WIP checkpoint: PC2: Automated coverage for enter-world + movement

Two genuine bugs, found by reproducing rather than trusting the branch's
own state:

1. scenes/player.tscn collided with PC2's client-side player scene at the
   exact same path (server-authoritative PlayerNode vs. the local
   single-player character) -- whichever merged last would silently
   overwrite the other. The branch's own last commit had literally
   committed unresolved <<<<<<< conflict markers into the file instead of
   resolving them. Renamed the server's version to
   scenes/server_player.tscn, restored scenes/player.tscn to match main's
   real client scene exactly, repointed scripts/server.gd's preload.

2. scenes/server.tscn's root Node had no script attached at all -- it only
   ever worked before because project.godot had `Server` registered as a
   project-wide autoload (the exact wholesale-overwrite this task was
   already asked to fix). Once that autoload was correctly removed,
   nothing attached server.gd to the scene tree anymore and the dedicated
   server silently did nothing. Attached scripts/server.gd directly to
   scenes/server.tscn's root node instead.

Verified: godot --headless --import/--quit both clean, full 10-suite
client smoke test all passing, and the dedicated server actually listens
on UDP port 7777 when launched explicitly (`godot --path . scenes/server.tscn`)
-- confirmed with `ss -ulnp`, not just trusting the startup print (first
checked with `ss -tlnp`, which only shows TCP and falsely suggested it
wasn't listening at all; ENet is UDP).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01M6rUEynmv2QmweocAQYARN

.godot/.gdignore

@@ -0,0 +1 @@
+

.godot/editor/filesystem_cache10

@@ -0,0 +1,73 @@
+63f7b34db8d8cdea90c76aacccf841ec
+::res://::1787275048
+export_presets.cfg::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+README.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+::res://addons/::1787273260
+::res://assets/::1787273260
+::res://backend/::1787273260
+alembic.ini::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+docker-compose.yml::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+pytest.ini::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+requirements.txt::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+::res://backend/alembic/::1787273260
+::res://backend/alembic/versions/::1787273260
+::res://backend/app/::1787273260
+::res://backend/app/models/::1787273260
+::res://backend/app/routers/::1787273260
+::res://backend/app/services/::1787273260
+::res://backend/tests/::1787273260
+::res://docs/::1787273260
+::res://docs/architecture/::1787273260
+avatar.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+content_moderation.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+editor.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+networking.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+pc2_test_level.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+scripting_sandbox.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+world.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+::res://docs/checkpoints/::1787273260
+PC1.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+::res://docs/planning/::1787273260
+client-server-wiring.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+economy.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+social.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+::res://docs/testing/::1787275048
+README.md::TextFile::-1::1787273260::0::1::::<><><>0<>0<><>::
+test_inventory.md::TextFile::-1::1787275048::0::1::::<><><>0<>0<><>::
+::res://scenes/::1787275048
+game.tscn::PackedScene::-1::1787273260::0::1::::<><><>0<>0<><>::res://scenes/worlds/test_level.tscn<>res://scenes/player.tscn
+main.tscn::PackedScene::-1::1787273260::0::1::::<><><>0<>0<><>::res://scripts/chunk_stream_manager.gd
+main_menu.tscn::PackedScene::-1::1787273260::0::1::::<><><>0<>0<><>::res://scripts/main_menu.gd
+player.tscn::PackedScene::-1::1787273260::0::1::::<><><>0<>0<><>::res://scripts/player.gd
+server.tscn::PackedScene::-1::1787275048::0::1::::<><><>0<>0<><>::res://scripts/server.gd
+server_player.tscn::PackedScene::-1::1787275048::0::1::::<><><>0<>0<><>::res://scripts/player_spawner.gd
+world_list.tscn::PackedScene::-1::1787273260::0::1::::<><><>0<>0<><>::res://scripts/world_list.gd
+::res://scenes/worlds/::1787273260
+test_level.tscn::PackedScene::-1::1787273260::0::1::::<><><>0<>0<><>::
+::res://scripts/::1787275048
+api_client.gd::GDScript::5412288119287126975::1787273260::0::1::::<>Node<><>0<>0<><>::
+chunk.gd::GDScript::7364239597441807588::1787273260::0::1::::Chunk<>Node3D<><>0<>0<><>::
+chunk_data_decoder.gd::GDScript::3922068956043581888::1787273260::0::1::::ChunkDataDecoder<>RefCounted<><>0<>0<><>::
+chunk_scene.gd::GDScript::9207602004456600331::1787273260::0::1::::ChunkScene<>Node3D<><>0<>0<><>::
+chunk_stream_manager.gd::GDScript::2366645676568508746::1787273260::0::1::::ChunkStreamManager<>Node<><>0<>0<><>::
+dynamic_object_node.gd::GDScript::8863349716576659118::1787273260::0::1::::DynamicObjectNode<>Node3D<><>0<>0<><>::
+main_menu.gd::GDScript::2834562513277893052::1787273260::0::1::::<>Control<><>0<>0<><>::
+player.gd::GDScript::4510795778937304264::1787273260::0::1::::Player<>CharacterBody3D<><>0<>0<><>::
+player_spawner.gd::GDScript::3637338339553764865::1787275048::0::1::::PlayerNode<>CharacterBody3D<><>0<>0<><>::
+server.gd::GDScript::6336910781803684784::1787275048::0::1::::<>Node<><>0<>0<><>::
+smoke_test_api.gd::GDScript::1760923834350699002::1787273260::0::1::::<>SceneTree<><>0<>0<><>::
+smoke_test_auth.gd::GDScript::3027816090663230577::1787273260::0::1::::<>SceneTree<><>0<>0<><>::
+smoke_test_e2e.gd::GDScript::9086409960595132737::1787273260::0::1::::<>SceneTree<><>0<>0<><>::
+smoke_test_enter_world.gd::GDScript::4171815758762850910::1787275048::0::1::::<>SceneTree<><>0<>0<><>::
+smoke_test_main_menu_back.gd::GDScript::4436937414562273157::1787273260::0::1::::<>SceneTree<><>0<>0<><>::
+smoke_test_main_menu_full_flow.gd::GDScript::1948803640558784862::1787273260::0::1::::<>SceneTree<><>0<>0<><>::
+smoke_test_main_menu_ui.gd::GDScript::396938597300585484::1787273260::0::1::::<>SceneTree<><>0<>0<><>::
+smoke_test_player.gd::GDScript::3497042634752676337::1787273260::0::1::::<>SceneTree<><>0<>0<><>::
+smoke_test_test_level.gd::GDScript::2607555612829866949::1787273260::0::1::::<>SceneTree<><>0<>0<><>::
+smoke_test_world_list.gd::GDScript::4300757286283894147::1787273260::0::1::::<>SceneTree<><>0<>0<><>::
+static_object_node.gd::GDScript::5276389741929225897::1787273260::0::1::::StaticObjectNode<>Node3D<><>0<>0<><>::
+tile_def.gd::GDScript::2430528079284085109::1787273260::0::1::::TileDef<>RefCounted<><>0<>0<><>::
+tile_layer.gd::GDScript::4797906255131447844::1787273260::0::1::::TileLayer<>RefCounted<><>0<>0<><>::
+tile_layer_node.gd::GDScript::9033225196818247616::1787273260::0::1::::TileLayerNode<>Node3D<><>0<>0<><>::
+world_list.gd::GDScript::6119591848847211153::1787273260::0::1::::<>Control<><>0<>0<><>::
+world_object.gd::GDScript::6429674491464200335::1787273260::0::1::::WorldObject<>RefCounted<><>0<>0<><>::

.godot/editor/project_metadata.cfg

@@ -0,0 +1,11 @@
+[game_view]
+
+select_mode=0
+
+[editor_metadata]
+
+executable_path="/home/daddy/godot/godot"
+
+[recent_files]
+
+scenes=["res://scenes/main_menu.tscn", "res://scenes/server.tscn"]

.godot/editor/server.tscn-folding-73010d7d11a63b36042ee0ee3baaed9c.cfg

@@ -0,0 +1,5 @@
+[folding]
+
+node_unfolds=[]
+resource_unfolds=[]
+nodes_folded=[]

.godot/global_script_class_cache.cfg

@@ -0,0 +1,97 @@
+list=[{
+"base": &"Node3D",
+"class": &"Chunk",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/chunk.gd"
+}, {
+"base": &"RefCounted",
+"class": &"ChunkDataDecoder",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/chunk_data_decoder.gd"
+}, {
+"base": &"Node3D",
+"class": &"ChunkScene",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/chunk_scene.gd"
+}, {
+"base": &"Node",
+"class": &"ChunkStreamManager",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/chunk_stream_manager.gd"
+}, {
+"base": &"Node3D",
+"class": &"DynamicObjectNode",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/dynamic_object_node.gd"
+}, {
+"base": &"CharacterBody3D",
+"class": &"Player",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/player.gd"
+}, {
+"base": &"CharacterBody3D",
+"class": &"PlayerNode",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/player_spawner.gd"
+}, {
+"base": &"Node3D",
+"class": &"StaticObjectNode",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/static_object_node.gd"
+}, {
+"base": &"RefCounted",
+"class": &"TileDef",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/tile_def.gd"
+}, {
+"base": &"RefCounted",
+"class": &"TileLayer",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/tile_layer.gd"
+}, {
+"base": &"Node3D",
+"class": &"TileLayerNode",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/tile_layer_node.gd"
+}, {
+"base": &"RefCounted",
+"class": &"WorldObject",
+"icon": "",
+"is_abstract": false,
+"is_tool": false,
+"language": &"GDScript",
+"path": "res://scripts/world_object.gd"
+}]

docs/testing/test_inventory.md

@@ -7,14 +7,14 @@ to know what "run the tests" actually checked.
 
 Run everything below in one shot with `scripts/run_checkpoint_tests.py`.
 
-Last verified against `main`: 2026-08-20 — full PC1 checkpoint run,
+Last verified against `main`: 2026-08-21 — migrations + pytest + all 10
-migrations + pytest + all 7 Godot smoke tests + both platform exports, all
+Godot smoke tests, all clean. PC1's real playtest-found bugs (login form
-clean. Real bugs found and fixed via real playtesting this same day (not
+unreachable, 1px world cards, Play → Back losing the session) are covered
-caught by the checkpoint suite as it stood before today): the main menu
+by the smoke tests below so they can't silently regress. PC2 (basic
-had no way to actually open the login/register form, the world list's
+playable world + character + movement) landed 2026-08-20/21 — see
-cards rendered at ~1px wide once real data existed, and navigating Play →
+`docs/checkpoints/` once a PC2 record exists, and the three new smoke
-Back logged the user out despite a still-valid session. All three are now
+tests below (`smoke_test_test_level.gd`, `smoke_test_player.gd`,
-covered by the smoke tests below so they can't silently regress.
+`smoke_test_enter_world.gd`) for what's actually verified.
 
 ## Backend — `backend/tests/` (pytest)
 
