Concerning Transitions between scenes; Moving the player X pixels from entering edge, handling "Fade-in / Fade-out" sequences.

[Sionnach86]

Hello there! I really appreciate what you've created - and it's been working great for a project I'm working on.

Question: I am attempting do the following:

1. Fade the screen to black when player exits a room.
2. Briefly lock the player's movement.
3. Load the player into a new room.
4. push the player away from the edge of the screen
5. Fade back in from black ...

Why:

I noticed with your system that if the player enters a room - then 'wiggles' left-right quickly - the player will eventually break the map and end up in the wrong cell.

I am trying to 'compensate' for this bug by fading the screen, ... allowing the player to load ... and then "moving" them away from the screen edge so that they cannot 'wiggle' on the edge of the screen.

However, I've been having trouble with this. I've tried to 'pause' the transition to allow the fade out to occur -- but the player then teleports to multiple rooms. I'm not really sure how to 'off-set' the player once they arrive in the new room, either - or how to handle 'fade out' or 'fade ins' between rooms.

Little help? I'm not a professional coder - I'm a spriter - but I know enough code to get by.

[KoBeWi]

I noticed with your system that if the player enters a room - then 'wiggles' left-right quickly - the player will eventually break the map and end up in the wrong cell.

That sounds like a bug, and one that should be fixed recently. What version of the addon are you using? Can you try 1.6?

In the built-in transition module, this line is responsible for moving the player position:

Metroidvania-System/addons/MetroidvaniaSystem/Template/Scripts/Modules/RoomTransitions.gd

Line 25 in bf0284e

player.position -= MetSys.get_current_room_instance().get_room_position_offset(prev_room_instance)

It uses exact room sizes, but you can increase the distance if it causes problems for whatever reason.

[Sionnach86]

Hello, thank you for the quick reply! I am using an older version of MetSys I am pretty sure - as I'm using Godot 4.4 - and have not updated to 4.5+. ... I was, uh, hoping to find a solution to the issue without having to potentially refactor / recompile ... tinker with the map editor cache, etc. I love the system - but am terrified to 'move' or change anything to avoid breaking too much.

I'll see if that line of code in RoomTransitions helps - as it "should" be a mater of capturing the player's direction, adding an offset, and then applying the offset to the player position during the repositioning -- though I have been having a lot of glitches with timing ...

The fade-out / fade-ins seem to go correctly, but the system itself seems to "think" the player is hanging out in the wrong cell for too long if there is any pauses / hesitation during transfer -- making it ... problematic for me to set up transitions / music shifts / cut scenes when the player exits / enters a cell.

[KoBeWi]

You can at least check if the new version fixes your problem (make a copy of your project and upgrade it). If it doesn't, try tinkering with the position value I linked.

[Sionnach86]

Greetings KoBewi-

I have updated to Godot 4.5.1 and upgraded to the newer version of Metsys. The issue I ran into still appears to be a problem- during bug testing, if a tester is on the edge of a room and rapidly hits 'left-right-left-right-left-right' and transitions between two cells rapidly, it still breaks the game.

I have found the part of your script you referenced and am trying to find a safe work around. System is very much viable / excellent! Just need some transition padding to prevent bug testers from being able to do this.

[Sionnach86]

I have modified the RoomTransition.gd in the following fashion:

## A MetSysModule that handles room transitions.
##
## The module connects to [signal MetroidvaniaSystem.room_changed]. When room changes, the new scene gets is loaded via [code]load_room()[/code] method. If MetSysGame has a player set, the player will be automatically teleported to the correct entrance.
extends "res://addons/MetroidvaniaSystem/Template/Scripts/MetSysModule.gd"

@export var transition_spawn_offset := 32.0

var player: Node2D

func _initialize():
	player = game.player
	assert(player)
	MetSys.room_changed.connect(_on_room_changed, CONNECT_DEFERRED)

func _on_room_changed(target_room: String):
	if target_room == MetSys.get_current_room_id():
		# This can happen when teleporting to another room.
		return
	
	var prev_room_instance := MetSys.get_current_room_instance()
	if prev_room_instance:
		prev_room_instance.get_parent().remove_child(prev_room_instance)
	
	await game.load_room(target_room)
	
	var new_room := MetSys.get_current_room_instance() # Added! New Code
	
	if prev_room_instance:
		#player.position -= MetSys.get_current_room_instance().get_room_position_offset(prev_room_instance)
		#prev_room_instance.queue_free()
		
		var room_offset := new_room.get_room_position_offset(prev_room_instance)
		player.position -= room_offset
		
		# New direction based off-set.
		var dir: Vector2 = room_offset.normalized()
		
		print("Player transition offset is being applied.")
		# Horizontal transitions
		if abs(dir.x) > abs(dir.y):
			player.position.x += sign(dir.x) * transition_spawn_offset
		#Vertical transitions
		elif abs(dir.y) > abs(dir.x):
			player.position.y += sign(dir.y) * transition_spawn_offset
			
		prev_room_instance.queue_free()
		
	
		
		
		

