Merge pull request #41 from ViPro-Technologies/NEON-29-expand-prototype-district

Neon 29 expand prototype district

.cursor/settings.json

@@ -2,6 +2,9 @@
   "plugins": {
     "atlassian": {
       "enabled": true
+    },
+    "linear": {
+      "enabled": true
     }
   }
 }

client/README.md

@@ -15,15 +15,51 @@ Do not grow an all-in-one **`main.gd`**. The main scene root should **compose**
 
 The main scene uses **`World/IsometricFollowCamera`** (`scripts/isometric_follow_camera.gd`): client-local **isometric follow** for **`Player`** (`NodePath` **`../Player`**), with damped eye motion (`follow_smoothness`, exponential lerp) and **teleport snap** when the eye is farther than **`snap_distance`** from the desired pose (e.g. after **`snap_to_server`**). Framing exports **`follow_distance`**, **`pitch_elevation_deg`**, and **`presentation_yaw_deg`** match the pre–NEO-15 static camera at spawn. **Orbit is off in the prototype:** **`allow_yaw`** is false, **`CameraState.yaw`** stays **0**, and no rotate input is read—enable **`allow_yaw`** later and drive **`_orbit_yaw_rad`** from input on the rig (see **`docs/decomposition/modules/E1_M2_IsometricCameraController.md`**). **`CameraState`** (`scripts/camera_state.gd`) is refreshed every **`_physics_process`** tick on the rig (**`process_physics_priority`** after **`Player`**) so framing tracks **`move_and_slide`** without display-vs-physics jitter. **`ground_pick`** uses the viewport camera; **`main.gd`** sets **`fallback_camera`** to **`World/IsometricFollowCamera/Camera3D`**.
 
+## Prototype district (NEON-29)
+
+The default play space is a **45 × 45** unit flat floor (~2 000 sq units, ~5× the pre-NEON-29 footprint). All geometry lives under `World/NavigationRegion3D` in `scenes/main.tscn`; `main.gd` rebakes the nav mesh at startup so the scene-file vertices are intentionally stale.
+
+### Props at a glance
+
+Elevated walkables use **distinct albedo tints** in `scenes/main.tscn` so screenshots and discussion can name the right prop (`Mat_terrace_platform_a`, `Mat_terrace_b_step`, etc.). The main **floor** slab uses neutral gray (`Mat_floor_slab`). **Occluders** keep the default mesh gray.
+
+| Node | Group | Tint | Size (m) | World XZ | Purpose |
+|------|-------|------|----------|----------|---------|
+| `Floor` | `walkable` | Neutral gray | 45 × 45 | (0, 0) | Main play surface |
+| `PrototypeTerminal` | `walkable` | Slate blue | 0.9 × 0.4 | (0, 0) | Interaction target |
+| `MoveRejectPedestal` | `walkable` | Orange | 1.5 × 1.5 | (7.5, −6.5) | NEON-7 vertical reject |
+| `MoveRejectFarPad` | `walkable` | Blue-gray | 2.5 × 2.5 | (9, 9) | Near-floor walkable pad; no longer a reject target (horizontal limit removed NEON-29) |
+| `Obstacle` | `occluder` | Default gray | 2 × 2 | (6, 5) | Original occlusion / click-through target |
+| `ObstacleB` | `occluder` | Default gray | 3 × 3 | (−10, 5) | Second occluder (wider angle from spawn) |
+| `ObstacleC` | `occluder` | Default gray | 2 × 4 | (5, −12) | Tall occluder, south quadrant |
+| `ObstacleD` | `occluder` | Default gray | 3 × 2 | (−8, −16) | Far-south occluder |
+| `TerracePlatformA` | `walkable` | **Teal** | 10 × 10, h=0.3 m | (13, −14) | Large SE pad; **three darker-teal approach treads per cardinal** (`TerracePlatformA_Approach` / `PAS_*`) — **1.0 m run** along the climb axis (~0.104 m rise each), wider than the **0.8 m** capsule diameter so the body is not wider than each tread |
+| `TerraceStepB` | `walkable` | **Gold** | 6 × 3, h=0.3 m | (−15, 8.5) | NW approach step; **`TerraceStepB_Approach`** / `TSB_*` — three treads per **S/E/W** (darker gold), **1.0 m** run on NS arms |
+| `TerracePlatformB` | `walkable` | **Violet** | 6 × 6, h=0.6 m | (−15, 13) | Upper NW terrace; **`TerracePlatformB_Approach`** / `TPB_*` — **six** treads per **N/E/W** (~0.104 m rise) for **0.6 m** to floor (**south** uses gold step, not violet treads) |
+| `TerracePlatformC` | `walkable` | **Green** | 8 × 8, h=0.3 m | (14, 14) | NE pad; **`TerracePlatformC_Approach`** / `PCS_*` — same tread pattern as teal (`PAS_*`), darker green albedo |
+
+### Height variation notes
+
+- **Single-step terraces (A, C):** 0.3 m rise — within `agent_max_climb = 0.35`, so the nav mesh routes directly from floor onto the pad; one click suffices. **`TerracePlatformA`** (teal) sits **12 mm** above the main floor slab and has **cardinal walkable treads** (`TerracePlatformA_Approach`) so movement does not rely on a bare vertical box lip; nav rebakes at startup.
+- **Two-level terrace B:** floor → `TerraceStepB` (**gold**, 0.3 m) → `TerracePlatformB` (**violet**, +0.3 m). **`agent_max_climb = 0.35`** applies to the nav mesh **and** to **walk step assist**: you cannot cheese the violet deck from the floor in one move — click the **gold step** (or the platform after you are already on the step), not the violet top from below. **Approach treads** on gold (**`TSB_*`**) and on violet’s **north / east / west** (**`TPB_*`**, six risers for 0.6 m) match the teal convention.
+- **QA / thin props:** **`PrototypeTerminal`**, **`MoveRejectPedestal`**, **`MoveRejectFarPad`** are unchanged (terminal kiosk, vertical reject demo, near-floor pad). Add ramps or treads later if they need full walk-up treatment.
+- **Occluders** are plain `StaticBody3D` with no `walkable` tag; the nav bake excludes their top surfaces, so they remain true obstacles for routing.
+
+### Designer / QA limits
+
+- Floor bounds: **±22.5 m** in X and Z from world origin. Clicks outside the `NavigationRegion3D` boundary (beyond the floor edge) will be rejected by `NavigationAgent3D` path queries.
+- The `MoveRejectPedestal` (orange box) top is ~2.5 m above the floor and will be rejected by the server's `MaxVerticalStep` (**2.2 m** by default) — the only remaining move-rejection criterion with default server config. Horizontal distance is never a rejection reason when `HorizontalStepEnabled` is false.
+- New obstacles are tagged `"occluder"` so the NEON-27 occlusion policy and NEON-30 click-through both apply automatically.
+
 ## Authoritative movement (NEO-7, NEO-11)
 
 With the game server running ([`server/README.md`](../server/README.md)), each valid floor click sends a **`MoveCommand`** (**`POST`**) and a follow-up **`GET`** for **`PositionState`**. The server still **snaps** authority to the target (NEO-7); the client **moves** toward that verified position using **`NavigationAgent3D`** + a **baked mesh** instead of teleporting on the **`GET`** (NEO-11). **Boot** `sync_from_server()` **snaps** once so spawn matches the server.
 
-**Tradeoff (prototype):** `player.gd` only steers **straight in xz** toward the goal for real **descend** cases, where the pick’s **Y** is below the capsule **feet** by a small margin (smooth **stepped bumps**). Same-height floor clicks now stay on the baked **`NavigationAgent3D`** path instead of looking like a descend just because the capsule origin sits above the floor. **Automatic routing around tall obstacles on one click is still not guaranteed** for those true descend-bypass cases — use **several clicks** to go around e.g. the gray **`Obstacle`** when needed.
+**Tradeoff (prototype):** Horizontal motion is a **direct XZ bee-line** toward the server’s verified target. The baked **`NavigationMesh`** is still used when **vertical routing** is latched **and** the capsule is inside the **nav column** hysteresis band (`NAV_COLUMN_STEER_ENTER_DIST` / `EXIT`) **and** **`is_on_floor()`** — terraces / steps then steer along **`get_current_navigation_path()`** using the first waypoint at least **`NAV_PATH_STEER_MIN_LOOKAHEAD`** (~22 cm) away in XZ (unlike a **5 cm** scan or raw **`get_next_path_position()`**, which both sat inside Jolt’s per-tick slide and could flip velocity **180°** every tick). While **airborne**, column path steering is **off** so horizontal motion stays a bee-line toward the click (avoids fall-time XZ oscillation). **No descend bypass** for gravity while on an upper deck (same as before). While walking, **gravity** still runs when **`is_on_floor()`** is false; if **snap / lip contacts** keep **`is_on_floor()`** true over open space (e.g. gold deck → gray floor), **`player.gd`** casts **several short down rays** under the **foot disk** (center + offsets along move direction so the **leading** edge off a deck is tested) and applies **gravity** when **none** hit upward-facing ground within **`WALK_SUPPORT_PROBE_DEPTH`**. In that case **`floor_snap_length`** is set to **0** for the tick so **moving snap** does not cancel **`velocity.y`** on every physics step. **Automatic routing around tall obstacles on one click is still not guaranteed** — use **several clicks** to go around e.g. the gray **`Obstacle`** when needed.
 
 **NEO-10 / movement QA bumps:** On **run**, **`spawn_short_random_bumps`** adds **two** green cylinders, each on its own **`StaticBody3D`** **sibling** of **`Floor`** under **`NavigationRegion3D`** (**`walkable`** on bump roots — avoids compound **internal-edge** jitter vs floor+cylinder on one body). Bump meshes use Godot group **`random_floor_bump_mesh`**. **Collision radius** = mesh **+ `COLLISION_RADIUS_EXTRA`** (see **`scripts/random_floor_bump_collision_constants.gd`**, capped by **`COLLISION_RADIUS_MAX`**). **`bake_navigation_mesh(false)`** after spawn.
 