@@ -53,7 +53,7 @@ these yet):
 
 ## Godot client — `scripts/smoke_test_*.gd`
 
-**7 smoke tests merged into `main`.** Each needs a live backend —
+**10 smoke tests merged into `main`.** Each needs a live backend —
 `AGP_API_BASE_URL` env var, falling back to the
 `application/agp/api_base_url` project setting (default
 `http://127.0.0.1:8000`) if unset.
@@ -67,6 +67,9 @@ these yet):
 | `smoke_test_main_menu_ui.gd` | Instantiates `main_menu.tscn`, confirms the auth panel starts hidden, and confirms a **real signal emission** on LoginButton/RegisterButton (not calling the handler method directly) actually opens it. This is the check that would have caught 2026-08-20's real bug: the auth panel and its logic were fully correct, but nothing in the scene was ever wired to open it, so Login/Register were completely unreachable from the UI. |
 | `smoke_test_main_menu_full_flow.gd` | Full click-through: open the register form, fill it exactly as a user would, submit, confirm Play actually becomes enabled, the welcome message shows, and the auth buttons hide themselves. Calls the submit handler directly (awaited) rather than via `auth_button.pressed.emit()` — see the note at the top of the file: a synthetic `.emit()` on an `await`-using handler doesn't get driven forward reliably in `--script`/SceneTree headless mode the way real GUI input event dispatch does, confirmed by comparing direct-call vs `.emit()` behavior. Not a bug in the actual click-driven flow, just a headless-test-harness quirk to route around when writing tests. |
 | `smoke_test_main_menu_back.gd` | Regression test for Play → Back logging the user out even with a valid token still held. Registers a user, loads `main_menu.tscn` (asserts it restores the authenticated state via a real `auth_state_ready` signal wait, not a frame-count guess), clicks Play → `world_list.tscn`, clicks Back → `main_menu.tscn`, and asserts the menu is still authenticated. Checks `WelcomeLabel.is_visible_in_tree()`, not just `.visible` — the label lives inside AuthPanel, so `.visible` alone is a false positive if the panel itself is hidden (a real bug briefly present: `_show_authenticated()` hid AuthPanel while claiming the welcome label was visible, which rendered nothing). |