I'm still working on getting fade-out, fade-in transitions to work. :) But this seems to have resolved a player being able to "wiggle" on a screen edge / outrun the room transition!

[Sionnach86]

I've created a transition between cells in the following manner:

Effects Transitions Between Cells

1. Create a Area2D object which detects the player when they enter it; this object also stores the direction the player was moving in. Place this object near but not on top of the edge of the cell exit.
2. Have the Object pause input by the player.
3. Have this object signal via Global singleton that ColorRect needs to fade out / fade in / screen effect etc.
4. Object intructs the player to move over the cell threshold, triggering a cell change. This object then is removed due to the queue_free().

In the other cell, the ColorRect in the HUD will have to be told when to "fade back in", completing the transition. I've done this with a timer. Player input can be disabled / enabled to prevent the player from 'wiggling' or upsetting anything.

These objects could be set to do a variety of things - from starting / stopping music, starting cut scenes, etc -- without upsetting the cell transition logic.

[KoBeWi]

I tried reproducing the issue you are experiencing (I modified the character to move by 1 pixel) and I can't:

godot45_YGA166kHSu.mp4

The rooms always change as expected.

What are you using for transitions? Did you make any modifications?

[Sionnach86]

Here is my Game.gd

# This is the main script of the game. It manages the current map and some other stuff.
extends "res://addons/MetroidvaniaSystem/Template/Scripts/MetSysGame.gd"
class_name Game

const SaveManager = preload("res://addons/MetroidvaniaSystem/Template/Scripts/SaveManager.gd")
const SAVE_PATH = "user://example_save_data.sav"


# The game starts in this map. Note that it's scene name only, just like MetSys refers to rooms.
@export var starting_map: String

@onready var hud := $HUD
@onready var screen_effect: ColorRect = $HUD/HUD_controller/ScreenEffect
@onready var mapwindow: Control = %MapWindow
@onready var minimap: Control = %Minimap




# Number of collected collectibles. Setting it also updates the counter.
var collectibles: int:
	set(count):
		collectibles = count
		%CollectibleCount.text = "%d/6" % count

# The coordinates of generated rooms. MetSys does not keep this list, so it needs to be done manually.
var generated_rooms: Array[Vector3i]
# The typical array of game events. It's supplementary to the storable objects.
var events: Array[String]
# For Custom Runner integration.
var custom_run: bool









######################
### Game Start #######
######################