-**Idle stability (NEO-14):** **Jolt Physics**; **TPS** **120**. **`physics/common/physics_interpolation`** is **off** — with **on**, small physics **position** changes on bump **edges** were **blended** across render frames and looked like **ghosting / extra jitter**. **`snap_to_server()`** still calls **`reset_physics_interpolation()`** for compatibility if you turn interpolation on later. **`floor_max_angle`** **~50°** walking / **~35°** idle; **loose** angle **~0.8 s** after walk stops. **Walk step assist**. **Idle rim / straddle:** **moving** `floor_max_angle` when floor normal is **shallow** or slide hits mix **floor + wall**. One idle **`move_and_slide()`**, rim **settle**, **`random_floor_bump_mesh`** **lip / rim / vertical-wall** escape (**`IDLE_BUMP_ESCAPE_STEP`**, **`PLAYER_CAPSULE_RADIUS`**, collider fudge from **`random_floor_bump_collision_constants.gd`**). **Flat idle hardening:** when support is already effectively level (floor normal almost **`Vector3.UP`** and no post-arrival loose-floor window), **`player.gd`** now skips the corrective idle slide / escape loop instead of nudging the capsule anyway, even if physics reports incidental extra contacts on an otherwise flat support. In that stable grounded state the player also keeps an **idle x/z anchor**, so any residual horizontal creep is clamped away until movement resumes or support stops looking stable. Goal arrival and descend-bypass checks both use the capsule **feet height** rather than the body origin, so flat floor clicks clear and route normally instead of lingering in a straight-line obstacle push. **`Player`:** interp **Off**, **`avoidance_enabled`** **false**, **`floor_block_on_wall`** **true** — do **not** rewrite **`global_transform`** in **`_process`** (can **ghost** **`CharacterBody3D`**). **`_snap_capsule_upright()`** now short-circuits when the basis is already identity. Idle **`FLOOR_SNAP_IDLE`** ~**11 cm**; walking **`FLOOR_SNAP_MOVING`** ~**0.32**. **Rendering:** **`Mat_player_capsule`**, **`cast_shadow = 0`**, capsule mesh **+Y ~3.4 cm** (visual-only vs **`CapsuleShape3D`** — less **z-fight** vs floor/bump tops), **`light_specular = 0`**, **`msaa_3d = 2`**. **`safe_margin`** **0.055**.
+**Idle stability (NEO-14 / NEON-16):** **Jolt Physics**; **TPS** **120**. **`physics/common/physics_interpolation`** is **off** — with **on**, small physics **position** changes on bump **edges** were **blended** across render frames and looked like **ghosting / extra jitter**. **`snap_to_server()`** still calls **`reset_physics_interpolation()`** for compatibility if you turn interpolation on later. **`floor_max_angle`** **~50°** walking / **~35°** idle; **loose** angle **~0.8 s** after walk stops. **Walk step assist**. **Idle rim / straddle:** **moving** `floor_max_angle` when floor normal is **shallow** or slide hits mix **floor + wall**. One idle **`move_and_slide()`**, rim **settle**, **`random_floor_bump_mesh`** **lip / rim / vertical-wall** escape (**`IDLE_BUMP_ESCAPE_STEP`**, **`PLAYER_CAPSULE_RADIUS`**, collider fudge from **`random_floor_bump_collision_constants.gd`**). **Flat idle hardening:** when support is already effectively level (floor normal almost **`Vector3.UP`** and no post-arrival loose-floor window), **`player.gd`** now skips the corrective idle slide / escape loop instead of nudging the capsule anyway, even if physics reports incidental extra contacts on an otherwise flat support. In that stable grounded state the player also keeps an **idle x/z anchor**, so any residual horizontal creep is clamped away until movement resumes or support stops looking stable. **Uniform shallow ramps** can latch stable idle; **nav-column path steering** is gated to flatter floors so ramp ribbons do not flip velocity each tick. Goal arrival and descend-bypass checks both use the capsule **feet height** rather than the body origin, so flat floor clicks clear and route normally instead of lingering in a straight-line obstacle push. **`Player`:** interp **Off**, **`avoidance_enabled`** **false**, **`floor_block_on_wall`** **true** — do **not** rewrite **`global_transform`** in **`_process`** (can **ghost** **`CharacterBody3D`**). **`_snap_capsule_upright()`** now short-circuits when the basis is already identity. Idle **`FLOOR_SNAP_IDLE`** ~**11 cm**; walking **`FLOOR_SNAP_MOVING`** ~**0.32**. **Rendering:** **`Mat_player_capsule`**, **`cast_shadow = 0`**, capsule mesh **+Y ~3.4 cm** (visual-only vs **`CapsuleShape3D`** — less **z-fight** vs floor/bump tops), **`light_specular = 0`**, **`msaa_3d = 2`**. **`safe_margin`** **0.055**.
 
 - **Scripts:** `scripts/ground_pick.gd` (walkable pick + `target_chosen`; occluder bodies tagged `"occluder"` are passed through unconditionally so clicks reach the ground behind them — NEO-20), `scripts/position_authority_client.gd` (`PositionAuthorityClient`: POST move, GET verify; second signal arg = boot snap vs nav goal), `scripts/player.gd` (path-follow), `scripts/isometric_follow_camera.gd` + `scripts/camera_state.gd` (NEO-15 follow), thin `scripts/main.gd` (nav bake on first frame, then wiring).
 - **Scene:** `scenes/main.tscn` — walkable **`StaticBody3D`** geometry lives under **`World/NavigationRegion3D`**. `main.gd` waits one **`process_frame`**, spawns **random test bumps** on **`Floor`**, then **`bake_navigation_mesh(false)`** (main-thread bake), then waits two **`physics_frame`**s so **`NavigationServer3D`** has a map before agents query paths. The baked **`NavigationMesh`** asset in the scene file is **stale** until you run or re-bake in the editor.
@@ -34,8 +70,8 @@ With the game server running ([`server/README.md`](../server/README.md)), each v
 1. From repo root: `cd server/NeonSprawl.Server && dotnet run` (note the URL/port, usually `http://localhost:5253`).
 2. If the port differs, set **`base_url`** on **`PositionAuthorityClient`** accordingly (e.g. `http://127.0.0.1:5253`).
 3. Open the client in Godot and run the main scene (**F5**). The player should **snap** to the server’s default position (e.g. **(-5, 0.9, -5)** per `Game:DefaultPosition` / NEO-9 walk demo).
-4. **Left-click** the floor: the client **POST**s the target, then **GET**s position; the capsule **walks** toward the authoritative target (may follow nav waypoints or bee-line in xz per the tradeoff above). NEO-10 reject clicks still show the reject label and do **not** start a path.
+4. **Left-click** the floor: the client **POST**s the target, then **GET**s position; the capsule **walks** in **XZ** straight toward that target (nav path only for **vertical** routing when you are already near the goal column on **flatter** floor). Server-rejected clicks show the reject label and do **not** start a path.
-5. Click the **far pad** or **pedestal top** (from spawn) to confirm **`horizontal_step_exceeded`** / **`vertical_step_exceeded`** behavior is unchanged.
+5. Click the **pedestal top** (orange box at ~(7.5, 0, −6.5)) to confirm **`vertical_step_exceeded`** rejection — the top is ~2.5 m above floor, which exceeds default **`MaxVerticalStep` (2.2 m)**. From the **physics ramp test block** top (**2 m**), clicking the floor should **succeed**. The `MoveRejectFarPad` (blue pad at (9, 9)) is a normal walkable surface; clicking it from any distance should succeed.
 6. After a move (or at spawn), **stand idle** with no click goal for **10+ seconds** and confirm the capsule does **not** visibly vibrate or drift in **x/z** on flat floor, then repeat on the **random green bumps** (positions change each run).
 
 If the server is **down**, boot **`GET`** fails silently (check Output for warnings); clicks while a request is in flight are ignored until it finishes.
