How to make room transition like celeste

Godot Version

<stable4.2>

Question

<Right now, my room transition system instantly change one room to another. How can I make it transition smoothly and pause while transitioning?

func _on_room_detector_area_entered(area):
	var collision_shape = area.get_node("CollisionShape2D")
	var size = collision_shape.shape.extents*2

	var cam = $Camera2D

	cam.limit_top = collision_shape.global_position.y - size.y/2
	cam.limit_left = collision_shape.global_position.x - size.x/2

	cam.limit_bottom = cam.limit_top + size.y
	cam.limit_right = cam.limit_left + size.x
	pass # Replace with function body.

Please show a video of celeste room transition

like this ?
b9jEH

You can do this with tween, here is the codes:

extends Node2D

@onready var player = $Player
@onready var camera = $Camera

var screen_pos = [0, 1920]

func _physical_process(delta):
    if player.global_position.x < screen_pos[0]:
        screen_pos[0] -= 1920
        screen_pos[1] -= 1920
        var tween = get_tree().create_tween()
        tween.tween_property(camera, "position:x", screen_pos[0], 1.2)
        tween.play()
        await tween.tween_finished
        tween.kill()
        return
    elif player.global_position.x > screen_pos[1]:
        screen_pos[0] += 1920
        screen_pos[1] += 1920
        var tween = get_tree().create_tween()
        tween.tween_property(camera, "position:x", screen_pos[0], 1.2)
        tween.play()
        await tween.tween_finished
        tween.kill()
        return

I write the codes for you, I have never created room transition,
If its not works, you can see this video

none of these worked. Found this tutorial and was trying to implement in 4.2 but facing an error. any idea how to solve ?

an error : position = lerpf(position, target_position, smoothing)
"Invalid argument for lerpf() function: argument 1 should be “float” but is “Vector2”

extends Camera2D

var smoothing: float 
@export var follow_smoothing: float = 0.1
@export var current_room_center: Vector2
@export var current_room_size: Vector2
@export var zoom_view_size: Vector2
@onready var view_size: Vector2 = get_viewport_rect().size

@onready var player = get_node("../player")


func _ready():
	position_smoothing_enabled = false
	smoothing = 1
	await get_tree().create_timer(0.1).timeout
	smoothing = follow_smoothing

func _physics_process(delta):
	zoom_view_size = view_size * zoom
	var target_position := calculate_target_position(current_room_center, current_room_size)
	position = lerpf(position, target_position, smoothing)

func calculate_target_position(room_center: Vector2, room_size: Vector2) -> Vector2:
	var x_margin: float = (room_size.x - zoom_view_size.x) / 2
	var y_margin: float = (room_size.y - zoom_view_size.y) / 2
	
	var return_position: Vector2 = Vector2.ZERO
	
	if x_margin <= 0:
		return_position.x = room_center.x
	else:
		var left_limit: float = room_center.x - x_margin
		var right_limit : float = room_center.x + x_margin
		return_position.x = clampf(player.position.x, left_limit, right_limit)
	
	if y_margin <= 0:
		return_position.y = room_center.y
	else:
		var top_limit: float = room_center.y - y_margin
		var bottom_limit: float = room_center.y + y_margin
		return_position.y = clampf(player.position.y, top_limit, bottom_limit)
	
	return return_position

Yes, use lerp instead of lerf, position = lerp(position, target_position, smoothing)

thanks that worked expect pause. How do i pause if im using node base state machine? Setting physics process to false would not work

What do you want to say? I don`t understand properly

well Id like to pause player and enemies when transitioning but dont know how

Outside the room? all enemies will pause? or just pause when the transition

just pause when the transition

Ok so try to do get_tree().paused = true and set the camera process mode to always

that worked perfectly! thank you very much KingGD

1 Like

how would you do this by using tween instead of lerp?

Lerp and tween is almost same but tween is best for better things and in normal function but using lerp in physical process is better than tween

I see. thanks