func _ready() -> void:
	

	
	
	# This is handled in GameConfig, which is a global, and signals Player_data.
	#if GameConfig.god_mode:
		#GameConfig.god_mode = true

	if GameConfig.spawn_hotspot != "":
		var spot = map.get_node_or_null(GameConfig.spawn_hotspot)
		if spot:
			player.global_position = spot.global_position
	
	
	
	print("Children of Game node:")
	for child in get_children():
		print(" - ", child.name)
		
	
	await get_tree().process_frame # Wait one frame.
	
	player = %Player
	
	mapwindow.player = player
	
	print("Starting map path ", starting_map)
	
	if not ResourceLoader.exists(starting_map):
		print("Starting map path is invalid: " + starting_map)
		return # Early exit if the map doesn't exist
	
	
	
	
	
	# A trick for static object reference (before static vars were a thing).
	get_script().set_meta(&"singleton", self)
	# Make sure MetSys is in initial state.
	# Does not matter in this project, but normally this ensures that the game works correctly when you exit to menu and start again.
	MetSys.reset_state()
	print("Reset State triggered.")
	# Assign player for MetSysGame.
	set_player($Player)
	
	
	if FileAccess.file_exists(SAVE_PATH):
		# If save data exists, load it using MetSys SaveManager.
		var save_manager := SaveManager.new()
		save_manager.load_from_text(SAVE_PATH)
		# Assign loaded values.
		collectibles = save_manager.get_value("collectible_count")
		generated_rooms.assign(save_manager.get_value("generated_rooms"))
		events.assign(save_manager.get_value("events"))
		player.abilities.assign(save_manager.get_value("abilities"))
		
		if not custom_run:
			var loaded_starting_map: String = save_manager.get_value("current_room")
			if not loaded_starting_map.is_empty(): # Some compatibility problem.
				starting_map = loaded_starting_map
	else:
		# If no data exists, set empty one.
		MetSys.set_save_data()
	
	# Initialize room when it changes.
	room_loaded.connect(init_room, CONNECT_DEFERRED)
	# Load the starting room.

		
	print("Loading room...")
	await load_room(starting_map)
	print ("Room loaded. Map: ", map)
	
	
	if map == null:
		print("Map is null after room loaded.")
		return
	
	
	# Find the save point and teleport the player to it, to start at the save point.
	var start : Node2D = map.get_node_or_null("Spawn")
	if start and not custom_run:
		player.position = start.position
		$Player/Camera2D.force_update_scroll() # Added to fix camera?
	
	
	
	## Listens for -- > room_changed signal <-- and automatically changes scenes and moves
	## the player to a correct position. For example if you exit a room to the
	## right, the module will load the connected scene and teleport the player
	## on the left side of the entered room.
	
	# Add module for room transitions.
	add_module("RoomTransitions.gd")
	# You can enable alternate transition effect by using this module instead.
	#add_module("ScrollingRoomTransitions.gd")
	add_module("PassageAutomapper.gd")
	
	
	
	# Reset position tracking (feature specific to this project).
	await get_tree().physics_frame
	reset_map_starting_coords.call_deferred()
	
	## Make sure minimap is at correct position (required for themes to work 
	## correctly).
	minimap.set_offsets_preset(Control.PRESET_TOP_RIGHT, Control.PRESET_MODE_MINSIZE, 8)

# Returns this node from anywhere.
static func get_singleton() -> Game:
	return (Game as Script).get_meta(&"singleton") as Game

# Save game using MetSys SaveManager.
func save_game():
	var save_manager := SaveManager.new()
	save_manager.set_value("collectible_count", collectibles)
	save_manager.set_value("generated_rooms", generated_rooms)
	save_manager.set_value("events", events)
	save_manager.set_value("current_room", MetSys.get_current_room_name())
	save_manager.set_value("abilities", player.abilities)
	save_manager.save_as_text(SAVE_PATH)

func reset_map_starting_coords():
	mapwindow.reset_starting_coords()

func init_room():
	MetSys.get_current_room_instance().adjust_camera_limits($Player/Camera2D)
	
	var current_room = MetSys.get_current_room_instance()
	var cam: Camera2D = $Player/Camera2D
	
	cam.make_current()
	cam.position_smoothing_enabled = false
	current_room.adjust_camera_limits(cam)
	CameraManager.set_camera(cam)
	
	
	var start: Node2D = current_room.get_node_or_null("Spawn")
	if start and not custom_run:
		player.position = start.position
	
	cam.force_update_scroll()
	await get_tree().process_frame
	cam.position_smoothing_enabled = true
		
	
	
	
	player.on_enter()
	
	# Initializes MetSys.get_current_coords(), so you can use it from the beginning.
	if MetSys.last_player_position.x == Vector2i.MAX.x:
		MetSys.set_player_position(player.position)


# Custom Teleport System
func teleport_to_room(target_room_path: String, spawn_point_name := "Spawn") -> void:
	if not ResourceLoader.exists(target_room_path):
		push_error("Target room does not exist: %s" % target_room_path)
		return
	
	# Optional: Fade out screen, show loading, etc.
	
	# Load room.
	await load_room(target_room_path) # Built-in method from MetSysGame.gd
	if map == null:
		push_error("Map failed to load: %s" % target_room_path)
		return
	

	
	# Move player to spawn point.
	var spawn_point := map.get_node_or_null(spawn_point_name)
	if spawn_point:
		player.position = spawn_point.global_position
		$Player/Camera2D.force_update_scroll()
	else:
		push_warning("Spawn point not found: %s" % spawn_point_name)
	
	map.add_child(player)
	player.global_position = spawn_point.global_position
	

	
	# Re-initialize room logic (camera limits, player settings)
	init_room()
	
	#Ensure the camera activates AFTER everything has settled
	await get_tree().process_frame
	
	# Camera is current
	var current_room = MetSys.get_current_room_instance()
	var cam: Camera2D = player.get_node_or_null("Camera2D")
	current_room.adjust_camera_limits(cam)
	
	if cam:
		cam.make_current()
		cam.force_update_scroll()
		cam.position_smoothing_enabled = true
		CameraManager.set_camera(cam)
	else:
		print("Player's Camera2D not found after room load.")
	
	room_loaded.emit()
		
	#$Player/Camera2d.make_current()