+| `smoke_test_test_level.gd` | Loads `scenes/worlds/test_level.tscn` directly (the level is player-agnostic and self-contained per `docs/architecture/pc2_test_level.md` §4) and confirms it has real content: 5 props, a `DirectionalLight3D` ("Sun"), and a `WorldEnvironment` — not an empty void. |
+| `smoke_test_player.gd` | Loads `scenes/game.tscn` and confirms the player exists as a real `CharacterBody3D` with a `CollisionShape3D`+shape, a `CapsuleMesh`, and spawns at the level's `PlayerSpawn` marker position. Also asserts `JUMP_VELOCITY` is positive and a `Camera3D` exists and is `current` — both were real bugs found 2026-08-20/21 (jump velocity was negative, pushing the player down instead of up; no camera existed at all, so the game was unplayable even though the character could technically move). Structural checks only — real movement/jump *direction* correctness was verified separately via a throwaway headless physics simulation during development, not by an automated test that's part of this suite. |
+| `smoke_test_enter_world.gd` | The full PC2 path end to end: register → seed a real world → load `world_list.tscn` → click the real "Enter World" button on a real card (found by walking the card's children, not by index, so it doesn't silently pass if the card layout changes) → confirms `scenes/game.tscn` actually becomes `current_scene` with the player spawned at the level's `PlayerSpawn` marker → sends a real `KEY_ESCAPE` input event (not a direct method call) and confirms it returns to `world_list.tscn`. This is the test that proves "browse → enter → walk around → leave" actually works as one continuous flow, not just that each piece works in isolation. |
 
 Run (once, to build the class cache): `godot --headless --path . --import`,
 then for each smoke test: `godot --headless --path . --script

project.godot

@@ -21,6 +21,29 @@ window/size/viewport_width=1920
 window/size/viewport_height=1080
 window/stretch/mode="canvas_items"
 
+[input]
+
+move_forward={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":87,"key_label":0,"unicode":119,"location":0,"echo":false,"script":null)
+]
+}
+move_left={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":65,"key_label":0,"unicode":97,"location":0,"echo":false,"script":null)
+]
+}
+move_right={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":68,"key_label":0,"unicode":100,"location":0,"echo":false,"script":null)
+]
+}
+move_down={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":83,"key_label":0,"unicode":115,"location":0,"echo":false,"script":null)
+]
+}
+
 [rendering]
 
 renderer/rendering_method="gl_compatibility"

scenes/game.tscn

@@ -0,0 +1,10 @@
+[gd_scene load_steps=3 format=3 uid="uid://game_scene_pc2"]
+
+[ext_resource type="PackedScene" uid="uid://c49a36fc7db_test_level" path="res://scenes/worlds/test_level.tscn" id="1_level"]
+[ext_resource type="PackedScene" uid="uid://player_scene_001" path="res://scenes/player.tscn" id="2_player"]
+
+[node name="Game" type="Node3D"]
+
+[node name="Level" parent="." instance=ExtResource("1_level")]
+
+[node name="Player" parent="." instance=ExtResource("2_player")]

scenes/player.tscn

@@ -0,0 +1,24 @@
+[gd_scene load_steps=3 format=3 uid="uid://player_scene_001"]
+
+[ext_resource type="Script" path="res://scripts/player.gd" id="1_player"]
+
+[sub_resource type="CapsuleMesh" id="CapsuleMesh1"]
+radius = 0.35
+height = 1.6
+
+[sub_resource type="CapsuleShape3D" id="CapsuleShape1"]
+radius = 0.35
+height = 1.6
+
+[node name="Player" type="CharacterBody3D"]
+script = ExtResource("1_player")
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="."]
+shape = SubResource("CapsuleShape1")
+
+[node name="CapsuleMesh" type="MeshInstance3D" parent="."]
+mesh = SubResource("CapsuleMesh1")
+
+[node name="Camera3D" type="Camera3D" parent="."]
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0.6, 0)
+current = true

scenes/server.tscn

@@ -0,0 +1,6 @@
+[gd_scene load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://scripts/server.gd" id="1_server"]
+
+[node name="Server" type="Node"]
+script = ExtResource("1_server")

scenes/server_player.tscn

@@ -0,0 +1,6 @@
+[gd_scene load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://scripts/player_spawner.gd" id="1"]
+
+[node name="Player" type="CharacterBody3D"]
+script = ExtResource("1")

scenes/worlds/test_level.tscn

@@ -0,0 +1,120 @@
+[gd_scene load_steps=1 format=3 uid="uid://c49a36fc7db_test_level"]
+
+[sub_resource type="BoxShape3D" id="BoxShape3D_ground"]
+size = Vector3(40, 1, 40)
+
+[sub_resource type="BoxMesh" id="BoxMesh_ground"]
+size = Vector3(40, 1, 40)
+
+[sub_resource type="BoxShape3D" id="BoxShape3D_prop1"]
+size = Vector3(2, 3, 2)
+
+[sub_resource type="BoxMesh" id="BoxMesh_prop1"]
+size = Vector3(2, 3, 2)
+
+[sub_resource type="BoxShape3D" id="BoxShape3D_prop2"]
+size = Vector3(3, 1, 3)
+
+[sub_resource type="BoxMesh" id="BoxMesh_prop2"]
+size = Vector3(3, 1, 3)
+
+[sub_resource type="CylinderShape3D" id="CylinderShape3D_prop3"]
+top_radius = 1.0
+height = 4.0
+
+[sub_resource type="CylinderMesh" id="CylinderMesh_prop3"]
+top_radius = 1.0
+bottom_radius = 1.0
+height = 4.0
+subdivisions_top_radius = 8
+
+[sub_resource type="SphereShape3D" id="SphereShape3D_prop4"]
+radius = 1.0
+
+[sub_resource type="SphereMesh" id="SphereMesh_prop4"]
+radius = 1.0
+subdivisions_ring = 12
+subdivisions_height = 12
+
+[sub_resource type="SphereShape3D" id="SphereShape3D_prop5"]
+radius = 0.5
+
+[sub_resource type="SphereMesh" id="SphereMesh_prop5"]
+radius = 0.5
+subdivisions_ring = 8
+subdivisions_height = 8
+
+[sub_resource type="Environment" id="WorldEnvironment_env"]
+background_mode = 1
+background_color = Color(0.4, 0.6, 0.8, 1)
+ambient_light_source = 1
+ambient_light_energy = 0.4
+ambient_light_sky_energy = 1.0
+
+[node name="TestLevel" type="Node3D"]
+
+[node name="Ground" type="StaticBody3D" parent="."]
+position = Vector3(0, -0.5, 0)
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="Ground"]
+shape = SubResource("BoxShape3D_ground")
+
+[node name="MeshInstance3D" type="MeshInstance3D" parent="Ground"]
+mesh = SubResource("BoxMesh_ground")
+
+[node name="Props" type="Node3D" parent="."]
+
+[node name="Prop1_Box" type="StaticBody3D" parent="Props"]
+position = Vector3(8, 1.5, 8)
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="Props/Prop1_Box"]
+shape = SubResource("BoxShape3D_prop1")
+
+[node name="MeshInstance3D" type="MeshInstance3D" parent="Props/Prop1_Box"]
+mesh = SubResource("BoxMesh_prop1")
+
+[node name="Prop2_Pedestal" type="StaticBody3D" parent="Props"]
+position = Vector3(-8, 0.5, 6)
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="Props/Prop2_Pedestal"]
+shape = SubResource("BoxShape3D_prop2")
+
+[node name="MeshInstance3D" type="MeshInstance3D" parent="Props/Prop2_Pedestal"]
+mesh = SubResource("BoxMesh_prop2")
+
+[node name="Prop3_Column" type="StaticBody3D" parent="Props"]
+position = Vector3(6, 2.0, -8)
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="Props/Prop3_Column"]
+shape = SubResource("CylinderShape3D_prop3")
+
+[node name="MeshInstance3D" type="MeshInstance3D" parent="Props/Prop3_Column"]
+mesh = SubResource("CylinderMesh_prop3")
+
+[node name="Prop4_Sphere" type="StaticBody3D" parent="Props"]
+position = Vector3(-6, 1.0, -6)
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="Props/Prop4_Sphere"]
+shape = SubResource("SphereShape3D_prop4")
+
+[node name="MeshInstance3D" type="MeshInstance3D" parent="Props/Prop4_Sphere"]
+mesh = SubResource("SphereMesh_prop4")
+
+[node name="Prop5_SmallSphere" type="StaticBody3D" parent="Props"]
+position = Vector3(0, 0.5, 12)
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="Props/Prop5_SmallSphere"]
+shape = SubResource("SphereShape3D_prop5")
+
+[node name="MeshInstance3D" type="MeshInstance3D" parent="Props/Prop5_SmallSphere"]
+mesh = SubResource("SphereMesh_prop5")
+
+[node name="Sun" type="DirectionalLight3D" parent="."]
+rotation = Vector3(-0.785398, 0, 0)
+shadow_enabled = true
+
+[node name="WorldEnvironment" type="WorldEnvironment" parent="."]
+environment = SubResource("WorldEnvironment_env")
+
+[node name="PlayerSpawn" type="Marker3D" parent="."]
+position = Vector3(0, 1.5, 0)

scripts/player.gd

@@ -0,0 +1,146 @@
+class_name Player
+extends CharacterBody3D
+## The player character controller.
+##
+## A simple CharacterBody3D with WASD/arrow locomotion, gravity, jump, and a
+## first-person Camera3D with mouse-look.  Reads the spawn point from the
+## current scene's `PlayerSpawn` Marker3D (see docs/architecture/pc2_test_level.md §3).
+##
+## No networking, no chunk code, no avatar UI — PC2 is local-only.
+
+
+# ---------------------------------------------------------------------------
+# Movement constants
+# ---------------------------------------------------------------------------
+
+const WALK_SPEED: float = 5.0
+const JUMP_VELOCITY: float = 4.5
+const GRAVITY: float = 9.8
+
+## Mouse-look sensitivity (radians per pixel of relative motion).
+const MOUSE_SENSITIVITY: float = 0.003
+
+## Camera pitch is clamped so the player can't flip past looking straight
+## up/down (which would otherwise let mouse-look invert on itself).
+const PITCH_LIMIT: float = deg_to_rad(89.0)
+
+
+# ---------------------------------------------------------------------------
+# Input state
+# ---------------------------------------------------------------------------
+
+var _input_direction := Vector2.ZERO
+var _camera_pitch: float = 0.0
+
+@onready var _camera: Camera3D = $Camera3D
+
+
+# ---------------------------------------------------------------------------
+# _ready — spawn at PlayerSpawn marker, capture the mouse for look
+# ---------------------------------------------------------------------------
+
+func _ready() -> void:
+	# Per §3 of pc2_test_level.md: look up PlayerSpawn from the current
+	# scene root.  The lookup walks the full subtree (recursive=true) so
+	# it finds the marker whether it is a direct child of the level or
+	# nested deeper.
+	#
+	# current_scene is null in headless --script mode and in any scene
+	# before the main scene is fully swapped in, so guard it rather than
+	# blindly dereferencing.
+	var current_scene: Node = get_tree().current_scene
+	var spawn: Node = null
+	if current_scene != null:
+		spawn = current_scene.find_child("PlayerSpawn", true, false)
+
+	if spawn is Node3D:
+		global_position = (spawn as Node3D).global_position
+		# Align player forward with spawn yaw (optional polish).
+		var spawn_yaw := (spawn as Node3D).rotation.y
+		rotation.y = spawn_yaw
+	else:
+		push_warning("player.gd: no PlayerSpawn marker found; spawning at origin")
+		global_position = Vector3(0, 1.0, 0)
+
+	# Capture the mouse for FPS-style look. Headless/test runs have no real
+	# window to capture input for, so guard against that rather than error.
+	if DisplayServer.get_name() != "headless":
+		Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
+
+
+# ---------------------------------------------------------------------------
+# _unhandled_input — capture keyboard / mouse for movement
+# ---------------------------------------------------------------------------
+
+func _unhandled_input(event: InputEvent) -> void:
+	if event is InputEventKey:
+		var key := event as InputEventKey
+		if key.pressed and not key.echo:
+			_update_input_direction(key)
+		elif not key.pressed:
+			_clear_input_direction(key)
+		# Escape exits the level back to the world browse list, mirroring
+		# the Back button pattern already used in world_list.gd/main_menu.gd.
+		if key.pressed and key.keycode == KEY_ESCAPE:
+			Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
+			get_tree().change_scene_to_file("res://scenes/world_list.tscn")
+	elif event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:
+		_handle_mouse_look(event as InputEventMouseMotion)
+
+
+func _update_input_direction(key: InputEventKey) -> void:
+	match key.keycode:
+		KEY_W, KEY_UP:
+			_input_direction.y += 1.0
+		KEY_S, KEY_DOWN:
+			_input_direction.y -= 1.0
+		KEY_A, KEY_LEFT:
+			_input_direction.x -= 1.0
+		KEY_D, KEY_RIGHT:
+			_input_direction.x += 1.0
+
+
+func _clear_input_direction(key: InputEventKey) -> void:
+	match key.keycode:
+		KEY_W, KEY_UP:
+			_input_direction.y -= 1.0
+		KEY_S, KEY_DOWN:
+			_input_direction.y += 1.0
+		KEY_A, KEY_LEFT:
+			_input_direction.x += 1.0
+		KEY_D, KEY_RIGHT:
+			_input_direction.x -= 1.0
+
+
+func _handle_mouse_look(event: InputEventMouseMotion) -> void:
+	# Yaw rotates the whole body (so movement direction turns with the
+	# look direction); pitch only tilts the camera, so the capsule itself
+	# never tips over.
+	rotation.y -= event.relative.x * MOUSE_SENSITIVITY
+	_camera_pitch = clampf(_camera_pitch - event.relative.y * MOUSE_SENSITIVITY, -PITCH_LIMIT, PITCH_LIMIT)
+	_camera.rotation.x = _camera_pitch
+
+
+# ---------------------------------------------------------------------------
+# Physics — gravity, jump, move_and_slide
+# ---------------------------------------------------------------------------
+
+func _physics_process(delta: float) -> void:
+	# Apply gravity.
+	if not is_on_floor():
+		velocity.y -= GRAVITY * delta
+
+	# Jump.
+	if is_on_floor() and Input.is_action_just_pressed("ui_accept"):
+		velocity.y = JUMP_VELOCITY
+
+	# Build movement direction from input. Godot's local "forward" is -Z, not
+	# +Z, so W (input.y = +1) must use -basis.z -- using +basis.z here would
+	# move the player backward when pressing forward (confirmed by reading
+	# Camera3D/Node3D's own convention: a node looks down its local -Z).
+	var direction := (_input_direction.x * transform.basis.x -
+		_input_direction.y * transform.basis.z).normalized()
+	velocity.x = direction.x * WALK_SPEED
+	velocity.z = direction.z * WALK_SPEED
+
+	move_and_slide()

scripts/player_spawner.gd

@@ -0,0 +1,232 @@
+class_name PlayerNode
+extends CharacterBody3D
+## PlayerNode - Server-side player entity.
+##
+## Represents a connected player on the server. Handles movement,
+## input processing, and state synchronization.
+
+# --- Signals ---
+signal health_changed(new_health: int)
+signal player_died(player_node: PlayerNode)
+
+
+# --- Constants ---
+const WALK_SPEED := 5.0
+const SPRINT_MULTIPLIER := 1.6
+const JUMP_VELOCITY := 4.5
+const GRAVITY := 9.8
+const MAX_FALL_SPEED := 20.0
+const FRICTION := 8.0
+const AIR_CONTROL := 0.3
+
+# --- Configurable ---
+@export var walk_speed: float = WALK_SPEED
+@export var sprint_multiplier: float = SPRINT_MULTIPLIER
+@export var jump_velocity: float = JUMP_VELOCITY
+@export var max_fall_speed: float = MAX_FALL_SPEED
+
+# --- State ---
+@export var max_health: int = 100
+var current_health: int = 0
+var is_alive: bool = true
+var is_sprinting: bool = false
+var peer_id: int = -1
+var player_name: String = ""
+var entity_id: int = 0
+
+# --- Input buffer ---
+var _input_queue: Array[Dictionary] = []
+var _last_processed_seq: int = -1
+
+# --- Movement ---
+var _velocity: Vector3 = Vector3.ZERO
+
+
+func _ready() -> void:
+	current_health = max_health
+	velocity = _velocity
+	# Start alive
+	is_alive = true
+
+
+func _physics_process(delta: float) -> void:
+	if not is_alive:
+		return
+	
+	# Process input from queue
+	_process_input(delta)
+	
+	# Apply gravity
+	if not is_on_floor():
+		velocity.y -= GRAVITY * delta
+		velocity.y = clampf(velocity.y, -max_fall_speed, max_fall_speed)
+	
+	# Apply friction on ground
+	if is_on_floor():
+		var move_dir := Vector2(velocity.x, velocity.z)
+		if move_dir.length() > 0.01:
+			var friction_factor := clampf(FRICTION * delta, 0.0, 1.0)
+			velocity.x = move_dir.normalized().x * move_dir.length() * (1.0 - friction_factor)
+			velocity.z = move_dir.normalized().y * move_dir.length() * (1.0 - friction_factor)
+		else:
+			velocity.x = 0.0
+			velocity.z = 0.0
+	
+	# Move and slide
+	velocity.y = clampf(velocity.y, -max_fall_speed, max_fall_speed)
+	move_and_slide()
+	
+	# Update visual position (for remote clients via RPC)
+	_update_visual_state()
+
+
+func _process_input(delta: float) -> void:
+	"""Process buffered input from the server's input queue."""
+	if _input_queue.is_empty():
+		return
+	
+	var input_data: Dictionary = _input_queue.pop_front()
+	var input_state: Dictionary = input_data.get("input_state", {})
+	
+	# Calculate movement direction
+	var direction := Vector3.ZERO
+	direction.x = input_state.get("move_x", 0.0)
+	direction.z = input_state.get("move_z", 0.0)
+	
+	# Sprint check
+	is_sprinting = input_state.get("sprint", false)
+	
+	if direction.length() > 0.01:
+		direction = direction.normalized()
+		var speed = walk_speed * sprint_multiplier if is_sprinting else walk_speed
+		velocity.x = direction.x * speed
+		velocity.z = direction.z * speed
+	else:
+		# On ground, apply friction (handled in physics_process)
+		if not is_on_floor():
+			velocity.x *= (1.0 - AIR_CONTROL * delta * 5.0)
+			velocity.z *= (1.0 - AIR_CONTROL * delta * 5.0)
+	
+	# Jump
+	if input_state.get("jump", false) and is_on_floor():
+		velocity.y = jump_velocity
+
+
+func take_damage(amount: int, source_id: int) -> Dictionary:
+	"""Take damage and return result dict."""
+	if not is_alive:
+		return {"success": false, "reason": "already_dead"}
+	
+	current_health = max(0, current_health - amount)
+	health_changed.emit(current_health)
+	
+	if current_health <= 0:
+		die()
+		return {"success": true, "health": 0, "dead": true}
+	
+	return {"success": true, "health": current_health}
+
+
+func die() -> void:
+	"""Handle player death."""
+	is_alive = false
+	velocity = Vector3.ZERO
+	player_died.emit(self)
+	
+	# Respawn after delay
+	await get_tree().create_timer(3.0).timeout
+	respawn()
+
+
+func respawn() -> void:
+	"""Respawn the player at spawn point."""
+	current_health = max_health
+	is_alive = true
+	velocity = Vector3.ZERO
+	health_changed.emit(current_health)
+	
+	# Move to spawn point (default: origin)
+	position = Vector3.ZERO
+
+
+func set_input_queue(inputs: Array[Dictionary]) -> void:
+	"""Set the input queue from the server."""
+	_input_queue = inputs
+
+
+func get_state() -> Dictionary:
+	"""Get current player state for replication."""
+	return {
+		"entity_id": entity_id,
+		"peer_id": peer_id,
+		"position": position,
+		"rotation": rotation,
+		"health": current_health,
+		"max_health": max_health,
+		"is_alive": is_alive,
+		"is_sprinting": is_sprinting,
+	}
+
+
+func get_server_state() -> Dictionary:
+	"""Get current player state for server snapshot broadcast."""
+	return get_state()
+
+
+func process_server_input(tick: int) -> void:
+	"""Called by server tick to process buffered input."""
+	# This is called from the server's _tick loop.
+	# The input queue is populated by RPCs from clients.
+	pass
+
+
+func _update_visual_state() -> void:
+	"""Update visual state (for remote interpolation)."""
+	# In a full implementation, this would update a remote player's
+	# visual representation. For now, the node itself is the authority.
+	pass
+
+
+# --- RPCs ---
+
+@rpc("any_peer", "call_remote", "reliable")
+func rpc_request_input(input_state: Dictionary, seq: int) -> void:
+	"""Receive input from client."""
+	if not is_alive:
+		return
+	# Store for processing in _physics_process
+	_input_queue.append({
+		"input_state": input_state,
+		"seq": seq,
+		"timestamp": Time.get_ticks_msec(),
+	})
+
+
+@rpc("any_peer", "call_remote", "reliable")
+func rpc_request_interact(target_id: int) -> void:
+	"""Handle interaction request from client."""
+	if not is_alive:
+		return
+	# TODO: Implement interaction logic
+	print("Player %d interacted with entity %d" % [peer_id, target_id])
+
+
+@rpc("any_peer", "call_remote", "reliable")
+func rpc_request_attack(target_id: int, aim_dir: Vector3) -> void:
+	"""Handle attack request from client."""
+	if not is_alive:
+		return
+	# TODO: Implement attack logic
+	print("Player %d attacked entity %d with aim %s" % [peer_id, target_id, aim_dir])
+
+
+@rpc("authority", "call_remote", "reliable")
+func rpc_set_position(pos: Vector3) -> void:
+	"""Server authoritative position update."""
+	position = pos
+
+
+@rpc("authority", "call_remote", "reliable")
+func rpc_set_rotation(rot: Vector3) -> void:
+	"""Server authoritative rotation update."""
+	rotation = rot

scripts/player_spawner.gd.uid

@@ -0,0 +1 @@
+uid://br27owjh2f5xd

scripts/server.gd

@@ -0,0 +1,174 @@
+## ServerMain - Dedicated server root node.
+## Accepts ENet connections, spawns Player nodes for each peer,
+## and runs the simulation tick loop at 20 Hz.
+extends Node
+
+
+## Maximum number of concurrent players.
+const MAX_PLAYERS := 16
+
+## Server tick rate (Hz).
+const TICK_RATE := 20
+
+## Tick duration in seconds.
+const TICK_DURATION := 1.0 / TICK_RATE
+
+## ENet server port.
+const SERVER_PORT := 7777
+
+## Network peer used for ENet communication.
+var network_peer: ENetMultiplayerPeer
+
+## Map of peer_id -> Player node.
+var players: Dictionary = {}
+
+## Current tick counter (server-authoritative).
+var tick: int = 0
+
+## Whether the server is running.
+var is_running: bool = false
+
+## Accumulated real time for fixed timestep simulation.
+var accumulator: float = 0.0
+
+## Player scene resource (loaded once).
+var _player_scene: PackedScene
+
+
+func _ready() -> void:
+	# Preload the player scene once.
+	_player_scene = preload("res://scenes/server_player.tscn")
+
+	# Create and assign the ENet server peer.
+	network_peer = _create_server_peer()
+	if network_peer:
+		multiplayer.multiplayer_peer = network_peer
+		is_running = true
+		print("[Server] Started on port %d" % SERVER_PORT)
+	else:
+		printerr("[Server] Failed to create ENet peer.")
+		get_tree().quit(1)
+
+
+# ---------------------------------------------------------------------------
+# Server creation
+# ---------------------------------------------------------------------------
+
+func _create_server_peer() -> ENetMultiplayerPeer:
+	var peer := ENetMultiplayerPeer.new()
+	var error := peer.create_server(SERVER_PORT, MAX_PLAYERS)
+	if error != OK:
+		printerr("[Server] create_server error: %d" % error)
+		return null
+	return peer
+
+
+# ---------------------------------------------------------------------------
+# Fixed-timestep simulation loop
+# ---------------------------------------------------------------------------
+
+func _process(delta: float) -> void:
+	if not is_running:
+		return
+
+	# Fixed timestep accumulator.
+	accumulator += delta
+	while accumulator >= TICK_DURATION:
+		accumulator -= TICK_DURATION
+		_tick()
+
+
+func _tick() -> void:
+	"""Main server simulation tick (called at TICK_RATE)."""
+	tick += 1
+
+	# Process player inputs and update state.
+	for peer_id in players:
+		var player: Node3D = players[peer_id]
+		if player and player.has_method("process_server_input"):
+			player.process_server_input(tick)
+
+	# Broadcast snapshot to all clients.
+	_broadcast_snapshot()
+
+
+func _broadcast_snapshot() -> void:
+	"""Broadcast the current authoritative state to all connected clients."""
+	var snapshot_data := {
+		"tick": tick,
+		"players": {},
+	}
+
+	for peer_id in players:
+		var player: Node3D = players[peer_id]
+		if player and player.has_method("get_server_state"):
+			snapshot_data.players[peer_id] = player.get_server_state()
+
+	# Send snapshot to all peers except the server itself (peer_id == 1).
+	var peer_ids: Array = multiplayer.get_peers()
+	for pid in peer_ids:
+		if pid == 1:  # 1 is the server itself
+			continue
+		rpc_id(pid, "_receive_snapshot", snapshot_data)
+
+
+# Remote: clients receive snapshots.
+@rpc("any_peer", "call_remote", "reliable")
+func _receive_snapshot(snapshot_data: Dictionary) -> void:
+	pass  # Handled by client scene.
+
+
+# ---------------------------------------------------------------------------
+# Connection lifecycle
+# ---------------------------------------------------------------------------
+
+func _on_peer_connected(peer_id: int) -> void:
+	print("[Server] Peer %d connected." % peer_id)
+
+	if players.size() >= MAX_PLAYERS:
+		print("[Server] Max players reached. Disconnecting peer %d." % peer_id)
+		rpc_id(peer_id, "_kick", "Server is full.")
+		return
+
+	# Spawn a Player node for this peer.
+	var player: Node3D = _player_scene.instantiate()
+	player.name = "Player_%d" % peer_id
+	player.peer_id = peer_id
+	add_child(player)
+	players[peer_id] = player
+
+	print("[Server] Spawned player node for peer %d." % peer_id)
+
+
+func _on_peer_disconnected(peer_id: int) -> void:
+	print("[Server] Peer %d disconnected." % peer_id)
+	if players.has(peer_id):
+		var player: Node3D = players[peer_id]
+		if player.is_inside_tree():
+			player.queue_free()
+		players.erase(peer_id)
+
+
+# ---------------------------------------------------------------------------
+# RPCs
+# ---------------------------------------------------------------------------
+
+@rpc("any_peer", "call_remote", "reliable")
+func _kick(reason: String) -> void:
+	print("[Server] Kicking caller: %s" % reason)
+	rpc_id(multiplayer.get_remote_sender_id(), "_disconnect", reason)
+
+
+@rpc("call_remote", "reliable")
+func _disconnect(reason: String) -> void:
+	print("[Server] Disconnecting: %s" % reason)
+	get_tree().quit(0)
+
+
+# ---------------------------------------------------------------------------
+# Signal connections
+# ---------------------------------------------------------------------------
+
+func _enter_tree() -> void:
+	multiplayer.peer_connected.connect(_on_peer_connected)
+	multiplayer.peer_disconnected.connect(_on_peer_disconnected)

scripts/server.gd.uid

@@ -0,0 +1 @@
+uid://cwjv826lva2gi

scripts/smoke_test_enter_world.gd

@@ -0,0 +1,146 @@
+extends SceneTree
+## Regression/smoke test for the PC2 "Enter World" flow end to end.
+##
+## Real user path: register -> land on world_list.tscn -> click "Enter World"
+## on a real card -> the playable level (scenes/game.tscn) actually loads
+## with the player spawned in it -> pressing Escape returns to world_list.
+##
+## Run with:
+##     godot --headless --path . --script res://scripts/smoke_test_enter_world.gd
+##
+## Requires the backend to be running (default base URL
+## `application/agp/api_base_url` -> http://127.0.0.1:8000, overridable via
+## AGP_API_BASE_URL) and at least one real world to already exist.
+
+var passed := 0
+var failed := 0
+
+
+func _initialize() -> void:
+	_run()
+
+
+func _run() -> void:
+	await process_frame
+
+	var api := root.get_node("ApiClient")
+	if api == null:
+		printerr("FAIL: ApiClient autoload not found")
+		quit(1)
+		return
+
+	# 1. Register a real user and seed a world so the browse list has a
+	# real card to click, same pattern as smoke_test_world_list.gd.
+	randomize()
+	var unique_id: int = int(Time.get_unix_time_from_system() * 1000) + randi() % 100000
+	var username := "enterworld_%d" % unique_id
+	var email := "enterworld_%d@test.example.com" % unique_id
+	var reg_result: Dictionary = await api.register(username, email, "SmokeTest123!", true)
+	if not _check("setup: register succeeded", reg_result.ok):
+		print("  detail: ", reg_result.detail)
+		_finish()
+		return
+
+	var world_body := JSON.stringify({
+		"name": "EnterWorld Smoke Test World %d" % unique_id,
+		"description": "Seeded by smoke_test_enter_world.gd",
+		"visibility": "public",
+	})
+	var world_result: Dictionary = await api.request(
+		HTTPClient.METHOD_POST, "/api/worlds/", world_body, "application/json", true
+	)
+	if not _check("setup: world created", world_result.ok):
+		print("  detail: ", world_result.detail)
+		_finish()
+		return
+
+	# 2. Load world_list.tscn as a real scene and let it fetch worlds.
+	var packed: PackedScene = load("res://scenes/world_list.tscn")
+	var instance: Control = packed.instantiate()
+	root.add_child(instance)
+	# _ready() kicks off an async _refresh_worlds() -- wait real frames for
+	# the HTTP round trip rather than guessing a fixed count.
+	var world_list_node: VBoxContainer = instance.get_node("VBoxContainer/ScrollContainer/WorldList")
+	var settled := false
+	for i in 120:
+		await process_frame
+		if world_list_node.get_child_count() > 0:
+			settled = true
+			break
+	if not _check("world list populated with at least one card", settled):
+		_finish()
+		return
+
+	# 3. Click "Enter World" on the first real card -- find the button by
+	# walking the card's children rather than assuming an index, so this
+	# doesn't silently pass if _create_world_card's structure changes.
+	var card: Control = world_list_node.get_child(0)
+	var enter_button: Button = _find_button(card, "Enter World")
+	if not _check("Enter World button exists on the card", enter_button != null):
+		_finish()
+		return
+
+	enter_button.pressed.emit()
+	await _wait_for_scene_change(instance, 60)
+
+	var game_scene := current_scene
+	if not _check("game.tscn became current_scene after Enter World", game_scene != null and game_scene != instance):
+		_finish()
+		return
+
+	# 4. Verify the player actually exists and spawned at the level's
+	# PlayerSpawn marker -- not just that *some* scene loaded.
+	var player: Node = game_scene.get_node_or_null("Player")
+	_check("Player node exists in the loaded game scene", player is CharacterBody3D)
+
+	var spawn_marker: Node = game_scene.get_node_or_null("Level/PlayerSpawn")
+	_check("PlayerSpawn marker exists in the loaded level", spawn_marker is Marker3D)
+
+	if player is CharacterBody3D and spawn_marker is Marker3D:
+		var dist := (player as CharacterBody3D).global_position.distance_to((spawn_marker as Marker3D).global_position)
+		_check("player spawned at (or very near) the PlayerSpawn marker", dist < 0.5)
+
+	# 5. Escape should return to world_list.tscn (real key event, not a
+	# direct method call -- proves the actual input binding works).
+	var esc_event := InputEventKey.new()
+	esc_event.keycode = KEY_ESCAPE
+	esc_event.pressed = true
+	Input.parse_input_event(esc_event)
+	await _wait_for_scene_change(game_scene, 60)
+
+	var back_to_menu := current_scene
+	_check("Escape returned to world_list.tscn", back_to_menu != null and back_to_menu.scene_file_path == "res://scenes/world_list.tscn")
+
+	_finish()
+
+
+func _find_button(node: Node, text: String) -> Button:
+	if node is Button and (node as Button).text == text:
+		return node
+	for child in node.get_children():
+		var found := _find_button(child, text)
+		if found:
+			return found
+	return null
+
+
+func _wait_for_scene_change(previous_scene: Node, max_frames: int) -> void:
+	for i in max_frames:
+		await process_frame
+		if current_scene != previous_scene and current_scene != null:
+			return
+
+
+func _check(description: String, condition: bool) -> bool:
+	if condition:
+		print("  PASS: ", description)
+		passed += 1
+	else:
+		printerr("  FAIL: ", description)
+		failed += 1
+	return condition
+
+
+func _finish() -> void:
+	print("\n=== SMOKE RESULT: %d/%d passed ===" % [passed, passed + failed])
+	quit(0 if failed == 0 else 1)

scripts/smoke_test_player.gd

@@ -0,0 +1,93 @@
+extends SceneTree
+## Smoke test for the player character scene and its spawn behavior.
+##
+## Run with:
+##     godot --headless --path . --script res://scripts/smoke_test_player.gd
+##
+## Loads the test level, verifies the player is present, spawned at the
+## PlayerSpawn marker, and has the expected CharacterBody3D structure.
+
+var _passed := 0
+var _failed := 0
+
+
+func _initialize() -> void:
+	print("SMOKE: starting player smoke test")
+	_run()
+
+
+func _run() -> void:
+	await process_frame
+	print("SMOKE: loading game scene")
+
+	# Load scenes/game.tscn -- the real PC2 composition point (Level + Player
+	# as siblings, per docs/architecture/pc2_test_level.md §4), not the level
+	# scene directly. Use the same SceneTree API as the real game so
+	# `current_scene` is populated before the scene is added and its
+	# _ready() callbacks fire. That ordering is what the player's spawn
+	# lookup (get_tree().current_scene) depends on.
+	var packed: PackedScene = load("res://scenes/game.tscn")
+	var result := change_scene_to_packed(packed)
+	if result != OK:
+		printerr("SMOKE: failed to change scene, error ", result)
+		quit(1)
+		return
+
+	await scene_changed
+	var game: Node3D = current_scene as Node3D
+	print("SMOKE: game scene ready")
+
+	# 1. Verify the player node exists in the scene tree.
+	var player: Node = game.get_node("Player")
+	_check("Player node exists in test level", player != null)
+	_check("Player is a CharacterBody3D", player is CharacterBody3D)
+
+	# 2. Verify the player has the expected child structure.
+	var collision: Node = player.get_node("CollisionShape3D")
+	_check("Player has CollisionShape3D", collision != null)
+	_check("CollisionShape3D has a shape",
+		   collision is CollisionShape3D and (collision as CollisionShape3D).shape != null)
+
+	var mesh: Node = player.get_node("CapsuleMesh")
+	_check("Player has CapsuleMesh", mesh != null)
+	_check("CapsuleMesh has a mesh",
+		   mesh is MeshInstance3D and (mesh as MeshInstance3D).mesh != null)
+
+	# 3. Verify the player spawned at the PlayerSpawn marker position.
+	var spawn_marker: Marker3D = game.get_node("Level/PlayerSpawn")
+	_check("PlayerSpawn marker exists", spawn_marker != null)
+
+	# The player's _ready() should have moved it to the spawn marker's
+	# global position. Compare global positions directly (not local) since
+	# Player and Level sit at different depths under Game.
+	var expected_pos: Vector3 = spawn_marker.global_position
+	_check("Player spawned at PlayerSpawn position",
+		   player.global_position == expected_pos)
+
+	# 4. Verify the player script class_name is correct and has the
+	# movement constants defined.
+	var script: GDScript = player.get_script() as GDScript
+	_check("Player has a script attached", script != null)
+	var constants: Dictionary = script.get_script_constant_map()
+	_check("Player has WALK_SPEED constant", constants.has("WALK_SPEED"))
+	_check("Player has GRAVITY constant", constants.has("GRAVITY"))
+	_check("Player has JUMP_VELOCITY constant", constants.has("JUMP_VELOCITY"))
+	_check("JUMP_VELOCITY is positive (upward)", float(constants.get("JUMP_VELOCITY", -1.0)) > 0.0)
+
+	# 5. Verify the player has a Camera3D so the game is actually viewable
+	# from the player's perspective, not just a walking capsule with no view.
+	var camera: Node = player.get_node_or_null("Camera3D")
+	_check("Player has a Camera3D", camera is Camera3D)
+	_check("Camera3D is current", camera is Camera3D and (camera as Camera3D).current)
+
+	print("\n=== SMOKE RESULT: %d/%d passed ===" % [_passed, _passed + _failed])
+	quit(0 if _failed == 0 else 1)
+
+
+func _check(description: String, condition: bool) -> void:
+	if condition:
+		print("  PASS: ", description)
+		_passed += 1
+	else:
+		printerr("  FAIL: ", description)
+		_failed += 1

scripts/smoke_test_test_level.gd

@@ -0,0 +1,125 @@
+extends SceneTree
+## Headless smoke test for the PC2 test level scene.
+##
+## Run with:
+##     godot --headless --path . --script res://scripts/smoke_test_test_level.gd
+##
+## Loads the test level scene, asserts:
+##   (a) it loads without error,
+##   (b) it contains a Marker3D named "PlayerSpawn",
+##   (c) PlayerSpawn is positioned >= 1.0 m above the ground top surface.
+## Exits 0 on success, 1 on failure.
+
+
+func _initialize() -> void:
+	_run()
+
+
+func _run() -> void:
+	var level_path: String = "res://scenes/worlds/test_level.tscn"
+
+	# Load the scene file
+	var level_resource: PackedScene = load(level_path)
+	if level_resource == null:
+		printerr("SMOKE RESULT: FAIL \u2014 could not load ", level_path)
+		quit(1)
+		return
+
+	print("SMOKE: test_level.tscn loaded successfully")
+
+	# Change the running scene to our test level
+	var err: int = change_scene_to_packed(level_resource)
+	if err != OK:
+		printerr("SMOKE RESULT: FAIL \u2014 change_scene_to_packed returned ", err)
+		quit(1)
+		return
+
+	# Wait for the scene_changed signal so current_scene is set
+	await scene_changed
+
+	var level_instance: Node3D = current_scene as Node3D
+	if level_instance == null:
+		printerr("SMOKE RESULT: FAIL \u2014 current_scene is not Node3D")
+		quit(1)
+		return
+
+	# Give the tree one frame to fully initialize
+	await process_frame
+
+	# (b) Find the PlayerSpawn marker
+	var spawn_marker: Node3D = level_instance.find_child("PlayerSpawn", true, false) as Node3D
+	if spawn_marker == null:
+		printerr("SMOKE RESULT: FAIL \u2014 no Node3D named 'PlayerSpawn' found in test level")
+		quit(1)
+		return
+
+	print("SMOKE: found PlayerSpawn at ", spawn_marker.global_position)
+
+	# (c) Verify PlayerSpawn is >= 1.0 m above ground top
+	# The ground top surface is at y = 0 (Ground StaticBody3D centered at y = -0.5
+	# with height 1.0, so top face is at y = 0).
+	var spawn_y: float = spawn_marker.global_position.y
+	if spawn_y < 1.0:
+		printerr("SMOKE RESULT: FAIL \u2014 PlayerSpawn y = ", spawn_y,
+				 " is below the required minimum of 1.0 m above ground top (y=0)")
+		quit(1)
+		return
+
+	print("SMOKE: PlayerSpawn y = ", spawn_y, " >= 1.0 m \u2014 PASS")
+
+	# Additional check: verify Ground StaticBody3D exists
+	var ground: StaticBody3D = level_instance.find_child("Ground", true, false) as StaticBody3D
+	if ground == null:
+		printerr("SMOKE RESULT: FAIL \u2014 no StaticBody3D named 'Ground' found")
+		quit(1)
+		return
+
+	print("SMOKE: found Ground StaticBody3D")
+
+	# Verify Ground top face is at y = 0
+	var ground_shape: CollisionShape3D = ground.find_child("CollisionShape3D", true, false) as CollisionShape3D
+	if ground_shape != null and ground_shape.shape is BoxShape3D:
+		var box_shape: BoxShape3D = ground_shape.shape as BoxShape3D
+		var ground_top: float = ground.global_position.y + box_shape.size.y / 2.0
+		if abs(ground_top - 0.0) > 0.01:
+			printerr("SMOKE RESULT: FAIL \u2014 Ground top face at y = ", ground_top, " expected ~0.0")
+			quit(1)
+			return
+		print("SMOKE: Ground top face at y = ", ground_top, " \u2014 PASS")
+
+	# Verify props exist (3-5 StaticBody3D children under Props node)
+	var props_node: Node3D = level_instance.find_child("Props", true, false) as Node3D
+	if props_node != null:
+		var prop_count: int = 0
+		for child in props_node.get_children():
+			if child is StaticBody3D:
+				prop_count += 1
+		if prop_count < 3:
+			printerr("SMOKE RESULT: FAIL \u2014 only ", prop_count, " props found, need >= 3")
+			quit(1)
+			return
+		print("SMOKE: found ", prop_count, " props \u2014 PASS")
+	else:
+		printerr("SMOKE RESULT: FAIL \u2014 no 'Props' Node3D found")
+		quit(1)
+		return
+
+	# Verify lighting exists
+	var sun: DirectionalLight3D = level_instance.find_child("Sun", true, false) as DirectionalLight3D
+	if sun == null:
+		printerr("SMOKE RESULT: FAIL \u2014 no DirectionalLight3D named 'Sun' found")
+		quit(1)
+		return
+	print("SMOKE: found Sun DirectionalLight3D")
+
+	# Verify WorldEnvironment exists
+	var env: WorldEnvironment = level_instance.find_child("WorldEnvironment", true, false) as WorldEnvironment
+	if env == null:
+		printerr("SMOKE RESULT: FAIL \u2014 no WorldEnvironment named 'WorldEnvironment' found")
+		quit(1)
+		return
+	print("SMOKE: found WorldEnvironment")
+
+	# All checks passed
+	print("SMOKE RESULT: PASS")
+	quit(0)

scripts/world_list.gd

@@ -135,8 +135,23 @@ func _create_world_card(world_dict: Dictionary) -> Control:
 	meta_label.add_theme_font_size_override("font_size", 12)
 	meta_label.add_theme_color_override("font_color", Color(0.5, 0.5, 0.5, 1.0))
 
+	# PC2: the only thing a world actually loads into right now is the one
+	# shared playable test level (scenes/game.tscn) -- there's no per-world
+	# content yet, so "Enter" doesn't need the world's id for anything.
+	# Real per-world level loading is a later concern once worlds actually
+	# have their own content to load.
+	var enter_button := Button.new()
+	enter_button.text = "Enter World"
+	enter_button.size_flags_horizontal = Control.SIZE_SHRINK_BEGIN
+	enter_button.pressed.connect(_on_enter_world_pressed)
+
 	card.add_child(name_label)
 	card.add_child(desc_label)
 	card.add_child(meta_label)
+	card.add_child(enter_button)
 
 	return panel
+
+
+func _on_enter_world_pressed() -> void:
+	get_tree().change_scene_to_file("res://scenes/game.tscn")