How to determine which room a player is in? - algorithm

Question

I am working on a 2D platforming video game. The rooms are divided into areas, which are essentially intangible hitboxes. The camera is bounded by these hitboxes, and will not show what is in the next room until the player transitions into a new one.
If the player walks from one room to another, the camera pans to the new room. Panning the camera pauses the physics engine to ensure the player cannot break the game or die while the camera is in it's animation.
My problem exists in the fact that the player doesn't belong to a single room at a time since the player's hitbox is 2D. When the player moves between rooms, for a short period of time, the hitbox overlaps two rooms at once.
This means, that if I pan the camera when the player enters a new room, the player can partially enter the new room (while still remaining in the old room), then go back into the old room, which doesn't pan the camera back because they never technically entered the old room. How could they have entered it? They never left it!
This also means, that if I pan the camera upon the player leaving a room, the player can partially enter a new room, then leave the new room that they never fully entered. This means that the camera pans to the same room that it was already in (this plays a weird animation, and pauses the physics engine).
How can I determine what room the camera should pan to?
I have access to:
When the player enters a room, and which room.
When the player exits a room, and which room.
All rooms, and the variables of all rooms.
func _on_room_area_2d_body_entered(body): # body enters room
if body.is_in_group("junko"): # is this the player?
player_inside = true
junko.pan_camera(self) # pan the camera
func _on_room_area_2d_body_exited(body): # body exits room
if body.is_in_group("junko"): # is this the player?
player_inside = false

Answer 1

Just because the rooms are big, it does not mean they have to keep track of what is inside of them. Instead, the character can keep track of inside of which rooms it is.
If you want to detect areas, you need an area. So make an area child of your player character… Which I'll call locator. Then set the locator up to detect the areas that make up the rooms. That means that locator must be monitoring, and the rooms must be monitorable. And also the collision layer of the rooms must overlap the collision mask the locator.
Then you can use area_entered and area_exited (notice these signals are called area_* not body_*).
You might find it easier to call get_overlapping_areas on the detector in _physics_process and then from the result pick the rooms.
for entry in $locator.get_overlapping_areas():
prints(entry)
Then perhaps only pan the camera when there is only one room and it is not the one where the camera is currently at, or some similar rule.
In fact, you don't need a detector. You can do what "Yakov Galka" suggested in the comments and ask Godot what areas are in a particular point.
You do that with intersect_point:
var result:Array = get_world().direct_space_state.intersect_point(
global_position,
32,
[],
2147483647,
false,
true
)
And that returns an Array with the results. So you can iterate like this:
for entry in result:
prints(entry.collider)
To explain the parameters:
First you pass the point coordinates global_position.
Second you pass how many result you want at most (32 in this case).
Then you pass an array with elements you want to exclude (none in this case: []).
Then the collision mask (2147483647 is all the bits)
Then if you want bodies (no, so false)
And finally if you want areas (yes, so true).
Please notice that even though this is only checking a single point, it does not guarantee you have a single result (you can have multiple if the areas overlap).