@@ -63,9 +99,9 @@ The main scene includes a **prototype terminal** at the map center (same world *
 
 ## Movement prototype (NEO-5 → NEO-11)
 
-**`player.gd`** uses **`NavigationAgent3D.get_next_path_position()`** + **`move_and_slide()`** for horizontal motion when following the mesh; it may steer **directly at the goal** in xz when the descend bypass applies (NEO-11). **`snap_to_server()`** remains for **boot** (and would apply for any future hard reconcile).
+**`player.gd`** steers **XZ** toward the authoritative goal and uses **`NavigationAgent3D`**’s **current path** only for the **vertical-routing** case above (on sufficiently flat floor); **`move_and_slide()`** does the motion. **`snap_to_server()`** remains for **boot** (and would apply for any future hard reconcile).
 
-- The avatar is on **physics layer 2** with **mask 1** (floor + obstacle on layer 1); the pick ray uses **mask 1** so clicks pass through the avatar and hit the floor.
+- The avatar is on **physics layer 2** with **collision_mask** **3** (scans layers **1** and **2** so all walkables/occluders pair reliably). Environment **StaticBody3D** nodes stay on **collision_layer** **1** with **collision_mask** **3** as well. The pick ray uses **mask 1** only, so clicks pass through the avatar and hit the floor.
 
 ### Manual check (remnants)
 

client/project.godot

@@ -68,6 +68,7 @@ dev_toggle_occluder_obstacle={
 
 common/physics_ticks_per_second=120
 3d/physics_engine="Jolt Physics"
+3d/default_gravity=9.81
 
 [rendering]
 

client/scripts/ground_pick.gd

@@ -1,6 +1,8 @@
 extends Node3D
 
 ## NS-16: walkable ground ray pick. Emits world target for MoveCommand; camera wired from main.
+## Flat tops on `occluder` bodies (horizontal normal) are valid destinations; vertical occluder
+## faces still punch through so ground behind can be picked.
 ## NS-19: reject vertical faces (pedestal). Stepped ray: steep walkable hits (bump slopes) advance
 ## along the ray so the next hit can be flat floor beyond — fixes “stuck” when leaving plateau.
 ## (No `class_name` so headless/CI can load the project before `.godot` import exists.)
@@ -64,6 +66,17 @@ func _try_pick(screen_pos: Vector2) -> void:
 			break
 		var hit_collider: Variant = hit.get("collider")
 		if _collider_is_occluder(hit_collider):
+			var hit_normal_o: Variant = hit.get("normal", Vector3.ZERO)
+			if hit_normal_o is not Vector3:
+				break
+			var nrm_o: Vector3 = (hit_normal_o as Vector3).normalized()
+			var ndot_o: float = nrm_o.dot(Vector3.UP)
+			if ndot_o >= MIN_WALKABLE_NORMAL_DOT_UP:
+				var top_pos: Variant = hit.get("position")
+				if top_pos is Vector3:
+					chosen = top_pos as Vector3
+					have_chosen = true
+				break
 			var occluder_pos: Variant = hit.get("position")
 			if occluder_pos is not Vector3:
 				break

client/scripts/main.gd

@@ -7,6 +7,15 @@ extends Node3D
 ## (see `isometric_follow_camera.gd`).
 ## Prototype: two random short bumps (sibling StaticBody3D under NavigationRegion3D; see
 ## `random_floor_bumps.gd`) before nav bake.
+## Prototype: `PhysicsRampTest*` (+X extension: west slab ends before the dip;
+## `PhysicsRampTestFloorExtensionNorthFill` / `SouthFill` restore walkable floor past the dip in ±Z;
+## block; gentle ramp on **+Z**; steep on **+X**), plus `PhysicsSmoothHillTest` /
+## `PhysicsSmoothDipTest` (HeightMap collision).
+## Steep ramp: **2 m / 1.5 m** rise/run (~53°) so slope exceeds `Player` `floor_max_angle` (~50°)
+## and is not walkable; gentle ramp stays shallower than `NavigationMesh.agent_max_climb`. Steep is
+## under `World` only (not nav source geometry).
+## Prototype HUD: world `CharacterBody3D` position in `UICanvas/PlayerPositionLabel`
+## (updated in `_physics_process` so it matches physics ticks).
 
 const MOVE_REJECT_MSG_SECONDS: float = 4.0
 
@@ -29,10 +38,12 @@ var _dev_obstacle_smoke: Node3D
 @onready var _authority: Node = $PositionAuthorityClient
 @onready var _radius_preview: Node3D = $World/InteractionMarkers
 @onready var _move_reject_label: Label = $UICanvas/MoveRejectLabel
+@onready var _player_pos_label: Label = $UICanvas/PlayerPositionLabel
 @onready var _floor: StaticBody3D = $World/NavigationRegion3D/Floor
 
 
 func _ready() -> void:
+	set_physics_process(true)
 	set_process_unhandled_key_input(true)
 	await get_tree().process_frame
 	_dev_obstacle_smoke = get_node_or_null("World/NavigationRegion3D/Obstacle") as Node3D
@@ -54,6 +65,13 @@ func _ready() -> void:
 		_radius_preview.call("setup_player", _player)
 
 
+func _physics_process(_delta: float) -> void:
+	if not is_instance_valid(_player) or not is_instance_valid(_player_pos_label):
+		return
+	var p: Vector3 = _player.global_position
+	_player_pos_label.text = "x: %.3f\ny: %.3f\nz: %.3f" % [p.x, p.y, p.z]
+
+
 func _on_target_chosen(world: Vector3) -> void:
 	_authority.call("submit_move_target", world)
 

client/scripts/prototype_smooth_hill_piece.gd

@@ -0,0 +1,124 @@
+extends StaticBody3D
+## Procedural smooth grid for the physics ramp strip: raised hill or sunken dip.
+## Uses HeightMapShape3D for collision (CharacterBody3D tunnels through ConcavePolygonShape3D
+## trimesh).
+## Keep the extension slab (`PhysicsRampTestFloorExtension`) short of this body's xz footprint so a
+## dip is not covered by a flat floor collider/render.
+
+enum PieceKind { HILL, DIP }
+
+@export var kind: PieceKind = PieceKind.HILL
+@export var footprint_x: float = 7.0
+@export var footprint_z: float = 4.5
+@export var amplitude: float = 0.42
+@export var subdiv_x: int = 36
+@export var subdiv_z: int = 22
+## Slight Y offset so the rim is not coplanar with the slab (reduces z-fighting with the floor).
+@export var base_lift: float = 0.022
+
+
+func _ready() -> void:
+	collision_layer = 1
+	_build_mesh_and_visual()
+	_build_heightmap_collision()
+
+
+func _build_mesh_and_visual() -> void:
+	var mi: MeshInstance3D = get_node_or_null("MeshInstance3D") as MeshInstance3D
+	if mi == null:
+		push_error("prototype_smooth_hill_piece: expected MeshInstance3D child.")
+		return
+
+	var sx: int = maxi(3, subdiv_x)
+	var sz: int = maxi(3, subdiv_z)
+	var half_x: float = footprint_x * 0.5
+	var half_z: float = footprint_z * 0.5
+	var height_sign := 1.0 if kind == PieceKind.HILL else -1.0
+
+	var verts := PackedVector3Array()
+	verts.resize((sx + 1) * (sz + 1))
+	var uvs := PackedVector2Array()
+	uvs.resize(verts.size())
+
+	var idx := 0
+	for j in sz + 1:
+		var v: float = float(j) / float(sz)
+		var z: float = lerpf(-half_z, half_z, v)
+		for i in sx + 1:
+			var u: float = float(i) / float(sx)
+			var x: float = lerpf(-half_x, half_x, u)
+			var envelope: float = sin(PI * u) * sin(PI * v)
+			var y: float = base_lift + height_sign * amplitude * envelope
+			verts[idx] = Vector3(x, y, z)
+			uvs[idx] = Vector2(u, v)
+			idx += 1
+
+	var st := SurfaceTool.new()
+	st.begin(Mesh.PRIMITIVE_TRIANGLES)
+	for j in sz:
+		for i in sx:
+			var a: int = j * (sx + 1) + i
+			var b: int = a + 1
+			var c: int = a + (sx + 1)
+			var d: int = c + 1
+			for tri in [[a, c, b], [b, c, d]]:
+				st.set_uv(uvs[tri[0]])
+				st.add_vertex(verts[tri[0]])
+				st.set_uv(uvs[tri[1]])
+				st.add_vertex(verts[tri[1]])
+				st.set_uv(uvs[tri[2]])
+				st.add_vertex(verts[tri[2]])
+	st.generate_normals()
+	var mesh: ArrayMesh = st.commit()
+	mi.mesh = mesh
+	mi.material_override = _qa_material_for_kind()
+
+
+func _build_heightmap_collision() -> void:
+	var cs: CollisionShape3D = get_node_or_null("CollisionShape3D") as CollisionShape3D
+	if cs == null:
+		push_error("prototype_smooth_hill_piece: expected CollisionShape3D child.")
+		return
+
+	var sx: int = maxi(3, subdiv_x)
+	var height_sign := 1.0 if kind == PieceKind.HILL else -1.0
+
+	var mw: int = maxi(3, sx + 1)
+	var md: int = maxi(3, subdiv_z + 1)
+	var s: float = footprint_x / float(mw - 1)
+	while (md - 1) * s < footprint_z - 0.0001 and md < 512:
+		md += 1
+
+	var data := PackedFloat32Array()
+	data.resize(mw * md)
+	for j in md:
+		var v: float = float(j) / float(md - 1) if md > 1 else 0.0
+		for i in mw:
+			var u: float = float(i) / float(mw - 1) if mw > 1 else 0.0
+			var envelope: float = sin(PI * u) * sin(PI * v)
+			var y_world: float = base_lift + height_sign * amplitude * envelope
+			data[j * mw + i] = y_world / s
+
+	var hm := HeightMapShape3D.new()
+	hm.map_width = mw
+	hm.map_depth = md
+	hm.map_data = data
+	cs.shape = hm
+	cs.scale = Vector3(s, s, s)
+	cs.position = Vector3.ZERO
+
+
+func _qa_material_for_kind() -> StandardMaterial3D:
+	var m := StandardMaterial3D.new()
+	m.cull_mode = BaseMaterial3D.CULL_DISABLED
+	m.roughness = 0.45
+	m.metallic = 0.0
+	m.emission_enabled = true
+	m.emission_energy_multiplier = 0.85
+	if kind == PieceKind.HILL:
+		m.albedo_color = Color(0.98, 0.12, 0.42)
+		m.emission = Color(0.45, 0.02, 0.15)
+	else:
+		m.albedo_color = Color(0.08, 0.35, 0.98)
+		m.emission = Color(0.02, 0.12, 0.45)
+	return m

client/scripts/prototype_smooth_hill_piece.gd.uid

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

client/test/player_idle_support_test.gd

@@ -0,0 +1,75 @@
+# Idle-support stability tests for res://scripts/player.gd (static helpers).
+extends GdUnitTestSuite
+
+const PLAYER_SCRIPT: Script = preload("res://scripts/player.gd")
+
+
+func test_idle_support_is_stable_on_flat_floor_without_wall_contacts() -> void:
+	var slide_normals: Array[Vector3] = [Vector3.UP]
+	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(true, Vector3.UP, slide_normals, 0)
+	assert_that(stable).is_true()
+
+
+func test_idle_support_is_stable_false_when_floor_is_not_flat_enough() -> void:
+	var slide_normals: Array[Vector3] = [Vector3.UP]
+	# Must be steeper than [member STABLE_IDLE_FLOOR_MIN_UP_DOT] (0.998) *and* below
+	# [member IDLE_SLOPE_STABLE_MIN_UP_DOT] (0.88), or the ramp short-circuit treats support as stable.
+	var tilted_floor: Vector3 = Vector3(0.5, 0.82, 0.0).normalized()
+	assert_that(tilted_floor.dot(Vector3.UP)).is_less(
+		PLAYER_SCRIPT.get("IDLE_SLOPE_STABLE_MIN_UP_DOT")
+	)
+	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(true, tilted_floor, slide_normals, 0)
+	assert_that(stable).is_false()
+
+
+func test_idle_support_is_stable_min_flat_up_dot_parameter() -> void:
+	var slide_normals: Array[Vector3] = [Vector3.UP]
+	var floor_n: Vector3 = Vector3(0.05, 0.99875, 0.0).normalized()
+	var strict: bool = PLAYER_SCRIPT.idle_support_is_stable(true, floor_n, slide_normals, 0, 0.999)
+	var holdish: bool = PLAYER_SCRIPT.idle_support_is_stable(true, floor_n, slide_normals, 0, 0.992)
+	assert_that(strict).is_false()
+	assert_that(holdish).is_true()
+
+
+func test_idle_support_is_stable_true_when_flat_floor_has_extra_contacts() -> void:
+	var slide_normals: Array[Vector3] = [Vector3.UP, Vector3(0.0, 0.6, 0.8).normalized()]
+	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(true, Vector3.UP, slide_normals, 0)
+	assert_that(stable).is_true()
+
+
+func test_idle_support_is_stable_true_when_loose_ticks_and_ridged_but_floor_still_level() -> void:
+	var slide_normals: Array[Vector3] = [Vector3.UP, Vector3(1.0, 0.0, 0.0)]
+	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(true, Vector3.UP, slide_normals, 12)
+	assert_that(stable).is_true()
+
+
+func test_idle_support_is_stable_false_when_loose_ticks_and_ridged_and_shallow_floor() -> void:
+	var slide_normals: Array[Vector3] = [Vector3.UP, Vector3(1.0, 0.0, 0.0)]
+	# Normal must be outside the ramp-stable band [IDLE_SLOPE_STABLE_MIN_UP_DOT, IDLE_RIM) or
+	# `idle_ridged_stair_lip_only` is false and the ramp short-circuit returns stable. Use a tread
+	# tilt above the rim dot but still below the ridged hold threshold (0.992).
+	var floor_n: Vector3 = Vector3(0.14, 0.98, 0.0).normalized()
+	var up_dot: float = floor_n.dot(Vector3.UP)
+	assert_that(up_dot).is_greater_equal(PLAYER_SCRIPT.get("IDLE_RIM_MIN_FLOOR_UP_DOT") as float)
+	assert_that(up_dot).is_less(PLAYER_SCRIPT.get("STABLE_IDLE_FLOOR_MIN_UP_DOT") as float)
+	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(true, floor_n, slide_normals, 12)
+	assert_that(stable).is_false()
+
+
+func test_idle_support_is_stable_true_when_loose_ticks_but_flat_open_support() -> void:
+	var slide_normals: Array[Vector3] = [Vector3.UP]
+	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(true, Vector3.UP, slide_normals, 12)
+	assert_that(stable).is_true()
+
+
+func test_idle_support_is_stable_true_when_loose_ticks_and_shallow_seam_not_ridged() -> void:
+	var n2: Vector3 = Vector3(0.0, 0.42, sqrt(1.0 - 0.42 * 0.42)).normalized()
+	var slide_normals: Array[Vector3] = [Vector3.UP, n2]
+	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(true, Vector3.UP, slide_normals, 12)
+	assert_that(stable).is_true()
+
+
+func test_idle_support_is_stable_false_when_not_on_floor() -> void:
+	var slide_normals: Array[Vector3] = [Vector3.UP]
+	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(false, Vector3.UP, slide_normals, 0)
+	assert_that(stable).is_false()

client/test/player_idle_support_test.gd.uid

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

client/test/player_test.gd

@@ -48,36 +48,18 @@ func test_clear_nav_goal_clears_velocity_and_nav_target() -> void:
 	assert_that(nav.target_position).is_equal(p.global_position)
 
 
-func test_idle_support_is_stable_on_flat_floor_without_wall_contacts() -> void:
+func test_nav_goal_lifecycle_resets_vert_route_latch() -> void:
-	var slide_normals: Array[Vector3] = [Vector3.UP]
+	var p := _make_player()
-	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(true, Vector3.UP, slide_normals, 0)
+	p.set_authoritative_nav_goal(Vector3(1.0, 0.0, 2.0))
-	assert_that(stable).is_true()
+	p.set("_walk_vert_route_latched", true)
-
+	p.clear_nav_goal()
-
+	assert_that(p.get("_walk_vert_route_latched")).is_false()
-func test_idle_support_is_stable_false_when_floor_is_not_flat_enough() -> void:
+	p.set("_walk_vert_route_latched", true)
-	var slide_normals: Array[Vector3] = [Vector3.UP]
+	p.set_authoritative_nav_goal(Vector3(3.0, 0.0, 4.0))
-	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(
+	assert_that(p.get("_walk_vert_route_latched")).is_false()
-		true, Vector3(0.02, 0.995, 0.0).normalized(), slide_normals, 0
+	p.set("_walk_vert_route_latched", true)
-	)
+	p.snap_to_server(Vector3(0.0, 0.9, 0.0))
-	assert_that(stable).is_false()
+	assert_that(p.get("_walk_vert_route_latched")).is_false()
-
-
-func test_idle_support_is_stable_true_when_flat_floor_has_extra_contacts() -> void:
-	var slide_normals: Array[Vector3] = [Vector3.UP, Vector3(0.0, 0.6, 0.8).normalized()]
-	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(true, Vector3.UP, slide_normals, 0)
-	assert_that(stable).is_true()
-
-
-func test_idle_support_is_stable_false_when_loose_ticks_active() -> void:
-	var slide_normals: Array[Vector3] = [Vector3.UP]
-	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(true, Vector3.UP, slide_normals, 12)
-	assert_that(stable).is_false()
-
-
-func test_idle_support_is_stable_false_when_not_on_floor() -> void:
-	var slide_normals: Array[Vector3] = [Vector3.UP]
-	var stable: bool = PLAYER_SCRIPT.idle_support_is_stable(false, Vector3.UP, slide_normals, 0)
-	assert_that(stable).is_false()
 
 
 func test_hold_idle_anchor_sets_anchor_first_then_clamps_xz() -> void:
@@ -89,7 +71,7 @@ func test_hold_idle_anchor_sets_anchor_first_then_clamps_xz() -> void:
 
 	p.global_position = Vector3(1.2, 0.7, 2.3)
 	p.call("_hold_idle_anchor")
-	assert_that(p.global_position).is_equal(Vector3(1.0, 0.7, 2.0))
+	assert_that(p.global_position).is_equal(Vector3(1.0, 0.5, 2.0))
 
 
 func test_snap_to_server_clears_idle_anchor() -> void:
@@ -119,6 +101,39 @@ func test_vertical_arrival_error_stays_large_for_origin_height_only_match() -> v
 	assert_that(absf(err - 0.5)).is_less(0.000001)
 
 
+func test_arrival_vert_err_large_for_step_goal_from_floor() -> void:
+	# Player at floor height (body Y=0.9). Goal at step surface (Y=0.3).
+	# Using actual capsule bottom (CAPSULE_HALF_HEIGHT + PLAYER_CAPSULE_RADIUS) the error
+	# must exceed VERT_ARRIVE_EPS so the arrival check does NOT fire prematurely.
+	var goal_y := 0.3
+	var body_y := 0.9
+	var full_half: float = (
+		(
+			PLAYER_SCRIPT.get("CAPSULE_HALF_HEIGHT") as float
+			+ PLAYER_SCRIPT.get("PLAYER_CAPSULE_RADIUS")
+		)
+		as float
+	)
+	var err: float = PLAYER_SCRIPT.vertical_arrival_error(goal_y, body_y, full_half)
+	assert_that(err).is_greater(PLAYER_SCRIPT.get("VERT_ARRIVE_EPS") as float)
+
+
+func test_arrival_vert_err_zero_when_standing_on_step() -> void:
+	# Player body centred at goal_y + total_half_height (i.e. actually standing on the step).
+	# Error must be within VERT_ARRIVE_EPS so arrival fires correctly once the player is up.
+	var goal_y := 0.3
+	var full_half: float = (
+		(
+			PLAYER_SCRIPT.get("CAPSULE_HALF_HEIGHT") as float
+			+ PLAYER_SCRIPT.get("PLAYER_CAPSULE_RADIUS")
+		)
+		as float
+	)
+	var body_y: float = goal_y + full_half
+	var err: float = PLAYER_SCRIPT.vertical_arrival_error(goal_y, body_y, full_half)
+	assert_that(err).is_less_equal(PLAYER_SCRIPT.get("VERT_ARRIVE_EPS") as float)
+
+
 func test_flat_floor_goal_is_not_below_feet_height_margin() -> void:
 	var goal_y := 0.0
 	var body_origin_y := 0.4
@@ -127,3 +142,8 @@ func test_flat_floor_goal_is_not_below_feet_height_margin() -> void:
 		goal_y < PLAYER_SCRIPT.capsule_feet_y(body_origin_y, 0.5) - descend_margin
 	)
 	assert_that(below_feet_margin).is_false()
+
+
+func test_step_assist_max_surface_delta_matches_navigation_mesh_agent_max_climb() -> void:
+	# Keep in sync with NavigationMesh `agent_max_climb` in `scenes/main.tscn`.
+	assert_that(PLAYER_SCRIPT.get("WALK_STEP_ASSIST_MAX_SURFACE_DELTA") as float).is_equal(0.35)

docs/plans/NEO-22-implementation-plan.md

@@ -0,0 +1,96 @@
+# NEO-22 — Implementation plan
+
+## Story reference
+
+| Field | Value |
+|--------|--------|
+| **Key** | NEO-22 |
+| **Title** | Retire prototype click-to-move; ship WASD locomotion on the client |
+| **Linear** | [NEO-22](https://linear.app/neon-sprawl/issue/NEO-22) |
+| **Parent** | [E1.M1 InputAndMovementRuntime](https://linear.app/neon-sprawl/project/e1m1-inputandmovementruntime-20eb28dd3db4) (or current movement project) |
+| **Supersedes / deprecates (prototype)** | [NEO-5](NEO-5-implementation-plan.md), [NEO-11](NEO-11-implementation-plan.md) click-to-move surface; [NEO-14](NEO-14-implementation-plan.md) seam/jitter mitigations tied to nav + goal steering |
+
+## Goal, scope, and out-of-scope
+
+**Goal:** Replace **mouse click → ground pick → `MoveCommand` → nav path → `player.gd` goal steering** with **keyboard WASD** (and optional gamepad later) as the **primary** locomotion input in the Godot prototype. Movement should feel predictable on stepped geometry without the column / nav-ribbon / slide-normal fight that click-to-move accumulated.
+
+**In scope**
+
+- **Input:** `project.godot` actions (or code) for **W/A/S/D**; read them in a thin place (`main.gd` or a small `locomotion_input.gd`) and drive the player’s **horizontal** intent each physics tick.
+- **Locomotion model:** `CharacterBody3D` + `move_and_slide()` with velocity derived from **wish direction × speed**, camera-relative or world-relative (decide in [Decisions](#decisions)); **no `NavigationAgent3D` path goal** for routine walking unless a later slice reintroduces hybrid “click to mark + auto-run” explicitly.
+- **Remove / disable** left-click ground pick as the default move trigger (`ground_pick.gd` → `main.gd` → `PositionAuthorityClient.submit_move_target`). Either delete the flow for this slice or gate it behind a dev flag documented as off by default.
+- **Server / authority:** Resolve how WASD maps to **NEO-7 `MoveCommand`** and **authoritative position** (see [Open questions](#open-questions--risks)). Minimum acceptable outcomes are spelled in acceptance criteria — pick one path and document it in `client/README.md` + decomposition.
+- **Cleanup:** Delete or drastically narrow **NEO-11 / NEO-14 / NEO-16** workaround blocks in `player.gd` (column seam damp, nav column steering, idle trace scaffolding tied to click goals) **only** after WASD path is stable; prefer one commit that switches input then a follow-up that deletes dead code.
+- **Docs:** Update `client/README.md`, `docs/decomposition/modules/E1_M1_InputAndMovementRuntime.md`, and this plan’s checklist when shipped.
+
+**Out of scope**
+
+- Full **client prediction + server reconciliation** for FPS-grade netcode (unless explicitly pulled into this story by product).
+- **Click-to-interact** changes (NEO-12-style interaction) except where click conflicts with removed move binding (document if unchanged).
+- **Occlusion / camera** feature work (NEO-17/20) beyond what’s needed so WASD direction feels correct with the follow camera.
+- **Production** navmesh tooling for NPCs — only player move input changes here.
+
+## Acceptance criteria checklist
+
+- [ ] **WASD** moves the avatar on the default **`main.tscn`** floor with **no** left-click requirement; speed and direction are stable on flat ground and on **stepped** QA props without the prior ±`MOVE_SPEED` seam oscillation at column/stair corners (subjective + optional `debug_idle_trace` spot-check).
+- [ ] **Left-click** no longer starts a walk by default (or is clearly dev-only and off in normal play, documented).
+- [ ] **Authoritative position** still converges with the server: document whether **continuous** sync, **throttled** `MoveCommand`, or **temporary client-only** prototype applies — and add the minimal client/server change so CI + manual steps do not lie.
+- [ ] **Cold boot `snap_to_server`** still works; no spawn underground / stale goal regressions.
+- [ ] **NEO-10** rejection UX: if clicks are removed, another path still exercises reject payloads in dev (automated test or documented console-only command) **or** clicks remain only for “set goal” debug, not default locomotion.
+- [ ] **GdUnit** (or existing harness) covers at least one pure helper for wish-dir / speed clamp if logic is non-trivial.
+
+## Technical approach
+
+1. **Linear + branch:** Issue **NEO-22** exists in Backlog; on kickoff set **In Progress** and branch `neo-22-retire-click-to-move-implement-wasd-locomotion-godot-client` (or team naming).
+2. **Authority model (blocking):** Decide with product/server owner:
+   - **A)** Client integrates WASD locally only for prototype; server receives **rate-limited** position or move deltas (may need new endpoint — likely **out of this slice** unless already planned), or  
+   - **B)** Keep **discrete `MoveCommand`** but drive target from **keyboard-sampled “stick to last intent”** (awkward), or  
+   - **C)** Server accepts a **stream** of small moves (largest change — schedule separately).  
+   Document chosen option in README before merging locomotion feel work.
+3. **Input layer:** Map WASD to `Vector2` in screen/camera space → world XZ tangent to `Camera3D` basis (same pattern as many third-person controllers); normalize; zero when no keys.
+4. **`player.gd` refactor:** Replace `_has_walk_goal` / `_auth_walk_goal` steering path with **wish velocity** from parent or injected each `_physics_process`; keep gravity, floor snap policy, and `snap_to_server` entry points. Strip `NavigationAgent3D` dependency for default walk if decision says so (agent node can stay in scene unused until a later hybrid story).
+5. **Remove click wiring:** Disconnect `target_chosen` → `submit_move_target` in `main.gd` for default build; optionally keep `ground_pick.gd` for debug “teleport goal” behind `OS.is_debug_build()` flag.
+6. **Tests + manual:** Run README manual path; add unit test for direction math if extracted.
+
+## Decisions
+
+| Topic | Choice | Rationale |
+|------|--------|-----------|
+| **Issue id** | **NEO-22** | Created in Linear 2026-04-16; plan filename matches this key. |
+| **Camera vs world steering** | **TBD in kickoff** — default recommendation: **camera-relative XZ** | Matches isometric follow rig; document if world-axis is chosen instead. |
+| **NavAgent** | Default **off** for routine WASD in this slice | Removes nav-ribbon + column latch class of bugs; re-add only with explicit hybrid design. |
+
+## Files to add
+
+| Path | Purpose |
+|------|---------|
+| None required. | Prefer extending existing scripts unless `locomotion_input.gd` (or similar) is needed to keep `main.gd` thin per `godot-client-script-organization`. If extracted, add here and list in “Files to modify” as N/A for that line. |
+
+## Files to modify
+
+| Path | Rationale |
+|------|-----------|
+| `client/project.godot` | Declare **`move_forward` / `move_back` / `move_left` / `move_right`** (or reuse Godot defaults) bound to WASD. |
+| `client/scripts/main.gd` | Stop wiring click pick to `submit_move_target` by default; optionally forward WASD intent to player/authority per chosen model. |
+| `client/scripts/ground_pick.gd` | Disable default `_input` pick **or** gate behind export/debug; update header comments (NS-16 lineage). |
+| `client/scripts/player.gd` | Replace goal/nav horizontal steering with WASD-driven velocity; delete obsolete seam/nav state once stable. |
+| `client/scripts/position_authority_client.gd` | Align with authority model (throttle, stream, or document client-only prototype). |
+| `client/scenes/main.tscn` | Only if `NavigationAgent3D` or nodes are removed/changed or input singleton paths change. |
+| `client/README.md` | Replace “click-move” manual checks with WASD + server steps; note deprecation of click-to-move prototype. |
+| `docs/decomposition/modules/E1_M1_InputAndMovementRuntime.md` | Snapshot: click-to-move retired in favor of WASD for prototype; link this plan. |
+| `docs/plans/NEO-11-implementation-plan.md` | Add one-line “superseded for locomotion input by NEO-22” in header or Resolution if policy is to annotate predecessors. |
+
+## Tests
+
+| File | Coverage |
+|------|----------|
+| `client/test/player_test.gd` | **Change:** remove or replace tests that assumed `_has_walk_goal` / nav steering; add tests for any extracted **wish-direction** or speed clamp helper. |
+| `client/test/position_authority_client_test.gd` | **Change:** align with new submit/sync cadence if `PositionAuthorityClient` changes. |
+| **Manual (required)** | README path: boot with server, WASD on flat + stepped geometry, `snap_to_server`, and whichever NEO-10 rejection path remains after click removal. |
+
+## Open questions / risks
+
+- **Server contract:** Today’s **`MoveCommand`** is **discrete target**-shaped ([NEO-7](NEO-7-implementation-plan.md)). WASD needs **continuous** intent — either extend the protocol, rate-limit many small commands, or temporarily diverge prototype authority. **This is the main schedule risk**; do not merge feel-only client changes without an explicit written decision in README + this plan.
+- **Interaction vs pick:** Confirm **E** / interaction does not rely on the same mouse button in a way that breaks when pick is disabled.
+- **Gamepad:** Out of scope unless trivial (`Input.get_vector`); note for follow-up story.
+- **Jira naming:** If the team uses **NEON-*** keys elsewhere, align Linear/Git subject lines per [linear-git-naming](../../.cursor/rules/jira-git-naming.md).

docs/plans/NEON-29-implementation-plan.md

@@ -0,0 +1,130 @@
+# NEON-29 Implementation Plan — Expand prototype client district for camera/nav stress QA
+
+## Story reference
+
+- **Key:** [NEON-29](https://neon-sprawl.atlassian.net/browse/NEON-29)
+- **Title:** E1.M2: Expand prototype client district for camera/nav stress QA
+- **Parent epic:** [NEON-1 — Epic 1 — Core Player Runtime](https://neon-sprawl.atlassian.net/browse/NEON-1)
+- **Labels:** E1, E1.M2, client-qa-district, decomposition
+
+---
+
+## Goal, scope, and out-of-scope
+
+### Goal
+
+Provide a **~5× footprint** (order-of-magnitude) prototype play space versus the current district, with **more obstacles** and **height-changing regions** (steps, terraces, bumps) so day-to-day client work can stress **motion, framing, and readability** for the camera, navigation, ground pick, and interaction systems.
+
+### Scope
+
+- `client/scenes/main.tscn`: expand walkable floor / nav source geometry; add props that participate in `NavigationRegion3D` bake and `walkable` picking as today; include elevated terrace/step platforms for vertical variation.
+- `client/README.md`: short runbook note covering district scale, intent, and any new designer-facing limits.
+- Optional: pointer in `docs/decomposition/modules/E1_M2_IsometricCameraController.md` that this geography is the default stress playground for client stories.
+
+### Out of scope
+
+- New camera features (zoom bands NEON-26, occlusion NEON-27) — geography may help test them, but this story does not implement them.
+- Server schema or MoveCommand contract changes unless existing NEON-7 step/bounds defaults visibly break on the larger map (in that case: document + minimal config tune only).
+- Production art pass or zone graph / Epic 4 content.
+
+---
+
+## Acceptance criteria checklist
+
+- [ ] Playable area is **materially larger** (~5× order of magnitude vs pre-change footprint) with **additional obstacles** and **vertical variation** usable with click-to-move.
+- [ ] **NavigationRegion3D** bakes successfully at startup; long clicks behave per existing NEON-8 tradeoffs (document if new geometry exposes new edge cases).
+- [ ] **Ground pick** and `walkable` grouping remain correct on new surfaces.
+- [ ] README updated for anyone running F5 + server.
+
+---
+
+## Technical approach
+
+### Current baseline
+
+The current `main.tscn` district is a single **20 × 20** unit flat floor (`BoxMesh_floor`, placed at Y = -0.1), giving an approximate playable area of ~400 sq units. Static props:
+
+- `PrototypeTerminal` (0.9 × 1 × 0.4) at origin
+- `MoveRejectPedestal` (1.5 × 2.5 × 1.5) at (7.5, 0, -6.5)
+- `MoveRejectFarPad` (2.5 × 0.12 × 2.5) at (9, 0.06, 9)
+- `Obstacle` (2 × 2 × 2, `occluder` group) at (6, 0, 5)
+- Player spawn at (-5, 0.9, -5)
+
+The `NavigationMesh` stored in the scene file is intentionally stale; `main.gd` calls `bake_navigation_mesh(false)` at startup so the live mesh always reflects actual collision geometry.
+
+### Expansion plan
+
+**Floor size:** Replace the 20 × 20 floor with a **45 × 45** unit floor, giving ~2025 sq units (~5× of 400). Keep floor mesh center at origin (X=0, Z=0) so spawn position and existing props stay roughly central.
+
+**Additional obstacles (nav stress + camera occlusion):** Add 3–4 extra `StaticBody3D` nodes in the `occluder` group, distributed across the expanded area — positioned so the follow camera must work around varying angles.
+
+**Vertical variation (terraces / steps):** Add 2–3 raised terrace platforms as `StaticBody3D` nodes in the `walkable` group, elevated ~0.5–2.5 m above the main floor, with ramp/step approach geometry. These are `StaticBody3D` siblings of `Floor` under `NavigationRegion3D` so the runtime bake includes them as nav sources. Each terrace:
+  - Has its own `CollisionShape3D` (BoxShape3D).
+  - Is in the `walkable` group so ground-pick raycasts hit it correctly.
+  - Has a small `StaticBody3D` ramp or step approach (also `walkable`) so `NavigationAgent3D` can route onto it within the NEON-8 step/climb parameters (`agent_max_climb = 0.35` in existing NavMesh settings — ramp grade must respect this, or use multi-step approach).
+
+**MoveReject props:** Keep `MoveRejectPedestal` and `MoveRejectFarPad` in place — they exercise NEON-7 reject behavior and must remain reachable. Shift `MoveRejectFarPad` outward if needed to stay within the expanded floor bounds and remain "far."
+
+**NavigationMesh settings:** No changes to agent parameters (height=1.0, radius=0.4, max_climb=0.35, cell_size=0.15) — they remain aligned with the player capsule per NEON-8. The stale baked mesh in the scene will update at runtime. The `geometry_collision_mask = 1` stays, so all collision-layer-1 bodies under the region contribute.
+
+**NEON-7 edge case check:** With a larger floor the server's `step_size` / `MaxDistance` defaults may now allow clicks that would previously have been out-of-range. Document in the README if this changes observed reject behavior; no server code change unless a new reject case is broken (not just shifted in range).
+
+---
+
+## Files to add
+
+None. All geometry lives in the existing scene file; no new GDScript logic is required.
+
+---
+
+## Files to modify
+
+| File | Rationale |
+|------|-----------|
+| `client/scenes/main.tscn` | Replace 20×20 floor with 45×45; add terrace/step platforms and extra obstacle props; update pre-baked `NavigationMesh` vertices (will be overwritten at runtime, but keeping a reasonable approximation avoids editor warnings). |
+| `client/README.md` | Add district runbook note: new footprint, vertical variation, intent as stress playground, updated manual-check geometry references. |
+| `docs/decomposition/modules/E1_M2_IsometricCameraController.md` | Optional lightweight pointer that this expanded geography is the default QA map for E1.M2 camera stories. |
+
+---
+
+## Tests
+
+No new automated GDScript tests are added for this story — there is no new GDScript logic. This story is pure scene geometry.
+
+**Manual verification replaces automated tests:**
+
+1. **F5** with server running: confirm player spawns and nav bake completes without errors in Output.
+2. Click-to-move across the expanded floor, up/down each terrace, and through obstacles — confirm `NavigationAgent3D` routes and `move_and_slide` behaves per NEON-8 tradeoffs.
+3. Ground-pick regression: click behind each new `occluder`-tagged obstacle with player in and out of occlusion fade range (per NEON-30 manual check in README).
+4. Confirm `MoveRejectPedestal` and `MoveRejectFarPad` still reject correctly.
+5. Follow camera: walk to far corners of the expanded floor — confirm `IsometricFollowCamera` tracks smoothly without snapping or losing the player (snap_distance not tripped by longer walks).
+6. Interaction radius: walk near `PrototypeTerminal` to confirm range indicators still work correctly.
+
+---
+
+## Decisions
+
+- **No horizontal step limit (resolved):** The server's `MaxHorizontalStep = 18 m` was too restrictive for the expanded 45 × 45 m floor (diagonal ≈ 63 m). Added `HorizontalStepEnabled` bool to `MovementValidationOptions` (defaults `false`), matching the `DistrictBoundsEnabled` pattern. The horizontal check is now skipped by default; the property remains available to opt back in via config. `MoveRejectFarPad` no longer exercises a horizontal range reject; it retains its walkable surface for vertical-step regression only.
+- **Step assist guard/lift bug fixed (resolved):** `_try_walk_step_assist` in `player.gd` compared the goal's surface Y against the **capsule centre** (`global_position.y ≈ 0.9`) instead of the actual capsule bottom (`global_position.y − CAPSULE_HALF_HEIGHT − PLAYER_CAPSULE_RADIUS = 0.0`). This disabled the assist for any surface below ≈ 0.925 m — including all three terrace platforms. The lift formula used offsets of 0.45/0.55 instead of the full total half-height (0.9), giving zero or negative lift. Fixed: guard now uses `actual_feet_y`; lift targets `goal.y + CAPSULE_HALF_HEIGHT + PLAYER_CAPSULE_RADIUS` via `clampf`.
+- **Arrival check using wrong capsule reference (resolved):** `vertical_arrival_error` was called with `CAPSULE_HALF_HEIGHT = 0.5`, giving code-feet at `body_y − 0.5 = 0.4` at floor level. Step surfaces (Y = 0.3) are only 0.1 m from that reference. When the Jolt physics engine nudges the capsule body down to ~0.8 m (bottom hemisphere contacts the step edge), code-feet becomes 0.3 — matching the step surface Y and making `vert_err = 0 ≤ VERT_ARRIVE_EPS`. If the player is also within `ARRIVE_EPS = 0.35 m` horizontally, the arrival check fires immediately, clearing the nav goal before the capsule has moved. Fixed: pass `CAPSULE_HALF_HEIGHT + PLAYER_CAPSULE_RADIUS` (= 0.9) to `vertical_arrival_error` so actual feet = `body_y − 0.9`. Step goal vert_err is now 0.3 >> 0.055 from floor height; arrival fires correctly only once the step assist has lifted the capsule onto the surface (body_y = 1.2, vert_err ≈ 0). Two regression tests added.
+- **snap_to_server places capsule underground (resolved):** The server stores the raw surface Y from the client's click (e.g. 0.6 for a terrace platform), not the capsule body-centre Y (which should be 0.6 + 0.9 = 1.5). `snap_to_server` was setting `global_position.y` directly to this surface Y, putting the capsule bottom at −0.3 m. With `_floor_angle_loose_ticks = 0` and a stale `is_on_floor() = true`, the idle path's `_stable_idle_support()` check passed and held the player without calling `move_and_slide()`, preventing Jolt from resolving the penetration. Fixed: clamp `global_position.y ≥ CAPSULE_HALF_HEIGHT + PLAYER_CAPSULE_RADIUS` (= 0.9 m) in `snap_to_server`; also set `_floor_angle_loose_ticks = FLOOR_ANGLE_LOOSE_TICKS_AFTER_STOP` (96 ticks) to force corrective idle physics before the next walk goal.
+- **Step assist undone by floor snap (resolved):** Each `_try_walk_step_assist()` cycle lifts the capsule 0.11 m. The prior `floor_snap_length = FLOOR_SNAP_MOVING = 0.32 m` meant the snap always reached the lower floor (0.11 m below the lifted bottom), pulling the capsule straight back down every tick. The player "nudged and stopped" because each lift was immediately cancelled. Fixed: added `WALK_STEP_ASSIST_SNAP = 0.09 m` constant (below 0.11 m so the snap cannot reach the previous floor, but above 0.03 m so it catches the step surface once cleared) and a `_step_assist_active` boolean flag. During active climbing, `floor_snap_length` is set to `WALK_STEP_ASSIST_SNAP` in both `_after_walk_move_and_slide()` and the main physics loop. The flag is cleared when the player lands cleanly on a floor without wall contact (`is_on_floor() and not is_on_wall()`), or when the nav goal is cleared/snapped.
+- **Terrace B descend / climb (resolved, iterated):** Scene lifts and **descend-bypass** bee-lines caused regressions (stuck climbs, lip oscillation, wrong-direction slides). **Removed the descend bypass:** vertical moves (e.g. platform ↔ floor) use the **baked nav path + step assist** only. **Walk gravity** is **`!is_on_floor()`** again — never “goal below feet” while still walking on an upper surface (that applied gravity across the whole **TerracePlatformB** deck and destroyed horizontal motion). **`velocity.y`** is cleared by the horizontal steer each tick as before. 
+- **Lip stuck (floor→platform / platform→floor):** QA screenshots for this were on **`TerracePlatformA`** (10 × 10 large SE pad, **0.3 m** single step — not the NW **Terrace B** step/platform pair). Step assist required **`vel_h.dot(want) ≤ 0.52`**, so a **head-on** push into the vertical face (dot ≈ 1) **never** triggered the lift. **Removed** that gate. For **platform→floor**, **`floor_block_on_wall = false`** only when the nav goal is **below** the feet **and** **`is_on_wall()`** or a **wall-ish slide normal** exists, so open deck walking stays stable.
+- **Teal pad still stuck (follow-up):** Step assist used **slide normals only**; Jolt often exposes the lip via **`is_on_wall()`** / **`get_wall_normal()`** instead — re-added a **directional** wall check (`wnh.dot(want) < -0.02`). Descend relax now also triggers on **shallow floor normal** (`get_floor_normal().dot(UP) < 0.992`) and slightly wider vertical-ish slide band. **`TerracePlatformA`** root **Y = 0.012 m** breaks **coplanarity** with the main floor without the larger gap that hurt **TerraceStepB** approach.
+- **Nav waypoint steering dropped (movement):** Following **`get_next_path_position()`** by default caused **near-zero** horizontal progress under **Jolt** + **120 Hz** (waypoint advance / finished edge cases), read as universal **stuck** movement even with the server up. **`player.gd`** now **bee-lines in XZ** toward **`_auth_walk_goal`** and uses path-based steer only when **`needs_vertical_routing`** (Schmitt **`WALK_VERT_ROUTE_LATCH_*`**) **and** **`NAV_COLUMN_STEER_*`** hysteresis **and** **`is_on_floor()`** (mid-air column steer caused **180° XZ flips** while falling). **`_set_horizontal_velocity_from_nav_path_or_goal`** scans **`get_current_navigation_path()`** for the first waypoint **≥ `NAV_PATH_STEER_MIN_LOOKAHEAD` (0.22 m)** in XZ, with a **goal-direction dot** guard — raw **`get_next_path_position()`** and a **5 cm** scan both sat inside Jolt’s per-tick slide and could flip velocity **180°** each tick.
+- **Walk ledge / void gravity (iterated):** **`is_on_floor()`** + **`floor_snap_length`** could keep the capsule **glued** while crossing void to a lower click. **Fix:** **multi-sample** down rays under the **foot disk** (offsets along **move direction**; depth ~**0.32**); apply gravity when **none** hit; **`floor_snap_length = 0`** that tick so snap does not cancel **`velocity.y`**. Dropped a **floor-normal** gate that skipped the probe on **lip** contacts.
+- **Step assist vs `agent_max_climb`:** Nav **`agent_max_climb = 0.35`** only constrained mesh links; **bee-line + chained step assist** could still climb **TerracePlatformB** (~**0.6 m** from floor) in one click. **`_try_walk_step_assist`** now returns false when **`_auth_walk_goal.y > feet + WALK_STEP_ASSIST_MAX_SURFACE_DELTA`** (**0.35**, same as the mesh).
+- **Teal cardinal / tread shake (rollback):** Aggressive tweaks (**0.16** lift, **1**-tick cooldown, **`descending_stall`** toggling **`floor_block_on_wall`**, **seam-based** step-assist clear, **walk-stall nav replan**) caused **oscillation** on the small approach treads. **Reverted** to **`WALK_STEP_ASSIST_DELTA = 0.11`**, **`WALK_STEP_ASSIST_COOLDOWN_TICKS = 8`**, **no** stall replan, **no** `descending_stall` branch, **no** seam-based assist clear — only the original clear (clean floor without wall, or airborne with no slides). **Climb** wallish snap cap applies only when **`goal.y > feet_y + 0.12`** so shallow tread-to-tread motion is not capped to assist snap every frame.
+- **Teal pad — geometry wins:** Script-only mitigations still failed in practice; **`TerracePlatformA_Approach`** adds **twelve** `walkable` **`StaticBody3D`** treads (three per cardinal) with **~0.104 m** rise each, **darker teal** albedo, flush to the platform lip — nav + `CharacterBody3D` use **sloped contact** instead of fighting a **single vertical face**. **Follow-up:** tread **run** was **0.45 m** along the climb axis while the capsule **diameter is 0.8 m** — the body was wider than each tread, causing straddle / stuck motion when **entering** and blocking horizontal progress toward the lip when **exiting**. Treads widened to **1.0 m** run with positions re-centered. **`NavigationAgent3D`** `path_desired_distance` / `target_desired_distance` were briefly lowered to **0.22** but that caused **floor** movement to **stall**; **reverted to 0.35**.
+
+## Approach treads (district convention)
+
+- **Shipped in scene:** **`TerracePlatformC_Approach`** (`PCS_*`, teal-style **3×4** cardinals, **7.2 m** NS / **WE** span), **`TerraceStepB_Approach`** (`TSB_*`, **S/E/W** only — north meets violet), **`TerracePlatformB_Approach`** (`TPB_*`, **N/E/W**, **six** ~**0.104 m** risers for **0.6 m** deck height; south remains **gold step**). **Smooth ramps** for other props can follow the same rise/run idea without new `player.gd` logic.
+- **Idle jitter on thin treads / flat stops:** (1) **`idle_support_is_stable`**: post-stop **`loose_ticks` + ridged** blocks stable idle only when **`floor_normal.dot(UP) < IDLE_RIM_MIN_FLOOR_UP_DOT`** — flat tread + vertical riser (e.g. **TerraceStepB_Approach** corner) no longer spends ~0.8 s in corrective idle. (2) **`use_loose_floor_angle`** not tied to **`loose_ticks` alone**. (3) **`STABLE_IDLE_FLOOR_MIN_UP_DOT` 0.998** (was 0.999 — Jolt flat-floor normals often ~0.9991+ so the anchor rarely latched and **`move_and_slide`** + nudges drifted HUD XZ); **`STABLE_IDLE_ENTER_STREAK_FRAMES` 2**; **`STABLE_IDLE_UNLATCH_TICKS` 10**; ridged **wallish ny < 0.35**; **stable latch + Y anchor**. (4) **Arrival** stable shortcut (immediate latch, no enter streak). (5) **Nav column steer** hysteresis. (6) **`needs_vertical_routing` Schmitt latch**; **`debug_idle_trace`** walking extras.
+- **Not in this pass:** **`PrototypeTerminal`**, **MoveReject** props, **runtime random bumps** — add geometry when those need climbable access.
+
+## Open questions / risks
+
+- **NavMesh bake time:** A 45×45 floor with several terraces will bake more polygons than the 20×20 baseline. Expected to be negligible for `bake_navigation_mesh(false)` on desktop, but monitor Output for a perceptible pause.
+- **Agent climb on terraces:** `agent_max_climb = 0.35` limits single-step height. Each terrace transition is 0.30 m; verify in Godot editor nav mesh debug overlay before shipping.

gdlintrc

@@ -32,7 +32,8 @@ function-preload-variable-name: ([A-Z][a-z0-9]*)+
 function-variable-name: '[a-z][a-z0-9]*(_[a-z0-9]+)*'
 load-constant-name: (([A-Z][a-z0-9]*)+|_?[A-Z][A-Z0-9]*(_[A-Z0-9]+)*)
 loop-variable-name: _?[a-z][a-z0-9]*(_[a-z0-9]+)*
-max-file-lines: 1000
+# `player.gd` is a single CharacterBody3D controller (~1.4k lines); keep headroom until it splits.
+max-file-lines: 1600
 max-line-length: 100
 max-public-methods: 20
 max-returns: 6

server/NeonSprawl.Server.Tests/Game/PositionState/MoveCommandApiTests.cs

@@ -115,7 +115,11 @@ public class MoveCommandApiTests
         {
             b.ConfigureTestServices(services =>
             {
-                services.PostConfigure<GamePositionOptions>(o => o.MovementValidation.MaxHorizontalStep = 1.0);
+                services.PostConfigure<GamePositionOptions>(o =>
+                {
+                    o.MovementValidation.HorizontalStepEnabled = true;
+                    o.MovementValidation.MaxHorizontalStep = 1.0;
+                });
             });
         });
         var client = factory.CreateClient();

server/NeonSprawl.Server.Tests/Game/PositionState/MoveCommandValidationTests.cs

@@ -5,9 +5,11 @@ namespace NeonSprawl.Server.Tests.Game.PositionState;
 
 public class MoveCommandValidationTests
 {
-    private static MovementValidationOptions Rules(double maxH, double maxV, bool bounds = false) =>
+    private static MovementValidationOptions Rules(
+        double maxH, double maxV, bool bounds = false, bool horizontalEnabled = true) =>
         new()
         {
+            HorizontalStepEnabled = horizontalEnabled,
             MaxHorizontalStep = maxH,
             MaxVerticalStep = maxV,
             DistrictBoundsEnabled = bounds,
@@ -63,6 +65,15 @@ public class MoveCommandValidationTests
         Assert.Equal(MoveCommandReasonCodes.HorizontalStepExceeded, code);
     }
 
+    [Fact]
+    public void TryValidate_ShouldAllow_WhenHorizontalDisabled()
+    {
+        var from = new PositionSnapshot(0, 0, 0, 0);
+        var to = new PositionVector { X = 1000, Y = 0, Z = 1000 };
+        Assert.True(MoveCommandValidation.TryValidate(from, to, Rules(1, 10, horizontalEnabled: false), out var code));
+        Assert.Equal("", code);
+    }
+
     [Fact]
     public void TryValidate_ShouldIgnoreBounds_WhenDistrictDisabled()
     {

server/NeonSprawl.Server/Game/PositionState/MoveCommandValidation.cs

@@ -18,13 +18,16 @@ public static class MoveCommandValidation
     {
         reasonCode = "";
 
-        var dx = to.X - from.X;
+        if (rules.HorizontalStepEnabled)
-        var dz = to.Z - from.Z;
-        var horizontal = Math.Sqrt(dx * dx + dz * dz);
-        if (horizontal > rules.MaxHorizontalStep)
         {
-            reasonCode = MoveCommandReasonCodes.HorizontalStepExceeded;
+            var dx = to.X - from.X;
-            return false;
+            var dz = to.Z - from.Z;
+            var horizontal = Math.Sqrt(dx * dx + dz * dz);
+            if (horizontal > rules.MaxHorizontalStep)
+            {
+                reasonCode = MoveCommandReasonCodes.HorizontalStepExceeded;
+                return false;
+            }
         }
 
         var dy = Math.Abs(to.Y - from.Y);

server/NeonSprawl.Server/Game/PositionState/MovementValidationOptions.cs

@@ -3,11 +3,15 @@ namespace NeonSprawl.Server.Game.PositionState;
 /// <summary>Per-command movement sanity limits (NS-19). Bound from <c>Game:MovementValidation</c>.</summary>
 public sealed class MovementValidationOptions
 {
-    /// <summary>Max horizontal displacement on X/Z in one move (meters). Inclusive at the limit.</summary>
+    /// <summary>When true, enforces <see cref="MaxHorizontalStep"/>. False (default) means no horizontal limit.</summary>
+    public bool HorizontalStepEnabled { get; set; }
+
+    /// <summary>Max horizontal displacement on X/Z in one move (meters). Inclusive at the limit.
+    /// Only applied when <see cref="HorizontalStepEnabled"/> is true.</summary>
     public double MaxHorizontalStep { get; set; } = 18.0;
 
     /// <summary>Max absolute delta on Y in one move (meters). Inclusive at the limit.</summary>
-    public double MaxVerticalStep { get; set; } = 1.25;
+    public double MaxVerticalStep { get; set; } = 2.2;
 
     /// <summary>When true, target must lie inside the axis-aligned district box (inclusive min/max).</summary>
     public bool DistrictBoundsEnabled { get; set; }

server/NeonSprawl.Server/appsettings.json

@@ -14,8 +14,9 @@
       "Z": -5
     },
     "MovementValidation": {
+      "HorizontalStepEnabled": false,
       "MaxHorizontalStep": 18,
-      "MaxVerticalStep": 1.25,
+      "MaxVerticalStep": 2.2,
       "DistrictBoundsEnabled": false
     }
   }

server/README.md

@@ -70,11 +70,11 @@ Unknown player ids return **404**. Full zone sync / replication is still out of
 | Config key | Meaning | Default (see `appsettings.json`) |
 |------------|---------|-----------------------------------|
 | `Game:MovementValidation:MaxHorizontalStep` | Max XZ displacement per command (m); inclusive at limit | `18` |
-| `Game:MovementValidation:MaxVerticalStep` | Max absolute Y delta per command (m); inclusive | `1.25` |
+| `Game:MovementValidation:MaxVerticalStep` | Max absolute Y delta per command (m); inclusive | `2.2` |
 | `Game:MovementValidation:DistrictBoundsEnabled` | Axis-aligned box on **target** (inclusive min/max) | `false` |
 | `Game:MovementValidation:DistrictMinX` … `DistrictMaxZ` | District extents when enabled | ±12 / Y −2…24 |
 
-**Manual QA (Godot `main.tscn`):** **Green bumps** are **two random short cylinders** each run (~**8–14 cm** rise) and stay under default `MaxVerticalStep` from the dev spawn; **orange reject pedestal** top is ~2.5 m above floor so a floor-level click yields **`vertical_step_exceeded`**; **far pad** is beyond default horizontal reach for **`horizontal_step_exceeded`**. The client’s **`ground_pick.gd`** only accepts ray hits whose surface **normal** is mostly **upward** (`MIN_WALKABLE_NORMAL_DOT_UP`), so **vertical faces** on the pedestal do not emit move targets—this complements server per-step limits and prevents “stair-stepping” up walls.
+**Manual QA (Godot `main.tscn`):** **Green bumps** are **two random short cylinders** each run (~**8–14 cm** rise) and stay under default `MaxVerticalStep` from the dev spawn; **orange reject pedestal** top is ~**2.5 m** above floor so a floor-level click still yields **`vertical_step_exceeded`** (default `MaxVerticalStep` is **2.2 m**); the **physics ramp test block** top is **2 m** so clicking the floor from it is **accepted**. **Far pad** is beyond default horizontal reach for **`horizontal_step_exceeded`** when horizontal limits are enabled. The client’s **`ground_pick.gd`** only accepts ray hits whose surface **normal** is mostly **upward** (`MIN_WALKABLE_NORMAL_DOT_UP`), so **vertical faces** on the pedestal do not emit move targets—this complements server per-step limits and prevents “stair-stepping” up walls.
 
 Request body (example):