#This has *nothing* to do with edge-transitions. This is for Debug / Direct Teleport situations.
func _on_teleporter_body_entered(body: Node2D) -> void:
	if body.name == "Player":
		var game = (Game as Script).get_meta("singleton") as Game
		if game:
			game.teleport_to_room("res://Maps/Cave1.tscn", "Entrance")






# Customized load function that handles maps generated in Dice.tscn.
#func _load_map(path: String) -> Node:
	#if not path.begins_with("GEN"):
		#return super(path)
	#
	## Base scene that will be customized (Junction.tscn).
	#var prototype := preload("uid://bikgu4uxf7vxt").instantiate()
	#prototype.scene_file_path = path
	#
	#var config := path.split("/")
	## Assign values to the scene (see the script in Junction.tscn).
	#prototype.exits = config[2].to_int()
	#prototype.has_collectible = config[3] == "true"
	## Apply the values. It has to happen before the scene enters tree.
	#prototype.apply_config()
	
	#return prototype
	return
	
	
## For inventory screen, don't touch.
func fade_in(duration := 0.5):
	%FadeRect.visible = true
	%FadeRect.modulate.a = 0.0
	var tween = create_tween()
	tween.tween_property(%FadeRect, "modulate:a", 1.0, duration)
	return await tween.finished

func fade_out(duration := 0.5):
	var tween = create_tween()
	tween.tween_property(%FadeRect, "modulate:a", 0.0, duration)
	await tween.finished
	%FadeRect.visible = false	
	

Annnnd here is the RoomTransistions.gd

## A MetSysModule that handles room transitions.
##
## The module connects to [signal MetroidvaniaSystem.room_changed]. When room changes, the new scene gets is loaded via [code]load_room()[/code] method. If MetSysGame has a player set, the player will be automatically teleported to the correct entrance.
extends "res://addons/MetroidvaniaSystem/Template/Scripts/MetSysModule.gd"

@export var transition_spawn_offset := 60.0


var player: Node2D

func _initialize():
	player = game.player
	assert(player)
	MetSys.room_changed.connect(_on_room_changed, CONNECT_DEFERRED)

func _on_room_changed(target_room: String):
	if target_room == MetSys.get_current_room_id():
		return

	var prev_room_instance := MetSys.get_current_room_instance()

	if prev_room_instance:
		prev_room_instance.get_parent().remove_child(prev_room_instance)

	await game.load_room(target_room)
	var new_room := MetSys.get_current_room_instance()

	if prev_room_instance:
		var room_offset := new_room.get_room_position_offset(prev_room_instance)
		player.position -= room_offset
		
		# Apply directional spawn offset
		var dir: Vector2 = room_offset.normalized()
		if abs(dir.x) > abs(dir.y):
			player.position.x += sign(dir.x) * transition_spawn_offset
		elif abs(dir.y) > abs(dir.x):
			player.position.y += sign(dir.y) * transition_spawn_offset

		prev_room_instance.queue_free()

	# Update camera limits immediately
	if CameraManager.camera:
		new_room.adjust_camera_limits(CameraManager.camera)
		CameraManager.set_limits(
			CameraManager.camera.limit_left,
			CameraManager.camera.limit_right,
			CameraManager.camera.limit_top,
			CameraManager.camera.limit_bottom
		)
		CameraManager.camera.force_update_scroll()

There are some other issues; for example:

• In the 2d Editor, I can't see the "ghost" version of adjacent cells.

It may very well be something I have done - and I'm having trouble nailing it down. It could also be that my player is a Rigidbody for physics reasons, it could be a collider issue where it doesn't place right, I don't know- but I'll happily share any code you want, or even provide footage if you want.

[KoBeWi]

The scripts don't tell me much. If you could somehow share the whole project I could experiment with it and see what's wrong. If you'd like to share it, but don't want to put it in public, you can DM me on RocketChat.

[Sionnach86]

I just wanted to say - with the edits I've made - things run fine and it doesn't break anymore with offsets. This may be situational and for my project specifically!

IF this happens with others - a work around is to just ad a slight offset to player positioning upon arrival in RoomTransitions.gd
IF it doesn't happen - your code is grand as is.