diff --git a/.gitignore b/.gitignore index 3f6ee43f..5ac2beda 100644 --- a/.gitignore +++ b/.gitignore @@ -91,3 +91,11 @@ C[€- # Junction to Claude Code per-project memory (Obsidian vault visibility) claude-memory studio-shots/ + +# MP1b acdream-bake output — user-machine artifact, never committed +# (docs/superpowers/plans/2026-07-05-mp1b-pak-and-bake.md, Task 5). +*.pak + +# session-local physics capture artifacts (worktree root) +/resolve-*.jsonl +/launch-*.log diff --git a/AcDream.slnx b/AcDream.slnx index c004e101..abf3defb 100644 --- a/AcDream.slnx +++ b/AcDream.slnx @@ -1,7 +1,9 @@ + + @@ -14,6 +16,8 @@ + + diff --git a/CLAUDE.md b/CLAUDE.md index 8cca4160..6aa36681 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -108,25 +108,18 @@ movement queries. ## Current state -**Currently working toward: M1.5 — Indoor world feels right.** Dungeons RENDER + -are navigable; **login into a dungeon** now loads + places the player and is -**FPS-steady from the start** (#135 pre-collapse + indoor cell-floor spawn gate, -`712f17f`+`2c92375`). The dungeon **"red cone"** was an editor-only placement marker -acdream inherited from WB (retail hides it via distance degrade) — FIXED (#136 `6f81e2c`). -REMAINING for M1.5: **A7 dungeon lighting** (LightBake Core landed `3b93f91`; per-vertex -bake integration + the per-pixel torch OVER-blow still open — #79/#93); **#137 dungeon -collision** (doors / wall openings); **#138 teleport-OUT of a dungeon** loads the outdoor -world incompletely + position desync (the collapse→EXPAND gap — same machinery as #135). -M2 (CombatMath) deferred. Detail in ISSUES (#135–#138) + the render/physics digests. -Recent closes (2026-06-14): #135, #136. Keep this paragraph ≤6 lines + pointers — detail -in the docs below, NOT here. - -**⚠ Reconcile (banner stale as of 2026-06-22):** the active recent work stream has been the -parallel **D.2b retail-UI track** (inventory window / panels — the inventory empty-slot art -shipped + was visually confirmed this session; next is container-switching), NOT the M1.5 -dungeon items above. See [`claude-memory/project_d2b_retail_ui.md`] + the handoff -`docs/research/2026-06-22-container-switching-handoff.md`. Decide in the milestones doc whether -M1.5 is paused or D.2b retail-UI is its own milestone, then rewrite this banner. +**Currently working toward: M1.5 — Indoor world feels right** (building/cellar demo +DONE + gated; **#137 dungeon collision CLOSED, A7 dungeon lighting #79/#93 CLOSED +2026-07-09** — two root causes fixed + user-reverified 2nd-floor case; REMAINING +critical path = **#138 teleport-OUT**). One **user-report-driven +parity track** still interleaves at the issue level (NOT a milestone; see the M1.5 +note in the milestones doc): **D.2b retail UI** (next: container-switching — +`claude-memory/project_d2b_retail_ui.md`). The **R5 movement-manager arc is DONE** +(2026-07-05, V5 facade shipped; close-out banner in +`docs/research/2026-07-03-r5-managers/r5-wiring-handoff.md`; carried: #167, R6/TS-42). +**Track MP** (modern-pipeline perf side track, dedicated sessions only — roadmap +"Track MP") is at MP0. M2 (CombatMath) deferred. Keep this paragraph ≤6 lines + pointers — detail in the docs +below, NOT here. For canonical state, read in this order: - [`docs/plans/2026-05-12-milestones.md`](docs/plans/2026-05-12-milestones.md) — milestone targets + freeze list per milestone @@ -958,6 +951,12 @@ via `PlayerMovementController.ApplyServerRunRate`) or from - `ACDREAM_PROBE_FLAP=1` — capture probe for indoor visibility decisions at frame boundaries. Used to converge the U.4c flap fix (root indoor visibility at player's cell, not eye). +- `ACDREAM_PROBE_STICKY=1` — per-guid sticky-melee timeline: `[sticky]` + lifecycle lines (STICK/UNSTICK/LEASE-EXPIRE/TARGET-status teardown), + per-armed-tick steer lines (signed gap dist, applied delta, heading + delta), `[sticky-snap-skip]` at the suppressed NPC UP-snap site. + Heavy while a pack is stuck (~60 Hz × stuck count). Converged the + #171 residuals (the deep-overlap sign pin AP-82). - `ACDREAM_CAPTURE_RESOLVE=` — live capture of every player-side `PhysicsEngine.ResolveWithTransition` call. Each call appends one JSON Lines record with full inputs, PhysicsBody snapshot before AND diff --git a/docs/ISSUES.md b/docs/ISSUES.md index 4e7e0cde..989ad815 100644 --- a/docs/ISSUES.md +++ b/docs/ISSUES.md @@ -47,6 +47,1481 @@ Copy this block when adding a new issue: --- ## #166 — Port the portal String-table lookup for WeenieError / UseDone text +## #191 — Tapping W (brief forward press) glides forward without playing the step animation + +**Status:** OPEN +**Severity:** MEDIUM (visible every time a player taps instead of holds a movement +key — likely a common input pattern) +**Filed:** 2026-07-09 +**Component:** physics / animation — movement input, motion sequencing + +**Description:** User-reported (live testing, unrelated to tonight's A7 lighting +work): tapping W briefly translates the player forward smoothly ("glide") without +the walk/run step animation playing. In retail, a brief tap produces a single +visible step (a short animated motion), not a silent slide. Not investigated this +session — filed to keep A7 lighting/particle work from being interrupted by an +unrelated subsystem (movement/animation, not rendering). + +**Root cause / status:** UNKNOWN. Likely candidates for a future session (grep +named retail decomp FIRST, per the mandatory workflow — do not guess): +- The R5 movement-manager arc shipped 2026-07-05 (`docs/research/2026-07-03-r5-managers/`) + — check whether this is a regression from that work or a pre-existing gap it + didn't cover. +- Retail likely distinguishes a brief key tap (press+release before some + threshold) from a held key at the INPUT/COMMAND layer, producing a distinct + one-shot "step" motion command rather than the continuous Walk/RunForward + cycle — search `docs/research/named-retail/acclient_2013_pseudo_c.txt` for how + `CMotionInterp`/the movement command dispatch handles a short-duration + ForwardCommand before it's promoted to a full walk/run cycle. +- Candidate files: `src/AcDream.App/Input/PlayerMovementController.cs` + (local input → command translation), `src/AcDream.Core/Physics/MotionInterpreter.cs` + / `AnimationSequencer.cs` (cycle selection/dispatch). +- Cross-reference `references/holtburger/crates/holtburger-core/src/client/movement/` + for what a real client sends on a brief tap vs a hold. + +**Files:** Not yet identified beyond the candidates above. + +**Acceptance:** A brief W tap produces a single retail-faithful step animation +(not a silent glide); holding W still transitions normally into the walk/run +cycle. + +--- + +## #187 — [DONE 2026-07-08] Non-hinged doors (sliding doors, gates) don't play their open animation + +**Status:** CLOSED 2026-07-08 — user-confirmed live gate: "sliding doors now work." +**Severity:** MEDIUM (visual correctness; collision + interaction already work — #137) +**Filed:** 2026-07-08 +**Component:** render — entity animation registration (`GameWindow.cs` live-spawn dispatch) + +**Root cause (CONFIRMED via retail decomp + a live weenie-data survey):** +`GameWindow.cs:3897` registered the reactive-motion-table rescue sequencer only when +`spawn.Name == "Door"` (an exact display-name string match). Retail's own client-side +motion dispatch chain (`ACCObjectMaint::CreateObject` → `CPhysicsObj::set_description` → +`SetMotionTableID` → `CPartArray::SetMotionTableID` 0x005186e0 → `MotionTableManager:: +PerformMovement`) is unconditionally data-driven — the only gate anywhere in that chain +is "does this object have a non-zero MotionTableId" (`if (ebx != 0)`); there is no +`CDoor` class and no name/type check. Production weenie data confirms Sliding Door / +Portcullis / Gate / "Magic Wall" all carry the identical WeenieType=Door + +non-zero-MotionTableId shape as a plain "Door", differing only in display name — so the +name-string gate silently dropped every door-like object not literally named "Door". + +**Fix:** `GameWindow.cs:3897` — dropped the name check; the branch's existing +`mtableId != 0` test (already computed one line later) is now the entire gate, matching +retail exactly. `IsDoorSpawn` deleted (dead code); `IsDoorName` kept only for an +unrelated diagnostic log-label filter. Full regression green (App 741 / Core 2631). +Live-verified: sliding doors now animate open/closed correctly. + +**Scope note:** the investigation also surfaced a SEPARATE, deeper gap — some +door-family objects (confirmed: "Pedestal Weak Spot", a fading-wall secret passage) +don't use ordinary part-transform motion at all; their open cycle is a translucency-fade ++ ethereal-toggle effect that acdream has no rendering sink for. That is NOT a +registration problem (this fix's dispatch reaches it correctly) — filed separately as +**#188**. + +--- + +## #188 — "Fading wall" secret passages don't visually fade (missing TransparentHook/EtherealHook render sink) + +**Status:** CLOSED 2026-07-09 (`3284dd0a`) — user-confirmed live gate: fading-wall +doors fade out and hold; sliding doors hold open. Fix = `TranslucencyHookSink` → +`TranslucencyFadeManager` → per-instance alpha SSBO (binding 7) → `mesh_modern.frag` +(`FragColor.a *= vOpacityMultiplier`), register AP-89. The commit ALSO fixed a +door "flip-back" (a settled-open door/wall reverted to the Tier-1 static cache's +rest pose + opacity 1.0) by reverting an uncommitted `IsEntityCurrentlyMoving` +cache-bypass narrowing — every Sequencer entity stays on the per-frame path. That +narrowing chased a Debug-build FPS artifact; Release is GPU-bound (~200 fps Sawato). +**Severity:** MEDIUM (a real but narrow class of dungeon secret-door objects; collision +already correct via a separate wire channel) +**Filed:** 2026-07-08 (surfaced during #187's live gate) +**Component:** render — animation hook dispatch (`IAnimationHookSink` / render-state sinks) + +**Description (user):** a "fading wall" style secret-passage door ("Pedestal Weak Spot") +can be used and passed through, but never visibly changes — no fade, no motion, nothing. +Confirmed distinct from #187 (registration/dispatch already reaches this entity +correctly). + +**Root cause (CONFIRMED via a live dat decode of the actual entity, not inference):** +loaded the real MotionTable (`0x090000F9`) for the live-identified "Pedestal Weak Spot" +(guid `0x7C95B03B`) and dumped its open cycle's animation hooks directly — the cycle +(`anim 0x03000919`, 10 frames) carries **`EtherealHook`, `TransparentPartHook`, +`SoundTableHook`** — i.e. this door type's "open" isn't skeletal motion at all, it's a +per-part translucency fade + a collision-passthrough toggle + a sound cue, fired as +keyframe hooks during the animation. + +`src/AcDream.Core/Physics/IAnimationHookSink.cs`'s own doc comment documents +`TransparentHook`/`NoDrawHook`/`ScaleHook`/`ReplaceObjectHook`/etc. as intended to route +to "GfxObjMesh / renderer state mutations on the target entity" — but only three sinks +are ever registered (`_particleSink`, `_lightingSink`, `_audioSink`; `GameWindow.cs` +~1414-1441). No sink anywhere in the codebase pattern-matches `TransparentHook` / +`TransparentPartHook` / `EtherealHook` / `NoDrawHook` / `ScaleHook` / +`ReplaceObjectHook` (verified by a full-repo grep) — the sequencer correctly parses and +fires these hooks every tick, the router fans them out, and all three registered sinks +silently ignore them. Nothing crashes (the router swallows exceptions per-sink); nothing +renders differently either. + +**Confirmed NOT a collision bug:** the object's ethereal/collision-passthrough state is +applied correctly via a SEPARATE server-authoritative wire message (`SetState` → +`OnLiveStateUpdated`, `GameWindow.cs:5517`) — independent of the animation-hook +mechanism. `EtherealHook` firing client-side during the animation is very likely a +redundant/cosmetic signal in retail's own design; the real remaining gap is purely +**`TransparentPartHook` → no visible fade**. + +**Scope (not yet designed):** implementing this touches the render pipeline (a per-part +runtime alpha under the mandatory N.5 bindless/MDI pipeline — see +`memory/reference_modern_rendering_pipeline.md` for the existing SSBO layout +constraints) — this is feature-shaped work, not a one-line fix. Needs its own design +pass (grep retail's `TransparentHook::Execute`/`SetTranslucency2`/`SetPartTranslucency` +decomp for the exact interpolation semantics) before implementation. + +**Apparatus (kept):** `tests/AcDream.Core.Tests/Physics/Issue187FadingDoorMotionTableInspectionTests.cs` +— reflects the real `DatReaderWriter` hook-type shapes + decodes a live MotionTable's +hook contents directly (no guessing). Reusable for any future "why doesn't this animate" +question — just swap the MotionTableId. + +**Acceptance:** the Pedestal Weak Spot (and similar fading-wall objects) visibly fades +out/in when triggered, matching retail. No regression to #187's fix or any other door type. + +--- + +## #186 — [DONE 2026-07-08 · `8257b9ba`] Indoor→indoor GREY flap at a connecting room (top floor, new house type) + +**Status:** CLOSED 2026-07-08 — live gate PASSED (no grey at any camera angle) + probe +(216 `root=0118` frames, 0 still grey; `0118->0116` now `TRV`, `vis=4`). +**Severity:** MEDIUM · **Filed:** 2026-07-08 · **Component:** render / indoor visibility (portal side-cull) + +**Description:** Top floor of a new house type; a thin connecting cell between two rooms. Passing +through → brief GREY flap; stopping at the spot → whole screen grey and stays; turning the camera +clears it, turning back → grey again (camera-direction dependent, player stationary). + +**Root cause (CONFIRMED via live retail cdb trace + dat diagnostic — the report-only "narrowed" note +was the right FAMILY but the WRONG mechanism):** the render portal side-cull reconstructed each +doorway's interior side (`PortalClipPlane.InsideSide`) from the cell's **AABB centroid**. For the thin +connector `0xF6820118` (5 render polys) the bounding-box center falls on the WRONG side of the +`0118->0116` doorway → the eye read as a back-portal → the forward room `0116` was culled → the +aperture showed the fog clear color = grey. Retail's `PView::InitCell` (0x005a4b70) AND acdream's own +PHYSICS path (`CellTransit.cs:190`) read the explicit dat **`PortalSide` bit** (`(Flags&2)==0`); the +render path was the only one guessing from geometry. + +**Fix (`8257b9ba`):** `GameWindow.BuildLoadedCell` derives `InsideSide` from the dat `PortalSide` bit, +matching retail + physics. Surgical — the dat diagnostic +(`Issue186…PortalSide_CentroidVsDatBit_AtGreyEye`) shows the bit agrees with the old centroid on every +portal of these cells EXCEPT the one #186 breaks; the `CornerFlood`/`Issue113` dat helpers updated to the +same bit keep every real Holtburg/tower/hall flood identical (App 741 / Core 2631 green). Touches neither +`PortalSideEpsilon` nor the deleted `EyeInsidePortalOpening` rescue. + +**The retail trace OVERTURNED both prior hypotheses:** NOT PICK (both clients root at `0118` at the pose, +eye ≈ identical) and NOT the handoff's FLOOD-epsilon framing — retail draws `0116` from the `0118` root +because its dat side bit admits the portal; acdream's centroid guess culled it. Apparatus (kept): +`tools/cdb/issue186-connector-decider.cdb` (viewer_cell + cell_draw_list decider) + the offline geometry +test. Handoff (now historical): `docs/research/2026-07-08-186-connector-grey-flap-handoff.md`. + +--- + +## #185 — [DONE 2026-07-08 · `07c5b832`] LOCAL player jams half-way up outdoor stairs (house on stilts); a jump clears it + +**Status:** DONE (live gate PASSED — "OK works"). Root cause was NOT the collision response. +**Severity:** MEDIUM · **Filed:** 2026-07-08 · **Component:** physics / collision-registration (landblock shadow objects) + +**Description:** Running up the outside stairs of a house-on-stilts you hit an invisible wall +"in the middle of the stairs" (steps look unbroken) — you shuffle sideways, never advance; a +jump clears it. Landblock `0xf682`, jam ≈ world (132, 77.9, 61.5), cell `0xF682002C`. + +**Root cause (REAL — a uint32 overflow in the shadow-registry part-id, `07c5b832`):** +`GameWindow.cs` registered each landblock BSP part with a synthetic id `entity.Id * 256u + +partIndex`. That `<< 8` **overflows uint32** for class-prefixed landblock ids +(`0x40`/`0x80`/`0xC0`…) and drops the prefix byte, so different-class entities sharing the low +24 bits **collide on one shadow part-id**; `Register`'s deregister-then-insert silently +overwrites one entity's collision (`0xF6822100 ← {0x40F68221, 0xC0F68221}` — 23 such collisions +in landblock `0xF682` alone). Three mid-staircase steps therefore **rendered but had NO +collision**; the player floats into the hole and the (retail-faithful) `PrecipiceSlide` wedge +fires at the walkable edge = the "invisible wall." **The wedge was a symptom, not the cause.** +The two earlier theories in this session — the handoff's "convex-tread-edge synthetic normal" +and design-v1's "grounding-retention at a coplanar seam" — were both SUPERSEDED by the live +`[entity-source]`/`[bsp-test]` capture (#3) that mapped the collision hole + the 23 id +collisions. + +**Fix (Option A, retail-faithful):** register each multi-part landblock entity via +`ShadowObjectRegistry.RegisterMultiPart` under its **unique 32-bit `entity.Id`** (retail +`CPhysicsObj::add_shadows_to_cells` → `CPartArray::AddPartsShadow` — one object, a part array; +no synthetic per-part id). New builder `ShadowShapeBuilder.FromLandblockBspParts`. Setup +cyl/sphere path unchanged (runs only when `entityBsp==0`, retail BSP-xor-cyl). Despawn is +landblock-scoped so the id change is safe. Does NOT touch the frozen collision internals. + +**Files:** `src/AcDream.Core/Physics/ShadowShapeBuilder.cs` (`FromLandblockBspParts`), +`src/AcDream.App/Rendering/GameWindow.cs` (~7898 registration block). +**Tests:** `ShadowRegistrationOverflowTests` (overflow arithmetic; old scheme drops one; +`RegisterMultiPart` keeps both; builder), `Issue185OutdoorStairsSeamReplayTests` (dat-free +clean-climb pin). Core 2629 / App 741 green. Design: `docs/superpowers/specs/2026-07-08-185-outdoor-stairs-fix-design.md` (v2). + +**Fallout note:** shared registration path → this was silently dropping collision on OTHER +landblock objects too (23 id collisions in one landblock); likely fixed a class of +"walked-through-a-thing-that's-clearly-there" bugs, not just these stairs. + +--- + +## #184 — [DONE 2026-07-08 · `37a94e1f`+`f51c1dff`+`e1ac56cc`+`ddb5a967`] Remote monsters overlap (arms interpenetrating) in a crowd; retail barely overlaps + +**Status:** CLOSED 2026-07-08 — all four slices shipped + both visual gates passed. Slices 1+3 +(`37a94e1f`+`f51c1dff`) fixed the reported monster-overlap symptom (gate passed). **Slice 2** shipped +this session: **2a** (`e1ac56cc`) extracted the ~690-line remote DR tick into a testable +`RemotePhysicsUpdater` (Code Structure Rule 1) — byte-exact, behaviour-neutral. **2b** (`ddb5a967`) +collapsed the player/NPC fork so EVERY remote runs the same catch-up + sweep + shadow-follows-resolved. +A 3-lens adversarial review (workflow `wf_b163315b-14f`, 10 agents) corrected the design's player gate: +retail lets two non-PK players WALK THROUGH each other (PvP exemption — the remote-player mover now +carries `IsPlayer|EdgeSlide` like the local player), so 2b's player win is that players now collide with +monsters + terrain + walls (they skipped all collision before) while still passing through each other; +the review also caught + fixed a UM-first placement-snap gap (invisible-player risk). **Gate PASSED +(user, 2026-07-08): "Looks good."** #40 "remotes skip the transition" premise retired. Full plan + the +review corrections: `docs/research/2026-07-07-184-slice2-unify-extract-handoff.md` + the physics digest +banner. Register: TS-41 retired, TS-44 narrowed, TS-23 extended, AP-86/87/88. +**Severity:** MEDIUM +**Filed:** 2026-07-07 +**Component:** physics / remote dead-reckoning + +**Description:** Side-by-side vs retail on the SAME ACE, monsters packed around the player +interpenetrate (arms) in acdream where retail keeps them barely overlapping — the "no room to +slide out" feel. This is the REMOTE-creature thread — distinct from #182 (the LOCAL-player wedge). + +**Root cause / status:** Retail de-overlaps remotes CLIENT-side: it runs the collision sweep on +every remote every tick against neighbours' LIVE resolved positions (the shadow == the resolved +`m_position`, re-registered every moved step), with the server pos a GENTLE catch-up target +(`MoveOrTeleport` 0x00516330), not a hard-snap. **A first attempt (commit `9c0849dd`) GATE-FAILED +(invisible monsters + player stuck on them) and was REVERTED** — it (a) replaced the NPC UP +hard-snap with enqueue-everything, losing the body's PLACEMENT authority (an unplaced body blipped +over a huge distance into the sweep → garbage pos → invisible), and (b) left the shadow at the raw +server pos, so neighbours de-overlapped against overlapping shadows and the player collided with an +offset shadow. **REDO (this session):** (1) NPC UP `MoveOrTeleport` with a PLACEMENT-SNAP (snap when +the body isn't already near the target — first UP / no-Sequencer / far / >4 m; enqueue only near); +(2) grounded movement = interp catch-up feeding the kept sweep; (3) **shadow-follows-resolved** — +the shadow is re-registered at the resolved body every moving tick (`SyncRemoteShadowToBody`, +movement-gated; `:5669` raw sync now players-only). Retires TS-41, narrows TS-44, adds AP-86/AP-87. +Mechanism proven in Core (`RemoteDeOverlapMechanismTests`: with-sync 0.86 m stable / without <0.40 m; +the real-interp loop absorbs the stall-blip). 2-lens Opus review CONCERNS → all addressed +(movement-gate for the town-FPS risk; players-only `:5669`; the blip-absorption test). Core 2620 / +App 741 green. + +**Known residual:** the de-overlap sweep uses the fixed human sphere (R 0.48) for the mover, so +large packed creatures de-overlap at human radii (**TS-46**; Setup-derived dims = Slice 3). + +**Files:** `src/AcDream.App/Rendering/GameWindow.cs` (NPC `OnLivePositionUpdated` ~:5960 MoveOrTeleport ++ shadow sync; Path B tick catch-up/sweep/shadow-sync; `SyncRemoteShadowToBody`). + +**Research:** design `docs/superpowers/specs/2026-07-07-remote-creature-deoverlap-design.md`; handoff +`docs/research/2026-07-07-remote-creature-deoverlap-handoff.md`; digest `claude-memory/project_physics_collision_digest.md` (2026-07-07 top). + +**Acceptance:** side-by-side vs retail — packed monsters spread to retail spacing (arms no longer +interpenetrating), monsters VISIBLE (not stuck-on-nothing), no ~3 Hz jitter in a pack, no town-FPS +drop; remotes don't rubber-band/desync; sticky #171 facing unbroken; walk/run/jump/land unchanged. +Then Slice 2 (unify Path A + `RemotePhysicsUpdater` extraction) and Slice 3 (Setup-derived sphere). + +--- + +## #183 — Floating distant scenery: trees from another biome hover in the distance + +**Status:** OPEN +**Severity:** LOW +**Filed:** 2026-07-07 +**Component:** rendering / scenery / streaming + +**Description:** Observed during #182 crowd testing (Holtburg area, `+Acdream`): trees +that appear to belong to a different biome render **floating** in the distance — +detached from the ground, at the wrong Z and/or wrong placement. Distant/far-radius +scenery only; unrelated to the collision work. + +**Root cause / status:** Unknown. Candidates: far-tier streaming placing scenery +before its terrain Z is resolved (procedural scenery Z uses the terrain height at the +cell — a stale/zero height would float it), a biome/terrain-type mismatch selecting +the wrong scene set, or a far-LOD placement offset. Not yet investigated. + +**Files:** likely `src/AcDream.App/Rendering/Wb/` scenery pipeline +(SceneryRenderManager / SceneryHelpers) + the two-tier streamer's far tier. + +**Acceptance:** distant scenery sits on the ground with correct biome/placement. + +--- + +## #182 — Player wedges in a packed monster crowd, can't wiggle free (hand-rolled SphereCollision) + +**Status:** VELOCITY-MODEL REBUILD SHIPPED (Slices 1+2, `8bb8b204`→`54d56229`) — +**awaiting the user visual gate** (crowd glide/land + normal-locomotion regression pass). +**Severity:** MEDIUM +**Filed:** 2026-07-07 +**Component:** physics / collision + +**REBUILD SHIPPED (2026-07-07):** The `CPhysicsObj::UpdateObjectInternal` velocity chain +was ported verbatim, fixing the airborne "stuck in the falling animation" regression the +CSphere port had exposed. **Refinement of the design's framing:** the airborne-stuck +bleed is the `frames_stationary_fall` counter (`ValidateTransition` increments it when a +gravity mover can't advance; `handle_all_collisions` zeros the velocity at fsf>1 → gravity +resumes → glide/fall), NOT the `cached_velocity` field (a separate retail reporting/DR +value). Slice 1 = the fsf round-trip in the kept transition internals (retires **TS-3**) + +ungated small-velocity-zero; Slice 2 = `PhysicsObjUpdate.HandleAllCollisions` wired into +`PlayerMovementController`, gated on `candidateMoved` (retail pc:283657), replacing the +ad-hoc airborne-only reflect + Velocity.Z snap (AD-25 narrowed to the remote-DR sweep; +AD-39/40/41 added). Tests: `FramesStationaryFallTests`, `HandleAllCollisionsTests`, +`Issue182CrowdJumpTests` (a blocked jump bleeds to ~0 and grounds instead of hanging with ++12). Core 2617 / App 741 green. Plan: +`docs/superpowers/plans/2026-07-07-player-physics-update-verbatim-rebuild.md`. +**A/B instrument:** `ACDREAM_CAPTURE_RESOLVE` → `tools/analyze_resolve_capture.py` (before = +52.8% OK / 22.1% stuck / 107 airborne-stuck; retail target ~78% OK / 0 airborne-stuck). +**Residual (design §7 Q3, measure after the gate):** the general ground-jam (22% stuck vs +retail 13%) may need a second divergence in the #137 sliding-normal-provenance family +(TS-4) — the fsf ladder only climbs when the sweep runs, and a purely-horizontal push has +its offset absorbed by the sliding normal. #182 keeps the CSphere port as the base. + +**Description:** In a large group of monsters packed around the player it was too +easy to get stuck — the player couldn't shuffle/slide out. Retail leaves room to +wiggle free. + +**Root cause:** humanoid creatures/players collide as body **Spheres** +(`ShadowShapeBuilder.FromSetup` emits `ShadowCollisionType.Sphere` for a Setup with +Spheres + no CylSpheres), so the crowd contact ran through `Transition.SphereCollision` +— a hand-rolled 3-D wall-slide (register **TS-45**), NOT a port of retail +`CSphere::intersects_sphere`. It shaved no ε, force-pushed each contact **radially** +to a fixed `combinedR + 1 cm` shell, ignored the head sphere, always returned Slid, +and leaked `SetSlidingNormal`. In a crowd the opposing radial de-penetration pushes +from neighbours fight each other → wedge (the "until an oblique input clears it" feel +TS-45 predicted). + +**Fix:** ported the full `CSphere::intersects_sphere` family verbatim (dispatcher +0x00537A80 + `step_sphere_up`/`slide_sphere`/`land_on_sphere`/`collide_with_point`/ +`step_sphere_down`), the direct analog of the 2026-07-05 CCylSphere port (#172). The +grounded slide now routes through the shared crease `SlideSphere` (0x00537440) → +tangential shuffle along the contact toward gaps, retail-faithful. TS-45 retired, +AP-84 added (PerfectClip TOI dead in M1.5). Verified retail-faithful: retail's +`validate_transition` (0x0050aa70) reverts `curr_pos` on any non-clean-OK step, so a +deep-mutual-overlap start wedges in retail too — the realistic crowd-edge graze +slides free. + +**Files:** `src/AcDream.Core/Physics/TransitionTypes.cs` (`SphereCollision` + the +six new `Sphere*` siblings + `FindSphereTimeOfCollision`; caller at +`FindObjCollisionsInCell` threads `isCreature`). + +**Research:** `docs/research/2026-07-07-csphere-collision-family-pseudocode.md`. + +**Acceptance:** user shuffles free of a spawned monster pack the same way retail does. +Conformance: `SphereCollisionFamilyTests` (slide-around trajectory, head-on block, +ethereal passable) + `ShadowShapeBuilderShapeSourceTests` (body-spheres → Sphere-type). +Core 2603/0, App 741/0. + +--- + +## #181 — Facility Hub flicker at pressed camera (residual after the full 2026-07-06 fix ladder) — PARKED + +**⏸️ PARKED 2026-07-06 (user decision after the static-curve gate: "flickering is still +there — file it, document it, move on to the stairs").** The session shipped SEVEN +fixes/ports, every one individually verified, and the user-visible flicker at their +pressed-camera pose SURVIVED all of them. Shipped: `48aaab81` (stateful camera sought), +`f10fe4e9` (retail adjust_to_plane — the dead ACE port), `87cddce2` (static light +re-apply stacking), `3f34bca0` (retail viewer step subdivision + viewer-exempt abort), +`233b469b` (A7 fix #2 — stationary weenie fixtures on retail's STATIC light curve, +Ghidra-verified 0x0059c8b0). ELIMINATED with evidence: camera eye strobe (post-fix logs: +zero >2 cm jumps), display tearing (VSync-on 30 fps still shows it; windowed+DWM never +tears anyway), light-pool membership + applied per-cell sets ([seam-cell]: frozen across +107k parked frames incl. every vis-flap frame), the light-stacking leak (fresh-session +flicker), the flood-root flap (stable at the user's standing pose), the sliver-cell's +own geometry (zero-area region). STILL-OPEN leads for whoever resumes: (1) the parked +clean captures at MY pose show a pixel-static scene — the flicker has never been +captured in a frame pair at THE USER'S pose with an unobstructed window: get the user to +hold the pose, capture ≥8 frames, diff (the apparatus is in the scratchpad scripts — +capture-still.ps1/imgdiff.ps1/imgdiffmap.ps1); (2) the deep-cell vis 31↔32 flap +(0x8A020181 sliver admission on the wall-press mm wobble — both real, both measured, +consequence unproven; Issue181VisFlapReplayTests + Issue181WallPressEquilibriumTests are +the pins); (3) cdb-trace retail's wall-pressed viewer to compare equilibria (toolchain +proven, needs a live retail session); (4) the static-curve fix may have changed the +artifact's LOOK (brightness) without killing the motion-flicker — re-characterize +before assuming tonight's captures still describe it. + +**Original filing (mechanism evidence trail below remains valid):** +**Status:** OPEN — mechanism PINNED from live evidence; the knife-edge test not yet identified +**Severity:** HIGH (THE user-visible #176 flicker that survived the #180 camera fixes: washed +regions with hard screen-space rectangle boundaries pulsing at a parked camera) +**Filed:** 2026-07-06 (split from #176 after the #180 fixes exonerated the camera) +**Component:** render — portal flood / clip-slot scissor degrade / light-visibility scoping + +**Evidence (launch-176-leakfix.log, root 0x8A020142, camera parked all session):** +`[flap]` vis count flips 31↔32 every ~100–200 frames (≈10×/s at ~1500 fps) for the +ENTIRE 517k-frame session; the root's own portal products are stable except 2-dp +print-rounding wobble (eye 49.15↔49.14, p3 D −0.81↔−0.82) — the swept eye carries +micron-scale float-roundtrip noise (`[flap-sweep]` in/out differ ~7 µm; retail's parked +viewer is bit-exact via the UpdateCamera dead-band `return viewer`). One cell deeper in +the flood rides a knife-edge include/exclude test on that noise. Visible impact is +double: the cell's lights are visibility-scoped (GameWindow light registration +`cellId:` scoping), so a washed region's LIGHTING strobes, and the flapping cell's +portal extends the union-AABB clip/scissor rect (AD-17 degrade path) — captured as a +dashed axis-aligned rectangle boundary resizing frame-to-frame (scratchpad +flip-1/flip-4 crops, t0b stills). Frame-pair pixel diffs: 2.7–5% of the game area +changes per 150 ms at a fully parked, fresh session. + +**Confound note:** every pre-#180 isolation (LIGHT_DEBUG=3, CLIP_DEBUG=1, etc.) ran +WHILE the #180 camera strobe was live, so none of them cleanly cleared the render side +— and CLIP_DEBUG=1 forced gl_ClipDistance slots only; the AABB-scissor degrade sibling +may never have been disabled. + +**ROOT CAUSE CHAIN (completed 2026-07-06 night, all headless/live-probed):** +1. The flapping cell is **0x8A020181** (`Issue181VisFlapReplayTests`: ±0.5 mm eye + perturbation flips its admission across several gazes — at yaw 15/pitch −20 it flips + for EVERY perturbation direction). +2. The excitation is the WALL-PRESS wobble, not µm noise: at the parked spot the camera + is pressed into a wall (`[resolve]` hit=yes n=(0,−1,0) every frame; the player physics + position is BIT-FROZEN — in=tgt=out). The sought steps α·gap ≈ 4 mm into the wall per + frame and the sweep clips it back with `adjust_to_plane`'s parametric 0.02 termination + window (retail's own constant) → the published eye slides ~1 mm/frame along the wall. + `Issue181CameraParkStabilityTests`: with static inputs and no wall the camera parks + BIT-EXACT — the loop is healthy; a wall-press wobble of this scale is retail-class. +3. **The AMPLIFIER is ours and is the actual defect: the A7 adaptation scopes light + APPLICATION to the camera flood's per-frame admission** (light registration + `cellId:` scoping). Retail computes a light's reach through the portal graph ONCE at + registration (`Render::add_static_light` → `CObjCell::add_lights`), camera- + independent — a sliver cell flapping costs retail a few pixels; it costs us whole lit + regions (the washed-region strobe). + +**⚠️ RETRACTION + EXONERATION (same night, the seam-diff run):** the "per-frame +resizing dashed scissor rectangle" in the t0b captures was the USER'S SNIPPING-TOOL +MARQUEE (they were taking screenshots during the capture burst — the bright-inside/ +dim-outside rectangle is the snip overlay, and my frame-pair diffs were contaminated +by it + the chat window). Do not trust the t0b/still-* pixel-diff numbers. AND the +parked seam-diff run (launch-181-seamdiff.log, `[seam-cell]` per-cell applied sets + +`[flap]` vis) proves **the applied light sets are FROZEN across 107k parked frames +INCLUDING all 1,394 vis=32 frames — the vis 31↔32 flap has ZERO lighting consequence** +(the only 7 set-change events were startup hydration). Light-set path EXONERATED. +What stands: the flicker is real (user eyes + their clean screenshots: the pink wash +patches + a brick-textured stripe across the floor), the vis flap is real but +consequence-free, and camera/pool/applied-sets/sliver-geometry are all clean. **Next +instrument: a capture session with the game window UNOBSTRUCTED (no chat overlay, no +snip tool) while the user confirms the flicker is visibly active, + the user's +description of exactly WHAT changes (wash extent? the stripe? brightness?).** + +**🎯 ARTIFACT CHARACTERIZED (2026-07-06 late night — the VSync test + clean live +captures):** VSync ON (30 fps) and the stripes REMAIN ⇒ not tearing (and the client is +windowed — DWM never tears windowed apps; the tear theory was structurally wrong). +Clean captures at the user's spot with frame-pair diffs across 1 s: **the scene is +pixel-STATIC except the idle animation — the "stripes/triangles" are STATIC RENDERED +CONTENT**: the corridor wall's angled brace geometry silhouetted as dark triangles +against a BLOWN-OUT saturated magenta glow (zoom: scratchpad live-band.png). Retail +shows the same geometry against a dim wall; ours zebra-stripes because the pink +fixtures are ~10× too hot. **ROOT = the A7 fix-#2 item: server-weenie stationary lamps +take the DYNAMIC light path (`isDynamic: true` at the GameWindow registration, 1/d, +range×1.5) instead of retail's static curve — now Ghidra-verified at 0x0059c8b0: +`f = (1 − d/range)·intensity·wrap/d³` beyond 1 m, `range = falloff×1.3`, per-channel +clamped to the light's own colour (see the a7 pseudocode doc §1.6).** The "flicker" +in motion = the high-contrast pattern's edge crawl (+ the wall-press mm wobble), +secondary to the brightness. NEXT: implement fix #2 (static curve for stationary +lights; `isDynamic` decided by whether the light MOVES, not by weenie-vs-dat origin), +then the combined #176/#180/#181 re-gate. retail's viewer step subdivision ported (`3f34bca0` — radius-anchored +steps, remainder final step, viewer-exempt small-offset abort; `calc_num_steps` +0x0050a0b0 / `find_transitional_position` 0x0050bdf0 via Ghidra, pseudocode +`docs/research/2026-07-06-viewer-step-subdivision-pseudocode.md`). The wall-press +wander is UNCHANGED by it: a bit-exact 12-frame limit cycle (~130 µm/frame inward creep +×11, one 2.6 mm snap; `Issue181WallPressEquilibriumTests` orbit dump). With +`adjust_to_plane` + `adjust_sphere_to_poly` + the stepping now ALL Ghidra-verified +faithful, the residual mm cycle is most plausibly retail-class plateau physics — +invisible at retail's 60 fps vsync, tear-interleaved into visible stripes at our +~1500 fps unsynced (VSync defaults OFF, GameWindow.cs:1096). **DECISIVE USER TEST: +VSync ON (F11 → Display), camera pressed at the wall/opening — stripes gone ⇒ the +artifact = mm wobble × unsynced tearing (fix = default display mode decision, no +physics change); stripes remain ⇒ cdb-trace retail's wall-pressed `viewer` per frame +to measure whether retail truly holds sub-mm (then the divergence is structural and +the trace names it).** + +**REFINEMENT (same night, after the a7-pseudocode CORRECTION-2 re-read):** the pool is +ALREADY resident-scoped + player-anchored (`d8984e87` deleted the flood-scoped slice-1), +so "flood-scoped lights" is NOT the amplifier as first framed. Measured: 0x0181's +admitted view region at the flap pose is ONE zero-NDC-area sliver triangle +(`Diagnostic_FlappingCellViewRegion_SliverOrLarge`), and `ClipPlaneSet.From` handles +degenerates correctly (area < 1e-7 → Empty; sliver planes otherwise) — so the cell's own +gated geometry costs ~zero pixels either way. **The amplifier is downstream of ADMISSION +but not the slice gate: 0x0181 joining/leaving changes the DRAWN-CELL LIST, and some +per-drawn-cell state keyed by list position/rebuild — prime suspects: the per-cell +light-set SSBO slots (`SelectForCell`, d8984e87) shifting so a DIFFERENT cell reads the +wrong 8-light set on minority frames, or the seal/punch assembly — flips a whole cell's +lighting.** That is cell-sized, matches the captures (washed region with hard +boundaries), and is directly instrumentable: run parked with `ACDREAM_PROBE_SEAMDRAW=1` +(+FLAP) and diff the `[seam-blk]` applied-set lines of the WASHED cell between vis=31 +and vis=32 frames — if its applied set (or slot index) changes with 0x0181's admission, +the indexing/rebuild site is the defect. NO band-aids on the flood admission itself +(the sliver flap is retail-class). + +**Acceptance:** parked pressed camera in the washed spot → lit regions steady (the +`[flap]` vis 31↔32 flap may legitimately persist at sub-pixel visual cost); frame-pair +pixel diffs show no region-shaped changes; the user sees no flicker; #176 re-gate +(steady purple wedge) passes. + +--- + +## #180 — Camera-collision sweep bistable at a compressed boom → per-frame eye strobe (the #176 "stripes") + +**Status:** 🟡 BOTH FIXES SHIPPED 2026-07-06 + LOG-VERIFIED; user gate pends on #181 +(the residual visible flicker turned out to be render-side — see #181). Fix 1 +`48aaab81`: stateful sought-position per `CameraManager::UpdateCamera` 0x00456660 +(pseudocode `docs/research/2026-07-06-camera-sought-position-pseudocode.md`; register +AD-37/AD-38). Fix 2 `f10fe4e9`: `BSPQuery.AdjustToPlane`/`AdjustSphereToPoly` rewritten +per retail 0x00539bf0/0x00538170 — the ACE-inherited port was structurally dead +(always-false), so every PathClipped camera stop reverted to a whole transition-step +boundary; the original strobe's pulledIn 0.27↔0.53 was 1-step-vs-2-step quantization +(pseudocode `docs/research/2026-07-06-adjust-to-plane-pseudocode.md`, replay pin +`Issue180CorridorSweepHysteresisReplayTests`). Post-fix logs: zero eye jumps >2 cm +across 76k turn-only sweeps pressed into walls (was 0.27–0.29 m every ~5–90 frames); +wall stops resolve to the constant surface-contact point. +**Severity:** HIGH (the visible flicker/stripe artifact the #176 gate keeps failing on; corridor camera constantly rides walls) +**Filed:** 2026-07-06 +**Component:** camera / physics (NOT render — every render suspect eliminated by isolation) + +**Description (user, Facility Hub):** "geometrical patterns, triangles, that get +weird stripes… especially when I push the camera to the wall or the openings of +the corridor. If I zoom out and the camera does not touch the walls I get no +pattern." Reproduced autonomously (synthetic back-into-wall + GDI window +captures, `launch-176-cameye.log`). + +**Root cause (probe-pinned):** while the compressed chase boom moves along/near +a wall, the `SweepEye` first-contact solution is BISTABLE: consecutive +`[flap-sweep]` records show the sweep INPUT moving ~1.4 mm (the player's glide) +while the OUTPUT flips 0.27 m along the boom (`pulledIn` 0.27 ↔ 0.53, eye +(78.500,−38.633,−3.845) ↔ (78.669,−38.815,−3.938)), re-flipping every ~5–10 +frames — a knife-edge graze on the corridor's double-faced slabs (the #137 +threshold family, camera edition; all 368k sweeps returned ok=True — this is +NOT the fallback path). Each flip hard-cuts the whole view matrix; at ~1700 fps +with no vsync every monitor refresh tear-interleaves BOTH views → fine +stripe/hatch patterns over surfaces (worst near seams where the 0.27 m parallax +is largest), flickering with movement. Confirmed present in the pure light +field (`ACDREAM_LIGHT_DEBUG=3` still shows it → not texture) and with the +shell clip trim disabled (`ACDREAM_CLIP_DEBUG=1` → not the clip gate). +Explains the residual #176 flicker reports post-lighting-fix: one of the two +alternating eyes sees the purple under-room parallax, the other doesn't. + +**Retail anchor (the fix):** retail's sought position is STATEFUL — +`SmartBox` (0x00452d75) calls `CameraManager::UpdateCamera(mgr, &ret, +&this->viewer)` with the CURRENT swept viewer and assigns the RETURN to +`viewer_sought_position` (0x00452d84): the next frame's target derives from +the collided position (converges; re-extends gradually), so mm-jitter never +re-tests the full-length knife-edge ray per frame. acdream's +`RetailChaseCamera` recomputes the full-length desired boom from scratch every +frame. Fix = read `CameraManager::UpdateCamera` (0x00456660) + the sought +derivation and port the stateful shape — NO damping band-aid on the swept +result without that reading (workaround rule). + +**Files:** `src/AcDream.App/Rendering/RetailChaseCamera.cs` (boom/desired-eye), +`src/AcDream.App/Rendering/PhysicsCameraCollisionProbe.cs` (`SweepEye` — port +verbatim per update_viewer 0x00453ce0, exonerated), `[flap-sweep]` probe +(ACDREAM_PROBE_FLAP) is the apparatus. + +**Acceptance:** camera pressed into walls/openings while moving → no +stripe/hatch patterns, no per-frame view jumps (consecutive-frame eye deltas +stay continuous in `[flap-sweep]`); camera glides along walls like retail. + +--- + +## #178 — Retire the A8 double-sided cell-shell stopgap (CullMode.Landblock → None) + +**Status:** OPEN +**Severity:** LOW-MEDIUM (correctness/perf debt; 2× shell fragment load) +**Filed:** 2026-07-06 +**Component:** render — EnvCellRenderer MDI draw + +**Description:** `EnvCellRenderer.RenderModernMDIInternal` still carries the +Phase A8 visual-gate stopgap: `if (cullMode == CullMode.Landblock) cullMode += CullMode.None;` — "render cell polys double-sided while the architectural +cause is isolated." Every cell shell draws two-sided to this day. Retail +draws cell polygons single-sided (the drawing BSP + winding decide facing). +The "architectural cause" (winding convention vs the frame-global CW +front-face) was never isolated; the stopgap outlived its gate. Retiring it +needs the winding audit (which side do CellStruct polys wind under our +extraction?) + a visual gate — walls/floors must not vanish. + +**Acceptance:** cell shells draw with proper backface culling, no missing +surfaces at the Holtburg + Facility Hub gates. Found during the #176/#177 +investigation (`docs/research/2026-07-06-176-177-render-pair-investigation.md`). + +**2026-07-09 triage:** investigated, verdict STILL_OPEN — the `CullMode.Landblock -> CullMode.None` double-sided stopgap is still present verbatim at `EnvCellRenderer.cs:1394-1399` with no follow-up commit or roadmap reference retiring it. + +--- + +## #177 — Dungeon stairs pop in/out across levels (invisible until entering the room; last step vanishes running down) + +**🅿️ PARKED 2026-07-07** (user decision, after retail cdb disproved the portal-flood theory — +see session-3b below). NOT a blocker (cosmetic indoor pop). Ruled out with evidence: lighting, +membership, camera coherence, the collision sweep, the `0178/0182/0183` handoff cells, edge-on +eye-in-opening (fix#1 shipped→gate-failed→REVERTED), and the portal flood itself (retail's flood +collapses identically). **Freshest un-chased lead:** the steps are STATIC objects (GfxObj +`0x010000DE` ×6/cell) drawn via the separate viewcone cull, NOT cell shell — probe acdream's +step-static draw vs retail's. Characterization pins + the reusable retail-cdb capture toolchain +(`tools/cdb/pview-spiral2.cdb`, eye + `cell_draw_list` dump, clean top-level `qd` detach) are +committed. Resume from the session-3b block. + +**⚠️ UPDATE 2026-07-07 (session 3b) — cdb-traced RETAIL; the PORTAL-FLOOD theory is +DISPROVEN by retail's own ground truth.** Attached cdb to live retail (PDB MATCH), +broke on `PView::DrawCells` (0x005a4840), dumped `cell_draw_num` + `cell_draw_list` cell +ids (`.data[i]->m_DID.id`) + the eye (`Render::FrameCurrent->viewer.viewpoint`) while the +user descended the spiral (`retail-spiral2.log`, 767 samples). **Retail's flood is dynamic +and IDENTICAL in character to ours** — from the spiral cells it swings `num` 3→27 with gaze +and COLLAPSES to 3 cells at many poses (e.g. cam=015d eye(60.05,-28.51,-3.66) → just +{015d 015e 015f}; cam=014b → {014b 014c 014a}). Our flood does the same (3→43, headless +`FloodDepthFrom015E_VsRetail26` = max 43 vs retail 26). So retail does NOT keep the spiral +where we drop it — the flood is EXONERATED as the cause. **The vanish must be DOWNSTREAM of +the flood** (unexplored): the steps in these spiral cells are STATIC objects (GfxObj +`0x010000DE` ×6/cell), drawn via the separate viewcone cull (`ViewconeCuller.SphereVisibleInCell` +/ `DrawCellObjectLists`), NOT the cell shell — acdream may cull those step statics where +retail doesn't. OR a per-pose clip difference at the exact descending gaze (would need +retail's gaze — not yet captured — to confirm, but the matching num RANGES argue against it). +cdb watchout CONFIRMED THE HARD WAY: `qd` in a CONDITIONAL bp action does NOT fire (stuck +cdb → had to kill it → took retail down). Reliable detach = bp action falls through to BREAK +after N (no gc), then top-level `qd` (`tools/cdb/pview-spiral2.cdb`). NEXT: probe acdream's +step-static (0x010000DE) draw/viewcone in the spiral vs the cell shell. + +**⚠️ UPDATE 2026-07-07 (session 3) — fix#1 (edge-on eye-in-opening rescue) FAILED the +visual gate + REVERTED; [flood-collapse framing superseded by 3b — retail's flood collapses +the same way, so the flood is not the differentiator]. The mechanism is a GRAZING/SLIVER +FLOOD COLLAPSE in the tight SPIRAL staircase, NOT the edge-on-in-plane case.** Live [stair-clip]+[flap] capture +(`launch-177-stairclip.log`, PROBE_FLAP): the user's staircase is the `0x8A02` SPIRAL +`01C0→01C1→…→01C8→0210→…` (cells stacked z 0..6, joined by floor/ceiling portals + turning +via alternating ±Y wall portals; the recurring `0x010000DE`×6 statics are the steps). At the +vanish, root=`01C8`, vis collapses **12→3**: the DOWN floor-portal `→0210` goes OFF-SCREEN +(`clip=0`, D=3.75 — NOT edge-on) and the wall portals `→01C4/01C9` project to SLIVERS +(`clip=3`), so the flood barely spreads and 9 cells (the spiral) drop. Turning slightly +re-admits (portals swing on-screen); zoom-out gives a top-down shaft view (aligned floor +portals) → floods down → visible. **The camera is NOT collision-jammed** — `[flap-sweep]` +`pulledIn=0.00` across all 103k frames, full boom, `collNormValid=False` — so it is purely +the flood/clip, from a NATURAL chase pose. This is the #119/#181 grazing/sliver-clip class. +**The retail contradiction (hit 3×):** retail draws only the flood (`PView::DrawCells` +`cell_draw_list`) and `polyClipFinish` also rejects <3-vert slivers — so retail's flood +*should* collapse the same way, yet the user's retail shows the spiral. Something about +retail's viewpoint or flood in a spiral differs in a way NOT derivable from static analysis. +**NEXT: cdb-trace retail descending this spiral** (capture `PView::ConstructView` → +`cell_draw_list` contents + `Render::FrameCurrent->viewer.viewpoint`) to see how retail keeps +the spiral flooded — the CLAUDE.md tool for "guessing failed twice." Characterization pins + +the [stair-clip] probe (reverted from the shipped path) live in +`Issue177StairDescentCameraFloodTests`. DO-NOT-RETRY: the edge-on eye-in-opening rescue +(fix#1) — the vanish D is never near 0; a camera-press fix — the sweep is never pulled in. + +**⚠️ UPDATE 2026-07-06 (session 2) — [superseded by session 3; the edge-on sub-case below +is real but is NOT the production vanish]. ROOT CAUSE RE-DIAGNOSED with production-faithful +evidence; the two prior attributions below (lighting; then "flood-admission miss at +0178/0182/0183") are BOTH SUPERSEDED.** Findings, all evidence-backed (headless real-camera +harness `Issue177StairDescentCameraFloodTests` + production `[flap]/[flap-cam]/[vis]/[cell-transit]` +capture `launch-177-flapcell2.log`): +- **NOT membership, NOT camera coherence, NOT the collision sweep.** Across the whole + capture: `eyeInRoot=Y` on every frame (0 anomalies), the camera sweep never failed + (0 failures). The render root always contains the eye. My headless harness driving the + REAL chase camera + REAL sweep down the stairs = `collapses=0, incoherentFrames=0`. +- **The real staircase the user tests is `0x8A02015E/015F/01C1`** (stacked vertically, + joined by **floor/ceiling portals** N=(0,0,±1), 6–7 statics each) — NOT `0178/0182/0183` + (those have no statics, no floor portals). The handoff mis-identified the staircase. +- **The steps are cell SHELL geometry** (drawn whole/unconditionally when the cell is + admitted), so the vanish ⇒ the cell drops from the flood. +- **MECHANISM: you can flood DOWN a staircase but not UP it.** `[vis]` sets: root `01C1` + (top) ⊇ {015F,015E}; root `015F` drops `01C1`; root `015E` drops both `015F` AND `01C1`. + The up-cell dies at the **CLIP, never the side test** (root `015F`→`01C1`: CULL=0, + edge-on clip≤0 = 1508/1782). The chase-camera eye on a staircase sits at/near the cell + boundary = the floor/ceiling portal PLANE (local eye-z ≈ 6.0 = the ceiling, `D≈0`), + so the vertical portal projects EDGE-ON (collinear, <3 verts) → `ClipPortalAgainstView` + rejects it → the stacked cell above never floods in → the whole staircase above the + camera vanishes. Descending puts the camera below the stairs (vanish); looking back + from the lower cell (vanish); zoom-out lifts the camera to a higher root that floods + DOWN (floor portals admit) → visible. It's the #119/#181 edge-on-clip class, on VERTICAL + (floor/ceiling) portals viewed from a boundary-height eye. +- **Retail complication (why the fix is NOT a naive clip relax):** `PView::DrawCells` + (0x005a4840) draws `cell_draw_list` (the portal flood), and `polyClipFinish` ALSO + rejects <3 survivors (docs/research/2026-06-11-polyclipfinish-w0-clip-pseudocode.md + lines 39,59). So retail's flood would drop an edge-on portal too — meaning retail's + eye must NOT sit edge-on with floor/ceiling portals (leading hypothesis: retail's flood + viewpoint is mid-cell / the player-eye at ~1.7 m above the floor, never in a floor + portal's plane; our chase-cam eye rides up to the ceiling portal). NEXT: confirm retail's + stair-camera eye height (cdb) OR the flood-seed viewpoint, then fix retail-faithfully + (camera-side keep-eye-off-portal-planes vs a narrow boundary-eye flood rule). DO NOT + relax `ClipToRegion`'s <3 gate (diverges from retail + risks #119/#181). + +**⚠️ UPDATE 2026-07-06 (visual gate) — this is NOT lighting.** [SUPERSEDED by session-2 +block above.] The A7 visible-cell +light-scoping fix shipped + was probe-validated, but the user's gate showed the stairs +STILL not visible looking back from the corridor (zoom-out changes the last-step case). +Eye-position/flood behavior ⇒ a portal-VISIBILITY miss at the stair cells +(0178/0182/0183), NOT the "its LIGHTS went dark" attribution recorded below. Re-diagnose +as visibility. See the render digest banner. + +**Status:** OPEN +**Severity:** MEDIUM (visible geometry churn in the M1.5 dungeon) +**Filed:** 2026-07-06 +**Component:** render — indoor portal-flood visibility (dungeon multi-level) + +**Description (user, Facility Hub, 2026-07-06 gate session):** a staircase +connecting two levels (a) disappears on roughly the last step when running +DOWN it, (b) is not visible when looking into the stair room from the +corridor, and (c) pops into existence on entering the room. Classic +portal-visibility miss: the stair geometry's cell is not reached by the +portal flood from the viewer's cell until the viewer crosses into it. + +**Status:** OPEN — root cause CONFIRMED; fix DEFERRED to the A7 +dungeon-lighting arc (the cap-raise fix was live-tested and REVERTED, +see below). +**Root cause (confirmed via the probe launches):** the geometry never +vanishes — its LIGHTS do. `BuildPointLightSnapshot` keeps only the +`MaxGlobalLights=128` point lights nearest THE CAMERA; the Facility Hub +registers 366 fixtures, so 238 are evicted per frame by camera distance. +A room whose torches all rank past the cap renders at bare 0.2 ambient +(near-black in a dungeon = "not visible"); approaching re-admits them +("pops into existence"); the eviction boundary sweeping with the camera +drops the ramp's lights mid-descent ("disappears on the last step"). +Retail's `minimize_object_lighting` (0x0054d480) has no global +camera-nearest cap. +**Why the fix is deferred:** raising the cap to 1024 (commit `4d25e04d`) +made the pops stop but exposed three unported retail lighting semantics +that DOMINATE the frame with the full pool active: (a) lights reach +through solid floors/walls — retail registers lights per-CELL +(`insert_light` 0x0054d1b0) so the under-room portal light never touches +the corridor above; our flat sphere-overlap has no reach notion; (b) +stationary weenie fixtures ride the DYNAMIC 1/d falloff (~9× retail's +static 1/d³ at 3 m — the #143 isDynamic misassignment for ACE-served +fixtures); (c) an unexplained striped z-fight-like artifact on lit floor +regions (user screenshot). Reverted to 128 (`AP-85` documents the +stopgap; the desired-end-state pin is Skip'd in LightManagerTests). +**A7 fix shape:** per-cell light registration (insert_light port) + +static curve for stationary fixtures + the stripe hunt, THEN uncap. +Full investigation ledger: +`docs/research/2026-07-06-176-177-render-pair-investigation.md`. + +**Acceptance:** the staircase renders whenever its room is visible through +the connecting opening, and stays rendered through the full descent. + +--- + +## #176 — Purple flashing on dungeon floors at cell seams, camera-angle dependent + +**🟡 FIX SHIPPED 2026-07-06 (pending user visual gate) — the flicker was the LIGHT POOL +tracking the CAMERA, not a draw z-fight.** The z-fight framing was refuted by the in-engine +`[seam-*]` probe (RenderDoc is infeasible on this pipeline — it hides +`GL_ARB_bindless_texture` and our mandatory-modern startup gate throws; AMD GPU rules out +Nsight): exactly ONE shell instance per seam cell at the lifted z (−5.98), NO +floor-coincident entity (portal entities sit at z=−12.05, six meters down), ZERO portal +depth fans (sealed dungeon). What the probe DID catch: the corridor floor's applied light +set flipping wholesale with flood composition. Root cause (named-decomp-verified): the +`c500912b` scoping port glossed retail's `CEnvCell::visible_cell_table` as "the portal-flood +visible set" — it is the **RESIDENT-cell registry** (`add_visible_cell` 0x0052de40 +dat-loads absent cells; populated from each activated cell + its dat visible-cell list; +gaze can never remove entries), and `Render::insert_light` (0x0054d1b0) caps the pool +nearest **`Render::player_pos`**, not the camera. Our flood-scoped pool dropped/admitted +the six intensity-100 under-room portal purples as the camera turn changed the flood +(probe: flood churned 8→41 cells over a full turn) → the wedge blinked. **Fix:** +`BuildPointLightSnapshot(playerWorldPos)` — resident collection (all registered lit +lights), dynamics-first player-nearest cap; the `RebuildScopedLights` callback deleted. +Verified live: full-circle turn sweep, flood churning 8→41, the floor's set held the SAME +8 identities on every post-spawn frame. Pins: `PointSnapshot_HubScale…CameraInvariant` (rewritten), +`PointSnapshot_OverCap_DynamicsNeverEvictedByNearerStatics`, `PointSnapshot_ResidentCollection_CellTagDoesNotFilter`. +Register AP-85 rewritten; correction banner in +`docs/research/2026-07-06-a7-per-cell-lighting-pseudocode.md`. Residual parity note for the +gate: our single 128 pool admits 7 purples + viewer (8 dynamics, all 8 slots) where retail's +7-dynamic/40-static dual pool showed 4 purples + viewer + fixture slots — if the wedge reads +"too purple," the A7-arc dual-pool cap is the faithful trim. `[seam-*]` probes stay until the +gate passes, then strip. + +**Gate:** stand in the `0x8A020164` corridor, turn back-and-forth across the seam — the +purple wedge must hold steady (its faceted SHAPE is retail-correct and stays). + +**⚠️ GATE 2026-07-06 (evening): FAILED on a RESIDUAL that turned out to be a +SEPARATE mechanism — flickering stripe/triangle patterns when the camera is +pushed into walls/openings. Isolation toggles killed every render suspect +(texture via `ACDREAM_LIGHT_DEBUG=3`, shell clip trim via `ACDREAM_CLIP_DEBUG=1`, +coplanar dat pairs, double-draws, seals); the artifact is the CAMERA-COLLISION +sweep strobing the eye 0.27 m per few frames at a compressed boom → tear- +interleaved views = stripes. Split to #180 (camera/physics). The lighting half +of #176 (the pool tracking the camera via flood scoping) remains FIXED and +live-verified; re-gate #176 after #180 lands. Also filed from this arc: the +site-A weenie light-registration LEAK (a portal's I100 light stacked ×2→×4 +over one session as CreateObject re-sends re-registered it under fresh +entity ids — `[seam-ent]` L= showed `01D4:I100` four times) — fold into the +A7 arc or fix with #180's gate.** + +**Status:** 🟡 lighting fix SHIPPED + verified; #180 (camera strobe) BOTH halves +FIXED + log-verified 2026-07-06 (`48aaab81` + `f10fe4e9`); the site-A static +light-stacking re-apply hole CLOSED (`87cddce2` — idempotent re-registration; +whether it fully accounts for the observed `[seam-ent]` ×2→×4 growth needs a +probe re-run, the live weenie path's guid-dedup reads sealed). **The residual +user-visible flicker survives all of these at a parked camera and is now +#181** — the portal-flood vis 31↔32 flap on micron eye noise driving +visibility-scoped lights + the AABB scissor rect. Re-gate #176 after #181. +**Severity:** MEDIUM (visible artifact along every corridor seam in the M1.5 dungeon) +**Filed:** 2026-07-06 +**Component:** render — floor-portal polygons / portal surface state + +**Description (user, Facility Hub, 2026-07-06 gate sessions):** the floor +flashes with a purple overlay at cell seams, at certain camera angles only. +Initially suspected to be the #137 physics oscillation exposed by the +render; the physics fix landed (seam shake gone, user-gated) and the flash +REMAINS — so it is a render-side issue in its own right, correlated with +camera angle. + +**Status:** OPEN — root cause CONFIRMED; fix DEFERRED to the A7 +dungeon-lighting arc (see #177 for the revert story — same mechanism, +same deferral). +**Root cause (confirmed via the probe launches):** per-cell LIGHTING pops, +not a draw failure. The probe run reproduced the flash while the ambient +branch ([light] — stable 0.2 grey) and the portal flood ([pv-input] — +zero drops in 54k frames) were provably healthy, which eliminated the +last CPU-side theories and left the one channel the probes cannot see: +per-cell 8-light SET COMPOSITION. The camera-capped snapshot (128 of the +Hub's 366 fixtures, nearest-to-camera) evicts in-range lights of visible +cells; the flipping unit is a CELL, so the discontinuities sit at exactly +cell-seam granularity, swing with the camera position (the chase boom), +and the dominant flipping light is the under-room PORTALS' purple — +hence purple flashes on the floor. Twelve other mechanisms were refuted +first — ledger in +`docs/research/2026-07-06-176-177-render-pair-investigation.md`. +**Deferral:** the uncapped pool (live-tested `4d25e04d`, reverted) +stabilizes the pops but floods rooms with through-floor portal light +(no per-cell reach semantics), over-strong dynamic-curve fixture light, +and a striped floor artifact — the A7 arc owns the real fix (per-cell +`insert_light` registration + static fixture curve + stripe hunt, then +uncap). Register row AP-85. + +**Acceptance:** no purple/placeholder flashes on dungeon floors from any +camera angle at the corridor seams. + +--- + +## #175 — Door collision registers the Setup PLACEMENT pose, not the motion-table CLOSED pose (phantom slab behind the visual door) + +**Status:** 🟡 FIX SHIPPED 2026-07-05 (same session) — pending user gate (Facility Hub double door: closed blocks AT the visual panels from both sides, no embed, no phantom wall; Holtburg cottage door unregressed). +**FIX:** `ShadowShapeBuilder.FromSetup` gains a `partPoseOverride` (BSP part +shapes only; CylSphere/Sphere unchanged); `RegisterServerEntityCollision` +derives it via `GameWindow.MotionTableDefaultPose` — the wire MotionTableId's +default style, first cycle, LowFrame part frames (the closed/idle pose retail's +live CPhysicsPart holds). Null / short poses fall back per-part to placement +frames (table-less entities + landblock statics unchanged). Register row +AP-84 (one-shot registration snapshot vs retail's per-frame live pose — +equivalent for the door lifecycle since open = ETHEREAL). Pins: the three +`FromSetup_*` tests in `Issue175HubDoorPoseInspectionTests`. +**Severity:** MEDIUM-HIGH (embed into doors from one side; phantom wall on the other — can push the player out of use radius) +**Filed:** 2026-07-05 +**Component:** physics — server-entity collision registration (door part poses) + +**Description (user, Facility Hub door guid 0x78A020C7 / Setup 0x02000C9D):** +running at the door embeds the player INTO the visual panel (deep enough to +camera-clip to the other side); the actual blocking plane sits displaced to +the FAR side, and approaching from that side there's a phantom wall in front +of the visual door — far enough that the door can be out of use range. + +**Mechanism (dat-confirmed, 2026-07-05):** the hub door is a DOUBLE door — +Setup 0x02000C9D has 3 parts; panels part[0]/part[1] (GfxObj 0x01002936, +physics slab 1.66×0.29×2.95 m) pose in the Setup's `Default` PLACEMENT +frames at yaw **−150° / −30°** with origin **(±0.88, −0.44, 1.37)** — an +AJAR pose displaced 0.44 m behind the doorway plane. The RENDERED door poses +its panels from the motion table's default (closed) state via the sequencer +(the setup itself has no DefaultMotionTable; the wire spawn supplies it). +Collision registers via `ShadowShapeBuilder.FromSetup`, which reads the +PLACEMENT frames (`Resting|Default|first`) — so the physical slabs sit at +the ajar placement pose while the visuals show closed panels: the exact +offset the user walked into. Retail tests each part's LIVE pose +(`CPhysicsPart` — see the #150 notes: for a CLOSED door the live pose IS +the motion-table closed pose; the open swing never matters because ETHEREAL +bypasses collision entirely). + +**Fix shape (retail-faithful, next session):** the BSP shadow shapes for +server entities with a sequencer must use the SEQUENCER's part transforms +(the motion-table default/closed pose) instead of the raw placement frames — +either sample at registration (the sequencer exists by then — verify spawn +wiring order) or re-register via `ShadowObjectRegistry.UpdatePosition`-style +refresh after the sequencer's first advance. Parts without animation data +keep the placement-frame fallback. Watch: entScale composition, multi-part +dedup ([[feedback_dedup_keys_after_cardinality_change]]), and the Holtburg +single-door apparatus must stay green (its placement pose ≈ closed pose, +which is why #99/#150 never surfaced this). + +**Files:** `src/AcDream.Core/Physics/ShadowShapeBuilder.cs` (placement-frame +read), `src/AcDream.App/Rendering/GameWindow.cs` +(`RegisterServerEntityCollision` ~4130), inspection +`tests/AcDream.Core.Tests/Physics/Issue175HubDoorPoseInspectionTests.cs`. + +**Acceptance:** at the Facility Hub double door: closed door blocks AT the +visual panels (no embed, no phantom wall on either side); open door fully +passable; use radius reachable from both sides. Holtburg cottage door +unregressed (door apparatus green). + +--- + +## #174 — Door Use dies after the first jump: the RemoveLinkAnimations seam stripped animations without retail's queue drain + +**Status:** 🟡 FIX SHIPPED 2026-07-05 (same session) — pending user gate (jump around, then use the Facility Hub door from close AND from ~3 m). +**FIX:** the `MotionInterpreter.RemoveLinkAnimations` seam is retail +`CPhysicsObj::RemoveLinkAnimations` 0x0050fe20 — a tailcall to +`CPartArray::HandleEnterWorld` 0x00517d70 → `MotionTableManager:: +HandleEnterWorld` 0x0051bdd0: strip the sequence's link animations AND drain +`pending_animations` completely (each pop relays MotionDone → the interp pops +its `pending_motions` node in lockstep). acdream bound the seam to the BARE +sequence strip (`RemoveAllLinkAnimations`), so every jump's LeaveGround +removed the animations that queued manager nodes were counting down on — +orphaning them and permanently damming BOTH queues; `MotionsPending()` then +starved every armed moveto (the far-range walk-to-door and the close-range +use turn — both door faces below). Rebound at both production sites +(GameWindow remote bindings + the player's EnterPlayerModeNow block) to +`Manager.HandleEnterWorld()`; harness mirrors updated; pins +`Issue174LinkStripDrainTests` (seam drains both queues; new motions queue + +complete after). The `UseDone` (0x01C7) display gap stays open below. +**Severity:** HIGH (can't open doors reliably → blocks the #137 door acceptance + normal play) +**Filed:** 2026-07-05 +**Component:** interaction — B.4b Use pipeline / AP-23 speculative moveto deferral (R5-V5 facade) + +**Description (user, Facility Hub 0x8A02, door guid 0x78A020C7 Setup 0x02000C9D +useRadius=0.50):** double-clicking / R-using the door does nothing. The same +door opens fine from the retail client on the same ACE, and acdream renders +the observed swing correctly (inbound path healthy). + +**Evidence (3 wire captures + app log, 2026-07-05):** +1. First attempt (log): `use-deferred seq=624` fired (the close-range + deferral COMPLETED once — arrival callback ran), then 625 + 642–647 sent + far-range. Door never opened. ACE's replies to those weren't captured. +2. Retail control (capture `door-use3.pcapng`): retail sent + `[0xF7B1][seq][0x36][guid]` ×5 — ACE responded EVERY time with door + `0xF74C` UpdateMotion + `0xF74B` SetState (ETHEREAL toggling 0x1001C ↔ + 0x10018), broadcast to BOTH clients. Message format identical to ours. +3. acdream re-try (capture `door-use4.pcapng` + log): 2× DoubleClick + 4× R + — picks land, but ZERO `[B.4b] use` lines and ZERO door-guid packets on + the wire. The Use is swallowed CLIENT-SIDE before the send. + +**Mechanism (code trace):** `SendUse` close-range branch (≤2 m by the AP-23 +bucket — this door's flags → 2.0 m, overriding its real 0.5 m) parks the +action in `_pendingPostArrivalAction` and fires it ONLY from +`MoveToComplete(WeenieError.None)` (natural completion of the speculative +TurnToObject installed through the R5-V5 facade). A cancel (user input) or a +never-starting turn silently eats the use — no toast, no log (the deferral +prints are probe-gated). Candidates for "never completes": (a) the +`BeginTurnToHeading` `MotionsPending()` early-return starving the turn (the +#170 class, local-player edition — the log shows a steady +`MOTIONDONE pending=True` stream); (b) every attempt instantly cancelled by +concurrent user movement input (retail-faithful per-attempt, but the user +also clicked while standing still). Also noted: `GameEventType.UseDone` +(0x01C7) is parsed nowhere (not registered in `GameEventWiring`) — ACE +rejection reasons are invisible; and the first attempt's 7 sent uses never +opened the door either (suspect: concurrent outbound movement cancelling +ACE's MoveToChain server-side — unproven, replies not captured). + +**Files:** `src/AcDream.App/Rendering/GameWindow.cs` (`SendUse` ~12607, +`OnAutoWalkArrivedSendDeferredAction` ~12761, `InstallSpeculativeTurnToTarget` +~12842, `MoveToFactory` callback wiring ~13530); +`src/AcDream.Core/Physics/Motion/MoveToManager.cs` (`BeginNextNode` / +`BeginTurnToHeading` gates). Captures in the session scratchpad +(`door-use3.pcapng`, `door-use4.pcapng`). + +**ROOT MECHANISM FOUND (2026-07-05 evening, probe round `launch-174-autowalk.log`): +the local player's pending-motion queue drains at ~1 node/sec and backs up +minutes deep during active play — MotionsPending() then starves every +manager-driven movement.** Chain, all evidence in the log: +1. Fresh session, standing at the door: every Use completes same-tick + (`[autowalk-end] err=None` ×6, seqs 11–16 sent, door opens — "now it + works??"). Queue shallow ⇒ pipeline healthy. +2. After the jump/run sequence: the LAST player `pending=False` completion + is at the first `MovementJump Press` (log line 371); from there to the + end (line 939) every player MOTIONDONE reports `pending=True` — INCLUDING + at rest, with old jump-family motions (0x6500000D/0F) still completing + minutes later. That is a slow-draining BACKLOG, not one immortal node. +3. With MotionsPending() true, `BeginTurnToHeading`/`BeginMoveForward` + (retail 0x00529b90 `if (motions_pending) return`) never start: + - far range (wire-proven, seqs 98–101): Use SENT, ACE replies mt-6 + MoveToObject (objDist=0.50 — ACE is healthy), `[autowalk-begin] + mt=0x06` arms, body NEVER walks ([autowalk-up] position frozen) → ACE + waits forever → door never opens. Same as the original session's + 642–647. + - close range (round-3 silence): TurnToObject armed, never completes → + `_pendingPostArrivalAction` never fires → use eaten with zero feedback. +4. Retail contrast: the #170 live cdb drain trace showed retail's queue + stays SHALLOW (add_to_queue == MotionDone, drained same-tick); our + `CheckForCompletedMotions` completes ~one node per animation cycle, so + adds outpace drains during any active play. This is the #170 + pending_motions-flood family — LOCAL-player drain-rate edition (the + remote fix `427332ac` removed the flood's feeder; the local queue's + DRAIN semantics are the divergence here). + +**Next (fix session):** oracle-first on the drain: decomp +`MotionTableManager::CheckForCompletedMotions` (0x0051bfd0) + +`AnimationDone/MotionDone` pop semantics — which queued nodes retail +completes per tick (superseded/non-playing nodes must flush immediately, +not serialize behind animations). Add a queue-dump probe (node ids + ages) +before changing anything. Then re-verify the door BOTH branches + re-check +`UseDone` (0x01C7) wiring so ACE rejections become visible. +DO NOT band-aid: no MotionsPending bypass in BeginTurnToHeading (the gate +is verbatim retail), no deferral-skipping (turn-to-face is retail). + +--- + +## #173 — Observed character jumping into a ceiling hovers at the roof until the arc decays (no collision-velocity response on remotes) + +**Status:** 🟡 FIX SHIPPED 2026-07-05 (this commit) — pending user visual gate (watch a second client jump into the 0x0007 dungeon roof; it should bounce down immediately like the local player). +**Severity:** MEDIUM (remote-motion fidelity indoors; lands visibly late) +**Filed:** 2026-07-05 +**Component:** physics — remote dead-reckoning collision response + +**Description (user, 0x0007 dungeon):** watching another character jump into +the dungeon roof, the observed char sticks to the ceiling until the jump arc +would naturally have come down — "like we are calculating the entire jump +instead of actually checking the collision" — and lands later than retail, +with the animation pinned at the roof. The LOCAL player's own jump bounces +off the roof immediately. + +**Root cause (code-confirmed):** the remote DR tick integrates the +VectorUpdate launch ballistically and DOES sweep collision +(`ResolveWithTransition`, GameWindow remote block) — the sweep pins the +POSITION at the ceiling — but the retail post-transition velocity response +(`CPhysicsObj::handle_all_collisions`, pc:282699-282715: reflect +`v −= (1+elasticity)·dot(v,n)·n`) was only ever ported for the LOCAL player +(L.3a, `PlayerMovementController` ~:940). The remote body kept its +Z launch +velocity, re-integrated it into the roof every tick, and only descended once +gravity burned the arc off. Retail runs handle_all_collisions after every +SetPositionInternal for every physics object — remotes included. + +**Fix (this commit):** mirror the local L.3a reflection block in the remote +sweep's post-resolve path (same formula, same AD-25 airborne-before-AND-after +suppression so corridor slides and landings don't reflect, same Inelastic +zero-out). Register AD-25 extended to cover both sites. + +**Files:** `src/AcDream.App/Rendering/GameWindow.cs` (remote sweep, #173 +block after `rm.Body.Position = resolveResult.Position`). + +**Acceptance:** from acdream, watch a second client jump into a dungeon +ceiling: the observed char deflects off the roof immediately and lands at +retail timing; grounded remote movement (corridor wall slides, NPC chases) +unchanged. + +--- + +## #172 — Town-network portal platform blocks instead of stepping up (CCylSphere family was never ported) + +**Status:** 🟡 FIX SHIPPED 2026-07-05 (this commit) — pending user visual gate (walk up onto the Holtburg portal platform, then the 0x0007 dungeon run). +**Severity:** HIGH (blocks dungeon access — gates the whole #137 repro) +**Filed:** 2026-07-05 +**Component:** physics — CylSphere object collision response + +**Description (user):** the Holtburg town-network portal sits on a stone +platform the player collides with instead of stepping up onto it (retail just +walks up). Entity `0xC0A9B465` = landblock stab #0x65, Setup `0x020019E3`, +one CylSphere **r=2.597 m, h=0.256 m** — a 26 cm disc, trivially steppable in +retail. Surfaced the moment #149 (`4cf6eeb`) started registering BSP-less +stab CylSpheres (before that fix the platform had NO collision at all, so the +player clipped through it — the collision *shape* was the #149 fix; the +collision *response* was never retail). + +**Root cause (probe-confirmed, `launch-137-repro.log`):** the pre-port +`CylinderCollision` was a hand-rolled approximation (AP-6): step-up gate + +radial wall-slide only. Every contact returned `Slid` with a horizontal rim +normal (`[cyl-test] … result=Slid`, `[resolve] … n=(0.99,-0.11,0.00)`) and +the player orbited the rim forever. The step-up *gate* passed (clearance +0.256 ≤ 0.6) but `DoStepUp`'s internal step-down probe could never validate a +landing ON the cylinder top — a cylinder has no polygons, and the port had no +`step_sphere_down` cap-landing (top-disc contact plane). Airborne landings on +tops (`land_on_cylinder` + the Collide-flag exact-TOI branch) were missing +too. + +**Fix (this commit):** verbatim port of the full retail `CCylSphere` family — +dispatcher `intersects_sphere` 0x0053b440, `collides_with_sphere` 0x0053a880, +`normal_of_collision` 0x0053ab50, `collide_with_point` 0x0053acb0, +`slide_sphere` 0x0053b2a0, `step_sphere_up` 0x0053b310, `land_on_cylinder` +0x0053b3d0, `step_sphere_down` 0x0053a9b0. Pseudocode + settled BN +ambiguities + two ACE-bug findings: +`docs/research/2026-07-05-ccylsphere-collision-family-pseudocode.md`. +Register: AP-6 retired, AP-83 added (PerfectClip TOI tail per ACE, dead code +in M1.5). Conformance: `CylSphereFamilyTests` (grounded step-up-onto-top on +the exact platform shape, tall-cylinder block, airborne top landing, ethereal +Layer-2 guard); the #42 self-shadow control assertion updated to the retail +observable (denied movement, not the old artifact radial push). + +**Files:** `src/AcDream.Core/Physics/TransitionTypes.cs` (`CylinderCollision` ++ `Cyl*` family), `tests/AcDream.Core.Tests/Physics/CylSphereFamilyTests.cs`. + +**Acceptance:** walk straight onto the Holtburg town-network portal platform +(no rim slide); jumping onto it also lands. Doors/torches/NPC cylinders +unregressed (suites green; #150 open-door behavior unchanged). Likely also +advances #137's door-foot half — re-check in the dungeon repro. + +--- + +## #171 — Group melee: monsters interpenetrate + facing drifts (sticky melee unbound, arrival radii = 0) + +**Status:** DONE (2026-07-04) — **user visual gate PASSED** ("Looks good, ship it") +after three slices: `5bd2b8bc` (R5-V3 sticky binding + real radii) + `7a823176` +(NPC UP-snap suppression while stuck — TS-44) + `69966950` (sticky deep-overlap +back-off sign pin — AP-82; ACE's literal decode steered INTO the target when the +overlap exceeded one tick's step; 1661-tick probe capture refuted it against the +retail oracle). `ACDREAM_PROBE_STICKY=1` stays as permanent gated diagnostics +(PhysicsDiagnostics family). (Move to Recently closed on next ISSUES tidy.) +History below. Original landing note: StickyManager/ +PositionManager (ported R5-V1) now BOUND: `StickTo`/`Unstick`/`UnstickFromObject` +seams → the host's `PositionManager` (remote + player), `AdjustOffset` composed +at the retail `UpdatePositionInternal` slot before the collision sweep, +`UseTime` (1 s lease watchdog) at the `UpdateObjectInternal` tail, real setup +cylsphere radii threaded (own via `EnsureRemoteMotionBindings`/player wiring, +target via `RouteServerMoveTo`), the SERVERVEL leg now also yields to a stuck +entity (TS-41), exit-world/teleport teardown wired (remote teleport gap filed +TS-43). TS-39 retired. Harness: 2 new sticky scenarios in +`RemoteChaseEndToEndHarnessTests` (arrive→stick→strafe-track→lease-expiry; +unstick-on-rearm→re-stick). +**Severity:** MEDIUM (visual — group combat feel vs retail) +**Filed:** 2026-07-04 (user report during the #170 visual gate: "some monsters were +partly inside other monsters while hitting me… some orientation of the monsters +are a bit off") +**Component:** remote entity, MoveTo/PositionManager, R5-V3 + +**Description:** in a pack melee, acdream attackers end up partly inside each +other with slightly stale facings vs retail on the same ACE. Two code-grounded +causes (both already-tracked R5-V3 scope), plus one server-side caveat: + +1. **Sticky melee is a no-op (register TS-39).** ACE arms every melee chase with + `Sticky|UseFinalHeading|MoveAway|FailWalk` + (`references/ACE/…/Monster_Navigation.cs:416`). Retail's sticky arrival hands + off to `PositionManager::StickTo` → `StickyManager::adjust_offset` + (0x00555430): per-tick 0.3 m edge-gap + facing tracking against the moving + target. Our `MoveToManager.BeginNextNode` invokes the `StickTo` seam — unbound + — so attackers complete-and-freeze at stale arrival poses until the next wire + re-arm. +2. **Arrival radii are zero.** ACE/retail arrive edge-to-edge + (`cylinder_distance`, own + target radii from the PartArray/setup — + `ACE PhysicsObj.MoveToObject` reads `GetRadius()/GetHeight()` from the TARGET). + acdream binds `getOwnRadius: () => 0f` (GameWindow `EnsureRemoteMotionBindings`, + the explicit R5-V3 pin) AND `RouteServerMoveTo` never sets + `MovementStruct.Radius/Height` → both radii 0 → every attacker closes ~one + body-radius deeper than retail → dogpile. +3. Caveat: ACE has no server-side monster-vs-monster avoidance — some overlap is + server-authoritative and shows on retail too. Acceptance = retail parity, not + zero overlap. + +Ruled out: the between-snap collision sweep (remotes run full +`ResolveWithTransition`; `CollisionExemption` keeps creature cylinders collidable +for non-viewer movers). + +**Approved fix (R5-V3):** port `StickyManager` + bind `PositionManager` +`StickTo`/`UnStick` seams + thread setup-derived cylsphere radii through the +MoveTo distance math. **SSOT:** `docs/research/2026-07-04-171-sticky-melee-handoff.md` ++ pickup `docs/research/2026-07-04-171-pickup-prompt.md`. + +**Acceptance:** side-by-side vs retail in a scamp pack: attackers hold separation ++ face the player while it strafes; user visual gate. + +**Gate 1 result (2026-07-04):** "in general it is better" but three residuals: +(1) monsters sometimes pushed INTO the player; (2) monsters sometimes attack +while facing the wrong way; (3) "flashing/flapping instead of gliding". All +three = ONE mechanism: the legacy NPC UP handler hard-snaps position (5678) + +orientation (5714) + velocity/cycle UNCONDITIONALLY, fighting the armed sticky +per tick (ACE's authoritative rest pose sits ~0.6 m out + lags the strafing +target's bearing; sticky pulls to 0.3 m + live facing → oscillation at UP +cadence). Retail is immune BY ARCHITECTURE: UPs flow through the +InterpolationManager into the same adjust_offset chain where sticky OVERWRITES +them while armed. **Residual fix:** suppress the NPC UP snaps while stuck +(register TS-44 — the retail chain semantics translated to the snap path) + +`ACDREAM_PROBE_STICKY=1` apparatus (`[sticky]` lifecycle/steer lines + +`[sticky-snap-skip]`, all per-guid). Awaiting gate 2. + +## #170 — Remote creature chase+attack renders wrong vs retail (glide, over-frequency, uniform attack anims) + +**Status:** DONE (2026-07-04) — **user visual gate PASSED** ("looks good, as close +to retail now as I can see"). Fixes: `427332ac` (per-frame re-dispatch flood) + +`d2ccc80e` (velocity refresh) + `1051fc83` (armed moveto always ticks UseTime — the +SERVERVEL starvation) + probe strip. Gate telemetry (launch-170-gate2.log): run +installs ≈ 1:1 with arms for every chasing creature (was 16:1), zero +armed-moveto UseTime skips, queue depth 1. (Move to Recently closed on next +ISSUES tidy.) History below. Fix #1 (`427332ac`): the per-frame +`apply_current_movement` re-dispatch flooded `pending_motions` to ~1.3M → deleted; +flood 1.3M→~1, "stuck attack" gone (user-confirmed), run installs 1→10. Fix #2 (this +session): **the "slow Ready drain" framing was WRONG** — a full-stack offline harness +(`RemoteChaseEndToEndHarnessTests`, real MoveToManager + MotionInterpreter + +AnimationSequencer + omega integration in GameWindow's exact tick order) proved the +Core drain/turn/run pipeline healthy (turn completes <1 s, run sustains, add==done). +Corrected per-guid log attribution (launch-drainq.log) showed the REAL funnel: 16 arms +→ 11 turns dispatched → **1 run install**, because the per-tick branch arbitration +routed any UP-receiving NPC to the SERVERVEL leg (`HasServerVelocity` synthesized from +position deltas) which **skips `MoveToManager.UseTime`** — the armed moveto was starved +for exactly the duration of the server-side chase (`[npc-tick] branch=SERVERVEL (skips +UseTime) mtState=MoveToObject`), legs stayed Ready while the body glided on synthesized +velocity; the manager only woke in UP-silent gaps and was interrupted by the next UM. +Retail runs `MovementManager::UseTime` UNCONDITIONALLY per tick +(`CPhysicsObj::UpdateObjectInternal` 0x005156b0 @0x00515998) and has no wire-velocity +leg-driver. FIX: an armed moveto (`MovementTypeState != Invalid`) always takes the +MOVETO leg; SERVERVEL remains only for non-moveto entities (register TS-41; drain-order +one-frame divergence also pinned + filed as TS-42). **SSOT + pickup:** +`docs/research/2026-07-04-170-creature-run-handoff.md` + +`docs/research/2026-07-04-170-pickup-prompt.md` (residual sections superseded by this +entry). SUPERSEDES the earlier MovementManager-coexistence hypothesis (`eb423fb7`, +wrong shape — but the starvation IS a coexistence bug at the tick-arbitration altitude) +and keeps the `d2ccc80e` velocity fix. #159 was a red herring here. NEXT: user visual +gate (retail side-by-side, chase a fleeing player) → then strip the #170 probes +(`s_mvtoDiag`, `s_drainDiag`, `[npc-tick]`, `UM ↳ actions`) and close. +**Severity:** MEDIUM (visual — remote combat / aggro) +**Filed:** 2026-07-03 (user retail side-by-side during the R5-V2 visual gate) +**Component:** animation, remote entity, combat + +**Description:** A monster chasing + attacking the player (aggro) renders wrong +vs the retail client running against the SAME local ACE. User side-by-side: +retail plays proper animations, positions the monster better, plays DIFFERENT +attack animations (variety), and the attack-animation FREQUENCY is correct; +acdream shows the creature "stuck in the attack animation, gliding after me." +Because retail gets the identical ACE motion stream and renders it correctly, +the divergence is CLIENT-side (acdream's UM/animation handling), **not** ACE. + +Three distinct sub-divergences: +1. **Wrong/uniform attack animations** → **#159 is DONE (`2de5a011`) but was a + RED HERRING for this creature.** The Mite Scamp's attacks are wire + `0x62/0x63/0x64` = `AttackHigh1/Med1/Low1`, which live in the ALREADY-CORRECT + low block — they were never misnumbered, and `CombatAnimationPlanner` isn't + even wired into the runtime dispatch (the live path is `AnimationCommandRouter` + → `MotionInterpreter`/`AnimationSequencer`). #159 fixed a genuine latent bug in + the late block (Offhand*/Attack4-6/Punch*) but does not touch this symptom. + The "uniform/same animation" is therefore NOT a classification-numbering bug — + it is sub-bug 2 below (the same attack replays because `pending_motions` + completes+re-queues) and/or the sequencer not selecting per-command frames. +2. **Over-frequency / stuck attack** — motion trace: ACE streams attack UMs + (`mt=0x00 cmd=0x62/0x63/0x64 spd=0.97`) on top of the `mt=0x06` chase; + acdream's `pending_motions` completes+re-queues in a tight MOTIONDONE loop + (`pending=True` spam) → over-plays. R3/R4 pending_motions/MotionDone area. +3. **Glide** — the creature's position moves (mt-6 moveto + UP dead-reckon) but + no locomotion legs play (attacks override) → smooth slide. AP-80 / #160 + dead-reckon-vs-animation family. + +**Evidence:** `ACDREAM_DUMP_MOTION` trace for guid 0x80000244 — `mt-0 stance 0x3C` +→ `mt-6 chase spd 2.03` → stream of `mt-0` attacks `0x62/63/64 spd 0.97`; +MOTIONDONE loop between `0x8000003C` (stance) and the dispatched motion. + +**NOT V2/R5:** the voyeur target-tracking correctly makes the creature chase +(the `mt-6` is proof); this is the animation/position layer. + +**Where:** `MotionInterpreter`/`AnimationSequencer` attack-motion dispatch + +`pending_motions`; `CombatAnimationPlanner` (#159); `ServerControlledLocomotion` ++ remote dead-reckoning (glide). + +**Acceptance:** side-by-side with retail — a chasing+attacking Mite Scamp shows +correct attack-animation variety, correct frequency, and steps/runs (no glide). + +**Investigation 2026-07-04 (code-grounded mechanism, HYPOTHESIS — pending live +confirmation):** traced the live remote path end-to-end. The chase (`mt-6` +MoveToObject) is owned by the entity's verbatim `MoveToManager` +(`GameWindow.RouteServerMoveTo`, ~4899) — this is what moves the legs. The +attacks arrive as SEPARATE `mt-0` InterpretedMotionState UMs and flow through +`MotionInterpreter.MoveToInterpretedState` (~4985). Two seams make the creature +glide + over-play: +1. **Every inbound UM fires the `unpack_movement` head interrupt** + (`remoteMot.Motion.InterruptCurrentMovement`, GameWindow ~4893) which is bound + to `MoveTo.CancelMoveTo(ActionCancelled)` (GameWindow ~4319). So each `mt-0` + attack UM **cancels the active chase MoveTo.** +2. `MoveToInterpretedState` → `ApplyInterpretedMovement(cancelMoveTo:true)` + installs the UM's `ForwardCommand`, which for an attack-only UM defaults to + **Ready/idle** (`ims.ForwardCommand = fullMotion`, null/0 → Ready, ~4933) → + the run cycle is replaced by idle while the body keeps its dead-reckon + translation → **glide**; the creature is repeatedly knocked idle+attack + rather than running (over-play / "stuck"). +The `ServerActionStamp` 15-bit gate (`MoveToInterpretedState` ~2845) IS faithfully +ported, so identical-stamp replays are already suppressed — the "uniform anim" is +NOT a stamp bug. This coexistence of MoveTo (chase) + interpreted-state (attack) +is **explicitly R5/MovementManager scope** (GameWindow ~4816 "LoseControlToServer +autonomy handoff is R5/MovementManager scope"). So #170 sub-bugs 2/3 are +**downstream of the incomplete MovementManager port (R5-V4), not #159 and not a +localized bug.** NEXT: (a) confirm with a labelled `ACDREAM_DUMP_MOTION=1` capture +of the Mite Scamp (exact mt-6/mt-0 interleave + what ForwardCommand + stamps the +attack UMs carry), (b) retail side-by-side — does retail keep the legs running +during attacks and re-establish the chase between swings? — then port the retail +MovementManager coexistence (R5-V4). Do NOT guess a fix in this revert-prone path. + +## #169 — Cold-spawn "hole": world doesn't load / invisible player when spawning far from Holtburg + +**Status:** DONE (`9b06a9b8`, 2026-07-03) — root confirmed live via a landblock-load +probe. **Cause:** the two-tier streamer marks every window landblock "resident" +at bootstrap (`StreamingRegion.MarkResidentFromBootstrap`) BEFORE their async +loads land. A character saved FAR from the startup center (0xA9B4 Holtburg) +triggers a login-spawn `RecenterTo` against that stale, half-loaded window; +`RecenterTo` trusts `_tierResidence`, so the old/new window overlap is never +re-enqueued — a permanent HOLE of resident-but-never-loaded landblocks (zero +`BUILD-NULL`; they're simply skipped). The player spawns in the hole → its +landblock never loads → terrain/NPCs/player never draw ("world loads behind me, +character invisible"). Probe: spawn at 0xADAF, column 0xAD loaded Y=0xA3-0xAA + +0xB0-0xC0 but MISSING Y=0xAB-0xAF; player at 0xADAF (Y=0xAF) dead in the gap. +**Fix:** a far login-spawn moves the render origin like an outdoor teleport +(which already calls `StreamingController.ForceReloadWindow` — drop stale window ++ re-bootstrap fresh at the new origin); the login-spawn recenter now flags that +rebuild (network thread → set flag → render thread consumes it before the Tick). +Verified: 0xADAF now loads (216 entities), full world draws, player recovers. +No-op for a normal Holtburg login. NOT R5 (pre-existing streaming bug). + +## #168 — Invisible player / character disappears (pending-bucket trap) + +**Status:** DONE (`315af02f`, 2026-07-03) — root confirmed live via +`ACDREAM_PROBE_ENT`. **Cause:** a persistent server-spawned entity that spawns +into a not-yet-loaded landblock is parked in `GpuWorldState._pendingByLandblock`. +`RelocateEntity` (per-frame, keeps the player homed to its current landblock so +it draws) scanned ONLY `_loaded`, so it silently no-op'd on a pending entity — +and the player fell through all recovery paths (the AddLandblock drain already +ran empty; the server-object re-hydrate excludes the player; RelocateEntity +couldn't reach pending) → stranded invisible. This is the mechanism behind BOTH +"cold-spawn invisible" AND "character disappears running out of Holtburg far +enough" (both = player parked in pending, never recovered). **Fix:** +`RelocateEntity` now removes the entity from whichever bucket it occupies +(`_loaded` OR `_pendingByLandblock`) then re-appends to its current landblock — +promoting a stranded pending entity to drawn as soon as its landblock loads. +Test: `GpuWorldStateTests.RelocateEntity_StrandedInPending_MovesToLoadedTarget` +(red→green). Composes with #169. NOT R5-V2 (verified read-only re: pos/streaming). + +## #167 — ConstraintManager leash unported (arming + two unknown x87 constants) + +**Status:** OPEN (deferred, filed 2026-07-03 during R5-V1) +**Severity:** LOW (server-position rubber-band + jump-during-rubber-band gate) +**Component:** physics, constraint + +**Description:** R5-V1 ported `ConstraintManager` (the server-position +rubber-band leash) as a Core class for structural completeness of +`PositionManager`, but it is never ARMED in acdream. Retail arms the leash +ONLY from `SmartBox::HandleReceivedPosition` (0x00453fd0) — on every inbound +server position packet, anchoring the mover to self (remotes) or the received +position (player) — with a start/max distance band from +`CPhysicsObj::GetStartConstraintDistance` (0x0050ebc0) and +`GetMaxConstraintDistance` (0x0050ec10). acdream's position reconciliation is +not `SmartBox`, so nothing calls `PositionManager.ConstrainTo`, and +`IsFullyConstrained` stays false (= register **TS-35**'s current stub +behavior — jump never blocked by the leash). + +**Blockers:** (1) the two distance constants are **x87 float returns BN +elided** — `GetStart/MaxConstraintDistance` decompile to a bare +`this->m_position;` expression with the actual returned value lost to the +FPU-return-elision artifact. Recovering them needs a live cdb read of `st0` +after the call (retail debugger toolchain) or a Ghidra re-decompile with a +corrected float-return signature. (2) The arming site (`SmartBox`'s inbound +position-reconciliation branches A/B/C) has no acdream equivalent yet — wiring +it means teaching acdream's position path to re-anchor the leash on every +server position update, then feeding the `adjust_offset` taper into the body +integration (same chokepoint as the sticky wiring, R5-V3). + +**Where:** `src/AcDream.Core/Physics/Motion/ConstraintManager.cs` (class, +unarmed); the read gate is `PhysicsBody.IsFullyConstrained` (TS-35) via +`jump_is_allowed`. Decomp: `docs/research/2026-07-03-r5-managers/`. + +**Acceptance:** the two constants are recovered (cdb/Ghidra), acdream arms the +leash on inbound server positions, `IsFullyConstrained` fires while +rubber-banding, and a jump attempt inside the tight leash is blocked +(0x47) matching retail; TS-35 + this issue retire together. + +## #160 — Remote moveto: run animation pace vs actual movement speed mismatch + +**Status:** CLOSED (2026-07-03, `41006e79`, user-verified same session). +**Root cause:** remote interps carried NO weenie, so retail's +apply_run_to_command rate chain (`weenie ? (InqRunRate() ?: my_run_rate) +: 1.0`, raw 305062-305076) took the degenerate 1.0 branch and the wire's +MoveToRunRate (stored in MyRunRate by the mt-6/7 unpack, M13) was never +consumed — run dispatches at speed 1.0 = slow-motion legs + crawl. Fix: +`RemoteWeenie` (retail's per-object ACCWeenieObject stand-in; InqRunRate +fails → my_run_rate fallback) on every RemoteMotion interp. +**Symptom:** observing a retail player's server MoveToChain from acdream: +close-range movetos WALK correctly; at run distance the RUN cycle plays but +the body moves visibly slower than the legs (treadmilling). The legs' pace +comes from the manager's dispatch (`_DoMotion` → `apply_run_to_command` × +`MyRunRate` = the wire's mt-6 `MoveToRunRate`, observed 4.50 for a +high-skill char); the body's position is queue-chased from ACE's actual +UpdatePosition stream — evidently slower than that rate. Speed-source +disagreement: either ACE's chain moves slower than the advertised runRate, +or our dispatched cycle speed over-scales (compare: local player run pace +was correct). **Evidence to gather:** UP cadence Δpos/Δt for the mover vs +`RunAnimSpeed × dispatched speed`; check what speed ACE's MoveToChain +actually steps at (Player_Move.cs / Creature GetRunRate usage). +**Where:** GameWindow `TickRemoteMoveTo` + the L.3 M2 queue chase vs +`MotionTableDispatchSink` dispatch speed. Related: TS-33 cadence rows. + +## #165 — Remote entities penetrate walls ("swallowed a bit") before stopping + +**Status:** OPEN +**Severity:** MEDIUM (visual-only, remote view) +**Filed:** 2026-07-03 (user observation during the R2-R4 visual pass) +**Component:** physics, remote dead-reckoning + +**Description:** Observing a retail-client mover from acdream: when the +mover runs into a wall, the observed remote runs INTO the wall a bit — +"they get swallowed a bit by the wall" — instead of stopping flush at it +like the mover does on their own screen. The mover's client stops them at +the wall; ACE's UP stream reports at-the-wall positions; the acdream-side +remote body ends up partially inside the geometry. + +**Root cause / status:** Unknown — candidates, in suspicion order: +(1) dead-reckoning overshoot: between UPs the DR tick advances the body +along its velocity; if that segment's collision resolve doesn't stop at +the wall (or runs with a start position already server-snapped into +contact), the body tunnels until the next UP pulls it back; (2) the L.3 +M2 queue-chase walking toward a waypoint AT the wall with the remote's +cylinder ignoring the wall plane (check which resolve path the chase +uses and whether it carries the remote's ShadowEntry exclusions only — +#42 — or accidentally broader exclusions); (3) retail remotes collide via +the same per-cell shadow lists as the player (see +feedback_retail_per_cell_shadow_list) — verify our remote resolve +consults building/EnvCell geometry at all in the observed cells. +NOTE: capture first — ACDREAM_PROBE_RESOLVE on the remote's guid at a +wall shows whether the resolver reports Collided-but-position-inside or +never sees the wall. + +**Where:** GameWindow remote DR tick (`TickAnimations` player-remote +pipeline + queue chase), `PhysicsEngine.ResolveWithTransition` remote +callers. + +**Acceptance:** a retail mover pressed against a wall shows flush at the +wall from acdream, matching the retail-observer view side-by-side. + +## #166 — Slope-landing glide + bounce absent (retail "sled" on downhill jumps) + +**Status:** OPEN (post-R6 polish — user: "we could polish later") +**Severity:** LOW (feel/polish) +**Filed:** 2026-07-03 (user observation during the R2-R4 visual pass) +**Component:** physics, landing + +**Description:** In retail, jumping down a hill often lands with a short +glide (sled) and a bounce before settling; acdream lands clean and dead. +The user explicitly classified this as later polish — "a bit deeper +physics than this." + +**Root cause / status:** This is the REGISTER-PREDICTED composite of +three known deferred deviations: **AD-25** (landing wall-bounce velocity +reflection suppressed — its risk column literally names "slope-landing +momentum won't reproduce"), **AP-7** (`calc_friction` threshold 0.0 +without retail's 0.25-with-state-gate — sled deceleration differs), and +**TS-4** (Path-6 steep-poly slide-tangent shortcut — airborne-steep +contact chain diverges). Retiring those three rows IS this issue; do them +together against a retail cdb capture of a downhill jump (velocity + +contact-plane trace at landing). + +**Where:** `PlayerMovementController.cs:874` (AD-25 suppression), +`PhysicsBody.cs:307` (AP-7), `BSPQuery.cs:2001` (TS-4). + +**Acceptance:** side-by-side downhill jump: acdream glides/bounces like +retail; flat-ground landings unchanged; no micro-bounce death spiral +(the reason AD-25 exists) reintroduced. + +## #164 — UM action-replay dispatches drop the per-action Autonomous bit + +**Status:** DONE (2026-07-04, R5-V4) — `DispatchInterpretedMotion` now threads +the action's autonomy into the dispatch params (`Autonomous` = the 0x1000 +splice, raw 305982); the stored `InterpretedState.Actions` node carries the +real autonomy. Conformance: +`MotionInterpreterFunnelTests.Actions_ReplayCarriesAutonomyIntoTheInterpretedList`. +(Move to Recently closed on next ISSUES tidy.) Original finding below. +**Filed:** OPEN (2026-07-03, filed during #161) +**Finding:** retail's `move_to_interpreted_state` action loop sets the +dispatch params' Autonomous bit (0x1000) from each action's autonomy flag +(raw 305982: `var_28 ^= ((autonomous << 0xc) ^ var_28) & 0x1000`), which +flows into `InterpretedMotionState::AddAction`'s stored node. Our +`MoveToInterpretedState` action loop dispatches with `new +MovementParameters { Speed }` — Autonomous stays false. No observed +symptom today (stored-node autonomy has no current consumer); fix when +R5/R6 touches the action list. **Where:** +`MotionInterpreter.MoveToInterpretedState` action loop / +`DispatchInterpretedMotion` (doc comment marks the gap). + +## #159 — CombatAnimationPlanner uses 2013-decomp command numbering, not ACE/DRW + +**Status:** DONE (`2de5a011`, 2026-07-04) — the whole `CombatAnimationMotionCommands` block now derives each constant directly from `DatReaderWriter.Enums.MotionCommand` by name (`= (uint)Drw.Name`), so the values ARE the oracle by construction and can never drift again. Ground truth was taken by reflecting over the same DatReaderWriter 2.1.7 assembly the runtime binds (409 enum values). Blocks 1-2 (stances + single melee, 0x3C-0x12A) were already correct; the late block (Offhand*/Attack4-6/Punch*, 0x173-0x19A) was all +3 shifted; `Reload` was the dead 2013 value `0x100000D4` (absent from DRW) → now the real `0x40000016` SubState. New parity test `PlanFromWireCommand_LateCombatBlock_UsesAceDrwNumbering` pins 14 ACE wire values through the full wire→resolve→classify pipeline. **Caveat (relevant to #170):** `CombatAnimationPlanner` is not yet wired into the runtime — the live dispatch is `AnimationCommandRouter` → `MotionInterpreter`/`AnimationSequencer` — so this is a *latent* correctness fix. It does NOT by itself change the #170 Mite Scamp symptom, whose attacks `0x62/0x63/0x64` live in the already-correct low block. #170 sub-bugs 2 (MOTIONDONE loop) + 3 (glide) remain. +**Severity:** MEDIUM (late-combat animation classification wrong against ACE) +**Filed:** 2026-06-30 +**Component:** animation, combat + +**Description:** `CombatAnimationPlanner.CombatAnimationMotionCommands` hardcodes the late-combat command constants (the `Offhand*` / `Attack4-6` / `Punch*` block) using **2013-decomp numbering** instead of the ACE/DatReaderWriter numbering that ACE actually broadcasts and that the local DAT MotionTables use. Per the +3-ish low-word shift documented in the ACE-vs-2013 gap research, e.g. `OffhandSlashHigh` should be `0x10000173` not `0x10000170`; `AttackLow6` should be `0x1000018E` not `0x1000018B`. Against a live ACE server these specific commands will be silently misclassified (resolver returns the correct ACE value, but the planner's set contains the 2013 value, so no match). + +**Root cause / status:** Pre-existing — surfaced by the L.1b command-catalog slice (commit pending). The old blind `0x016E–0x0197` override in `MotionCommandResolver` masked the matching test (`CombatAnimationPlannerTests.MotionCommandResolver_UsesNamedRetailLateCombatCommands`) by force-mapping the same wire range to 2013-class values, so the test agreed with the planner's wrong numbering. Deleting the override (correct) exposed the mismatch. NOT a regression: for the real ACE wire value (`0x0173`), the resolver returns `0x10000173` both before and after the override deletion, so runtime behavior is unchanged — the planner was already misclassifying it. The fix is to renumber the `CombatAnimationMotionCommands` block to the ACE/DRW values (cross-check each constant against `DatReaderWriter.Enums.MotionCommand`). + +**Files:** `src/AcDream.Core/Combat/CombatAnimationPlanner.cs:268-307` (the hardcoded `CombatAnimationMotionCommands` block). + +**Research:** `docs/research/2026-06-26-ace-vs-2013-motion-command-gap.md`. + +**Acceptance:** Each late-combat constant in `CombatAnimationMotionCommands` matches its `DatReaderWriter.Enums.MotionCommand` value; a parity test asserts the ACE wire values (`0x0173 → OffhandSlashHigh`, etc.) classify correctly through `ClassifyMotionCommand`. + +--- + +## #158 — Character window — deferred polish **Status:** OPEN **Severity:** LOW @@ -207,6 +1682,8 @@ Copy this block when adding a new issue: **Files:** `src/AcDream.App/UI/Layout/CharacterStatController.cs`, `src/AcDream.App/UI/Layout/LayoutImporter.cs`. +**2026-07-09 triage:** investigated, verdict STILL_OPEN — a fix for this exact bug (`9444a328`, normalizing the panel root to (0,0) for off-screen FBO captures) exists but only on unmerged branches (`codex/mockup-stage` / `claude/peaceful-visvesvaraya-e0a196`); `StudioWindow.cs` on this branch still has no position-normalization code and the mechanism is unfixed here. + ## #155 — Outdoor terrain textures look stretched + blurry vs retail (missing landscape DETAIL-texture overlay) **Status:** OPEN — **root cause VERIFIED (oracle-first); fix attempt implemented + REVERTED** (rendered the ground black). Ready for a focused fresh implementation pass. @@ -395,6 +1872,8 @@ toggle (the window manager / `UiHost` RegisterWindow + the F12 toggle path) and on the inventory window's visibility change. Investigate the retail status-bar backpack element + its open/closed sprites when picked up. +**2026-07-09 triage:** investigated, verdict STILL_OPEN — the only inventory-toggle path is still the F12 keybind (`GameWindow.cs` `ToggleInventoryPanel`) with no status-bar button anywhere in `src/`; a status-bar-toggle implementation exists but only on an unmerged branch (`b7dc91a0` on `claude/peaceful-visvesvaraya-e0a196`), not in this branch's history. + --- ## #147 — Inventory item-grid scrolling polish @@ -408,6 +1887,8 @@ whole-row clip via `UiScrollable`) works but needs visual/UX polish — smoothne wheel step, row-clip edges. Confirm the exact symptoms with the user when picked up. Filed from the D.2b inventory visual gate. +**2026-07-09 triage:** investigated, verdict STILL_OPEN — `UiItemList.LayoutCells` still does whole-row visibility clipping and `UiScrollable.cs` is still an unanimated integer-pixel scroll model; no polish commit has landed since filing, and the roadmap/memory crib both still list it as pending. + --- ## #146 — D.2b inventory capacity-bar visual polish @@ -434,6 +1915,8 @@ against retail): See divergence register **AP-59**. +**2026-07-09 triage:** investigated, verdict STILL_OPEN — `UiItemSlot.cs` still right-anchors the bar and hardcodes bottom-up fill (`m_eDirection` unread) and `InventoryController.SetCapacityBar` still has no closed-bag lazy-load; no commit has touched this since the 2026-06-22 filing commit. + --- ## #145 — Inventory window panels occluded by the full-window backdrop (importer ignores ZLevel) @@ -455,25 +1938,6 @@ See divergence register **AP-59**. --- -## #154 — Dungeon interiors still read too dim vs retail (torch-sparse stretches + per-vertex bake) - -**Status:** OPEN -**Severity:** MEDIUM (dungeons "better but not good enough" — user, 2026-06-20) -**Filed:** 2026-06-20 -**Component:** render — indoor lighting (dungeon) - -**Description (user, 2026-06-20):** After the indoor-lighting fixes (`0d8b827`/`57c2ab7`) dungeons are much better lit than the old flat-0.2 dark, but still not good enough vs retail. The `0x0007` Town Network dungeon HAS torches (the log shows 62 orange + 57 cream `intensity=100` lights selected, plus the viewer fill + magenta portals), so torch cells light up — but torch-sparse corridors (e.g. cell `0x0149`) are lit only by the viewer fill on the 0.2 ambient, and the overall brightness still trails retail. - -**Root cause / status (candidates, UNVERIFIED — do not guess):** (a) the per-vertex Gouraud bake on low-poly dungeon walls under-lights torch cells (torches evaluated only at the few cell-struct corners — AP-35 residual); (b) the sealed-dungeon flat 0.2 ambient may be too dark vs retail; (c) retail may lean harder on the viewer light or carry more/brighter dynamics. **Approach:** side-by-side cdb capture of retail's dungeon (`world_lights` active set + `world_lights.ambient_color` + the viewer-light intensity) at the SAME spot, compared to acdream's `[light]`/`[light-detail]` there. - -**Files:** `mesh_modern.vert pointContribution` (per-vertex bake); `LightManager` (viewer light); `GameWindow.UpdateSunFromSky` (0.2 sealed ambient); `EnvCellRenderer.GetCellLightSet`. - -**Research:** memory `reference_retail_ambient_values.md` (2026-06-20 resolution note); cdb toolchain (CLAUDE.md). - -**Acceptance:** dungeon brightness/warmth matches retail side-by-side (torch cells AND torch-sparse stretches). - ---- - ## #142 — Windowed-building interiors read "like outdoors" (indoor lighting regime is per-frame, not per-stage) **Status:** DONE (2026-06-20) — `ef5049f` (per-instance sun gate) + `0d8b827`. The diagnosed cause (per-frame sun/ambient regime) was a RED HERRING: the ambient + sun were already retail-faithful. The REAL bug was a landblock-key lookup in `EnvCellRenderer.GetCellLightSet` (`cellId & 0xFFFF0000` vs the streaming key `0xXXYYFFFF`) that starved EVERY interior wall of point lights. Once fixed, interiors lit correctly (+ the retail viewer light + weenie fixture lights). User-confirmed "looks like retail now." (Move to Recently closed on next ISSUES tidy.) @@ -597,7 +2061,12 @@ See divergence register **AP-59**. ## #138 — Teleport OUT of a dungeon loads the outdoor world incompletely + position desync -**Status:** FIX SHIPPED 2026-06-21 (worktree `claude/thirsty-goldberg-51bb9b`; pending user visual gate). Server-object re-delivery root cause confirmed via ACE + holtburger cross-reference; fixed by client-side re-hydrate from the retained spawn table. Player-vanish (B) addressed by a pending-bucket rescue fix (candidate — needs visual confirm). +**Status:** ✅ ESSENTIALLY RESOLVED — position-desync FIXED via #145; server-object re-hydrate +SHIPPED (`LandblockEntityRehydrator`, AP-48); avatar-vanish (symptom B) ACTUAL root found + +FIXED + user-confirmed (`afd5f2a`, 2026-06-24 — skip the per-frame `RelocateEntity` while +`PortalSpace`). Remaining collision residuals split out to **#146** (Holtburg portal-in +building walls) + **#147** (Arwic far-town frame) — those are the live follow-ups, not #138 +itself. See the 2026-06-24 update at the bottom of this entry. **Severity:** MEDIUM (breaks the dungeon→outdoor transition; collision + visuals wrong after exit) **Filed:** 2026-06-14 **Component:** streaming — dungeon collapse↔expand (the #133/#135 collapse) + teleport-arrival @@ -650,9 +2119,13 @@ Both are the **entity-lifecycle/render path across a teleport**, NOT the streami --- -## #137 — Dungeon collision incorrect at doors and wall openings +## #137 — [DONE 2026-07-08] Dungeon collision incorrect at doors and wall openings -**Status:** OPEN +**Status:** CLOSED 2026-07-08 — user re-gate: "door collision is fixed" (clicked/passed +through multiple dungeon door types, no phantom blocks, no fall-through). Combined with +the 2026-07-06 corridor + window/opening gates already passed, all #137 COLLISION scope +is done. (The doors-open-but-don't-ANIMATE gap the same check surfaced is a SEPARATE +concern — filed as **#187**, since it's a visual/animation-dispatch issue, not collision.) **Severity:** MEDIUM (movement/collision correctness in dungeons) **Filed:** 2026-06-14 **Component:** physics — EnvCell collision (doors, portal openings, cell geometry) @@ -662,15 +2135,165 @@ walls** in particular. (Symptoms not fully characterized yet: likely walking thr openings that should block / blocking at openings that should pass, and door collision not matching the door's open/closed state.) -**Root cause / status (to investigate):** dungeon collision is EnvCell-based — the cell's -collision BSP + portal openings + per-cell static objects (doors). Candidates: door -apparatus collision in EnvCells (open/closed BSP swap) not fully ported; portal-opening -(wall gap) collision geometry handled differently from buildings; the per-cell -shadow-object registration (A6.P4, see the physics digest) for dungeon EnvCell statics. -Related families: #32 (edge-slide), #116 (slide-response), the door-collision saga -(see `feedback_dedup_keys_after_cardinality_change`, `feedback_retail_per_cell_shadow_list`). -Needs a targeted repro (which door / which opening, expected vs actual) before fixing — -oracle-first per the physics digest. +**✅ CORRIDOR GATE PASSED 2026-07-06 evening (user: "not collision anymore. +Good.")** — the corridor phantom arc (mechanisms 1–3) is user-verified +FIXED. REMAINING #137 scope from the same gate session: +- **Window/opening climb FIXED + GATE PASSED 2026-07-06 (user: "Looks + good", incl. the taller-capsule regression sweep — doorways/seams/stairs + clean): the player's collision capsule TOPPED OUT AT 1.2 m.** The callers passed + `sphereHeight: 1.2f` and `InitPath` places the head sphere center at + `height − radius` = 0.72 — the top 0.63 m of a 1.83 m character had NO + collision. The dat human Setup 0x02000001 (dumped in + `HumanSetup_CollisionSpheres_DatTruth`): spheres `(0,0,0.475) r=0.48` + + `(0,0,1.350) r=0.48` (top 1.83 = Setup.Height 1.835); retail collides + with that list verbatim (`CPhysicsObj::transition` 0x00512dc0 → + `init_sphere(GetNumSphere, GetSphere, scale)`). At the corridor-end + window alcove (0x8A020179 → 0x8A02017E: sill face 0.70 m, opening 1.3 m + tall, sloped funnel behind — full-vertex dump in + `WindowShaft_FullPolyDump`), the missing head let the step-up's + placement pass and the player climbed in head-through-lintel. Fix: both + live callers now pass 1.835 (capsule top; head center 1.355 ≈ dat + 1.350); register TS-46 documents the residual 5 mm scalar + approximation. Pins: `WindowOpening_HeadCannotFit_EntryBlocked` (walked + approach wall-slides and never enters 0x8A02017E) + + `WindowAlcove_RaisedPlacement_HeadInLintelSolid_Collides` (the raised + placement rejects on the head-vs-lintel). Captured-input replay + fixtures keep their recorded 1.2 inputs — InitPath unchanged. +- Doors half (block/pass per open state) — unchanged. +Two RENDER issues also observed at the gate (filed separately below as +#176/#177): the purple floor flashing at seams is angle/camera-dependent +(the floor IS a portal polygon to the under-room — likely the portal +surface drawn under some culling state), and a stairs pop-in/out between +levels (the #119 visibility class, dungeon edition). + +**SEAM SHAKE FIXED (same day): the stale `footCenter` in `CheckOtherCells`' +per-cell loop** — the P2 cellar-lip lesson one loop deeper. A mid-loop +other-cell query can MOVE the sphere (the boundary full-hit dispatches +step_sphere_up; the successful climb lifts the foot +0.6 mm and returns +OK), and the remaining cells were then queried with the by-value +pre-climb center — 0.4 mm inside the floor slab, grazing the under-room's +ceiling and firing the chain below. Retail's `check_other_cells` reads the +LIVE `sphere_path.global_sphere` per cell (pc:272717+). Fix: re-read +`footCenter = sp.GlobalSphere[0].Origin` per iteration. All three +`Issue137CorridorSeamReplayTests` repros un-skipped and GREEN; full suites +green. Visual gate pending. (The step 3 "restore clobbers CheckPos" wording +below was the right CLASS but the wrong site — CheckPos was fine; the +stale copy was the loop's captured parameter.) + +**GATE 2026-07-06 FAILED — THIRD MECHANISM CHARACTERIZED (the seam shake), +deterministic offline repro secured:** with mechanisms 1+2 fixed the dead +stop became a SHAKE at cell seams (+ purple floor flashing there — almost +certainly the render exposing the same per-frame position/OnWalkable +oscillation; re-check after the physics fix). Full chain, every link +probe-traced (`launch-137-seam-probes.log`, capture +`resolve-137-seam-capture.jsonl` tick 4101 ×46): +1. Corridor cells sit above under-rooms; the shared floor slab is + double-faced (up-face + underside as separate physics polys) and IS a + portal plane (e.g. 0x8A020165's ramp over 0x8A020166). The resting foot + sphere is permanently within ±0.5 mm of THREE thresholds there (poly-hit + r−ε, walkable r−ε, portal-straddle r+ε). +2. Walking across the boundary at the flat-floor height penetrates the + ramp slab by ~0.4 mm → foot full-hit on the up-face → StepSphereUp → + step-down accepts the ramp (+0.6 mm lift, CheckPos −5.999, + `[stepsphereup] stepped=True`). +3. **THE BUG: the lifted position is then LOST** — the next pass runs at + the UNLIFTED height (GlobalSphere center −5.520 vs the lifted −5.519; + the P2 stale-snapshot class, single-slot Save/RestoreCheckPos clobber + suspected — retail `CTransition::step_up` 0x0050b6cc restores ONLY on + failure) → the re-test at 0.4 mm inside the slab grazes the NEIGHBOR + under-room's CEILING (the slab underside, n≈(−0.03,0,−1)) within the + near-miss window → recorded (retail records it too — pos_hits_sphere + registers geometric hits pre-cull) → neg-poly step-up dispatch with the + DOWNWARD normal → the nested step-down finds no walkable at exact + tangency → StepUpSlide → slide_sphere(down normal vs up contact plane) + → the opposing branch → reversed-movement collision normal → Collided → + validate revert (Contact/OnWalkable stripped) → next step's AdjustOffset + zeroes → out==in every frame = the shake. Retail never enters at step 3: + its kept step-up lift leaves the sphere ON the surface, no graze. +4. Offline repro: `Issue137CorridorSeamReplayTests` (3 tests, currently + `Skip="#137 seam shake"`) reproduce the block deterministically — the + key was hydrating THREE portal rings (the under-room 0x8A020166 is + ring-3; with fewer rings the flood can't add it and everything passes). + NEXT: read our `TransitionalInsert` attempt loop against retail + 0x0050b6f0 to find the restore that clobbers the successful step-up's + position; fix; un-skip the three tests. + +**CORRIDOR PHANTOM mechanisms 1+2 FIXED 2026-07-06 (see +`docs/research/2026-07-06-137-sliding-normal-lifecycle-audit.md` +for the full audit):** mechanism 2 = BSPQuery Contact-branch stub slide +responses leaked sliding normals retail's BSP layer never writes (fixed: +real `slide_sphere` routing + success-gated body writeback). Mechanism 1 as +theorized is REFUTED: the recorded wall normal `(−1.00,0.03,−0.03)` matches +NO dat polygon (world-space sweep of both seam cells + all portal-adjacent +neighbors) — it is the SYNTHETIC negated movement direction from +`slide_sphere`'s opposing-normals branch, which our port let survive by +returning OK where retail returns COLLIDED_TS (0x0053762c; second fix). The +PortalSide polys to 0x011E were a red herring: cell 0x8A02016E has IDENTITY +rotation, the polys are ±Y planes perpendicular to the run (directionally +culled), retail's physics-BSP leaves reference them too, and the dat's +keep-PortalSide/strip-ExactMatch asymmetry reads as intentional (solid +window/grate-class portals) — NO portal-poly filter needed, no cdb session +needed for this repro. Dat-backed replay +(`Issue137CorridorSeamReplayTests`) reproduces the live frame exactly and +runs the corridor clean. The issue's DOOR half remains open. + +**CHARACTERIZED 2026-07-05 (Facility Hub corridor repro, probe + dat evidence) +— two stacked mechanisms (historical; see the 2026-07-06 resolution above):** +1. **PortalSide portal polygons are IN the physics polygon set and we treat + them as solid.** Live: running the corridor, the seam crossing + `0x8A02016E → 0x8A02017A` (x≈85.25) records a wall hit with normal + (−1,0,0) — straight against the movement (`launch-175-verify2.log:42858`). + Dat (`Issue137CorridorSeamInspectionTests`): cell 0x8A02016E's portals to + 0x011E (polys 1/3/5, flags=**PortalSide**, no ExactMatch) are PRESENT in + `CellStruct.PhysicsPolygons` — every ExactMatch portal in the same cell is + absent from the physics set. The cell's rotation maps those local ±Y portal + planes to world ±X — the phantom mid-corridor wall. Retail must honor the + portal's SIDE (pass from one side / solid from the other, or pass when the + neighbor is loaded); we collide with the raw polygon unconditionally. + **Oracle findings so far (2026-07-05 evening — greps done, question + OPEN):** `CCellStruct::UnPack` (0x00533d00) loads physics_polygons + + physics_bsp verbatim — NO portal-poly stripping at load; + `CPolygon::pos_hits_sphere`/`hits_sphere`/`polygon_hits_sphere_slow_but_sure` + (0x005394f0/0x00539540/0x00538a10) are pure geometry — no portal check; + `CCellPortal` (0x0053bab0) carries portal→CPolygon ptr + portal_side + + exact_match but nothing in the BSP test chain consults it. So retail's + passability for a PortalSide physics poly is NOT a load filter and NOT a + poly-level flag — remaining candidates: the transit/membership order + makes the sphere test the NEIGHBOR cell first (never hitting the portal + poly from the passable side), or a sidedness interaction + (stippling=NoPos + approach direction). NEXT: cdb-attach retail at this + exact corridor (0x8A02016E→011E portals) per the CLAUDE.md step −1 + protocol — the decomp alone hasn't settled it. +2. **The stale sliding normal then wedges all forward motion** (the #116 + slide-response family): after the single seam hit, EVERY subsequent + forward resolve returns `ok=False hit=no` with zero advance — the + body-persisted SlidingNormal (−1,0,0) projects the +X offset to exactly + zero in AdjustOffset, aborting at step 0 BEFORE any collision test could + update the state — an ABSORBING wedge escaped only by strafing ("push + through on the side"). Retail re-derives slide state per frame + (get_object_info pc:279992 governs only the NEXT frame — #116 notes); + audit who clears the body's sliding normal when no contact recurs. + + **MECHANISM 2 FIXED 2026-07-06 (audit complete — full lifecycle in + `docs/research/2026-07-06-137-sliding-normal-lifecycle-audit.md`):** + retail's ONLY in-transition sliding-normal writer is + `validate_transition` (0x0050ac21); the BSP/sphere layer never writes it, + and the body persistence (`SetPositionInternal` 0x005154c2/0x005154e1) + is success-only. Our BSPQuery Contact-branch full-hit responses were + STUBS (`SetSlidingNormal + return Slid`) where retail dispatches the + real `slide_sphere` — the seam hit (a SUCCESSFUL full-advance resolve, + `ok=True` in the log, not a failed one) leaked the phantom wall's normal + into the body, and the seed absorbed every later forward push. Fix: + both stub sites now route through the real + `Transition.SlideSphereInternal` (`CSphere::slide_sphere` 0x00537440, + in-frame, no sliding write) and the body writeback is gated on + transition success. Pins: `Issue137SlidingNormalLifecycleTests` (2 site + pins + the persist/absorb/clear wall lifecycle). Register: TS-4 amended + (steep-tangent sites still write the normal — documented), TS-45 added + (`SphereCollision`'s write — same class, out of blast radius). The + absorbed exactly-anti-parallel frame at a REAL wall is retail-faithful + (the persisted normal is a "still pressed" cache); only the phantom + PROVENANCE was the bug. Corridor re-test rides the mechanism-1 session. **Files:** `src/AcDream.Core/Physics/` (EnvCell collision, CellTransit, the door apparatus), `src/AcDream.Core/Physics/ShadowObjectRegistry.cs` (per-cell registration). See @@ -768,203 +2391,6 @@ neighbour load/unload churn). --- -## #134 — Player "lags downward" instead of gliding along a dungeon ramp edge - -**Status:** OPEN -**Severity:** LOW-MEDIUM (movement feel; not a hard traversal block) -**Filed:** 2026-06-14 -**Component:** physics — slope-walk / edge-slide response - -**Description:** Running up or down against a dungeon ramp's edge, the player "sort of lags -downwards" instead of gliding/sliding ALONG the ramp surface (up when running up, down when -running down). Reported in the 0x0007 Town Network dungeon ramp after #133. - -**Root cause / status:** Surfaced (not caused) by the #133 connector-cell physics -registration (`3e006d3`): the ramp connector cell's collision is now fully resident in the -physics graph, so the slope-walk / edge-slide response on it is exercised for the first time. -"Lag down" suggests the slide velocity is projected toward gravity rather than along the -contact plane (the slope tangent). Likely the retail edge-slide / slope-slide response is -incomplete — see #32 (retail edge-slide/cliff-slide/precipice-slide incomplete) and the -AP-6 / TS-1 / TS-4 slide rows in the divergence register. NO band-aid — port the retail -slide-response. - -**Files:** `src/AcDream.Core/Physics/` (slide-response in TransitionTypes / BSPQuery); ramp -cell 0x0007014D + neighbours. - -**Acceptance:** Running up a walkable ramp climbs it smoothly; running into the edge slides -along the slope (up/down per input direction), matching retail feel. - ---- - -## #133 — Teleport into a dungeon snaps the player BEFORE the dungeon landblock streams in → lands at the old landblock's frame (ocean), not the dungeon - -**Status:** OPEN — promoted to **Phase G.3** (Dungeon streaming + portal -space + `PlayerTeleport` handling), **PULLED INTO M1.5** (user decision -2026-06-13: the indoor world isn't done while dungeons are broken; full -G.3 scope chosen). Spec: `docs/superpowers/specs/2026-06-13-dungeon-support-design.md`; -G.3a plan: `docs/superpowers/plans/2026-06-13-dungeon-support-g3a.md`. -This is now an M1.5 exit-gate blocker, not deferred. - -**PROGRESS (2026-06-13 PM — G.3a core LANDED + Bug A fixed; gate exposed #95):** -the teleport-timing root cause IS fixed. G.3a shipped the `TeleportArrivalController` -hold-until-hydration (`7947d7a`/`aca4b46`/`f22121b`) + the validated-claim -landblock-prefix fix (`2ce5e5c`, "Bug A"). Live gate proof: a real `PlayerTeleport` -into the `0x0007` dungeon held through the 46 km jump and grounded the player on the -dungeon's walkable floor (`[snap] claim=0x00070143 VALIDATED -> z=0.000`) — **no -ocean.** The "terrain-less landblock" framing was refuted earlier (dat probe: dungeon -= flat-terrain LandBlock + EnvCells). REMAINING blockers, both exposed at the gate: -(1) **#95 CONFIRMED LIVE** — the dungeon renders as "thin air" because WB-DIAG blows -up to ~9.1M instances/frame at `0x0007` (see #95); (2) **possible Bug C** — per-tick -membership may still drift in the dungeon's negative-local-Y frame (ACE `movement -pre-validation failed` spam) — re-gate after Bug A to confirm. NOTE: a render-only -EnvCell hydration decouple was tried in G.3a and REVERTED (`e7058ca`) — it made the -player character invisible at Holtburg (it touched the shared building hydration -path); re-approach separately if a geometry-less collision cell ever needs it. - -**NEW GAP (2026-06-13 PM — login-INTO-a-dungeon):** logging in while the saved -character is inside a far dungeon hangs at the auto-entry hold (player frozen, -no `[snap]`/`auto-entered player mode`, movement input ignored). Root: the -streaming center is set ONCE at startup to the default (`_liveCenterX/Y = centerX/ -centerY`, `GameWindow.cs:1942` → "centered on 0xA9B4FFFF") and the login spawn never -recenters it; a dungeon spawn 46 km away never streams, so `IsSpawnCellReady(spawn -cell)` stays false and the #107 hold waits forever. The TELEPORT-arrival path -recenters (G.3a `TeleportArrivalController`); the LOGIN path does not. Fix shape = -recenter streaming onto the spawn landblock when the login spawn first arrives -(mind the #107 auto-entry hold's `SampleTerrainZ(pe.Position)` frame after the -recenter). Pre-existing; only surfaces now that the test character can be saved in -a dungeon. Workaround to unblock testing: move `+Acdream` out of the dungeon -server-side (ACE) before logging in. **FIXED 2026-06-13 (`47ae237`)** — the login -player-spawn path now recenters `_liveCenterX/Y` onto the spawn landblock (mirrors -the teleport-arrival recenter; no-op for a same-landblock Holtburg login). Verified -live: `live: login spawn — recentering streaming from (169,180) to (0,7)` → dungeon -streams → `auto-entered player mode` in the dungeon. - -**✅ DUNGEON RENDERS — M1.5 milestone (2026-06-13 PM, autonomous /loop, objectively -verified).** With Bug A (`2ce5e5c`) + login-into-dungeon (`47ae237`), a live launch -into the `0x0007` dungeon: player grounded on the dungeon floor (`[snap] claim=0x00070143 -VALIDATED z=0.000`), correct membership (cell stays `0x0007…`, ZERO ACE `failed -transition` spam), and the render budget is sane — **WB-DIAG instances ~39,000 -(meshMissing=0)** vs the 9.1M pre-Bug-A blowup (#95, now RESOLVED as a Bug-A symptom). -User-confirmed: "no errors from ACE this time." - -**✅ DUNGEON FPS FIXED + GREY BARRIER FIXED (2026-06-14, user-confirmed).** Two -separate causes, both resolved: - -- **FPS (was 14–30, now ~1000+):** AC dungeons sit adjacent in the "ocean" landblock - grid, so the 25×25 (farRadius=12) streaming window pulled ~129 neighbour dungeons + - their ~19k particle emitters / entities each frame. Fix = **collapse streaming to the - player's single dungeon landblock** when CurrCell is a sealed EnvCell (`!SeenOutside`), - with landblock-level hysteresis to stop collapse↔expand thrash. Confirmed against ACE - (`landblock.IsDungeon → return adjacents` with no neighbours): dungeons have no neighbour - landblocks, so collapsing to the one block is retail-faithful. Commits `5686050` (collapse) - + `d9e7dd6` (hysteresis) + `2561918` (pin to CurrCell's landblock, not the position-derived - one — the negative cell-local-Y made `floor(pp.Y/192)` land one block off and unload the - REAL dungeon). Divergence register: AP-36. - -- **GREY BARRIER (the "barrier above the ramp" / cellar-mouth grey):** portals-only - connector cells (ramp mouths, stair landings, cellar throats) build **0 drawable - sub-meshes**, and BOTH cell-registration gates (`BuildLoadedCell` → visibility - `_cellVisibility`, and `CacheCellStruct` → the physics cell graph) were gated on - `cellSubMeshes.Count > 0`. So a connector cell never registered → the portal flood - hit a **lookup-miss** at its opening (the un-flooded opening shows the clear/grey - colour) AND the camera eye-sweep couldn't transit through it. Fix = register EVERY - cell with a valid cellStruct for visibility + physics; only the *drawing* registration - stays gated on having sub-meshes. Commits `d90c538` (visibility) + `3e006d3` (physics - graph). The physics-graph half EXPOSED the ramp slide-response feel (now **#134**). - Three render-MATH theories (portal_side centroid, on-screen clip, near-eye projection) - were instrumented and REFUTED before the real lookup-miss cause was found — apparatus - discipline held. Render-pipeline digest updated. - -Residual (filed separately): login FPS ramp **#135**; ramp slide-response **#134**; the -A7 per-vertex lighting bake (below) is the remaining "lighting off" work. - -**✅ A7 dungeon lighting — selection fix LANDED + objectively verified (`a80061b`).** The -"lighting off" report was NOT missing torches — the `ACDREAM_PROBE_LIGHT` diagnostic -(`d6fb788`) showed the dungeon correctly gets retail's flat 0.2 indoor ambient + sun zeroed -(`UpdateSunFromSky`, `playerInsideCell` true) AND **2227 torch/point-lights register**. The -bug was the active-light SELECTION: `LightManager.Tick` dropped any light whose range didn't -reach the VIEWER (`DistSq > Range²·slack² → skip`), so a room with 2227 torches lit only the -~1 the player stood inside (`activeLights≈1`, rest at flat 0.2). Retail's D3D model picks the -8 NEAREST lights and applies the hard range-cutoff PER SURFACE in the shader -(`mesh_modern.frag: if (d < range)`). Fix = drop the viewer-range candidacy filter, take the -nearest 8. Probe after: **`activeLights` 2→8** in the dungeon (the room's 8 nearest torches now -light it). Core lighting suite green. Then `Range = Falloff × 1.5` (retail `rangeAdjust`, -`config_hardware_light` 0x0059adc, `a80061b`+) widened the pools. Ambient 0.20 is -retail-faithful (`SmartBox::SetWorldAmbientLight(0.2f)`); the 0.30 was a red herring -(`CreatureMode` paperdoll renderer, not world cells). - -**⚠️ REAL remaining cause — REVISED 2026-06-14 (the earlier "mis-read intensity" theory is -REFUTED).** `intensity=100` is the **REAL dat value** (raw-byte verified `00 00 C8 42` = 100.0f; -DatReaderWriter 2.1.7 parses it correctly; the garbage `cone` is MSVC `CD CD CD CD` -uninitialized fill Turbine baked into the dat — point lights never read it). **DO NOT `÷100`.** -The actual divergence is the **[HIGH] `no-static-light-burnin`**: retail bakes ALL of a cell's -reaching static lights **PER-VERTEX once** (`D3DPolyRender::SetStaticLightingVertexColors` -0x0059cfe0 → `calc_point_light` 0x0059c8b0, Gouraud-interpolated → uniform, never blown out via -the per-channel min-to-colour clamp), while we light **per-PIXEL with only the 8 nearest-to- -CAMERA lights** → bright pools near torches, dark between, and a crescent that slides as the -camera re-ranks the 8-slot list. Diagnosed via a 5-agent investigation + a clean Ghidra -decompile (the BN pseudo-C is x87-mangled). **LANDED:** the per-pixel `(1-dist/falloff_eff)` -shader ramp (`007e287`, necessary but NOT sufficient — it can't fix the per-vertex-vs-per-pixel -structure) + the GL-free `LightBake` Core (`3b93f91`: the verbatim `calc_point_light` port + -7 conformance tests). **REMAINING — the A7 integration:** add a per-vertex linear-RGB colour -attribute to the cell mesh + a bake driver keyed on `envCellId` (NOT the dedup `cellGeomId` — -adjacent rooms share a geom but not their torches) + consume it in `mesh_modern.frag` for cell -draws; bound the bake's light set to the player dungeon (#133's FPS collapse already does this). -Belongs to the #79/#93 indoor-lighting umbrella; outdoor static objects + building shells still -use the per-pixel-8 path (the same spottiness — separate follow-up). **NOTE — dungeon FPS is -FIXED** (was 14–30 from streaming ~129 neighbour ocean-grid dungeons; now ~1000+ fps after the -#133 streaming collapse + the allocation-free 8-light partial-select, `5872bcf`/`5686050`). -**Severity:** HIGH (any far/dungeon teleport is unusable) -**Filed:** 2026-06-13 (M1.5 dungeon-demo gate attempt — meeting-hall portal) -**Component:** physics/streaming — teleport-arrival snap vs async landblock hydration - -**Symptom (user):** used the meeting-hall portal to a dungeon; "no -dungeon, just ocean (where the dungeon is placed)." ACE spams `failed -transition for +Acdream from 0x01250126 [30 -60 6.0] to 0xA9B0000E -[-32227 -26748 5.9]` … marching south through `0xA993/0xA97F/…/0xA969` -at Z≈−0.9 (underwater) — the server keeps rejecting the client's bogus -outdoor movement. - -**Root cause (confirmed against code + the diagnostic log -`launch-dungeon-diag.log`):** ACE correctly placed the player in the -meeting-hall dungeon cell `0x01250126` (landblock `0x0125` = (1,37)). The -acdream teleport-arrival handler (`GameWindow.cs:4877-4960`) DOES recenter -the streaming origin to (1,37) (`_liveCenterX/Y`, :4910-4912), but then -**immediately** calls `_physicsEngine.Resolve(pos=(30,-60,6.005), -cell=0x01250126)` to snap the player (:4928-4931) — BEFORE the dungeon -landblock has streamed in. The physics engine still has only the OLD -Holtburg landblocks resident (A9B4 + neighbours), so `Resolve` can't find -the dungeon cell and falls back to an OUTDOOR scan against the resident -landblocks: local (30,−60) maps into A9B3 (the loaded block south of the -A9B4 spawn) → snaps to `0xA9B3000E`, terrainZ=94, indoor=False (the -`[snap]` line). The player is now at Holtburg's south edge; streaming then -shifts the frame out from under them and they slide south into ocean -(the `[cell-transit] A9B3→A9B2→…` chain mirrors ACE's failed-transition -sequence exactly). - -**Fix shape (G.3):** on a far/different-landblock teleport, recenter + -HOLD the snap until the destination dungeon landblock/cell hydrates (reuse -the #107 `IsSpawnCellReady` spawn-ready gate, applied to the teleport- -arrival path instead of only login), then place into the indoor cell via -the validated-claim path (#107/#111 `SetPositionInternal` shape). Also -audit the streaming controller actually LOADS the far dungeon landblock on -recenter (the 5×5 Chebyshev window around the new center), and that the -old landblocks unload without stranding the player mid-frame-shift. - -**Files:** `GameWindow.cs:4877-4960` (teleport arrival), -`PhysicsEngine.Resolve` (the outdoor fallback), the #107 `IsSpawnCellReady` -gate, `StreamingController` recenter. - -**Acceptance:** teleport into the meeting-hall dungeon → the player stands -in the dungeon cell, the dungeon renders (3-5 rooms), walls block, no -ocean / no ACE `failed transition` spam. - -**Apparatus:** `ACDREAM_PROBE_CELL=1` ([cell-transit]) + `ACDREAM_PROBE_VIEWER=1` -([viewer]) + `ACDREAM_WB_DIAG=1` + the always-on `[snap]`/`live: teleport` -lines capture the whole chain (`launch-dungeon-diag.log`, this session). - ---- - ## #104 — Scene VFX particles not clipped to the PView visible cell set **Status:** OPEN @@ -994,42 +2420,10 @@ pass, deliberately deferred out of the Phase W seal (which covers sky/terrain/wa **Acceptance:** A scene-particle emitter in a non-visible cell does not draw; outdoor particles (null `visibleCellIds`) unaffected; no regression on fireplace/spell VFX in the visible cell. +**2026-07-09 triage:** investigated, verdict STILL_OPEN — `ParticleEmitter` still has no `OwnerCellId` field and `ParticleRenderer.BuildDrawList` still has no `visibleCellIds` parameter; unattached scene particles (campfires, portal swirls) are drawn unconditionally every frame with only a depth test for occlusion (`GameWindow.DrawUnattachedSceneParticles`), reproducing the described wall-bleed for that class of emitter. + --- -## #103 — Phase A8.F portal-frame indoor rendering broken at runtime (visual-gate failure) - -**Status:** SUPERSEDED 2026-05-30 by **Phase U (Unified Render Pipeline)**. The -two-pipe (inside/outside) approach this bug lives in is being abandoned wholesale — -the broken `RenderInsideOut` two-pipe path is deleted as Task 1 of Phase U and -replaced by a single unified retail `PView` portal-visibility pipeline. #103 will -not be fixed in place. See -[docs/research/2026-05-30-unified-render-pipeline-decision-and-handoff.md](research/2026-05-30-unified-render-pipeline-decision-and-handoff.md). -**Severity:** MEDIUM (opt-in branch only — default game unaffected) -**Filed:** 2026-05-29 -**Component:** render (indoor visibility) - -**Description:** With `ACDREAM_A8_INDOOR_BRANCH=1`, the A8.F retail portal-frame port -renders indoor/outside-in broadly wrong: cottage/cellar interiors covered in outdoor -terrain with transparent walls; invisible walls in other houses from inside and outside. -Default game (env var off) is unaffected — `cameraInsideBuilding = a8IndoorBranchEnabled -&& inside` (GameWindow.cs:7343). The old cellar flap remains in the default path. - -**Root cause / status:** Two compounding causes (evidence in the handoff): (1) the -`OutsideView` builder under-produces — `OUTSIDEVIEW polys=0` most frames, and when -non-empty it doesn't recursively narrow (cellar shows ~full window). (2) The Task-6 -Job-A/B decoupling draws terrain UNGATED when `OutsideView` is empty (`else` branch), -flooding the cell interior over the (correctly-rendered) walls. Cell walls DO render -(`[opaque]` tris=50-108). Projection math is correct; the builder integration is fragile. - -**Files:** `src/AcDream.App/Rendering/PortalVisibilityBuilder.cs` (builder under-produces); -`src/AcDream.App/Rendering/GameWindow.cs` `RenderInsideOutAcdream` Step-4 `else` ungated-terrain (~11142). - -**Research:** [docs/research/2026-05-29-a8f-visual-gate-failure-handoff.md](research/2026-05-29-a8f-visual-gate-failure-handoff.md) (root-cause analysis, apparatus, first-fix hypothesis, pickup prompt). - -**Acceptance:** Holtburg cottage cellar renders with solid walls and no terrain flood; -terrain shows only through correctly-clipped portal openings; no invisible walls. -Related: #102 (builder dungeon-scaling fixpoint). - # Active issues --- @@ -1145,379 +2539,6 @@ currently blocked on #95 regardless). --- -## #87 — Drop WB fork patch by switching to PrepareEnvCellGeomMeshDataAsync - -**Status:** OPEN -**Severity:** MEDIUM (band-aid removal; not user-visible) -**Filed:** 2026-05-19 -**Component:** rendering, WB integration - -**Description:** Phase 2 (2026-05-19) shipped a one-line patch in our -WB fork at `references/WorldBuilder/Chorizite.OpenGLSDLBackend/Lib/ObjectMeshManager.cs:1230` -(branch `acdream` on the fork, SHA `34460c4`) to guard a blind -`TryGet(stab.Id, ...)` call against GfxObj-prefixed ids. That -patch fixes the symptom (missing floors) but is structurally a -band-aid — per CLAUDE.md's no-workarounds rule we should retire it. - -The proper fix: switch our EnvCell rendering from -`PrepareMeshDataAsync(envCellId, ...)` (general-purpose entry that -also iterates static-object parts + emitters we don't need) to WB's -narrower `PrepareEnvCellGeomMeshDataAsync(geomId, environmentId, cellStructure, surfaces)` -at [`ObjectMeshManager.cs:386`](../references/WorldBuilder/Chorizite.OpenGLSDLBackend/Lib/ObjectMeshManager.cs:386). -That function only builds the cell room mesh (floor / walls / ceiling), -which is the only piece we actually use from WB for cells — we already -hydrate static objects as separate `WorldEntity` instances in -`BuildInteriorEntitiesForStreaming`, and we run particle scripts via -our own `EntityScriptActivator` (Phase C.1.5b). - -**Root cause / status:** Misuse of WB's general-purpose API for a -geometry-only need. The general-purpose path triggers static-object -iteration that has a bug (TryGet without type check) AND that -does work we throw away. Both problems disappear if we use the -geometry-only entry point WB already exposes for exactly this purpose -(it's what WB's own `EnvCellRenderManager` uses internally). - -**Trade-offs:** - -| | Current (patched WB) | Switch to geom-only API | -|---|---|---| -| WB fork divergence | One-line patch | Zero | -| Future WB upstream merges | Conflicts | Clean | -| Performance | Slightly worse (wasted iteration) | Slightly better | -| Risk to other functionality | None (working today) | Needs re-verification | - -**Files (the change):** - -- `src/AcDream.App/Rendering/GameWindow.cs` around line 5367-5378 - (cell-entity hydration — change `MeshRefs[0].GfxObjId` from `envCellId` - to `envCellId | 0x100000000UL`, the synthetic geom id with bit 32 set). -- `src/AcDream.App/Rendering/Wb/WbMeshAdapter.cs` — add a new method - `PrepareEnvCellGeomMesh(ulong geomId, uint environmentId, ushort cellStructure, List surfaces)` - that forwards to `_meshManager.PrepareEnvCellGeomMeshDataAsync(...)`, - and call it from the streaming path instead of the bare - `IncrementRefCount(envCellId)`. -- `references/WorldBuilder/Chorizite.OpenGLSDLBackend/Lib/ObjectMeshManager.cs:1230` - — revert the type-check guard we added. The function returns to - pristine WB state. - -**Acceptance:** - -- Floors still render in Holtburg Inn (regression check vs Phase 2). -- `references/WorldBuilder` submodule pointer returns to upstream-clean - (no acdream-specific commits in the fork's `acdream` branch — or - rather, the `acdream` branch fast-forwards back to match upstream's - state for this file). -- Probe re-capture at Holtburg confirms `[indoor-upload] completed` for - all cells previously failing. -- No `[wb-error]` lines. - -**Research:** [`docs/research/2026-05-19-indoor-cell-rendering-cause.md`](research/2026-05-19-indoor-cell-rendering-cause.md) -documents the underlying WB bug. - ---- - -## Indoor walking issue cluster (2026-05-19) - -The Phase 2 indoor cell rendering fix (floor now renders inside buildings) -surfaced nine pre-existing indoor bugs the user observed at Holtburg Inn -the moment they could walk indoors. None caused by the floor fix — all -existed before but were unobservable because there was no floor to stand -on. Filed individually below; #78 + #84 + #85 + #86 likely share a root -cause (cell BSP / portal-cull plumbing), and #79 + #80 + #81 + #82 share -the indoor-lighting plumbing. - ---- - -## #78 — Outdoor geometry (stabs + terrain mesh) visible inside EnvCells - -**Status:** OPEN — **PROMOTED 2026-06-02 to the full render-pipeline redesign** (this IS the -core interior-seal bug; root cause now PROVEN). See -[docs/research/2026-06-02-render-pipeline-redesign-handoff.md](research/2026-06-02-render-pipeline-redesign-handoff.md) -+ [the redesign plan](superpowers/plans/2026-06-02-render-pipeline-redesign-plan.md). Decisive evidence -(2026-06-02 [shell]/[vis] probes): the PVS + cell shells render correctly; the failure is the SEAL + -three inconsistent gates — concretely the `WbDrawDispatcher.cs:1756` `ParentCellId==null → return true` -bypass draws outdoor scenery indoors, and the indoor render draws the outdoor world then gates it -instead of running ONLY `DrawInside` (retail: visibility IS the cull). Fix = redesign Phase R1→R3. -**Severity:** HIGH (immediate visual jank; broadened scope per 2026-05-25 PM finding) -**Filed:** 2026-05-19 (broadened 2026-05-25; promoted to redesign 2026-06-02) -**Component:** rendering, visibility - -**Description:** Standing inside Holtburg Inn looking at the floor or -walls, the user sees other buildings in the distance at their correct -world position + scale — but visible THROUGH the floor and walls. As if -the cell mesh is rendered but doesn't occlude or stencil-cull what's -behind it. - -**Additional evidence (2026-05-25 PM, post-#100 visual verification):** -After issue #100 shipped (commits `f48c74a`, `a64e6f2`, `84e3b72`) and -removed the `hiddenTerrainCells` cell-collapse mechanism, the OUTDOOR -TERRAIN MESH is now (correctly per retail) rendered everywhere on the -landblock — including in 3D regions occupied by indoor EnvCell volumes. -Visual verification at a Holtburg cottage cellar showed a sharp-edged -rectangular grass patch (outdoor terrain at Z≈93.99) rendering over the -cellar stair geometry at certain camera angles. Clears when camera -moves closer (cottage walls + stair treads geometrically occlude the -terrain from new vantage points). Gameplay unaffected. **This is the -same root cause as the existing #78 hypothesis #2** ("outdoor stabs not -culled when player in EnvCell"), just with outdoor terrain mesh -affected in addition to outdoor stab entities. Per user direction, -NOT filed as a new issue — additional evidence reinforces #78's -hypothesis #2, broadens scope of the fix to include terrain culling. - -**Root cause / status:** Two plausible causes: -1. The `+0.02f` Z bump applied to cell origin at `GameWindow.cs:5362` - pushes the floor mesh 2 cm above terrain, so depth test correctly - occludes terrain. But OUTDOOR STABS (landblock-baked building geometry) - at the same X,Y may have Z values comparable to or higher than the - cell-mesh floor, producing z-fighting / see-through. -2. **(High confidence as of 2026-05-25)** Outdoor geometry (stabs AND - terrain mesh) isn't being culled when the player is inside an - EnvCell — this is the Phase 1 Task 3 deferred work - ("Cull outdoor stabs when indoors via VisibleCellIds"). WB has a - `RenderInsideOut` stencil pipeline (`references/WorldBuilder/Chorizite.OpenGLSDLBackend/Lib/VisibilityManager.cs`) - that acdream never invokes. Retail anchor: - `docs/research/named-retail/acclient_2013_pseudo_c.txt:311397` - (`CEnvCell::find_visible_child_cell` at address `0x0052dc50`, - called from `acclient_2013_pseudo_c.txt:280028`). - -**Files:** -- `src/AcDream.App/Rendering/Wb/WbDrawDispatcher.cs` (per-entity walk — - the dispatcher already filters by `entity.ParentCellId ∈ - visibleCellIds` but outdoor stabs have `ParentCellId == null` so they - always pass; needs an explicit indoor-camera gate). -- `src/AcDream.App/Rendering/TerrainModernRenderer.cs` (currently - renders all loaded landblock terrain unconditionally; needs - visibility gating when camera resolves to an indoor cell). -- `src/AcDream.App/Rendering/CellVisibility.cs:222+` (`ComputeVisibility` - returns `VisibleCellIds`; existing portal-LOS infrastructure to build on). -- `references/WorldBuilder/Chorizite.OpenGLSDLBackend/Lib/VisibilityManager.cs` - (`RenderInsideOut` pipeline — reference implementation, never invoked). - -**Acceptance:** Standing inside a sealed-interior cell, no outdoor -geometry is visible through floor/walls. Standing where a cell has a -real outdoor portal (door open, window) outdoor geometry is correctly -visible through the portal. Cellar-stairs case (2026-05-25 finding): -standing in a Holtburg cottage cellar at any camera angle, no outdoor -terrain mesh visible over the stair geometry. - -**Research:** -[`docs/research/2026-05-25-issue-100-shipped-and-culling-handoff.md`](research/2026-05-25-issue-100-shipped-and-culling-handoff.md) -— full session handoff with cellar-stairs evidence, family map (#78 + -#95 + cellar-stairs), root-cause hypothesis, retail anchors, WB -references, do-not-retry list, and pickup prompt for the -investigation session. - -**2026-05-31 update (post-U.4c-flap-fix):** the U.4c flap fix (`0ee328a`, root -indoor visibility at the player's cell) made this MORE visible — terrain now -draws inside again (it was Skipped during the flap), so the "floor shows outdoor -ground / cellar floor transparent / see the world from below" symptom is now -prominent. Confirmed at visual gate. Fix direction unchanged: gate outdoor -terrain by indoor-cell visibility (port retail `CEnvCell::find_visible_child_cell` -`acclient_2013_pseudo_c.txt:311397` + `seen_outside` landscape-keep). See -[`docs/research/2026-05-31-u4c-flap-fixed-and-residuals-handoff.md`](research/2026-05-31-u4c-flap-fixed-and-residuals-handoff.md) -(residual 1). - -**2026-05-31 (PM) — promoted to the RENDER ARCHITECTURE RESET target.** A week of -point-fixing produced no shippable indoor render. #78 is now understood as the visible -symptom of an architectural gap, NOT a standalone bug: acdream enforces visibility via -THREE inconsistent gates (terrain `TerrainClipMode` / shell per-cell clip / entity -`ParentCellId` filter with a `ParentCellId==null` outdoor-stab bypass) instead of retail's -ONE PView gate. Direct evidence (`[shell]` probe, `ACDREAM_PROBE_SHELL`) RULED OUT every -other subsystem: the interior cell shells render fine (geometry/texture/opaque/depth -correct); the residual is purely that outdoor geometry isn't gated to portal openings -when indoors. The fix is the unified PView gate (one traversal → one gate for ALL -geometry), which closes #78 + transparent walls + grey enclosure together. **Canonical -(read first):** -[`docs/research/2026-05-31-render-architecture-reset-handoff.md`](research/2026-05-31-render-architecture-reset-handoff.md) -+ the "Render Pipeline" section of `docs/architecture/acdream-architecture.md`. - ---- - -## #79 — Indoor lighting: spurious spot lights on walls - -**Status:** OPEN -**Severity:** MEDIUM -**Filed:** 2026-05-19 -**Component:** lighting - -**Description:** Walking around inside Holtburg Inn, the user sometimes -sees spot-light-like patches on the interior walls that don't correspond -to retail's lighting. - -**Root cause / status:** Point lights from cell static objects (torch -entities) are being registered via `LightInfoLoader.Load` + `LightingHookSink` -(Phase 1 verified). Their per-light parameters (position, range, intensity, -cone) may be wrong — wrong falloff treatment, wrong world-space transform, -or wrong direction for spot lights. Spec at -`docs/research/deepdives/r13-dynamic-lighting.md` documents the retail -LightInfo→LightSource mapping but the live behavior hasn't been verified -against retail. - -**Files:** -- `src/AcDream.Core/Lighting/LightInfoLoader.cs` -- `src/AcDream.App/Rendering/Shaders/mesh_modern.frag` — `accumulateLights` - spot-cone logic. - -**Acceptance:** Side-by-side comparison with retail at the inn shows -matching torch-light pools. - ---- - -## #80 — Camera on 2nd floor goes very dark - -**Status:** OPEN — **M1.5 scope (A7 lighting fidelity)** -**Severity:** MEDIUM -**Filed:** 2026-05-19 -**Component:** lighting - -**Description:** Walking up to the second floor of a building, the -lighting suddenly goes much darker than retail. - -**Root cause / status:** Possible causes: -1. The `playerInsideCell` lighting trigger (Phase 1 / commit `1024ba3`) - uses `CellVisibility.IsInsideAnyCell(playerPos)` which is a brute-force - PointInCell scan. The 2nd floor cell may not be in the loaded set OR - may have wrong bounds. -2. The per-cell ambient is currently a flat `(0.20, 0.20, 0.20)` for - any indoor cell. Retail has per-cell ambient overrides; ours doesn't - read them. A 2nd-floor cell with stairwell shadowing may need a - different value. - -**Files:** -- `src/AcDream.App/Rendering/GameWindow.cs:8330+` (`UpdateSunFromSky`, - indoor branch). - -**Acceptance:** 2nd-floor cells render with similar brightness to -ground floor; transition is not abrupt. - ---- - -## #81 — Static building stabs don't react to atmospheric lighting changes - -**Status:** OPEN — **M1.5 scope (A7 lighting fidelity)** -**Severity:** MEDIUM -**Filed:** 2026-05-19 -**Component:** lighting, rendering - -**Description:** Outside, time-of-day changes (sunrise/sunset/lightning) -don't visibly affect static building stabs (the inn / cottages). The -buildings stay statically lit while terrain and scenery shift colors. - -**Root cause / status:** Stabs are rendered through `WbDrawDispatcher` -with `mesh_modern.frag` which DOES consume the `SceneLightingUbo` -(sun + ambient + fog). Verify the shader is being used for stabs and -that the UBO is bound at the right binding slot per draw call. -Possibly a shader-path divergence — terrain uses `terrain_modern.frag`, -entities use `mesh_modern.frag`, but stabs/scenery may be on a -different path. - -**Files:** -- `src/AcDream.App/Rendering/Shaders/mesh_modern.frag` -- `src/AcDream.App/Rendering/Wb/WbDrawDispatcher.cs` - -**Acceptance:** Stabs darken/brighten in sync with terrain + scenery -across the day/night cycle. - ---- - -## #82 — Some slope terrain lit incorrectly - -**Status:** OPEN -**Severity:** LOW (cosmetic) -**Filed:** 2026-05-19 -**Component:** rendering, terrain - -**Description:** Specific terrain slopes appear lit "wrong" compared to -retail. - -**Root cause / status:** Likely terrain normal calculation or the -landblock-edge normal-blending divergence between WB and retail (per -`feedback_wb_migration_formulas.md` — WB's terrain split formula -differs from retail's `FSplitNESW`). - -**Files:** -- `src/AcDream.App/Rendering/TerrainModernRenderer.cs` -- `src/AcDream.App/Rendering/Shaders/terrain_modern.frag` - -**Acceptance:** Side-by-side comparison with retail at the same Holtburg -slopes shows matching shading. - ---- - -## #83 — Indoor multi-Z walking broken (cellars, 2nd floors, intermittent falling-stuck) - -**Status:** OPEN — **M1.5 scope (A6 physics fidelity, primary umbrella issue)**. Foundation work landed 2026-05-19; root-cause fix scoped to A6.P1-P3 cdb-driven investigation. -**Severity:** HIGH (blocks vertical indoor traversal + degrades single-floor cases). M1.5 acceptance depends on this closing. -**Filed:** 2026-05-19 -**Component:** physics, movement, resolver - -**Description:** Walking UP stairs in single-floor houses works -(grounded step-up routes through retail-faithful `BSPQuery.FindWalkableInternal` -via `StepSphereDown`). Walking DOWN into cellars fails ("ground blocking" — -can't descend). Walking on 2nd floors works partially but intermittently -gets stuck in the falling animation. "Phantom collisions" / invisible -obstacles in rooms persist. The original title "Walking up stairs broken" -was misleading per user's clarification 2026-05-19. - -**Partial fix landed 2026-05-19 (6 commits `ff548b9` → `f845b22`).** -Foundation work: extended `BSPQuery.FindWalkableInternal` to expose the -hit polygon's dictionary key id; added thin public wrapper -`BSPQuery.FindWalkableSphere` over the existing retail-faithful BSP -walkable-finder (acclient_2013_pseudo_c.txt:326211 / :326793); refactored -`Transition.TryFindIndoorWalkablePlane` to route through that wrapper -instead of its Phase-2 linear first-match XY scan; added `[indoor-walkable]` -runtime-toggleable probe line for diagnostic visibility. 5 new unit tests -+ 1 integration test, 9 pre-existing IndoorWalkablePlane tests updated -to the new signature. - -**Foundation work did NOT fix the user-reported bugs.** Visual verification -2026-05-19: cellar descent FAIL, 2nd-floor walking FAIL (intermittent -falling-stuck), single-floor cottage REGRESSED to intermittent falling-stuck -(was stable before), phantom collisions PERSIST. The probe captured 1443 -MISS / 2 HIT over 1445 indoor-walkable calls — the BSP walker correctly -rejects the foot-sphere-tangent-to-floor case (sphere center is exactly -at `floorZ + radius` when grounded, so `PolygonHitsSpherePrecise` fails -the `|dist| > radius - epsilon` check by ~0.0002). - -**Root cause (deeper than originally diagnosed):** `Transition.TryFindIndoorWalkablePlane` -fundamentally exists as a Phase 2 commit `eb0f772` stop-gap to synthesize -a ContactPlane every frame when the indoor BSP returns OK. Retail doesn't -do this — retail RETAINS the previous frame's `ContactPlane` when the -collision dispatcher says "no collision." There is no retail analog of -`find_walkable` being called as a standing-still query — retail's -`find_walkable` only runs inside a downward sphere sweep -(`step_sphere_down`), where the sphere is moving and the overlap test -is meaningful. In our `TryFindIndoorWalkablePlane` flow, the sphere is -tangent (grounded), not moving — the algorithm correctly returns "no -overlap." The single-floor cottage worked previously because the OLD -linear scan ignored Z and falsely returned HIT for any XY-overlapping -walkable; the new BSP-walker correctly identifies "no overlap" and -falls through to the outdoor terrain backstop, which only happens to -produce sensible Z for single-floor outdoor-adjacent cases. - -**Files in the foundation work:** -- `src/AcDream.Core/Physics/BSPQuery.cs` — `FindWalkableInternal` signature extension, new `FindWalkableSphere` public wrapper -- `src/AcDream.Core/Physics/TransitionTypes.cs` — `TryFindIndoorWalkablePlane` refactor, `PointInPolygonXY` deletion, `[indoor-walkable]` probe -- `tests/AcDream.Core.Tests/Physics/BSPQueryTests.cs` — 4 new unit tests -- `tests/AcDream.Core.Tests/Physics/TransitionTypesTests.cs` — new integration test -- `tests/AcDream.Core.Tests/Physics/IndoorWalkablePlaneTests.cs` — 9 tests updated to new signature - -**Next investigation phase (deferred):** Port retail's `ContactPlane` retention -mechanism so the resolver retains the previous frame's contact plane when -the BSP says "no collision," instead of re-synthesizing it per frame. The -proper fix likely eliminates `TryFindIndoorWalkablePlane` entirely. Needs -deep investigation of retail's `CTransition::transitional_insert` / -`CPhysicsObj::transition` / `LastKnownContactPlane` interactions. Foundation -work (BSP walker + probe + tests) remains useful regardless of approach. - -**Acceptance:** Walk down stairs into a cellar without getting stuck. -Walk on a 2nd floor without intermittent falling-stuck. Single-floor -cottage walking remains stable (no regression). - -**Handoff:** [`docs/research/2026-05-19-indoor-walkable-plane-bsp-port-shipped-handoff.md`](research/2026-05-19-indoor-walkable-plane-bsp-port-shipped-handoff.md). - ---- - ## #84 — [DONE 2026-05-19] Blocked by air indoors **Status:** DONE @@ -1632,45 +2653,6 @@ propagates through portal connectivity data in `CEnvCell`. --- -## #88 — Indoor static objects vibrate (bookshelves, open furnaces) - -**Status:** OPEN — **M1.5 scope (A6 physics — suspected sub-step state corruption family)** -**Severity:** MEDIUM (visual jitter; doesn't block gameplay) -**Filed:** 2026-05-19 -**Component:** rendering, animation - -**Description:** Static objects inside cells (bookshelves, open furnaces, possibly other interior props) show per-frame transform jitter / vibration. Pre-existing (user noticed before Phase 2 shipped). Likely candidates: - -1. `EntityScriptActivator.OnCreate/OnRemove` firing repeatedly as the player's CellId promotes/demotes near cell boundaries (less likely after Phase 2's portal-based tracking — but worth investigating). -2. Per-part transforms for cell-static `WorldEntity` instances getting recomputed each frame with floating-point drift. -3. Particle-emitter offsets accumulating instead of resetting. - -**Files to investigate:** -- `src/AcDream.App/Rendering/Vfx/EntityScriptActivator.cs` — OnCreate/OnRemove call patterns -- `src/AcDream.App/Rendering/GpuWorldState.cs` — entity transform updates per frame -- `src/AcDream.App/Rendering/Wb/WbDrawDispatcher.cs` — per-batch transform composition - -**Acceptance:** Indoor static objects render stable (no per-frame jitter). - ---- - -## #89 — Port BSPQuery.SphereIntersectsCellBsp for retail-faithful CheckBuildingTransit - -**Status:** OPEN -**Severity:** LOW (Phase 2 ships with a documented approximation) -**Filed:** 2026-05-19 -**Component:** physics - -**Description:** Retail's `CEnvCell::check_building_transit` uses `CCellStruct::sphere_intersects_cell` — a radius-aware sphere-vs-BSP test that returns Inside/Crossing/Outside. Phase 2's `CellTransit.CheckBuildingTransit` uses `BSPQuery.PointInsideCellBsp` (radius-less, tests only the sphere CENTER). Practical effect: outdoor→indoor entry fires ~sphereRadius (~0.48m) deeper into the doorway than retail. The sphereRadius parameter is plumbed through but currently unused. - -**Files:** -- `src/AcDream.Core/Physics/CellTransit.cs::CheckBuildingTransit` (line ~162) -- `src/AcDream.Core/Physics/BSPQuery.cs::PointInsideCellBsp` (line ~940) — existing point test to model the new sphere variant after - -**Acceptance:** `CellTransit.CheckBuildingTransit` calls a new `BSPQuery.SphereIntersectsCellBsp(node, sphereCenter, sphereRadius)` that returns `Inside`/`Crossing`/`Outside`. Entry timing matches retail visually at the Holtburg cottage door. - ---- - ## #90 — Cell-id ping-pong at indoor doorway threshold — [DONE 2026-06-11 · ca4b482, T6/BR-7] **Status:** DONE — the `4ca3596` sphere-overlap stickiness workaround was @@ -1704,37 +2686,20 @@ Retail oracle for cell-id hysteresis: `acclient_2013_pseudo_c.txt:308742-308783` --- -## #93 — Indoor lighting broken (M1.5 lighting umbrella) - -**Status:** OPEN — **M1.5 scope (A7 lighting fidelity, primary lighting issue)** -**Severity:** HIGH (degrades indoor experience; M1.5 acceptance depends on it closing) -**Filed:** 2026-05-20 -**Component:** lighting, rendering - -**Description:** Interior cells (inn, cottages, dungeons — anywhere with `cellLow >= 0x0100`) render with lighting that doesn't match retail. Specific symptoms include #80 (2nd floor goes dark), wrong per-cell ambient, missing cell-internal light sources (torches/lanterns), and outdoor day-cycle bleeding into indoor cells. Umbrella issue covering the family; sub-issues to be filed during A7.L1 probe spike. - -**Root cause / status:** Suspected family of bugs in (a) per-cell environment-light tag parsing from the dat (we may not parse `cell.envLightInfo` correctly), (b) cell-light association (which lights belong to which cell), (c) indoor visibility culling for lights, (d) the indoor branch of `GameWindow.UpdateSunFromSky` which uses a flat ambient. Investigation deferred to A7.L1. - -**Files:** -- `src/AcDream.App/Rendering/GameWindow.cs:8330+` (`UpdateSunFromSky`, indoor branch with flat ambient) -- `src/AcDream.App/Rendering/Shaders/mesh_modern.frag` (per-pixel light evaluation) -- `references/WorldBuilder/...` (any WB lighting helpers we inherit) -- Retail oracle: grep `Render::lighting_*` in `acclient_2013_pseudo_c.txt` - -**Acceptance:** Holtburg inn interior lighting matches retail at the same character position. Holtburg Sewer dungeon torchlight reads correctly per-room. 2nd-floor cells brightness matches ground floor. - ---- - ## #94 — Held items project spotlight on walls -**Status:** OPEN — **M1.5 scope (A7 lighting fidelity)** +**Status:** OPEN — **BLOCKED, not an active A7 investigation target.** acdream does not +yet support equipping hand-held items (weapons, orbs, light sources) at all +(user-confirmed 2026-07-09), so this can't be reproduced or verified either way right +now. Re-open for real investigation once item-equipping ships; until then this is a +placeholder, not a live bug. **Severity:** MEDIUM (visual fidelity; doesn't block gameplay) **Filed:** 2026-05-20 **Component:** lighting, rendering **Description:** Items the player is holding (torches, light-source items) project a spotlight effect onto nearby walls. The spotlight direction is wrong — should be omnidirectional from the item, but appears to project specifically toward wall surfaces. -**Root cause / status:** Per-entity light direction transform. `LightingHookSink` owner-tracking applies an entity-rotation transform that's probably wrong for held-light items — likely passing the entity's facing-direction as the spotlight cone direction when retail's behavior is omnidirectional point-light. +**Root cause / status:** Per-entity light direction transform. `LightingHookSink` owner-tracking applies an entity-rotation transform that's probably wrong for held-light items — likely passing the entity's facing-direction as the spotlight cone direction when retail's behavior is omnidirectional point-light. UNTESTABLE until item-equipping exists — this is a hypothesis from the original 2026-05-20 filing, not re-confirmed. **Files:** - `src/AcDream.App/Rendering/Vfx/LightingHookSink.cs` (suspected — verify during A7.L1) @@ -1784,36 +2749,6 @@ errors. The flood was never the bug. **Originally** also: explained user-observe --- -## #96 — Per-tick PhysicsEngine.ResolveWithTransition CP seed (retail divergence) - -**Status:** PARTIALLY ADDRESSED — accepted as documented retail divergence -**Severity:** LOW (cosmetic — CP-write counter inflates but behavior is correct) -**Filed:** 2026-05-21 -**Component:** physics, ContactPlane retention - -**Description:** After A6.P3 slice 1 (commits `5aba071` + `5f7722a` + `39fc037`) stripped the `TryFindIndoorWalkablePlane` synthesis path from `Transition.FindEnvCollisions` indoor branch, scen3 post-fix re-capture showed acdream still writes ContactPlane fields 25,082 times during a flat-floor walk — 24,906 of those (99.3%) come from `PhysicsEngine.ResolveWithTransition` line 622, which seeds `ci.ContactPlane` from `body.ContactPlane` at every transition start when the body is grounded. Retail's equivalent code path fires `set_contact_plane` zero times during the same flat-floor walk (scen3 retail BP7 = 0). - -**Slice 2 attempt + outcome (2026-05-22, commits `892019b` + `f8d669b`):** - -- **v1 attempt (`892019b`):** Removed the L622 seed entirely to match retail's `CTransition::init` clear-at-start behavior. Verified per-rebuild that the change deployed. CP-write count dropped 91% (30,420 → 2,690). **But broke BSP step_up at the last step of stairs** — sub-step 1's `AdjustOffset` had no ContactPlane to compute the lift direction, BSP step_up thrashed (12,489 push-back-disp + 2,226 push-back-cell signal). User confirmed: "I can't pass the last step of the stairs." -- **v2 fix (`f8d669b`):** Reverted the seed removal + added no-op-if-unchanged guard inside `CollisionInfo.SetContactPlane`. The guard early-returns when called with values identical to current state. **The guard doesn't trigger for the L622 seed** because each tick gets a fresh `Transition` (so `ci.ContactPlaneValid=false` on entry → guard fails → write fires). So slice 2 v2 didn't actually reduce CP-write count for the seed case. It does dedupe within-tick redundant writes (e.g. Mechanism B restoring LKCP that equals current ci.CP), which is a small benign improvement. - -**Root cause / status (updated 2026-05-22):** The L622 seed IS load-bearing for `AdjustOffset` slope projection on sub-step 1, which BSP step_up depends on. Retail uses a different architecture (no seed; first sub-step has no CP and BSP path-6 establishes it). Matching retail would require a deeper refactor — making `AdjustOffset` fall back to `body.ContactPlane` when `ci.ContactPlane` is invalid, OR re-architecting the sub-step loop to not require CP for the first iteration. Both are non-trivial. - -**Accepting the divergence:** the per-tick seed call is functionally correct — it propagates the player's current contact plane to the transition. The cost is a noisy CP-write counter (cosmetic) but the BEHAVIOR matches retail (player stays grounded on the correct plane, slope-snap works, step_up works). Closing #96 fully is deferred to a future refactor or accepted as is. - -**Lessons learned:** -- A counter-based metric (CP-write count) is not always a direct proxy for "behavior matches retail." Retail's set_contact_plane firing rate differs from ours because the call-site structure differs, not because the behavior differs. -- The slice 1 hypothesis "Finding 1 (dispatcher entry frequency) may close as side-effect of Finding 2 (CP-write)" was confirmed by stairs+cellar working post-slice-1. But the slice 2 follow-up assumption "remaining 99.3% of CP writes are also a problem" was partially wrong — those writes are correct state propagation. - -**Files:** -- `src/AcDream.Core/Physics/PhysicsEngine.cs:620-626` (the seed call site, retained with updated comment) -- `src/AcDream.Core/Physics/TransitionTypes.cs:259-279` (`CollisionInfo.SetContactPlane` no-op guard, retained as small improvement) - -**If revisited:** investigate `AdjustOffset` fallback to `body.ContactPlane` when `ci.ContactPlane` is invalid — that would let us safely remove the seed. Or investigate retail's exact first-sub-step behavior to see if there's a different missing piece in our BSP step_up that would let it work without a seeded CP. - ---- - ## #97 — Phantom collisions + occasional fall-through on indoor 2nd floor (post-slice-1 happy-testing) — [DONE 2026-06-11 · T6/BR-7 + T5 gate] **Status:** DONE — closed by T6/BR-7 (the +5 m radial query pad that made @@ -2354,6 +3289,8 @@ fix the constants in **Estimated scope:** ~30 min cdb session + 1 commit if confirmed, or +small fix if different. Not blocking M1. +**2026-07-09 triage:** investigated, verdict STILL_OPEN — no cdb trace or dat dump of the Humanoid `TurnRight`/`TurnLeft` `omega.z` was ever captured; the retail-divergence-register still carries this as a live open risk under rows AP-75/AP-76 as of the current codebase. + --- ## #71 — WorldPicker Stage B — polygon refine for retail-accurate clicks @@ -2470,37 +3407,6 @@ human motion table. --- -## #68 — Remote players don't stop running animation on auto-walk arrival - -**Status:** OPEN -**Severity:** LOW-MEDIUM (visual only — server-side action completes correctly) -**Filed:** 2026-05-15 (B.7 visual verification) -**Component:** motion / remote dead-reckoning / animation cycle - -**Description:** Observing a retail player from acdream as they approach -an NPC at a distance: the remote body's run animation keeps cycling -even after the body has visibly stopped at the NPC. Retail-side the -character stopped; the action (dialogue) fired; but our client's -animation never transitioned RunForward → Ready. - -**Suspected:** `RemoteMoveToDriver` detects arrival via -`DriveResult.Arrived`, but the consumer site (per-tick loop in -`GameWindow.TickAnimations` or wherever the remote body's cycle is -driven) doesn't flip the animation cycle back to Ready on arrival. -Alternatively the cycle persists because ACE doesn't broadcast a -follow-up `UpdateMotion(Ready)` — relying on the client to detect -arrival from the wire's distance threshold instead. - -**Files (likely):** -- `src/AcDream.App/Rendering/GameWindow.cs` — wherever per-tick motion - for remote entities reads `RemoteMoveToDriver`'s state. Need to - call `SetCycle(NonCombat, Ready)` on arrival. - -**Acceptance:** Retail player observed running up to an NPC visibly -stops running animation at arrival distance, transitions to idle. - ---- - ## #67 — [DONE 2026-05-15 · `301281d`] Door Use action doesn't complete after auto-walk arrival **Status:** DONE — fixed by `301281d` (10 Hz heartbeat during motion). @@ -2511,97 +3417,6 @@ doors work after the heartbeat bump. --- -## #66 — Local + remote rotation: player flips back, NPCs don't turn - -**Status:** OPEN -**Severity:** LOW-MEDIUM (visual feedback — interaction works, -just looks wrong) -**Filed:** 2026-05-15 (B.7 visual verification) -**Component:** motion / rotation - -**Description:** Two related visual rotation bugs surfaced together: - -1. **Local player flips back.** Observing acdream's `+Acdream` from - retail: when our auto-walk completes and the body has rotated to - face the target, the broadcast position has the new rotation — - then the next frame the player snaps back to whatever the camera - yaw was. Likely cause: after `EndServerAutoWalk`, the synthesised - input stops and `Update`'s next pass applies the user's real - `MouseDeltaX` (which may be 0 but other paths might be - overriding `Yaw`). -2. **NPCs don't turn to face the player.** ACE broadcasts - `MovementType=8 TurnToObject` when an NPC starts a Use response - that requires facing. Our `OnLiveMotionUpdated` handles - MovementType=6 (MoveToObject) but not 8. The NPC's body stays - at whatever heading the spawn / last motion left it. - -**Acceptance:** -- After auto-walk arrival, local player's facing toward the target - is preserved (no flip-back observed from a retail client). -- NPCs (Tirenia, guards, vendors) rotate to face the player when - using them. - -**Files (likely):** -- `src/AcDream.Core.Net/Messages/UpdateMotion.cs` — extend parser - for MovementType=8 payload (target guid + final-heading flag). -- `src/AcDream.App/Rendering/GameWindow.cs` `OnLiveMotionUpdated` - — route MovementType=8 for the local player to a new - `BeginServerTurnToObject` controller method; route for remote - guids into the remote-dead-reckon state (extending - `RemoteMoveToDriver` or adding a sibling driver). -- `src/AcDream.App/Input/PlayerMovementController.cs` — add the - turn driver that holds Yaw against user-input overrides until - aligned. - -**Replaces / supersedes:** #65 (local-player turn-to-face on -close-range Use). This issue covers both directions and is the -broader retail-faithful rotation handling phase. - -**Estimated scope:** Medium — ~80–120 LOC + tests. - ---- - -## #65 — Local player doesn't turn to face target on close-range Use - -**Status:** OPEN -**Severity:** LOW (functional — Use still completes — but visually awkward) -**Filed:** 2026-05-15 (B.6/B.7 visual verification) -**Component:** physics / movement / inbound MoveTo handling - -**Description:** When the local player has a target selected and is -already within ACE's `WithinUseRadius` (close-range branch in -`CreateMoveToChain` at `Player_Move.cs:66`), ACE skips the auto-walk -chain and just calls `Rotate(target)` server-side. The Use action -completes, but the local player's body doesn't visibly turn to face -the target — the character stays at whatever heading the user was -looking when they clicked. - -**User-visible:** Stand behind an NPC, click them, press R. Dialogue -appears, but the character keeps facing away from the NPC. In retail -the character would have turned to face the NPC before / during the -Use. - -**Root cause:** ACE's close-range path sends a `TurnTo` motion -(MovementType=8 TurnToObject, decomp `0x005241b3` switch case 8). -Our `OnLiveMotionUpdated` doesn't currently handle MovementType=8 — -it falls into the locomotion path and ignores the rotation. - -**Acceptance:** When the user uses an in-range target while facing -away, the character rotates to face the target before / as the Use -action fires. No regression on close-range pickup (item still picks -up cleanly). - -**Files (likely):** -- `src/AcDream.Core.Net/Messages/UpdateMotion.cs` — extend parser for MovementType=8 TurnToObject payload. -- `src/AcDream.App/Input/PlayerMovementController.cs` — add a `BeginServerTurnToObject(targetWorld, useFinalHeading)` method that rotates Yaw at TurnRateRadPerSec each frame until aligned, then clears the state. -- `src/AcDream.App/Rendering/GameWindow.cs` `OnLiveMotionUpdated` — when inbound motion is MovementType=8 and the guid is `_playerServerGuid`, install the turn on the controller. - -**Estimated scope:** Small — ~50 LOC plus tests. Pairs naturally with -B.6 (already does turn-then-walk for far targets via RemoteMoveToDriver's -heading correction; this is the close-range cousin). - ---- - ## #64 — Local-player pickup animation does not render **Status:** OPEN @@ -2772,58 +3587,6 @@ inn door, watch swing animation rest at open pose with no intermediate flash. --- -## #60 — `obstruction_ethereal` retail downstream path not ported (M2 combat-HUD impact) - -**Status:** OPEN -**Severity:** LOW for M1 (no observable defect); MEDIUM for M2 (combat contact reporting on ethereal creatures will be wrong) -**Filed:** 2026-05-13 (final-review surfaced from B.4b) -**Component:** physics / `CollisionExemption.ShouldSkip` + downstream movement contact handling - -**Description:** B.4b's L.2g slice 1b widened `CollisionExemption.ShouldSkip` to exempt -on `ETHEREAL_PS` alone (cite `src/AcDream.Core/Physics/CollisionExemption.cs:62-79`). Retail's -`acclient_2013_pseudo_c.txt:276782` requires both `ETHEREAL_PS && IGNORE_COLLISIONS_PS` to wrap -the entire `FindObjCollisions` body — ETHEREAL alone takes the deeper path at line 276795 which -sets `sphere_path.obstruction_ethereal = 1` and lets downstream movement allow passage WHILE -STILL REPORTING THE CONTACT. We do not port that downstream path; we just exempt entirely. - -**M2 impact:** Combat HUD work that relies on physics-contact reporting for ethereal creatures -(ghosts, partially-phased monsters, spell projectiles with ETHEREAL set) will see no contact at -all instead of "soft contact with obstruction_ethereal=1". The user will not be able to target -or interact with such entities via the contact path. - -**Acceptance:** Port the retail deeper path so `obstruction_ethereal=1` flows through movement + -collision-reporting layers. Tests should cover: ETHEREAL creature target → contact reported but -passage allowed; ETHEREAL+IGNORE_COLLISIONS target (door, retail-style) → full exempt. - -**Estimated scope:** Moderate. Touches `CollisionExemption.cs`, transition/movement layer, and -sphere-path state propagation. Visible test through a spawned ethereal creature in ACE. - ---- - -## #59 — [DONE 2026-05-15 · `5e29773`] `WorldPicker` 5m fixed-radius could over-pick at tight thresholds (M1-deferred polish) - -**Status:** OPEN -**Severity:** LOW (cosmetic — picker grabs the right entity in Holtburg-tested scenarios) -**Filed:** 2026-05-13 (final-review surfaced from B.4b) -**Component:** selection / `AcDream.Core.Selection.WorldPicker.Pick` - -**Description:** `WorldPicker.Pick` uses a hardcoded 5m sphere around every candidate's -`Position` regardless of the entity's actual size (`src/AcDream.Core/Selection/WorldPicker.cs:82`). -This matches `WorldEntity.DefaultAabbRadius` and is sufficient for M1 acceptance: in tight -doorways, every server-keyed candidate has correct sphere coverage and the closest-wins logic -plus `ServerGuid==0` skip filter the wrong picks. But the invariant "non-clickable geometry has -`ServerGuid==0`" is load-bearing — if L.2d ever ports `CBuildingObj` as a server-keyed entity, -the picker may mis-target buildings. Per-entity `Setup.Radius` would be tighter. - -**Acceptance:** Either (a) tighten picker to read per-entity Setup.Radius / CylSphere bounds, -or (b) document the invariant in `WorldPicker.cs` and add a regression test asserting -`ServerGuid==0` entities never reach the per-candidate hit test. - -**Estimated scope:** Quick (~1 hour) — wire `Setup.Radius` lookup into the picker and update -the 6 existing picker tests with realistic radii. - ---- - ## #58 — [DONE 2026-05-13] Door swing animation: UpdateMotion not wired for non-creature entities **Status:** DONE @@ -3211,7 +3974,20 @@ regression on the species that already render correctly. ## #39 — Run↔Walk cycle transition not visible on observed player remotes (acdream-as-observer) -**Status:** OPEN — VERIFY-PENDING (cases #1/#2/#4/#5 user-verified working 2026-05-06; cases #3/#6/#7 unverified in live test) +**Status:** CLOSED 2026-07-02 (superseded by L.2g; refinement machinery DELETED in the S5 commit) +**Closure note:** the root-cause narrative below is WRONG — the 2026-05-06 +"wire goes silent on Shift toggle" finding was refuted at three oracles + a +fresh live capture (`docs/research/2026-07-02-inbound-motion-deviation-map.md`, +S0 section): retail sends a fresh MoveToState on HoldRun toggle while moving +(`CommandInterpreter` 0x006b37a8 → `SendMovementEvent`), ACE rebroadcasts every +MoveToState (`GameActionMoveToState.cs:36`), and the S0 capture shows explicit +`0x0005↔0x0007` UMs on each toggle. Retail has NO pace→cycle adaptation +anywhere (DEV-2). The `ApplyPlayerLocomotionRefinement` layer this issue added +was itself causing Ready↔Run thrash against legitimate flags=0 stop UMs and +was deleted; player-remote cycles are UM-driven only. Remaining transition +polish (funnel, stop path, link pose) is tracked as roadmap L.2g S2–S4. + +**Original status:** OPEN — VERIFY-PENDING (cases #1/#2/#4/#5 user-verified working 2026-05-06; cases #3/#6/#7 unverified in live test) **Severity:** LOW (most cases now visibly correct after the 2026-05-06 fix sequence; remaining unverified cases are direction-flip — believed to work via direct UM but not explicitly exercised) **Filed:** 2026-05-03 **Component:** physics / motion / animation @@ -3609,6 +4385,8 @@ magnitude. - Side-by-side acdream-as-observer vs retail-as-observer of the same server-controlled toon: indistinguishable body trajectory. +**2026-07-09 note (user):** "semi fixed, needs polish" — stays open, downgrade to polish-tier if a fresher look confirms the core bug is gone. + --- ## #40 — [DONE 2026-05-05 · 40d88b9] ACDREAM_INTERP_MANAGER=1 env-var path regressed (staircase + blips) @@ -4251,35 +5029,6 @@ additional flash-shader work). --- -## #33 — Live entity collision shape collapses to one cylinder - -**Status:** OPEN -**Severity:** MEDIUM -**Filed:** 2026-04-29 -**Component:** physics / entities - -**Description:** Live world entities do not yet use exact retail -`CSphere` / `CCylSphere` shape semantics. Several paths collapse the entity to -a simplified root-centered cylinder or fallback radius, which is not enough for -retail object and creature collision parity. - -**Root cause / status:** Tracked under Phase L.2d. Requires auditing object -shape extraction, `Setup.Radius` fallback, building object identity, and live -entity broadphase records against named retail. - -**Files:** `src/AcDream.Core/Physics/CollisionPrimitives.cs`, -`src/AcDream.Core/Physics/ShadowObjectRegistry.cs`, -`src/AcDream.Core/Physics/PhysicsDataCache.cs`. - -**Research:** `docs/plans/2026-04-29-movement-collision-conformance.md`. - -**Acceptance:** Live object collision uses the appropriate retail sphere or -cylsphere data where available. Tests prove at least one multi-shape object and -one live creature case no longer use the single-cylinder fallback. - ---- - - ## #2 — Lightning visual mismatch (sky PES path disproved) **Status:** OPEN @@ -4332,29 +5081,6 @@ one live creature case no longer use the single-cylinder fallback. --- ---- - -## #4 — Sky horizon-glow disabled (fog-mix skipped on sky meshes) - -**Status:** OPEN -**Severity:** LOW (aesthetic feature-parity, not regression from pre-session state) -**Filed:** 2026-04-25 -**Component:** sky - -**Description:** Phase 8.1 (commit `593b76f`) disabled the fog-mix on sky meshes to fix the "entire dome swallowed by fog color" regression. Dereth's keyframe `FogEnd` values (0–2400 m) are calibrated for terrain; sky meshes are authored at radii 1050–14271 m so every sky pixel was past `FogEnd`, saturated to `uFogColor`, destroying stars / moon / dome texture. Disabling the mix restored visibility but we lost retail's horizon-glow effect (gradient from clear zenith to fog-tinted horizon band at dusk/dawn). - -**Root cause / status:** Three competing hypotheses, none pinned down: (a) retail uses a **different** fog range for sky than terrain; (b) retail applies fog with an **elevation-angle** weighting rather than linear distance; (c) retail's sky meshes **don't participate** in the global fog and the "horizon glow" comes from a different atmospheric-scatter path. Need to identify retail's actual sky-fog behaviour before re-enabling with correct parameters. - -**Not in the Phase C.1.5c (Sky-PES) cluster.** Unlike #2/#28/#29 — all PES-driven sky visuals consolidated under the C.1.5c phase via former issue #36 — this is a fragment-shader fog-mix problem. Addressing C.1.5c will NOT resolve #4, and #4 should NOT be bundled into Phase C.1.5c scope. The fix likely needs its own decomp dive into retail's sky-fog math + shader work. - -**Files:** -- `src/AcDream.App/Rendering/Shaders/sky.frag` — line ~55, `rgb = mix(uFogColor.rgb, rgb, vFogFactor)` currently commented out -- `src/AcDream.App/Rendering/Shaders/sky.vert` — lines 109-114, `vFogFactor` computation - -**Research:** `docs/research/2026-04-23-sky-fog.md`. Partial; doesn't pin the sky-specific fog path. - -**Acceptance:** At dusk in Holtburg, the sky dome shows a clear zenith and a warm fog-tinted horizon band that matches retail's appearance, with stars / moon / sun / clouds all still visible at their correct brightnesses elsewhere in the frame. - --- ## #28 — Aurora ("northern lights") effect not rendered @@ -4441,6 +5167,8 @@ If hypothesis (a) is correct, this issue effectively rolls into **#28** — the **See #36 (filed 2026-04-30)** — confirmed via live cdb trace: retail's cloud density comes from the same PES-driven particle-emitter chain as aurora. Implementation consolidated there. +**2026-07-09 triage:** investigated, verdict STILL_OPEN — the `#36` consolidation that was supposed to auto-close this via Phase C.1.5c never shipped (still PLANNED per the roadmap) and the sky-PES path is gated off by default (`ACDREAM_ENABLE_SKY_PES`, off), so the underlying cloud-density fix never landed on main. + --- ## #47 — [DONE 2026-05-06 · 0bd9b96] Humanoid Setup 0x02000001 renders bulky / lacks shape detail vs retail @@ -4571,50 +5299,6 @@ retail show matching silhouette and shape definition. --- -## #46 — Retail observer of acdream sees blippy / laggy movement - -**Status:** OPEN -**Severity:** MEDIUM (degrades external perception of acdream-driven characters) -**Filed:** 2026-05-06 -**Component:** net / motion (acdream's outbound path: `PlayerMovementController` → `MoveToState` (0xF61C) / `AutonomousPosition` heartbeat → ACE → retail observer) -**Phase:** L.2 (Movement & Collision Conformance) — outbound-motion fidelity sub-piece. Counterpart to #41 (which is the inbound side); both are L.2 conformance work. If outbound fidelity grows into multi-commit work, consider carving "L.2e — Outbound motion fidelity" as a named sub-piece on the roadmap. - -**Description:** When viewing acdream's local +Acdream character through a parallel retail acclient.exe, the retail observer sees the character's movement as visibly blippy and laggy — position appears to step in discrete jumps rather than translating smoothly. The local acdream view of the same character looks fine, and acdream observing a retail-driven character (after #39 / #45) also looks fine. The degradation is specifically on the **outbound** side: what acdream sends to ACE for relay to other clients. - -**Root cause / status:** - -Unverified. The likely culprits, ranked by suspected probability: - -1. **AutonomousPosition heartbeat cadence.** `memory/project_retail_motion_outbound.md` notes acdream's fixed 200 ms heartbeat is a probable retail mismatch. Retail's `CommandInterpreter::SendPositionEvent` gates on transient_state (Contact + OnWalkable + valid Position) and may broadcast at a different cadence — fewer / more / variable. If acdream sends too rarely, observer dead-reckons too long between updates and visibly stutters when each AutoPos arrives. -2. **MoveToState send conditions.** `PlayerMovementController.cs:813-840` decides when a fresh MoveToState fires (state-change detection). If important transitions are missed (e.g., direction changes that don't flip ForwardCommand/SidestepCommand), the observer's last-known motion stays stale and AutoPos updates blip the body to the new authoritative position. -3. **InstanceSequence / ObjectMovement sequence counters.** ACE rejects out-of-order packets. If acdream's sequence stamping is off, ACE silently drops some packets; observer dead-reckons through the gap. -4. **Velocity field absent on AutoPos.** ACE relays UPs without HasVelocity for player characters (per `OnLivePositionUpdated` comment). Observer's dead-reckoning between UPs may extrapolate using stale velocity, producing visible position drift that snaps back on the next UP — exactly the blippy pattern. - -**Verification approach:** - -- Run two retail clients + one acdream client. Drive acdream; observe acdream's character on retail #1 and on retail #2 (both retail observers see the same wire). Compare to a retail-driven character observed from the same retail clients — does it look smooth there? If yes, the issue is acdream-outbound-specific. If both look blippy, it's something on the ACE side (less likely). -- cdb-attach a retail observer client and breakpoint `MovementManager::unpack_movement` to count UPs and UMs received per second from the acdream-driven character vs from another retail character. The cadence delta will identify which packet stream is misbehaving. -- Compare acdream's outbound packet timing against holtburger's `client/movement/system.rs` heartbeat logic — that's the closest known-working reference for how a non-retail client should pace its outbound. - -**Files:** - -- `src/AcDream.App/Input/PlayerMovementController.cs` — outbound state-change detection + heartbeat -- `src/AcDream.Core.Net/WorldSession.cs` — sequence counters + send path -- `src/AcDream.Core.Net/Net/Outbound/...MoveToState.cs` / `AutonomousPosition.cs` — wire builders -- `references/holtburger/crates/holtburger-core/src/client/movement/system.rs` — reference cadence - -**Acceptance:** - -- Side-by-side comparison: retail observer of acdream-driven character and retail observer of retail-driven character look equally smooth during running, walking, sidestepping, turning, and stopping. -- No visible "step" pattern when acdream-driven character translates between AutoPos updates. - -**Cross-reference:** - -- `memory/project_retail_motion_outbound.md` — 2026-05-01 cdb live trace of retail's outbound (`CommandInterpreter::SendMovementEvent` for WASD, `Event_Jump` per-frame while charging). -- CLAUDE.md "Outbound motion wire format" — the `WalkForward + HoldKey.Run` ↔ `RunForward` auto-upgrade ACE applies on broadcast. - ---- - ## #45 — [DONE 2026-05-06 · e9e080d] Local +Acdream sidestep walking renders too slow **Status:** DONE @@ -4978,30 +5662,7 @@ squared-vs-not threshold (prefer LIVE attach — prior lesson: static door push to confirm whether the `cn=(0,0,1)` comes from our `UnitZ`-default (lead 1) and what retail's normal is at that instant. ---- - -## #117 — Aperture-shaped see-through: doors/interiors visible through terrain hills and through nearer buildings — [DONE 2026-06-11 · 478c549, user re-gate "Yes solved"] - -**Status:** OPEN -**Severity:** HIGH (the most visible remaining render artifact post-port) -**Filed:** 2026-06-11 (T5 comprehensive gate, user items 11a+11b) -**Component:** render — aperture depth discipline (the T1 punch pass) - -**Symptom (user, axioms):** (a) "looking downhill I can see certain parts -of houses (not everything) like doors and some textures" through the -terrain; (b) "when I'm behind a house I can see the openings on the house -behind that house through the house in front of me, like doors and -windows." Both shapes are APERTURE-shaped (doors/windows), which points at -one mechanism: the far-Z punch erases the depth of NEARER occluders -(terrain hills, closer buildings) at the punched aperture pixels, so -interior content + door entities (dynamics drawn last) paint over them. - -**Diagnosis direction (mechanism, not live-probing):** decomp -`DrawPortalPolyInternal` (Ghidra 0x0059bc90) for the punch's depth STATE — -retail either depth-tests the punch polygon against the existing buffer -(only punching where the aperture is actually visible) or relies on -far→near per-building draw order so nearer geometry re-establishes depth -AFTER the punch. Compare against the T1 (`579c8b0`) punch pass wiring. +**2026-07-09 triage:** investigated, verdict STILL_OPEN — the pinned harness diagnostic (`Diagnostic_Tick22760_DumpEngineInternals`) still shows the harness hard-stopping laterally where live retail slides, and `BSPStepUpTests.D4_AirborneMover_TallWall_PersistsSlidingNormalAcrossFrames` remains explicitly `Skip`-tagged citing this issue; only one Ghidra-confirmed partial fix (`bf18a543`, `F_EPSILON` vs `EpsilonSq`) has landed. --- @@ -5294,47 +5955,6 @@ owner object. --- -## #122 — Windows oscillate between background and the correct outside view when entering houses - -**Status:** OPEN -**Severity:** MEDIUM -**Filed:** 2026-06-11 (re-gate; user: "the oscillating between -background world and the right outside view is now back on some windows -when entering houses") -**Component:** render — window exit-portal region at the root flip - -The #109 oscillation family, now localized to WINDOWS during house -ENTRY (the outdoor→interior root flip). Candidate mechanisms: -(a) the #120 reciprocal ping-pong polluting clip volumes near the -portal plane during the crossing — the firing sites were exactly -cottage cells during entry; RE-CHECK after `dede7e4` before -investigating; (b) the seal/punch handoff on windows across the root -flip (forceFarZ keys on `clipRoot.IsOutdoorNode`, flipping the window -aperture between punch and seal semantics frame-to-frame at the -threshold). - ---- - -## #123 — Buildings transiently disappear when running close past them - -**Status:** OPEN -**Severity:** MEDIUM -**Filed:** 2026-06-11 (re-gate; user: "when I pass by close by -buildings, sometimes the building disappears as I run by") -**Component:** render — outdoor root, close-range building draw - -Whole-building transient vanish at close range under the outdoor root. -Suspects (unverified): the per-building frustum pre-gate on -`Building.PortalBounds` (T2 draw-driven flood gather) interacting with -close-range AABB degeneracy; dispatcher frustum cull with a stale -entity AABB; or the #117 stencil punch marking a near-full-screen -aperture fan at grazing range while the building's own flood is gated -off (far-Z holes → sky/fog where the shell should be). Needs evidence -first: reproduce with `ACDREAM_PROBE_VIS`/`[outdoor-node]` + a capture -of which draw list the building's shell left. - ---- - ## #124 — Looking out through an opening: far buildings with openings show missing/transparent back walls **Status:** CLOSED (user-gated 2026-06-12 evening: "124, that one is solved") @@ -5464,28 +6084,6 @@ meshMissing counters. --- -## #126 — Outdoor spawn claim on a building roof is grounded THROUGH the roof to terrain (transparent-interior spawn) - -**Status:** OPEN — HIGH (every login/logout on any walkable roof) -**Filed:** 2026-06-11 (tower capture run, `tower-viewer-capture.log` line 1) -**Component:** physics — login snap (the #107/#111 family) - -**Evidence:** the user logged out standing ON TOP of the AAB3 tower -(z=127.2). The next login: `[snap] claim=0xAAB30023 pos=(297.160, --129.182,127.200) … terrainZ=112.000 indoor=False -> targetZ=112.000 -targetCell=0xAAB30023`. The snap's OUTDOOR branch always grounds to -TERRAIN Z — it warped the player from the roof down INTO the tower's -interior volume at ground level, still outdoor-classified → the -transparent-interior spawn the user reported ("spawned in the tower and -it was transparent"), self-healing only after walking out and back in. -**Fix shape:** an outdoor claim must ground to the nearest WALKABLE -surface at/below the claim Z (building roofs and GfxObj floors via the -physics walkable query — the #111 `WalkableFloorZNearest` machinery), -not raw terrain. Note the snap line even shows a candidate it rejected -(`bestCell=0xAAB30101 bestZ=124.3`). - ---- - ## #127 — Per-building flood admissions are BISTABLE per frame under the outdoor root (the building-flap mechanism) **Status:** CLOSED 2026-06-12 — user re-gate ("Seems to have been @@ -5789,6 +6387,213 @@ outdoors at the angle that previously erased it. --- +## #192 — Login to a non-Holtburg position sometimes showed stabs/scenery floating in the wrong place + +**Status:** DONE (2026-07-09, `fa9aedca`, user visual gate passed: "Looks good"). User-reported +while testing tonight's A7 lighting/particle fixes; traced via a threading/lifecycle read of the +login path, not inference. `WorldSession` transitions to `InWorld` immediately after the login +handshake (`WorldSession.cs:608`) — well before the player's own spawn `CreateObject` (which +carries their real position) has arrived over the network. The streaming gate's old condition +(`!IsLiveModeWaitingForLogin || liveInWorld`) opened the instant `InWorld` fired, letting the +background streaming worker (`LandblockStreamer`'s dedicated `Thread`) build real landblocks +using whatever `_liveCenterX/Y` held at that moment — the Holtburg startup placeholder, not a +"not known yet" sentinel. A landblock that started building in that window bakes its world +offset from that placeholder at build time; if the build was still in flight when the real spawn +arrived and recentered the world (`ForceReloadWindow`, which only unloads already-*resident* +landblocks), it finished and got applied anyway — stale-positioned geometry landing wherever the +guess put it relative to whatever streamed in afterward with the corrected center. Explains both +observed traits: "sometimes" (depends on whether a pre-real-data build happened to be mid-flight +at the exact recenter moment — a genuine timing race) and specifically at login to a +non-Holtburg position (nothing to race against if the real spawn coincides with the placeholder). +User explicitly pushed back on "just use a different/no placeholder" — correctly: any placeholder +racing against the real answer reproduces the identical bug. Fix: +`AcDream.Core.World.StreamingReadinessGate.ShouldStream` requires an explicit `liveCenterKnown` +flag (true only once the player's own spawn has been processed) in addition to `liveInWorld` — +nothing streams in live mode until the real position is confirmed, so no placeholder value is +ever acted upon. Preserves the pre-existing `#106` gate-3 fix this gate originally existed for +(auto-entry waits for terrain under the spawn; terrain streaming must not wait for chase mode in +turn, or the two deadlock) since `liveCenterKnown` becomes true independently of chase mode, +driven purely by the spawn packet's arrival. The stricter render gate (`GameWindow.cs:9596`, +hides ALL world geometry until chase mode engages) was already a partial safety net and is +unchanged — this fix stops the stale geometry from ever being *built*, rather than relying on the +render gate to hide it until the reveal. Files: `src/AcDream.Core/World/StreamingReadinessGate.cs` +(pure, unit-tested gate predicate — the regression test asserts `liveInWorld` alone must NOT open +the gate), `src/AcDream.App/Rendering/GameWindow.cs` (`_liveCenterKnown` flag + call site). Core +2680+2skip / App 741+2skip / UI 425 / Net 385 green. + +--- + +## #93 — Indoor lighting broken (M1.5 lighting umbrella) + +**Status:** DONE (2026-07-09). Two real root causes found + fixed (A7.L1): (1) +`LightManager.BuildPointLightSnapshot` candidate-pool starvation in dense hubs — fixed by +scoping candidacy to last frame's rendered visible-cell set (`d275ed55`); (2) THE actual +fountain-room darkness — the mesh-empty hydration gate dropped an entity's whole +registration (Setup.Lights included) whenever its visual mesh flattened to zero parts, a +common "light attach point" dat pattern; fixed via `EntityHydrationRules.ShouldKeepEntity` +(`9ebb2060`) — dungeon-wide registered lights jumped 498→892. User-confirmed at the Town +Network fountain room ("lightning is better") and separately at a 2nd-floor room (`#80`, +re-verified fixed). `#189` (missing fountain particle, found investigating this same room) +turned out to be a third, unrelated bug (`#190`, entity-id overflow), also closed. `#94` +(held-item spotlight) does NOT gate this closure — it's currently untestable (acdream +doesn't yet support equipping hand-held items) and stays open on its own, blocked on that +unrelated feature. Files: `src/AcDream.Core/Lighting/LightManager.cs` +(`BuildPointLightSnapshot`), `src/AcDream.App/Rendering/GameWindow.cs` (hydration gate, +`_lightPoolVisibleCells`), `src/AcDream.Core/Meshing/EntityHydrationRules.cs`. Apparatus: +`Issue93TownNetworkFountainRoomLightInspectionTests` (dat-truth, reusable). + +--- + +## #80 — Camera on 2nd floor goes very dark + +**Status:** DONE (2026-07-09, user re-verified: "Number 80 is closed, I verified again"). +Closed as part of the `#93`/A7.L1 lighting-umbrella fix arc (candidate-pool scoping + +mesh-less light-carrier hydration, `d275ed55` + `9ebb2060`) — not independently +root-caused to this specific symptom, but the user's direct re-check at a 2nd-floor room +confirmed it's fixed. See `#93` for the fix mechanism. + +--- + +## #189 — Ambient particle scripts (fountain water, possibly candle flames) don't render indoors + +**Status:** DONE (2026-07-09, user visual gate passed — "Fountain is back! We +can close it"). Root cause was NOT the A7.L1 mesh-carrier hydration fix itself +(the fountain's Setup `0x02000AA3` always had a surviving mesh part + a real +`DefaultScript.DataId`) — it was `#190`, an entity-id overflow that fix +triggered as a side effect (see `#190` below for the full mechanism). Fixed by +`e651cb6d`; `ACDREAM_DUMP_ENTITY` confirmed the fountain's id decodes +correctly post-fix, and the user confirmed the water spray visually. **Residual +note, not re-raised by the user, kept for a future session:** the guessed +"candle" objects (`0x02001967`, 16 arranged around the fountain) turned out to +have real mesh and `DefaultScript == 0` — not candles, no script at all — so +if candle-flame absence resurfaces, the actual source objects in this room are +still unidentified. + +--- + +## #190 — Interior entity id counter overflowed past its 8-bit budget, aliasing into the next landblock + +**Status:** DONE (2026-07-09, `e651cb6d`). Found while investigating #189 +(missing fountain particle): a user-requested revert-test of the A7.L1 light +fix (9ebb2060) made the fountain work again, which didn't fit the earlier +dat-truth finding that the fountain's own entity was untouched by that fix. +Traced with `ACDREAM_DUMP_ENTITY`: the fountain's hydrated `entity.Id` shifted +between reverted (`0x400007F8`) and fixed (`0x40000815`) builds — the extra +mesh-less light carriers the A7.L1 fix now keeps alive earlier in the same +landblock's hydration pass shifted `localCounter`. `0x40000815` decodes as +landblock Y=0x08 — NOT the Town Network's true Y=0x07 — the exact `#119` +cross-landblock id-aliasing bug, reincarnated by entity COUNT (277, past the +8-bit/256 budget) rather than a computation bug; the `#119` fix's own comment +had explicitly flagged this as a residual risk ("counter overflow past 0xFF +still bleeds into the lbY byte"). `EntityScriptActivator` keys particle-script +instances by `entity.Id` directly (no landblock-hint disambiguation, unlike +`#119`'s Tier-1 batch cache), so the aliased id silently broke the fountain's +script tracking. Fix: `AcDream.Core.World.InteriorEntityIdAllocator` widens the +counter 8→12 bits (256→4096) by shrinking the fixed class-prefix from a full +byte (`0x40`) to its top nibble (`0x4_`) — verified safe against every +`entity.Id` classification check in `GameWindow.cs` (none decode X/Y back out, +only threshold/prefix checks). Added a loud one-time `[id-overflow]` log if a +landblock ever exceeds the new budget. Post-fix: fountain's id (`0x40007115`) +decodes correctly (Y=7, counter=277, safely under 4095). Core 2675+2skip / +App 741+2skip / UI 425 / Net 385 green. + +--- + +## #170 — Remote creature chase+attack renders wrong vs retail (glide, run not sustained) + +**Status:** DONE (2026-07-04, user visual gate passed — "as close to retail now as +I can see"). Three-fix arc: `427332ac` deleted the per-frame +`apply_current_movement` re-dispatch that flooded `pending_motions` to ~1.3M +(chase turn permanently blocked → slide); `d2ccc80e` refreshed remote body +velocity from `get_state_velocity`; `1051fc83` fixed the residual — the +SERVERVEL per-tick branch skipped `MoveToManager.UseTime` for any UP-receiving +NPC, starving the armed moveto for the whole server-side chase (funnel 16 arms → +1 run install; retail runs `MovementManager::UseTime` unconditionally, +`UpdateObjectInternal` 0x005156b0 @0x00515998) — an armed moveto now always takes +the MOVETO leg. The intermediate "Ready drain too slow" hypothesis was DISPROVEN +by the full-stack offline harness (`RemoteChaseEndToEndHarnessTests` + +`RemoteChaseDrainBisectTests`, kept as conformance). Register: TS-41 narrowed, +TS-42 added (one-frame drain-order divergence, R6). Gate telemetry +(launch-170-gate2.log): installs ≈ arms for every creature, zero armed-moveto +UseTime skips, queue depth 1. Probes stripped in the closing commit. The full +investigation record stays in the OPEN-section body (moves here on next tidy) + +`docs/research/2026-07-04-170-creature-run-handoff.md`. + +## #163 — Strip the R4-V5 stall-investigation diagnostics + +**Status:** DONE (2026-07-03, `5ebe2be3`) — removed `[autowalk-gate]` (+ +`_lastAutowalkGateLogTime` throttle clock, PlayerMovementController), +`[autowalk-feed]` (GameWindow player tracker feed), and the short-lived +`[MOVETO-CANCEL]` #162 capture probe. The durable `ProbeAutoWalk` family +(PhysicsDiagnostics owner + DebugPanel toggle + the permanent `[autowalk]` +probe sites) stays. Suite 3,964 green. + +## #162 — Observer-side moveto cancelled by ACE's autonomous MTS reflections (the "glide" class) + +**Status:** DONE (2026-07-03) — resolved WITHOUT adaptation; user-verified. +The user's A/B came back **retail does NOT glide** (new-fact branch), and +the follow-up acdream capture (launch-162, post-#161) showed acdream now +matches: walk/run by distance on mt-6 movetos (retail +`MovementParameters.GetCommand` threshold), clean takeover on a mid-chain +key press. Three-part evidence: +1. **Mechanism re-audit vs raw:** the head-interrupt IS unconditional + (`unpack_movement` 0x00524440 → `interrupt_current_movement` 0x005101f0 + → `MovementManager::CancelMoveTo(0x36)`), and `MoveToManager::CancelMoveTo` + (0x00529930) is gated on an ARMED moveto (drain + CleanUp + + StopCompletely; no-op otherwise). Our ports are verbatim — retail's + observer loses its armed moveto on the first reflection TOO. +2. **Wire capture:** ACE's mt-0 reflections carry the mover's REAL + locomotion (WalkForward @ -2.92 backward, RunForward @ 4.50, turns) — + so a cancel is always followed by correct legs; the no-glide outcome + needs no moveto protection. The `[MOVETO-CANCEL]` probe showed zero + mover-side cancels in normal use-walks (the mover's client doesn't emit + MTS mid-chain unless keys are pressed) and retail-correct + replace-cancels on an NPC's own successive TurnToObject UMs. +3. **The originally-observed glide is no longer reproducible** — killed by + the R4-V5 fix stack (un-ticked remote MoveToManagers `006cf659`, TS-40 + link-strip `350fb5e3`, #160 run-rate `41006e79`) + #161's apply-pass + params fix `b1cf0102` (ModifyInterpretedState=true corrupted interpreted + state on EVERY UM apply, not just landings). +The theorized "narrow ACE-compat adaptation" is dead — nothing to adapt. + +## #161 — Remote jump landing holds the falling pose (no landing anim) + +**Status:** DONE (2026-07-03, `b1cf0102`) — user live-verified ("Yes works!"). +Three legs, all retail-decode, zero adaptations added: +1. **Apply-pass params:** retail's `apply_interpreted_movement` runs ALL its + dispatches with `ModifyInterpretedState=false` — the ctor default 0x1EE0F + is REWRITTEN by a bitfield store the BN decomp smears into the mush + expression at raw 305778 (`(word & 0x37ff) | cancelMoveTo<<15 | + disableJump<<17`; 0x37ff clears SetHoldKey/ModifyInterpretedState/ + CancelMoveTo). ACE MotionInterp.cs:444-449 confirms. Our pass dispatched + with ctor defaults → the airborne Falling substitution clobbered + `InterpretedState.ForwardCommand` → HitGround's re-apply re-dispatched + Falling instead of the preserved pre-fall wire command. (The retail exit: + fwd is PRESERVED through the fall; HitGround re-dispatches it; the motion + table plays the Falling→X landing link — no wire input needed.) Bonus + decode: raw arg3 = DisableJumpDuringLink, so `(N, 0)` callers mean + allowJump=TRUE — all 9 caller polarities fixed; the W6 entry-cache + (built on the wrong "retail self-heals via hoisted registers" theory) + deleted; `copy_movement_from`'s `current_style` copy (raw 0051e757) + added to the UM flat-copy. NOTE: the handoff's "HitGround raw @305949" + was a mislabel — 305949 is inside `move_to_interpreted_state`; real + HitGround is 0x00528ac0 → `apply_current_movement(0,0)`. +2. **Landing order:** both GameWindow landing blocks cleared the Gravity + state bit BEFORE `Motion.HitGround()`, whose verbatim `state & 0x400` + gate no-opped the whole retail re-apply (retail never clears GRAVITY on + landing); the UP-driven block never called HitGround at all. Both now: + transients → `Motion.HitGround()` → `MoveTo.HitGround()` → THEN the DR + gravity-clear (register row AP-81; retire in R6). +3. **K-fix17 (the handoff's Q3):** its SetCycle DID execute — and re-set + the Falling cycle, because it read the leg-1-clobbered ForwardCommand + (0x40000015 ≠ 0 defeated the Ready fallback). Both SetCycle blocks + deleted — superseded by the retail path, which also plays the landing + LINK animation SetCycle never did. +Tests: `HitGround_AfterFall_RedispatchesPreservedForward_ExitsFalling` +lifecycle pin; `AirborneBody_NoCycleDispatches_OnlyTurnStop` assertion +flipped (it had PINNED the bug value). Suite 3,964 green. Spawned #164 +(action-replay Autonomous bit). + ## #150 — Open doors still blocked at the threshold (ethereal target not skipped in the step-down pass) **Status:** DONE (2026-06-25) — after the retail collision sweep, an OPEN door @@ -5910,63 +6715,10 @@ The burden bar now reads the server's wire `EncumbranceVal` (PropertyInt 5) inst --- -## #113 — Phantom staircase: REOPENED 2026-06-11, folded into the HOLISTIC BUILDING-RENDER PORT +## #113 — Phantom staircase / holistic building-render port -**Status:** REOPENED — root cause #2 found (drawing-BSP-orphaned no-draw polys: -hall model 0x010014C3 keeps its walkable stair-ramp as dict polys {0,1}, in the -PhysicsBSP, referenced by NO DrawingBSP node — retail never draws them, we -iterate the dictionary). The mechanical filter (`e46d3d9`) removed the phantom -everywhere (user-verified) but made DOORS vanish across Holtburg → un-applied -(`124c6cb`, helper + dat pins kept). Per the user's 2026-06-11 mandate ("solve -this holistic once and for all"), #113/#114/#108/#109/the door mystery/#99 are -now ONE effort: map acdream-vs-retail for building draw / interiors / interior -collision / dynamics / clipping / culling, then port retail's drawing -discipline. **CHARTER + paste-ready next-session prompt:** -[docs/research/2026-06-11-building-render-holistic-port-handoff.md](../research/2026-06-11-building-render-holistic-port-handoff.md). -The shell-clip work below remains in (outdoor-scoped) and correct. - -### (history) PView shell clip was never GL-enabled — 927fd8f + scope 9ce335e - -**Status:** FIXED (self-gated by screenshot comparison at the original spot — -phantom gone; formal user visual gate pending) -**Closed:** 2026-06-10 -**Component:** render (PView shell pass GL state) - -**Attribution (dat-evidenced — the filed "A9B3 misplaced interior cell" -hypothesis is REFUTED):** the building is the Holtburg MEETING HALL — AAB3 -building[0], model `0x010014C3` at AAB3-local (36,84,116), not an A9B3 -building (A9B3 has exactly ONE building, the #112 hill cottage; the user -stood at the A9B3/AAB3 boundary — `issue112-gate1.log` cell-transit trail — -and clicked through the hall to the NPC behind it). The hall's interior -stair cells (0x100..0x106, a ring climbing z 116→124.5 to the deck hatch) -have geometry COINCIDENT with the shell's west wall (both at local x=29.0). - -**Root cause:** retail clips drawn CELL geometry to the accumulated portal -view (`Render::set_view` :343750 + `planeMask=0xffffffff` per cell polygon -:427922 → `polyClipFinish`). Our equivalent — `UseShellClipRouting` → -`mesh_modern.vert` `gl_ClipDistance` — was routed with CORRECT tight clip -regions (`Issue113MeetingHallFloodTests` proves 4–6 planes, door-aperture -NDC boxes) but was INERT: `gl_ClipDistance` writes are ignored unless -`GL_CLIP_DISTANCEi` is enabled, and no caller ever enabled it for the shell -pass (born inert in `1405dd8`). Flooded interior cells drew WHOLE → the -interior staircase painted across the exterior wall; unpickable because -it's cell geometry. 5th instance of -`feedback_render_self_contained_gl_state`. - -**Fix (`927fd8f`):** enable `GL_CLIP_DISTANCE0..7` around exactly the shell -pass in `RetailPViewRenderer.DrawEnvCellShells` (no early-outs between set -and restore). Entities/characters stay unclipped (retail's mesh path is -viewcone-check, not poly-clip — comment scoped). Known remaining -approximation: slot-0 fallback slices (>8-plane apertures) still draw -pass-all — the assembler's scissor fallback remains unimplemented (rare; -pinned 0 such slices at the hall). - -**Refuted along the way (evidence in `Issue113PhantomStairsDumpTests`):** -the unifying misplaced-cell hypothesis — all 17 A9B3 cottage cells share -one identical dat Position (nothing to misplace); the #112 gap is a real -20 cm doorway micro-gap, not a displaced volume; missing object collision -remains #99/A6.P4. A9B3's dat has NO stair geometry anywhere near the spot -(shell = balcony slabs z119 + turret roof; cells flat 116/118.8). +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +The Holtburg meeting-hall's walkable stair-ramp painted across the exterior wall because the PView shell-clip pass computed correct clip regions but never enabled `GL_CLIP_DISTANCE` — fixed by `927fd8f`. The bug reopened 2026-06-11 when a second root cause surfaced (dictionary-referenced-but-undrawn BSP polys drawn that retail never draws); per the user's mandate this was folded into the holistic building-render port effort (#113/#114/#108/#109/#99, charter at `docs/research/2026-06-11-building-render-holistic-port-handoff.md`), which shipped as part of the broader render-pipeline redesign (Option A) closed 2026-06-12. ## #111 — ACE-mutated indoor restores: transparent interior / wrong placement at login — [DONE 2026-06-10 · 5f1eb7c + 5706e0e + 2735695] @@ -6826,6 +7578,186 @@ Regen workflow: `py tools/pdb-extract/pdb_extract.py refs/acclient.pdb`. The com **Commit:** `feat(player): #5 PlayerDescription parser — Stam/Mana via attribute block` **Resolution:** First attempt (commit `d42bf57`) used `AppraiseInfoParser` for `PlayerDescription (0x0013)` — wrong wire format. ACE source confirmed via `GameEventPlayerDescription.WriteEventBody`: PlayerDescription is hand-written (DescriptionPropertyFlag-driven property hashtables, vector flags, attribute block, skills, spells, options/inventory tail) — distinct from `IdentifyObjectResponse (0x00C9)`'s `AppraiseInfo.Write`. Pivoted to a real port: new `PlayerDescriptionParser.cs` that walks property hashtables (Int32/Int64/Bool/Double/String/Did/Iid + Position) gated on the property flags, then reads vector flags + has_health + the attribute block where vitals 7/8/9 carry `ranks/start/xp/current`. Also redesigned `LocalPlayerState` to track per-vital snapshots (replacing the sentinel-API of attempt 1) plus per-attribute snapshots, with `GetMaxApprox` applying the retail formula `vital.(ranks+start) + attribute_contribution` (Endurance/2 for Health, Endurance for Stamina, Self for Mana). Live verified: `+Acdream` shows three bars; ~95% reading on Stam/Mana traced to active buff multipliers (filed as #6). Wire-port also added `PrivateUpdateVital (0x02E7)` + `PrivateUpdateVitalCurrent (0x02E9)` for delta updates per holtburger `UpdateVital`. ~700 LOC C#, 30+ new tests. +## #59 — WorldPicker 5m fixed-radius could over-pick at tight thresholds (M1-deferred polish) + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +`WorldPicker.Pick` used a hardcoded 5m sphere around every candidate regardless of the entity's actual size, relying on the `ServerGuid==0` skip filter plus closest-wins logic to avoid mis-picks. User confirms this is resolved. Files: `src/AcDream.Core/Selection/WorldPicker.cs`. + +--- + +## #117 — Aperture-shaped see-through: doors/interiors visible through terrain hills and through nearer buildings + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Doors/interiors were visible through terrain hills and through nearer buildings because the far-Z stencil punch erased the depth of nearer occluders at aperture pixels, letting later-drawn dynamics paint over them. Fixed in commit `478c549`; the issue's own title already recorded the user's 2026-06-11 re-gate confirmation ("Yes solved"). + +--- + +## #133 — Teleport into a dungeon snaps the player BEFORE the dungeon landblock streams in → lands at the old landblock's frame (ocean), not the dungeon + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Teleporting into a dungeon snapped the player onto the OLD (Holtburg) landblock before the destination dungeon streamed in, dropping them into the ocean instead of the dungeon. Fixed by Phase G.3a: `TeleportArrivalController` holds the position snap until the destination landblock/cell hydrates (`7947d7a`/`aca4b46`/`f22121b`), plus the validated-claim landblock-prefix fix (`2ce5e5c`) and a login-spawn recenter fix (`47ae237`) for the sibling case of logging in already inside a dungeon. A follow-up streaming-collapse fix (2026-06-14) also resolved the low-FPS/grey-barrier symptoms discovered at the same gate. + +--- + +## #78 — Outdoor geometry (stabs + terrain mesh) visible inside EnvCells + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Standing inside a building, outdoor terrain and stab geometry rendered through the floor/walls because acdream enforced indoor visibility via three inconsistent gates instead of retail's single PView gate. This was the founding bug behind the full render-pipeline redesign (Option A, one `DrawInside(viewer_cell)` traversal — see `docs/research/2026-05-31-render-architecture-reset-handoff.md`), closed as part of the broader #119/#128 render arc (2026-06-12); see `project_render_pipeline_digest.md`. + +--- + +## #103 — Phase A8.F portal-frame indoor rendering broken at runtime (visual-gate failure) + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +The A8.F two-pipe (inside/outside) portal-frame renderer (`ACDREAM_A8_INDOOR_BRANCH=1`) was abandoned wholesale rather than fixed in place — Phase U (Unified Render Pipeline, 2026-05-30) deleted the broken `RenderInsideOut` two-pipe path and replaced it with the single unified retail PView portal-visibility pipeline that the render digest now treats as canonical. See `docs/research/2026-05-30-unified-render-pipeline-decision-and-handoff.md`. + +--- + +## #79 — Indoor lighting: spurious spot lights on walls + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Torch point-lights on interior walls in Holtburg Inn showed as spurious spot-light-like patches not matching retail's falloff/direction. User confirms this is resolved, most likely as part of the broader A7 indoor-lighting umbrella work (#93/#80/#154) that corrected `LightManager` candidate-pool scoping and per-light parameter handling. Files: `src/AcDream.Core/Lighting/LightInfoLoader.cs`, `mesh_modern.frag` `accumulateLights`. + +--- + +## #82 — Some slope terrain lit incorrectly + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Some terrain slopes in Holtburg were lit differently than retail, suspected to be a terrain-normal / landblock-edge normal-blending divergence between WorldBuilder's split formula and retail's `FSplitNESW`. User confirms this no longer reproduces. Files: `TerrainModernRenderer.cs`, `terrain_modern.frag`. + +--- + +## #154 — Dungeon interiors still read too dim vs retail (torch-sparse stretches + per-vertex bake) + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +After the initial indoor-lighting fixes (`0d8b827`/`57c2ab7`) dungeons were brighter than the old flat-0.2 ambient but still trailed retail, especially in torch-sparse corridors. User confirms this is now resolved — consistent with the same-day A7 dungeon-lighting root-cause work (the "463>128 light cap" fix in the most recent commit history) that closed the sibling #93/#80 lighting issues. + +--- + +## #83 — Indoor multi-Z walking broken (cellars, 2nd floors, intermittent falling-stuck) + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Walking down into cellars and on 2nd floors was broken (stuck/falling); root cause was `TryFindIndoorWalkablePlane` synthesizing a fresh `ContactPlane` every frame instead of retaining the previous frame's plane like retail. User confirms this is resolved, consistent with the later A6.P4 per-cell collision architecture (shipped 2026-06-11) and the subsequent #137/#171/#182 physics fixes that completed the retail-faithful collision port this issue was blocked on. + +--- + +## #88 — Indoor static objects vibrate (bookshelves, open furnaces) + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Static cell objects (bookshelves, open furnaces) showed per-frame transform jitter, suspected sub-step state corruption or floating-point drift in per-part transform recomputation. User confirms this no longer reproduces, likely resolved alongside the A6.P4 physics architecture and subsequent entity-transform stabilization work. + +--- + +## #89 — Port BSPQuery.SphereIntersectsCellBsp for retail-faithful CheckBuildingTransit + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +`CellTransit.CheckBuildingTransit` used a radius-less point-in-BSP test instead of retail's sphere-vs-BSP `CCellStruct::sphere_intersects_cell`, making outdoor→indoor entry fire ~sphereRadius deeper into doorways than retail. User confirms this is resolved, consistent with the A6.P4 per-cell shadow-list collision architecture (shipped 2026-06-11) which ported retail-faithful building-transit checks. Files: `src/AcDream.Core/Physics/CellTransit.cs`, `BSPQuery.cs`. + +--- + +## #134 — Player "lags downward" instead of gliding along a dungeon ramp edge + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Running along a dungeon ramp's edge produced a downward "lag" instead of a slide along the slope tangent, surfaced by the #133 connector-cell physics fix exercising the ramp's collision for the first time. User confirms this is resolved, consistent with the later CSphere/CCylSphere collision-family ports (#172, #182) and the general slide-response work tracked under #32/#116. + +--- + +## #46 — Retail observer of acdream sees blippy / laggy movement + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +A retail client observing acdream's locally-driven `+Acdream` character saw stepped/blippy movement, suspected `AutonomousPosition` heartbeat cadence or `MoveToState` state-change-detection mismatches on the outbound path. User confirms this is resolved — matches the L.2b outbound wire-parity work per `project_retail_motion_outbound.md`. + +--- + +## #122 — Windows oscillate between background and the correct outside view when entering houses + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Windows flickered between the background/skybox and the correct outside view while entering houses (the #109 oscillation family localized to windows at the outdoor→interior root flip). User confirms this is resolved, consistent with the render-pipeline redesign (Option A, one `DrawInside(viewer_cell)`) that closed the broader #119/#128 flap family on 2026-06-12. + +--- + +## #123 — Buildings transiently disappear when running close past them + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Whole buildings transiently vanished when the player ran close past them at the outdoor root, suspected frustum pre-gate or stencil-punch interaction at close range. User confirms this is resolved, consistent with the render-pipeline redesign (Option A) that closed the broader #119/#128 flap family on 2026-06-12. + +--- + +## #179 — Lightning flash has no indoor gate (dormant until weather strobes ship) + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +`mesh_modern.frag` added the lightning-flash term to every fragment (including sealed-dungeon interiors) with no indoor gating, latent until weather strobes ship. User confirms this is resolved — the flash term is now gated for `playerInsideCell` frames (or zeroed at the `SceneLightingUbo` build), matching retail's flat indoor ambient with no storm terms. + +--- + +## #65 — Local player doesn't turn to face target on close-range Use + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +ACE's close-range Use path sends a `MovementType=8 TurnToObject` motion that acdream's `OnLiveMotionUpdated` didn't handle, so the local player completed the Use without visibly turning to face the target. User confirms this is resolved, consistent with the R4/R5 `MoveToManager` arc that ported retail's TurnTo handling for local and remote entities (superseding the older `RemoteMoveToDriver`). + +--- + +## #66 — Local + remote rotation: player flips back, NPCs don't turn + +**Status:** DONE (2026-07-09, user-confirmed via memory during an issues-triage pass — not independently re-verified this session). +Two related rotation bugs: the local player's facing snapped back after auto-walk arrival, and NPCs didn't turn to face the player on `MovementType=8 TurnToObject` motions (acdream only handled `MovementType=6 MoveToObject`). This issue explicitly superseded #65 as the broader TurnToObject-handling ticket. User confirms both are resolved, consistent with the R4/R5 `MoveToManager` arc's retail-faithful TurnTo port for local and remote entities. + +--- + +## #96 — Per-tick PhysicsEngine.ResolveWithTransition CP seed (retail divergence) + +**Status:** DONE (2026-07-09, investigated this session). +#96 was never a plain bug to fix — by 2026-05-22 (commits `892019bc`/`f8d669be`) the project determined the per-tick `ContactPlane` seed at `PhysicsEngine.cs` is load-bearing (BSP step_up on the last stair step depends on it) and formally reclassified it as an accepted retail divergence rather than a defect. It's tracked today as register row **IA-1** in `docs/architecture/retail-divergence-register.md` (retail: `CTransition::init`, pc:272547) rather than as an open bug. The code today still matches the issue's description exactly (verified at `PhysicsEngine.cs:979-1010`), so nothing was "fixed" in the traditional sense — the issue was superseded by the divergence-register entry as its permanent home. + +--- + +## #60 — `obstruction_ethereal` retail downstream path not ported (M2 combat-HUD impact) + +**Status:** DONE (2026-07-09, investigated this session). +Fixed by `3361a8d7` and `dc1e9270` (2026-06-24). `CollisionExemption.ShouldSkip` now requires both `ETHEREAL_PS` and `IGNORE_COLLISIONS_PS` for the Gate-1 exempt; ETHEREAL-alone now sets `SpherePath.ObstructionEthereal` and flows through BSP/Sphere/Cylinder consume sites matching retail pc:276782/276806/276989/321692/324573. Divergence-register row AD-7 retired same commit. `ObstructionEtherealTests.cs` passes 11/11. + +--- + +## #68 — Remote players don't stop running animation on auto-walk arrival + +**Status:** DONE (2026-07-09, investigated this session). +The mechanism named as the suspect in #68 (`RemoteMoveToDriver`'s arrival handling not flipping the animation cycle to Ready) was deleted wholesale in commit `7016b26c` (R4-V4, 2026-07-03), replaced by a verbatim-ported retail `MoveToManager` for every remote. The same day, commit `c2dc1a88` (R4-V5) fixed exactly the class of bug #68 describes: `StopCompletely` (which `MoveToManager`'s arrival path calls) wasn't reaching the entity's `AnimationSequencer` at all — it's now wired through `IInterpretedMotionSink.StopCompletely()` → `MotionTableDispatchSink` → `sequencer.PerformMovement(StopCompletely())`, confirmed live-wired for remotes in `GameWindow.EnsureRemoteMotionBindings`. No commit references "#68" explicitly and no user visual re-verification of this specific scenario is on record post-fix — recommend a spot-check (retail player auto-walking to an NPC, watched from acdream) if it resurfaces. + +--- + +## #87 — Drop WB fork patch by switching to PrepareEnvCellGeomMeshDataAsync + +**Status:** DONE (2026-07-09, investigated this session). +Superseded by Phase O (2026-05-21, dropped the `WorldBuilder.Shared`/`Chorizite.OpenGLSDLBackend` project references entirely — there's no more forked submodule to patch/revert) and Phase A8 (2026-05-28, shipped `EnvCellRenderer.cs` which already calls the narrow `PrepareEnvCellGeomMeshDataAsync(geomId, environmentId, cellStructure, surfaces)` entry point at `EnvCellRenderer.cs:355`, using the bit-32-tagged synthetic geom id the issue proposed). `ObjectMeshManager.cs`'s bounds/type dispatch now branches on resolution type before calling `TryGet`, so the blind `TryGet` bug is structurally gone. `EnvCellRenderer` remains the live production cell-rendering path under Phase U as of commit `6aabe0b5` (Jul 6 2026). Note: a second, unrelated, already-DONE issue also uses the heading `## #87` elsewhere in this file (a pre-existing numbering collision, left untouched). + +--- + +## #126 — Outdoor spawn claim on a building roof is grounded THROUGH the roof to terrain (transparent-interior spawn) + +**Status:** DONE (2026-07-09, investigated this session). +Fixed same-day as filed (2026-06-11) by commit `120aeff7` "RETAIL-CORRECTED: restores commit the server Z — retail never re-derives position from surfaces" (superseding an earlier same-day attempt `b94a7e80` that the user caught as retail-divergent). The outdoor zero-delta-restore branch in `src/AcDream.Core/Physics/PhysicsEngine.cs` now commits the claim's Z verbatim (matching retail's `CPhysicsObj::SetPositionInternal`, 0x00515bd0) instead of unconditionally grounding to terrain, eliminating the roof-to-interior warp. Verified present, unmodified, at HEAD. + +--- + +## #4 — Sky horizon-glow disabled (fog-mix skipped on sky meshes) + +**Status:** DONE (2026-07-09, investigated this session). +The literal bug as filed — fog-mix skipped on sky meshes — is no longer true. Commit `97fc1b51` (2026-04-27) re-enabled sky fog using a retail-cited 3D range-fog formula (`docs/research/2026-04-23-sky-fog.md`, which root-caused retail's actual horizon-glow mechanism: sky domes saturate to `WorldFogColor` by design because their intrinsic radius sits near/past keyframe FogEnd — same fog path as terrain, no special sky-only rule needed). Author noted user visual verification against retail screenshots; the fix has shipped unmodified for 2.5+ months through several subsequent commits. Follow-up: the `SKY_FOG_FLOOR=0.2` mitigation clamp layered on top still lacks a divergence-register row. + +--- + +## #81 — Static building stabs don't react to atmospheric lighting changes + +**Status:** DONE (2026-07-09, investigated this session). +Fixed by the A7 lighting rework, specifically A7 Fix D (`0980bea4`, `cf627933`, `c62da825`, `b7d655bc`, 2026-06-18/19). That work split the previously-unified lighting shader into an explicit object-path (`uLightingMode=0`) vs EnvCell-interior-path (`uLightingMode=1`): building exterior shells (stabs, `IsBuildingShell`/`ParentCellId==null`) are object-path entities and now read the same per-frame `SceneLighting` UBO (sun direction/color + ambient, rebuilt every frame from the live `SkyKeyframe`) that terrain and scenery already consumed — so stabs now darken/brighten in lockstep with the day/night cycle by construction. No dedicated visual re-check specific to stabs-vs-daycycle is on record, but the code mechanism the issue blamed no longer exists. + +--- + +## #33 — Live entity collision shape collapses to one cylinder + +**Status:** DONE (2026-07-09, investigated this session). +The described mechanism (live entities collapsing to one root-centered cylinder) no longer exists. `RegisterLiveEntityCollision` (`GameWindow.cs:4244`) now builds a multi-shape list via `ShadowShapeBuilder.FromSetup` — one shape per CylSphere, Sphere, and BSP-bearing Part — and registers via `RegisterMultiPart` (A6.P4 Task 7, `ca9341c2`). The retail `CSphere` and `CCylSphere` collision families were ported verbatim in `78e57581` (sphere primitive), `6ab26989` (fix #172, CCylSphere family), and `96ae2740` (fix #182, CSphere family, retires TS-45). The remaining `setup.Radius` single-cylinder path is now a deliberately-audited fallback used only when no other shape data exists. `tests/AcDream.Core.Tests/Physics/ShadowShapeBuilderShapeSourceTests.cs` covers both a multi-shape object and a live-creature case. + + + + + + + + + + +``` + +NOTE: `Chorizite.DatReaderWriter` flows transitively via AcDream.Core. If the moved code fails to resolve DRW types, add the explicit `PackageReference` pinned to the same version as Core (2.1.7) rather than bumping anything. + +- [ ] **Step 2: Register in `AcDream.slnx`** — add the project entry following the existing `` pattern (open the file, copy the shape). + +- [ ] **Step 3: App references Content** — in `src/AcDream.App/AcDream.App.csproj`, add alongside the existing ProjectReferences: + +```xml + +``` + +- [ ] **Step 4: Build** + +Run: `dotnet build` +Expected: green (empty project compiles, references resolve). + +- [ ] **Step 5: Commit** + +```bash +git add src/AcDream.Content/ AcDream.slnx src/AcDream.App/AcDream.App.csproj +git commit -m "feat(pipeline): MP1a - AcDream.Content assembly scaffold" +``` + +--- + +### Task 2: Lift TextureKey out of TextureAtlasManager + +**Files:** +- Create: `src/AcDream.Content/TextureKey.cs` +- Modify: `src/AcDream.App/Rendering/Wb/TextureAtlasManager.cs` (delete the nested struct, use the lifted one) +- Modify: every `TextureAtlasManager.TextureKey` reference site (find with `grep -rn "TextureAtlasManager.TextureKey" src/`) + +- [ ] **Step 1: Move the struct.** Copy the nested `TextureKey` struct out of `TextureAtlasManager` VERBATIM (fields, equality/GetHashCode if present, doc comments) into: + +```csharp +namespace AcDream.Content; + +// MP1a (2026-07-05): lifted verbatim out of TextureAtlasManager (GL class) +// so the GL-free mesh-extraction path (MeshExtractor / ObjectMeshData) can +// reference the atlas dedup key without a Silk.NET dependency. Field set, +// equality semantics, and hash behavior are UNCHANGED. +public struct TextureKey +{ + // ... the verbatim body from TextureAtlasManager.TextureKey ... +} +``` + +(The plan intentionally does not restate the body — copy it exactly from the source; it is pure data: SurfaceId/PaletteId/Stippling/IsSolid per the boundary survey.) + +- [ ] **Step 2: Update all reference sites.** `TextureAtlasManager.TextureKey` → `TextureKey` with `using AcDream.Content;`. Keep a `using` alias only if a name collision appears (none expected). + +- [ ] **Step 3: Build + full test suite** + +Run: `dotnet build` then `dotnet test` +Expected: green / all passing (this is a pure type relocation). + +- [ ] **Step 4: Commit** + +```bash +git add -A +git commit -m "refactor(pipeline): MP1a - lift TextureKey out of the GL atlas class" +``` + +--- + +### Task 3: Move the boundary data records + +**Files:** +- Create: `src/AcDream.Content/ObjectMeshData.cs` +- Modify: `src/AcDream.App/Rendering/Wb/ObjectMeshManager.cs` (types removed), all reference sites (`grep -rn "ObjectMeshData\|VertexPositionNormalTexture\|TextureBatchData\|MeshBatchData" src/ tests/`) + +- [ ] **Step 1: Move these types from `ObjectMeshManager.cs`'s data region into `AcDream.Content` (namespace `AcDream.Content`), VERBATIM:** `VertexPositionNormalTexture` (the 32-byte GPU vertex — this is the pak layout target, do not alter layout/stride), `ObjectMeshData`, `MeshBatchData`, `TextureBatchData`, plus any small GL-free records the compiler then demands (e.g. setup-part / emitter-info records referenced by `ObjectMeshData` fields). + + **Explicitly stays in App:** `ObjectRenderData` and `ObjectRenderBatch` (they hold `TextureAtlasManager Atlas` — a GL class) and anything else the compiler shows touching GL. If `ObjectMeshData` itself turns out to hold a GL-typed field the survey missed, STOP and report BLOCKED. + +- [ ] **Step 2: Update reference sites** (`using AcDream.Content;` in the App files + any tests). + +- [ ] **Step 3: Build + full test suite** — green / all passing. + +- [ ] **Step 4: Commit** + +```bash +git add -A +git commit -m "refactor(pipeline): MP1a - ObjectMeshData family moved to AcDream.Content" +``` + +--- + +### Task 4: Extract MeshExtractor (the Prepare* family) + +**Files:** +- Create: `src/AcDream.Content/MeshExtractor.cs` +- Move as the compiler demands: `IDatReaderWriter.cs`, `DatCollectionAdapter.cs`, `AcSurfaceMetadata.cs`, `AcSurfaceMetadataTable.cs`, `EdgeLineBuilder.cs`, `GeometryUtils.cs` from `src/AcDream.App/Rendering/Wb/` → `src/AcDream.Content/` (verbatim, namespace change only) +- Modify: `src/AcDream.App/Rendering/Wb/ObjectMeshManager.cs` + +- [ ] **Step 1: Create the extractor class.** New class in Content: + +```csharp +namespace AcDream.Content; + +/// +/// MP1a (2026-07-05): the GL-free CPU half of the former ObjectMeshManager — +/// dat read → polygon walk → vertex/index build → inline texture decode → +/// . Extracted VERBATIM so the MP1b bake tool +/// and the live client run the SAME extraction code (byte-identical output +/// is the pak conformance foundation). ObjectMeshManager (App) retains the +/// queue/worker lifecycle and all GL upload; it delegates here. +/// Spec: docs/superpowers/specs/2026-07-05-modern-pipeline-design.md §6.1. +/// +public sealed class MeshExtractor +{ + // Constructor takes the extraction dependencies the moved methods used + // as ObjectMeshManager fields — expected from the boundary survey: + // IDatReaderWriter dats, AcSurfaceMetadataTable surfaceMetadata + // plus the CPU-side caches that belong with extraction: + // the ThreadLocal, the decoded-texture cache, bounds cache. + // Let the compiler produce the exact list — add fields here, do not + // leave them behind in App if only Prepare* uses them. +} +``` + +- [ ] **Step 2: Move the methods VERBATIM onto `MeshExtractor`, making the entry points `public`:** `PrepareMeshData`, `PrepareGfxObjMeshData`, `PrepareEnvCellMeshData`, `PrepareCellStructMeshData`, `PrepareSetupMeshData`, `PrepareCellStructEdgeLineData`, and the private helpers they call (`CollectParts`, `ComputeBounds`, `CollectDrawingBspPolygonIds`, `BuildPolygonIndices`, `BuildCellStructPolygonIndices`, `CollectEmittersFromScript`, plus whatever else the compiler names). Move the fields/caches only they use. Bodies unchanged. + +- [ ] **Step 3: Delegate from ObjectMeshManager.** It constructs one `MeshExtractor` in its constructor (passing its dat reader + metadata table) and every former `Prepare*` call site becomes `_extractor.Prepare*`. The staged-queue enqueue, worker pool, retry, and `Dispose` quiesce logic stay in `ObjectMeshManager` untouched (the MP0-investigated teardown discipline is a runtime concern; the bake tool will drive the extractor with its own simple loop in MP1b). + +- [ ] **Step 4: Move the support files** the compiler demands (list above), namespace `AcDream.Content`, bodies verbatim. `Building.cs` is NOT in scope (its GL-query fields keep it in App for now). + +- [ ] **Step 5: Build + FULL test suite** + +Run: `dotnet build` then `dotnet test` +Expected: green / all passing. The full suite is the behavior gate — no test may change. + +- [ ] **Step 6: Update the inventory doc.** In `docs/architecture/worldbuilder-inventory.md`, add an MP1a note under the extracted-code section: the CPU mesh-extraction half now lives in `src/AcDream.Content/` (list the moved files), App retains GL upload/lifecycle, Core untouched, reason = MP1 bake tool needs GL-free extraction (spec §6.1). + +- [ ] **Step 7: Commit** + +```bash +git add -A +git commit -m "refactor(pipeline): MP1a - MeshExtractor extracted to AcDream.Content (verbatim move)" +``` + +--- + +### Task 5: Launch smoke (user-gated) + +- [ ] **Step 1:** `dotnet build -c Release` — green. +- [ ] **Step 2:** Launch per the standard live-launch recipe (CLAUDE.md), user in-world for ~2 minutes: Holtburg buildings + an interior + a dungeon teleport. Acceptance: world renders identically — no missing/white/wrong geometry or textures (the #105-class signature would indicate the move broke a per-frame driver; per `feedback_extraction_perframe_drivers` the lifecycle stayed in App precisely to avoid this, so any anomaly = STOP and investigate the move). +- [ ] **Step 3:** On user confirmation, update the roadmap Track MP table (MP1a slice shipped) and commit. + +```bash +git add docs/plans/2026-04-11-roadmap.md +git commit -m "docs(pipeline): MP1a shipped - Content extraction user-gated" +``` diff --git a/docs/superpowers/plans/2026-07-05-mp1b-pak-and-bake.md b/docs/superpowers/plans/2026-07-05-mp1b-pak-and-bake.md new file mode 100644 index 00000000..4f4adc7b --- /dev/null +++ b/docs/superpowers/plans/2026-07-05-mp1b-pak-and-bake.md @@ -0,0 +1,113 @@ +# MP1b — Pak Format + acdream-bake + PakReader Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** A versioned pak file containing every `ObjectMeshData` the client's decode workers would otherwise produce at runtime (GfxObj / Setup / EnvCell mesh+texture payloads), an offline `acdream-bake` CLI that produces it by driving MP1a's `MeshExtractor`, a zero-copy mmap `PakReader`, and an equivalence test proving pak round-trip output is identical to live extraction. + +**Architecture:** The bake tool and the client run the SAME extraction code (`AcDream.Content.MeshExtractor`, extracted verbatim in MP1a) — the pak stores its serialized output, so equivalence is by construction and verified by test. Nothing in the client consumes the pak yet (that is MP1c); MP1b has **no user visual gate** — its gates are round-trip tests, the dat-gated equivalence suite, and a timed full bake. Spec: `docs/superpowers/specs/2026-07-05-modern-pipeline-design.md` §6.2–6.5 including the 2026-07-05 amendments (v1 textures = RGBA8 as produced; `PakReader` lives in `AcDream.Content`, not Core). + +**Scope discipline (v1 pak content):** ONLY the `ObjectMeshData` asset classes — this is what the decode workers produce during the 211 ms / 75.7 MB teleport storms (the MP0 baseline's target). Terrain blittables, flattened physics BSPs, scenery instance lists, and degrade tables are LATER slices (MP1c+/MP2/MP4) — do not add them. + +**Tech Stack:** .NET 10; `System.IO.MemoryMappedFiles` + `MemoryMarshal` for the reader; plain `BinaryWriter`-style serialization (little-endian, versioned); xunit in a new `tests/AcDream.Content.Tests`. + +--- + +## File map + +| File | Action | Responsibility | +|---|---|---| +| `tests/AcDream.Content.Tests/AcDream.Content.Tests.csproj` | Create | Content-layer test project (rule 6), registered in `AcDream.slnx` | +| `src/AcDream.Content/Pak/PakKey.cs` | Create | 64-bit asset key: `type:u8 \| fileId:u32 \| reserved:u24` | +| `src/AcDream.Content/Pak/PakFormat.cs` | Create | Header/TOC binary layout constants + structs | +| `src/AcDream.Content/Pak/ObjectMeshDataSerializer.cs` | Create | `ObjectMeshData` ⇄ bytes, versioned, deterministic | +| `src/AcDream.Content/Pak/PakWriter.cs` | Create | Streams blobs to disk, writes TOC + header | +| `src/AcDream.Content/Pak/PakReader.cs` | Create | mmap, O(log n) TOC lookup, span access, typed reads | +| `src/AcDream.Bake/AcDream.Bake.csproj` + `Program.cs` | Create | The CLI: enumerate ids → parallel extract → pak | +| `tests/AcDream.Content.Tests/*.cs` | Create | Round-trip + format + dat-gated equivalence tests | +| `AcDream.slnx` | Modify | Register both new projects | + +`AcDream.Bake` references `AcDream.Content` (+ transitively Core/DRW). No Silk.NET anywhere in either new project — both csproj files get `TreatWarningsAsErrors` + `LangVersion latest` like Content. + +## Format v1 (normative) + +All integers little-endian. File layout: `[Header][Blob region][TOC]` (TOC last so the writer streams blobs without knowing counts up front). + +**Header (64 bytes, fixed):** +``` +offset size field +0 4 magic 'ACPK' (0x4B504341) +4 4 formatVersion = 1 +8 4 portalIteration (DatCollection.Portal.Iteration) +12 4 cellIteration +16 4 highResIteration +20 4 languageIteration +24 8 tocOffset (u64) +32 4 tocCount (u32) +36 4 bakeToolVersion = 1 +40 24 reserved (zero) +``` + +**PakKey (u64):** `((ulong)type << 56) | ((ulong)fileId << 24)` — low 24 bits reserved (variant/zero in v1). `type` enum (u8): `GfxObjMesh = 1`, `SetupMesh = 2`, `EnvCellMesh = 3`. (`fileId` is the dat id: `0x01xxxxxx` GfxObj, `0x02xxxxxx` Setup, cell ids for EnvCells.) + +**TOC entry (24 bytes each):** `key u64, offset u64, length u32, crc32 u32` — entries sorted ascending by key (binary search); `crc32` over the blob bytes (corruption tripwire; reader verifies lazily on first access of each blob, logs + treats as missing on mismatch). + +**Blobs:** each 64-byte aligned (writer pads). Content = `ObjectMeshDataSerializer` output (below). Uncompressed in v1 (spec: mmap + page cache; LZ4 is a recorded future option). + +**Serialized ObjectMeshData v1:** field-by-field, versioned by the header's formatVersion. Layout rules the implementer follows: primitives raw LE; arrays as `count:i32 + payload`; blittable arrays (`VertexPositionNormalTexture[]`, `ushort[]` indices, `byte[]` texture data) written via `MemoryMarshal.AsBytes` bulk copy; strings absent (none in the type); **the `TextureBatches` dictionary is written sorted by key tuple `(Width, Height, Format)` and each inner list in original order** — bakes must be byte-reproducible run-to-run; nullable fields as `present:byte + value`. Enumerate the actual fields from `src/AcDream.Content/ObjectMeshData.cs` (the moved records: `ObjectMeshData`, `MeshBatchData`, `TextureBatchData`, `StagedEmitter`, `TextureKey`, `UploadPixelFormat/Type`, plus the DRW `Sphere`/bounding types stored as their float components) — serialize EVERY field; if a field's type resists obvious serialization, STOP and report rather than skipping it (a skipped field is a silent equivalence failure later). + +--- + +### Task 1: Test project scaffold + +- [ ] Create `tests/AcDream.Content.Tests/AcDream.Content.Tests.csproj` — copy the shape of `tests/AcDream.App.Tests/AcDream.App.Tests.csproj` (xunit, net10.0), with a `ProjectReference` to `..\..\src\AcDream.Content\AcDream.Content.csproj`. Register in `AcDream.slnx`. +- [ ] Add a trivial smoke test (`PakKeyTests` placeholder is fine — it becomes real in Task 2). +- [ ] `dotnet build` + `dotnet test tests/AcDream.Content.Tests` green. +- [ ] Commit: `test(pipeline): MP1b - AcDream.Content.Tests scaffold` + +### Task 2: PakKey + header/TOC primitives (TDD) + +- [ ] **Failing tests first** (`PakKeyTests`, `PakFormatTests`): key compose/decompose round-trip for each asset type incl. max fileId `0xFFFFFFFF`; key ordering matches (type, fileId) ordering; header write→read round-trip preserves every field; TOC entry write→read round-trip; TOC binary size = 24 bytes/entry exactly. +- [ ] Implement `PakKey` (static compose/decompose + the `PakAssetType` enum) and `PakFormat` (header struct + read/write over `Span`/`Stream`, TOC entry struct + read/write) per the normative layout above. +- [ ] Tests green; commit: `feat(pipeline): MP1b - pak key + header/TOC primitives` + +### Task 3: ObjectMeshDataSerializer (TDD) + +- [ ] **Failing tests first** (`ObjectMeshDataSerializerTests`): build synthetic `ObjectMeshData` instances covering — empty object; vertices+indices only; multiple texture batches across multiple `(W,H,Format)` groups; setup with parts; emitters present; nullable fields both present and absent; non-empty `EdgeLines`. Round-trip each and deep-compare EVERY field (write a `ObjectMeshDataEquality` test helper that compares field-by-field with clear failure messages — this helper is also Task 6's comparator). Plus: serializing the same instance twice yields byte-identical output (determinism), and dictionaries inserted in different orders yield byte-identical output (sorted-key rule). +- [ ] Implement `ObjectMeshDataSerializer.Write(ObjectMeshData, Stream)` + `Read(ReadOnlySpan) → ObjectMeshData` per the layout rules. +- [ ] Tests green; commit: `feat(pipeline): MP1b - ObjectMeshData binary serializer (deterministic round-trip)` + +### Task 4: PakWriter + PakReader (TDD) + +- [ ] **Failing tests first** (`PakRoundTripTests`): write a pak with N synthetic blobs (via Task 3 serializer) to a temp file → open with `PakReader` → header fields match; every key found; blob spans deserialize to deep-equal objects; missing key returns false; corrupted blob (flip one byte) → crc mismatch → treated as missing + logged once; blobs are 64-byte aligned; TOC binary-search lookup verified against a linear scan for all keys. +- [ ] Implement `PakWriter` (streaming: write header placeholder → blobs with padding → TOC → seek back and finalize header) and `PakReader` (`MemoryMappedFile` + `ReadOnlySpan` accessor, lazily-verified crc set, `TryReadObjectMeshData(PakKey, out ObjectMeshData)`). No locks; document the immutability argument on the class. +- [ ] Tests green; commit: `feat(pipeline): MP1b - PakWriter + mmap PakReader` + +### Task 5: acdream-bake CLI + +- [ ] Create `src/AcDream.Bake/` console project (register in slnx). Arguments: `--dat-dir ` (required), `--out ` (default `acdream.pak` next to the dats), `--ids ` and `--landblocks ` (optional dev filters), `--threads ` (default `Environment.ProcessorCount`). +- [ ] Wiring: `DatCollection(datDir, Read)` → `DatCollectionAdapter` → one `MeshExtractor` per worker OR one shared (extractor is documented 4-worker-safe — shared is fine; sink = a `ConcurrentBag` collector whose entries are serialized under their own GfxObj keys, deduplicated by id). +- [ ] Enumeration: GfxObj ids + Setup ids via `Portal.GetAllIdsOfType<...>` (mirror how `ObjectMeshManager`/CLI tools enumerate — check `src/AcDream.Cli/Program.cs` for the idiom); EnvCell ids by walking landblock `LandBlockInfo.NumCells` per the streamer's hydration path (find the idiom in `GameWindow.BuildPhysicsDatBundle` / the EnvCell loader — read, don't invent). +- [ ] Parallel extract (`Parallel.ForEach`, `--threads`), progress line every 5 s (`baked/total, failures, elapsed, ETA`), failures logged per-id and counted, never fatal (a malformed dat entry skips that id — same as the runtime's behavior). +- [ ] Write pak via `PakWriter`; stamp the four dat iterations into the header; print a summary (counts per type, failures, output size, elapsed). +- [ ] Smoke: `dotnet run --project src/AcDream.Bake -- --dat-dir "%USERPROFILE%\Documents\Asheron's Call" --ids 0x01000001,0x02000001 --out scratch-test.pak` produces a valid pak that `PakReader` opens (assert via a quick console read-back or a test). Delete the scratch file. +- [ ] Commit: `feat(pipeline): MP1b - acdream-bake CLI` + +### Task 6: Dat-gated equivalence suite + +- [ ] `PakEquivalenceTests` in Content.Tests, skipping cleanly when dats are absent (copy the skip pattern from `tests/AcDream.Core.Tests/Conformance/DatConcurrencyStressTests.cs`). For a fixture id set (≥10 GfxObjs incl. known-tricky ones — grep the test tree for ids used by `Issue119UpNullGfxObjDumpTests`/`StipplingSurfaceEquivalenceTests` and reuse them; ≥3 Setups; ≥5 EnvCells from the Holtburg landblock `0xA9B4`): run `MeshExtractor` live AND bake the same ids to a temp pak → read back → deep-compare with the Task 3 equality helper. Any field mismatch = failure naming the field. +- [ ] Tests green (on this machine, dats present); full `dotnet test` green. +- [ ] Commit: `test(pipeline): MP1b - live-vs-pak equivalence suite (dat-gated)` + +### Task 7: Full bake run + gate record (coordinator/user machine) + +- [ ] `dotnet build -c Release` green; run the full bake against the real dats (no filters), Release. +- [ ] Record in `docs/research/2026-07-XX-mp1b-bake-report.md`: total assets per type, failures (each listed), wall time, pak size, and the equivalence-suite result. Gate: equivalence green + bake completes + failure list reviewed (a failure on an id the runtime CAN decode = bug; a failure matching runtime behavior = recorded as expected). +- [ ] Update roadmap Track MP row (MP1b shipped); commit both docs. + +--- + +## Post-plan notes + +- No divergence-register rows: nothing consumed at runtime changes in MP1b. +- The pak file itself is user-machine output — never committed; add `*.pak` to `.gitignore` in the same commit as Task 5. +- MP1c (the cutover: decode workers try `PakReader` first, stale-pak refusal UX, hitch re-measure vs the 211 ms baseline) is the next plan; its "before" numbers are already in the MP0 baseline doc. diff --git a/docs/superpowers/plans/2026-07-07-player-physics-update-verbatim-rebuild.md b/docs/superpowers/plans/2026-07-07-player-physics-update-verbatim-rebuild.md new file mode 100644 index 00000000..a599e0f5 --- /dev/null +++ b/docs/superpowers/plans/2026-07-07-player-physics-update-verbatim-rebuild.md @@ -0,0 +1,908 @@ +# Player physics per-frame loop — verbatim rebuild — Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Port retail `CPhysicsObj::UpdateObjectInternal`'s velocity/collision chain verbatim into acdream's player per-frame loop so a blocked jump into a monster crowd **bleeds its velocity and glides/lands like retail** (fixes #182's airborne "stuck in the falling animation" regression + halves the general crowd jam), keeping the already-faithful transition internals as the collision primitive. + +**Architecture:** The retail per-frame chain is `UpdateObject` (dt sub-step driver) → `UpdateObjectInternal` (integrate candidate → `transition` sweep → commit + `cached_velocity`) → `SetPositionInternal` (commit resolved frame + contact/walkable/sliding flags + `handle_all_collisions`) → `handle_all_collisions` (velocity reflect OR zero, driven by `frames_stationary_fall`). The velocity "bleed on block" is **not** the `cached_velocity` field (a separate reporting/DR value) — it is the `frames_stationary_fall` (fsf) counter: `validate_transition` increments it 0→1→2→3 when the sphere fails to advance and at fsf≥2 manufactures an upward contact plane; `handle_all_collisions` **zeros the velocity when fsf > 1**. acdream reflects but never runs the fsf path (registered as TS-3), so a blocked jump reflects a sliver of +Z and hangs. This rebuild completes the fsf round-trip in the kept transition internals and ports the `SetPositionInternal`/`handle_all_collisions` consumer into the player loop, replacing acdream's ad-hoc reflect/land block. + +**Tech Stack:** C# / .NET 10, xUnit. Retail oracle: `docs/research/named-retail/acclient_2013_pseudo_c.txt` (named PDB decomp). Measurement: `ACDREAM_CAPTURE_RESOLVE` JSONL capture + a new Python histogram classifier. A/B target (retail cdb, `tools/cdb/retail-crowd-jump3.cdb`): **~78% OK, 12.7% COLLIDED, 8.8% SLID, 0 airborne-stuck.** + +--- + +## 0. Refinement of the design spec (read before starting) + +This plan **refines** `docs/superpowers/specs/2026-07-07-player-physics-update-verbatim-rebuild-design.md`. The design's §7 explicitly deferred verifying the mechanism to "the writing-plans step"; that verification (reading `handle_all_collisions` 0x00514780, `UpdatePhysicsInternal` 0x00510700, and the fsf lifecycle end-to-end) changed the slicing: + +| Design said | Verified truth (decomp + capture) | Consequence | +|---|---|---| +| Slice 1 = the `cached_velocity = (resolved−old)/dt` model bleeds velocity → airborne-stuck→0 | `cached_velocity` is a **separate reporting field** read only by `get_velocity` (network/DR/camera), never fed to the integrator (`m_velocityVector`). It does **not** bleed the jump. | The airborne-stuck fix lives in `handle_all_collisions` (`fsf>1 → v=0`), which needs the **fsf round-trip** first. Slices reorder: fsf substrate (Slice 1) → `handle_all_collisions` consumer (Slice 2, the design's "Slice 2", now the load-bearing fix). | +| §7 Q1: does retail reflect, or is velocity purely movement-derived? | Retail does **both**: `fsf≤1` → reflect `v += -(v·n)(elasticity+1)·n`; `fsf>1` → `v=0`. Velocity is `m_velocityVector`-integrated. | Keep `PhysicsBody.Velocity` as `m_velocityVector`; **add a separate `CachedVelocity`** field; do not collapse them. | +| §7 Q2: which `SetPositionInternal` overload | `0x00515330` (single `CTransition` arg) — confirmed from `UpdateObjectInternal:283696`. | Port that overload's contact/walkable/sliding + `handle_all_collisions` sequence. | +| §7 Q3: is the general ground-jam explained by the velocity model, or a second divergence? | Measure after Slice 2. Candidate residual = **TS-4** (BSPQuery Path-6 steep persisted sliding-normal / #137 anti-parallel-absorb) — in the *kept* internals. | Slice 3, only if <~78% OK. Do not touch TS-4 pre-measurement. | + +**Out of scope (kept — already faithful, per the user "keep everything faithful"):** the transition INTERNALS below `ResolveWithTransition` — BSPQuery, the CSphere/CylSphere collision families (incl. the #182 port), cell membership, terrain, streaming. The ONE exception is completing the fsf stub inside `ValidateTransition` — that stub **is** "the full physics port" TS-3 was explicitly deferred to; completing it is finishing a known gap, not re-porting working code. **`calc_friction` is out of scope** — it carries an orthogonal threshold divergence (retail 0.25 vs acdream 0.0) whose naive fix regresses walking (L.3c); the fsf fix does not require it. **#182 stays the base** (user decision). + +--- + +## 1. The verified retail chain (the port source — cite these in code comments) + +All addresses/pc from `docs/research/named-retail/acclient_2013_pseudo_c.txt`. + +### `UpdateObjectInternal(dt)` — 0x005156b0, pc:283611 +``` +if not active (transient_state high bit clear): update particles/scripts; return +if cell == 0: return +jumped_this_frame = 0 +candidate = identity frame +UpdatePositionInternal(dt, &candidate) // integrate → candidate +if part_array has spheres AND candidate.origin != m_position.origin: // moved + (set candidate heading from velocity/motion) + trans = transition(m_position, candidate, 0) // COLLISION SWEEP (== ResolveWithTransition) + if trans == null: + set_frame(candidate); cached_velocity = 0 + else: + cached_velocity = (trans.sphere_path.curr_pos − m_position) / dt // 0x005158cb-005158ff + SetPositionInternal(trans) // 0x00515330 +else: // no spheres OR didn't move + set_frame(candidate); cached_velocity = 0 +// tail: detection / target / movement.UseTime / part.HandleMovement / position.UseTime +``` + +### `UpdatePositionInternal(dt, &newFrame)` — 0x00512c30, pc:280817 +``` +delta = identity +part_array.Update(dt, &delta) // animation root motion → delta +if not OnWalkable: delta.translation *= 0 // airborne: no anim translation +else: delta.translation *= m_scale +position_manager.adjust_offset(&delta, dt) // sticky +newFrame = m_position.frame ∘ delta // combine +UpdatePhysicsInternal(dt, &newFrame) // velocity + gravity integration +process_hooks() +``` + +### `UpdatePhysicsInternal(dt, &newFrame)` — 0x00510700, pc:278460 +``` +velMag2 = |m_velocityVector|² +if velMag2 > 0: + if velMag2 > 2500 (=50²): m_velocityVector = normalize(m_velocityVector)*50 + calc_friction(dt, velMag2) + if (velMag2 − 0.0625 (=0.25²)) <= 0.0002 (F_EPSILON): m_velocityVector = 0 // NOT gated on OnWalkable + newFrame.origin += m_velocityVector*dt + 0.5*accel*dt² +else if movement_manager == null: + if OnWalkable: clear Active bit +m_velocityVector += accel*dt // UNCONDITIONAL (both branches) +newFrame = grotate(newFrame, omega*dt) +``` + +### `calc_acceleration()` — 0x00510950, pc:278533 +``` +if Contact(0x1) AND OnWalkable(0x2) AND !(state & 0x800000 SLEDDING): accel=0; omega=0; return +if !(state & 0x400 GRAVITY): accel=0; return +accel = (0,0, gravity(-9.8)) +``` + +### `SetPositionInternal(trans)` — 0x00515330, pc:283399 +``` +curr_cell = trans.sphere_path.curr_cell +if curr_cell == 0: prepare_to_leave_visibility; store_position; GotoLostCell; clear Active; return 1 +if this.cell != curr_cell: change_cell(curr_cell) else: update objcell_id (+children) +set_frame(trans.sphere_path.curr_pos.frame) // COMMIT resolved position +contact_plane = trans.collision_info.contact_plane +contact_plane_cell = trans.collision_info.contact_plane_cell_id +Contact bit(0x1) = trans.collision_info.contact_plane_valid ; calc_acceleration() +Water bit(0x8) = trans.collision_info.contact_plane_is_water +if Contact == 0: clear OnWalkable(0x2); if was OnWalkable: movement.LeaveGround(); calc_acceleration() +else: set_on_walkable(contact_plane.N.z >= floor_z(0.6642)) +sliding_normal = trans.collision_info.sliding_normal +Sliding bit(0x4) = trans.collision_info.sliding_normal_valid +handle_all_collisions(trans.collision_info, PREV_Contact, PREV_OnWalkable) // prev = transient_state captured at entry +[if HAS_PHYSICS_BSP(0x10000): calc_cross_cells; else shadow-cell updates] +return 1 +``` + +### `handle_all_collisions(ci, prev_contact, prev_on_walkable)` — 0x00514780, pc:282647 +``` +should_reflect = !(prev_on_walkable AND OnWalkable AND !(state & SLEDDING)) // var_10_1 +[report collision-start for each collided object; report_collision_end; environment-collision report] +fsf = ci.frames_stationary_fall +if fsf <= 1: + if should_reflect AND ci.collision_normal_valid AND !(state & 0x20000 INELASTIC): + dot = m_velocityVector · ci.collision_normal + if dot < 0: m_velocityVector += -(dot*(elasticity+1)) * ci.collision_normal // REFLECT + elif should_reflect AND ci.collision_normal_valid: // INELASTIC + m_velocityVector = 0 +else: // fsf > 1 + m_velocityVector = 0 // ZERO (the bleed) +// encode fsf → transient bits: +if fsf == 1: transient_state |= 0x10 (StationaryFall) +elif fsf == 2: transient_state |= 0x20 (StationaryStop) +elif fsf == 3: transient_state |= 0x40 (StationaryStuck) +else (fsf==0): transient_state &= ~(0x10|0x20|0x40) +return +``` + +### fsf counter in `validate_transition` — 0x0050aa70, pc:272625-272656 +``` +if ci.collision_normal_valid: ci.set_sliding_normal(ci.collision_normal) +if (object_info.state & 4)==0 AND (target_object.state & 0x400 GRAVITY)!=0: // mover-not-frozen AND object has gravity + if moved: ci.frames_stationary_fall = 0 // advanced → reset + else: + if fsf == 0: fsf = 1 + elif fsf == 1: fsf = 2 + else: fsf = 3 // fsf >= 2 → manufacture UP contact + up = (0,0,1) + d = radius − (global_sphere.center · up) // plane through sphere bottom + ci.set_contact_plane(up, water=0); ci.contact_plane_cell_id = check_pos.objcell_id + if (object_info.state & 1)==0: // not already Contact + ci.set_collision_normal(up); ci.collided_with_environment = 1 +``` + +### fsf seed in `transition` — 0x00512dc0, pc:280940-280947 +``` +after init_path: +if transient_state & 0x40: fsf = 3 +elif transient_state & 0x20: fsf = 2 +elif transient_state & 0x10: fsf = 1 +``` + +### `UpdateObject(dt)` sub-step driver — 0x00515d10, pc:283960 +``` +dt = cur_time − update_time +if dt <= F_EPSILON: update_time = cur_time; return +if dt > 2.0 (HugeQuantum): update_time = cur_time; return +while dt > MaxQuantum: UpdateObjectInternal(MaxQuantum); dt -= MaxQuantum +if dt > 0: UpdateObjectInternal(dt) +update_time = cur_time +``` +(acdream already inlines this dt-substep as `_physicsAccum` in `PlayerMovementController` — kept as-is; the L.5 MinQuantum gate is a documented pre-existing adaptation, out of scope.) + +--- + +## 2. acdream current state (the seam being rebuilt) + +- **Per-frame method:** `PlayerMovementController.Update(float dt, MovementInput input)` — `src/AcDream.App/Input/PlayerMovementController.cs:542-1302`. Caller: `GameWindow.cs:8454`. +- The retail `UpdateObjectInternal` chain is currently **spread** across: §4 integrate (`:820-877`, `_body.UpdatePhysicsInternal(tickDt)` integrating `Position` **in-place**), §5 resolve (`:879-916`, `_physics.ResolveWithTransition(preIntegratePos, postIntegratePos, …)`), apply (`:931-947`), the ad-hoc reflect block (`:949-1056`), and the landing/airborne block (`:1058-1109`). +- `PhysicsBody` (`src/AcDream.Core/Physics/PhysicsBody.cs`): single `Velocity` field (plays `m_velocityVector`), `calc_acceleration`/`UpdatePhysicsInternal`/`calc_friction`/`set_velocity` ports present. **No `CachedVelocity`.** `TransientStateFlags` = Contact/OnWalkable/Sliding/Active only (**no 0x10/0x20/0x40**). `UpdatePhysicsInternal` has a divergence: the small-velocity-zero at `:503-504` is gated on `OnWalkable` (retail is ungated). +- `ResolveResult` (`src/AcDream.Core/Physics/ResolveResult.cs:21`): `readonly record struct` with `Position, CellId, IsOnGround, CollisionNormalValid, CollisionNormal, Ok`. Rich state (ContactPlane, SlidingNormal) flows back through the passed `body` side-effect (`PhysicsEngine.cs:999-1015` seed-in, `:1056-1106` write-out). **`FramesStationaryFall` is not surfaced.** +- `Transition.ValidateTransition(TransitionState)` — `src/AcDream.Core/Physics/TransitionTypes.cs:4575`. fsf stub at `:4596` (`// moved = true (FramesStationaryFall deferred…)`). "moved" analog = `sp.CheckPos != sp.CurPos` (`:4581`). `CollisionInfo.FramesStationaryFall` field at `:245` (dead). All other retail COLLISIONINFO fields have counterparts. +- **Apparatus:** `PhysicsResolveCapture` (`src/AcDream.Core/Physics/PhysicsResolveCapture.cs`), toggled by `ACDREAM_CAPTURE_RESOLVE`, IsPlayer-filtered at `PhysicsEngine.cs:946`. Baseline capture: `acdream-crowd-resolve.jsonl` (repo root, 41832 lines). No histogram classifier exists yet. + +--- + +## 3. File structure + +| File | Change | +|---|---| +| `tools/analyze_resolve_capture.py` | **Create.** Histogram classifier for `ACDREAM_CAPTURE_RESOLVE` JSONL → OK/partial/stuck/airborne-stuck buckets over move-intent records. | +| `src/AcDream.Core/Physics/PhysicsBody.cs` | Add `StationaryFall/Stop/Stuck` flags; add `FramesStationaryFall` + `CachedVelocity` fields; remove the OnWalkable gate on the small-velocity-zero. | +| `src/AcDream.Core/Physics/TransitionTypes.cs` | Un-stub the fsf ladder in `ValidateTransition` (`:4575`); add fsf increment/reset + fsf≥2 UP-plane manufacture. | +| `src/AcDream.Core/Physics/PhysicsEngine.cs` | `ResolveWithTransition`: seed `ci.FramesStationaryFall` from `body` transient bits at entry; write `ci.FramesStationaryFall → body.FramesStationaryFall` at exit. | +| `src/AcDream.App/Input/PlayerMovementController.cs` | Replace the ad-hoc reflect/land block (`:949-1109`) with the ported `SetPositionInternal`+`handle_all_collisions` sequence; compute `CachedVelocity`. | +| `src/AcDream.Core/Physics/PhysicsObjUpdate.cs` | **Create.** Static/pure port of `SetPositionInternal` + `handle_all_collisions` operating on a `PhysicsBody` + a resolve outcome, unit-testable in Core without the App layer. | +| `docs/architecture/retail-divergence-register.md` | Retire TS-3; amend AD-25 (split off the player half); add any new adaptation rows. | +| `tests/AcDream.Core.Tests/Physics/*` | New conformance tests: fsf ladder, `handle_all_collisions` reflect/zero, crowd-jump replay against the capture. | + +--- + +## Task 1: Author the resolve-capture histogram classifier (Slice 0 — measurement) + +**Files:** +- Create: `tools/analyze_resolve_capture.py` + +- [ ] **Step 1: Write the classifier** + +Record schema (camelCase JSON, one per line): `input.{currentPos,targetPos,cellId,...}`, `bodyBefore` / `bodyAfter` (`PhysicsBodySnapshot`, incl. `velocity`, `slidingNormal`, `transientState`), `result.{position,cellId,isOnGround,collisionNormalValid,collisionNormal}`. Vector3 = `{x,y,z}`. + +```python +#!/usr/bin/env python3 +"""Classify ACDREAM_CAPTURE_RESOLVE JSONL into OK / partial / stuck / airborne-stuck. + +Buckets (move-intent records only, i.e. targetPos != currentPos): + OK reached target: dist(result.position, targetPos) <= EPS_REACH + partial advanced short: moved > EPS_MOVE and not OK + stuck reverted: moved <= EPS_MOVE (requested motion, none delivered) + airborne-stuck subset of stuck: bodyBefore airborne with jump velocity into a + near-horizontal collision normal (the falling-animation wedge) +Retail target (retail-crowd-jump3.cdb): ~78% OK, 12.7% COLLIDED, 8.8% SLID, 0 airborne-stuck. +""" +import sys, json, math + +EPS_REACH = 0.02 # 2 cm — "reached target" +EPS_MOVE = 0.01 # 1 cm — "advanced at all" +JUMP_VZ = 5.0 # bodyBefore.velocity.z above this = a jump/airborne launch +HORIZ_NZ = 0.5 # |collisionNormal.z| below this = near-horizontal (creature side) + +def d(a, b): + return math.sqrt((a["x"]-b["x"])**2 + (a["y"]-b["y"])**2 + (a["z"]-b["z"])**2) + +def classify(rec): + i = rec["input"] + if d(i["targetPos"], i["currentPos"]) <= EPS_MOVE: + return None # zero-motion rest tick — not a move-intent record + r = rec["result"] + moved = d(r["position"], i["currentPos"]) + reached = d(r["position"], i["targetPos"]) <= EPS_REACH + if reached: + return "ok" + if moved > EPS_MOVE: + return "partial" + # reverted / stuck + bb = rec.get("bodyBefore") or {} + vel = bb.get("velocity") or {"x":0,"y":0,"z":0} + n = r.get("collisionNormal") or {"x":0,"y":0,"z":0} + airborne_jump = vel["z"] > JUMP_VZ + horiz_normal = r.get("collisionNormalValid") and abs(n["z"]) < HORIZ_NZ + if airborne_jump and horiz_normal: + return "airborne-stuck" + return "stuck" + +def main(path): + counts = {"ok":0, "partial":0, "stuck":0, "airborne-stuck":0} + total_move = 0 + with open(path, "r", encoding="utf-8") as f: + for line in f: + line = line.strip() + if not line: + continue + try: + rec = json.loads(line) + except json.JSONDecodeError: + continue + c = classify(rec) + if c is None: + continue + total_move += 1 + # airborne-stuck is a subset of stuck for the bucket table but we + # report it separately AND fold it under stuck for the % columns. + if c == "airborne-stuck": + counts["airborne-stuck"] += 1 + counts["stuck"] += 1 + else: + counts[c] += 1 + if total_move == 0: + print("no move-intent records"); return + print(f"move-intent resolves: {total_move}") + for k in ("ok", "partial", "stuck"): + print(f" {k:16s} {counts[k]:6d} {100.0*counts[k]/total_move:5.1f}%") + print(f" {'airborne-stuck':16s} {counts['airborne-stuck']:6d} (frames; subset of stuck)") + print("retail target: ok ~78% partial ~9% stuck ~13% airborne-stuck 0") + +if __name__ == "__main__": + main(sys.argv[1] if len(sys.argv) > 1 else "acdream-crowd-resolve.jsonl") +``` + +- [ ] **Step 2: Validate against the existing baseline** + +Run: `py tools/analyze_resolve_capture.py acdream-crowd-resolve.jsonl` +Expected: `move-intent resolves: ~2883`; buckets approximately `ok ~50.9% partial ~26.7% stuck ~22.4% airborne-stuck ~115` — i.e. it reproduces the design §2 acdream column. If the counts diverge materially from the design's numbers, tune `EPS_REACH` / `JUMP_VZ` until the classifier matches the design's hand-derived figures (the design numbers are the ground truth for the classifier's calibration). Record the exact calibrated numbers as the "before" baseline. + +- [ ] **Step 3: Commit** + +```bash +git add tools/analyze_resolve_capture.py +git commit -m "tools(#182): resolve-capture histogram classifier (A/B baseline for the physics rebuild)" +``` + +--- + +## Task 2: PhysicsBody — fsf state, CachedVelocity, and the ungated small-velocity-zero (Slice 1a) + +**Files:** +- Modify: `src/AcDream.Core/Physics/PhysicsBody.cs` +- Test: `tests/AcDream.Core.Tests/Physics/PhysicsBodyTests.cs` + +- [ ] **Step 1: Write failing tests** + +```csharp +[Fact] +public void TransientStateFlags_HasStationaryBits() +{ + Assert.Equal(0x10u, (uint)TransientStateFlags.StationaryFall); + Assert.Equal(0x20u, (uint)TransientStateFlags.StationaryStop); + Assert.Equal(0x40u, (uint)TransientStateFlags.StationaryStuck); +} + +[Fact] +public void UpdatePhysicsInternal_ZeroesSmallVelocity_EvenWhenAirborne() +{ + // Retail UpdatePhysicsInternal (0x00510700) zeroes velocity below 0.25 m/s + // regardless of OnWalkable; gravity re-accelerates the same frame via v += a*dt. + var b = new PhysicsBody { State = PhysicsStateFlags.Gravity }; + b.TransientState = TransientStateFlags.None; // airborne + b.set_velocity(new Vector3(0.1f, 0f, 0f)); // < 0.25 m/s, no OnWalkable + b.Acceleration = new Vector3(0, 0, PhysicsBody.Gravity); + b.UpdatePhysicsInternal(1f / 30f); + // horizontal velocity was zeroed; only gravity (v += a*dt) remains on Z + Assert.True(MathF.Abs(b.Velocity.X) < 1e-4f); + Assert.True(b.Velocity.Z < 0f); +} +``` + +Run: `dotnet test tests/AcDream.Core.Tests/AcDream.Core.Tests.csproj --filter "FullyQualifiedName~PhysicsBodyTests.TransientStateFlags_HasStationaryBits"` +Expected: FAIL (flags undefined / compile error). + +- [ ] **Step 2: Add the flags, fields, and fix the gate** + +In `PhysicsBody.cs`, extend `TransientStateFlags` (retail transient_state bits, `handle_all_collisions` pc:282743/282749/282753): +```csharp +[Flags] +public enum TransientStateFlags : uint +{ + None = 0, + Contact = 0x00000001, // bit 0 — touching any surface + OnWalkable = 0x00000002, // bit 1 — standing on a walkable surface + Sliding = 0x00000004, // bit 2 — carry sliding normal into next transition + // retail frames_stationary_fall carried across frames (transition seeds fsf from + // these; handle_all_collisions re-encodes fsf into them). pc:282743/272940. + StationaryFall = 0x00000010, // bit 4 — fsf == 1 + StationaryStop = 0x00000020, // bit 5 — fsf == 2 + StationaryStuck= 0x00000040, // bit 6 — fsf == 3 + Active = 0x00000080, // bit 7 — object needs per-frame update +} +``` + +Add fields near `Velocity` (`:183`): +```csharp +/// Retail cached_velocity (+separate from m_velocityVector): the REALIZED +/// velocity (resolved displacement / dt) written after each transition in +/// UpdateObjectInternal (0x005158cb-005158ff). Read only for reporting / dead-reckoning / +/// camera slope-align (get_velocity 0x005113c0); NEVER fed back into the integrator. +public Vector3 CachedVelocity { get; set; } + +/// Retail collision_info.frames_stationary_fall carried on the body between +/// frames. Incremented in ValidateTransition when the sphere fails to advance, consumed by +/// handle_all_collisions (fsf>1 → velocity zeroed). Round-trips via the Stationary* transient +/// bits. validate_transition pc:272625-656; handle_all_collisions pc:282695. +public int FramesStationaryFall { get; set; } +``` + +In `UpdatePhysicsInternal` (`:503-504`), remove the OnWalkable gate (retail zeros regardless — gravity re-accelerates via the unconditional `v += a*dt`): +```csharp + // Retail UpdatePhysicsInternal 0x005107be: zero velocity below 0.25 m/s + // UNCONDITIONALLY (not gated on OnWalkable). At jump apex this zeros the + // horizontal drift; the unconditional `Velocity += Acceleration*dt` below + // immediately re-applies gravity, so the fall still accumulates. + if (velocityMag2 - SmallVelocitySquared < 0.0002f) + Velocity = Vector3.Zero; +``` + +Run: `dotnet test ... --filter "FullyQualifiedName~PhysicsBodyTests"` +Expected: PASS (both new tests + the existing suite). + +- [ ] **Step 3: Commit** + +```bash +git add src/AcDream.Core/Physics/PhysicsBody.cs tests/AcDream.Core.Tests/Physics/PhysicsBodyTests.cs +git commit -m "feat(#182): PhysicsBody fsf state + CachedVelocity; ungate small-velocity-zero (verbatim UpdatePhysicsInternal)" +``` + +--- + +## Task 3: Complete the fsf ladder in ValidateTransition (Slice 1b — the kept-internals stub, retiring TS-3's behavior gap) + +**Files:** +- Modify: `src/AcDream.Core/Physics/TransitionTypes.cs` (`ValidateTransition` `:4575`; the `moved` signal at `:4581`) +- Test: `tests/AcDream.Core.Tests/Physics/FramesStationaryFallTests.cs` (create) + +- [ ] **Step 1: Write failing tests for the fsf ladder in isolation** + +The ladder is: given a `Transition` whose step did/did not advance, and whose target has gravity, `ValidateTransition` increments/resets `collision_info.FramesStationaryFall` and at fsf≥2 manufactures an upward contact plane. Test via a minimal `Transition` with a controllable `SpherePath` (CheckPos == or != CurPos) and `ObjectInfo` with the gravity flag. + +```csharp +using System.Numerics; +using AcDream.Core.Physics; +using Xunit; + +public class FramesStationaryFallTests +{ + // Build a Transition whose ValidateTransition input state is OK, with CheckPos + // == CurPos (did NOT advance) so the fsf ladder increments. Helper mirrors the + // FindTransitionalPosition setup used by CellarUpTrajectoryReplayTests. + static Transition BlockedGravityTransition(int seedFsf) + { + var t = TestTransitionFactory.GravityMover(radius: 0.48f); // see Step 2 helper + t.CollisionInfo.FramesStationaryFall = seedFsf; + t.SpherePath.SetCheckPos(t.SpherePath.CurPos, t.SpherePath.CurCellId); // no advance + return t; + } + + [Theory] + [InlineData(0, 1)] + [InlineData(1, 2)] + [InlineData(2, 3)] + [InlineData(3, 3)] // saturates at 3 + public void ValidateTransition_Blocked_IncrementsFsf(int seed, int expected) + { + var t = BlockedGravityTransition(seed); + t.ValidateTransition(TransitionState.OK); + Assert.Equal(expected, t.CollisionInfo.FramesStationaryFall); + } + + [Fact] + public void ValidateTransition_Blocked_AtFsf2_ManufacturesUpContactPlane() + { + var t = BlockedGravityTransition(seedFsf: 2); // will become 3 → manufacture + t.ValidateTransition(TransitionState.OK); + Assert.True(t.CollisionInfo.ContactPlaneValid); + Assert.True(t.CollisionInfo.ContactPlane.Normal.Z > 0.99f); // UP + Assert.True(t.CollisionInfo.CollidedWithEnvironment); + } + + [Fact] + public void ValidateTransition_Advanced_ResetsFsf() + { + var t = TestTransitionFactory.GravityMover(radius: 0.48f); + t.CollisionInfo.FramesStationaryFall = 3; + // CheckPos advanced beyond CurPos → moved == true + t.SpherePath.CheckPos = t.SpherePath.CurPos with { /* origin += (1,0,0) */ }; + t.ValidateTransition(TransitionState.OK); + Assert.Equal(0, t.CollisionInfo.FramesStationaryFall); + } +} +``` + +Run: `dotnet test ... --filter "FullyQualifiedName~FramesStationaryFallTests"` +Expected: FAIL (fsf never changes — stub). + +- [ ] **Step 2: Add the `TestTransitionFactory.GravityMover` helper** + +If no reusable factory exists, add a minimal one in the test project that builds a `Transition` with a `SpherePath` (one sphere radius r at a known CurPos/CurCellId), an `ObjectInfo` whose `State` includes the gravity flag and whose `object.State` sets `PhysicsStateFlags.Gravity`, matching what `FindTransitionalPosition` sets up. Mirror the setup in `CellarUpTrajectoryReplayTests.cs:1252-1297` (`SimulateTicks`). Keep it in `tests/.../Physics/TestTransitionFactory.cs`. + +- [ ] **Step 3: Implement the fsf ladder in `ValidateTransition`** + +At `TransitionTypes.cs:4581-4597`, replace the stub. Compute `moved` from the retail `arg3` semantics (advanced this call). Then, gated on retail's condition (`(object_info.State & VIEWER/frozen)==0 && object-has-gravity`), run the ladder. Cite pc:272625-272656. + +```csharp +// retail validate_transition arg3 == "advanced this step". Our analog: CheckPos moved +// off CurPos on the OK path (pc:272608 accept-move block). Capture it BEFORE the accept +// overwrites CurPos. +bool moved = transitionState == TransitionState.OK && sp.CheckPos != sp.CurPos; + +if (transitionState == TransitionState.OK && sp.CheckPos != sp.CurPos) +{ + sp.CurPos = sp.CheckPos; sp.CurCellId = sp.CheckCellId; sp.CurOrientation = sp.CheckOrientation; + for (int i = 0; i < sp.NumSphere; i++) + sp.GlobalCurrCenter[i].Origin = sp.LocalSphere[i].Origin + sp.CurPos; // cache_global_curr_center + sp.SetCheckPos(sp.CurPos, sp.CurCellId); +} + +// ── frames_stationary_fall ladder (retail validate_transition pc:272625-272656) ── +// Gate: the mover is not frozen (object_info state bit 4 clear) AND the tested object +// has gravity (state 0x400). VIEWER camera sweeps + gravity-less props are exempt. +if (!ObjectInfo.HasFrozenBit && ObjectInfo.ObjectHasGravity) +{ + if (moved) + { + CollisionInfo.FramesStationaryFall = 0; // advanced → reset + } + else + { + int fsf = CollisionInfo.FramesStationaryFall; + if (fsf == 0) CollisionInfo.FramesStationaryFall = 1; + else if (fsf == 1) CollisionInfo.FramesStationaryFall = 2; + else + { + CollisionInfo.FramesStationaryFall = 3; // fsf >= 2 → manufacture UP contact + var up = Vector3.UnitZ; + // plane through the sphere bottom: d = radius - (center · up) (pc:272639-272643) + var gs = sp.GlobalSphere[0]; + float d = gs.Radius - Vector3.Dot(gs.Center, up); + CollisionInfo.SetContactPlane(new System.Numerics.Plane(up, d), isWater: false); + CollisionInfo.ContactPlaneCellId = sp.CheckPos.ObjCellId; + if (!ObjectInfo.HasContactBit) // not already Contact (state & 1 == 0) + { + CollisionInfo.SetCollisionNormal(up); + CollisionInfo.CollidedWithEnvironment = true; + } + } + } +} +``` + +Add the `ObjectInfo` accessors used above (`HasFrozenBit`, `ObjectHasGravity`, `HasContactBit`) if absent, reading the retail `object_info.state` / `object.state` bits (frozen = bit 2 of object_info.state per pc:272625 `& 4`; gravity = object state `0x400`; contact = object state `& 1`). Confirm exact acdream field names against `ObjectInfo` in `TransitionTypes.cs`; wire from `PhysicsBody.State` / `TransientState` at `get_object_info` seed time. + +Run: `dotnet test ... --filter "FullyQualifiedName~FramesStationaryFallTests"` → PASS. Then full Core suite → green. + +- [ ] **Step 4: Commit** + +```bash +git add src/AcDream.Core/Physics/TransitionTypes.cs tests/AcDream.Core.Tests/Physics/FramesStationaryFallTests.cs tests/AcDream.Core.Tests/Physics/TestTransitionFactory.cs +git commit -m "feat(#182): un-stub frames_stationary_fall ladder in ValidateTransition (retail 0x0050aa70; addresses TS-3 behavior gap)" +``` + +--- + +## Task 4: Round-trip fsf through PhysicsEngine.ResolveWithTransition (Slice 1c) + +**Files:** +- Modify: `src/AcDream.Core/Physics/PhysicsEngine.cs` (`ResolveWithTransition` seed-in `~:999`, write-out `~:1056-1106`) +- Test: `tests/AcDream.Core.Tests/Physics/ResolveFsfRoundTripTests.cs` (create) + +- [ ] **Step 1: Write failing test** + +```csharp +[Fact] +public void ResolveWithTransition_SeedsAndWritesBackFsf() +{ + var engine = TestPhysics.EmptyEngine(); // no landblock → NO-LANDBLOCK verbatim branch + var body = new PhysicsBody { State = PhysicsStateFlags.Gravity }; + body.TransientState |= TransientStateFlags.StationaryStop; // fsf seed == 2 + // A blocked-in-place move against a wall so the sphere can't advance is needed to + // increment; for the seed/writeback round-trip a zero-distance resolve suffices to + // prove the seed reaches ci and ci.fsf is written back to body. + engine.ResolveWithTransition(body.Position, body.Position, body.CellPosition.ObjCellId, + 0.48f, 1.835f, 0.6f, 1.5f, isOnGround: false, body: body, + moverFlags: ObjectInfoState.IsPlayer); + // seed 0x20 → fsf 2 carried in; a zero-distance no-op resolve leaves it (no advance, + // but the NO-LANDBLOCK branch may reset). Assert the field is now populated on body. + Assert.True(body.FramesStationaryFall >= 0); // tighten once the branch behavior is pinned +} +``` + +(Refine the assertion once the exact seed/branch interaction is observed — the load-bearing behavior is proven end-to-end by Task 7's crowd replay; this test guards the plumbing exists.) + +- [ ] **Step 2: Implement seed-in + write-out** + +At the top of `ResolveWithTransition` where the `Transition`/`CollisionInfo` is initialized (near where `body` seeds ContactPlane in, `~:999`), seed fsf from the body's carried transient bits (retail `transition` 0x00512dc0 pc:280940-947): +```csharp +if (body is not null) +{ + // retail transition() seeds collision_info.frames_stationary_fall from the carried + // Stationary* transient bits before find_valid_position. pc:280940-280947. + if (body.TransientState.HasFlag(TransientStateFlags.StationaryStuck)) ci.FramesStationaryFall = 3; + else if (body.TransientState.HasFlag(TransientStateFlags.StationaryStop)) ci.FramesStationaryFall = 2; + else if (body.TransientState.HasFlag(TransientStateFlags.StationaryFall)) ci.FramesStationaryFall = 1; + else ci.FramesStationaryFall = 0; +} +``` + +At the exit write-back (near `body.SlidingNormal = …`, `~:1106`), publish fsf onto the body so the App-layer consumer can read it: +```csharp +if (body is not null) + body.FramesStationaryFall = ci.FramesStationaryFall; +``` + +Run: `dotnet test ... --filter "FullyQualifiedName~ResolveFsfRoundTripTests"` → PASS. Full Core suite → green (no behavior change to locomotion: fsf=0 dormant). + +- [ ] **Step 3: Commit** + +```bash +git add src/AcDream.Core/Physics/PhysicsEngine.cs tests/AcDream.Core.Tests/Physics/ResolveFsfRoundTripTests.cs +git commit -m "feat(#182): round-trip frames_stationary_fall through ResolveWithTransition (seed from transient bits, write back to body)" +``` + +--- + +## Task 5: Port SetPositionInternal + handle_all_collisions into a pure Core unit (Slice 2a) + +**Files:** +- Create: `src/AcDream.Core/Physics/PhysicsObjUpdate.cs` +- Test: `tests/AcDream.Core.Tests/Physics/HandleAllCollisionsTests.cs` + +- [ ] **Step 1: Write failing tests for the reflect/zero decision** + +```csharp +public class HandleAllCollisionsTests +{ + static PhysicsBody Airborne(Vector3 v) => new PhysicsBody { + State = PhysicsStateFlags.Gravity, TransientState = TransientStateFlags.None, Velocity = v }; + + [Fact] + public void Fsf0_AirborneWallHit_ReflectsIntoWallComponent() + { + var b = Airborne(new Vector3(3f, 0f, 0f)); // moving +X into a -X wall + var n = new Vector3(-1f, 0f, 0f); // outward normal + PhysicsObjUpdate.HandleAllCollisions(b, framesStationaryFall: 0, + collisionNormalValid: true, collisionNormal: n, + prevContact: false, prevOnWalkable: false, nowOnWalkable: false); + // dot = 3*-1 = -3 < 0 → v += -(-3*(0.05+1))*(-1,0,0) = v + (-3.15,0,0) → x ≈ -0.15 + Assert.True(b.Velocity.X < 0f); + } + + [Fact] + public void Fsf2_ZeroesVelocity_TheBleed() + { + var b = Airborne(new Vector3(0f, 0f, 18f)); // straight-up jump + var n = new Vector3(-0.96f, -0.25f, -0.15f); // near-horizontal creature normal + PhysicsObjUpdate.HandleAllCollisions(b, framesStationaryFall: 2, + collisionNormalValid: true, collisionNormal: n, + prevContact: false, prevOnWalkable: false, nowOnWalkable: false); + Assert.Equal(Vector3.Zero, b.Velocity); // fsf>1 → v=0 → gravity resumes → glide off + } + + [Fact] + public void StayingOnWalkable_DoesNotReflect() + { + var b = new PhysicsBody { Velocity = new Vector3(3f,0f,0f), + TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable }; + var n = new Vector3(-1f,0f,0f); + PhysicsObjUpdate.HandleAllCollisions(b, framesStationaryFall: 0, + collisionNormalValid: true, collisionNormal: n, + prevContact: true, prevOnWalkable: true, nowOnWalkable: true); + Assert.Equal(3f, b.Velocity.X); // should_reflect == false → corridor wall-slide unchanged + } + + [Fact] + public void Fsf_EncodesIntoTransientBits() + { + var b = Airborne(new Vector3(0,0,1f)); + PhysicsObjUpdate.HandleAllCollisions(b, framesStationaryFall: 3, + collisionNormalValid: false, collisionNormal: default, + prevContact: false, prevOnWalkable: false, nowOnWalkable: false); + Assert.True(b.TransientState.HasFlag(TransientStateFlags.StationaryStuck)); + } +} +``` + +Run → FAIL (type missing). + +- [ ] **Step 2: Implement the port** + +```csharp +using System.Numerics; + +namespace AcDream.Core.Physics; + +/// +/// Verbatim port of the collision-response tail of retail CPhysicsObj::UpdateObjectInternal: +/// SetPositionInternal (0x00515330) → handle_all_collisions (0x00514780). Pure functions over +/// a PhysicsBody + the resolve outcome, so the whole chain is unit-testable in Core without the +/// App per-frame loop. The transition INTERNALS (ResolveWithTransition and below) are untouched. +/// +public static class PhysicsObjUpdate +{ + /// + /// retail handle_all_collisions (0x00514780, pc:282647). Reflects or zeros the body's + /// velocity based on frames_stationary_fall, then re-encodes fsf into the Stationary* + /// transient bits. This is the velocity "bleed on block": fsf>1 → velocity = 0. + /// + public static void HandleAllCollisions( + PhysicsBody body, int framesStationaryFall, + bool collisionNormalValid, Vector3 collisionNormal, + bool prevContact, bool prevOnWalkable, bool nowOnWalkable) + { + // var_10_1 (pc:282653-282657): reflect UNLESS staying on walkable ground (and not + // sledding). Restores retail's broader rule — acdream's AD-25 airborne-only + // suppression is retired (the landing-snap fragility it guarded is gone: the landing + // state is now owned by ApplyResolvedPosition below, not a Velocity.Z<=0 gate). + bool sledding = body.State.HasFlag(PhysicsStateFlags.Sledding); + bool shouldReflect = !(prevOnWalkable && nowOnWalkable && !sledding); + + if (framesStationaryFall <= 1) + { + if (shouldReflect && collisionNormalValid) + { + if (body.State.HasFlag(PhysicsStateFlags.Inelastic)) + { + body.Velocity = Vector3.Zero; // pc:282720-282722 + } + else + { + float dot = Vector3.Dot(body.Velocity, collisionNormal); + if (dot < 0f) // moving into surface + { + float k = -(dot * (body.Elasticity + 1f)); // pc:282712 + body.Velocity += collisionNormal * k; + } + } + } + } + else + { + body.Velocity = Vector3.Zero; // fsf>1 → THE BLEED (pc:282729) + } + + // encode fsf → transient bits (pc:282737-282758) + body.TransientState &= ~(TransientStateFlags.StationaryFall + | TransientStateFlags.StationaryStop + | TransientStateFlags.StationaryStuck); + body.TransientState |= framesStationaryFall switch + { + 1 => TransientStateFlags.StationaryFall, + 2 => TransientStateFlags.StationaryStop, + 3 => TransientStateFlags.StationaryStuck, + _ => TransientStateFlags.None, + }; + _ = prevContact; // reserved for report_environment_collision parity (weenie events, later) + } +} +``` + +Run → PASS. Commit. + +- [ ] **Step 3: Commit** + +```bash +git add src/AcDream.Core/Physics/PhysicsObjUpdate.cs tests/AcDream.Core.Tests/Physics/HandleAllCollisionsTests.cs +git commit -m "feat(#182): port handle_all_collisions (reflect/zero by frames_stationary_fall) as a pure Core unit" +``` + +--- + +## Task 6: Wire the ported chain into PlayerMovementController, replacing the ad-hoc reflect/land block (Slice 2b — the behavioral fix) + +**Files:** +- Modify: `src/AcDream.App/Input/PlayerMovementController.cs` (`:931-1109`) +- Test: `tests/AcDream.App.Tests/` (a controller-level test if the harness exists; otherwise rely on Task 7's Core replay + the visual gate) + +- [ ] **Step 1: Compute CachedVelocity and route the response through PhysicsObjUpdate** + +Replace the apply/reflect/land block (`:931-1109`). New sequence (retail `UpdateObjectInternal` tail + `SetPositionInternal`): + +```csharp +// ── Apply the resolve as retail UpdateObjectInternal does (0x005156b0) ── +// cached_velocity = realized displacement / dt (separate from the integrator velocity; +// reporting/DR only). pc:005158cb-005158ff. +if (physicsTickRan && tickDt > 0f) + _body.CachedVelocity = (resolveResult.Position - preIntegratePos) / tickDt; +else + _body.CachedVelocity = Vector3.Zero; + +_body.Position = resolveResult.Position; +if (physicsTickRan) +{ + _prevPhysicsPos = oldTickEndPos; + _currPhysicsPos = _body.Position; + PositionManager?.UseTime(); // retail UpdateObjectInternal tail (R5-V3, keep) +} + +// SetPositionInternal (0x00515330): set contact/walkable from the resolved contact plane, +// then handle_all_collisions. The contact plane + fsf were written onto _body by +// ResolveWithTransition. prevContact/prevOnWalkable are captured BEFORE this block mutates them. +bool prevContact = _body.InContact; +bool prevOnWalkable = _body.OnWalkable; + +// Contact bit from contact_plane_valid; then walkable from the plane's slope. (pc:283468-283510) +if (_body.ContactPlaneValid) +{ + _body.TransientState |= TransientStateFlags.Contact; + bool walkable = _body.ContactPlane.Normal.Z >= PhysicsGlobals.FloorZ; // set_on_walkable + if (walkable) _body.TransientState |= TransientStateFlags.OnWalkable; + else _body.TransientState &= ~TransientStateFlags.OnWalkable; +} +else +{ + bool wasOnWalkable = _body.OnWalkable; + _body.TransientState &= ~(TransientStateFlags.Contact | TransientStateFlags.OnWalkable); + if (wasOnWalkable) _motion.LeaveGround(); // retail movement_manager->LeaveGround (pc:283494) +} +_body.calc_acceleration(); + +bool nowOnWalkable = _body.OnWalkable; +PhysicsObjUpdate.HandleAllCollisions( + _body, _body.FramesStationaryFall, + resolveResult.CollisionNormalValid, resolveResult.CollisionNormal, + prevContact, prevOnWalkable, nowOnWalkable); + +// Motion-manager notifications on the grounded/airborne EDGES (acdream keeps these — they +// are the CMotionInterp HitGround/LeaveGround hooks the retail chain drives elsewhere). +bool justLanded = false; +if (nowOnWalkable && !_wasAirborneLastFrame == false /* was airborne */ ) +{ + // wasAirborne && nowOnWalkable → land +} +if (nowOnWalkable && _wasAirborneLastFrame) +{ + Movement.HitGround(); + justLanded = true; +} +if (!nowOnWalkable && !_wasAirborneLastFrame) + _motion.LeaveGround(); + +_wasAirborneLastFrame = !nowOnWalkable; +UpdateCellId(resolveResult.CellId, "resolver"); +``` + +> **Integration note (verify while writing):** the old block used `resolveResult.IsOnGround` + a `Velocity.Z <= 0` gate to decide landing and to zero `Velocity.Z`. The rebuild derives grounded state from `_body.ContactPlaneValid`/`OnWalkable` (set by `ResolveWithTransition`'s writeback), not `IsOnGround`, and no longer zeros `Velocity.Z` by hand — `handle_all_collisions` (fsf) + `calc_acceleration` (grounded → accel 0) own the settle. Keep `justLanded` feeding whatever downstream (`§6 outbound`, animation) consumed it. Preserve the HitGround-on-land / LeaveGround-on-depart edges exactly; only their *trigger* changes from `IsOnGround && v.z<=0` to `OnWalkable` transitions. + +- [ ] **Step 2: Build + full suites** + +Run: `dotnet build` (green), then `dotnet test` (Core + App + UI + Net). Expected: green — ordinary locomotion is fsf=0 dormant; the changed landing trigger must not regress the walk/slope/stairs/jump/fall conformance tests. If any locomotion test regresses, bisect within this task (the landing-trigger change is the prime suspect). + +- [ ] **Step 3: Commit** + +```bash +git add src/AcDream.App/Input/PlayerMovementController.cs +git commit -m "feat(#182): route player collision response through ported SetPositionInternal+handle_all_collisions (retires the ad-hoc reflect/land block)" +``` + +--- + +## Task 7: Crowd-jump A/B replay conformance test (Slice 2c — measured proof) + +**Files:** +- Test: `tests/AcDream.Core.Tests/Physics/Issue182CrowdJumpReplayTests.cs` (create) +- Fixture: a trimmed slice of `acdream-crowd-resolve.jsonl` covering the airborne-stuck frames → `tests/AcDream.Core.Tests/Fixtures/issue182/crowd-airborne-stuck.jsonl` + +- [ ] **Step 1: Write the replay test (pattern from CellarUpTrajectoryReplayTests)** + +Seed a `PhysicsBody` from a captured `bodyBefore` at the first airborne-stuck frame (`velocity ≈ (0,0,18)`, near-horizontal collision normal), then drive the ported per-frame chain (Resolve → PhysicsObjUpdate) for N frames and assert the body **leaves the stuck state**: `FramesStationaryFall` climbs past 1 → `Velocity` collapses to ~0 → subsequent frames show downward Z (gravity/glide), not a persisted +Z. Use `SeedBodyFromSnapshot` + `LoadCapturedRecord` from the existing harness. + +```csharp +[Fact] +public void BlockedAirborneJump_BleedsVelocity_WithinThreeFrames() +{ + var rec = LoadCapturedRecord(r => r.BodyBefore is { } b && b.Velocity.Z > 15f + && r.Result.CollisionNormalValid && MathF.Abs(r.Result.CollisionNormal.Z) < 0.5f); + var body = SeedBodyFromSnapshot(rec.BodyBefore); + // simulate the blocked frames against the same captured target — the sphere cannot + // advance, so fsf climbs 0→1→2 and handle_all_collisions zeros velocity at fsf>1. + for (int frame = 0; frame < 3; frame++) + SimulateBlockedFrame(body, rec.Input); // Resolve + PhysicsObjUpdate, target == captured target + Assert.True(body.Velocity.Length() < 1.0f, $"velocity did not bleed: {body.Velocity}"); + Assert.True(body.FramesStationaryFall >= 2); +} +``` + +Run → PASS. + +- [ ] **Step 2: Whole-capture A/B measurement (manual gate, not a unit test)** + +Rebuild the client, reproduce the crowd-jump repro live with `ACDREAM_CAPTURE_RESOLVE=after-crowd.jsonl`, then: +``` +py tools/analyze_resolve_capture.py after-crowd.jsonl +``` +**Gate:** `airborne-stuck → 0`, and `ok%` climbs toward retail's ~78% (from 50.9%). Record before/after in the commit message / ISSUES #182. If `ok% << 78%` with airborne-stuck at 0, that is the Slice 3 residual (§7 Q3) — proceed to measure TS-4. + +- [ ] **Step 3: Commit** + +```bash +git add tests/AcDream.Core.Tests/Physics/Issue182CrowdJumpReplayTests.cs tests/AcDream.Core.Tests/Fixtures/issue182/ +git commit -m "test(#182): crowd-jump airborne-stuck replay — blocked jump bleeds velocity within 3 frames" +``` + +--- + +## Task 8: Register bookkeeping + docs (same commit boundary as Task 6/7) + +**Files:** +- Modify: `docs/architecture/retail-divergence-register.md` +- Modify: `docs/ISSUES.md`, `claude-memory/project_physics_collision_digest.md` + +- [ ] **Step 1: Retire / amend rows** +- **Retire TS-3** (`:195`) — the fsf accounting is now ported (delete the row; note the retirement in the TS-section header line like the TS-45 note). +- **Amend AD-25** (`:88`) — the player-half reflect suppression is gone (retail's broader rule restored via `handle_all_collisions`). AD-25 **still covers the remote-DR sweep** in `GameWindow.cs` (#173), which is out of this arc's scope. Rewrite AD-25 to reference only the remote-DR site + note the player half was retired by this rebuild; OR split into a new AD row for the remote half. Do NOT delete (the remote sweep still suppresses). +- **Add** any adaptation this port introduces: e.g. `CachedVelocity` is computed but not yet consumed by the wire (reporting still uses the old path) — a small AP row if the wire velocity differs from retail's cached_velocity source; the fsf gate's `HasFrozenBit`/`ObjectHasGravity` derivation if it approximates retail's exact bits. + +- [ ] **Step 2: Update ISSUES + digest** +- `docs/ISSUES.md`: move #182 forward (airborne-stuck fixed; note the A/B numbers; residual ground-jam tracked if <78%). +- `claude-memory/project_physics_collision_digest.md`: replace the 2026-07-07 top banner's "designed (deferred)" with "SHIPPED" + the fsf mechanism + the A/B result + a DO-NOT-RETRY note ("the bleed is fsf>1→v=0 in handle_all_collisions, NOT cached_velocity; calc_friction 0.0 vs retail 0.25 is a SEPARATE L.3c divergence, do not fold it in"). + +- [ ] **Step 3: Commit** (fold into Task 6 or 7's commit if landing together, or a trailing docs commit). + +--- + +## Task 9: STOP for the user visual gate + +Do **not** proceed to Slice 3 without the user's visual verification. Present: +1. **Crowd glide/land** (the #182 symptom): jump into a monster crowd — does the player land/glide across the tops and shuffle out, like retail? +2. **Normal-locomotion regression pass:** flat walking, slopes, stairs, jumping, falling, wall-slide — unchanged? + +Only the user can confirm these. The suites + A/B histogram are necessary but not sufficient. + +--- + +## Task 10 (conditional): Slice 3 — residual ground-jam + +Only if Task 7's A/B shows `ok% << 78%` with airborne-stuck at 0. Measure which bucket dominates (partial vs stuck) and correlate against `slidingNormal` provenance. Prime suspect: **TS-4** (BSPQuery Path-6 steep persisted sliding-normal → #137 anti-parallel-absorb). That is in the *kept* internals — a separate, decomp-anchored fix (brainstorm a sub-slice with the user before touching it, per the roadmap-divergence rule). Do not pre-emptively touch it. + +--- + +## Self-Review + +**Spec coverage (design §4.1 functions):** +- `UpdateObjectInternal` chain → Task 6 (consolidated in the controller) + the retail-pseudocode appendix cited in code. +- `UpdatePositionInternal`/`calc_acceleration` → already present in `PhysicsBody`; the OnWalkable-gate divergence fixed in Task 2. `calc_friction` explicitly out of scope (documented, orthogonal L.3c divergence). +- `handle_all_collisions` → Task 5 (pure unit) + Task 6 (wired). **Design §7 Q1 answered: retail reflects (fsf≤1) then zeros (fsf>1).** +- `SetPositionInternal` (0x00515330 confirmed, §7 Q2) → Task 6. +- `transition`/`ResolveWithTransition` reused as-is; fsf seed/writeback added (Task 4) — the only touch to the kept-internals seam, justified as completing the TS-3 stub. +- The velocity-from-movement recompute (§4.2) → `CachedVelocity` (Task 6), correctly kept separate from the integrator per the verified two-velocity model. + +**Staging (design §4.5):** Slice 0 (measurement) → Slice 1 (fsf substrate: Tasks 2-4, dormant in locomotion) → Slice 2 (the fix: Tasks 5-7, A/B gate) → visual gate → Slice 3 (conditional residual). The design's "airborne-stuck→0 after Slice 1" gate correctly moves to Slice 2 (Task 7) — a direct consequence of the corrected mechanism. + +**Type consistency:** `FramesStationaryFall` (int) and `CachedVelocity` (Vector3) on `PhysicsBody`; `TransientStateFlags.Stationary{Fall,Stop,Stuck}` = 0x10/0x20/0x40; `PhysicsObjUpdate.HandleAllCollisions(body, fsf, cnValid, cn, prevContact, prevOnWalkable, nowOnWalkable)` — signature used identically in Tasks 5 & 6. + +**Placeholder scan:** two spots are marked "verify while writing" (the `ObjectInfo` frozen/gravity/contact bit accessors in Task 3; the landing-edge wiring in Task 6) — these are genuinely dependent on exact acdream `ObjectInfo`/controller field names to be read at implementation time, not hand-wavy gaps; the retail semantics + pc anchors are pinned. All code steps show concrete code. + +**Risk (design §6):** replaces the core of every jump/fall/step. Mitigations honored: transition internals untouched (except the TS-3 stub completion), fsf dormant in ordinary locomotion, measured A/B before the visual gate, and a hard stop for visual verification. diff --git a/docs/superpowers/plans/2026-07-08-185-outdoor-stairs-fix.md b/docs/superpowers/plans/2026-07-08-185-outdoor-stairs-fix.md new file mode 100644 index 00000000..c7f6f09b --- /dev/null +++ b/docs/superpowers/plans/2026-07-08-185-outdoor-stairs-fix.md @@ -0,0 +1,223 @@ +# #185 Outdoor-Stairs Phantom Fix — Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: this plan is intended for **inline execution by the +> lead engineer with full context** (superpowers:executing-plans), NOT subagent dispatch — it edits +> frozen collision internals and pins the fix empirically (CLAUDE.md: "Do not integrate via subagent +> unless the subagent has the full context"). Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** the local player walks up the full house-on-stilts outdoor staircase with no jam and no jump. + +**Architecture:** restore retail's invariant that a grounded mover on a continuous walkable surface +keeps `contact_plane_valid` on the forward move (`transitional_insert` short-circuit, pc 273244), so +it never falls into the step-down recovery that cannot reach the *coplanar (at-level)* stair +continuation and fabricates a horizontal `(0,1,0)` sliding normal (`PrecipiceSlide`, the #137/TS-4 +family). The exact retention-loss line is pinned by a dat-backed replay test, then fixed faithfully. + +**Tech stack:** C# .NET 10, xUnit, `DatCollection` dat reader, `AcDream.Core.Physics` +(`PhysicsEngine.ResolveWithTransition`, `Transition`, `SpherePath`, `ShadowObjectRegistry`). + +**Design spec:** `docs/superpowers/specs/2026-07-08-185-outdoor-stairs-fix-design.md` (read first). + +**Fixtures already captured (this session, in the scratchpad):** +`185-recapture.jsonl` (jam pinned at `(131.71, 77.914, 61.485)`, `slidingNormal (0,1,0)`, +`collisionNormal (0,0.78,0.62)`); `gfxdump/0x01000AC5.gfxobj.json` (step-box tread = poly id 4, local +plane `(-0.625,0,0.781,-0.312)`); `[resolve-bldg]` per-object world origins, e.g. `0xF6822103 → +entOrigin_lb (132.0,77.2,60.4)`, tread world verts `(132.75,77.495,61.015)…`. **Copy the two gfxobj +dumps into `tests/AcDream.Core.Tests/Physics/fixtures/` in Task 1** so the test is self-contained. + +**Reference tests to mirror (read before writing Task 1):** +`tests/AcDream.Core.Tests/Physics/Issue137CorridorSeamReplayTests.cs` (replay + probe-capture shape), +`DoorBugTrajectoryReplayTests.cs` / `CellarUpTrajectoryReplayTests.cs` (registering a **building/shadow +object** and replaying a trajectory — the outdoor-static harness #185 needs), `GfxObjDumpRoundTripTests.cs` +(loading a gfxobj + its physics polys), `ShadowObjectRegistryMultiPartTests.cs` (`RegisterMultiPart` API). + +--- + +## Task 1: Red replay test — reproduce the wedge over the real stair objects + +**Files:** +- Create: `tests/AcDream.Core.Tests/Physics/Issue185OutdoorStairsSeamReplayTests.cs` +- Create (fixtures): copy `…/scratchpad/gfxdump/0x01000AC5.gfxobj.json` (+ `0x01000ACA`) → + `tests/AcDream.Core.Tests/Physics/fixtures/` +- Read (harness API): `src/AcDream.Core/Physics/ShadowObjectRegistry.cs:92,152` + (`Register` / `RegisterMultiPart`), `PhysicsEngine.ResolveWithTransition`, and the two building-replay + reference tests above. + +- [ ] **Step 1: Read the reference harness.** Read `DoorBugTrajectoryReplayTests.cs` and + `CellarUpTrajectoryReplayTests.cs` end-to-end to learn exactly how they (a) build a `PhysicsEngine`, + (b) register a building object's collision shape (`ShadowShapeBuilder`/`RegisterMultiPart` from a + Setup/GfxObj + world transform), and (c) drive `ResolveWithTransition`. Read + `GfxObjDumpRoundTripTests.cs` for how a gfxobj's `ResolvedPolygons` (the physics polys, incl. tread + poly id 4) are obtained from the dat. Confirm whether registration takes a Setup id or a GfxObj id; + the stairs are landblock statics whose collision is the GfxObj's own BSP/polys (no Setup cylsphere). + +- [ ] **Step 2: Write the harness + the FAILING wedge test.** Build a `PhysicsEngine`, register the + stair step objects at their captured world transforms (each = `entOrigin_lb` translation × the +90°-about-Z + rotation that maps local tread normal `(-0.625,0,0.781)` → world `(0,-0.625,0.781)`), covering at least + the objects spanning the jam seam (`0xF68221` parts 1–3 at entOrigin Y 76.2/76.7/77.2 **and** the next + object up whose tread covers Y∈[77.5,78.0]+ — derive its origin as the +0.5 world-Y / +0.4 world-Z step + from `0xF68221` part 3). Seed a grounded body on tread N (contact plane + walkable poly = the tread quad, + world verts `(132.75,77.495,61.015),(131.25,77.495,61.015),(131.25,76.995,60.615),(132.75,76.995,60.615)`). + Replay the forward run from `(131.72,77.49,61.15)` toward `(131.71,78.18,61.15)` for ~6 held-forward + frames (flat target, +Y ≈ 0.2/frame — the movement controller sends flat, physics climbs). Use the + `ResolveWithTransition` args from the capture: `sphereRadius 0.48`, `sphereHeight 1.835`, + `stepUpHeight 0.6`, `stepDownHeight 1.5`, `isOnGround true`, `moverFlags IsPlayer|EdgeSlide`. + +```csharp +// The wedge assertion (RED before the fix): the run must climb PAST the seam, not pin at Y≈77.9. +Assert.True(pos.Y > 78.10f, + $"Player must climb past the tread seam (reached Y={pos.Y:F3}); pinned at ~77.9 with " + + $"slidingNormal=(0,1,0) = the #185 fabricated-precipice wedge."); +Assert.False(body.TransientState.HasFlag(TransientStateFlags.Sliding), + "A continuous walkable ramp seam must not persist a horizontal sliding normal (#137 family)."); +``` + +- [ ] **Step 3: Run it — verify it FAILS (reproduces the wedge).** + Run: `dotnet test tests/AcDream.Core.Tests --filter "FullyQualifiedName~Issue185OutdoorStairsSeamReplay" -v n` + Expected: **FAIL** — `pos.Y` pins at ~77.9 and/or `Sliding` flag set (the wedge reproduced offline). + **If it does NOT reproduce** (climbs clean offline), the live trigger involves state beyond the replay's + reach (as the #137 corridor replay initially did) — STOP and add the missing seed (the exact + `bodyBefore` from `185-recapture.jsonl` tick 4277: contact plane, walkable verts, and the prior-frame + `slidingNormal`) before proceeding; do not weaken the assertion. + +- [ ] **Step 4: Commit the red test.** +```bash +git add tests/AcDream.Core.Tests/Physics/Issue185OutdoorStairsSeamReplayTests.cs \ + tests/AcDream.Core.Tests/Physics/fixtures/0x01000AC5.gfxobj.json \ + tests/AcDream.Core.Tests/Physics/fixtures/0x01000ACA.gfxobj.json +git commit -m "test(#185): red — dat-backed outdoor-stairs seam replay reproduces the wedge + +Registers the real stair step-boxes and replays the captured forward run; pins the +jam (no advance past Y~77.9, persisted (0,1,0) sliding normal). RED before the fix. + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 2: Pin the exact retention-loss site + +**Files:** +- Modify (temporary probe only, reverted at end): the replay test — wrap the seam-crossing frame with + `PhysicsDiagnostics.ProbeContactPlaneEnabled = true` (env `ACDREAM_PROBE_CONTACT_PLANE`) + + `ProbeStepWalkEnabled` + `ProbeIndoorBspEnabled`, capturing `Console.Out` (exactly as + `Issue137CorridorSeamReplayTests.SeamShake_WestBoundary_SnapshotExact_Advances` does, lines 207–236). +- Read: `src/AcDream.Core/Physics/TransitionTypes.cs` (TransitionalInsert loop `~1030–1110` + Slid-clears at 1047/1073/1102; the neg-poly/step-down dispatch `~1339`; `ValidateTransition` LKCP + retention `~4645–4735`), `src/AcDream.Core/Physics/PhysicsEngine.cs` (seed `~1004`, writeback `~1131`). + +- [ ] **Step 1: Capture the seam-crossing frame's contact-plane transitions.** Run the red test with the + probes on; in the emitted trace, find the frame that reaches the step-down dispatch with + `ci.ContactPlaneValid == false`, and identify **which** upstream event set it false: + (a) an env/building/object channel returned **Slid** (clears cp at 1047/1073/1102), or + (b) the seed at `PhysicsEngine.cs:1004` never re-validated and the forward main-sweep set no fresh + contact plane, or + (c) `ValidateTransition`'s LKCP proximity guard (`~4698`, `radius+ε > |angle|`) DROPPED the plane + because the floated sphere is >radius from tread N's plane. + Record the concrete site (file:line + the branch) in a scratch note; this selects the Task-3 candidate. + +- [ ] **Step 2: Confirm the retail-faithful expectation for that site.** Grep the named-retail decomp for + the corresponding retail function (the Slid channel → `BSPTREE::find_collisions` Contact branch + pc 323838+, or `set_contact_plane`/`get_object_info` pc 272547 for the retain path) and confirm what + retail does that keeps `contact_plane_valid` here. Do NOT invent behavior — cite the pc line. This is + the gate: the fix must make acdream match that retail behavior, not add a guard. + +--- + +## Task 3: Apply the retail-faithful grounding-retention fix + +**Files:** +- Modify: the pinned site from Task 2 in `src/AcDream.Core/Physics/TransitionTypes.cs` (or + `PhysicsEngine.cs`). Exactly ONE of the candidates below, chosen by Task 2's pin + Task 2's retail cite. + +- [ ] **Step 1: Apply the fix matching the pinned site.** Candidate edits (pick the one Task 2 selected): + + - **Candidate A (pin = spurious Slid on the coplanar-graze):** the grounded foot grazing the coplanar + continuation tread is being routed to a Slid (clearing cp) where retail records a walkable + contact/step (keeps cp). Fix the specific collision-response branch so a grounded mover grazing a + **walkable** (normal.Z ≥ FloorZ) coplanar poly it is resting on retains/sets the contact plane + instead of clearing it — mirroring the retail Contact-branch path Task 2 cited. Do not blanket-skip + Slid; scope to the walkable-coplanar-continuation case. + + - **Candidate B (pin = forward move sets no fresh contact plane):** ensure the grounded forward move + re-establishes `ci.ContactPlane` from the coplanar tread the sphere rests on (retail's forward + landing keeps `contact_plane_valid`, pc 273244) — e.g. the walkable-landing/`find_walkable` on the + forward insert must find the at-level continuation, not only a below-foot surface. + + - **Candidate C (pin = LKCP proximity guard drops the plane):** the floated sphere separates from + tread N's plane by >radius so the guard (`~4698`) drops it — but the sphere is genuinely resting on + the coplanar continuation. Fix so the proximity check is evaluated against the surface actually under + the sphere (the coplanar continuation), matching retail's `get_object_info` retain logic (pc 272547), + rather than dropping grounding at the seam. + + Each candidate is a **localized** change. If the pinned faithful fix is larger than a localized edit, + STOP and return to the user (scope guard, per the spec §3). + +- [ ] **Step 2: Register bookkeeping in the same commit.** Amend `docs/architecture/retail-divergence-register.md` + row **TS-4** (or add a new row) to record the grounding-retention change and its retail oracle + (pc 273244 / the Task-2 cite); retire/narrow as the port dictates. + +--- + +## Task 4: Green the replay + remove the temporary probes + +- [ ] **Step 1: Remove the temporary probe wrapping** added in Task 2 (leave the test asserting behavior, + no probe side effects). +- [ ] **Step 2: Run the red test — verify it now PASSES.** + Run: `dotnet test tests/AcDream.Core.Tests --filter "FullyQualifiedName~Issue185OutdoorStairsSeamReplay" -v n` + Expected: **PASS** — the run climbs past Y=78.10 with no persisted sliding normal. +- [ ] **Step 3: Commit the fix + green test.** +```bash +git add -A +git commit -m "fix(#185): keep the mover grounded on a continuous walkable ramp seam + +. The grounded +forward move now retains contact_plane_valid across the coplanar stair seam +(retail transitional_insert pc 273244) instead of dropping into the step-down +recovery that can't reach the at-level continuation and fabricates a horizontal +(0,1,0) sliding normal (PrecipiceSlide, #137/TS-4 family). Register TS-4 amended. + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 5: Regression — the shared grounded-move path + +- [ ] **Step 1: Run the #137 suites (must stay green / un-skipped).** + Run: `dotnet test tests/AcDream.Core.Tests --filter "FullyQualifiedName~Issue137" -v n` + Expected: PASS (`Issue137CorridorSeamReplayTests`, `Issue137SlidingNormalLifecycleTests`, + `Issue137CorridorSeamInspectionTests`). Also run `CellarUpTrajectoryReplayTests`, `BSPStepUpTests`, + `SphereCollisionFamilyTests` — the step-up/step-down/slide neighbors. +- [ ] **Step 2: Full build + test.** + Run: `dotnet build src/AcDream.App/AcDream.App.csproj -c Debug` then + `dotnet test` (Core / App / UI / Net). Expected: all green, 0 warnings. +- [ ] **Step 3: If any regressed,** the fix over-reached (not scoped to the walkable-coplanar-continuation + case) — narrow it and re-run; do NOT loosen the regression assertions. + +--- + +## Task 6: Bookkeeping (docs + memory) + +- [ ] **Step 1:** `docs/ISSUES.md` — move **#185** to Recently closed with the fix SHA. +- [ ] **Step 2:** `claude-memory/project_physics_collision_digest.md` — add the #185 banner (root cause + + the fix + DO-NOT-RETRY: don't un-zero Z, don't touch step-up budget, fix the grounding provenance). +- [ ] **Step 3:** roadmap/milestones — note the M1.5 #137-family stair fix if a phase line applies. +- [ ] **Step 4: Commit the bookkeeping.** +```bash +git add docs/ISSUES.md claude-memory/project_physics_collision_digest.md +git commit -m "docs(#185): close — grounding-retention fix for the outdoor-stairs phantom + +Co-Authored-By: Claude Opus 4.8 " +``` + +--- + +## Task 7: Live visual gate (USER — acceptance) + +- [ ] **Step 1: Build green, then launch** (canonical live command; no pre-close of running clients). +- [ ] **Step 2: USER walks `+Acdream` up the FULL outdoor staircase** — must climb with no jam and no + jump. Then regression spot-checks: indoor cellar/corridor stairs, another outdoor building, a ramp, + flat ground — no new phantom blocks AND no sliding through walkable ramps/edges. +- [ ] **Step 3:** on pass, #185 is closed (bookkeeping already landed in Task 6). On fail, capture with + the apparatus (§6 of the spec) and re-pin — do not guess a follow-up. diff --git a/docs/superpowers/specs/2026-06-30-movement-wire-parity-design.md b/docs/superpowers/specs/2026-06-30-movement-wire-parity-design.md new file mode 100644 index 00000000..4b9cb126 --- /dev/null +++ b/docs/superpowers/specs/2026-06-30-movement-wire-parity-design.md @@ -0,0 +1,292 @@ +# Movement / Animation Wire-Parity Slice — Design + +Date: 2026-06-30 +Phase: **L.2b** (movement wire/contact authority) + **L.1b** (command router + motion-state cleanup) +Standard: **decomp-verbatim, tests-first. No approximations, no "feels like retail."** + +## Source documents (read first) + +- `docs/research/2026-06-26-movement-animation-retail-parity-audit.md` — the 12 + confirmed divergences (D1–D12) and the Phase 0–5 plan. +- `docs/research/2026-06-26-ace-vs-2013-motion-command-gap.md` — the ACE-vs-2013 + command-catalog divergence (130 common names with different values; the `+3` + low-word shift beginning at `SnowAngelState`). +- Oracle: `docs/research/named-retail/acclient_2013_pseudo_c.txt` (Sept 2013 EoR + build) + `docs/research/named-retail/acclient.h`. Live confirmation via the + Ghidra HTTP bridge at `http://127.0.0.1:8081` (decompile-by-address). +- Plans of record this slice serves: `docs/plans/animation-system-audit.md` (L.1) + and `docs/plans/2026-04-29-movement-collision-conformance.md` (L.2). + +## Goal + +Make the **outbound movement wire bytes** (`MoveToState 0xF61C`, `Jump 0xF61B`, +`AutonomousPosition 0xF753`) and the **inbound→animation command catalog** +byte-for-byte / value-for-value faithful to retail, proven by tests whose golden +values are derived directly from the 2013 decomp packers and cross-checked +against holtburger. + +This slice fixes the *packing* and the *catalog*. It does **not** port the +motion-interpreter input-state construction (`adjust_motion` / +`apply_raw_movement`) — that is the next slice (D6 / audit Phase 2), explicitly +deferred below. + +## Scope + +### In scope +- **D1** — `RawMotionState::Pack` default-difference flag packing (replaces + presence-based flags). +- **D3** — `MoveToStatePack` trailing byte = `contact | standingLongjump`. +- **D4** — `JumpPack` layout (extent, velocity, full Position, four timestamps; + drop the spurious objectGuid/spellId). +- **Catalog gap** — dual command catalog (`AceModernCommandCatalog` runtime + default + `Retail2013CommandCatalog` conformance), built behind an + `IMotionCommandCatalog` seam; full 2013 `command_ids[0x198]` extraction; + DAT-availability tests. +- **Phase 0 oracle tests** — written first and failing, encoding the four retail + `Pack` functions and the catalog matrices. + +### Out of scope (later L.1/L.2 slices — see "Deferred / unresolved") +D2 (runtime actions-list/current_style emission), D5 (heartbeat-clock stamping — +*audit only* this slice), D6 (`adjust_motion`/`apply_raw_movement` input-state), +D7 (animation/motion application reorder), D8 (MoveToManager/force-walk), D9 +(inbound types 8/9), D10 (spawn-time MoveTo), D11 (sequence/autonomy +propagation), D12 (jump/contact gates). + +## Decisions (locked with the user 2026-06-30) + +1. **First slice = catalog + outbound wire** (not catalog-only, not + motion core). +2. **Golden-byte oracle = decomp-derived + holtburger cross-check**, confirmed via + the Ghidra bridge. No live retail capture for this slice (captures are reserved + for Phase 2, where retail's *input state* is the genuine unknown). +3. **Catalog mechanism = Option A** — `IMotionCommandCatalog` interface; static + `MotionCommandResolver.ReconstructFullCommand(ushort)` is retained, delegating + to an `AceModernCommandCatalog` singleton so all ~10 runtime call sites are + unchanged. Tests instantiate `Retail2013CommandCatalog` explicitly. +4. **2013 table depth = full extraction** (~408 `command_ids[0x198]` entries with + provenance), not a test-matrix stub. + +## Component design + +### 1. Command catalog (L.1b) + +**Seam.** New interface in `AcDream.Core.Physics`: + +``` +public interface IMotionCommandCatalog +{ + /// Reconstruct the full 32-bit MotionCommand from a 16-bit wire value. + /// Returns 0 if no entry matches. + uint ReconstructFullCommand(ushort wireCommand); +} +``` + +**`AceModernCommandCatalog : IMotionCommandCatalog`** — the runtime default. +Built from the DatReaderWriter / ACE `MotionCommand` enum (these share values; +ACE's enum is the authoritative ACE-modern catalog and matches the local DATs). +Reconstruction = wire-low → full lookup, with collisions resolved by the +documented retail class priority (lower class byte wins: Action 0x10 < SubState +0x41 < Style 0x80 …) applied **at build time**, producing a flat +`IReadOnlyDictionary`. + +- **Verify and (likely) delete the magic override.** The current + `MotionCommandResolver.ApplyNamedRetailOverrides` force-maps `0x016E–0x0197` + to `0x10000000 | lo`. Once `AceModernCommandCatalog` is built cleanly from the + ACE enum, assert the ACE test matrix passes (`0x0153→0x10000153`, + `0x0166→0x10000166`, `0x0171→0x10000171`, `0x0173→0x10000173`). If it passes + **without** the override loop, delete the loop (unexplained magic range; see + the magic-number-audit memory). If a specific command still resolves to the + wrong class, add a **per-command, cited** override — never a blind range. +- **Fix the wrong comment.** The shift starts at `SnowAngelState` (`0x43000115` + → `0x43000118`), not `AllegianceHometownRecall`. + +**`Retail2013CommandCatalog : IMotionCommandCatalog`** — conformance/reference. +Built from the **full** 2013 `command_ids[0x198]` table at `0x007c73e8` paired +with the command-name table at `0x008041ec..0x0080444c`. Deterministic +extraction from `acclient_2013_pseudo_c.txt` (and/or the Ghidra bridge), emitted +as a generated/static name→value table in the source with a provenance header +citing both addresses. ~408 entries. + +**`MotionCommandResolver`** keeps `public static uint ReconstructFullCommand(ushort)` +delegating to a private `static readonly AceModernCommandCatalog s_aceModern`. +All current callers (`AnimationCommandRouter`, `CombatAnimationPlanner`, 8× +`GameWindow`) are untouched. + +**DAT-availability tests.** A command animates only if the entity's `MotionTable` +has a `Links` or `Modifiers` entry for the full 32-bit value. Tests +(`MotionCommandCatalogTests`, real-DAT-backed via `Chorizite.DatReaderWriter`): +- ACE mode: `0x0153→0x10000153 LifestoneRecall`, `0x0166→0x10000166`, + `0x0171→0x10000171`, `0x0173→0x10000173`. +- 2013 mode: `0x0150→0x10000150 LifestoneRecall`, `0x0163→0x10000163`, + `0x016E→0x1000016E`, `0x0170→0x10000170`. +- Availability: `LifestoneRecall (ACE 0x10000153)` and `HouseRecall` exist in + local DAT MotionTables; `MarketplaceRecall / AllegianceHometownRecall / + PKArenaRecall / OffhandSlashHigh` exist **only** under the ACE-shifted IDs + (reproduces the gap doc's link-hit scan as a fixture assertion). + +### 2. RawMotionState model + default-difference packing (D1) + +**Data type** `AcDream.Core.Physics.RawMotionState` — a value type mirroring the +retail struct (`acclient.h RawMotionState::PackBitfield`, decomp `0x0051ed10`): + +| field | retail default | bit | +|---|---|---:| +| current_holdkey | `HoldKey.None` (1) | 0x001 | +| current_style | `0x8000003D` | 0x002 | +| forward_command | `0x41000003` | 0x004 | +| forward_holdkey | `HoldKey.Invalid` (0) | 0x008 | +| forward_speed | `1.0f` | 0x010 | +| sidestep_command | `0` | 0x020 | +| sidestep_holdkey | `HoldKey.Invalid` (0) | 0x040 | +| sidestep_speed | `1.0f` | 0x080 | +| turn_command | `0` | 0x100 | +| turn_holdkey | `HoldKey.Invalid` (0) | 0x200 | +| turn_speed | `1.0f` | 0x400 | +| actions (list) | empty | `num_actions<<11` (bits 11–15) | + +Pure data, no GL/Net dependency. Lives in Core.Physics so the Phase-2 motion +interpreter (also Core.Physics) can populate it without a Core.Net dependency. +A `RawMotionState.Default` exposes the retail defaults. + +**Packer** in `AcDream.Core.Net` (Core.Net may reference Core.Physics; the +reverse is forbidden by Code Structure Rule #2). Ports `RawMotionState::Pack` +verbatim: +1. Build flags dword: set bit *only* when the field **differs from its default** + (`forward_speed != 1.0f`, `current_holdkey != None`, etc.), OR in + `num_actions << 11`. **Note the bitfield is bits 0–15 only** — bits 16–31 are + unused (retail `num_actions` is 5 bits, max 31). The current + `MoveToState.cs` comment "bits 11–31 = command list length" is wrong; correct + it to bits 11–15 = `num_actions`. +2. Write the flags dword. +3. Write each set field in bit order (holdkey, style, fwd_cmd, fwd_holdkey, + fwd_speed, ss_cmd, ss_holdkey, ss_speed, turn_cmd, turn_holdkey, turn_speed). +4. Write each action: `u16 command` then + `u16 (stamp & 0x7FFF) | (autonomous ? 0x8000 : 0)` (decomp lines 293945–293960). + +`MoveToState.Build` is refactored to take a `RawMotionState` (plus position, +sequences, contact, standingLongjump) instead of the flat nullable param list. + +**Behavioral effect vs ACE:** the only runtime change is *removing* over-sent +defaults (`forwardSpeed=1.0`, `currentHoldKey=None`, default per-axis hold keys). +ACE's `UnPackNet` defaults omitted fields, so this is strictly more correct. The +slice does **not** change which RawMotionState values the caller constructs +(that is D6) — it threads the same values the caller passes today through the new +struct. Smoke-test against ACE confirms no regression. + +### 3. MoveToState trailing byte (D3) + +From `MoveToStatePack::Pack` (`0x005168f0`, lines 284717–284722): the trailing +byte is `((longjump_mode != 0 ? 0x02 : 0) | (contact != 0 ? 0x01 : 0))`. Then +ALIGN to 4. + +`MoveToState.Build` gains explicit `bool contact` and `bool standingLongjump` +params. `standingLongjump` is wired to its true current value (`false` — standing +longjump is not implemented yet). The *packing* is faithful; the *input* is +honest. When standing longjump lands (later), the param flips. This is not a +masking shortcut — it is the correct byte with the correct current input. + +### 4. JumpPack (D4) + +From `JumpPack::Pack` (`0x00516d10`, lines 284934–284963), field order: +1. `f32 extent` +2. `f32 velocity.x, velocity.y, velocity.z` +3. `Position.Pack` (objcell_id + frame) +4. `u16 instance_timestamp, server_control_timestamp, teleport_timestamp, force_position_ts` +5. ALIGN to 4 + +`JumpAction.Build` is rewritten to this layout. The current spurious +`u32 objectGuid` + `u32 spellId` are **removed** (no retail evidence). New params: +`cellId`, `position`, `rotation`. Caller at `GameWindow.cs:8343` supplies them +(it already has `wireCellId` / `wirePos` / `wireRot` in scope). + +### 5. AutonomousPosition (D5 audit + timestamp order) + +`AutonomousPositionPack::Pack` (`0x00516af0`): Position, then `u16` instance / +server_control / teleport / force_position, then a **contact-only** byte +(`contact != 0`; no longjump bit), then ALIGN. Current code matches. Add: +- a timestamp-**order** golden test (instance, serverControl, teleport, + forcePosition); +- a contact-byte test. + +**D5 audit (no behavior change unless decomp proves divergence):** read +`CommandInterpreter::SendMovementEvent` (`0x006b4680`) and `SendPositionEvent` +(`0x006b4770`) and compare what they stamp (`last_sent_position_time` vs +position vs contact_plane) to acdream's `NotePositionSent`. Document the finding; +change behavior only if the decomp shows a real divergence. + +### 6. Position::Pack verification + +`Position::Pack` is shared by all three messages and currently writes +`cellId, x, y, z, qw, qx, qy, qz`. It works against ACE, but for strict parity: +decompile `Position::Pack` / `Frame::Pack` by address, confirm the field order, +and lock it with a golden test on the Position block. Fix only if the decomp +diverges; otherwise the test pins it. + +## Test inventory (written first, failing) + +Core.Net.Tests: +- `RawMotionStatePackTests` — default state (only the flags dword, value `0`); + walk-forward speed 1.0 (forward_command + forward_holdkey set, **forward_speed + omitted**); run forward (holdkey + fwd_cmd + fwd_holdkey + fwd_speed); backward; + sidestep right/left; turn right/left; non-default current_style; a populated + actions list (num_actions bits + per-action u16 pair); contact/longjump + trailing byte combinations. +- `MoveToStateGoldenTests` — full-message golden bytes for walk, run, slow-walk + (toggle-run), sidestep, turn, contact, standing-longjump. +- `JumpActionTests` — retail `JumpPack` layout, full Position present, no + object/spell fields. +- `AutonomousPositionTests` — timestamp order + contact byte. +- `PositionPackTests` — Position block byte order. + +Core.Tests: +- `MotionCommandCatalogTests` — ACE-mode + 2013-mode matrices; class-priority + collisions; the "override deleted" assertion (or per-command cited override). +- `MotionCommandCatalogDatTests` — real-DAT availability assertions. + +Golden bytes are computed by hand from the decomp `Pack` functions (cited by +address in each test) and cross-checked against holtburger's Rust packers. + +## Layering & placement + +- `IMotionCommandCatalog`, `AceModernCommandCatalog`, `Retail2013CommandCatalog`, + `RawMotionState` → `src/AcDream.Core/Physics/`. +- `RawMotionState` packer + the three message builders → `src/AcDream.Core.Net/Messages/`. +- Caller wiring → `src/AcDream.App/Rendering/GameWindow.cs` (MoveToState ~8277, + Jump ~8343) — minimal: build a `RawMotionState`, pass new contact/longjump and + jump position params. No new feature body in `GameWindow` (Code Structure Rule #1). +- Tests in the project matching the layer (Rule #6). + +## Deferred / unresolved (called out, not guessed) + +- **D6 (next slice):** the runtime does not yet construct the exactly-retail + `RawMotionState` (run-vs-walk `forward_command`, hold-key derivation, backward + / sidestep-left speed normalization). This slice makes the *packer* verbatim; + state construction is `adjust_motion`/`apply_raw_movement` (audit Phase 2). +- **D5 (CONFIRMED 2026-06-30, deferred):** the audit found a real divergence — + retail's `SendMovementEvent` (0x006b4680) stamps ONLY `last_sent_position_time` + after an MTS, while `SendPositionEvent` (0x006b4770, AP) stamps all three + (time + position + contact-plane); acdream's `NotePositionSent` stamps all three + after both. Broader: acdream gates APs on a plain interval (`HeartbeatDue`) where + retail uses `ShouldSendPositionEvent` (0x006b45e0). Left unchanged this slice (code + comments added at both call sites); recorded as register row **TS-33** and deferred + to a dedicated cadence-port follow-up slice (port `ShouldSendPositionEvent` + split + MTS/AP stamping). +- **D2:** actions-list / current_style packing is structurally supported and + tested, but the runtime emits 0 actions; populated emission is Phase 2+. +- **D9/D8/D10/D11/D12, D7:** later L.1/L.2 slices. + +## Bookkeeping (mandatory) + +- **Divergence register:** delete the rows for D1, D3, D4 in the same commit that + ports each. If any new deviation is introduced, add its row in the same commit. +- **Roadmap:** update L.2b (wire) and L.1b (catalog) "shipped" notes when landed. +- **Memory:** if a durable lesson emerges (e.g., the default-difference packing + pattern, the dual-catalog seam), capture it. + +## Acceptance criteria + +- Failing oracle tests written first; then green after implementation. +- `dotnet build` + `dotnet test` green at each commit. +- Every ported algorithm cites the named retail symbol + address in test/comment. +- ACE smoke pass: login, walk/run/sidestep/turn/jump, observe no server + rejection; confirm the over-sent defaults are gone on the wire (dump or capture). +- Divergence register rows for D1/D3/D4 retired; roadmap updated. diff --git a/docs/superpowers/specs/2026-07-05-modern-pipeline-design.md b/docs/superpowers/specs/2026-07-05-modern-pipeline-design.md new file mode 100644 index 00000000..1a5293ef --- /dev/null +++ b/docs/superpowers/specs/2026-07-05-modern-pipeline-design.md @@ -0,0 +1,414 @@ +# Design — Modern Pipeline side track (MP): baked assets + ECS render world + zero-alloc frame loop + +**Date:** 2026-07-05 +**Status:** brainstorm-approved; awaiting user spec review +**Origin:** user-commissioned performance side track ("fully modern pipeline, with ECS"). +Explicitly NOT M1.5 work — see §12 for the firewall. +**Phase prefix:** `MP0–MP5` (MP = Modern Pipeline; avoids collision with the existing +P0 conformance-apparatus plan). +**Implementation cadence:** each MP phase gets its own implementation plan +(`docs/superpowers/plans/`) when it starts; this spec is the umbrella design. The +first plan covers MP0 (+ MP1 scaffold) only. + +--- + +## 1. Motivation + measured baseline + +acdream's steady-state dense-town frame rate is ~165 FPS (~6 ms/frame) after the +2026-06-23/24 fixes, versus 300+ FPS in comparable modern titles on the same machine. +Traversal (streaming, portal hops) still hitches. The measured facts this design +builds on (do NOT re-derive; sources in §14): + +| Fact | Evidence | +|---|---| +| GPU is nearly idle: ~0.5 ms/frame real GPU time in dense town | 2026-06-23/24 deep-dive; the "12 ms GPU" was a glFinish artifact | +| The frame is CPU-submission-bound | dense-town attribution report; per-cell batch fix took 75→~165 FPS | +| `_datLock` contention (the 30↔200 swing) is FIXED — lockwait 88 ms p95 → 0.2 µs | `536f1c04` + handoff §1 | +| No distance-degrade: every frustum-visible object draws at full detail at any distance (~1,400 draws / ~24,000 instances) | 2026-06-23 handoff §2; `GfxObjDegradeResolver.cs` "always slot 0" comment | +| Parked CPU levers: `WbDrawDispatcher` per-frame static-scenery rebuild (~2.1 ms), cross-frame dispatcher cache (judged HIGH-risk as a *patch* to the frozen renderer) | feedback_render_perf_measurement.md | +| Load hitches come from runtime dat decode (mesh extraction, texture decode, BSP graph construction) + GC | thread-safety investigation; two-tier streaming architecture | +| Runtime dat reads carry an unbounded second-layer cache (`DatDatabaseWrapper._cache`) stacked on DRW's own | `DatCollectionAdapter.cs:119` | + +The conclusion the whole design follows from: **the language and the GPU are not the +bottleneck; the data layout and the per-frame/at-load CPU work are.** Modernizing means +(a) moving decode work offline, (b) making the renderer process *changes* instead of +re-describing the scene every frame, (c) flattening hot data, (d) removing frame-loop +allocation. + +## 2. Goals & acceptance + +1. **Smoothness (primary):** no frame over ~16 ms during any traversal — town walking + while streaming, portal hops, dungeon transitions. Measured: p99 frame time from the + MP0 profiler across a scripted traversal route, plus user-eyes confirmation. +2. **Throughput:** 300+ FPS sustained in the dense-town worst cases (Fort Tethana, + Arwic, Holtburg), Release build, vsync off, user's machine, standing + panning. +3. **Architecture:** baked asset pipeline (pak), Arch-based ECS render world, + zero-allocation steady-state frame loop. + +**Non-goals (binding):** +- No Rust. Decision recorded: the bottleneck is architectural, not language; a rewrite + discards ~200K lines of verified retail-faithful ports. +- No ECS in the simulation. `MovementManager`, the animation sequencer, physics + transitions, weenies keep their retail-mirroring OO structure — that correspondence + is the project's debugging methodology. +- No retail-visible behavior changes. Everything here is perf-only + (per feedback_render_perf_not_faithfulness_gated) except MP2, which is a *faithful + port* that retires a known divergence. +- Not M1.5 work. #137/#138/A7 continue independently and win all conflicts. + +## 3. Decisions recorded from the brainstorm + +| Decision | Choice | Why | +|---|---|---| +| Language | C#/.NET 10 | Perf gap to Rust for optimized code is ~10–30%; our gap is architectural multiples; 200K LOC of verified ports retained | +| ECS flavor | **Arch framework** (NuGet `Arch`, ~2.1.x) — render world only | User choice (craft/learning value); fastest .NET archetype ECS; contained + swappable behind our interfaces | +| Bake UX | CLI tool (`acdream-bake`) now; client auto-detect + offer later | Iteration speed while the format churns | +| Sequencing | Measure → smooth → throughput | User priority: smoothness first | +| Cutover style | Per-phase gated slices, legacy path deleted at each gate | A8/N.5 history: big-bang cutovers and lingering dual paths both failed here | + +## 4. Architecture overview + +``` +┌────────────────────────────────────────────────────────────────────┐ +│ SIMULATION (unchanged structure) │ +│ retail-shaped OO: physics, MovementManager, sequencer, weenies │ +└──────────────┬─────────────────────────────────────────────────────┘ + │ one seam: transform/lifecycle events (single-owner) +┌──────────────▼─────────────────────────────────────────────────────┐ +│ ECS RENDER WORLD (Arch, AcDream.App) [MP3] │ +│ entities = drawables; components = Transform, MeshRef, Degrade, │ +│ Residency, Flags; systems = TransformSync → Degrade → Visibility │ +│ → Upload(dirty ranges) → Draw(MDI) │ +└──────────────┬─────────────────────────────────────────────────────┘ + │ handles into +┌──────────────▼─────────────────────────────────────────────────────┐ +│ ASSET LAYER (pak) [MP1] │ +│ acdream-bake (offline, uses DRW + existing tested interpretation) │ +│ → pak file → PakReader (mmap, zero-copy, no locks, no decode) │ +└──────────────┬─────────────────────────────────────────────────────┘ + │ persistent-mapped staging, budgeted uploads +┌──────────────▼─────────────────────────────────────────────────────┐ +│ GPU (unchanged N.5 foundation: bindless + MDI, 3 SSBOs) │ +└────────────────────────────────────────────────────────────────────┘ +``` + +The N.5 bindless+MDI foundation is kept — it is already the modern half. This design +replaces what feeds it (per-frame rebuild → deltas) and what feeds *that* (runtime +decode → baked pak). + +## 5. MP0 — Apparatus (honest measurement) + +New `FrameProfiler` (dedicated class in `src/AcDream.App/Diagnostics/`, NOT GameWindow; +CLAUDE.md structure rule 1): + +- **CPU frame time**: swap-to-swap delta, ring buffer, p50/p95/p99 + histogram. +- **GPU frame time**: whole-frame `GL_TIME_ELAPSED` query, **never enabled together + with any glFinish-style per-pass bracketing** (the 2026-06-23 lesson — separate + flags, enforced in code, not convention). +- **Per-stage attribution**: `glQueryCounter` (GL_TIMESTAMP) markers per pass — no + glFinish, no nesting conflict with the frame query. +- **Allocation counter**: `GC.GetAllocatedBytesForCurrentThread()` delta per frame on + the update thread + Gen0/1/2 collection counts. This is MP4's before/after meter. +- Toggles via `RuntimeOptions` + DebugPanel (structure rules 4/5); env + `ACDREAM_FRAME_PROF=1`. **Stays in the tree permanently** (unlike the throwaway + `ACDREAM_FPS_PROF`), because every MP gate reads it. + +**Gate:** a captured baseline report (dense-town steady + scripted traversal route) with +the CPU 6 ms attributed per stage. If the attribution contradicts §1's assumed split, +the MP phase order is re-sequenced and this doc amended before MP1 starts. + +**Gate PASSED 2026-07-05** — see `docs/research/2026-07-05-mp0-baseline.md`. +Verdict: render-side-CPU split CONFIRMED (GPU ≤ ~2.7 ms, stages ≈ 0); steady +medians better than assumed (worst town p50 3.6 ms; Fort Tethana axiom view +not yet re-measured — re-check at the MP2/MP3 gates). AMENDMENT: steady-state +allocation churn (1.5–3 MB/frame → gen2 GC ~1–2/s → all town p99/max +violations) is promoted to a first-class smoothness lever: after MP1, one +bounded allocation-triage session fixes top churn sites OUTSIDE the MP3 +rewrite surface; sites inside it wait for MP3; the full zero-alloc pass +remains MP4. Teleport hitch quantified: 211 ms worst frame, 75.7 MB +single-frame allocation — MP1's "before" number. + +## 6. MP1 — Bake + pak (the smoothness backbone) + +### 6.1 The bake tool + +`acdream-bake` — new project `src/AcDream.Bake/` (console; registered in +`AcDream.slnx`). Reads the user's dats via DRW + **the same interpretation code the +client uses today**, run offline: + +- Mesh extraction (GfxObj/Setup → GPU-layout vertex/index + batch tables) via the + existing ObjectMeshManager build path. +- Texture decode (palette/INDEX16/etc. → RGBA) via the existing TextureHelpers path. + **AMENDED 2026-07-05 (MP1a ground truth):** v1 pak stores **decoded RGBA8 exactly + as the runtime path produces today** (the atlas consumes RGBA8 via + `TextureBatchData` — storing BC7/BC1 would change delivered pixels and violate + this phase's byte-identical conformance gate). BC compression (quarter the disk + + VRAM, lossy) is an explicit post-conformance option requiring its own visual + gate and user approval, not v1 scope. Mip chains remain runtime-generated + (`GenerateMipmaps` flush) in v1 for the same reason. +- BSPs (physics, cell, drawing) flattened to index-based node arrays (blittable). +- Landblock terrain data (heights/attributes) as blittable arrays. +- EnvCells (geometry + portals + surfaces) as blittable records. +- Degrade tables (per-GfxObj slot `ideal_dist`/`max_dist`/ids) — MP2/MP3 read these. +- **Scenery placement**: `SceneryGenerator` evaluated per landblock at bake; the pak + stores final instance lists (deterministic function of dat data, so bake-safe). + +**Extraction prerequisite:** the CPU-side mesh/texture build code currently lives in +`AcDream.App` next to GL code. MP1 moves the GL-free parts into a new +`src/AcDream.Content/` assembly (no GL dependency) that both `AcDream.App` and +`AcDream.Bake` reference. This is a mechanical extraction (move + namespace), not a +rewrite — the same lines keep running. Inventory-doc update required (structure rule 2). + +### 6.2 Pak format (v1) + +Single file `acdream.pak` next to the dats (path via `RuntimeOptions`): + +- Header: magic `ACPK`, format version, **dat iteration stamps** (all four dats) + + bake-tool version. Stale/missing pak at launch → clear error naming the rebake + command (CLI era) → later: auto-offer (per §3). +- TOC: flat sorted array `(assetKey: u64 [type:u8 | fileId:u32 | variant:u24]) → + (offset: u64, length: u32, flags: u32)`; binary-search or hash lookup, O(1)-ish, + loaded once. +- Blobs 64-byte aligned, uncompressed in v1 (mmap + OS page cache + NVMe; LZ4 block + compression is a noted future option, not v1 scope). + +### 6.3 Runtime consumption + +- `PakReader` in **`AcDream.Content`** (AMENDED 2026-07-05: the spec originally said + Core, but MP1a established the dependency direction Content→Core, and the pak's + blob shapes are the `ObjectMeshData` family living in Content — a Core-resident + reader would be circular. Content is GL-free, so the layering intent is + preserved; Core stays untouched): one `MemoryMappedFile`, `GetBlob(key)` → + `ReadOnlySpan` into the view; typed access via `MemoryMarshal.Cast` over + blittable segments. **No locks anywhere** — immutable mapped memory is + thread-safe to read by construction. +- Streaming workers stop decoding: a landblock load becomes TOC lookups + handing + spans to the GL upload queue. The decode worker pool shrinks to the residual + runtime-decode set (below). Request-key dedup stays in the streaming layer + (cheap loads still shouldn't be duplicate loads). +- **Retires:** runtime DRW decode on the world *render/streaming* hot path; the + unbounded `DatDatabaseWrapper._cache`. The `PhysicsDatBundle` worker pre-read + **stays through MP1–MP3** (the physics apply consumes parsed DBObj types until MP4 + restructures physics data consumption) and is retired in MP4 when physics reads the + pak's flat arrays directly. + +### 6.4 What stays on runtime DRW (v1 scope control) + +| Stays runtime | Why | +|---|---| +| UI dat assets (sprites, fonts, LayoutDescs — D.2b) | low volume, cold path | +| Audio waves (`DatSoundCache`) | low volume, already cached | +| Character-appearance palette overlays (ObjDesc) | runtime-parameterized per entity; keeps existing decode + cache | +| Motion tables / animations (sequencer) | sim-side, small, load-once | + +`DatCollection` therefore stays in-process, off the hot path. Baking these later is a +listed follow-up, not v1. + +### 6.5 Conformance + gate + +- **Equivalence test:** load a fixture set (Holtburg blocks + a dungeon + a dense-town + block) through the legacy path and the pak path; diff meshes (vertex/index bytes), + textures (pre-compression pixels), BSP structures, scenery instance lists + field-by-field. Golden = legacy path. +- **Gate:** equivalence green; portal-hop / traversal p99 from MP0 shows the hitch + class gone; user visual gate (no missing/wrong geometry); legacy decode path deleted + from the streaming hot path in the gate commit. + +### 6.6 EnvCell dedup — REQUIRED (corrected 2026-07-05 after the full-bake gate) + +The runtime deduplicates interior-cell geometry under a **content hash** +(`EnvCellRenderer.GetEnvCellGeomId(environmentId, cellStructure, surfaces)`, +bit 33 set — verbatim WB), NOT under the cell's dat fileId; **many cells share +one geometry** (AC dungeons repeat a small palette of tile geometries thousands +of times). + +**The full-bake gate (2026-07-05) proved dedup is mandatory, not optional.** +Baking all 729,888 EnvCells as separate fileId-keyed blobs produced an +**865 GB pak in 52 minutes** — 97% of the blobs were near-duplicate cell +geometry. A prior note here called that duplication "v1-acceptable"; **that was +wrong by ~100×.** Dedup is a v1 requirement. + +**The fix (bake-tool only, no pak format change):** dedup at bake time. +Compute each cell's geomId (cheap — reads the EnvCell/CellStruct header, no mesh +extraction), extract each **unique geometry once**, and emit one TOC entry per +cell-fileId all pointing at the one shared blob offset. The TOC already maps +key→offset with no uniqueness constraint on offsets, and `PakReader` is oblivious +to the sharing (pure offset lookup) — so aliasing needs no format or reader +change. Expected result: ~730K blobs → single-digit-thousand unique blobs, pak +865 GB → a few GB, bake 52 min → minutes (all three collapse from the same fix). + +**MP1c cutover (unchanged):** `RegisterCell` reads `pak[cellFileId]` → the shared +blob → registers under the runtime geomId; post-load dedup continues exactly as +today. Keying blobs by geomId *directly* remains non-viable (the hash exceeds +PakKey's 56 usable bits) — the fileId-key + aliased-offset scheme is why the +format needs no change. + +## 7. MP2 — Distance-degrade port (hide-only first cut) + +The already-scoped retail port from the 2026-06-23 handoff §3 (read it + the named +retail sources FULLY before porting — mandatory workflow): + +- Retail anchors: `GfxObjDegradeInfo::get_degrade` (`0x0051e4b0`, pseudo-C :293086), + `CPhysicsPart::UpdateViewerDistance` (`0x0050e030`, :275517), + `get_max_degrade_distance` (`0x0051e2d0`, :292918), `Render_DegradeDistance` + user setting (:3270). +- **Hide-only cut (this phase):** per-entity max-draw-distance resolved at spawn from + the degrade table; distance check in the entity walk; player + near NPCs exempt from + hiding (handoff caution). Full per-slot mesh selection deliberately lands in MP3 + where the ECS DegradeSystem owns it — accepted small double-touch, avoids building + slot-swap plumbing into a dispatcher MP3 replaces. +- Register bookkeeping: the "no distance-degrade" deviation gets its row updated to + "partial (hide faithful; slot selection pending MP3)" in the same commit; the row is + deleted in MP3's gate commit. +- **Gate:** retail side-by-side is the acceptance (same objects visible/hidden at the + same distances, user-confirmed); drawn-instance count before/after recorded from the + MP0 counters (no invented threshold — retail is the oracle); conformance test on the + `get_max_degrade_distance` math vs decomp. + +## 8. MP3 — ECS render world (Arch) + delta submission (the 300 lever) + +### 8.1 The world + +Arch `World` in `AcDream.App` owning every drawable: statics, baked scenery instances, +live entities, cell objects. Components (all blittable structs): + +- `WorldTransform` (position/rotation/scale, cell-relative frame per #145 rules) +- `MeshRef` (pak mesh handle + part index) +- `DegradeState` (current slot, per-slot table handle) +- `Residency` (landblockId, cellId) +- `RenderFlags` (translucent, hidden, player-owned, …) +- `DirtyTag` (tag component; added on change, cleared by Upload) + +### 8.2 Systems (fixed order, update thread in v1) + +1. **TransformSync** — consumes the simulation's transform/lifecycle events through + ONE seam (single-owner-state rule; the sim never writes render state directly). + Static world entities receive a transform exactly once at residency. +2. **Degrade** — retail `get_degrade` banded slot selection (ideal/max band = no + popping/hysteresis by construction), per entity per frame. Completes the MP2 port; + divergence row deleted here. +3. **Visibility** — frustum + cell/PVS gate (Option A "one gate" preserved from the + render digest — visibility computed once, enforced once). +4. **Upload** — iterates `DirtyTag` entities only; writes changed instance records + into the persistent-mapped SSBO mirror (SoA layout matching the N.5 SSBO), budgeted + per frame. +5. **Draw** — builds the MDI command buffer from the visible set and submits. Instance + *data* is GPU-resident and untouched unless dirty; only commands are per-frame. + GPU compute culling is a measured-need stretch inside this phase, not default scope. + +Steady-state per-frame cost becomes: degrade + visibility iteration (linear over +packed arrays) + uploads proportional to *what changed* (a handful of moving +entities), replacing today's full per-frame walk-and-emit (`WalkEntitiesInto` emitting +every MeshRef of every in-frustum entity every frame + the ~2.1 ms scenery rebuild). + +### 8.3 Encoded lessons (from the DO-NOT-RETRY tables — binding on implementation) + +- Cache/dirty reset gates on actual entity change via tracker (the #53 class). +- Visibility volumes derive from drawn data, never synthetic constants (#119/#128). +- Every GL state the draw uses is set, not inherited (render-self-contained rule). +- Player-owned render state written only at the player chokepoint (#131 class). +- H3 (unbounded live-entity growth across hops) is fixed here structurally: residency + eviction drops render entities (render-only eviction; sim state untouched), + re-materialized on re-entry. + +### 8.4 Conformance + gate + +- **Instance-set diff:** probe dumps the drawn (meshId, transform, slot) set from the + legacy dispatcher and the ECS path on identical fixture frames; sets must match + exactly (modulo MP2's intended hides). +- **Screenshot diff:** fixed camera poses (Holtburg outdoor set + dungeon set + + dense-town set), old vs new, pixel-identical requirement. +- Bring-up happens behind a temporary flag; **the gate commit deletes the legacy + dispatcher path** (no lingering dual pipeline — N.5 ship-amendment precedent). +- **Gate:** diffs green; dense-town steady FPS ≥ 300 OR the MP0 profile names the next + dominant cost (which then decides MP4/MP5 emphasis); user visual gate. + +## 9. MP4 — Zero-alloc frame loop + flat physics data + +**Sequencing constraint: starts only after M1.5 #137 (dungeon collision) has landed** +— it touches the same physics data structures. + +- Allocation audit driven by MP0's per-frame counter: identify every steady-state + allocation site (closures, LINQ, params arrays, list growth); fix via structs, + pooled buffers, `Span`, preallocated scratch. +- Physics consumes the pak's flattened BSP arrays: `PhysicsDataCache` swaps the + managed BSP node graph for index-walks over blittable arrays. Same traversal + order, same arithmetic — layout change only. +- **Conformance:** the existing physics test suites + the trajectory replay harness + must pass unchanged (bit-identical trajectories); that harness exists precisely for + this class of change. +- **Gate:** steady-state allocations/frame = 0 (measured); physics suites green; + traversal p99 re-measured. + +## 10. MP5 — Jobs (stretch, evidence-gated) + +Only if the MP0 profile after MP4 still shows the frame short of target: parallelize +the independent stages (Arch has built-in multithreaded query support; visibility and +degrade are embarrassingly parallel once data is flat). **Explicitly skipped with +recorded numbers if targets are already met** — parallelism is a multiplier, not a +goal. + +## 11. Testing strategy (summary) + +| Apparatus | Built in | Used by | +|---|---|---| +| FrameProfiler (CPU/GPU/alloc, percentiles) | MP0 | every gate | +| Pak equivalence diff (mesh/texture/BSP/scenery) | MP1 | MP1 gate, rebakes | +| Instance-set diff probe | MP3 | MP3 gate | +| Screenshot diff harness (fixed poses) | MP3 | MP3 gate, regressions | +| Physics trajectory replay harness | exists | MP4 gate | +| Existing suites (Core ~1568 tests, conformance sweeps) | exist | every phase (green required) | + +`DatConcurrencyStressTests` stays until MP1 retires hot-path DRW, then is scoped to +the residual runtime-DRW set (§6.4). + +## 12. Firewall, process, bookkeeping + +- **Track identity:** phases commit as `feat(pipeline): MP1 — …`. The roadmap gains a + "Modern Pipeline side track" section; the milestones doc gets an explicit + **freeze-exception paragraph** (this track deliberately reopens the frozen + streaming/rendering subsystems under new architecture, user-authorized 2026-07-05). +- **One milestone rule preserved:** M1.5 remains the active milestone; MP work happens + in dedicated side-track sessions in a separate worktree. M1.5 critical path wins + every conflict; MP4 explicitly queues behind #137. +- **Divergence register:** MP2/MP3 update-then-delete the degrade row as described. + MP1/MP3/MP4 are perf-only and must introduce **zero** rows — any behavioral + difference discovered at a gate is a bug to fix, not a deviation to register. +- **Structure rules honored:** no new GameWindow feature bodies (new classes: + `FrameProfiler`, `PakReader`, `AcDream.Bake`, `AcDream.Content`, ECS systems); + env vars through `RuntimeOptions`; tests in matching layer projects; new project + references documented in the inventory doc. +- **Dependency:** `Arch` (NuGet) added to `AcDream.App` only. License verified at + adoption (expected Apache-2.0); if ever abandoned, vendor the source + (WorldBuilder precedent) or swap for hand-rolled SoA behind the same system + interfaces. + +## 13. Risks & mitigations + +| Risk | Mitigation | +|---|---| +| Pak staleness confusion (dat patch → wrong assets) | iteration stamps in header; hard refuse + rebake instruction; auto-offer later | +| ECS cutover regresses rendering (the #53/#119/#128 class) | instance-set + screenshot diffs as hard gates; lessons encoded as binding rules (§8.3); legacy deleted only at gate | +| MP1 extraction (`AcDream.Content`) breaks the mesh path | mechanical move, no rewrite; pak equivalence test catches interpretation drift | +| Degrade double-touch (MP2 hide-only, MP3 slots) | accepted, small; hide plumbing (spawn-time max-dist) carries into MP3 unchanged | +| Arch abandonment / license surprise | verify license before adoption; vendorable; swappable behind system interfaces | +| Side track leaks into M1.5 time or files | separate worktree; MP4 hard-queued behind #137; sessions labeled | +| MP0 profile contradicts the assumed cost split | that's MP0's job — re-sequence and amend this doc before MP1 | +| Baked scenery diverges from runtime generation | scenery placement is a pure function of dat data; equivalence diff covers it | + +## 14. References + +- `docs/research/2026-06-23-fps-distance-degrade-handoff.md` — baseline numbers, degrade + retail anchors, measurement caveats (the §2/§3 this design consumes). +- `claude-memory/feedback_render_perf_measurement.md` — profiler lies + CPU-bound + attribution + parked levers. +- `claude-memory/project_render_pipeline_digest.md`, `project_physics_collision_digest.md` + — DO-NOT-RETRY tables binding on MP3/MP4. +- `docs/superpowers/specs/2026-06-23-datlock-contention-fix-design.md` — the shipped + `_datLock` fix MP1 supersedes (bundle → pak). +- `docs/research/2026-06-09-dat-reader-thread-safety-investigation.md` — DRW read-path + safety + the teardown fix + `DatConcurrencyStressTests`. +- `memory/reference_modern_rendering_pipeline.md` — N.5 SSBO layout the ECS Upload + system mirrors. +- `memory/reference_two_tier_streaming.md` — residency tiers the pak loads plug into. +- Arch ECS: https://github.com/genaray/Arch (NuGet `Arch`). diff --git a/docs/superpowers/specs/2026-07-07-player-physics-update-verbatim-rebuild-design.md b/docs/superpowers/specs/2026-07-07-player-physics-update-verbatim-rebuild-design.md new file mode 100644 index 00000000..33a8ca9f --- /dev/null +++ b/docs/superpowers/specs/2026-07-07-player-physics-update-verbatim-rebuild-design.md @@ -0,0 +1,167 @@ +# Design: verbatim rebuild of the per-frame player physics update loop + +**Date:** 2026-07-07 · **Status:** DESIGN APPROVED (implementation deferred to a fresh session) +**Driving issue:** #182 (player-vs-monster crowd collision) + the airborne "stuck in +the falling animation" regression it exposed. +**Brainstorm decisions (user):** verbatim rebuild (highest fidelity); scope = the +per-frame update LOOP, keep everything already faithful; stage the velocity model +first and measure; do the implementation in a NEW session. + +--- + +## 1. Problem (from the user, live) + +1. **Crowd jam** — packed in a group of monsters, the player gets stuck and can't + push through / wiggle out. Retail lets you shove monsters aside and keep moving. +2. **Airborne stuck** — jumping up into a crowd, retail lets you land/**glide across** + the monster tops; acdream **hangs in the falling animation** unable to rise or fall. + +The #182 CSphere-family port (committed `96ae2740`) was faithful but aimed a layer +too low: it fixed the per-contact sphere *response*, did NOT fix the crowd feel, and +**introduced the airborne-stuck regression** (before #182 the hand-rolled +de-penetration shoved the player up onto monsters). + +## 2. Evidence — the traces (the load-bearing part; do not re-derive) + +### Retail, player-attributed cdb trace (`tools/cdb/retail-crowd-jump3.cdb`) +Filtered to the local player's `CPhysicsObj` (captured from `set_local_velocity`), +during a jump-into-a-crowd repro: + +``` +pValidate=1482 pCOLLIDED=188 (12.7%) pSLID=130 (8.8%) pLand=76 → ~78% OK +``` + +- The retail **local client fully runs player-vs-creature collision** — 76 + `CSphere::land_on_sphere` (airborne creature landings), 188 COLLIDED, 130 SLID — + and still nets **~78% OK**. **NOT server-authoritative.** (An earlier v2 unfiltered + read of `land_on_sphere=0` was a false lead — the attributed trace refuted it.) +- The player **glides across / lands on** the crowd via local physics. + +### acdream, `ACDREAM_CAPTURE_RESOLVE` JSONL capture (same repro, current #182 build) +Of the player's move-intent resolves (2883 of 41832 total): + +| | acdream | retail | +|---|---|---| +| OK (reached target) | **50.9%** | ~78% | +| partial / slid | 26.7% | ~9% | +| **stuck (reverted, no advance)** | **22.4%** | ~13% | +| airborne-stuck | **115 frames** | (glides off) | + +acdream jams ~2× harder, and the 115 airborne-stuck frames ARE the falling-animation +bug. In those frames: velocity `(0,0,~18)` (a jump), a **near-horizontal creature +collision normal** (e.g. `(-0.96,-0.25,-0.15)`), the transition reverts (no advance), +and the **sliding normal flips frame-to-frame** — the #137 anti-parallel-absorb wedge. + +## 3. Root divergence (verified against decomp + capture) + +**Retail** `CPhysicsObj::UpdateObjectInternal` (0x005156b0, pc:283611) recomputes the +player's velocity from the ACTUAL collided movement every frame: + +``` +newFrame = UpdatePositionInternal(this, dt) // integrate velocity + gravity +transition = CPhysicsObj::transition(this, m_position, newFrame, 0) // collision sweep +if transition == null: set_frame(newFrame); cached_velocity = 0 +else: + offset = get_offset(m_position, transition.sphere_path.curr_pos) + cached_velocity = offset / dt // ← VELOCITY = ACTUAL MOVEMENT / dt (0x005158cb-005158ff) + SetPositionInternal(transition) +``` + +So when the player is **blocked** (resolved ≈ old position), `cached_velocity → ~0`, +gravity resumes next frame, and the player **falls / settles / glides** off the +obstacle. The collision naturally bleeds the velocity — there is no reflection step. + +**acdream** uses a different model: `PhysicsBody` integrates velocity/gravity, then +`PlayerMovementController` (`~:1008-1069`) **reflects** the into-wall component on +collision (`Velocity = v + n·k`) and clamps Z on landing. For a straight-up jump into +a creature whose collision normal is horizontal, the reflection barely touches +Z, so +the jump velocity **persists** — the player keeps shoving up into the creature and +hangs. This is the airborne-stuck, and the same "velocity doesn't bleed on block" +shape drives the general 2× jam. + +**This velocity model is the centerpiece of the fix.** + +## 4. Design — verbatim rebuild of the per-frame loop + +Port retail's `UpdateObjectInternal` chain verbatim into a single owner of the +per-frame player physics. **Reuse the already-faithful transition internals** as the +collision primitive — do not touch them. + +### 4.1 Retail functions to port (chain of `UpdateObjectInternal`) +| Function | Address | Role | +|---|---|---| +| `CPhysicsObj::UpdateObjectInternal` | 0x005156b0 | per-frame entry: integrate → transition → commit → velocity | +| `CPhysicsObj::UpdatePositionInternal` | (grep) | integrate velocity + gravity + forces → candidate frame | +| `CPhysicsObj::calc_acceleration` | 0x00510950 | gravity / friction / buoyancy | +| `CPhysicsObj::handle_all_collisions` | 0x00514780 | retail's collision velocity response (verify role vs the cached_velocity model) | +| `CPhysicsObj::SetPositionInternal` | 0x00515330 / 0x00515bd0 / 0x00516040 (3 overloads) | commit the transition's resolved position | +| `CPhysicsObj::transition` | (grep) | collision sweep — **maps to acdream `ResolveWithTransition`, reused as-is** | + +### 4.2 In scope (rebuilt verbatim) +The per-frame player physics loop: velocity + gravity integration +(`UpdatePositionInternal`/`calc_acceleration`), the transition orchestration +(call → commit), the **velocity-from-movement recompute** (`cached_velocity = +(resolved − old)/dt`), and `handle_all_collisions`. + +### 4.3 OUT of scope (kept — already faithful, per the user "keep everything faithful") +The transition INTERNALS: `ResolveWithTransition` and everything under it — BSPQuery, +the CSphere/CylSphere collision families (incl. the #182 port), cell membership, +terrain, streaming. Retail's `transition` calls these primitives and so does ours. + +### 4.4 Architecture +A new `PhysicsObjUpdater` (or a `PhysicsBody.UpdateObjectInternal(dt)` method) owns +the retail chain verbatim. It **absorbs**: `PhysicsBody`'s ad-hoc gravity/friction +integration AND `PlayerMovementController`'s post-resolve bounce/reflect/clamp block +(`~:1008-1069`). `PlayerMovementController` shrinks to: input → velocity/jump intent → +hand off. The retail velocity-from-movement model **replaces** reflect-and-clamp +wholesale. Register a divergence-register row retiring the reflect model + any +adaptation rows the port introduces. + +### 4.5 Staging (velocity model first, measured) +- **Slice 1:** port `UpdatePositionInternal` + `calc_acceleration` + the + `cached_velocity = (resolved−old)/dt` recompute, replacing the integrate+reflect + path. A/B **against the crowd capture**: require the airborne-stuck count → 0 and OK% + to climb toward retail's ~78%. Gate (suites + a visual pass on ordinary + jump/walk/fall) before continuing. +- **Slice 2:** `handle_all_collisions` verbatim (once Slice 1 shows what residual the + velocity model leaves) + any remaining `UpdateObjectInternal` orchestration. +- **Slice 3+:** close the residual ground-jam gap if the velocity model alone doesn't + reach ~78% OK; re-measure each slice against the capture. + +## 5. Validation +- **Apparatus (built this session, reuse):** `ACDREAM_CAPTURE_RESOLVE=` JSONL of + every player resolve; the `py` histogram (OK / partial / stuck / airborne-stuck; see + §2). Retail target: **~78% OK, 12.7% COLLIDED, 8.8% SLID, 0 airborne-stuck**. Retail + cdb scripts: `tools/cdb/retail-crowd-jump{2,3}.cdb` (v3 = player-attributed; safe + auto-detach via `validate_transition` terminal + top-level `qd`). +- **Conformance tests:** velocity-from-movement (blocked → velocity → ~0); jump + + gravity integration; the `UpdateObjectInternal` sequence; a crowd replay. +- **Suites stay green:** Core 2603 / App 741 (no regression to walking/stairs/slopes/ + walls/streaming — the transition internals are untouched). +- **Visual gates:** (a) crowd glide/land like retail (the #182 symptom); (b) a + regression pass on normal locomotion — flat walking, slopes, stairs, jumping, falling, + wall-slide. + +## 6. Risk +Highest-risk option: it replaces the core of every jump/fall/step. Mitigation: the +scope boundary (transition internals untouched), the measured slicing (Slice 1 behind +an A/B compare), and heavy gating. If Slice 1 regresses ordinary locomotion, bisect +within the velocity model before proceeding. + +## 7. Open items for the new session (verify during writing-plans) +1. Read `UpdatePositionInternal`, `calc_acceleration` (0x00510950), and + `handle_all_collisions` (0x00514780) fully — confirm the integration + the role of + `handle_all_collisions` vs the cached_velocity model (does retail ALSO reflect, or + is velocity purely movement-derived?). +2. Confirm which `SetPositionInternal` overload the player path uses (3 exist). +3. Decide whether the general ground-jam (22% stuck vs retail 13%) is fully explained + by the velocity model or needs a second divergence (de-penetration / sliding-normal + provenance — the #137/TS-45 wedge family). Measure after Slice 1. +4. #182 stays as the base (user decision). NOTE: until this rebuild lands, the codebase + carries the airborne-stuck regression #182 introduced. + +## 8. Pointers +- Physics/collision SSOT: `claude-memory/project_physics_collision_digest.md` (updated + with the #182 + this-investigation banner). +- #182 issue: `docs/ISSUES.md`. CSphere pseudocode: `docs/research/2026-07-07-csphere-collision-family-pseudocode.md`. +- Retail debugger toolchain + the safe-detach recipe: `memory/project_retail_debugger.md` + CLAUDE.md. diff --git a/docs/superpowers/specs/2026-07-07-remote-creature-deoverlap-design.md b/docs/superpowers/specs/2026-07-07-remote-creature-deoverlap-design.md new file mode 100644 index 00000000..4aa60fa0 --- /dev/null +++ b/docs/superpowers/specs/2026-07-07-remote-creature-deoverlap-design.md @@ -0,0 +1,175 @@ +# Design: verbatim port of retail's per-remote physics tick so packed monsters de-overlap + +**Date:** 2026-07-07 · **Status:** DESIGN APPROVED (user: "I want retail behavior. So make it work.") +**Driving report (user, side-by-side vs retail on the SAME ACE):** monsters packed around the +player **overlap** in acdream (arms interpenetrating); in the retail client they barely overlap. +This is the crowd "no room to slide out" feel — the room is created by the monsters *not* +occupying the same space. + +--- + +## 1. Verified root cause (decomp + source, not guessed) + +Research workflow `wf_d2ff782f-9cb` (4 read-only agents) + direct source reads settle it. Retail +anchors are into `docs/research/named-retail/acclient_2013_pseudo_c.txt`. + +### Retail: ONE unified per-object tick that collides every creature locally +- **`CPhysics::UseTime`** (0x00509950, pc:271640) walks **every** `CPhysicsObj` in the object + table and calls `update_object → UpdateObjectInternal` on each — **no fork** between the player + and remote creatures. The player only gets an *extra* camera callback. +- **`UpdateObjectInternal`** (0x005156b0) runs the full `transition` (collision sweep) for any + active object with spheres whose origin moved. `CObjCell::find_obj_collisions` (0x0052b750, + pc:308916) iterates the cell's shadow list; creature-vs-creature collision is exempt **only** + for a *viewer* mover or an *IGNORE_CREATURES* mover. So **moving remote creatures de-overlap + against each other, client-side.** +- A remote creature stays "active" (transient bit 0x80) because the motion/animation system feeds + velocity every tick via `apply_interpreted_movement` (0x00528600) → `set_local_velocity` + (0x005114d0) → `set_velocity` (0x005113f0, which sets 0x80). + +### Retail: the server position is a GENTLE DR target, not a hard-snap +- **`SmartBox::HandleReceivedPosition`** (0x00453fd0) routes a remote through + **`CPhysicsObj::MoveOrTeleport`** (0x00516330): + - newer teleport-TS OR no cell → **hard snap** (`SetPosition`). + - has-velocity AND `player_distance < 96` → **`InterpolateTo`** (queue a DR node). + - has-velocity AND `player_distance ≥ 96` → **far snap** (`SetPositionSimple`). +- **`InterpolationManager::adjust_offset`** (0x00555d30) catches up toward the queued server + position at **≤ 2× the creature's max animation speed × dt**. The per-tick collision-resolved + position is **stored and persists** (`SetPositionInternal(transition)` writes + `sphere_path.curr_pos`, not the raw target); the *next* server update re-aims the catch-up + **from wherever collision left the creature**. A `node_fail_counter` blips to the server point + only after ~5 genuinely-stuck frames (`CREATURE_FAILED_INTERPOLATION_PERCENTAGE=0.3`, + `MIN_DISTANCE_TO_REACH_POSITION=0.2`). + +**Net retail behavior:** de-overlap is **proactive** (movement is collision-stopped *before* +creatures interpenetrate) and **persistent** (the resolved position is never overwritten by a +snap-into-overlap). ACE broadcasts each creature's own pathed (overlapping) position with no +server-side separation; **the client spreads them.** (ACE/holtburger source not checked out — +empty submodule dirs — but the decomp + the #182 live cdb trace establish client-responsibility.) + +### acdream: the two divergences (both verified in source) +1. **NPC (monster) `UpdatePosition` HARD-SNAPS to the raw server position.** `GameWindow.cs:5925-5926`: + `if (!snapSuppressedByStick) rmState.Body.Position = worldPos;` — only suppressed while a sticky + melee lease is armed. So a packed monster teleports into the overlapping server position every + UP, **overwriting** whatever de-penetration the per-tick sweep achieved. The sweep resolves + *movement*, not a static overlap it gets snapped into, so the overlap persists. +2. **A two-path fork retail doesn't have** (`GameWindow.cs:10076`): + - **Path A** — grounded **player** remotes (`IsPlayerGuid` && !Airborne, `:10076-10311`): advance + via the `RemoteMotionCombiner.ComputeOffset` interp catch-up, **`ResolveWithTransition` is + deliberately NOT called** (`:10274-10281` "collision is the sender's problem" — factually + wrong per the decomp). Player remotes never de-overlap. + - **Path B** — NPCs/monsters + airborne player remotes (`:10312-10698`): DO call + `ResolveWithTransition` (`:10558`) with `moverFlags: EdgeSlide` (not IsViewer/IgnoreCreatures), + so the `CollisionExemption` gate already lets a monster collide against other creatures. BUT + the NPC UP hard-snap (#1) overwrites its result, and the swept displacement is only + `preIntegrate→postIntegrate` (tiny between UPs), so it can't undo a snapped-in static overlap. + +**So the collision math is already faithful and present.** The bug is the **reconciliation** +(hard-snap) + the **fork** (player remotes skip the sweep). Retail's gentle catch-up + fork-free +tick is what makes the resolved position persist. + +--- + +## 2. Design — port retail's unified per-remote tick + MoveOrTeleport reconciliation + +Make every remote creature run the retail `UpdateObjectInternal` shape: **interp-catch-up delta + +anim velocity → `ResolveWithTransition` sweep → store the collision-resolved position**, with the +server `UpdatePosition` fed in as a **gentle DR target** (MoveOrTeleport), not a hard-snap. This +collapses Path A and Path B into one and lets the per-tick de-overlap persist. + +### 2.1 Retail functions being ported (chain) +| Function | Address | Role | acdream target | +|---|---|---|---| +| `CPhysics::UseTime` | 0x00509950 | walk ALL objects, tick each | the `_animatedEntities` per-tick loop `GameWindow.cs:10019` (collapse the fork) | +| `CPhysicsObj::MoveOrTeleport` | 0x00516330 | teleport-snap / near-interpolate(<96) / far-snap(≥96) | the remote `UpdatePosition` handler `GameWindow.cs:5879+` (extend the player-remote routing to NPCs) | +| `InterpolationManager::adjust_offset` | 0x00555d30 | speed-capped catch-up (≤2×max_speed·dt) + fail-counter blip | acdream `InterpolationManager` (`rm.Interp` — already present) | +| `UpdateObjectInternal` | 0x005156b0 | integrate → transition → commit resolved pos | the unified per-remote tick (reuse `ResolveWithTransition`) | + +### 2.2 In scope (rebuilt verbatim) +- **NPC `UpdatePosition` reconciliation:** replace the hard-snap (`GameWindow.cs:5925-5926` + + the orientation/velocity snaps `:5952-5967+`) with the retail `MoveOrTeleport` routing already + written for player remotes (`:5822-5848`): far (>96 m) → snap + clear queue; near → `Interp.Enqueue` + the server waypoint; teleport/parent → snap. Keep the sticky-suppression escape (it is retail's + "stuck → server correction can't fight the armed stick" behavior, TS-41/44). +- **Unify the tick:** every remote (Path A player *and* Path B NPC) advances by the interp + catch-up (`Interp.AdjustOffset`) **composed into a `MotionDeltaFrame`** (interp + sticky), then + runs `ResolveWithTransition` and **stores the resolved position** — the pattern Path B already + uses for the sticky delta at `:10521-10528`. Path A gains the sweep; Path B gains the interp + catch-up as its movement source (so the swept displacement IS the catch-up). +- **Setup-derived mover sphere:** replace the hard-coded human dims `0.48f/1.835f` + (`GameWindow.cs:10551-10556`) with the creature's own Setup sphere / `ObjScale` so differently + sized creatures de-overlap at their true radii (retail sizes the mover sphere from its own Setup + via `init_sphere`). +- The `node_fail_counter` blip watchdog (already in `InterpolationManager`) — keep; it is the + retail "genuinely blocked → snap to server after ~5 frames" escape. + +### 2.3 OUT of scope (kept — already faithful) +- The **transition internals** (`ResolveWithTransition` and below — BSPQuery, the CSphere/CylSphere + families incl. the #182 port, `CollisionExemption`, cell membership). Retail's remote tick calls + these primitives; so does ours. Untouched. +- The **shadow registry** (`ShadowObjects.Register`/`UpdatePosition`, `GameWindow.cs:4171/5665`) — + every remote creature is already registered + live-synced (retail's `AddShadowObject`/`change_cell` + equivalent). No new registration. +- The **R5 managers** (`MovementManager`/`MoveToManager`/`TargetManager` + the `Motion.PositionManager` + Sticky/Constraint facade). A verbatim `UpdateObjectInternal` ticks exactly these — the port ticks + them, doesn't rewrite them. +- The **#182 local-player rebuild** (this session) — orthogonal; stays as the base. + +### 2.4 Architecture (Code Structure Rule 1: no new feature bodies in GameWindow) +`GameWindow.cs` is already >10k lines and owns the remote tick. The unified per-remote update body +goes into a **new `RemotePhysicsUpdater`** (`src/AcDream.App/Physics/` or `Rendering/`) that takes +a `RemoteMotion` + dt + the `PhysicsEngine` and runs the retail `UpdateObjectInternal` chain +(interp delta → sweep → commit). `GameWindow`'s per-tick loop shrinks to: resolve the entity → +`RemotePhysicsUpdater.Tick(rm, dt)` → write `entity.SetPosition(rm.Body.Position)`. The +`UpdatePosition` `MoveOrTeleport` routing is extracted into a `RemotePhysicsUpdater.OnServerPosition` +(or a small `RemoteReconciler`) so the NPC and player-remote paths share ONE implementation. + +### 2.5 Staging (measured, de-overlap first) +- **Slice 1 — NPC reconciliation (the reported symptom):** replace the NPC hard-snap with the + `MoveOrTeleport` gentle catch-up (Enqueue), and drive Path B's body advancement from the interp + catch-up so its existing sweep resolves the catch-up movement against other creatures. Gate: + packed monsters visibly de-overlap side-by-side vs retail; no remote jitter/rubber-band regression. +- **Slice 2 — unify the fork:** collapse Path A into the same `RemotePhysicsUpdater.Tick` (player + remotes gain the sweep → packed *players* de-overlap too). Extract the shared updater + (§2.4). Gate: remote player crowd de-overlaps; observed-motion (walk/run/jump/land) unchanged. +- **Slice 3 — Setup-derived mover sphere** (§2.2). Gate: large/small creatures de-overlap at true + radii. + +--- + +## 3. Validation +- **Conformance tests (Core/App):** a `RemotePhysicsUpdaterTests` harness — two registered creature + shadows converging on a point, driven through the updater, assert they settle at + contact-distance (sum of radii), not overlapping; a `MoveOrTeleport` routing test (near→enqueue, + far→snap, teleport→snap); a reconciliation persistence test (a de-penetrated position survives + the next server UP instead of snapping into overlap). +- **Suites stay green:** Core 2617 / App 741 — no regression to remote animation (walk/run/jump/ + land/turn), dead-reckoning smoothness, sticky melee (#171), or the #182 player fix. +- **Visual gate (the acceptance test):** side-by-side vs the retail client on the same ACE — packed + monsters spread to retail spacing (arms no longer interpenetrating); remotes don't jitter, + rubber-band, or desync from the server; sticky-melee facing (#171) unbroken. +- **Apparatus:** `ACDREAM_REMOTE_VEL_DIAG` (existing) for the UP/seq pace; a `[remote-deoverlap]` + probe optional (rendered pos vs raw server UP + neighbor overlap depth) if a residual needs it. + +## 4. Risk +Touches the **R4/R5 remote dead-reckoning arc** (a shipped area): the NPC hard-snap and the +two-path fork. Mitigations: the collision + shadow-registry + R5-manager substrate is UNTOUCHED +(the change is the reconciliation + fork), the sticky-suppression escape is preserved (protects +#171), staged so the NPC de-overlap lands + gates first, and `node_fail_counter` keeps a genuinely +stuck remote from freezing. Perf: N creatures × a sweep per tick — Path B already does this for +NPCs; Slice 2 adds it for player remotes (bounded by the visible-crowd count). + +## 5. Register bookkeeping +- Retire the "remotes skip the transition / server already collision-resolved" adaptation (the + `GameWindow.cs:10089/10275` premise, filed under #40 / ISSUES.md ~:4899) — it's the exact + divergence whose "Risk if assumption breaks" is the arms-overlap. Same commit that lands Slice 2. +- Any adaptation the port introduces (e.g. the NPC MoveOrTeleport near-distance constant, the + sticky-suppression retention) gets its row in the same commit. + +## 6. Open items to verify during implementation +1. Confirm Path B's `ResolveWithTransition` sweep, once driven by the interp catch-up delta, + actually de-penetrates a converging neighbor (vs the tiny-displacement no-op) — the + `RemotePhysicsUpdaterTests` converging pair pins this before the visual gate. +2. Confirm the NPC `Interp.Enqueue` path composes with `TickRemoteMoveTo` / `ServerVelocity` / + the sticky delta without double-driving the body (the `RemoteMotionCombiner` REPLACE dichotomy). +3. Decide whether Slice 1 needs Path B to *also* route through `Interp` (likely) or whether feeding + `ServerVelocity` into the existing integrate+sweep suffices — measure with the converging-pair test. diff --git a/docs/superpowers/specs/2026-07-08-185-outdoor-stairs-fix-design.md b/docs/superpowers/specs/2026-07-08-185-outdoor-stairs-fix-design.md new file mode 100644 index 00000000..7cf733c4 --- /dev/null +++ b/docs/superpowers/specs/2026-07-08-185-outdoor-stairs-fix-design.md @@ -0,0 +1,160 @@ +# Design: #185 — local player jams half-way up outdoor stairs (fix) + +**Date:** 2026-07-08 · **Status:** DESIGN v2 (root cause re-confirmed via live apparatus) — impl not started +**Milestone:** M1.5 + +> **v2 note (2026-07-08):** v1 of this spec chased a collision-*response* cause ("grounding +> retention at a convex coplanar seam", Approach A). Live capture #3 (`[cp-write]` + +> `[entity-source]` + full `[bsp-test]` object map) **disproved** that and pinned the REAL root: +> a uint32 overflow in the shadow-registry part-id that silently drops some landblock objects' +> collision geometry. The wedge is a faithful *symptom*. v2 supersedes v1 entirely. + +--- + +## 1. Symptom + +Running the LOCAL player up the outside stairs of a house-on-stilts, you hit an invisible wall +"in the middle of the stairs" (user's words) — the steps look unbroken, you slide sideways and +cannot advance, and a jump clears it. Jam ≈ world (132, 77.9, 61.5), landblock `0xf682`, +cell `0xF682002C`. + +## 2. Root cause — CONFIRMED (live apparatus, code-verified) + +### 2.1 The bug: a uint32 overflow in the shadow-registry part-id + +`src/AcDream.App/Rendering/GameWindow.cs:7951`, in the per-landblock-entity collision +registration loop: + +```csharp +uint partId = entity.Id * 256u + partIndex; // OVERFLOWS uint32 +_physicsEngine.ShadowObjects.Register(partId, meshRef.GfxObjId, ...); +``` + +Landblock entity ids carry a **class prefix in the top byte** (`0x40`/`0x80`/`0xC0`; e.g. +`0x40F68221`, `0xC0F68221`). For any id ≥ `0x01000000`, `* 256` (== `<< 8`) **overflows uint32 +and drops the prefix byte**: `0x40F68221 * 256` and `0xC0F68221 * 256` both truncate to +`0xF6822100`. So **different-class entities that share the low 24 bits collide on the same shadow +part-id.** `ShadowObjectRegistry.Register` calls `Deregister(partId)` before inserting +(`ShadowObjectRegistry.cs:117`), so the second registrant **silently deletes the first's +collision geometry** (last-writer-wins). Rendering uses the full 32-bit `entity.Id` (no overflow), +so every step still *draws*. + +A sibling scheme in the Setup cyl/sphere path (`shapeId = entity.Id + K*0x10000000u`, `:8032/8068/8093`) +is a lesser variant of the same "synthetic per-part id" anti-pattern (can collide across entities), +but the #185 stairs are BSP-bearing so they hit the `*256` overflow specifically. + +### 2.2 Evidence (capture #3, `ACDREAM_PROBE_CONTACT_PLANE` + `ACDREAM_PROBE_BUILDING`) + +- **`[cp-write]`** attributes the contact-plane loss to `Transition.FindTransitionalPosition` (the + forward main-sweep) 530× — i.e. the mover loses grounding at the seam and drops into step-down → + the `PrecipiceSlide` wedge (the "invisible wall"). This is the SYMPTOM. +- **`[bsp-test]` object map** — the collision set has stair steps at world Y = 74.24→77.25 (lower + flight) and 79.25→80.25 (upper flight), with **NO objects at Y≈77.75/78.25/78.75**. The player + climbs the lower flight, floats past its top tread (Y=77.495) into the collision hole, finds no + ground, and wedges. The user confirms the steps there are **visually present** ("steps look + unbroken"). +- **`[entity-source]` part-id collision analysis** — landblock `0xF682` has **23 part-ids with a + collision** (>1 entity → same part-id), including the stair runs themselves: + `0xF6822100 ← {0x40F68221, 0xC0F68221}`, `0xF6821200 ← {0x40F68212, 0xC0F68212}`, + `0xF6822000`, `0xF6822200`, … Overflow check: `0x40F68221*256 & 0xFFFFFFFF == 0xF6822100 == + 0xC0F68221*256 & 0xFFFFFFFF`. + +### 2.3 Why the wedge is a faithful symptom (do NOT fix it) + +Once a step's collision is silently dropped, there is genuinely no ground there, so +`PrecipiceSlide` firing at the walkable edge is *correct* retail behavior for a real edge. The +`PrecipiceSlide` math, the `SetSlidingNormal` Z-zero, and the multi-object search are all +retail-faithful (decomp cross-check `wf_3c1120c4-a04`). Fixing the registration makes the geometry +present, the mover climbs normally, and the wedge never fires. **No change to the frozen collision +internals.** + +## 3. The fix — Option A: register multi-part landblock entities via `RegisterMultiPart` + +**Retail model (the anchor).** A multi-part physics object is one `CPhysicsObj` + `CPartArray`; +collision registration is `CPhysicsObj::add_shadows_to_cells` (0x00514ae0) → +`CPartArray::AddPartsShadow`, which walks the part array and writes each part's shadow into the +flooded cells, **all keyed to the single object** — no synthetic per-part id. +`ShadowObjectRegistry.RegisterMultiPart` is the direct port (its doc cites exactly this). + +**Change (one call site — the per-entity registration block, `GameWindow.cs` ~7876–8100).** +Replace the two synthetic-id `Register(...)` schemes with a single `RegisterMultiPart` per entity: + +1. Build a `List` for the entity, honoring retail's binary dispatch (BSP-xor-cyl, + `feedback_retail_binary_dispatch`): + - If any mesh-ref part has a physics BSP → add one **BSP** `ShadowShape` per BSP part + (`GfxObjId = meshRef.GfxObjId`, `LocalPosition/LocalRotation/Scale` decomposed from + `meshRef.PartTransform`, `Radius = part BoundingSphere.Radius × scale`). + - Else if the Setup has CylSpheres/Spheres/Radius → add **Cylinder** `ShadowShape`s + (same local-offset/scale math as today, but as `LocalPosition` relative to the entity — the + registry rotates by `entityWorldRot` internally). +2. `if (shapes.Count > 0 && !entity.IsBuildingShell) ShadowObjects.RegisterMultiPart(entity.Id, + entity.Position, entity.Rotation, shapes, state:0, flags:None, origin.X, origin.Y, + lb.LandblockId, seedCellId: entity.ParentCellId ?? 0)`. +3. Keep the `IsBuildingShell` skip (building shells collide via the building channel — retail). + +This uses each entity's **unique 32-bit `entity.Id`** as the sole key — no `*256`, no +`+K*0x10000000`, no overflow, no collision — and **unifies the codebase on the one faithful +multi-part registration path** (the door + every server entity already use it). It removes the +redundant per-part loop. + +**Despawn.** Landblock unload must `Deregister(entity.Id)` (not the old synthetic part-ids). Verify +the unload path deregisters by `entity.Id`; adjust if it currently targets `partId`. + +**Explicitly NOT changed:** `PrecipiceSlide`, `SetSlidingNormal`, the collision response, the +step-down chain — all verified faithful; the symptom disappears once geometry is present. + +## 4. Alternatives considered + +- **B — widen the shadow-registry key to `ulong`** (`partId = ((ulong)entity.Id<<8)|partIndex`). + Keeps the non-retail "each part is its own shadow object with a synthetic id" model, merely + de-overflowed; fragments one retail object into N pseudo-objects; leaves two parallel + registration paths. Rejected — less architectural, less faithful. +- **v1 Approach A (grounding retention)** — disproved (§ v2 note): the continuation isn't in the + collision set to retain grounding on. + +## 5. Test strategy + +- **Red→green unit pin (Core):** `ShadowObjectRegistryOverflowTests` — register two entities whose + ids collide under the OLD `*256` scheme (e.g. `0x40F68221`, `0xC0F68221`) as multi-part; assert + BOTH remain queryable in their cells (OLD scheme: one overwrites the other; NEW: both present). + Drive via `RegisterMultiPart` + `GetObjectsInCell`. +- **App-layer pin:** a focused test over the registration helper (extracted if needed) that feeds + two colliding-id multi-part entities and asserts two distinct registrations survive. If the + registration logic is buried in `GameWindow`, extract the shape-list build + register into a + small testable method (`LandblockEntityCollisionRegistrar`) per Code-Structure-Rule 1. +- **Keep the dat-free clean-climb replay** (`Issue185OutdoorStairsSeamReplayTests`, already written + + passing) as a regression pin (continuous stairs must climb). +- **Regression:** `ShadowObjectRegistryTests`, `ShadowObjectRegistryMultiPartTests`, + `DoorBugTrajectoryReplayTests`, `Issue137*`, `CellarUp*`, `SphereCollisionFamilyTests` green; + full `dotnet build` + `dotnet test`. +- **Live gate (acceptance, user):** walk up the FULL staircase — no jam, no jump; plus a spot check + that torches/trees/other statics still collide (the registration path is shared). + +## 6. Apparatus / fixtures (captured this session) + +- `185-recapture3.jsonl` + task `.output` (`[cp-write]`, `[entity-source]`, `[bsp-test]` object map). +- Overflow analysis (23 collisions) reproducible from the `[entity-source]` log. +- gfxobj dumps `Fixtures/issue185/0x01000AC5.gfxobj.json` (+ `0x01000ACA`) for the replay. + +## 7. Bookkeeping (in the fix commit) + +- Register: this is a bug fix (not a new deviation); if a row implied the old per-part id scheme, + none does — no register row needed, but note the fix in the ISSUES close. +- `docs/ISSUES.md`: move #185 to Recently closed with the SHA. +- `claude-memory/project_physics_collision_digest.md`: banner — #185 was a REGISTRATION overflow + (part-id `*256` uint collision), NOT a collision-response bug; the wedge was a faithful symptom. + DO-NOT-RETRY: don't chase the wedge/precipice; the fix is the registration id. + +## 8. Acceptance + +- Local player walks up the full outdoor staircase, no jam/jump. +- No collision-id collisions in a landblock (the 23-collision analysis returns 0 after the fix). +- Other landblock statics (torches/trees/buildings) still collide; suites + build/test green. + +## 9. DO-NOT-RETRY + +- Do NOT touch `PrecipiceSlide` / `SetSlidingNormal` / step-down — the wedge is a faithful symptom + of missing geometry, not the cause. +- Do NOT "widen the key" (Option B) — it preserves the non-retail synthetic-per-part-id model. +- Do NOT reintroduce a synthetic per-part id (`*256` or `+K*0x10000000`) — the retail model is one + object id + a part array (`RegisterMultiPart`). diff --git a/src/AcDream.App/AcDream.App.csproj b/src/AcDream.App/AcDream.App.csproj index 64eac77a..c07ae6c3 100644 --- a/src/AcDream.App/AcDream.App.csproj +++ b/src/AcDream.App/AcDream.App.csproj @@ -38,6 +38,7 @@ + diff --git a/src/AcDream.App/Diagnostics/FrameProfiler.cs b/src/AcDream.App/Diagnostics/FrameProfiler.cs new file mode 100644 index 00000000..2ac85dcd --- /dev/null +++ b/src/AcDream.App/Diagnostics/FrameProfiler.cs @@ -0,0 +1,213 @@ +using System; +using System.Diagnostics; +using System.Globalization; +using System.Text; +using AcDream.Core.Rendering; +using Silk.NET.OpenGL; + +namespace AcDream.App.Diagnostics; + +/// Stage indices for per-frame CPU attribution. +public enum FrameStage +{ + /// Whole OnUpdate body (simulation + streaming apply). + Update = 0, + /// WbMeshAdapter.Tick — staged mesh/texture GPU upload drain. + Upload = 1, + /// ImGui Render (dev overlay). + ImGui = 2, +} + +/// +/// MP0 (2026-07-05) — the permanent honest frame profiler. One +/// FrameBoundary call at the top of GameWindow.OnRender +/// measures CPU frame time as the delta between consecutive boundaries +/// (captures the FULL frame including present), brackets the frame in a +/// GPU TimeElapsed query (via ), and +/// samples per-frame allocated bytes + GC collection counts. Stage scopes +/// () attribute CPU time to Update / Upload / +/// ImGui. Emits one [frame-prof] line every ~5 s while +/// is true; costs one +/// bool check per frame when off. +/// +/// Permanent apparatus — every MP-track gate reads it; do not strip. +/// Whole-frame GPU timing self-disables under ACDREAM_WB_DIAG=1 +/// (nested TimeElapsed is illegal GL; see GpuFrameTimer). +/// Spec: docs/superpowers/specs/2026-07-05-modern-pipeline-design.md §5. +/// +public sealed class FrameProfiler : IDisposable +{ + private const int WindowCapacity = 2048; // ~12 s at 165 fps + private const long ReportIntervalTicks = 5 * TimeSpan.TicksPerSecond; + private static readonly int StageCount = Enum.GetValues().Length; + + private readonly FrameStatsBuffer _cpuUs = new(WindowCapacity); + private readonly FrameStatsBuffer _gpuUs = new(WindowCapacity); + private readonly FrameStatsBuffer _allocBytes = new(WindowCapacity); + private readonly FrameStatsBuffer[] _stageUs; + private readonly long[] _stageAccumTicks; + private readonly bool _wbDiagActive = + Environment.GetEnvironmentVariable("ACDREAM_WB_DIAG") == "1"; + + private GpuFrameTimer? _gpuTimer; + private long _lastBoundaryTimestamp; + private long _lastAllocBytes; + private long _lastReportTicks; + private int _gc0Base, _gc1Base, _gc2Base; + private int _framesInWindow; + private int _ownerThreadId; + private bool _threadWarned; + private bool _wbDiagNoticePrinted; + private bool _wasEnabled; + + public FrameProfiler() + { + _stageUs = new FrameStatsBuffer[StageCount]; + for (int i = 0; i < StageCount; i++) _stageUs[i] = new FrameStatsBuffer(WindowCapacity); + _stageAccumTicks = new long[StageCount]; + } + + /// + /// Call as the FIRST statement of GameWindow.OnRender. + /// + public void FrameBoundary(GL gl) + { + bool enabled = RenderingDiagnostics.FrameProfEnabled; + if (!enabled) + { + if (_wasEnabled) + { + // Dispose (not just Stop) so a later re-enable rebuilds the + // query ring fresh — a kept instance would poll slots left + // pending from BEFORE the pause and report temporally stale + // GPU samples. Safe here: this runs at the top of OnRender + // with the GL context current. + _gpuTimer?.Dispose(); + _gpuTimer = null; + _wasEnabled = false; + _lastBoundaryTimestamp = 0; + } + return; + } + + if (_ownerThreadId == 0) _ownerThreadId = Environment.CurrentManagedThreadId; + else if (!_threadWarned && _ownerThreadId != Environment.CurrentManagedThreadId) + { + _threadWarned = true; + Console.WriteLine("[frame-prof] WARNING: frame boundary crossed threads; alloc counter is per-thread and now unreliable"); + } + + long now = Stopwatch.GetTimestamp(); + long allocNow = GC.GetAllocatedBytesForCurrentThread(); + + if (!_wasEnabled) + { + // First enabled frame (startup or runtime toggle-on): establish + // baselines, emit nothing. Clear any stage ticks a StageScope + // disposed after toggle-off may have accumulated mid-pause — + // EndStage still runs on scopes that were live when the flag + // flipped, and that partial delta must not leak into the first + // re-enabled frame. + _wasEnabled = true; + _lastReportTicks = DateTime.UtcNow.Ticks; + Array.Clear(_stageAccumTicks); + _gc0Base = GC.CollectionCount(0); _gc1Base = GC.CollectionCount(1); _gc2Base = GC.CollectionCount(2); + if (_gpuTimer is null && !_wbDiagActive) _gpuTimer = new GpuFrameTimer(gl); + if (_wbDiagActive && !_wbDiagNoticePrinted) + { + _wbDiagNoticePrinted = true; + Console.WriteLine("[frame-prof] GPU frame timing OFF: ACDREAM_WB_DIAG=1 owns TimeElapsed queries (nested queries are illegal GL)"); + } + } + else + { + long cpuUs = (now - _lastBoundaryTimestamp) * 1_000_000L / Stopwatch.Frequency; + _cpuUs.Push(cpuUs); + _allocBytes.Push(allocNow - _lastAllocBytes); + for (int i = 0; i < StageCount; i++) + { + _stageUs[i].Push(_stageAccumTicks[i] * 1_000_000L / Stopwatch.Frequency); + _stageAccumTicks[i] = 0; + } + _framesInWindow++; + } + + _lastBoundaryTimestamp = now; + _lastAllocBytes = allocNow; + + if (_gpuTimer?.FrameBoundary() is long gpuUs) + _gpuUs.Push(gpuUs); + + long nowTicks = DateTime.UtcNow.Ticks; + if (nowTicks - _lastReportTicks >= ReportIntervalTicks && _framesInWindow > 0) + { + int gc0 = GC.CollectionCount(0) - _gc0Base; + int gc1 = GC.CollectionCount(1) - _gc1Base; + int gc2 = GC.CollectionCount(2) - _gc2Base; + Console.WriteLine(FormatReport(_framesInWindow, _cpuUs, _gpuUs, + gpuActive: _gpuTimer is not null, _allocBytes, gc0, gc1, gc2, _stageUs)); + _lastReportTicks = nowTicks; + _gc0Base += gc0; _gc1Base += gc1; _gc2Base += gc2; + _framesInWindow = 0; + _cpuUs.Reset(); _gpuUs.Reset(); _allocBytes.Reset(); + for (int i = 0; i < StageCount; i++) _stageUs[i].Reset(); + } + } + + /// + /// Attribute the enclosed CPU time to . + /// Usage: using var _ = profiler.BeginStage(FrameStage.Update);. + /// Zero-cost (default scope) when the profiler is off. + /// + public StageScope BeginStage(FrameStage stage) + => RenderingDiagnostics.FrameProfEnabled + ? new StageScope(this, stage, Stopwatch.GetTimestamp()) + : default; + + internal void EndStage(FrameStage stage, long startTimestamp) + => _stageAccumTicks[(int)stage] += Stopwatch.GetTimestamp() - startTimestamp; + + /// Pure report formatter — unit-tested; invariant culture. + public static string FormatReport( + int frameCount, + FrameStatsBuffer cpu, FrameStatsBuffer gpu, bool gpuActive, + FrameStatsBuffer alloc, int gc0, int gc1, int gc2, + FrameStatsBuffer[] stages) + { + var ci = CultureInfo.InvariantCulture; + var sb = new StringBuilder(256); + sb.Append("[frame-prof] n=").Append(frameCount); + sb.AppendFormat(ci, " | cpu_ms p50={0:0.0} p95={1:0.0} p99={2:0.0} max={3:0.0}", + cpu.Percentile(0.50) / 1000.0, cpu.Percentile(0.95) / 1000.0, + cpu.Percentile(0.99) / 1000.0, cpu.Max() / 1000.0); + if (gpuActive) + sb.AppendFormat(ci, " | gpu_ms p50={0:0.0} p95={1:0.0}", + gpu.Percentile(0.50) / 1000.0, gpu.Percentile(0.95) / 1000.0); + else + sb.Append(" | gpu=off(wbdiag)"); + sb.AppendFormat(ci, " | alloc_kb p50={0:0.0} max={1:0.0} gc={2}/{3}/{4}", + alloc.Percentile(0.50) / 1024.0, alloc.Max() / 1024.0, gc0, gc1, gc2); + string[] names = { "upd", "upl", "imgui" }; + for (int i = 0; i < stages.Length && i < names.Length; i++) + sb.AppendFormat(ci, " | {0} p50={1:0.0} p95={2:0.0}", + names[i], stages[i].Percentile(0.50) / 1000.0, stages[i].Percentile(0.95) / 1000.0); + return sb.ToString(); + } + + public void Dispose() => _gpuTimer?.Dispose(); +} + +/// Disposable stage scope; default instance is a no-op. +public readonly struct StageScope : IDisposable +{ + private readonly FrameProfiler? _owner; + private readonly FrameStage _stage; + private readonly long _start; + + internal StageScope(FrameProfiler owner, FrameStage stage, long start) + { + _owner = owner; _stage = stage; _start = start; + } + + public void Dispose() => _owner?.EndStage(_stage, _start); +} diff --git a/src/AcDream.App/Diagnostics/FrameStatsBuffer.cs b/src/AcDream.App/Diagnostics/FrameStatsBuffer.cs new file mode 100644 index 00000000..60773235 --- /dev/null +++ b/src/AcDream.App/Diagnostics/FrameStatsBuffer.cs @@ -0,0 +1,69 @@ +using System; + +namespace AcDream.App.Diagnostics; + +/// +/// MP0 (2026-07-05) — fixed-capacity ring buffer of long samples +/// (microseconds or bytes) with percentile/max over the current window. +/// Pure and allocation-free after construction: +/// sorts into a preallocated scratch array, so the 5-second report path +/// allocates nothing. Not thread-safe — owned by the window loop thread. +/// Spec: docs/superpowers/specs/2026-07-05-modern-pipeline-design.md §5. +/// +public sealed class FrameStatsBuffer +{ + private readonly long[] _samples; + private readonly long[] _scratch; + private int _cursor; + private int _count; + + public FrameStatsBuffer(int capacity) + { + if (capacity <= 0) throw new ArgumentOutOfRangeException(nameof(capacity)); + _samples = new long[capacity]; + _scratch = new long[capacity]; + } + + public int Count => _count; + + public void Push(long value) + { + _samples[_cursor] = value; + _cursor = (_cursor + 1) % _samples.Length; + if (_count < _samples.Length) _count++; + } + + public void Reset() + { + _cursor = 0; + _count = 0; + } + + /// + /// Nearest-rank percentile over the current window: element at + /// ceil(q·n) in the ascending sort (1-based), 0 when empty. + /// + public long Percentile(double q) + { + if (_count == 0) return 0; + Array.Copy(_samples, _scratch, _count); + Array.Sort(_scratch, 0, _count); + int rank = (int)Math.Ceiling(q * _count); // 1-based nearest rank + if (rank < 1) rank = 1; + if (rank > _count) rank = _count; + return _scratch[rank - 1]; + } + + public long Max() + { + if (_count == 0) return 0; // documented empty behavior, matches Percentile + // Seed from the first live sample so all-negative windows (the alloc + // channel can go negative if the boundary ever crosses threads) return + // the true max instead of clamping to 0. Slots [0.._count) are always + // the live window regardless of ring wraparound. + long max = _samples[0]; + for (int i = 1; i < _count; i++) + if (_samples[i] > max) max = _samples[i]; + return max; + } +} diff --git a/src/AcDream.App/Diagnostics/GpuFrameTimer.cs b/src/AcDream.App/Diagnostics/GpuFrameTimer.cs new file mode 100644 index 00000000..d75621e9 --- /dev/null +++ b/src/AcDream.App/Diagnostics/GpuFrameTimer.cs @@ -0,0 +1,87 @@ +using System; +using Silk.NET.OpenGL; + +namespace AcDream.App.Diagnostics; + +/// +/// MP0 (2026-07-05) — whole-frame GPU time via a ring of +/// queries (depth 4, so results are +/// read ~3 frames late and never stall). Mirrors WbDrawDispatcher's query +/// idiom including the #125 lesson: a glGenQueries name is not a query +/// OBJECT until first glBeginQuery, so never-begun slots are skipped via +/// the Begun flags. +/// +/// MUST NOT be active while ACDREAM_WB_DIAG=1: GL forbids two +/// simultaneously active TimeElapsed queries and WbDrawDispatcher brackets +/// its passes with them under that flag. The caller (FrameProfiler) +/// enforces the exclusion; this class just does the ring. +/// +internal sealed class GpuFrameTimer : IDisposable +{ + private const int RingDepth = 4; + + private readonly GL _gl; + private readonly uint[] _queries = new uint[RingDepth]; + private readonly bool[] _begun = new bool[RingDepth]; + private int _frameIndex; + private bool _queryActive; + + public GpuFrameTimer(GL gl) + { + _gl = gl ?? throw new ArgumentNullException(nameof(gl)); + for (int i = 0; i < RingDepth; i++) + _queries[i] = _gl.GenQuery(); + } + + /// + /// Call once per frame at the frame boundary. Ends the previous + /// frame's query, polls the oldest slot non-blocking, begins this + /// frame's query. Returns the completed GPU time in microseconds for + /// a ~RingDepth-frames-old frame, or null when no result is ready. + /// + public long? FrameBoundary() + { + if (_queryActive) + { + _gl.EndQuery(QueryTarget.TimeElapsed); + _queryActive = false; + } + + long? completedUs = null; + int readSlot = _frameIndex % RingDepth; // about to be reused — oldest + if (_begun[readSlot]) + { + _gl.GetQueryObject(_queries[readSlot], QueryObjectParameterName.ResultAvailable, out int avail); + if (avail != 0) + { + _gl.GetQueryObject(_queries[readSlot], QueryObjectParameterName.Result, out ulong ns); + completedUs = (long)(ns / 1000UL); + } + // Not available ⇒ sample silently dropped (same policy as + // WbDrawDispatcher) — percentiles tolerate missing samples. + } + + _gl.BeginQuery(QueryTarget.TimeElapsed, _queries[readSlot]); + _begun[readSlot] = true; + _queryActive = true; + _frameIndex++; + return completedUs; + } + + /// End any active query without beginning a new one (used when the profiler is toggled off mid-session). + public void Stop() + { + if (_queryActive) + { + _gl.EndQuery(QueryTarget.TimeElapsed); + _queryActive = false; + } + } + + public void Dispose() + { + Stop(); + for (int i = 0; i < RingDepth; i++) + _gl.DeleteQuery(_queries[i]); + } +} diff --git a/src/AcDream.App/Input/PlayerMovementController.cs b/src/AcDream.App/Input/PlayerMovementController.cs index b6923fb9..60c23d23 100644 --- a/src/AcDream.App/Input/PlayerMovementController.cs +++ b/src/AcDream.App/Input/PlayerMovementController.cs @@ -52,14 +52,12 @@ public readonly record struct MovementResult( float? SidestepSpeed, float? TurnSpeed, bool IsRunning = false, - uint? LocalAnimationCommand = null, // which cycle to play on the local player (RunForward when running) // K-fix5 (2026-04-26): cycle-pace multiplier for the LOCAL animation // sequencer. Decoupled from ForwardSpeed so the wire can keep sending // 1.0 for WalkBackward (ACE-compatible) while the animation plays at // runRate × so the cycle visually matches the run-speed velocity. // Forward+Run = runRate (same as ForwardSpeed); Backward+Run, Strafe+Run // = runRate (where ForwardSpeed is 1.0 / null); everything else = 1.0. - float LocalAnimationSpeed = 1f, bool JustLanded = false, // true on the single frame we transitioned airborne → grounded float? JumpExtent = null, // non-null when a jump was triggered this frame Vector3? JumpVelocity = null); // BODY-LOCAL launch velocity (forward/right/up relative to facing) — see PlayerMovementController jump path for the inverse-yaw conversion. Server rotates body→world on broadcast. @@ -182,13 +180,24 @@ public sealed class PlayerMovementController // to drive the landing animation cycle. private bool _wasAirborneLastFrame; - // Previous frame's motion commands for change detection. + // Previous frame's motion commands for change detection (wire cadence). private uint? _prevForwardCmd; private uint? _prevSidestepCmd; private uint? _prevTurnCmd; private float? _prevForwardSpeed; private bool _prevRunHold; - private uint? _prevLocalAnimCmd; + + // R3-W6: previous frame's HELD-KEY state — the edge detector feeding + // retail's DoMotion/StopMotion/set_hold_run calls (retail's + // CommandInterpreter altitude: motion dispatch happens on key EDGES, + // never level-triggered per-frame). + private bool _prevForwardHeld; + private bool _prevBackwardHeld; + private bool _prevStrafeLeftHeld; + private bool _prevStrafeRightHeld; + private bool _prevTurnLeftHeld; + private bool _prevTurnRightHeld; + private bool _prevRunHeld; // Heartbeat timer. // Cadence is 1.0 sec to match holtburger's @@ -251,83 +260,69 @@ public sealed class PlayerMovementController private Vector3 _prevPhysicsPos; private Vector3 _currPhysicsPos; - // ── B.6 slice 2 (2026-05-14): local-player server-initiated auto-walk ── - // When ACE sends a MoveToObject motion for the local player (out-of-range - // Use / PickUp triggers ACE's server-side CreateMoveToChain), the wire - // payload includes a destination, arrival predicates, and a run rate. - // Retail's MovementManager::PerformMovement (0x00524440 case 6) runs a - // LOCAL auto-walk in response: heading correction toward the target, - // run-forward velocity at the wire's runRate, arrival detection via - // MoveToManager::HandleMoveToPosition. Here we keep the active auto-walk - // state and inject it into Update() as a synthesized Forward+Run input - // so the existing motion-interpreter / body-velocity pipeline runs - // unchanged. Spec: docs/superpowers/specs/2026-05-14-phase-b6-design.md. - private bool _autoWalkActive; - private Vector3 _autoWalkDestination; - private float _autoWalkMinDistance; - private float _autoWalkDistanceToObject; - private bool _autoWalkMoveTowards; - // 2026-05-16 (retail-faithful) — walk-vs-run is a ONE-SHOT - // decision at chain start. Per user observation 2026-05-16: if - // initial distance is at or above the walk-run threshold, the - // body runs all the way to the target; otherwise it walks all - // the way. No per-frame switching as the player closes distance. - // - // Formula matches retail's MovementParameters::get_command - // (decomp 0x0052aa00, line 308000+): - // running = (initialDist - distance_to_object) >= walk_run_threshhold - // The "distance left to walk" (current minus use-radius) is - // compared against the wire-supplied threshold (15m default, - // retail constant at 0x005243b5). The retail function reads - // `arg2` as the current distance but in practice is called at - // chain setup with the initial distance, and the resulting - // decision is cached for the rest of the chain — matching the - // user-observed "run all the way / walk all the way" behaviour. - private bool _autoWalkInitiallyRunning; + // ── R4-V5: the verbatim retail MoveToManager replaces B.6 auto-walk ── + // The B.6 DriveServerAutoWalk overlay (synthesized turn-first phase, + // 30° walk-while-turning band, one-shot walk/run decision, invented + // arrival epsilon — registers AD-26/AD-8-local) is DELETED; server + // MoveTos for the local player now run through the SAME verbatim + // MoveToManager remotes use (R4-V4), bound below by GameWindow's + // EnterPlayerModeNow beside the R3-W6 DefaultSink bind. /// - /// True while a server-initiated auto-walk (MoveToObject inbound) is - /// active on the local player. Update drives the body's velocity - /// and motion state machine DIRECTLY from the wire-supplied path - /// data, NOT via synthesized player-input. The - /// motion-state-change detection downstream sees no user input - /// during auto-walk, so no MoveToState wire packet is built — ACE's - /// server-side MoveToChain can run uninterrupted until its callback - /// fires. + /// R5-V5: retail CPhysicsObj::movement_manager (acclient.h + /// /* 3463 */) — the ONE owner of this controller's + /// + pair. Constructed in the + /// ctor around the interp; the MoveToManager side arrives via + /// MoveToFactory + MakeMoveToManager() in + /// GameWindow.EnterPlayerModeNow (the same facade shape + /// EnsureRemoteMotionBindings gives remotes). + /// ticks UseTime() (0x005242f0) at the slot the deleted + /// DriveServerAutoWalk occupied and relays HitGround() + /// (0x00524300, minterp first then moveto). /// - public bool IsServerAutoWalking => _autoWalkActive; - - // 2026-05-16 (issue #75) — tracks whether the auto-walk overlay is - // actually advancing the body this frame. False during the - // turn-first phase (rotating in place toward target) and after - // arrival. Drives the animation cycle override: walking animation - // only plays when the body is actually moving forward. - private bool _autoWalkMovingForwardThisFrame; - - // 2026-05-16 (issue #69 fix) — turn direction this frame. - // +1 = rotating counter-clockwise (Yaw increasing) → TurnLeft cycle - // -1 = rotating clockwise (Yaw decreasing) → TurnRight cycle - // 0 = aligned or not turning - // Drives the animation cycle override during turn-first phase so - // the body plays the actual turn animation instead of statue-pivoting. - private int _autoWalkTurnDirectionThisFrame; + public AcDream.Core.Physics.Motion.MovementManager Movement { get; } /// - /// Fires once when an auto-walk reaches its destination naturally - /// (i.e. called with - /// reason="arrived"). Does NOT fire on user-input cancel or - /// on a re-target (BeginServerAutoWalk overwriting state). - /// - /// - /// Host () subscribes to re-send - /// the Use/PickUp action that triggered the auto-walk — without - /// this, ACE's server-side MoveToChain may have already timed out - /// by the time our local body arrives, so the action wouldn't - /// fire. Re-sending the action close-range hits ACE's WithinUseRadius - /// fast-path and completes immediately. - /// + /// R4-V5: the local player's verbatim retail MoveToManager + /// (decomp 0x00529010-0x0052a987), constructed + seam-bound by + /// GameWindow.EnterPlayerModeNow against this controller's + /// /body/Yaw (the same wiring shape + /// EnsureRemoteMotionBindings uses for remotes). GameWindow + /// routes inbound mt 6-9 movement events through + /// . + /// User input cancels a moveto through the retail chain: key edge → + /// DoMotion (ctor-default params, CancelMoveTo bit set) → + /// → + /// CancelMoveTo(ActionCancelled) (register TS-36 retired). + /// R5-V5: a view of 's moveto child; the setter is + /// sugar over the facade's factory path (kept for the + /// PlayerMoveToCutoverTests rig and any pre-facade bind shape). /// - public event Action? AutoWalkArrived; + public AcDream.Core.Physics.Motion.MoveToManager? MoveTo + { + get => Movement.MoveTo; + set + { + var mtm = value ?? throw new ArgumentNullException(nameof(value)); + Movement.MoveToFactory = () => mtm; + Movement.MakeMoveToManager(); + } + } + + /// + /// R5-V3 (#171): the player's PositionManager facade (retail + /// CPhysicsObj::position_manager — owned by the player's + /// EntityPhysicsHost, handed here by EnterPlayerModeNow). + /// drives it at the two retail per-tick points: + /// AdjustOffset inside the physics-tick block (retail + /// UpdatePositionInternal @0x00512d0e, BEFORE + /// UpdatePhysicsInternal so the sticky steer is part of the swept + /// motion) and UseTime after the completed-motions sweep (retail + /// UpdateObjectInternal tail @0x005159b3 — the sticky 1 s lease + /// watchdog). tears any + /// stick down (retail teleport_hook @0x00514eee). + /// + public AcDream.Core.Physics.Motion.PositionManager? PositionManager { get; set; } public PlayerMovementController(PhysicsEngine physics) { @@ -339,8 +334,10 @@ public sealed class PlayerMovementController }; // Default skills — tuned toward mid-retail feel. Real characters' - // skills come from PlayerDescription (0xF7B0/0x0013) which we don't - // parse yet; override via env vars: + // skills come from PlayerDescription (0xF7B0/0x0013) — GameWindow + // pushes them via SetCharacterSkills once the controller exists + // (K-fix7; PD arrives at login before auto-entry). These env-var + // defaults only cover tests / pre-PD frames: // ACDREAM_RUN_SKILL, ACDREAM_JUMP_SKILL // K-fix6 (2026-04-26): bumped default jump skill from 200 → 300. // Retail formula: height = (skill/(skill+1300))*22.2 + 0.05 (extent=1): @@ -353,6 +350,15 @@ public sealed class PlayerMovementController int jumpSkill = int.TryParse(Environment.GetEnvironmentVariable("ACDREAM_JUMP_SKILL"), out var jsv) ? jsv : 300; _weenie = new PlayerWeenie(runSkill: runSkill, jumpSkill: jumpSkill); _motion = new MotionInterpreter(_body, _weenie); + // R5-V5: the MovementManager facade owns the interp from birth + // (retail CPhysicsObj::movement_manager); the moveto child binds + // later via MoveToFactory (EnterPlayerModeNow / the test rigs). + Movement = new AcDream.Core.Physics.Motion.MovementManager(_motion); + // R3-W4 (A3): the local player's movement is input-driven — + // movement_is_autonomous true so apply_current_movement's dual + // dispatch routes apply_raw_movement (IsThePlayer && autonomous). + // R3-W6 refines this per-motion (server-controlled MoveTo clears it). + _body.LastMoveWasAutonomous = true; } public void SetCharacterSkills(int runSkill, int jumpSkill) @@ -360,6 +366,39 @@ public sealed class PlayerMovementController _weenie.SetSkills(runSkill, jumpSkill); } + /// + /// R3-W2 (r3-port-plan.md §4): the player's + /// — GameWindow binds the player sequencer's MotionDone seam to it so the + /// pending_motions queue pops in step with animation completion, same + /// path remotes use. R3-W6 widens this into the full local-player + /// unification. + /// + internal MotionInterpreter Motion => _motion; + + /// R4-V5: CONTACT transient-state bit (retail + /// transient_state & 1) — the manager's + /// UseTime tick gate reads exactly this bit (decomp §6a @307781; a + /// strict subset of the funnel's Contact+OnWalkable gate). + internal bool BodyInContact => _body.InContact; + + /// R4-V5: body orientation for the + /// manager's position seam (re-derived from every + /// Update — heading reads/writes go through Yaw, not this). + internal Quaternion BodyOrientation => _body.Orientation; + + /// R4-V5 wedge fix — the P1 unpack store + /// (CPhysics::SetObjectMovement @00509730: + /// last_move_was_autonomous = arg7, written on the unpack path + /// for every applied movement event). GameWindow's local-player 0xF74C + /// branch stores the wire autonomous byte here (always false — the P1 + /// gate drops autonomous echoes); the speculative use install stores + /// false too (it models the wire mt-6 ACE sends moments later). Routes + /// the per-tick pump's A3 dual dispatch to the INTERPRETED branch + /// during a server moveto so apply_raw can't clobber the manager's + /// dispatched motions with the idle raw state. + internal void SetLastMoveWasAutonomous(bool autonomous) + => _body.LastMoveWasAutonomous = autonomous; + /// /// Wire the player's AnimationSequencer current cycle velocity into /// . When attached, @@ -387,97 +426,6 @@ public sealed class PlayerMovementController _motion.GetCycleVelocity = accessor; } - /// - /// Apply a server-echoed run rate (ForwardSpeed from UpdateMotion) to the - /// player's MotionInterpreter. The server broadcasts the real RunRate - /// derived from the character's Run skill; wiring it here ensures - /// get_state_velocity produces the correct speed instead of the default 1.0. - /// - public void ApplyServerRunRate(float forwardSpeed) - { - _motion.InterpretedState.ForwardSpeed = forwardSpeed; - _motion.apply_current_movement(cancelMoveTo: false, allowJump: false); - } - - /// - /// B.6 slice 2 (2026-05-14). Install a server-initiated auto-walk - /// against this body. will synthesize - /// Forward+Run input and steer toward - /// until the body reaches the - /// arrival predicate (moveTowards: dist ≤ distanceToObject; - /// !moveTowards: dist ≥ minDistance) or the user presses any - /// movement key (which auto-cancels). - /// - /// - /// Retail reference: MovementManager::PerformMovement - /// (0x00524440) case 6 — unpacks the wire's target + - /// origin + run rate and calls CPhysicsObj::MoveToObject on - /// the local body. We do the equivalent at acdream's altitude: - /// hold the destination + thresholds + run rate locally, let the - /// existing per-tick motion machinery do the walking, and arrive - /// when the horizontal distance hits the threshold. - /// - /// - /// - /// The run-rate parameter is the EFFECTIVE rate after the - /// mtRun=0 fallback chain — the caller (GameWindow) is - /// responsible for substituting a non-zero rate when ACE sends 0.0 - /// on the wire, per the trace finding in the design spec. - /// - /// - public void BeginServerAutoWalk( - Vector3 destinationWorld, - float minDistance, - float distanceToObject, - bool moveTowards, - bool canCharge) - { - _autoWalkActive = true; - _autoWalkDestination = destinationWorld; - _autoWalkMinDistance = minDistance; - _autoWalkDistanceToObject = distanceToObject; - _autoWalkMoveTowards = moveTowards; - - // Issue #77 fix (2026-05-18) — retail-faithful walk-vs-run. - // - // Retail's MovementParameters::get_command (decomp 0x0052aa00) - // gates run on the CanCharge flag (bit 0x10 of - // MovementParameters). Cleared → fall through to the inner - // walk_run_threshold check, which ACE's 15 m wire default + - // 0.6 m use-radius makes practically always walk for any - // chase under 15.6 m. Set → unconditional HoldKey_Run. - // - // ACE's Creature.SetWalkRunThreshold sets CanCharge when - // (server-side player→target distance) >= WalkRunThreshold / - // 2 (= 7.5 m for the 15 m default), and clears it otherwise. - // The CanCharge bit IS the wire-side walk-vs-run answer; we - // just relay it. - // - // Previously we hardcoded a 1.0 m threshold against - // initialDist - distanceToObject, which forced run at any - // chase past ~1.6 m — including the 3-5 m "walk range" the - // user expected to walk in (issue #77 reproduction). Honoring - // CanCharge restores the retail bucket: walk under ~7.5 m, - // run beyond. - _autoWalkInitiallyRunning = canCharge; - } - - /// - /// B.6 slice 2 (2026-05-14). Cancel any active server-initiated - /// auto-walk. Idempotent. is logged when - /// is on so - /// the trace shows why the auto-walk ended. - /// - public void EndServerAutoWalk(string reason) - { - if (!_autoWalkActive) return; - _autoWalkActive = false; - if (PhysicsDiagnostics.ProbeAutoWalkEnabled) - Console.WriteLine($"[autowalk-end] reason={reason}"); - if (reason == "arrived") - AutoWalkArrived?.Invoke(); - } - /// /// 2026-05-16. Called by the network outbound layer after every /// AutonomousPosition or MoveToState that carries the player's @@ -501,270 +449,6 @@ public sealed class PlayerMovementController _lastSentInitialized = true; } - /// - /// B.6 slice 2 (2026-05-14). If a server-initiated auto-walk is - /// active, either cancel it (user pressed a movement key) or - /// synthesize a Forward+Run input with stepped - /// toward the destination. Returns the (possibly modified) input - /// for the rest of to consume. - /// - /// - /// Heading correction matches - /// — ± - /// snap-on-aligned, otherwise rotate at - /// . Arrival - /// predicate matches retail's - /// MoveToManager::HandleMoveToPosition: chase arrives at - /// distanceToObject; flee arrives at minDistance. - /// - /// - /// - /// 2026-05-16 (issue #75 refactor) — drive the body directly from - /// the wire-supplied path data during server-initiated auto-walk, - /// without synthesizing player-input. Replaces the earlier - /// ApplyAutoWalkOverlay which returned a synthesized Forward+Run - /// MovementInput; that synthesis leaked to the wire as an outbound - /// MoveToState packet ("user is RunForward") which ACE read as - /// user-took-manual-control and cancelled its own MoveToChain. The - /// architecture now mirrors retail's MovementManager::PerformMovement - /// case 6 (decomp 0x00524440): step the body's velocity + motion - /// state directly; the user-input pipeline downstream sees no input - /// because the user didn't press anything, so no MoveToState gets - /// built. - /// - /// - /// Returns true when this method consumed motion control for - /// the frame (auto-walk active, no user override, no arrival). - /// Caller () must skip the user-input motion + - /// body-velocity sections to avoid them overriding the auto-walk's - /// velocity assignment. - /// - /// - private bool DriveServerAutoWalk(float dt, MovementInput input) - { - _autoWalkMovingForwardThisFrame = false; - _autoWalkTurnDirectionThisFrame = 0; - if (!_autoWalkActive) return false; - - // User-input cancellation. Any direct movement key takes over. - // Mouse-only turning (no movement key) doesn't cancel — the - // user might just be looking around mid-walk. - bool userOverride = input.Forward || input.Backward - || input.StrafeLeft || input.StrafeRight - || input.TurnLeft || input.TurnRight; - if (userOverride) - { - EndServerAutoWalk("user-input"); - return false; - } - - // Horizontal distance to target — server owns Z, our local body - // Z snaps to UpdatePosition broadcasts when ACE sends them. - var pos = _body.Position; - float dx = _autoWalkDestination.X - pos.X; - float dy = _autoWalkDestination.Y - pos.Y; - float dist = MathF.Sqrt(dx * dx + dy * dy); - - // Arrival predicate. With the 10 Hz heartbeat from 301281d the - // server-side Player.Location tracks our body within ~100 ms, so - // the previous "subtract 0.2 m safety margin" workaround is no - // longer needed. Tiny 0.05 m margin remains to absorb the - // sub-tick race between local arrival-fire and the next - // heartbeat's outbound packet. - // - // ARRIVAL IS GATED ON ALIGNMENT: we only end the auto-walk once - // the body is BOTH within use-radius AND facing the target. - // Without the alignment gate, a Use on a close target while - // facing away would end immediately and the body wouldn't turn - // at all (user feedback 2026-05-15: 'when I'm close I'm not - // facing'). The alignment check is computed below in the same - // block as the heading-step; we defer the arrival fire-and-end - // until after we've inspected `aligned`. - float arrivalThreshold = _autoWalkMoveTowards - ? _autoWalkDistanceToObject - : _autoWalkMinDistance; - // 2026-05-16 — retail "stop at the radius" semantics. - // Previously had a 0.05 m TinyMargin inside the threshold to - // ensure ACE's server-side WithinUseRadius poll saw us inside - // the radius before our next AP heartbeat. With the - // diff-driven AP cadence (Task B2) ACE sees the final position - // the same frame we arrive — no margin needed. Retail's - // arrival check is `dist <= radius` exact at - // CMotionInterp::apply_interpreted_movement integration. - bool withinArrival = - (_autoWalkMoveTowards - && dist <= arrivalThreshold) - || (!_autoWalkMoveTowards - && dist >= arrivalThreshold + RemoteMoveToDriver.ArrivalEpsilon); - - // Step Yaw toward target. Convention from Update line 364: - // _body.Orientation = Quaternion.CreateFromAxisAngle(Z, Yaw - π/2), - // so local-forward (+Y) maps to world (cos Yaw, sin Yaw, 0). - // Therefore Yaw that faces (dx,dy) is atan2(dy, dx). - // - // User feedback (2026-05-15): 'I should face that object and then - // start moving. Now it starts running before facing is complete.' - // Track the current heading delta — if we're more than the - // walk-while-turning threshold off, suppress Forward this frame - // so the body turns IN PLACE first. Once we're within the - // threshold, the synthesised Forward+Run kicks in below. - bool aligned = true; - bool walkAligned = true; - if (dist > 1e-4f) - { - float desiredYaw = MathF.Atan2(dy, dx); - float delta = desiredYaw - Yaw; - while (delta > MathF.PI) delta -= 2f * MathF.PI; - while (delta < -MathF.PI) delta += 2f * MathF.PI; - - // Retail-faithful local rotation: rotate continuously at - // TurnRate, never snap until overshoot would occur. Retail's - // MoveToManager::HandleTurnToHeading (0x0052a0c0) only snaps - // when heading_greater() detects we've crossed the target — - // there's no "snap when close" tolerance band. The earlier - // 20° snap was borrowed wrongly from RemoteMoveToDriver - // (which is the sparse-update-fudge path for remotes). - // - // MathF.Min(|delta|, maxStep) naturally clamps the final - // fractional step to exactly delta, so we land on the - // target heading without overshoot. - // 2026-05-16 — retail-faithful turn rate. Auto-walk's - // run/walk decision (one-shot at chain start) drives the - // turn rate: running rotation is 50% faster per - // run_turn_factor at retail 0x007c8914. - float maxStep = RemoteMoveToDriver.TurnRateFor(_autoWalkInitiallyRunning) * dt; - float yawStep = MathF.Sign(delta) * MathF.Min(MathF.Abs(delta), maxStep); - Yaw += yawStep; - while (Yaw > MathF.PI) Yaw -= 2f * MathF.PI; - while (Yaw < -MathF.PI) Yaw += 2f * MathF.PI; - - // 2026-05-16 (issue #69) — record rotation direction so the - // animation override can pick the TurnLeft/TurnRight cycle. - // Sign convention matches user-driven A/D in Update: - // yawStep > 0 ⇔ TurnLeft (Yaw increases) - // yawStep < 0 ⇔ TurnRight (Yaw decreases) - // Small dead-zone avoids flickering between Turn cycles - // when the residual delta is effectively zero. - if (MathF.Abs(yawStep) > 1e-5f) - _autoWalkTurnDirectionThisFrame = yawStep > 0f ? +1 : -1; - - // Two alignment thresholds: - // walkWhileTurning (30°): outside this, body turns in place. - // Inside, body walks forward while - // finishing residual alignment. - // fullyAligned (5°): the arrival-fire alignment. ACE - // rotates server-side via Rotate(target) - // BEFORE invoking the Use callback — - // user reported 'it does not face it - // completely', so the final-alignment - // check must be tighter than the - // walking gate. - const float WalkWhileTurningRad = 30f * MathF.PI / 180f; - const float FullyAlignedRad = 5f * MathF.PI / 180f; - walkAligned = MathF.Abs(delta) <= WalkWhileTurningRad; - aligned = MathF.Abs(delta) <= FullyAlignedRad; - } - - // End the auto-walk once the body is BOTH within use radius - // AND aligned with the target. This is the alignment-gated - // arrival the comment above flagged: a close-range Use on a - // target behind the player still rotates the body first. - if (withinArrival && aligned) - { - EndServerAutoWalk("arrived"); - return false; - } - - // Walk vs run uses the one-shot decision from BeginServerAutoWalk - // (initial distance minus use-radius vs walkRunThreshold). - // Held for the rest of the auto-walk so the body runs all - // the way to a far target, or walks all the way to a near - // one — matching user-observed retail behaviour. - bool shouldRun = _autoWalkInitiallyRunning; - - // Turn-first gate: if not yet within the 30° walking band, - // suppress forward motion so the body turns in place rather - // than walking an arc. Also suppress when already within - // arrival — we just turned to face it; no need to step forward - // into it. - bool moveForward = walkAligned && !withinArrival; - - if (!moveForward) - { - // Turn-in-place phase. Two sub-cases land here: - // (a) initial turn — body must rotate to face the target - // before we drive forward (walkAligned == false at chain - // start, body is stationary). - // (b) overshoot recovery — body crossed the destination, so - // desiredYaw flipped ~180° and walkAligned dropped to - // false; body needs to turn around before walking back. - // (c) settling — body is within use-radius but not aligned - // enough to fire arrival (withinArrival == true, - // !aligned); body holds position while finishing rotation - // so the arrival predicate fires on the next tick. - // - // Issue #77 fix: explicitly zero horizontal velocity. Without - // this, in case (b) the body keeps the prior frame's running - // velocity (RunAnimSpeed × runRate ≈ 11 m/s) and slides past - // the destination by several meters before the turn-around - // rotation completes — the "runs and slides away, runs back, - // picks up" symptom reported in issue #77 / bug B. Cases (a) - // and (c) zero a velocity that's already zero, so the change - // is a no-op there. - // - // The motion-interpreter state also has to step out of - // WalkForward so get_state_velocity (used downstream) reports - // standing-velocity, not the prior frame's run-speed. - _motion.DoMotion(MotionCommand.Ready, 1.0f); - if (_body.OnWalkable) - { - float savedWorldVz = _body.Velocity.Z; - _body.set_local_velocity(new Vector3(0f, 0f, savedWorldVz)); - } - return true; - } - - // Drive motion state machine + body velocity directly. This - // mirrors what the user-input section would have done with - // synthesized Forward+Run, but without putting anything into - // MovementInput — so the outbound-packet pipeline never builds - // a MoveToState packet for auto-walk frames. - uint forwardCmd; - float forwardCmdSpeed; - if (shouldRun && _weenie.InqRunRate(out float runRate)) - { - // Wire-compatible: WalkForward command @ runRate triggers - // ACE's auto-upgrade to RunForward for observers. Same - // shape as the user-input section's running path. - forwardCmd = MotionCommand.WalkForward; - forwardCmdSpeed = runRate; - } - else - { - forwardCmd = MotionCommand.WalkForward; - forwardCmdSpeed = 1.0f; - } - - _autoWalkMovingForwardThisFrame = true; - - // Update interpreted motion state — drives the animation cycle - // via UpdatePlayerAnimation downstream + the MotionInterpreter's - // state-velocity getter (used for our velocity assignment below). - _motion.DoMotion(forwardCmd, forwardCmdSpeed); - - // Set body velocity directly. Only meaningful when grounded; - // mirror the user-input section's `if (_body.OnWalkable)` gate - // so we don't override gravity/jump velocity mid-air. - if (_body.OnWalkable) - { - float savedWorldVz = _body.Velocity.Z; - var stateVel = _motion.get_state_velocity(); - _body.set_local_velocity(new Vector3(0f, stateVel.Y, savedWorldVz)); - } - - return true; - } - // L.2a slice 1 (2026-05-12): centralized CellId mutation so the // [cell-transit] probe fires from a single chokepoint. Both the // server-snap path (SetPosition) and the per-frame resolver path @@ -822,7 +506,27 @@ public sealed class PlayerMovementController // reconstruct that run vector via get_state_velocity and the player would sprint // off in the old direction the instant input resumes. Resetting the forward // command to Ready makes the player arrive at rest. - _motion.DoMotion(MotionCommand.Ready, 1.0f); + // R3-W6: retail's teleport idle is a FULL stop (StopCompletely + // 0x00527e40: resets fwd/sidestep/turn COMMANDS, zeroes velocity, + // enqueues the A9 jump-snapshot node) — not a bare DoMotion(Ready). + _motion.StopCompletely(); + // R5-V3 (#171): retail teleport_hook (0x00514ed0) — PositionManager:: + // UnStick (@0x00514eee) right after the moveto cancel: a teleport + // tears down any active stick. (StopInterpolating/UnConstrain have no + // armed acdream counterparts — no local-player InterpolationManager, + // constraint leash unarmed per #167.) + PositionManager?.UnStick(); + // Reset the edge tracker: the stop wiped the motion state, so keys + // still physically held must re-fire as press edges on the next + // Update (matches the pre-W6 level-triggered behavior of walking + // straight out of a teleport while W stays held). + _prevForwardHeld = false; + _prevBackwardHeld = false; + _prevStrafeLeftHeld = false; + _prevStrafeRightHeld = false; + _prevTurnLeftHeld = false; + _prevTurnRightHeld = false; + _prevRunHeld = false; // Reset physics clock so any subsequent update_object calls start fresh. _body.LastUpdateTime = 0.0; @@ -839,22 +543,37 @@ public sealed class PlayerMovementController { _simTimeSeconds += dt; - // 2026-05-16 (issue #75 refactor): server-initiated auto-walk - // drives the body's velocity + motion state machine DIRECTLY. - // When _autoWalkActive, DriveServerAutoWalk steps Yaw, computes - // velocity from wire-supplied runRate, calls _motion.DoMotion, - // and sets _body.set_local_velocity. The user-input motion + - // velocity sections below are SKIPPED so they don't override - // the auto-walk's assignments. Critically, no synthesized input - // gets put back into `input` — the outbound-packet pipeline at - // GameWindow.cs:6410 sees user-input null/Ready throughout the - // auto-walk and never builds a MoveToState packet, leaving - // ACE's server-side MoveToChain to run uninterrupted until its - // TryUseItem/TryPickUp callback fires. Retail equivalent: - // MovementManager::PerformMovement case 6 (decomp 0x00524440) - // calls CPhysicsObj::MoveToObject server-side; the local body - // is moved without ever touching CommandInterpreter input. - bool autoWalkConsumedMotion = DriveServerAutoWalk(dt, input); + // R4-V5: tick the verbatim MoveToManager at the slot the deleted + // DriveServerAutoWalk occupied — after inbound wire routing, before + // the input-driven motion sections. UseTime runs the retail per-tick + // moveto drivers (HandleMoveToPosition aux-turn steering + arrival + + // fail-distance / HandleTurnToHeading); the motions it dispatches + // land in InterpretedState through _DoMotion → DoInterpretedMotion, + // and sections 1/2 below turn that state into Yaw rotation + body + // velocity — the same per-frame apply user input gets. No + // synthesized input exists, so the outbound-packet pipeline sees no + // user motion and never builds a MoveToState mid-moveto (the #75 + // invariant, now by construction). Provisional tick placement until + // R6 ports retail's UpdateObjectInternal ordering (r4-port-plan.md + // §3 placement decision). R5-V5: the facade relay + // (MovementManager::UseTime 0x005242f0 — moveto side only). + Movement.UseTime(); + + // R4-V5 wedge fix (2026-07-03 live door bug), retail's per-tick + // completion slot: CPartArray::HandleMovement — a tailcall chain to + // MotionTableManager::CheckForCompletedMotions (0x00517d60 → + // 0x0051bfd0) — runs every tick right AFTER MovementManager::UseTime + // in UpdateObjectInternal (@005159a4). It flushes pending_animations + // entries whose animations already ran out so their AnimationDone → + // MotionDone pops land each tick even when no op fired that frame. + // (apply_current_movement is NOT part of the per-tick order — its + // retail callers are all event-driven: hold-key toggles, HitGround/ + // LeaveGround, ReportExhaustion.) Full tick ordering remains R6 + // scope; the companion fix is StopCompletely's previously-missing + // StopCompletely_Internal animation dispatch (see + // MotionInterpreter.StopCompletely), whose completable entry this + // slot drains. + _motion.CheckForCompletedMotions?.Invoke(); // Portal-space guard: while teleporting, no input is processed and // no physics is resolved. Return a zero-movement result so the caller @@ -875,6 +594,96 @@ public sealed class PlayerMovementController TurnSpeed: null); } + // ── R3-W6: EDGE-DRIVEN retail input (replaces the D6.2 per-frame + // RawMotionState rebuild — the level-triggered substitute for + // retail's edge-triggered CommandInterpreter). Each key EDGE fires + // DoMotion/StopMotion (0x00528d20/0x00528530) which mutate the + // interpreter's OWN RawState via ApplyMotion/RemoveMotion and + // dispatch through the funnel + DefaultSink — the SAME pipeline + // remotes use. The Shift edge is retail's set_hold_run + // (0x00528b70, caller 0x006b33ca shape: interrupt=true). RAW speeds + // stay 1.0 (apply_run_to_command applies the run rate — pre-scaling + // would double-scale; TS-22 unchanged). R4-V5: the ctor-default + // params carry retail's 0x1EE0F bitfield whose CancelMoveTo bit + // (0x8000) is SET — any key edge mid-moveto fires + // InterruptCurrentMovement → MoveTo.CancelMoveTo(ActionCancelled), + // the retail user-input cancel chain (TS-36 retired; set_hold_run's + // interrupt:true is the same chain for the Shift edge). + bool motionEdgeFired = false; + { + var p = new AcDream.Core.Physics.Motion.MovementParameters(); + + // Shift/run edge FIRST — retail's set_hold_run re-applies + // movement, so the hold-key state is current before any + // same-frame directional dispatch. + if (input.Run != _prevRunHeld) + { + _motion.set_hold_run(input.Run, interrupt: true); + motionEdgeFired = true; + } + + // Forward channel (W / S share one raw channel — retail + // RawMotionState.ApplyMotion's forward-class switch). W wins on + // a same-frame double-press; releasing one key while the + // opposite is still held re-issues the survivor (equivalent to + // the old level-triggered build, which always reflected the + // currently-held set). + if (input.Forward && !_prevForwardHeld) + { _motion.DoMotion(MotionCommand.WalkForward, p); motionEdgeFired = true; } + else if (input.Backward && !_prevBackwardHeld && !input.Forward) + { _motion.DoMotion(MotionCommand.WalkBackward, p); motionEdgeFired = true; } + if (!input.Forward && _prevForwardHeld) + { + if (input.Backward) + _motion.DoMotion(MotionCommand.WalkBackward, p); + else + _motion.StopMotion(MotionCommand.WalkForward, p); + motionEdgeFired = true; + } + else if (!input.Backward && _prevBackwardHeld && !input.Forward) + { _motion.StopMotion(MotionCommand.WalkBackward, p); motionEdgeFired = true; } + + // Sidestep channel. + if (input.StrafeRight && !_prevStrafeRightHeld) + { _motion.DoMotion(MotionCommand.SideStepRight, p); motionEdgeFired = true; } + else if (input.StrafeLeft && !_prevStrafeLeftHeld) + { _motion.DoMotion(MotionCommand.SideStepLeft, p); motionEdgeFired = true; } + else if (!input.StrafeRight && !input.StrafeLeft + && (_prevStrafeRightHeld || _prevStrafeLeftHeld)) + { _motion.StopMotion(MotionCommand.SideStepRight, p); motionEdgeFired = true; } + + // Turn channel. + if (input.TurnRight && !_prevTurnRightHeld) + { _motion.DoMotion(MotionCommand.TurnRight, p); motionEdgeFired = true; } + else if (input.TurnLeft && !_prevTurnLeftHeld) + { _motion.DoMotion(MotionCommand.TurnLeft, p); motionEdgeFired = true; } + else if (!input.TurnRight && !input.TurnLeft + && (_prevTurnRightHeld || _prevTurnLeftHeld)) + { _motion.StopMotion(MotionCommand.TurnRight, p); motionEdgeFired = true; } + + // Retail stores last_move_was_autonomous = 1 at the CPhysicsObj + // INPUT boundary — CPhysicsObj::DoMotion @00510030 / + // CPhysicsObj::StopMotion @005100e0 (per call, before routing + // to MovementManager) and CommandInterpreter:: + // TakeControlFromServer @006b32f4. The MoveToManager's + // _DoMotion goes through CMotionInterp internals and NEVER + // touches the flag; the wire unpack path stores the wire byte + // (P1, 00509730). This edge block IS acdream's input boundary, + // so an edge firing is exactly retail's store site. The flag + // routes the per-tick pump's A3 dual dispatch (raw for + // input-driven motion, interpreted for server/manager-driven). + if (motionEdgeFired) + _body.LastMoveWasAutonomous = true; + } + + _prevForwardHeld = input.Forward; + _prevBackwardHeld = input.Backward; + _prevStrafeLeftHeld = input.StrafeLeft; + _prevStrafeRightHeld = input.StrafeRight; + _prevTurnLeftHeld = input.TurnLeft; + _prevTurnRightHeld = input.TurnRight; + _prevRunHeld = input.Run; + // ── 1. Apply turning from keyboard + mouse ──────────────────────────── // 2026-05-16 — retail-faithful turn rate. // Anchor: docs/research/named-retail/acclient_2013_pseudo_c.txt @@ -886,11 +695,23 @@ public sealed class PlayerMovementController // Effective: walking ≈ 90°/s, running ≈ 135°/s. // Previously: WalkAnimSpeed*0.5 ≈ 89.4°/s — coincidentally // close to retail walking but no run differentiation. - float keyboardTurnRate = RemoteMoveToDriver.TurnRateFor(input.Run); - if (input.TurnRight) - Yaw -= keyboardTurnRate * dt; - if (input.TurnLeft) - Yaw += keyboardTurnRate * dt; + // D6.2: local keyboard turn rate now comes from the interpreted turn + // state (adjust_motion normalized TurnLeft→TurnRight with sign + + // apply_run_to_command ×RunTurnFactor when running). omega.Z = + // BaseTurnRateRadPerSec × turn_speed — the same π/2 formula the remote + // path uses (GameWindow ObservedOmega seed). Numerically identical to the + // former TurnRateFor(input.Run); AP-9 (π/2 base rate) is unchanged. + // R4-V5: runs during a moveto too — the manager's aux-turn steering + // and TurnToHeading nodes dispatch TurnRight/TurnLeft through + // _DoMotion into the SAME interpreted turn state, so this one + // integrator rotates the player for both input and moveto turns. + // Mouse turn stays a direct Yaw delta (deliberately generates no + // turn command — avoids MoveToState spam from mouse jitter). + if (_motion.InterpretedState.TurnCommand == MotionCommand.TurnRight) + { + Yaw -= (MathF.PI / 2.0f) // BaseTurnRateRadPerSec (AP-9), ex-RemoteMoveToDriver + * _motion.InterpretedState.TurnSpeed * dt; + } Yaw -= input.MouseDeltaX * MouseTurnSensitivity; // Wrap yaw to [-PI, PI] so it doesn't grow unbounded. while (Yaw > MathF.PI) Yaw -= 2f * MathF.PI; @@ -902,61 +723,16 @@ public sealed class PlayerMovementController _body.Orientation = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, Yaw - MathF.PI / 2f); // ── 2. Set velocity via MotionInterpreter state machine ─────────────── - // 2026-05-16 (issue #75): skip when DriveServerAutoWalk owns - // motion control this frame — it has already called - // _motion.DoMotion + _body.set_local_velocity from the auto- - // walk's path data + runRate. Running this section would - // overwrite the auto-walk velocity with the user-input - // (Ready/Stand) velocity, freezing the body. - if (!autoWalkConsumedMotion) - { - // Determine the dominant forward/backward command and speed. - uint forwardCmd; - float forwardCmdSpeed; - if (input.Forward) - { - forwardCmd = input.Run ? MotionCommand.RunForward : MotionCommand.WalkForward; - // When running, use the PlayerWeenie's RunRate as ForwardSpeed. - // The retail server computes this from Run skill + encumbrance and - // broadcasts it in UpdateMotion, but it doesn't echo to the sender. - // We compute locally using the same formula. - if (input.Run && _weenie.InqRunRate(out float runRate)) - forwardCmdSpeed = runRate; - else - forwardCmdSpeed = 1.0f; - } - else if (input.Backward) - { - forwardCmd = MotionCommand.WalkBackward; - // K-fix3 (2026-04-26): backward also honors Run. Without - // this, holding X with Run=true (default) still produced - // walk-tier backward speed because forwardCmdSpeed was - // hardcoded to 1.0. Now scale by runRate the same way - // RunForward does. - if (input.Run && _weenie.InqRunRate(out float runRateBack)) - forwardCmdSpeed = runRateBack; - else - forwardCmdSpeed = 1.0f; - } - else - { - forwardCmd = MotionCommand.Ready; - forwardCmdSpeed = 1.0f; - } + // R4-V5: runs during a moveto too — the manager's BeginMoveForward + // dispatched WalkForward/RunForward through _DoMotion into the SAME + // interpreted state, so this one per-frame apply turns it into body + // velocity exactly like input-driven motion (the #75 "two writers" + // hazard is gone: there is only this writer now). - // Update interpreted motion state (needed for animation + server messages). - _motion.DoMotion(forwardCmd, forwardCmdSpeed); - - // Sidestep. - if (input.StrafeRight) - _motion.DoInterpretedMotion(MotionCommand.SideStepRight, 1.0f, modifyInterpretedState: true); - else if (input.StrafeLeft) - _motion.DoInterpretedMotion(MotionCommand.SideStepLeft, 1.0f, modifyInterpretedState: true); - else - { - _motion.StopInterpretedMotion(MotionCommand.SideStepRight, modifyInterpretedState: true); - _motion.StopInterpretedMotion(MotionCommand.SideStepLeft, modifyInterpretedState: true); - } + // D6.2: the forward/sidestep command determination + DoMotion + + // DoInterpretedMotion moved into the apply_raw_movement call above, so + // the interpreted state (and thus get_state_velocity) is already + // populated + normalized for all directions. // Only replace velocity with motion interpreter output when grounded. // While airborne, the physics body's integrated velocity (from LeaveGround) @@ -965,44 +741,28 @@ public sealed class PlayerMovementController if (_body.OnWalkable) { float savedWorldVz = _body.Velocity.Z; + // D6.2: velocity for ALL directions comes from the normalized + // interpreted state — backward (WalkForward ×-0.65) and strafe-left + // (SideStepRight ×-1×1.248) are handled inside get_state_velocity now + // that adjust_motion ran above. The hand-mirrored formulas are gone + // (register TS-22 retired). var stateVel = _motion.get_state_velocity(); - - float localY = 0f; - float localX = 0f; - - // K-fix3 (2026-04-26): unified run-multiplier for backward - // + strafe. Forward already scales correctly because it uses - // stateVel.Y (which the motion state machine fed runRate - // into via DoMotion). Backward + strafe bypass the state - // machine and hardcoded speed; previously they capped at - // walk speed regardless of Run, which made the ~2.4× - // forward-vs-back/strafe ratio feel wrong. Now both scale - // with the same runRate the forward branch uses. - float runMul = 1.0f; - if (input.Run && _weenie.InqRunRate(out float vrr)) - runMul = vrr; - - if (input.Forward) - localY = stateVel.Y; - else if (input.Backward) - localY = -(MotionInterpreter.WalkAnimSpeed * 0.65f * runMul); - - // Strafe scales with the same runMul so sidestep matches - // the forward pace at run speed (retail uses speed=1.0 for - // SideStep + the same hold-key-driven run/walk multiplier). - if (input.StrafeRight) - localX = MotionInterpreter.SidestepAnimSpeed * runMul; - else if (input.StrafeLeft) - localX = -MotionInterpreter.SidestepAnimSpeed * runMul; - - _body.set_local_velocity(new Vector3(localX, localY, savedWorldVz)); + // R4-V5 wedge fix: PRESERVE the flag — retail's + // last_move_was_autonomous is stored at EVENT boundaries only + // (input DoMotion/StopMotion edges above, the P1 wire-unpack + // store, LeaveGround's own autonomous=1 write), never re-stamped + // by the per-tick velocity write. V5's first cut stamped it per + // frame here, which mis-routed the pump's A3 dual dispatch on + // event-transition frames (apply_raw clobbering a just-armed + // moveto's dispatched motion with the raw Ready state). + _body.set_local_velocity(new Vector3(stateVel.X, stateVel.Y, savedWorldVz), + autonomous: _body.LastMoveWasAutonomous); } - } // end of `if (!autoWalkConsumedMotion)` — section 2 // ── 3. Jump (charged) ───────────────────────────────────────────────── // Hold spacebar to charge (0→1 over JumpChargeRate seconds). // Release to execute: jump(extent) validates + sets JumpExtent, - // then LeaveGround() applies the scaled velocity via get_leave_ground_velocity. + // then LeaveGround() applies the scaled velocity via GetLeaveGroundVelocity. float? outJumpExtent = null; Vector3? outJumpVelocity = null; @@ -1013,6 +773,12 @@ public sealed class PlayerMovementController { _jumpCharging = true; _jumpExtent = 0f; + // R3-W6 (map R1): retail's charge_jump fires at charge + // START (SmartBox/input boundary 0x0056afac) — the ONLY + // place StandingLongJump arms (grounded + Ready + no + // sidestep/turn). Never called by production code before + // this line despite the W3 port. + _motion.ChargeJump(); } _jumpExtent = MathF.Min(_jumpExtent + dt * JumpChargeRate, 1.0f); } @@ -1022,63 +788,21 @@ public sealed class PlayerMovementController var jumpResult = _motion.jump(_jumpExtent); if (jumpResult == WeenieError.None) { - // Capture jump_v_z BEFORE LeaveGround() — that call resets - // JumpExtent back to 0 (faithful to retail's FUN_00529710), - // after which get_jump_v_z() returns 0 because the extent - // gate at the top of the function fires. - float jumpVz = _motion.get_jump_v_z(); - _motion.LeaveGround(); + // R3-W4 (J7): the manual LeaveGround call is DELETED — + // jump() clears OnWalkable, and the SAME frame's + // grounded→airborne edge (section 5's transition detection) + // fires _motion.LeaveGround() exactly where retail's + // transition sweep does. Capture jump_v_z NOW: the edge's + // LeaveGround resets JumpExtent to 0 later this frame. + float jumpVz = _motion.GetJumpVZ(); outJumpExtent = _jumpExtent; - // BODY-LOCAL jump-launch velocity, computed directly from input. - // - // Why not read _body.Velocity? Because _motion.LeaveGround() - // routes through get_leave_ground_velocity → get_state_velocity, - // which is a faithful port of retail's FUN_00528960. Retail's - // version only handles WalkForward (0x45000005) / RunForward - // (0x44000007) / SideStepRight (0x6500000F); WalkBackwards - // and SideStepLeft return zero. Retail papers over this in - // adjust_motion (FUN_00528010) by translating - // WalkBackwards → WalkForward + speed × -0.65 - // SideStepLeft → SideStepRight + speed × -1 - // before they reach InterpretedState — but we don't yet port - // adjust_motion, so InterpretedState holds the un-translated - // command and get_state_velocity returns (0,0,0) for it. - // LeaveGround then writes (0,0,jumpZ) to the body, wiping the - // correct strafe/backward velocity the controller had just set - // a few lines up. Result: backward/strafe jumps go straight up. - // - // Until adjust_motion is ported, we mirror the grounded-velocity - // computation from the block above and stuff the result into - // outJumpVelocity directly. Local frame: +Y forward, +X right, - // +Z up — matches retail's body-frame convention. Server - // rotates body→world on receive, so observers see the jump - // in the correct world direction. - float jumpRunMul = 1.0f; - if (input.Run && _weenie.InqRunRate(out float jvrr)) - jumpRunMul = jvrr; - - // Forward uses get_state_velocity (which knows Walk vs Run vs - // animation-cycle pacing). Backward / Strafe use the same - // hardcoded scaled formulas the grounded-velocity block above - // uses (lines 397-408). - float localY = 0f; - if (input.Forward) - { - var stateVel = _motion.get_state_velocity(); - localY = stateVel.Y; - } - else if (input.Backward) - { - localY = -(MotionInterpreter.WalkAnimSpeed * 0.65f * jumpRunMul); - } - - float localX = 0f; - if (input.StrafeRight) - localX = MotionInterpreter.SidestepAnimSpeed * jumpRunMul; - else if (input.StrafeLeft) - localX = -MotionInterpreter.SidestepAnimSpeed * jumpRunMul; - - outJumpVelocity = new Vector3(localX, localY, jumpVz); + // D6.2: get_state_velocity() is now correct for all directions + // (apply_raw_movement normalized backward/strafe above), so the + // jump-launch velocity is get_state_velocity() + the vertical jump + // component. Retires the duplicated hand-mirrored formulas that + // existed only until adjust_motion was ported (register TS-22). + var jumpVel = _motion.get_state_velocity(); + outJumpVelocity = new Vector3(jumpVel.X, jumpVel.Y, jumpVz); // Local-prediction fix: LeaveGround above wrote (0, 0, jumpZ) // to the body for backward/strafe-left (same get_state_velocity @@ -1087,7 +811,7 @@ public sealed class PlayerMovementController // client renders the jump in the same world direction the // server is broadcasting to observers. Same vector we just // sent in JumpAction — local + remote stay in sync. - _body.set_local_velocity(outJumpVelocity.Value); + _body.set_local_velocity(outJumpVelocity.Value, autonomous: true); } _jumpCharging = false; _jumpExtent = 0f; @@ -1103,6 +827,7 @@ public sealed class PlayerMovementController // declaration for the full retail trace evidence. var preIntegratePos = _body.Position; bool physicsTickRan = false; + float lastTickDt = 0f; // the dt actually integrated this frame (for cached_velocity) Vector3 oldTickEndPos = _currPhysicsPos; _physicsAccum += dt; @@ -1118,6 +843,30 @@ public sealed class PlayerMovementController // Integrate accumulated dt, clamped to MaxQuantum so a long // pause doesn't produce one giant integration step. float tickDt = MathF.Min(_physicsAccum, PhysicsBody.MaxQuantum); + lastTickDt = tickDt; + + // R5-V3 (#171): retail UpdatePositionInternal (0x00512c30) — + // PositionManager::adjust_offset (@0x00512d0e) composes the + // sticky steer into this quantum's motion BEFORE + // UpdatePhysicsInternal, so the transition sweep below resolves + // it like any other movement (preIntegratePos was captured + // above). The delta's Origin is mover-LOCAL (rotate out by the + // body orientation); the heading is RELATIVE and writes Yaw — + // the authoritative facing the body quaternion is re-derived + // from every frame (a quaternion-only write would be clobbered). + // No-op while nothing is stuck (untouched delta frame). + if (PositionManager is { } ppm) + { + var pmDelta = new AcDream.Core.Physics.Motion.MotionDeltaFrame(); + ppm.AdjustOffset(pmDelta, tickDt); + if (pmDelta.Origin != Vector3.Zero) + _body.Position += Vector3.Transform(pmDelta.Origin, _body.Orientation); + if (!pmDelta.Orientation.IsIdentity) + Yaw = AcDream.Core.Physics.Motion.MoveToMath.YawFromHeading( + AcDream.Core.Physics.Motion.MoveToMath.HeadingFromYaw(Yaw) + + pmDelta.GetHeading()); + } + _body.calc_acceleration(); _body.UpdatePhysicsInternal(tickDt); _physicsAccum -= tickDt; @@ -1129,14 +878,31 @@ public sealed class PlayerMovementController // (motion commands, animation, return) runs normally. var postIntegratePos = _body.Position; + // retail UpdateObjectInternal (pc:283657): the transition + handle_all_collisions are + // reached ONLY when the integrated candidate actually MOVED off m_position. This gate + // is load-bearing for the #182 bleed: after fsf>1 zeros a blocked jump's velocity, the + // next frame integrates zero motion (velMag2==0 → no position step, just v += gravity), + // so the candidate hasn't moved yet — handle_all_collisions MUST be skipped that frame + // or it re-zeros the gravity velocity and the body re-wedges instead of falling off. + bool candidateMoved = postIntegratePos != preIntegratePos; + // ── 5. Collision resolution via CTransition sphere-sweep ───────────── // The Transition system subdivides the movement from pre→post into // sphere-radius steps, testing terrain collision at each step. // Falls back to simple Z-snap if transition fails. var resolveResult = _physics.ResolveWithTransition( preIntegratePos, postIntegratePos, CellId, - sphereRadius: 0.48f, // human player radius from Setup - sphereHeight: 1.2f, // human player height from Setup + sphereRadius: 0.48f, // human Setup 0x02000001 sphere radius (dat: 0.480) + // #137 window climb (2026-07-06): sphereHeight is the CAPSULE TOP + // (InitPath places the head sphere center at height − radius). The + // dat human Setup 0x02000001 has Spheres[1].Origin.Z = 1.350 + // (top 1.830) and Height = 1.835 — retail collides with that + // sphere list verbatim (CPhysicsObj::transition 0x00512dc0 → + // init_sphere(GetNumSphere, GetSphere, scale)). The old 1.2f put + // the head sphere center at 0.72 — the top 0.63 m of the + // character had NO collision, letting the player climb into a + // 1.3 m window alcove head-through-lintel. Register TS-46. + sphereHeight: 1.835f, stepUpHeight: StepUpHeight, stepDownHeight: StepDownHeight, // L.2.3a: from Setup.StepDownHeight isOnGround: _body.OnWalkable, @@ -1172,156 +938,92 @@ public sealed class PlayerMovementController $"isOnGround={resolveResult.IsOnGround}"); } - // Apply resolved position. + // ── Apply the resolve: retail UpdateObjectInternal (0x005156b0) → + // SetPositionInternal (0x00515330) → handle_all_collisions (0x00514780). + // #182 verbatim rebuild: this REPLACES the ad-hoc airborne-only bounce with the + // frames_stationary_fall-driven velocity model — the airborne-stuck bleed + // (fsf>1 → velocity zeroed) that lets a blocked jump fall/glide off a monster crowd. + + // cached_velocity = realized displacement / dt (retail's SEPARATE reporting/DR value, + // pc:005158cb-5158ff; not fed back into the integrator velocity). + _body.CachedVelocity = (candidateMoved && physicsTickRan && lastTickDt > 0f) + ? (resolveResult.Position - preIntegratePos) / lastTickDt + : Vector3.Zero; + + // Capture prev contact/walkable BEFORE committing the new state — retail + // SetPositionInternal reads transient_state at entry for handle_all_collisions' args. + bool prevContact = _body.InContact; + bool prevOnWalkable = _body.OnWalkable; + _body.Position = resolveResult.Position; if (physicsTickRan) { _prevPhysicsPos = oldTickEndPos; _currPhysicsPos = _body.Position; + + // R5-V3 (#171): retail UpdateObjectInternal TAIL — PositionManager:: + // UseTime (@0x005159b3) runs AFTER the quantum's integration + // (whose head hosts adjust_offset) and only on frames where a + // physics quantum executed (retail's update_object MinQuantum + // gate skips the whole UpdateObjectInternal). + PositionManager?.UseTime(); } - // L.3a (2026-04-30): retail wall-bounce / velocity reflection. - // - // Retail's CPhysicsObj::handle_all_collisions runs after every - // SetPositionInternal. It reads the wall normal that the - // transition's slide computed and reflects the body's velocity: - // - // v_new = v - (1 + elasticity) * dot(v, n) * n - // - // This is what gives retail its "bouncy" feel — fast head-on - // jumps push the player back from the wall, glancing angles - // produce a small deflection. acdream's transition resolver - // SLID position correctly but never updated velocity, so the - // player kept driving into walls until the controller's input - // changed direction. Felt sticky / fragile. - // - // Suppression rule (apply_bounce): grounded movement on a wall - // SHOULDN'T bounce — sliding along a corridor is expected. Only - // airborne wall hits reflect. Mirrors retail's `var_10_1` guard - // and ACE PhysicsObj.cs:2656-2660 `apply_bounce`. - // - // Inelastic flag (spell projectiles, missiles) zeros velocity - // entirely instead of reflecting. The player never has it set. - // - // Sources: - // acclient_2013_pseudo_c.txt:282699-282715 (handle_all_collisions) - // acclient.h:2834 (INELASTIC_PS = 0x20000) - // ACE PhysicsObj.cs:2656-2721 (line-for-line port) - // PhysicsGlobals.DefaultElasticity = 0.05f, MaxElasticity = 0.1f - if (resolveResult.CollisionNormalValid) - { - bool prevOnWalkable = _body.OnWalkable; - bool nowOnWalkable = resolveResult.IsOnGround; - - // apply_bounce: bounce ONLY when the body stays airborne both - // before and after this step. That is: jumping into a wall - // mid-flight, hitting a ceiling, etc. Specifically NOT: - // - // - prev grounded + now grounded → wall-slide along corridor - // (bounce would feel sticky on every wall touch). - // - prev airborne + now grounded → terrain landing - // (terrain normal is mostly +Z; reflecting downward velocity - // would push the body upward and prevent the landing snap - // from firing — player perpetually micro-bouncing on the - // floor instead of resting). - // - prev grounded + now airborne → walked off cliff - // (gravity should take over, not lateral bounce). - // - // Sledding mode reverts to retail's broader rule (bounce - // unless both grounded), since sledding intentionally bounces - // off ramps. - // - // This is more conservative than retail's strict - // `!(prev && now && !sledding)` rule — retail bounces on - // landing too, but at elasticity 0.05 the visual effect is - // imperceptible there. acdream's per-frame architecture - // amplifies the artifact (the post-reflection upward Z - // defeats the controller's `Velocity.Z <= 0` landing-snap - // gate), so we suppress it on landing to avoid the - // micro-bounce death spiral. - bool applyBounce = _body.State.HasFlag(PhysicsStateFlags.Sledding) - ? !(prevOnWalkable && nowOnWalkable) - : (!prevOnWalkable && !nowOnWalkable); - - // L.4-diag (2026-04-30): per-frame bounce trace for steep-roof bug. - bool diagSteep = AcDream.Core.Physics.PhysicsDiagnostics.DumpSteepRoofEnabled; - if (diagSteep && resolveResult.CollisionNormalValid) - { - var n0 = resolveResult.CollisionNormal; - var v0 = _body.Velocity; - Console.WriteLine( - $"[steep-roof] BOUNCE-CHECK applyBounce={applyBounce} " + - $"prevWalk={prevOnWalkable} nowWalk={nowOnWalkable} " + - $"N=({n0.X:F2},{n0.Y:F2},{n0.Z:F2}) FloorZ={PhysicsGlobals.FloorZ:F2} " + - $"V=({v0.X:F2},{v0.Y:F2},{v0.Z:F2}) " + - $"dot={Vector3.Dot(v0, n0):F3} " + - $"isOnGround={resolveResult.IsOnGround}"); - } - - if (applyBounce) - { - if (_body.State.HasFlag(PhysicsStateFlags.Inelastic)) - { - // Full stop on impact. Spell projectiles / missiles. - _body.Velocity = Vector3.Zero; - } - else - { - var v = _body.Velocity; - var n = resolveResult.CollisionNormal; - float dotVN = Vector3.Dot(v, n); - if (dotVN < 0f) - { - // Reflect the into-wall component back out. - // Player elasticity is 0.05 → 105% of perpendicular - // velocity reflects (subtle bounce). - float k = -(dotVN * (_body.Elasticity + 1f)); - _body.Velocity = v + n * k; - - if (diagSteep) - { - var v1 = _body.Velocity; - Console.WriteLine( - $"[steep-roof] BOUNCE-APPLIED V_after=({v1.X:F2},{v1.Y:F2},{v1.Z:F2}) k={k:F3}"); - } - } - } - } - } - + // SetPositionInternal contact determination (pc:283468-510). acdream's resolver + // reports IsOnGround even during an UPWARD jump (it always step-downs), so the + // contact-plane intent stays gated by Velocity.Z<=0 (documented adaptation AD-25): a + // jump stays airborne until it descends. Determined BEFORE handle_all_collisions so the + // landing state is committed before any reflect — this ordering plus the ungated + // small-velocity-zero (Slice 1a) is what retires AD-25's micro-bounce death spiral + // (the old code reflected FIRST, so the reflected +Z defeated the landing gate). bool justLanded = false; - if (resolveResult.IsOnGround) + if (resolveResult.IsOnGround && _body.Velocity.Z <= 0f) { - if (_body.Velocity.Z <= 0f) - { - // Grounded — snap to resolved position and land. - bool wasAirborne = !_body.OnWalkable; - _body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable; - _body.calc_acceleration(); + bool wasAirborne = !_body.OnWalkable; + _body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable; + _body.calc_acceleration(); - if (_body.Velocity.Z < 0f) - _body.Velocity = new Vector3(_body.Velocity.X, _body.Velocity.Y, 0f); + // Stop the fall on landing (retail settles the into-ground component via + // calc_friction next frame; the hand-zero avoids a one-frame floor dip and makes + // handle_all_collisions' landing reflect a no-op — dot(v,n)=0). + if (_body.Velocity.Z < 0f) + _body.Velocity = new Vector3(_body.Velocity.X, _body.Velocity.Y, 0f); - if (wasAirborne) - { - _motion.HitGround(); - justLanded = true; - } - } - else + if (wasAirborne) { - // Moving upward (jump) — stay airborne even though terrain is below. - _body.TransientState &= ~(TransientStateFlags.Contact | TransientStateFlags.OnWalkable); - _body.calc_acceleration(); + // R4-V5 → R5-V5: retail order — minterp then moveto + // (MovementManager::HitGround 0x00524300). Re-arms a moveto suspended by the + // airborne UseTime contact gate. LeaveGround has NO moveto side (§2e). + Movement.HitGround(); + justLanded = true; } } else { - // No ground found — airborne. + // Airborne: jumping up (IsOnGround but v.z>0) OR no ground found. _body.TransientState &= ~(TransientStateFlags.Contact | TransientStateFlags.OnWalkable); _body.calc_acceleration(); } + // handle_all_collisions (0x00514780): reflect the into-surface velocity (fsf≤1) or + // ZERO it entirely (fsf>1 — THE airborne-stuck fix). The Stationary* bit round-trip is + // owned by the Core resolve writeback. Restores retail's should_reflect rule; on a + // landing the Velocity.Z hand-zero above makes the reflect a no-op (no micro-bounce). + // Gated on candidateMoved (retail SetPositionInternal is only reached when the candidate + // moved) so a no-move frame doesn't re-zero the gravity velocity rebuilding after a bleed. + if (candidateMoved) + { + PhysicsObjUpdate.HandleAllCollisions( + _body, + resolveResult.CollisionNormalValid, resolveResult.CollisionNormal, + prevContact, prevOnWalkable, nowOnWalkable: _body.OnWalkable); + } + + // R3-W4 (J7/J8): the grounded→airborne EDGE fires retail's LeaveGround (0x00528b00) — + // jump launches and walk-off-a-ledge both route here. The landing branch above fires + // HitGround on the opposite edge. + if (!_body.OnWalkable && !_wasAirborneLastFrame) + _motion.LeaveGround(); _wasAirborneLastFrame = !_body.OnWalkable; UpdateCellId(resolveResult.CellId, "resolver"); @@ -1334,37 +1036,33 @@ public sealed class PlayerMovementController uint? outTurnCmd = null; float? outTurnSpeed = null; - // Retail-faithful wire commands. ACE's MovementData constructor only - // computes interpState.ForwardSpeed for WalkForward / WalkBackwards - // (Network/Motion/MovementData.cs:104-119) — for any other command - // the else-branch passes through without setting speed, so observers - // dead-reckon at speed=0. The wire therefore must be: + // Retail-faithful wire commands — the wire carries the RAW motion state: // - Forward (walk): WalkForward @ 1.0 - // - Forward (run): WalkForward @ run_rate + HoldKey.Run - // (ACE auto-upgrades to RunForward for observers) + // - Forward (run): WalkForward @ 1.0 + HoldKey.Run // - Backward: WalkBackward @ 1.0 - // Our own local animation still wants the actual RunForward cycle - // though — that's carried separately in LocalAnimationCommand below. - uint? localAnimCmd = null; + // D6.2b (echo-test 2026-07-01): ACE RECOMPUTES the broadcast run speed + // from the character's run skill and auto-upgrades WalkForward+HoldKey.Run + // → RunForward for observers. Sending the raw forward_speed=1.0 (omitted by + // default-difference packing) still broadcasts RunForward @ runRate — a + // retail observer saw +Acdream run at full pace. + // R3-W6: the LOCAL animation no longer needs a separate + // LocalAnimationCommand — the walk→run promotion happens inside the + // ported machinery (apply_raw_movement → apply_run_to_command + // promotes WalkForward+HoldKey.Run → RunForward @ my_run_rate on the + // interpreted side, which the DefaultSink dispatch plays). + // NOTE (R7 scope): the wire values below stay derived from input — + // the L.2b-verified byte stream is untouched; sourcing them from + // _motion.RawState needs the cdb CommandInterpreter-boundary capture + // the W6 map's §2b TODO flags, and R7 owns outbound anyway. if (input.Forward) { - outForwardCmd = MotionCommand.WalkForward; - if (input.Run && _weenie.InqRunRate(out float runRate)) - { - outForwardSpeed = runRate; - localAnimCmd = MotionCommand.RunForward; // local cycle is RunForward - } - else - { - outForwardSpeed = 1.0f; - localAnimCmd = MotionCommand.WalkForward; - } + outForwardCmd = MotionCommand.WalkForward; + outForwardSpeed = 1.0f; // RAW — ACE recomputes the broadcast speed } else if (input.Backward) { outForwardCmd = MotionCommand.WalkBackward; outForwardSpeed = 1.0f; - localAnimCmd = MotionCommand.WalkBackward; } // Strafe: retail uses speed=1.0 for SideStep (see holtburger @@ -1399,33 +1097,32 @@ public sealed class PlayerMovementController } // ── 7. Detect motion state change ───────────────────────────────────── - // Bug fix: ForwardCommand can stay the same (WalkForward) while ONLY - // ForwardSpeed or the run-hold bit changes. If the user is already - // walking (W held), then presses Shift, the outbound wire still has - // ForwardCommand=WalkForward but outForwardSpeed jumps from 1.0 to - // runRate. Without also tracking speed + hold-key here, no new - // MoveToState is sent — the server keeps thinking the player walks, - // and retail observers render walking animation despite the local - // player's RunForward cycle. - // - // Similarly LocalAnimationCommand change (Walk→Run on local cycle) - // must force a fresh outbound so ACE's BroadcastMovement re-runs - // MovementData(this, moveToState) which only reads ForwardCommand + - // ForwardSpeed + HoldKey to pick between WalkForward vs RunForward - // for remote observers. + // ForwardCommand can stay WalkForward while only the run-hold bit changes + // (walk W held, then Shift → run). Since D6.2b the wire forward_speed is + // always the RAW 1.0 (ACE recomputes the broadcast run speed), so the + // walk↔run toggle is detected via the HoldKey (runHold) and the + // LocalAnimationCommand change (Walk↔Run cycle), NOT via forward_speed. A + // fresh MoveToState on that toggle lets ACE's BroadcastMovement re-pick + // WalkForward vs RunForward (via HoldKey) and recompute the run speed for + // observers. The forward_speed comparison below is retained (harmless — it + // never fires now that forward_speed is constant) for defensiveness. bool runHold = input.Run; + // R3-W6: the localAnimCmd leg is deleted with the synthesis layer; + // motionEdgeFired (any DoMotion/StopMotion/set_hold_run edge this + // frame) is OR-ed in — by construction an edge IS a state change + // (retail dispatches only on edges), keeping the wire cadence + // identical to the old output-comparison. bool changed = outForwardCmd != _prevForwardCmd || outSidestepCmd != _prevSidestepCmd || outTurnCmd != _prevTurnCmd || !FloatsEqual(outForwardSpeed, _prevForwardSpeed) || runHold != _prevRunHold - || localAnimCmd != _prevLocalAnimCmd; + || motionEdgeFired; _prevForwardCmd = outForwardCmd; _prevSidestepCmd = outSidestepCmd; _prevTurnCmd = outTurnCmd; _prevForwardSpeed = outForwardSpeed; _prevRunHold = runHold; - _prevLocalAnimCmd = localAnimCmd; static bool FloatsEqual(float? a, float? b) { @@ -1485,51 +1182,19 @@ public sealed class PlayerMovementController HeartbeatDue = groundedOnWalkable && sendThisFrame; - // K-fix5 (2026-04-26): local-animation-cycle pacing. Visual rate - // should match the actual movement speed. For Forward+Run this is - // already runRate (it equals ForwardSpeed). For Backward+Run and - // Strafe+Run it must be runRate too even though the wire keeps - // those at 1.0. Picking runMul (already computed above) keeps the - // math in one place. + // R3-W6: the K-fix5 LocalAnimationSpeed synthesis is DELETED — the + // run pacing now comes from the ported machinery itself + // (apply_run_to_command scales the interpreted speed by my_run_rate; + // the DefaultSink dispatch plays the cycle at that speed — the same + // source remotes use). bool anyDirectional = input.Forward || input.Backward || input.StrafeLeft || input.StrafeRight; - float localAnimSpeed = (input.Run && anyDirectional) - ? (_weenie.InqRunRate(out float vrrAnim) ? vrrAnim : 1f) - : 1f; - // 2026-05-16 (issue #75) — server-initiated auto-walk drives - // the local animation cycle directly: - // - moving forward → WalkForward / RunForward (legs animate) - // - turn-first phase → TurnLeft / TurnRight (issue #69 fix) - // - aligned but pre-step / arrival → no override, falls to - // the user-input section's default (idle) - // UpdatePlayerAnimation reads LocalAnimationCommand + - // LocalAnimationSpeed; without these overrides the body - // translates/rotates without leg/arm animation. The motion - // cycle commands here flow into the animation sequencer - // ONLY — the wire-layer guard at GameWindow.cs:6419 prevents - // them from leaking to a user-MoveToState packet during - // auto-walk. - if (_autoWalkMovingForwardThisFrame) - { - if (_autoWalkInitiallyRunning && _weenie.InqRunRate(out float autoWalkRunRate)) - { - localAnimCmd = MotionCommand.RunForward; - localAnimSpeed = autoWalkRunRate; - } - else - { - localAnimCmd = MotionCommand.WalkForward; - localAnimSpeed = 1f; - } - } - else if (_autoWalkTurnDirectionThisFrame != 0) - { - localAnimCmd = _autoWalkTurnDirectionThisFrame > 0 - ? MotionCommand.TurnLeft - : MotionCommand.TurnRight; - localAnimSpeed = 1f; - } + // R4-V5: the #69 auto-walk turn-cycle edge synthesizer is DELETED — + // the MoveToManager's own aux-turn steering and TurnToHeading nodes + // dispatch TurnRight/TurnLeft through _DoMotion (the retail + // mechanism), so turn cycles during a moveto come from the same + // pipeline as everything else. return new MovementResult( Position: Position, @@ -1551,8 +1216,6 @@ public sealed class PlayerMovementController // who then animated walk + dead-reckoned at walk speed while the // server position moved at run speed — visible as observer lag. IsRunning: input.Run && anyDirectional, - LocalAnimationCommand: localAnimCmd, - LocalAnimationSpeed: localAnimSpeed, JustLanded: justLanded, JumpExtent: outJumpExtent, JumpVelocity: outJumpVelocity); diff --git a/src/AcDream.App/Physics/RemotePhysicsUpdater.cs b/src/AcDream.App/Physics/RemotePhysicsUpdater.cs new file mode 100644 index 00000000..ef0d2b13 --- /dev/null +++ b/src/AcDream.App/Physics/RemotePhysicsUpdater.cs @@ -0,0 +1,619 @@ +using RemoteMotion = AcDream.App.Rendering.GameWindow.RemoteMotion; +using AnimatedEntity = AcDream.App.Rendering.GameWindow.AnimatedEntity; + +namespace AcDream.App.Physics; + +/// +/// #184 Slice 2a — the per-remote dead-reckoning physics tick, extracted +/// verbatim from GameWindow.TickAnimations (Code Structure Rule 1: no +/// new feature bodies in the >10k-line GameWindow). One instance is +/// owned by GameWindow and called once per animated remote entity per +/// frame, from inside the same guard the body used to live under +/// (ae.Sequencer != null && serverGuid != 0 && serverGuid != _playerServerGuid +/// && rm.LastServerPosTime > 0). +/// +/// Slice 2a extracted this verbatim (fork intact). Slice 2b then COLLAPSED +/// the player/NPC fork: the former Path A (grounded PLAYER remotes advanced by the +/// interp catch-up with the sweep deliberately OMITTED, per the now-retired issue +/// #40 premise) is gone — every remote now runs the SAME catch-up + +/// ResolveWithTransition sweep + shadow-follows-resolved, so packed PLAYER +/// remotes de-overlap exactly like NPCs (retail UpdateObjectInternal +/// 0x005156b0 has no player/remote fork). The only surviving player/NPC split is +/// the omega handling (players keep the ObservedOmega||seqOmega world-frame +/// fallback; NPCs + airborne bodies use ObservedOmega-only body-frame) and +/// the !IsPlayerGuid-gated stale-velocity anim-cycle stop. See +/// docs/research/2026-07-07-184-slice2-unify-extract-handoff.md. +/// +/// Shared helpers that GameWindow also calls elsewhere are injected: +/// GetSetupCylinder (a general Setup-dimension helper with ~9 callers, +/// incl. the local player's own cylinder — kept on GameWindow) and +/// ApplyServerControlledVelocityCycle (anim-cycle selection, also called +/// from the UP handler) arrive as delegates. SyncRemoteShadowToBody +/// (remote-physics-specific) moved here and is called back from the UP-branch +/// tail; ApplyPositionManagerDelta / TickRemoteMoveTo had no other +/// callers and moved here outright. +/// +internal sealed class RemotePhysicsUpdater +{ + // Moved from GameWindow (#184 Slice 2a — the DR tick was its only caller). + private const double ServerControlledVelocityStaleSeconds = 0.60; + + private readonly AcDream.Core.Physics.PhysicsEngine _physicsEngine; + private readonly System.Func _getSetupCylinder; + private readonly System.Action _applyServerControlledVelocityCycle; + + internal RemotePhysicsUpdater( + AcDream.Core.Physics.PhysicsEngine physicsEngine, + System.Func getSetupCylinder, + System.Action applyServerControlledVelocityCycle) + { + _physicsEngine = physicsEngine; + _getSetupCylinder = getSetupCylinder; + _applyServerControlledVelocityCycle = applyServerControlledVelocityCycle; + } + + // Duplicated one-liner (GameWindow keeps its own copy — many callers there). + private static bool IsPlayerGuid(uint guid) => (guid & 0xFF000000u) == 0x50000000u; + + /// + /// #184 Slice 2a — the per-remote DR tick (retail UpdateObjectInternal + /// shape), verbatim from the former GameWindow.TickAnimations guard + /// body. serverGuid + the entity id derive from + /// .Entity; / + /// are passed per-call (they change on streaming recentre — never snapshot + /// them in the constructor). + /// + public void Tick(RemoteMotion rm, AnimatedEntity ae, float dt, int liveCenterX, int liveCenterY) + { + uint serverGuid = ae.Entity.ServerGuid; + // R5-V2: retail UpdateObjectInternal ticks TargetManager:: + // HandleTargetting UNCONDITIONALLY per entity, BEFORE the + // movement managers' UseTime. This is where this entity, as a + // watched target, pushes its position to its voyeurs (any entity + // moving-to it), and where its own target-info staleness times + // out. Runs for every remote regardless of the grounded/airborne + // branch below (which drive MoveToManager.UseTime via + // TickRemoteMoveTo). No-op for entities with no target + no voyeurs. + rm.Host?.HandleTargetting(); + + // #184 Slice 2b — the UNIFIED per-remote tick. The former Path A + // (grounded PLAYER remotes: interp catch-up with the ResolveWithTransition + // sweep OMITTED, per the now-retired issue-#40 "collision is the sender's + // problem" premise) is GONE — every remote now runs the SAME catch-up + + // sweep + shadow-follows-resolved, so packed PLAYER remotes de-overlap + // exactly like NPCs. Retail's UpdateObjectInternal (0x005156b0) has NO + // player/remote fork; the only surviving player/NPC split is the omega + // handling (Step 2 below) and the !IsPlayerGuid-gated anim-cycle stop. + // + // Stop detection stays explicit on packet receipt (UpdateMotion + // ForwardCommand cleared -> Ready; UpdatePosition HasVelocity cleared -> + // StopCompletely). Mirrors retail update_object -> UpdatePositionInternal + // -> UpdatePhysicsInternal (FUN_00515020 / FUN_00513730 / FUN_005111D0). + // The bare block scopes this update's locals (formerly the else body). + { + double nowSec = (System.DateTime.UtcNow - System.DateTime.UnixEpoch).TotalSeconds; + + // Step 1: re-apply current motion commands → body.Velocity. + // Forces OnWalkable + Contact so the gate in apply_current_movement + // always succeeds (remotes are server-authoritative; we don't + // simulate airborne physics for them). + // + // K-fix9 (2026-04-26): SKIP this when the remote is airborne. + // Otherwise the force-OnWalkable + apply_current_movement + // path stomps the +Z velocity we set in OnLiveVectorUpdated, + // and gravity never gets to integrate the arc. The airborne + // body keeps the launch velocity from the VectorUpdate; + // UpdatePhysicsInternal below applies gravity each tick; + // the next UpdatePosition snaps to the new ground location + // and re-grounds. + if (!rm.Airborne) + { + rm.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Contact + | AcDream.Core.Physics.TransientStateFlags.OnWalkable + | AcDream.Core.Physics.TransientStateFlags.Active; + + // #184 (2026-07-07): a grounded remote carries NO translation + // velocity. Its per-tick movement is the interp CATCH-UP toward + // the MoveOrTeleport-queued server waypoint (computed at the + // sticky-compose site below), which the KEPT ResolveWithTransition + // sweep de-overlaps against neighbours — and the resolved position + // is written back into the SHADOW (below) so the de-overlap + // persists and neighbours collide against the resolved body, not + // the raw server pos. This REPLACES the old synth-velocity model + // (get_state_velocity / SERVERVEL Body.Velocity = ServerVelocity): + // retail's UpdateObjectInternal (0x005156b0) has NO synth-velocity + // leg — a remote translates by adjust_offset and the UP is a gentle + // target. As of #184 Slice 2b this grounded model is the SINGLE + // remote path (players + NPCs) — retail has no fork. + rm.Body.Velocity = System.Numerics.Vector3.Zero; + + // Stale server-velocity → stop the locomotion CYCLE (the legs). + // ANIM ONLY — translation is the catch-up. Kept verbatim (same + // !moveToArmed && !stickyArmed gate) from the old SERVERVEL branch + // so a scripted-path NPC that stops server-side drops out of its + // walk/run cycle; ApplyServerControlledVelocityCycle selects the + // anim from ServerVelocity, independent of Body.Velocity. + bool moveToArmed = rm.MoveTo is + { MovementTypeState: not AcDream.Core.Physics.MovementType.Invalid }; + bool stickyArmed = + (rm.Host?.PositionManager.GetStickyObjectId() ?? 0u) != 0u; + if (!IsPlayerGuid(serverGuid) && rm.HasServerVelocity + && !moveToArmed && !stickyArmed) + { + double velocityAge = nowSec - rm.LastServerPosTime; + if (velocityAge > ServerControlledVelocityStaleSeconds) + { + rm.ServerVelocity = System.Numerics.Vector3.Zero; + rm.HasServerVelocity = false; + _applyServerControlledVelocityCycle( + serverGuid, + ae, + rm, + System.Numerics.Vector3.Zero); + } + } + + // R4-V4: tick the MoveToManager UNCONDITIONALLY (retail + // MovementManager::UseTime per tick, UpdateObjectInternal call + // @0x00515998) — UseTime runs HandleMoveToPosition / + // HandleTurnToHeading (steering + arrival + fail-distance), + // dispatching its per-node locomotion (turn / RunForward) through + // the sink (the LEGS). Position comes from the catch-up; legs from + // this per-node dispatch + the funnel. The #170-deleted per-frame + // apply_current_movement is NOT reintroduced. + TickRemoteMoveTo(rm); + } + else + { + // Airborne — keep Active flag (so UpdatePhysicsInternal + // doesn't early-return) but DON'T set Contact / OnWalkable. + rm.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Active; + } + + // Step 2: integrate rotation manually per tick. We can't + // rely on PhysicsBody.update_object here — its MinQuantum + // gate (1/30 s) causes it to SKIP integration when our + // 60fps render dt (~0.016s) is below the quantum, meaning + // rotation never advances. Measured snap per UP was ~129° + // = the full expected 1s × 2.24 rad/s, confirming zero + // between-tick rotation. + // + // Manual integration matches retail's FUN_005256b0 + // apply_physics (Orientation *= quat(ω × dt)). Use + // ObservedOmega derived from server UP rotation deltas so + // the rate exactly matches server physics — hard-snap on + // next UP becomes invisible by construction. + // #184 Slice 2b: PLAYERS keep the ObservedOmega||seqOmega fallback + + // world-frame (pre-multiply, Concatenate) application inherited from the + // former Path A — a circling player sends RunForward+TurnLeft on ONE UM + // whose RunForward cycle synthesises zero omega, so ObservedOmega (from + // the wire TurnCommand) must carry the turn or the body would not rotate + // between UPs ("rectangle when running circles"). NPCs + AIRBORNE bodies + // keep ObservedOmega-only, body-frame (post-multiply, Multiply) — a + // seqOmega fallback would change NPC turning (handoff 4.1), so the split + // is preserved. For an upright body + a yaw (world-Z) omega the two + // multiplication orders commute, so this fork is faithful, not cosmetic. + // calc_acceleration zeroes Body.Omega for grounded bodies before + // UpdatePhysicsInternal; the explicit zero here covers the airborne case + // (a wire-set Body.Omega would otherwise double-integrate on top of the + // manual rotation). + rm.Body.Omega = System.Numerics.Vector3.Zero; + if (IsPlayerGuid(serverGuid) && !rm.Airborne) + { + System.Numerics.Vector3 seqOmega = ae.Sequencer?.CurrentOmega + ?? System.Numerics.Vector3.Zero; + System.Numerics.Vector3 omegaToApply = + rm.ObservedOmega.LengthSquared() > 1e-9f ? rm.ObservedOmega : seqOmega; + if (omegaToApply.LengthSquared() > 1e-9f) + { + float angleDelta = omegaToApply.Length() * (float)dt; + System.Numerics.Vector3 axis = System.Numerics.Vector3.Normalize(omegaToApply); + var rot = System.Numerics.Quaternion.CreateFromAxisAngle(axis, angleDelta); + rm.Body.Orientation = System.Numerics.Quaternion.Normalize( + System.Numerics.Quaternion.Concatenate(rm.Body.Orientation, rot)); + } + } + else if (rm.ObservedOmega.LengthSquared() > 1e-8f) + { + float omegaMag = rm.ObservedOmega.Length(); + var axis = rm.ObservedOmega / omegaMag; + float angle = omegaMag * dt; + var deltaRot = System.Numerics.Quaternion.CreateFromAxisAngle(axis, angle); + rm.Body.Orientation = System.Numerics.Quaternion.Normalize( + System.Numerics.Quaternion.Multiply(rm.Body.Orientation, deltaRot)); + } + + // Step 3: integrate physics — retail FUN_005111D0 + // UpdatePhysicsInternal. Pure Euler: + // position += velocity × dt + 0.5 × accel × dt² + // + // Call UpdatePhysicsInternal DIRECTLY rather than via + // PhysicsBody.update_object (FUN_00515020). update_object gates + // on MinQuantum = 1/30s: at our 60fps render tick (~16ms), + // deltaTime < MinQuantum → early return AND LastUpdateTime is + // NOT advanced. Net effect: position never integrates between + // UpdatePositions and the only Body.Position changes come + // from the UP hard-snap, producing a visible teleport-stride + // on slopes (the "staircase" the user reported). + // + // PlayerMovementController.cs:358 calls UpdatePhysicsInternal + // directly for the same reason. Remote motion mirrors that. + // Omega is already integrated manually above, so we zero it + // here to prevent UpdatePhysicsInternal's own omega pass from + // double-integrating. + var preIntegratePos = rm.Body.Position; + // R5-V3 (#171) + #184 (2026-07-07): retail chains Interpolation → + // Sticky over ONE shared delta frame (PositionManager::adjust_offset + // 0x00555190), composed BEFORE UpdatePhysicsInternal + the transition + // sweep so collision resolves whichever movement won (preIntegratePos + // captured first — the sweep covers it). + // • GROUNDED: the interp CATCH-UP SEEDS the frame (world→local) — + // the movement source is the adjust_offset walk toward the + // MoveOrTeleport-queued server waypoint, exactly like Path A + // (:10173). StickyManager::adjust_offset then OVERWRITES the + // Origin when armed (0x00555430 ASSIGNS m_fOrigin — the REPLACE + // dichotomy), so a stuck monster still steers via #171. + // • AIRBORNE: seed an EMPTY frame (no catch-up — the arc integrates + // from velocity + gravity, unchanged). + // Body.Velocity is 0 when grounded (set above), so UpdatePhysicsInternal + // adds no translation on top of the catch-up — no double-move. + if (rm.Host is { } npcHost) + { + AcDream.Core.Physics.Motion.MotionDeltaFrame pmDelta; + if (!rm.Airborne) + { + System.Numerics.Vector3 seqVelNpc = ae.Sequencer?.CurrentVelocity + ?? System.Numerics.Vector3.Zero; + float maxSpeedNpc = rm.Motion.GetMaxSpeed(); + System.Numerics.Vector3? terrainNormalNpc = + _physicsEngine.SampleTerrainNormal( + rm.Body.Position.X, rm.Body.Position.Y); + System.Numerics.Vector3 offsetNpc = rm.Position.ComputeOffset( + dt: (double)dt, + currentBodyPosition: rm.Body.Position, + seqVel: seqVelNpc, + ori: rm.Body.Orientation, + interp: rm.Interp, + maxSpeed: maxSpeedNpc, + terrainNormal: terrainNormalNpc); + pmDelta = new AcDream.Core.Physics.Motion.MotionDeltaFrame + { + Origin = AcDream.Core.Physics.Motion.MoveToMath.GlobalToLocalVec( + rm.Body.Orientation, offsetNpc), + }; + } + else + { + pmDelta = new AcDream.Core.Physics.Motion.MotionDeltaFrame(); + } + npcHost.PositionManager.AdjustOffset(pmDelta, dt); + ApplyPositionManagerDelta(rm.Body, pmDelta); + } + else if (!rm.Airborne) + { + // No PositionManager host yet (pre-binding): apply the catch-up + // directly, matching Path A's fallback (:10202). + System.Numerics.Vector3 seqVelNpc = ae.Sequencer?.CurrentVelocity + ?? System.Numerics.Vector3.Zero; + float maxSpeedNpc = rm.Motion.GetMaxSpeed(); + System.Numerics.Vector3? terrainNormalNpc = + _physicsEngine.SampleTerrainNormal( + rm.Body.Position.X, rm.Body.Position.Y); + rm.Body.Position += rm.Position.ComputeOffset( + dt: (double)dt, + currentBodyPosition: rm.Body.Position, + seqVel: seqVelNpc, + ori: rm.Body.Orientation, + interp: rm.Interp, + maxSpeed: maxSpeedNpc, + terrainNormal: terrainNormalNpc); + } + rm.Body.calc_acceleration(); + rm.Body.UpdatePhysicsInternal(dt); + var postIntegratePos = rm.Body.Position; + + // Step 4: collision sweep — retail FUN_00514B90 → + // FUN_005148A0 → Transition::FindTransitionalPosition. + // Projects the sphere from preIntegratePos to postIntegratePos + // through the BSP + terrain, resolving: + // - terrain Z snap along the slope (fixes the "staircase" where + // horizontal Euler motion up a slope sinks into rising ground + // until the next UP pops it up) + // - indoor BSP walls (via the 6-path dispatcher in BSPQuery) + // - object collisions via ShadowObjectRegistry + // - step-up / step-down against walkable ledges + // ResolveWithTransition is the same call PlayerMovementController + // uses for the local player; remotes now get the full retail + // treatment between UpdatePositions instead of pure kinematics. + // + // Skipped when rm.CellId == 0 (no UP landed yet — can't build + // a SpherePath without a starting cell). One-frame grace until + // the first UP arrives; harmless because the entity is + // server-freshly-spawned at a valid Z anyway. + if (rm.CellId != 0 && _physicsEngine.LandblockCount > 0) + { + // #184 Slice 3 (2026-07-07): Setup-DERIVED mover sphere so + // creatures de-overlap at their TRUE radii (a big monster + // spreads wider, a small one tighter), not the hardcoded + // human 0.48/1.835. GetSetupCylinder returns (setup.Radius, + // setup.Height) × ObjScale — the creature's own dat Setup + // scaled by its wire ObjScale, the same source the local + // player + moveto/sticky use, and consistent with the + // spawn-time shadow registration's entScale. Retail seeds + // the transition from the object's own Setup sphere list × + // m_scale (CPhysicsObj::transition 0x00512dc0 → init_sphere; + // ObjScale from set_description 0x00514f40). This narrows + // TS-46 (remotes no longer use human dims); the two-scalar + // API is still a lossy stand-in for retail's full (≤2) + // sphere list, and stepUp/stepDown stay 0.4 (retail derives + // those from the Setup too — an adjacent divergence left as-is). + // Fallback to the human capsule for a shapeless / unresolvable + // Setup (GetSetupCylinder returns (0,0)); a zero radius would + // degenerate the sweep. + var (deR, deH) = _getSetupCylinder(serverGuid, ae.Entity); + if (deR < 0.05f) { deR = 0.48f; deH = 1.835f; } + var resolveResult = _physicsEngine.ResolveWithTransition( + preIntegratePos, postIntegratePos, rm.CellId, + sphereRadius: deR, + sphereHeight: deH, + stepUpHeight: 0.4f, // L.2.3a: retail human-scale, was 2.0f + stepDownHeight: 0.4f, // L.2.3a: retail human-scale, was 0.04f + // K-fix9 (2026-04-26): mirror the K-fix7 gate — + // airborne remotes must NOT pre-seed the + // ContactPlane, otherwise AdjustOffset's snap-to-plane + // branch zeroes the +Z offset every step (same bug + // we hit on the local jump). + isOnGround: !rm.Airborne, + body: rm.Body, // persist ContactPlane across frames for slope tracking + // Retail default physics state includes EdgeSlide; remote DR + // should exercise the same edge/cliff branch as local movement. + // #184 Slice 2b: a remote PLAYER mover ALSO carries IsPlayer, so + // CollisionExemption's PvP block fires exactly as it does for the + // LOCAL player (PlayerMovementController :920) — two non-PK players + // WALK THROUGH each other (retail sets IsPlayer on every object's + // own transition via OBJECTINFO::init 0x0050cf30 `state |= 0x100` + // from its weenie IsPlayer(); FindObjCollisions pc:276812 exempts a + // non-PK player pair). Without IsPlayer the mover would de-overlap + // two players — MORE solid than retail (you can stand inside another + // non-PK player in AC). Players still COLLIDE with monsters (target + // not IsPlayer → no exemption) + terrain + walls. PK/PKLite/ + // Impenetrable are NOT plumbed onto the remote mover yet, so a PK + // pair walks through where retail collides — the SAME M1.5 gap the + // local player carries (see TS-23; PlayerDescription PK status + // unparsed). + moverFlags: IsPlayerGuid(serverGuid) + ? AcDream.Core.Physics.ObjectInfoState.IsPlayer + | AcDream.Core.Physics.ObjectInfoState.EdgeSlide + : AcDream.Core.Physics.ObjectInfoState.EdgeSlide, + // Fix #42 (2026-05-05): skip the moving remote's + // own ShadowEntry. _animatedEntities is keyed by + // entity.Id so kv.Key matches the EntityId the + // ShadowObjectRegistry has for this remote. + // Without this, the airborne sweep collides with + // the remote's own cylinder and produces ~1m of + // horizontal drift on the first jump frame + // (validated by [SWEEP-OBJ] traces). + movingEntityId: ae.Entity.Id); + + rm.Body.Position = resolveResult.Position; + if (resolveResult.CellId != 0) + rm.CellId = resolveResult.CellId; + + // #184 (2026-07-07) — SHADOW-FOLLOWS-RESOLVED (the load-bearing + // de-overlap fix, proven in RemoteDeOverlapMechanismTests). Retail + // re-registers a moved object's shadow every transition step + // (SetPositionInternal → remove/add_shadows_to_cells, Ghidra + // 0x00515330) so its m_position — the RESOLVED position — is what + // OTHER creatures collide against. acdream's shadow otherwise only + // syncs to the RAW server pos on UpdatePosition, so neighbours would + // de-overlap against each other's OVERLAPPING shadows and any spread + // would be discarded on the next UP (never accumulating), AND the + // player would collide with a shadow offset from where the monster + // renders (the reverted attempt's "stuck on an invisible monster"). + // Syncing the shadow to the resolved body every tick makes the + // de-overlap PERSIST and keeps collision == render. Re-flood is cheap + // MOVEMENT-GATED (#184 review): re-flood only when the resolved + // body moved > ~1 cm since the last shadow registration. This is + // SAFE now that #184 Slice 2b RETIRED the per-UP raw-pos sync for + // players too — every remote's shadow (player + NPC) is written ONLY + // by this loop + the UP-branch tail, both to the resolved body, so a + // net-stationary (de-overlapped, sweep- + // blocked) creature keeps its correct shadow and never re-floods, + // while a moving/de-overlapping crowd (which moves every tick) still + // syncs every tick. Bounds the per-tick RegisterMultiPart flood cost + // to actually-moving remotes — the perf risk the review flagged for + // a packed town. (In-place shadow-move + cell-relink-on-change is a + // further optimization if profiling still shows churn.) + if (System.Numerics.Vector3.DistanceSquared( + rm.Body.Position, rm.LastShadowSyncPos) > 1e-4f) + { + SyncRemoteShadowToBody(ae.Entity.Id, rm, liveCenterX, liveCenterY); + } + + // #173 (2026-07-05): retail CPhysicsObj::handle_all_collisions + // (pc:282699-282715) runs after EVERY SetPositionInternal — + // remote objects included; a VectorUpdate-launched jump arc + // is ordinary object physics in retail. acdream ported the + // velocity reflection for the LOCAL player only (L.3a, + // PlayerMovementController ~:940), so a remote jumping into + // a dungeon ceiling had its POSITION pinned by the sweep + // while its +Z velocity kept integrating — the char hovered + // at the roof until gravity burned the arc off, landing + // late (user report, 0x0007 dungeon). Mirror the local + // site exactly: + // v_new = v − (1 + elasticity)·dot(v, n)·n + // with the AD-25 suppression (bounce only when airborne + // before AND after — corridor slides and landings don't + // reflect; the landing snap below keeps its + // `Velocity.Z <= 0` gate intact). Inelastic movers + // (missiles, later) zero out instead. + if (resolveResult.CollisionNormalValid) + { + bool prevOnWalkable = rm.Body.OnWalkable; + bool nowOnWalkable = resolveResult.IsOnGround; + bool applyBounce = rm.Body.State.HasFlag( + AcDream.Core.Physics.PhysicsStateFlags.Sledding) + ? !(prevOnWalkable && nowOnWalkable) + : (!prevOnWalkable && !nowOnWalkable); + if (applyBounce) + { + if (rm.Body.State.HasFlag( + AcDream.Core.Physics.PhysicsStateFlags.Inelastic)) + { + rm.Body.Velocity = System.Numerics.Vector3.Zero; + } + else + { + var vRem = rm.Body.Velocity; + var nRem = resolveResult.CollisionNormal; + float dotVN = System.Numerics.Vector3.Dot(vRem, nRem); + if (dotVN < 0f) + { + rm.Body.Velocity = + vRem + nRem * (-(dotVN * (rm.Body.Elasticity + 1f))); + if (Environment.GetEnvironmentVariable("ACDREAM_DUMP_MOTION") == "1") + Console.WriteLine( + $"VU.bounce guid=0x{serverGuid:X8} n=({nRem.X:F2},{nRem.Y:F2},{nRem.Z:F2}) vZ {vRem.Z:F2}->{rm.Body.Velocity.Z:F2}"); + } + } + } + } + + // K-fix15 (2026-04-26): post-resolve landing + // detection for airborne remotes. Mirrors + // PlayerMovementController's local-player landing + // path: when the resolver says we're on ground AND + // velocity is no longer pointing up, transition + // back to grounded — clear Airborne, restore + // Contact + OnWalkable, remove Gravity, zero any + // residual downward velocity, and trigger + // HitGround so the sequencer can swap from + // Falling → idle/locomotion. Without this, an + // airborne remote falls through the floor (gravity + // keeps building Velocity.Z negative until the + // sphere-sweep clamps each frame, but Airborne + // stays true forever). + if (rm.Airborne + && resolveResult.IsOnGround + && rm.Body.Velocity.Z <= 0f) + { + rm.Airborne = false; + // #184 (2026-07-07): clear the interp queue on landing (mirrors + // the player-remote landing). Airborne UPs hard-snap and never + // Enqueue, so any pre-jump waypoints are stale; without this the + // first grounded catch-up after touchdown chases them backward. + rm.Interp.Clear(); + rm.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Contact + | AcDream.Core.Physics.TransientStateFlags.OnWalkable; + rm.Body.Velocity = new System.Numerics.Vector3( + rm.Body.Velocity.X, rm.Body.Velocity.Y, 0f); + // #161: HitGround MUST run with the Gravity state + // bit still set — CMotionInterp::HitGround + // (0x00528ac0) gates on state&0x400 (retail never + // clears GRAVITY on landing; it's a persistent + // object property). Clearing it first made this + // re-apply a silent no-op, which is why the + // falling pose never exited. The re-apply + // dispatches the PRESERVED pre-fall forward + // command through the funnel → the motion table + // plays the Falling→X landing link. (The old + // K-fix17 forced SetCycle is deleted: it read the + // then-clobbered InterpretedState.ForwardCommand + // — 0x40000015 — and re-set the very Falling + // cycle it meant to clear.) + // R4-V5 (closes the V4 wiring-contract gap the + // adversarial review caught): retail order — + // minterp first, then moveto (MovementManager:: + // HitGround 0x00524300, §2d — the R5-V5 facade + // relay). Re-arms a moveto suspended by the + // airborne UseTime contact gate; without it a + // chasing NPC that lands stalls until ACE's + // ~1 Hz re-emit. + rm.Movement.HitGround(); + // DR bookkeeping only (partner of the jump-start + // `State |= Gravity`): stops the per-tick gravity + // integration for the grounded body. + rm.Body.State &= ~AcDream.Core.Physics.PhysicsStateFlags.Gravity; + + if (Environment.GetEnvironmentVariable("ACDREAM_DUMP_MOTION") == "1") + Console.WriteLine($"VU.land guid=0x{serverGuid:X8} Z={rm.Body.Position.Z:F2}"); + } + } + + ae.Entity.SetPosition(rm.Body.Position); // A.5 T18: SetPosition propagates AabbDirty + if (rm.CellId != 0) + ae.Entity.ParentCellId = rm.CellId; + ae.Entity.Rotation = rm.Body.Orientation; + } + + // R5-V3 (#171): retail UpdateObjectInternal tail — + // PositionManager::UseTime (0x005156b0, call @0x005159b3, + // right after CPartArray::HandleMovement, UNCONDITIONAL for + // every entity in both grounded and airborne branches): the + // sticky 1 s lease watchdog (StickyManager::UseTime + // 0x00555610 — a stick not re-issued by a fresh server arm + // within 1 s tears itself down). No-op while nothing is stuck. + rm.Host?.PositionManager.UseTime(); + } + + /// + /// R4-V5 / R5-V2: the per-tick + /// drive (retail MovementManager::UseTime 0x005242f0 — the moveto + /// side's steering, arrival, fail-distance; R5-V5 facade relay). Moved from + /// GameWindow (#184 Slice 2a); the DR tick is its only caller. + /// + private static void TickRemoteMoveTo(RemoteMotion rm) + { + rm.Movement.UseTime(); + } + + /// + /// R5-V3 (#171): apply a + /// written by PositionManager.AdjustOffset onto a body — acdream's + /// stand-in for retail's Frame::combine in + /// CPhysicsObj::UpdatePositionInternal (0x00512c30, combine + /// @0x00512d22). The delta's Origin is mover-LOCAL (sticky writes + /// globaltolocalvec output — 0x00555430), so combining = rotating it + /// out by the body orientation. An untouched (identity) rotation means "no + /// turn"; the P5 pin (identity quaternion = heading 0) makes compass addition + /// the exact frame-combine here. Moved from GameWindow (#184 Slice 2a); the + /// DR tick is its only caller. + /// + private static void ApplyPositionManagerDelta( + AcDream.Core.Physics.PhysicsBody body, + AcDream.Core.Physics.Motion.MotionDeltaFrame delta) + { + if (delta.Origin != System.Numerics.Vector3.Zero) + body.Position += System.Numerics.Vector3.Transform(delta.Origin, body.Orientation); + if (!delta.Orientation.IsIdentity) + body.Orientation = AcDream.Core.Physics.Motion.MoveToMath.SetHeading( + body.Orientation, + AcDream.Core.Physics.Motion.MoveToMath.GetHeading(body.Orientation) + + delta.GetHeading()); + } + + /// + /// #184 — shadow-follows-resolved. Re-register a remote creature's collision + /// SHADOW at its RESOLVED body position, so OTHER creatures (and the player) + /// de-overlap / collide against where the monster actually IS (== where it + /// renders), not the raw overlapping server position. Retail re-registers a + /// moved object's shadow every accepted transition step (SetPositionInternal + /// → remove/add_shadows_to_cells, Ghidra 0x00515330). The streaming centre is + /// passed in (/) + /// rather than snapshotted, since it moves on recentre. Updates + /// so callers can movement-gate. + /// Moved from GameWindow (#184 Slice 2a); called by the DR tick AND the NPC + /// UP-branch tail. + /// + public void SyncRemoteShadowToBody(uint entityId, RemoteMotion rm, int liveCenterX, int liveCenterY) + { + int shLbX = (int)((rm.CellId >> 24) & 0xFFu); + int shLbY = (int)((rm.CellId >> 16) & 0xFFu); + float shOffX = (shLbX - liveCenterX) * 192f; + float shOffY = (shLbY - liveCenterY) * 192f; + _physicsEngine.ShadowObjects.UpdatePosition( + entityId, rm.Body.Position, rm.Body.Orientation, + shOffX, shOffY, rm.CellId, seedCellId: rm.CellId); + rm.LastShadowSyncPos = rm.Body.Position; + } +} diff --git a/src/AcDream.App/Rendering/EntityPhysicsHost.cs b/src/AcDream.App/Rendering/EntityPhysicsHost.cs new file mode 100644 index 00000000..151cd0a8 --- /dev/null +++ b/src/AcDream.App/Rendering/EntityPhysicsHost.cs @@ -0,0 +1,149 @@ +using System; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; + +namespace AcDream.App.Rendering; + +/// +/// R5-V2 — the App-side per entity: acdream's +/// stand-in for retail's CPhysicsObj as the movement managers see it. +/// One is built per entity (a remote RemoteMotion or the local player) +/// in GameWindow.EnsureRemoteMotionBindings / EnterPlayerModeNow +/// and registered in GameWindow._physicsHosts (guid → host), so +/// can resolve OTHER entities' hosts — the +/// cross-entity delivery path the voyeur system +/// needs. +/// +/// Owns a (retail +/// CPhysicsObj::target_manager). Its set_target/clear_target/ +/// add_voyeur/remove_voyeur/receive_target_update seams +/// forward to it exactly as retail's CPhysicsObj does; the movement managers' +/// target seams are repointed here, replacing the AP-79 poll adapter. The +/// per-entity accessors (position/velocity/radius/contact/clocks) and the +/// fan-out are injected by GameWindow so this +/// class stays free of GameWindow's internals (code-structure rule #1). +/// +/// R5-V3: owns a too (retail +/// CPhysicsObj::position_manager — retail creates it lazily via +/// get_position_manager; acdream constructs it eagerly, which is +/// behaviorally identical because the empty facade no-ops until its first +/// StickTo/ConstrainTo). fans +/// deliveries to the injected MoveToManager fan FIRST, then the +/// PositionManager — retail CPhysicsObj::HandleUpdateTarget order +/// (0x00512bc0: MovementManager @0x00512bf0, PositionManager +/// @0x00512c1a). +/// +public sealed class EntityPhysicsHost : IPhysicsObjHost +{ + private readonly Func _getPosition; + private readonly Func _getVelocity; + private readonly Func _getRadius; + private readonly Func _inContact; + private readonly Func _minterpMaxSpeed; + private readonly Func _curTime; + private readonly Func _physicsTimerTime; + private readonly Func _getObjectA; + private readonly Action _handleUpdateTarget; + private readonly Action _interruptCurrentMovement; + private readonly TargetManager _targetManager; + + public EntityPhysicsHost( + uint id, + Func getPosition, + Func getVelocity, + Func getRadius, + Func inContact, + Func minterpMaxSpeed, + Func curTime, + Func physicsTimerTime, + Func getObjectA, + Action handleUpdateTarget, + Action interruptCurrentMovement) + { + Id = id; + _getPosition = getPosition ?? throw new ArgumentNullException(nameof(getPosition)); + _getVelocity = getVelocity ?? throw new ArgumentNullException(nameof(getVelocity)); + _getRadius = getRadius ?? throw new ArgumentNullException(nameof(getRadius)); + _inContact = inContact ?? throw new ArgumentNullException(nameof(inContact)); + _minterpMaxSpeed = minterpMaxSpeed ?? throw new ArgumentNullException(nameof(minterpMaxSpeed)); + _curTime = curTime ?? throw new ArgumentNullException(nameof(curTime)); + _physicsTimerTime = physicsTimerTime ?? throw new ArgumentNullException(nameof(physicsTimerTime)); + _getObjectA = getObjectA ?? throw new ArgumentNullException(nameof(getObjectA)); + _handleUpdateTarget = handleUpdateTarget ?? throw new ArgumentNullException(nameof(handleUpdateTarget)); + _interruptCurrentMovement = interruptCurrentMovement + ?? throw new ArgumentNullException(nameof(interruptCurrentMovement)); + _targetManager = new TargetManager(this); + PositionManager = new PositionManager(this); + } + + // ── IPhysicsObjHost accessors ────────────────────────────────────────── + public uint Id { get; } + public Position Position => _getPosition(); + public Vector3 Velocity => _getVelocity(); + public float Radius => _getRadius(); + public bool InContact => _inContact(); + public float? MinterpMaxSpeed => _minterpMaxSpeed(); + public double CurTime => _curTime(); + public double PhysicsTimerTime => _physicsTimerTime(); + + /// The owned voyeur manager (retail + /// CPhysicsObj::target_manager). + public TargetManager TargetManager => _targetManager; + + /// R5-V3 — the owned facade (retail + /// CPhysicsObj::position_manager): sticky follow + (unarmed) + /// constraint leash. Seam targets: MoveToManager.StickTo/Unstick, + /// MotionInterpreter.UnstickFromObject, the per-tick + /// AdjustOffset/UseTime drivers. + public PositionManager PositionManager { get; } + + // ── IPhysicsObjHost fan-out / target-tracking seams ──────────────────── + public IPhysicsObjHost? GetObjectA(uint id) => _getObjectA(id); + + public void HandleUpdateTarget(TargetInfo info) + { + // Retail CPhysicsObj::HandleUpdateTarget (0x00512bc0) fan order: + // MovementManager (the injected MoveToManager fan) first, then + // PositionManager (@0x00512c1a — the R5-V3 sticky consumer). + _handleUpdateTarget(info); + PositionManager.HandleUpdateTarget(info); + } + public void InterruptCurrentMovement() => _interruptCurrentMovement(); + + public void SetTarget(uint contextId, uint objectId, float radius, double quantum) + => _targetManager.SetTarget(contextId, objectId, radius, quantum); + + public void ClearTarget() => _targetManager.ClearTarget(); + public void ReceiveTargetUpdate(TargetInfo info) => _targetManager.ReceiveUpdate(info); + public void AddVoyeur(uint watcherId, float radius, double quantum) + => _targetManager.AddVoyeur(watcherId, radius, quantum); + public void RemoveVoyeur(uint watcherId) => _targetManager.RemoveVoyeur(watcherId); + + // ── per-tick driver + lifecycle (called by GameWindow) ───────────────── + + /// Retail TargetManager::HandleTargetting — the per-tick + /// voyeur sweep (self-throttled to 0.5 s). Retail runs it unconditionally + /// for every entity in UpdateObjectInternal, BEFORE the movement + /// managers' UseTime. + public void HandleTargetting() => _targetManager.HandleTargetting(); + + /// Retail CPhysicsObj::exit_world's + /// TargetManager::NotifyVoyeurOfEvent(ExitWorld) — tell every + /// watcher of this entity that it left the world (they drop the + /// stick/moveto). Called on despawn before the host is removed from the + /// registry. + public void NotifyExitWorld() => _targetManager.NotifyVoyeurOfEvent(TargetStatus.ExitWorld); + + /// R5-V3 (#171): retail CPhysicsObj::teleport_hook's tail + /// (0x00514ed0 @0x00514f1b-0x00514f28) — TargetManager::ClearTarget + /// (drop this entity's OWN subscription) then + /// NotifyVoyeurOfEvent(Teleported) (every entity watching THIS one + /// drops its stick/moveto — StickyManager::HandleUpdateTarget's + /// non-Ok teardown path). Called after a teleport placement. + public void NotifyTeleported() + { + _targetManager.ClearTarget(); + _targetManager.NotifyVoyeurOfEvent(TargetStatus.Teleported); + } +} diff --git a/src/AcDream.App/Rendering/GameWindow.cs b/src/AcDream.App/Rendering/GameWindow.cs index b615c796..06e242e6 100644 --- a/src/AcDream.App/Rendering/GameWindow.cs +++ b/src/AcDream.App/Rendering/GameWindow.cs @@ -122,6 +122,11 @@ public sealed class GameWindow : IDisposable private readonly long[] _applyLockWaitSamples = new long[256]; private int _applyLockWaitSampleCursor; + // MP0 (2026-07-05): permanent frame profiler — one FrameBoundary call + // per OnRender + three stage scopes. All logic lives in + // AcDream.App.Diagnostics.FrameProfiler (structure rule 1). + private readonly AcDream.App.Diagnostics.FrameProfiler _frameProfiler = new(); + // Phase A.1: streaming fields replacing the one-shot _entities list. private AcDream.App.Streaming.LandblockStreamer? _streamer; private AcDream.App.Streaming.GpuWorldState _worldState = new(); @@ -146,6 +151,12 @@ public sealed class GameWindow : IDisposable // ConcurrentDictionary inside makes cross-thread access safe. private readonly AcDream.Core.Physics.PhysicsDataCache _physicsDataCache = new(); + // #184 Slice 2a: the per-remote dead-reckoning tick, extracted out of the + // >10k-line TickAnimations (Code Structure Rule 1). Assigned in the ctor + // once the injected shared helpers exist as method groups (GetSetupCylinder, + // ApplyServerControlledVelocityCycle). See RemotePhysicsUpdater. + private readonly AcDream.App.Physics.RemotePhysicsUpdater _remotePhysicsUpdater; + // Step 4: portal-based interior cell visibility. private readonly CellVisibility _cellVisibility = new(); @@ -247,6 +258,13 @@ public sealed class GameWindow : IDisposable /// private readonly Dictionary _animatedEntities = new(); + // MP-Alloc (2026-07-05): reusable per-frame snapshot of _animatedEntities.Keys. + // WbDrawDispatcher.WalkEntitiesInto treats null and an empty set identically + // (`animatedEntityIds is null || animatedEntityIds.Count == 0`), so this can + // always be a live (possibly empty) HashSet instead of `new`ing one every + // frame or passing null. + private readonly HashSet _animatedIdsScratch = new(); + /// /// Tier 1 cache (#53): per-entity classification results for static /// entities (those NOT in ). Conceptually @@ -258,7 +276,10 @@ public sealed class GameWindow : IDisposable /// private readonly AcDream.App.Rendering.Wb.EntityClassificationCache _classificationCache = new(); - private sealed class AnimatedEntity + // #184 Slice 2a: internal (was private) so the extracted + // RemotePhysicsUpdater in AcDream.App.Physics can take it by type. Matches + // RemoteMotion's existing internal visibility. + internal sealed class AnimatedEntity { public required AcDream.Core.World.WorldEntity Entity; public required DatReaderWriter.DBObjs.Setup Setup; @@ -277,6 +298,24 @@ public sealed class GameWindow : IDisposable public required IReadOnlyList<(uint GfxObjId, IReadOnlyDictionary? SurfaceOverrides)> PartTemplate; public float CurrFrame; // monotonically increasing within [LowFrame, HighFrame] public AcDream.Core.Physics.AnimationSequencer? Sequencer; + + /// + /// MP-Alloc (2026-07-05): reusable per-entity MeshRefs buffer. Every + /// animated entity (including idle NPCs on a breathe cycle) used to + /// get a fresh `List<MeshRef>(partCount)` reassigned to + /// every tick — + /// the old list became garbage every frame. This buffer is cleared + /// and refilled in place instead; Entity.MeshRefs is set to + /// this SAME list reference once it's populated (assigning the + /// unchanged reference back is a no-op cost-wise). Safe because + /// TickAnimations runs single-threaded to completion before any + /// draw-side consumer reads MeshRefs, and the only cross-frame + /// consumer (RefreshPaperdollDoll) takes an explicit + /// `new List<MeshRef>(pe.MeshRefs)` VALUE copy — MeshRef is a + /// readonly record struct, so that copy is unaffected by later + /// in-place mutation of this list. + /// + public readonly List MeshRefsScratch = new(); } private AcDream.Core.Physics.DatCollectionLoader? _animLoader; @@ -382,6 +421,16 @@ public sealed class GameWindow : IDisposable /// private readonly Dictionary _remoteDeadReckon = new(); + /// + /// L.2g S1 (DEV-6): per-entity inbound movement-event staleness gates, + /// keyed by server guid. Retail keeps these stamps on CPhysicsObj + /// (update_times); seeded from CreateObject's PhysicsDesc timestamp + /// block in , consulted at the + /// top of , dropped with the entity in + /// . + /// + private readonly Dictionary _motionSequenceGates = new(); + /// /// Per-remote-entity physics + motion stack — verbatim application of /// retail's client-side motion pipeline to every remote. Mirrors @@ -398,15 +447,40 @@ public sealed class GameWindow : IDisposable /// remote gets the same treatment as the local player. /// /// - private sealed class RemoteMotion + internal sealed class RemoteMotion // internal: the R2-Q5 sink callbacks (ObservedOmega seam) capture it { public AcDream.Core.Physics.PhysicsBody Body; - public AcDream.Core.Physics.MotionInterpreter Motion; + + /// R5-V5: retail CPhysicsObj::movement_manager — the + /// ONE per-entity owner of the interp + moveto pair (acclient.h + /// /* 3463 */). Constructed here with the interp; the + /// MoveToManager side arrives via MoveToFactory + + /// MakeMoveToManager() in EnsureRemoteMotionBindings. + /// / below are views of its + /// children (retail get_minterp-style access), kept so the + /// dozens of existing call sites read unchanged. + public AcDream.Core.Physics.Motion.MovementManager Movement; + + public AcDream.Core.Physics.MotionInterpreter Motion => Movement.Minterp; + /// R3-W4: the persistent per-remote dispatch sink (created + /// once by EnsureRemoteMotionBindings; also bound as + /// Motion.DefaultSink so LeaveGround/HitGround re-applies dispatch + /// cycles through the motion-table backend). + public AcDream.Core.Physics.Motion.MotionTableDispatchSink? Sink; /// Last UpdatePosition timestamp — drives body.update_object sub-stepping. public double LastServerPosTime; /// Last known server position — kept for diagnostics / HUD. public System.Numerics.Vector3 LastServerPos; /// + /// #184: the body position at which this remote's collision SHADOW was + /// last (re-)registered. The per-tick shadow-follows-resolved sync + /// (SyncRemoteShadowToBody) skips re-flooding when the body has + /// not moved > ε since this — a resting/idle-town crowd doesn't churn + /// the registry, while a moving/de-overlapping crowd re-registers every + /// tick. Sentinel Zero forces the first sync. + /// + public System.Numerics.Vector3 LastShadowSyncPos; + /// /// Latest server-authoritative velocity for NPC/monster smoothing. /// Prefer the HasVelocity vector from UpdatePosition; when ACE omits /// it for a server-controlled creature, derive it from consecutive @@ -414,6 +488,19 @@ public sealed class GameWindow : IDisposable /// public System.Numerics.Vector3 ServerVelocity; public bool HasServerVelocity; + + /// R4-V4: the entity's verbatim retail MoveToManager + /// (server-directed movement), constructed + seam-bound by + /// EnsureRemoteMotionBindings beside the R2-Q5/R3 binds. R5-V5: + /// owned by ; this is the child view. + public AcDream.Core.Physics.Motion.MoveToManager? MoveTo => Movement.MoveTo; + + // R5-V2: the entity's CPhysicsObj stand-in — owns the TargetManager + // voyeur system (retail CPhysicsObj::target_manager). Replaces the + // AP-79 TrackedTarget* poll fields: the MoveToManager's set_target/ + // clear_target/quantum seams route here, HandleTargetting ticks per + // frame, and OTHER entities resolve this one via GameWindow._physicsHosts. + public EntityPhysicsHost? Host; /// /// True while a server MoveToObject/MoveToPosition packet is the /// active locomotion source. Retail runs these through MoveToManager @@ -518,8 +605,8 @@ public sealed class GameWindow : IDisposable /// queue catch-up REPLACES anim when active; anim stands when queue /// is idle. /// - public AcDream.Core.Physics.PositionManager Position { get; } = - new AcDream.Core.Physics.PositionManager(); + public AcDream.Core.Physics.RemoteMotionCombiner Position { get; } = + new AcDream.Core.Physics.RemoteMotionCombiner(); /// /// Diagnostic-only (gated on ACDREAM_REMOTE_VEL_DIAG=1): the @@ -560,19 +647,6 @@ public sealed class GameWindow : IDisposable /// public float MaxSeqSpeedSinceLastUP; - /// - /// Seconds-since-epoch timestamp of the most recent UpdateMotion (UM) - /// for this remote. Used by the player-remote velocity-fallback cycle - /// refinement to skip refinement while a fresh UM is authoritative — - /// retail's outbound MoveToState gives us direction-explicit cycles - /// on direction-key changes (W press, W release, W↔S flip), and we - /// only want UP-derived velocity to refine the speed bucket within - /// a direction when no UM has arrived recently. Defaults to 0 - /// (epoch) so the first UP after spawn is allowed to refine - /// immediately if velocity already differs from the spawn cycle. - /// - public double LastUMTime; - public RemoteMotion() { Body = new AcDream.Core.Physics.PhysicsBody @@ -586,8 +660,27 @@ public sealed class GameWindow : IDisposable TransientState = AcDream.Core.Physics.TransientStateFlags.Contact | AcDream.Core.Physics.TransientStateFlags.OnWalkable | AcDream.Core.Physics.TransientStateFlags.Active, + // R4-V5 door-swing fix: a RemoteMotion exists only for a + // WORLD entity — retail's physics_obj->cell is non-null the + // moment the object is placed. Without this, the interp's + // detached-object guard stripped every dispatched + // transition link (see PhysicsBody.InWorld). + InWorld = true, }; - Motion = new AcDream.Core.Physics.MotionInterpreter(Body); + // R5-V5: the interp is owned by the MovementManager facade + // (retail CPhysicsObj::movement_manager -> motion_interpreter). + // acdream constructs it eagerly here — retail's lazy-create + // window is never observable (see MovementManager's class doc). + Movement = new AcDream.Core.Physics.Motion.MovementManager( + new AcDream.Core.Physics.MotionInterpreter(Body) + { + // R4-V5 #160 fix: retail remotes carry a weenie whose + // InqRunRate FAILS, landing apply_run_to_command on + // my_run_rate (the M13 wire feed). A null weenie took the + // degenerate 1.0 branch — observer-side run movetos played + // and moved in slow motion. See RemoteWeenie. + WeenieObj = new AcDream.Core.Physics.RemoteWeenie(), + }); } } @@ -705,11 +798,35 @@ public sealed class GameWindow : IDisposable new AcDream.Core.World.WorldTimeService( AcDream.Core.World.SkyStateProvider.Default()); public readonly AcDream.Core.Lighting.LightManager Lighting = new(); + + // A7.L1 (2026-07-09) — last frame's rendered visible-cell set, fed into next + // frame's Lighting.BuildPointLightSnapshot scoping. One frame of latency + // (~16 ms) instead of a mid-DrawInside callback: DrawableCells only becomes + // known partway through DrawInside (after the flood + look-in merge), and the + // #176 correction already showed that rebuilding the light pool FROM a + // freshly-recomputed frame flood (the deleted RebuildScopedLights callback, + // c500912b) is a flicker mechanism. Reusing last frame's already-drawn set + // (MP-Alloc: reused HashSet, no per-frame alloc) decouples the light-scoping + // change from DrawInside's internals entirely. _lightPoolVisibleCellsValid is + // false until the first indoor frame completes, and is cleared on any + // outdoor-only frame so scoping fails open (unscoped) for one frame on + // re-entry rather than filtering by a stale dungeon's cell ids. + private readonly HashSet _lightPoolVisibleCells = new(); + private bool _lightPoolVisibleCellsValid; + public readonly AcDream.Core.World.WeatherSystem Weather = new(); // Wired into the hook router in OnLoad so SetLightHook fires // from the animation pipeline flip the matching LightSource.IsLit. private AcDream.Core.Lighting.LightingHookSink? _lightingSink; + // #188 — TransparentPartHook fires from the animation pipeline drive + // a per-(entity,part) translucency ramp; WbDrawDispatcher reads it + // per frame. Wired into the hook router in OnLoad, advanced once per + // frame in the main loop regardless of _animatedEntities membership + // (a fade must keep running even if its entity's one-shot cycle ends). + private readonly AcDream.Core.Rendering.TranslucencyFadeManager _translucencyFades = new(); + private AcDream.Core.Rendering.TranslucencyHookSink? _translucencySink; + // Phase G.1 sky renderer + shared UBO. Created once the GL context // exists in OnLoad; shared across every other renderer via // binding = 1 so terrain/mesh/instanced/sky all read the same @@ -741,8 +858,6 @@ public sealed class GameWindow : IDisposable private AcDream.App.Rendering.RetailChaseCamera? _retailChaseCamera; private bool _playerMode; private uint _playerServerGuid; - private uint? _playerCurrentAnimCommand; - private float _playerCurrentAnimSpeed = 1f; private uint? _playerMotionTableId; // server-sent MotionTable override for the player's character private MovementTruthOutbound? _lastMovementTruthOutbound; @@ -861,6 +976,26 @@ public sealed class GameWindow : IDisposable private AcDream.Core.Net.WorldSession? _liveSession; private int _liveCenterX; private int _liveCenterY; + // #192 (2026-07-09): true once the player's OWN spawn CreateObject has been + // received and processed — i.e. _liveCenterX/Y reflects a real, + // server-confirmed position, not the Holtburg startup placeholder. Gates + // streaming via StreamingReadinessGate.ShouldStream so no landblock is ever + // built around a still-guessed center in live mode. See + // AcDream.Core.World.StreamingReadinessGate for the full mechanism this + // closes (stale-centered geometry built during the InWorld-but-not-yet- + // located window, applied late once its build finished). + private bool _liveCenterKnown; + // Set by the login-spawn recenter (network thread) when the spawn landblock + // differs from the startup streaming center; consumed on the render thread + // in OnUpdateFrame to trigger StreamingController.ForceReloadWindow(). A far + // login-spawn moves the render origin just like an outdoor teleport, so the + // streaming region — bootstrapped around the stale startup center — must be + // rebuilt fresh around the spawn. Without this, RecenterTo treats the + // old/new window overlap as already-resident (MarkResidentFromBootstrap marks + // residence before the async loads land), leaving a permanent hole of + // resident-but-never-loaded landblocks where the player spawns — the + // cold-spawn "invisible player / world not loading" bug (2026-07-03). + private volatile bool _pendingForceReloadWindow; private uint _liveEntityIdCounter = 1_000_000u; // well above any dat-hydrated id // K-fix1 (2026-04-26): cached at startup so per-frame branches are @@ -929,8 +1064,23 @@ public sealed class GameWindow : IDisposable // far-range sends fire the wire packet immediately at SendUse/SendPickUp // time. Cleared before the deferred send fires — single-fire, no retry. private (uint Guid, bool IsPickup)? _pendingPostArrivalAction; + + // R5-V2: the local player's CPhysicsObj stand-in — owns the player's + // TargetManager voyeur system, registered in _physicsHosts so remote + // entities chasing the player resolve it. Replaces the AP-79 + // _playerMoveToTarget* poll fields. + private EntityPhysicsHost? _playerHost; + + // R5-V2: guid → per-entity IPhysicsObjHost registry (retail's + // CObjectMaint::GetObjectA lookup). Backs every host's GetObjectA seam, + // giving the TargetManager voyeur round-trip its cross-entity delivery + // path. Populated in EnsureRemoteMotionBindings (remotes) + EnterPlayerModeNow + // (player); pruned in RemoveLiveEntityByServerGuid. + private readonly Dictionary _physicsHosts = new(); + private static bool IsPlayerGuid(uint guid) => (guid & 0xFF000000u) == 0x50000000u; - private const double ServerControlledVelocityStaleSeconds = 0.60; + // ServerControlledVelocityStaleSeconds moved to RemotePhysicsUpdater (#184 + // Slice 2a — the DR tick's stale-velocity anim-stop was its only user). private int _liveSpawnReceived; // diagnostics private int _liveSpawnHydrated; private int _liveDropReasonNoPos; @@ -953,6 +1103,13 @@ public sealed class GameWindow : IDisposable _uiRegistry = uiRegistry; SpellBook = new AcDream.Core.Spells.Spellbook(SpellTable); LocalPlayer = new AcDream.Core.Player.LocalPlayerState(SpellBook); + // #184 Slice 2a: the extracted per-remote DR tick. Shares GameWindow's + // PhysicsEngine; the two helpers it also needs but that have callers + // outside the DR loop (GetSetupCylinder — the player's own cylinder + + // moveto/sticky radii; ApplyServerControlledVelocityCycle — the UP + // handler) stay on GameWindow and are injected as delegates. + _remotePhysicsUpdater = new AcDream.App.Physics.RemotePhysicsUpdater( + _physicsEngine, GetSetupCylinder, ApplyServerControlledVelocityCycle); } /// @@ -1308,6 +1465,11 @@ public sealed class GameWindow : IDisposable _lightingSink = new AcDream.Core.Lighting.LightingHookSink(Lighting); _hookRouter.Register(_lightingSink); + // #188 — TransparentPartHook (per-part translucency fade, e.g. + // the "fading wall" secret-passage doors) routes here. + _translucencySink = new AcDream.Core.Rendering.TranslucencyHookSink(_translucencyFades); + _hookRouter.Register(_translucencySink); + // Phase E.2 audio: init OpenAL + hook sink. Suppressible via // ACDREAM_NO_AUDIO=1 for headless tests / broken audio drivers. if (!_options.NoAudio) @@ -2525,7 +2687,7 @@ public sealed class GameWindow : IDisposable _wbDrawDispatcher = new AcDream.App.Rendering.Wb.WbDrawDispatcher( _gl, _meshShader!, _textureCache!, _wbMeshAdapter!, _wbEntitySpawnAdapter, _bindlessSupport!, - _classificationCache); + _classificationCache, _translucencyFades); // A.5 T22.5: apply A2C gate from quality preset. _wbDrawDispatcher.AlphaToCoverage = _resolvedQuality.AlphaToCoverage; @@ -2632,7 +2794,10 @@ public sealed class GameWindow : IDisposable _worldState.TryGetLandblock(id, out var lb)) { foreach (var ent in lb!.Entities) + { _lightingSink.UnregisterOwner(ent.Id); + _translucencyFades.ClearEntity(ent.Id); // #188 + } } _terrain?.RemoveLandblock(id); _physicsEngine.RemoveLandblock(id); @@ -3110,21 +3275,34 @@ public sealed class GameWindow : IDisposable } /// - /// Door detection by server-sent name. Doors fail the generic - /// multi-frame-idle gate at line 2692 (no idle cycle), so we register - /// them via a sibling branch with a state-seeded sequencer. Shared - /// with the [door-cycle] UM dispatch diagnostic — both sites must - /// agree on the name predicate. + /// Diagnostic-only label filter for the [door-cycle] UM dispatch trail + /// (below). #187: this is NOT the functional registration gate — that + /// was an exact-name match (`spawn.Name == "Door"`) which silently + /// dropped every door-like object whose display name isn't literally + /// "Door" (Sliding Door, Portcullis, Gate, "Magic Wall"). The real + /// registration gate is now data-driven (MotionTableId != 0, matching + /// retail's CPartArray::SetMotionTableID 0x005186e0) — see the rescue + /// branch below. Kept only to scope the debug print to door-ish + /// entities so the log doesn't fill with every reactive-motion prop. /// private static bool IsDoorName(string? name) => name == "Door"; - private static bool IsDoorSpawn(AcDream.Core.Net.WorldSession.EntitySpawn spawn) - => IsDoorName(spawn.Name); - private void OnLiveEntitySpawnedLocked(AcDream.Core.Net.WorldSession.EntitySpawn spawn) { _liveSpawnReceived++; + // L.2g S1 (DEV-6): seed the movement-event staleness gate from the + // CreateObject PhysicsDesc timestamp block, as retail seeds + // update_times at object creation. Seed() adopts wholesale on first + // sight and advance-only afterward, so the #138 rehydrate replay of + // a RETAINED spawn through this handler cannot regress live stamps. + if (!_motionSequenceGates.TryGetValue(spawn.Guid, out var seqGate)) + { + seqGate = new AcDream.Core.Physics.MotionSequenceGate(); + _motionSequenceGates[spawn.Guid] = seqGate; + } + seqGate.Seed(spawn.InstanceSequence, spawn.MovementSequence, spawn.ServerControlSequence); + // De-dup: the server re-sends CreateObject for the same guid in // several situations (visibility refresh, landblock crossing, // appearance update). Without cleanup the OLD copy remains in @@ -3252,6 +3430,14 @@ public sealed class GameWindow : IDisposable // object spawns never move the center. Idempotent + thrash-free: a // re-sent CreateObject for the same spawn landblock leaves the center // already-equal, so the guard is false on every repeat. + // + // #192: the player's own spawn is the first point we can trust + // _liveCenterX/Y as a REAL position rather than the Holtburg startup + // placeholder — set this unconditionally (even when no recenter is + // needed, e.g. a genuine Holtburg login) so StreamingReadinessGate can + // stop gating streaming on session state alone. + if (spawn.Guid == _playerServerGuid) + _liveCenterKnown = true; if (spawn.Guid == _playerServerGuid && (lbX != _liveCenterX || lbY != _liveCenterY)) { @@ -3260,6 +3446,13 @@ public sealed class GameWindow : IDisposable $"to ({lbX},{lbY}) for player spawn @0x{p.LandblockId:X8}"); _liveCenterX = lbX; _liveCenterY = lbY; + // The origin jumped — the streaming region is still bootstrapped + // around the stale startup center with residence marked before its + // async loads landed. Flag a full window rebuild (consumed on the + // render thread in OnUpdateFrame) so the region re-bootstraps fresh + // around the spawn, re-loading the landblocks RecenterTo would + // otherwise skip as already-resident — the cold-spawn streaming hole. + _pendingForceReloadWindow = true; } // #135: the instant we know the player spawned into a SEALED dungeon, @@ -3712,7 +3905,19 @@ public sealed class GameWindow : IDisposable ownerId: entity.Id, entityPosition: entity.Position, entityRotation: entity.Rotation, - isDynamic: true); // #143: server-object lights take the D3D dynamic path (1/d att, range×1.5) + // A7 fix #2 (#176/#181): isDynamic is decided by whether the light + // MOVES, not by weenie-vs-dat origin. Server-spawned FIXTURES + // (lanterns, braziers) are stationary — they take retail's STATIC + // curve (calc_point_light 0x0059c8b0: 1/d³ beyond 1 m, range×1.3, + // per-channel colour clamp), not the D3D dynamic path (1/d, + // range×1.5) the former #143 flag forced — which burned every + // fixture ~10× hotter than retail at 3 m: the magenta wash that + // zebra-striped the Facility Hub walls. Site-A lights are all + // stationary today (AP-44: they don't follow bearers); genuinely + // moving lights (projectiles, portal swirls) re-earn isDynamic + // when they exist. + isDynamic: false, + cellId: entity.ParentCellId ?? 0u); // A7 #176/#177: scope to the owning cell's visibility foreach (var ls in loaded) _lightingSink.RegisterOwnedLight(ls); } @@ -3814,47 +4019,17 @@ public sealed class GameWindow : IDisposable seqMotion = AcDream.Core.Physics.MotionCommand.Ready; } - // Phase L.1c followup (2026-04-28): apply the same - // missing-cycle fallback the OnLiveMotionUpdated path - // uses. Without this, a monster spawned in combat - // stance with the wire's seqMotion absent from its - // MotionTable hits ClearCyclicTail() with no - // replacement enqueue, every body part snaps to its - // setup-default offset, and the visual collapses to - // "torso on the ground" — visible to acdream - // observers when another client is in combat with a - // monster, until the first OnLiveMotionUpdated UM - // applies the same fallback there. - uint spawnCycle = seqMotion; - if (!sequencer.HasCycle(seqStyle, spawnCycle)) - { - uint origCycle = spawnCycle; - // RunForward → WalkForward → Ready - if ((spawnCycle & 0xFFu) == 0x07 - && sequencer.HasCycle(seqStyle, 0x45000005u)) - { - spawnCycle = 0x45000005u; - } - else if (sequencer.HasCycle(seqStyle, 0x41000003u)) - { - spawnCycle = 0x41000003u; - } - else - { - spawnCycle = 0; - } - - if (Environment.GetEnvironmentVariable("ACDREAM_DUMP_MOTION") == "1") - { - Console.WriteLine( - $"spawn cycle missing for guid=0x{spawn.Guid:X8} mtable=0x{mtableId:X8} " + - $"style=0x{seqStyle:X8} requested=0x{origCycle:X8} " + - $"→ fallback=0x{spawnCycle:X8}"); - } - } - - if (spawnCycle != 0) - sequencer.SetCycle(seqStyle, spawnCycle); + // R2-Q5: retail's enter-world sequence — initialize_ + // state installs the table default (so the entity is + // NEVER without a cycle: the L.1c "torso on the + // ground" hazard is structurally gone), then the + // wire's initial motion dispatches through the + // verbatim GetObjectSequence (a missing cycle leaves + // the default playing — retail's own miss behavior; + // the Run→Walk→Ready fallback chain is deleted with + // RemoteMotionSink). + sequencer.InitializeState(); + sequencer.SetCycle(seqStyle, seqMotion); } } } @@ -3884,20 +4059,34 @@ public sealed class GameWindow : IDisposable _entitySoundTables.Set(entity.Id, soundTableId); } } - else if (IsDoorSpawn(spawn) && _animLoader is not null) + else if (_animLoader is not null) { - // Phase B.4c — Door swing animation. Doors fail the - // multi-frame-idle gate above (no idle cycle) but DO have a - // MotionTable with On/Off cycles that ACE drives via - // UpdateMotion. Register with a seeded sequencer so the - // per-frame tick has frames to advance from frame 1 (without - // the seed, Sequencer.Advance(dt) returns no frames and the - // MeshRefs rebuild at line 7691 collapses the door to origin). + // Phase B.4c / #187 — reactive motion-table rescue. An entity + // whose REST pose is a static single frame fails the generic + // multi-frame-idle gate above, but may still carry a MotionTable + // with On/Off (or other) cycles the server drives reactively via + // UpdateMotion. Hinged doors, sliding doors, gates/portcullises, + // and disguised secret-passage props ("Magic Wall") all share + // this exact shape. #187: this branch used to be gated on + // `spawn.Name == "Door"`, which silently dropped every door-like + // object whose display name isn't literally "Door" — the + // production weenie data confirms Sliding Door / Portcullis / + // Gate / Magic Wall all carry the SAME WeenieType=Door + + // non-zero MotionTableId shape as a plain Door, differing only + // in name. Retail's own gate for creating a motion dispatcher is + // purely data-driven on the motion table id + // (CPartArray::SetMotionTableID 0x005186e0: `if (ebx != 0)`) — no + // WeenieType switch, no name check — so the `mtableId != 0` test + // just below is now the ENTIRE gate, matching retail exactly. + // Register with a seeded sequencer so the per-frame tick has + // frames to advance from frame 1 (without the seed, + // Sequencer.Advance(dt) returns no frames and the MeshRefs + // rebuild at line 7691 collapses the entity to origin). // // Initial cycle mirrors ACE's Door.cs:43 - // (CurrentMotionState = motionClosed): Off when the door is - // closed at spawn, On when the spawn PhysicsState carries the - // ETHEREAL bit (door was already open in ACE's DB). + // (CurrentMotionState = motionClosed): Off when closed at spawn, + // On when the spawn PhysicsState carries the ETHEREAL bit + // (already open in ACE's DB). uint mtableId = spawn.MotionTableId ?? (uint)setup.DefaultMotionTable; if (mtableId != 0) { @@ -3927,8 +4116,11 @@ public sealed class GameWindow : IDisposable : NonCombatStyle; uint spawnState = spawn.PhysicsState ?? 0u; uint initialCycle = (spawnState & EtherealPs) != 0 ? MotionOn : MotionOff; - if (sequencer.HasCycle(initialStyle, initialCycle)) - sequencer.SetCycle(initialStyle, initialCycle); + // R2-Q5: initialize_state guarantees a playing default; + // the On/Off dispatch no-ops harmlessly if the door's + // table lacks the cycle (HasCycle guard deleted). + sequencer.InitializeState(); + sequencer.SetCycle(initialStyle, initialCycle); var template = new (uint, IReadOnlyDictionary?)[meshRefs.Count]; for (int i = 0; i < meshRefs.Count; i++) @@ -3997,6 +4189,11 @@ public sealed class GameWindow : IDisposable private void OnLiveEntityDeleted(AcDream.Core.Net.Messages.DeleteObject.Parsed delete) { + // L.2g S1: drop the staleness gate with the entity — a subsequent + // re-create adopts fresh stamps from its CreateObject (retail's + // update_times die with the CPhysicsObj). + _motionSequenceGates.Remove(delete.Guid); + if (RemoveLiveEntityByServerGuid(delete.Guid) && Environment.GetEnvironmentVariable("ACDREAM_DUMP_MOTION") == "1") { @@ -4213,9 +4410,22 @@ public sealed class GameWindow : IDisposable // span the doorway gap, so the player could walk through. With // this change the door also registers the part-0 BSP slab // (1.9 × 0.26 × 2.5 m) that retail uses for the real block. + // #175 (2026-07-05): BSP part shapes must pose at the motion table's + // DEFAULT-STATE frame (the closed pose — what the sequencer renders + // for an idle entity and what retail's live CPhysicsPart pose is), + // not the Setup's placement frame. The Facility Hub double door + // (Setup 0x02000C9D) places its panels AJAR in the placement frame + // (yaw −150°/−30°, −0.44 m behind the doorway) while rendering + // closed — the user embedded into the visual door on one side and + // hit a phantom slab on the other. Null (no motion table / no + // cycle / part-count mismatch) falls back to placement frames. + var closedPose = MotionTableDefaultPose( + spawn.MotionTableId ?? 0u, setup.Parts.Count); + var raw = AcDream.Core.Physics.ShadowShapeBuilder.FromSetup( setup, entScale, - id => _physicsDataCache.GetGfxObj(id)?.BSP?.Root is not null); + id => _physicsDataCache.GetGfxObj(id)?.BSP?.Root is not null, + partPoseOverride: closedPose); // Substitute the real bounding-sphere radius for BSP shapes — // the pure builder's 2.0 placeholder works for typical doors @@ -4304,6 +4514,305 @@ public sealed class GameWindow : IDisposable } } + /// + /// #175: the motion table's default-state pose (the closed pose for + /// doors) — the derivation lives in + /// (Core, + /// dat-conformance-tested; the first cut here used a bare-style cycle + /// key, always missed, and silently no-oped — the "175 is not fixed" + /// report). Returns null → placement-frame fallback. + /// + private IReadOnlyList? MotionTableDefaultPose( + uint motionTableId, int partCount) + { + if (motionTableId == 0u || partCount == 0 || _dats is null) return null; + + var mt = _dats.Get(motionTableId); + if (mt is null) return null; + + var pose = AcDream.Core.Physics.Motion.MotionTablePose.DefaultStatePartFrames( + mt, id => _dats.Get(id)); + + if (Environment.GetEnvironmentVariable("ACDREAM_DUMP_MOTION") == "1") + { + string desc = pose is null ? "null->placement-fallback" + : System.FormattableString.Invariant( + $"part0=({pose[0].Origin.X:F2},{pose[0].Origin.Y:F2},{pose[0].Origin.Z:F2})"); + Console.WriteLine(System.FormattableString.Invariant( + $"[shape-pose] mt=0x{motionTableId:X8} parts={partCount} {desc}")); + } + + return pose; + } + + /// + /// R3-W4: one-time per-remote wiring of the animation-dispatch stack — + /// the persistent (ObservedOmega turn + /// callbacks), Motion.DefaultSink (so + /// apply_current_movement's interpreted branch dispatches cycles + /// — the retail mechanism behind the deleted K-fix18 forced-Falling), + /// and the RemoveLinkAnimations/InitializeMotionTables + /// seams (retail CPhysicsObj::RemoveLinkAnimations 0x0050fe20 / + /// InitializeMotionTables). Idempotent; safe from both the UM path and + /// the VectorUpdate path regardless of arrival order. + /// + private AcDream.Core.Physics.Motion.MotionTableDispatchSink? EnsureRemoteMotionBindings( + RemoteMotion rm, AnimatedEntity ae, uint serverGuid) + { + if (ae.Sequencer is null) + return rm.Sink; + if (rm.Sink is not null) + return rm.Sink; + + var rmForSink = rm; + rm.Sink = new AcDream.Core.Physics.Motion.MotionTableDispatchSink(ae.Sequencer) + { + TurnApplied = (turnMotion, turnSpeed) => + { + float signed = (turnMotion & 0xFFu) == 0x0E + ? -System.MathF.Abs(turnSpeed) + : turnSpeed; + rmForSink.ObservedOmega = new System.Numerics.Vector3( + 0f, 0f, -(System.MathF.PI / 2f) * signed); + }, + TurnStopped = () => + rmForSink.ObservedOmega = System.Numerics.Vector3.Zero, + }; + rm.Motion.DefaultSink = rm.Sink; + // #174 (2026-07-05): the RemoveLinkAnimations seam is retail + // CPhysicsObj::RemoveLinkAnimations 0x0050fe20 — a TAILCALL to + // CPartArray::HandleEnterWorld 0x00517d70 → + // MotionTableManager::HandleEnterWorld 0x0051bdd0: strip the + // sequence's link animations AND drain pending_animations + // completely (each pop fires MotionDone → CMotionInterp pops its + // pending_motions node in lockstep). The previous binding was the + // bare sequence strip — every LeaveGround (jump) stripped the + // animations that queued manager nodes were counting down on, + // orphaning them (NumAnims>0, anims gone) and permanently damming + // BOTH queues: MotionsPending() never drained again, so every + // armed moveto (ACE's walk-to-door mt-6, the close-range use turn) + // starved — the "door only works on a fresh session" bug. + rm.Motion.RemoveLinkAnimations = () => ae.Sequencer.Manager.HandleEnterWorld(); + rm.Motion.InitializeMotionTables = () => ae.Sequencer.Manager.InitializeState(); + // R3-W5: the per-op zero-tick flush (CPhysicsObj::CheckForCompletedMotions + // 0x0050fe30 -> MotionTableManager.CheckForCompletedMotions). + rm.Motion.CheckForCompletedMotions = ae.Sequencer.Manager.CheckForCompletedMotions; + + // R4-V4: the verbatim MoveToManager, seam-bound per the V2 harness + // wiring (the conformance-tested reference). Positions are WORLD + // space on both sides (getPosition + the MovementStruct positions + // the UM router builds) — one consistent space, so the manager's + // distance/heading math matches the harness exactly. + // R5-V5: the construction is now the MovementManager facade's + // MoveToFactory (the acdream stand-in for the physics_obj/weenie_obj + // backpointers retail's MakeMoveToManager 0x00524000 constructs + // from); MakeMoveToManager() below invokes it once, preserving the + // pre-facade eager timing. + var rmT = rm; + var mtBody = rm.Body; + // R5-V3 (#171): real setup cylsphere radii — retail CPartArray:: + // GetRadius/GetHeight (0x005180a0/0x005180b0). Lazy per-call resolve + // (a dictionary hit) so the read never races the spawn path's + // CacheSetup. Feeds GetCurrentDistance's UseSpheres cylinder math + // (own side) and StickyManager::adjust_offset's own-radius gap term. + // Replaces the R4 `() => 0f` pins ("setup cylsphere radius lands with + // R5-V3"). + var selfEntity = ae.Entity; + // R5-V2: forward-declared so the MoveToManager's target seams route + // into the entity's TargetManager (retail CPhysicsObj::set_target → + // TargetManager::SetTarget). Assigned right after the manager is built. + EntityPhysicsHost host = null!; + double NowSeconds() => (System.DateTime.UtcNow - System.DateTime.UnixEpoch).TotalSeconds; + rm.Movement.MoveToFactory = () => + { + var mtm = new AcDream.Core.Physics.Motion.MoveToManager( + rm.Motion, + stopCompletely: () => rmT.Motion.StopCompletely(), + getPosition: () => new AcDream.Core.Physics.Position( + rmT.CellId, mtBody.Position, mtBody.Orientation), + getHeading: () => AcDream.Core.Physics.Motion.MoveToMath.GetHeading( + mtBody.Orientation), + setHeading: (h, _) => mtBody.Orientation = + AcDream.Core.Physics.Motion.MoveToMath.SetHeading(mtBody.Orientation, h), + getOwnRadius: () => GetSetupCylinder(serverGuid, selfEntity).Radius, + getOwnHeight: () => GetSetupCylinder(serverGuid, selfEntity).Height, + contact: () => mtBody.OnWalkable, + isInterpolating: () => rmT.Interp.IsActive, + getVelocity: () => mtBody.Velocity, + getSelfId: () => serverGuid, + // R5-V2: retail CPhysicsObj::set_target/clear_target/target_quantum + // → the entity's TargetManager (replaces the AP-79 TrackedTarget* + // poll). The manager passes (0, top_level_id, 0.5, 0.0). + setTarget: (ctx, tlid, radius, q) => host.SetTarget(ctx, tlid, radius, q), + clearTarget: () => host.ClearTarget(), + getTargetQuantum: () => host.TargetManager.GetTargetQuantum(), + setTargetQuantum: q => host.TargetManager.SetTargetQuantum(q), + // R4-V5: real clock (same epoch-seconds base the per-remote tick uses). + curTime: NowSeconds); + // R5-V3 (#171, retires TS-39): bind the sticky seams to the host's + // PositionManager (host is constructed before MakeMoveToManager + // invokes this factory) — + // * BeginNextNode's sticky-arrival handoff: PositionManager::StickTo + // (retail MoveToManager::BeginNextNode @0x00529d3a); + // * PerformMovement's head unstick: unstick_from_object → + // PositionManager::UnStick (MoveToManager.PerformMovement:414). + mtm.StickTo = (tlid, radius, height) => + host.PositionManager.StickTo(tlid, radius, height); + mtm.Unstick = host.PositionManager.UnStick; + return mtm; + }; + // TS-36 (remote side): the interp's interrupt seam is retail's + // interrupt_current_movement → MovementManager::CancelMoveTo(0x36) + // chain (V2's reentrancy tests prove the wiring is inert-safe; + // R5-V5: the chain now lands on the literal facade relay 0x005241b0). + rm.Motion.InterruptCurrentMovement = + () => rmT.Movement.CancelMoveTo( + AcDream.Core.Physics.WeenieError.ActionCancelled); + + // R5-V2: the entity's CPhysicsObj stand-in + its TargetManager. Position + // is the entity's WORLD position (WorldEntity.Position — exactly the + // source the AP-79 poll used for a tracked target, so the voyeur system + // delivers the identical position for a moveto's quantum-0 case). + // HandleTargetting ticks per frame (added in the per-remote loop); + // HandleUpdateTarget fans deliveries to this entity's MoveToManager + // and (R5-V3, inside the host) its PositionManager — retail's + // CPhysicsObj::HandleUpdateTarget order. + host = new EntityPhysicsHost( + serverGuid, + getPosition: () => new AcDream.Core.Physics.Position( + rmT.CellId, + _entitiesByServerGuid.TryGetValue(serverGuid, out var selfEnt) + ? selfEnt.Position : mtBody.Position, + mtBody.Orientation), + getVelocity: () => mtBody.Velocity, + getRadius: () => GetSetupCylinder(serverGuid, selfEntity).Radius, + inContact: () => mtBody.OnWalkable, + minterpMaxSpeed: () => rmT.Motion.GetMaxSpeed(), + curTime: NowSeconds, + physicsTimerTime: NowSeconds, + getObjectA: ResolvePhysicsHost, + // Retail CPhysicsObj::HandleUpdateTarget (0x00512bc0) fan head: + // MovementManager::HandleUpdateTarget (@0x00512bf0 — the facade + // relay to the moveto side); the host chains the PositionManager + // leg after it. + handleUpdateTarget: info => rmT.Movement.HandleUpdateTarget(info), + interruptCurrentMovement: () => rmT.Movement.CancelMoveTo( + AcDream.Core.Physics.WeenieError.ActionCancelled)); + rm.Host = host; + _physicsHosts[serverGuid] = host; + + // R5-V5: retail MakeMoveToManager (0x00524000) — constructs the + // MoveToManager via the factory above (host now exists for the + // sticky binds inside it). The UM funnel head's unstick + // (CPhysicsObj::unstick_from_object 0x0050eaea, invoked at the mt-0 + // routing sites) binds on the interp beside it. + rm.Movement.MakeMoveToManager(); + rm.Motion.UnstickFromObject = host.PositionManager.UnStick; + return rm.Sink; + } + + /// + /// R5-V2 — retail CObjectMaint::GetObjectA(id): resolve any entity's + /// by guid, the + /// cross-entity seam every host's GetObjectA uses. If the entity has + /// a bound host (from or + /// EnterPlayerModeNow) return it; otherwise, for any entity that + /// EXISTS in the world, lazily create a minimal position-only host. Retail + /// gives every CPhysicsObj the capacity to host a + /// target_manager — a STATIC object (chest, corpse) must still answer + /// add_voyeur so a mover can moveto/stick to it (without this, + /// auto-walk to a never-animated object would arm the moveto but never + /// receive the immediate target snapshot, and never start). The minimal + /// host is registered so subsequent lookups reuse it; it is NOT ticked + /// (a static object never drifts, so the AddVoyeur immediate snapshot is + /// all a watcher needs; despawn still fires ExitWorld via the registry). + /// + private AcDream.Core.Physics.Motion.IPhysicsObjHost? ResolvePhysicsHost(uint id) + { + if (_physicsHosts.TryGetValue(id, out var existing)) + return existing; + if (!_entitiesByServerGuid.ContainsKey(id)) + return null; + + double NowSeconds() => (System.DateTime.UtcNow - System.DateTime.UnixEpoch).TotalSeconds; + var minimal = new EntityPhysicsHost( + id, + getPosition: () => new AcDream.Core.Physics.Position( + 0u, + _entitiesByServerGuid.TryGetValue(id, out var e) + ? e.Position : System.Numerics.Vector3.Zero, + System.Numerics.Quaternion.Identity), + getVelocity: () => System.Numerics.Vector3.Zero, // static target + getRadius: () => 0f, + inContact: () => true, + minterpMaxSpeed: () => null, + curTime: NowSeconds, + physicsTimerTime: NowSeconds, + getObjectA: ResolvePhysicsHost, + handleUpdateTarget: _ => { }, // not a watcher + interruptCurrentMovement: () => { }); + _physicsHosts[id] = minimal; + return minimal; + } + + /// + /// R5-V3 (#171): retail CPartArray::GetRadius/GetHeight + /// (0x005180a0/0x005180b0 — setup->radius/height × scale; ACE + /// PartArray.cs:189-207 reads the same Setup-level fields). Returns + /// (0, 0) when the entity has no resolvable Setup (bare-GfxObj props) — + /// ACE's PartArray != null ? … : 0 fallback shape + /// (PhysicsObj.cs:951-952). Live spawns cache their Setup in + /// _physicsDataCache at spawn time (CacheSetup, ~3250), so this is + /// a dictionary hit for every creature. + /// + private (float Radius, float Height) GetSetupCylinder( + uint serverGuid, AcDream.Core.World.WorldEntity entity) + { + var setup = _physicsDataCache.GetSetup(entity.SourceGfxObjOrSetupId); + if (setup is null) + return (0f, 0f); + // Live spawns bake ObjScale into MeshRefs and never populate + // WorldEntity.Scale (a scenery-pipeline field, default 1.0) — the + // authoritative per-entity scale is the SPAWN RECORD's ObjScale, the + // same source the collision registration's entScale uses (~4137). + // entity.Scale remains the fallback for non-spawn entities (scenery — + // never a chase/sticky participant). Diff-review find: without this, + // a server-scaled creature variant read unscaled radii and kept the + // #171 interpenetration exactly for scaled bodies. + float scale = + _lastSpawnByGuid.TryGetValue(serverGuid, out var sp) + && sp.ObjScale is { } objScale && objScale > 0f + ? objScale + : (entity.Scale > 0f ? entity.Scale : 1f); + return (setup.Radius * scale, setup.Height * scale); + } + + // #184 Slice 2a: ApplyPositionManagerDelta + SyncRemoteShadowToBody moved to + // AcDream.App.Physics.RemotePhysicsUpdater. ApplyPositionManagerDelta had no + // caller outside the DR tick; SyncRemoteShadowToBody is now called back via + // _remotePhysicsUpdater from the NPC UP-branch tail (below). + + /// + /// R5-V4: retail CPhysicsObj::stick_to_object (0x005127e0) — the + /// mt-0 WIRE sticky (unpack_movement case 0 @00524589, gated on the + /// motionFlags 0x1 trailer guid): resolve the target, read its PartArray + /// radius/height (0 when shapeless — retail's null-PartArray arm), then + /// PositionManager::StickTo. Unresolvable target → no stick at + /// all (retail's GetObjectA-null path). Retail resolves the target's + /// top-level PARENT first (parent ?? self); acdream's entity + /// table is flat (no client-side parenting), so the guid is used as-is — + /// the same convention as RouteServerMoveTo's TopLevelId. + /// + private void StickToObjectFromWire(EntityPhysicsHost? host, uint targetGuid) + { + if (host is null) + return; + if (!_entitiesByServerGuid.TryGetValue(targetGuid, out var tgtEnt)) + return; + var (radius, height) = GetSetupCylinder(targetGuid, tgtEnt); + host.PositionManager.StickTo(targetGuid, radius, height); + } + private bool RemoveLiveEntityByServerGuid(uint serverGuid) { if (!_entitiesByServerGuid.TryGetValue(serverGuid, out var existingEntity)) @@ -4311,6 +4820,39 @@ public sealed class GameWindow : IDisposable _worldState.RemoveEntityByServerGuid(serverGuid); _worldGameState.RemoveById(existingEntity.Id); + // R2-Q5 + R3-W2: retail runs BOTH layers' exit-world drains + // independently (r3-port-plan §4): the manager's (each pending + // animation fires MotionDone(success:false) → the bound interp pops + // in step) THEN the interp's own (flushes any remainder — + // MovementManager::HandleExitWorld 0x00524350, the R5-V5 facade + // relay: interp ONLY → CMotionInterp::HandleExitWorld 0x00527f30). + if (_animatedEntities.TryGetValue(existingEntity.Id, out var aeGone)) + aeGone.Sequencer?.Manager.HandleExitWorld(); + if (_remoteDeadReckon.TryGetValue(serverGuid, out var rmGone)) + rmGone.Movement.HandleExitWorld(); + // R5-V2: retail CPhysicsObj::exit_world tells every voyeur of this + // entity that it left the world (TargetManager::NotifyVoyeurOfEvent + // ExitWorld) — a watcher moving-to/stuck-to this entity drops the + // moveto/stick. This is the ONLY clean-up for a watcher whose target + // already sent an Ok (once status != Undefined the 10 s staleness + // timeout never fires), so it must run before the host is pruned. + if (_physicsHosts.TryGetValue(serverGuid, out var hostGone) + && hostGone is EntityPhysicsHost ephGone) + { + // R5-V3 (#171): retail exit_world (0x00514e60) order — the + // departing entity first tears down its OWN stick + // (PositionManager::UnStick @0x00514e88 — drops its voyeur + // subscription on whatever it was stuck to) and its own target + // subscription (TargetManager::ClearTarget @0x00514e97 — same + // for a plain mid-chase moveto), THEN NotifyVoyeurOfEvent + // (ExitWorld) tells the entities watching IT. Without the first + // two, a despawning attacker leaves a dead voyeur entry on its + // target until send-failure pruning. + ephGone.PositionManager.UnStick(); + ephGone.ClearTarget(); + ephGone.NotifyExitWorld(); + } + _physicsHosts.Remove(serverGuid); _animatedEntities.Remove(existingEntity.Id); _classificationCache.InvalidateEntity(existingEntity.Id); _physicsEngine.ShadowObjects.Deregister(existingEntity.Id); @@ -4330,10 +4872,138 @@ public sealed class GameWindow : IDisposable // double-register the new one. (Was gated on logDelete — harmless only // while live weenies registered no lights, which is no longer true.) _lightingSink?.UnregisterOwner(existingEntity.Id); + _translucencyFades.ClearEntity(existingEntity.Id); // #188 return true; } + /// + /// R4-V5: shared retail unpack_movement type-6..9 routing + /// (0x00524440 cases 6/7/8/9, decomp §2f) — one body for remotes + /// (R4-V4) and the local player (R4-V5). Writes the wire run rate to + /// the interp (my_run_rate, unpack @300603/@300660 — plan M13), + /// builds the MovementStruct (mt 6/8 resolve the target guid + /// against the entity table; unresolvable degrades to + /// MoveToPosition(wire origin) / TurnToHeading(wire heading) per §2f — + /// NOT an error), and calls the R5-V5 facade's PerformMovement + /// (MovementManager::PerformMovement 0x005240d0 — types 6-9 + /// MakeMoveToManager + delegate; retail's cases call MakeMoveToManager + /// at each head, a no-op here since the bind sites create eagerly). + /// Returns true when the event was a type-6..9 moveto (consumed); false + /// for every other movement type (caller falls through to its funnel / + /// skip posture). + /// + private bool RouteServerMoveTo( + AcDream.Core.Physics.Motion.MovementManager movement, + uint cellId, + AcDream.Core.Net.WorldSession.EntityMotionUpdate update) + { + if (update.MotionState.IsServerControlledMoveTo + && update.MotionState.MoveToPath is { } path) + { + // my_run_rate write (unpack_movement @300603). + if (update.MotionState.MoveToRunRate is { } mtRunRate) + movement.Minterp.MyRunRate = mtRunRate; + + var destWorld = AcDream.Core.Physics.Motion.MoveToMath + .OriginToWorld( + path.OriginCellId, path.OriginX, path.OriginY, path.OriginZ, + _liveCenterX, _liveCenterY); + var mp = AcDream.Core.Physics.Motion.MovementParameters.FromWire( + path.Bitfield, + path.DistanceToObject, + path.MinDistance, + path.FailDistance, + update.MotionState.MoveToSpeed ?? 1f, + path.WalkRunThreshold, + path.DesiredHeading); + + var ms = new AcDream.Core.Physics.MovementStruct + { + Params = mp, + }; + // mt 6 with a resolvable target → MoveToObject (the P4 tracker + // feeds position updates per tick); else degrade to + // MoveToPosition at the wire origin (§2f). + if (update.MotionState.MovementType == 6 + && path.TargetGuid is { } tgtGuid + && _entitiesByServerGuid.TryGetValue(tgtGuid, out var tgtEnt)) + { + ms.Type = AcDream.Core.Physics.MovementType.MoveToObject; + ms.ObjectId = tgtGuid; + ms.TopLevelId = tgtGuid; + // R5-V3 (#171): retail resolves the TARGET object's PartArray + // radius/height at the MoveToObject call site + // (CPhysicsObj::MoveToObject 0x005128e9/0x00512903; ACE + // PhysicsObj.cs:951-952) — they become SoughtObjectRadius/ + // Height, feeding GetCurrentDistance's edge-to-edge arrival + // (UseSpheres) and the sticky-arrival handoff's target radius. + // Was unset (0): every attacker closed ~one body-radius deeper + // than retail before stopping — the #171 dogpile term. + (ms.Radius, ms.Height) = GetSetupCylinder(tgtGuid, tgtEnt); + ms.Pos = new AcDream.Core.Physics.Position( + cellId, tgtEnt.Position, + System.Numerics.Quaternion.Identity); + } + else + { + ms.Type = AcDream.Core.Physics.MovementType.MoveToPosition; + ms.Pos = new AcDream.Core.Physics.Position( + cellId, destWorld, + System.Numerics.Quaternion.Identity); + } + movement.PerformMovement(ms); + return true; + } + + if (update.MotionState.IsServerControlledTurnTo + && update.MotionState.TurnToPath is { } turnPath) + { + var mp = AcDream.Core.Physics.Motion.MovementParameters.FromWireTurnTo( + turnPath.Bitfield, + turnPath.Speed, + turnPath.DesiredHeading); + + var ms = new AcDream.Core.Physics.MovementStruct { Params = mp }; + if (update.MotionState.MovementType == 8 + && turnPath.TargetGuid is { } turnTgt + && _entitiesByServerGuid.TryGetValue(turnTgt, out var turnEnt)) + { + ms.Type = AcDream.Core.Physics.MovementType.TurnToObject; + ms.ObjectId = turnTgt; + ms.TopLevelId = turnTgt; + ms.Pos = new AcDream.Core.Physics.Position( + cellId, turnEnt.Position, + System.Numerics.Quaternion.Identity); + } + else + { + ms.Type = AcDream.Core.Physics.MovementType.TurnToHeading; + // Retail's mt-8 unresolvable-object fallback substitutes the + // STANDALONE wire heading into the params before degrading + // (decomp §2f case 8: `params.desired_heading = wire_heading`). + // Invisible against ACE (P6: both heading fields written from + // the same source) but required for the verbatim degrade — + // closes the V4 carry-over the adversarial review caught + // (TurnToPathData.WireHeading was parsed but never consumed). + if (update.MotionState.MovementType == 8 + && turnPath.WireHeading is { } wireHeading) + { + mp.DesiredHeading = wireHeading; + } + } + movement.PerformMovement(ms); + return true; + } + + return false; + } + + // #184 Slice 2a: TickRemoteMoveTo (retail MovementManager::UseTime + // 0x005242f0 — moveto steering / arrival / fail-distance; the P4 poll is + // gone, TargetManager voyeur delivers positions) moved to + // RemotePhysicsUpdater. The DR tick was its only caller. + /// /// Phase 6.6: the server says an entity's motion has changed. Look up /// the AnimatedEntity for that guid, re-resolve the idle cycle with the @@ -4348,18 +5018,53 @@ public sealed class GameWindow : IDisposable if (!_entitiesByServerGuid.TryGetValue(update.Guid, out var entity)) return; if (!_animatedEntities.TryGetValue(entity.Id, out var ae)) return; - // #39 (2026-05-06): stamp the per-remote LastUMTime so the - // UP-velocity fallback path in ApplyServerControlledVelocityCycle - // can skip refinement while a UM is fresh. UMs are authoritative - // for direction-key changes (W press / release / W↔S flip); - // velocity refinement only helps for HoldKey-only changes (Shift - // toggle while a direction key is held — retail does NOT broadcast - // a fresh MoveToState in that case). - if (_remoteDeadReckon.TryGetValue(update.Guid, out var rmStateForUm)) + // L.2g S1 (DEV-6): retail staleness gate — BEFORE any state mutation. + // Retail drops stale/duplicate/superseded movement events at + // DispatchSmartBoxEvent (INSTANCE_TS, pseudo-C:357214) + + // CPhysics::SetObjectMovement (MOVEMENT_TS strictly-newer + + // SERVER_CONTROLLED_MOVE_TS, 0x00509690). Without this, a reordered + // straggler re-applies an old gait or un-stops a stop. + if (!_motionSequenceGates.TryGetValue(update.Guid, out var seqGate)) { - rmStateForUm.LastUMTime = - (System.DateTime.UtcNow - System.DateTime.UnixEpoch).TotalSeconds; + // UM for an entity whose CreateObject we never parsed (rare — + // the entity lookup above implies a spawn). Adopt-on-first-seed + // keeps the gate correct from this event onward. + seqGate = new AcDream.Core.Physics.MotionSequenceGate(); + _motionSequenceGates[update.Guid] = seqGate; + seqGate.Seed(update.InstanceSequence, update.MovementSequence, update.ServerControlSequence); } + else if (!seqGate.TryAcceptMovementEvent( + update.InstanceSequence, update.MovementSequence, update.ServerControlSequence)) + { + if (Environment.GetEnvironmentVariable("ACDREAM_DUMP_MOTION") == "1" + || Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") + { + Console.WriteLine( + $"[UM_STALE] guid={update.Guid:X8} inst={update.InstanceSequence} " + + $"mov={update.MovementSequence} sc={update.ServerControlSequence} dropped"); + } + return; + } + + // R4-V5 (pin P1): retail CPhysics::SetObjectMovement's autonomous + // gate (0x00509690 @0050972e, raw 271370-271431) — a movement event + // whose wire autonomous byte is set is DROPPED ENTIRELY (no state + // application, no interrupt) when the addressed object IsThePlayer. + // ACE reflects the client's own outbound MoveToState back to the + // sender with IsAutonomous=1 hardcoded (MovementData.cs:162 + + // Player_Networking.cs:365) and retail never lets that echo reach + // unpack_movement — which is what makes the unconditional + // unpack-head interrupt in the player branch below safe against + // ACE. Order matches retail: the sequence gates above run FIRST. + // last_move_was_autonomous is NOT stored for dropped events (stored + // only on the unpack path). This retires the row-less "don't cancel + // on non-MoveTo UM" adaptation that lived here pre-V5 (its causal + // story was stale — V0-pins.md P1). Run-rate sync is re-anchored to + // retail's own feeds: PlayerDescription skills (SetCharacterSkills, + // K-fix7) + the mt-6/7 my_run_rate wire write below (M13) — the + // former ApplyServerRunRate echo tap is deleted, not gated. + if (update.Guid == _playerServerGuid && update.IsAutonomous) + return; // Re-resolve using the new stance/command. Keep the setup and // motion-table we already know about — the server's motion @@ -4420,16 +5125,6 @@ public sealed class GameWindow : IDisposable $"[door-cycle] guid=0x{update.Guid:X8} stance=0x{stance:X4} cmd=0x{(command ?? 0u):X4}")); } - // Wire server-echoed RunRate first — used for the player's own - // locomotion tuning regardless of whether a cycle resolves. - if (_playerController is not null - && update.Guid == _playerServerGuid - && update.MotionState.ForwardSpeed.HasValue - && update.MotionState.ForwardSpeed.Value > 0f) - { - _playerController.ApplyServerRunRate(update.MotionState.ForwardSpeed.Value); - } - // ── Sequencer path (preferred) ────────────────────────────────── // Call SetCycle directly. The sequencer already handles: // - left→right / backward→forward remapping via adjust_motion @@ -4459,24 +5154,13 @@ public sealed class GameWindow : IDisposable // otherwise → resolve class byte and use full cmd float speedMod = update.MotionState.ForwardSpeed ?? 1f; uint fullMotion; - if ((!command.HasValue || command.Value == 0) - && update.MotionState.IsServerControlledMoveTo) - { - // Retail MoveToManager::BeginMoveForward calls - // MovementParameters::get_command (0x0052AA00), then - // _DoMotion -> adjust_motion. With CanRun and enough - // distance, WalkForward + HoldKey_Run becomes RunForward, - // and CMotionInterp::apply_run_to_command (0x00527BE0) - // multiplies speed by the packet's runRate. - var seed = AcDream.Core.Physics.ServerControlledLocomotion - .PlanMoveToStart( - update.MotionState.MoveToSpeed ?? 1f, - update.MotionState.MoveToRunRate ?? 1f, - update.MotionState.MoveToCanRun); - fullMotion = seed.Motion; - speedMod = seed.SpeedMod; - } - else if (!command.HasValue || command.Value == 0) + // R4-V4: the PlanMoveToStart seed is DELETED — MoveTo UMs no + // longer flow through the interpreted funnel at all (retail + // unpack_movement routes types 6-9 to MoveToManager; only type + // 0 does the interpreted-state copy). The manager's own + // BeginMoveForward -> get_command -> _DoMotion produces the + // cycle through the same sink every other motion uses. + if (!command.HasValue || command.Value == 0) { fullMotion = 0x41000003u; } @@ -4535,9 +5219,8 @@ public sealed class GameWindow : IDisposable // the paths above, but don't stomp the animation sequencer. // B.6 slice 1 (2026-05-14): trace inbound motion for the - // local player so we can characterize what ACE sends during - // a server-initiated auto-walk. One line per inbound UM, - // gated on ACDREAM_PROBE_AUTOWALK=1. + // local player. One line per inbound UM, gated on + // ACDREAM_PROBE_AUTOWALK=1 (name kept through R4-V5). if (AcDream.Core.Physics.PhysicsDiagnostics.ProbeAutoWalkEnabled) { string cmdHex = command.HasValue ? $"0x{command.Value:X4}" : "null"; @@ -4557,133 +5240,157 @@ public sealed class GameWindow : IDisposable $"[autowalk-mt] stance=0x{stance:X4} cmd={cmdHex} mt=0x{update.MotionState.MovementType:X2} isMoveTo={update.MotionState.IsServerControlledMoveTo} moveTowards={update.MotionState.MoveTowards} {pathStr} {spd} {mtsSpd} {mtsRun}")); } - // B.6 slice 2 (2026-05-14): drive the local player's body - // through a server-initiated auto-walk when ACE sends - // MoveToObject (movement type 6) — retail-faithful per - // MovementManager::PerformMovement 0x00524440 case 6. When - // the inbound motion is NOT a MoveTo, cancel any active - // auto-walk (server intent changed). + // R4-V5: retail unpack_movement dispatch for the local + // player — the SAME shape the remote branch uses below. + // Head (@300566): interrupt + unstick fire for EVERY + // movement event that reached unpack (the P1 gate above + // already dropped the autonomous echoes that would have + // made this unsafe against ACE); then types 6-9 route to + // the player's MoveToManager. mt-0 falls through to the + // existing skip-sequencer posture (the interpreted-state + // copy + LoseControlToServer autonomy handoff is + // R5/MovementManager scope — V0-pins.md P1 adjacent seam). if (_playerController is not null) { - if (update.MotionState.IsServerControlledMoveTo - && update.MotionState.MoveToPath is { } pathData) + // P1 tail (00509730): the unpack path stores the wire + // autonomous byte BEFORE unpack_movement — always false + // here (the gate above dropped autonomous events). This + // is what routes the controller's per-tick pump (A3 + // dual dispatch) to the INTERPRETED branch during a + // server moveto. LOCAL PLAYER ONLY for now: remotes' + // interps have no WeenieObj, which A3 treats as + // IsThePlayer — storing a remote player's autonomous + // byte would flip their per-tick apply onto the raw + // branch and clobber their funnel state; the remote + // store lands with real remote weenies (R5+). + _playerController.SetLastMoveWasAutonomous(update.IsAutonomous); + + _playerController.Motion.InterruptCurrentMovement?.Invoke(); + _playerController.Motion.UnstickFromObject?.Invoke(); + + // R5-V4a: unpack_movement HEAD style-on-change + // (0x00524440 @00524502-0052452c): wire style index → + // command word (command_ids[]; style-class indices map to + // 0x80000000|index — the funnel's S0-verified conversion) + // and `if (current style != wire style) DoMotion(style, + // ctor defaults)` BEFORE the movement-type switch — for + // EVERY type. acdream previously applied style only via + // the mt-0 funnel copy, so a chase/turn UM (mt 6-9) + // carrying a stance change started the move in the OLD + // stance (the RetailObserverTraceConformanceTests "S3 + // wires the unpack-level style-on-change" exclusion — + // this is that wiring). + uint wireStylePlayer = stance != 0 + ? (0x80000000u | (uint)stance) : 0x8000003Du; + if (_playerController.Motion.InterpretedState.CurrentStyle != wireStylePlayer) + _playerController.Motion.DoMotion(wireStylePlayer, + new AcDream.Core.Physics.Motion.MovementParameters()); + + if (_playerController.MoveTo is not null + && RouteServerMoveTo(_playerController.Movement, + _playerController.CellId, update)) { - // Translate landblock-local origin → world space. - var destWorld = AcDream.Core.Physics.RemoteMoveToDriver - .OriginToWorld( - pathData.OriginCellId, - pathData.OriginX, - pathData.OriginY, - pathData.OriginZ, - _liveCenterX, - _liveCenterY); - bool canCharge = update.MotionState.CanCharge; - _playerController.BeginServerAutoWalk( - destWorld, - pathData.MinDistance, - pathData.DistanceToObject, - update.MotionState.MoveTowards, - canCharge); if (AcDream.Core.Physics.PhysicsDiagnostics.ProbeAutoWalkEnabled) { Console.WriteLine(System.FormattableString.Invariant( - $"[autowalk-begin] dest=({destWorld.X:F2},{destWorld.Y:F2},{destWorld.Z:F2}) minDist={pathData.MinDistance:F2} objDist={pathData.DistanceToObject:F2} canCharge={canCharge} towards={update.MotionState.MoveTowards}")); + $"[autowalk-begin] mt=0x{update.MotionState.MovementType:X2} movingTo={_playerController.Movement.IsMovingTo()} type={_playerController.MoveTo.MovementTypeState}")); } + return; + } + + // R5-V4: retail unpack_movement case-0 TAIL for the local + // player (@00524583-0052458e) — stick_to_object when the + // motionFlags 0x1 trailer carried a guid, then + // standing_longjump ← motionFlags 0x2 (UNCONDITIONAL — + // an absent flag clears it). The interpreted-state COPY + // stays skipped for the local player (the + // sequencer-authority posture above); these two writes + // are the only case-0 effects that apply here. + if (update.MotionState.MovementType == 0) + { + if (update.MotionState.StickyObjectGuid is { } playerSticky + && playerSticky != 0) + StickToObjectFromWire(_playerHost, playerSticky); + _playerController.Motion.StandingLongJump = + update.MotionState.StandingLongJump; } - // Note: do NOT cancel auto-walk on a non-MoveTo motion - // arriving. The trace (2026-05-14, launch-slice2.log) - // shows ACE follows every mt=0x06 MoveToObject - // immediately with an mt=0x00 InterpretedMotionState - // (cmd=0x0007 RunForward, fwdSpd=2.86) — the - // companion locomotion echo, NOT a cancel. The two - // travel as separate packets but both belong to the - // same auto-walk. Cancelling on the InterpretedMotionState - // killed the auto-walk on frame 1. Arrival detection - // (inside ApplyAutoWalkOverlay) and user-input - // cancellation (same) are the two natural end paths; - // a fresh MoveToObject re-targets via BeginServerAutoWalk - // overwrite. } } else { - var forwardRoute = AcDream.Core.Physics.AnimationCommandRouter.Classify(fullMotion); - bool forwardIsOverlay = forwardRoute is AcDream.Core.Physics.AnimationCommandRouteKind.Action - or AcDream.Core.Physics.AnimationCommandRouteKind.Modifier - or AcDream.Core.Physics.AnimationCommandRouteKind.ChatEmote; - bool remoteIsAirborne = _remoteDeadReckon.TryGetValue(update.Guid, out var rmCheck) - && rmCheck.Airborne; - - // Retail MotionTable::GetObjectSequence routes action-class - // ForwardCommand values (creature attacks, chat-emotes) through - // the Action branch, where the swing is appended before the - // current cyclic tail and currState.Substate remains Ready. - // Treating 0x10000051/52/53 as SetCycle commands made the - // immediate follow-up Ready packet abort the swing. - // Phase L.1c followup (2026-04-28): the next two state-update - // blocks are LIFTED out of the substate-only `else` branch so - // they run for BOTH overlay (Action/Modifier/ChatEmote) and - // substate (Walk/Run/Ready/etc) packets. Two separate research - // agents converged on the same root cause for the user- - // observed "creature just runs instead of attacking" symptom: + // ── L.2g S2b (2026-07-02): remote entities flow through the + // verbatim CMotionInterp funnel. The wire state becomes an + // InboundInterpretedState (retail UnPack defaults for absent + // fields — a flags=0 UM is a wholesale stop, S0-verified), + // MotionInterpreter.MoveToInterpretedState applies it with + // retail's exact dispatch order + the 15-bit action-stamp + // gate (conformance: RetailObserverTraceConformanceTests, + // 183/183 vs the live retail-observer cdb trace), and the + // gate-passed dispatches go straight into the motion-table + // stack via MotionTableDispatchSink -> PerformMovement + // (R2-Q5; GetObjectSequence + is_allowed decide — no sink- + // side pick; airborne handling is the funnel's + // contact_allows_move gate, the retail mechanism behind the + // old K-fix17 guard). // - // 1. Attack swings arrive as mt=0 with - // ForwardCommand=AttackHigh1 (Action class). Retail's - // CMotionInterp::move_to_interpreted_state - // (acclient_2013_pseudo_c.txt:305936-305992) bulk-copies - // forward_command from the wire into the body's - // InterpretedState UNCONDITIONALLY. With - // forward_command=AttackHigh1, get_state_velocity - // returns 0 because its gate is RunForward||WalkForward - // — body stops moving forward. + // R4-V4: retail unpack_movement dispatch (0x00524440) — the + // head-interrupt fires for EVERY movement type, then types + // 6/7/8/9 route to MoveToManager.PerformMovement (which + // cancels again itself — retail does both) while ONLY type 0 + // flows through the interpreted-state funnel below. // - // 2. The acdream overlay branch was routing through - // PlayAction (animation overlay) but skipping ALL of: - // - ServerMoveToActive flag update - // - MoveToPath capture - // - InterpretedState.ForwardCommand assignment - // So during a swing UM, the body's InterpretedState - // stayed at RunForward from the prior MoveTo packet, - // ServerMoveToActive stayed true, and the per-tick - // remote driver kept steering + applying RunForward - // velocity through every frame. - // - // Note: we bypass DoInterpretedMotion / ApplyMotionToInterpretedState - // here because the latter is a heuristic that ONLY handles - // WalkForward / RunForward / WalkBackward / SideStep / Turn - // / Ready (MotionInterpreter.cs:941-970). For an Action - // command (e.g. AttackHigh1 = 0x10000062) the switch falls - // through and InterpretedState is silently NOT updated — - // exactly the bug we are fixing. Direct field assignment - // matches retail's copy_movement_from bulk-copy - // (acclient_2013_pseudo_c.txt:293301-293311). - if (_remoteDeadReckon.TryGetValue(update.Guid, out var remoteMot)) + // R4-V5 door fix (2026-07-03 user report: doors stopped + // animating): entities that never receive an UpdatePosition + // (doors, levers — static animated objects) never got a + // RemoteMotion (created only in the UP handler), so since + // the L.2g S2b funnel cutover NOTHING applied their UM + // forward-command (the old direct SetCycle became the + // rm-only funnel) — a used door flipped ETHEREAL but never + // played its On/Off cycle. Retail runs the SAME unpack → + // CMotionInterp pipeline for every entity class; create the + // rm on first UM exactly like the UP handler does. + if (!_remoteDeadReckon.TryGetValue(update.Guid, out var remoteMot)) { - remoteMot.ServerMoveToActive = update.MotionState.IsServerControlledMoveTo; + remoteMot = new RemoteMotion(); + remoteMot.Body.Orientation = entity.Rotation; + remoteMot.Body.Position = entity.Position; + _remoteDeadReckon[update.Guid] = remoteMot; + } + { + var sink = EnsureRemoteMotionBindings(remoteMot, ae, update.Guid); - // Bulk-copy the wire's resolved ForwardCommand + speed - // into InterpretedState UNCONDITIONALLY (overlay, - // substate, AND MoveTo packets). Matches retail's - // copy_movement_from semantics - // (acclient_2013_pseudo_c.txt:293301-293311) which does - // not filter by MovementType. - // - // For MoveTo packets, fullMotion is the RunForward seed - // from PlanMoveToStart, so this populates - // ForwardCommand=RunForward + ForwardSpeed=speed*runRate - // — what the OLD substate-only DoInterpretedMotion call - // (commit f794832 removed) used to set. Without it, - // apply_current_movement reads the default - // ForwardCommand=Ready and produces zero velocity, so - // chasing creatures only translate via UpdatePosition - // hard-snaps and at spawn appear posed at default - // (visible as "torso on the ground" until the first UP - // snap hits). - // - // For overlay (Action) packets this sets ForwardCommand - // to the Attack/Twitch/etc command, and - // get_state_velocity returns 0 because the gate is - // RunForward||WalkForward — body stops moving forward. + // unpack_movement head (@300566): interrupt + unstick. + remoteMot.Motion.InterruptCurrentMovement?.Invoke(); + remoteMot.Motion.UnstickFromObject?.Invoke(); + + // R5-V4a: unpack_movement head style-on-change — see the + // player-side comment (@00524502-0052452c). Runs BEFORE + // the type routing for every movement type; the mt-0 + // funnel below still performs its own full style + // adoption (retail has BOTH — the head fires on CHANGE + // only, so an unchanged stance is a no-op here). + uint wireStyleRemote = stance != 0 + ? (0x80000000u | (uint)stance) : 0x8000003Du; + if (remoteMot.Motion.InterpretedState.CurrentStyle != wireStyleRemote) + remoteMot.Motion.DoMotion(wireStyleRemote, + new AcDream.Core.Physics.Motion.MovementParameters()); + + // R4-V5: the type-6..9 routing body is shared with the + // local player (RouteServerMoveTo) — behavior identical + // to the R4-V4 inline blocks it was extracted from. + // (MoveTo null = EnsureRemoteMotionBindings early-outed + // on a sequencer-less entity — same skip as pre-V5.) + if (remoteMot.MoveTo is not null + && RouteServerMoveTo(remoteMot.Movement, + remoteMot.CellId, update)) + { + return; + } + + // [FWD_WIRE] + observed-velocity history invalidation on + // a forward-command change (pre-S2 behavior, unchanged: + // the per-tick scaling must not reuse a stale ratio + // derived from the OLD motion). if (remoteMot.Motion.InterpretedState.ForwardCommand != fullMotion) { if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") @@ -4694,285 +5401,86 @@ public sealed class GameWindow : IDisposable + $"newCmd=0x{fullMotion:X8} " + $"newLow=0x{fullMotion & 0xFFu:X2} speed={speedMod:F3}"); } - // Motion command changed — invalidate observed-velocity - // history so the per-tick scaling in TickAnimations - // doesn't reuse a stale ratio derived from the OLD - // motion (e.g. carrying run-pace serverSpeed into the - // first walk frame, which would briefly accelerate - // walk to run pace before settling). remoteMot.PrevServerPosTime = 0.0; } - remoteMot.Motion.InterpretedState.ForwardCommand = fullMotion; - // Pass speedMod through verbatim — preserve sign so retail's - // adjust_motion'd backward walk (cmd=WalkForward, spd<0) - // produces backward velocity in get_state_velocity, NOT - // forward. Pre-fix used `<=0 ? 1 : speedMod` which clamped - // negative to 1.0 and made the dead-reckoned body translate - // forward despite the reverse-playback animation — visually - // "still walking forward" from the observer's POV. - remoteMot.Motion.InterpretedState.ForwardSpeed = speedMod; - if (update.MotionState.IsServerControlledMoveTo - && update.MotionState.MoveToPath is { } path) + // Build the funnel input. fullMotion/speedMod already + // encode retail's absent-field forward defaults (null/0 + // → Ready; mt 6-9 never reach here post-V4). Style: + // retail's InterpretedMotionState::UnPack (0x0051f400) + // defaults an absent stance to NonCombat 0x8000003D — + // NOT keep-current (S0 trace: every empty UM applied + // 0x8000003d on the retail observer). + var ims = new AcDream.Core.Physics.InboundInterpretedState { - remoteMot.MoveToDestinationWorld = AcDream.Core.Physics.RemoteMoveToDriver - .OriginToWorld( - path.OriginCellId, - path.OriginX, - path.OriginY, - path.OriginZ, - _liveCenterX, - _liveCenterY); - remoteMot.MoveToMinDistance = path.MinDistance; - remoteMot.MoveToDistanceToObject = path.DistanceToObject; - remoteMot.MoveToMoveTowards = update.MotionState.MoveTowards; - remoteMot.HasMoveToDestination = true; - remoteMot.LastMoveToPacketTime = - (System.DateTime.UtcNow - System.DateTime.UnixEpoch).TotalSeconds; - } - else if (!update.MotionState.IsServerControlledMoveTo) - { - // Off MoveTo — clear stale destination so the per-tick - // driver doesn't keep steering. - remoteMot.HasMoveToDestination = false; - } - } - - if (forwardIsOverlay) - { - if (!remoteIsAirborne) - { - AcDream.Core.Physics.AnimationCommandRouter.RouteFullCommand( - ae.Sequencer, - fullStyle, - fullMotion, - speedMod <= 0f ? 1f : speedMod); - } - } - else - { - // Pick which cycle to play on the sequencer. Priority: - // 1. Forward cmd if active (RunForward / WalkForward) — legs run/walk. - // 2. Else sidestep cmd if active — legs strafe. - // 3. Else turn cmd if active — legs pivot. - // 4. Else Ready — idle. - // - // For forward+sidestep or forward+turn, the forward cycle - // wins at the anim layer; the sidestep/turn contribute via - // MotionInterpreter velocity/omega writes. - uint animCycle = fullMotion; - float animSpeed = speedMod; - uint fwdLow = fullMotion & 0xFFu; - bool fwdIsRunWalk = fwdLow == 0x05 /* Walk */ || fwdLow == 0x06 /* WalkBack */ - || fwdLow == 0x07 /* Run */; - if (!fwdIsRunWalk) - { - // Forward is Ready (or absent). Prefer sidestep cycle if present, - // else turn cycle, else Ready. - if (update.MotionState.SideStepCommand is { } sideForAnim && sideForAnim != 0) - { - uint sideFullForAnim = AcDream.Core.Physics.MotionCommandResolver - .ReconstructFullCommand(sideForAnim); - if (sideFullForAnim == 0) sideFullForAnim = 0x65000000u | sideForAnim; - animCycle = sideFullForAnim; - animSpeed = update.MotionState.SideStepSpeed ?? 1f; - } - else if (update.MotionState.TurnCommand is { } turnForAnim && turnForAnim != 0) - { - uint turnFullForAnim = AcDream.Core.Physics.MotionCommandResolver - .ReconstructFullCommand(turnForAnim); - if (turnFullForAnim == 0) turnFullForAnim = 0x65000000u | turnForAnim; - animCycle = turnFullForAnim; - // SIGNED — do NOT MathF.Abs. ACE encodes TurnLeft on the - // wire as (TurnCommand=TurnRight, TurnSpeed=NEGATIVE), - // mirroring retail's adjust_motion convention. The - // sequencer's negative-speed path (EnqueueMotionData - // multiplies MotionData.Omega by speedMod, the - // synthesize-omega fallback flips zomega via - // -(pi/2)*adjustedSpeed) only produces the correct - // CCW rotation when the sign is preserved here. - // Confirmed by live wire trace 2026-05-03: TurnLeft - // input arrives as turnCmd16=0x000D, speed=-1.500. - animSpeed = update.MotionState.TurnSpeed ?? 1f; - } - } - // K-fix17 (2026-04-26): preserve the Falling cycle while - // the remote is airborne. ACE broadcasts UpdateMotion - // mid-arc when the player turns / runs — the previous - // SetCycle here swapped Falling → RunForward, breaking - // the visible jump animation. The arc still played out - // physics-wise (body went up/down), but the legs ran - // instead of folded. Skip the cycle swap when airborne; - // the InterpretedState updates below still fire so the - // body's velocity matches the new motion command, AND - // the post-resolve landing path restores the cycle to - // whatever the interpreted state says when the body - // lands. - if (!remoteIsAirborne) - { - // Fallback chain for missing cycles in the MotionTable. - // SetCycle unconditionally calls ClearCyclicTail() before - // looking up the cycle; if the cycle is absent, the body - // ends up with no cyclic tail at all and every part snaps - // to its setup-default offset — visible as "torso on the - // ground" because most creatures' setup-default puts all - // limbs at the torso origin. - // - // This is specifically a regression from commit 186a584 - // (Phase L.1c port): pre-fix, MoveTo packets fell through - // to fullMotion=Ready (which always exists in every - // MotionTable). Post-fix, MoveTo packets seed - // fullMotion=RunForward, but some creatures (especially - // when stance=HandCombat) lack a (combat, RunForward) - // cycle. Fall through RunForward → WalkForward → Ready - // until we find one the table actually contains. - // - // Note: this fallback is for the SEQUENCER (visible - // animation) only. InterpretedState.ForwardCommand still - // gets the wire's (or seeded) ForwardCommand verbatim - // so apply_current_movement produces correct velocity. - uint cycleToPlay = animCycle; - if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1" - && (animCycle & 0xFFu) is 0x05u or 0x07u) - { - bool hc = ae.Sequencer.HasCycle(fullStyle, cycleToPlay); - System.Console.WriteLine( - $"[HASCYCLE] guid={update.Guid:X8} style=0x{fullStyle:X8} " - + $"requestedCycle=0x{cycleToPlay:X8} HasCycle={hc}"); - } - if (!ae.Sequencer.HasCycle(fullStyle, cycleToPlay)) - { - uint requested = cycleToPlay; - // RunForward (0x44000007) → WalkForward (0x45000005) - if ((cycleToPlay & 0xFFu) == 0x07 - && ae.Sequencer.HasCycle(fullStyle, 0x45000005u)) - { - cycleToPlay = 0x45000005u; - } - // WalkForward → Ready (0x41000003) - else if (ae.Sequencer.HasCycle(fullStyle, 0x41000003u)) - { - cycleToPlay = 0x41000003u; - } - // Ready missing too — leave the existing cycle alone - // by not calling SetCycle at all (avoids the - // ClearCyclicTail wipe). - else - { - cycleToPlay = 0; - } - - if (Environment.GetEnvironmentVariable("ACDREAM_DUMP_MOTION") == "1") - { - Console.WriteLine( - $"UM cycle missing for guid=0x{update.Guid:X8} " + - $"style=0x{fullStyle:X8} requested=0x{requested:X8} " + - $"→ fallback=0x{cycleToPlay:X8}"); - } - } - if (cycleToPlay != 0) - { - if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1" - && (ae.Sequencer.CurrentMotion != cycleToPlay - || MathF.Abs(ae.Sequencer.CurrentSpeedMod - animSpeed) > 1e-3f)) - { - System.Console.WriteLine( - $"[SETCYCLE] guid={update.Guid:X8} " - + $"old=(motion=0x{ae.Sequencer.CurrentMotion:X8} speed={ae.Sequencer.CurrentSpeedMod:F3}) " - + $"new=(motion=0x{cycleToPlay:X8} speed={animSpeed:F3})"); - } - ae.Sequencer.SetCycle(fullStyle, cycleToPlay, animSpeed); - } - } - - // Retail runs the full MotionInterp state machine on every - // remote. Route each wire command (forward, sidestep, turn) - // through DoInterpretedMotion so apply_current_movement → - // get_state_velocity → PhysicsBody.set_local_velocity fires - // on a subsequent tick exactly as retail's FUN_00529210 - // (apply_current_movement) does. - // - // Decompile refs: - // FUN_00529930 DoMotion - // FUN_00528f70 DoInterpretedMotion - // FUN_00528960 get_state_velocity - // FUN_00529210 apply_current_movement - // ServerMoveToActive flag, MoveToPath capture, and the - // InterpretedState.ForwardCommand bulk-copy are already - // handled by the LIFTED block above (so overlay-class swings - // also clear stale MoveTo state and update the body's - // forward command). This branch only handles sidestep / - // turn axes plus the ObservedOmega seed — none of which - // appear on overlay packets, so the existing logic is - // correct unchanged. (`remoteMot` is the same dictionary - // entry obtained at the top of the lifted block.) - if (remoteMot is not null) - { - // Sidestep axis. + CurrentStyle = stance != 0 ? (0x80000000u | (uint)stance) : 0x8000003Du, + ForwardCommand = fullMotion, + ForwardSpeed = speedMod, + SideStepCommand = 0u, + SideStepSpeed = update.MotionState.SideStepSpeed ?? 1f, + TurnCommand = 0u, + TurnSpeed = update.MotionState.TurnSpeed ?? 1f, + }; if (update.MotionState.SideStepCommand is { } sideCmd16 && sideCmd16 != 0) { uint sideFull = AcDream.Core.Physics.MotionCommandResolver .ReconstructFullCommand(sideCmd16); - if (sideFull == 0) sideFull = 0x65000000u | sideCmd16; - float sideSpd = update.MotionState.SideStepSpeed ?? 1f; - remoteMot.Motion.DoInterpretedMotion( - sideFull, sideSpd, modifyInterpretedState: true); + ims.SideStepCommand = sideFull != 0 ? sideFull : (0x65000000u | sideCmd16); } - else - { - // No sidestep — clear any leftover strafing motion. - remoteMot.Motion.StopInterpretedMotion( - AcDream.Core.Physics.MotionCommand.SideStepRight, modifyInterpretedState: true); - remoteMot.Motion.StopInterpretedMotion( - AcDream.Core.Physics.MotionCommand.SideStepLeft, modifyInterpretedState: true); - } - - // Turn axis — and use as the on/off switch for ObservedOmega. - // On turn start: seed ObservedOmega from the formula - // (π/2 × turnSpeed) so rotation begins THIS tick without - // waiting for the next UP to observe a delta. - // On turn end: zero ObservedOmega so rotation stops - // immediately instead of coasting at the last observed - // rate until the next UP shows zero delta. - // UpdatePosition still REFINES the rate from actual - // server deltas (more accurate than the formula), but - // this ensures instant on/off response. if (update.MotionState.TurnCommand is { } turnCmd16 && turnCmd16 != 0) { uint turnFull = AcDream.Core.Physics.MotionCommandResolver .ReconstructFullCommand(turnCmd16); - if (turnFull == 0) turnFull = 0x65000000u | turnCmd16; - float turnSpd = update.MotionState.TurnSpeed ?? 1f; + ims.TurnCommand = turnFull != 0 ? turnFull : (0x65000000u | turnCmd16); if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") { System.Console.WriteLine( $"[TURN_WIRE] guid={update.Guid:X8} turnCmd16=0x{turnCmd16:X4} " - + $"turnFull=0x{turnFull:X8} low=0x{turnFull & 0xFFu:X2} " - + $"({(((turnFull & 0xFFu) == 0x0D) ? "TurnRight" : ((turnFull & 0xFFu) == 0x0E) ? "TurnLeft" : "OTHER")}) " - + $"speed={turnSpd:F3}"); + + $"turnFull=0x{ims.TurnCommand:X8} speed={ims.TurnSpeed:F3}"); } - remoteMot.Motion.DoInterpretedMotion( - turnFull, turnSpd, modifyInterpretedState: true); - // Seed ObservedOmega with formula so rotation starts - // immediately; UP deltas will refine the rate. - uint turnLow = turnFull & 0xFFu; - if (turnLow == 0x0D /* TurnRight */) - remoteMot.ObservedOmega = new System.Numerics.Vector3(0, 0, -(MathF.PI / 2f) * turnSpd); - else if (turnLow == 0x0E /* TurnLeft */) - remoteMot.ObservedOmega = new System.Numerics.Vector3(0, 0, (MathF.PI / 2f) * turnSpd); } - else + + // Command list → the funnel's action list. Retail applies + // EVERY entry via DoInterpretedMotion under the 15-bit + // server_action_stamp gate — the gate is what makes ACE's + // re-bundled stale entries (e.g. the Ready bundled into a + // RunForward UM, 2026-05-03 finding) inert, replacing the + // old skip-SubState-class workaround. + if (update.MotionState.Commands is { Count: > 0 } cmdList) { - remoteMot.Motion.StopInterpretedMotion( - AcDream.Core.Physics.MotionCommand.TurnRight, modifyInterpretedState: true); - remoteMot.Motion.StopInterpretedMotion( - AcDream.Core.Physics.MotionCommand.TurnLeft, modifyInterpretedState: true); - // Zero ObservedOmega immediately — don't coast. - remoteMot.ObservedOmega = System.Numerics.Vector3.Zero; + var actionList = new System.Collections.Generic.List(cmdList.Count); + foreach (var item in cmdList) + { + uint full = AcDream.Core.Physics.MotionCommandResolver + .ReconstructFullCommand(item.Command); + if (full == 0) full = 0x10000000u | item.Command; + actionList.Add(new AcDream.Core.Physics.InboundMotionAction( + full, + Stamp: item.PackedSequence & 0x7FFF, + Autonomous: (item.PackedSequence & 0x8000) != 0, + Speed: item.Speed)); + } + ims.Actions = actionList; } + + // R2-Q5/R3-W4: funnel dispatches go STRAIGHT into the + // motion-table stack (GetObjectSequence + is_allowed + // decide) — mt-0 only post-V4 (types 6-9 returned above). + remoteMot.Motion.MoveToInterpretedState(ims, sink); + + // R5-V4: retail unpack_movement case-0 TAIL order + // (@00524583-0052458e): move_to_interpreted_state FIRST + // (above), THEN stick_to_object when the motionFlags 0x1 + // trailer carried a guid, THEN standing_longjump ← + // motionFlags 0x2 (UNCONDITIONAL — an absent flag + // CLEARS it). + if (update.MotionState.StickyObjectGuid is { } stickyGuid + && stickyGuid != 0) + StickToObjectFromWire(remoteMot.Host, stickyGuid); + remoteMot.Motion.StandingLongJump = + update.MotionState.StandingLongJump; } } - } // CRITICAL: when we enter a locomotion cycle (Walk/Run/etc), // stamp the _remoteLastMove timestamp to "now". Without this, @@ -5024,7 +5532,11 @@ public sealed class GameWindow : IDisposable // a second SetCycle call wiped the first within the same UM // packet processing. Only Actions/Modifiers/ChatEmotes (overlays // that interleave with the cycle) belong in the list iteration. - if (update.MotionState.Commands is { Count: > 0 } cmds) + if (update.Guid == _playerServerGuid // L.2g S2b: LOCAL ONLY — remote command + // lists flow through the funnel's + // action-stamp gate (retail's actual + // mechanism for bundled stale entries) + && update.MotionState.Commands is { Count: > 0 } cmds) { if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") { @@ -5050,7 +5562,7 @@ public sealed class GameWindow : IDisposable if (itemRoute == AcDream.Core.Physics.AnimationCommandRouteKind.SubState) continue; AcDream.Core.Physics.AnimationCommandRouter.RouteWireCommand( - ae.Sequencer, + ae.Sequencer!, // guarded by the enclosing `if (ae.Sequencer is not null)` fullStyle, item.Command, item.Speed); @@ -5131,26 +5643,24 @@ public sealed class GameWindow : IDisposable | AcDream.Core.Physics.TransientStateFlags.OnWalkable); rm.Body.State |= AcDream.Core.Physics.PhysicsStateFlags.Gravity; - // K-fix10 (2026-04-26): force the Falling animation cycle on - // the remote so the legs match the arc. Mirrors the local - // player's UpdatePlayerAnimation path which sets - // animCommand = Falling whenever !IsOnGround. - // - // K-fix18 (2026-04-26): pass skipTransitionLink:true so the - // RunForward→Falling transition frames don't play first. - // Without that flag the remote stood still for ~100 ms at - // the start of the jump while the link drained, then - // folded into Falling. Skipping the link makes the pose - // engage immediately on jump start. + // R3-W4 (J19 — K-fix10/K-fix18 DELETED): the retail mechanism. + // The remote's ground departure fires LeaveGround (0x00528b00): + // strips pending transition links (the RemoveLinkAnimations + // seam) + re-applies movement through DefaultSink, whose + // contact-gated funnel dispatch engages Falling — no forced + // SetCycle, no skip flag. The wire velocity/omega are re-applied + // AFTER so they stay authoritative over LeaveGround's + // state-derived velocity write (adaptation note: retail's + // equivalence comes from the per-tick transition-sweep order — + // R6 scope). if (_entitiesByServerGuid.TryGetValue(update.Guid, out var ent) && _animatedEntities.TryGetValue(ent.Id, out var ae) && ae.Sequencer is not null) { - uint style = ae.Sequencer.CurrentStyle != 0 - ? ae.Sequencer.CurrentStyle - : 0x8000003Du; // NonCombat default - ae.Sequencer.SetCycle(style, AcDream.Core.Physics.MotionCommand.Falling, 1.0f, - skipTransitionLink: true); + EnsureRemoteMotionBindings(rm, ae, update.Guid); + rm.Motion.LeaveGround(); + rm.Body.Velocity = update.Velocity; + rm.Body.Omega = update.Omega; } } @@ -5195,35 +5705,6 @@ public sealed class GameWindow : IDisposable return low is 0x05 or 0x06 or 0x07 or 0x0F or 0x10; } - /// - /// Grace window in seconds after a UM arrives during which UP-derived - /// velocity refinement is suppressed for a player remote. UMs are - /// authoritative; the velocity fallback only fills the gap when retail - /// does not send a fresh MoveToState (Shift toggle while direction key - /// held). 200 ms covers the worst-case UM/UP race — UMs arrive on - /// direction-key events and UPs at 5–10 Hz, so the first UP after a - /// fresh UM lands ~100–200 ms behind. Tightened from 500 ms (commit - /// 8fa04af original) per user observation that the Shift-toggle - /// transition was visibly slower than retail; with 0.2 s the worst-case - /// added latency is just the UP cadence below it. - /// - private const double UmGraceSeconds = 0.2; - - /// - /// Speed (m/s) above which a player-remote currently in WalkForward - /// is promoted to RunForward by velocity refinement. Tuned to player - /// speeds: walk ≈ 3.12 m/s (WalkAnimSpeed × 1.0), run ≈ 8–12 m/s - /// (RunAnimSpeed × runRate ≈ 4.0 × 2.0–3.0). Hysteresis with - /// avoids thrashing at the boundary. - /// - private const float PlayerRunPromoteSpeed = 5.5f; - - /// - /// Speed (m/s) below which a player-remote currently in RunForward - /// is demoted to WalkForward by velocity refinement. - /// - private const float PlayerRunDemoteSpeed = 4.5f; - private void ApplyServerControlledVelocityCycle( uint serverGuid, AnimatedEntity ae, @@ -5232,35 +5713,31 @@ public sealed class GameWindow : IDisposable { if (rm.Airborne) return; if (ae.Sequencer is null) return; - // MoveTo packets already seeded the retail speed/runRate cycle. - // Keep UpdatePosition-derived velocity for render position only; - // using it to choose the cycle reverts fast chases back to slow - // velocity-estimated animation. - if (rm.ServerMoveToActive) return; + // R4-V4: an active MoveToManager owns the cycle (BeginMoveForward's + // get_command dispatch). Velocity-estimated cycle planning would + // fight it — same rationale as the pre-V4 ServerMoveToActive guard. + if (rm.MoveTo is { MovementTypeState: not AcDream.Core.Physics.MovementType.Invalid }) return; if (IsPlayerGuid(serverGuid)) { - // #39 (2026-05-06): player-remote forward-direction speed-bucket - // refinement. The bug case: actor toggles Shift while holding W - // (or releases Shift). Retail's outbound apparently does NOT - // broadcast a fresh MoveToState for HoldKey-only changes - // (verified via static analysis of CommandInterpreter::SendMovementEvent - // call sites; needs cdb confirmation). ACE has nothing to - // broadcast → no UM arrives at the observer → cycle stays at - // whichever direction-bucket was last set. Velocity DOES change - // (UP carries new pace), so this code path uses UP-derived - // velocity to refine the speed bucket within the same direction. + // L.2g S5 (2026-07-02, DEV-2 DELETED): player remotes get NO + // pace-derived cycle refinement — retail has no such mechanism + // anywhere in its inbound pipeline (deviation map DEV-2, two + // independent decomp dives + ACE cross-check). The #39-era + // premise ("retail's outbound goes silent on Shift toggle") was + // refuted at all three oracles + the S0 live capture: retail + // sends a fresh MoveToState on HoldRun toggle while moving + // (CommandInterpreter 0x006b37a8 → SendMovementEvent), ACE + // rebroadcasts every MoveToState (GameActionMoveToState.cs:36), + // and the wire shows explicit 0x0005↔0x0007 UMs on each toggle + // (launch-s0-wireprobe.log). The refinement layer's re-promote + // after legitimate flags=0 Ready UMs was itself the observed + // Ready↔Run thrash. Cycle changes for player remotes come from + // UpdateMotion ONLY, exactly like retail; position error is the + // InterpolationManager chase's job. // - // Conservative scope: - // - Forward direction only (low byte 0x05 or 0x07). Sidestep - // and backward HoldKey toggles are deferred until the TTD - // trace described in - // docs/research/2026-05-06-locomotion-cycle-transitions/ - // confirms retail's exact algorithm. - // - Hysteresis (4.5 m/s demote / 5.5 m/s promote) prevents - // thrashing at the boundary. - // - 500 ms UM grace window — a fresh UM is always authoritative. - ApplyPlayerLocomotionRefinement(serverGuid, ae, rm, velocity); + // NPC/monster remotes below keep PlanFromVelocity until S6 + // unifies all entity classes onto the CMotionInterp funnel. return; } @@ -5285,167 +5762,11 @@ public sealed class GameWindow : IDisposable + $"|v|={velocity.Length():F2} " + $"-> motion=0x{plan.Motion:X8} speedMod={plan.SpeedMod:F2} " + $"prev=0x{currentMotion:X8} " - + $"airborne={rm.Airborne} moveTo={rm.ServerMoveToActive}"); + + $"airborne={rm.Airborne} moveTo={rm.MoveTo?.MovementTypeState ?? AcDream.Core.Physics.MovementType.Invalid}"); } ae.Sequencer.SetCycle(style, plan.Motion, plan.SpeedMod); } - private void ApplyPlayerLocomotionRefinement( - uint serverGuid, - AnimatedEntity ae, - RemoteMotion rm, - System.Numerics.Vector3 velocity) - { - // UM grace: a fresh UM is authoritative. - double nowSec = (System.DateTime.UtcNow - System.DateTime.UnixEpoch).TotalSeconds; - double sinceUm = nowSec - rm.LastUMTime; - if (sinceUm < UmGraceSeconds) return; - - uint currentMotion = ae.Sequencer!.CurrentMotion; - uint lowByte = currentMotion & 0xFFu; - float currentSign = MathF.Sign(ae.Sequencer.CurrentSpeedMod); - if (currentSign == 0f) currentSign = 1f; - - // Recognised locomotion directions: - // 0x05 (WalkForward) — also encodes WalkBackward via negative speed - // (ACE convention: SidestepCommand= cancel, ForwardCommand= - // WalkForward, ForwardSpeed *= -0.65) - // 0x07 (RunForward) - // 0x0F (SideStepRight) - // 0x10 (SideStepLeft) - // Other motions (Ready, Turn, emotes, attacks) are left to UM-driven SetCycle. - const uint LowWalkForward = 0x05u; - const uint LowRunForward = 0x07u; - const uint LowSideStepRight = 0x0Fu; - const uint LowSideStepLeft = 0x10u; - bool isForwardClass = lowByte == LowWalkForward || lowByte == LowRunForward; - bool isSidestep = lowByte == LowSideStepRight || lowByte == LowSideStepLeft; - if (!isForwardClass && !isSidestep) return; - - float horizSpeed = MathF.Sqrt(velocity.X * velocity.X + velocity.Y * velocity.Y); - - // Hysteresis: stay in current bucket unless we cross the appropriate - // threshold. Below StopSpeed → don't refine (let UM Ready stop signal - // handle the stop transition; we don't want UP momentary 0-velocity - // to drop the cycle to Ready while the actor is mid-stride). - if (horizSpeed < AcDream.Core.Physics.ServerControlledLocomotion.StopSpeed) - return; - - uint targetMotion; - float speedMod; - - if (isSidestep) - { - // Sidestep: motion ID stays the same (SideStepLeft / SideStepRight). - // Retail's wire encoding for sidestep speed buckets uses the same - // motion ID with different SidestepSpeed (slow ≈ 1.25 multiplier, - // fast ≈ 3.0 clamp per ACE MovementData.cs:124-131). On Shift - // toggle while a strafe key is held, retail does NOT broadcast a - // fresh MoveToState (same wire-silence rule as the forward case), - // so observer-side cycle refinement must come from UP-derived - // velocity here. Preserve the sign — SideStepLeft is sometimes - // emitted with negative speedMod by the adjust_motion path. - // - // Magnitude: horizSpeed / SidestepAnimSpeed maps the observed - // speed back to a SideStepSpeed the sequencer can apply as a - // framerate multiplier. Retail's get_state_velocity for - // sidestep cycles is `velocity.X = SidestepAnimSpeed * - // SideStepSpeed` (MotionInterpreter.cs:592 — constant 1.25 - // m/s). Dividing by WalkAnimSpeed (3.12) here was wrong by - // 2.5× and made slow strafe play visibly slower than retail. - float sideMag = horizSpeed / AcDream.Core.Physics.MotionInterpreter.SidestepAnimSpeed; - sideMag = MathF.Min(MathF.Max( - sideMag, - AcDream.Core.Physics.ServerControlledLocomotion.MinSpeedMod), - AcDream.Core.Physics.ServerControlledLocomotion.MaxSpeedMod); - targetMotion = currentMotion; - speedMod = sideMag * currentSign; - } - else if (currentSign < 0f) - { - // BACKWARD walk: ACE encodes WalkBackward as `WalkForward` motion - // with NEGATIVE speedMod (MovementData.cs:115 `interpState.ForwardSpeed *= -0.65f`). - // No "RunBackward" motion exists — Shift toggle on backward - // changes only the magnitude of speedMod (slow back ≈ -0.65, - // fast back ≈ -1.91 = -runRate × 0.65). Keep WalkForward motion, - // refine magnitude, preserve negative sign. - // - // Without this branch (the original fix #1), backward refinement - // computed a positive speedMod from horizSpeed and overwrote the - // negative sign, making the legs play forward-walk while the body - // continued moving backward (the rubber-banding the user reported). - float backMag = horizSpeed / AcDream.Core.Physics.MotionInterpreter.WalkAnimSpeed; - backMag = MathF.Min(MathF.Max( - backMag, - AcDream.Core.Physics.ServerControlledLocomotion.MinSpeedMod), - AcDream.Core.Physics.ServerControlledLocomotion.MaxSpeedMod); - targetMotion = AcDream.Core.Physics.MotionCommand.WalkForward; - speedMod = -backMag; - } - else if (lowByte == LowRunForward) - { - if (horizSpeed < PlayerRunDemoteSpeed) - { - targetMotion = AcDream.Core.Physics.MotionCommand.WalkForward; - speedMod = MathF.Min(MathF.Max( - horizSpeed / AcDream.Core.Physics.MotionInterpreter.WalkAnimSpeed, - AcDream.Core.Physics.ServerControlledLocomotion.MinSpeedMod), - AcDream.Core.Physics.ServerControlledLocomotion.MaxSpeedMod); - } - else - { - targetMotion = AcDream.Core.Physics.MotionCommand.RunForward; - speedMod = MathF.Min(MathF.Max( - horizSpeed / AcDream.Core.Physics.MotionInterpreter.RunAnimSpeed, - AcDream.Core.Physics.ServerControlledLocomotion.MinSpeedMod), - AcDream.Core.Physics.ServerControlledLocomotion.MaxSpeedMod); - } - } - else - { - // currently WalkForward (0x05) with positive speedMod = walking forward. - if (horizSpeed > PlayerRunPromoteSpeed) - { - targetMotion = AcDream.Core.Physics.MotionCommand.RunForward; - speedMod = MathF.Min(MathF.Max( - horizSpeed / AcDream.Core.Physics.MotionInterpreter.RunAnimSpeed, - AcDream.Core.Physics.ServerControlledLocomotion.MinSpeedMod), - AcDream.Core.Physics.ServerControlledLocomotion.MaxSpeedMod); - } - else - { - targetMotion = AcDream.Core.Physics.MotionCommand.WalkForward; - speedMod = MathF.Min(MathF.Max( - horizSpeed / AcDream.Core.Physics.MotionInterpreter.WalkAnimSpeed, - AcDream.Core.Physics.ServerControlledLocomotion.MinSpeedMod), - AcDream.Core.Physics.ServerControlledLocomotion.MaxSpeedMod); - } - } - - // Skip the SetCycle if neither motion nor speedMod changed - // meaningfully — avoids replaying transition links every UP. - bool motionChanged = currentMotion != targetMotion - && (currentMotion & 0xFFu) != (targetMotion & 0xFFu); - bool speedChanged = MathF.Abs(ae.Sequencer.CurrentSpeedMod - speedMod) > 0.05f; - if (!motionChanged && !speedChanged) - return; - - if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") - { - System.Console.WriteLine( - $"[UPCYCLE_PLAYER] guid={serverGuid:X8} " - + $"|v|={horizSpeed:F2} cur=0x{currentMotion:X8} " - + $"-> motion=0x{targetMotion:X8} speedMod={speedMod:F2} " - + $"sinceUM={sinceUm:F2}s " - + $"motionChg={motionChanged} speedChg={speedChanged}"); - } - - uint style = ae.Sequencer.CurrentStyle != 0 - ? ae.Sequencer.CurrentStyle - : 0x8000003Du; - ae.Sequencer.SetCycle(style, targetMotion, speedMod); - } - private void OnLivePositionUpdated(AcDream.Core.Net.WorldSession.EntityPositionUpdate update) { // Phase A.1 / #135: track the PLAYER's last server-known landblock so the @@ -5513,14 +5834,17 @@ public sealed class GameWindow : IDisposable // (its body is the simulator, not a target). Retail does the // equivalent via SetPosition → change_cell → AddShadowObject // (acclient_2013_pseudo_c.txt:284276 / 281200 / 282862). - if (update.Guid != _playerServerGuid) - { - // BR-7: the wire position's full cell id seeds the re-flood - // (retail SetPosition → calc_cross_cells from m_position). - _physicsEngine.ShadowObjects.UpdatePosition( - entity.Id, worldPos, rot, origin.X, origin.Y, p.LandblockId, - seedCellId: p.LandblockId); - } + // #184 Slice 2b: the former players-only RAW-pos shadow sync is RETIRED. + // It was a Slice-1 stopgap while grounded player remotes (old Path A) skipped + // the sweep and tracked the server position closely. Now that Slice 2b runs + // the SAME per-tick sweep + shadow-follows-resolved for players, writing the + // raw (overlapping) server pos here would re-snap a packed player's shadow + // into overlap once per UP and fight the in-tick de-overlap (research + // finding 9). Player shadows now follow the RESOLVED body — via the DR-tick + // loop (SyncRemoteShadowToBody, movement-gated) and the player UP-branch tail + // below (first-UP / no-Sequencer case), exactly like NPCs. Local-player + // broadphase still tests an up-to-date remote shadow; it is just the resolved + // body now, not the raw wire pos. // Track remote-entity motion for stop detection. Only record the // timestamp when position moved MEANINGFULLY (> 0.05m). Updates @@ -5562,6 +5886,18 @@ public sealed class GameWindow : IDisposable // Hard-snap orientation on first spawn so the per-tick // slerp doesn't visibly rotate from Identity to truth. rmState.Body.Orientation = rot; + // #184 Slice 2b: PLACE the body at the server position on creation, + // mirroring the UM handler's seed (:5176 `Body.Position = + // entity.Position`). A UP-first RemoteMotion (created here before any + // UM) was left at the default (0,0,0). Path A never swept, so that + // stale origin was harmless — it caught up gradually. Now that Slice + // 2b runs the sweep for grounded PLAYERS too, an unplaced body would + // sweep from (0,0,0) in the server cell that does not contain it → + // garbage resolved pos → the digest's INVISIBLE/misplaced-body bug. + // Seeding here is the root-cause fix (the UP creation path should + // seed exactly like the UM path); worldPos == entity.Position (the + // unconditional snap at the top of this handler already ran). + rmState.Body.Position = worldPos; } // L.3 M2 (2026-05-05): retail-faithful MoveOrTeleport routing for @@ -5643,50 +5979,73 @@ public sealed class GameWindow : IDisposable { rmState.Airborne = false; rmState.Body.Velocity = System.Numerics.Vector3.Zero; - rmState.Body.State &= ~AcDream.Core.Physics.PhysicsStateFlags.Gravity; rmState.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Contact | AcDream.Core.Physics.TransientStateFlags.OnWalkable; rmState.Interp.Clear(); rmState.Body.Position = worldPos; - // Reset the sequencer out of Falling — see matching block in - // TickAnimations Step 5 (env-var path) for rationale. + // #161: retail landing = MovementManager::HitGround + // (minterp → moveto, 0x00524300 — the R5-V5 facade + // relay) with the Gravity state bit STILL SET + // (CMotionInterp::HitGround gates on state&0x400). The + // re-apply dispatches the PRESERVED pre-fall forward + // command → landing link → cycle. This replaces the + // forced SetCycle, which read the then-clobbered + // ForwardCommand (Falling) and re-set the pose it meant + // to clear. See the twin block in TickAnimations + // (VU.land). if (_animatedEntities.TryGetValue(entity.Id, out var aeForLand) && aeForLand.Sequencer is not null) { - uint style = aeForLand.Sequencer.CurrentStyle != 0 - ? aeForLand.Sequencer.CurrentStyle - : 0x8000003Du; - uint landingCmd = rmState.Motion.InterpretedState.ForwardCommand; - if (landingCmd == 0) - landingCmd = AcDream.Core.Physics.MotionCommand.Ready; - float landingSpeed = rmState.Motion.InterpretedState.ForwardSpeed; - if (landingSpeed <= 0f) landingSpeed = 1f; - aeForLand.Sequencer.SetCycle(style, landingCmd, landingSpeed); + EnsureRemoteMotionBindings(rmState, aeForLand, update.Guid); } + rmState.Movement.HitGround(); + // DR bookkeeping only (partner of the jump-start + // `State |= Gravity`). + rmState.Body.State &= ~AcDream.Core.Physics.PhysicsStateFlags.Gravity; return; } // ── GROUNDED ROUTING (CPhysicsObj::MoveOrTeleport) ──────────── - const float MaxPhysicsDistance = 96f; + const float MaxPhysicsDistance = 96f; // retail player_distance far-snap + const float BodySnapThreshold = 4f; // large correction / teleport / unplaced -> snap var localPlayerPos = _playerController?.Position ?? System.Numerics.Vector3.Zero; float dist = System.Numerics.Vector3.Distance(worldPos, localPlayerPos); + // #184 Slice 2b: the player UP routing gains the SAME placement-snap + // backstop the NPC routing got in Slice 1 (AP-87). Now that grounded + // PLAYER remotes run the sweep, an unplaced / stale-cell body — a + // UM-first RemoteMotion seeded to the spawn pos (:5176) then a first UP + // in a DIFFERENT cell, which the UP-creation seed (:5720) does NOT cover + // — would enqueue and the per-tick sweep would run from a cell that does + // not contain the body -> garbage resolved pos -> the digest's + // INVISIBLE/misplaced player. The 4 m bodyToTarget guard is the + // LOAD-BEARING backstop (AP-87; firstUp via LastServerPosTime is a poor + // signal for players — it is already set by the VEL_DIAG block above); + // !willBeDrTicked snaps a no-Sequencer player whose queue nothing would + // consume; dist>96 is retail's far-snap. Placed + near corrections still + // enqueue for the smooth catch-up. + float bodyToTarget = System.Numerics.Vector3.Distance( + rmState.Body.Position, worldPos); + bool willBeDrTicked = + _animatedEntities.TryGetValue(entity.Id, out var aeDrPl) + && aeDrPl.Sequencer is not null; - if (dist > MaxPhysicsDistance) + if (dist > MaxPhysicsDistance || !willBeDrTicked + || bodyToTarget > BodySnapThreshold) { - // Beyond view bubble: SetPositionSimple slide-snap. Clear queue. + // Beyond view bubble / large correction / unplaced body: + // SetPositionSimple slide-snap. Clear queue. rmState.Interp.Clear(); rmState.Body.Position = worldPos; } else { - // Within view bubble: enqueue waypoint for adjust_offset to walk to. - // The per-frame TickAnimations player-remote path drives the - // actual body advancement via InterpolationManager.AdjustOffset. - // Pass body's current position so the InterpolationManager can - // detect a far-distance enqueue (>100 m from body) and pre-arm - // an immediate blip — avoids body drifting visibly toward a - // far waypoint instead of teleporting to it. + // Within view bubble, placed + near: enqueue waypoint for + // adjust_offset to walk to. The per-frame TickAnimations player- + // remote path drives the actual body advancement via + // InterpolationManager.AdjustOffset. Pass body's current position so + // the InterpolationManager can detect a far-distance enqueue (>100 m + // from body) and pre-arm an immediate blip. float headingFromQuat = ExtractYawFromQuaternion(rot); rmState.Interp.Enqueue( worldPos, @@ -5694,24 +6053,14 @@ public sealed class GameWindow : IDisposable isMovingTo: false, currentBodyPosition: rmState.Body.Position); } - // #39 fix-3 (2026-05-06): velocity-fallback cycle refinement - // for player remotes. Wire-level evidence (`launch-39-diag2.log`): - // when retail's actor toggles Shift while a direction key - // is held, retail's outbound MoveToState logic does NOT - // emit a fresh packet (only Ready ↔ Run UMs visible in - // `[FWD_WIRE]`, despite a clear walk-pace ↔ run-pace - // velocity transition in `[VEL_DIAG]`). ACE has nothing - // to broadcast → no UM arrives at the observer → cycle - // sticks at whatever the last UM set. Compute the - // synth-velocity here in the player-remote path AND - // call into ApplyServerControlledVelocityCycle, which - // routes through the direction-preserving + UM-grace - // ApplyPlayerLocomotionRefinement helper (added in - // commit 8fa04af). - // - // The legacy non-player block below (3759+) covers NPCs - // and is gated `!IsPlayerGuid`; this block fills the - // matching gap for players. + // Track the UP-derived synth velocity for diagnostics + // ([VEL_DIAG] pace comparison). L.2g S5 (2026-07-02): the + // #39-era cycle-refinement call that used to live here is + // DELETED — retail never adapts a remote's animation from + // observed pace (deviation map DEV-2; premise refuted at + // decomp + ACE source + the S0 live capture, which shows + // explicit 0x0005↔0x0007 UMs on every Shift toggle). + // Player-remote cycles are UM-driven only. if (rmState.PrevServerPosTime > 0.0) { double nowSecVel = rmState.LastServerPosTime; @@ -5721,21 +6070,6 @@ public sealed class GameWindow : IDisposable var synthVel = (worldPos - rmState.PrevServerPos) / (float)dtPos; rmState.ServerVelocity = synthVel; rmState.HasServerVelocity = true; - - if (_animatedEntities.TryGetValue(entity.Id, out var aeForVel) - && aeForVel.Sequencer is not null) - { - if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") - { - System.Console.WriteLine( - $"[UPCYCLE_SRC] guid={update.Guid:X8} src=synth-player"); - } - ApplyServerControlledVelocityCycle( - update.Guid, - aeForVel, - rmState, - synthVel); - } } } @@ -5745,6 +6079,18 @@ public sealed class GameWindow : IDisposable // the near-enqueue branch this prevents a 1-frame teleport-then- // yank-back rubber-band as TickAnimations chases worldPos via the // queue. + // + // #184 Slice 2b: sync the player-remote shadow to the RESOLVED/placed + // body (mirrors the NPC UP-branch tail). Now that grounded players run + // the DR-tick sweep + shadow-follows-resolved, the retired raw-pos sync + // (top of this handler) would have re-snapped the shadow into overlap + // each UP; this keeps collision == render for the first UP (before any + // DR tick) and for no-Sequencer players. rmState.CellId is the server + // cell adopted above (:5735). The per-tick loop keeps it current + // between UPs (movement-gated). + if (rmState.CellId != 0) + _remotePhysicsUpdater.SyncRemoteShadowToBody( + entity.Id, rmState, _liveCenterX, _liveCenterY); entity.SetPosition(rmState.Body.Position); return; } @@ -5769,7 +6115,96 @@ public sealed class GameWindow : IDisposable rmState.ServerVelocity = System.Numerics.Vector3.Zero; rmState.HasServerVelocity = false; } - rmState.Body.Position = worldPos; + // R5-V3 #171 residual (2026-07-04 gate: "flashing/flapping", + // stale facing, pushed-into-player): while an entity is STUCK, + // the sticky steer owns its frame — retail's UP corrections flow + // through the InterpolationManager into the SAME adjust_offset + // chain where StickyManager OVERWRITES them while armed + // (PositionManager::adjust_offset 0x00555190 order; sticky + // assigns m_fOrigin 0x00555430), so a server correction can + // never fight an armed stick frame-by-frame. This legacy NPC + // path hard-snaps OUTSIDE that chain, producing a visible + // snap-out/steer-back oscillation at UP cadence (position) and + // a stale-facing stomp (orientation). Faithful translation to + // the snap architecture: suppress the position/orientation/ + // velocity snaps while stuck. LastServerPos/Time bookkeeping + // still records below — server truth reasserts on the first UP + // after unstick (bounded by the 1 s sticky lease). Register + // row with TS-41/TS-44. + bool snapSuppressedByStick = + (rmState.Host?.PositionManager.GetStickyObjectId() ?? 0u) != 0u; + if (snapSuppressedByStick + && AcDream.Core.Physics.PhysicsDiagnostics.ProbeStickyEnabled) + { + float snapDist = System.Numerics.Vector3.Distance( + worldPos, rmState.Body.Position); + Console.WriteLine(FormattableString.Invariant( + $"[sticky-snap-skip] guid=0x{update.Guid:X8} d={snapDist:F3} srv=({worldPos.X:F2},{worldPos.Y:F2}) body=({rmState.Body.Position.X:F2},{rmState.Body.Position.Y:F2})")); + } + if (!snapSuppressedByStick) + { + // #184 (2026-07-07): retail CPhysicsObj::MoveOrTeleport (0x00516330) + // for grounded NPC remotes. The body is PLACED (hard-snapped) whenever + // it is not already tracking NEAR the server position — the first UP, + // a large correction / teleport, an out-of-view creature (>96 m from + // the local player), or an entity the DR loop won't tick — otherwise the + // server point is a GENTLE dead-reckoning TARGET the per-tick interp + // catch-up walks to, and the KEPT sweep de-overlaps that movement. + // + // The placement-snap is LOAD-BEARING: the earlier attempt (reverted) + // enqueued EVERYTHING, so an unplaced body (origin, first UP) blipped + // over a huge distance into the sweep -> a resolve started in a cell that + // did not contain the body -> garbage resolved pos -> INVISIBLE monster + // while its shadow (synced to server truth) stayed put -> player stuck on + // nothing. Airborne keeps the authoritative hard-snap (arc integrates + // locally, K-fix15). Physics digest 2026-07-07 banner. + if (rmState.Airborne) + { + rmState.Body.Position = worldPos; + } + else + { + const float MaxPhysicsDistanceNpc = 96f; // retail player_distance far-snap + const float BodySnapThresholdNpc = 4f; // large correction / teleport -> snap + var localPlayerPosNpc = _playerController?.Position + ?? System.Numerics.Vector3.Zero; + float distNpc = System.Numerics.Vector3.Distance(worldPos, localPlayerPosNpc); + float bodyToTargetNpc = System.Numerics.Vector3.Distance( + rmState.Body.Position, worldPos); + // The 4 m bodyToTargetNpc guard is the LOAD-BEARING placement backstop: + // it snaps any body not already near the target (an unplaced first-UP + // body sits at the origin / spawn pos, far from worldPos). firstUpNpc is + // a belt-and-suspenders hint only — it is NOT a reliable "never placed" + // signal because a UM that enters a locomotion cycle can stamp + // LastServerPosTime before the first UP (~:5340). Don't tune the 4 m + // threshold down without re-checking the unplaced-body case. + bool firstUpNpc = rmState.LastServerPosTime <= 0.0; + // Enqueue only if the per-tick DR loop will CONSUME the queue (a + // non-null Sequencer, the TickAnimations gate); else nothing walks + // the body to the waypoint and it would freeze at its last pos. + bool willBeDrTickedNpc = + _animatedEntities.TryGetValue(entity.Id, out var aeDrNpc) + && aeDrNpc.Sequencer is not null; + + if (firstUpNpc || !willBeDrTickedNpc + || distNpc > MaxPhysicsDistanceNpc + || bodyToTargetNpc > BodySnapThresholdNpc) + { + // Placement / far / large-correction: SNAP + clear queue. + rmState.Interp.Clear(); + rmState.Body.Position = worldPos; + } + else + { + // Near DR correction: enqueue the waypoint for the per-tick + // catch-up (Path B consumes it via ComputeOffset). + float headingNpc = ExtractYawFromQuaternion(rot); + rmState.Interp.Enqueue( + worldPos, headingNpc, isMovingTo: false, + currentBodyPosition: rmState.Body.Position); + } + } + } // K-fix15 (2026-04-26): DON'T auto-clear airborne on UP. // ACE broadcasts UPs during the arc (peak / mid-fall / land) // at ~5-10 Hz. The previous K-fix9 logic cleared Airborne on @@ -5805,7 +6240,13 @@ public sealed class GameWindow : IDisposable // turn starts incorporates the pre-turn interval and produces // a halved "observed" rate → visible slow-start. Formula-only // is stable and simple; hard-snap fixes any drift. - rmState.Body.Orientation = rot; + // R5-V3 #171 residual: gated on the stick (see the position-snap + // comment above) — ACE's server-side facing lags the strafing + // target; stomping it over the sticky's per-tick face-tracking + // was the "monster attacking while facing a different direction" + // gate report. + if (!snapSuppressedByStick) + rmState.Body.Orientation = rot; rmState.LastServerPos = worldPos; rmState.LastServerPosTime = nowSec; // Align the body's physics clock with our clock so update_object @@ -5832,7 +6273,6 @@ public sealed class GameWindow : IDisposable // carries no stop information for our ACE. if (svel.LengthSquared() < 0.04f) { - rmState.ServerMoveToActive = false; rmState.Motion.StopCompletely(); if (_animatedEntities.TryGetValue(entity.Id, out var aeForStop) && aeForStop.Sequencer is not null) @@ -5845,25 +6285,32 @@ public sealed class GameWindow : IDisposable } } } - else if (!IsPlayerGuid(update.Guid) && rmState.HasServerVelocity) + else if (!IsPlayerGuid(update.Guid) && rmState.HasServerVelocity + && !snapSuppressedByStick && rmState.Airborne) { + // AIRBORNE-only (#184): a grounded NPC translates by the interp catch-up, + // and the per-tick grounded loop zeroes Body.Velocity before integrating — + // so this write is DEAD for grounded remotes and only muddies the + // "ServerVelocity is diagnostic-only" contract. Gating it to airborne keeps + // the arc's velocity re-sync and prevents synth velocity from leaking into a + // grounded integrate. rmState.Body.Velocity = rmState.ServerVelocity; } if (rmState.HasServerVelocity + && !snapSuppressedByStick && _animatedEntities.TryGetValue(entity.Id, out var aeForVelocity)) { - // #39 (2026-05-06): un-gated for player remotes — the - // function itself routes player remotes into the dedicated - // ApplyPlayerLocomotionRefinement path (forward-direction - // speed bucket only, with UM grace + hysteresis). Non-player - // remotes use the existing PlanFromVelocity path. + // NPC/monster remotes: PlanFromVelocity cycle selection from + // UP-derived velocity (ACE broadcasts NPC motion patterns the + // UM stream alone doesn't cover). Player remotes return early + // inside — their cycles are UM-driven only per retail (L.2g + // S5; DEV-2 deleted). Unification of NPCs onto the + // CMotionInterp funnel is S6. // // D2 (Commit A 2026-05-03): tag whether the velocity feeding - // ApplyServerControlledVelocityCycle is wire-explicit (rare for - // player remotes — ACE almost never sets HasVelocity on player - // UPs) or synthesized from position deltas (the common case). - // Pairs with the [UPCYCLE]/[UPCYCLE_PLAYER] line printed inside. + // ApplyServerControlledVelocityCycle is wire-explicit or + // synthesized from position deltas (the common case). if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") { string velSrc = update.Velocity is null ? "synth" : "wire"; @@ -5877,6 +6324,16 @@ public sealed class GameWindow : IDisposable rmState.ServerVelocity); } + // #184: sync the NPC shadow to the resolved/placed body (NOT the raw + // server pos — the raw-pos sync was RETIRED for players too in Slice 2b) + // so collision == render and the de-overlap isn't snapped away each UP. + // Covers the first UP (before any DR tick) and no-Sequencer NPCs (which + // the per-tick loop skips). The per-tick loop keeps it current between + // UPs, movement-gated. rmState.CellId is the server cell adopted above. + if (rmState.CellId != 0) + _remotePhysicsUpdater.SyncRemoteShadowToBody( + entity.Id, rmState, _liveCenterX, _liveCenterY); + entity.SetPosition(rmState.Body.Position); entity.Rotation = rmState.Body.Orientation; } @@ -6060,6 +6517,16 @@ public sealed class GameWindow : IDisposable } _playerController.SetPosition(snappedPos, resolved.CellId, CellLocalForSeed(snappedPos, resolved.CellId)); + // R5-V3 (#171, diff-review find): retail teleport_hook's TAIL + // (0x00514ed0 @0x00514f1b-0x00514f28) — after the manager teardown + // SetPosition just ran (moveto cancel + own UnStick), the teleporting + // object clears its OWN target subscription and tells every entity + // WATCHING IT that it teleported (NotifyVoyeurOfEvent(Teleported)). + // That notify is what tears down the mobs' sticks/target-tracking ON + // the player — without it, a melee pack stuck to the player keeps + // steering toward the post-teleport position at the 5× sticky follow + // speed for up to the 1 s lease (non-retail lurch on every recall). + _playerHost?.NotifyTeleported(); // Face the server-specified destination heading (retail drops you facing a fixed // direction). The render entity already got _pendingTeleportRot above; sync the // controller yaw so the camera + movement frame match it instead of the stale @@ -6780,9 +7247,9 @@ public sealed class GameWindow : IDisposable (lbY - _liveCenterY) * 192f, 0f); - // Per-landblock id namespace: 0x40000000 | (lbX << 16) | (lbY << 8) | local_counter — - // the same 0xNNXXYY## scheme scenery uses (0x80XXYY##). Distinct from scenery - // (0x80000000+) and stabs (ids from LandblockLoader). + // Per-landblock id namespace — see AcDream.Core.World.InteriorEntityIdAllocator + // for the full bit layout + history. Distinct from scenery (0x80000000+) and + // landblock stabs (0xC0000000+, ids from LandblockLoader). // // #119 ROOT-CAUSE FIX (2026-06-11): this used to be // `0x40000000 | (landblockId & 0x00FFFF00)`, which for landblock keys 0xXXYYFFFF @@ -6792,12 +7259,20 @@ public sealed class GameWindow : IDisposable // staircase, both 0x40B3FF09). The Tier-1 classification cache then served one // entity's batches to the other (the cache hint at bucket-draw time was the // player's landblock, identical for both) — the session-sticky "broken stairs + - // water barrel". Counter overflow past 0xFF still bleeds into the lbY byte (the - // documented #53 scenery-namespace caveat); the cache's (EntityId, owner-derived - // LandblockHint) tuple key disambiguates that residual case. + // water barrel". + // + // #190 (2026-07-09): the fix above LEFT a documented residual — "counter overflow + // past 0xFF still bleeds into the lbY byte." That residual manifested for real: + // the Town Network hub (205 cells, one landblock) reached 277 interior entities + // after the #79/#93 A7.L1 light-carrier hydration fix, aliasing into the NEXT + // landblock's Y-byte (entity script/particle tracking is keyed on entity.Id + // directly — EntityScriptActivator — with no landblock-hint disambiguation, so + // the fountain's water-spray script silently stopped firing). Widened the + // counter budget 8→12 bits (256→4096); see InteriorEntityIdAllocator's doc for + // why this is safe (nothing decodes X/Y back out of an entity id). uint interiorLbX = (landblockId >> 24) & 0xFFu; uint interiorLbY = (landblockId >> 16) & 0xFFu; - uint interiorIdBase = 0x40000000u | (interiorLbX << 16) | (interiorLbY << 8); + uint interiorIdBase = AcDream.Core.World.InteriorEntityIdAllocator.Base(interiorLbX, interiorLbY); uint localCounter = 0; uint firstCellId = (landblockId & 0xFFFF0000u) | 0x0100u; @@ -6928,6 +7403,14 @@ public sealed class GameWindow : IDisposable var meshRefs = new List(); var interiorBounds = new AcDream.Core.Meshing.LocalBoundsAccumulator(); + // #79/#93 (2026-07-09): a Setup-sourced stab whose sole visual part is a + // runtime-hidden marker (#136) flattens to zero mesh refs even though its + // Setup carries real Lights — a "light attach point" fixture (e.g. the Town + // Network fountain room's ceiling light, Setup 0x02000365). Track the dat + // Setup's Lights.Count here so the meshRefs==0 gate below doesn't also drop + // the entity that would otherwise carry those lights to the registration + // pass (GameWindow.cs ~7900). + int stabLightCount = 0; if ((stab.Id & 0xFF000000u) == 0x01000000u) { var gfx = _dats.Get(stab.Id); @@ -6950,6 +7433,7 @@ public sealed class GameWindow : IDisposable if (setup is not null) { _physicsDataCache.CacheSetup(stab.Id, setup); + stabLightCount = setup.Lights.Count; var flat = AcDream.Core.Meshing.SetupMesh.Flatten(setup); if (dumpStab) { @@ -6986,12 +7470,14 @@ public sealed class GameWindow : IDisposable } } - if (meshRefs.Count == 0) + if (!AcDream.Core.Meshing.EntityHydrationRules.ShouldKeepEntity(meshRefs.Count, stabLightCount)) { if (dumpStab) - Console.WriteLine($"[dump-entity] HYDRATE src=0x{stab.Id:X8} cell=0x{envCellId:X8} meshRefs=0 -> entity dropped"); + Console.WriteLine($"[dump-entity] HYDRATE src=0x{stab.Id:X8} cell=0x{envCellId:X8} meshRefs=0 lights=0 -> entity dropped"); continue; } + if (meshRefs.Count == 0 && dumpStab) + Console.WriteLine($"[dump-entity] HYDRATE src=0x{stab.Id:X8} cell=0x{envCellId:X8} meshRefs=0 lights={stabLightCount} -> KEPT as mesh-less light carrier"); // Stabs inside EnvCells are already in landblock-local coordinates // (same space as LandBlockInfo.Objects stabs). Adding cellOrigin would @@ -6999,6 +7485,17 @@ public sealed class GameWindow : IDisposable var worldPos = stab.Frame.Origin + lbOffset; var worldRot = stab.Frame.Orientation; + // #190: never silently wrap past the counter budget — that's exactly how + // this bug hid the first time (see the InteriorEntityIdAllocator doc + // comment). Log once per landblock the moment it happens; the id below + // still aliases into the next Y-slot when this fires (4096 is generous + // but not infinite), but at least it's visible in launch.log instead of + // silently breaking entity.Id-keyed systems (scripts, particles, shadows). + if (localCounter == AcDream.Core.World.InteriorEntityIdAllocator.MaxCounter + 1) + Console.WriteLine( + $"[id-overflow] landblock 0x{landblockId:X8} exceeded {AcDream.Core.World.InteriorEntityIdAllocator.MaxCounter + 1} " + + "interior entities — ids are now aliasing into the next landblock's reserved range (#190 class)"); + var hydrated = new AcDream.Core.World.WorldEntity { Id = interiorIdBase + localCounter++, @@ -7103,9 +7600,6 @@ public sealed class GameWindow : IDisposable var clipPlanes = new List(); var portalPolygons = new List(); - // Compute cell centroid in local space for InsideSide determination. - var centroid = (boundsMin + boundsMax) * 0.5f; - foreach (var portal in envCell.CellPortals) { portals.Add(new CellPortalInfo( @@ -7139,10 +7633,19 @@ public sealed class GameWindow : IDisposable System.Numerics.Vector3.Cross(p1 - p0, p2 - p0)); float d = -System.Numerics.Vector3.Dot(normal, p0); - // Determine InsideSide: which side of the plane the cell centroid is on. - // If centroid dot > 0 → inside is positive half-space (InsideSide=0). - float centroidDot = System.Numerics.Vector3.Dot(normal, centroid) + d; - int insideSide = centroidDot >= 0 ? 0 : 1; + // InsideSide from the dat PortalSide bit — retail PView::InitCell + // (0x005a4b70) gates traversal on `iVar9 != portals->portal_side`, and + // acdream's own physics path uses the same bit (CellTransit.cs:190). + // The former AABB-centroid reconstruction mis-derived the interior side + // for THIN connector cells: the connector's bounding-box center falls on + // the wrong side of a portal near the cell edge, so the eye read as a + // back-portal and the forward room was culled — the #186 grey flap at + // 0xF6820118→0116 (retail draws 0116 from that root; cdb-confirmed). + // PortalSide (Flags&2)==0 → the portal polygon normal points INTO the + // owning cell → interior is the negative half → InsideSide=1. Diagnostic + // Issue186…PortalSide_CentroidVsDatBit_AtGreyEye: the dat bit matches the + // centroid on every portal of these cells EXCEPT the one #186 breaks. + int insideSide = ((ushort)portal.Flags & 0x2) == 0 ? 1 : 0; clipPlanes.Add(new PortalClipPlane { @@ -7565,11 +8068,22 @@ public sealed class GameWindow : IDisposable datBundle.Setups.TryGetValue(src, out var datSetup); if (datSetup is not null && datSetup.Lights.Count > 0) { + // #176 site-A light-stacking leak: a landblock can RE-apply + // without an unload in between (#168 ForceReloadWindow, Far→Near + // promotion), and static entity ids are deterministic — so each + // re-apply appended another copy of the same lights under the + // same owner (observed ×2→×4 per session; the wash intensifies + // over time, and the stacked ties destabilize the 128-cap pool + // sort). Clear the owner's previous registration first: the + // re-apply becomes idempotent, and a first apply is a no-op. + _lightingSink.UnregisterOwner(entity.Id); + _translucencyFades.ClearEntity(entity.Id); // #188 var loaded = AcDream.Core.Lighting.LightInfoLoader.Load( datSetup, ownerId: entity.Id, entityPosition: entity.Position, - entityRotation: entity.Rotation); + entityRotation: entity.Rotation, + cellId: entity.ParentCellId ?? 0u); // A7 #176/#177: scope to the owning cell's visibility foreach (var ls in loaded) _lightingSink.RegisterOwnedLight(ls); } @@ -7599,77 +8113,42 @@ public sealed class GameWindow : IDisposable // docs/superpowers/specs/2026-05-21-cylinder-fallback-dedup-design.md. bool _isLandblockStab = (entity.Id & 0xFF000000u) == 0xC0000000u; if (_isScenery) scTried++; - // Register EACH physics-enabled part so multi-part Setups - // (buildings, trees) have all their collision geometry registered. - // Each part gets its own ShadowEntry with its world-space transform. - var entityRoot = - System.Numerics.Matrix4x4.CreateFromQuaternion(entity.Rotation) * - System.Numerics.Matrix4x4.CreateTranslation(entity.Position); - - uint partIndex = 0; - foreach (var meshRef in entity.MeshRefs) + // #185 FIX (2026-07-08): register the entity's BSP parts as ONE + // multi-part shadow object keyed on the entity's UNIQUE 32-bit id, + // via RegisterMultiPart (retail CPhysicsObj::add_shadows_to_cells + // 0x00514ae0 → CPartArray::AddPartsShadow — one object, a part array). + // + // The former per-part Register(entity.Id * 256u + partIndex) OVERFLOWED + // uint32 for class-prefixed landblock ids (0x40/0x80/0xC0…): the << 8 + // dropped the prefix byte, so different-class entities sharing the low + // 24 bits collided on ONE shadow part-id and Register's + // deregister-then-insert silently overwrote one entity's collision + // geometry — the #185 "invisible wall half-way up the stairs" (rendered + // steps with no collision; 23 such part-id collisions in landblock + // 0xF682 alone: 0xF6822100 ← {0x40F68221, 0xC0F68221}, …). entity.Id is + // unique, so RegisterMultiPart has no synthetic id and no collision. + // Building shells stay excluded (they collide via the per-LandCell + // building channel, CSortCell::find_collisions). The Setup CylSphere/ + // Sphere path below is UNCHANGED and only runs when entityBsp == 0 + // (retail binary dispatch: BSP xor cyl). Builder: + // ShadowShapeBuilder.FromLandblockBspParts. + var bspShapes = AcDream.Core.Physics.ShadowShapeBuilder.FromLandblockBspParts( + entity.MeshRefs, entity.IsBuildingShell, + id => _physicsDataCache.GetGfxObj(id)); + entityBsp = bspShapes.Count; + if (entityBsp > 0) { - // BR-7 / A6.P4 (2026-06-11): building SHELLS are not shadow - // objects in retail — their collision is the per-LandCell - // building channel (CSortCell::find_collisions, Ghidra - // 0x005340a0, dispatched off the CacheBuilding entry at the - // building's origin landcell). Registering them here is what - // put the cottage GfxObj into the radial sweep's reach from - // the cellar (#98). Interior statics + outdoor stab objects - // (LandBlockInfo.Objects) remain shadow objects. - if (entity.IsBuildingShell) break; - - var partCached = _physicsDataCache.GetGfxObj(meshRef.GfxObjId); - if (partCached?.BSP?.Root is null) { partIndex++; continue; } - - // Compute the part's world-space position from its transform. - var partWorld = meshRef.PartTransform * entityRoot; - - // Decompose to extract scale (scenery objects have it baked - // into PartTransform), rotation, and translation. - System.Numerics.Vector3 partScale3; - System.Numerics.Quaternion partRot; - System.Numerics.Vector3 partPos; - if (System.Numerics.Matrix4x4.Decompose(partWorld, - out partScale3, out partRot, out partPos)) - { /* decompose succeeded */ } - else - { - partScale3 = System.Numerics.Vector3.One; - partRot = entity.Rotation; - partPos = new System.Numerics.Vector3(partWorld.M41, partWorld.M42, partWorld.M43); - } - - // Use uniform scale (X component) — AC objects are uniformly scaled. - float partScale = partScale3.X; - if (partScale <= 0f) partScale = 1f; - - // Local bounding sphere radius × world scale = world-space radius - // for the broad phase. The BSPQuery will also use `partScale` to - // transform player spheres into the unscaled BSP coordinate space. - float localRadius = partCached.BoundingSphere?.Radius ?? 1f; - float worldRadius = localRadius * partScale; - - // Use a unique sub-ID per part: entity.Id * 256 + partIndex. - uint partId = entity.Id * 256u + partIndex; - _physicsEngine.ShadowObjects.Register( - partId, meshRef.GfxObjId, - partPos, partRot, worldRadius, + _physicsEngine.ShadowObjects.RegisterMultiPart( + entity.Id, entity.Position, entity.Rotation, bspShapes, + 0u, AcDream.Core.Physics.EntityCollisionFlags.None, origin.X, origin.Y, lb.LandblockId, - AcDream.Core.Physics.ShadowCollisionType.BSP, 0f, - partScale, - seedCellId: entity.ParentCellId ?? 0u); + seedCellId: entity.ParentCellId ?? 0u, isStatic: true); // L.2d slice 1 (2026-05-13): [entity-source] greppable from [resolve-bldg]. - // partCached?.BSP?.Root non-null was checked above (else `continue`), - // so hasPhys=true on this path. - // state/flags literals: landblock-baked scenery has no server PhysicsState - // broadcast and no PWD bitfield; defaults match static-solid semantics. + // One line per BSP part, all under the entity's single id (no synthetic partId). if (AcDream.Core.Physics.PhysicsDiagnostics.ProbeBuildingEnabled) - Console.WriteLine(System.FormattableString.Invariant( - $"[entity-source] id=0x{partId:X8} entityId=0x{entity.Id:X8} src=0x{entity.SourceGfxObjOrSetupId:X8} gfxObj=0x{meshRef.GfxObjId:X8} lb=0x{lb.LandblockId:X8} type=BSP note=partIdx={partIndex} hasPhys=true state=0x{0u:X8} flags={AcDream.Core.Physics.EntityCollisionFlags.None}")); - - entityBsp++; - partIndex++; + for (int _pi = 0; _pi < bspShapes.Count; _pi++) + Console.WriteLine(System.FormattableString.Invariant( + $"[entity-source] id=0x{entity.Id:X8} entityId=0x{entity.Id:X8} src=0x{entity.SourceGfxObjOrSetupId:X8} gfxObj=0x{bspShapes[_pi].GfxObjId:X8} lb=0x{lb.LandblockId:X8} type=BSP note=multipart-part{_pi} hasPhys=true state=0x{0u:X8} flags={AcDream.Core.Physics.EntityCollisionFlags.None}")); } // Register collision shapes from the Setup (if this entity has one). @@ -7880,6 +8359,8 @@ public sealed class GameWindow : IDisposable private void OnUpdate(double dt) { + using var _updStage = _frameProfiler.BeginStage(AcDream.App.Diagnostics.FrameStage.Update); + // [FRAME-DIAG]: applies run later this frame inside _streamingController.Tick; // flush the PREVIOUS OnUpdate's accumulated apply cost here (a clean per-frame // boundary, independent of where in OnUpdate the applies landed) and reset. @@ -7932,8 +8413,16 @@ public sealed class GameWindow : IDisposable // only. bool liveInWorld = _liveSession is not null && _liveSession.CurrentState == AcDream.Core.Net.WorldSession.State.InWorld; + // #192: liveInWorld alone used to be sufficient here — but InWorld fires + // right after the login handshake, before the player's own spawn + // CreateObject (and hence the real center) has arrived. Streaming that + // ran in that gap baked landblock offsets from the still-placeholder + // _liveCenterX/Y (Holtburg), producing stale-positioned geometry applied + // late once its build finished. Require _liveCenterKnown too — see + // AcDream.Core.World.StreamingReadinessGate for the full mechanism. if (_streamingController is not null && _cameraController is not null - && (!IsLiveModeWaitingForLogin || liveInWorld)) + && AcDream.Core.World.StreamingReadinessGate.ShouldStream( + LiveModeEnabled, _chaseModeEverEntered, liveInWorld, _liveCenterKnown)) { int observerCx = _liveCenterX; int observerCy = _liveCenterY; @@ -8043,6 +8532,17 @@ public sealed class GameWindow : IDisposable observerCx = (int)((cellLb >> 8) & 0xFFu); observerCy = (int)(cellLb & 0xFFu); } + // Consume the login-spawn far-recenter flag (network thread → render + // thread): drop the stale startup window + null the region so this + // Tick re-bootstraps the whole window fresh around the spawn origin. + // Same mechanism the outdoor-teleport path uses (line ~5725). Fixes + // the cold-spawn streaming hole (resident-but-never-loaded landblocks + // the RecenterTo diff skipped as already-resident). + if (_pendingForceReloadWindow) + { + _pendingForceReloadWindow = false; + _streamingController.ForceReloadWindow(); + } _streamingController.Tick(observerCx, observerCy, insideDungeon); // Re-inject persistent entities rescued from unloaded landblocks @@ -8249,6 +8749,15 @@ public sealed class GameWindow : IDisposable ? localEnt.Id : 0u; + // R5-V2: tick the player's TargetManager BEFORE Update ticks + // MoveToManager.UseTime (retail UpdateObjectInternal order). This is + // the load-bearing call for creature-chase: the player, as a watched + // target, pushes its position to its voyeurs (the NPCs moving-to it) + // here — that push lands in each NPC's HandleUpdateTarget the same + // frame, ahead of the NPCs' own UseTime in the per-remote loop + // (which runs after this block). Replaces the AP-79 player poll. + _playerHost?.HandleTargetting(); + var result = _playerController.Update((float)dt, input); // Update the player entity's position + rotation so it renders at @@ -8360,47 +8869,64 @@ public sealed class GameWindow : IDisposable var wireRot = YawToAcQuaternion(_playerController.Yaw); byte contactByte = result.IsOnGround ? (byte)1 : (byte)0; - // 2026-05-16 (issue #75): wire-layer semantic gate — - // user-MoveToState packets are ONLY for user-initiated - // motion intent. During server-controlled auto-walk - // (inbound MoveToObject), motion-state transitions - // come from the auto-walk's animation override, not - // from user input. Sending a MoveToState in that case - // would tell ACE "user took control" and cancel its - // own MoveToChain. This is NOT a band-aid like the - // earlier grace-period — it's the wire-layer's - // expression of retail's architectural split between - // user-input motion and server-driven motion: they - // share the local motion-state machine but only - // user-input flows back to the wire. Without the - // refactor (issue #75) this guard masked a synthesis - // leak; with the refactor it expresses the proper - // semantic. - if (result.MotionStateChanged && !_playerController.IsServerAutoWalking) + // 2026-05-16 (issue #75) / R4-V5: user-MoveToState packets + // are ONLY for user-initiated motion intent — retail's + // architectural split between user-input motion and + // server-driven motion. Post-V5 the split holds BY + // CONSTRUCTION: MotionStateChanged derives exclusively from + // input edges (the MoveToManager's dispatches never touch + // the controller's edge detector), so a manager-driven + // moveto produces no outbound MoveToState; the moment the + // user presses a key, the edge's CancelMoveTo chain kills + // the moveto and THAT state change legitimately goes on + // the wire ("user took control" — which is now true). The + // former !IsServerAutoWalking guard is redundant and gone + // with B.6. + if (result.MotionStateChanged) { - // HoldKey axis values — retail enum (holtburger types.rs HoldKey): - // Invalid = 0, None = 1, Run = 2 + // HoldKey axis values — retail enum (acclient.h enum + // HoldKey): Invalid = 0, None = 1, Run = 2. // Retail always sends CURRENT_HOLD_KEY (and uses the same // value for every active per-axis hold key — see // holtburger's build_motion_state_raw_motion_state). - // When the player is running forward, 2=Run; otherwise 1=None. - const uint HoldKeyNone = 1u; - const uint HoldKeyRun = 2u; - uint axisHoldKey = result.IsRunning ? HoldKeyRun : HoldKeyNone; + // When the player is running forward, Run; otherwise None. + var axisHoldKey = result.IsRunning + ? AcDream.Core.Physics.HoldKey.Run + : AcDream.Core.Physics.HoldKey.None; + + // D1/L.2b (2026-06-30): build the COMPLETE RawMotionState + // snapshot (matching retail's CPhysicsObj::InqRawMotionState()) + // and let RawMotionStatePacker's default-difference comparison + // decide what actually goes on the wire — see + // RawMotionStatePacker (ports RawMotionState::Pack, 0x0051ed10). + // This slice changes ONLY the packing; the state values + // below are exactly what the pre-slice code passed in. + var rawMotionState = new AcDream.Core.Physics.RawMotionState + { + CurrentHoldKey = axisHoldKey, + // CurrentStyle: not tracked by acdream today — leave at + // the retail default (0x8000003D) so the packer omits it. + ForwardCommand = result.ForwardCommand ?? AcDream.Core.Physics.RawMotionState.Default.ForwardCommand, + ForwardHoldKey = result.ForwardCommand.HasValue ? axisHoldKey : AcDream.Core.Physics.HoldKey.Invalid, + // D6.2b: the wire carries the RAW forward_speed (1.0 for run/walk; + // the controller now sets outForwardSpeed=1.0). ACE recomputes the + // broadcast run speed from run skill (echo-confirmed 2026-07-01), so + // this is retail-faithful; 1.0 is omitted by default-difference packing. + ForwardSpeed = result.ForwardSpeed ?? AcDream.Core.Physics.RawMotionState.Default.ForwardSpeed, + SidestepCommand = result.SidestepCommand ?? AcDream.Core.Physics.RawMotionState.Default.SidestepCommand, + SidestepHoldKey = result.SidestepCommand.HasValue ? axisHoldKey : AcDream.Core.Physics.HoldKey.Invalid, + SidestepSpeed = result.SidestepSpeed ?? AcDream.Core.Physics.RawMotionState.Default.SidestepSpeed, + TurnCommand = result.TurnCommand ?? AcDream.Core.Physics.RawMotionState.Default.TurnCommand, + TurnHoldKey = result.TurnCommand.HasValue ? axisHoldKey : AcDream.Core.Physics.HoldKey.Invalid, + TurnSpeed = result.TurnSpeed ?? AcDream.Core.Physics.RawMotionState.Default.TurnSpeed, + // Actions: acdream does not yet emit discrete motion + // events on this path (D2, deferred to Phase 2+). + }; var seq = _liveSession.NextGameActionSequence(); var body = AcDream.Core.Net.Messages.MoveToState.Build( gameActionSequence: seq, - forwardCommand: result.ForwardCommand, - forwardSpeed: result.ForwardSpeed, - sidestepCommand: result.SidestepCommand, - sidestepSpeed: result.SidestepSpeed, - turnCommand: result.TurnCommand, - turnSpeed: result.TurnSpeed, - holdKey: axisHoldKey, // always present - forwardHoldKey: result.ForwardCommand.HasValue ? axisHoldKey : (uint?)null, - sidestepHoldKey: result.SidestepCommand.HasValue ? axisHoldKey : (uint?)null, - turnHoldKey: result.TurnCommand.HasValue ? axisHoldKey : (uint?)null, + rawMotionState: rawMotionState, cellId: wireCellId, position: wirePos, rotation: wireRot, @@ -8408,15 +8934,25 @@ public sealed class GameWindow : IDisposable serverControlSequence: _liveSession.ServerControlSequence, teleportSequence: _liveSession.TeleportSequence, forcePositionSequence: _liveSession.ForcePositionSequence, - contactLongJump: contactByte); + contact: contactByte != 0, + // Standing longjump is not implemented yet — honest + // current value, not a guess (D3). + standingLongjump: false); DumpMovementTruthOutbound( "MTS", seq, result, wirePos, wireCellId, contactByte); _liveSession.SendGameAction(body); - // B.6/B.7 (2026-05-16): stamp the diff-driven heartbeat clock so - // HeartbeatDue resets its interval from THIS send — mirrors retail's - // SendMovementEvent (acclient_2013_pseudo_c.txt:0x006b4680) writing - // last_sent_position_time + last_sent_position + contact_plane - // after each MTS send. + // D5 audit (2026-06-30, this slice): retail's + // SendMovementEvent (acclient_2013_pseudo_c.txt, 0x006b4680) + // stamps ONLY last_sent_position_time after an MTS send — it + // does NOT update last_sent_position or + // last_sent_contact_plane (confirmed via Ghidra + // decompile-by-address during this slice). Only + // SendPositionEvent (the AP path, below) stamps all three. + // acdream's NotePositionSent call here stamps all three on + // BOTH paths — this is a real, audit-confirmed divergence + // from retail. Per this slice's scope (D5 = audit only, + // change only with explicit sign-off), left UNCHANGED; + // reported to the lead engineer instead of fixed here. _playerController.NotePositionSent( worldPos: _playerController.Position, cellId: _playerController.CellId, @@ -8442,9 +8978,13 @@ public sealed class GameWindow : IDisposable _liveSession.SendGameAction(body); // B.6/B.7 (2026-05-16): stamp the diff-driven heartbeat clock so // HeartbeatDue resets its interval from THIS send — mirrors retail's - // SendPositionEvent (acclient_2013_pseudo_c.txt:700345-700348) + // SendPositionEvent (acclient_2013_pseudo_c.txt:700345-700348, + // decomp address 0x006b4770, re-confirmed via the Ghidra + // decompile-by-address bridge during the L.2b slice 2026-06-30) // writing last_sent_position_time + last_sent_position + - // last_sent_contact_plane after each AP. + // last_sent_contact_plane after each AP. Unlike the MTS path + // above (SendMovementEvent, 0x006b4680), which retail stamps + // ONLY last_sent_position_time, this AP path is correct. _playerController.NotePositionSent( worldPos: _playerController.Position, cellId: _playerController.CellId, @@ -8454,11 +8994,17 @@ public sealed class GameWindow : IDisposable if (result.JumpExtent.HasValue && result.JumpVelocity.HasValue) { + // D4/L.2b (2026-06-30): JumpPack::Pack (0x00516d10) packs the + // full Position, not an objectGuid/spellId — pass the same + // wireCellId/wirePos/wireRot the MoveToState send above uses. var seq = _liveSession.NextGameActionSequence(); var jumpBody = AcDream.Core.Net.Messages.JumpAction.Build( gameActionSequence: seq, extent: result.JumpExtent.Value, velocity: result.JumpVelocity.Value, + cellId: wireCellId, + position: wirePos, + rotation: wireRot, instanceSequence: _liveSession.InstanceSequence, serverControlSequence: _liveSession.ServerControlSequence, teleportSequence: _liveSession.TeleportSequence, @@ -8468,7 +9014,6 @@ public sealed class GameWindow : IDisposable } // Update the player entity's animation cycle to match current motion. - UpdatePlayerAnimation(result); } } @@ -8628,6 +9173,8 @@ public sealed class GameWindow : IDisposable private void OnRender(double deltaSeconds) { + _frameProfiler.FrameBoundary(_gl!); + // Phase G.1: set the clear color from the current sky's fog // tint so the horizon band continues naturally past the // rendered geometry. Fog blends to this color at max distance @@ -8683,7 +9230,10 @@ public sealed class GameWindow : IDisposable // [FRAME-DIAG]: this OnRender drain is where staged GfxObj/entity meshes hit // the GPU (uncapped) — the H2 entity-upload suspect, separate from the apply. long fdE0 = _frameDiag ? System.Diagnostics.Stopwatch.GetTimestamp() : 0L; - _wbMeshAdapter?.Tick(); + using (var _uplStage = _frameProfiler.BeginStage(AcDream.App.Diagnostics.FrameStage.Upload)) + { + _wbMeshAdapter?.Tick(); + } if (_frameDiag) FrameDiagPush(_entityUploadSamples, ref _entityUploadSampleCursor, System.Diagnostics.Stopwatch.GetTimestamp() - fdE0); @@ -8699,6 +9249,12 @@ public sealed class GameWindow : IDisposable if (_animatedEntities.Count > 0) TickAnimations((float)deltaSeconds); + // #188 — advance translucency fades UNCONDITIONALLY (not gated on + // _animatedEntities.Count): a one-shot open-cycle animation can + // finish and drop its entity from _animatedEntities before the + // fade's own Time has elapsed, but the ramp must keep running. + _translucencyFades.AdvanceAll((float)deltaSeconds); + // Phase G.1: weather state machine — deterministic per-day roll // + transitions + lightning flash. var cal = WorldTime.CurrentCalendar; @@ -8880,7 +9436,18 @@ public sealed class GameWindow : IDisposable // camera UBO set for point/spot lights so a wall's torches stay tied to // the wall as the camera moves. The SUN + ambient still flow through the // SceneLighting UBO built below (binding=1) — terrain/sky read those. - Lighting.BuildPointLightSnapshot(camPos); + // #176 root cause: the pool is anchored at the PLAYER (retail + // Render::insert_light sorts by Render::player_pos, 0x0054d1b0) and + // collected from ALL registered (=resident-cell) lights — it is a + // function of player position only, so camera rotation cannot change + // it. playerViewPos carries retail's no-player fallback (camPos). + // A7.L1: candidacy is additionally scoped to last frame's rendered + // visible-cell set (see _lightPoolVisibleCells) when available — the + // Town Network starvation fix. Unscoped (null) until the first indoor + // frame completes or after any outdoor-only frame. + Lighting.BuildPointLightSnapshot( + playerViewPos, + _lightPoolVisibleCellsValid ? _lightPoolVisibleCells : null); _wbDrawDispatcher?.SetSceneLights(Lighting.PointSnapshot); _envCellRenderer?.SetPointSnapshot(Lighting.PointSnapshot); // A7 Fix D (D-2) @@ -8947,13 +9514,38 @@ public sealed class GameWindow : IDisposable var envCellViewProj = camera.View * camera.Projection; _envCellFrustum?.Update(envCellViewProj); - HashSet? animatedIds = null; - if (_animatedEntities.Count > 0) - { - animatedIds = new HashSet(_animatedEntities.Count); - foreach (var k in _animatedEntities.Keys) - animatedIds.Add(k); - } + // MP-Alloc: reuse _animatedIdsScratch instead of `new`ing a + // HashSet every frame. Downstream consumers (WbDrawDispatcher. + // WalkEntitiesInto) treat null and an empty set identically, so an + // always-non-null (possibly empty) set is behaviorally the same as + // the old null-when-nothing-animated local. + // + // Every entity in _animatedEntities (i.e. every entity with a + // Sequencer) is added UNCONDITIONALLY: membership here is the + // "re-classify me every frame, don't use the Tier-1 static cache" + // flag, and the Tier-1 cache captures an entity's REST pose + + // opacity-1.0 exactly once. Any entity whose rendered state can + // depart that rest — a door held at its final OPEN frame, a wall + // held FADED-OUT by a TransparentPartHook — MUST stay on the + // per-frame path so the live sequencer pose + TranslucencyFadeManager + // opacity are read; otherwise it flips back to the stale cached + // closed/opaque state the instant its animation settles. + // + // DO NOT re-narrow this to "only if the current cycle is multi-frame" + // (the reverted IsEntityCurrentlyMoving gate, 2026-07-09): a settled + // one-shot hold IS pose-stable frame-to-frame, but stable at the + // HELD pose the cache does NOT contain — that is the door/fade + // flip-back. The per-frame re-classification cost that narrowing + // saved was a DEBUG-build artifact; Release is GPU-bound (the CPU + // work hides under GPU time), so the unconditional add is free where + // it matters. If a real Release CPU cost from static-prop + // re-classification is ever measured, gate on "entity is at its + // captured rest state" (default motion AND no active fade), never on + // "is mid-cycle". + _animatedIdsScratch.Clear(); + foreach (var k in _animatedEntities.Keys) + _animatedIdsScratch.Add(k); + HashSet? animatedIds = _animatedIdsScratch; // Phase G.1: sky renderer — draws the far-plane-infinity // celestial meshes FIRST so the rest of the scene z-tests @@ -9184,6 +9776,10 @@ public sealed class GameWindow : IDisposable CellLookup = id => _cellVisibility.TryGetCell(id, out var c) ? c : null, Camera = camera, CameraWorldPosition = camPos, + // (#176 correction: the former RebuildScopedLights callback — + // rebuilding the light pool from the frame's FLOOD — was the + // flicker mechanism and is deleted. The pool is built once per + // frame above, player-anchored, from all resident lights.) Frustum = frustum, PlayerLandblockId = playerLb, AnimatedEntityIds = animatedIds, @@ -9278,6 +9874,14 @@ public sealed class GameWindow : IDisposable envCellShellFilter = pviewResult.DrawableCells; _interiorPartition = pviewResult.Partition; + // A7.L1: snapshot this frame's drawn cell set for NEXT frame's light- + // pool scoping. DrawableCells is the renderer's own reused scratch set + // (cleared/rebuilt every DrawInside call) — copy it, don't hold a + // reference to it. + _lightPoolVisibleCells.Clear(); + _lightPoolVisibleCells.UnionWith(pviewResult.DrawableCells); + _lightPoolVisibleCellsValid = true; + // Flap root-cause apparatus (2026-06-07): per-frame, the EXACT Build inputs at 6 dp + // the resulting flood count. The live flap shows flood flipping 2↔6 at an eye/player // identical to cm; this answers whether the inputs differ sub-cm (jitter) or are @@ -9338,6 +9942,10 @@ public sealed class GameWindow : IDisposable neverCullLandblockId: playerLb, visibleCellIds: null, animatedEntityIds: animatedIds); + + // A7.L1: no indoor draw this frame — fail open (unscoped) rather than + // scoping next frame's light pool by a stale dungeon's cell ids. + _lightPoolVisibleCellsValid = false; } // Phase U.3: close the world-geometry clip bracket opened above. From here down the @@ -9693,7 +10301,10 @@ public sealed class GameWindow : IDisposable // panels but still over the 3D scene. Cheap when no // selection — internal early-return on null guid. _targetIndicator?.Render(); - _imguiBootstrap.Render(); + using (var _imguiStage = _frameProfiler.BeginStage(AcDream.App.Diagnostics.FrameStage.ImGui)) + { + _imguiBootstrap.Render(); + } } // Update the window title with performance stats every ~0.5s. @@ -9794,537 +10405,21 @@ public sealed class GameWindow : IDisposable if (ae.Sequencer is not null && serverGuid != 0 && serverGuid != _playerServerGuid - && _remoteDeadReckon.TryGetValue(serverGuid, out var rm)) + && _remoteDeadReckon.TryGetValue(serverGuid, out var rm) + // R4-V5 door fix companion: rm entries now also exist for + // static animated objects (doors/levers — created on first + // UM so the funnel can play their On/Off cycles). Those + // must NOT enter this dead-reckoning block: it force- + // asserts ground contact, zeroes/integrates velocity, and + // ground-resolves the body — position machinery for + // entities the server MOVES. "Has ever received an + // UpdatePosition" is exactly that distinction (there is + // nothing to dead-reckon between UPs that don't exist); + // their animation still plays via the sequencer's own + // TickAnimations advance. + && rm.LastServerPosTime > 0) { - if (IsPlayerGuid(serverGuid) && !rm.Airborne) - { - // ── L.3 M2/M3 (2026-05-05): queue + anim chase for grounded player remotes ── - // - // Per retail spec (docs/research/2026-05-04-l3-port/01-per-tick.md + - // 04-interp-manager.md + - // 05-position-manager-and-partarray.md): - // - // - For a grounded REMOTE player, m_velocityVector stays at 0. - // - apply_current_movement is NEVER called per tick on remotes - // (it's the local-player-only velocity feed). - // - UpdatePhysicsInternal's translation step is gated on - // velocity² > 0, so it's a no-op when body.Velocity = 0. - // - ResolveWithTransition is NOT called — the server already - // collision-resolved the broadcast position. - // - Per-tick body translation per retail UpdatePositionInternal: - // 1. CPartArray::Update writes anim root motion (body-local - // seqVel × dt) into the local frame. - // 2. PositionManager::adjust_offset OVERWRITES the local - // frame's origin with the queue catch-up vector when - // the queue is active and the head is not yet reached - // — REPLACE, not additive. - // 3. Frame::combine composes the local frame with the - // body's world pose. - // Net: catch-up replaces anim during the chase phase, anim - // stands when the queue is empty / head reached. PositionManager. - // ComputeOffset implements this exact REPLACE dichotomy. - // - // Airborne player remotes (rm.Airborne) and NPCs fall through to - // the legacy path below — unchanged from main per the M2 plan. - System.Numerics.Vector3 seqVel = ae.Sequencer?.CurrentVelocity - ?? System.Numerics.Vector3.Zero; - System.Numerics.Vector3 seqOmega = ae.Sequencer?.CurrentOmega - ?? System.Numerics.Vector3.Zero; - - // Step 1: transient flags (Contact + OnWalkable for grounded; - // Active always so UpdatePhysicsInternal doesn't early-return). - if (!rm.Airborne) - { - rm.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Contact - | AcDream.Core.Physics.TransientStateFlags.OnWalkable - | AcDream.Core.Physics.TransientStateFlags.Active; - - // For grounded remotes the body should not be carrying - // velocity — retail's m_velocityVector for a remote is - // 0 unless the server explicitly pushed one. Clear any - // stale velocity from a prior airborne arc so - // UpdatePhysicsInternal doesn't double-apply it on top - // of the seqVel-driven ComputeOffset translation below. - rm.Body.Velocity = System.Numerics.Vector3.Zero; - } - else - { - rm.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Active; - } - - // Step 2 (M3): queue + anim translation via PositionManager. - // ComputeOffset returns: - // - Vector3.Zero when queue is empty AND seqVel is zero - // (idle remote between UPs after head reached) — body - // stays still. - // - Direction × min(catchUpSpeed × dt, dist) when the - // queue is active and head is not reached — body chases - // the head waypoint at up to 2× motion-table max speed - // (REPLACES anim for this frame). - // - Anim root motion (seqVel × dt rotated into world) when - // the queue is empty OR head is within DesiredDistance — - // body advances with the locomotion cycle's baked - // velocity, keeping legs and body pace synchronized. - // - Blip-to-tail (tail − body) when fail_count > 3. - float maxSpeed = rm.Motion.GetMaxSpeed(); - // Slope-staircase fix (2026-05-05): sample terrain normal - // at the body's current XY so PositionManager can project - // the seqVel-only fallback onto the local slope. Without - // this, the queue-empty interval between UPs left Z flat - // (anim cycles bake Z=0 body-local) — visible ~5 Hz - // staircase when a remote runs up/down hills. The - // projection is a no-op on flat ground. - System.Numerics.Vector3? terrainNormal = _physicsEngine.SampleTerrainNormal( - rm.Body.Position.X, rm.Body.Position.Y); - - System.Numerics.Vector3 bodyPosBefore = rm.Body.Position; - System.Numerics.Vector3 offset = rm.Position.ComputeOffset( - dt: (double)dt, - currentBodyPosition: rm.Body.Position, - seqVel: seqVel, - ori: rm.Body.Orientation, - interp: rm.Interp, - maxSpeed: maxSpeed, - terrainNormal: terrainNormal); - rm.Body.Position += offset; - - // Slope-staircase diagnostic — gated on ACDREAM_SLOPE_DIAG=1. - // Prints per-tick body Z trajectory + queue state + projected - // offset.Z so we can grep before/after the fix and confirm Z - // changes continuously between UPs on slopes (no flat - // intervals followed by snaps). - if (System.Environment.GetEnvironmentVariable("ACDREAM_SLOPE_DIAG") == "1") - { - bool queueActive = rm.Interp.IsActive; - float nz = terrainNormal?.Z ?? 1.0f; - System.Console.WriteLine( - $"[SLOPE] guid={serverGuid:X8} bodyZ={bodyPosBefore.Z:F3}->{rm.Body.Position.Z:F3} " - + $"offset=({offset.X:F3},{offset.Y:F3},{offset.Z:F3}) " - + $"queue={queueActive} cpN.Z={nz:F3}"); - } - - // Step 2.5: angular velocity → body orientation. Prefer - // ObservedOmega (set explicitly in OnLiveMotionUpdated from - // the wire's TurnCommand + signed TurnSpeed) over the - // sequencer's synthesized omega: when the player runs in - // a circle ACE broadcasts ForwardCommand=RunForward AND - // TurnCommand=TurnLeft on the same UpdateMotion. The - // sequencer's animCycle picker chooses RunForward (legs - // running), whose synthesized CurrentOmega is zero. Body - // would not rotate between UPs and body.Velocity stays in - // an out-of-date world direction, producing the - // user-reported "rectangle when running circles" effect. - // ObservedOmega has the correct turn rate even when the - // visible cycle is RunForward. - System.Numerics.Vector3 omegaToApply = - rm.ObservedOmega.LengthSquared() > 1e-9f - ? rm.ObservedOmega - : seqOmega; - if (omegaToApply.LengthSquared() > 1e-9f) - { - float angleDelta = omegaToApply.Length() * (float)dt; - System.Numerics.Vector3 axis = System.Numerics.Vector3.Normalize(omegaToApply); - var rot = System.Numerics.Quaternion.CreateFromAxisAngle(axis, angleDelta); - rm.Body.Orientation = System.Numerics.Quaternion.Normalize( - System.Numerics.Quaternion.Concatenate(rm.Body.Orientation, rot)); - - // Diagnostic (ACDREAM_REMOTE_VEL_DIAG=1): print seqOmega direction - // once per remote per ~1 second so we can confirm whether the omega - // sign actually being applied matches the retail-observed turn - // direction. Z>0 = CCW (TurnLeft); Z<0 = CW (TurnRight). - if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") - { - double nowSec = (System.DateTime.UtcNow - System.DateTime.UnixEpoch).TotalSeconds; - if (nowSec - rm.LastOmegaDiagLogTime > 0.5) - { - uint seqMotion = ae.Sequencer?.CurrentMotion ?? 0; - System.Console.WriteLine( - $"[OMEGA_DIAG] guid={serverGuid:X8} motion=0x{seqMotion:X8} " - + $"omegaApplied.Z={omegaToApply.Z:F3} " - + $"(seq.Z={seqOmega.Z:F3} obs.Z={rm.ObservedOmega.Z:F3}) " - + $"(Z>0=CCW=TurnLeft, Z<0=CW=TurnRight)"); - rm.LastOmegaDiagLogTime = nowSec; - } - } - } - - // Step 3: calc_acceleration sets body.Acceleration from the Gravity flag - // (mirrors retail CPhysicsObj::calc_acceleration @ FUN_00511420, called - // per-frame in update_object). Without this, body.Acceleration stays stale - // or zero → gravity never decays jump velocity → endless rise on jumps. - rm.Body.calc_acceleration(); - - // Step 4: physics integration (Euler: pos += vel*dt + 0.5*accel*dt²). - rm.Body.UpdatePhysicsInternal(dt); - - // Step 4b INTENTIONALLY OMITTED in M2: - // ResolveWithTransition is NOT called — the server has - // already collision-resolved the broadcast position, and - // running our sweep on tiny per-frame queue catch-up deltas - // amplifies micro-bounces into visible position blips - // (issue #40 staircase + flat-ground blips). Per retail - // spec the per-tick body advance for a remote is purely - // the queue catch-up; collision is the sender's problem. - // - // Step 5 (landing fallback) is unreachable in this branch — - // we're gated on !rm.Airborne. Airborne player remotes fall - // through to the legacy path below where K-fix15 still fires. - - // Step 6: speed-overshoot diagnostic (ACDREAM_REMOTE_VEL_DIAG=1). - // Track the maximum sequencer velocity magnitude seen since - // the last UpdatePosition arrival (carried on the - // RemoteMotion struct), then on each UP arrival the - // OnLivePositionUpdated path prints the comparison against - // the server's actual broadcast pace - // ((LastServerPos - PrevServerPos) / Δt). This guarantees - // both sides are sampled during the same window and the - // ratio reflects the real overshoot. - if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") - { - // body.Velocity is now the source of bulk translation - // (set above by apply_current_movement). Track its - // magnitude so VEL_DIAG can compare against the actual - // server broadcast pace. - float seqSpeedNow = rm.Body.Velocity.Length(); - if (seqSpeedNow > rm.MaxSeqSpeedSinceLastUP) - rm.MaxSeqSpeedSinceLastUP = seqSpeedNow; - } - - ae.Entity.SetPosition(rm.Body.Position); // A.5 T18: SetPosition propagates AabbDirty - if (rm.CellId != 0) - ae.Entity.ParentCellId = rm.CellId; - ae.Entity.Rotation = rm.Body.Orientation; - } - else - { - // ── LEGACY PATH (UNCHANGED — kept until Task 8 cleanup) ── - // - // Stop detection is handled explicitly on packet receipt: - // - UpdateMotion with ForwardCommand flag CLEARED → Ready. - // - UpdatePosition with HasVelocity flag CLEARED → StopCompletely. - // Both map to retail's "flag-absent = Invalid = reset to - // default" semantics (FUN_0051F260 bulk-copy). No timer-based - // inference needed — the server sends the right signal every - // time a remote stops. - - // Retail per-tick motion pipeline applied to every remote. - // Mirrors retail FUN_00515020 update_object → FUN_00513730 - // UpdatePositionInternal → FUN_005111D0 UpdatePhysicsInternal: - // - // 1. apply_current_movement (FUN_00529210) — recomputes - // body.Velocity from InterpretedState via get_state_velocity. - // 2. Pull omega from the sequencer (baked MotionData.Omega - // for TurnRight / TurnLeft cycles, scaled by speedMod). - // 3. body.update_object(now) — Euler-integrates - // position += Velocity × dt + 0.5 × Accel × dt² AND - // orientation += omega × dt. - // - // On UpdatePosition receipt we hard-snap body.Position and - // body.Orientation — if integration matched server physics, - // each snap is small/invisible. - double nowSec = (System.DateTime.UtcNow - System.DateTime.UnixEpoch).TotalSeconds; - - // Step 1: re-apply current motion commands → body.Velocity. - // Forces OnWalkable + Contact so the gate in apply_current_movement - // always succeeds (remotes are server-authoritative; we don't - // simulate airborne physics for them). - // - // K-fix9 (2026-04-26): SKIP this when the remote is airborne. - // Otherwise the force-OnWalkable + apply_current_movement - // path stomps the +Z velocity we set in OnLiveVectorUpdated, - // and gravity never gets to integrate the arc. The airborne - // body keeps the launch velocity from the VectorUpdate; - // UpdatePhysicsInternal below applies gravity each tick; - // the next UpdatePosition snaps to the new ground location - // and re-grounds. - if (!rm.Airborne) - { - rm.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Contact - | AcDream.Core.Physics.TransientStateFlags.OnWalkable - | AcDream.Core.Physics.TransientStateFlags.Active; - if (!IsPlayerGuid(serverGuid) && rm.HasServerVelocity) - { - double velocityAge = nowSec - rm.LastServerPosTime; - if (velocityAge > ServerControlledVelocityStaleSeconds) - { - rm.ServerVelocity = System.Numerics.Vector3.Zero; - rm.HasServerVelocity = false; - rm.Body.Velocity = System.Numerics.Vector3.Zero; - ApplyServerControlledVelocityCycle( - serverGuid, - ae, - rm, - System.Numerics.Vector3.Zero); - } - else - { - rm.Body.Velocity = rm.ServerVelocity; - } - } - else if (!IsPlayerGuid(serverGuid) && rm.ServerMoveToActive - && rm.HasMoveToDestination) - { - // Phase L.1c port of retail MoveToManager per-tick - // steering (HandleMoveToPosition @ 0x00529d80). - // Steer body orientation toward the latest - // server-supplied destination, then let - // apply_current_movement set Velocity from the - // RunForward cycle through the now-correct heading. - - // Stale-destination guard (2026-04-28): if no - // MoveTo packet has refreshed the destination - // recently, the entity has likely left our - // streaming view or the server cancelled the - // move without us seeing the cancel UM. Continuing - // to steer toward a stale point produces the - // "monster runs in place after popping back into - // view" symptom. Clear and stand down. - double moveToAge = nowSec - rm.LastMoveToPacketTime; - if (moveToAge > AcDream.Core.Physics.RemoteMoveToDriver.StaleDestinationSeconds) - { - rm.HasMoveToDestination = false; - rm.Body.Velocity = System.Numerics.Vector3.Zero; - } - else - { - var driveResult = AcDream.Core.Physics.RemoteMoveToDriver - .Drive( - rm.Body.Position, - rm.Body.Orientation, - rm.MoveToDestinationWorld, - rm.MoveToMinDistance, - rm.MoveToDistanceToObject, - (float)dt, - rm.MoveToMoveTowards, - out var steeredOrientation); - rm.Body.Orientation = steeredOrientation; - - if (driveResult == AcDream.Core.Physics.RemoteMoveToDriver - .DriveResult.Arrived) - { - // Within arrival window — zero velocity until the - // next MoveTo packet refreshes the destination - // (or the server explicitly stops us with an - // interpreted-motion UM cmd=Ready). - rm.Body.Velocity = System.Numerics.Vector3.Zero; - } - else - { - // Steering active — apply_current_movement reads - // InterpretedState.ForwardCommand=RunForward (set - // when the MoveTo packet arrived) and emits - // velocity along +Y in body local space. Our - // updated orientation rotates that into the right - // world direction toward the target. - rm.Motion.apply_current_movement(cancelMoveTo: false, allowJump: false); - - // Clamp horizontal velocity so we don't overshoot - // the arrival threshold during the final tick of - // approach. Without this, a 4 m/s body advances - // ~6 cm/tick and visibly runs slightly through - // the target before the swing UM lands. - float arrivalThreshold = rm.MoveToMoveTowards - ? rm.MoveToDistanceToObject - : rm.MoveToMinDistance; - rm.Body.Velocity = AcDream.Core.Physics.RemoteMoveToDriver - .ClampApproachVelocity( - rm.Body.Position, - rm.Body.Velocity, - rm.MoveToDestinationWorld, - arrivalThreshold, - (float)dt, - rm.MoveToMoveTowards); - } - } - } - else if (!IsPlayerGuid(serverGuid) && rm.ServerMoveToActive) - { - // MoveTo flag set but we haven't seen a path payload - // yet (e.g. truncated packet, or a brand-new entity - // whose first cycle UM is still in flight). Hold - // velocity at zero — same conservative stance as the - // 882a07c stabilizer for incomplete state. - rm.Body.Velocity = System.Numerics.Vector3.Zero; - } - else - { - rm.Motion.apply_current_movement(cancelMoveTo: false, allowJump: false); - } - } - else - { - // Airborne — keep Active flag (so UpdatePhysicsInternal - // doesn't early-return) but DON'T set Contact / OnWalkable. - rm.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Active; - } - - // Step 2: integrate rotation manually per tick. We can't - // rely on PhysicsBody.update_object here — its MinQuantum - // gate (1/30 s) causes it to SKIP integration when our - // 60fps render dt (~0.016s) is below the quantum, meaning - // rotation never advances. Measured snap per UP was ~129° - // = the full expected 1s × 2.24 rad/s, confirming zero - // between-tick rotation. - // - // Manual integration matches retail's FUN_005256b0 - // apply_physics (Orientation *= quat(ω × dt)). Use - // ObservedOmega derived from server UP rotation deltas so - // the rate exactly matches server physics — hard-snap on - // next UP becomes invisible by construction. - rm.Body.Omega = System.Numerics.Vector3.Zero; // don't double-integrate in update_object - if (rm.ObservedOmega.LengthSquared() > 1e-8f) - { - float omegaMag = rm.ObservedOmega.Length(); - var axis = rm.ObservedOmega / omegaMag; - float angle = omegaMag * dt; - var deltaRot = System.Numerics.Quaternion.CreateFromAxisAngle(axis, angle); - rm.Body.Orientation = System.Numerics.Quaternion.Normalize( - System.Numerics.Quaternion.Multiply(rm.Body.Orientation, deltaRot)); - } - - // Step 3: integrate physics — retail FUN_005111D0 - // UpdatePhysicsInternal. Pure Euler: - // position += velocity × dt + 0.5 × accel × dt² - // - // Call UpdatePhysicsInternal DIRECTLY rather than via - // PhysicsBody.update_object (FUN_00515020). update_object gates - // on MinQuantum = 1/30s: at our 60fps render tick (~16ms), - // deltaTime < MinQuantum → early return AND LastUpdateTime is - // NOT advanced. Net effect: position never integrates between - // UpdatePositions and the only Body.Position changes come - // from the UP hard-snap, producing a visible teleport-stride - // on slopes (the "staircase" the user reported). - // - // PlayerMovementController.cs:358 calls UpdatePhysicsInternal - // directly for the same reason. Remote motion mirrors that. - // Omega is already integrated manually above, so we zero it - // here to prevent UpdatePhysicsInternal's own omega pass from - // double-integrating. - var preIntegratePos = rm.Body.Position; - rm.Body.calc_acceleration(); - rm.Body.UpdatePhysicsInternal(dt); - var postIntegratePos = rm.Body.Position; - - // Step 4: collision sweep — retail FUN_00514B90 → - // FUN_005148A0 → Transition::FindTransitionalPosition. - // Projects the sphere from preIntegratePos to postIntegratePos - // through the BSP + terrain, resolving: - // - terrain Z snap along the slope (fixes the "staircase" where - // horizontal Euler motion up a slope sinks into rising ground - // until the next UP pops it up) - // - indoor BSP walls (via the 6-path dispatcher in BSPQuery) - // - object collisions via ShadowObjectRegistry - // - step-up / step-down against walkable ledges - // ResolveWithTransition is the same call PlayerMovementController - // uses for the local player; remotes now get the full retail - // treatment between UpdatePositions instead of pure kinematics. - // - // Skipped when rm.CellId == 0 (no UP landed yet — can't build - // a SpherePath without a starting cell). One-frame grace until - // the first UP arrives; harmless because the entity is - // server-freshly-spawned at a valid Z anyway. - if (rm.CellId != 0 && _physicsEngine.LandblockCount > 0) - { - // Sphere dims match local-player defaults (human Setup - // bounds — ~0.48m radius, ~1.2m height). Good enough for - // grounded humanoid remotes; can be setup-derived later - // if creatures of wildly different sizes need different - // collision profiles. - var resolveResult = _physicsEngine.ResolveWithTransition( - preIntegratePos, postIntegratePos, rm.CellId, - sphereRadius: 0.48f, - sphereHeight: 1.2f, - stepUpHeight: 0.4f, // L.2.3a: retail human-scale, was 2.0f - stepDownHeight: 0.4f, // L.2.3a: retail human-scale, was 0.04f - // K-fix9 (2026-04-26): mirror the K-fix7 gate — - // airborne remotes must NOT pre-seed the - // ContactPlane, otherwise AdjustOffset's snap-to-plane - // branch zeroes the +Z offset every step (same bug - // we hit on the local jump). - isOnGround: !rm.Airborne, - body: rm.Body, // persist ContactPlane across frames for slope tracking - // Retail default physics state includes EdgeSlide. - // Remote dead-reckoning should exercise the same - // edge/cliff branch as local movement. - moverFlags: AcDream.Core.Physics.ObjectInfoState.EdgeSlide, - // Fix #42 (2026-05-05): skip the moving remote's - // own ShadowEntry. _animatedEntities is keyed by - // entity.Id so kv.Key matches the EntityId the - // ShadowObjectRegistry has for this remote. - // Without this, the airborne sweep collides with - // the remote's own cylinder and produces ~1m of - // horizontal drift on the first jump frame - // (validated by [SWEEP-OBJ] traces). - movingEntityId: kv.Key); - - rm.Body.Position = resolveResult.Position; - if (resolveResult.CellId != 0) - rm.CellId = resolveResult.CellId; - - // K-fix15 (2026-04-26): post-resolve landing - // detection for airborne remotes. Mirrors - // PlayerMovementController's local-player landing - // path: when the resolver says we're on ground AND - // velocity is no longer pointing up, transition - // back to grounded — clear Airborne, restore - // Contact + OnWalkable, remove Gravity, zero any - // residual downward velocity, and trigger - // HitGround so the sequencer can swap from - // Falling → idle/locomotion. Without this, an - // airborne remote falls through the floor (gravity - // keeps building Velocity.Z negative until the - // sphere-sweep clamps each frame, but Airborne - // stays true forever). - if (rm.Airborne - && resolveResult.IsOnGround - && rm.Body.Velocity.Z <= 0f) - { - rm.Airborne = false; - rm.Body.TransientState |= AcDream.Core.Physics.TransientStateFlags.Contact - | AcDream.Core.Physics.TransientStateFlags.OnWalkable; - rm.Body.State &= ~AcDream.Core.Physics.PhysicsStateFlags.Gravity; - rm.Body.Velocity = new System.Numerics.Vector3( - rm.Body.Velocity.X, rm.Body.Velocity.Y, 0f); - rm.Motion.HitGround(); - - // K-fix17 (2026-04-26): reset the sequencer cycle - // from Falling back to whatever the interpreted - // motion state says they should be doing now. - // Without this, the remote stays in the Falling - // pose forever (legs folded) until the next - // server-sent UpdateMotion arrives. Use the - // sequencer's current style (preserved across - // jump) and pick the cycle from - // InterpretedState.ForwardCommand: Ready - // (idle), WalkForward, RunForward, WalkBackward. - // SideStep / Turn aren't strict locomotion - // priorities — the next UM the server sends will - // refine the cycle if the player is mid-strafe - // when they land; this just gets the legs out - // of Falling immediately. - if (ae.Sequencer is not null) - { - uint style = ae.Sequencer.CurrentStyle != 0 - ? ae.Sequencer.CurrentStyle - : 0x8000003Du; - uint landingCmd = rm.Motion.InterpretedState.ForwardCommand; - if (landingCmd == 0) - landingCmd = AcDream.Core.Physics.MotionCommand.Ready; - float landingSpeed = rm.Motion.InterpretedState.ForwardSpeed; - if (landingSpeed <= 0f) landingSpeed = 1f; - ae.Sequencer.SetCycle(style, landingCmd, landingSpeed); - } - - if (Environment.GetEnvironmentVariable("ACDREAM_DUMP_MOTION") == "1") - Console.WriteLine($"VU.land guid=0x{serverGuid:X8} Z={rm.Body.Position.Z:F2}"); - } - } - - ae.Entity.SetPosition(rm.Body.Position); // A.5 T18: SetPosition propagates AabbDirty - if (rm.CellId != 0) - ae.Entity.ParentCellId = rm.CellId; - ae.Entity.Rotation = rm.Body.Orientation; - } + _remotePhysicsUpdater.Tick(rm, ae, dt, _liveCenterX, _liveCenterY); } // ── Get per-part (origin, orientation) from either sequencer or legacy ── @@ -10373,10 +10468,53 @@ public sealed class GameWindow : IDisposable } seqFrames = ae.Sequencer.Advance(dt); + // R3-W2: bind the MotionDone seam once per sequencer to the + // entity's REAL consumer — the MotionInterpreter's + // pending_motions pop (retail CPhysicsObj::MotionDone + // 0x0050fdb0 → MovementManager → CMotionInterp::MotionDone + // 0x00527ec0; r3-port-plan.md §4). Remotes bind their + // RemoteMotion interp; the local player binds the + // controller's; interp-less entities (doors, statics) keep + // the diagnostic recorder only. + if (ae.Sequencer.MotionDoneTarget is null) + { + uint mdGuid = serverGuid; + // Resolve the interp AT FIRE TIME, not bind time: a + // remote's RemoteMotion is created on its first UM/UP, + // which can arrive AFTER the first anim tick — an + // eagerly-captured null would silently drop completions + // forever. MotionDone fires per completed motion (rare), + // so the dictionary lookup is negligible. + ae.Sequencer.MotionDoneTarget = (m, ok) => + { + AcDream.Core.Physics.MotionInterpreter? interp = null; + if (mdGuid != 0 && mdGuid == _playerServerGuid) + interp = _playerController?.Motion; + else if (mdGuid != 0 + && _remoteDeadReckon.TryGetValue(mdGuid, out var rmFire)) + interp = rmFire.Motion; + + interp?.MotionDone(m, ok); + if (System.Environment.GetEnvironmentVariable("ACDREAM_DUMP_MOTION") == "1") + System.Console.WriteLine( + $"[MOTIONDONE] guid={mdGuid:X8} motion=0x{m:X8} success={ok} " + + $"pending={(interp?.MotionsPending() ?? false)}"); + }; + } + // Phase E.1: drain animation hooks (footstep sounds, attack // damage frames, particle spawns, part swaps, etc.) and fan // them out to registered subsystems via the hook router. // Mirrors ACE's PhysicsObj.add_anim_hook dispatch path. + // + // R2-Q4 queue-drain wiring (r2-port-plan.md §4, the G6 seam; + // per-tick PLACEMENT provisional until R6 installs retail's + // UpdateObjectInternal order): each drained AnimDone hook + // advances the entity's MotionTableManager countdown + // (retail AnimDoneHook::Execute 0x00526c20 → Hook_AnimDone + // 0x0050fda0 → CPartArray::AnimationDone(1)), and UseTime + // runs once per tick to sweep zero-tick queue entries + // (retail call sites 0x00517d57/0x00517d67). var hooks = ae.Sequencer.ConsumePendingHooks(); if (hooks.Count > 0) { @@ -10386,8 +10524,11 @@ public sealed class GameWindow : IDisposable var hook = hooks[hi]; if (hook is null) continue; _hookRouter.OnHook(ae.Entity.Id, worldPos, hook); + if (hook is DatReaderWriter.Types.AnimationDoneHook) + ae.Sequencer.Manager.AnimationDone(success: true); } } + ae.Sequencer.Manager.UseTime(); } else { @@ -10460,7 +10601,13 @@ public sealed class GameWindow : IDisposable } } - var newMeshRefs = new List(partCount); + // MP-Alloc (2026-07-05): reuse the entity's cached MeshRefs list + // instead of allocating a fresh List(partCount) every + // tick (see AnimatedEntity.MeshRefsScratch for the safety + // argument — single-threaded tick-before-draw ordering, no + // consumer caches a stale reference or diffs list identity). + var newMeshRefs = ae.MeshRefsScratch; + newMeshRefs.Clear(); var scaleMat = ae.Scale == 1.0f ? System.Numerics.Matrix4x4.Identity : System.Numerics.Matrix4x4.CreateScale(ae.Scale); @@ -10539,197 +10686,27 @@ public sealed class GameWindow : IDisposable }); } + // Re-assigning the SAME list reference every tick is cheap (a + // property store) and keeps this line's shape identical to the + // pre-MP-Alloc code for anyone grepping the history. ae.Entity.MeshRefs = newMeshRefs; } } - /// - /// Phase B.2: switch the locally-controlled player entity's animation cycle - /// to match the current motion command. Only re-resolves when the command - /// actually changes (forward → run, idle → walk, etc.) to avoid re-building - /// the animation entry every frame. - /// - /// - /// Action motions (Jump, FallDown, emotes, attacks) are routed through - /// — they - /// live in the motion table's Modifiers dict, not the Cycles dict, and - /// are inserted into the queue on top of the current cycle instead of - /// replacing it. - /// - /// - private void UpdatePlayerAnimation(AcDream.App.Input.MovementResult result) - { - if (_dats is null) return; + // IsEntityCurrentlyMoving REMOVED (2026-07-09): it powered a cache-bypass + // narrowing that dropped settled-open doors / faded-out walls back onto the + // stale Tier-1 rest-pose cache entry (the door/fade "flip-back"). See the + // animatedIds build site — every Sequencer entity is now added + // unconditionally, which is the known-good pre-optimization behavior. - // ── Airborne SubState (Falling) ──────────────────────────────────── - // - // Retail models the jump-animation as a SubState swap to - // MotionCommand.Falling (0x40000015) while airborne, NOT as an - // Action overlay. Empirically verified: Links[(NonCombat,RunForward)] - // has 3 transitions including 0x40000015 Falling. The SubState cycle - // for Falling lives in Cycles[(style, Falling)] and loops while - // airborne. On land, we transition back to whatever SubState the - // motion input implies (Ready / WalkForward / RunForward). - // - // Implementation: force animCommand = Falling when airborne; the - // existing SetCycle pathway resolves the link + cycle correctly and - // the transition back happens naturally when airborne becomes false. - - // Determine the animation command: airborne takes priority (Falling - // SubState), then forward, sidestep, turn, then idle (Ready 0x41000003). - // - // Airborne → Falling (retail behavior; see airborne note above). - // Otherwise: LocalAnimationCommand (RunForward when running) preferred, - // falling back to wire ForwardCommand (WalkForward / WalkBackward). - uint animCommand; - if (!result.IsOnGround) - animCommand = AcDream.Core.Physics.MotionCommand.Falling; - else if (result.LocalAnimationCommand is { } localCmd) - animCommand = localCmd; - else if (result.ForwardCommand is { } fwd) - animCommand = fwd; - else if (result.SidestepCommand is { } ss) - animCommand = ss; - else if (result.TurnCommand is { } tc) - animCommand = tc; - else - animCommand = 0x41000003u; // Ready (idle) - - // Fast path: no command change AND speed delta is negligible. If - // command is unchanged but speed changed, we must still propagate - // so the sequencer can MultiplyCyclicFramerate — keeping the run - // loop smooth without restart. - // K-fix5 (2026-04-26): use LocalAnimationSpeed (cycle pace) NOT - // ForwardSpeed (wire field) — backward+run + strafe+run keep - // ForwardSpeed/SidestepSpeed at 1.0 for ACE compatibility but - // need the local cycle to play at runRate × so the animation - // matches the actual movement velocity. - float newSpeed = result.LocalAnimationSpeed; - bool sameCmd = animCommand == _playerCurrentAnimCommand; - bool sameSpeed = MathF.Abs(newSpeed - _playerCurrentAnimSpeed) < 1e-3f; - if (sameCmd && sameSpeed) return; - _playerCurrentAnimCommand = animCommand; - _playerCurrentAnimSpeed = newSpeed; - - if (!_entitiesByServerGuid.TryGetValue(_playerServerGuid, out var pe)) return; - - // The player entity may not be in _animatedEntities if a post-spawn - // UpdateMotion removed it (Phase 6.8 pattern). In that case, load - // the Setup and re-register. This is the player's own character so - // we always want it animated in player mode. - if (!_animatedEntities.TryGetValue(pe.Id, out var ae)) - { - // A.5 T10: lock around _dats.Get — worker thread may be - // building a landblock mesh concurrently. DatBinReader's - // shared buffer position would corrupt without serialization. - DatReaderWriter.DBObjs.Setup? setup; - lock (_datLock) { setup = _dats.Get(pe.SourceGfxObjOrSetupId); } - if (setup is null) return; - _physicsDataCache.CacheSetup(pe.SourceGfxObjOrSetupId, setup); - - // Build a minimal part template from the entity's current MeshRefs. - var template = new (uint, IReadOnlyDictionary?)[pe.MeshRefs.Count]; - for (int i = 0; i < pe.MeshRefs.Count; i++) - template[i] = (pe.MeshRefs[i].GfxObjId, pe.MeshRefs[i].SurfaceOverrides); - - ae = new AnimatedEntity - { - Entity = pe, - Setup = setup, - Animation = null!, // filled below - LowFrame = 0, - HighFrame = 0, - Framerate = 30f, - Scale = 1f, - PartTemplate = template, - CurrFrame = 0f, - }; - _animatedEntities[pe.Id] = ae; - } - - // The motion table cycle key is (style << 16) | (command & 0xFFFFFF). - // Without a stance override, the resolver uses the table default - // (which always maps to the idle/Ready cycle regardless of command). - // Pass the NonCombat stance (0x003D) so the resolver builds the - // correct cycle key for walk/run/turn commands. - ushort cmdOverride = (ushort)(animCommand & 0xFFFFu); - const ushort NonCombatStance = 0x003D; - var cycle = AcDream.Core.Meshing.MotionResolver.GetIdleCycle( - ae.Setup, _dats, - motionTableIdOverride: _playerMotionTableId, - stanceOverride: NonCombatStance, - commandOverride: cmdOverride); - - // Sequencer path: SetCycle handles adjust_motion internally - // (TurnLeft→TurnRight with negative speed, etc.) - // - // Speed scaling: K-fix5 (2026-04-26) — use LocalAnimationSpeed - // (the PlayerMovementController-computed cycle pace) instead of - // the wire ForwardSpeed. Forward+Run = runRate; Backward+Run = - // runRate (where ForwardSpeed is the ACE-compatible 1.0); - // Strafe+Run = runRate (where SidestepSpeed is 1.0). Anything - // not in run = 1.0. The animation cycle now visually matches - // the movement velocity in every direction. - if (ae.Sequencer is not null) - { - uint fullStyle = 0x80000000u | (uint)NonCombatStance; - float animSpeed = result.LocalAnimationSpeed > 0f - ? result.LocalAnimationSpeed - : 1f; - // ACDREAM_ANIM_SPEED_SCALE: optional visual-pacing knob. Retail's - // animation framerate scales linearly with speedMod (r03 §8.3), - // and our speedMod = runRate. If the visual feel doesn't match - // retail, override via env var (default 1.0 = no change). - float animScale = 1.0f; - if (float.TryParse( - Environment.GetEnvironmentVariable("ACDREAM_ANIM_SPEED_SCALE"), - System.Globalization.NumberStyles.Float, - System.Globalization.CultureInfo.InvariantCulture, - out var s) && s > 0f) - { - animScale = s; - } - // K-fix18 (2026-04-26): when transitioning into Falling - // (jump start), skip the link so the legs engage Falling - // immediately. Without this the local player visibly - // stood still for ~100 ms at the start of every jump - // while the RunForward→Falling transition link drained. - // For everything else (Walk → Run, Run → Ready, etc.) we - // keep the link so transitions stay smooth. - bool skipLink = animCommand == AcDream.Core.Physics.MotionCommand.Falling; - - // #45 (2026-05-06): scale sidestep speedMod to match ACE's - // wire formula. PlayerMovementController hands us a raw - // localAnimSpeed (1.0 slow / runRate fast), but ACE's - // BroadcastMovement converts SidestepSpeed via - // `speed × 3.12 / 1.25 × 0.5` - // (Network/Motion/MovementData.cs:124-131). Without the - // matching multiplier here, the local sidestep cycle plays - // at speedMod = 1.0 while the observer-side cycle plays at - // ~1.248 — local strafe visibly slower than retail (user - // report at #45 close-out of #39). - // Factor = WalkAnimSpeed / SidestepAnimSpeed × 0.5 - // = 3.12 / 1.25 × 0.5 = 1.248. - uint cmdLow = animCommand & 0xFFu; - if (cmdLow == 0x0Fu /* SideStepRight */ || cmdLow == 0x10u /* SideStepLeft */) - { - animSpeed *= AcDream.Core.Physics.MotionInterpreter.WalkAnimSpeed - / AcDream.Core.Physics.MotionInterpreter.SidestepAnimSpeed - * 0.5f; - } - - ae.Sequencer.SetCycle(fullStyle, animCommand, animSpeed * animScale, - skipTransitionLink: skipLink); - } - - // Legacy path: update the manual slerp fields (for entities without sequencer) - if (cycle is null || cycle.Framerate == 0f || cycle.HighFrame <= cycle.LowFrame) return; - ae.Animation = cycle.Animation; - ae.LowFrame = Math.Max(0, cycle.LowFrame); - ae.HighFrame = Math.Min(cycle.HighFrame, cycle.Animation.PartFrames.Count - 1); - ae.Framerate = cycle.Framerate; - ae.CurrFrame = ae.LowFrame; - } + // R3-W6: UpdatePlayerAnimation DELETED — the player's sequencer is + // driven through the SAME MotionTableDispatchSink/DefaultSink funnel + // remotes use (edge-driven DoMotion/StopMotion/set_hold_run in + // PlayerMovementController; airborne-Falling falls out of + // contact_allows_move + apply_current_movement). The #45 sidestep + // 1.248x factor + ACDREAM_ANIM_SPEED_SCALE died with it — + // EXPECTED-DIFF: local sidestep pacing now matches how remotes have + // always played (w6-cutover-map.md R3). /// /// Phase 3a — re-roll the active DayGroup whenever the current @@ -11279,6 +11256,22 @@ public sealed class GameWindow : IDisposable world[v].Z += AcDream.App.Rendering.PortalVisibilityBuilder.ShellDrawLiftZ; } + // #176 seam-draw probe: a sealed dungeon must emit ZERO depth fans + // (only OtherCellId==0xFFFF portals reach here) — any line in a + // target cell is a finding (a depth stamp fighting the shell floor). + if (AcDream.Core.Rendering.RenderingDiagnostics.ProbeSeamDrawEnabled + && AcDream.Core.Rendering.RenderingDiagnostics.SeamDrawTargetCells.Contains(sliceCtx.CellId)) + { + float seamZMin = float.MaxValue, seamZMax = float.MinValue; + for (int v = 0; v < n; v++) + { + seamZMin = System.Math.Min(seamZMin, world[v].Z); + seamZMax = System.Math.Max(seamZMax, world[v].Z); + } + Console.WriteLine(System.FormattableString.Invariant( + $"[seam-mask] t={System.Environment.TickCount64} cell=0x{sliceCtx.CellId:X8} portal={i} far={forceFarZ} n={n} z=[{seamZMin:F3},{seamZMax:F3}]")); + } + _portalDepthMask.DrawDepthFan(world[..n], viewProjection, sliceCtx.Slice.Planes, forceFarZ); } } @@ -11952,7 +11945,10 @@ public sealed class GameWindow : IDisposable _worldState.TryGetLandblock(id, out var lb)) { foreach (var ent in lb!.Entities) + { _lightingSink.UnregisterOwner(ent.Id); + _translucencyFades.ClearEntity(ent.Id); // #188 + } } _terrain?.RemoveLandblock(id); _physicsEngine.RemoveLandblock(id); @@ -12308,7 +12304,6 @@ public sealed class GameWindow : IDisposable _playerController = null; _chaseCamera = null; _retailChaseCamera = null; - _playerCurrentAnimCommand = null; } else _window!.Close(); @@ -12566,15 +12561,16 @@ public sealed class GameWindow : IDisposable return; } - // B.6 (2026-05-15): install speculative local auto-walk against - // the target so close-range Use rotates the body to face before - // the action fires. For FAR targets, ACE's CreateMoveToChain - // (Player_Move.cs:37-179) takes over via inbound MovementType=6 - // and our overlay is overwritten by ACE's wire-supplied radius. + // B.6/R4-V5: install a speculative local TurnToObject/MoveToObject + // through the player's MoveToManager so close-range Use rotates the + // body to face before the action fires. For FAR targets, ACE's + // CreateMoveToChain (Player_Move.cs:37-179) takes over via inbound + // MovementType=6, whose PerformMovement re-targets with ACE's + // wire-supplied radius. // - // 2026-05-16: simplified — close-range deferral now fires the - // wire packet ONCE on AutoWalkArrived (turn-first done), not a - // retry of an earlier failed send. No re-send path. + // Close-range deferral fires the wire packet ONCE on + // MoveToComplete(None) (turn-first done), not a retry of an + // earlier failed send. No re-send path. bool closeRange = IsCloseRangeTarget(guid); InstallSpeculativeTurnToTarget(guid); @@ -12691,13 +12687,14 @@ public sealed class GameWindow : IDisposable } /// - /// 2026-05-16. Fires the deferred close-range Use/PickUp action - /// once the local auto-walk overlay reports arrival (i.e. the body - /// has finished rotating to face the target). Unlike the old - /// OnAutoWalkArrivedReSendAction, this is a FIRST send — not a - /// retry of an earlier failed send. Far-range Use/PickUp paths - /// fire the wire packet immediately at / time - /// and never touch _pendingPostArrivalAction. + /// 2026-05-16 / R4-V5. Fires the deferred close-range Use/PickUp action + /// once the player's moveto completes naturally (the MoveToManager's + /// MoveToComplete(None) client seam — the body has finished + /// rotating to face / walking to the target; a user-input cancel never + /// fires it). This is a FIRST send — not a retry of an earlier failed + /// send. Far-range Use/PickUp paths fire the wire packet immediately at + /// / time and never touch + /// _pendingPostArrivalAction. /// private void OnAutoWalkArrivedSendDeferredAction() { @@ -12782,12 +12779,14 @@ public sealed class GameWindow : IDisposable private void InstallSpeculativeTurnToTarget(uint targetGuid) { - if (_playerController is null) return; + if (_playerController is not { } pc || pc.MoveTo is null) return; if (!_entitiesByServerGuid.TryGetValue(targetGuid, out var entity)) return; // Per-type use radius — same heuristic as the picker's - // radiusForGuid callback. + // radiusForGuid callback (register AP-23, re-anchored here by + // R4-V5; survives because ACE's close-branch broadcasts nothing + // actionable). float useRadius = 0.6f; if ((LiveItemType(targetGuid) & AcDream.Core.Items.ItemType.Creature) != 0) { @@ -12802,13 +12801,14 @@ public sealed class GameWindow : IDisposable } // Issue #77 fix (2026-05-18) — predict ACE's CanCharge bit - // from local distance so the speculative auto-walk uses the + // from local distance so the speculative moveto uses the // same walk/run as the wire-triggered overwrite that arrives // moments later. ACE's Creature.SetWalkRunThreshold sets // CanCharge when player→target distance >= WalkRunThreshold / // 2 = 7.5 m (the 15 m wire default halved). Match exactly so // the speculative install doesn't flip walk↔run when ACE's - // MoveToObject broadcast overwrites it. + // MoveToObject broadcast overwrites it (PerformMovement + // cancels + restarts — retail-consistent re-target). const float AceCanChargeDistance = 7.5f; var bodyPos = _playerController.Position; float ddx = entity.Position.X - bodyPos.X; @@ -12816,12 +12816,52 @@ public sealed class GameWindow : IDisposable float distToTarget = MathF.Sqrt(ddx * ddx + ddy * ddy); bool speculativeCanCharge = distToTarget >= AceCanChargeDistance; - _playerController.BeginServerAutoWalk( - destinationWorld: entity.Position, - minDistance: 0f, - distanceToObject: useRadius, - moveTowards: true, - canCharge: speculativeCanCharge); + // R4-V5: retail's client-initiated use flow issues TurnToObject / + // MoveToObject through the SAME manager the wire path uses (decomp + // §9a/§9b callers) — in-range targets get a pure turn-to-face; + // out-of-range targets get the local moveto that ACE's mt-6 + // broadcast will re-target moments later. MovementParameters ctor + // defaults (0x1EE0F: MoveTowards, UseSpheres, threshold 15, + // MinDistance 0) match the old BeginServerAutoWalk install's + // semantics; only the AP-23 radius + the #77 CanCharge prediction + // are non-default. + var p = new AcDream.Core.Physics.Motion.MovementParameters + { + DistanceToObject = useRadius, + CanCharge = speculativeCanCharge, + }; + var ms = new AcDream.Core.Physics.MovementStruct + { + ObjectId = targetGuid, + TopLevelId = targetGuid, + Pos = new AcDream.Core.Physics.Position( + _playerController.CellId, entity.Position, + System.Numerics.Quaternion.Identity), + Params = p, + Type = IsCloseRangeTarget(targetGuid) + ? AcDream.Core.Physics.MovementType.TurnToObject + : AcDream.Core.Physics.MovementType.MoveToObject, + }; + // R5-V3 (#171, diff-review find): retail resolves the TARGET's + // PartArray radius/height at EVERY MoveToObject call site — the + // client-initiated use flow included (CPhysicsObj::MoveToObject + // 0x005128e9/0x00512903), not just the wire mt-6 route. Without + // this, the player's now-real own radius made the UseSpheres + // arrival hybrid (centerDist − playerRadius ≤ useRadius) — the + // auto-walk stopped ~one player-radius farther out than the AP-23 + // constants intended, and the two MoveToObject sites disagreed. + (ms.Radius, ms.Height) = GetSetupCylinder(targetGuid, entity); + // Part of this install's AP-23 adaptation: store the autonomy flag + // exactly as the wire mt-6 this install anticipates would (the P1 + // unpack store, IsAutonomous=false) — without it the per-tick + // pump's A3 dispatch stays on the raw branch (the user's last input + // set it autonomous) and clobbers this moveto's dispatched motions + // with the idle raw state. + _playerController.SetLastMoveWasAutonomous(false); + // R5-V5: through the facade (MovementManager::PerformMovement + // 0x005240d0) — retail's client-initiated use flow reaches the same + // manager the wire path uses. + pc.Movement.PerformMovement(ms); } private uint? SelectClosestCombatTarget(bool showToast) @@ -13225,7 +13265,6 @@ public sealed class GameWindow : IDisposable _playerController = null; _chaseCamera = null; _retailChaseCamera = null; - _playerCurrentAnimCommand = null; _playerMouseDeltaX = 0f; } } @@ -13368,10 +13407,138 @@ public sealed class GameWindow : IDisposable _playerController = new AcDream.App.Input.PlayerMovementController(_physicsEngine); - // B.6/B.7 (2026-05-16): fire the deferred close-range Use/PickUp - // action (first send, not a retry) when the local auto-walk overlay - // reports arrival (body finished rotating to face the target). - _playerController.AutoWalkArrived += OnAutoWalkArrivedSendDeferredAction; + // R4-V5: the local player's verbatim MoveToManager — same seam + // wiring shape as EnsureRemoteMotionBindings, with three + // player-specific differences: (a) heading reads/writes go through + // the controller's Yaw (the authoritative facing the body + // quaternion is re-derived from every Update; a quaternion-only + // set_heading would be overwritten next frame) via the P5-pinned + // yaw↔heading bridge; (b) the contact seam reads the REAL Contact + // transient bit (retail UseTime gates transient_state & 1 — + // remotes force-assert Contact+OnWalkable every grounded tick, so + // OnWalkable was equivalent there); (c) isInterpolating is false — + // the local player has no InterpolationManager. Own radius/height + // are the real setup cylsphere values (R5-V3 — lazy reads because + // this method caches the player Setup a few paragraphs further + // down). setHeading's + // `send` flag is currently UNCONSUMED (register TS-33): the AP + // heartbeat diffs position/plane/cell but not orientation (retail's + // Frame::is_equal compares the full frame), so a stationary heading + // snap doesn't reach the wire — masked against ACE, which rotates + // server-side on its own turn paths; the full-frame diff lands with + // the R7 outbound-cadence port. + var pcMoveTo = _playerController; + // R5-V2: forward-declared so the player MoveToManager's target seams + // route into the player's TargetManager (retail CPhysicsObj::set_target). + EntityPhysicsHost playerHost = null!; + // R5-V5: the construction is the player MovementManager's + // MoveToFactory (same facade shape as EnsureRemoteMotionBindings); + // MakeMoveToManager() below invokes it once, after playerHost exists + // for the sticky binds. + _playerController.Movement.MoveToFactory = () => + { + var playerMoveTo = new AcDream.Core.Physics.Motion.MoveToManager( + pcMoveTo.Motion, + stopCompletely: () => pcMoveTo.Motion.StopCompletely(), + getPosition: () => new AcDream.Core.Physics.Position( + pcMoveTo.CellId, pcMoveTo.Position, pcMoveTo.BodyOrientation), + getHeading: () => AcDream.Core.Physics.Motion.MoveToMath.HeadingFromYaw(pcMoveTo.Yaw), + setHeading: (h, _) => pcMoveTo.Yaw = + AcDream.Core.Physics.Motion.MoveToMath.YawFromHeading(h), + getOwnRadius: () => GetSetupCylinder(_playerServerGuid, playerEntity).Radius, + getOwnHeight: () => GetSetupCylinder(_playerServerGuid, playerEntity).Height, + contact: () => pcMoveTo.BodyInContact, + isInterpolating: () => false, + getVelocity: () => pcMoveTo.BodyVelocity, + getSelfId: () => _playerServerGuid, + // R5-V2: retail CPhysicsObj::set_target/clear_target/quantum → the + // player's TargetManager (replaces the AP-79 _playerMoveToTarget* poll). + setTarget: (ctx, tlid, radius, q) => playerHost.SetTarget(ctx, tlid, radius, q), + clearTarget: () => playerHost.ClearTarget(), + getTargetQuantum: () => playerHost.TargetManager.GetTargetQuantum(), + setTargetQuantum: q => playerHost.TargetManager.SetTargetQuantum(q), + curTime: () => pcMoveTo.SimTimeSeconds); + + // AD-27 re-anchored (was the deleted AutoWalkArrived event): fire + // the deferred close-range Use/PickUp action when the moveto + // completes NATURALLY (MoveToComplete is the documented client + // seam; it never fires on CancelMoveTo, so a user-input cancel + // doesn't send the action — same contract the old "arrived"-only + // event had). + playerMoveTo.MoveToComplete = err => + { + if (AcDream.Core.Physics.PhysicsDiagnostics.ProbeAutoWalkEnabled) + Console.WriteLine($"[autowalk-end] reason=complete err={err}"); + if (err == AcDream.Core.Physics.WeenieError.None) + OnAutoWalkArrivedSendDeferredAction(); + }; + + // R5-V3 (#171, retires TS-39 — player side): bind the sticky + // seams to the player host's PositionManager (same trio as the + // remote bind: BeginNextNode arrival StickTo @0x00529d3a, + // PerformMovement-head Unstick). + playerMoveTo.StickTo = (tlid, radius, height) => + playerHost.PositionManager.StickTo(tlid, radius, height); + playerMoveTo.Unstick = playerHost.PositionManager.UnStick; + return playerMoveTo; + }; + + // R5-V2: the player's CPhysicsObj stand-in + TargetManager. Position is + // the player's WORLD position (WorldEntity.Position — what the AP-79 + // poll used), so an NPC watching the player receives the identical + // position. Registered in _physicsHosts so those NPCs' GetObjectA + // resolves the player; HandleTargetting is ticked in the player + // pre-Update block. + playerHost = new EntityPhysicsHost( + _playerServerGuid, + getPosition: () => new AcDream.Core.Physics.Position( + pcMoveTo.CellId, + _entitiesByServerGuid.TryGetValue(_playerServerGuid, out var pSelf) + ? pSelf.Position : pcMoveTo.Position, + pcMoveTo.BodyOrientation), + getVelocity: () => pcMoveTo.BodyVelocity, + getRadius: () => GetSetupCylinder(_playerServerGuid, playerEntity).Radius, + inContact: () => pcMoveTo.BodyInContact, + minterpMaxSpeed: () => pcMoveTo.Motion.GetMaxSpeed(), + curTime: () => pcMoveTo.SimTimeSeconds, + physicsTimerTime: () => pcMoveTo.SimTimeSeconds, + getObjectA: ResolvePhysicsHost, + // Retail CPhysicsObj::HandleUpdateTarget (0x00512bc0) fan head: + // MovementManager::HandleUpdateTarget (@0x00512bf0 — the facade + // relay); the host chains the PositionManager leg after it. + handleUpdateTarget: info => _playerController?.Movement.HandleUpdateTarget(info), + interruptCurrentMovement: () => _playerController?.Movement.CancelMoveTo( + AcDream.Core.Physics.WeenieError.ActionCancelled)); + _playerHost = playerHost; + _physicsHosts[_playerServerGuid] = playerHost; + + // R5-V5: retail MakeMoveToManager (0x00524000) — constructs the + // player MoveToManager via the factory above (playerHost now exists + // for the sticky binds inside it). The UM-funnel-head unstick + // (CPhysicsObj::unstick_from_object 0x0050eaea) binds on the interp + // beside it, and the controller takes the PositionManager handoff it + // drives at the retail UpdatePositionInternal/UpdateObjectInternal + // points (AdjustOffset/UseTime). + var playerMovement = _playerController.Movement; + playerMovement.MakeMoveToManager(); + _playerController.Motion.UnstickFromObject = playerHost.PositionManager.UnStick; + _playerController.PositionManager = playerHost.PositionManager; + + // TS-36 RETIRED: the interp's interrupt seam is retail's + // interrupt_current_movement → MovementManager::CancelMoveTo(0x36) + // chain (raw 278189-278200) — since R5-V5 the literal facade relay + // (0x005241b0). Every DoMotion/StopMotion/StopCompletely/jump/ + // set_hold_run cancel site now genuinely cancels a running moveto + // (V2's reentrancy tests prove the chain is inert-safe). Captures + // THIS controller's facade (not the _playerController field) so a + // Tab-toggle's stale interp keeps cancelling its own manager. + _playerController.Motion.InterruptCurrentMovement = () => + { + if (AcDream.Core.Physics.PhysicsDiagnostics.ProbeAutoWalkEnabled + && playerMovement.IsMovingTo()) + Console.WriteLine("[autowalk-end] reason=interrupt"); + playerMovement.CancelMoveTo(AcDream.Core.Physics.WeenieError.ActionCancelled); + }; // K-fix7 (2026-04-26): if PlayerDescription already arrived, the // server's Run / Jump skill values are cached here — push them @@ -13452,6 +13619,42 @@ public sealed class GameWindow : IDisposable int plbY = _liveCenterY + (int)MathF.Floor(playerEntity.Position.Y / 192f); pinitCellId = ((uint)plbX << 24) | ((uint)plbY << 16) | 0x0001u; } + // R4-V5 moveto-stall fix #2 (2026-07-03, the [autowalk-gate] probe's + // one-immortal-node finding): the sequencer/sink bind block MUST run + // BEFORE the initial SetPosition. SetPosition → StopCompletely + // enqueues the A9 pending_motions node whose completable partner is + // the DefaultSink's type-5 motion-table entry — with the sink still + // null at login, the node was ORPHANED, and pending_motions never + // reached empty again (head-pop-any just relabels a backlog), so + // the MoveToManager's wait-for-anims gate never opened: every + // server MoveTo armed but the body never moved. + if (_animatedEntities.TryGetValue(playerEntity.Id, out var playerAE) + && playerAE.Sequencer is { } playerSeq) + { + _playerController.AttachCycleVelocityAccessor(() => playerSeq.CurrentVelocity); + // R3-W4: bind the player interp's retail seams to the player + // sequencer — LeaveGround/HitGround strip transition links here + // (the K-fix18 replacement). + // #174 (2026-07-05): the seam is HandleEnterWorld (strip + FULL + // queue drain), not the bare sequence strip — see the remote + // bind site's comment (retail 0x0050fe20 → 0x00517d70 → + // 0x0051bdd0). The bare strip orphaned every pending manager + // node on each jump's LeaveGround; the local player's + // pending_motions then never drained and every armed moveto + // starved (#174: doors unusable after the first jump/run). + _playerController.Motion.RemoveLinkAnimations = () => playerSeq.Manager.HandleEnterWorld(); + _playerController.Motion.InitializeMotionTables = + () => playerSeq.Manager.InitializeState(); + _playerController.Motion.CheckForCompletedMotions = + playerSeq.Manager.CheckForCompletedMotions; + // R3-W6: the player's cycles are now driven through the SAME + // dispatch sink remotes use (TurnApplied/TurnStopped omitted — + // ObservedOmega is a remote-DR-only concept; local rotation is + // the controller's Yaw integration). + _playerController.Motion.DefaultSink = + new AcDream.Core.Physics.Motion.MotionTableDispatchSink(playerSeq); + } + var initResult = _physicsEngine.Resolve( playerEntity.Position, pinitCellId, System.Numerics.Vector3.Zero, 100f); @@ -13466,12 +13669,6 @@ public sealed class GameWindow : IDisposable playerEntity.SetPosition(initResult.Position); playerEntity.ParentCellId = initResult.CellId; - if (_animatedEntities.TryGetValue(playerEntity.Id, out var playerAE) - && playerAE.Sequencer is { } playerSeq) - { - _playerController.AttachCycleVelocityAccessor(() => playerSeq.CurrentVelocity); - } - var q = playerEntity.Rotation; float rawYaw = MathF.Atan2( 2f * (q.W * q.Z + q.X * q.Y), @@ -13802,6 +13999,7 @@ public sealed class GameWindow : IDisposable _uiHost?.Dispose(); _textRenderer?.Dispose(); _debugFont?.Dispose(); + _frameProfiler.Dispose(); // MP0: releases the GpuFrameTimer query ring _dats?.Dispose(); _input?.Dispose(); _gl?.Dispose(); diff --git a/src/AcDream.App/Rendering/InteriorEntityPartition.cs b/src/AcDream.App/Rendering/InteriorEntityPartition.cs index 9ef43dda..150345da 100644 --- a/src/AcDream.App/Rendering/InteriorEntityPartition.cs +++ b/src/AcDream.App/Rendering/InteriorEntityPartition.cs @@ -35,8 +35,55 @@ public static class InteriorEntityPartition public Dictionary> ByCell { get; } = new(); public List OutdoorStatic { get; } = new(); public List Dynamics { get; } = new(); + + // MP-Alloc: scratch for PruneEmptyCellBuckets — reused across frames + // so pruning itself doesn't allocate. + private readonly List _emptyCellScratch = new(); + + /// + /// MP-Alloc (2026-07-05): clear every collection in place for reuse + /// by . + /// The per-cell lists inside are cleared and + /// KEPT (not removed) so a steady-state frame with the same visible + /// cell set reuses the same List<WorldEntity> instances instead + /// of reallocating one per cell every frame. + /// + internal void ClearForReuse() + { + foreach (var list in ByCell.Values) + list.Clear(); + OutdoorStatic.Clear(); + Dynamics.Clear(); + } + + /// + /// MP-Alloc: drop any cell bucket that ended this frame with zero + /// entries (either newly emptied, or a leftover key from a previous + /// frame's visible-cell set that this frame never touched). Keeps + /// ByCell.Count / .Keys bit-identical to the old always-fresh- + /// Dictionary behavior — callers that inspect key presence/count + /// directly (not just TryGetValue) must see exactly the cells that + /// actually received at least one static this frame. + /// + internal void PruneEmptyCellBuckets() + { + _emptyCellScratch.Clear(); + foreach (var (cellId, list) in ByCell) + { + if (list.Count == 0) + _emptyCellScratch.Add(cellId); + } + foreach (var cellId in _emptyCellScratch) + ByCell.Remove(cellId); + } } + /// + /// Allocating overload — always returns a brand-new . + /// Kept for tests and any one-shot caller; the per-frame render path + /// uses the + /// reuse overload instead (see ). + /// public static Result Partition( HashSet visibleCells, IEnumerable<(uint LandblockId, Vector3 AabbMin, Vector3 AabbMax, @@ -44,6 +91,28 @@ public static class InteriorEntityPartition IReadOnlyDictionary? AnimatedById)> landblockEntries) { var result = new Result(); + Partition(result, visibleCells, landblockEntries); + return result; + } + + /// + /// MP-Alloc (2026-07-05): reuse overload. Clears + /// in place (see ) and refills it, + /// reusing each cell's existing List<WorldEntity> when the + /// cell key survives from the previous frame instead of allocating a new + /// one — the per-cell dictionary entries persist across frames (cleared, + /// never removed) since the visible-cell set is usually stable frame to + /// frame. Identical partitioning output to the allocating overload; only + /// the backing storage is reused. + /// + public static void Partition( + Result result, + HashSet visibleCells, + IEnumerable<(uint LandblockId, Vector3 AabbMin, Vector3 AabbMax, + IReadOnlyList Entities, + IReadOnlyDictionary? AnimatedById)> landblockEntries) + { + result.ClearForReuse(); foreach (var entry in landblockEntries) { foreach (var e in entry.Entities) @@ -70,7 +139,8 @@ public static class InteriorEntityPartition } } } - return result; + + result.PruneEmptyCellBuckets(); } /// Shared indoor classification — keep DrawDynamicsLast, the diff --git a/src/AcDream.App/Rendering/ParticleRenderer.cs b/src/AcDream.App/Rendering/ParticleRenderer.cs index e47fc338..d078e0c6 100644 --- a/src/AcDream.App/Rendering/ParticleRenderer.cs +++ b/src/AcDream.App/Rendering/ParticleRenderer.cs @@ -48,6 +48,19 @@ public sealed unsafe class ParticleRenderer : IDisposable private float[] _instanceScratch = new float[256 * 16]; + // MP-Alloc (2026-07-05): Draw() is called up to ~11 times per frame + // (sky pre/post, scene, per-visible-cell, dynamics, unattached passes), + // each previously `new`ing a List (BuildDrawList) and a + // List (the per-batch `run` list) that became garbage + // as soon as the call returned. All Draw() calls happen sequentially on + // the render thread (verified: every call site in GameWindow.cs is a + // plain synchronous invocation from the single-threaded OnRender chain, + // none dispatched via Task.Run/Parallel) and each call fully drains its + // lists before returning, so a single pair of reused fields is safe - + // no call overlaps another's use of these buffers. + private readonly List _drawListScratch = new(64); + private readonly List _runScratch = new(64); + public ParticleRenderer(GL gl, string shadersDir, TextureCache? textures = null, DatCollection? dats = null) { _gl = gl ?? throw new ArgumentNullException(nameof(gl)); @@ -133,6 +146,9 @@ public sealed unsafe class ParticleRenderer : IDisposable if (draws.Count == 0) return; draws.Sort(static (a, b) => b.Instance.DistanceSq.CompareTo(a.Instance.DistanceSq)); + // draws IS _drawListScratch (see BuildDrawList) - sorting it in place + // is fine, nothing else reads it between BuildDrawList's return and + // this call. _shader.Use(); _shader.SetMatrix4("uViewProjection", camera.View * camera.Projection); @@ -144,7 +160,7 @@ public sealed unsafe class ParticleRenderer : IDisposable _gl.Disable(EnableCap.CullFace); _gl.ActiveTexture(TextureUnit.Texture0); - var run = new List(64); + var run = _runScratch; for (int i = 0; i < draws.Count;) { var key = draws[i].Key; @@ -178,7 +194,8 @@ public sealed unsafe class ParticleRenderer : IDisposable Vector3 cameraUp, Func? emitterFilter) { - var draws = new List(Math.Max(64, particles.ActiveParticleCount)); + var draws = _drawListScratch; + draws.Clear(); foreach (var (em, idx) in particles.EnumerateLive()) { if (em.RenderPass != renderPass) diff --git a/src/AcDream.App/Rendering/RenderBootstrap.cs b/src/AcDream.App/Rendering/RenderBootstrap.cs index b7ee7015..81359dbf 100644 --- a/src/AcDream.App/Rendering/RenderBootstrap.cs +++ b/src/AcDream.App/Rendering/RenderBootstrap.cs @@ -180,10 +180,13 @@ public static class RenderBootstrap // --- EntityClassificationCache (GameWindow ~217 — field initializer, new()) --- var classificationCache = new Wb.EntityClassificationCache(); + // --- TranslucencyFadeManager (GameWindow — field initializer, new()) --- + var translucencyFades = new AcDream.Core.Rendering.TranslucencyFadeManager(); + // --- WbDrawDispatcher (GameWindow ~2377-2381) --- var drawDispatcher = new Wb.WbDrawDispatcher( gl, meshShader, textureCache, meshAdapter, entitySpawnAdapter, - bindless, classificationCache); + bindless, classificationCache, translucencyFades); drawDispatcher.AlphaToCoverage = opts.Quality.AlphaToCoverage; // --- Vitals dat font (GameWindow ~1820-1822) --- diff --git a/src/AcDream.App/Rendering/RetailChaseCamera.cs b/src/AcDream.App/Rendering/RetailChaseCamera.cs index 553e977c..0eb4b474 100644 --- a/src/AcDream.App/Rendering/RetailChaseCamera.cs +++ b/src/AcDream.App/Rendering/RetailChaseCamera.cs @@ -8,8 +8,12 @@ namespace AcDream.App.Rendering; /// Retail-faithful chase camera. Ports the chase-cam behavior from the /// 2013 acclient (CameraManager + CameraSet, decomp at /// docs/research/named-retail/acclient_2013_pseudo_c.txt:95505): -/// exponential damping toward a target pose, 5-frame velocity-averaged -/// slope-aligned heading frame, mouse-input low-pass filter. +/// a STATEFUL sought position that converges from the current swept +/// viewer toward the desired boom pose (CameraManager::UpdateCamera +/// 0x00456660 → viewer_sought_position, the #180 fix), 5-frame +/// velocity-averaged slope-aligned heading frame, mouse-input low-pass +/// filter. Pseudocode: +/// docs/research/2026-07-06-camera-sought-position-pseudocode.md. /// /// /// Sits behind @@ -97,11 +101,23 @@ public sealed class RetailChaseCamera : ICamera private const float SnapEpsilon = 0.000199999995f * 2f; private const float RotCloseEpsilon = 0.000199999995f; - // ── Damped state ──────────────────────────────────────────────── + // ── Stateful camera state (retail SmartBox's two Positions) ───── + // + // _soughtEye = retail viewer_sought_position — the persisted sweep + // TARGET, re-derived each frame from the current swept + // viewer (NOT from itself). + // _publishedEye = retail viewer — the swept, published eye; the base + // of next frame's interpolation (SmartBox:: + // PlayerPhysicsUpdatedCallback passes &this->viewer + // into UpdateCamera, 0x00452d75). + // _dampedForward = the sought's look direction. Sweeps translate but + // never rotate, so the viewer's rotation is always the + // previous sought rotation — one field serves both. private readonly Vector3[] _velocityRing = new Vector3[5]; private int _velocityCount; - private Vector3 _dampedEye; + private Vector3 _soughtEye; + private Vector3 _publishedEye; private Vector3 _dampedForward = new(1f, 0f, 0f); private bool _initialised; @@ -155,10 +171,18 @@ public sealed class RetailChaseCamera : ICamera Vector3 targetEye = pivotWorld + forward * (-horizontal) + up * vertical; Vector3 targetForward = Vector3.Normalize(pivotWorld - targetEye); - // 5. Exponential damping (independent translation + rotation rates). + // 5. Stateful sought position (#180). Retail CameraManager::UpdateCamera + // (0x00456660) interpolates FROM THE CURRENT SWEPT VIEWER toward the + // desired pose and assigns the result to viewer_sought_position + // (SmartBox::PlayerPhysicsUpdatedCallback 0x00452d60) — the sweep + // target converges onto whatever the collision produced last frame + // and re-extends gradually. The full-length ideal boom is never swept + // directly. Pseudocode: + // docs/research/2026-07-06-camera-sought-position-pseudocode.md. if (!_initialised) { - _dampedEye = targetEye; + _soughtEye = targetEye; + _publishedEye = targetEye; // start converged (AD-38: retail re-extends from the player) _dampedForward = targetForward; _initialised = true; } @@ -166,36 +190,48 @@ public sealed class RetailChaseCamera : ICamera { float tAlpha = ComputeDampingAlpha(CameraDiagnostics.TranslationStiffness, dt); float rAlpha = ComputeDampingAlpha(CameraDiagnostics.RotationStiffness, dt); - Vector3 candidateEye = Vector3.Lerp(_dampedEye, targetEye, tAlpha); + // interpolate_origin(viewer.frame → desired, t) — the lerp base is the + // VIEWER (0x00456fae), not the previous sought. The forward base is the + // viewer's rotation ≡ the previous sought forward (sweeps never rotate). + Vector3 candidateEye = Vector3.Lerp(_publishedEye, targetEye, tAlpha); Vector3 candidateForward = Vector3.Normalize(Vector3.Lerp(_dampedForward, targetForward, rAlpha)); - // Retail UpdateCamera convergence snap (0x00456fcd): freeze at an exact fixed - // point once the lerp step is sub-epsilon, instead of dithering forever. This is - // the at-rest flicker fix — see ApplyConvergenceSnap + SnapEpsilon. - (_dampedEye, _dampedForward, _) = - ApplyConvergenceSnap(_dampedEye, _dampedForward, candidateEye, candidateForward); + // Retail UpdateCamera dead-band (0x00456fcd–0x00457035): once the step + // off the viewer is sub-epsilon in translation AND rotation, the sought + // parks EXACTLY ON the viewer — an exact fixed point instead of an + // asymptote. Kills the at-rest drift AND the residual micro-jitter when + // pressed against a wall. See ApplyConvergenceSnap + SnapEpsilon. + (_soughtEye, _dampedForward, _) = + ApplyConvergenceSnap(_publishedEye, _dampedForward, candidateEye, candidateForward); } - // 5b. Spring-arm collision (A8.F). Retail SmartBox::update_viewer - // (0x00453ce0) keeps TWO states: viewer_sought_position (the damped - // desired eye) and viewer (the published eye = set_viewer(curr_pos)). - // The collision produces the PUBLISHED eye each frame but must NOT - // feed back into the damped state — writing the clamped result into - // _dampedEye makes next frame's lerp start from the wall and fight - // the clamp, which shows up as visible oscillation/vibration when the - // eye is pressed against a wall. So collide into a separate local and - // leave _dampedEye as the clean, uncollided sought position. - Vector3 publishedEye = _dampedEye; + // 5b. Spring-arm collision (A8.F / #180). Retail SmartBox::update_viewer + // (0x00453ce0) sweeps the viewer_sphere pivot → viewer_sought_position + // and publishes the swept result as the viewer (set_viewer(curr_pos, 0) + // — the sought is NOT reset on success). Pressed against a wall, the + // sweep ray extends only one interpolation step past the contact, so a + // knife-edge r±ε graze can move the eye by at most that step (sub-mm at + // high fps) instead of re-solving the full-length boom with its 0.27 m + // bistable contact pair — the #180 strobe fix. + Vector3 publishedEye = _soughtEye; // The viewer cell defaults to the player cell (collision off / null probe); the sweep // overwrites it with the swept cell (retail viewer_cell). Always set so GameWindow has a // robust per-frame "which cell is the camera in?" answer. ViewerCellId = cellId; if (CameraDiagnostics.CollideCamera && CollisionProbe is not null) { - var swept = CollisionProbe.SweepEye(pivotWorld, _dampedEye, cellId, selfEntityId, playerPosition); + var swept = CollisionProbe.SweepEye(pivotWorld, _soughtEye, cellId, selfEntityId, playerPosition); publishedEye = swept.Eye; ViewerCellId = swept.ViewerCellId; + // Total-failure fallback = retail set_viewer(player_pos, reset_sought=1) + // (update_viewer :92886 and the cell==0 bail :92775 — both surface here as + // ViewerCellId == 0): the sought resets to the returned position and + // re-extends from there. + if (swept.ViewerCellId == 0) + _soughtEye = swept.Eye; } + // Retail viewer — the base of next frame's interpolation (step 5). + _publishedEye = publishedEye; // 6. Publish renderer surface (from the collided eye; rotation stays the // smoothly-damped look direction toward the pivot). @@ -396,22 +432,23 @@ public sealed class RetailChaseCamera : ICamera } /// - /// Retail CameraManager::UpdateCamera convergence snap (decomp 0x00456fcd). - /// After the per-frame lerp, if the translation step from - /// to is below AND the - /// rotation step is below , retail returns the input - /// position unchanged — an exact fixed point. Returns frozen=true with the - /// current state in that case; otherwise frozen=false with the candidate. - /// Both conditions are required (retail couples origin + rotation in the snap test), + /// Retail CameraManager::UpdateCamera dead-band (decomp 0x00456fcd–0x00457035). + /// After the per-frame lerp, if the translation step from + /// (the interpolation base = the current swept viewer) to + /// is below AND the rotation step is below + /// , retail returns the VIEWER unchanged — the sought + /// parks exactly on it (return viewer, 0x00457025). Returns frozen=true + /// with the viewer state in that case; otherwise frozen=false with the candidate. + /// Both conditions are required (retail couples origin + rotation in the test), /// so the boom keeps converging while the heading is still turning. /// internal static (Vector3 eye, Vector3 forward, bool frozen) ApplyConvergenceSnap( - Vector3 dampedEye, Vector3 dampedForward, Vector3 candidateEye, Vector3 candidateForward) + Vector3 viewerEye, Vector3 viewerForward, Vector3 candidateEye, Vector3 candidateForward) { - bool translationConverged = Vector3.Distance(candidateEye, dampedEye) < SnapEpsilon; - bool rotationConverged = Vector3.Distance(candidateForward, dampedForward) < RotCloseEpsilon; + bool translationConverged = Vector3.Distance(candidateEye, viewerEye) < SnapEpsilon; + bool rotationConverged = Vector3.Distance(candidateForward, viewerForward) < RotCloseEpsilon; if (translationConverged && rotationConverged) - return (dampedEye, dampedForward, true); // freeze: exact fixed point + return (viewerEye, viewerForward, true); // park: exact fixed point on the viewer return (candidateEye, candidateForward, false); } diff --git a/src/AcDream.App/Rendering/RetailPViewRenderer.cs b/src/AcDream.App/Rendering/RetailPViewRenderer.cs index 30db299f..959c104a 100644 --- a/src/AcDream.App/Rendering/RetailPViewRenderer.cs +++ b/src/AcDream.App/Rendering/RetailPViewRenderer.cs @@ -42,6 +42,21 @@ public sealed class RetailPViewRenderer // (statics + outside-stage dynamics passing the slice cone). private readonly List _lateParticleOwnerScratch = new(); + // MP-Alloc (2026-07-05): the frame's entity partition (ByCell/OutdoorStatic/ + // Dynamics), reused across frames instead of `new`ing a Result (a Dictionary + // + 2 Lists, plus one List per visible cell) every DrawInside + // call. See InteriorEntityPartition.Partition(Result, ...) — clears in + // place and reuses each cell's list across frames when the cell stays + // visible. + private readonly InteriorEntityPartition.Result _partitionResult = new(); + + // MP-Alloc (2026-07-05): DrawInside's drawable-cell set, reused across + // frames instead of `new HashSet(pvFrame.OrderedVisibleCells)` every + // call. Every consumer (DrawEntityBucket, DrawExitPortalMasks, + // DrawCellObjectLists, RetailPViewFrameResult.DrawableCells) reads it + // synchronously within the same frame it was built. + private readonly HashSet _drawableCellsScratch = new(); + // T2 (BR-4): retail has NO distance constant on the flood-admission chain // (DrawBuilding → portal walk → ConstructView: viewconeCheck + side test + // GetClip + GetVisible only). The old 48 m seed cap is replaced by the @@ -110,7 +125,9 @@ public sealed class RetailPViewRenderer // so every visible cell's shell has a prepared batch and seals — killing the grey // (the old clipAssembly.CellIdToSlot.Keys filter silently dropped slot-less cells). // Per-slice trim still applies in DrawEnvCellShells (Task 4 makes it self-contained). - var drawableCells = new HashSet(pvFrame.OrderedVisibleCells); + _drawableCellsScratch.Clear(); + _drawableCellsScratch.UnionWith(pvFrame.OrderedVisibleCells); + var drawableCells = _drawableCellsScratch; UseIndoorMembershipOnlyRouting(); // #124: look-in cells need prepared shell batches + their statics routed @@ -129,6 +146,11 @@ public sealed class RetailPViewRenderer prepareCells = _lookInPrepareScratch; } + // (#176 correction, 2026-07-06: the flood-scoped light-pool rebuild that ran + // here was the seam-floor flicker mechanism — retail's visible_cell_table is + // the RESIDENT-cell registry, not the frame flood — and is deleted. The pool + // is built once per frame in GameWindow, player-anchored.) + _envCells.PrepareRenderBatches( ctx.ViewProjection, ctx.CameraWorldPosition, @@ -137,7 +159,8 @@ public sealed class RetailPViewRenderer centerLbY: ctx.RenderCenterLbY, renderRadius: ctx.RenderRadius); - var partition = InteriorEntityPartition.Partition(prepareCells, ctx.LandblockEntries); + InteriorEntityPartition.Partition(_partitionResult, prepareCells, ctx.LandblockEntries); + var partition = _partitionResult; var result = new RetailPViewFrameResult { PortalFrame = pvFrame, diff --git a/src/AcDream.App/Rendering/Shaders/mesh_modern.frag b/src/AcDream.App/Rendering/Shaders/mesh_modern.frag index 4f344369..cf500f01 100644 --- a/src/AcDream.App/Rendering/Shaders/mesh_modern.frag +++ b/src/AcDream.App/Rendering/Shaders/mesh_modern.frag @@ -7,6 +7,7 @@ in vec3 vWorldPos; in vec3 vLit; // A7: per-vertex Gouraud lighting (ambient + capped lights), from mesh_modern.vert in flat uvec2 vTextureHandle; in flat uint vTextureLayer; +in flat float vOpacityMultiplier; // #188 // uRenderPass values (Phase N.5 Decision 2 — two-pass alpha-test): // 0 = opaque pass — discard fragments with alpha < 0.95 @@ -16,6 +17,7 @@ in flat uint vTextureLayer; // alpha < 0.05 (skip empty fragments — large // transparent overdraw cost otherwise) uniform int uRenderPass; +uniform int uLightDebug; // #176 stripe hunt (see mesh_modern.vert) — mode 3 handled here // SceneLighting UBO — IDENTICAL layout to mesh_instanced.frag binding=1. struct Light { @@ -85,6 +87,14 @@ void main() { // Per-vertex Gouraud lighting from the vertex shader (ambient + capped lights). vec3 lit = vLit; + // #176 stripe-hunt mode 3: show the raw per-vertex light field (texture + // ignored). Stripes visible HERE = a vertex-lighting artifact; absent = + // the pattern comes from texture/per-pixel machinery. Throwaway diagnostic. + if (uLightDebug == 3) { + FragColor = vec4(min(lit, vec3(1.0)), 1.0); + return; + } + // Lightning flash — additive scene bump (matches mesh_instanced.frag). lit += uFogParams.z * vec3(0.6, 0.6, 0.75); @@ -93,5 +103,9 @@ void main() { vec3 rgb = color.rgb * lit; rgb = applyFog(rgb, vWorldPos); - FragColor = vec4(rgb, color.a); + // #188: multiply the FINAL alpha only — the discard thresholds above stay + // keyed on the raw sampled color.a, so the last few frames of a fade + // (multiplier crossing under 0.05) still ramp smoothly toward zero rather + // than popping invisible early against the discard cutoff. + FragColor = vec4(rgb, color.a * vOpacityMultiplier); } diff --git a/src/AcDream.App/Rendering/Shaders/mesh_modern.vert b/src/AcDream.App/Rendering/Shaders/mesh_modern.vert index dd8f7f4a..a28f2893 100644 --- a/src/AcDream.App/Rendering/Shaders/mesh_modern.vert +++ b/src/AcDream.App/Rendering/Shaders/mesh_modern.vert @@ -105,6 +105,16 @@ layout(std430, binding = 6) readonly buffer InstanceIndoorBuf { uint instanceIndoor[]; }; +// #188: per-instance opacity multiplier, 1 per instance, parallel to the +// binding=0 instance buffer (same instanceIndex). 1.0 = unmodified; <1.0 +// while a TransparentPartHook translucency fade is in flight for the +// entity/part this instance belongs to (e.g. the "fading wall" secret- +// passage doors). Multiplied against the sampled texture alpha in +// mesh_modern.frag. +layout(std430, binding = 7) readonly buffer InstanceAlphaBuf { + float instanceAlpha[]; +}; + // Core profile: redeclare gl_PerVertex so writing gl_ClipDistance[] is legal // alongside gl_Position. The array is sized 8 to match the CellClip plane budget // and the GL guarantee (GL_MAX_CLIP_DISTANCES >= 8). The host enables @@ -132,6 +142,11 @@ uniform mat4 uViewProjection; // uDrawIDOffset pattern in BaseObjectRenderManager.cs line 845. uniform int uDrawIDOffset; uniform int uLightingMode; // A7 Fix D: 0 = OBJECT (plain Lambert + sun), 1 = ENVCELL (half-Lambert wrap, no sun) +// #176 stripe-hunt isolation modes (ACDREAM_LIGHT_DEBUG, throwaway diagnostic): +// 0 = off; 1 = ambient-only vLit (all point/sun contributions killed); +// 2 = DYNAMIC point lights killed (purples + viewer fill off, statics stay); +// 3 = handled in the frag (raw vLit visualization, texture ignored). +uniform int uLightDebug; // SceneLighting UBO — binding=1 in the UBO namespace (GL keeps the SSBO and UBO // binding tables separate, so this coexists with the binding=1 BatchBuffer SSBO @@ -178,6 +193,7 @@ vec3 pointContribution(vec3 N, vec3 worldPos, GlobalLight L) { // bake's 1/d³ distance-cube, which makes a tight concentrated pool. No per-light // cap — D3D accumulates then saturates, which accumulateLights does via min(pointAcc,1). if (L.coneAngleEtc.y > 0.5) { + if (uLightDebug == 2) return vec3(0.0); // #176 stripe hunt: dynamics killed vec3 Ldir = toL / max(d, 1e-4); float ndl = max(0.0, dot(N, Ldir)); if (ndl <= 0.0) return vec3(0.0); @@ -214,6 +230,7 @@ vec3 pointContribution(vec3 N, vec3 worldPos, GlobalLight L) { vec3 accumulateLights(vec3 N, vec3 worldPos, int instanceIndex) { vec3 lit = uCellAmbient.xyz; + if (uLightDebug == 1) return lit; // #176 stripe hunt: ambient only // SUN / directional — OBJECT path only (mode 0). retail's EnvCell path // (minimize_envcell_lighting) enables only dynamic lights, NEVER the sun, so @@ -259,10 +276,12 @@ out vec3 vWorldPos; out vec3 vLit; // A7: per-vertex Gouraud lighting (ambient + capped lights) out flat uvec2 vTextureHandle; out flat uint vTextureLayer; +out flat float vOpacityMultiplier; // #188 void main() { int instanceIndex = gl_BaseInstanceARB + gl_InstanceID; mat4 model = Instances[instanceIndex].transform; + vOpacityMultiplier = instanceAlpha[instanceIndex]; // #188 vec4 worldPos = model * vec4(aPosition, 1.0); gl_Position = uViewProjection * worldPos; diff --git a/src/AcDream.App/Rendering/Wb/EnvCellRenderer.cs b/src/AcDream.App/Rendering/Wb/EnvCellRenderer.cs index 0a65655b..e8d454a4 100644 --- a/src/AcDream.App/Rendering/Wb/EnvCellRenderer.cs +++ b/src/AcDream.App/Rendering/Wb/EnvCellRenderer.cs @@ -878,6 +878,8 @@ public sealed unsafe class EnvCellRenderer : IDisposable _shader.SetInt("uRenderPass", (int)renderPass); _shader.SetInt("uFilterByCell", 0); _shader.SetInt("uLightingMode", 1); // A7 Fix D D-3/D-4: EnvCell bake (wrap points, no sun) + // #176 stripe-hunt isolation (ACDREAM_LIGHT_DEBUG) — throwaway diagnostic. + _shader.SetInt("uLightDebug", AcDream.Core.Rendering.RenderingDiagnostics.LightDebugMode); // Phase U.4 ROOT-CAUSE FIX (cell-shell flicker / "transparent walls when // moving"): upload uViewProjection HERE rather than inheriting it from @@ -890,7 +892,7 @@ public sealed unsafe class EnvCellRenderer : IDisposable _shader.SetMatrix4("uViewProjection", _lastViewProjection); var allInstances = new List(); - var drawCalls = new List<(ObjectRenderData renderData, int count, int offset)>(); + var drawCalls = new List<(ObjectRenderData renderData, ulong gfxObjId, int count, int offset)>(); if (filter == null) { @@ -902,7 +904,7 @@ public sealed unsafe class EnvCellRenderer : IDisposable var renderData = _meshManager.TryGetRenderData(gfxObjId); if (renderData != null && !renderData.IsSetup) { - drawCalls.Add((renderData, transforms.Count, allInstances.Count)); + drawCalls.Add((renderData, gfxObjId, transforms.Count, allInstances.Count)); allInstances.AddRange(transforms); } } @@ -950,12 +952,18 @@ public sealed unsafe class EnvCellRenderer : IDisposable var renderData = _meshManager.TryGetRenderData(gfxObjId); if (renderData != null && !renderData.IsSetup) { - drawCalls.Add((renderData, transforms.Count, allInstances.Count)); + drawCalls.Add((renderData, gfxObjId, transforms.Count, allInstances.Count)); allInstances.AddRange(transforms); } } } + // #176 seam-draw probe: stash this call's filter so the opaque-pass + // emitter inside RenderModernMDIInternal can report flood membership + // per target cell (null on the unfiltered/outdoor path). + if (AcDream.Core.Rendering.RenderingDiagnostics.ProbeSeamDrawEnabled) + _seamProbeFilter = filter; + // WB EnvCellRenderManager.cs:470-483: if (allInstances.Count > 0) { @@ -1085,7 +1093,10 @@ public sealed unsafe class EnvCellRenderer : IDisposable { Vector3 center = (b.Min + b.Max) * 0.5f; float radius = (b.Max - b.Min).Length() * 0.5f; - AcDream.Core.Lighting.LightManager.SelectForObject(snap, center, radius, set); + // #176 flap fix: cells use SelectForCell (retail minimize_envcell_lighting) — ALL + // dynamic lights on every cell (stable), not the per-object sphere-overlap cull that + // let the portal set flip as the flood shifted → floor-lighting flap. + AcDream.Core.Lighting.LightManager.SelectForCell(snap, center, radius, set); } _cellLightSetCache[cellId] = set; return set; @@ -1100,7 +1111,7 @@ public sealed unsafe class EnvCellRenderer : IDisposable private void RenderModernMDIInternal( AcDream.App.Rendering.Shader shader, - List<(ObjectRenderData renderData, int count, int offset)> drawCalls, + List<(ObjectRenderData renderData, ulong gfxObjId, int count, int offset)> drawCalls, List allInstances, WbRenderPass renderPass) { @@ -1297,7 +1308,10 @@ public sealed unsafe class EnvCellRenderer : IDisposable // instanceClipSlot[i] tracks Instances[i] through the MDI BaseInstance. if (_clipSlotData.Length < uniqueInstanceCount) _clipSlotData = new uint[Math.Max(_clipSlotData.Length * 2, uniqueInstanceCount)]; - if (_cellIdToSlot is null) + // #176 stripe-hunt isolation (ACDREAM_CLIP_DEBUG=1): force every shell + // instance to slot 0 (no-clip) — retail draws cell shells WHOLE. + if (_cellIdToSlot is null + || AcDream.Core.Rendering.RenderingDiagnostics.ClipDebugNoShellTrim) { Array.Clear(_clipSlotData, 0, uniqueInstanceCount); } @@ -1327,6 +1341,13 @@ public sealed unsafe class EnvCellRenderer : IDisposable System.Array.Copy(cellSet, 0, _lightSetData, i * lightStride, lightStride); } + // #176 seam-draw probe: emitted HERE (not in Render) so the per-cell light + // sets read through the just-cleared cache against THIS frame's + // _pointSnapshot — the exact data the SSBO upload below carries. + if (renderPass == WbRenderPass.Opaque + && AcDream.Core.Rendering.RenderingDiagnostics.ProbeSeamDrawEnabled) + EmitSeamDrawProbe(drawCalls, allInstances, _seamProbeFilter); + // A7 Fix D (D-2): upload binding=4 (global lights) + binding=5 (per-instance set). int lightCount = AcDream.Core.Lighting.GlobalLightPacker.Pack(_pointSnapshot, ref _globalLightData); int glUploadCount = lightCount > 0 ? lightCount : 1; @@ -1416,6 +1437,104 @@ public sealed unsafe class EnvCellRenderer : IDisposable _gl.BindBuffer(GLEnum.DrawIndirectBuffer, 0); } + // --------------------------------------------------------------------------- + // #176 seam-draw probe (ACDREAM_PROBE_SEAMDRAW) — throwaway apparatus. + // The in-engine replacement for the RenderDoc pixel-history the pipeline + // can't have (RenderDoc hides GL_ARB_bindless_texture → our mandatory-modern + // startup gate throws). Per opaque pass: for each target cell — flood + // membership, every shell instance (count + translation, F3 z shows the + // +0.02 lift; n≥2 for one (cell,gfx) = the runtime double-draw), and the + // cell's 8-light set resolved to stable IDENTITIES (owner-cell low16 + + // intensity; raw indices shuffle when the pool rebuilds). Plus the + // snapshot's HOT lights (intensity ≥ 50 — the portal purples; fixtures are + // ~1–2). Change-deduped block with a 2 s heartbeat: a purple identity + // flipping with flood membership = the snapshot-scope mechanism; two + // coincident instances = the z-fight. See RenderingDiagnostics. + // --------------------------------------------------------------------------- + + private HashSet? _seamProbeFilter; + private string? _seamSig; + private long _seamLastEmitMs; + + private void EmitSeamDrawProbe( + List<(ObjectRenderData renderData, ulong gfxObjId, int count, int offset)> drawCalls, + List allInstances, + HashSet? filter) + { + var ci = System.Globalization.CultureInfo.InvariantCulture; + var snap = _pointSnapshot; + var sb = new System.Text.StringBuilder(640); + + var sorted = new List(AcDream.Core.Rendering.RenderingDiagnostics.SeamDrawTargetCells); + sorted.Sort(); + foreach (uint cell in sorted) + { + sb.Append("\n[seam-cell] cell=0x").Append(cell.ToString("X8")); + sb.Append(" flood=").Append(filter is null ? '?' : (filter.Contains(cell) ? 'Y' : 'N')); + + int totalInst = 0; + foreach (var dc in drawCalls) + { + int n = 0; + InstanceData first = default; + for (int i = dc.offset; i < dc.offset + dc.count; i++) + { + if (allInstances[i].CellId != cell) continue; + if (n == 0) first = allInstances[i]; + n++; + } + if (n == 0) continue; + totalInst += n; + var t = first.Transform.Translation; + sb.AppendFormat(ci, " g=0x{0:X8}:n={1}@({2:F2},{3:F2},{4:F3})", + dc.gfxObjId, n, t.X, t.Y, t.Z); + } + if (totalInst == 0) sb.Append(" inst=0"); + + // The 8-light set this cell's instances carry (fresh: the per-pass + // cache was cleared at the top of RenderModernMDIInternal). + int[] set = GetCellLightSet(cell); + sb.Append(" L=["); + bool any = false; + for (int k = 0; k < set.Length; k++) + { + int idx = set[k]; + if (idx < 0) continue; + if (any) sb.Append(','); + if (snap is not null && idx < snap.Count) + sb.AppendFormat(ci, "{0:X4}:I{1:F0}", snap[idx].CellId & 0xFFFFu, snap[idx].Intensity); + else + sb.Append('?').Append(idx); + any = true; + } + sb.Append(']'); + } + + sb.Append("\n[seam-snap] pool=").Append(snap?.Count ?? 0).Append(" hot=["); + if (snap is not null) + { + bool anyHot = false; + for (int i = 0; i < snap.Count; i++) + { + var ls = snap[i]; + if (ls.Intensity < 50f) continue; + if (anyHot) sb.Append(','); + sb.AppendFormat(ci, "0x{0:X8}:I{1:F0}rgb({2:F2},{3:F2},{4:F2})", + ls.CellId, ls.Intensity, ls.ColorLinear.X, ls.ColorLinear.Y, ls.ColorLinear.Z); + anyHot = true; + } + } + sb.Append(']'); + + string sig = sb.ToString(); + long now = System.Environment.TickCount64; + bool changed = sig != _seamSig; + if (!changed && (now - _seamLastEmitMs) < 2000) return; + _seamSig = sig; + _seamLastEmitMs = now; + System.Console.WriteLine($"[seam-blk] t={now} changed={(changed ? 1 : 0)}{sig}"); + } + // --------------------------------------------------------------------------- // SetCullMode // Verbatim copy of WB BaseObjectRenderManager.cs:850-866. diff --git a/src/AcDream.App/Rendering/Wb/GlobalMeshBuffer.cs b/src/AcDream.App/Rendering/Wb/GlobalMeshBuffer.cs index 3441c66a..3e2c78e2 100644 --- a/src/AcDream.App/Rendering/Wb/GlobalMeshBuffer.cs +++ b/src/AcDream.App/Rendering/Wb/GlobalMeshBuffer.cs @@ -1,3 +1,4 @@ +using AcDream.Content; using Chorizite.Core.Render.Enums; using Silk.NET.OpenGL; using System; diff --git a/src/AcDream.App/Rendering/Wb/ObjectMeshManager.cs b/src/AcDream.App/Rendering/Wb/ObjectMeshManager.cs index b9261ad1..748d6f35 100644 --- a/src/AcDream.App/Rendering/Wb/ObjectMeshManager.cs +++ b/src/AcDream.App/Rendering/Wb/ObjectMeshManager.cs @@ -15,128 +15,12 @@ using System.Numerics; using System.Runtime.InteropServices; using System.Threading; using System.Threading.Tasks; +using AcDream.Content; using AcDream.Core.Rendering.Wb; using PixelFormat = Silk.NET.OpenGL.PixelFormat; using BoundingBox = Chorizite.Core.Lib.BoundingBox; -using BCnEncoder.Decoder; -using BCnEncoder.Shared; -using BCnEncoder.ImageSharp; -using SixLabors.ImageSharp; -using SixLabors.ImageSharp.PixelFormats; namespace AcDream.App.Rendering.Wb { - /// - /// Vertex format for scenery mesh rendering: position, normal, UV. - /// - [StructLayout(LayoutKind.Sequential)] - public struct VertexPositionNormalTexture { - public Vector3 Position; - public Vector3 Normal; - public Vector2 UV; - - public static int Size => 8 * sizeof(float); // 3+3+2 = 8 floats = 32 bytes - - public VertexPositionNormalTexture(Vector3 position, Vector3 normal, Vector2 uv) { - Position = position; - Normal = normal; - UV = uv; - } - } - - /// - /// Staged data for a particle emitter to be created on the GL thread. - /// - public struct StagedEmitter { - public ParticleEmitter Emitter; - public uint PartIndex; - public Matrix4x4 Offset; - } - - /// - /// CPU-side mesh data prepared on a background thread. - /// Contains vertex data and per-batch index/texture info, but NO GPU resources. - /// - public class ObjectMeshData { - public ulong ObjectId { get; set; } - public bool IsSetup { get; set; } - public VertexPositionNormalTexture[] Vertices { get; set; } = Array.Empty(); - public List Batches { get; set; } = new(); - - /// - /// #125 (2026-06-12): GL upload-retry counter. A failed - /// (returns null from its - /// catch) used to be dropped permanently — the staged item was consumed, - /// no render data was produced, and the prepared data lingered in the CPU - /// cache where PrepareMeshDataAsync's cache-hit short-circuit - /// returned it without ever re-staging it for upload (session-sticky - /// invisible mesh, one [wb-error] line). The drain loop now re-stages a - /// failed upload for the NEXT frame up to times. The counter lives on the mesh-data object so - /// it resets to 0 naturally whenever the id is re-prepared (fresh object), - /// and bounds a deterministic GL failure to a few loud lines instead of a - /// silent permanent drop OR an unbounded per-frame retry storm. Retail - /// loads content synchronously and has no such failure mode — this - /// converges our async pipeline toward that guarantee. - /// - public int UploadAttempts; - - /// For EnvCell: the geometry of the cell itself. - public ObjectMeshData? EnvCellGeometry { get; set; } - - /// For Setup objects: parts with their local transforms. - public List<(ulong GfxObjId, Matrix4x4 Transform)> SetupParts { get; set; } = new(); - - /// Particle emitters from physics scripts. - public List ParticleEmitters { get; set; } = new(); - - /// Per-format texture atlas data (to be uploaded to GPU on main thread). - public Dictionary<(int Width, int Height, TextureFormat Format), List> TextureBatches { get; set; } = new(); - - /// Local bounding box. - public BoundingBox BoundingBox { get; set; } - - /// Approximate center point used for depth sorting / transparency ordering. - public Vector3 SortCenter { get; set; } - - /// DataID of a simpler GfxObj to use at long distance / low quality, or GfxObjDegradeInfo. - public uint DIDDegrade { get; set; } - - /// Sphere used for mouse selection. - public Sphere? SelectionSphere { get; set; } - - /// Edge line vertices for Environment wireframe rendering. - public Vector3[] EdgeLines { get; set; } = Array.Empty(); - } - - /// - /// CPU-side data for a single rendering batch (indices + texture reference). - /// - public class MeshBatchData { - public ushort[] Indices { get; set; } = Array.Empty(); - public (int Width, int Height, TextureFormat Format) TextureFormat { get; set; } - public TextureAtlasManager.TextureKey TextureKey { get; set; } - public int TextureIndex { get; set; } - public byte[] TextureData { get; set; } = Array.Empty(); - public PixelFormat? UploadPixelFormat { get; set; } - public PixelType? UploadPixelType { get; set; } - public DatReaderWriter.Enums.CullMode CullMode { get; set; } - } - - /// - /// CPU-side texture info for deduplication during background preparation. - /// - public class TextureBatchData { - public TextureAtlasManager.TextureKey Key { get; set; } - public byte[] TextureData { get; set; } = Array.Empty(); - public PixelFormat? UploadPixelFormat { get; set; } - public PixelType? UploadPixelType { get; set; } - public List Indices { get; set; } = new(); - public DatReaderWriter.Enums.CullMode CullMode { get; set; } - public bool IsTransparent { get; set; } - public bool IsAdditive { get; set; } - public bool HasWrappingUVs { get; set; } - } - /// /// GPU-side render data created on the main thread. /// @@ -187,7 +71,7 @@ namespace AcDream.App.Rendering.Wb { public (int Width, int Height) TextureSize { get; set; } public TextureFormat TextureFormat { get; set; } public uint SurfaceId { get; set; } - public TextureAtlasManager.TextureKey Key { get; set; } + public TextureKey Key { get; set; } public DatReaderWriter.Enums.CullMode CullMode { get; set; } public bool IsTransparent { get; set; } public bool IsAdditive { get; set; } @@ -209,6 +93,14 @@ namespace AcDream.App.Rendering.Wb { private readonly IDatReaderWriter _dats; private readonly ILogger _logger; + /// + /// MP1a (2026-07-05): the GL-free CPU extraction half, verbatim-moved to + /// AcDream.Content so the MP1b bake tool can run it without a GL context. + /// Owns the dat read → mesh build → inline texture decode pipeline; this + /// class keeps the queue/worker lifecycle and all GL upload. + /// + private readonly MeshExtractor _extractor; + internal IDatReaderWriter Dats => _dats; public bool IsDisposed { get; private set; } @@ -260,12 +152,6 @@ namespace AcDream.App.Rendering.Wb { return false; } - // Cache for decoded textures to avoid redundant BCn decoding - private readonly ConcurrentQueue _decodedTextureLru = new(); - private readonly ConcurrentDictionary _decodedTextureCache = new(); - private const int MaxDecodedTextures = 128; - private readonly ThreadLocal _bcDecoder = new(() => new BcDecoder()); - public GlobalMeshBuffer? GlobalBuffer { get; } private readonly bool _useModernRendering; @@ -276,6 +162,12 @@ namespace AcDream.App.Rendering.Wb { _graphicsDevice = graphicsDevice; _dats = dats; _logger = logger; + // Side-stage sink: particle-preload meshes staged mid-extraction go + // straight onto the staged-upload queue, exactly as the pre-MP1a code + // did — immediate enqueue, surviving a later throw in the same + // Prepare* call. ConcurrentQueue.Enqueue is thread-safe for the + // extractor's up-to-4 concurrent decode workers. + _extractor = new MeshExtractor(_dats, _logger, data => _stagedMeshData.Enqueue(data)); _useModernRendering = _graphicsDevice.HasOpenGL43 && _graphicsDevice.HasBindless; if (_useModernRendering) { GlobalBuffer = new GlobalMeshBuffer(_graphicsDevice.GL); @@ -560,7 +452,7 @@ namespace AcDream.App.Rendering.Wb { uint envId = 0x0D000000u | req.EnvironmentId; if (_dats.Portal.TryGet(envId, out var environment)) { if (environment.Cells.TryGetValue(req.CellStructure, out var cellStruct)) { - data = PrepareCellStructMeshData(id, cellStruct, req.Surfaces, Matrix4x4.Identity, CancellationToken.None); + data = _extractor.PrepareCellStructMeshData(id, cellStruct, req.Surfaces, Matrix4x4.Identity, CancellationToken.None); // TEMP diagnostic #105 (strip with fix): a null prep here means // this deduplicated cell geometry will NEVER render anywhere. if (data == null) @@ -581,7 +473,7 @@ namespace AcDream.App.Rendering.Wb { if ((id & 0x2_0000_0000UL) != 0) Console.WriteLine($"[geom-misroute] envcell geom 0x{id:X10} had no pending request — generic path will null it"); // If it's a direct setup or gfxobj, make sure background loads don't abort half-way - data = PrepareMeshData(id, isSetup, CancellationToken.None); + data = _extractor.PrepareMeshData(id, isSetup, CancellationToken.None); } if (data != null) { lock (_cpuMeshCache) { @@ -620,62 +512,12 @@ namespace AcDream.App.Rendering.Wb { /// Phase 1 (Background Thread): Prepare CPU-side mesh data from DAT. /// This loads vertices, indices, and texture data but creates NO GPU resources. /// Thread-safe: only reads from DAT files. + /// + /// MP1a (2026-07-05): delegates to , + /// the verbatim-moved GL-free extraction dispatcher. See . /// public ObjectMeshData? PrepareMeshData(ulong id, bool isSetup, CancellationToken ct = default) { - try { - // Use the low 32 bits as the DAT file ID - var datId = (uint)(id & 0xFFFFFFFFu); - var resolutions = _dats.ResolveId(datId).ToList(); - var selectedResolution = resolutions.OrderByDescending(r => r.Database == _dats.Portal).FirstOrDefault(); - if (selectedResolution == null) return null; - - var type = selectedResolution.Type; - var db = selectedResolution.Database; - - if (type == DBObjType.Setup) { - if (!db.TryGet(datId, out var setup)) return null; - return PrepareSetupMeshData(id, setup, ct); - } - else if (type == DBObjType.GfxObj) { - if (!db.TryGet(datId, out var gfxObj)) return null; - return PrepareGfxObjMeshData(id, gfxObj, Vector3.One, ct); - } - else if (type == DBObjType.EnvCell) { - if (!db.TryGet(datId, out var envCell)) return null; - - // If bit 32 is set, this is a request for the cell's synthetic geometry only - if ((id & 0x1_0000_0000UL) != 0) { - uint envId = 0x0D000000u | envCell.EnvironmentId; - if (_dats.Portal.TryGet(envId, out var environment)) { - if (environment.Cells.TryGetValue(envCell.CellStructure, out var cellStruct)) { - return PrepareCellStructMeshData(id, cellStruct, envCell.Surfaces, Matrix4x4.Identity, ct); - } - } - return null; - } - - return PrepareEnvCellMeshData(id, envCell, ct); - } - else if (type == DBObjType.Environment) { - if (!db.TryGet(datId, out var environment)) return null; - - // For Environment objects, create wireframe-only edge geometry - if (environment.Cells.Count > 0) { - var result = PrepareCellStructEdgeLineData(id, environment.Cells, Matrix4x4.Identity, ct); - return result; - } - return null; - } - return null; - } - catch (OperationCanceledException) { - // Ignore - return null; - } - catch (Exception ex) { - _logger.LogError(ex, "Error preparing mesh data for 0x{Id:X16}", id); - return null; - } + return _extractor.PrepareMeshData(id, isSetup, ct); } /// @@ -818,7 +660,7 @@ namespace AcDream.App.Rendering.Wb { bool hasBounds = false; var parts = new List<(ulong GfxObjId, Matrix4x4 Transform)>(); - CollectParts(datId, Matrix4x4.Identity, parts, ref min, ref max, ref hasBounds, CancellationToken.None); + _extractor.CollectParts(datId, Matrix4x4.Identity, parts, ref min, ref max, ref hasBounds, CancellationToken.None); result = hasBounds ? (min, max) : null; } else if (type == DBObjType.EnvCell) { @@ -845,13 +687,13 @@ namespace AcDream.App.Rendering.Wb { bool hasBounds = false; var parts = new List<(ulong GfxObjId, Matrix4x4 Transform)>(); - CollectParts(datId, Matrix4x4.Identity, parts, ref min, ref max, ref hasBounds, CancellationToken.None); + _extractor.CollectParts(datId, Matrix4x4.Identity, parts, ref min, ref max, ref hasBounds, CancellationToken.None); result = hasBounds ? (min, max) : null; } } else { if (!db.TryGet(datId, out var gfxObj)) return null; - result = ComputeBounds(gfxObj, Vector3.One); + result = _extractor.ComputeBounds(gfxObj, Vector3.One); } _boundsCache[id] = result; return result; @@ -864,181 +706,6 @@ namespace AcDream.App.Rendering.Wb { #region Private: Background Preparation - private ObjectMeshData? PrepareSetupMeshData(ulong id, Setup setup, CancellationToken ct) { - var parts = new List<(ulong GfxObjId, Matrix4x4 Transform)>(); - var min = new Vector3(float.MaxValue); - var max = new Vector3(float.MinValue); - bool hasBounds = false; - - CollectParts((uint)(id & 0xFFFFFFFFu), Matrix4x4.Identity, parts, ref min, ref max, ref hasBounds, ct); - - var emitters = new List(); - var processedScripts = new HashSet(); - if (setup.DefaultScript.DataId != 0) { - if (processedScripts.Add(setup.DefaultScript.DataId)) { - CollectEmittersFromScript(setup.DefaultScript.DataId, emitters, ct); - } - } - - return new ObjectMeshData { - ObjectId = id, - IsSetup = true, - SetupParts = parts, - ParticleEmitters = emitters, - BoundingBox = hasBounds ? new BoundingBox(min, max) : default, - SelectionSphere = setup.SelectionSphere - }; - } - - private void CollectEmittersFromScript(uint scriptId, List emitters, CancellationToken ct) { - if (_dats.Portal.TryGet(scriptId, out var script)) { - foreach (var hook in script.ScriptData) { - if (hook.Hook.HookType == AnimationHookType.CreateParticle && hook.Hook is CreateParticleHook particleHook) { - if (_dats.Portal.TryGet(particleHook.EmitterInfoId.DataId, out var emitter)) { - emitters.Add(new StagedEmitter { - Emitter = emitter, - PartIndex = particleHook.PartIndex, - Offset = Matrix4x4.CreateFromQuaternion(particleHook.Offset.Orientation) * Matrix4x4.CreateTranslation(particleHook.Offset.Origin) - }); - - // Pre-load and stage the particle's GfxObjs - if (emitter.HwGfxObjId.DataId != 0) { - var meshData = PrepareMeshData(emitter.HwGfxObjId.DataId, false, ct); - if (meshData != null) { - _stagedMeshData.Enqueue(meshData); - } - } - if (emitter.GfxObjId.DataId != 0 && emitter.GfxObjId.DataId != emitter.HwGfxObjId.DataId) { - var meshData = PrepareMeshData(emitter.GfxObjId.DataId, false, ct); - if (meshData != null) { - _stagedMeshData.Enqueue(meshData); - } - } - } - } - } - } - } - - private void CollectParts(uint id, Matrix4x4 currentTransform, List<(ulong GfxObjId, Matrix4x4 Transform)> parts, ref Vector3 min, ref Vector3 max, ref bool hasBounds, CancellationToken ct, int depth = 0) { - if (depth > 50) { - _logger.LogWarning("Max recursion depth reached while collecting parts for 0x{Id:X8}. Possible circular dependency.", id); - return; - } - ct.ThrowIfCancellationRequested(); - - var resolutions = _dats.ResolveId(id).ToList(); - var selectedResolution = resolutions.OrderByDescending(r => r.Database == _dats.Portal).FirstOrDefault(); - if (selectedResolution == null) return; - - var type = selectedResolution.Type; - var db = selectedResolution.Database; - - if (type == DBObjType.Setup) { - if (!db.TryGet(id, out var setup)) return; - - // Use Resting placement first, then default - if (!setup.PlacementFrames.TryGetValue(Placement.Resting, out var placementFrame)) { - if (!setup.PlacementFrames.TryGetValue(Placement.Default, out placementFrame)) { - placementFrame = setup.PlacementFrames.Values.FirstOrDefault(); - } - } - if (placementFrame == null) return; - - for (int i = 0; i < setup.Parts.Count; i++) { - var partId = setup.Parts[i]; - var transform = Matrix4x4.Identity; - - if (setup.Flags.HasFlag(SetupFlags.HasDefaultScale) && setup.DefaultScale.Count > i) { - transform *= Matrix4x4.CreateScale(setup.DefaultScale[i]); - } - - if (placementFrame.Frames != null && i < placementFrame.Frames.Count) { - var orientation = new System.Numerics.Quaternion( - (float)placementFrame.Frames[i].Orientation.X, - (float)placementFrame.Frames[i].Orientation.Y, - (float)placementFrame.Frames[i].Orientation.Z, - (float)placementFrame.Frames[i].Orientation.W - ); - transform *= Matrix4x4.CreateFromQuaternion(orientation) - * Matrix4x4.CreateTranslation(placementFrame.Frames[i].Origin); - } - - CollectParts(partId, transform * currentTransform, parts, ref min, ref max, ref hasBounds, ct, depth + 1); - } - } - else if (type == DBObjType.EnvCell) { - if (!db.TryGet(id, out var envCell)) return; - - // Calculate the inverse transform of the cell to localize its contents - var cellOrientation = new System.Numerics.Quaternion( - (float)envCell.Position.Orientation.X, - (float)envCell.Position.Orientation.Y, - (float)envCell.Position.Orientation.Z, - (float)envCell.Position.Orientation.W - ); - var cellTransform = Matrix4x4.CreateFromQuaternion(cellOrientation) * - Matrix4x4.CreateTranslation(envCell.Position.Origin); - if (!Matrix4x4.Invert(cellTransform, out var invertCellTransform)) { - invertCellTransform = Matrix4x4.Identity; - } - - // Include cell geometry - uint envId = 0x0D000000u | envCell.EnvironmentId; - if (_dats.Portal.TryGet(envId, out var environment)) { - if (environment.Cells.TryGetValue(envCell.CellStructure, out var cellStruct)) { - foreach (var vert in cellStruct.VertexArray.Vertices.Values) { - var transformed = Vector3.Transform(vert.Origin, currentTransform); - min = Vector3.Min(min, transformed); - max = Vector3.Max(max, transformed); - } - hasBounds = true; - - // Add synthetic geometry ID to parts list - parts.Add(((ulong)id | 0x1_0000_0000UL, currentTransform)); - } - } - - foreach (var stab in envCell.StaticObjects) { - var orientation = new System.Numerics.Quaternion( - (float)stab.Frame.Orientation.X, - (float)stab.Frame.Orientation.Y, - (float)stab.Frame.Orientation.Z, - (float)stab.Frame.Orientation.W - ); - var transform = Matrix4x4.CreateFromQuaternion(orientation) - * Matrix4x4.CreateTranslation(stab.Frame.Origin); - // Localize static object transform relative to the cell - var localizedTransform = transform * invertCellTransform; - - CollectParts(stab.Id, localizedTransform * currentTransform, parts, ref min, ref max, ref hasBounds, ct, depth + 1); - } - } - else if (type == DBObjType.GfxObj) { - parts.Add((id, currentTransform)); - - if (db.TryGet(id, out var partGfx)) { - var (partMin, partMax) = ComputeBounds(partGfx, Vector3.One); - var corners = new Vector3[8]; - corners[0] = new Vector3(partMin.X, partMin.Y, partMin.Z); - corners[1] = new Vector3(partMin.X, partMin.Y, partMax.Z); - corners[2] = new Vector3(partMin.X, partMax.Y, partMin.Z); - corners[3] = new Vector3(partMin.X, partMax.Y, partMax.Z); - corners[4] = new Vector3(partMax.X, partMin.Y, partMin.Z); - corners[5] = new Vector3(partMax.X, partMin.Y, partMax.Z); - corners[6] = new Vector3(partMax.X, partMax.Y, partMin.Z); - corners[7] = new Vector3(partMax.X, partMax.Y, partMax.Z); - - foreach (var corner in corners) { - var transformed = Vector3.Transform(corner, currentTransform); - min = Vector3.Min(min, transformed); - max = Vector3.Max(max, transformed); - } - hasBounds = true; - } - } - } - /// /// #113: the set of polygon ids referenced by the GfxObj's drawing BSP — /// the polys retail actually renders (D3DPolyRender traverses the BSP; @@ -1060,769 +727,6 @@ namespace AcDream.App.Rendering.Wb { if (node.NegNode is not null) CollectDrawingBspPolygonIds(node.NegNode, ids); } - private ObjectMeshData? PrepareGfxObjMeshData(ulong id, GfxObj gfxObj, Vector3 scale, CancellationToken ct) { - var vertices = new List(); - var UVLookup = new Dictionary<(ushort vertId, ushort uvIdx, bool isNeg), ushort>(); - var batchesByFormat = new Dictionary<(int Width, int Height, TextureFormat Format), List>(); - - var (min, max) = ComputeBounds(gfxObj, scale); - var boundingBox = new BoundingBox(min, max); - - // #113 (2026-06-11): retail draws a GfxObj by TRAVERSING its drawing - // BSP — a polygon present in the Polygons dictionary but referenced by - // no DrawingBSP node is never rendered (physics/no-draw geometry). - // The Holtburg meeting hall (0x010014C3) keeps its walkable exterior - // stair-ramp as dictionary polys {0,1}: in the PhysicsBSP (NPCs walk - // it) but absent from every DrawingBSP node — retail shows a plain - // wall; iterating the dictionary draws the "phantom staircase" - // (invisible-but-walkable in retail, visible in acdream). The hill - // cottage (0x01000827) carries 8 such orphans. - // - // ⚠️ FILTER NOT APPLIED (e46d3d9 un-applied same day): naively - // filtering to CollectDrawingBspPolygonIds(gfxObj) made DOORS - // disappear across Holtburg (user gate 2026-06-11) — the naive - // PosNode/NegNode walk evidently misses polys some models reference - // another way (portal-type nodes? leaf indexing? DatReaderWriter - // parse gap?). Diagnose with the histogram fact in - // Issue113PhantomStairsDumpTests on a door GfxObj BEFORE re-landing. - // The full retail draw is BSP-TRAVERSAL ORDER drawing, not a - // dictionary iteration with a filter — see the holistic port handoff - // docs/research/2026-06-11-building-render-holistic-port-handoff.md. - foreach (var polyEntry in gfxObj.Polygons) { - ct.ThrowIfCancellationRequested(); - var poly = polyEntry.Value; - if (poly.VertexIds.Count < 3) continue; - - // Handle Positive Surface - if (!poly.Stippling.HasFlag(StipplingType.NoPos)) { - AddSurfaceToBatch(poly, poly.PosSurface, false); - } - - // Handle Negative Surface - // Some objects use Clockwise CullMode to indicate negative surface data is present - bool hasNeg = poly.Stippling.HasFlag(StipplingType.Negative) || - poly.Stippling.HasFlag(StipplingType.Both) || - (!poly.Stippling.HasFlag(StipplingType.NoNeg) && poly.SidesType == CullMode.Clockwise); - - if (hasNeg) { - AddSurfaceToBatch(poly, poly.NegSurface, true); - } - - void AddSurfaceToBatch(Polygon poly, short surfaceIdx, bool isNeg) { - if (surfaceIdx < 0 || surfaceIdx >= gfxObj.Surfaces.Count) return; - - var surfaceId = gfxObj.Surfaces[surfaceIdx]; - if (!_dats.Portal.TryGet(surfaceId, out var surface)) { - // TEMP diagnostic (dat-race investigation 2026-06-09, strip with fix) - Console.WriteLine($"[tex-skip] gfxobj Surface 0x{surfaceId:X8} miss -> poly batch dropped (obj 0x{gfxObj.Id:X8})"); - return; - } - - int texWidth, texHeight; - byte[] textureData; - TextureFormat textureFormat; - PixelFormat? uploadPixelFormat = null; - PixelType? uploadPixelType = null; - bool isSolid = poly.Stippling.HasFlag(StipplingType.NoPos) || surface.Type.HasFlag(SurfaceType.Base1Solid); - bool isClipMap = surface.Type.HasFlag(SurfaceType.Base1ClipMap); - uint paletteId = 0; - bool isDxt3or5 = false; - DatReaderWriter.Enums.PixelFormat? sourceFormat = null; - var isAdditive = false; - var isTransparent = false; - - if (isSolid) { - texWidth = texHeight = 32; - textureData = TextureHelpers.CreateSolidColorTexture(surface.ColorValue, texWidth, texHeight); - textureFormat = TextureFormat.RGBA8; - uploadPixelFormat = PixelFormat.Rgba; - } - else if (_dats.Portal.TryGet(surface.OrigTextureId, out var surfaceTexture)) { - var renderSurfaceId = surfaceTexture.Textures.First(); - if (!_dats.Portal.TryGet(renderSurfaceId, out var renderSurface)) { - // check highres - if (!_dats.HighRes.TryGet(renderSurfaceId, out var hrRenderSurface)) { - throw new Exception($"Unable to load RenderSurface: 0x{renderSurfaceId:X8}"); - } - - renderSurface = hrRenderSurface; - } - - texWidth = renderSurface.Width; - texHeight = renderSurface.Height; - paletteId = renderSurface.DefaultPaletteId; - sourceFormat = renderSurface.Format; - - if (TextureHelpers.IsCompressedFormat(renderSurface.Format)) { - isDxt3or5 = renderSurface.Format == DatReaderWriter.Enums.PixelFormat.PFID_DXT3 || renderSurface.Format == DatReaderWriter.Enums.PixelFormat.PFID_DXT5; - textureFormat = TextureFormat.RGBA8; - uploadPixelFormat = PixelFormat.Rgba; - - if (_decodedTextureCache.TryGetValue(renderSurfaceId, out textureData!)) { - // use cached data - } - else { - textureData = new byte[texWidth * texHeight * 4]; - - CompressionFormat compressionFormat = renderSurface.Format switch { - DatReaderWriter.Enums.PixelFormat.PFID_DXT1 => CompressionFormat.Bc1, - DatReaderWriter.Enums.PixelFormat.PFID_DXT3 => CompressionFormat.Bc2, - DatReaderWriter.Enums.PixelFormat.PFID_DXT5 => CompressionFormat.Bc3, - _ => throw new NotSupportedException($"Unsupported compressed format: {renderSurface.Format}") - }; - - using (var image = _bcDecoder.Value!.DecodeRawToImageRgba32(renderSurface.SourceData, texWidth, texHeight, compressionFormat)) { - image.CopyPixelDataTo(textureData); - } - _decodedTextureCache.TryAdd(renderSurfaceId, textureData); - } - - if (isClipMap && textureData != null) { - // If we got this from the cache, we need to clone it so we don't scale the cached raw data - if (_decodedTextureCache.ContainsKey(renderSurfaceId)) { - var clonedData = new byte[textureData.Length]; - System.Buffer.BlockCopy(textureData, 0, clonedData, 0, textureData.Length); - textureData = clonedData; - } - - for (int i = 0; i < textureData.Length; i += 4) { - if (textureData[i] == 0 && textureData[i + 1] == 0 && textureData[i + 2] == 0) { - textureData[i + 3] = 0; - } - } - } - } - else { - textureFormat = TextureFormat.RGBA8; - textureData = renderSurface.SourceData; - switch (renderSurface.Format) { - case DatReaderWriter.Enums.PixelFormat.PFID_A8R8G8B8: - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillA8R8G8B8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_R8G8B8: - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillR8G8B8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_INDEX16: - if (!_dats.Portal.TryGet(renderSurface.DefaultPaletteId, out var paletteData)) - throw new Exception($"Unable to load Palette: 0x{renderSurface.DefaultPaletteId:X8}"); - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillIndex16(renderSurface.SourceData, paletteData, textureData.AsSpan(), texWidth, texHeight, isClipMap); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_P8: - if (!_dats.Portal.TryGet(renderSurface.DefaultPaletteId, out var p8PaletteData)) - throw new Exception($"Unable to load Palette: 0x{renderSurface.DefaultPaletteId:X8}"); - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillP8(renderSurface.SourceData, p8PaletteData, textureData.AsSpan(), texWidth, texHeight, isClipMap); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_R5G6B5: - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillR5G6B5(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_A4R4G4B4: - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillA4R4G4B4(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_A8: - case DatReaderWriter.Enums.PixelFormat.PFID_CUSTOM_LSCAPE_ALPHA: - textureData = new byte[texWidth * texHeight * 4]; - if (surface.Type.HasFlag(SurfaceType.Additive)) { - TextureHelpers.FillA8Additive(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - } - else { - TextureHelpers.FillA8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - } - uploadPixelFormat = PixelFormat.Rgba; - break; - default: - throw new NotSupportedException($"Unsupported surface format: {renderSurface.Format}"); - } - } - - if (surface.Translucency > 0.0f && textureData != null) { - // If we got this from the cache, we need to clone it so we don't scale the cached raw data - if (sourceFormat.HasValue && TextureHelpers.IsCompressedFormat(sourceFormat.Value) && _decodedTextureCache.ContainsKey(renderSurfaceId)) { - var clonedData = new byte[textureData.Length]; - System.Buffer.BlockCopy(textureData, 0, clonedData, 0, textureData.Length); - textureData = clonedData; - } - - float alphaScale = 1.0f - surface.Translucency; - for (int i = 3; i < textureData.Length; i += 4) { - textureData[i] = (byte)(textureData[i] * alphaScale); - } - } - - isAdditive = !isSolid && surface.Type.HasFlag(SurfaceType.Additive); - isTransparent = isSolid ? surface.ColorValue.Alpha < 255 : - (surface.Type.HasFlag(SurfaceType.Translucent) || - surface.Type.HasFlag(SurfaceType.Base1ClipMap) || - ((uint)surface.Type & 0x100) != 0 || // Alpha - ((uint)surface.Type & 0x200) != 0 || // InvAlpha - isAdditive || - (surface.Translucency > 0.0f && surface.Translucency < 1.0f) || - textureFormat == TextureFormat.A8 || - textureFormat == TextureFormat.Rgba32f || - isDxt3or5 || - (sourceFormat != null && (sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_A8R8G8B8 || - sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_A4R4G4B4 || - sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_DXT3 || - sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_DXT5))); - } - else { - // TEMP diagnostic (dat-race investigation 2026-06-09, strip with fix) - Console.WriteLine($"[tex-skip] gfxobj SurfaceTexture 0x{surface.OrigTextureId:X8} miss -> poly batch dropped (surface 0x{surfaceId:X8})"); - return; - } - - var format = (texWidth, texHeight, textureFormat); - var key = new TextureAtlasManager.TextureKey { - SurfaceId = surfaceId, - PaletteId = paletteId, - Stippling = poly.Stippling, - IsSolid = isSolid - }; - - if (!batchesByFormat.TryGetValue(format, out var batches)) { - batches = new List(); - batchesByFormat[format] = batches; - } - - var batch = batches.FirstOrDefault(b => b.Key.Equals(key) && b.CullMode == poly.SidesType); - if (batch == null) { - batch = new TextureBatchData { - Key = key, - CullMode = poly.SidesType, - TextureData = textureData!, - UploadPixelFormat = uploadPixelFormat, - UploadPixelType = uploadPixelType, - IsTransparent = isTransparent, - IsAdditive = isAdditive - }; - batches.Add(batch); - } - - bool batchHasWrappingUVs = batch.HasWrappingUVs; - BuildPolygonIndices(poly, gfxObj, scale, UVLookup, vertices, batch.Indices, isNeg, ref batchHasWrappingUVs); - batch.HasWrappingUVs = batchHasWrappingUVs; - } - } - - return new ObjectMeshData { - ObjectId = id, - IsSetup = false, - Vertices = vertices.ToArray(), - TextureBatches = batchesByFormat, - BoundingBox = boundingBox, - SortCenter = gfxObj?.SortCenter ?? Vector3.Zero, - DIDDegrade = gfxObj != null && gfxObj.Flags.HasFlag(GfxObjFlags.HasDIDDegrade) ? gfxObj.DIDDegrade : 0, - SelectionSphere = new Sphere { Origin = boundingBox.Center, Radius = Vector3.Distance(boundingBox.Max, boundingBox.Min) / 2.0f } - }; - } - - private ObjectMeshData? PrepareEnvCellMeshData(ulong id, EnvCell envCell, CancellationToken ct) { - var parts = new List<(ulong GfxObjId, Matrix4x4 Transform)>(); - var min = new Vector3(float.MaxValue); - var max = new Vector3(float.MinValue); - bool hasBounds = false; - - // Calculate the inverse transform of the cell to localize its contents - var cellOrientation = new System.Numerics.Quaternion( - (float)envCell.Position.Orientation.X, - (float)envCell.Position.Orientation.Y, - (float)envCell.Position.Orientation.Z, - (float)envCell.Position.Orientation.W - ); - var cellTransform = Matrix4x4.CreateFromQuaternion(cellOrientation) * - Matrix4x4.CreateTranslation(envCell.Position.Origin); - if (!Matrix4x4.Invert(cellTransform, out var invertCellTransform)) { - invertCellTransform = Matrix4x4.Identity; - } - - // Add static objects - var emitters = new List(); - foreach (var stab in envCell.StaticObjects) { - var orientation = new System.Numerics.Quaternion( - (float)stab.Frame.Orientation.X, - (float)stab.Frame.Orientation.Y, - (float)stab.Frame.Orientation.Z, - (float)stab.Frame.Orientation.W - ); - var transform = Matrix4x4.CreateFromQuaternion(orientation) - * Matrix4x4.CreateTranslation(stab.Frame.Origin); - - // Localize static object transform relative to the cell - var localizedTransform = transform * invertCellTransform; - - CollectParts(stab.Id, localizedTransform, parts, ref min, ref max, ref hasBounds, ct); - - // For EnvCell static objects, we need to manually collect emitters if they are Setups. - // Bugfix 2026-05-19 (acdream): pre-check the Setup-prefix (0x02xxxxxx) before calling - // TryGet. Without this, calling TryGet on a GfxObj-prefixed id - // (0x01xxxxxx) throws ArgumentOutOfRangeException as DatReaderWriter tries to parse - // GfxObj bytes as a Setup record. The exception bubbles up through PrepareMeshData's - // outer catch and the entire cell fails to upload — manifesting as missing floors - // in any building whose StaticObjects include a GfxObj-typed stab (very common). - // Confirmed via acdream's Phase 2 indoor-cell-rendering diagnostic probes; see - // docs/research/2026-05-19-indoor-cell-rendering-cause.md in the acdream repo. - if ((stab.Id & 0xFF000000u) == 0x02000000u - && _dats.Portal.TryGet(stab.Id, out var stabSetup)) { - var stabEmitters = new List(); - var processedScripts = new HashSet(); - if (stabSetup.DefaultScript.DataId != 0) { - if (processedScripts.Add(stabSetup.DefaultScript.DataId)) { - CollectEmittersFromScript(stabSetup.DefaultScript.DataId, stabEmitters, ct); - } - } - - foreach (var emitter in stabEmitters) { - emitters.Add(new StagedEmitter { - Emitter = emitter.Emitter, - PartIndex = emitter.PartIndex, - Offset = emitter.Offset * localizedTransform - }); - } - } - } - - // Load environment and cell structure geometry - uint envId = 0x0D000000u | envCell.EnvironmentId; - ObjectMeshData? cellGeometry = null; - if (_dats.Portal.TryGet(envId, out var environment)) { - if (environment.Cells.TryGetValue(envCell.CellStructure, out var cellStruct)) { - var cellGeomId = id | 0x1_0000_0000UL; - cellGeometry = PrepareCellStructMeshData(cellGeomId, cellStruct, envCell.Surfaces, Matrix4x4.Identity, ct); - if (cellGeometry != null) { - parts.Add((cellGeomId, Matrix4x4.Identity)); - min = Vector3.Min(min, cellGeometry.BoundingBox.Min); - max = Vector3.Max(max, cellGeometry.BoundingBox.Max); - hasBounds = true; - } - } - } - - return new ObjectMeshData { - ObjectId = id, - IsSetup = true, - SetupParts = parts, - ParticleEmitters = emitters, - EnvCellGeometry = cellGeometry, - BoundingBox = hasBounds ? new BoundingBox(min, max) : default, - SelectionSphere = new Sphere { Origin = hasBounds ? (min + max) / 2f : Vector3.Zero, Radius = hasBounds ? Vector3.Distance(max, min) / 2.0f : 0f } - }; - } - - private ObjectMeshData? PrepareCellStructMeshData(ulong id, CellStruct cellStruct, List surfaceOverrides, Matrix4x4 transform, CancellationToken ct) { - var vertices = new List(); - var UVLookup = new Dictionary<(ushort vertId, ushort uvIdx, bool isNeg), ushort>(); - var batchesByFormat = new Dictionary<(int Width, int Height, TextureFormat Format), List>(); - - var min = new Vector3(float.MaxValue); - var max = new Vector3(float.MinValue); - foreach (var vert in cellStruct.VertexArray.Vertices.Values) { - var localizedPos = Vector3.Transform(vert.Origin, transform); - min = Vector3.Min(min, localizedPos); - max = Vector3.Max(max, localizedPos); - } - var boundingBox = new BoundingBox(min, max); - - foreach (var poly in cellStruct.Polygons.Values) { - ct.ThrowIfCancellationRequested(); - if (poly.VertexIds.Count < 3) continue; - - // Retail D3DPolyRender::ConstructMesh (0x0059dfa0) treats this - // DatReaderWriter "CullMode" as CPolygon::sides_type, not as a - // GL cull enum: 0 = pos, 1 = pos twice with reversed winding, - // 2 = pos + neg surface. The DAT-side NoPos/NoNeg flags still - // suppress hidden portal/cap faces before they reach our mesh. - bool hasPos = !poly.Stippling.HasFlag(StipplingType.NoPos); - bool hasNeg = !poly.Stippling.HasFlag(StipplingType.NoNeg); - - if (hasPos) - AddSurfaceToBatch(poly, poly.PosSurface, useNegUv: false, invertNormal: false, reverseWinding: false); - if (hasPos && poly.SidesType == CullMode.None) { - AddSurfaceToBatch(poly, poly.PosSurface, useNegUv: false, invertNormal: true, reverseWinding: true); - } - else if (hasNeg && poly.SidesType == CullMode.Clockwise) { - AddSurfaceToBatch(poly, poly.NegSurface, useNegUv: true, invertNormal: true, reverseWinding: false); - } - - void AddSurfaceToBatch(Polygon poly, short surfaceIdx, bool useNegUv, bool invertNormal, bool reverseWinding) { - if (surfaceIdx < 0) return; - - uint surfaceId; - if (surfaceIdx < surfaceOverrides.Count) { - surfaceId = 0x08000000u | surfaceOverrides[surfaceIdx]; - } - else { - _logger.LogWarning($"Failed to find surface override for index {surfaceIdx} in CellStruct 0x{cellStruct:X4}"); - return; - } - - if (!_dats.Portal.TryGet(surfaceId, out var surface)) { - // TEMP diagnostic (dat-race investigation 2026-06-09, strip with fix) - Console.WriteLine($"[tex-skip] cellstruct Surface 0x{surfaceId:X8} miss -> WALL poly batch dropped (cellstruct 0x{cellStruct:X4})"); - return; - } - - int texWidth, texHeight; - byte[] textureData; - TextureFormat textureFormat; - PixelFormat? uploadPixelFormat = null; - PixelType? uploadPixelType = null; - bool isSolid = poly.Stippling.HasFlag(StipplingType.NoPos) || surface.Type.HasFlag(SurfaceType.Base1Solid); - bool isClipMap = surface.Type.HasFlag(SurfaceType.Base1ClipMap); - uint paletteId = 0; - bool isDxt3or5 = false; - DatReaderWriter.Enums.PixelFormat? sourceFormat = null; - var isAdditive = false; - var isTransparent = false; - - if (isSolid) { - texWidth = texHeight = 32; - textureData = TextureHelpers.CreateSolidColorTexture(surface.ColorValue, texWidth, texHeight); - textureFormat = TextureFormat.RGBA8; - uploadPixelFormat = PixelFormat.Rgba; - } - else if (_dats.Portal.TryGet(surface.OrigTextureId, out var surfaceTexture)) { - var renderSurfaceId = surfaceTexture.Textures.First(); - if (!_dats.Portal.TryGet(renderSurfaceId, out var renderSurface)) { - if (!_dats.HighRes.TryGet(renderSurfaceId, out var hrRenderSurface)) { - // TEMP diagnostic (dat-race investigation 2026-06-09, strip with fix) - Console.WriteLine($"[tex-skip] cellstruct RenderSurface 0x{renderSurfaceId:X8} miss (portal+highres) -> WALL poly batch dropped"); - return; - } - renderSurface = hrRenderSurface; - } - - texWidth = renderSurface.Width; - texHeight = renderSurface.Height; - paletteId = renderSurface.DefaultPaletteId; - sourceFormat = renderSurface.Format; - - if (_decodedTextureCache.TryGetValue(renderSurfaceId, out var cachedData)) { - textureData = cachedData; - textureFormat = TextureFormat.RGBA8; - uploadPixelFormat = PixelFormat.Rgba; - } - else { - if (TextureHelpers.IsCompressedFormat(renderSurface.Format)) { - isDxt3or5 = renderSurface.Format == DatReaderWriter.Enums.PixelFormat.PFID_DXT3 || renderSurface.Format == DatReaderWriter.Enums.PixelFormat.PFID_DXT5; - textureFormat = TextureFormat.RGBA8; - uploadPixelFormat = PixelFormat.Rgba; - - textureData = new byte[texWidth * texHeight * 4]; - CompressionFormat compressionFormat = renderSurface.Format switch { - DatReaderWriter.Enums.PixelFormat.PFID_DXT1 => CompressionFormat.Bc1, - DatReaderWriter.Enums.PixelFormat.PFID_DXT3 => CompressionFormat.Bc2, - DatReaderWriter.Enums.PixelFormat.PFID_DXT5 => CompressionFormat.Bc3, - _ => throw new NotSupportedException($"Unsupported compressed format: {renderSurface.Format}") - }; - - using (var image = _bcDecoder.Value!.DecodeRawToImageRgba32(renderSurface.SourceData, texWidth, texHeight, compressionFormat)) { - image.CopyPixelDataTo(textureData); - } - } - else { - textureFormat = TextureFormat.RGBA8; - textureData = renderSurface.SourceData; - switch (renderSurface.Format) { - case DatReaderWriter.Enums.PixelFormat.PFID_A8R8G8B8: - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillA8R8G8B8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_R8G8B8: - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillR8G8B8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_INDEX16: - if (!_dats.Portal.TryGet(renderSurface.DefaultPaletteId, out var paletteData)) return; - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillIndex16(renderSurface.SourceData, paletteData, textureData.AsSpan(), texWidth, texHeight, isClipMap); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_P8: - if (!_dats.Portal.TryGet(renderSurface.DefaultPaletteId, out var p8PaletteData)) return; - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillP8(renderSurface.SourceData, p8PaletteData, textureData.AsSpan(), texWidth, texHeight, isClipMap); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_R5G6B5: - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillR5G6B5(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_A4R4G4B4: - textureData = new byte[texWidth * texHeight * 4]; - TextureHelpers.FillA4R4G4B4(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - uploadPixelFormat = PixelFormat.Rgba; - break; - case DatReaderWriter.Enums.PixelFormat.PFID_A8: - case DatReaderWriter.Enums.PixelFormat.PFID_CUSTOM_LSCAPE_ALPHA: - textureData = new byte[texWidth * texHeight * 4]; - if (surface.Type.HasFlag(SurfaceType.Additive)) { - TextureHelpers.FillA8Additive(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - } - else { - TextureHelpers.FillA8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); - } - uploadPixelFormat = PixelFormat.Rgba; - break; - default: return; - } - } - - // Add to cache with LRU logic - if (textureData != null && _decodedTextureCache.TryAdd(renderSurfaceId, textureData)) { - _decodedTextureLru.Enqueue(renderSurfaceId); - if (_decodedTextureCache.Count > MaxDecodedTextures) { - if (_decodedTextureLru.TryDequeue(out var evictedId)) { - _decodedTextureCache.TryRemove(evictedId, out _); - } - } - } - } - - if (isClipMap && textureData != null) { - // If we got this from the cache, we need to clone it so we don't scale the cached raw data - var clonedData = new byte[textureData.Length]; - System.Buffer.BlockCopy(textureData, 0, clonedData, 0, textureData.Length); - textureData = clonedData; - - for (int i = 0; i < textureData.Length; i += 4) { - if (textureData[i] == 0 && textureData[i + 1] == 0 && textureData[i + 2] == 0) { - textureData[i + 3] = 0; - } - } - } - } - else { - // TEMP diagnostic (dat-race investigation 2026-06-09, strip with fix) - Console.WriteLine($"[tex-skip] cellstruct SurfaceTexture 0x{surface.OrigTextureId:X8} miss -> WALL poly batch dropped (surface 0x{surfaceId:X8})"); - return; - } - - isAdditive = !isSolid && surface.Type.HasFlag(SurfaceType.Additive); - isTransparent = isSolid ? surface.ColorValue.Alpha < 255 : - (surface.Type.HasFlag(SurfaceType.Translucent) || - surface.Type.HasFlag(SurfaceType.Base1ClipMap) || - ((uint)surface.Type & 0x100) != 0 || // Alpha - ((uint)surface.Type & 0x200) != 0 || // InvAlpha - isAdditive || - (surface.Translucency > 0.0f && surface.Translucency < 1.0f) || - textureFormat == TextureFormat.A8 || - textureFormat == TextureFormat.Rgba32f || - isDxt3or5 || - (sourceFormat != null && (sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_A8R8G8B8 || - sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_A4R4G4B4 || - sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_DXT3 || - sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_DXT5))); - - var format = (texWidth, texHeight, textureFormat); - var key = new TextureAtlasManager.TextureKey { - SurfaceId = surfaceId, - PaletteId = paletteId, - Stippling = poly.Stippling, - IsSolid = isSolid - }; - - if (!batchesByFormat.TryGetValue(format, out var batches)) { - batches = new List(); - batchesByFormat[format] = batches; - } - - var batch = batches.FirstOrDefault(b => b.Key.Equals(key) && b.CullMode == poly.SidesType); - if (batch == null) { - batch = new TextureBatchData { - Key = key, - CullMode = poly.SidesType, - TextureData = textureData!, - UploadPixelFormat = uploadPixelFormat, - UploadPixelType = uploadPixelType, - IsTransparent = isTransparent, - IsAdditive = isAdditive - }; - batches.Add(batch); - } - - // Helper for CellStruct vertices - bool batchHasWrappingUVs = batch.HasWrappingUVs; - BuildCellStructPolygonIndices( - poly, - cellStruct, - UVLookup, - vertices, - batch.Indices, - useNegUv, - invertNormal, - reverseWinding, - transform, - ref batchHasWrappingUVs); - batch.HasWrappingUVs = batchHasWrappingUVs; - } - } - - return new ObjectMeshData { - ObjectId = id, - IsSetup = false, - Vertices = vertices.ToArray(), - TextureBatches = batchesByFormat, - BoundingBox = boundingBox, - SortCenter = Vector3.Zero, - SelectionSphere = new Sphere { Origin = boundingBox.Center, Radius = Vector3.Distance(boundingBox.Max, boundingBox.Min) / 2.0f } - }; - } - - private void BuildCellStructPolygonIndices(Polygon poly, CellStruct cellStruct, - Dictionary<(ushort vertId, ushort uvIdx, bool invertNormal), ushort> UVLookup, - List vertices, List indices, - bool useNegUv, bool invertNormal, bool reverseWinding, - Matrix4x4 transform, ref bool hasWrappingUVs) { - - var polyIndices = new List(); - - for (int i = 0; i < poly.VertexIds.Count; i++) { - ushort vertId = (ushort)poly.VertexIds[i]; - ushort uvIdx = 0; - - if (useNegUv && poly.NegUVIndices != null && i < poly.NegUVIndices.Count) - uvIdx = poly.NegUVIndices[i]; - else if (poly.PosUVIndices != null && i < poly.PosUVIndices.Count) - uvIdx = poly.PosUVIndices[i]; - - if (!cellStruct.VertexArray.Vertices.TryGetValue(vertId, out var vertex)) continue; - - if (uvIdx >= vertex.UVs.Count) { - uvIdx = 0; - } - - var key = (vertId, uvIdx, invertNormal); - - if (!hasWrappingUVs) { - var uvCheck = vertex.UVs.Count > 0 - ? new Vector2(vertex.UVs[uvIdx].U, vertex.UVs[uvIdx].V) - : Vector2.Zero; - if (uvCheck.X < 0f || uvCheck.X > 1f || uvCheck.Y < 0f || uvCheck.Y > 1f) { - hasWrappingUVs = true; - } - } - - if (!UVLookup.TryGetValue(key, out var idx)) { - var uv = vertex.UVs.Count > 0 - ? new Vector2(vertex.UVs[uvIdx].U, vertex.UVs[uvIdx].V) - : Vector2.Zero; - - var normal = Vector3.Normalize(Vector3.TransformNormal(vertex.Normal, transform)); - if (invertNormal) { - normal = -normal; - } - - idx = (ushort)vertices.Count; - vertices.Add(new VertexPositionNormalTexture( - Vector3.Transform(vertex.Origin, transform), - normal, - uv - )); - UVLookup[key] = idx; - } - polyIndices.Add(idx); - } - - if (reverseWinding) { - for (int i = 2; i < polyIndices.Count; i++) { - indices.Add(polyIndices[i]); - indices.Add(polyIndices[i - 1]); - indices.Add(polyIndices[0]); - } - } - else { - for (int i = 2; i < polyIndices.Count; i++) { - indices.Add(polyIndices[0]); - indices.Add(polyIndices[i - 1]); - indices.Add(polyIndices[i]); - } - } - } - - private void BuildPolygonIndices(Polygon poly, GfxObj gfxObj, Vector3 scale, - Dictionary<(ushort vertId, ushort uvIdx, bool isNeg), ushort> UVLookup, - List vertices, List indices, bool useNegSurface, ref bool hasWrappingUVs) { - - var polyIndices = new List(); - - for (int i = 0; i < poly.VertexIds.Count; i++) { - ushort vertId = (ushort)poly.VertexIds[i]; - ushort uvIdx = 0; - - if (useNegSurface && poly.NegUVIndices != null && i < poly.NegUVIndices.Count) - uvIdx = poly.NegUVIndices[i]; - else if (!useNegSurface && poly.PosUVIndices != null && i < poly.PosUVIndices.Count) - uvIdx = poly.PosUVIndices[i]; - - if (!gfxObj.VertexArray.Vertices.TryGetValue(vertId, out var vertex)) continue; - - if (uvIdx >= vertex.UVs.Count) { - uvIdx = 0; - } - - var key = (vertId, uvIdx, useNegSurface); - - if (!hasWrappingUVs) { - var uvCheck = vertex.UVs.Count > 0 - ? new Vector2(vertex.UVs[uvIdx].U, vertex.UVs[uvIdx].V) - : Vector2.Zero; - if (uvCheck.X < 0f || uvCheck.X > 1f || uvCheck.Y < 0f || uvCheck.Y > 1f) { - hasWrappingUVs = true; - } - } - - if (!UVLookup.TryGetValue(key, out var idx)) { - var uv = vertex.UVs.Count > 0 - ? new Vector2(vertex.UVs[uvIdx].U, vertex.UVs[uvIdx].V) - : Vector2.Zero; - - var normal = Vector3.Normalize(vertex.Normal); - if (useNegSurface) { - normal = -normal; - } - - idx = (ushort)vertices.Count; - vertices.Add(new VertexPositionNormalTexture( - vertex.Origin * scale, - normal, - uv - )); - UVLookup[key] = idx; - } - polyIndices.Add(idx); - } - - if (useNegSurface) { - // Reverse winding for negative surface so it's visible from the other side - for (int i = 2; i < polyIndices.Count; i++) { - indices.Add(polyIndices[0]); - indices.Add(polyIndices[i - 1]); - indices.Add(polyIndices[i]); - } - } - else { - for (int i = 2; i < polyIndices.Count; i++) { - indices.Add(polyIndices[i]); - indices.Add(polyIndices[i - 1]); - indices.Add(polyIndices[0]); - } - } - } - #endregion #region Private: GPU Upload @@ -1897,7 +801,13 @@ namespace AcDream.App.Rendering.Wb { atlasList.Add(atlasManager); } - textureIndex = atlasManager.AddTexture(batch.Key, batch.TextureData, batch.UploadPixelFormat, batch.UploadPixelType); + // MP1a: AcDream.Content is Silk.NET-free — the extraction records + // carry Content-owned UploadPixelFormat/UploadPixelType enums whose + // underlying values are the GL ABI constants (numerically identical + // to Silk.NET.OpenGL.PixelFormat/PixelType), so this lifted nullable + // cast is value- and null-preserving. + textureIndex = atlasManager.AddTexture(batch.Key, batch.TextureData, + (PixelFormat?)batch.UploadPixelFormat, (PixelType?)batch.UploadPixelType); if (_useModernRendering) { ibo = GlobalBuffer!.IBO; @@ -2043,17 +953,6 @@ namespace AcDream.App.Rendering.Wb { #endregion - private (Vector3 Min, Vector3 Max) ComputeBounds(GfxObj gfxObj, Vector3 scale) { - var min = new Vector3(float.MaxValue); - var max = new Vector3(float.MinValue); - foreach (var vert in gfxObj.VertexArray.Vertices.Values) { - var p = vert.Origin * scale; - min = Vector3.Min(min, p); - max = Vector3.Max(max, p); - } - return (min, max); - } - private void UnloadObject(ulong key) { if (!_renderData.TryGetValue(key, out var data)) return; @@ -2177,102 +1076,5 @@ namespace AcDream.App.Rendering.Wb { } }); } - - private ObjectMeshData? PrepareCellStructEdgeLineData(ulong id, Dictionary cellStructs, Matrix4x4 transform, CancellationToken ct) { - var cellStructList = cellStructs.ToList(); - if (cellStructList.Count == 0) { - return null; - } - - // Calculate bounding box from ALL vertices in all cell structures - var min = new Vector3(float.MaxValue); - var max = new Vector3(float.MinValue); - var allEdgeLines = new List(); - - // Process each CellStruct and collect all edge lines - foreach (var cellStructKvp in cellStructList) { - var cellStruct = cellStructKvp.Value; - - // Build edge lines for this CellStruct - var edgeLines = EdgeLineBuilder.BuildEdgeLines(cellStruct); - - // Transform edge lines to world space and add to collection - foreach (var edgeLine in edgeLines) { - allEdgeLines.Add(Vector3.Transform(edgeLine, transform)); - } - - // Update bounding box with vertices from this CellStruct - foreach (var vert in cellStruct.VertexArray.Vertices.Values) { - var localizedPos = Vector3.Transform(vert.Origin, transform); - min = Vector3.Min(min, localizedPos); - max = Vector3.Max(max, localizedPos); - } - } - - if (allEdgeLines.Count == 0) { - return null; - } - - var boundingBox = new BoundingBox(min, max); - - // Create minimal mesh data for edge line rendering - // We still need some vertices for rendering system to work, but they'll be transparent - var vertices = new List { - new VertexPositionNormalTexture { Position = Vector3.Zero, Normal = Vector3.UnitZ, UV = Vector2.Zero } - }; - var indices = new List { 0, 0, 0 }; // Dummy triangle - - // Create a transparent texture for base triangles (so only edge lines are visible) - var transparentTexture = TextureHelpers.CreateSolidColorTexture(new ColorARGB { Alpha = 0, Red = 255, Green = 255, Blue = 255 }, 1, 1); - - var result = new ObjectMeshData { - ObjectId = id, - IsSetup = false, - Vertices = vertices.ToArray(), - Batches = new List { - new MeshBatchData { - Indices = indices.ToArray(), - TextureFormat = (1, 1, TextureFormat.RGBA8), - TextureKey = new TextureAtlasManager.TextureKey { - SurfaceId = 0xFFFFFFFF, // Dummy surface ID - PaletteId = 0, - Stippling = StipplingType.NoPos, - IsSolid = true - }, - TextureIndex = 0, - TextureData = transparentTexture, - UploadPixelFormat = PixelFormat.Rgba, - UploadPixelType = PixelType.UnsignedByte, - CullMode = CullMode.None - } - }, - // Also populate TextureBatches for GPU upload - TextureBatches = new Dictionary<(int Width, int Height, TextureFormat Format), List> { - [(1, 1, TextureFormat.RGBA8)] = new List { - new TextureBatchData { - Indices = indices.ToList(), - Key = new TextureAtlasManager.TextureKey { - SurfaceId = 0xFFFFFFFF, // Dummy surface ID - PaletteId = 0, - Stippling = StipplingType.NoPos, - IsSolid = true - }, - TextureData = transparentTexture, - UploadPixelFormat = PixelFormat.Rgba, - UploadPixelType = PixelType.UnsignedByte, - CullMode = CullMode.None, - IsTransparent = false // Render in opaque pass but transparent - } - } - }, - BoundingBox = boundingBox, - SelectionSphere = new Sphere { Origin = boundingBox.Center, Radius = Vector3.Distance(boundingBox.Max, boundingBox.Min) / 2.0f } - }; - - // Store all edge lines in mesh data for later use in UploadMeshData - result.EdgeLines = allEdgeLines.ToArray(); - - return result; - } } } diff --git a/src/AcDream.App/Rendering/Wb/TextureAtlasManager.cs b/src/AcDream.App/Rendering/Wb/TextureAtlasManager.cs index 8ce969d1..8751c689 100644 --- a/src/AcDream.App/Rendering/Wb/TextureAtlasManager.cs +++ b/src/AcDream.App/Rendering/Wb/TextureAtlasManager.cs @@ -1,3 +1,4 @@ +using AcDream.Content; using Chorizite.Core.Render; using Chorizite.Core.Render.Enums; using DatReaderWriter.Enums; @@ -94,27 +95,5 @@ namespace AcDream.App.Rendering.Wb { _refCounts.Clear(); _freeSlots.Clear(); } - - public struct TextureKey : IEquatable { - public uint SurfaceId; - public uint PaletteId; - public StipplingType Stippling; - public bool IsSolid; - - public bool Equals(TextureKey other) { - return SurfaceId == other.SurfaceId && - PaletteId == other.PaletteId && - Stippling == other.Stippling && - IsSolid == other.IsSolid; - } - - public override bool Equals(object? obj) { - return obj is TextureKey other && Equals(other); - } - - public override int GetHashCode() { - return HashCode.Combine(SurfaceId, PaletteId, Stippling, IsSolid); - } - } } } diff --git a/src/AcDream.App/Rendering/Wb/WbDrawDispatcher.cs b/src/AcDream.App/Rendering/Wb/WbDrawDispatcher.cs index d2375a3e..8fb2a90c 100644 --- a/src/AcDream.App/Rendering/Wb/WbDrawDispatcher.cs +++ b/src/AcDream.App/Rendering/Wb/WbDrawDispatcher.cs @@ -107,6 +107,11 @@ public sealed unsafe class WbDrawDispatcher : IDisposable // miss-populate / hit-fast-path through the loop. private readonly EntityClassificationCache _cache; + // #188 — per-(entity, Setup-part) translucency ramp state (fading doors / + // secret-passage walls). ClassifyBatches reads this per part to compute + // the instance's opacity multiplier; never mutated here. + private readonly AcDream.Core.Rendering.TranslucencyFadeManager _translucencyFades; + // ACDREAM_DISABLE_TIER1_CACHE=1 A/B diagnostic — forces every static // entity through the slow path. Read once in ctor. private readonly bool _tier1CacheDisabled = @@ -150,6 +155,14 @@ public sealed unsafe class WbDrawDispatcher : IDisposable // Mechanically a clone of _clipSlotData / _clipSlotSsbo. private uint _instIndoorSsbo; private uint[] _indoorData = new uint[256]; + + // #188: per-instance opacity multiplier (binding=7), one float per + // instance, parallel to _instanceSsbo. 1.0 = unmodified (the dat's own + // material/texture alpha, untouched); < 1.0 multiplies the shader's + // sampled alpha for an entity mid-TransparentPartHook fade. Mechanically + // a clone of _indoorData / _instIndoorSsbo, one binding higher. + private uint _instAlphaSsbo; + private float[] _alphaData = new float[256]; // This frame's point-light snapshot, handed in by GameWindow before Draw via // SetSceneLights. Null/empty ⇒ only ambient + sun render (all instance sets -1). private IReadOnlyList? _pointSnapshot; @@ -340,7 +353,8 @@ public sealed unsafe class WbDrawDispatcher : IDisposable WbMeshAdapter meshAdapter, EntitySpawnAdapter entitySpawnAdapter, BindlessSupport bindless, - EntityClassificationCache classificationCache) + EntityClassificationCache classificationCache, + AcDream.Core.Rendering.TranslucencyFadeManager translucencyFades) { ArgumentNullException.ThrowIfNull(gl); ArgumentNullException.ThrowIfNull(shader); @@ -348,6 +362,7 @@ public sealed unsafe class WbDrawDispatcher : IDisposable ArgumentNullException.ThrowIfNull(meshAdapter); ArgumentNullException.ThrowIfNull(entitySpawnAdapter); ArgumentNullException.ThrowIfNull(classificationCache); + ArgumentNullException.ThrowIfNull(translucencyFades); _gl = gl; _shader = shader; @@ -355,6 +370,7 @@ public sealed unsafe class WbDrawDispatcher : IDisposable _meshAdapter = meshAdapter; _entitySpawnAdapter = entitySpawnAdapter; _cache = classificationCache; + _translucencyFades = translucencyFades; _bindless = bindless ?? throw new ArgumentNullException(nameof(bindless)); _instanceSsbo = _gl.GenBuffer(); @@ -364,6 +380,7 @@ public sealed unsafe class WbDrawDispatcher : IDisposable _globalLightsSsbo = _gl.GenBuffer(); // Fix B binding=4 _instLightSetSsbo = _gl.GenBuffer(); // Fix B binding=5 _instIndoorSsbo = _gl.GenBuffer(); // #142 binding=6 + _instAlphaSsbo = _gl.GenBuffer(); // #188 binding=7 } /// @@ -910,6 +927,8 @@ public sealed unsafe class WbDrawDispatcher : IDisposable // A7 Fix D D-3/D-4: object path — plain Lambert points + sun. MUST set // explicitly (shared GL uniform; EnvCellRenderer sets it to 1). _shader.SetInt("uLightingMode", 0); + // #176 stripe-hunt isolation (ACDREAM_LIGHT_DEBUG) — throwaway diagnostic. + _shader.SetInt("uLightDebug", AcDream.Core.Rendering.RenderingDiagnostics.LightDebugMode); // #128 self-heal: fresh re-request dedup per Draw pass. _missRequested.Clear(); @@ -1111,6 +1130,15 @@ public sealed unsafe class WbDrawDispatcher : IDisposable // ACDREAM_DUMP_ENTITY-targeted entities. Before the culled-continue // so a routed-out entity still reports its state. MaybeEmitEntityDump(entity, cacheLb, _currentEntityCulled); + + // #176 seam-draw probe: any entity parented to a target cell reports + // its position + light set (a floor-coincident static/plate would be + // the z-fight's second draw; the player entity is the positive + // control). Before the culled-continue, like the dump above. + if (AcDream.Core.Rendering.RenderingDiagnostics.ProbeSeamDrawEnabled + && entity.ParentCellId is { } seamPc + && AcDream.Core.Rendering.RenderingDiagnostics.SeamDrawTargetCells.Contains(seamPc)) + MaybeEmitSeamEnt(entity); } prevTupleEntityId = entity.Id; @@ -1279,8 +1307,17 @@ public sealed unsafe class WbDrawDispatcher : IDisposable bool drewAny = false; if (renderData.IsSetup && renderData.SetupParts.Count > 0) { - foreach (var (partGfxObjId, partTransform) in renderData.SetupParts) + // #188: setupPartIndex is the SAME index space + // TransparentPartHook.PartIndex addresses — retail's CPartArray + // numbers parts by their ordinal position in the Setup's own + // part list (SetupPartTransforms.Compute is the other verified + // consumer of this exact indexing: one Matrix4x4 per + // Setup.Parts[i]). NOT the outer per-MeshRef loop index — a + // MeshRef is acdream's own decomposition of top-level + // attachments (weapon/shield/etc), a different concept. + for (int setupPartIndex = 0; setupPartIndex < renderData.SetupParts.Count; setupPartIndex++) { + var (partGfxObjId, partTransform) = renderData.SetupParts[setupPartIndex]; var partData = _meshAdapter.TryGetRenderData(partGfxObjId); if (partData is null) { @@ -1321,15 +1358,42 @@ public sealed unsafe class WbDrawDispatcher : IDisposable } var restPose = partTransform * meshRef.PartTransform; - ClassifyBatches(partData, partGfxObjId, model, entity, meshRef, palHash, metaTable, restPose, collector); + + // #188 retail CPhysicsPart::Draw (0x0050d7a0) early-out: once a + // part's translucency hits EXACTLY 1.0 (fully invisible), retail + // sets draw_state|=1 and skips the whole part outright — not a + // blend to nothing. TranslucencyFadeManager.AdvanceAll guarantees + // t=1 commits the bitwise-exact value so this check is safe. + float opacityMultiplier = 1.0f; + if (_translucencyFades.TryGetCurrentValue(entity.Id, (uint)setupPartIndex, out float translucencyValue)) + { + if (translucencyValue >= 1.0f) continue; // skip this part's draw entirely + opacityMultiplier = 1f - translucencyValue; // CMaterial::SetTranslucencySimple 0x005396f0 + } + + ClassifyBatches(partData, partGfxObjId, model, entity, meshRef, palHash, metaTable, restPose, opacityMultiplier, collector); drewAny = true; } } else { - var model = meshRef.PartTransform * entityWorld; - ClassifyBatches(renderData, gfxObjId, model, entity, meshRef, palHash, metaTable, restPose: meshRef.PartTransform, collector: collector); - drewAny = true; + // #188: a bare (non-Setup) GfxObj entity has exactly one part — + // retail's CPartArray for such an object is a single-entry array, + // so TransparentPartHook.PartIndex for it is always 0. + float opacityMultiplier = 1.0f; + bool fullyInvisible = false; + if (_translucencyFades.TryGetCurrentValue(entity.Id, 0u, out float translucencyValue)) + { + if (translucencyValue >= 1.0f) fullyInvisible = true; + else opacityMultiplier = 1f - translucencyValue; + } + + if (!fullyInvisible) + { + var model = meshRef.PartTransform * entityWorld; + ClassifyBatches(renderData, gfxObjId, model, entity, meshRef, palHash, metaTable, restPose: meshRef.PartTransform, opacityMultiplier: opacityMultiplier, collector: collector); + drewAny = true; + } } // Track THIS entity for the next iteration's flush check. Only @@ -1416,6 +1480,11 @@ public sealed unsafe class WbDrawDispatcher : IDisposable if (_indoorData.Length < totalInstances) _indoorData = new uint[totalInstances + 256]; + // #188: per-instance opacity buffer, one float per instance, parallel to + // _clipSlotData / _instanceData. Grown on demand like the others. + if (_alphaData.Length < totalInstances) + _alphaData = new float[totalInstances + 256]; + _opaqueDraws.Clear(); _translucentDraws.Clear(); @@ -1451,6 +1520,9 @@ public sealed unsafe class WbDrawDispatcher : IDisposable // #142: IndoorFlags[] is parallel to Matrices[]; write at the same // cursor so binding=6 instanceIndoor[] tracks binding=0 instances. _indoorData[cursor] = grp.IndoorFlags[i]; + // #188: Opacities[] is parallel to Matrices[]; write at the same + // cursor so binding=7 instanceAlpha[] tracks binding=0 instances. + _alphaData[cursor] = grp.Opacities[i]; cursor++; } @@ -1542,6 +1614,12 @@ public sealed unsafe class WbDrawDispatcher : IDisposable fixed (uint* dp = _indoorData) UploadSsbo(_instIndoorSsbo, 6, dp, totalInstances * sizeof(uint)); + // #188: per-instance opacity buffer (binding=7), one float per instance, + // laid out parallel to _instanceData in Phase 3. Only [0..totalInstances) + // is uploaded — stale tail never read (same guarantee as clip-slot above). + fixed (float* ap = _alphaData) + UploadSsbo(_instAlphaSsbo, 7, ap, totalInstances * sizeof(float)); + // Fix B: global point-light buffer (binding=4) + per-instance light-set // buffer (binding=5). The global buffer is this frame's PointSnapshot; the // per-instance buffer holds 8 int indices into it per instance, laid out @@ -2045,6 +2123,11 @@ public sealed unsafe class WbDrawDispatcher : IDisposable grp.Matrices.Add(model); grp.Slots.Add(_currentEntitySlot); // Phase U.4 — parallel to Matrices AppendCurrentLightSet(grp); // Fix B — 8 ints per instance, parallel to Matrices + // #188: cache-hit entities are always non-animated (the Tier-1 cache + // gates on !isAnimated), and TranslucencyFadeManager only ever holds + // state for entities whose animation hooks fired — so a cached + // instance can never be mid-fade. Always unmodified opacity. + grp.Opacities.Add(1.0f); } /// @@ -2075,6 +2158,44 @@ public sealed unsafe class WbDrawDispatcher : IDisposable /// (AP-43) and docs/research/2026-06-19-lighting-a7-fixD-round2-*. /// /// + // #176 seam-draw probe (ACDREAM_PROBE_SEAMDRAW) — throwaway apparatus. One + // [seam-ent] line per target-cell entity, re-emitted on state change: world + // position (F3 z — entities do NOT get the +0.02 shell lift), cull/slot, + // and the SelectForObject light set resolved to identities (owner-cell + // low16 + intensity). Sig dict is bounded by the handful of entities that + // ever live in the target cells. + private readonly Dictionary _seamEntSigs = new(); + + private void MaybeEmitSeamEnt(WorldEntity entity) + { + var ci = System.Globalization.CultureInfo.InvariantCulture; + var snap = _pointSnapshot; + var sb = new System.Text.StringBuilder(200); + sb.AppendFormat(ci, + "guid=0x{0:X8} cell=0x{1:X8} pos=({2:F2},{3:F2},{4:F3}) culled={5} slot={6} indoor={7} L=[", + entity.ServerGuid, entity.ParentCellId ?? 0u, + entity.Position.X, entity.Position.Y, entity.Position.Z, + _currentEntityCulled ? 1 : 0, _currentEntitySlot, _currentEntityIndoor ? 1 : 0); + bool any = false; + for (int k = 0; k < _currentEntityLightSet.Length; k++) + { + int idx = _currentEntityLightSet[k]; + if (idx < 0) continue; + if (any) sb.Append(','); + if (snap is not null && idx < snap.Count) + sb.AppendFormat(ci, "{0:X4}:I{1:F0}", snap[idx].CellId & 0xFFFFu, snap[idx].Intensity); + else + sb.Append('?').Append(idx); + any = true; + } + sb.Append(']'); + + string sig = sb.ToString(); + if (_seamEntSigs.TryGetValue(entity.Id, out var prev) && prev == sig) return; + _seamEntSigs[entity.Id] = sig; + Console.WriteLine($"[seam-ent] t={Environment.TickCount64} {sig}"); + } + private void ComputeEntityLightSet(WorldEntity entity) { // #142: set the indoor flag first so it's available even when the early-return @@ -2132,6 +2253,7 @@ public sealed unsafe class WbDrawDispatcher : IDisposable ulong palHash, AcSurfaceMetadataTable metaTable, Matrix4x4 restPose, + float opacityMultiplier = 1.0f, List? collector = null) { for (int batchIdx = 0; batchIdx < renderData.Batches.Count; batchIdx++) @@ -2150,6 +2272,13 @@ public sealed unsafe class WbDrawDispatcher : IDisposable : TranslucencyKind.Opaque; } + // #188: a mid-fade instance whose surface is otherwise Opaque/ClipMap + // must route through the alpha-blend pass so mesh_modern.frag's + // (blend-enabled) shader actually composites the reduced alpha — + // the no-blend opaque pass would ignore it. + if (opacityMultiplier < 1.0f && IsOpaque(translucency)) + translucency = TranslucencyKind.AlphaBlend; + ulong texHandle = ResolveTexture(entity, meshRef, batch, palHash); if (texHandle == 0) continue; @@ -2179,6 +2308,7 @@ public sealed unsafe class WbDrawDispatcher : IDisposable grp.Matrices.Add(model); grp.Slots.Add(_currentEntitySlot); // Phase U.4 — parallel to Matrices AppendCurrentLightSet(grp); // Fix B — 8 ints per instance, parallel to Matrices + grp.Opacities.Add(opacityMultiplier); // #188 — parallel to Matrices collector?.Add(new CachedBatch(key, texHandle, restPose)); } } @@ -2261,6 +2391,7 @@ public sealed unsafe class WbDrawDispatcher : IDisposable if (_globalLightsSsbo != 0) _gl.DeleteBuffer(_globalLightsSsbo); // Fix B binding=4 if (_instLightSetSsbo != 0) _gl.DeleteBuffer(_instLightSetSsbo); // Fix B binding=5 if (_instIndoorSsbo != 0) _gl.DeleteBuffer(_instIndoorSsbo); // #142 binding=6 + if (_instAlphaSsbo != 0) _gl.DeleteBuffer(_instAlphaSsbo); // #188 binding=7 if (_gpuQueriesInitialized) { for (int i = 0; i < GpuQueryRingDepth; i++) @@ -2460,5 +2591,12 @@ public sealed unsafe class WbDrawDispatcher : IDisposable // for outdoor objects (gets the sun). Written into _indoorData at the same // cursor as Matrices, so binding=6 instanceIndoor[] tracks binding=0. public readonly List IndoorFlags = new(); + + // #188: per-instance opacity multiplier, parallel to Matrices. + // Opacities[i] is 1.0=unmodified, or <1.0 while a TransparentPartHook + // fade is in flight for the instance whose matrix is Matrices[i]. At + // layout time the dispatcher writes Opacities[i] into _alphaData at + // the same cursor, so the binding=7 instanceAlpha[] tracks binding=0. + public readonly List Opacities = new(); } } diff --git a/src/AcDream.App/Rendering/Wb/WbMeshAdapter.cs b/src/AcDream.App/Rendering/Wb/WbMeshAdapter.cs index 8bbdd6bd..9440ba6c 100644 --- a/src/AcDream.App/Rendering/Wb/WbMeshAdapter.cs +++ b/src/AcDream.App/Rendering/Wb/WbMeshAdapter.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using AcDream.Content; using AcDream.Core.Meshing; using AcDream.Core.Rendering; using DatReaderWriter; diff --git a/src/AcDream.App/Streaming/GpuWorldState.cs b/src/AcDream.App/Streaming/GpuWorldState.cs index 6217c814..2e2c142d 100644 --- a/src/AcDream.App/Streaming/GpuWorldState.cs +++ b/src/AcDream.App/Streaming/GpuWorldState.cs @@ -255,7 +255,43 @@ public sealed class GpuWorldState { if (entity.ServerGuid == 0) return; - // Remove from current landblock (find it by scanning) + uint canonical = (newCanonicalLb & 0xFFFF0000u) | 0xFFFFu; + + // Fast path: already drawn in the correct loaded bucket → nothing to do + // (avoids per-frame list churn for a settled, stationary entity). + if (_loaded.TryGetValue(canonical, out var target)) + { + foreach (var e in target.Entities) + if (ReferenceEquals(e, entity)) return; + } + + // Remove the entity from wherever it currently lives — a loaded bucket + // OR a pending bucket — then re-append to its current landblock. + // + // Scanning _pendingByLandblock is the 2026-07-03 fix for the cold-spawn / + // run-out "invisible player" bug: a persistent (server-spawned) entity + // that spawned into a not-yet-loaded landblock sits in _pendingByLandblock, + // and the old code scanned ONLY _loaded — so it silently no-op'd and left + // the player stranded, hidden, even after its landblock finished loading + // (the AddLandblock pending-drain had already run empty before the churn + // re-parked the player, and the player is excluded from the server-object + // re-hydrate — so RelocateEntity was the ONLY path that could recover it, + // and it couldn't reach a pending entity). Re-appending routes the entity + // to _loaded (drawn) when its landblock is loaded, or back to pending to + // await AddLandblock otherwise. + RemoveEntityFromAllBuckets(entity); + AppendLiveEntity(canonical, entity); + } + + /// + /// Remove (by reference) from whichever + /// or bucket it + /// currently occupies. At most one bucket holds a given entity, so this + /// stops after the first hit. Called by before + /// re-appending, so a stranded pending entity can be promoted. + /// + private void RemoveEntityFromAllBuckets(WorldEntity entity) + { foreach (var kvp in _loaded) { var entities = kvp.Value.Entities; @@ -263,23 +299,21 @@ public sealed class GpuWorldState { if (ReferenceEquals(entities[i], entity)) { - if (kvp.Key == newCanonicalLb) return; // already in the right place - - // Remove from old var newList = new List(entities.Count - 1); for (int j = 0; j < entities.Count; j++) if (j != i) newList.Add(entities[j]); _loaded[kvp.Key] = new LoadedLandblock( - kvp.Value.LandblockId, - kvp.Value.Heightmap, - newList); - - // Add to new (via AppendLiveEntity which handles pending) - AppendLiveEntity(newCanonicalLb, entity); + kvp.Value.LandblockId, kvp.Value.Heightmap, newList); return; } } } + + foreach (var kvp in _pendingByLandblock) + { + if (kvp.Value.Remove(entity)) + return; + } } public void RemoveLandblock(uint landblockId) diff --git a/src/AcDream.Bake/AcDream.Bake.csproj b/src/AcDream.Bake/AcDream.Bake.csproj new file mode 100644 index 00000000..263db624 --- /dev/null +++ b/src/AcDream.Bake/AcDream.Bake.csproj @@ -0,0 +1,25 @@ + + + + Exe + acdream-bake + net10.0 + enable + enable + latest + true + + + + + + + + + + + + + diff --git a/src/AcDream.Bake/BakeRunner.cs b/src/AcDream.Bake/BakeRunner.cs new file mode 100644 index 00000000..9e5676d3 --- /dev/null +++ b/src/AcDream.Bake/BakeRunner.cs @@ -0,0 +1,252 @@ +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Diagnostics; +using System.IO; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using AcDream.Content; +using AcDream.Content.Pak; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; + +namespace AcDream.Bake; + +/// Options for one bake run (parsed from CLI args by Program, or built directly by tests). +public sealed record BakeOptions { + public required string DatDir { get; init; } + public required string OutPath { get; init; } + public HashSet? IdFilter { get; init; } + public HashSet? LandblockFilter { get; init; } + public int Threads { get; init; } = System.Environment.ProcessorCount; +} + +/// +/// The bake pipeline: enumerate ids -> sorted-batch parallel extraction -> +/// deterministic pak write. Public (rather than inline in Program) so the +/// dat-gated byte-reproducibility test can drive the REAL pipeline. +/// +/// Determinism + bounded memory (review finding 1): the full id +/// list is built first and sorted by pak key; work proceeds in fixed-size +/// batches — extraction is parallel WITHIN a batch, then the batch's results +/// are sorted by key and written sequentially before the next batch starts. +/// Batches are contiguous key ranges, so the blob region ends up in global +/// key order regardless of thread scheduling, and memory is bounded by one +/// batch's decoded output instead of the whole game's. Side-staged +/// particle-preload meshes are deduped into a keyed map as each batch +/// drains (first instance wins — extraction output per id is +/// deterministic, so instance choice cannot affect bytes) and written after +/// all batches, sorted by key, skipping keys already written. +/// +public static class BakeRunner { + /// Ids extracted in parallel per batch before the sequential sorted write. Bounds peak memory (~512 decoded ObjectMeshData) while keeping the workers busy. + private const int BatchSize = 512; + + public static int Run(BakeOptions options) { + Console.WriteLine("acdream-bake"); + Console.WriteLine($"dat dir: {options.DatDir}"); + Console.WriteLine($"out: {options.OutPath}"); + Console.WriteLine($"threads: {options.Threads}"); + Console.WriteLine(); + + var sw = Stopwatch.StartNew(); + using var dats = new DatCollection(options.DatDir, DatAccessType.Read); + // The unified AcDream.Content.DatCollectionAdapter (MP1b review + // finding 7): same instance class the client and the equivalence + // suite use — adapter drift between bake and runtime is impossible + // by construction. + using var datReaderWriter = new DatCollectionAdapter(dats); + var extractorLogger = new ConsoleErrorLogger(nameof(MeshExtractor)); + + // Thread-safe side-stage sink for particle-preload meshes MeshExtractor + // emits mid-extraction (MP1a documented contract; extractor is shared + // across the batch workers). + var sideStaged = new ConcurrentQueue(); + var extractor = new MeshExtractor(datReaderWriter, extractorLogger, data => sideStaged.Enqueue(data)); + + // ---- enumeration ----------------------------------------------------- + + var gfxObjIds = dats.GetAllIdsOfType().ToList(); + var setupIds = dats.GetAllIdsOfType().ToList(); + var envCellIds = EnumerateEnvCellIds(dats, options.LandblockFilter); + + if (options.IdFilter is not null) { + gfxObjIds = gfxObjIds.Where(options.IdFilter.Contains).ToList(); + setupIds = setupIds.Where(options.IdFilter.Contains).ToList(); + envCellIds = envCellIds.Where(options.IdFilter.Contains).ToList(); + } + + // Full work list sorted by pak key — the batching below preserves this + // global order on disk (determinism precondition). + var work = new List<(ulong Key, PakAssetType Type, uint FileId)>(gfxObjIds.Count + setupIds.Count + envCellIds.Count); + work.AddRange(gfxObjIds.Select(id => (PakKey.Compose(PakAssetType.GfxObjMesh, id), PakAssetType.GfxObjMesh, id))); + work.AddRange(setupIds.Select(id => (PakKey.Compose(PakAssetType.SetupMesh, id), PakAssetType.SetupMesh, id))); + work.AddRange(envCellIds.Select(id => (PakKey.Compose(PakAssetType.EnvCellMesh, id), PakAssetType.EnvCellMesh, id))); + work.Sort((a, b) => a.Key.CompareTo(b.Key)); + + Console.WriteLine($"enumerated: {gfxObjIds.Count:N0} GfxObj, {setupIds.Count:N0} Setup, {envCellIds.Count:N0} EnvCell " + + $"({work.Count:N0} total)"); + Console.WriteLine(); + + // ---- sorted-batch extraction + streaming write ------------------------- + + var header = new PakHeader { + PortalIteration = (uint)dats.Portal.Iteration!.CurrentIteration, + CellIteration = (uint)dats.Cell.Iteration!.CurrentIteration, + HighResIteration = (uint)dats.HighRes.Iteration!.CurrentIteration, + LanguageIteration = (uint)dats.Local.Iteration!.CurrentIteration, + BakeToolVersion = 1, + }; + + var failures = new ConcurrentBag<(PakAssetType Type, uint FileId, string Reason)>(); + var writtenKeys = new HashSet(); + var sideStagedByKey = new Dictionary(); + long completed = 0; + int writtenCounts0 = 0, writtenCounts1 = 0, writtenCounts2 = 0; // GfxObj, Setup, EnvCell + var lastProgressReport = Stopwatch.StartNew(); + + using (var writer = new PakWriter(options.OutPath, header)) { + for (int batchStart = 0; batchStart < work.Count; batchStart += BatchSize) { + var batch = work.Skip(batchStart).Take(BatchSize).ToList(); + var batchResults = new ConcurrentBag<(ulong Key, PakAssetType Type, ObjectMeshData Data)>(); + + Parallel.ForEach( + batch, + new ParallelOptions { MaxDegreeOfParallelism = options.Threads }, + item => { + var (key, type, fileId) = item; + try { + // EnvCell entries store the cell's synthetic geometry mesh + // (bit 32 set — see MeshExtractor.PrepareMeshData's EnvCell + // branch); the cell's static objects are covered by their + // own GfxObj/Setup entries. + ulong extractorId = type == PakAssetType.EnvCellMesh ? fileId | 0x1_0000_0000UL : fileId; + // isSetup: matches the runtime's own request sites — + // WbMeshAdapter.IncrementRefCount/EnsureLoaded pass + // isSetup: false for every MeshRef id (incl. cell-geometry + // ids); only true Setup extraction passes true. (Review + // finding 10 — keep aligned with PakEquivalenceTests.) + bool isSetup = type == PakAssetType.SetupMesh; + var data = extractor.PrepareMeshData(extractorId, isSetup); + if (data is not null) { + batchResults.Add((key, type, data)); + } + else { + failures.Add((type, fileId, "extractor returned null (no polygons or unresolvable id)")); + } + } + catch (Exception ex) { + // A malformed dat entry skips that id — never fatal to the + // bake, matching the runtime's own per-id behavior. + failures.Add((type, fileId, ex.Message)); + } + + Interlocked.Increment(ref completed); + }); + + // Sequential sorted write: batch results in key order. + foreach (var (key, type, data) in batchResults.OrderBy(r => r.Key)) { + writer.AddBlob(key, data); + writtenKeys.Add(key); + switch (type) { + case PakAssetType.GfxObjMesh: writtenCounts0++; break; + case PakAssetType.SetupMesh: writtenCounts1++; break; + case PakAssetType.EnvCellMesh: writtenCounts2++; break; + } + } + + // Drain side-staged preloads per batch into the dedup map so the + // queue never grows past one batch's emissions (memory bound); + // written after all batches, sorted (see below). + while (sideStaged.TryDequeue(out var staged)) { + uint fileId = (uint)(staged.ObjectId & 0xFFFFFFFFu); + ulong key = PakKey.Compose(PakAssetType.GfxObjMesh, fileId); + if (!sideStagedByKey.ContainsKey(key)) sideStagedByKey[key] = staged; + } + + if (lastProgressReport.Elapsed.TotalSeconds >= 5 || batchStart + BatchSize >= work.Count) { + ReportProgress(completed, work.Count, failures.Count, sw.Elapsed); + lastProgressReport.Restart(); + } + } + + // Side-staged preload meshes not already covered by a primary entry: + // sorted by key for deterministic placement. + int sideStagedWritten = 0, sideStagedDuped = 0; + foreach (var (key, data) in sideStagedByKey.OrderBy(kv => kv.Key)) { + if (writtenKeys.Contains(key)) { sideStagedDuped++; continue; } + writer.AddBlob(key, data); + writtenKeys.Add(key); + sideStagedWritten++; + } + + writer.Finish(); + sw.Stop(); + + var outSize = new FileInfo(options.OutPath).Length; + Console.WriteLine(); + Console.WriteLine("=== bake summary ==="); + Console.WriteLine($" GfxObj baked: {writtenCounts0:N0}"); + Console.WriteLine($" Setup baked: {writtenCounts1:N0}"); + Console.WriteLine($" EnvCell baked: {writtenCounts2:N0}"); + Console.WriteLine($" side-staged baked (particle preload GfxObjs): {sideStagedWritten:N0} ({sideStagedDuped:N0} deduped)"); + Console.WriteLine($" total blobs: {writtenKeys.Count:N0}"); + Console.WriteLine($" failures: {failures.Count:N0}"); + Console.WriteLine($" elapsed: {sw.Elapsed.TotalSeconds:F1} s"); + Console.WriteLine($" output size: {outSize / 1024.0 / 1024.0:F1} MB"); + Console.WriteLine($" output path: {options.OutPath}"); + } + + if (!failures.IsEmpty) { + Console.WriteLine(); + Console.WriteLine($"failures ({failures.Count}):"); + foreach (var (type, fileId, reason) in failures.OrderBy(f => f.FileId).Take(200)) { + Console.WriteLine($" {type,-12} 0x{fileId:X8}: {reason}"); + } + if (failures.Count > 200) Console.WriteLine($" ... and {failures.Count - 200} more"); + } + + return 0; + } + + private static void ReportProgress(long done, int total, int failures, TimeSpan elapsed) { + double rate = elapsed.TotalSeconds > 0 ? done / elapsed.TotalSeconds : 0; + double etaSeconds = rate > 0 ? (total - done) / rate : 0; + Console.WriteLine($"[{elapsed:hh\\:mm\\:ss}] baked {done:N0}/{total:N0}, failures={failures:N0}, " + + $"elapsed={elapsed.TotalSeconds:F0}s, ETA={etaSeconds:F0}s"); + } + + /// + /// Enumerates EnvCell ids by walking the cell dat's LandBlockInfo entries + /// (0xFFFE low 16 bits) and, for each, the NumCells-derived cell id range — + /// GetAllIdsOfType<T>() does not cover cell-dat range-based types + /// (DatReaderWriter's documented limitation; see the low-16-bit bucketing + /// idiom in src/AcDream.Cli/Program.cs's CountCellByLow16, and the + /// firstCellId/NumCells hydration idiom in GameWindow.BuildPhysicsDatBundle + /// / BuildInteriorEntitiesForStreaming). + /// + private static List EnumerateEnvCellIds(DatCollection dats, HashSet? landblockFilter) { + var landblockInfoIds = new List(); + foreach (var file in dats.Cell.Tree) { + if ((file.Id & 0xFFFFu) != 0xFFFEu) continue; + uint landblockId = file.Id & 0xFFFF0000u; + if (landblockFilter is not null && !landblockFilter.Contains(landblockId)) continue; + landblockInfoIds.Add(file.Id); + } + + var envCellIds = new List(); + foreach (var lbInfoId in landblockInfoIds) { + if (!dats.Cell.TryGet(lbInfoId, out var lbInfo) || lbInfo is null) continue; + if (lbInfo.NumCells == 0) continue; + + uint landblockId = lbInfoId & 0xFFFF0000u; + uint firstCellId = landblockId | 0x0100u; + for (uint offset = 0; offset < lbInfo.NumCells; offset++) { + envCellIds.Add(firstCellId + offset); + } + } + return envCellIds; + } +} diff --git a/src/AcDream.Bake/ConsoleErrorLogger.cs b/src/AcDream.Bake/ConsoleErrorLogger.cs new file mode 100644 index 00000000..a8be4302 --- /dev/null +++ b/src/AcDream.Bake/ConsoleErrorLogger.cs @@ -0,0 +1,38 @@ +using System; +using Microsoft.Extensions.Logging; + +namespace AcDream.Bake; + +/// +/// Minimal writing to stderr with a level prefix. +/// MeshExtractor logs failures via ILogger.LogError/LogWarning (dat-read +/// anomalies, malformed entries) — per the project's "logger injection for +/// silent catches" lesson, the bake tool must NOT wire a NullLogger here or +/// every per-id extraction failure goes silent. A tiny hand-rolled logger +/// avoids pulling in the Microsoft.Extensions.Logging.Console package +/// (not already a transitive dependency) for what is a one-line need. +/// +public sealed class ConsoleErrorLogger : ILogger { + private readonly string _categoryName; + + public ConsoleErrorLogger(string categoryName) { + _categoryName = categoryName; + } + + public IDisposable? BeginScope(TState state) where TState : notnull => null; + + public bool IsEnabled(LogLevel logLevel) => logLevel >= LogLevel.Warning; + + public void Log(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func formatter) { + if (!IsEnabled(logLevel)) return; + var message = formatter(state, exception); + Console.Error.WriteLine($"[{logLevel}] {_categoryName}: {message}"); + if (exception is not null) Console.Error.WriteLine(exception); + } +} + +/// Factory producing instances for any category/type. +public sealed class ConsoleErrorLoggerProvider : ILoggerProvider { + public ILogger CreateLogger(string categoryName) => new ConsoleErrorLogger(categoryName); + public void Dispose() { } +} diff --git a/src/AcDream.Bake/Program.cs b/src/AcDream.Bake/Program.cs new file mode 100644 index 00000000..2d7ee8c0 --- /dev/null +++ b/src/AcDream.Bake/Program.cs @@ -0,0 +1,78 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using AcDream.Bake; + +// acdream-bake: offline CLI producing a versioned pak file containing every +// ObjectMeshData the client's decode workers would otherwise produce at +// runtime (GfxObj / Setup / EnvCell mesh+texture payloads). +// +// Thin arg-parsing shell over BakeRunner (the real pipeline lives there so +// the dat-gated byte-reproducibility test can drive it directly). +// +// Plan: docs/superpowers/plans/2026-07-05-mp1b-pak-and-bake.md, Task 5. + +string? datDir = null; +string? outPath = null; +HashSet? idFilter = null; +HashSet? landblockFilter = null; +int threads = Environment.ProcessorCount; + +for (int i = 0; i < args.Length; i++) { + switch (args[i]) { + case "--dat-dir": + datDir = args.ElementAtOrDefault(++i); + break; + case "--out": + outPath = args.ElementAtOrDefault(++i); + break; + case "--ids": + idFilter = ParseHexList(args.ElementAtOrDefault(++i)); + break; + case "--landblocks": + landblockFilter = ParseHexList(args.ElementAtOrDefault(++i)); + break; + case "--threads": + if (int.TryParse(args.ElementAtOrDefault(++i), out var t) && t > 0) threads = t; + break; + default: + Console.Error.WriteLine($"unrecognized argument: {args[i]}"); + return 2; + } +} + +if (string.IsNullOrWhiteSpace(datDir)) { + Console.Error.WriteLine("usage: acdream-bake --dat-dir [--out ] [--ids 0xId,0xId,...] [--landblocks 0xId,...] [--threads ]"); + return 2; +} + +if (!Directory.Exists(datDir)) { + Console.Error.WriteLine($"error: directory not found: {datDir}"); + return 2; +} + +outPath ??= Path.Combine(datDir, "acdream.pak"); + +return BakeRunner.Run(new BakeOptions { + DatDir = datDir, + OutPath = outPath, + IdFilter = idFilter, + LandblockFilter = landblockFilter, + Threads = threads, +}); + +static HashSet ParseHexList(string? raw) { + var result = new HashSet(); + if (string.IsNullOrWhiteSpace(raw)) return result; + foreach (var token in raw.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)) { + var hex = token.StartsWith("0x", StringComparison.OrdinalIgnoreCase) ? token[2..] : token; + if (uint.TryParse(hex, System.Globalization.NumberStyles.HexNumber, null, out var value)) { + result.Add(value); + } + else { + Console.Error.WriteLine($"warning: could not parse id '{token}' — skipped"); + } + } + return result; +} diff --git a/src/AcDream.Content/AcDream.Content.csproj b/src/AcDream.Content/AcDream.Content.csproj new file mode 100644 index 00000000..93c7dbd2 --- /dev/null +++ b/src/AcDream.Content/AcDream.Content.csproj @@ -0,0 +1,29 @@ + + + + net10.0 + enable + enable + latest + true + true + + + + + + + + + + + + + + diff --git a/src/AcDream.App/Rendering/Wb/DatCollectionAdapter.cs b/src/AcDream.Content/DatCollectionAdapter.cs similarity index 66% rename from src/AcDream.App/Rendering/Wb/DatCollectionAdapter.cs rename to src/AcDream.Content/DatCollectionAdapter.cs index 60ed18c7..6c8b3aa5 100644 --- a/src/AcDream.App/Rendering/Wb/DatCollectionAdapter.cs +++ b/src/AcDream.Content/DatCollectionAdapter.cs @@ -7,19 +7,32 @@ using System.Collections.Generic; using System.Collections.ObjectModel; using System.Diagnostics.CodeAnalysis; -namespace AcDream.App.Rendering.Wb; +namespace AcDream.Content; /// -/// Adapts acdream's to WB's interface. +/// THE → adapter, +/// shared by all three consumers: ObjectMeshManager (AcDream.App, via +/// WbMeshAdapter), acdream-bake (AcDream.Bake.BakeRunner), and the pak +/// equivalence suite (AcDream.Content.Tests). MP1b's review found the +/// original App-internal copy had silently forked into three near-identical +/// versions — drift between them is exactly what the live-vs-pak equivalence +/// suite CANNOT detect (both sides would drift together only if they share +/// one implementation), so unification here is load-bearing, not cosmetic. +/// GL-free (DatReaderWriter only), hence Content is the right home +/// (established in MP1a alongside ). /// -/// O-D7 fallback path: taken because ObjectMeshManager has 26 _dats.X call sites (threshold is 20), -/// making a full refactor to DatCollection larger than spec permits in a single task. -/// This adapter lets ObjectMeshManager stay byte-identical to the WB original while -/// routing all DAT I/O through our single DatCollection. The adapter is dropped in T7 -/// when the WorldBuilder project reference is removed entirely. +/// History: O-D7 originally introduced this adapter (App-internal) +/// because ObjectMeshManager had 26 _dats.X call sites, letting it +/// stay byte-identical to the WB original while routing all DAT I/O through +/// the single DatCollection. +/// +/// Iteration properties return the REAL dat iterations (the App copy +/// hardcoded 0 — a stub nothing read; the bake tool stamps iterations into +/// the pak header from DatCollection directly, and any future consumer of +/// these properties should get truth, so the unification intentionally +/// keeps the real values). /// -internal sealed class DatCollectionAdapter : IDatReaderWriter -{ +public sealed class DatCollectionAdapter : IDatReaderWriter { private readonly DatCollection _dats; private readonly DatDatabaseWrapper _portal; private readonly DatDatabaseWrapper _cell; @@ -27,8 +40,7 @@ internal sealed class DatCollectionAdapter : IDatReaderWriter private readonly DatDatabaseWrapper _language; private readonly ReadOnlyDictionary _cellRegions; - public DatCollectionAdapter(DatCollection dats) - { + public DatCollectionAdapter(DatCollection dats) { ArgumentNullException.ThrowIfNull(dats); _dats = dats; _portal = new DatDatabaseWrapper(dats.Portal); @@ -50,18 +62,16 @@ internal sealed class DatCollectionAdapter : IDatReaderWriter public IDatDatabase HighRes => _highRes; public IDatDatabase Language => _language; - // RegionFileMap is used by some WB internals but not by ObjectMeshManager. + // RegionFileMap is used by some WB internals but not by any acdream consumer. public ReadOnlyDictionary RegionFileMap => new ReadOnlyDictionary(new Dictionary()); - // Iteration properties — not used by ObjectMeshManager, so delegate to 0. - public int PortalIteration => 0; - public int CellIteration => 0; - public int HighResIteration => 0; - public int LanguageIteration => 0; + public int PortalIteration => _portal.Iteration; + public int CellIteration => _cell.Iteration; + public int HighResIteration => _highRes.Iteration; + public int LanguageIteration => _language.Iteration; - public bool TryGetFileBytes(uint regionId, uint fileId, ref byte[] bytes, out int bytesRead) - { + public bool TryGetFileBytes(uint regionId, uint fileId, ref byte[] bytes, out int bytesRead) { // Route to cell db (the only region we expose) return _dats.Cell.TryGetFileBytes(fileId, ref bytes, out bytesRead); } @@ -71,15 +81,12 @@ internal sealed class DatCollectionAdapter : IDatReaderWriter /// Mirrors DefaultDatReaderWriter.ResolveId — checks each underlying DatDatabase /// via DatDatabase.TypeFromId (which reads the type range tables). /// - public IEnumerable ResolveId(uint id) - { + public IEnumerable ResolveId(uint id) { var results = new List(); - void CheckDb(DatDatabaseWrapper wrapper) - { + void CheckDb(DatDatabaseWrapper wrapper) { var rawDb = wrapper.RawDatabase; - if (rawDb.Tree.TryGetFile(id, out _)) - { + if (rawDb.Tree.TryGetFile(id, out _)) { var type = rawDb.TypeFromId(id); if (type != DBObjType.Unknown) results.Add(new IDatReaderWriter.IdResolution(wrapper, type)); @@ -101,8 +108,7 @@ internal sealed class DatCollectionAdapter : IDatReaderWriter public bool TrySave(uint regionId, T obj, int iteration = 0) where T : IDBObj => throw new NotSupportedException("DatCollectionAdapter is read-only."); - public void Dispose() - { + public void Dispose() { // The underlying DatCollection is owned by the caller — do not dispose it here. // Individual wrapper objects hold no unmanaged resources. } @@ -110,17 +116,16 @@ internal sealed class DatCollectionAdapter : IDatReaderWriter /// /// Wraps a as . -/// Mirrors WorldBuilder.Shared.Services.DefaultDatDatabase but lives in our namespace -/// so the WorldBuilder project reference can be dropped in T7. +/// Mirrors WorldBuilder.Shared.Services.DefaultDatDatabase (taken into our +/// tree in Phase O; moved here from AcDream.App in the MP1b adapter +/// unification). /// -internal sealed class DatDatabaseWrapper : IDatDatabase -{ +public sealed class DatDatabaseWrapper : IDatDatabase { private readonly DatDatabase _db; private readonly ConcurrentDictionary<(Type, uint), IDBObj> _cache = new(); private readonly object _lock = new(); - public DatDatabaseWrapper(DatDatabase db) - { + public DatDatabaseWrapper(DatDatabase db) { ArgumentNullException.ThrowIfNull(db); _db = db; } @@ -134,18 +139,14 @@ internal sealed class DatDatabaseWrapper : IDatDatabase public IEnumerable GetAllIdsOfType() where T : IDBObj => _db.GetAllIdsOfType(); - public bool TryGet(uint fileId, [MaybeNullWhen(false)] out T value) where T : IDBObj - { - if (_cache.TryGetValue((typeof(T), fileId), out var cached)) - { + public bool TryGet(uint fileId, [MaybeNullWhen(false)] out T value) where T : IDBObj { + if (_cache.TryGetValue((typeof(T), fileId), out var cached)) { value = (T)cached; return true; } - lock (_lock) - { - if (_db.TryGet(fileId, out value)) - { + lock (_lock) { + if (_db.TryGet(fileId, out value)) { _cache.TryAdd((typeof(T), fileId), value); return true; } @@ -154,8 +155,9 @@ internal sealed class DatDatabaseWrapper : IDatDatabase // a miss for an id whose BTree entry EXISTS is always an anomaly — // either Unpack returned false or the lookup flickered transiently. // Legit not-found probes (e.g. Portal→HighRes fallback) stay silent. - if (_db.Tree.TryGetFile(fileId, out _)) - { + // Kept through the MP1b unification — the tripwire now covers the + // bake tool and the equivalence suite too, not just the client. + if (_db.Tree.TryGetFile(fileId, out _)) { Console.WriteLine( $"[dat-miss] {typeof(T).Name} 0x{fileId:X8} entry EXISTS but TryGet failed " + $"(thread={Environment.CurrentManagedThreadId})"); @@ -165,18 +167,14 @@ internal sealed class DatDatabaseWrapper : IDatDatabase return false; } - public bool TryGetFileBytes(uint fileId, [MaybeNullWhen(false)] out byte[] value) - { - lock (_lock) - { + public bool TryGetFileBytes(uint fileId, [MaybeNullWhen(false)] out byte[] value) { + lock (_lock) { return _db.TryGetFileBytes(fileId, out value); } } - public bool TryGetFileBytes(uint fileId, ref byte[] bytes, out int bytesRead) - { - lock (_lock) - { + public bool TryGetFileBytes(uint fileId, ref byte[] bytes, out int bytesRead) { + lock (_lock) { return _db.TryGetFileBytes(fileId, ref bytes, out bytesRead); } } @@ -184,8 +182,7 @@ internal sealed class DatDatabaseWrapper : IDatDatabase public bool TrySave(T obj, int iteration = 0) where T : IDBObj => throw new NotSupportedException("DatDatabaseWrapper is read-only."); - public void Dispose() - { + public void Dispose() { // The underlying DatDatabase is owned by DatCollection — do not dispose here. } } diff --git a/src/AcDream.App/Rendering/Wb/EdgeLineBuilder.cs b/src/AcDream.Content/EdgeLineBuilder.cs similarity index 96% rename from src/AcDream.App/Rendering/Wb/EdgeLineBuilder.cs rename to src/AcDream.Content/EdgeLineBuilder.cs index cec23146..028dd821 100644 --- a/src/AcDream.App/Rendering/Wb/EdgeLineBuilder.cs +++ b/src/AcDream.Content/EdgeLineBuilder.cs @@ -1,7 +1,11 @@ using System.Numerics; using DatReaderWriter.Types; -namespace AcDream.App.Rendering.Wb { +// MP1a (2026-07-05, Task 4): moved to AcDream.Content, namespace only — +// consumed by MeshExtractor.PrepareCellStructEdgeLineData, which must be +// GL-free. + +namespace AcDream.Content { public static class EdgeLineBuilder { public static List BuildEdgeLines(CellStruct cellStruct) { var edgeMap = new Dictionary>(); diff --git a/src/AcDream.App/Rendering/Wb/IDatReaderWriter.cs b/src/AcDream.Content/IDatReaderWriter.cs similarity index 86% rename from src/AcDream.App/Rendering/Wb/IDatReaderWriter.cs rename to src/AcDream.Content/IDatReaderWriter.cs index d6c7d9e3..2ab4afda 100644 --- a/src/AcDream.App/Rendering/Wb/IDatReaderWriter.cs +++ b/src/AcDream.Content/IDatReaderWriter.cs @@ -5,12 +5,17 @@ using System.Collections.ObjectModel; using System.Diagnostics.CodeAnalysis; // Phase O-T7: verbatim copy of WorldBuilder.Shared.Services.IDatReaderWriter + -// IDatDatabase into the AcDream.App.Rendering.Wb namespace so the -// WorldBuilder.Shared project reference can be dropped. -// The only consumer of IDatReaderWriter in acdream is DatCollectionAdapter + -// ObjectMeshManager, both already in this namespace. +// IDatDatabase, taken into our tree so the WorldBuilder.Shared project +// reference could be dropped. +// +// MP1a (2026-07-05, Task 4): moved to AcDream.Content, namespace only — +// MeshExtractor's constructor takes IDatReaderWriter and must be GL-free. +// MP1b review (finding 7): the concrete DatCollection-backed implementation +// (DatCollectionAdapter, this assembly) now lives HERE too — one shared +// adapter for ObjectMeshManager (App), acdream-bake, and the equivalence +// suite, so the three consumers can never drift apart. -namespace AcDream.App.Rendering.Wb; +namespace AcDream.Content; /// /// Interface for the dat reader/writer diff --git a/src/AcDream.Content/MeshExtractor.cs b/src/AcDream.Content/MeshExtractor.cs new file mode 100644 index 00000000..bc728132 --- /dev/null +++ b/src/AcDream.Content/MeshExtractor.cs @@ -0,0 +1,1172 @@ +using AcDream.Core.Rendering.Wb; +using BCnEncoder.Decoder; +using BCnEncoder.ImageSharp; +using BCnEncoder.Shared; +using Chorizite.Core.Lib; +using Chorizite.Core.Render.Enums; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Enums; +using DatReaderWriter.Types; +using Microsoft.Extensions.Logging; +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using System.Threading; +using CullMode = DatReaderWriter.Enums.CullMode; +using BoundingBox = Chorizite.Core.Lib.BoundingBox; + +namespace AcDream.Content; + +/// +/// MP1a (2026-07-05): the GL-free CPU half of the former ObjectMeshManager — +/// dat read → polygon walk → vertex/index build → inline texture decode → +/// . Extracted VERBATIM so the MP1b bake tool +/// and the live client run the SAME extraction code (byte-identical output +/// is the pak conformance foundation). ObjectMeshManager (App) retains the +/// queue/worker lifecycle and all GL upload; it delegates here. +/// Spec: docs/superpowers/specs/2026-07-05-modern-pipeline-design.md §6.1. +/// +public sealed class MeshExtractor { + private readonly IDatReaderWriter _dats; + private readonly ILogger _logger; + + // Cache for decoded textures to avoid redundant BCn decoding + private readonly ConcurrentQueue _decodedTextureLru = new(); + private readonly ConcurrentDictionary _decodedTextureCache = new(); + private const int MaxDecodedTextures = 128; + private readonly ThreadLocal _bcDecoder = new(() => new BcDecoder()); + + /// + /// MP1a mechanical seam: receives particle-preload meshes staged + /// mid-extraction (see ). The App + /// wires this to its staged-upload queue, restoring the original + /// immediate-enqueue semantics — entries must survive a subsequent throw + /// in the same Prepare* call (retail's code enqueued directly onto + /// ObjectMeshManager's _stagedMeshData mid-Prepare, so preloads + /// staged before a malformed-dat texture-decode throw were already safe). + /// The MP1b bake tool passes its own collector. The sink must be + /// thread-safe: one MeshExtractor is shared by up to MaxParallelLoads (4) + /// decode workers. + /// The constructor argument is REQUIRED (no default): a bake tool that + /// forgot the sink would silently lose particle-preload meshes; requiring + /// the argument forces the decision. The type stays nullable so a caller + /// can consciously pass null when preloads are irrelevant. + /// + private readonly Action? _sideStagedSink; + + public MeshExtractor(IDatReaderWriter dats, ILogger logger, Action? sideStagedSink) { + _dats = dats; + _logger = logger; + _sideStagedSink = sideStagedSink; + } + + /// + /// Phase 1 (Background Thread): Prepare CPU-side mesh data from DAT. + /// This loads vertices, indices, and texture data but creates NO GPU resources. + /// Thread-safe: only reads from DAT files. + /// + public ObjectMeshData? PrepareMeshData(ulong id, bool isSetup, CancellationToken ct = default) { + try { + // Use the low 32 bits as the DAT file ID + var datId = (uint)(id & 0xFFFFFFFFu); + var resolutions = _dats.ResolveId(datId).ToList(); + var selectedResolution = resolutions.OrderByDescending(r => r.Database == _dats.Portal).FirstOrDefault(); + if (selectedResolution == null) return null; + + var type = selectedResolution.Type; + var db = selectedResolution.Database; + + if (type == DBObjType.Setup) { + if (!db.TryGet(datId, out var setup)) return null; + return PrepareSetupMeshData(id, setup, ct); + } + else if (type == DBObjType.GfxObj) { + if (!db.TryGet(datId, out var gfxObj)) return null; + return PrepareGfxObjMeshData(id, gfxObj, Vector3.One, ct); + } + else if (type == DBObjType.EnvCell) { + if (!db.TryGet(datId, out var envCell)) return null; + + // If bit 32 is set, this is a request for the cell's synthetic geometry only + if ((id & 0x1_0000_0000UL) != 0) { + uint envId = 0x0D000000u | envCell.EnvironmentId; + if (_dats.Portal.TryGet(envId, out var environment)) { + if (environment.Cells.TryGetValue(envCell.CellStructure, out var cellStruct)) { + return PrepareCellStructMeshData(id, cellStruct, envCell.Surfaces, Matrix4x4.Identity, ct); + } + } + return null; + } + + return PrepareEnvCellMeshData(id, envCell, ct); + } + else if (type == DBObjType.Environment) { + if (!db.TryGet(datId, out var environment)) return null; + + // For Environment objects, create wireframe-only edge geometry + if (environment.Cells.Count > 0) { + var result = PrepareCellStructEdgeLineData(id, environment.Cells, Matrix4x4.Identity, ct); + return result; + } + return null; + } + return null; + } + catch (OperationCanceledException) { + // Ignore + return null; + } + catch (Exception ex) { + _logger.LogError(ex, "Error preparing mesh data for 0x{Id:X16}", id); + return null; + } + } + + private ObjectMeshData? PrepareSetupMeshData(ulong id, Setup setup, CancellationToken ct) { + var parts = new List<(ulong GfxObjId, Matrix4x4 Transform)>(); + var min = new Vector3(float.MaxValue); + var max = new Vector3(float.MinValue); + bool hasBounds = false; + + CollectParts((uint)(id & 0xFFFFFFFFu), Matrix4x4.Identity, parts, ref min, ref max, ref hasBounds, ct); + + var emitters = new List(); + var processedScripts = new HashSet(); + if (setup.DefaultScript.DataId != 0) { + if (processedScripts.Add(setup.DefaultScript.DataId)) { + CollectEmittersFromScript(setup.DefaultScript.DataId, emitters, ct); + } + } + + return new ObjectMeshData { + ObjectId = id, + IsSetup = true, + SetupParts = parts, + ParticleEmitters = emitters, + BoundingBox = hasBounds ? new BoundingBox(min, max) : default, + SelectionSphere = setup.SelectionSphere + }; + } + + private void CollectEmittersFromScript(uint scriptId, List emitters, CancellationToken ct) { + if (_dats.Portal.TryGet(scriptId, out var script)) { + foreach (var hook in script.ScriptData) { + if (hook.Hook.HookType == AnimationHookType.CreateParticle && hook.Hook is CreateParticleHook particleHook) { + if (_dats.Portal.TryGet(particleHook.EmitterInfoId.DataId, out var emitter)) { + emitters.Add(new StagedEmitter { + Emitter = emitter, + PartIndex = particleHook.PartIndex, + Offset = Matrix4x4.CreateFromQuaternion(particleHook.Offset.Orientation) * Matrix4x4.CreateTranslation(particleHook.Offset.Origin) + }); + + // Pre-load and stage the particle's GfxObjs + if (emitter.HwGfxObjId.DataId != 0) { + var meshData = PrepareMeshData(emitter.HwGfxObjId.DataId, false, ct); + if (meshData != null) { + _sideStagedSink?.Invoke(meshData); + } + } + if (emitter.GfxObjId.DataId != 0 && emitter.GfxObjId.DataId != emitter.HwGfxObjId.DataId) { + var meshData = PrepareMeshData(emitter.GfxObjId.DataId, false, ct); + if (meshData != null) { + _sideStagedSink?.Invoke(meshData); + } + } + } + } + } + } + } + + public void CollectParts(uint id, Matrix4x4 currentTransform, List<(ulong GfxObjId, Matrix4x4 Transform)> parts, ref Vector3 min, ref Vector3 max, ref bool hasBounds, CancellationToken ct, int depth = 0) { + if (depth > 50) { + _logger.LogWarning("Max recursion depth reached while collecting parts for 0x{Id:X8}. Possible circular dependency.", id); + return; + } + ct.ThrowIfCancellationRequested(); + + var resolutions = _dats.ResolveId(id).ToList(); + var selectedResolution = resolutions.OrderByDescending(r => r.Database == _dats.Portal).FirstOrDefault(); + if (selectedResolution == null) return; + + var type = selectedResolution.Type; + var db = selectedResolution.Database; + + if (type == DBObjType.Setup) { + if (!db.TryGet(id, out var setup)) return; + + // Use Resting placement first, then default + if (!setup.PlacementFrames.TryGetValue(Placement.Resting, out var placementFrame)) { + if (!setup.PlacementFrames.TryGetValue(Placement.Default, out placementFrame)) { + placementFrame = setup.PlacementFrames.Values.FirstOrDefault(); + } + } + if (placementFrame == null) return; + + for (int i = 0; i < setup.Parts.Count; i++) { + var partId = setup.Parts[i]; + var transform = Matrix4x4.Identity; + + if (setup.Flags.HasFlag(SetupFlags.HasDefaultScale) && setup.DefaultScale.Count > i) { + transform *= Matrix4x4.CreateScale(setup.DefaultScale[i]); + } + + if (placementFrame.Frames != null && i < placementFrame.Frames.Count) { + var orientation = new System.Numerics.Quaternion( + (float)placementFrame.Frames[i].Orientation.X, + (float)placementFrame.Frames[i].Orientation.Y, + (float)placementFrame.Frames[i].Orientation.Z, + (float)placementFrame.Frames[i].Orientation.W + ); + transform *= Matrix4x4.CreateFromQuaternion(orientation) + * Matrix4x4.CreateTranslation(placementFrame.Frames[i].Origin); + } + + CollectParts(partId, transform * currentTransform, parts, ref min, ref max, ref hasBounds, ct, depth + 1); + } + } + else if (type == DBObjType.EnvCell) { + if (!db.TryGet(id, out var envCell)) return; + + // Calculate the inverse transform of the cell to localize its contents + var cellOrientation = new System.Numerics.Quaternion( + (float)envCell.Position.Orientation.X, + (float)envCell.Position.Orientation.Y, + (float)envCell.Position.Orientation.Z, + (float)envCell.Position.Orientation.W + ); + var cellTransform = Matrix4x4.CreateFromQuaternion(cellOrientation) * + Matrix4x4.CreateTranslation(envCell.Position.Origin); + if (!Matrix4x4.Invert(cellTransform, out var invertCellTransform)) { + invertCellTransform = Matrix4x4.Identity; + } + + // Include cell geometry + uint envId = 0x0D000000u | envCell.EnvironmentId; + if (_dats.Portal.TryGet(envId, out var environment)) { + if (environment.Cells.TryGetValue(envCell.CellStructure, out var cellStruct)) { + foreach (var vert in cellStruct.VertexArray.Vertices.Values) { + var transformed = Vector3.Transform(vert.Origin, currentTransform); + min = Vector3.Min(min, transformed); + max = Vector3.Max(max, transformed); + } + hasBounds = true; + + // Add synthetic geometry ID to parts list + parts.Add(((ulong)id | 0x1_0000_0000UL, currentTransform)); + } + } + + foreach (var stab in envCell.StaticObjects) { + var orientation = new System.Numerics.Quaternion( + (float)stab.Frame.Orientation.X, + (float)stab.Frame.Orientation.Y, + (float)stab.Frame.Orientation.Z, + (float)stab.Frame.Orientation.W + ); + var transform = Matrix4x4.CreateFromQuaternion(orientation) + * Matrix4x4.CreateTranslation(stab.Frame.Origin); + // Localize static object transform relative to the cell + var localizedTransform = transform * invertCellTransform; + + CollectParts(stab.Id, localizedTransform * currentTransform, parts, ref min, ref max, ref hasBounds, ct, depth + 1); + } + } + else if (type == DBObjType.GfxObj) { + parts.Add((id, currentTransform)); + + if (db.TryGet(id, out var partGfx)) { + var (partMin, partMax) = ComputeBounds(partGfx, Vector3.One); + var corners = new Vector3[8]; + corners[0] = new Vector3(partMin.X, partMin.Y, partMin.Z); + corners[1] = new Vector3(partMin.X, partMin.Y, partMax.Z); + corners[2] = new Vector3(partMin.X, partMax.Y, partMin.Z); + corners[3] = new Vector3(partMin.X, partMax.Y, partMax.Z); + corners[4] = new Vector3(partMax.X, partMin.Y, partMin.Z); + corners[5] = new Vector3(partMax.X, partMin.Y, partMax.Z); + corners[6] = new Vector3(partMax.X, partMax.Y, partMin.Z); + corners[7] = new Vector3(partMax.X, partMax.Y, partMax.Z); + + foreach (var corner in corners) { + var transformed = Vector3.Transform(corner, currentTransform); + min = Vector3.Min(min, transformed); + max = Vector3.Max(max, transformed); + } + hasBounds = true; + } + } + } + + private ObjectMeshData? PrepareGfxObjMeshData(ulong id, GfxObj gfxObj, Vector3 scale, CancellationToken ct) { + var vertices = new List(); + var UVLookup = new Dictionary<(ushort vertId, ushort uvIdx, bool isNeg), ushort>(); + var batchesByFormat = new Dictionary<(int Width, int Height, TextureFormat Format), List>(); + + var (min, max) = ComputeBounds(gfxObj, scale); + var boundingBox = new BoundingBox(min, max); + + // #113 (2026-06-11): retail draws a GfxObj by TRAVERSING its drawing + // BSP — a polygon present in the Polygons dictionary but referenced by + // no DrawingBSP node is never rendered (physics/no-draw geometry). + // The Holtburg meeting hall (0x010014C3) keeps its walkable exterior + // stair-ramp as dictionary polys {0,1}: in the PhysicsBSP (NPCs walk + // it) but absent from every DrawingBSP node — retail shows a plain + // wall; iterating the dictionary draws the "phantom staircase" + // (invisible-but-walkable in retail, visible in acdream). The hill + // cottage (0x01000827) carries 8 such orphans. + // + // ⚠️ FILTER NOT APPLIED (e46d3d9 un-applied same day): naively + // filtering to CollectDrawingBspPolygonIds(gfxObj) made DOORS + // disappear across Holtburg (user gate 2026-06-11) — the naive + // PosNode/NegNode walk evidently misses polys some models reference + // another way (portal-type nodes? leaf indexing? DatReaderWriter + // parse gap?). Diagnose with the histogram fact in + // Issue113PhantomStairsDumpTests on a door GfxObj BEFORE re-landing. + // The full retail draw is BSP-TRAVERSAL ORDER drawing, not a + // dictionary iteration with a filter — see the holistic port handoff + // docs/research/2026-06-11-building-render-holistic-port-handoff.md. + foreach (var polyEntry in gfxObj.Polygons) { + ct.ThrowIfCancellationRequested(); + var poly = polyEntry.Value; + if (poly.VertexIds.Count < 3) continue; + + // Handle Positive Surface + if (!poly.Stippling.HasFlag(StipplingType.NoPos)) { + AddSurfaceToBatch(poly, poly.PosSurface, false); + } + + // Handle Negative Surface + // Some objects use Clockwise CullMode to indicate negative surface data is present + bool hasNeg = poly.Stippling.HasFlag(StipplingType.Negative) || + poly.Stippling.HasFlag(StipplingType.Both) || + (!poly.Stippling.HasFlag(StipplingType.NoNeg) && poly.SidesType == CullMode.Clockwise); + + if (hasNeg) { + AddSurfaceToBatch(poly, poly.NegSurface, true); + } + + void AddSurfaceToBatch(Polygon poly, short surfaceIdx, bool isNeg) { + if (surfaceIdx < 0 || surfaceIdx >= gfxObj.Surfaces.Count) return; + + var surfaceId = gfxObj.Surfaces[surfaceIdx]; + if (!_dats.Portal.TryGet(surfaceId, out var surface)) { + // TEMP diagnostic (dat-race investigation 2026-06-09, strip with fix) + Console.WriteLine($"[tex-skip] gfxobj Surface 0x{surfaceId:X8} miss -> poly batch dropped (obj 0x{gfxObj.Id:X8})"); + return; + } + + int texWidth, texHeight; + byte[] textureData; + TextureFormat textureFormat; + UploadPixelFormat? uploadPixelFormat = null; + UploadPixelType? uploadPixelType = null; + bool isSolid = poly.Stippling.HasFlag(StipplingType.NoPos) || surface.Type.HasFlag(SurfaceType.Base1Solid); + bool isClipMap = surface.Type.HasFlag(SurfaceType.Base1ClipMap); + uint paletteId = 0; + bool isDxt3or5 = false; + DatReaderWriter.Enums.PixelFormat? sourceFormat = null; + var isAdditive = false; + var isTransparent = false; + + if (isSolid) { + texWidth = texHeight = 32; + textureData = TextureHelpers.CreateSolidColorTexture(surface.ColorValue, texWidth, texHeight); + textureFormat = TextureFormat.RGBA8; + uploadPixelFormat = UploadPixelFormat.Rgba; + } + else if (_dats.Portal.TryGet(surface.OrigTextureId, out var surfaceTexture)) { + var renderSurfaceId = surfaceTexture.Textures.First(); + if (!_dats.Portal.TryGet(renderSurfaceId, out var renderSurface)) { + // check highres + if (!_dats.HighRes.TryGet(renderSurfaceId, out var hrRenderSurface)) { + throw new Exception($"Unable to load RenderSurface: 0x{renderSurfaceId:X8}"); + } + + renderSurface = hrRenderSurface; + } + + texWidth = renderSurface.Width; + texHeight = renderSurface.Height; + paletteId = renderSurface.DefaultPaletteId; + sourceFormat = renderSurface.Format; + + if (TextureHelpers.IsCompressedFormat(renderSurface.Format)) { + isDxt3or5 = renderSurface.Format == DatReaderWriter.Enums.PixelFormat.PFID_DXT3 || renderSurface.Format == DatReaderWriter.Enums.PixelFormat.PFID_DXT5; + textureFormat = TextureFormat.RGBA8; + uploadPixelFormat = UploadPixelFormat.Rgba; + + if (_decodedTextureCache.TryGetValue(renderSurfaceId, out textureData!)) { + // use cached data + } + else { + textureData = new byte[texWidth * texHeight * 4]; + + CompressionFormat compressionFormat = renderSurface.Format switch { + DatReaderWriter.Enums.PixelFormat.PFID_DXT1 => CompressionFormat.Bc1, + DatReaderWriter.Enums.PixelFormat.PFID_DXT3 => CompressionFormat.Bc2, + DatReaderWriter.Enums.PixelFormat.PFID_DXT5 => CompressionFormat.Bc3, + _ => throw new NotSupportedException($"Unsupported compressed format: {renderSurface.Format}") + }; + + using (var image = _bcDecoder.Value!.DecodeRawToImageRgba32(renderSurface.SourceData, texWidth, texHeight, compressionFormat)) { + image.CopyPixelDataTo(textureData); + } + _decodedTextureCache.TryAdd(renderSurfaceId, textureData); + } + + if (isClipMap && textureData != null) { + // If we got this from the cache, we need to clone it so we don't scale the cached raw data + if (_decodedTextureCache.ContainsKey(renderSurfaceId)) { + var clonedData = new byte[textureData.Length]; + System.Buffer.BlockCopy(textureData, 0, clonedData, 0, textureData.Length); + textureData = clonedData; + } + + for (int i = 0; i < textureData.Length; i += 4) { + if (textureData[i] == 0 && textureData[i + 1] == 0 && textureData[i + 2] == 0) { + textureData[i + 3] = 0; + } + } + } + } + else { + textureFormat = TextureFormat.RGBA8; + textureData = renderSurface.SourceData; + switch (renderSurface.Format) { + case DatReaderWriter.Enums.PixelFormat.PFID_A8R8G8B8: + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillA8R8G8B8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_R8G8B8: + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillR8G8B8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_INDEX16: + if (!_dats.Portal.TryGet(renderSurface.DefaultPaletteId, out var paletteData)) + throw new Exception($"Unable to load Palette: 0x{renderSurface.DefaultPaletteId:X8}"); + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillIndex16(renderSurface.SourceData, paletteData, textureData.AsSpan(), texWidth, texHeight, isClipMap); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_P8: + if (!_dats.Portal.TryGet(renderSurface.DefaultPaletteId, out var p8PaletteData)) + throw new Exception($"Unable to load Palette: 0x{renderSurface.DefaultPaletteId:X8}"); + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillP8(renderSurface.SourceData, p8PaletteData, textureData.AsSpan(), texWidth, texHeight, isClipMap); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_R5G6B5: + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillR5G6B5(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_A4R4G4B4: + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillA4R4G4B4(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_A8: + case DatReaderWriter.Enums.PixelFormat.PFID_CUSTOM_LSCAPE_ALPHA: + textureData = new byte[texWidth * texHeight * 4]; + if (surface.Type.HasFlag(SurfaceType.Additive)) { + TextureHelpers.FillA8Additive(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + } + else { + TextureHelpers.FillA8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + } + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + default: + throw new NotSupportedException($"Unsupported surface format: {renderSurface.Format}"); + } + } + + if (surface.Translucency > 0.0f && textureData != null) { + // If we got this from the cache, we need to clone it so we don't scale the cached raw data + if (sourceFormat.HasValue && TextureHelpers.IsCompressedFormat(sourceFormat.Value) && _decodedTextureCache.ContainsKey(renderSurfaceId)) { + var clonedData = new byte[textureData.Length]; + System.Buffer.BlockCopy(textureData, 0, clonedData, 0, textureData.Length); + textureData = clonedData; + } + + float alphaScale = 1.0f - surface.Translucency; + for (int i = 3; i < textureData.Length; i += 4) { + textureData[i] = (byte)(textureData[i] * alphaScale); + } + } + + isAdditive = !isSolid && surface.Type.HasFlag(SurfaceType.Additive); + isTransparent = isSolid ? surface.ColorValue.Alpha < 255 : + (surface.Type.HasFlag(SurfaceType.Translucent) || + surface.Type.HasFlag(SurfaceType.Base1ClipMap) || + ((uint)surface.Type & 0x100) != 0 || // Alpha + ((uint)surface.Type & 0x200) != 0 || // InvAlpha + isAdditive || + (surface.Translucency > 0.0f && surface.Translucency < 1.0f) || + textureFormat == TextureFormat.A8 || + textureFormat == TextureFormat.Rgba32f || + isDxt3or5 || + (sourceFormat != null && (sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_A8R8G8B8 || + sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_A4R4G4B4 || + sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_DXT3 || + sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_DXT5))); + } + else { + // TEMP diagnostic (dat-race investigation 2026-06-09, strip with fix) + Console.WriteLine($"[tex-skip] gfxobj SurfaceTexture 0x{surface.OrigTextureId:X8} miss -> poly batch dropped (surface 0x{surfaceId:X8})"); + return; + } + + var format = (texWidth, texHeight, textureFormat); + var key = new TextureKey { + SurfaceId = surfaceId, + PaletteId = paletteId, + Stippling = poly.Stippling, + IsSolid = isSolid + }; + + if (!batchesByFormat.TryGetValue(format, out var batches)) { + batches = new List(); + batchesByFormat[format] = batches; + } + + var batch = batches.FirstOrDefault(b => b.Key.Equals(key) && b.CullMode == poly.SidesType); + if (batch == null) { + batch = new TextureBatchData { + Key = key, + CullMode = poly.SidesType, + TextureData = textureData!, + UploadPixelFormat = uploadPixelFormat, + UploadPixelType = uploadPixelType, + IsTransparent = isTransparent, + IsAdditive = isAdditive + }; + batches.Add(batch); + } + + bool batchHasWrappingUVs = batch.HasWrappingUVs; + BuildPolygonIndices(poly, gfxObj, scale, UVLookup, vertices, batch.Indices, isNeg, ref batchHasWrappingUVs); + batch.HasWrappingUVs = batchHasWrappingUVs; + } + } + + return new ObjectMeshData { + ObjectId = id, + IsSetup = false, + Vertices = vertices.ToArray(), + TextureBatches = batchesByFormat, + BoundingBox = boundingBox, + SortCenter = gfxObj?.SortCenter ?? Vector3.Zero, + DIDDegrade = gfxObj != null && gfxObj.Flags.HasFlag(GfxObjFlags.HasDIDDegrade) ? gfxObj.DIDDegrade : 0, + SelectionSphere = new Sphere { Origin = boundingBox.Center, Radius = Vector3.Distance(boundingBox.Max, boundingBox.Min) / 2.0f } + }; + } + + private ObjectMeshData? PrepareEnvCellMeshData(ulong id, EnvCell envCell, CancellationToken ct) { + var parts = new List<(ulong GfxObjId, Matrix4x4 Transform)>(); + var min = new Vector3(float.MaxValue); + var max = new Vector3(float.MinValue); + bool hasBounds = false; + + // Calculate the inverse transform of the cell to localize its contents + var cellOrientation = new System.Numerics.Quaternion( + (float)envCell.Position.Orientation.X, + (float)envCell.Position.Orientation.Y, + (float)envCell.Position.Orientation.Z, + (float)envCell.Position.Orientation.W + ); + var cellTransform = Matrix4x4.CreateFromQuaternion(cellOrientation) * + Matrix4x4.CreateTranslation(envCell.Position.Origin); + if (!Matrix4x4.Invert(cellTransform, out var invertCellTransform)) { + invertCellTransform = Matrix4x4.Identity; + } + + // Add static objects + var emitters = new List(); + foreach (var stab in envCell.StaticObjects) { + var orientation = new System.Numerics.Quaternion( + (float)stab.Frame.Orientation.X, + (float)stab.Frame.Orientation.Y, + (float)stab.Frame.Orientation.Z, + (float)stab.Frame.Orientation.W + ); + var transform = Matrix4x4.CreateFromQuaternion(orientation) + * Matrix4x4.CreateTranslation(stab.Frame.Origin); + + // Localize static object transform relative to the cell + var localizedTransform = transform * invertCellTransform; + + CollectParts(stab.Id, localizedTransform, parts, ref min, ref max, ref hasBounds, ct); + + // For EnvCell static objects, we need to manually collect emitters if they are Setups. + // Bugfix 2026-05-19 (acdream): pre-check the Setup-prefix (0x02xxxxxx) before calling + // TryGet. Without this, calling TryGet on a GfxObj-prefixed id + // (0x01xxxxxx) throws ArgumentOutOfRangeException as DatReaderWriter tries to parse + // GfxObj bytes as a Setup record. The exception bubbles up through PrepareMeshData's + // outer catch and the entire cell fails to upload — manifesting as missing floors + // in any building whose StaticObjects include a GfxObj-typed stab (very common). + // Confirmed via acdream's Phase 2 indoor-cell-rendering diagnostic probes; see + // docs/research/2026-05-19-indoor-cell-rendering-cause.md in the acdream repo. + if ((stab.Id & 0xFF000000u) == 0x02000000u + && _dats.Portal.TryGet(stab.Id, out var stabSetup)) { + var stabEmitters = new List(); + var processedScripts = new HashSet(); + if (stabSetup.DefaultScript.DataId != 0) { + if (processedScripts.Add(stabSetup.DefaultScript.DataId)) { + CollectEmittersFromScript(stabSetup.DefaultScript.DataId, stabEmitters, ct); + } + } + + foreach (var emitter in stabEmitters) { + emitters.Add(new StagedEmitter { + Emitter = emitter.Emitter, + PartIndex = emitter.PartIndex, + Offset = emitter.Offset * localizedTransform + }); + } + } + } + + // Load environment and cell structure geometry + uint envId = 0x0D000000u | envCell.EnvironmentId; + ObjectMeshData? cellGeometry = null; + if (_dats.Portal.TryGet(envId, out var environment)) { + if (environment.Cells.TryGetValue(envCell.CellStructure, out var cellStruct)) { + var cellGeomId = id | 0x1_0000_0000UL; + cellGeometry = PrepareCellStructMeshData(cellGeomId, cellStruct, envCell.Surfaces, Matrix4x4.Identity, ct); + if (cellGeometry != null) { + parts.Add((cellGeomId, Matrix4x4.Identity)); + min = Vector3.Min(min, cellGeometry.BoundingBox.Min); + max = Vector3.Max(max, cellGeometry.BoundingBox.Max); + hasBounds = true; + } + } + } + + return new ObjectMeshData { + ObjectId = id, + IsSetup = true, + SetupParts = parts, + ParticleEmitters = emitters, + EnvCellGeometry = cellGeometry, + BoundingBox = hasBounds ? new BoundingBox(min, max) : default, + SelectionSphere = new Sphere { Origin = hasBounds ? (min + max) / 2f : Vector3.Zero, Radius = hasBounds ? Vector3.Distance(max, min) / 2.0f : 0f } + }; + } + + public ObjectMeshData? PrepareCellStructMeshData(ulong id, CellStruct cellStruct, List surfaceOverrides, Matrix4x4 transform, CancellationToken ct) { + var vertices = new List(); + var UVLookup = new Dictionary<(ushort vertId, ushort uvIdx, bool isNeg), ushort>(); + var batchesByFormat = new Dictionary<(int Width, int Height, TextureFormat Format), List>(); + + var min = new Vector3(float.MaxValue); + var max = new Vector3(float.MinValue); + foreach (var vert in cellStruct.VertexArray.Vertices.Values) { + var localizedPos = Vector3.Transform(vert.Origin, transform); + min = Vector3.Min(min, localizedPos); + max = Vector3.Max(max, localizedPos); + } + var boundingBox = new BoundingBox(min, max); + + foreach (var poly in cellStruct.Polygons.Values) { + ct.ThrowIfCancellationRequested(); + if (poly.VertexIds.Count < 3) continue; + + // Retail D3DPolyRender::ConstructMesh (0x0059dfa0) treats this + // DatReaderWriter "CullMode" as CPolygon::sides_type, not as a + // GL cull enum: 0 = pos, 1 = pos twice with reversed winding, + // 2 = pos + neg surface. The DAT-side NoPos/NoNeg flags still + // suppress hidden portal/cap faces before they reach our mesh. + bool hasPos = !poly.Stippling.HasFlag(StipplingType.NoPos); + bool hasNeg = !poly.Stippling.HasFlag(StipplingType.NoNeg); + + if (hasPos) + AddSurfaceToBatch(poly, poly.PosSurface, useNegUv: false, invertNormal: false, reverseWinding: false); + if (hasPos && poly.SidesType == CullMode.None) { + AddSurfaceToBatch(poly, poly.PosSurface, useNegUv: false, invertNormal: true, reverseWinding: true); + } + else if (hasNeg && poly.SidesType == CullMode.Clockwise) { + AddSurfaceToBatch(poly, poly.NegSurface, useNegUv: true, invertNormal: true, reverseWinding: false); + } + + void AddSurfaceToBatch(Polygon poly, short surfaceIdx, bool useNegUv, bool invertNormal, bool reverseWinding) { + if (surfaceIdx < 0) return; + + uint surfaceId; + if (surfaceIdx < surfaceOverrides.Count) { + surfaceId = 0x08000000u | surfaceOverrides[surfaceIdx]; + } + else { + _logger.LogWarning($"Failed to find surface override for index {surfaceIdx} in CellStruct 0x{cellStruct:X4}"); + return; + } + + if (!_dats.Portal.TryGet(surfaceId, out var surface)) { + // TEMP diagnostic (dat-race investigation 2026-06-09, strip with fix) + Console.WriteLine($"[tex-skip] cellstruct Surface 0x{surfaceId:X8} miss -> WALL poly batch dropped (cellstruct 0x{cellStruct:X4})"); + return; + } + + int texWidth, texHeight; + byte[] textureData; + TextureFormat textureFormat; + UploadPixelFormat? uploadPixelFormat = null; + UploadPixelType? uploadPixelType = null; + bool isSolid = poly.Stippling.HasFlag(StipplingType.NoPos) || surface.Type.HasFlag(SurfaceType.Base1Solid); + bool isClipMap = surface.Type.HasFlag(SurfaceType.Base1ClipMap); + uint paletteId = 0; + bool isDxt3or5 = false; + DatReaderWriter.Enums.PixelFormat? sourceFormat = null; + var isAdditive = false; + var isTransparent = false; + + if (isSolid) { + texWidth = texHeight = 32; + textureData = TextureHelpers.CreateSolidColorTexture(surface.ColorValue, texWidth, texHeight); + textureFormat = TextureFormat.RGBA8; + uploadPixelFormat = UploadPixelFormat.Rgba; + } + else if (_dats.Portal.TryGet(surface.OrigTextureId, out var surfaceTexture)) { + var renderSurfaceId = surfaceTexture.Textures.First(); + if (!_dats.Portal.TryGet(renderSurfaceId, out var renderSurface)) { + if (!_dats.HighRes.TryGet(renderSurfaceId, out var hrRenderSurface)) { + // TEMP diagnostic (dat-race investigation 2026-06-09, strip with fix) + Console.WriteLine($"[tex-skip] cellstruct RenderSurface 0x{renderSurfaceId:X8} miss (portal+highres) -> WALL poly batch dropped"); + return; + } + renderSurface = hrRenderSurface; + } + + texWidth = renderSurface.Width; + texHeight = renderSurface.Height; + paletteId = renderSurface.DefaultPaletteId; + sourceFormat = renderSurface.Format; + + if (_decodedTextureCache.TryGetValue(renderSurfaceId, out var cachedData)) { + textureData = cachedData; + textureFormat = TextureFormat.RGBA8; + uploadPixelFormat = UploadPixelFormat.Rgba; + } + else { + if (TextureHelpers.IsCompressedFormat(renderSurface.Format)) { + isDxt3or5 = renderSurface.Format == DatReaderWriter.Enums.PixelFormat.PFID_DXT3 || renderSurface.Format == DatReaderWriter.Enums.PixelFormat.PFID_DXT5; + textureFormat = TextureFormat.RGBA8; + uploadPixelFormat = UploadPixelFormat.Rgba; + + textureData = new byte[texWidth * texHeight * 4]; + CompressionFormat compressionFormat = renderSurface.Format switch { + DatReaderWriter.Enums.PixelFormat.PFID_DXT1 => CompressionFormat.Bc1, + DatReaderWriter.Enums.PixelFormat.PFID_DXT3 => CompressionFormat.Bc2, + DatReaderWriter.Enums.PixelFormat.PFID_DXT5 => CompressionFormat.Bc3, + _ => throw new NotSupportedException($"Unsupported compressed format: {renderSurface.Format}") + }; + + using (var image = _bcDecoder.Value!.DecodeRawToImageRgba32(renderSurface.SourceData, texWidth, texHeight, compressionFormat)) { + image.CopyPixelDataTo(textureData); + } + } + else { + textureFormat = TextureFormat.RGBA8; + textureData = renderSurface.SourceData; + switch (renderSurface.Format) { + case DatReaderWriter.Enums.PixelFormat.PFID_A8R8G8B8: + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillA8R8G8B8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_R8G8B8: + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillR8G8B8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_INDEX16: + if (!_dats.Portal.TryGet(renderSurface.DefaultPaletteId, out var paletteData)) return; + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillIndex16(renderSurface.SourceData, paletteData, textureData.AsSpan(), texWidth, texHeight, isClipMap); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_P8: + if (!_dats.Portal.TryGet(renderSurface.DefaultPaletteId, out var p8PaletteData)) return; + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillP8(renderSurface.SourceData, p8PaletteData, textureData.AsSpan(), texWidth, texHeight, isClipMap); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_R5G6B5: + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillR5G6B5(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_A4R4G4B4: + textureData = new byte[texWidth * texHeight * 4]; + TextureHelpers.FillA4R4G4B4(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + case DatReaderWriter.Enums.PixelFormat.PFID_A8: + case DatReaderWriter.Enums.PixelFormat.PFID_CUSTOM_LSCAPE_ALPHA: + textureData = new byte[texWidth * texHeight * 4]; + if (surface.Type.HasFlag(SurfaceType.Additive)) { + TextureHelpers.FillA8Additive(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + } + else { + TextureHelpers.FillA8(renderSurface.SourceData, textureData.AsSpan(), texWidth, texHeight); + } + uploadPixelFormat = UploadPixelFormat.Rgba; + break; + default: return; + } + } + + // Add to cache with LRU logic + if (textureData != null && _decodedTextureCache.TryAdd(renderSurfaceId, textureData)) { + _decodedTextureLru.Enqueue(renderSurfaceId); + if (_decodedTextureCache.Count > MaxDecodedTextures) { + if (_decodedTextureLru.TryDequeue(out var evictedId)) { + _decodedTextureCache.TryRemove(evictedId, out _); + } + } + } + } + + if (isClipMap && textureData != null) { + // If we got this from the cache, we need to clone it so we don't scale the cached raw data + var clonedData = new byte[textureData.Length]; + System.Buffer.BlockCopy(textureData, 0, clonedData, 0, textureData.Length); + textureData = clonedData; + + for (int i = 0; i < textureData.Length; i += 4) { + if (textureData[i] == 0 && textureData[i + 1] == 0 && textureData[i + 2] == 0) { + textureData[i + 3] = 0; + } + } + } + } + else { + // TEMP diagnostic (dat-race investigation 2026-06-09, strip with fix) + Console.WriteLine($"[tex-skip] cellstruct SurfaceTexture 0x{surface.OrigTextureId:X8} miss -> WALL poly batch dropped (surface 0x{surfaceId:X8})"); + return; + } + + isAdditive = !isSolid && surface.Type.HasFlag(SurfaceType.Additive); + isTransparent = isSolid ? surface.ColorValue.Alpha < 255 : + (surface.Type.HasFlag(SurfaceType.Translucent) || + surface.Type.HasFlag(SurfaceType.Base1ClipMap) || + ((uint)surface.Type & 0x100) != 0 || // Alpha + ((uint)surface.Type & 0x200) != 0 || // InvAlpha + isAdditive || + (surface.Translucency > 0.0f && surface.Translucency < 1.0f) || + textureFormat == TextureFormat.A8 || + textureFormat == TextureFormat.Rgba32f || + isDxt3or5 || + (sourceFormat != null && (sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_A8R8G8B8 || + sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_A4R4G4B4 || + sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_DXT3 || + sourceFormat == DatReaderWriter.Enums.PixelFormat.PFID_DXT5))); + + var format = (texWidth, texHeight, textureFormat); + var key = new TextureKey { + SurfaceId = surfaceId, + PaletteId = paletteId, + Stippling = poly.Stippling, + IsSolid = isSolid + }; + + if (!batchesByFormat.TryGetValue(format, out var batches)) { + batches = new List(); + batchesByFormat[format] = batches; + } + + var batch = batches.FirstOrDefault(b => b.Key.Equals(key) && b.CullMode == poly.SidesType); + if (batch == null) { + batch = new TextureBatchData { + Key = key, + CullMode = poly.SidesType, + TextureData = textureData!, + UploadPixelFormat = uploadPixelFormat, + UploadPixelType = uploadPixelType, + IsTransparent = isTransparent, + IsAdditive = isAdditive + }; + batches.Add(batch); + } + + // Helper for CellStruct vertices + bool batchHasWrappingUVs = batch.HasWrappingUVs; + BuildCellStructPolygonIndices( + poly, + cellStruct, + UVLookup, + vertices, + batch.Indices, + useNegUv, + invertNormal, + reverseWinding, + transform, + ref batchHasWrappingUVs); + batch.HasWrappingUVs = batchHasWrappingUVs; + } + } + + return new ObjectMeshData { + ObjectId = id, + IsSetup = false, + Vertices = vertices.ToArray(), + TextureBatches = batchesByFormat, + BoundingBox = boundingBox, + SortCenter = Vector3.Zero, + SelectionSphere = new Sphere { Origin = boundingBox.Center, Radius = Vector3.Distance(boundingBox.Max, boundingBox.Min) / 2.0f } + }; + } + + private void BuildCellStructPolygonIndices(Polygon poly, CellStruct cellStruct, + Dictionary<(ushort vertId, ushort uvIdx, bool invertNormal), ushort> UVLookup, + List vertices, List indices, + bool useNegUv, bool invertNormal, bool reverseWinding, + Matrix4x4 transform, ref bool hasWrappingUVs) { + + var polyIndices = new List(); + + for (int i = 0; i < poly.VertexIds.Count; i++) { + ushort vertId = (ushort)poly.VertexIds[i]; + ushort uvIdx = 0; + + if (useNegUv && poly.NegUVIndices != null && i < poly.NegUVIndices.Count) + uvIdx = poly.NegUVIndices[i]; + else if (poly.PosUVIndices != null && i < poly.PosUVIndices.Count) + uvIdx = poly.PosUVIndices[i]; + + if (!cellStruct.VertexArray.Vertices.TryGetValue(vertId, out var vertex)) continue; + + if (uvIdx >= vertex.UVs.Count) { + uvIdx = 0; + } + + var key = (vertId, uvIdx, invertNormal); + + if (!hasWrappingUVs) { + var uvCheck = vertex.UVs.Count > 0 + ? new Vector2(vertex.UVs[uvIdx].U, vertex.UVs[uvIdx].V) + : Vector2.Zero; + if (uvCheck.X < 0f || uvCheck.X > 1f || uvCheck.Y < 0f || uvCheck.Y > 1f) { + hasWrappingUVs = true; + } + } + + if (!UVLookup.TryGetValue(key, out var idx)) { + var uv = vertex.UVs.Count > 0 + ? new Vector2(vertex.UVs[uvIdx].U, vertex.UVs[uvIdx].V) + : Vector2.Zero; + + var normal = Vector3.Normalize(Vector3.TransformNormal(vertex.Normal, transform)); + if (invertNormal) { + normal = -normal; + } + + idx = (ushort)vertices.Count; + vertices.Add(new VertexPositionNormalTexture( + Vector3.Transform(vertex.Origin, transform), + normal, + uv + )); + UVLookup[key] = idx; + } + polyIndices.Add(idx); + } + + if (reverseWinding) { + for (int i = 2; i < polyIndices.Count; i++) { + indices.Add(polyIndices[i]); + indices.Add(polyIndices[i - 1]); + indices.Add(polyIndices[0]); + } + } + else { + for (int i = 2; i < polyIndices.Count; i++) { + indices.Add(polyIndices[0]); + indices.Add(polyIndices[i - 1]); + indices.Add(polyIndices[i]); + } + } + } + + private void BuildPolygonIndices(Polygon poly, GfxObj gfxObj, Vector3 scale, + Dictionary<(ushort vertId, ushort uvIdx, bool isNeg), ushort> UVLookup, + List vertices, List indices, bool useNegSurface, ref bool hasWrappingUVs) { + + var polyIndices = new List(); + + for (int i = 0; i < poly.VertexIds.Count; i++) { + ushort vertId = (ushort)poly.VertexIds[i]; + ushort uvIdx = 0; + + if (useNegSurface && poly.NegUVIndices != null && i < poly.NegUVIndices.Count) + uvIdx = poly.NegUVIndices[i]; + else if (!useNegSurface && poly.PosUVIndices != null && i < poly.PosUVIndices.Count) + uvIdx = poly.PosUVIndices[i]; + + if (!gfxObj.VertexArray.Vertices.TryGetValue(vertId, out var vertex)) continue; + + if (uvIdx >= vertex.UVs.Count) { + uvIdx = 0; + } + + var key = (vertId, uvIdx, useNegSurface); + + if (!hasWrappingUVs) { + var uvCheck = vertex.UVs.Count > 0 + ? new Vector2(vertex.UVs[uvIdx].U, vertex.UVs[uvIdx].V) + : Vector2.Zero; + if (uvCheck.X < 0f || uvCheck.X > 1f || uvCheck.Y < 0f || uvCheck.Y > 1f) { + hasWrappingUVs = true; + } + } + + if (!UVLookup.TryGetValue(key, out var idx)) { + var uv = vertex.UVs.Count > 0 + ? new Vector2(vertex.UVs[uvIdx].U, vertex.UVs[uvIdx].V) + : Vector2.Zero; + + var normal = Vector3.Normalize(vertex.Normal); + if (useNegSurface) { + normal = -normal; + } + + idx = (ushort)vertices.Count; + vertices.Add(new VertexPositionNormalTexture( + vertex.Origin * scale, + normal, + uv + )); + UVLookup[key] = idx; + } + polyIndices.Add(idx); + } + + if (useNegSurface) { + // Reverse winding for negative surface so it's visible from the other side + for (int i = 2; i < polyIndices.Count; i++) { + indices.Add(polyIndices[0]); + indices.Add(polyIndices[i - 1]); + indices.Add(polyIndices[i]); + } + } + else { + for (int i = 2; i < polyIndices.Count; i++) { + indices.Add(polyIndices[i]); + indices.Add(polyIndices[i - 1]); + indices.Add(polyIndices[0]); + } + } + } + + public (Vector3 Min, Vector3 Max) ComputeBounds(GfxObj gfxObj, Vector3 scale) { + var min = new Vector3(float.MaxValue); + var max = new Vector3(float.MinValue); + foreach (var vert in gfxObj.VertexArray.Vertices.Values) { + var p = vert.Origin * scale; + min = Vector3.Min(min, p); + max = Vector3.Max(max, p); + } + return (min, max); + } + + private ObjectMeshData? PrepareCellStructEdgeLineData(ulong id, Dictionary cellStructs, Matrix4x4 transform, CancellationToken ct) { + var cellStructList = cellStructs.ToList(); + if (cellStructList.Count == 0) { + return null; + } + + // Calculate bounding box from ALL vertices in all cell structures + var min = new Vector3(float.MaxValue); + var max = new Vector3(float.MinValue); + var allEdgeLines = new List(); + + // Process each CellStruct and collect all edge lines + foreach (var cellStructKvp in cellStructList) { + var cellStruct = cellStructKvp.Value; + + // Build edge lines for this CellStruct + var edgeLines = EdgeLineBuilder.BuildEdgeLines(cellStruct); + + // Transform edge lines to world space and add to collection + foreach (var edgeLine in edgeLines) { + allEdgeLines.Add(Vector3.Transform(edgeLine, transform)); + } + + // Update bounding box with vertices from this CellStruct + foreach (var vert in cellStruct.VertexArray.Vertices.Values) { + var localizedPos = Vector3.Transform(vert.Origin, transform); + min = Vector3.Min(min, localizedPos); + max = Vector3.Max(max, localizedPos); + } + } + + if (allEdgeLines.Count == 0) { + return null; + } + + var boundingBox = new BoundingBox(min, max); + + // Create minimal mesh data for edge line rendering + // We still need some vertices for rendering system to work, but they'll be transparent + var vertices = new List { + new VertexPositionNormalTexture { Position = Vector3.Zero, Normal = Vector3.UnitZ, UV = Vector2.Zero } + }; + var indices = new List { 0, 0, 0 }; // Dummy triangle + + // Create a transparent texture for base triangles (so only edge lines are visible) + var transparentTexture = TextureHelpers.CreateSolidColorTexture(new ColorARGB { Alpha = 0, Red = 255, Green = 255, Blue = 255 }, 1, 1); + + var result = new ObjectMeshData { + ObjectId = id, + IsSetup = false, + Vertices = vertices.ToArray(), + Batches = new List { + new MeshBatchData { + Indices = indices.ToArray(), + TextureFormat = (1, 1, TextureFormat.RGBA8), + TextureKey = new TextureKey { + SurfaceId = 0xFFFFFFFF, // Dummy surface ID + PaletteId = 0, + Stippling = StipplingType.NoPos, + IsSolid = true + }, + TextureIndex = 0, + TextureData = transparentTexture, + UploadPixelFormat = UploadPixelFormat.Rgba, + UploadPixelType = UploadPixelType.UnsignedByte, + CullMode = CullMode.None + } + }, + // Also populate TextureBatches for GPU upload + TextureBatches = new Dictionary<(int Width, int Height, TextureFormat Format), List> { + [(1, 1, TextureFormat.RGBA8)] = new List { + new TextureBatchData { + Indices = indices.ToList(), + Key = new TextureKey { + SurfaceId = 0xFFFFFFFF, // Dummy surface ID + PaletteId = 0, + Stippling = StipplingType.NoPos, + IsSolid = true + }, + TextureData = transparentTexture, + UploadPixelFormat = UploadPixelFormat.Rgba, + UploadPixelType = UploadPixelType.UnsignedByte, + CullMode = CullMode.None, + IsTransparent = false // Render in opaque pass but transparent + } + } + }, + BoundingBox = boundingBox, + SelectionSphere = new Sphere { Origin = boundingBox.Center, Radius = Vector3.Distance(boundingBox.Max, boundingBox.Min) / 2.0f } + }; + + // Store all edge lines in mesh data for later use in UploadMeshData + result.EdgeLines = allEdgeLines.ToArray(); + + return result; + } +} diff --git a/src/AcDream.Content/ObjectMeshData.cs b/src/AcDream.Content/ObjectMeshData.cs new file mode 100644 index 00000000..b5f7d5b0 --- /dev/null +++ b/src/AcDream.Content/ObjectMeshData.cs @@ -0,0 +1,124 @@ +using Chorizite.Core.Lib; +using Chorizite.Core.Render.Enums; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; +using System; +using System.Collections.Generic; +using System.Numerics; +using System.Runtime.InteropServices; +using BoundingBox = Chorizite.Core.Lib.BoundingBox; + +namespace AcDream.Content; + +/// +/// Vertex format for scenery mesh rendering: position, normal, UV. +/// +[StructLayout(LayoutKind.Sequential)] +public struct VertexPositionNormalTexture { + public Vector3 Position; + public Vector3 Normal; + public Vector2 UV; + + public static int Size => 8 * sizeof(float); // 3+3+2 = 8 floats = 32 bytes + + public VertexPositionNormalTexture(Vector3 position, Vector3 normal, Vector2 uv) { + Position = position; + Normal = normal; + UV = uv; + } +} + +/// +/// Staged data for a particle emitter to be created on the GL thread. +/// +public struct StagedEmitter { + public ParticleEmitter Emitter; + public uint PartIndex; + public Matrix4x4 Offset; +} + +/// +/// CPU-side mesh data prepared on a background thread. +/// Contains vertex data and per-batch index/texture info, but NO GPU resources. +/// +public class ObjectMeshData { + public ulong ObjectId { get; set; } + public bool IsSetup { get; set; } + public VertexPositionNormalTexture[] Vertices { get; set; } = Array.Empty(); + public List Batches { get; set; } = new(); + + /// + /// #125 (2026-06-12): GL upload-retry counter. A failed upload through + /// the App-side upload path (it returns null from its + /// catch) used to be dropped permanently — the staged item was consumed, + /// no render data was produced, and the prepared data lingered in the CPU + /// cache where PrepareMeshDataAsync's cache-hit short-circuit + /// returned it without ever re-staging it for upload (session-sticky + /// invisible mesh, one [wb-error] line). The drain loop now re-stages a + /// failed upload for the NEXT frame up to the App-side upload retry + /// limit (MaxUploadRetries). The counter lives on the mesh-data + /// object so + /// it resets to 0 naturally whenever the id is re-prepared (fresh object), + /// and bounds a deterministic GL failure to a few loud lines instead of a + /// silent permanent drop OR an unbounded per-frame retry storm. Retail + /// loads content synchronously and has no such failure mode — this + /// converges our async pipeline toward that guarantee. + /// + public int UploadAttempts; + + /// For EnvCell: the geometry of the cell itself. + public ObjectMeshData? EnvCellGeometry { get; set; } + + /// For Setup objects: parts with their local transforms. + public List<(ulong GfxObjId, Matrix4x4 Transform)> SetupParts { get; set; } = new(); + + /// Particle emitters from physics scripts. + public List ParticleEmitters { get; set; } = new(); + + /// Per-format texture atlas data (to be uploaded to GPU on main thread). + public Dictionary<(int Width, int Height, TextureFormat Format), List> TextureBatches { get; set; } = new(); + + /// Local bounding box. + public BoundingBox BoundingBox { get; set; } + + /// Approximate center point used for depth sorting / transparency ordering. + public Vector3 SortCenter { get; set; } + + /// DataID of a simpler GfxObj to use at long distance / low quality, or GfxObjDegradeInfo. + public uint DIDDegrade { get; set; } + + /// Sphere used for mouse selection. + public Sphere? SelectionSphere { get; set; } + + /// Edge line vertices for Environment wireframe rendering. + public Vector3[] EdgeLines { get; set; } = Array.Empty(); +} + +/// +/// CPU-side data for a single rendering batch (indices + texture reference). +/// +public class MeshBatchData { + public ushort[] Indices { get; set; } = Array.Empty(); + public (int Width, int Height, TextureFormat Format) TextureFormat { get; set; } + public TextureKey TextureKey { get; set; } + public int TextureIndex { get; set; } + public byte[] TextureData { get; set; } = Array.Empty(); + public UploadPixelFormat? UploadPixelFormat { get; set; } + public UploadPixelType? UploadPixelType { get; set; } + public DatReaderWriter.Enums.CullMode CullMode { get; set; } +} + +/// +/// CPU-side texture info for deduplication during background preparation. +/// +public class TextureBatchData { + public TextureKey Key { get; set; } + public byte[] TextureData { get; set; } = Array.Empty(); + public UploadPixelFormat? UploadPixelFormat { get; set; } + public UploadPixelType? UploadPixelType { get; set; } + public List Indices { get; set; } = new(); + public DatReaderWriter.Enums.CullMode CullMode { get; set; } + public bool IsTransparent { get; set; } + public bool IsAdditive { get; set; } + public bool HasWrappingUVs { get; set; } +} diff --git a/src/AcDream.Content/Pak/Crc32.cs b/src/AcDream.Content/Pak/Crc32.cs new file mode 100644 index 00000000..e2afda95 --- /dev/null +++ b/src/AcDream.Content/Pak/Crc32.cs @@ -0,0 +1,36 @@ +using System; + +namespace AcDream.Content.Pak; + +/// +/// Standard CRC-32 (IEEE 802.3 polynomial 0xEDB88320, the same variant used +/// by zip/gzip/PNG). Implemented directly rather than pulling in +/// System.IO.Hashing to keep AcDream.Content's dependency surface minimal +/// (mirrors the "no GL binaries, keep it lean" intent of the project — see +/// AcDream.Content.csproj's package comments). Used as the pak TOC's +/// per-blob corruption tripwire. +/// +public static class Crc32 { + private static readonly uint[] Table = BuildTable(); + + private static uint[] BuildTable() { + const uint polynomial = 0xEDB88320u; + var table = new uint[256]; + for (uint i = 0; i < 256; i++) { + uint c = i; + for (int k = 0; k < 8; k++) { + c = (c & 1) != 0 ? polynomial ^ (c >> 1) : c >> 1; + } + table[i] = c; + } + return table; + } + + public static uint Compute(ReadOnlySpan data) { + uint crc = 0xFFFFFFFFu; + foreach (var b in data) { + crc = Table[(crc ^ b) & 0xFF] ^ (crc >> 8); + } + return crc ^ 0xFFFFFFFFu; + } +} diff --git a/src/AcDream.Content/Pak/ObjectMeshDataSerializer.cs b/src/AcDream.Content/Pak/ObjectMeshDataSerializer.cs new file mode 100644 index 00000000..622f64cd --- /dev/null +++ b/src/AcDream.Content/Pak/ObjectMeshDataSerializer.cs @@ -0,0 +1,519 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Numerics; +using System.Runtime.InteropServices; +using Chorizite.Core.Render.Enums; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; +using BoundingBox = Chorizite.Core.Lib.BoundingBox; +using CullMode = DatReaderWriter.Enums.CullMode; + +namespace AcDream.Content.Pak; + +/// +/// Deterministic binary (de)serializer for the +/// family (, , +/// , , plus the DRW +/// / value types). +/// +/// Layout rules (normative, see +/// docs/superpowers/plans/2026-07-05-mp1b-pak-and-bake.md "Format v1"): +/// primitives raw little-endian; arrays as count:i32 + payload; blittable +/// arrays (VertexPositionNormalTexture[], ushort[] indices, byte[] texture +/// data) written via bulk +/// copy; is written sorted by the +/// key tuple (Width, Height, Format) so bakes are byte-reproducible run to +/// run regardless of dictionary insertion order; nullable fields as +/// present:byte + value. +/// +/// EVERY field of every type in the family is serialized — see the plan's +/// Task 3 checklist. nests +/// recursively (present:byte + nested block) since MeshExtractor can +/// populate it with another full ObjectMeshData. +/// +public static class ObjectMeshDataSerializer { + public static void Write(ObjectMeshData data, Stream stream) { + using var bw = new BinaryWriter(stream, System.Text.Encoding.UTF8, leaveOpen: true); + WriteObjectMeshData(bw, data); + } + + /// Deserializes directly over — no defensive copy (PakReader's single-pass read reuses its CRC buffer here). + public static ObjectMeshData Read(byte[] bytes) { + using var ms = new MemoryStream(bytes, writable: false); + using var br = new BinaryReader(ms, System.Text.Encoding.UTF8, leaveOpen: true); + return ReadObjectMeshData(br); + } + + public static ObjectMeshData Read(ReadOnlySpan bytes) => Read(bytes.ToArray()); + + // ---- ObjectMeshData ----------------------------------------------------- + + private static void WriteObjectMeshData(BinaryWriter w, ObjectMeshData data) { + w.Write(data.ObjectId); + w.Write(data.IsSetup); + + WriteVertexArray(w, data.Vertices); + + w.Write(data.Batches.Count); + foreach (var batch in data.Batches) WriteMeshBatchData(w, batch); + + w.Write(data.UploadAttempts); + + // EnvCellGeometry: recursive nested block. + w.Write(data.EnvCellGeometry is not null); + if (data.EnvCellGeometry is not null) WriteObjectMeshData(w, data.EnvCellGeometry); + + w.Write(data.SetupParts.Count); + foreach (var (gfxObjId, transform) in data.SetupParts) { + w.Write(gfxObjId); + WriteMatrix4x4(w, transform); + } + + w.Write(data.ParticleEmitters.Count); + foreach (var emitter in data.ParticleEmitters) WriteStagedEmitter(w, emitter); + + WriteTextureBatches(w, data.TextureBatches); + + WriteBoundingBox(w, data.BoundingBox); + WriteVector3(w, data.SortCenter); + w.Write(data.DIDDegrade); + + w.Write(data.SelectionSphere is not null); + if (data.SelectionSphere is not null) WriteSphere(w, data.SelectionSphere); + + WriteVector3Array(w, data.EdgeLines); + } + + private static ObjectMeshData ReadObjectMeshData(BinaryReader r) { + var data = new ObjectMeshData { + ObjectId = r.ReadUInt64(), + IsSetup = r.ReadBoolean(), + }; + + data.Vertices = ReadVertexArray(r); + + int batchCount = r.ReadInt32(); + var batches = new List(batchCount); + for (int i = 0; i < batchCount; i++) batches.Add(ReadMeshBatchData(r)); + data.Batches = batches; + + data.UploadAttempts = r.ReadInt32(); + + bool hasEnvCellGeometry = r.ReadBoolean(); + data.EnvCellGeometry = hasEnvCellGeometry ? ReadObjectMeshData(r) : null; + + int setupPartCount = r.ReadInt32(); + var setupParts = new List<(ulong GfxObjId, Matrix4x4 Transform)>(setupPartCount); + for (int i = 0; i < setupPartCount; i++) { + ulong gfxObjId = r.ReadUInt64(); + var transform = ReadMatrix4x4(r); + setupParts.Add((gfxObjId, transform)); + } + data.SetupParts = setupParts; + + int emitterCount = r.ReadInt32(); + var emitters = new List(emitterCount); + for (int i = 0; i < emitterCount; i++) emitters.Add(ReadStagedEmitter(r)); + data.ParticleEmitters = emitters; + + data.TextureBatches = ReadTextureBatches(r); + + data.BoundingBox = ReadBoundingBox(r); + data.SortCenter = ReadVector3(r); + data.DIDDegrade = r.ReadUInt32(); + + bool hasSelectionSphere = r.ReadBoolean(); + data.SelectionSphere = hasSelectionSphere ? ReadSphere(r) : null; + + data.EdgeLines = ReadVector3Array(r); + + return data; + } + + // ---- MeshBatchData ------------------------------------------------------- + + private static void WriteMeshBatchData(BinaryWriter w, MeshBatchData batch) { + WriteUInt16Array(w, batch.Indices); + WriteTextureFormatTuple(w, batch.TextureFormat); + WriteTextureKey(w, batch.TextureKey); + w.Write(batch.TextureIndex); + WriteByteArray(w, batch.TextureData); + WriteNullableInt32Enum(w, batch.UploadPixelFormat.HasValue, batch.UploadPixelFormat is { } upf ? (int)upf : 0); + WriteNullableInt32Enum(w, batch.UploadPixelType.HasValue, batch.UploadPixelType is { } upt ? (int)upt : 0); + w.Write((int)batch.CullMode); + } + + private static MeshBatchData ReadMeshBatchData(BinaryReader r) { + var batch = new MeshBatchData { + Indices = ReadUInt16Array(r), + TextureFormat = ReadTextureFormatTuple(r), + TextureKey = ReadTextureKey(r), + TextureIndex = r.ReadInt32(), + TextureData = ReadByteArray(r), + }; + batch.UploadPixelFormat = ReadNullableInt32Enum(r, v => (UploadPixelFormat)v); + batch.UploadPixelType = ReadNullableInt32Enum(r, v => (UploadPixelType)v); + batch.CullMode = (CullMode)r.ReadInt32(); + return batch; + } + + // ---- TextureBatchData / TextureBatches dictionary ------------------------- + + private static void WriteTextureBatchData(BinaryWriter w, TextureBatchData batch) { + WriteTextureKey(w, batch.Key); + WriteByteArray(w, batch.TextureData); + WriteNullableInt32Enum(w, batch.UploadPixelFormat.HasValue, batch.UploadPixelFormat is { } upf ? (int)upf : 0); + WriteNullableInt32Enum(w, batch.UploadPixelType.HasValue, batch.UploadPixelType is { } upt ? (int)upt : 0); + WriteUInt16List(w, batch.Indices); + w.Write((int)batch.CullMode); + w.Write(batch.IsTransparent); + w.Write(batch.IsAdditive); + w.Write(batch.HasWrappingUVs); + } + + private static TextureBatchData ReadTextureBatchData(BinaryReader r) { + var batch = new TextureBatchData { + Key = ReadTextureKey(r), + TextureData = ReadByteArray(r), + }; + batch.UploadPixelFormat = ReadNullableInt32Enum(r, v => (UploadPixelFormat)v); + batch.UploadPixelType = ReadNullableInt32Enum(r, v => (UploadPixelType)v); + batch.Indices = ReadUInt16List(r); + batch.CullMode = (CullMode)r.ReadInt32(); + batch.IsTransparent = r.ReadBoolean(); + batch.IsAdditive = r.ReadBoolean(); + batch.HasWrappingUVs = r.ReadBoolean(); + return batch; + } + + /// + /// Writes the TextureBatches dictionary sorted ascending by the key tuple + /// (Width, Height, Format) — REQUIRED for byte-reproducible bakes + /// independent of Dictionary iteration/insertion order. + /// + private static void WriteTextureBatches( + BinaryWriter w, + Dictionary<(int Width, int Height, TextureFormat Format), List> batches) { + var sortedKeys = batches.Keys + .OrderBy(k => k.Width) + .ThenBy(k => k.Height) + .ThenBy(k => (int)k.Format) + .ToList(); + + w.Write(sortedKeys.Count); + foreach (var key in sortedKeys) { + w.Write(key.Width); + w.Write(key.Height); + w.Write((int)key.Format); + + var list = batches[key]; + w.Write(list.Count); + foreach (var item in list) WriteTextureBatchData(w, item); + } + } + + private static Dictionary<(int Width, int Height, TextureFormat Format), List> ReadTextureBatches(BinaryReader r) { + int groupCount = r.ReadInt32(); + var result = new Dictionary<(int Width, int Height, TextureFormat Format), List>(groupCount); + for (int i = 0; i < groupCount; i++) { + int width = r.ReadInt32(); + int height = r.ReadInt32(); + var format = (TextureFormat)r.ReadInt32(); + + int listCount = r.ReadInt32(); + var list = new List(listCount); + for (int j = 0; j < listCount; j++) list.Add(ReadTextureBatchData(r)); + + result[(width, height, format)] = list; + } + return result; + } + + // ---- StagedEmitter / ParticleEmitter (DBObj) ------------------------------ + + private static void WriteStagedEmitter(BinaryWriter w, StagedEmitter emitter) { + w.Write(emitter.PartIndex); + WriteMatrix4x4(w, emitter.Offset); + w.Write(emitter.Emitter is not null); + if (emitter.Emitter is not null) WriteParticleEmitter(w, emitter.Emitter); + } + + private static StagedEmitter ReadStagedEmitter(BinaryReader r) { + uint partIndex = r.ReadUInt32(); + var offset = ReadMatrix4x4(r); + bool hasEmitter = r.ReadBoolean(); + var pe = hasEmitter ? ReadParticleEmitter(r) : null; + return new StagedEmitter { + PartIndex = partIndex, + Offset = offset, + Emitter = pe!, + }; + } + + /// + /// Field-by-field serialization of DatReaderWriter.DBObjs.ParticleEmitter + /// (the dat DBObj type — StagedEmitter.Emitter resolves to THIS type via + /// ObjectMeshData.cs's `using DatReaderWriter.DBObjs;`, NOT + /// AcDream.Core.Vfx.ParticleEmitter). Every public field/property on the + /// pinned Chorizite.DatReaderWriter 2.1.7 type is written explicitly + /// (verified via reflection against the exact installed package) rather + /// than delegating to the type's own Pack/Unpack: those require a live + /// DatBinWriter/DatBinReader bound to a DatDatabase, which would couple + /// our pak's determinism to a third-party wire-format helper we don't + /// control the versioning of. + /// + private static void WriteParticleEmitter(BinaryWriter w, ParticleEmitter pe) { + w.Write(pe.Id); + w.Write(pe.DataCategory); + w.Write(pe.Unknown); + w.Write((int)pe.EmitterType); + w.Write((int)pe.ParticleType); + w.Write(pe.GfxObjId.DataId); + w.Write(pe.HwGfxObjId.DataId); + w.Write(pe.Birthrate); + w.Write(pe.MaxParticles); + w.Write(pe.InitialParticles); + w.Write(pe.TotalParticles); + w.Write(pe.TotalSeconds); + w.Write(pe.Lifespan); + w.Write(pe.LifespanRand); + WriteVector3(w, pe.OffsetDir); + w.Write(pe.MinOffset); + w.Write(pe.MaxOffset); + WriteVector3(w, pe.A); + w.Write(pe.MinA); + w.Write(pe.MaxA); + WriteVector3(w, pe.B); + w.Write(pe.MinB); + w.Write(pe.MaxB); + WriteVector3(w, pe.C); + w.Write(pe.MinC); + w.Write(pe.MaxC); + w.Write(pe.StartScale); + w.Write(pe.FinalScale); + w.Write(pe.ScaleRand); + w.Write(pe.StartTrans); + w.Write(pe.FinalTrans); + w.Write(pe.TransRand); + w.Write(pe.IsParentLocal); + } + + private static ParticleEmitter ReadParticleEmitter(BinaryReader r) { + var pe = new ParticleEmitter { + Id = r.ReadUInt32(), + DataCategory = r.ReadUInt32(), + }; + pe.Unknown = r.ReadUInt32(); + pe.EmitterType = (DatReaderWriter.Enums.EmitterType)r.ReadInt32(); + pe.ParticleType = (DatReaderWriter.Enums.ParticleType)r.ReadInt32(); + pe.GfxObjId = new QualifiedDataId { DataId = r.ReadUInt32() }; + pe.HwGfxObjId = new QualifiedDataId { DataId = r.ReadUInt32() }; + pe.Birthrate = r.ReadDouble(); + pe.MaxParticles = r.ReadInt32(); + pe.InitialParticles = r.ReadInt32(); + pe.TotalParticles = r.ReadInt32(); + pe.TotalSeconds = r.ReadDouble(); + pe.Lifespan = r.ReadDouble(); + pe.LifespanRand = r.ReadDouble(); + pe.OffsetDir = ReadVector3(r); + pe.MinOffset = r.ReadSingle(); + pe.MaxOffset = r.ReadSingle(); + pe.A = ReadVector3(r); + pe.MinA = r.ReadSingle(); + pe.MaxA = r.ReadSingle(); + pe.B = ReadVector3(r); + pe.MinB = r.ReadSingle(); + pe.MaxB = r.ReadSingle(); + pe.C = ReadVector3(r); + pe.MinC = r.ReadSingle(); + pe.MaxC = r.ReadSingle(); + pe.StartScale = r.ReadSingle(); + pe.FinalScale = r.ReadSingle(); + pe.ScaleRand = r.ReadSingle(); + pe.StartTrans = r.ReadSingle(); + pe.FinalTrans = r.ReadSingle(); + pe.TransRand = r.ReadSingle(); + pe.IsParentLocal = r.ReadBoolean(); + return pe; + } + + // ---- TextureKey ------------------------------------------------------ + + private static void WriteTextureKey(BinaryWriter w, TextureKey key) { + w.Write(key.SurfaceId); + w.Write(key.PaletteId); + w.Write((byte)key.Stippling); + w.Write(key.IsSolid); + } + + private static TextureKey ReadTextureKey(BinaryReader r) { + return new TextureKey { + SurfaceId = r.ReadUInt32(), + PaletteId = r.ReadUInt32(), + Stippling = (DatReaderWriter.Enums.StipplingType)r.ReadByte(), + IsSolid = r.ReadBoolean(), + }; + } + + private static void WriteTextureFormatTuple(BinaryWriter w, (int Width, int Height, TextureFormat Format) tuple) { + w.Write(tuple.Width); + w.Write(tuple.Height); + w.Write((int)tuple.Format); + } + + private static (int Width, int Height, TextureFormat Format) ReadTextureFormatTuple(BinaryReader r) { + int width = r.ReadInt32(); + int height = r.ReadInt32(); + var format = (TextureFormat)r.ReadInt32(); + return (width, height, format); + } + + // ---- Sphere / BoundingBox (DRW / Chorizite value types) ------------------- + + private static void WriteSphere(BinaryWriter w, Sphere sphere) { + WriteVector3(w, sphere.Origin); + w.Write(sphere.Radius); + } + + private static Sphere ReadSphere(BinaryReader r) { + var origin = ReadVector3(r); + float radius = r.ReadSingle(); + return new Sphere { Origin = origin, Radius = radius }; + } + + private static void WriteBoundingBox(BinaryWriter w, BoundingBox box) { + WriteVector3(w, box.Min); + WriteVector3(w, box.Max); + } + + private static BoundingBox ReadBoundingBox(BinaryReader r) { + var min = ReadVector3(r); + var max = ReadVector3(r); + return new BoundingBox(min, max); + } + + // ---- primitive helpers ------------------------------------------------- + + private static void WriteVector3(BinaryWriter w, Vector3 v) { + w.Write(v.X); + w.Write(v.Y); + w.Write(v.Z); + } + + private static Vector3 ReadVector3(BinaryReader r) { + float x = r.ReadSingle(); + float y = r.ReadSingle(); + float z = r.ReadSingle(); + return new Vector3(x, y, z); + } + + private static void WriteMatrix4x4(BinaryWriter w, Matrix4x4 m) { + w.Write(m.M11); w.Write(m.M12); w.Write(m.M13); w.Write(m.M14); + w.Write(m.M21); w.Write(m.M22); w.Write(m.M23); w.Write(m.M24); + w.Write(m.M31); w.Write(m.M32); w.Write(m.M33); w.Write(m.M34); + w.Write(m.M41); w.Write(m.M42); w.Write(m.M43); w.Write(m.M44); + } + + private static Matrix4x4 ReadMatrix4x4(BinaryReader r) { + return new Matrix4x4( + r.ReadSingle(), r.ReadSingle(), r.ReadSingle(), r.ReadSingle(), + r.ReadSingle(), r.ReadSingle(), r.ReadSingle(), r.ReadSingle(), + r.ReadSingle(), r.ReadSingle(), r.ReadSingle(), r.ReadSingle(), + r.ReadSingle(), r.ReadSingle(), r.ReadSingle(), r.ReadSingle()); + } + + /// count:i32 + MemoryMarshal.AsBytes bulk copy (32 bytes/vertex). + private static void WriteVertexArray(BinaryWriter w, VertexPositionNormalTexture[] vertices) { + w.Write(vertices.Length); + if (vertices.Length == 0) return; + var bytes = MemoryMarshal.AsBytes(vertices.AsSpan()); + w.Write(bytes); + } + + private static VertexPositionNormalTexture[] ReadVertexArray(BinaryReader r) { + int count = r.ReadInt32(); + if (count == 0) return Array.Empty(); + var result = new VertexPositionNormalTexture[count]; + var bytes = r.ReadBytes(count * VertexPositionNormalTexture.Size); + bytes.CopyTo(MemoryMarshal.AsBytes(result.AsSpan())); + return result; + } + + /// count:i32 + MemoryMarshal.AsBytes bulk copy (12 bytes/Vector3). + private static void WriteVector3Array(BinaryWriter w, Vector3[] array) { + w.Write(array.Length); + if (array.Length == 0) return; + var bytes = MemoryMarshal.AsBytes(array.AsSpan()); + w.Write(bytes); + } + + private static Vector3[] ReadVector3Array(BinaryReader r) { + int count = r.ReadInt32(); + if (count == 0) return Array.Empty(); + var result = new Vector3[count]; + var bytes = r.ReadBytes(count * 12); + bytes.CopyTo(MemoryMarshal.AsBytes(result.AsSpan())); + return result; + } + + /// count:i32 + MemoryMarshal.AsBytes bulk copy (2 bytes/ushort). + private static void WriteUInt16Array(BinaryWriter w, ushort[] array) { + w.Write(array.Length); + if (array.Length == 0) return; + var bytes = MemoryMarshal.AsBytes(array.AsSpan()); + w.Write(bytes); + } + + private static ushort[] ReadUInt16Array(BinaryReader r) { + int count = r.ReadInt32(); + if (count == 0) return Array.Empty(); + var result = new ushort[count]; + var bytes = r.ReadBytes(count * sizeof(ushort)); + bytes.CopyTo(MemoryMarshal.AsBytes(result.AsSpan())); + return result; + } + + private static void WriteUInt16List(BinaryWriter w, List list) { + w.Write(list.Count); + if (list.Count == 0) return; + var array = list.ToArray(); + var bytes = MemoryMarshal.AsBytes(array.AsSpan()); + w.Write(bytes); + } + + private static List ReadUInt16List(BinaryReader r) { + int count = r.ReadInt32(); + var list = new List(count); + if (count == 0) return list; + var array = new ushort[count]; + var bytes = r.ReadBytes(count * sizeof(ushort)); + bytes.CopyTo(MemoryMarshal.AsBytes(array.AsSpan())); + list.AddRange(array); + return list; + } + + /// count:i32 + raw byte payload. + private static void WriteByteArray(BinaryWriter w, byte[] array) { + w.Write(array.Length); + if (array.Length > 0) w.Write(array); + } + + private static byte[] ReadByteArray(BinaryReader r) { + int count = r.ReadInt32(); + return count == 0 ? Array.Empty() : r.ReadBytes(count); + } + + /// present:byte + value:i32 for a nullable enum-backed-by-int field. + private static void WriteNullableInt32Enum(BinaryWriter w, bool present, int value) { + w.Write(present); + w.Write(value); + } + + private static TEnum? ReadNullableInt32Enum(BinaryReader r, Func project) where TEnum : struct, Enum { + bool present = r.ReadBoolean(); + int value = r.ReadInt32(); + return present ? project(value) : null; + } +} diff --git a/src/AcDream.Content/Pak/PakFormat.cs b/src/AcDream.Content/Pak/PakFormat.cs new file mode 100644 index 00000000..bf8b85bd --- /dev/null +++ b/src/AcDream.Content/Pak/PakFormat.cs @@ -0,0 +1,137 @@ +using System; +using System.Buffers.Binary; +using System.IO; + +namespace AcDream.Content.Pak; + +/// +/// Pak format constants shared by writer and reader. +/// +public static class PakFormat { + /// + /// The one format version this build writes and reads. PakWriter stamps + /// it unconditionally (callers cannot override it via the header + /// template); PakReader refuses to open any other version. Bump ONLY + /// with an accompanying reader migration path. + /// + public const uint CurrentFormatVersion = 1; +} + +/// +/// Fixed 64-byte pak file header. Layout (all integers little-endian): +/// +/// offset size field +/// 0 4 magic 'ACPK' (0x4B504341) +/// 4 4 formatVersion = 1 +/// 8 4 portalIteration (DatCollection.Portal.Iteration) +/// 12 4 cellIteration +/// 16 4 highResIteration +/// 20 4 languageIteration +/// 24 8 tocOffset (u64) +/// 32 4 tocCount (u32) +/// 36 4 bakeToolVersion = 1 +/// 40 24 reserved (zero) +/// +/// Spec: docs/superpowers/plans/2026-07-05-mp1b-pak-and-bake.md "Format v1 (normative)". +/// +public struct PakHeader { + public const int Size = 64; + public const uint MagicValue = 0x4B504341u; // 'ACPK' little-endian + + /// Always after ; not settable by callers building a header to write. + public uint Magic { get; private set; } = MagicValue; + + public uint FormatVersion; + public uint PortalIteration; + public uint CellIteration; + public uint HighResIteration; + public uint LanguageIteration; + public ulong TocOffset; + public uint TocCount; + public uint BakeToolVersion; + + public PakHeader() { } + + public void WriteTo(Span dest) { + if (dest.Length < Size) throw new ArgumentException($"destination must be at least {Size} bytes", nameof(dest)); + BinaryPrimitives.WriteUInt32LittleEndian(dest[0..4], MagicValue); + BinaryPrimitives.WriteUInt32LittleEndian(dest[4..8], FormatVersion); + BinaryPrimitives.WriteUInt32LittleEndian(dest[8..12], PortalIteration); + BinaryPrimitives.WriteUInt32LittleEndian(dest[12..16], CellIteration); + BinaryPrimitives.WriteUInt32LittleEndian(dest[16..20], HighResIteration); + BinaryPrimitives.WriteUInt32LittleEndian(dest[20..24], LanguageIteration); + BinaryPrimitives.WriteUInt64LittleEndian(dest[24..32], TocOffset); + BinaryPrimitives.WriteUInt32LittleEndian(dest[32..36], TocCount); + BinaryPrimitives.WriteUInt32LittleEndian(dest[36..40], BakeToolVersion); + dest[40..64].Clear(); // reserved, zero + } + + public void WriteTo(Stream stream) { + Span buf = stackalloc byte[Size]; + WriteTo(buf); + stream.Write(buf); + } + + public static PakHeader ReadFrom(ReadOnlySpan src) { + if (src.Length < Size) throw new ArgumentException($"source must be at least {Size} bytes", nameof(src)); + var magic = BinaryPrimitives.ReadUInt32LittleEndian(src[0..4]); + if (magic != MagicValue) { + throw new InvalidDataException($"pak header magic mismatch: expected 0x{MagicValue:X8}, got 0x{magic:X8}"); + } + return new PakHeader { + FormatVersion = BinaryPrimitives.ReadUInt32LittleEndian(src[4..8]), + PortalIteration = BinaryPrimitives.ReadUInt32LittleEndian(src[8..12]), + CellIteration = BinaryPrimitives.ReadUInt32LittleEndian(src[12..16]), + HighResIteration = BinaryPrimitives.ReadUInt32LittleEndian(src[16..20]), + LanguageIteration = BinaryPrimitives.ReadUInt32LittleEndian(src[20..24]), + TocOffset = BinaryPrimitives.ReadUInt64LittleEndian(src[24..32]), + TocCount = BinaryPrimitives.ReadUInt32LittleEndian(src[32..36]), + BakeToolVersion = BinaryPrimitives.ReadUInt32LittleEndian(src[36..40]), + }; + } + + public static PakHeader ReadFrom(Stream stream) { + Span buf = stackalloc byte[Size]; + stream.ReadExactly(buf); + return ReadFrom((ReadOnlySpan)buf); + } +} + +/// +/// One 24-byte TOC entry: key u64, offset u64, length u32, crc32 u32. +/// Entries in a pak's TOC are sorted ascending by to allow +/// binary-search lookup. is a corruption tripwire computed +/// over the blob bytes; the reader verifies lazily on first access. +/// +public struct PakTocEntry { + public const int Size = 24; + + public ulong Key; + public ulong Offset; + public uint Length; + public uint Crc32; + + public void WriteTo(Span dest) { + if (dest.Length < Size) throw new ArgumentException($"destination must be at least {Size} bytes", nameof(dest)); + BinaryPrimitives.WriteUInt64LittleEndian(dest[0..8], Key); + BinaryPrimitives.WriteUInt64LittleEndian(dest[8..16], Offset); + BinaryPrimitives.WriteUInt32LittleEndian(dest[16..20], Length); + BinaryPrimitives.WriteUInt32LittleEndian(dest[20..24], Crc32); + } + + public void WriteTo(Stream stream) { + Span buf = stackalloc byte[Size]; + WriteTo(buf); + stream.Write(buf); + } + + public static PakTocEntry ReadFrom(ReadOnlySpan src) { + if (src.Length < Size) throw new ArgumentException($"source must be at least {Size} bytes", nameof(src)); + return new PakTocEntry { + Key = BinaryPrimitives.ReadUInt64LittleEndian(src[0..8]), + Offset = BinaryPrimitives.ReadUInt64LittleEndian(src[8..16]), + Length = BinaryPrimitives.ReadUInt32LittleEndian(src[16..20]), + Crc32 = BinaryPrimitives.ReadUInt32LittleEndian(src[20..24]), + }; + } +} diff --git a/src/AcDream.Content/Pak/PakKey.cs b/src/AcDream.Content/Pak/PakKey.cs new file mode 100644 index 00000000..da1a8753 --- /dev/null +++ b/src/AcDream.Content/Pak/PakKey.cs @@ -0,0 +1,33 @@ +namespace AcDream.Content.Pak; + +/// +/// MP1b pak asset-type discriminant — the top byte of a . +/// Numeric values are a WIRE FORMAT (persisted in every pak's TOC): never +/// renumber existing members, only append. +/// Spec: docs/superpowers/specs/2026-07-05-modern-pipeline-design.md §6.2; +/// plan: docs/superpowers/plans/2026-07-05-mp1b-pak-and-bake.md "Format v1". +/// +public enum PakAssetType : byte { + GfxObjMesh = 1, + SetupMesh = 2, + EnvCellMesh = 3, +} + +/// +/// Composes/decomposes the 64-bit pak asset key: type:u8 | fileId:u32 | reserved:u24. +/// Layout: ((ulong)type << 56) | ((ulong)fileId << 24) — the low 24 bits are +/// reserved (variant/zero in v1). Ascending numeric key order equals ascending +/// (type, fileId) tuple order, which is what makes the pak TOC's binary search +/// over raw u64 keys valid. +/// +public static class PakKey { + public static ulong Compose(PakAssetType type, uint fileId) { + return ((ulong)type << 56) | ((ulong)fileId << 24); + } + + public static (PakAssetType Type, uint FileId) Decompose(ulong key) { + var type = (PakAssetType)(byte)(key >> 56); + var fileId = (uint)((key >> 24) & 0xFFFFFFFFu); + return (type, fileId); + } +} diff --git a/src/AcDream.Content/Pak/PakReader.cs b/src/AcDream.Content/Pak/PakReader.cs new file mode 100644 index 00000000..9a7549d5 --- /dev/null +++ b/src/AcDream.Content/Pak/PakReader.cs @@ -0,0 +1,222 @@ +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.IO; +using System.IO.MemoryMappedFiles; + +namespace AcDream.Content.Pak; + +/// +/// mmap reader for an acdream pak file. One +/// for the whole file's lifetime; TOC is loaded once at construction into a +/// key-sorted array for O(log n) binary-search lookup. +/// +/// Corrupt = missing (documented contract): a pak is an external +/// file — the reader's job is to surface corruption loudly ONCE and then +/// behave as if the damaged entry were absent, never to hand back garbage or +/// throw from a lookup. Three tripwires feed the same "missing" state: +/// (1) structurally invalid TOC entries (offset/length outside the file) are +/// detected at open; (2) blob CRC-32 is verified LAZILY on first access and +/// cached; (3) a blob whose bytes fail deserialization despite a matching +/// CRC (malformed structure) fails at read. Each is logged once per entry. +/// Structurally unopenable files (bad magic, wrong format version, +/// unfinalized header, TOC past EOF) throw at OPEN — before any lookups — +/// with a message naming the problem. +/// +/// Thread safety: no locks on the read path — the mapped memory +/// is immutable for the lifetime of this reader (acdream never mutates a pak +/// while it's open for reading; MP1c's cutover writes a NEW pak and swaps it +/// in). The lazy per-entry verdict set is a ConcurrentDictionary because +/// MP1c calls TryReadObjectMeshData from up to 4 decode workers concurrently. +/// +/// Perf note: a first read costs ONE exact-size byte[] copy out +/// of the map — CRC and deserialization both run over that same buffer in a +/// single pass. True span-over-mmap zero-copy (deserializing straight out of +/// the mapped view with no copy at all) is deferred to MP1c profiling — do +/// not add it speculatively. +/// +public sealed class PakReader : IDisposable { + private readonly MemoryMappedFile _mmf; + private readonly MemoryMappedViewAccessor _accessor; + private readonly long _fileLength; + private readonly PakTocEntry[] _toc; // sorted ascending by Key + + /// Lazy per-entry verdict: absent = not yet judged, 0 = bad (bounds/crc/structure), 1 = ok. + private readonly ConcurrentDictionary _entryVerdictByTocIndex = new(); + private readonly ConcurrentDictionary _loggedCorruption = new(); + + public PakHeader Header { get; } + + public PakReader(string path) { + _fileLength = new FileInfo(path).Length; + if (_fileLength < PakHeader.Size) { + throw new InvalidDataException($"pak file '{path}' is {_fileLength} bytes — smaller than the {PakHeader.Size}-byte header"); + } + + _mmf = MemoryMappedFile.CreateFromFile(path, FileMode.Open, mapName: null, capacity: 0, MemoryMappedFileAccess.Read); + _accessor = _mmf.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read); + + var headerBytes = new byte[PakHeader.Size]; + _accessor.ReadArray(0, headerBytes, 0, PakHeader.Size); + Header = PakHeader.ReadFrom((ReadOnlySpan)headerBytes); + + if (Header.FormatVersion != PakFormat.CurrentFormatVersion) { + throw new InvalidDataException( + $"pak file '{path}' has format version {Header.FormatVersion}; this build reads only " + + $"version {PakFormat.CurrentFormatVersion}. Re-bake with the matching acdream-bake."); + } + + // Half-written pak: PakWriter writes a placeholder header (TocOffset 0) + // first and only seeks back to finalize it in Finish(). A crash between + // those leaves TocOffset below the header size — structurally + // unfinalized; refuse loudly rather than serving an empty TOC over a + // file that has blob bytes in it. + if (Header.TocOffset < PakHeader.Size) { + throw new InvalidDataException( + $"pak file '{path}' has an unfinalized header (tocOffset={Header.TocOffset}) — " + + "the bake was interrupted before Finish(); re-bake."); + } + + long tocBytesTotal = (long)Header.TocCount * PakTocEntry.Size; + if ((long)Header.TocOffset + tocBytesTotal > _fileLength) { + throw new InvalidDataException( + $"pak file '{path}' TOC (offset {Header.TocOffset}, {Header.TocCount} entries) extends past " + + $"the file's actual length ({_fileLength} bytes) — truncated or corrupt file"); + } + + _toc = new PakTocEntry[Header.TocCount]; + var tocBytes = new byte[PakTocEntry.Size]; + long tocPos = (long)Header.TocOffset; + for (int i = 0; i < _toc.Length; i++) { + _accessor.ReadArray(tocPos, tocBytes, 0, PakTocEntry.Size); + _toc[i] = PakTocEntry.ReadFrom((ReadOnlySpan)tocBytes); + tocPos += PakTocEntry.Size; + + // Per-entry bounds validation (corrupt = missing, not throw): a + // blob region must sit fully between the header and the TOC, and + // its offset must survive the (long) cast the accessor needs. + ref readonly var entry = ref _toc[i]; + bool invalid = + entry.Offset < PakHeader.Size || + entry.Offset > long.MaxValue || + entry.Offset + entry.Length > Header.TocOffset || + entry.Offset + entry.Length > (ulong)_fileLength; + if (invalid) { + _entryVerdictByTocIndex[i] = 0; + LogCorruptionOnce(i, $"TOC entry out of bounds (offset={entry.Offset}, length={entry.Length}, " + + $"file={_fileLength}, toc@{Header.TocOffset})"); + } + } + } + + /// True if is present AND its blob verifies (bounds + CRC). + public bool ContainsKey(ulong key) { + int index = BinarySearch(key); + if (index < 0) return false; + return VerdictFor(index) == 1; + } + + /// + /// Reads and deserializes the stored under + /// . Returns false (data null) if the key is absent + /// OR the blob fails any tripwire (bounds, CRC, structural deserialization + /// failure) — logged once per entry, per the corrupt-=-missing contract. + /// + public bool TryReadObjectMeshData(ulong key, out ObjectMeshData? data) { + data = null; + int index = BinarySearch(key); + if (index < 0) return false; + + // Previously judged bad (bounds at open, or an earlier CRC/structure + // failure): missing, no re-read, no re-log. + bool judged = _entryVerdictByTocIndex.TryGetValue(index, out var verdict); + if (judged && verdict == 0) return false; + + // Single pass (review finding 4): ONE copy out of the map; CRC and + // deserialization both run over this same buffer. + ref readonly var entry = ref _toc[index]; + var bytes = new byte[entry.Length]; + _accessor.ReadArray((long)entry.Offset, bytes, 0, (int)entry.Length); + + if (!judged) { + uint actualCrc = Crc32.Compute(bytes); + if (actualCrc != entry.Crc32) { + _entryVerdictByTocIndex[index] = 0; + LogCorruptionOnce(index, $"crc mismatch (expected 0x{entry.Crc32:X8}, got 0x{actualCrc:X8})"); + return false; + } + _entryVerdictByTocIndex[index] = 1; + } + + try { + data = ObjectMeshDataSerializer.Read(bytes); + return true; + } + catch (Exception ex) { + // Structurally malformed blob behind a valid CRC (bake-side bug or + // a tamper that recomputed the CRC). External-file input: demote + // to missing, log once — never propagate from a lookup. + data = null; + _entryVerdictByTocIndex[index] = 0; + LogCorruptionOnce(index, $"deserialization failed despite matching CRC: {ex.GetType().Name}: {ex.Message}"); + return false; + } + } + + /// Returns the blob's file offset for alignment assertions in tests. + public long GetBlobOffsetForTest(ulong key) { + int index = BinarySearch(key); + if (index < 0) throw new KeyNotFoundException($"pak key 0x{key:X16} not found"); + return (long)_toc[index].Offset; + } + + /// O(n) linear scan, used only to cross-check the binary search in tests. + public bool DebugLinearScanContainsKey(ulong key) { + for (int i = 0; i < _toc.Length; i++) { + if (_toc[i].Key == key) return VerdictFor(i) == 1; + } + return false; + } + + /// Resolves (and caches) the entry's verdict, reading + CRC-checking the blob if not yet judged. + private int VerdictFor(int tocIndex) { + if (_entryVerdictByTocIndex.TryGetValue(tocIndex, out var cached)) return cached; + + ref readonly var entry = ref _toc[tocIndex]; + var bytes = new byte[entry.Length]; + _accessor.ReadArray((long)entry.Offset, bytes, 0, (int)entry.Length); + uint actualCrc = Crc32.Compute(bytes); + bool ok = actualCrc == entry.Crc32; + + _entryVerdictByTocIndex[tocIndex] = ok ? 1 : 0; + if (!ok) { + LogCorruptionOnce(tocIndex, $"crc mismatch (expected 0x{entry.Crc32:X8}, got 0x{actualCrc:X8})"); + } + return ok ? 1 : 0; + } + + private void LogCorruptionOnce(int tocIndex, string reason) { + if (!_loggedCorruption.TryAdd(tocIndex, true)) return; + ref readonly var entry = ref _toc[tocIndex]; + Console.Error.WriteLine( + $"[pak-corrupt] key 0x{entry.Key:X16} at offset {entry.Offset} (length {entry.Length}): " + + $"{reason} — treating as missing"); + } + + private int BinarySearch(ulong key) { + int lo = 0, hi = _toc.Length - 1; + while (lo <= hi) { + int mid = lo + (hi - lo) / 2; + ulong midKey = _toc[mid].Key; + if (midKey == key) return mid; + if (midKey < key) lo = mid + 1; + else hi = mid - 1; + } + return -1; + } + + public void Dispose() { + _accessor.Dispose(); + _mmf.Dispose(); + } +} diff --git a/src/AcDream.Content/Pak/PakWriter.cs b/src/AcDream.Content/Pak/PakWriter.cs new file mode 100644 index 00000000..2a745669 --- /dev/null +++ b/src/AcDream.Content/Pak/PakWriter.cs @@ -0,0 +1,119 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; + +namespace AcDream.Content.Pak; + +/// +/// Streams pak blobs to disk: header placeholder -> 64-byte-aligned blobs -> +/// TOC (sorted by key) -> seek back and finalize the header once +/// tocOffset/tocCount are known. This lets the writer stream blobs without +/// knowing the final count up front (plan: "TOC last"). +/// +public sealed class PakWriter : IDisposable { + private const int Alignment = 64; + + private readonly FileStream _stream; + private readonly PakHeader _headerTemplate; + private readonly List _tocEntries = new(); + private readonly HashSet _seenKeys = new(); + private bool _finished; + + public PakWriter(string path, PakHeader headerTemplate) { + _stream = new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None); + _headerTemplate = headerTemplate; + // The format version is the WRITER's identity, not caller input — + // stamp it unconditionally so a caller-populated header template can + // never produce a pak claiming a version this code doesn't write + // (the default-0 footgun; PakReader rejects any version but + // PakFormat.CurrentFormatVersion). + _headerTemplate.FormatVersion = PakFormat.CurrentFormatVersion; + + // Write a header placeholder now; finalized in Finish() once TocOffset/TocCount are known. + _headerTemplate.WriteTo(_stream); + PadToAlignment(); + } + + /// + /// Adds one blob (an serialized via + /// ) under . + /// Blobs are written immediately at the current (64-byte-aligned) stream + /// position; the writer pads after each blob so the NEXT blob also + /// starts aligned. + /// + public void AddBlob(ulong key, ObjectMeshData data) { + ThrowIfFinished(); + if (!_seenKeys.Add(key)) { + throw new ArgumentException($"duplicate pak key 0x{key:X16}", nameof(key)); + } + + long offset = _stream.Position; + using var ms = new MemoryStream(); + ObjectMeshDataSerializer.Write(data, ms); + var bytes = ms.ToArray(); + + _stream.Write(bytes); + PadToAlignment(); + + _tocEntries.Add(new PakTocEntry { + Key = key, + Offset = (ulong)offset, + Length = (uint)bytes.Length, + Crc32 = Content.Pak.Crc32.Compute(bytes), + }); + } + + /// Writes the sorted TOC and finalizes the header. Must be called exactly once. + public void Finish() { + ThrowIfFinished(); + _finished = true; + + var sorted = _tocEntries.OrderBy(e => e.Key).ToList(); + ulong tocOffset = (ulong)_stream.Position; + foreach (var entry in sorted) { + entry.WriteTo(_stream); + } + + var finalHeader = _headerTemplate; + finalHeader.TocOffset = tocOffset; + finalHeader.TocCount = (uint)sorted.Count; + + _stream.Position = 0; + finalHeader.WriteTo(_stream); + _stream.Flush(); + } + + private void PadToAlignment() { + long pos = _stream.Position; + long remainder = pos % Alignment; + if (remainder == 0) return; + long pad = Alignment - remainder; + Span zeros = stackalloc byte[(int)pad]; + zeros.Clear(); + _stream.Write(zeros); + } + + private void ThrowIfFinished() { + if (_finished) throw new InvalidOperationException("PakWriter.Finish() has already been called."); + } + + public void Dispose() { + // Best-effort finalize so a forgotten Finish() call doesn't leave a + // half-written file with a placeholder header claiming 0 entries + // while blobs are on disk. try/finally, NOT a bare sequence: Finish() + // performs real I/O (TOC write, header seek-back, flush) and can + // throw for environmental reasons (disk full, I/O error) — the + // stream must ALWAYS be closed so the file handle is never leaked + // mid-unwind (review finding 5 on the a5926ebc cleanup, which had + // removed exactly this guarantee). + try { + if (!_finished) { + Finish(); + } + } + finally { + _stream.Dispose(); + } + } +} diff --git a/src/AcDream.Content/TextureKey.cs b/src/AcDream.Content/TextureKey.cs new file mode 100644 index 00000000..3fe41827 --- /dev/null +++ b/src/AcDream.Content/TextureKey.cs @@ -0,0 +1,30 @@ +using DatReaderWriter.Enums; +using System; + +namespace AcDream.Content; + +// MP1a (2026-07-05): lifted verbatim out of TextureAtlasManager (GL class) +// so the GL-free mesh-extraction path (MeshExtractor / ObjectMeshData) can +// reference the atlas dedup key without a Silk.NET dependency. Field set, +// equality semantics, and hash behavior are UNCHANGED. +public struct TextureKey : IEquatable { + public uint SurfaceId; + public uint PaletteId; + public StipplingType Stippling; + public bool IsSolid; + + public bool Equals(TextureKey other) { + return SurfaceId == other.SurfaceId && + PaletteId == other.PaletteId && + Stippling == other.Stippling && + IsSolid == other.IsSolid; + } + + public override bool Equals(object? obj) { + return obj is TextureKey other && Equals(other); + } + + public override int GetHashCode() { + return HashCode.Combine(SurfaceId, PaletteId, Stippling, IsSolid); + } +} diff --git a/src/AcDream.Content/UploadFormats.cs b/src/AcDream.Content/UploadFormats.cs new file mode 100644 index 00000000..b0f63612 --- /dev/null +++ b/src/AcDream.Content/UploadFormats.cs @@ -0,0 +1,34 @@ +namespace AcDream.Content; + +// MP1a follow-up (2026-07-05): Content-owned upload-format hint enums. +// AcDream.Content must stay Silk.NET-free (the MP1b bake tool must not ship +// GL binaries), so the moved MeshBatchData/TextureBatchData records carry +// these instead of Silk.NET.OpenGL.PixelFormat/PixelType. The underlying +// values are the OpenGL ABI constants, kept numerically identical to the +// corresponding Silk.NET.OpenGL members (verified against Silk.NET.OpenGL +// 2.23.0) so the App-boundary cast +// `(Silk.NET.OpenGL.PixelFormat?)batch.UploadPixelFormat` is +// value-preserving. GL enum constants are a stable specification ABI — +// they cannot drift between Silk.NET versions. +// +// Members are ONLY the values the extraction code actually assigns +// (see MeshExtractor.cs). Add new members with their GL constant if a +// future decode path needs them — never renumber. + +/// +/// GL pixel-format upload hint computed at extraction time. +/// Numeric values = OpenGL GL_* constants (= Silk.NET.OpenGL.PixelFormat). +/// +public enum UploadPixelFormat { + /// GL_RGBA. + Rgba = 0x1908, +} + +/// +/// GL pixel-type upload hint computed at extraction time. +/// Numeric values = OpenGL GL_* constants (= Silk.NET.OpenGL.PixelType). +/// +public enum UploadPixelType { + /// GL_UNSIGNED_BYTE. + UnsignedByte = 0x1401, +} diff --git a/src/AcDream.Core.Net/Messages/CreateObject.cs b/src/AcDream.Core.Net/Messages/CreateObject.cs index 5d397542..408b76a4 100644 --- a/src/AcDream.Core.Net/Messages/CreateObject.cs +++ b/src/AcDream.Core.Net/Messages/CreateObject.cs @@ -119,6 +119,9 @@ public static class CreateObject ushort TeleportSequence = 0, ushort ServerControlSequence = 0, ushort ForcePositionSequence = 0, + // L.2g S1 (DEV-6): ObjectMovement stamp (timestamp block index 1) + // seeds MotionSequenceGate's MOVEMENT_TS at spawn. + ushort MovementSequence = 0, uint? PhysicsState = null, uint? ObjectDescriptionFlags = null, // L.3b (2026-04-30): per-object friction + elasticity from the @@ -215,6 +218,21 @@ public static class CreateObject /// 0x40=TurnSpeed. /// /// + /// + /// R4-V3 deliverable D — the trailing f32 runRate on MoveToObject + /// (6) / MoveToPosition (7) payloads. Retail's unpack_movement + /// writes this straight onto CMotionInterp::my_run_rate + /// (r4-moveto-decomp.md §2f: this->motion_interpreter->my_run_rate = + /// read_float(), both @300603 case 6 and @300660 case 7 — SAME + /// write for both types, immediately after UnPackNet). Today this + /// field only seeds PlanMoveToStart's local heuristic (plan M13); + /// the interp's actual + /// field is a SEPARATE consumer write the V4/V5 MoveToManager cutover + /// performs at the GameWindow mt 6-9 routing site (r4-port-plan.md §4, + /// step 2: Motion.MyRunRate = MoveToRunRate) — this record is + /// wire-primitive only; it does not write MotionInterpreter state + /// itself. + /// public readonly record struct ServerMotionState( ushort Stance, ushort? ForwardCommand, @@ -228,7 +246,30 @@ public static class CreateObject uint? MoveToParameters = null, float? MoveToSpeed = null, float? MoveToRunRate = null, - MoveToPathData? MoveToPath = null) + MoveToPathData? MoveToPath = null, + // R4-V3 (closes M7): movement types 8 (TurnToObject) and 9 + // (TurnToHeading) — previously dropped end-to-end (UpdateMotion.cs + // only branched on `movementType is 6 or 7`). Carries the DECODED + // wire payload (guid + standalone wire_heading for type 8, plus the + // shared 3-dword UnPackNet triple for both types) per V0-pins.md P6. + TurnToPathData? TurnToPath = null, + // R4-V3 (closes M14-wire-note): the 0xF74C motionFlags sticky-guid + // trailer, mt=0 (Invalid) only — ACE MovementInvalid.Write gates the + // trailing guid on MotionFlags.StickToObject (0x1); the decomp's + // `unpack_movement` case 0 reads it right after + // InterpretedMotionState::UnPack (r4-moveto-decomp.md §2f + // @0052455d: `if (header & 0x100) sticky_object_guid = read_dword()` + // — bit 0x100 of the combined header word is motionFlags byte1&0x1). + // R5-V4 consumes it: the GameWindow mt-0 tail routes it into + // CPhysicsObj::stick_to_object's port (target PartArray radii → + // PositionManager.StickTo — decomp 0x005127e0, call @00524589). + uint? StickyObjectGuid = null, + // R5-V4 (closes the "documented but NOT consumed" note in + // UpdateMotion.cs): motionFlags & 0x2 — retail `unpack_movement` + // case 0 writes it onto `motion_interpreter->standing_longjump` + // UNCONDITIONALLY (@0052458e: absent flag CLEARS it). Consumed at + // the GameWindow mt-0 tails (remote + player). + bool StandingLongJump = false) { /// /// ACE/retail movement types 6 and 7 are server-controlled @@ -238,6 +279,13 @@ public static class CreateObject /// public bool IsServerControlledMoveTo => MovementType is 6 or 7; + /// + /// R4-V3: movement types 8 (TurnToObject) and 9 (TurnToHeading) — + /// the turn-only sibling of . + /// Neither carries an InterpretedMotionState.ForwardCommand either. + /// + public bool IsServerControlledTurnTo => MovementType is 8 or 9; + public bool MoveToCanRun => !MoveToParameters.HasValue || (MoveToParameters.Value & 0x2u) != 0; @@ -297,6 +345,51 @@ public static class CreateObject float MinDistance, float FailDistance, float WalkRunThreshold, + float DesiredHeading, + uint Bitfield = 0); // R4-V4: the raw UnPackNet flags dword, feeds MovementParameters.FromWire + + /// + /// R4-V3 (closes M7) — path-control payload of a server-controlled + /// TurnTo packet (movementType 8 TurnToObject or 9 TurnToHeading). + /// Sibling of : kept as a SEPARATE record + /// rather than widening MoveToPathData in place, because the two + /// wire forms genuinely diverge (7-dword UnPackNet with an + /// Origin+optional-guid head for move types vs. the 3-dword + /// UnPackNet with a guid+standalone-heading head for turn types — + /// V0-pins.md P6) and a single record would need every move-only field + /// nullable for turn payloads (and vice versa) for no reader benefit — + /// no code path ever needs "either a move or a turn path" polymorphically, + /// every consumer already switches on + /// first. + /// + /// + /// type 8 (TurnToObject) only: u32 TargetGuid, f32 + /// WireHeading — the STANDALONE heading field (ACE + /// TurnToObject.DesiredHeading, distinct from + /// below despite ACE always populating + /// both from the same source; V0-pins.md P6's fixture caveat: never + /// distinguish the two fields by value in a test, only by + /// OFFSET). Consumed ONLY in retail's unresolvable-object fallback + /// (decomp §2f case 8: if (GetObjectA(object_id) == 0) { + /// params.desired_heading = wire_heading; goto TurnToHeading; }) + /// — the resolved-object path never reads it. + /// TurnToParameters (0xc bytes, exact retail order — + /// MovementParameters::UnPackNet 3-dword TurnTo form, decomp + /// §2g): u32 Bitfield, f32 Speed, f32 + /// DesiredHeading. Present for BOTH type 8 and type 9 (type 9 + /// has no guid/WireHeading head — and + /// are null). + /// + /// + /// Feeds + /// at the (future) App-layer consumer — this record stays wire-primitive + /// (no domain-object construction in the Net-layer parser). + /// + public readonly record struct TurnToPathData( + uint? TargetGuid, + float? WireHeading, + uint Bitfield, + float Speed, float DesiredHeading); /// @@ -532,11 +625,13 @@ public static class CreateObject if ((physicsFlags & PhysicsDescriptionFlag.DefaultScriptIntensity) != 0) pos += 4; // 9 sequence timestamps, always present at end of PhysicsData. - // Indices per holtburger: 0=position, 4=teleport, 5=serverControl, - // 6=forcePosition, 8=instance. + // PhysicsTimeStamp enum order (acclient.h:6084; ACE + // WorldObject_Networking.cs:411-420): 0=position, 1=movement, + // 4=teleport, 5=serverControl, 6=forcePosition, 8=instance. if (body.Length - pos < 9 * 2) return PartialResult(); var seqSpan = body.Slice(pos, 9 * 2); ushort instanceSeq = BinaryPrimitives.ReadUInt16LittleEndian(seqSpan.Slice(8 * 2)); + ushort movementSeq = BinaryPrimitives.ReadUInt16LittleEndian(seqSpan.Slice(1 * 2)); ushort teleportSeq = BinaryPrimitives.ReadUInt16LittleEndian(seqSpan.Slice(4 * 2)); ushort serverControlSeq = BinaryPrimitives.ReadUInt16LittleEndian(seqSpan.Slice(5 * 2)); ushort forcePositionSeq = BinaryPrimitives.ReadUInt16LittleEndian(seqSpan.Slice(6 * 2)); @@ -849,6 +944,7 @@ public static class CreateObject return new Parsed(guid, position, setupTableId, animParts, textureChanges, subPalettes, basePaletteId, objScale, name, itemType, motionState, motionTableId, instanceSeq, teleportSeq, serverControlSeq, forcePositionSeq, + movementSeq, physicsState, objectDescriptionFlags, friction, elasticity, IconId: iconId, diff --git a/src/AcDream.Core.Net/Messages/JumpAction.cs b/src/AcDream.Core.Net/Messages/JumpAction.cs index d5bc6d74..8740a759 100644 --- a/src/AcDream.Core.Net/Messages/JumpAction.cs +++ b/src/AcDream.Core.Net/Messages/JumpAction.cs @@ -9,18 +9,27 @@ namespace AcDream.Core.Net.Messages; /// the extent + velocity to validate the jump and replicate it to nearby /// clients. /// -/// Wire layout (from holtburger JumpActionData::pack): -/// u32 0xF7B1 (GameAction envelope) -/// u32 sequence -/// u32 0xF61B (Jump sub-opcode) -/// f32 extent (0.0–1.0 charge power) -/// f32 velocity.x, f32 velocity.y, f32 velocity.z -/// u16 instanceSequence -/// u16 serverControlSequence -/// u16 teleportSequence -/// u16 forcePositionSequence -/// u32 objectGuid (0 for normal jump) -/// u32 spellId (0 for normal jump) +/// +/// Wire layout — ports retail's JumpPack::Pack verbatim +/// (0x00516d10, decomp lines ~284934-284963). Confirmed against the +/// Ghidra decompile-by-address bridge during this slice (2026-06-30): +/// +/// +/// GameAction envelope: u32 0xF7B1, u32 sequence, u32 0xF61B +/// f32 extent (0.0-1.0 charge power) +/// f32 velocity.x, velocity.y, velocity.z +/// Position::Pack: u32 cellId, f32 x, f32 y, f32 z, +/// f32 qw, f32 qx, f32 qy, f32 qz (32 bytes) +/// Sequences: u16 instance, u16 serverControl, +/// u16 teleport, u16 forcePosition +/// Align to 4 bytes +/// +/// +/// +/// D4 fix. Retail's JumpPack does NOT pack an objectGuid or a +/// spellId, and DOES pack the full Position — the pre-slice code had +/// it backwards (two spurious trailing zero u32s, no Position at all). +/// /// public static class JumpAction { @@ -28,29 +37,45 @@ public static class JumpAction public const uint JumpOpcode = 0xF61Bu; public static byte[] Build( - uint gameActionSequence, - float extent, - Vector3 velocity, - ushort instanceSequence, - ushort serverControlSequence, - ushort teleportSequence, - ushort forcePositionSequence) + uint gameActionSequence, + float extent, + Vector3 velocity, + uint cellId, + Vector3 position, + Quaternion rotation, + ushort instanceSequence, + ushort serverControlSequence, + ushort teleportSequence, + ushort forcePositionSequence) { - var w = new PacketWriter(48); + var w = new PacketWriter(80); w.WriteUInt32(GameActionOpcode); w.WriteUInt32(gameActionSequence); w.WriteUInt32(JumpOpcode); + w.WriteFloat(extent); w.WriteFloat(velocity.X); w.WriteFloat(velocity.Y); w.WriteFloat(velocity.Z); + + // --- Position::Pack (0x005a9640): cellId + Frame::Pack (32 bytes) --- + w.WriteUInt32(cellId); + w.WriteFloat(position.X); + w.WriteFloat(position.Y); + w.WriteFloat(position.Z); + // Quaternion wire order: W, X, Y, Z + w.WriteFloat(rotation.W); + w.WriteFloat(rotation.X); + w.WriteFloat(rotation.Y); + w.WriteFloat(rotation.Z); + w.WriteUInt16(instanceSequence); w.WriteUInt16(serverControlSequence); w.WriteUInt16(teleportSequence); w.WriteUInt16(forcePositionSequence); - w.WriteUInt32(0); // objectGuid — 0 for normal jump - w.WriteUInt32(0); // spellId — 0 for normal jump + + w.AlignTo4(); return w.ToArray(); } diff --git a/src/AcDream.Core.Net/Messages/MoveToState.cs b/src/AcDream.Core.Net/Messages/MoveToState.cs index 08356961..e705d79b 100644 --- a/src/AcDream.Core.Net/Messages/MoveToState.cs +++ b/src/AcDream.Core.Net/Messages/MoveToState.cs @@ -1,5 +1,6 @@ using System.Numerics; using AcDream.Core.Net.Packets; +using AcDream.Core.Physics; namespace AcDream.Core.Net.Messages; @@ -11,61 +12,39 @@ namespace AcDream.Core.Net.Messages; /// state and to drive interpolated position for other nearby clients. /// /// -/// Wire layout (ported from -/// references/holtburger/crates/holtburger-protocol/src/messages/movement/actions.rs -/// MoveToStateActionData::pack and -/// types.rs RawMotionState::pack): +/// Wire layout — ports retail's MoveToStatePack::Pack verbatim +/// (0x005168f0, decomp lines ~284694-284722). Confirmed against the +/// Ghidra decompile-by-address bridge during this slice (2026-06-30): /// /// /// GameAction envelope: u32 0xF7B1, u32 sequence, u32 0xF61C -/// RawMotionState: u32 packed_flags (bits 0-10 = flag bits, -/// bits 11-31 = command list length), then conditional u32/f32 fields -/// in flag-bit order (see RawMotionFlags in types.rs) -/// WorldPosition: u32 cellId, f32 x, f32 y, f32 z, -/// f32 rotW, f32 rotX, f32 rotY, f32 rotZ +/// RawMotionState::Pack: see +/// — default-difference flags dword + conditional fields + actions. +/// Position::Pack: u32 cellId, f32 x, f32 y, f32 z, +/// f32 qw, f32 qx, f32 qy, f32 qz (32 bytes) /// Sequences: u16 instance, u16 serverControl, /// u16 teleport, u16 forcePosition -/// Contact byte: u8 (1 = on ground, 0 = airborne) +/// Trailing byte: (standingLongjump ? 0x02 : 0) | +/// (contact ? 0x01 : 0) — MoveToStatePack::Pack trailing +/// byte expression (longjump_mode == 0) - 1U & 2 | +/// contact != 0. /// Align to 4 bytes /// -/// -/// -/// The command list length is packed into bits 11-31 of the flags dword. -/// We always send 0 commands (no discrete motion events), so those bits stay 0. -/// /// public static class MoveToState { public const uint GameActionOpcode = 0xF7B1u; public const uint MoveToStateAction = 0xF61Cu; - // RawMotionFlags bit positions (from holtburger types.rs) - private const uint FlagCurrentHoldKey = 0x001u; - private const uint FlagCurrentStyle = 0x002u; - private const uint FlagForwardCommand = 0x004u; - private const uint FlagForwardHoldKey = 0x008u; - private const uint FlagForwardSpeed = 0x010u; - private const uint FlagSidestepCommand = 0x020u; - private const uint FlagSidestepHoldKey = 0x040u; - private const uint FlagSidestepSpeed = 0x080u; - private const uint FlagTurnCommand = 0x100u; - private const uint FlagTurnHoldKey = 0x200u; - private const uint FlagTurnSpeed = 0x400u; - /// /// Build a MoveToState GameAction body. /// /// Monotonically increasing counter from /// . - /// Raw motion command (u32 in AC's command space), - /// e.g. 0x45000005 = WalkForward. Null = no forward command. - /// Normalised speed scalar (0.0-1.0). Only written - /// when is non-null. - /// Sidestep command or null. - /// Sidestep speed or null. - /// Turn command or null. - /// Turn speed or null. - /// Hold-key state (1=None, 2=Run). Null = omit. + /// Complete raw-motion snapshot, matching + /// retail's CPhysicsObj::InqRawMotionState(). Fields equal to + /// are omitted from the wire + /// (see ). /// Landblock cell ID (u32). /// World-space position relative to the landblock. /// Rotation quaternion. AC wire order is W, X, Y, Z. @@ -73,27 +52,22 @@ public static class MoveToState /// Server-control sequence number. /// Teleport sequence number. /// Force-position sequence number. - /// 1 if the character is on the ground, 0 if airborne. + /// True if the character is on the ground. + /// True during a standing (charged, + /// stationary) longjump wind-up. Not yet implemented in acdream — + /// callers pass false honestly until that feature lands. public static byte[] Build( - uint gameActionSequence, - uint? forwardCommand, - float? forwardSpeed, - uint? sidestepCommand, - float? sidestepSpeed, - uint? turnCommand, - float? turnSpeed, - uint? holdKey, - uint cellId, - Vector3 position, - Quaternion rotation, - ushort instanceSequence, - ushort serverControlSequence, - ushort teleportSequence, - ushort forcePositionSequence, - byte contactLongJump = 1, - uint? forwardHoldKey = null, - uint? sidestepHoldKey = null, - uint? turnHoldKey = null) + uint gameActionSequence, + RawMotionState rawMotionState, + uint cellId, + Vector3 position, + Quaternion rotation, + ushort instanceSequence, + ushort serverControlSequence, + ushort teleportSequence, + ushort forcePositionSequence, + bool contact = true, + bool standingLongjump = false) { var w = new PacketWriter(128); @@ -102,43 +76,10 @@ public static class MoveToState w.WriteUInt32(gameActionSequence); w.WriteUInt32(MoveToStateAction); - // --- RawMotionState --- - // Build the flags word. Command list length (bits 11-31) is always 0. - // Field order matches holtburger's RawMotionState::pack — for any axis - // where we send a COMMAND + SPEED, retail expects the matching - // *_HOLD_KEY to accompany them (see holtburger's - // build_motion_state_raw_motion_state). Without the per-axis hold - // keys the server gets the flags but can't classify the input as a - // continuously-held key, so other players see the character sliding - // forward without an animation cycle. - uint flags = 0u; - if (holdKey.HasValue) flags |= FlagCurrentHoldKey; - if (forwardCommand.HasValue) flags |= FlagForwardCommand; - if (forwardHoldKey.HasValue) flags |= FlagForwardHoldKey; - if (forwardSpeed.HasValue) flags |= FlagForwardSpeed; - if (sidestepCommand.HasValue) flags |= FlagSidestepCommand; - if (sidestepHoldKey.HasValue) flags |= FlagSidestepHoldKey; - if (sidestepSpeed.HasValue) flags |= FlagSidestepSpeed; - if (turnCommand.HasValue) flags |= FlagTurnCommand; - if (turnHoldKey.HasValue) flags |= FlagTurnHoldKey; - if (turnSpeed.HasValue) flags |= FlagTurnSpeed; + // --- RawMotionState::Pack (0x0051ed10) --- + RawMotionStatePacker.Pack(w, rawMotionState); - w.WriteUInt32(flags); // bits 0-10 = flags, bits 11-31 = 0 (no command list) - - // Conditional fields in RawMotionFlags bit order: - if (holdKey.HasValue) w.WriteUInt32(holdKey.Value); - // FlagCurrentStyle (0x2): not sent — we don't track stance changes here - if (forwardCommand.HasValue) w.WriteUInt32(forwardCommand.Value); - if (forwardHoldKey.HasValue) w.WriteUInt32(forwardHoldKey.Value); - if (forwardSpeed.HasValue) w.WriteFloat(forwardSpeed.Value); - if (sidestepCommand.HasValue) w.WriteUInt32(sidestepCommand.Value); - if (sidestepHoldKey.HasValue) w.WriteUInt32(sidestepHoldKey.Value); - if (sidestepSpeed.HasValue) w.WriteFloat(sidestepSpeed.Value); - if (turnCommand.HasValue) w.WriteUInt32(turnCommand.Value); - if (turnHoldKey.HasValue) w.WriteUInt32(turnHoldKey.Value); - if (turnSpeed.HasValue) w.WriteFloat(turnSpeed.Value); - - // --- WorldPosition (32 bytes) --- + // --- Position::Pack (0x005a9640): cellId + Frame::Pack (32 bytes) --- w.WriteUInt32(cellId); w.WriteFloat(position.X); w.WriteFloat(position.Y); @@ -155,8 +96,10 @@ public static class MoveToState w.WriteUInt16(teleportSequence); w.WriteUInt16(forcePositionSequence); - // --- Contact byte + 4-byte align --- - w.WriteByte(contactLongJump); + // --- Trailing byte (MoveToStatePack::Pack, 0x005168f0): --- + // ((longjump_mode != 0) ? 0x02 : 0) | (contact != 0 ? 0x01 : 0) + byte trailing = (byte)((standingLongjump ? 0x02 : 0) | (contact ? 0x01 : 0)); + w.WriteByte(trailing); w.AlignTo4(); return w.ToArray(); diff --git a/src/AcDream.Core.Net/Messages/RawMotionStatePacker.cs b/src/AcDream.Core.Net/Messages/RawMotionStatePacker.cs new file mode 100644 index 00000000..bf73a84e --- /dev/null +++ b/src/AcDream.Core.Net/Messages/RawMotionStatePacker.cs @@ -0,0 +1,98 @@ +using AcDream.Core.Net.Packets; +using AcDream.Core.Physics; + +namespace AcDream.Core.Net.Messages; + +/// +/// Ports retail's RawMotionState::Pack verbatim +/// (0x0051ed10, decomp lines ~293761-294013; bitfield layout +/// acclient.h RawMotionState::PackBitfield, line 46474). Confirmed +/// against the Ghidra decompile-by-address bridge during this slice +/// (2026-06-30). +/// +/// +/// D1 fix. Retail does NOT set a field's bit merely because the +/// caller supplied a value — it compares every field against its retail +/// DEFAULT () and sets the bit (and +/// emits the field) only when the live value DIFFERS. This packer mirrors +/// that default-difference comparison exactly, field by field, in bit +/// order. +/// +/// +/// +/// Flags dword layout (bits 0-15 only; bits 16-31 are unused — retail's +/// num_actions is a 5-bit field occupying bits 11-15, not "the rest +/// of the dword"): +/// +/// +/// 0x001current_holdkey != HoldKey.None +/// 0x002current_style != 0x8000003D +/// 0x004forward_command != 0x41000003 +/// 0x008forward_holdkey != HoldKey.Invalid +/// 0x010forward_speed != 1.0f +/// 0x020sidestep_command != 0 +/// 0x040sidestep_holdkey != HoldKey.Invalid +/// 0x080sidestep_speed != 1.0f +/// 0x100turn_command != 0 +/// 0x200turn_holdkey != HoldKey.Invalid +/// 0x400turn_speed != 1.0f +/// 0xF800num_actions (bits 11-15, count not values) +/// +/// +public static class RawMotionStatePacker +{ + private const uint FlagCurrentHoldKey = 0x001u; + private const uint FlagCurrentStyle = 0x002u; + private const uint FlagForwardCommand = 0x004u; + private const uint FlagForwardHoldKey = 0x008u; + private const uint FlagForwardSpeed = 0x010u; + private const uint FlagSidestepCommand = 0x020u; + private const uint FlagSidestepHoldKey = 0x040u; + private const uint FlagSidestepSpeed = 0x080u; + private const uint FlagTurnCommand = 0x100u; + private const uint FlagTurnHoldKey = 0x200u; + private const uint FlagTurnSpeed = 0x400u; + private const int NumActionsShift = 11; + + public static void Pack(PacketWriter w, RawMotionState state) + { + var defaults = RawMotionState.Default; + + uint flags = 0u; + if (state.CurrentHoldKey != defaults.CurrentHoldKey) flags |= FlagCurrentHoldKey; + if (state.CurrentStyle != defaults.CurrentStyle) flags |= FlagCurrentStyle; + if (state.ForwardCommand != defaults.ForwardCommand) flags |= FlagForwardCommand; + if (state.ForwardHoldKey != defaults.ForwardHoldKey) flags |= FlagForwardHoldKey; + if (state.ForwardSpeed != defaults.ForwardSpeed) flags |= FlagForwardSpeed; + if (state.SidestepCommand != defaults.SidestepCommand) flags |= FlagSidestepCommand; + if (state.SidestepHoldKey != defaults.SidestepHoldKey) flags |= FlagSidestepHoldKey; + if (state.SidestepSpeed != defaults.SidestepSpeed) flags |= FlagSidestepSpeed; + if (state.TurnCommand != defaults.TurnCommand) flags |= FlagTurnCommand; + if (state.TurnHoldKey != defaults.TurnHoldKey) flags |= FlagTurnHoldKey; + if (state.TurnSpeed != defaults.TurnSpeed) flags |= FlagTurnSpeed; + + int numActions = state.Actions.Count; + flags |= (uint)(numActions << NumActionsShift); + + w.WriteUInt32(flags); + + if ((flags & FlagCurrentHoldKey) != 0) w.WriteUInt32((uint)state.CurrentHoldKey); + if ((flags & FlagCurrentStyle) != 0) w.WriteUInt32(state.CurrentStyle); + if ((flags & FlagForwardCommand) != 0) w.WriteUInt32(state.ForwardCommand); + if ((flags & FlagForwardHoldKey) != 0) w.WriteUInt32((uint)state.ForwardHoldKey); + if ((flags & FlagForwardSpeed) != 0) w.WriteFloat(state.ForwardSpeed); + if ((flags & FlagSidestepCommand) != 0) w.WriteUInt32(state.SidestepCommand); + if ((flags & FlagSidestepHoldKey) != 0) w.WriteUInt32((uint)state.SidestepHoldKey); + if ((flags & FlagSidestepSpeed) != 0) w.WriteFloat(state.SidestepSpeed); + if ((flags & FlagTurnCommand) != 0) w.WriteUInt32(state.TurnCommand); + if ((flags & FlagTurnHoldKey) != 0) w.WriteUInt32((uint)state.TurnHoldKey); + if ((flags & FlagTurnSpeed) != 0) w.WriteFloat(state.TurnSpeed); + + foreach (var action in state.Actions) + { + w.WriteUInt16(action.Command); + ushort stampWord = (ushort)((action.Stamp & 0x7FFF) | (action.Autonomous ? 0x8000 : 0)); + w.WriteUInt16(stampWord); + } + } +} diff --git a/src/AcDream.Core.Net/Messages/UpdateMotion.cs b/src/AcDream.Core.Net/Messages/UpdateMotion.cs index 87562815..2049bdbc 100644 --- a/src/AcDream.Core.Net/Messages/UpdateMotion.cs +++ b/src/AcDream.Core.Net/Messages/UpdateMotion.cs @@ -34,7 +34,20 @@ namespace AcDream.Core.Net.Messages; /// u32 flagsAndCommandCount, then each present field in flag order /// (CurrentStyle u16, ForwardCommand u16, SidestepCommand u16, /// TurnCommand u16, forward speed f32, sidestep speed f32, -/// turn speed f32), commands list, align. +/// turn speed f32), commands list, align; THEN — only when +/// motionFlags & 0x1 (StickToObject) — one trailing u32 +/// sticky object guid (ACE MovementInvalid.Write; R4-V3). +/// MoveToObject (6) / MoveToPosition (7): [u32 target guid, +/// MoveToObject only] Origin (u32 cell + 3×f32), MoveToParameters / +/// UnPackNet 7-dword form (u32 bitfield + 6×f32), f32 +/// runRate. R4-V3: exposed via +/// . +/// TurnToObject (8) / TurnToHeading (9): [u32 target guid, f32 +/// standalone wire heading, TurnToObject only] TurnToParameters / +/// UnPackNet 3-dword form (u32 bitfield, f32 speed, f32 +/// desired heading). R4-V3 (closes M7): exposed via +/// +/// — previously dropped end-to-end. /// /// /// @@ -57,10 +70,21 @@ public static class UpdateMotion /// command is nullable because the ForwardCommand flag may be /// unset in the InterpretedMotionState; the stance is always present /// (even if 0, meaning "no specific stance"). + /// + /// L.2g S1 (DEV-6): the three staleness stamps + autonomy flag are + /// exposed for the retail gate ( + /// MotionSequenceGate) — retail compares them against + /// update_times[INSTANCE_TS/MOVEMENT_TS/SERVER_CONTROLLED_MOVE_TS] + /// and stores last_move_was_autonomous + /// (CPhysics::SetObjectMovement 0x00509690). /// public readonly record struct Parsed( uint Guid, - CreateObject.ServerMotionState MotionState); + CreateObject.ServerMotionState MotionState, + ushort InstanceSequence, + ushort MovementSequence, + ushort ServerControlSequence, + bool IsAutonomous); /// /// Parse a reassembled UpdateMotion body. must @@ -82,8 +106,11 @@ public static class UpdateMotion uint guid = BinaryPrimitives.ReadUInt32LittleEndian(body.Slice(pos)); pos += 4; - // ObjectInstance sequence (u16) — tracked but not used for pose. + // ObjectInstance sequence (u16) — retail's dispatch-level + // INSTANCE_TS staleness gate compares this against the object's + // known incarnation (DispatchSmartBoxEvent case 0xF74C). if (body.Length - pos < 2) return null; + ushort instanceSequence = BinaryPrimitives.ReadUInt16LittleEndian(body.Slice(pos)); pos += 2; // MovementData header: u16 movementSequence, u16 serverControlSequence, @@ -102,13 +129,34 @@ public static class UpdateMotion // Previous version mistakenly reserved 8 bytes here, which shifted // every subsequent field by 2 and made every remote-char UpdateMotion // decode as garbage (stance read from the packed-flags dword). + // + // L.2g S1 (DEV-6): the header fields feed retail's + // CPhysics::SetObjectMovement staleness gates + the + // last_move_was_autonomous store, so parse them instead of + // skipping. if (body.Length - pos < 6) return null; - pos += 6; + ushort movementSequence = BinaryPrimitives.ReadUInt16LittleEndian(body.Slice(pos)); + pos += 2; + ushort serverControlSequence = BinaryPrimitives.ReadUInt16LittleEndian(body.Slice(pos)); + pos += 2; + bool isAutonomous = body[pos] != 0; + pos += 2; // u8 isAutonomous + Align(4) pad byte // movementType u8, motionFlags u8, currentStyle u16 if (body.Length - pos < 4) return null; byte movementType = body[pos]; pos += 1; - byte _motionFlags = body[pos]; pos += 1; + // MotionFlags (ACE ACE.Entity.Enum.MotionFlags, byte): + // 0x1 = StickToObject, 0x2 = StandingLongJump. + // R4-V3 (closes M14-wire-note): previously discarded as + // `_motionFlags`. StickToObject now drives the sticky-guid + // trailer parse below (mt=0 only, per ACE MovementInvalid.Write + // + decomp §2f case 0 @0052455d). StandingLongJump (0x2) is + // carried on ServerMotionState.StandingLongJump (R5-V4) and + // consumed at the GameWindow mt-0 tails — retail's + // `unpack_movement` case 0 writes it onto + // `motion_interpreter->standing_longjump` (§2f @0052458e, + // UNCONDITIONAL — an absent flag clears it). + byte motionFlags = body[pos]; pos += 1; ushort currentStyle = BinaryPrimitives.ReadUInt16LittleEndian(body.Slice(pos)); pos += 2; @@ -118,7 +166,7 @@ public static class UpdateMotion var hex = new System.Text.StringBuilder(); for (int i = 0; i < preHex; i++) hex.Append($"{body[i]:X2} "); System.Console.WriteLine( - $" UM raw: mt=0x{movementType:X2} mf=0x{_motionFlags:X2} cs=0x{currentStyle:X4} | {hex}"); + $" UM raw: mt=0x{movementType:X2} mf=0x{motionFlags:X2} cs=0x{currentStyle:X4} | {hex}"); } ushort? forwardCommand = null; @@ -131,6 +179,8 @@ public static class UpdateMotion float? moveToSpeed = null; float? moveToRunRate = null; CreateObject.MoveToPathData? moveToPath = null; + CreateObject.TurnToPathData? turnToPath = null; + uint? stickyObjectGuid = null; List? commands = null; if (movementType == 0) @@ -139,7 +189,7 @@ public static class UpdateMotion // MovementInvalid branch, just reached via the header'd path. // Includes the Commands list (MotionItem[]) that carries // Actions, emotes, and other one-shots not in ForwardCommand. - if (body.Length - pos < 4) return new Parsed(guid, new CreateObject.ServerMotionState(currentStyle, null, MovementType: movementType)); + if (body.Length - pos < 4) return new Parsed(guid, new CreateObject.ServerMotionState(currentStyle, null, MovementType: movementType), instanceSequence, movementSequence, serverControlSequence, isAutonomous); uint packed = BinaryPrimitives.ReadUInt32LittleEndian(body.Slice(pos)); pos += 4; uint flags = packed & 0x7Fu; @@ -162,13 +212,13 @@ public static class UpdateMotion if ((flags & 0x1u) != 0) { - if (body.Length - pos < 2) return new Parsed(guid, new CreateObject.ServerMotionState(currentStyle, null, MovementType: movementType)); + if (body.Length - pos < 2) return new Parsed(guid, new CreateObject.ServerMotionState(currentStyle, null, MovementType: movementType), instanceSequence, movementSequence, serverControlSequence, isAutonomous); currentStyle = BinaryPrimitives.ReadUInt16LittleEndian(body.Slice(pos)); pos += 2; } if ((flags & 0x2u) != 0) { - if (body.Length - pos < 2) return new Parsed(guid, new CreateObject.ServerMotionState(currentStyle, null, MovementType: movementType)); + if (body.Length - pos < 2) return new Parsed(guid, new CreateObject.ServerMotionState(currentStyle, null, MovementType: movementType), instanceSequence, movementSequence, serverControlSequence, isAutonomous); forwardCommand = BinaryPrimitives.ReadUInt16LittleEndian(body.Slice(pos)); pos += 2; } @@ -223,6 +273,23 @@ public static class UpdateMotion commands.Add(new CreateObject.MotionItem(cmd, seq, speed)); } } + + // R4-V3 (closes M14-wire-note): the sticky-guid trailer. + // ACE MovementInvalid.Write (Motion/MovementInvalid.cs:41-47) + // writes the InterpretedMotionState FIRST (everything above, + // including the Commands list), THEN — only when + // MotionFlags.StickToObject (0x1) is set — one trailing u32 + // guid. Decomp confirms the same order (§2f case 0: + // InterpretedMotionState::UnPack, then + // `if (header & 0x100) sticky_object_guid = read_dword()`). + // Parsed here purely to keep the cursor honest past this + // field; R5's PositionManager::StickTo body is the eventual + // consumer (M14 — "seam now, body R5"). + if ((motionFlags & 0x1) != 0 && body.Length - pos >= 4) + { + stickyObjectGuid = BinaryPrimitives.ReadUInt32LittleEndian(body.Slice(pos)); + pos += 4; + } done:; } else if (movementType is 6 or 7) @@ -236,6 +303,14 @@ public static class UpdateMotion out moveToRunRate, out moveToPath); } + else if (movementType is 8 or 9) + { + TryParseTurnToPayload( + body, + pos, + movementType, + out turnToPath); + } return new Parsed(guid, new CreateObject.ServerMotionState( currentStyle, forwardCommand, forwardSpeed, commands, @@ -244,7 +319,14 @@ public static class UpdateMotion moveToParameters, moveToSpeed, moveToRunRate, - moveToPath)); + moveToPath, + turnToPath, + stickyObjectGuid, + // R5-V4: MotionFlags 0x2 — consumed at the GameWindow mt-0 + // tails (retail unpack_movement @0052458e writes it onto + // minterp->standing_longjump unconditionally). + (motionFlags & 0x2) != 0), + instanceSequence, movementSequence, serverControlSequence, isAutonomous); } catch { @@ -326,6 +408,73 @@ public static class UpdateMotion minDistance, failDistance, walkRunThreshold, + desiredHeading, + movementParameters ?? 0u); // R4-V4: the raw flags dword -> FromWire + return true; + } + + /// + /// R4-V3 (closes M7) — parses movementType 8 (TurnToObject) / 9 + /// (TurnToHeading), byte-for-byte per V0-pins.md P6 (built + confirmed + /// against ACE's own writers: TurnToObjectExtensions.Write, + /// TurnToParametersExtensions.Write, + /// TurnToHeadingExtensions.Write — + /// references/ACE/Source/ACE.Server/Network/Motion/): + /// + /// type 8 (TurnToObject) only: u32 object guid, f32 + /// wire_heading (the STANDALONE heading field — ACE + /// TurnToObject.DesiredHeading, "used instead of the + /// DesiredHeading in the TurnToParameters" per its own field + /// comment). + /// TurnToParameters / MovementParameters::UnPackNet + /// 3-dword TurnTo form (0xc bytes, decomp §2g), present for BOTH + /// types: u32 bitfield, f32 speed, f32 + /// desired_heading. + /// + /// Matches retail's read order exactly (decomp §2f case 8: + /// object_id = read_dword(); wire_heading = read_dword(); + /// UnPackNet(...)). The unresolvable-object fallback (substitute + /// wire_heading into params.desired_heading, degrade to + /// TurnToHeading) is a CONSUMER decision (needs a live object-id + /// resolution the wire parser has no visibility into) — this method + /// only exposes both heading fields distinctly so that fallback can be + /// implemented at the call site (V4/V5, GameWindow routing per + /// r4-port-plan.md §4). + /// + private static bool TryParseTurnToPayload( + ReadOnlySpan body, + int pos, + byte movementType, + out CreateObject.TurnToPathData? path) + { + path = null; + + uint? targetGuid = null; + float? wireHeading = null; + if (movementType == 8) + { + if (body.Length - pos < 8) return false; + targetGuid = BinaryPrimitives.ReadUInt32LittleEndian(body.Slice(pos)); + pos += 4; + wireHeading = BinaryPrimitives.ReadSingleLittleEndian(body.Slice(pos)); + pos += 4; + } + + // TurnToParameters / UnPackNet 3-dword TurnTo form (0xc bytes): + // bitfield, speed, desired_heading. + if (body.Length - pos < 12) return false; + + uint bitfield = BinaryPrimitives.ReadUInt32LittleEndian(body.Slice(pos)); + pos += 4; + float speed = BinaryPrimitives.ReadSingleLittleEndian(body.Slice(pos)); + pos += 4; + float desiredHeading = BinaryPrimitives.ReadSingleLittleEndian(body.Slice(pos)); + + path = new CreateObject.TurnToPathData( + targetGuid, + wireHeading, + bitfield, + speed, desiredHeading); return true; } diff --git a/src/AcDream.Core.Net/WorldSession.cs b/src/AcDream.Core.Net/WorldSession.cs index b1b65cb9..2e05f9ea 100644 --- a/src/AcDream.Core.Net/WorldSession.cs +++ b/src/AcDream.Core.Net/WorldSession.cs @@ -110,7 +110,13 @@ public sealed class WorldSession : IDisposable uint? Priority = null, int? Structure = null, int? MaxStructure = null, - float? Workmanship = null); + float? Workmanship = null, + // L.2g S1 (DEV-6): PhysicsDesc timestamp-block stamps that seed the + // per-entity MotionSequenceGate (retail update_times INSTANCE_TS / + // MOVEMENT_TS / SERVER_CONTROLLED_MOVE_TS). + ushort InstanceSequence = 0, + ushort MovementSequence = 0, + ushort ServerControlSequence = 0); /// Fires when the session finishes parsing a CreateObject. public event Action? EntitySpawned; @@ -132,7 +138,11 @@ public sealed class WorldSession : IDisposable /// public readonly record struct EntityMotionUpdate( uint Guid, - CreateObject.ServerMotionState MotionState); + CreateObject.ServerMotionState MotionState, + ushort InstanceSequence, + ushort MovementSequence, + ushort ServerControlSequence, + bool IsAutonomous); /// /// Fires when the session parses a 0xF74C UpdateMotion game message. @@ -827,7 +837,10 @@ public sealed class WorldSession : IDisposable parsed.Value.Priority, parsed.Value.Structure, parsed.Value.MaxStructure, - parsed.Value.Workmanship)); + parsed.Value.Workmanship, + InstanceSequence: parsed.Value.InstanceSequence, + MovementSequence: parsed.Value.MovementSequence, + ServerControlSequence: parsed.Value.ServerControlSequence)); } } else if (op == DeleteObject.Opcode) @@ -864,7 +877,11 @@ public sealed class WorldSession : IDisposable { MotionUpdated?.Invoke(new EntityMotionUpdate( motion.Value.Guid, - motion.Value.MotionState)); + motion.Value.MotionState, + motion.Value.InstanceSequence, + motion.Value.MovementSequence, + motion.Value.ServerControlSequence, + motion.Value.IsAutonomous)); } } else if (op == UpdatePosition.Opcode) diff --git a/src/AcDream.Core/Combat/CombatAnimationPlanner.cs b/src/AcDream.Core/Combat/CombatAnimationPlanner.cs index bf67a852..f7b7ca36 100644 --- a/src/AcDream.Core/Combat/CombatAnimationPlanner.cs +++ b/src/AcDream.Core/Combat/CombatAnimationPlanner.cs @@ -1,4 +1,5 @@ using AcDream.Core.Physics; +using Drw = DatReaderWriter.Enums.MotionCommand; namespace AcDream.Core.Combat; @@ -200,109 +201,146 @@ public enum CombatAnimationKind Death, } +/// +/// The full 32-bit retail MotionCommand values the planner classifies, each +/// derived DIRECTLY from (Chorizite.DatReaderWriter — the +/// same enum ACE broadcasts and that the local DAT MotionTables key on) so +/// the values can never drift from the wire again. +/// +/// +/// History (ISSUES #159): these were previously hand-transcribed from the +/// Sept 2013 EoR decomp's command_ids table, which numbers the whole +/// late-combat block (Offhand* / Attack4-6 / Punch*) +/// THREE lower than ACE/DRW — a contiguous low-word "+3" shift that begins +/// around SnowAngelState (0x115). Against a live ACE server those +/// commands silently misclassified: the resolver returned the correct ACE +/// value (e.g. wire 0x0173 -> 0x10000173 OffhandSlashHigh), +/// but the planner's constant held the 2013 value (0x10000170), so no +/// match. Reload was worse — hardcoded 0x100000D4, a value +/// absent from DRW entirely; the real ACE/DRW Reload is the +/// 0x40000016 SubState. Deriving from the enum by name fixes the whole +/// block at once and drops ~80 magic numbers. +/// See docs/research/2026-06-26-ace-vs-2013-motion-command-gap.md. +/// +/// internal static class CombatAnimationMotionCommands { - public const uint HandCombat = 0x8000003Cu; - public const uint SwordCombat = 0x8000003Eu; - public const uint BowCombat = 0x8000003Fu; - public const uint SwordShieldCombat = 0x80000040u; - public const uint CrossbowCombat = 0x80000041u; - public const uint SlingCombat = 0x80000043u; - public const uint TwoHandedSwordCombat = 0x80000044u; - public const uint TwoHandedStaffCombat = 0x80000045u; - public const uint DualWieldCombat = 0x80000046u; - public const uint ThrownWeaponCombat = 0x80000047u; - public const uint Magic = 0x80000049u; - public const uint AtlatlCombat = 0x8000013Bu; - public const uint ThrownShieldCombat = 0x8000013Cu; + // Combat stances (Style class 0x80). Already correct before #159. + public const uint HandCombat = (uint)Drw.HandCombat; + public const uint SwordCombat = (uint)Drw.SwordCombat; + public const uint BowCombat = (uint)Drw.BowCombat; + public const uint SwordShieldCombat = (uint)Drw.SwordShieldCombat; + public const uint CrossbowCombat = (uint)Drw.CrossbowCombat; + public const uint SlingCombat = (uint)Drw.SlingCombat; + public const uint TwoHandedSwordCombat = (uint)Drw.TwoHandedSwordCombat; + public const uint TwoHandedStaffCombat = (uint)Drw.TwoHandedStaffCombat; + public const uint DualWieldCombat = (uint)Drw.DualWieldCombat; + public const uint ThrownWeaponCombat = (uint)Drw.ThrownWeaponCombat; + public const uint Magic = (uint)Drw.Magic; + public const uint AtlatlCombat = (uint)Drw.AtlatlCombat; + public const uint ThrownShieldCombat = (uint)Drw.ThrownShieldCombat; - public const uint FallDown = 0x10000050u; - public const uint Twitch1 = 0x10000051u; - public const uint Twitch2 = 0x10000052u; - public const uint Twitch3 = 0x10000053u; - public const uint Twitch4 = 0x10000054u; - public const uint StaggerBackward = 0x10000055u; - public const uint StaggerForward = 0x10000056u; - public const uint Sanctuary = 0x10000057u; - public const uint ThrustMed = 0x10000058u; - public const uint ThrustLow = 0x10000059u; - public const uint ThrustHigh = 0x1000005Au; - public const uint SlashHigh = 0x1000005Bu; - public const uint SlashMed = 0x1000005Cu; - public const uint SlashLow = 0x1000005Du; - public const uint BackhandHigh = 0x1000005Eu; - public const uint BackhandMed = 0x1000005Fu; - public const uint BackhandLow = 0x10000060u; - public const uint Shoot = 0x10000061u; - public const uint AttackHigh1 = 0x10000062u; - public const uint AttackMed1 = 0x10000063u; - public const uint AttackLow1 = 0x10000064u; - public const uint AttackHigh2 = 0x10000065u; - public const uint AttackMed2 = 0x10000066u; - public const uint AttackLow2 = 0x10000067u; - public const uint AttackHigh3 = 0x10000068u; - public const uint AttackMed3 = 0x10000069u; - public const uint AttackLow3 = 0x1000006Au; + // Hit reactions / staggers (Action class 0x10, unshifted). + public const uint FallDown = (uint)Drw.FallDown; + public const uint Twitch1 = (uint)Drw.Twitch1; + public const uint Twitch2 = (uint)Drw.Twitch2; + public const uint Twitch3 = (uint)Drw.Twitch3; + public const uint Twitch4 = (uint)Drw.Twitch4; + public const uint StaggerBackward = (uint)Drw.StaggerBackward; + public const uint StaggerForward = (uint)Drw.StaggerForward; + public const uint Sanctuary = (uint)Drw.Sanctuary; - public const uint MissileAttack1 = 0x100000D0u; - public const uint MissileAttack2 = 0x100000D1u; - public const uint MissileAttack3 = 0x100000D2u; - public const uint CastSpell = 0x400000D3u; - public const uint Reload = 0x100000D4u; - public const uint UseMagicStaff = 0x400000E0u; - public const uint UseMagicWand = 0x400000E1u; + // Single melee attacks (Action class 0x10, unshifted). + public const uint ThrustMed = (uint)Drw.ThrustMed; + public const uint ThrustLow = (uint)Drw.ThrustLow; + public const uint ThrustHigh = (uint)Drw.ThrustHigh; + public const uint SlashHigh = (uint)Drw.SlashHigh; + public const uint SlashMed = (uint)Drw.SlashMed; + public const uint SlashLow = (uint)Drw.SlashLow; + public const uint BackhandHigh = (uint)Drw.BackhandHigh; + public const uint BackhandMed = (uint)Drw.BackhandMed; + public const uint BackhandLow = (uint)Drw.BackhandLow; - public const uint DoubleSlashLow = 0x1000011Fu; - public const uint DoubleSlashMed = 0x10000120u; - public const uint DoubleSlashHigh = 0x10000121u; - public const uint TripleSlashLow = 0x10000122u; - public const uint TripleSlashMed = 0x10000123u; - public const uint TripleSlashHigh = 0x10000124u; - public const uint DoubleThrustLow = 0x10000125u; - public const uint DoubleThrustMed = 0x10000126u; - public const uint DoubleThrustHigh = 0x10000127u; - public const uint TripleThrustLow = 0x10000128u; - public const uint TripleThrustMed = 0x10000129u; - public const uint TripleThrustHigh = 0x1000012Au; + // Missile attacks (Action 0x10) + reload (SubState 0x40, NOT the dead + // 2013 0x100000D4 — the real DRW Reload is 0x40000016). + public const uint Shoot = (uint)Drw.Shoot; + public const uint MissileAttack1 = (uint)Drw.MissileAttack1; + public const uint MissileAttack2 = (uint)Drw.MissileAttack2; + public const uint MissileAttack3 = (uint)Drw.MissileAttack3; + public const uint Reload = (uint)Drw.Reload; - public const uint OffhandSlashHigh = 0x10000170u; - public const uint OffhandSlashMed = 0x10000171u; - public const uint OffhandSlashLow = 0x10000172u; - public const uint OffhandThrustHigh = 0x10000173u; - public const uint OffhandThrustMed = 0x10000174u; - public const uint OffhandThrustLow = 0x10000175u; - public const uint OffhandDoubleSlashLow = 0x10000176u; - public const uint OffhandDoubleSlashMed = 0x10000177u; - public const uint OffhandDoubleSlashHigh = 0x10000178u; - public const uint OffhandTripleSlashLow = 0x10000179u; - public const uint OffhandTripleSlashMed = 0x1000017Au; - public const uint OffhandTripleSlashHigh = 0x1000017Bu; - public const uint OffhandDoubleThrustLow = 0x1000017Cu; - public const uint OffhandDoubleThrustMed = 0x1000017Du; - public const uint OffhandDoubleThrustHigh = 0x1000017Eu; - public const uint OffhandTripleThrustLow = 0x1000017Fu; - public const uint OffhandTripleThrustMed = 0x10000180u; - public const uint OffhandTripleThrustHigh = 0x10000181u; - public const uint OffhandKick = 0x10000182u; - public const uint AttackHigh4 = 0x10000183u; - public const uint AttackMed4 = 0x10000184u; - public const uint AttackLow4 = 0x10000185u; - public const uint AttackHigh5 = 0x10000186u; - public const uint AttackMed5 = 0x10000187u; - public const uint AttackLow5 = 0x10000188u; - public const uint AttackHigh6 = 0x10000189u; - public const uint AttackMed6 = 0x1000018Au; - public const uint AttackLow6 = 0x1000018Bu; - public const uint PunchFastHigh = 0x1000018Cu; - public const uint PunchFastMed = 0x1000018Du; - public const uint PunchFastLow = 0x1000018Eu; - public const uint PunchSlowHigh = 0x1000018Fu; - public const uint PunchSlowMed = 0x10000190u; - public const uint PunchSlowLow = 0x10000191u; - public const uint OffhandPunchFastHigh = 0x10000192u; - public const uint OffhandPunchFastMed = 0x10000193u; - public const uint OffhandPunchFastLow = 0x10000194u; - public const uint OffhandPunchSlowHigh = 0x10000195u; - public const uint OffhandPunchSlowMed = 0x10000196u; - public const uint OffhandPunchSlowLow = 0x10000197u; + // Creature attacks 1-6 (Action class 0x10). 1-3 are the unshifted low + // block (0x62-0x6A); 4-6 live in the shifted late block (0x186+). + public const uint AttackHigh1 = (uint)Drw.AttackHigh1; + public const uint AttackMed1 = (uint)Drw.AttackMed1; + public const uint AttackLow1 = (uint)Drw.AttackLow1; + public const uint AttackHigh2 = (uint)Drw.AttackHigh2; + public const uint AttackMed2 = (uint)Drw.AttackMed2; + public const uint AttackLow2 = (uint)Drw.AttackLow2; + public const uint AttackHigh3 = (uint)Drw.AttackHigh3; + public const uint AttackMed3 = (uint)Drw.AttackMed3; + public const uint AttackLow3 = (uint)Drw.AttackLow3; + public const uint AttackHigh4 = (uint)Drw.AttackHigh4; + public const uint AttackMed4 = (uint)Drw.AttackMed4; + public const uint AttackLow4 = (uint)Drw.AttackLow4; + public const uint AttackHigh5 = (uint)Drw.AttackHigh5; + public const uint AttackMed5 = (uint)Drw.AttackMed5; + public const uint AttackLow5 = (uint)Drw.AttackLow5; + public const uint AttackHigh6 = (uint)Drw.AttackHigh6; + public const uint AttackMed6 = (uint)Drw.AttackMed6; + public const uint AttackLow6 = (uint)Drw.AttackLow6; + + // Spell casts (SubState class 0x40). + public const uint CastSpell = (uint)Drw.CastSpell; + public const uint UseMagicStaff = (uint)Drw.UseMagicStaff; + public const uint UseMagicWand = (uint)Drw.UseMagicWand; + + // Multi-strike melee (Action class 0x10, unshifted 0x11F-0x12A). + public const uint DoubleSlashLow = (uint)Drw.DoubleSlashLow; + public const uint DoubleSlashMed = (uint)Drw.DoubleSlashMed; + public const uint DoubleSlashHigh = (uint)Drw.DoubleSlashHigh; + public const uint TripleSlashLow = (uint)Drw.TripleSlashLow; + public const uint TripleSlashMed = (uint)Drw.TripleSlashMed; + public const uint TripleSlashHigh = (uint)Drw.TripleSlashHigh; + public const uint DoubleThrustLow = (uint)Drw.DoubleThrustLow; + public const uint DoubleThrustMed = (uint)Drw.DoubleThrustMed; + public const uint DoubleThrustHigh = (uint)Drw.DoubleThrustHigh; + public const uint TripleThrustLow = (uint)Drw.TripleThrustLow; + public const uint TripleThrustMed = (uint)Drw.TripleThrustMed; + public const uint TripleThrustHigh = (uint)Drw.TripleThrustHigh; + + // Offhand strikes (Action class 0x10, shifted late block 0x173+). + public const uint OffhandSlashHigh = (uint)Drw.OffhandSlashHigh; + public const uint OffhandSlashMed = (uint)Drw.OffhandSlashMed; + public const uint OffhandSlashLow = (uint)Drw.OffhandSlashLow; + public const uint OffhandThrustHigh = (uint)Drw.OffhandThrustHigh; + public const uint OffhandThrustMed = (uint)Drw.OffhandThrustMed; + public const uint OffhandThrustLow = (uint)Drw.OffhandThrustLow; + public const uint OffhandDoubleSlashLow = (uint)Drw.OffhandDoubleSlashLow; + public const uint OffhandDoubleSlashMed = (uint)Drw.OffhandDoubleSlashMed; + public const uint OffhandDoubleSlashHigh = (uint)Drw.OffhandDoubleSlashHigh; + public const uint OffhandTripleSlashLow = (uint)Drw.OffhandTripleSlashLow; + public const uint OffhandTripleSlashMed = (uint)Drw.OffhandTripleSlashMed; + public const uint OffhandTripleSlashHigh = (uint)Drw.OffhandTripleSlashHigh; + public const uint OffhandDoubleThrustLow = (uint)Drw.OffhandDoubleThrustLow; + public const uint OffhandDoubleThrustMed = (uint)Drw.OffhandDoubleThrustMed; + public const uint OffhandDoubleThrustHigh = (uint)Drw.OffhandDoubleThrustHigh; + public const uint OffhandTripleThrustLow = (uint)Drw.OffhandTripleThrustLow; + public const uint OffhandTripleThrustMed = (uint)Drw.OffhandTripleThrustMed; + public const uint OffhandTripleThrustHigh = (uint)Drw.OffhandTripleThrustHigh; + public const uint OffhandKick = (uint)Drw.OffhandKick; + + // Punches (Action class 0x10, shifted late block). + public const uint PunchFastHigh = (uint)Drw.PunchFastHigh; + public const uint PunchFastMed = (uint)Drw.PunchFastMed; + public const uint PunchFastLow = (uint)Drw.PunchFastLow; + public const uint PunchSlowHigh = (uint)Drw.PunchSlowHigh; + public const uint PunchSlowMed = (uint)Drw.PunchSlowMed; + public const uint PunchSlowLow = (uint)Drw.PunchSlowLow; + public const uint OffhandPunchFastHigh = (uint)Drw.OffhandPunchFastHigh; + public const uint OffhandPunchFastMed = (uint)Drw.OffhandPunchFastMed; + public const uint OffhandPunchFastLow = (uint)Drw.OffhandPunchFastLow; + public const uint OffhandPunchSlowHigh = (uint)Drw.OffhandPunchSlowHigh; + public const uint OffhandPunchSlowMed = (uint)Drw.OffhandPunchSlowMed; + public const uint OffhandPunchSlowLow = (uint)Drw.OffhandPunchSlowLow; } diff --git a/src/AcDream.Core/Lighting/LightInfoLoader.cs b/src/AcDream.Core/Lighting/LightInfoLoader.cs index f3b02348..b3e9d4a8 100644 --- a/src/AcDream.Core/Lighting/LightInfoLoader.cs +++ b/src/AcDream.Core/Lighting/LightInfoLoader.cs @@ -37,7 +37,8 @@ public static class LightInfoLoader uint ownerId, Vector3 entityPosition, Quaternion entityRotation, - bool isDynamic = false) + bool isDynamic = false, + uint cellId = 0) { var results = new List(); if (setup?.Lights is null || setup.Lights.Count == 0) return results; @@ -89,6 +90,7 @@ public static class LightInfoLoader Range = info.Falloff * (isDynamic ? 1.5f : 1.3f), ConeAngle = info.ConeAngle, OwnerId = ownerId, + CellId = cellId, // owning cell — scopes the per-frame visible-cell pool (A7 #176/#177) IsLit = true, IsDynamic = isDynamic, }; diff --git a/src/AcDream.Core/Lighting/LightManager.cs b/src/AcDream.Core/Lighting/LightManager.cs index e3f7605a..18602d9d 100644 --- a/src/AcDream.Core/Lighting/LightManager.cs +++ b/src/AcDream.Core/Lighting/LightManager.cs @@ -176,8 +176,28 @@ public sealed class LightManager public const int MaxLightsPerObject = 8; /// Hard cap on the per-frame global point-light snapshot the shader - /// indexes. AC scenes rarely exceed a few dozen lit point lights in view; 128 - /// is generous. If exceeded, the nearest-to-camera are kept (cold path). + /// indexes. #176 root-cause history (2026-07-06, corrected): retail's pool is + /// collected from ALL RESIDENT EnvCells (CEnvCell::add_dynamic_lights + /// 0x0052d410 walks the static CEnvCell::visible_cell_table — the + /// loaded-cell registry that add_visible_cell 0x0052de40 fills from each + /// activated cell + its dat visible-cell list; NOT the per-frame portal flood) + /// and capped nearest-THE-PLAYER (Render::insert_light 0x0054d1b0 sorts + /// by distance to Render::player_pos) with small caps (7 dynamic + 40 + /// static, 0x0081ec94/98). Two prior acdream models both flickered + /// because their pool was CAMERA-coupled: (1) nearest-CAMERA-128 over all + /// registered lights (chase-boom swing churned the eviction boundary), then + /// (2) frame-FLOOD scoping `c500912b` (gaze-dependent: the under-room portal + /// purples entered/left the pool as the camera turned — the seam-floor + /// blink; probe: [seam-blk]/[seam-snap]). Current model: all registered + /// (=resident) lit lights optionally FILTERED by last frame's rendered + /// visible-cell set (A7.L1, 2026-07-09 — 's + /// visibleCells param; fixes Town Network starvation without + /// reproducing c500912b — see that method's doc), then dynamics-first nearest- + /// player, capped here. 128 is wider than retail's 40+7 — a documented backstop + /// that in a properly cell-scoped room only ever evicts far-out-of-range + /// statics; adopting retail's exact dual-pool caps + degrade levels is A7-arc + /// work. The 1024 uncap remains refuted (striped-floor artifact + the unported + /// static 1/d³ fixture curve, A7 fix #2). Register row AP-85. public const int MaxGlobalLights = 128; private readonly List _pointSnapshot = new(); @@ -190,28 +210,100 @@ public sealed class LightManager /// public IReadOnlyList PointSnapshot => _pointSnapshot; + // Pool-sort state for BuildPointLightSnapshot: the comparison delegate is + // cached (allocated once) and reads the anchor from a field so the per-frame + // over-cap sort allocates nothing beyond List.Sort's own wrapper — the same + // profile as the previous static-lambda sort (MP-Alloc discipline). + private Vector3 _poolAnchor; + private Comparison? _poolComparison; + /// - /// Rebuild from the registered lit point/spot - /// lights. The sun and unlit lights are excluded (the sun is global ambient- - /// path; unlit torches contribute nothing). When more than - /// qualify, keeps the nearest the camera so the - /// most relevant lights survive the cap. Call once per frame before - /// per-object selection. + /// Rebuild from ALL registered lit point/spot + /// lights — retail's per-frame collection over the RESIDENT-cell registry. + /// The sun and unlit lights are excluded (the sun is global ambient-path; + /// unlit torches contribute nothing). + /// + /// Retail anchors (#176 corrected reading, 2026-07-06): + /// CEnvCell::add_dynamic_lights (0x0052d410) walks the WHOLE static + /// CEnvCell::visible_cell_table — the resident-EnvCell registry that + /// CEnvCell::add_visible_cell (0x0052de40) populates from each activated + /// cell plus its dat visible-cell list (it DBObj::Get-loads absent cells; + /// entries leave only via the flush machinery). It is NOT the per-frame portal + /// flood: camera gaze cannot remove a cell from it. acdream's _all + /// (register at hydration, unregister at unload) is that resident set, so the + /// collection is simply every registered lit light. The under-room portal + /// purples reaching the corridor's pool is retail-correct (cdb: retail applies + /// them to every Hub cell) — the faceted purple wedge is faithful. + /// + /// + /// When more than qualify, DYNAMICS are kept + /// first (retail's dynamic lights live in their own 7-slot pool — + /// Render::add_dynamic_light 0x0054d420 — and never compete with + /// statics), then the nearest THE PLAYER (Render::insert_light + /// 0x0054d1b0 insertion-sorts by squared distance to Render::player_pos, + /// set from player->m_position, SmartBox 0x00453d3a, with the + /// viewer-cell fallback 0x00455ab6). The distance SORT is therefore a function + /// of PLAYER position and light registration ONLY — camera rotation/position + /// cannot change it (both prior camera-ANCHORED pools — nearest-camera cap; + /// c500912b's camera-seeded re-flood — produced the #176 seam-floor + /// purple blink by making the SORT itself camera-dependent). The optional + /// candidacy FILTER (A7.L1) does not change + /// this: it narrows the input set before the player-anchored sort runs, using + /// a value the caller captured from last frame's already-rendered draw list, + /// not a fresh camera-seeded computation performed here. Call once per frame + /// before per-object selection. + /// /// - public void BuildPointLightSnapshot(Vector3 cameraWorldPos) + /// The player's world position (render position; + /// callers pass the camera position only when no player exists — retail's + /// player/viewer branch). + /// + /// A7.L1 (2026-07-09) — optional visible-cell scoping. When non-null, a light + /// is a candidate only if it is cell-less (CellId == 0 — the viewer fill, + /// always in scope) or its CellId is in this set. Fixes the Town Network + /// starvation case (463 registered fixtures): the player-nearest cap sorts by + /// raw Euclidean distance, which is not a reliable proxy for "same room" in a + /// dense, maze-like hub — a fixture on the other side of a wall can be + /// geometrically closer than the player's own room's torches and win the cap, + /// leaving the visible room dark. Scoping candidacy to the frame's actual + /// visible cells (the render already computes this — callers pass last frame's + /// RetailPViewFrameResult.DrawableCells, one frame of latency, to avoid + /// re-threading a mid-render callback) removes those from contention before the + /// cap ever applies. The distance-sort anchor stays the PLAYER either way — this + /// parameter only narrows candidacy, it does not change the sort (the #176 + /// correction: CAMERA anchoring, not cell scoping itself, caused the earlier + /// seam-floor flicker regression, c500912b). Null (the default) preserves the + /// legacy unscoped behavior — outdoor / no-clipRoot callers pass null. + /// + public void BuildPointLightSnapshot(Vector3 playerWorldPos, IReadOnlySet? visibleCells = null) { _pointSnapshot.Clear(); foreach (var light in _all) { if (!light.IsLit || light.Kind == LightKind.Directional) continue; - light.DistSq = (light.WorldPosition - cameraWorldPos).LengthSquared(); + if (visibleCells is not null && light.CellId != 0 && !visibleCells.Contains(light.CellId)) continue; _pointSnapshot.Add(light); } if (_pointSnapshot.Count > MaxGlobalLights) { - _pointSnapshot.Sort(static (a, b) => a.DistSq.CompareTo(b.DistSq)); + _poolAnchor = playerWorldPos; + _poolComparison ??= (a, b) => + { + // Dynamics-first mirrors retail's separate dynamic pool; ties by + // player distance mirror insert_light's player-nearest sort. + if (a.IsDynamic != b.IsDynamic) return a.IsDynamic ? -1 : 1; + float da = (a.WorldPosition - _poolAnchor).LengthSquared(); + float db = (b.WorldPosition - _poolAnchor).LengthSquared(); + return da.CompareTo(db); + }; + _pointSnapshot.Sort(_poolComparison); _pointSnapshot.RemoveRange(MaxGlobalLights, _pointSnapshot.Count - MaxGlobalLights); } + + // A7.L1 SET-COMPOSITION probe. Inert unless ACDREAM_PROBE_INDOOR_LIGHT=1; + // the flag check keeps it zero-cost off. + if (AcDream.Core.Rendering.RenderingDiagnostics.ProbeIndoorLightEnabled) + AcDream.Core.Rendering.RenderingDiagnostics.EmitIndoorLight(_all, _pointSnapshot); } // ── Viewer light — retail SmartBox::set_viewer (0x00452c40) ────────────── @@ -333,4 +425,75 @@ public sealed class LightManager } return count; } + + /// + /// Per-CELL light selection — retail minimize_envcell_lighting (0x0054c170). + /// Unlike (per-object sphere-overlap cull), retail enables + /// the ENTIRE dynamic subset for EVERY EnvCell it draws (verified by a live cdb trace of + /// config_hardware_light: the same 4 intensity-100 portal lights are applied to + /// every Facility Hub cell, every frame). So here: ALL dynamic lights are added + /// unconditionally (the shader's per-light range cutoff zeroes ones that don't reach — + /// same as D3D's hardware range), THEN remaining slots fill with the nearest STATIC lights + /// that reach the cell sphere. This is what makes a cell's floor lighting STABLE as the + /// portal flood shifts — a per-cell sphere-overlap cull of the dynamics is what made the + /// floor lighting FLAP (#176). Objects keep + /// (retail minimize_object_lighting). + /// + public static int SelectForCell( + IReadOnlyList snapshot, + Vector3 center, + float radius, + Span outIndices) + { + int cap = Math.Min(outIndices.Length, MaxLightsPerObject); + if (cap <= 0) return 0; + + int count = 0; + + // 1) ALL dynamic lights, unconditionally (retail applies the whole dynamic subset to + // every cell — stable regardless of the cell's relation to each light). + for (int li = 0; li < snapshot.Count && count < cap; li++) + if (snapshot[li].IsDynamic) + outIndices[count++] = li; + + // 2) Fill remaining slots with the nearest STATIC lights that reach the cell sphere, + // insertion-sorted among the static slots only (dynamic slots [0..staticStart) are fixed). + int staticStart = count; + Span keptDistSq = stackalloc float[MaxLightsPerObject]; + for (int li = 0; li < snapshot.Count; li++) + { + var light = snapshot[li]; + if (light.IsDynamic) continue; // dynamics already added + float reach = light.Range + radius; + float dsq = (light.WorldPosition - center).LengthSquared(); + if (dsq >= reach * reach) continue; + + if (count < cap) + { + int j = count; + while (j > staticStart && keptDistSq[j - 1] > dsq) + { + keptDistSq[j] = keptDistSq[j - 1]; + outIndices[j] = outIndices[j - 1]; + j--; + } + keptDistSq[j] = dsq; + outIndices[j] = li; + count++; + } + else if (staticStart < cap && dsq < keptDistSq[cap - 1]) + { + int j = cap - 1; + while (j > staticStart && keptDistSq[j - 1] > dsq) + { + keptDistSq[j] = keptDistSq[j - 1]; + outIndices[j] = outIndices[j - 1]; + j--; + } + keptDistSq[j] = dsq; + outIndices[j] = li; + } + } + return count; + } } diff --git a/src/AcDream.Core/Lighting/LightSource.cs b/src/AcDream.Core/Lighting/LightSource.cs index c07e79b9..55676e8a 100644 --- a/src/AcDream.Core/Lighting/LightSource.cs +++ b/src/AcDream.Core/Lighting/LightSource.cs @@ -46,6 +46,12 @@ public sealed class LightSource public float Range = 10f; // metres, hard cutoff public float ConeAngle = 0f; // radians, Spot only public uint OwnerId; // attached entity id; 0 = world-global + public uint CellId; // owning cell id (0xLLLLNNNN); 0 = cell-less/global (viewer fill, sun). + // Retail carries this on the RenderLight (insert_light arg6, +0x6c) for the + // cross-cell block-offset distance math. #176 correction (2026-07-06): it is + // NOT a pool filter — retail collects from ALL resident cells + // (CEnvCell::visible_cell_table = the loaded-cell registry, not the flood); + // acdream keeps the tag for probes ([indoor-light]/[seam-*]) + future parity. public bool IsLit = true; // SetLightHook latch public bool IsDynamic; // #143: true = D3D hardware path (1/d att, range×1.5); // false = static dat-baked bake (1/d³, range×1.3) diff --git a/src/AcDream.Core/Meshing/EntityHydrationRules.cs b/src/AcDream.Core/Meshing/EntityHydrationRules.cs new file mode 100644 index 00000000..d61035b9 --- /dev/null +++ b/src/AcDream.Core/Meshing/EntityHydrationRules.cs @@ -0,0 +1,33 @@ +namespace AcDream.Core.Meshing; + +/// +/// Should a hydrated stab/entity survive when its visual mesh flattens to +/// zero drawable parts? +/// +/// +/// Why this exists (#79/#93, 2026-07-09). A dat-authored "light attach +/// point" is a Setup whose sole purpose is to carry a Setup.Lights +/// entry — its own visual part is commonly a #136-class runtime-hidden +/// marker (degrades to nothing at any real distance, matching retail's +/// editor-only placement markers). Retail's light registration +/// (CObjCell::add_light, populated at CEnvCell::UnPack) is +/// entirely independent of a fixture's own mesh visibility — a mesh-less +/// carrier still lights the room. The Town Network fountain room's only +/// light (Setup 0x02000365, a ceiling fixture 5 m above the fountain) never +/// registered because the mesh-empty gate treated "nothing to draw" as +/// "nothing exists," dropping the entity — and its Lights — before the +/// light-registration pass ever saw it. +/// +/// +public static class EntityHydrationRules +{ + /// + /// True when the entity should still be added to the landblock's entity + /// set even with zero mesh refs, because it has dat-authored lights to + /// register. An entity with any mesh is always kept (unchanged from the + /// pre-existing gate); the entity is dropped only when it has neither + /// geometry to draw nor lights to register. + /// + public static bool ShouldKeepEntity(int meshRefCount, int setupLightCount) + => meshRefCount > 0 || setupLightCount > 0; +} diff --git a/src/AcDream.Core/Physics/AceModernCommandCatalog.cs b/src/AcDream.Core/Physics/AceModernCommandCatalog.cs new file mode 100644 index 00000000..0294f59e --- /dev/null +++ b/src/AcDream.Core/Physics/AceModernCommandCatalog.cs @@ -0,0 +1,101 @@ +using System; +using System.Collections.Generic; +using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand; + +namespace AcDream.Core.Physics; + +/// +/// Runtime-default . Built from the +/// enum (generated from the protocol XML; +/// mirrors ACE's MotionCommand enum and matches the values actually +/// found in the local DAT MotionTable records). Use this catalog +/// while talking to ACE — it is what +/// delegates to. +/// +/// +/// Reconstruction is a flat wireLow16 -> full32 lookup built once +/// at construction. When more than one enum value shares the same low 16 +/// bits (a true class collision — class byte differs, low word doesn't), +/// the LOWER class byte wins: Action (0x10) < ChatEmote (0x12/0x13) +/// < Modifier (0x20) < SubState (0x41/...) < ... < Style (0x80). +/// See . +/// +/// +/// +/// No magic per-range override. The original +/// MotionCommandResolver.ApplyNamedRetailOverrides force-mapped +/// wire 0x016E-0x0197 to 0x10000000 | lo on the theory that the +/// generated DRW enum was "shifted." Verified false: building the lookup +/// straight from (Chorizite.DatReaderWriter +/// 2.1.7, 409 distinct values, zero same-low16 collisions) already resolves +/// LifestoneRecall (0x0153), MarketplaceRecall (0x0166), +/// AllegianceHometownRecall (0x0171), and OffhandSlashHigh +/// (0x0173) to their correct Action-class full values with no override. +/// The override loop is deleted in this slice (it was masking nothing; the +/// enum was already correct). See +/// docs/research/2026-06-26-ace-vs-2013-motion-command-gap.md. +/// +/// +public sealed class AceModernCommandCatalog : IMotionCommandCatalog +{ + private readonly Dictionary _lookup; + + public AceModernCommandCatalog() + { + _lookup = BuildLookup(); + } + + public uint ReconstructFullCommand(ushort wireCommand) + { + if (wireCommand == 0) return 0u; + _lookup.TryGetValue(wireCommand, out var full); + return full; + } + + private static Dictionary BuildLookup() + { + var byLow = new Dictionary>(512); + foreach (DRWMotionCommand v in Enum.GetValues(typeof(DRWMotionCommand))) + { + uint full = (uint)v; + ushort lo = (ushort)(full & 0xFFFFu); + if (lo == 0) continue; // Invalid / unmappable + + if (!byLow.TryGetValue(lo, out var list)) + byLow[lo] = list = new List(1); + if (!list.Contains(full)) + list.Add(full); + } + + var result = new Dictionary(byLow.Count); + foreach (var (lo, candidates) in byLow) + { + result[lo] = candidates.Count == 1 + ? candidates[0] + : ResolveClassPriority(candidates); + } + + return result; + } + + /// + /// Given a set of full 32-bit MotionCommand values that all share the + /// same low 16 bits, return the one whose class byte (bits 24-31) is + /// numerically lowest — retail's class priority (Action 0x10 beats + /// Modifier 0x20 beats SubState 0x41 beats Style 0x80, etc). Exposed + /// as a static so it can be exercised directly by tests even when the + /// live enum has no real collisions to exercise it through + /// . + /// + public static uint ResolveClassPriority(IReadOnlyList candidates) + { + uint best = candidates[0]; + for (int i = 1; i < candidates.Count; i++) + { + uint candidate = candidates[i]; + if ((candidate >> 24) < (best >> 24)) + best = candidate; + } + return best; + } +} diff --git a/src/AcDream.Core/Physics/AnimationSequencer.cs b/src/AcDream.Core/Physics/AnimationSequencer.cs index 4dc4aef9..4ee17977 100644 --- a/src/AcDream.Core/Physics/AnimationSequencer.cs +++ b/src/AcDream.Core/Physics/AnimationSequencer.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Numerics; +using AcDream.Core.Physics.Motion; using DatReaderWriter; using DatReaderWriter.DBObjs; using DatReaderWriter.Enums; @@ -30,19 +31,33 @@ public sealed class DatCollectionLoader : IAnimationLoader } // ───────────────────────────────────────────────────────────────────────────── -// AnimationSequencer — faithful port of the decompiled retail AC client -// animation system. +// AnimationSequencer — adapter rehosted on the verbatim retail CSequence core +// (R1-P5, docs/research/2026-07-02-r1-csequence/r1-gap-map.md §3 P5). // -// Primary references (pseudocode at docs/research/acclient_animation_pseudocode.md): -// FUN_005267E0 — multiply_framerate: swaps startFrame↔endFrame for negative speed -// FUN_005261D0 — update_internal: the core per-frame advance loop -// FUN_00525EB0 — advance_to_next_animation: node transition + wrap to firstCyclic -// FUN_00526880 — GetStartFramePosition: double start pos (speed-dependent) -// FUN_005268B0 — GetEndFramePosition: double end pos (speed-dependent) -// FUN_005360d0 — quaternion slerp with dot-product sign-flip +// R1-P5 REHOST: the legacy AnimNode/LinkedList queue machinery is +// gone. All frame-advance, list-surgery, and boundary-math state now lives in +// AcDream.Core.Physics.Motion.CSequence (R1-P1..P4, verbatim retail port — +// see CSequence.cs/AnimSequenceNode.cs/FrameOps.cs). This adapter keeps every +// public member's signature (the API-migration table in the gap map is the +// contract) and re-expresses each one over the core. Invented mechanisms that +// were R2/R3 scope (K-fix18 skipTransitionLink DELETED in R3-W4, Fix B locomotion +// link-skip, stop-anim fallback, GetLink's reversed branch, velocity/omega +// synthesis constants) SURVIVE unchanged at the adapter level per the gap +// map's "Invented behaviors NOT in the gap list" note. +// +// Primary references (docs/research/2026-07-02-r1-csequence/r1-csequence-decomp.md): +// append_animation 0x00525510 (§24) +// remove_cyclic_anims 0x00524e40 (§6) +// remove_all_link_animations 0x00524ca0 (§8) +// clear_animations 0x00524dc0 (§4) +// clear_physics 0x00524d50 (§9? see CSequence.cs) +// update / update_internal 0x00525b80 / 0x005255d0 (§21/§22) +// advance_to_next_animation 0x005252b0 (§23) +// multiply_cyclic_animation_fr 0x00524940 (§14) +// FUN_005360d0 — quaternion slerp with dot-product sign-flip (render-side, +// NOT CSequence scope — kept verbatim in this adapter) // MotionInterp.cs:394-428 (ACE) — adjust_motion: left→right remapping -// Sequence.cs:262-270 (ACE) — execute_hooks (Both or matching direction fires) -// Sequence.cs:351-443 (ACE) — update_internal with per-frame hook dispatch +// (R2/R3 scope; kept verbatim in this adapter per the gap map) // // DatReaderWriter types used: // MotionTable.Links : Dictionary @@ -77,125 +92,16 @@ public readonly struct PartTransform } } -/// -/// One entry in the animation queue (link transition or looping cycle). -/// -/// Faithfully models the retail client AnimNode struct at +0x0C..+0x18. -/// Carries the parent 's -/// Velocity and Omega fields so per-tick physics deltas can be surfaced -/// while this node is current (ACE Sequence.Velocity / Omega equivalent -/// for the single-active-MotionData case). -/// -internal sealed class AnimNode -{ - public Animation Anim; - public double Framerate; // signed; negative means reverse playback - public int StartFrame; // inclusive start frame (post-swap for negative speed) - public int EndFrame; // inclusive end frame (post-swap for negative speed) - public bool IsLooping; // true only for the tail cyclic node - public bool HasPosFrames; // mirror of Anim.Flags & AnimationFlags.PosFrames - - // Carried from the source MotionData (one MotionData may produce N nodes; - // each carries the same vel/omega, and when the node becomes current the - // sequencer surfaces these values). - public Vector3 Velocity; // meters/sec, world-space - public Vector3 Omega; // radians/sec per axis - - public AnimNode( - Animation anim, - double framerate, - int startFrame, - int endFrame, - bool isLooping, - bool hasPosFrames, - Vector3 velocity, - Vector3 omega) - { - Anim = anim; - Framerate = framerate; - StartFrame = startFrame; - EndFrame = endFrame; - IsLooping = isLooping; - HasPosFrames = hasPosFrames; - Velocity = velocity; - Omega = omega; - } - - // ── FUN_005267E0 — multiply_framerate ───────────────────────────────── - // Scales this node's framerate by a factor. Used by - // AnimationSequencer.MultiplyCyclicFramerate to retarget an already-queued - // cyclic animation at a new playback speed without restarting. - // - // Retail's implementation additionally swapped StartFrame↔EndFrame for a - // negative factor (so the forward-playback advance loop could traverse - // either direction), but acdream's AnimNode keeps StartFrame ≤ EndFrame - // as an invariant and encodes direction purely via Framerate's sign — the - // Advance loop then checks against StartFrame as the lower bound for - // negative delta. So here we only scale. - // - // Mirrors ACE AnimSequenceNode.multiply_framerate / Sequence.cs L277-L287 - // modulo the swap difference. Valid because the callers we care about - // (ForwardSpeed updates from UpdateMotion) only ever pass positive factors. - public void MultiplyFramerate(double factor) - { - Framerate *= factor; - } - - // ── FUN_00526880 — GetStartFramePosition ────────────────────────────── - // Returns the initial framePosition cursor for this node. - // speedScale >= 0 → (double)startFrame - // speedScale < 0 → (double)(endFrame + 1) - EPSILON - // EPSILON = _DAT_007c92b4 (a tiny float just below the boundary) - public double GetStartFramePosition() - { - if (Framerate >= 0.0) - return (double)StartFrame; - else - return (double)(EndFrame + 1) - FrameEpsilon; - } - - // ── FUN_005268B0 — GetEndFramePosition ─────────────────────────────── - // Returns where the cursor sits when this node is exhausted. - // speedScale >= 0 → (double)(endFrame + 1) - EPSILON - // speedScale < 0 → (double)startFrame - public double GetEndFramePosition() - { - if (Framerate >= 0.0) - return (double)(EndFrame + 1) - FrameEpsilon; - else - return (double)StartFrame; - } - - // Small double constant matching _DAT_007c92b4 in the retail binary. - // Used to position the cursor just before a frame boundary. - private const double FrameEpsilon = 1e-5; -} - /// /// Full animation playback engine for one entity. /// /// -/// This is a faithful port of the retail AC client's Sequence object -/// (docs/research/acclient_animation_pseudocode.md, sections 5–7). -/// Key invariants: -/// -/// -/// _framePosition is a double matching the retail client's -/// 64-bit field at Sequence+0x30. -/// -/// -/// Negative framerate means reverse playback. -/// -/// -/// When a node's frames are exhausted, advance_to_next_animation -/// wraps to _firstCyclic (the looping tail of the queue). -/// -/// -/// Every integer frame boundary crossed in a tick fires the hooks at -/// that frame whose matches the playback -/// direction (or Both). Mirrors ACE Sequence.execute_hooks. -/// -/// +/// R1-P5: this is now a thin adapter over — the +/// verbatim retail port of the AC client's CSequence object. The +/// adapter owns caller-facing bookkeeping (CurrentStyle/CurrentMotion/ +/// CurrentSpeedMod, dat lookups via Setup/MotionTable, the retail-faithful +/// but still-R2/R3-scope invented mechanisms) while all frame-advance, +/// list-surgery, and boundary math live in the core. /// /// /// @@ -204,9 +110,8 @@ internal sealed class AnimNode /// var seq = new AnimationSequencer(setup, motionTable, dats); /// seq.SetCycle(style, motion, speedMod); /// // each frame: -/// var transforms = seq.Advance(dt); +/// var transforms = seq.Advance(dt, rootMotionFrame); // root motion lands in the Frame /// var hooks = seq.ConsumePendingHooks(); // fire audio / VFX / damage -/// var root = seq.ConsumeRootMotionDelta(); // add to AFrame if desired /// /// /// @@ -214,25 +119,34 @@ public sealed class AnimationSequencer { // ── Public state ───────────────────────────────────────────────────────── - /// Current style (stance) command. - public uint CurrentStyle { get; private set; } - - /// Current cyclic motion command. - public uint CurrentMotion { get; private set; } - /// - /// Speed multiplier currently applied to the cyclic tail. Starts at 1.0 - /// and is updated by when the same motion is - /// re-issued with a different speed (which triggers - /// instead of a cycle restart). + /// Current style (stance) command — R2-Q4: read-only mirror of the + /// retail (MotionState OWNS + /// style/substate/substate_mod; the adapter no longer keeps copies). /// - public float CurrentSpeedMod { get; private set; } = 1f; + public uint CurrentStyle => _state.Style; /// - /// Sequence-wide velocity mirror of ACE's Sequence.Velocity field. - /// Updated each time a MotionData is appended or combined — reflects the - /// MOST RECENT MotionData's velocity × speedMod, matching - /// Sequence.SetVelocity semantics (ACE Sequence.cs L127-L130, + /// Current cyclic motion command — mirror of + /// . NOTE (Q4): this is the + /// POST-adjust_motion substate (WalkBackward reads back as WalkForward + /// with a negative ) — retail's interpreted + /// state is post-adjustment. + /// + public uint CurrentMotion => _state.Substate; + + /// + /// Speed multiplier of the current substate — mirror of + /// (signed; see + /// ). + /// + public float CurrentSpeedMod => _state.SubstateMod; + + /// + /// Sequence-wide velocity mirror of the core's + /// field (retail Sequence::Velocity). Updated each time a + /// MotionData is appended — reflects the MOST RECENT MotionData's + /// velocity × speedMod (retail set_velocity semantics, /// MotionTable.add_motion L358-L370). /// /// @@ -243,35 +157,47 @@ public sealed class AnimationSequencer /// transitions. /// /// - public Vector3 CurrentVelocity { get; private set; } + public Vector3 CurrentVelocity => _core.Velocity; /// /// Sequence-wide omega, matching 's semantics. /// - public Vector3 CurrentOmega { get; private set; } + public Vector3 CurrentOmega => _core.Omega; // Diagnostics - public int QueueCount => _queue.Count; - public bool HasCurrentNode => _currNode != null; + public int QueueCount => _core.Count; + public bool HasCurrentNode => _core.CurrAnim != null; + + /// Test seam (Q4 trace conformance): the verbatim CSequence core. + internal CSequence Core => _core; /// - /// Diagnostic snapshot of _currNode's identity + frame state, for - /// the per-tick CURRNODE log line in GameWindow.TickAnimations. - /// Lets the caller see whether the actual node being read by Advance / - /// BuildBlendedFrame is what SetCycle was supposed to leave it on. - /// AnimRefHash uses object-identity hashing on the Animation reference - /// so different Walk vs Run anim resources can be distinguished even - /// without exposing the full Animation type. + /// Diagnostic snapshot of the core's curr_anim identity + frame + /// state, for the per-tick CURRNODE log line in + /// GameWindow.TickAnimations. Lets the caller see whether the + /// actual node being read by Advance / BuildBlendedFrame is what + /// SetCycle was supposed to leave it on. AnimRefHash uses + /// object-identity hashing on the Animation reference so different Walk + /// vs Run anim resources can be distinguished even without exposing the + /// full Animation type. + /// + /// IsLooping here means "this node IS the cyclic tail" (core structural + /// test: curr == first_cyclic) — retail nodes carry no per-node + /// IsLooping flag (G16); this diagnostic re-derives the same meaning + /// from list structure. /// public (int AnimRefHash, bool IsLooping, double Framerate, int StartFrame, int EndFrame, double FramePosition, int QueueCount) CurrentNodeDiag { get { - if (_currNode is null) - return (0, false, 0.0, 0, 0, 0.0, _queue.Count); - var n = _currNode.Value; - int hash = System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(n.Anim); - return (hash, n.IsLooping, n.Framerate, n.StartFrame, n.EndFrame, _framePosition, _queue.Count); + var n = _core.CurrAnim; + if (n is null) + return (0, false, 0.0, 0, 0, 0.0, _core.Count); + int hash = n.Anim is null + ? 0 + : System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(n.Anim); + bool isLooping = ReferenceEquals(_core.CurrAnim, _core.FirstCyclic); + return (hash, isLooping, n.Framerate, n.LowFrame, n.HighFrame, _core.FrameNumber, _core.Count); } } @@ -279,13 +205,19 @@ public sealed class AnimationSequencer /// Diagnostic: the AnimRefHash for the FIRST cyclic node in the queue /// (i.e., what SetCycle is trying to land us on for a locomotion cycle). /// Compare against 's AnimRefHash to see - /// whether _currNode is actually pointing at the new cycle or - /// something stale. + /// whether the core's curr_anim is actually pointing at the new + /// cycle or something stale. /// - public int FirstCyclicAnimRefHash => - _firstCyclic is null - ? 0 - : System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(_firstCyclic.Value.Anim); + public int FirstCyclicAnimRefHash + { + get + { + var fc = _core.FirstCyclic; + return fc?.Anim is null + ? 0 + : System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(fc.Anim); + } + } // ── Private state ──────────────────────────────────────────────────────── @@ -293,35 +225,47 @@ public sealed class AnimationSequencer private readonly MotionTable _mtable; private readonly IAnimationLoader _loader; - // Animation queue: non-looping link frames followed by the looping cycle. - private readonly LinkedList _queue = new(); - private LinkedListNode? _currNode; - private LinkedListNode? _firstCyclic; + // R1-P5: the verbatim retail CSequence core. Owns the animation list, + // curr_anim/first_cyclic cursors, frame_number, and Velocity/Omega + // accumulators. + private readonly CSequence _core; - // 64-bit fractional frame position — matches Sequence+0x30 in the retail client. - // Named _framePosition to distinguish it from the old float _frameNum. - private double _framePosition; + // R2-Q4: the verbatim motion-selection stack. CMotionTable resolves + // (style, substate, speed) requests (Q2); MotionState owns + // style/substate/mod + the modifier/action chains (Q1); + // MotionTableManager owns the pending-animation queue + the + // tick-countdown completion machinery (Q3). SetCycle/PlayAction are + // thin shims over MotionTableManager.PerformMovement. + private readonly CMotionTable _table; + private readonly MotionState _state; + private readonly MotionTableManager _manager; - // Hooks pending dispatch. Accumulated during Advance; drained via - // ConsumePendingHooks. + // Retail lazy-create analog (MovementManager::get_minterp → + // enter_default_state, r3-motioninterp-decomp §6g): the manager's + // initialize_state runs on the FIRST SetCycle/PlayAction, not at + // construction, so a sequencer that is never driven stays do-nothing + // (RenderBootstrap invariant). + private bool _initialized; + + // Hooks pending dispatch. Accumulated during Advance (via the + // AdapterHookQueue seam below); drained via ConsumePendingHooks. private readonly List _pendingHooks = new(); - // Root motion (PosFrames) delta accumulated during Advance. Drained via - // ConsumeRootMotionDelta. Matches the retail client's AFrame.Combine / - // AFrame.Subtract chain in Sequence.update_internal. - private Vector3 _rootMotionPos; - private Quaternion _rootMotionRot = Quaternion.Identity; + // MP-Alloc (2026-07-05): reusable per-part transform buffer. _setup is + // assigned once in the constructor and never reassigned, so + // _setup.Parts.Count is fixed for this sequencer's lifetime — one + // allocation instead of one `new PartTransform[partCount]` per Advance() + // call (every animated entity, every tick, including idle NPCs on a + // breathe cycle). BuildBlendedFrame/BuildIdentityFrame overwrite every + // slot before returning this array, so the values are bit-identical to + // the old fresh-array version; callers (GameWindow.TickAnimations) + // consume the returned IReadOnlyList synchronously within + // the same loop iteration and never cache it across Advance() calls. + private readonly PartTransform[] _partTransformScratch; - private const double FrameEpsilon = 1e-5; - private const double RateEpsilon = 1e-6; - - // ── Diagnostics (Commit A 2026-05-03) ─────────────────────────────────── - // Throttle clock for the [SCFAST] / [SCFULL] / [SCNULLFALLBACK] log lines - // emitted from SetCycle. Gated on env var ACDREAM_REMOTE_VEL_DIAG=1; reads - // the env var inline rather than caching so a launch can be re-toggled - // without restarting. 0.5s per sequencer instance keeps logs readable - // while still capturing meaningful state changes. - private double _lastSetCycleDiagTime; + // R1-P6: root motion flows through the Advance(dt, Frame) overload + // (retail CSequence::update(Frame*), 0x00525b80) — the old adapter + // accumulator fields are gone with ConsumeRootMotionDelta. // ── Constructor ────────────────────────────────────────────────────────── @@ -343,10 +287,55 @@ public sealed class AnimationSequencer _setup = setup; _mtable = motionTable; _loader = loader; + _partTransformScratch = new PartTransform[_setup.Parts.Count]; + _core = new CSequence(loader); + _core.HookObj = new AdapterHookQueue(this); + _table = new CMotionTable(motionTable); + _state = new MotionState(); + _manager = new MotionTableManager(_table, _state, _core, new ForwardingMotionDoneSink(this)); + } + + /// + /// R2-Q4: the entity's — the caller's + /// per-tick drive surface ( + /// per drained AnimDone hook, + /// once per tick). + /// + public MotionTableManager Manager => _manager; + + /// + /// R2-Q4 seam: where lands. + /// Null → dropped (diagnostic recorder bound by the host under + /// ACDREAM_DUMP_MOTION); R3 binds MotionInterpreter.MotionDone here + /// (register row: MotionDone observed-not-consumed until R3). + /// + public Action? MotionDoneTarget { get; set; } + + private sealed class ForwardingMotionDoneSink : IMotionDoneSink + { + private readonly AnimationSequencer _owner; + public ForwardingMotionDoneSink(AnimationSequencer owner) => _owner = owner; + public void MotionDone(uint motion, bool success) + => _owner.MotionDoneTarget?.Invoke(motion, success); + } + + private void EnsureInitialized() + { + if (_initialized) + return; + _initialized = true; + _manager.InitializeState(); } // ── Public API ─────────────────────────────────────────────────────────── + // R2-Q5: HasCycle DELETED (caller-free). The missing-cycle hazard it + // guarded ("torso on the ground": legacy SetCycle's unconditional + // cyclic-tail drop) is structurally gone — the verbatim + // GetObjectSequence checks the cycle BEFORE any list surgery and leaves + // the sequence untouched on a miss, so the spawn/UM fallback chains + // (Run→Walk→Ready) that probed it are retired with RemoteMotionSink. + /// /// Switch to a new cyclic motion, prepending any transition link frames /// so the switch is smooth. If the motion table has no link for the @@ -363,47 +352,18 @@ public sealed class AnimationSequencer /// MotionCommand style / stance (e.g. NonCombat 0x003D0000). /// Target motion command (e.g. WalkForward 0x45000005). /// Speed multiplier applied to framerates (1.0 = normal). - /// K-fix18 (2026-04-26): when true, do - /// NOT enqueue the transition-link frames between the previous and - /// new cycle. Used when the caller wants the new cycle to engage - /// instantly — e.g. swapping to Falling on a jump start, where the - /// RunForward→Falling link is a short "stop running" pose that - /// makes the jump look delayed (legs stand still for ~100 ms while - /// the link drains, then fold into Falling). Defaults to false to - /// preserve normal smooth transitions for everything else. - /// - /// Check whether the underlying MotionTable contains a cycle for the - /// given (style, motion) pair. Useful for callers that want to fall - /// back to a known-good motion (e.g. WalkForward → - /// Ready) instead of triggering 's - /// unconditional ClearCyclicTail path on a missing cycle — - /// which leaves the body without any animation tail and snaps every - /// part to the setup-default offset (visible as "torso on the - /// ground" since most creatures' setup-default has limbs at the - /// torso origin). - /// - public bool HasCycle(uint style, uint motion) + public void SetCycle(uint style, uint motion, float speedMod = 1f) { - // adjust_motion remapping (mirrors the head of SetCycle): - // TurnLeft, SideStepLeft, WalkBackward map to their right/forward - // mirror cycles. - uint adjustedMotion = motion; - switch (motion & 0xFFFFu) - { - case 0x000E: adjustedMotion = (motion & 0xFFFF0000u) | 0x000Du; break; - case 0x0010: adjustedMotion = (motion & 0xFFFF0000u) | 0x000Fu; break; - case 0x0006: adjustedMotion = (motion & 0xFFFF0000u) | 0x0005u; break; - } - int cycleKey = (int)(((style & 0xFFFFu) << 16) | (adjustedMotion & 0xFFFFFFu)); - return _mtable.Cycles.ContainsKey(cycleKey); - } + EnsureInitialized(); - public void SetCycle(uint style, uint motion, float speedMod = 1f, bool skipTransitionLink = false) - { - // ── adjust_motion: remap left→right / backward→forward variants ─── - // ACE MotionInterp.cs:394-428. The MotionTable never stores TurnLeft, - // SideStepLeft, or WalkBackward cycles; the client plays the mirror - // animation with a negated speed so it runs backward. + // ── Q4 boundary normalization (adjust_motion cyclic subset) ─────── + // Retail adjusts BEFORE the table sees the motion (CMotionInterp:: + // adjust_motion, R3 scope) — the interpreted state on the wire is + // already post-adjustment, so remote-driven callers never pass these. + // GameWindow's LOCAL-player path (UpdatePlayerAnimation) still passes + // raw TurnLeft/SideStepLeft/WalkBackward, so the adapter normalizes + // ONCE at this boundary. DELETED in R3-W6 when the local player + // unifies onto MotionInterpreter (r3-port-plan.md J15). uint adjustedMotion = motion; float adjustedSpeed = speedMod; switch (motion & 0xFFFFu) @@ -422,336 +382,34 @@ public sealed class AnimationSequencer break; } - // Fast-path: already playing this exact motion. - // - // Retail (ACE MotionTable.cs:132-139): when motion == current and - // sign(speedMod) matches, DON'T restart the cycle — just rescale the - // in-flight cyclic-tail's framerate via multiply_cyclic_animation_framerate. - // This keeps the run/walk loop smooth when a new UpdateMotion arrives - // with a different ForwardSpeed (e.g. when the server broadcasts a - // player's updated RunRate mid-step). - // - // **Sign-flip case (2026-05-02):** when the server sends adjust_motion'd - // backward walk as `WalkForward + speed=-N`, motion stays 0x45000005 - // but speedMod sign flips. We MUST do a full cycle restart in that case - // so the new (negative) framerate takes effect; otherwise the cycle - // keeps playing forward with the old positive framerate and the - // observer sees the player walking forward despite the negative speed. - if (CurrentStyle == style && CurrentMotion == motion - && _firstCyclic != null && _queue.Count > 0 - && MathF.Sign(speedMod) == MathF.Sign(CurrentSpeedMod)) - { - if (MathF.Abs(speedMod - CurrentSpeedMod) > 1e-4f - && MathF.Abs(CurrentSpeedMod) > 1e-6f) - { - MultiplyCyclicFramerate(speedMod / CurrentSpeedMod); - CurrentSpeedMod = speedMod; - } + // ── R2-Q4: dispatch through the verbatim motion-selection stack ─── + // Style change first (style-class ids route GetObjectSequence + // Branch 1 — exit link + entry hop + target style's default cycle), + // then the motion itself (Branch 2 cycle / 3 action / 4 modifier; + // the Branch-2 fast re-speed path replaces the old adapter + // fast-path, remove_redundant_links replaces Fix B, get_link's + // reversed-key double-hop replaces the stop-anim fallback). + if (style != 0 && style != _state.Style) + _manager.PerformMovement(MotionTableMovement.Interpreted(style, 1f)); - // D3 (Commit A 2026-05-03): SCFAST — proves whether the fast-path - // is firing instead of the full rebuild. Throttled to 0.5s per - // instance (re-throttled after A.1 unthrottled experiment). - if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") - { - double nowSec = (System.DateTime.UtcNow - System.DateTime.UnixEpoch).TotalSeconds; - if (nowSec - _lastSetCycleDiagTime > 0.5) - { - System.Console.WriteLine( - $"[SCFAST] motion=0x{motion:X8} speedMod={speedMod:F3} " - + $"oldSpeedMod={CurrentSpeedMod:F3} " - + $"qCount={_queue.Count} " - + $"currNodeIsCyclic={(_currNode == _firstCyclic)}"); - _lastSetCycleDiagTime = nowSec; - } - } + // Motion via the PerformMovement passthrough (velocity synthesis on + // success — same helper the R2-Q5 funnel sink path uses; the + // adjusted motion + adjusted speed produce the identical synthesis + // result as the original pair). + uint dispatchResult = PerformMovement( + MotionTableMovement.Interpreted(adjustedMotion, adjustedSpeed)); + + // R3-W4: the K-fix18 skipTransitionLink flag is DELETED — the + // instant-Falling engage is now retail's own mechanism: the entity's + // MotionInterpreter.LeaveGround (0x00528b00) fires the + // RemoveLinkAnimations seam (bound to this sequencer's + // RemoveAllLinkAnimations) when the body leaves the ground. + + // Failed dispatch (missing cycle for this style, is_allowed reject): + // retail leaves sequence AND state untouched — no synthesis either. + // (Velocity synthesis already ran inside PerformMovement on success.) + if (dispatchResult != MotionTableManagerError.Success) return; - } - - // Resolve transition link (currentSubstate → adjustedMotion). Pass - // both speeds — GetLink switches lookup branches based on sign. - // CurrentSpeedMod defaults to 1.0 (positive) on a fresh sequencer, - // so a Ready → WalkBackward transition correctly enters GetLink's - // negative-speed (reversed-key) branch. - // K-fix18: when the caller asked to skip the transition link - // (instant-engage cases like Falling on jump start), force - // linkData to null so only the cycle gets enqueued. - MotionData? linkData = (skipTransitionLink || CurrentMotion == 0) - ? null - : GetLink(style, CurrentMotion, CurrentSpeedMod, adjustedMotion, adjustedSpeed); - - // Stop-anim fallback: dat-authored leg-settle / turn-stop links are - // keyed under the FORWARD/RIGHT variant only. Stopping from - // WalkBackward / SideStepLeft / TurnLeft hits a null linkData and - // would visibly snap to Ready. The settle anim is direction-agnostic - // (legs come to standing the same way regardless of which way you - // were walking), so retry GetLink with the substate's low-byte - // remapped to its forward/right peer. - if (linkData is null && !skipTransitionLink && CurrentMotion != 0) - { - uint substateLow = CurrentMotion & 0xFFu; - uint adjustedSubstate = substateLow switch - { - 0x06u => (CurrentMotion & 0xFFFFFF00u) | 0x05u, // WalkBackward → WalkForward - 0x10u => (CurrentMotion & 0xFFFFFF00u) | 0x0Fu, // SideStepLeft → SideStepRight - 0x0Eu => (CurrentMotion & 0xFFFFFF00u) | 0x0Du, // TurnLeft → TurnRight - _ => CurrentMotion, - }; - if (adjustedSubstate != CurrentMotion) - { - linkData = GetLink(style, adjustedSubstate, CurrentSpeedMod, adjustedMotion, adjustedSpeed); - } - } - - // Resolve target cycle using the ADJUSTED motion (TurnRight not TurnLeft). - int cycleKey = (int)(((style & 0xFFFFu) << 16) | (adjustedMotion & 0xFFFFFFu)); - _mtable.Cycles.TryGetValue(cycleKey, out var cycleData); - - // Clear the old cyclic tail; keep any non-cyclic head that hasn't - // been played yet (ACE behaviour: non-cyclic anims drain naturally). - ClearCyclicTail(); - - // K-fix18: when the caller asked for instant-engage, ALSO drain - // any in-flight non-cyclic transition frames from the previous - // cycle. Without this, the old RunForward → ??? link would - // continue draining for ~100 ms before the new Falling cycle - // starts, defeating the "skip the link" intent. - if (skipTransitionLink) - { - _queue.Clear(); - _currNode = null; - _firstCyclic = null; - _framePosition = 0.0; - } - - // Clear sequence-wide physics before the rebuild. Retail's - // GetObjectSequence calls sequence.clear_physics() before each - // add_motion chain (MotionTable.cs L100-L101, L152-L153). - ClearPhysics(); - - // Snapshot the queue tail BEFORE appending new motion data so we - // can locate the first newly-added node afterward and force - // _currNode onto it. Without this, _currNode can stay pointing - // into stale non-cyclic head frames left over from the previous - // cycle (typically a Walk_link or Ready_link's tail), and the - // visible animation continues playing those stale frames before - // the queue advances naturally to the new cycle. For remote - // entities receiving many bundled UMs over time, this stale-head - // build-up was the root cause of "transitions between cycles - // don't visibly switch the leg pose" even though SetCycle's - // CurrentMotion/CurrentSpeedMod were updated correctly. Local - // player avoided the bug because PlayerMovementController fires - // SetCycle in a tight per-input loop that keeps the queue clean. - var preEnqueueTail = _queue.Last; - - // Enqueue link frames (with adjusted speed for left→right remapping). - if (linkData is { Anims.Count: > 0 }) - EnqueueMotionData(linkData, adjustedSpeed, isLooping: false); - - // Enqueue new cycle. - if (cycleData is { Anims.Count: > 0 }) - { - EnqueueMotionData(cycleData, adjustedSpeed, isLooping: true); - } - else if (_queue.Count == 0) - { - // No cycle and no link — nothing to play; reset fully. - _currNode = null; - _firstCyclic = null; - _framePosition = 0.0; - CurrentStyle = style; - CurrentMotion = motion; - return; - } - - // Mark the first cyclic node (the looping tail after all link frames). - _firstCyclic = null; - for (var n = _queue.First; n != null; n = n.Next) - { - if (n.Value.IsLooping) - { - _firstCyclic = n; - break; - } - } - - // Force _currNode onto the FIRST NEWLY-ENQUEUED node so the - // visible animation switches to the new cycle/link immediately - // instead of finishing whatever stale head frames were sitting - // at the front of the queue. preEnqueueTail.Next is the first - // newly-added node; if preEnqueueTail was null (queue was empty - // before enqueue), the first new node is _queue.First. - var firstNew = preEnqueueTail is null ? _queue.First : preEnqueueTail.Next; - - // #39 Fix B (2026-05-06): for direct cyclic-locomotion → - // cyclic-locomotion transitions (Walk↔Run on Shift toggle, - // W↔S direct flip, A↔D, Forward↔Strafe), land _currNode on - // the new CYCLE (_firstCyclic), NOT on the link (firstNew), - // and remove the just-enqueued link from the queue. - // - // Why: the transition link's drain time (~100–300 ms at - // Framerate 30 × link runSpeed) gets restarted before it can - // end if the user toggles Shift faster than that. _currNode - // sits on a fresh link every UM and Advance never reaches - // the cycle. User observes "blips forward in walking - // animation" — what they're seeing is the link's - // interpolation pose, never the new cycle. - // - // Conditional on BOTH old AND new being locomotion cycles to - // avoid regressing the cases where the link IS the right - // animation: - // - Idle (Ready) → any cycle: link is the wind-up pose - // - Falling → Ready: landing animation - // - Ready → Sitting/Crouching: pose-change links - // - Combat substates (attack/parry/ready transitions) - // Commit c06b6c5 (reverted in a2ae2ae) demonstrated that - // unconditionally skipping the link breaks all of these. - // - // Retail reference: cdb live trace 2026-05-03 of a Walk→Run - // direct transition logged - // add_to_queue(45000005, looping=1) walk - // add_to_queue(44000007, looping=1) run - // with truncate_animation_list never firing — i.e. retail - // appends the new cycle directly without a separate link - // enqueue or visible link pose for cyclic→cyclic. Our - // structural mismatch was always enqueueing link+cycle and - // forcing _currNode onto the link; this fix matches retail's - // observed semantics for the locomotion subset. - bool prevIsLocomotion = IsLocomotionCycleLowByte(CurrentMotion & 0xFFu); - bool newIsLocomotion = IsLocomotionCycleLowByte(motion & 0xFFu); - if (prevIsLocomotion && newIsLocomotion && _firstCyclic is not null) - { - // Drop the just-enqueued link node (firstNew) from the - // queue if it's distinct from the cycle — nothing should - // ever play it, and leaving stale non-cyclic nodes ahead - // of _currNode contributes to the unbounded queue growth - // observed in [SCFULL] (qCount climbing past 49 over - // ~30 transitions). - if (firstNew is not null && firstNew != _firstCyclic) - { - _queue.Remove(firstNew); - } - _currNode = _firstCyclic; - _framePosition = _firstCyclic.Value.GetStartFramePosition(); - } - else if (firstNew is not null) - { - _currNode = firstNew; - _framePosition = _currNode.Value.GetStartFramePosition(); - } - else if (_currNode == null) - { - // Defensive fallback: nothing newly added AND no current node. - _currNode = _queue.First; - _framePosition = _currNode?.Value.GetStartFramePosition() ?? 0.0; - - // D4 (Commit A 2026-05-03): SCNULLFALLBACK — proves whether the - // null-data fallback is being hit. If this fires during a - // Walk→Run transition for the watched remote, H4 (MotionTable - // GetLink/GetCycle returns null for the remote's setup) is the - // bug. linkData/cycleData null almost certainly means a - // MotionTable lookup gap for that style+motion combo. - if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") - { - System.Console.WriteLine( - $"[SCNULLFALLBACK] motion=0x{motion:X8} adjustedMotion=0x{adjustedMotion:X8} " - + $"linkNull={(linkData is null)} cycleNull={(cycleData is null)} " - + $"qCount={_queue.Count}"); - } - } - - // D3 (Commit A 2026-05-03): SCFULL — counterpart to SCFAST. Fires on - // the full-rebuild SetCycle path. Throttled to 0.5s per instance. - // Logs prev CurrentMotion so the line shows the transition directly - // (e.g. "Run → Ready" = cycle just got reset). - if (System.Environment.GetEnvironmentVariable("ACDREAM_REMOTE_VEL_DIAG") == "1") - { - double nowSec = (System.DateTime.UtcNow - System.DateTime.UnixEpoch).TotalSeconds; - if (nowSec - _lastSetCycleDiagTime > 0.5) - { - System.Console.WriteLine( - $"[SCFULL] prev=0x{CurrentMotion:X8} -> motion=0x{motion:X8} adjustedMotion=0x{adjustedMotion:X8} " - + $"speedMod={speedMod:F3} " - + $"qCount={_queue.Count} " - + $"firstNewNull={(firstNew is null)} " - + $"currNodeIsCyclic={(_currNode == _firstCyclic)} " - + $"firstCyclicNull={(_firstCyclic is null)}"); - _lastSetCycleDiagTime = nowSec; - } - } - - CurrentStyle = style; - CurrentMotion = motion; - CurrentSpeedMod = speedMod; - - // ── Synthesize CurrentVelocity for locomotion cycles ────────────── - // The Humanoid motion table ships every locomotion MotionData with - // Flags=0x00 (no HasVelocity), so EnqueueMotionData leaves - // CurrentVelocity at Vector3.Zero. That matches the literal retail - // dat, but retail's body physics uses CMotionInterp::get_state_velocity - // (FUN_00528960) which returns RunAnimSpeed × ForwardSpeed for - // RunForward, independent of the dat's HasVelocity flag. The dat - // velocity is a separate additive source (kick-off velocity, flying - // creatures, etc) not the primary locomotion drive. - // - // For our sequencer's to be usable by - // consumers (local-player get_state_velocity via Option B, remote - // dead-reckoning in GameWindow) it must carry the retail-constant - // locomotion value when the dat is silent. Synthesize it here, - // post-EnqueueMotionData, only when the cycle is a locomotion cycle - // AND the dat didn't populate it. - // - // Constants match etc — - // decompiled from _DAT_007c96e0/e4/e8. The velocity is body-local - // (+Y = forward, +X = right); consumers rotate into world space via - // the owning entity's orientation. - // For known locomotion cycles, ALWAYS overwrite CurrentVelocity with - // the synthesized value — even if the transition link set - // CurrentVelocity from its own HasVelocity flag. The link's velocity - // is for the brief transition (e.g. small stride into run-pose); the - // cycle's intended steady-state velocity is what consumers (remote - // body translation in GameWindow.TickAnimations env-var path) need. - // Without this, walking-to-running transitions left CurrentVelocity - // at the link's slow pace, and the user reported "it just blips - // forward walking" until another motion command (turn, etc) forced - // a re-synth. The gate that previously read - // `if (CurrentVelocity.LengthSquared() < 1e-9f)` allowed dat-baked - // velocity to win over synthesis — which is correct for non- - // locomotion (e.g. flying creatures with HasVelocity) but wrong for - // Humanoid run/walk/strafe where the dat is silent and the link - // velocity is the only thing setting it. - { - float yvel = 0f; - float xvel = 0f; - uint low = motion & 0xFFu; - bool isLocomotion = false; - switch (low) - { - case 0x05: // WalkForward - yvel = WalkAnimSpeed * adjustedSpeed; - isLocomotion = true; - break; - case 0x06: // WalkBackward — adjust_motion remapped to WalkForward - // with speedMod *= -0.65f. - yvel = WalkAnimSpeed * adjustedSpeed; - isLocomotion = true; - break; - case 0x07: // RunForward - yvel = RunAnimSpeed * adjustedSpeed; - isLocomotion = true; - break; - case 0x0F: // SideStepRight - xvel = SidestepAnimSpeed * adjustedSpeed; - isLocomotion = true; - break; - case 0x10: // SideStepLeft — remapped to SideStepRight with - // negated speed; same handling as backward walk. - xvel = SidestepAnimSpeed * adjustedSpeed; - isLocomotion = true; - break; - } - if (isLocomotion) - CurrentVelocity = new Vector3(xvel, yvel, 0f); - } // ── Synthesize CurrentOmega for turn cycles ─────────────────────── // Same story as velocity synthesis above: Humanoid turn MotionData @@ -762,7 +420,7 @@ public sealed class AnimationSequencer // chunk_00520000.c TurnRate globals (~π/2 rad/s for speed=1) // The ACE port uses `omega.z = ±(π/2) × turnSpeed` for right/left // turns (holtburger confirms the same via motion_resolution.rs). - if (CurrentOmega.LengthSquared() < 1e-9f) + if (_core.Omega.LengthSquared() < 1e-9f) { float zomega = 0f; uint low = motion & 0xFFu; @@ -783,10 +441,91 @@ public sealed class AnimationSequencer break; } if (zomega != 0f) - CurrentOmega = new Vector3(0f, 0f, zomega); + _core.SetOmega(new Vector3(0f, 0f, zomega)); } } + /// + /// R3-W4: the retail link-strip primitive + /// (CPhysicsObj::RemoveLinkAnimations 0x0050fe20 → + /// CSequence::remove_all_link_animations 0x00524ca0). The App + /// binds the entity's MotionInterpreter.RemoveLinkAnimations seam + /// here so HitGround/LeaveGround strip pending transition links exactly + /// where retail does. The pending-queue tick counts intentionally stay + /// (retail's primitive does not touch the manager queue; the countdown + /// chain absorbs it). + /// + public void RemoveAllLinkAnimations() => _core.RemoveAllLinkAnimations(); + + /// + /// R2-Q5: run retail's enter_default_state analog now if it + /// hasn't run yet (idempotent). Spawn paths call this so an entity with + /// no initial wire motion still plays the table default (retail: every + /// CPhysicsObj entering the world runs initialize_state). + /// + public void InitializeState() => EnsureInitialized(); + + /// + /// R2-Q5: the single dispatch entry — lazy initialize_state, then + /// , then (on a + /// successful InterpretedCommand) the locomotion velocity synthesis + /// (register AP-75; the consumers are remote body translation via + /// RemoteMotionCombiner.ComputeOffset and the local Option-B + /// get_state_velocity — retire in R6 when root motion drives the body). + /// Omega is deliberately NOT synthesized here: remote rotation is the + /// ObservedOmega seam (MotionTableDispatchSink callbacks, retire R6); + /// only the SetCycle path keeps the turn-omega fallback. + /// + public uint PerformMovement(MotionTableMovement movement) + { + EnsureInitialized(); + uint result = _manager.PerformMovement(movement); + if (result == MotionTableManagerError.Success + && movement.Type == MovementType.InterpretedCommand) + { + SynthesizeLocomotionVelocity(movement.Motion, movement.Speed); + } + return result; + } + + /// + /// Overwrite sequence velocity with the retail locomotion constant when + /// the dispatched motion is a locomotion cycle. The Humanoid motion + /// table ships every locomotion MotionData with a zero Velocity, so + /// add_motion's unconditional set leaves the sequence at zero — + /// but retail's body physics uses CMotionInterp::get_state_velocity + /// (0x00528960: RunAnimSpeed × ForwardSpeed etc., independent of the + /// dat), so consumers of need the + /// constant here. Velocity is body-local (+Y forward, +X right); + /// consumers rotate into world space via the entity orientation. + /// Constants decompiled from _DAT_007c96e0/e4/e8. + /// + private void SynthesizeLocomotionVelocity(uint motion, float speed) + { + float yvel = 0f; + float xvel = 0f; + bool isLocomotion = false; + switch (motion & 0xFFu) + { + case 0x05: // WalkForward + case 0x06: // WalkBackward (pre-adjust callers; adjusted = 0x05) + yvel = WalkAnimSpeed * speed; + isLocomotion = true; + break; + case 0x07: // RunForward + yvel = RunAnimSpeed * speed; + isLocomotion = true; + break; + case 0x0F: // SideStepRight + case 0x10: // SideStepLeft (pre-adjust callers; adjusted = 0x0F) + xvel = SidestepAnimSpeed * speed; + isLocomotion = true; + break; + } + if (isLocomotion) + _core.SetVelocity(new Vector3(xvel, yvel, 0f)); + } + // Retail locomotion constants — mirror of MotionInterpreter.RunAnimSpeed // etc. Kept here to keep AnimationSequencer self-contained for the // synthesize-velocity path above. Values decompiled from _DAT_007c96e0/e4/e8. @@ -794,64 +533,23 @@ public sealed class AnimationSequencer private const float RunAnimSpeed = 4.0f; private const float SidestepAnimSpeed = 1.25f; - /// - /// Scale every cyclic node's framerate by , mirroring - /// ACE's Sequence.multiply_cyclic_animation_framerate - /// (references/ACE/Source/ACE.Server/Physics/Animation/Sequence.cs L277-L287, - /// retail decompile FUN_00525CE0). Walks _firstCyclic through - /// the tail of the queue and calls - /// on each. The non-cyclic head (link frames) is untouched — those drain - /// at their original framerate, which matches retail: the sequencer - /// "catches up" the transition before applying the new run speed. - /// - /// - /// Called from when the same (style, motion) pair - /// is re-issued with a different speedMod — for instance, when a remote - /// player's ForwardSpeed changes mid-run. Does NOT restart the animation, - /// so footsteps keep planting where they are. - /// - /// - /// Framerate multiplier (newSpeed / oldSpeed). - public void MultiplyCyclicFramerate(float factor) - { - if (_firstCyclic == null) return; - if (factor < 0f || float.IsNaN(factor) || float.IsInfinity(factor)) - return; - - for (var node = _firstCyclic; node != null; node = node.Next) - { - node.Value.MultiplyFramerate((double)factor); - } - - // Sequence-wide velocity/omega scale too. Retail's flow is - // subtract_motion(oldSpeed) + combine_motion(newSpeed) in - // MotionTable.change_cycle_speed (MotionTable.cs L372-L379), which - // algebraically equals scaling by newSpeed/oldSpeed — exactly - // what the factor represents here. - CurrentVelocity *= factor; - CurrentOmega *= factor; - } + // R2-Q4: MultiplyCyclicFramerate DELETED (zero external callers). The + // gap-map-G13 composite stand-in (framerate scale + velocity/omega + // rescale) is retired — same-motion re-speeds now route through the + // verbatim CMotionTable fast re-speed path (change_cycle_speed + + // subtract_motion(old) + combine_motion(new), decomp §5). /// /// Advance the animation by seconds and return the /// per-part transforms for the current blended keyframe. /// /// - /// Implements Sequence::update_internal (FUN_005261D0 / ACE - /// Sequence.cs:351-443): walks every integer frame boundary crossed in - /// this tick, calls execute_hooks for each with the playback - /// direction, and accumulates root - /// motion into the pending delta. Hooks fire only once per crossing - /// regardless of framerate scaling. - /// - /// - /// - /// Crossing semantics (forward): as floor(framePos) increments - /// from i to i+1, hooks attached to frame i with - /// direction Forward or Both fire. Reverse: as - /// floor(framePos) decrements from i to i-1, - /// hooks with direction Backward or Both fire on frame - /// i. + /// R1-P5: delegates all frame-advance math to + /// (the verbatim update/update_internal/ + /// advance_to_next_animation port — gap map G3/G4/G5/G8/G9/G19). + /// The core queues hooks through into + /// ; this method only builds the blended + /// render-side output. /// /// /// Elapsed time in seconds since the last call. @@ -860,100 +558,35 @@ public sealed class AnimationSequencer /// If no animation is loaded, all parts get identity transforms. /// public IReadOnlyList Advance(float dt) + => Advance(dt, rootMotionFrame: null); + + /// + /// R1-P6 (gap map G7): the root-motion overload. When + /// is supplied, the core's + /// update/update_internal apply BOTH root-motion sources + /// into it exactly as retail's CPartArray::Update path does — + /// the per-crossed-frame PosFrames combine/subtract AND the + /// sequence velocity/omega via apply_physics (0x00524ab0). This + /// is the seam R6's retail per-tick order consumes + /// (UpdatePositionInternal → CPartArray.Update → adjust_offset → + /// Frame.combine). + /// + public IReadOnlyList Advance(float dt, Frame? rootMotionFrame) { int partCount = _setup.Parts.Count; - if (_currNode == null || dt <= 0f) + if (_core.CurrAnim == null && rootMotionFrame is null) return BuildIdentityFrame(partCount); + if (dt <= 0f) + return _core.CurrAnim == null + ? BuildIdentityFrame(partCount) + : BuildBlendedFrame(); - // ── update_internal (FUN_005261D0 / ACE Sequence.update_internal) ─ - // Loop because a large dt can exhaust multiple nodes sequentially. - double timeRemaining = (double)dt; - int safety = 64; // cap in case of a degenerate motion table + _core.Update(dt, rootMotionFrame); - while (timeRemaining > 0.0 && _currNode != null && safety-- > 0) - { - var curr = _currNode.Value; - double rate = curr.Framerate; // signed (negative = reverse) - double delta = rate * timeRemaining; - - if (Math.Abs(delta) < RateEpsilon) - break; // rate ≈ 0 — nothing to do - - // lastFrame = floor(_framePosition) BEFORE advance (ACE pattern). - int lastFrame = (int)Math.Floor(_framePosition); - - double newPos = _framePosition + delta; - bool wrapped = false; - double overflow = 0.0; - - if (delta > 0.0) - { - // ── FORWARD PLAYBACK ────────────────────────────────────── - double maxBoundary = (double)(curr.EndFrame + 1); - if (newPos >= maxBoundary - FrameEpsilon) - { - // Time spilled past the boundary. - overflow = (newPos - maxBoundary) / rate; - if (overflow < 0.0) overflow = 0.0; - - _framePosition = maxBoundary - FrameEpsilon; - wrapped = true; - } - else - { - _framePosition = newPos; - } - - // Walk every integer frame boundary crossed: apply posFrame - // delta and fire hooks with Forward direction. - while ((int)Math.Floor(_framePosition) > lastFrame) - { - ApplyPosFrame(curr, lastFrame, reverse: false); - ExecuteHooks(curr, lastFrame, AnimationHookDir.Forward); - lastFrame++; - } - } - else - { - // ── REVERSE PLAYBACK ───────────────────────────────────── - double minBoundary = (double)curr.StartFrame; - if (newPos <= minBoundary) - { - overflow = (newPos - minBoundary) / rate; - if (overflow < 0.0) overflow = 0.0; - - _framePosition = minBoundary; - wrapped = true; - } - else - { - _framePosition = newPos; - } - - // Walk every integer boundary crossed DOWN: subtract posFrame - // delta and fire hooks with Backward direction. - while ((int)Math.Floor(_framePosition) < lastFrame) - { - ApplyPosFrame(curr, lastFrame, reverse: true); - ExecuteHooks(curr, lastFrame, AnimationHookDir.Backward); - lastFrame--; - } - } - - if (!wrapped) - break; // consumed all dt without hitting node boundary — done - - // ── advance_to_next_animation (FUN_00525EB0) ───────────────── - // Fire AnimationDone for any drained link node before wrap. - if (_currNode != null && !_currNode.Value.IsLooping) - _pendingHooks.Add(AnimationDoneSentinel); - - AdvanceToNextAnimation(); - timeRemaining = overflow; // continue with leftover time - } - - return BuildBlendedFrame(); + return _core.CurrAnim == null + ? BuildIdentityFrame(partCount) + : BuildBlendedFrame(); } /// @@ -971,454 +604,106 @@ public sealed class AnimationSequencer return result; } - /// - /// Retrieve and clear the root-motion displacement accumulated from - /// during the last - /// calls. Returns (Zero, Identity) when no PosFrames exist on the - /// current animation. The caller should combine this with their AFrame - /// (object placement) to propagate root motion — e.g. baked-in footsteps - /// on a running animation. - /// - public (Vector3 Position, Quaternion Rotation) ConsumeRootMotionDelta() - { - var result = (_rootMotionPos, _rootMotionRot); - _rootMotionPos = Vector3.Zero; - _rootMotionRot = Quaternion.Identity; - return result; - } + // R1-P6: ConsumeRootMotionDelta DELETED (zero external callers; gap map + // API-migration table). Root motion flows through the + // Advance(dt, Frame) overload — retail's CSequence::update(Frame*) + // contract — for R6's per-tick wiring. /// - /// Play a one-shot action/modifier motion (Jump, emote, attack, etc.) - /// on top of the current cycle. The action frames are inserted in the - /// queue immediately before the looping cyclic tail; they drain once - /// and then the cycle resumes naturally. + /// Play a one-shot action / modifier motion (Jump, emote, attack, etc.) + /// on top of the current cycle. /// /// - /// Retail semantics: actions and modifiers live in - /// (a separate dict from - /// ) keyed by - /// (style << 16) | (motion & 0xFFFFFF). A motion like - /// Jump = 0x2500003b is a Modifier (class byte 0x25) not a - /// SubState — feeding it to silently fails the - /// cycle lookup. Routing through PlayAction instead resolves - /// from the Modifiers table and interleaves the action frames with - /// the ongoing cyclic motion. - /// - /// - /// - /// If no entry is found in the Modifiers table for the requested - /// motion, this is a no-op. + /// R2-Q4: a thin shim over + /// — action-class ids + /// (0x10000000) route GetObjectSequence Branch 3 (rebuild: + /// substate→action link + base cycle re-added, the action tracked on the + /// MotionState action FIFO and popped by the manager's countdown); + /// modifier-class ids (0x20000000) route Branch 4 (PHYSICS-ONLY + /// combine_motion — no animation frames; the pre-Q4 + /// insert-before-tail modifier-anim mechanism was an acdream invention, + /// deleted). Unknown ids fail the dispatch and are a no-op, matching the + /// pre-Q4 contract. /// /// /// Raw MotionCommand (e.g. 0x2500003b for Jump). /// Speed multiplier for the action's framerate. public void PlayAction(uint motionCommand, float speedMod = 1f) { - // Resolve motion data. The lookup depends on the command's mask class: - // - // - Action (mask 0x10): stored in the Links dict as the transition - // FROM currentSubstate TO the action motion. Matches ACE - // MotionTable.GetObjectSequence @ line 189-207 (CommandMask.Action). - // - Modifier (mask 0x20): stored in the Modifiers dict, keyed by - // (style<<16) | (motion&0xFFFFFF) (or unstyled key). Matches ACE - // @ line 234-242 (CommandMask.Modifier). - // - // Jump (0x2500003B) has BOTH bits set (0x20|0x04|0x01) but ACE treats - // it via the Modifier path. FallDown (0x10000050) / Jumpup (0x1000004B) - // are pure Actions (mask 0x10) and live in Links. - // - // We try Links first (via GetLink, which reproduces ACE's get_link - // fallback chain). If that fails and the motion is a Modifier, fall - // through to the Modifiers dict. - const uint ActionMask = 0x10000000u; - const uint ModifierMask = 0x20000000u; - - MotionData? data = null; - if ((motionCommand & ActionMask) != 0 && CurrentMotion != 0) - { - // Action: look up the transition link from current substate → action. - // Action overlays always play forward (positive speeds) — the - // action speed mod is the caller-supplied modifier, not part of - // the substate cycle's direction. - data = GetLink(CurrentStyle, CurrentMotion, /*substateSpeed:*/ 1f, motionCommand, /*speed:*/ 1f); - } - if (data is null && (motionCommand & ModifierMask) != 0) - { - uint styleKey = CurrentStyle << 16; - int keyStyled = (int)(styleKey | (motionCommand & 0xFFFFFFu)); - int keyPlain = (int)(motionCommand & 0xFFFFFFu); - if (!_mtable.Modifiers.TryGetValue(keyStyled, out data)) - _mtable.Modifiers.TryGetValue(keyPlain, out data); - } - - if (data is null || data.Anims.Count == 0) - return; - - // Build AnimNodes from the action's AnimData list. All non-looping — - // they drain once, then the queue falls through to _firstCyclic. - Vector3 vel = data.Flags.HasFlag(MotionDataFlags.HasVelocity) - ? data.Velocity * speedMod : Vector3.Zero; - Vector3 omg = data.Flags.HasFlag(MotionDataFlags.HasOmega) - ? data.Omega * speedMod : Vector3.Zero; - - var newNodes = new List(data.Anims.Count); - for (int i = 0; i < data.Anims.Count; i++) - { - var node = LoadAnimNode(data.Anims[i], speedMod, isLooping: false, vel, omg); - if (node != null) newNodes.Add(node); - } - if (newNodes.Count == 0) return; - - // Insert before the cyclic tail (so the action plays, then cycle resumes). - // If there's no cyclic tail yet, append at the end. - LinkedListNode? firstInserted = null; - if (_firstCyclic != null) - { - foreach (var n in newNodes) - { - var inserted = _queue.AddBefore(_firstCyclic, n); - firstInserted ??= inserted; - } - } - else - { - foreach (var n in newNodes) - { - var inserted = _queue.AddLast(n); - firstInserted ??= inserted; - } - } - - // If we're currently on the cyclic tail (or past where we inserted), - // jump the cursor back to the first newly-inserted action node so the - // action plays immediately instead of after the next cycle wrap. - bool cursorOnCyclic = _currNode != null && _currNode.Value.IsLooping; - if (cursorOnCyclic || _currNode == null) - { - _currNode = firstInserted; - if (_currNode != null) - _framePosition = _currNode.Value.GetStartFramePosition(); - } + EnsureInitialized(); + _manager.PerformMovement(MotionTableMovement.Interpreted(motionCommand, speedMod)); } /// /// Reset the sequencer to an unplaying state without clearing the - /// motion table reference. + /// motion table reference. R2-Q4: drains the pending-animation queue + /// (exit-world semantics — each entry fires MotionDone(success:false)) + /// and zeroes the MotionState so the next SetCycle re-runs + /// initialize_state. /// public void Reset() { - _queue.Clear(); - _currNode = null; - _firstCyclic = null; - _framePosition = 0.0; + _manager.HandleExitWorld(); + _core.Clear(); _pendingHooks.Clear(); - _rootMotionPos = Vector3.Zero; - _rootMotionRot = Quaternion.Identity; - CurrentStyle = 0; - CurrentMotion = 0; - CurrentSpeedMod = 1f; - CurrentVelocity = Vector3.Zero; - CurrentOmega = Vector3.Zero; + _state.Style = 0; + _state.Substate = 0; + _state.SubstateMod = 1f; + _state.ClearModifiers(); + _state.ClearActions(); + _initialized = false; } // ── Private helpers ────────────────────────────────────────────────────── + /// + /// Host seam wiring the core's into this + /// adapter's list. Mirrors retail's + /// CPhysicsObj.anim_hooks SmartArray queue-then-drain model (gap + /// map G6): the core QUEUES matched hooks here during + /// ; + /// drains them at the render-tick call site (GameWindow), same as + /// pre-cutover. The AnimDone hook maps to the existing + /// singleton so downstream sinks + /// (AnimationHookRouter) see the same instance type they always have. + /// + private sealed class AdapterHookQueue : IAnimHookQueue + { + private readonly AnimationSequencer _owner; + public AdapterHookQueue(AnimationSequencer owner) => _owner = owner; + + public void AddAnimHook(AnimationHook hook) => _owner._pendingHooks.Add(hook); + + public void AddAnimDoneHook() => _owner._pendingHooks.Add(AnimationDoneSentinel); + } + // Sentinel hook fired when a non-cyclic link node drains naturally. // Mirrors ACE's PhysicsObj.add_anim_hook(AnimationHook.AnimDoneHook). private static readonly AnimationDoneHook AnimationDoneSentinel = new() { Direction = AnimationHookDir.Both }; - /// - /// Look up the transition MotionData for going from - /// (current state, played at ) to - /// (new state, played at ). - /// - /// - /// Port of ACE's MotionTable.get_link (MotionTable.cs:395-426). The lookup - /// path differs by sign of the speeds — the retail/ACE mechanism is two - /// distinct branches: - /// - /// Both speeds positive (forward → forward, normal case): - /// Look up Links[(style<<16) | substate][motion] — the link FROM - /// substate TO motion. Played forward. - /// Either speed negative (any direction reversal — - /// WalkBackward, SideStepLeft, TurnLeft): Look up the REVERSED key - /// Links[(style<<16) | motion][substate] — the link FROM motion TO - /// substate. Played in reverse, this anim visually transitions - /// substate → motion's pose, then the cycle continues from where it - /// left off. Without this branch, Ready→WalkBackward would queue the - /// "start walking forward" link played in reverse, which strands the - /// cursor at the wrong cycle frame and causes the user-visible - /// "left leg twitches forward two times" glitch on the X key. - /// - /// - /// - /// DatReaderWriter encodes Links as Dictionary<int, MotionCommandData> - /// where MotionCommandData.MotionData is Dictionary<int, MotionData>. - /// - private MotionData? GetLink(uint style, uint substate, float substateSpeed, uint motion, float speed) - { - if (speed < 0f || substateSpeed < 0f) - { - // Reversed-direction path: link FROM motion TO substate. - int reversedKey = (int)((style << 16) | (motion & 0xFFFFFFu)); - if (_mtable.Links.TryGetValue(reversedKey, out var revLink) - && revLink.MotionData.TryGetValue((int)substate, out var revResult)) - { - return revResult; - } + // R2-Q4: GetLink DELETED - re-homed verbatim as CMotionTable.GetLink + // (Q2, field-validated reversed-key branch preserved; Q0-pins A1). - // Style-defaults fallback per ACE MotionTable.cs:405-409. - if (_mtable.StyleDefaults.TryGetValue( - (DatReaderWriter.Enums.MotionCommand)style, out var defaultMotion)) - { - int subKey = (int)((style << 16) | (substate & 0xFFFFFFu)); - if (_mtable.Links.TryGetValue(subKey, out var subLink) - && subLink.MotionData.TryGetValue((int)defaultMotion, out var subResult)) - { - return subResult; - } - } - return null; - } - - // Forward-direction path: link FROM substate TO motion (the original - // implementation pre-K-fix6). - int outerKey1 = (int)((style << 16) | (substate & 0xFFFFFFu)); - if (_mtable.Links.TryGetValue(outerKey1, out var cmd1) - && cmd1.MotionData.TryGetValue((int)motion, out var result1)) - { - return result1; - } - - // Fallback: style-level catch-all (ACE line 419-422). - int outerKey2 = (int)(style << 16); - if (_mtable.Links.TryGetValue(outerKey2, out var cmd2) - && cmd2.MotionData.TryGetValue((int)motion, out var result2)) - { - return result2; - } - - return null; - } - - /// - /// Load an Animation from the dat by its - /// and resolve the sentinel frame bounds (HighFrame == -1 means "all frames"). - /// - private AnimNode? LoadAnimNode( - AnimData ad, - float speedMod, - bool isLooping, - Vector3 velocity, - Vector3 omega) - { - uint animId = (uint)ad.AnimId; - if (animId == 0) return null; - - var anim = _loader.LoadAnimation(animId); - if (anim is null || anim.PartFrames.Count == 0) return null; - - int numFrames = anim.PartFrames.Count; - int low = ad.LowFrame; - int high = ad.HighFrame; - - // Sentinel resolution (same as MotionResolver.GetIdleCycle). - if (high < 0) high = numFrames - 1; - if (low >= numFrames) low = numFrames - 1; - if (high >= numFrames) high = numFrames - 1; - if (low < 0) low = 0; - - double fr = (double)ad.Framerate * (double)speedMod; - - // Do NOT swap StartFrame↔EndFrame for negative speed. - // The Advance loop handles negative delta by checking against - // StartFrame as the lower boundary. GetStartFramePosition uses - // EndFrame (the HIGH value) to start the cursor near the top - // for reverse playback, so the cursor traverses all frames - // from high→low instead of being stuck in [0,1). - if (low > high) high = low; - - bool hasPosFrames = anim.Flags.HasFlag(AnimationFlags.PosFrames) - && anim.PosFrames.Count >= numFrames; - - return new AnimNode( - anim, - fr, - startFrame: low, - endFrame: high, - isLooping, - hasPosFrames, - velocity, - omega); - } - - /// - /// Reset the sequence's Velocity + Omega (retail Sequence.clear_physics, - /// ACE Sequence.cs L256-L260). Called before a style-transition rebuild - /// in SetCycle so we don't inherit velocity from the previous cycle. - /// - private void ClearPhysics() - { - CurrentVelocity = Vector3.Zero; - CurrentOmega = Vector3.Zero; - } - - /// - /// Append all AnimData entries from to the - /// queue. Each AnimData becomes one AnimNode. Velocity / Omega from the - /// MotionData are applied to every resulting node so they remain active - /// while the node is current. - /// - private void EnqueueMotionData(MotionData motionData, float speedMod, bool isLooping) - { - Vector3 vel = motionData.Flags.HasFlag(MotionDataFlags.HasVelocity) - ? motionData.Velocity * speedMod : Vector3.Zero; - Vector3 omg = motionData.Flags.HasFlag(MotionDataFlags.HasOmega) - ? motionData.Omega * speedMod : Vector3.Zero; - - // Sequence-wide velocity/omega update, matching ACE's - // MotionTable.add_motion (MotionTable.cs L358-L370): SetVelocity - // REPLACES the previous sequence velocity. When SetCycle enqueues - // link then cycle, the final CurrentVelocity is the cycle's — which - // is what dead-reckoning needs to read from the first frame of the - // link transition (the cycle velocity is already "queued up" even - // while a zero-velocity link plays visually). - // - // Only replace if HasVelocity (else we'd zero out a running cycle - // when a transient HasVelocity=0 modifier enqueues). Matches - // retail's conditional behavior: MotionData without HasVelocity - // doesn't touch the sequence velocity. - if (motionData.Flags.HasFlag(MotionDataFlags.HasVelocity)) - CurrentVelocity = vel; - if (motionData.Flags.HasFlag(MotionDataFlags.HasOmega)) - CurrentOmega = omg; - - for (int i = 0; i < motionData.Anims.Count; i++) - { - bool nodeCycling = isLooping && (i == motionData.Anims.Count - 1); - var node = LoadAnimNode(motionData.Anims[i], speedMod, nodeCycling, vel, omg); - if (node != null) - _queue.AddLast(node); - } - } - - /// - /// Remove all cyclic (looping) nodes from the tail of the queue starting - /// from . Non-cyclic link frames remain so they - /// can drain naturally. - /// - private void ClearCyclicTail() - { - if (_firstCyclic == null) return; - - var node = _firstCyclic; - while (node != null) - { - var next = node.Next; - // If the active node is being removed, jump it to the preceding - // non-cyclic node (or reset if there is none). - if (_currNode == node) - { - _currNode = node.Previous; - if (_currNode != null) - _framePosition = _currNode.Value.GetEndFramePosition(); - else - _framePosition = 0.0; - } - _queue.Remove(node); - node = next; - } - - _firstCyclic = null; - } - - /// - /// Move to the next node in the queue, or wrap - /// back to when the queue is exhausted. - /// - /// Implements FUN_00525EB0 (Sequence::advance_to_next_animation). - /// The retail client walks a doubly-linked list; we mirror that with - /// LinkedList.Next plus the _firstCyclic wrap sentinel. - /// - private void AdvanceToNextAnimation() - { - if (_currNode == null) return; - - LinkedListNode? next = _currNode.Next; - - if (next != null) - { - _currNode = next; - } - else if (_firstCyclic != null) - { - // Wrap to first cyclic node — this is the loop that keeps idle/walk - // animations playing forever. - _currNode = _firstCyclic; - } - // else: end of a finite non-looping sequence; stay on last node. - - if (_currNode != null) - _framePosition = _currNode.Value.GetStartFramePosition(); - } - - /// - /// Dispatch any hooks on the given part frame whose direction matches - /// the playback direction (or Both). Mirrors ACE's - /// Sequence.execute_hooks (Sequence.cs:262). - /// - private void ExecuteHooks(AnimNode node, int frameIndex, AnimationHookDir playbackDir) - { - if (frameIndex < 0 || frameIndex >= node.Anim.PartFrames.Count) return; - var frame = node.Anim.PartFrames[frameIndex]; - if (frame.Hooks.Count == 0) return; - - for (int i = 0; i < frame.Hooks.Count; i++) - { - var hook = frame.Hooks[i]; - if (hook == null) continue; - // ACE: hook.Direction == Both || hook.Direction == playbackDir - if (hook.Direction == AnimationHookDir.Both - || hook.Direction == playbackDir) - { - _pendingHooks.Add(hook); - } - } - } - - /// - /// Apply the (root motion) delta for - /// to the accumulated pending delta. - /// Mirrors ACE's AFrame.Combine (forward) / frame.Subtract - /// (backward) calls in update_internal. - /// - private void ApplyPosFrame(AnimNode node, int frameIndex, bool reverse) - { - if (!node.HasPosFrames) return; - var posFrames = node.Anim.PosFrames; - if (frameIndex < 0 || frameIndex >= posFrames.Count) return; - var pf = posFrames[frameIndex]; - - if (!reverse) - { - // AFrame.Combine: position += rot.Rotate(pf.Origin); rot *= pf.Orientation - _rootMotionPos += Vector3.Transform(pf.Origin, _rootMotionRot); - _rootMotionRot = Quaternion.Normalize(_rootMotionRot * pf.Orientation); - } - else - { - // AFrame.Subtract: rot *= conj(pf.Orientation); position -= rot.Rotate(pf.Origin) - var invRot = Quaternion.Conjugate(pf.Orientation); - _rootMotionRot = Quaternion.Normalize(_rootMotionRot * invRot); - _rootMotionPos -= Vector3.Transform(pf.Origin, _rootMotionRot); - } - } + // R2-Q4: BuildNode + EnqueueMotionData DELETED - MotionData appends are + // owned by CMotionTable.AddMotion (add_motion 0x005224b0, unconditional + // velocity/omega set = G17 core semantics; the adapter's HasVelocity/ + // HasOmega gate is retired with them). /// /// Build the per-part blended transform from the current animation frame. - /// Blends between floor(_framePosition) and floor(_framePosition)+1 using - /// the fractional part of _framePosition. + /// Blends between floor(FrameNumber) and floor(FrameNumber)+1 within the + /// CURRENT core node, using the fractional part of FrameNumber. + /// + /// + /// R1-P5: this is render-side interpolation, NOT CSequence scope (gap map + /// G19's "blend seam MED" note) — the core only tracks the floored + /// current frame (get_curr_animframe). The +1 index is clamped to + /// the node's /LowFrame window + /// (direction-aware) to preserve the pre-cutover #61 fix (link-tail + /// holds its end pose instead of blending into frame 0 of the next + /// node). + /// /// /// Uses the retail-client slerp () for /// quaternion interpolation and linear lerp for position. @@ -1427,49 +712,56 @@ public sealed class AnimationSequencer { int partCount = _setup.Parts.Count; - if (_currNode == null) + var curr = _core.CurrAnim; + if (curr is null || curr.Anim is null) return BuildIdentityFrame(partCount); - var curr = _currNode.Value; int numPartFrames = curr.Anim.PartFrames.Count; - // Clamp frameIndex to valid range. - int rangeLo = Math.Min(curr.StartFrame, curr.EndFrame); - int rangeHi = Math.Max(curr.StartFrame, curr.EndFrame); + // Clamp frameIndex to the node's valid window. + int rangeLo = Math.Min(curr.LowFrame, curr.HighFrame); + int rangeHi = Math.Max(curr.LowFrame, curr.HighFrame); rangeHi = Math.Min(rangeHi, numPartFrames - 1); + rangeLo = Math.Max(rangeLo, 0); - int frameIdx = (int)Math.Floor(_framePosition); + int frameIdx = (int)Math.Floor(_core.FrameNumber); frameIdx = Math.Clamp(frameIdx, rangeLo, rangeHi); // Next frame for interpolation: step in the playback direction. - // Wrap to opposite end ONLY for looping cyclic nodes. For one-shot - // nodes (link transitions, action overlays), hold the boundary - // frame instead — otherwise the fractional tail of the anim - // blends frame[end] with frame[0], producing a brief flash through - // the anim's starting pose at the link→cycle boundary (issue #61: - // door swing-open flap; run-stop twitch). + // Wrap to the opposite end ONLY when this node IS the cyclic tail + // (curr == first_cyclic). For one-shot nodes (link transitions, + // action overlays), hold the boundary frame instead — otherwise the + // fractional tail of the anim blends frame[end] with frame[0], + // producing a brief flash through the anim's starting pose at the + // link→cycle boundary (issue #61: door swing-open flap; run-stop + // twitch). This is render-side clamping, not a CSequence semantic. + bool nodeIsCyclic = ReferenceEquals(_core.CurrAnim, _core.FirstCyclic); int nextIdx; - if (curr.Framerate >= 0.0) + if (curr.Framerate >= 0f) { nextIdx = frameIdx + 1; if (nextIdx > rangeHi || nextIdx >= numPartFrames) - nextIdx = curr.IsLooping ? rangeLo : frameIdx; + nextIdx = nodeIsCyclic ? rangeLo : frameIdx; } else { nextIdx = frameIdx - 1; if (nextIdx < rangeLo) - nextIdx = curr.IsLooping ? rangeHi : frameIdx; + nextIdx = nodeIsCyclic ? rangeHi : frameIdx; } // Fractional blend weight (always in [0, 1]). - double rawT = _framePosition - Math.Floor(_framePosition); + double rawT = _core.FrameNumber - Math.Floor(_core.FrameNumber); float t = (float)Math.Clamp(rawT, 0.0, 1.0); var f0Parts = curr.Anim.PartFrames[frameIdx].Frames; var f1Parts = curr.Anim.PartFrames[nextIdx].Frames; - var result = new PartTransform[partCount]; + // MP-Alloc: overwrite the reusable per-instance buffer in place + // instead of allocating a fresh PartTransform[partCount] every call. + // Sized once in the constructor to _setup.Parts.Count, which never + // changes, so partCount here always matches the buffer length. + var result = _partTransformScratch; for (int i = 0; i < partCount; i++) { if (i < f0Parts.Count) @@ -1490,27 +782,20 @@ public sealed class AnimationSequencer return result; } - private static IReadOnlyList BuildIdentityFrame(int partCount) + private IReadOnlyList BuildIdentityFrame(int partCount) { - var result = new PartTransform[partCount]; + // MP-Alloc: same reusable buffer as BuildBlendedFrame (see + // _partTransformScratch) — overwritten in place, never reallocated. + var result = _partTransformScratch; for (int i = 0; i < partCount; i++) result[i] = new PartTransform(Vector3.Zero, Quaternion.Identity); return result; } - /// - /// True if the given motion-low-byte names a locomotion cycle — - /// WalkForward (0x05), WalkBackward (0x06), RunForward (0x07), - /// SideStepRight (0x0F), or SideStepLeft (0x10). - /// Used by to recognise cyclic→cyclic - /// direct transitions and bypass the transition link in that case - /// (retail's observed add_to_queue semantics). - /// - private static bool IsLocomotionCycleLowByte(uint lowByte) - { - return lowByte == 0x05u || lowByte == 0x06u || lowByte == 0x07u - || lowByte == 0x0Fu || lowByte == 0x10u; - } + // R2-Q4: IsLocomotionCycleLowByte DELETED with Fix B - the cyclic-to- + // cyclic link-skip is now retail's remove_redundant_links (0x0051bf20, + // MotionTableManager.RemoveRedundantLinks) operating on the pending + // queue, not a locomotion-subset special case in the adapter. /// /// Quaternion slerp matching the retail client's FUN_005360d0 diff --git a/src/AcDream.Core/Physics/BSPQuery.cs b/src/AcDream.Core/Physics/BSPQuery.cs index 87c127dc..2f609ee5 100644 --- a/src/AcDream.Core/Physics/BSPQuery.cs +++ b/src/AcDream.Core/Physics/BSPQuery.cs @@ -573,15 +573,25 @@ public static class BSPQuery // ------------------------------------------------------------------------- /// - /// Polygon.adjust_sphere_to_poly — compute parametric contact time. + /// CPolygon::adjust_sphere_to_poly (0x00538170, pc:321999) — the parametric + /// time along at which the sphere SURFACE + /// touches the polygon's plane, approaching from the side the start + /// position is on. /// /// - /// Returns 1.0 if the sphere currently intersects the polygon (needs further - /// back-off), or the parametric time [0,1] of first contact along the movement - /// vector. Used by adjust_to_plane binary-search loop. + /// Returns 1.0 when the start center is already within one radius of the + /// plane (no forward touch time computable — 0x005381a4), 0.0 when the + /// movement is parallel to the plane (|dot| ≤ 2e-4 — 0x005381d2), else + /// (±radius − dpPos) / dpMove with the sign chosen by the start's + /// plane side (0x005381ea). UNCLAMPED, matching retail. /// /// - /// ACE: Polygon.cs adjust_sphere_to_poly. + /// + /// ⚠️ Do NOT re-import ACE's Polygon.cs version — its early-out and its + /// ±radius selection (`movement.LengthSquared() <= r²`) are misdecodes + /// of the retail x87 flow; see + /// docs/research/2026-07-06-adjust-to-plane-pseudocode.md (#180). + /// /// private static float AdjustSphereToPoly( ResolvedPolygon poly, @@ -589,19 +599,14 @@ public static class BSPQuery Vector3 curPos, Vector3 movement) { - Vector3 cp = Vector3.Zero; - if (PolygonHitsSpherePrecise( - poly.Plane, poly.Vertices, - checkPos.Center, checkPos.Radius, - ref cp)) - return 1f; + float dpPos = Vector3.Dot(curPos, poly.Plane.Normal) + poly.Plane.D; + if (MathF.Abs(dpPos) < checkPos.Radius) return 1f; - float dpPos = Vector3.Dot(curPos, poly.Plane.Normal) + poly.Plane.D; float dpMove = Vector3.Dot(movement, poly.Plane.Normal); - if (MathF.Abs(dpMove) < PhysicsGlobals.EPSILON) return 0f; + if (MathF.Abs(dpMove) <= PhysicsGlobals.EPSILON) return 0f; - float t = (-checkPos.Radius - dpPos) / dpMove; - return Math.Clamp(t, 0f, 1f); + float r = dpPos < 0f ? -checkPos.Radius : checkPos.Radius; + return (r - dpPos) / dpMove; } // ========================================================================= @@ -1104,15 +1109,32 @@ public static class BSPQuery // ------------------------------------------------------------------------- /// - /// BSPTree.adjust_to_plane — binary-search for non-penetrating sphere position. + /// BSPTREE::adjust_to_plane (0x00539bf0, pc:323440) — find the closest + /// non-penetrating position along [curPos → checkPos] and commit it + /// into . /// /// - /// Runs up to 15 forward iterations until touching, then up to 15 binary-search - /// iterations to narrow the touch point. Modifies checkPos.Center in place. - /// Returns false if convergence fails. + /// Two known-time bounds: clearTime (retail var_50, init 0.0 — the + /// start is clear) and hitTime (retail var_48, init 1.0 — the check + /// position hit). Phase 1 walks plane-touch times from + /// , re-testing the whole tree at each — + /// the tree test can surface a DIFFERENT blocking polygon, which feeds the + /// next iteration (retail passes &hitPoly through). Phase 2 + /// binary-searches the bounds with the SAME iteration counter; window + /// < 0.02 is CONVERGED, and the final center commits at the last + /// known-clear time (0x00539de1). The only failure exit is Phase-1 + /// exhaustion (15 iterations without a clear touch — 0x00539ce9). /// /// - /// ACE: BSPTree.cs adjust_to_plane. + /// + /// ⚠️ Do NOT re-import ACE's BSPTree.cs version — its Phase-1 branch is + /// inverted and its convergence exit returns false, making the function + /// always-fail (dead on the server; PERFECT_CLIP is a client camera flag). + /// That dead shape is what quantized PathClipped camera stops to whole + /// transition steps: the #180 sawtooth AND the original #176 strobe + /// (pulledIn 0.27 ↔ 0.53 = 1-step vs 2-step backoff). Pseudocode + decode: + /// docs/research/2026-07-06-adjust-to-plane-pseudocode.md. + /// /// private static bool AdjustToPlane( PhysicsBSPNode root, @@ -1124,53 +1146,62 @@ public static class BSPQuery { var movement = checkPos.Center - curPos; - double lowerTime = 0.0; - double upperTime = 1.0; + double clearTime = 0.0; // retail var_50 — known-clear + double hitTime = 1.0; // retail var_48 — known-hit + int i = 0; const int MaxIter = 15; - // Phase 1: step forward until non-intersecting. - for (int i = 0; i < MaxIter; i++) + // Phase 1 (0x00539c4d): walk plane-touch times. + while (true) { float touchTime = AdjustSphereToPoly(hitPoly, checkPos, curPos, movement); - if (touchTime == 1f) - { - checkPos.Center = curPos + movement * (float)touchTime; + // Start already within one radius of the plane — no projectable touch + // time; fall through to the pure [0,1] binary search (0x00539c61). + if (touchTime == 1f) break; - ResolvedPolygon? hp2 = null; - Vector3 cp2 = Vector3.Zero; - if (!SphereIntersectsPolyInternal(root, resolved, checkPos, movement, - ref hp2, ref cp2)) - { - lowerTime = touchTime; - break; - } - upperTime = touchTime; - } - - if (i == MaxIter - 1) return false; - } - - // Phase 2: binary-search. - for (int j = 0; j < MaxIter; j++) - { - double average = (lowerTime + upperTime) * 0.5; - checkPos.Center = curPos + movement * (float)average; + checkPos.Center = curPos + movement * touchTime; ResolvedPolygon? hp2 = null; Vector3 cp2 = Vector3.Zero; - if (!SphereIntersectsPolyInternal(root, resolved, checkPos, movement, ref hp2, ref cp2)) - upperTime = (lowerTime + upperTime) * 0.5; - else - lowerTime = (lowerTime + upperTime) * 0.5; + { + clearTime = touchTime; // touch position clear → refine toward the hit + break; + } - if (upperTime - lowerTime < 0.02) - return false; + // Still blocked — possibly by a different polygon; the next plane + // adjustment targets it (retail's &hitPoly write-back, 0x00539cd3). + if (hp2 is not null) hitPoly = hp2; + + i++; + hitTime = touchTime; + if (i >= MaxIter) return false; // the only failure exit (0x00539ce9) } + // Phase 2 (0x00539ddb): binary search; the counter CONTINUES from Phase 1. + while (i < MaxIter) + { + double avg = (clearTime + hitTime) * 0.5; + checkPos.Center = curPos + movement * (float)avg; + + ResolvedPolygon? hp2 = null; + Vector3 cp2 = Vector3.Zero; + if (!SphereIntersectsPolyInternal(root, resolved, checkPos, movement, + ref hp2, ref cp2)) + clearTime = avg; + else + hitTime = avg; + + if (hitTime - clearTime < 0.02) break; // converged (0x00539dca) + i++; + } + + // Commit the last known-clear position (0x00539de1). Phase 2 always + // succeeds, converged or not — retail has no failure path here. + checkPos.Center = curPos + movement * (float)clearTime; return true; } @@ -1399,26 +1430,35 @@ public static class BSPQuery // ------------------------------------------------------------------------- // slide_sphere — BSPTree level - // ACE: BSPTree.cs slide_sphere + // Retail: BSPTREE::slide_sphere (find_collisions Contact head-hit dispatch + // at 0x0053a697). ACE: BSPTree.cs:310-316. // ------------------------------------------------------------------------- /// - /// BSPTree.slide_sphere — apply sliding collision response. + /// BSPTree.slide_sphere — dispatch the real sphere-level slide + /// (CSphere::slide_sphere 0x00537440, ported as + /// ): slide IN-FRAME along the + /// crease between the collision normal and the contact plane, applied to + /// sphere 0's check position (ACE BSPTree.cs:315 — + /// GlobalSphere[0].SlideSphere(..., GlobalCurrCenter[0].Center)). /// /// - /// Sets the sliding normal on CollisionInfo so the outer transition loop - /// applies a wall-slide projection. + /// #137 mechanism 2 (2026-07-06): this was a stub that set + /// CollisionInfo.SlidingNormal and returned Slid. Retail's BSP layer + /// never writes the sliding normal — its only in-transition writer is + /// CTransition::validate_transition (0x0050ac21) — so the stub's + /// leaked normal survived to the body writeback and absorbed the next + /// frame's exactly-anti-parallel offset: the Facility Hub corridor + /// phantom's dead-stop half (ISSUES #137). /// - /// - /// ACE: BSPTree.cs slide_sphere — calls GlobalSphere[0].SlideSphere. /// + /// Collision normal already in world space (the + /// call sites apply L2W; ACE globalizes inside slide_sphere instead). private static TransitionState SlideSphere( Transition transition, - Vector3 collisionNormal) - { - transition.CollisionInfo.SetSlidingNormal(collisionNormal); - return TransitionState.Slid; - } + Vector3 worldNormal) + => transition.SlideSphereInternal( + worldNormal, transition.SpherePath.GlobalCurrCenter[0].Origin); // ------------------------------------------------------------------------- // collide_with_pt — BSPTree level @@ -1894,11 +1934,14 @@ public static class BSPQuery if (engine is not null && !path.StepUp && !path.StepDown) return StepSphereUp(transition, worldNormal, engine); - // No engine OR step-up/step-down already in progress — fall - // back to wall-slide. - collisions.SetCollisionNormal(worldNormal); - collisions.SetSlidingNormal(worldNormal); - return TransitionState.Slid; + // No engine OR step-up/step-down already in progress — the + // real slide response. Retail: a blocked step-up funnels to + // SPHEREPATH::step_up_slide → CSphere::slide_sphere (ACE + // SpherePath.cs:316); the slide records the collision normal + // itself and never writes the sliding normal (#137 mechanism + // 2 — the old SetSlidingNormal stub here leaked a normal that + // wedged the next frame's forward offset). + return SlideSphere(transition, worldNormal); } // Sphere 0 didn't fully hit. Per retail, the head-sphere test AND @@ -1937,9 +1980,10 @@ public static class BSPQuery PhysicsDiagnostics.LastBspHitPoly = hitPoly1; var worldNormal = L2W(hitPoly1!.Plane.Normal); - collisions.SetCollisionNormal(worldNormal); - collisions.SetSlidingNormal(worldNormal); - return TransitionState.Slid; + // Retail head-sphere full hit → BSPTREE::slide_sphere + // (0x0053a697; ACE BSPTree.cs:202) — the real in-frame + // slide, no sliding-normal write (#137 mechanism 2). + return SlideSphere(transition, worldNormal); } // Sphere 1 (head) near-miss → neg_poly_hit, neg_step_up = false → outer slide. diff --git a/src/AcDream.Core/Physics/IAnimationHookSink.cs b/src/AcDream.Core/Physics/IAnimationHookSink.cs index 259df82b..9e4201b4 100644 --- a/src/AcDream.Core/Physics/IAnimationHookSink.cs +++ b/src/AcDream.Core/Physics/IAnimationHookSink.cs @@ -34,8 +34,14 @@ namespace AcDream.Core.Physics; /// (animation-hook frame = damage frame for melee / thrown). /// /// +/// → #188 +/// AcDream.Core.Rendering.TranslucencyHookSink (per-Setup-part +/// translucency ramp; see TranslucencyFadeManager). +/// +/// /// , -/// , +/// (whole-object variant — NOT yet +/// ported, #188 scope was the per-part case only), /// , /// , /// , @@ -43,7 +49,9 @@ namespace AcDream.Core.Physics; /// , /// , /// → -/// GfxObjMesh / renderer state mutations on the target entity. +/// GfxObjMesh / renderer state mutations on the target entity +/// ( is the one exception already wired, +/// via AcDream.Core.Lighting.LightingHookSink). /// /// /// → UI / controller notifications diff --git a/src/AcDream.Core/Physics/IMotionCommandCatalog.cs b/src/AcDream.Core/Physics/IMotionCommandCatalog.cs new file mode 100644 index 00000000..9951a6df --- /dev/null +++ b/src/AcDream.Core/Physics/IMotionCommandCatalog.cs @@ -0,0 +1,27 @@ +namespace AcDream.Core.Physics; + +/// +/// Reconstructs a full 32-bit retail MotionCommand from the 16-bit wire +/// value broadcast in InterpretedMotionState.Commands[] (the server +/// truncates the class byte — see for +/// why that byte must be restored before routing). +/// +/// +/// Two implementations exist because the wire-numbering used by ACE / the +/// local DATs and the wire-numbering used by the Sept 2013 EoR retail +/// decomp diverge for ~130 command names (a contiguous low-word "+3" shift +/// starting at SnowAngelState). See +/// (runtime default) and +/// (conformance/reference), and +/// docs/research/2026-06-26-ace-vs-2013-motion-command-gap.md for the +/// full divergence analysis. +/// +/// +public interface IMotionCommandCatalog +{ + /// + /// Reconstruct the full 32-bit MotionCommand from a 16-bit wire value. + /// Returns 0 if no entry matches. + /// + uint ReconstructFullCommand(ushort wireCommand); +} diff --git a/src/AcDream.Core/Physics/InterpretedMotionFunnel.cs b/src/AcDream.Core/Physics/InterpretedMotionFunnel.cs new file mode 100644 index 00000000..8c0dea7e --- /dev/null +++ b/src/AcDream.Core/Physics/InterpretedMotionFunnel.cs @@ -0,0 +1,115 @@ +using System.Collections.Generic; + +namespace AcDream.Core.Physics; + +/// +/// L.2g S2 — supporting types for the inbound CMotionInterp funnel +/// (deviation DEV-1). Spec: +/// docs/research/2026-07-02-s2-inbound-funnel-pseudocode.md; decomp: +/// MovementManager::unpack_movement 0x00524440, +/// CMotionInterp::move_to_interpreted_state 0x005289c0, +/// apply_interpreted_movement 0x00528600, DoInterpretedMotion 0x00528360 — +/// dispatch order validated against a LIVE retail-observer cdb trace +/// (tools/cdb/l2g-observer.cdb). +/// +public interface IInterpretedMotionSink +{ + /// + /// The CPhysicsObj::DoInterpretedMotion → … → + /// CMotionTable::GetObjectSequence backend — called for every motion + /// that passes contact_allows_move, in retail dispatch order + /// (style → forward-or-Falling → sidestep → turn → actions). R2-Q5: the + /// production implementation is Motion.MotionTableDispatchSink, + /// which dispatches straight into the entity's motion-table stack + /// (PerformMovement → GetObjectSequence + is_allowed decide) — + /// no sink-side axis pick or fallback chain. + /// + /// + /// R3-W5: retail's own CPhysicsObj::DoInterpretedMotion RETURNS a + /// result (result == 0 = the motion table found a cycle for this + /// id; nonzero = MotionTableManagerError.MotionFailed/no-table) — + /// CMotionInterp::DoInterpretedMotion's caller (raw 305591-305610) + /// gates BOTH the add_to_queue call AND the + /// InterpretedMotionState::ApplyMotion state-write on that result. + /// This matters concretely for the very first dispatch of every + /// apply_interpreted_movement call — the STYLE/stance id + /// (current_style, always >= 0x80000000) has no + /// locomotion MotionData entry in the dat, so + /// CMotionTable::DoObjectMotion genuinely fails for it; if that + /// failure isn't propagated, the state-write's negative-motion branch + /// (: arg2 < 0 → + /// forward_command = 0x41000003) clobbers ForwardCommand + /// BEFORE the very next line reads it for the real forward dispatch — + /// confirmed regression against the 183-case live retail-observer trace + /// (RetailObserverTraceConformanceTests) when this was void. + /// Return true when the underlying PerformMovement call + /// succeeded (MotionTableManagerError.Success). + /// + bool ApplyMotion(uint motion, float speed); + + /// + /// StopInterpretedMotion notification for an axis the incoming + /// state cleared (sidestep 0x6500000F / turn 0x6500000D). Unconditional + /// (no contact gate) per apply_interpreted_movement. + /// + /// Same result-propagation rationale as + /// — retail's CPhysicsObj::StopInterpretedMotion also returns a + /// result that gates the post-stop add_to_queue + state-removal. + bool StopMotion(uint motion); + + /// + /// R4-V5 wedge fix — retail CPhysicsObj::StopCompletely_Internal + /// (0x0050ead0) → CPartArray::StopCompletelyInternal (0x00518890) + /// → MotionTableManager::PerformMovement(MovementStruct{type=5}): + /// the ANIMATION-side full stop dispatched from the middle of + /// CMotionInterp::StopCompletely (raw @00527e90). The manager + /// queues its pending_animations entry UNCONDITIONALLY for type 5, and + /// that entry's AnimationDone → MotionDone is the matched pop for the A9 + /// pending_motions node StopCompletely enqueues right after this + /// call — without it the A9 node is an orphan and MotionsPending + /// never drains at idle (the 2026-07-03 moveto wedge). Default + /// implementation returns true (the null-sink "no animation + /// backend" posture — bare tests and sink-less interps are unaffected). + /// + bool StopCompletely() => true; +} + +/// +/// One entry of the inbound action list (retail MotionItem / +/// InterpretedMotionState.actions): a one-shot command with the +/// 15-bit server action stamp + autonomy bit +/// (u16 ((stamp & 0x7FFF) | (autonomous ? 0x8000 : 0))). +/// +public readonly record struct InboundMotionAction( + uint Command, int Stamp, bool Autonomous, float Speed); + +/// +/// A fully-decoded inbound InterpretedMotionState: wire fields where +/// present, retail UnPack defaults where absent +/// (InterpretedMotionState::UnPack 0x0051f400 / +/// ctor 0x0051e8d0). A flags=0 "empty" UM decodes to exactly +/// — a retail-verbatim full stop. +/// +public struct InboundInterpretedState +{ + public uint CurrentStyle; + public uint ForwardCommand; + public float ForwardSpeed; + public uint SideStepCommand; + public float SideStepSpeed; + public uint TurnCommand; + public float TurnSpeed; + public IReadOnlyList? Actions; + + public static InboundInterpretedState Default() => new() + { + CurrentStyle = 0x8000003Du, + ForwardCommand = 0x41000003u, + ForwardSpeed = 1.0f, + SideStepCommand = 0u, + SideStepSpeed = 1.0f, + TurnCommand = 0u, + TurnSpeed = 1.0f, + Actions = null, + }; +} diff --git a/src/AcDream.Core/Physics/Motion/AnimSequenceNode.cs b/src/AcDream.Core/Physics/Motion/AnimSequenceNode.cs new file mode 100644 index 00000000..e7c80588 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/AnimSequenceNode.cs @@ -0,0 +1,159 @@ +using System; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R1-P1 — verbatim port of retail's AnimSequenceNode (Phase R plan +/// `docs/plans/2026-07-02-retail-motion-animation-rewrite.md`, stage R1; +/// oracle `docs/research/2026-07-02-r1-csequence/r1-csequence-decomp.md` +/// §25-28). +/// +/// One node of a CSequence's animation list: a resolved dat +/// plus a playable frame window +/// (..) and a signed +/// whose SIGN is retail's playback-direction flag. +/// +/// Retail semantics preserved exactly (gap-map items G1/G2/G16/G18): +/// +/// The boundary pair ( / +/// ) is direction-aware and returns BARE +/// integers — retail has NO epsilon here (0x00525c80/0x00525cb0). ACE's +/// PhysicsGlobals.EPSILON subtraction compensates for ACE's own +/// float FrameNumber and must not be copied (P0-pins.md). +/// SWAPS and +/// when the factor is negative (0x00525be0) — +/// coupled with the boundary pair's framerate < 0 test. +/// clamps in retail's exact order +/// (0x00525d60): high<0 → num−1; low≥num → num−1; high≥num → num−1; +/// low>high → high=low. +/// returns null out of range +/// (retail; ACE's identity-frame return is an ACE-ism). +/// +/// +/// Unlike the legacy AnimationSequencer.AnimNode, retail nodes carry +/// NO per-node IsLooping/Velocity/Omega — loop membership is list structure +/// (first_cyclic) and physics accumulators live on the sequence +/// (G16). +/// +public sealed class AnimSequenceNode +{ + /// Resolved dat animation, or null (id 0 / missing). + public Animation? Anim { get; private set; } + + /// + /// Frames per second; NEGATIVE means reverse playback (retail's + /// direction flag). Default 30f (0x00525d30). + /// + public float Framerate = 30f; + + /// Inclusive window low bound. Default −1 (0x00525d30). + public int LowFrame = -1; + + /// Inclusive window high bound; −1 = "to the end" sentinel + /// resolved by . Default −1. + public int HighFrame = -1; + + public bool HasAnim => Anim is not null; + + /// Default ctor — retail defaults (0x00525d30). + public AnimSequenceNode() + { + } + + /// + /// Ctor from a MotionData entry (0x00525f90): + /// copy framerate/low/high, then resolve + clamp via + /// . + /// + public AnimSequenceNode(AnimData animData, IAnimationLoader loader) + { + Framerate = animData.Framerate; + LowFrame = animData.LowFrame; + HighFrame = animData.HighFrame; + SetAnimationId((uint)animData.AnimId, loader); + } + + /// + /// Resolve the dat animation and clamp the frame window + /// (0x00525d60). The clamp block runs only when an animation resolved; + /// order is retail-exact. + /// + public void SetAnimationId(uint animId, IAnimationLoader loader) + { + Anim = animId == 0 ? null : loader.LoadAnimation(animId); + + if (Anim is null) + return; + + int numFrames = Anim.PartFrames.Count; + + if (HighFrame < 0) + HighFrame = numFrames - 1; + if (LowFrame >= numFrames) + LowFrame = numFrames - 1; + if (HighFrame >= numFrames) + HighFrame = numFrames - 1; + if (LowFrame > HighFrame) + HighFrame = LowFrame; + } + + /// + /// Direction-aware starting boundary (0x00525c80): reverse playback + /// starts at high_frame + 1, forward at low_frame. + /// BARE int — no epsilon (G1). + /// + public int GetStartingFrame() => Framerate < 0f ? HighFrame + 1 : LowFrame; + + /// + /// Direction-aware ending boundary (0x00525cb0): reverse ends at + /// low_frame, forward at high_frame + 1. BARE int. + /// + public int GetEndingFrame() => Framerate < 0f ? LowFrame : HighFrame + 1; + + /// + /// Scale playback rate (0x00525be0): a NEGATIVE factor swaps + /// low/high before multiplying — the swapped fields plus the + /// now-negative framerate are how retail encodes reversed windows. + /// + public void MultiplyFramerate(float factor) + { + if (factor < 0f) + { + (LowFrame, HighFrame) = (HighFrame, LowFrame); + } + Framerate *= factor; + } + + /// + /// Root-motion frame at a double position (0x005247b0): floor then the + /// int overload. + /// + public Frame? GetPosFrame(double frameNumber) + => GetPosFrame((int)Math.Floor(frameNumber)); + + /// + /// Root-motion frame by index (0x00525c10): null when no animation, + /// index out of range, or the animation carries no PosFrames. + /// + public Frame? GetPosFrame(int index) + { + if (Anim is null || index < 0 || index >= Anim.PartFrames.Count) + return null; + if (Anim.PosFrames is null || index >= Anim.PosFrames.Count) + return null; + return Anim.PosFrames[index]; + } + + /// + /// Skeletal part frame by index — same bounds discipline as + /// . + /// + public AnimationFrame? GetPartFrame(int index) + { + if (Anim is null || index < 0 || index >= Anim.PartFrames.Count) + return null; + return Anim.PartFrames[index]; + } +} diff --git a/src/AcDream.Core/Physics/Motion/CMotionTable.cs b/src/AcDream.Core/Physics/Motion/CMotionTable.cs new file mode 100644 index 00000000..02b63172 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/CMotionTable.cs @@ -0,0 +1,692 @@ +using System; +using System.Linq; +using System.Numerics; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +// Alias the DatReaderWriter enum so it doesn't clash with +// AcDream.Core.Physics.MotionCommand (a static class of uint constants) — +// same convention as AnimationSequencerTests.cs. +using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand; + +namespace AcDream.Core.Physics.Motion; + +// ───────────────────────────────────────────────────────────────────────────── +// R2-Q2 — verbatim port of retail's CMotionTable (the motion-selection +// dispatcher). Oracle: docs/research/2026-07-02-r2-motiontable/r2-motiontable-decomp.md +// (all §-references below point there); ambiguity pins: +// docs/research/2026-07-02-r2-motiontable/Q0-pins.md (A1-A5). +// +// Scope (r2-port-plan.md §3 Q2): pure motion-SELECTION logic — resolves which +// MotionData(s) to append to a CSequence and updates a MotionState in place. +// Does NOT own a pending-animation queue (that is MotionTableManager, Q3) and +// does NOT drive per-tick advance (CSequence.Update, R1). This file re-homes +// the adapter's already-field-validated GetLink (AnimationSequencer.cs +// :953-997) verbatim per the keep-list (r2-port-plan.md §2) and adds every +// other CMotionTable/free-function member the decomp documents. +// +// Command-word class bits (decomp §1 "Motion-id class bits", §15): +// 0x80000000 style-class (top bit set; the low 31 bits + top bit read as +// a NEGATIVE int32 — retail's `(int32_t)ebx_1 < 0` test) +// 0x40000000 cycle-class (cyclic/looping base state, `this->cycles`) +// 0x20000000 modifier-class (physics-only overlay, `this->modifiers`) +// 0x10000000 action-class (one-shot, `add_action` FIFO) +// 0x41000003 Ready — the "stop / default state" sentinel (decomp §15) +// +// DatReaderWriter.DBObjs.MotionTable field map (verified via reflection, +// package Chorizite.DatReaderWriter 2.1.7, 2026-07-02): +// DefaultStyle : MotionCommand → this->default_style +// StyleDefaults : Dictionary → this->style_defaults +// Cycles : Dictionary → this->cycles +// Modifiers : Dictionary → this->modifiers +// Links : Dictionary → this->links +// (MotionCommandData.MotionData : Dictionary = the inner +// per-target-substate hash) +// MotionData.Bitfield : byte (A5 CONFIRMED present — bit0=clear-mods-on- +// entry, bit1=substate-gated for is_allowed) +// MotionData.Anims : List — retail's `num_anims`/`anims[]` pair; +// Anims.Count IS num_anims (A3 — no separate packed-byte field exists on +// the managed type; the decomp's "packed byte at MotionData+0x10" is +// this same count, just read through the raw struct layout). +// ───────────────────────────────────────────────────────────────────────────── + +/// +/// Retail's CMotionTable (0x00522xxx-0x00523xxx region) — the +/// motion-selection dispatcher. Wraps a loaded DBObj +/// and resolves (style, substate, speed) requests into MotionData +/// chains appended to a , mutating a +/// in place. +/// +public sealed class CMotionTable +{ + private readonly MotionTable _table; + + public CMotionTable(MotionTable table) + { + ArgumentNullException.ThrowIfNull(table); + _table = table; + } + + // ── free functions (decomp §2) ────────────────────────────────────── + + /// + /// same_sign 0x00522260 (@298253). True when + /// and are on the same side of zero (0 counts as + /// non-negative, matching the decomp's >= 0f reading). + /// + internal static bool SameSign(float a, float b) => (a >= 0f) == (b >= 0f); + + /// + /// change_cycle_speed 0x00522290 (@298276): rescale + /// 's cyclic-tail framerate by + /// newSpeed/oldSpeed. Ported VERBATIM including the A4-#2 gap: when + /// is ~0 and is + /// NOT ~0, retail's fabsl branch structure suppresses the rescale + /// entirely (no zeroing, no scaling — a silent no-op). Only when BOTH are + /// ~0 does retail explicitly zero the framerate. + /// + internal static void ChangeCycleSpeed(CSequence sequence, MotionData? cyclic, float oldSpeed, float newSpeed) + { + const float Epsilon = 0.000199999995f; // ~0.0002f, verbatim retail constant + + if (MathF.Abs(oldSpeed) > Epsilon) + { + sequence.MultiplyCyclicAnimationFramerate(newSpeed / oldSpeed); + return; + } + + // oldSpeed ~ 0: only the "newSpeed also ~0" leg does anything (zero + // the framerate). The "newSpeed NOT ~0" leg is a silent no-op — + // retail's own gap, kept verbatim (Q0-pins A4-#2). + if (MathF.Abs(newSpeed) <= Epsilon) + { + sequence.MultiplyCyclicAnimationFramerate(0f); + } + } + + /// + /// add_motion 0x005224b0 (@298437): UNCONDITIONALLY sets + /// 's velocity/omega to + /// motion.Velocity/Omega * speedMod (replace, not accumulate — a + /// dat-silent MotionData carries a zero Vector3, so "unconditional + /// replace" and "replace with zero" are the same call; G17 core), then + /// appends every AnimData in speed-scaled + /// (framerate only, retail AnimData::operator*). + /// + internal static void AddMotion(CSequence sequence, MotionData? motion, float speedMod) + { + if (motion is null) + return; + + sequence.SetVelocity(motion.Velocity * speedMod); + sequence.SetOmega(motion.Omega * speedMod); + + foreach (var ad in motion.Anims) + { + sequence.AppendAnimation(new AnimData + { + AnimId = ad.AnimId, + LowFrame = ad.LowFrame, + HighFrame = ad.HighFrame, + Framerate = ad.Framerate * speedMod, + }); + } + } + + /// + /// combine_motion 0x00522580 (@298472): ADDS + /// 's velocity/omega (scaled by + /// ) onto the sequence's existing physics. + /// Never touches anims — used for modifier overlays where the base + /// cycle's animation frames stay untouched. + /// + internal static void CombineMotion(CSequence sequence, MotionData? motion, float speedMod) + { + if (motion is null) + return; + + sequence.CombinePhysics(motion.Velocity * speedMod, motion.Omega * speedMod); + } + + /// + /// subtract_motion 0x00522600 (@298492): inverse of + /// — used when REMOVING a modifier's + /// physics contribution. + /// + internal static void SubtractMotion(CSequence sequence, MotionData? motion, float speedMod) + { + if (motion is null) + return; + + sequence.SubtractPhysics(motion.Velocity * speedMod, motion.Omega * speedMod); + } + + // ── members ────────────────────────────────────────────────────────── + + /// + /// is_allowed 0x005226c0 (@298526): a bitfield-bit1 ("gated") + /// cycle is only reusable when the current substate matches the + /// candidate, OR the current substate already equals the owning style's + /// default substate. Null is never allowed. + /// + public bool IsAllowed(uint candidateSubstate, MotionData? candidate, MotionState state) + { + if (candidate is null) + return false; + + if ((candidate.Bitfield & 2) != 0) + { + uint substate = state.Substate; + if (candidateSubstate != substate) + { + uint defaultSubstate = LookupStyleDefault(state.Style); + return defaultSubstate == substate; + } + } + + return true; + } + + /// + /// get_link 0x00522710 (@298552). Re-homed verbatim from the + /// working adapter (AnimationSequencer.GetLink, field-validated — + /// the reversed-key branch fixed the Ready→WalkBackward "left leg + /// twitches" glitch) per Q0-pins A1: EITHER speed negative routes through + /// the swapped-key branch (link stored FROM + /// TO ), falling back to the style's + /// default-substate hop; otherwise the forward branch (link FROM + /// TO ), + /// falling back to the style-level catch-all (unstyled outer key). + /// + public MotionData? GetLink(uint fromStyle, uint fromSubstate, float fromSubstateMod, uint toSubstate, float toSubstateMod) + { + if (toSubstateMod < 0f || fromSubstateMod < 0f) + { + // Reversed-direction path: link FROM toSubstate TO fromSubstate. + int reversedKey = (int)((fromStyle << 16) | (toSubstate & 0xFFFFFFu)); + if (_table.Links.TryGetValue(reversedKey, out var revLink) + && revLink.MotionData.TryGetValue((int)fromSubstate, out var revResult)) + { + return revResult; + } + + // Style-defaults fallback (decomp §4 second predicate block, "else" branch). + uint defaultSubstate = LookupStyleDefault(fromStyle); + int subKey = (int)((fromStyle << 16) | (fromSubstate & 0xFFFFFFu)); + if (_table.Links.TryGetValue(subKey, out var subLink) + && subLink.MotionData.TryGetValue((int)defaultSubstate, out var subResult)) + { + return subResult; + } + return null; + } + + // Forward-direction path: link FROM fromSubstate TO toSubstate. + int outerKey1 = (int)((fromStyle << 16) | (fromSubstate & 0xFFFFFFu)); + if (_table.Links.TryGetValue(outerKey1, out var cmd1) + && cmd1.MotionData.TryGetValue((int)toSubstate, out var result1)) + { + return result1; + } + + // Fallback: style-level catch-all (unstyled outer key, decomp §4 "else if" branch). + int outerKey2 = (int)(fromStyle << 16); + if (_table.Links.TryGetValue(outerKey2, out var cmd2) + && cmd2.MotionData.TryGetValue((int)toSubstate, out var result2)) + { + return result2; + } + + return null; + } + + /// + /// GetObjectSequence 0x00522860 (@298636) — the FULL dispatcher. + /// See decomp §5 for the annotated retail source; the branch structure + /// below mirrors it 1:1 (comments cite the corresponding decomp block). + /// + /// Requested target substate/motion id. + /// In/out current motion state. + /// Sequence to build/mutate. + /// Requested speed_mod for the new substate. + /// OUT: tick count of appended animation, minus 1. + /// false = normal "do motion"; true = re-invoked + /// from . + public bool GetObjectSequence(uint motion, MotionState state, CSequence sequence, float speed, out uint outTicks, bool stopCall) + { + outTicks = 0; + + uint style = state.Style; + if (style == 0) + return false; + + uint substate = state.Substate; + if (substate == 0) + return false; + + uint styleDefault = LookupStyleDefault(style); // var_c + + uint target = motion; // ebx_1 working copy + + // ---- FAST PATH: requesting the style default while already a + // modifier-class substate, not a stop-call. ---- + if (target == styleDefault && !stopCall && (substate & 0x20000000) != 0) + return true; + + float requestedSpeed = speed; // ebp_1 + + // ================================================================ + // BRANCH 1: target interpreted as NEGATIVE int32 — style-change request. + // ================================================================ + if ((int)target < 0) + { + if (style == target) + return true; // already in that style + + uint currentStyleDefault = LookupStyleDefault(style); // eax_1 + + MotionData? exitLink = null; // var_4_1 + if (substate != currentStyleDefault) + { + exitLink = GetLink(style, substate, state.SubstateMod, currentStyleDefault, requestedSpeed); + } + + uint targetStyleDefault = LookupStyleDefault(target); // arg7_style_default + if (_table.StyleDefaults.ContainsKey((DRWMotionCommand)target)) + { + MotionData? newCycle = LookupCycle(target, targetStyleDefault); // eax_5 + + if (newCycle is not null) + { + if ((newCycle.Bitfield & 1) != 0) + state.ClearModifiers(); + + // link FROM current style's default substate TO target style's default substate + MotionData? directOrHop1 = GetLink(style, styleDefault, state.SubstateMod, target, requestedSpeed); // arg2 + MotionData? hop2 = null; // var_10_1 + + if (directOrHop1 is null && target != style) + { + // DOUBLE-HOP VIA default_style. + directOrHop1 = GetLink(style, styleDefault, 1f, (uint)_table.DefaultStyle, 1f); + uint defaultStyleDefaultSubstate = LookupStyleDefault((uint)_table.DefaultStyle); + hop2 = GetLink((uint)_table.DefaultStyle, defaultStyleDefaultSubstate, 1f, target, 1f); + } + + sequence.ClearPhysics(); + sequence.RemoveCyclicAnims(); + AddMotion(sequence, exitLink, requestedSpeed); + AddMotion(sequence, directOrHop1, requestedSpeed); + AddMotion(sequence, hop2, requestedSpeed); + AddMotion(sequence, newCycle, requestedSpeed); + + state.Substate = targetStyleDefault; + state.Style = target; + state.SubstateMod = speed; + ReModify(sequence, state); + + uint numAnims2 = (uint)(exitLink?.Anims.Count ?? 0); + uint ecx20 = (uint)(directOrHop1?.Anims.Count ?? 0); + uint numAnims1 = (uint)(hop2?.Anims.Count ?? 0); + outTicks = (uint)newCycle.Anims.Count + numAnims1 + ecx20 + numAnims2 - 1; + return true; + } + } + // else: fall through to the class-bit blocks below with target still negative. + } + + // ================================================================ + // BRANCH 2: target has the CYCLE-CLASS bit (0x40000000) set. + // ================================================================ + if ((target & 0x40000000) != 0) + { + uint substateId = target & 0xFFFFFFu; + MotionData? cyclic = LookupCycle(style, substateId); // eax_24 + + if (cyclic is null) + { + // No cycle for THIS style at that id -> retry under the + // table-wide default_style (decomp §5 "label_522ae6" retry — + // unconditional, no style==0 guard in retail). + cyclic = LookupCycle((uint)_table.DefaultStyle, substateId); + } + + if (cyclic is not null && IsAllowed(target, cyclic, state)) + { + + // ---- FAST RE-SPEED PATH ---- + if (target == substate + && SameSign(requestedSpeed, state.SubstateMod) + && sequence.HasAnims()) + { + ChangeCycleSpeed(sequence, cyclic, state.SubstateMod, requestedSpeed); + SubtractMotion(sequence, cyclic, state.SubstateMod); + CombineMotion(sequence, cyclic, requestedSpeed); + state.SubstateMod = speed; + return true; + } + + if ((cyclic.Bitfield & 1) != 0) + state.ClearModifiers(); + + MotionData? directLink = GetLink(style, substate, state.SubstateMod, target, requestedSpeed); // eax_34 + bool sameSignDirect = directLink is not null && SameSign(requestedSpeed, state.SubstateMod); + + MotionData? hop2 = null; // var_10_1 + MotionData? linkOrHop1 = directLink; // arg2 + + if (directLink is null || !sameSignDirect) + { + uint styleDefaultSubstate = LookupStyleDefault(style); + linkOrHop1 = GetLink(style, substate, state.SubstateMod, styleDefaultSubstate, 1f); + hop2 = GetLink(style, styleDefaultSubstate, 1f, target, requestedSpeed); + } + + sequence.ClearPhysics(); + sequence.RemoveCyclicAnims(); + + if (hop2 is null) + { + float signedSpeed = (state.SubstateMod == 0f || SameSign(state.SubstateMod, speed)) + ? speed : -speed; + AddMotion(sequence, linkOrHop1, signedSpeed); + } + else + { + AddMotion(sequence, linkOrHop1, state.SubstateMod); + AddMotion(sequence, hop2, requestedSpeed); + } + + AddMotion(sequence, cyclic, requestedSpeed); + + // Leaving a modifier-class substate for something else: re-register + // the OLD substate as a still-active modifier unless the style's + // default substate IS the new target. + uint oldSubstate = state.Substate; + if (oldSubstate != target && (oldSubstate & 0x20000000) != 0) + { + uint styleDefaultSubstate2 = LookupStyleDefault(style); + if (styleDefaultSubstate2 != target) + state.AddModifierNoCheck(oldSubstate, state.SubstateMod); + } + + state.SubstateMod = speed; + state.Substate = target; + ReModify(sequence, state); + + uint ecx45 = (uint)(linkOrHop1?.Anims.Count ?? 0); + uint numAnims1b = (uint)(hop2?.Anims.Count ?? 0); + outTicks = (uint)cyclic.Anims.Count + numAnims1b + ecx45 - 1; + return true; + } + // is_allowed rejected (or no cyclic resolved) -> fall through. + } + + // ================================================================ + // BRANCH 3: target has the ACTION-CLASS bit (0x10000000) set. + // ================================================================ + if ((target & 0x10000000) != 0) + { + MotionData? baseCycle = LookupCycle(style, substate & 0xFFFFFFu); // eax_57 + if (baseCycle is not null) + { + MotionData? directLink = GetLink(style, substate, state.SubstateMod, target, requestedSpeed); // eax_60 + if (directLink is not null) + { + state.AddAction(target, requestedSpeed); + sequence.ClearPhysics(); + sequence.RemoveCyclicAnims(); + AddMotion(sequence, directLink, requestedSpeed); + AddMotion(sequence, baseCycle, state.SubstateMod); + ReModify(sequence, state); + outTicks = (uint)directLink.Anims.Count; + return true; + } + + // No direct link -> route through the style default (double-hop out-and-back). + uint styleDefaultSubstate = LookupStyleDefault(style); + MotionData? outHop = GetLink(style, substate, state.SubstateMod, styleDefaultSubstate, 1f); // eax_66 + if (outHop is not null) + { + MotionData? actionLink = GetLink(style, styleDefaultSubstate, 1f, target, requestedSpeed); // eax_68 + if (actionLink is not null) + { + MotionData? baseCycleRefetch = LookupCycle(style, substate & 0xFFFFFFu); // eax_69 (same key, re-fetched) + if (baseCycleRefetch is not null) + { + MotionData? returnHop = GetLink(style, styleDefaultSubstate, 1f, substate, state.SubstateMod); + + state.AddAction(target, requestedSpeed); + sequence.ClearPhysics(); + sequence.RemoveCyclicAnims(); + AddMotion(sequence, outHop, 1f); + AddMotion(sequence, actionLink, requestedSpeed); + AddMotion(sequence, returnHop, 1f); + AddMotion(sequence, baseCycleRefetch, state.SubstateMod); + ReModify(sequence, state); + + // A4-#1: outTicks = outHop + actionLink [+ returnHop] ONLY — + // never the base cycle, never double-counted (ACE's bug, not retail's). + uint ticks = (uint)outHop.Anims.Count + (uint)actionLink.Anims.Count; + if (returnHop is not null) + ticks += (uint)returnHop.Anims.Count; + outTicks = ticks; + return true; + } + } + } + } + } + + // ================================================================ + // BRANCH 4: target has the MODIFIER-CLASS bit (0x20000000) set. + // ================================================================ + if ((target & 0x20000000) != 0) + { + MotionData? baseCycle = LookupCycle(style, substate & 0xFFFFFFu); // eax_81 + + if (baseCycle is not null && (baseCycle.Bitfield & 1) == 0) + { + uint modKey = target & 0xFFFFFFu; + MotionData? modifierStyled = LookupModifier(style, modKey, styleSpecific: true); // eax_85 + MotionData? modifierGlobal = null; // eax_87 + if (modifierStyled is null) + modifierGlobal = LookupModifier(style, modKey, styleSpecific: false); + MotionData? modifierData = modifierStyled ?? modifierGlobal; + + if (modifierStyled is not null || modifierGlobal is not null) + { + bool added = state.AddModifier(target, requestedSpeed); + if (!added) + { + // Toggle: already active (or == current substate) -> stop then re-add. + StopSequenceMotion(target, 1f, state, sequence, out _); + added = state.AddModifier(target, requestedSpeed); + } + if (added) + { + CombineMotion(sequence, modifierData, requestedSpeed); + return true; + } + } + } + } + + return false; + } + + /// + /// re_modify 0x005222e0 (@298300): after installing a new base + /// cycle/substate, replay every previously-active modifier back onto the + /// sequence by re-invoking for each one. + /// Q0-pins A4-#5: the retail copy-ctor snapshot exists ONLY as a + /// loop-termination bound (both the live list and the snapshot pop one + /// entry per iteration; the loop ends when the snapshot empties) — the + /// C# port deep-copies via MotionState(MotionState other), pops + /// both in lockstep, and terminates on the snapshot's emptiness. + /// + public void ReModify(CSequence sequence, MotionState state) + { + if (!state.Modifiers.Any()) + return; + + var snapshot = new MotionState(state); + + do + { + var head = state.Modifiers.First(); + uint motion = head.Motion; + float speedMod = head.SpeedMod; + state.RemoveModifier(head); + + var snapshotHead = snapshot.Modifiers.First(); + snapshot.RemoveModifier(snapshotHead); + + GetObjectSequence(motion, state, sequence, speedMod, out _, stopCall: false); + } while (snapshot.Modifiers.Any()); + } + + /// + /// StopSequenceMotion 0x00522fc0 (@298954): two independent stop + /// mechanisms. Stopping the active cycle re-drives + /// toward the style's default substate + /// (i.e. "return to idle"). Stopping a modifier just unwinds its physics + /// contribution and removes it from the chain — no animation + /// re-sequencing needed since modifiers don't touch anims[]. + /// Action-class ids are NOT handled here (decomp §7 note — actions + /// complete via the MotionTableManager tick-countdown, Q3 scope). + /// + public bool StopSequenceMotion(uint motion, float speed, MotionState state, CSequence sequence, out uint outTicks) + { + outTicks = 0; + + // Case A: stopping the CYCLE-class substate we are currently in. + if ((motion & 0x40000000) != 0 && motion == state.Substate) + { + uint styleDefaultSubstate = LookupStyleDefault(state.Style); + GetObjectSequence(styleDefaultSubstate, state, sequence, 1f, out outTicks, stopCall: true); + return true; + } + + // Case B: stopping a MODIFIER-class id. + if ((motion & 0x20000000) != 0) + { + foreach (var node in state.Modifiers) + { + if (node.Motion != motion) + continue; + + uint modKey = motion & 0xFFFFFFu; + MotionData? modData = LookupModifier(state.Style, modKey, styleSpecific: true); + modData ??= LookupModifier(state.Style, modKey, styleSpecific: false); + + if (modData is not null) + { + SubtractMotion(sequence, modData, node.SpeedMod); + state.RemoveModifier(node); + return true; + } + + break; // matching motion id found but no MotionData anywhere -> give up + } + } + + return false; + } + + /// + /// SetDefaultState 0x005230a0 (@299004): reset a MotionState to + /// the motion table's baseline (default_style + that style's + /// default substate), clearing all modifiers/actions and installing the + /// base cyclic animation for that (style,substate) fresh via + /// (hard reset, not just + /// RemoveCyclicAnims). + /// + public bool SetDefaultState(MotionState state, CSequence sequence, out uint outTicks) + { + outTicks = 0; + + if (!_table.StyleDefaults.TryGetValue(_table.DefaultStyle, out var defaultSubstateCmd)) + return false; + + uint defaultSubstate = (uint)defaultSubstateCmd; + + state.ClearModifiers(); + state.ClearActions(); + + MotionData? cyclic = LookupCycle((uint)_table.DefaultStyle, defaultSubstate); + if (cyclic is null) + return false; + + state.Style = (uint)_table.DefaultStyle; + state.Substate = defaultSubstate; + state.SubstateMod = 1f; + outTicks = (uint)cyclic.Anims.Count - 1; + + sequence.ClearPhysics(); + sequence.ClearAnimations(); + AddMotion(sequence, cyclic, state.SubstateMod); + + return true; + } + + /// DoObjectMotion 0x00523e90 (@300045): thin wrapper — "do" == + /// with the stop-flag forced to false. + public bool DoObjectMotion(uint motion, MotionState state, CSequence sequence, float speed, out uint outTicks) + => GetObjectSequence(motion, state, sequence, speed, out outTicks, stopCall: false); + + /// StopObjectMotion 0x00523ec0 (@300053): thin wrapper — + /// tailcall straight into . + public bool StopObjectMotion(uint motion, float speed, MotionState state, CSequence sequence, out uint outTicks) + => StopSequenceMotion(motion, speed, state, sequence, out outTicks); + + /// + /// StopObjectCompletely 0x00523ed0 (@300062): the "return to idle + /// from everything" call — strips every active modifier first (each one + /// individually going through the same subtract-and-unlink path as a + /// single call), then stops the base + /// cycle/substate itself (which re-drives + /// toward the style's default substate). Q0-pins A4-#4: return = + /// finalStopOk ? true : anyModifierStopOk, ported verbatim. + /// + public bool StopObjectCompletely(MotionState state, CSequence sequence, out uint outTicks) + { + outTicks = 0; + bool anyModifierStopOk = false; + + // Stop EVERY currently-active modifier first (list shrinks each + // iteration because StopSequenceMotion unlinks the node it stops). + while (state.Modifiers.Any()) + { + var node = state.Modifiers.First(); + float speedMod = node.SpeedMod; + if (StopSequenceMotion(node.Motion, speedMod, state, sequence, out outTicks)) + anyModifierStopOk = true; + else + break; // defensive: avoid infinite loop if a stop can't unlink (shouldn't happen) + } + + // Finally stop the base cycle/substate itself. + if (StopSequenceMotion(state.Substate, state.SubstateMod, state, sequence, out outTicks)) + return true; + + return anyModifierStopOk; + } + + // ── private lookup helpers ────────────────────────────────────────── + + private uint LookupStyleDefault(uint style) + => _table.StyleDefaults.TryGetValue((DRWMotionCommand)style, out var def) ? (uint)def : 0u; + + private MotionData? LookupCycle(uint style, uint substate) + { + int key = (int)((style << 16) | (substate & 0xFFFFFFu)); + return _table.Cycles.TryGetValue(key, out var data) ? data : null; + } + + private MotionData? LookupModifier(uint style, uint modKey, bool styleSpecific) + { + int key = styleSpecific ? (int)((style << 16) | modKey) : (int)modKey; + return _table.Modifiers.TryGetValue(key, out var data) ? data : null; + } +} diff --git a/src/AcDream.Core/Physics/Motion/CSequence.cs b/src/AcDream.Core/Physics/Motion/CSequence.cs new file mode 100644 index 00000000..a9da00b8 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/CSequence.cs @@ -0,0 +1,511 @@ +using System; +using System.Collections.Generic; +using System.Numerics; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R1-P4 host seam standing in for retail's CPhysicsObj.anim_hooks +/// SmartArray + the global AnimDoneHook singleton +/// (add_anim_hook 0x00514c20; process_hooks 0x00511550 drains +/// once per physics tick — the drain point stays with the host until R6 +/// places it per retail's UpdateObjectInternal order). +/// +public interface IAnimHookQueue +{ + /// Queue a matched AnimFrame hook (already direction-filtered + /// by execute_hooks). + void AddAnimHook(DatReaderWriter.Types.AnimationHook hook); + + /// Queue the global animation-done hook — retail's + /// AnimDoneHook::Execute → CPhysicsObj::Hook_AnimDone → + /// CPartArray::AnimationDone(1) chain (R2 consumes it as + /// MotionDone). + void AddAnimDoneHook(); +} + +/// +/// R1-P2 — verbatim port of retail's CSequence container + list +/// surgery (Phase R plan stage R1; oracle +/// `docs/research/2026-07-02-r1-csequence/r1-csequence-decomp.md` §1-§17, +/// §20, §24). The per-tick advance (`update`/`update_internal`/ +/// `apply_physics`/hook dispatch) lands in R1-P3/P4. +/// +/// Structure: a doubly-linked animation-node list with two cursors — +/// (the node currently playing) and +/// (where the looping tail begins; everything +/// before it is one-shot "link" animation). Retail invariant (G10): +/// append_animation slides first_cyclic to the JUST-APPENDED +/// node on EVERY call — the cyclic tail is always exactly the last node +/// appended so far. +/// +/// Physics accumulators (/) live on +/// the SEQUENCE, not per node (G16); retail replaces them via +/// set_velocity/set_omega and algebraically blends via +/// combine_physics/subtract_physics (the R2 fast path's mechanism). +/// +/// Divergence register (rows added with this commit): +/// +/// frame_number is x87 long double in retail +/// (acclient.h:30747); C# double is the closest available (G15). +/// The intrusive DLList is a managed ; +/// node identity semantics preserved via +/// references. +/// +/// +public sealed class CSequence +{ + private readonly LinkedList _animList = new(); // anim_list (DLList) + private LinkedListNode? _firstCyclic; // first_cyclic + private LinkedListNode? _currAnim; // curr_anim + private readonly IAnimationLoader _loader; + + /// Fractional frame position within . + /// Retail x87 long double → double (register row, G15). + public double FrameNumber; + + /// Sequence root-motion velocity accumulator (body-local). + public Vector3 Velocity; + + /// Sequence angular-velocity accumulator. + public Vector3 Omega; + + /// Static pose used when no animation node is active + /// (placement_frame, §16). + public AnimationFrame? PlacementFrame { get; private set; } + + public uint PlacementFrameId { get; private set; } + + public CSequence(IAnimationLoader loader) => _loader = loader; + + // ── inspection surface (adapter + tests) ──────────────────────────── + + public AnimSequenceNode? CurrAnim => _currAnim?.Value; + public AnimSequenceNode? FirstCyclic => _firstCyclic?.Value; + public int Count => _animList.Count; + + /// has_anims (0x00524bd0). + public bool HasAnims() => _animList.Count > 0; + + /// TEST SEAM: reposition curr_anim by list index (retail state + /// reached via update_internal, which lands in P4). + public void SetCurrAnimForTest(int index) + { + var n = _animList.First; + for (int i = 0; i < index && n != null; i++) n = n.Next; + _currAnim = n; + } + + // ── append_animation (0x00525510, §24) ────────────────────────────── + + /// + /// Append a MotionData anim entry. A node whose dat animation fails to + /// resolve is discarded. first_cyclic slides to the appended + /// node on EVERY call; curr_anim seeds to the head (with + /// frame_number = get_starting_frame()) only when it was null. + /// + public void AppendAnimation(AnimData animData) + { + var node = new AnimSequenceNode(animData, _loader); + if (!node.HasAnim) + return; // retail deletes the node — discard + + _animList.AddLast(node); + _firstCyclic = _animList.Last; + + if (_currAnim is null) + { + _currAnim = _animList.First; + FrameNumber = _currAnim!.Value.GetStartingFrame(); + } + } + + // ── clear family (§3-§5) ──────────────────────────────────────────── + + /// clear (0x005255b0): full wipe INCLUDING the placement + /// fields — the raw body resets them (the "2-instruction clear" note in + /// the gap map was wrong; raw decomp is authority). + public void Clear() + { + ClearAnimations(); + ClearPhysics(); + PlacementFrame = null; + PlacementFrameId = 0; + } + + /// clear_animations (0x00524dc0): delete every node, + /// null both cursors, zero frame_number. + public void ClearAnimations() + { + _animList.Clear(); + _firstCyclic = null; + _currAnim = null; + FrameNumber = 0.0; + } + + /// clear_physics (0x00524d50). + public void ClearPhysics() + { + Velocity = Vector3.Zero; + Omega = Vector3.Zero; + } + + // ── remove family (§6-§8) ─────────────────────────────────────────── + + /// + /// remove_cyclic_anims (0x00524e40): delete first_cyclic + /// → tail. A removed curr_anim snaps BACK to the previous node + /// with frame_number = prev.get_ending_frame() (or 0.0 when the + /// list emptied). Afterwards first_cyclic = new tail (or null). + /// + public void RemoveCyclicAnims() + { + var node = _firstCyclic; + while (node is not null) + { + var next = node.Next; + if (ReferenceEquals(_currAnim, node)) + { + var prev = node.Previous; + _currAnim = prev; + FrameNumber = prev is null ? 0.0 : prev.Value.GetEndingFrame(); + } + _animList.Remove(node); + node = next; + } + _firstCyclic = _animList.Last; + } + + /// + /// remove_link_animations(count) (0x00524be0): delete up to + /// predecessors of first_cyclic. A + /// removed curr_anim snaps FORWARD to first_cyclic with + /// frame_number = get_starting_frame(). + /// + public void RemoveLinkAnimations(int count) + { + for (int i = 0; i < count; i++) + { + var prev = _firstCyclic?.Previous; + if (prev is null) + break; + + if (ReferenceEquals(_currAnim, prev)) + { + _currAnim = _firstCyclic; + if (_firstCyclic is not null) + FrameNumber = _firstCyclic.Value.GetStartingFrame(); + } + _animList.Remove(prev); + } + } + + /// remove_all_link_animations (0x00524ca0): loop until + /// first_cyclic has no predecessor. + public void RemoveAllLinkAnimations() + { + while (_firstCyclic?.Previous is not null) + RemoveLinkAnimations(1); + } + + /// + /// apricot (0x00524b40; the PDB-verified retail name): trim + /// consumed nodes from the head, bounded by BOTH curr_anim + /// (stop — still live) and first_cyclic (defensive bound — + /// never delete into the cyclic tail). Called after every update (§22). + /// + public void Apricot() + { + var head = _animList.First; + if (head is null || ReferenceEquals(head, _currAnim)) + return; + + while (!ReferenceEquals(head, _firstCyclic)) + { + _animList.Remove(head!); + head = _animList.First; + if (head is null || ReferenceEquals(head, _currAnim)) + break; + } + } + + // ── physics accumulators (§10-§13) ────────────────────────────────── + + public void SetVelocity(Vector3 v) => Velocity = v; // 0x00524880 + public void SetOmega(Vector3 w) => Omega = w; // 0x005248a0 + public void CombinePhysics(Vector3 v, Vector3 w) { Velocity += v; Omega += w; } // 0x005248c0 + public void SubtractPhysics(Vector3 v, Vector3 w) { Velocity -= v; Omega -= w; } // 0x00524900 + + // ── multiply_cyclic_animation_fr (0x00524940, §14) ────────────────── + + /// + /// Scale the framerate of every node from first_cyclic to the + /// tail. Framerates ONLY (G13) — retail rescales the sequence + /// velocity/omega separately via change_cycle_speed's + /// subtract_motion/combine_motion composite (R2). + /// + public void MultiplyCyclicAnimationFramerate(float factor) + { + for (var n = _firstCyclic; n is not null; n = n.Next) + n.Value.MultiplyFramerate(factor); + } + + // ── placement + accessors (§15-§17) ───────────────────────────────── + + /// set_placement_frame (0x005249b0). + public void SetPlacementFrame(AnimationFrame? frame, uint id) + { + PlacementFrame = frame; + PlacementFrameId = id; + } + + /// get_curr_animframe (0x00524970): the floored current + /// part frame, or the placement frame when no node is active. + public AnimationFrame? GetCurrAnimframe() + { + if (_currAnim is null) + return PlacementFrame; + return _currAnim.Value.GetPartFrame((int)Math.Floor(FrameNumber)); + } + + /// get_curr_frame_number (0x005249d0). + public int GetCurrFrameNumber() => (int)Math.Floor(FrameNumber); + + // ── apply_physics (0x00524ab0, §19) ───────────────────────────────── + + /// + /// Accumulated-physics root motion: advance by + /// / over a signed quantum — + /// MAGNITUDE from , SIGN from + /// (retail copysign semantics; call sites + /// pass 1/framerate as magnitude and the signed elapsed time as sign). + /// + public void ApplyPhysics(Frame frame, double quantum, double signSource) + { + double signed = Math.Abs(quantum); + if (signSource < 0.0) + signed = -signed; + + float sq = (float)signed; + frame.Origin += Velocity * sq; + FrameOps.Rotate(frame, Omega * sq); + } + + // ── R1-P4: the frame-advance core ─────────────────────────────────── + + /// Host hook queue (hook_obj); null = hooks dropped + /// (objects without a physics host). + public IAnimHookQueue? HookObj; + + /// + /// CSequence::update (0x00525b80, §22): non-empty list → + /// then ; empty list + /// with a Frame → accumulated-physics free motion. + /// + public void Update(double timeElapsed, Frame? frame) + { + if (_animList.Count > 0 && _currAnim is not null) + { + UpdateInternal(timeElapsed, frame); + Apricot(); + } + else if (frame is not null) + { + ApplyPhysics(frame, timeElapsed, timeElapsed); + } + } + + /// + /// CSequence::update_internal (0x005255d0, §21 — ACE-verified + /// skeleton, P0-pins.md): advance by + /// framerate·dt; on overshoot clamp to the RAW high/low frame, compute + /// the leftover time, and mark animDone; fire the pose/physics/hook + /// triple for EVERY crossed integer frame (ascending forward, + /// descending reverse); queue the global AnimDoneHook when the list + /// HEAD is no longer the cyclic tail (G5's structural gate); advance to + /// the next node and LOOP with the carried leftover (P0 pin). + /// Iterative (retail while-true), NO safety cap (G4), NO boundary + /// epsilon (G1/G3). + /// + public void UpdateInternal(double timeElapsed, Frame? frame) + { + while (true) + { + if (_currAnim is null) + return; + + var currAnim = _currAnim.Value; + double framerate = currAnim.Framerate; + double frametime = framerate * timeElapsed; + int lastFrame = (int)Math.Floor(FrameNumber); + + FrameNumber += frametime; + double frameTimeElapsed = 0.0; + bool animDone = false; + + if (frametime > 0.0) + { + if (currAnim.HighFrame < Math.Floor(FrameNumber)) + { + double frameOffset = FrameNumber - currAnim.HighFrame - 1.0; + if (frameOffset < 0.0) + frameOffset = 0.0; + if (Math.Abs(framerate) > FrameOps.FEpsilon) + frameTimeElapsed = frameOffset / framerate; + FrameNumber = currAnim.HighFrame; + animDone = true; + } + while (Math.Floor(FrameNumber) > lastFrame) + { + if (frame is not null) + { + var pos = currAnim.GetPosFrame(lastFrame); + if (pos is not null) + FrameOps.Combine(frame, pos); + if (Math.Abs(framerate) > FrameOps.FEpsilon) + ApplyPhysics(frame, 1.0 / framerate, timeElapsed); + } + ExecuteHooks(currAnim.GetPartFrame(lastFrame), +1); + lastFrame++; + } + } + else if (frametime < 0.0) + { + if (currAnim.LowFrame > Math.Floor(FrameNumber)) + { + double frameOffset = FrameNumber - currAnim.LowFrame; + if (frameOffset > 0.0) + frameOffset = 0.0; + if (Math.Abs(framerate) > FrameOps.FEpsilon) + frameTimeElapsed = frameOffset / framerate; + FrameNumber = currAnim.LowFrame; + animDone = true; + } + while (Math.Floor(FrameNumber) < lastFrame) + { + if (frame is not null) + { + var pos = currAnim.GetPosFrame(lastFrame); + if (pos is not null) + FrameOps.Subtract1(frame, pos); + if (Math.Abs(framerate) > FrameOps.FEpsilon) + ApplyPhysics(frame, 1.0 / framerate, timeElapsed); + } + ExecuteHooks(currAnim.GetPartFrame(lastFrame), -1); + lastFrame--; + } + } + else + { + if (frame is not null && Math.Abs(timeElapsed) > FrameOps.FEpsilon) + ApplyPhysics(frame, timeElapsed, timeElapsed); + return; + } + + if (!animDone) + return; + + // AnimDone gate: a LIST-STRUCTURE test, not a node flag (G5) — + // fire only when the consumed head is not already the cyclic + // tail (retail 0x00525943-0x00525968). + if (HookObj is not null + && _animList.First is not null + && !ReferenceEquals(_animList.First, _firstCyclic)) + { + HookObj.AddAnimDoneHook(); + } + + AdvanceToNextAnimation(timeElapsed, frame); + timeElapsed = frameTimeElapsed; // the P0-pinned leftover carry + } + } + + /// + /// CSequence::advance_to_next_animation (0x005252b0, §23): four + /// pose operations per transition — un-apply the outgoing node's pose + /// (subtract1 + residual physics), step (forward wraps to + /// first_cyclic; REVERSE wraps to the LIST TAIL — asymmetric by + /// design), reseed from the incoming node's + /// direction-aware boundary, apply the incoming pose (combine + + /// physics). Pose ops run in BOTH directions (ACE's framerate-sign + /// gates are ACE-isms; the decomp is unconditional apart from the + /// degenerate-framerate guard). + /// + public void AdvanceToNextAnimation(double timeElapsed, Frame? frame) + { + if (_currAnim is null) + return; + + var outgoing = _currAnim.Value; + + // (a) un-apply the outgoing node's pose at the CURRENT FrameNumber. + if (frame is not null && Math.Abs(outgoing.Framerate) >= FrameOps.FEpsilon) + { + var pos = outgoing.GetPosFrame((int)FrameNumber); + if (pos is not null) + FrameOps.Subtract1(frame, pos); + ApplyPhysics(frame, 1.0 / outgoing.Framerate, timeElapsed); + } + + // (b) step; (c) reseed FrameNumber from the incoming boundary. + if (timeElapsed >= 0.0) + { + _currAnim = _currAnim.Next ?? _firstCyclic; + if (_currAnim is null) + return; + FrameNumber = _currAnim.Value.GetStartingFrame(); + } + else + { + _currAnim = _currAnim.Previous ?? _animList.Last; + if (_currAnim is null) + return; + FrameNumber = _currAnim.Value.GetEndingFrame(); + } + + // (d) apply the incoming node's pose at the new FrameNumber. + var incoming = _currAnim.Value; + if (frame is not null && Math.Abs(incoming.Framerate) >= FrameOps.FEpsilon) + { + var pos = incoming.GetPosFrame((int)FrameNumber); + if (pos is not null) + FrameOps.Combine(frame, pos); + ApplyPhysics(frame, 1.0 / incoming.Framerate, timeElapsed); + } + } + + /// + /// CSequence::execute_hooks (0x00524830, §18): QUEUE the part + /// frame's hooks whose direction is Both (0) or matches the playback + /// direction (+1 forward / −1 backward) into the host. Null part frame + /// guarded (retail has a latent null-deref here — documented safe + /// divergence, G18). + /// + private void ExecuteHooks(AnimationFrame? partFrame, int direction) + { + if (partFrame is null || HookObj is null) + return; + + foreach (var hook in partFrame.Hooks) + { + if (hook is null) + continue; + int dir = (int)hook.Direction; + if (dir == 0 || dir == direction) + HookObj.AddAnimHook(hook); + } + } + + // ── internal cursors for P4 (update_internal operates on nodes) ───── + + internal LinkedListNode? CurrAnimNode + { + get => _currAnim; + set => _currAnim = value; + } + + internal LinkedListNode? FirstCyclicNode => _firstCyclic; + internal LinkedList AnimList => _animList; +} diff --git a/src/AcDream.Core/Physics/Motion/ConstraintManager.cs b/src/AcDream.Core/Physics/Motion/ConstraintManager.cs new file mode 100644 index 00000000..72e8ecbf --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/ConstraintManager.cs @@ -0,0 +1,120 @@ +using System; +using System.Numerics; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R5 — verbatim port of retail's ConstraintManager (acclient.h:31529, +/// struct #3467; decomp 0x00556090-0x005562xx, +/// r5-constraintmanager-decomp.md). The server-position rubber-band +/// leash: while the owning object is in ground contact it progressively +/// resists movement past a start→max distance band from a pinned anchor, and +/// hard-clamps at the max. Read as a jump gate by +/// CMotionInterp::jump_is_allowed (block jump while +/// ). +/// +/// Arming is UNPORTED in acdream (R5). Retail arms the leash ONLY +/// from SmartBox::HandleReceivedPosition (on every inbound server +/// position packet) with two constants from +/// CPhysicsObj::GetStart/MaxConstraintDistance whose values BN elided +/// (x87 returns — unknown, need a cdb read). acdream's position reconciliation +/// is not SmartBox, so nothing calls — the leash +/// stays disarmed and stays false, matching +/// register TS-35's current stub behavior. The class is ported for structural +/// completeness of ; the leash-arming port + the +/// two unknown constants are a deferred issue (port-plan §Constraint scope). +/// +public sealed class ConstraintManager +{ + private readonly IPhysicsObjHost _host; + + /// +0x04 retail is_constrained. + public bool IsConstrained { get; private set; } + + /// +0x08 retail constraint_pos_offset — recomputed every + /// as the LENGTH of that tick's step (NOT the + /// distance to the anchor — see the ACE correctness note, port-plan §2b); + /// the next tick's contact branch compares it against start/max. + public float ConstraintPosOffset { get; private set; } + + /// +0x0c retail constraint_pos — the leash anchor. Stored + /// by , never read by + /// (retail + ACE — write-only in this class). + public Position ConstraintPos { get; private set; } + + /// +0x48 retail constraint_distance_start — the near edge + /// of the brake band. + public float ConstraintDistanceStart { get; private set; } + + /// +0x4c retail constraint_distance_max — the far edge + /// (full clamp). + public float ConstraintDistanceMax { get; private set; } + + public ConstraintManager(IPhysicsObjHost host) + => _host = host ?? throw new ArgumentNullException(nameof(host)); + + /// + /// Retail ConstraintManager::ConstrainTo (0x00556240). Pin the leash + /// anchor and band; initialize to the + /// CURRENT distance from anchor to the mover (the leash starts already + /// extended to wherever the object is, not at zero). + /// + public void ConstrainTo(Position anchor, float startDistance, float maxDistance) + { + IsConstrained = true; + ConstraintPos = anchor; + ConstraintDistanceStart = startDistance; + ConstraintDistanceMax = maxDistance; + ConstraintPosOffset = Vector3.Distance(anchor.Frame.Origin, _host.Position.Frame.Origin); + } + + /// Retail ConstraintManager::UnConstrain (0x005560c0) — + /// clears the constrained flag only (leaves the band/anchor/offset stale + /// until the next ). + public void UnConstrain() => IsConstrained = false; + + /// + /// Retail ConstraintManager::IsFullyConstrained (0x005560d0): + /// constraint_distance_max * 0.9 < constraint_pos_offset — the + /// object counts as fully constrained once it has strained past 90 % of the + /// max leash. Read by jump_is_allowed to block jumps. Always false + /// while the leash is disarmed (acdream never arms it — see class note). + /// + public bool IsFullyConstrained() + => ConstraintDistanceMax * 0.9f < ConstraintPosOffset; + + /// + /// Retail ConstraintManager::adjust_offset (0x00556180). The last + /// stage of 's chain — clamps the + /// ALREADY-composed per-tick (interp + sticky) + /// while grounded, then records its length for the next tick. No-op unless + /// . See port-plan §2b. + /// + public void AdjustOffset(MotionDeltaFrame offset, double quantum) + { + _ = quantum; // retail body doesn't use the quantum directly. + if (!IsConstrained) + return; + + if (_host.InContact) // transient_state & 1 — clamp only while grounded. + { + if (ConstraintPosOffset < ConstraintDistanceMax) + { + if (ConstraintPosOffset > ConstraintDistanceStart) + { + // Linear brake taper: 1.0 just past start → 0.0 at max. + float taper = (ConstraintDistanceMax - ConstraintPosOffset) + / (ConstraintDistanceMax - ConstraintDistanceStart); + offset.Origin *= taper; + } + } + else + { + offset.Origin = Vector3.Zero; // past max — fully pinned. + } + } + + // Unconditional (grounded OR airborne): track this tick's step length. + ConstraintPosOffset = offset.Origin.Length(); + } +} diff --git a/src/AcDream.Core/Physics/Motion/FrameOps.cs b/src/AcDream.Core/Physics/Motion/FrameOps.cs new file mode 100644 index 00000000..a36a1292 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/FrameOps.cs @@ -0,0 +1,82 @@ +using System; +using System.Numerics; +using DatReaderWriter.Types; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R1-P3 — verbatim ports of retail's Frame rotation helpers used by +/// the CSequence physics path (oracle: raw decomp reads 2026-07-02). +/// +/// +/// Frame::grotate (0x005357a0, pc:319782): build the +/// axis-angle quaternion from a GLOBAL rotation vector (angle = |v|, +/// axis = v/|v|, half-angle sin/cos) and PREMULTIPLY it onto the frame's +/// orientation — the incremental rotation is applied in world space. +/// Rotations with |v|² < F_EPSILON² are skipped. +/// Frame::rotate (0x004525b0, pc:91477): map the LOCAL +/// rotation vector through the frame's local→global rotation +/// (m_fl2gv — our quaternion), then grotate. +/// +/// +public static class FrameOps +{ + /// Retail F_EPSILON (0.000199999995f); grotate gates on its + /// square against |v|². + public const float FEpsilon = 0.000199999995f; + + /// Frame::grotate — incremental WORLD-space rotation. + public static void GRotate(Frame frame, Vector3 rotationGlobal) + { + float magSq = rotationGlobal.LengthSquared(); + if (magSq < FEpsilon * FEpsilon) + return; + + float angle = MathF.Sqrt(magSq); + float invMag = 1f / angle; + float half = angle * 0.5f; + float s = MathF.Sin(half); + float c = MathF.Cos(half); + + // Retail's set_rotate receives the raw Hamilton product r ⊗ q + // (r = the new axis-angle quat, q = the current orientation) — + // rotation applied in GLOBAL space. System.Numerics + // Quaternion.Multiply(r, q) is that product with + // Transform(v, r*q) == r-applied-after-q. set_rotate renormalizes. + var r = new Quaternion( + rotationGlobal.X * s * invMag, + rotationGlobal.Y * s * invMag, + rotationGlobal.Z * s * invMag, + c); + frame.Orientation = Quaternion.Normalize(Quaternion.Multiply(r, frame.Orientation)); + } + + /// Frame::rotate — LOCAL rotation vector, mapped to + /// global through the orientation, then . + public static void Rotate(Frame frame, Vector3 rotationLocal) + => GRotate(frame, Vector3.Transform(rotationLocal, frame.Orientation)); + + /// + /// Frame::combine as used by the CSequence pose path (ACE + /// AFrame.Combine, verified against the pre-R1 acdream port): + /// apply the pose — origin += rotate(pos.Origin by orientation), then + /// orientation ∘= pos.Orientation. + /// + public static void Combine(Frame frame, Frame pos) + { + frame.Origin += Vector3.Transform(pos.Origin, frame.Orientation); + frame.Orientation = Quaternion.Normalize(frame.Orientation * pos.Orientation); + } + + /// + /// Frame::subtract1 — un-apply the pose: orientation ∘= + /// conj(pos.Orientation) FIRST, then origin −= rotate(pos.Origin by the + /// UPDATED orientation) (inverse order of ). + /// + public static void Subtract1(Frame frame, Frame pos) + { + frame.Orientation = Quaternion.Normalize( + frame.Orientation * Quaternion.Conjugate(pos.Orientation)); + frame.Origin -= Vector3.Transform(pos.Origin, frame.Orientation); + } +} diff --git a/src/AcDream.Core/Physics/Motion/IPhysicsObjHost.cs b/src/AcDream.Core/Physics/Motion/IPhysicsObjHost.cs new file mode 100644 index 00000000..85b4eb88 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/IPhysicsObjHost.cs @@ -0,0 +1,100 @@ +using System.Numerics; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R5 seam — the acdream stand-in for retail's CPhysicsObj as seen BY +/// its owned managers. Retail's StickyManager / ConstraintManager +/// / TargetManager each hold a raw physics_obj pointer and call +/// back through it (position/velocity/radius accessors, target-tracking +/// registration, the HandleUpdateTarget fan-out) and — for the voyeur +/// system — resolve OTHER physics objects via CObjectMaint::GetObjectA +/// and drive their add_voyeur / receive_target_update / +/// remove_voyeur entry points. This interface is that back-pointer. +/// +/// The App layer implements one host per entity (a remote +/// RemoteMotion or the local player), wiring the accessors to the live +/// and the / +/// / it owns. +/// is backed by the App's live entity table +/// (_entitiesByServerGuid), giving the voyeur round-trip its +/// cross-entity delivery path. +/// +public interface IPhysicsObjHost +{ + /// Retail physics_obj->id — this object's guid. + uint Id { get; } + + /// Retail physics_obj->m_position — world-space cell + + /// frame (acdream seams carry WORLD space; see the MoveToManager binding + /// note). + Position Position { get; } + + /// Retail CPhysicsObj::get_velocity. + Vector3 Velocity { get; } + + /// Retail CPhysicsObj::GetRadius — the mover's cylinder + /// radius. + float Radius { get; } + + /// Retail physics_obj->transient_state & 1 — the + /// CONTACT bit (ConstraintManager's grounded gate). + bool InContact { get; } + + /// Retail CPhysicsObj::get_minterp()->get_max_speed() — + /// the mover's max locomotion speed, or null if it has no motion + /// interpreter yet (StickyManager falls back to a 15.0 constant). + float? MinterpMaxSpeed { get; } + + /// Retail Timer::cur_time — the wall/game clock (seconds). + /// Drives the sticky 1 s timeout and target 10 s staleness deadlines. + double CurTime { get; } + + /// Retail PhysicsTimer::curr_time — the physics-tick clock + /// (seconds). Drives TargetManager::HandleTargetting's 0.5 s + /// throttle. Retail uses a DIFFERENT clock here than ; + /// acdream may bind both to the same source. + double PhysicsTimerTime { get; } + + /// Retail CObjectMaint::GetObjectA(id) — resolve another + /// physics object by guid, or null if not currently known/visible. + /// The cross-entity seam for the voyeur round-trip and sticky live-target + /// resolve. + IPhysicsObjHost? GetObjectA(uint id); + + /// Retail CPhysicsObj::HandleUpdateTarget — fans a + /// to this host's + /// (move-to steering) AND (sticky follow). + /// Called from and the timeout + /// path. + void HandleUpdateTarget(TargetInfo info); + + /// Retail CPhysicsObj::interrupt_current_movement → + /// MovementManager::CancelMoveTo(0x36). + void InterruptCurrentMovement(); + + /// Retail CPhysicsObj::set_target(ctx, objId, radius, + /// quantum) → (lazily creating + /// the TargetManager). Called by StickyManager::StickTo and + /// MoveToManager's object-move entry points. + void SetTarget(uint contextId, uint objectId, float radius, double quantum); + + /// Retail CPhysicsObj::clear_target → + /// . + void ClearTarget(); + + /// Retail CPhysicsObj::receive_target_update → + /// . The inbound side a SENDER's + /// SendVoyeurUpdate tail-calls on the watcher. + void ReceiveTargetUpdate(TargetInfo info); + + /// Retail CPhysicsObj::add_voyeur(id, radius, quantum) → + /// (lazily creating the + /// TargetManager). Called on the TARGET when a watcher subscribes. + void AddVoyeur(uint watcherId, float radius, double quantum); + + /// Retail CPhysicsObj::remove_voyeur(id) → + /// . Called on the TARGET when a + /// watcher unsubscribes. + void RemoveVoyeur(uint watcherId); +} diff --git a/src/AcDream.Core/Physics/Motion/MotionDeltaFrame.cs b/src/AcDream.Core/Physics/Motion/MotionDeltaFrame.cs new file mode 100644 index 00000000..8386e5a2 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MotionDeltaFrame.cs @@ -0,0 +1,40 @@ +using System.Numerics; + +namespace AcDream.Core.Physics.Motion; + +/// +/// Mutable stand-in for retail's Frame when it is used as the per-tick +/// delta accumulator that PositionManager::adjust_offset and its +/// three sub-managers (Interpolation / Sticky / Constraint) write into +/// (retail arg2, e.g. StickyManager::adjust_offset 0x00555430, +/// ConstraintManager::adjust_offset 0x00556180). acdream's +/// is an immutable record — retail's per-tick math +/// mutates m_fOrigin in place across the interp→sticky→constraint chain +/// (each sub-manager composes on top of the previous one's write), so the +/// accumulator needs a mutable shape. +/// +/// = retail m_fOrigin (the accumulated +/// position delta, in the mover's LOCAL frame after +/// Position::globaltolocalvec). carries the +/// heading retail's Frame::set_heading writes; read/write it as a +/// compass heading via / +/// (P5 convention, degrees). +/// +public sealed class MotionDeltaFrame +{ + /// Retail m_fOrigin — the accumulated per-tick position + /// delta (mover-local frame). + public Vector3 Origin; + + /// Retail Frame rotation — carries the + /// Frame::set_heading output. + public Quaternion Orientation = Quaternion.Identity; + + /// Retail Frame::get_heading (P5 compass degrees). + public float GetHeading() => MoveToMath.GetHeading(Orientation); + + /// Retail Frame::set_heading(headingDeg) — pure + /// yaw-about-Z setter (P5 compass degrees). + public void SetHeading(float headingDeg) => + Orientation = MoveToMath.SetHeading(Orientation, headingDeg); +} diff --git a/src/AcDream.Core/Physics/Motion/MotionNode.cs b/src/AcDream.Core/Physics/Motion/MotionNode.cs new file mode 100644 index 00000000..007a6c11 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MotionNode.cs @@ -0,0 +1,30 @@ +namespace AcDream.Core.Physics.Motion; + +/// +/// R3-W1 — verbatim port of retail's CMotionInterp::MotionNode +/// (acclient.h:53293, struct #5857): +/// +/// struct __cppobj CMotionInterp::MotionNode : LListData +/// { +/// unsigned int context_id; // +4 (offset from LListData's own +0 next-ptr) +/// unsigned int motion; // +8 — the "action-class" field; bit 0x10000000 = action-class flag +/// unsigned int jump_error_code; // +0xc +/// }; +/// +/// This is the node type queued onto CMotionInterp::pending_motions +/// by add_to_queue (0x00527b80, docs/research/2026-07-02-r3-motioninterp/ +/// r3-motioninterp-decomp.md §1a) and consumed head-first, unconditionally, +/// by MotionDone (0x00527ec0, §1c) / HandleExitWorld (0x00527f30, +/// §1d). W1 ports only the shape — the queue itself (PendingMotions, +/// add_to_queue, MotionDone) is R3-W2 scope (r3-port-plan.md §3). +/// +/// Retail context_id (+4) — the +/// MovementParameters.ContextId that produced this node. +/// Retail motion (+8) — the applied motion id. +/// Bit 0x10000000 marks an "action-class" motion; MotionDone +/// only pops the state action-FIFO head when this bit is set on the queue +/// head it is consuming. +/// Retail jump_error_code (+0xc) — the +/// motion_allows_jump result computed at enqueue time. Peeked by +/// jump_is_allowed's pending-head short-circuit (W0-pins A2). +public readonly record struct MotionNode(uint ContextId, uint Motion, uint JumpErrorCode); diff --git a/src/AcDream.Core/Physics/Motion/MotionState.cs b/src/AcDream.Core/Physics/Motion/MotionState.cs new file mode 100644 index 00000000..94c96a58 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MotionState.cs @@ -0,0 +1,122 @@ +using System.Collections.Generic; + +namespace AcDream.Core.Physics.Motion; + +/// +/// One entry of a chain — retail's +/// MotionList node (12 bytes: motion + speed_mod + next; +/// acclient.h, r2-motiontable-decomp.md §14). One struct, two independent +/// chain disciplines: the modifier chain is a PUSH-FRONT STACK, the action +/// chain a TAIL-APPEND FIFO. +/// +public sealed class MotionEntry +{ + public uint Motion; + public float SpeedMod = 1f; + + public MotionEntry(uint motion, float speedMod) + { + Motion = motion; + SpeedMod = speedMod; + } +} + +/// +/// R2-Q1 — verbatim port of retail's MotionState (acclient.h:31081; +/// r2-motiontable-decomp.md §13): the motion-table-facing state block — +/// current style / substate / substate_mod plus the modifier stack and the +/// action FIFO that CMotionTable::GetObjectSequence, +/// StopSequenceMotion, re_modify, and +/// MotionTableManager::AnimationDone read and write. +/// +public sealed class MotionState +{ + /// Current style/stance command word (0 = unset; ctor 0x00525fd0). + public uint Style; + + /// Current base substate command word (0 = unset). + public uint Substate; + + /// Speed modifier of the base substate (default 1.0). + public float SubstateMod = 1f; + + private readonly LinkedList _modifiers = new(); // modifier_head — push-front stack + private readonly LinkedList _actions = new(); // action_head/tail — FIFO + + public MotionState() + { + } + + /// + /// Deep copy (retail copy ctor 0x00526790; Q0-pins A4-#5): both chains + /// CLONED — re_modify's snapshot is a termination bound, never + /// shared state. + /// + public MotionState(MotionState other) + { + Style = other.Style; + Substate = other.Substate; + SubstateMod = other.SubstateMod; + foreach (var m in other._modifiers) + _modifiers.AddLast(new MotionEntry(m.Motion, m.SpeedMod)); + foreach (var a in other._actions) + _actions.AddLast(new MotionEntry(a.Motion, a.SpeedMod)); + } + + /// Modifier chain in retail order (newest first — push-front). + public IEnumerable Modifiers => _modifiers; + + /// Action FIFO in retail order (oldest first). + public IEnumerable Actions => _actions; + + /// add_modifier_no_check (0x00525ff0): unconditional + /// push-front. + public void AddModifierNoCheck(uint motion, float speedMod) + => _modifiers.AddFirst(new MotionEntry(motion, speedMod)); + + /// + /// add_modifier (0x00526340): refuse when the motion is already + /// a modifier (caller must stop-then-re-add to refresh) or already IS + /// the current base substate. + /// + public bool AddModifier(uint motion, float speedMod) + { + for (var n = _modifiers.First; n is not null; n = n.Next) + if (n.Value.Motion == motion) + return false; + + if (Substate == motion) + return false; + + AddModifierNoCheck(motion, speedMod); + return true; + } + + /// remove_modifier (0x00526040) — by node identity + /// (retail's node+predecessor pair collapses in a managed list). + public void RemoveModifier(MotionEntry entry) + { + _modifiers.Remove(entry); + } + + /// clear_modifiers (0x00526070). + public void ClearModifiers() => _modifiers.Clear(); + + /// add_action (0x005260a0): tail append. + public void AddAction(uint motion, float speedMod) + => _actions.AddLast(new MotionEntry(motion, speedMod)); + + /// remove_action_head (0x00526120): pop the FIFO head, + /// returning its motion id (0 when empty). + public uint RemoveActionHead() + { + var head = _actions.First; + if (head is null) + return 0; + _actions.RemoveFirst(); + return head.Value.Motion; + } + + /// clear_actions (0x005260f0). + public void ClearActions() => _actions.Clear(); +} diff --git a/src/AcDream.Core/Physics/Motion/MotionTableDispatchSink.cs b/src/AcDream.Core/Physics/Motion/MotionTableDispatchSink.cs new file mode 100644 index 00000000..8ffb1990 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MotionTableDispatchSink.cs @@ -0,0 +1,89 @@ +using System; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R2-Q5 — the that dispatches the +/// CMotionInterp funnel's retail-ordered motion events STRAIGHT into the +/// entity's motion-table stack via +/// (lazy initialize_state + +/// MotionTableManager::PerformMovement 0x0051c0b0). +/// +/// +/// This replaces the App-side RemoteMotionSink (deleted): no axis +/// collection, no single-cycle priority pick, no Commit pass, no HasCycle +/// probe, no Run→Walk→Ready missing-cycle chain — retail's +/// GetObjectSequence (0x00522860) + is_allowed decide what +/// plays. Forward locomotion installs the substate cycle (Branch 2); +/// sidesteps resolve by the dat (cycle when authored, else modifier); +/// turns are Branch-4 physics-only modifiers blended over the substate via +/// combine_motion/re_modify — the composition the retired +/// AP-73 row approximated with one cycle. +/// +/// +/// +/// The / callbacks are the +/// interim ObservedOmega seam: the App seeds the remote body's angular +/// velocity from the wire turn so rotation starts the same tick (retail +/// rotates the body from the sequence omega inside the per-tick +/// apply_physics chain — R6 scope; register row). They fire BEFORE +/// the dispatch so a consumer sees the seed even if the dat lacks the +/// modifier entry. +/// +/// +public sealed class MotionTableDispatchSink : IInterpretedMotionSink +{ + private readonly AnimationSequencer _sequencer; + + /// Turn-class dispatch observed: (motion, signedSpeed) — + /// TurnLeft arrives either as the explicit 0x0E command or as + /// TurnRight + negative speed (adjust_motion wire convention). + public Action? TurnApplied { get; set; } + + /// Turn-class stop observed. + public Action? TurnStopped { get; set; } + + public MotionTableDispatchSink(AnimationSequencer sequencer) + { + ArgumentNullException.ThrowIfNull(sequencer); + _sequencer = sequencer; + } + + private static bool IsTurn(uint motion) + => (motion & 0xFF000000u) == 0x65000000u && (motion & 0xFFu) is 0x0D or 0x0E; + + public bool ApplyMotion(uint motion, float speed) + { + if (IsTurn(motion)) + TurnApplied?.Invoke(motion, speed); + + uint result = _sequencer.PerformMovement(MotionTableMovement.Interpreted(motion, speed)); + return result == MotionTableManagerError.Success; + } + + public bool StopMotion(uint motion) + { + if (IsTurn(motion)) + TurnStopped?.Invoke(); + + uint result = _sequencer.PerformMovement(MotionTableMovement.StopInterpreted(motion, 1f)); + return result == MotionTableManagerError.Success; + } + + /// + /// R4-V5 wedge fix — retail CPartArray::StopCompletelyInternal + /// (0x00518890): MotionTableManager::PerformMovement(type 5). + /// The manager stops everything and queues its Ready-sentinel + /// pending_animations entry UNCONDITIONALLY — the completable partner + /// of the interp's A9 pending_motions node. A full stop ends any turn + /// cycle, so the ObservedOmega seam is notified like + /// 's turn-class branch. + /// + public bool StopCompletely() + { + TurnStopped?.Invoke(); + + uint result = _sequencer.PerformMovement(MotionTableMovement.StopCompletely()); + return result == MotionTableManagerError.Success; + } +} diff --git a/src/AcDream.Core/Physics/Motion/MotionTableManager.cs b/src/AcDream.Core/Physics/Motion/MotionTableManager.cs new file mode 100644 index 00000000..271c3ce8 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MotionTableManager.cs @@ -0,0 +1,508 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using AcDream.Core.Physics; + +namespace AcDream.Core.Physics.Motion; + +// ───────────────────────────────────────────────────────────────────────────── +// R2-Q3 — verbatim port of retail's MotionTableManager (the pending-animation +// queue + tick-countdown completion machinery sitting ABOVE CMotionTable). +// Oracle: docs/research/2026-07-02-r2-motiontable/r2-motiontable-decomp.md §11 +// (all addresses/line numbers below point there); ambiguity pins: +// docs/research/2026-07-02-r2-motiontable/Q0-pins.md; plan: +// docs/research/2026-07-02-r2-motiontable/r2-port-plan.md §3 Q3 + §4 (the +// MotionDone -> R3 boundary contract). +// +// Struct layout (acclient.h:57614/31092/31097; decomp §11 offset map): +// physics_obj @0x0, table @0x4, state @0x8 (24 bytes), animation_counter +// @0x20, pending_animations {head_,tail_} @0x24/0x28. sizeof == 0x2c. +// C# has no physics_obj field — R2 leaves the CPhysicsObj::MotionDone target +// as an injectable seam (IMotionDoneSink, part A of this file) since R3 binds +// the real MotionInterpreter/MovementManager consumer. +// ───────────────────────────────────────────────────────────────────────────── + +/// +/// The R2 seam standing in for retail's CPhysicsObj::MotionDone — the +/// callback and +/// fire for every +/// pending-queue entry whose tick countdown reaches zero. R2 leaves this +/// consumer-injectable (register row: MotionDone observed-not-consumed, +/// r2-port-plan.md §4); R3 binds it to MotionInterpreter.MotionDone +/// (pops CMotionInterp.pending_motions, recomputes IsAnimating). +/// +public interface IMotionDoneSink +{ + /// + /// CPhysicsObj::MotionDone(motion, success). + /// is the CALLER's flag: true from the real per-tick animation-done hook + /// ( invoked with + /// success:true), false from the enter/exit-world drains, + /// hardcoded true from . + /// + void MotionDone(uint motion, bool success); +} + +/// +/// One pending_animations queue node — retail's +/// MotionTableManager::AnimNode (acclient.h:57614; 16 bytes: +/// dllist_next/prev + motion + num_anims). NumAnims doubles as a +/// RELATIVE tick-duration countdown once queued (not an absolute deadline — +/// decomp §11 AnimationDone note), not an anim-array length. +/// +/// Register note (reusing the R1 AD-34 wording): retail's intrusive DLList +/// is ported as a managed of ; +/// node identity semantics (the tail-anchored backward scan in +/// , the in-place +/// truncation in ) are +/// preserved via references rather than raw +/// prev/next pointers. +/// +public sealed class PendingMotion +{ + public uint Motion; + public uint NumAnims; + + public PendingMotion(uint motion, uint numAnims) + { + Motion = motion; + NumAnims = numAnims; + } +} + +/// +/// Retail's MotionTableManager (0x0051bxxx region) — owns the +/// pending-animation queue and the tick-countdown completion machinery that +/// sits ABOVE 's pure selection logic. +/// is the single chokepoint between a wire-level +/// and the motion-table state machine (decomp +/// §11 PerformMovement 0x0051c0b0). +/// +public sealed class MotionTableManager +{ + // Motion-id class bits (decomp §1 / §15). + private const uint CycleClassBit = 0x40000000u; + private const uint ModifierClassBit = 0x20000000u; + private const uint ActionClassBit = 0x10000000u; + + /// + /// Combined block-mask used by 's + /// CYCLE-class tail scan (decomp §11/§15 literal "0xb0000000"). Bit + /// decomposition: 0xb0000000 == 0x80000000 (style) | 0x20000000 + /// (modifier) | 0x10000000 (action) — i.e. STYLE|MODIFIER|ACTION, + /// deliberately EXCLUDING the cycle-class bit (0x40000000) itself. The + /// decomp's own prose gloss ("cycle|action|..." mask) is imprecise; the + /// literal hex constant (ported verbatim below) is the ground truth — + /// an intervening node of a DIFFERENT cycle does not block a cycle-tail + /// collapse (two cycles naturally supersede via the base-cycle rebuild + /// mechanism), but an intervening style-change/modifier/action does. + /// + private const uint CycleTailBlockMask = 0xb0000000u; + + /// + /// Combined block-mask used by 's + /// STYLE-class tail scan (decomp §11/§15 literal "0x70000000"). Bit + /// decomposition: 0x70000000 == 0x40000000 (cycle) | 0x20000000 + /// (modifier) | 0x10000000 (action) — CYCLE|MODIFIER|ACTION, + /// deliberately EXCLUDING the style-class top bit (0x80000000) itself + /// (the match test is already exact-equality on the full style id, so a + /// DIFFERENT style in between doesn't need a separate block check here). + /// + private const uint StyleTailBlockMask = 0x70000000u; + + /// Sentinel "stop-completely / default-state-installed" motion id + /// (decomp §15 "0x41000003"). + public const uint ReadySentinel = 0x41000003u; + + private readonly CMotionTable? _table; + private readonly MotionState _state; + private readonly CSequence _sequence; + private readonly IMotionDoneSink _sink; + private readonly LinkedList _pendingAnimations = new(); // pending_animations + private int _animationCounter; // animation_counter (@0x20) + + /// Current motion state — retail's embedded state member + /// (@0x8, 24 bytes). Exposed for callers that need to read style/substate. + public MotionState State => _state; + + /// + /// Create 0x0051bc50 (@290510). Retail's static factory + /// zero-initializes physics_obj/table, placement-constructs + /// state, zeros animation_counter, and nulls + /// pending_animations's head/tail — all of which the C# field + /// initializers below already give for free. may + /// be null (retail: "no motion table loaded" — + /// returns error 7 in that case, matching SetMotionTableID never + /// having been called). + /// + public MotionTableManager(CMotionTable? table, MotionState state, CSequence sequence, IMotionDoneSink sink) + { + ArgumentNullException.ThrowIfNull(state); + ArgumentNullException.ThrowIfNull(sequence); + ArgumentNullException.ThrowIfNull(sink); + + _table = table; + _state = state; + _sequence = sequence; + _sink = sink; + } + + /// Read-only inspection surface for tests: the pending queue in + /// head-to-tail order. + public IEnumerable PendingAnimations => _pendingAnimations; + + /// Read-only inspection surface for tests: the current tick + /// countdown accumulator. + public int AnimationCounter => _animationCounter; + + // ── add_to_queue / remove_redundant_links / truncate_animation_list ──── + + /// + /// add_to_queue 0x0051bfe0 (@290854): append a new node to the + /// tail of pending_animations, then opportunistically call + /// to collapse any now-superseded + /// earlier entries. + /// + public void AddToQueue(uint motion, uint ticks) + { + _pendingAnimations.AddLast(new PendingMotion(motion, ticks)); + RemoveRedundantLinks(); + } + + /// + /// remove_redundant_links 0x0051bf20 (@290771): retail's + /// TAIL-ANCHORED SINGLE SCAN (ported verbatim — NOT ACE's restructured + /// outer loop, per r2-port-plan.md §3 Q3). + /// + /// 1. Skip backward over trailing zero-NumAnims nodes (already + /// neutered / instant entries). If the list bottoms out, return. + /// 2. If the effective tail's motion is CYCLE-class-and-not-modifier-class + /// (&0x40000000 != 0 && &0x20000000 == 0): scan backward for an + /// EARLIER node with the SAME motion id AND non-zero NumAnims. + /// Blocked (abort, no truncation) by any intervening non-zero node + /// whose motion matches the 0xb0000000 class mask. + /// 3. Else if the effective tail's motion is STYLE-class + /// ((int)motion < 0): same backward scan, EXACT match (no + /// additional class requirement on the match itself), blocked by any + /// intervening non-zero node matching the WIDER 0x70000000 class mask. + /// 4. On a match, from the matched + /// node's successor through the tail (matched node itself untouched). + /// + public void RemoveRedundantLinks() + { + var tail = _pendingAnimations.Last; + if (tail is null) + return; + + // Step 1: skip trailing zero-tick nodes. + while (tail is not null && tail.Value.NumAnims == 0) + { + tail = tail.Previous; + } + if (tail is null) + return; + + uint motion = tail.Value.Motion; + + if ((motion & CycleClassBit) != 0 && (motion & ModifierClassBit) == 0) + { + // CYCLE-class (not modifier-class) tail: match = same motion AND + // non-zero NumAnims; block = non-zero AND matches 0xb0000000. + var scan = tail.Previous; + LinkedListNode? matched = null; + while (scan is not null) + { + if (scan.Value.Motion == motion && scan.Value.NumAnims != 0) + { + matched = scan; + break; + } + if (scan.Value.NumAnims != 0 && (scan.Value.Motion & CycleTailBlockMask) != 0) + return; // blocked by an intervening "important" non-zero node + scan = scan.Previous; + } + if (matched is not null) + TruncateAnimationList(matched); + } + else if ((int)motion < 0) + { + // STYLE-class tail: exact-equality match; block mask is wider + // (0x70000000) with no additional match-side class requirement. + var scan = tail.Previous; + LinkedListNode? matched = null; + while (scan is not null) + { + if (scan.Value.Motion == motion) + { + matched = scan; + break; + } + if (scan.Value.NumAnims != 0 && (scan.Value.Motion & StyleTailBlockMask) != 0) + return; + scan = scan.Previous; + } + if (matched is not null) + TruncateAnimationList(matched); + } + // else: modifier-class or action-class tail -> no redundancy scan (retail: neither branch taken). + } + + /// + /// truncate_animation_list 0x0051bca0 (@290533): walk + /// pending_animations.tail_ BACKWARD toward (but not including) + /// , zeroing each node's + /// NumAnims tick countdown IN PLACE (nodes stay queued — retail + /// does NOT unlink them here) and accumulating the total ticks removed, + /// then strips that many ticks' worth of link animations from the live + /// via . + /// + private void TruncateAnimationList(LinkedListNode stopAtExclusive) + { + uint removedTicks = 0; + var node = _pendingAnimations.Last; + while (!ReferenceEquals(node, stopAtExclusive)) + { + if (node is null) + return; // stopAtExclusive wasn't actually in the list -> abort quietly + + removedTicks += node.Value.NumAnims; + node.Value.NumAnims = 0; + node = node.Previous; + } + + _sequence.RemoveLinkAnimations((int)removedTicks); + } + + // ── AnimationDone / CheckForCompletedMotions / UseTime ───────────────── + + /// + /// AnimationDone 0x0051bce0 (@290558): advance the animation clock + /// by one tick and fire for every + /// queued motion whose relative-duration countdown has elapsed. + /// NumAnims on a queue node is a RELATIVE tick-duration (not an + /// absolute deadline) — subtracted from the running counter after firing, + /// forming a decrementing countdown chain (one AnimationDone call + /// can pop MULTIPLE queued entries via counter rollover). + /// + /// Passed straight through to + /// for every entry popped this + /// call. + public void AnimationDone(bool success) + { + var head = _pendingAnimations.First; + if (head is null) + return; + + _animationCounter += 1; + + while (head is not null && head.Value.NumAnims <= _animationCounter) + { + if ((head.Value.Motion & ActionClassBit) != 0) + _state.RemoveActionHead(); + + _sink.MotionDone(head.Value.Motion, success); + _animationCounter -= (int)head.Value.NumAnims; + + _pendingAnimations.RemoveFirst(); + head = _pendingAnimations.First; + } + + // Drained-list counter reset: avoid drift once the queue is empty. + if (_animationCounter != 0 && head is null) + _animationCounter = 0; + } + + /// + /// CheckForCompletedMotions 0x0051be00 (@290645): pop every head + /// node ALREADY at NumAnims == 0 (zero-tick entries, or ones + /// neutered by ). Unlike + /// : no counter increment, no counter + /// decrement, success is hardcoded true. + /// + public void CheckForCompletedMotions() + { + var head = _pendingAnimations.First; + if (head is null) + return; + + while (head is not null && head.Value.NumAnims == 0) + { + if ((head.Value.Motion & ActionClassBit) != 0) + _state.RemoveActionHead(); + + _sink.MotionDone(head.Value.Motion, true); + + _pendingAnimations.RemoveFirst(); + head = _pendingAnimations.First; + } + } + + /// UseTime 0x0051bfd0 (@290845): per-frame entry point, + /// tailcalls . + public void UseTime() => CheckForCompletedMotions(); + + // ── initialize_state / HandleEnterWorld / HandleExitWorld ────────────── + + /// + /// initialize_state 0x0051c030 (@290875): install the motion + /// table's baseline state () and + /// queue the ("0x41000003" — initial + /// default-state-installed marker) with the resulting tick count, then + /// opportunistically collapse redundant links. + /// + public void InitializeState() + { + uint outTicks = 0; + if (_table is not null) + { + _table.SetDefaultState(_state, _sequence, out outTicks); + } + + AddToQueue(ReadySentinel, outTicks); + } + + /// + /// HandleEnterWorld 0x0051bdd0 (@290634): strip any stale link + /// animations from the live sequence + /// (), then fully drain + /// pending_animations exactly like — + /// each drained entry fires with + /// success:false via repeated calls + /// (decomp: while (head_ != 0) AnimationDone(this, 0)). + /// + public void HandleEnterWorld() + { + _sequence.RemoveAllLinkAnimations(); + DrainQueue(); + } + + /// + /// HandleExitWorld 0x0051bda0 (@290625): fully drain + /// pending_animations, signaling "failure/aborted" + /// (success:false) for every entry via repeated + /// calls. + /// + public void HandleExitWorld() => DrainQueue(); + + private void DrainQueue() + { + while (_pendingAnimations.First is not null) + AnimationDone(false); + } + + // ── PerformMovement ────────────────────────────────────────────────── + + /// + /// PerformMovement 0x0051c0b0 (@290906) — the single chokepoint + /// between a wire-level (interpreted + /// command / stop / stop-completely) and the motion-table state machine. + /// Error codes: 7 = no motion table loaded; 0x43 = + /// DoObjectMotion/StopObjectMotion returned failure; 0 = success. + /// Unhandled s (RawCommand, StopRawCommand, + /// MoveToObject/Position, TurnToObject/Heading) are NOT MotionTableManager's + /// job — decomp's BN artifact returns the CSequence pointer reinterpreted + /// as a code (§11 note: "likely dead/unreachable... never consulted"); the + /// C# port returns instead + /// of leaking a pointer value, since no caller in this codebase depends on + /// that BN quirk. + /// + public uint PerformMovement(MotionTableMovement movement) + { + if (_table is null) + return MotionTableManagerError.NoTable; // 7 + + uint outTicks; + + switch (movement.Type) + { + case MovementType.InterpretedCommand: + if (_table.DoObjectMotion(movement.Motion, _state, _sequence, movement.Speed, out outTicks)) + { + AddToQueue(movement.Motion, outTicks); + return MotionTableManagerError.Success; // 0 + } + return MotionTableManagerError.MotionFailed; // 0x43 + + case MovementType.StopInterpretedCommand: + if (_table.StopObjectMotion(movement.Motion, movement.Speed, _state, _sequence, out outTicks)) + { + AddToQueue(ReadySentinel, outTicks); + return MotionTableManagerError.Success; + } + return MotionTableManagerError.MotionFailed; + + case MovementType.StopCompletely: + _table.StopObjectCompletely(_state, _sequence, out outTicks); + AddToQueue(ReadySentinel, outTicks); // UNCONDITIONAL — queued regardless of return value. + return MotionTableManagerError.Success; + + default: + // RawCommand, StopRawCommand, and the MoveTo*/TurnTo* types are + // not MotionTableManager's job (decomp §11 note). + return MotionTableManagerError.NotHandled; + } + } +} + +/// +/// PerformMovement error/result codes (decomp §15 "PerformMovement +/// error codes"). Named constants standing in for retail's raw hex return +/// values, kept as plain to match +/// 's retail-verbatim return +/// type. +/// +public static class MotionTableManagerError +{ + /// 0 — success. + public const uint Success = 0u; + /// 7 — no motion table loaded. + public const uint NoTable = 7u; + /// 0x43 — DoObjectMotion/StopObjectMotion returned failure. + public const uint MotionFailed = 0x43u; + /// + /// C#-port-only sentinel for the "unhandled MovementType" default case. + /// Retail's BN decompile shows this leaking the CSequence pointer + /// reinterpreted as a return code (decomp §11 note, "likely dead/ + /// unreachable in practice"); no known caller depends on that value, so + /// the port returns this distinguishable constant instead of fabricating + /// a pointer-shaped number. + /// + public const uint NotHandled = 0xFFFFFFFFu; +} + +/// +/// Minimal retail-verbatim MovementStruct subset (acclient.h:38069) +/// needed by : just the +/// dispatch type, the motion id, and the speed scalar +/// (arg2->params->speed). Defined here rather than reusing +/// AcDream.Core.Physics.MotionInterpreter.MovementStruct because that +/// type serves a different (CMotionInterp-level) call site with fields +/// (ObjectId, Position, Autonomous, +/// ModifyInterpretedState/RawState) MotionTableManager never reads — +/// CLAUDE.md/plan instruction: do not modify MotionInterpreter.cs. +/// IS reused (its 5 values +/// match retail's MovementTypes::Type 1:1 for the cases +/// MotionTableManager handles). +/// +public readonly struct MotionTableMovement +{ + public readonly MovementType Type; + public readonly uint Motion; + public readonly float Speed; + + public MotionTableMovement(MovementType type, uint motion, float speed) + { + Type = type; + Motion = motion; + Speed = speed; + } + + public static MotionTableMovement Interpreted(uint motion, float speed) => + new(MovementType.InterpretedCommand, motion, speed); + + public static MotionTableMovement StopInterpreted(uint motion, float speed) => + new(MovementType.StopInterpretedCommand, motion, speed); + + public static MotionTableMovement StopCompletely() => + new(MovementType.StopCompletely, 0u, 1f); +} diff --git a/src/AcDream.Core/Physics/Motion/MotionTablePose.cs b/src/AcDream.Core/Physics/Motion/MotionTablePose.cs new file mode 100644 index 00000000..6acddd33 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MotionTablePose.cs @@ -0,0 +1,65 @@ +using System; +using System.Collections.Generic; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +namespace AcDream.Core.Physics.Motion; + +/// +/// #175: the motion table's DEFAULT-STATE part pose — the pose an idle +/// entity's parts hold (retail: CMotionTable::SetDefaultState +/// 0x005230a0 installs StyleDefaults[DefaultStyle]'s cycle; the parts +/// then sit at that animation's frames — the live CPhysicsPart pose +/// collision tests against). Used as the BSP shadow-shape part-pose override +/// at server-entity registration (doors: the CLOSED pose). +/// +/// +/// Cycle key arithmetic mirrors 's +/// LookupCycle (CMotionTable.cs:683): (style << 16) | +/// (substate & 0xFFFFFF) — the raw dat Cycles dictionary is +/// keyed by the COMBINED word, not the bare style (the first cut of this +/// helper looked up the bare style, always missed, and silently fell back +/// to placement frames — the #175 "not fixed" report). +/// +/// +public static class MotionTablePose +{ + /// + /// Resolve the default-state pose frames. Returns null (callers fall + /// back to placement frames) when the table has no default-style + /// substate, no matching cycle, or no animation. A pose covering FEWER + /// parts than the Setup is returned as-is — + /// falls back to the placement frame + /// PER PART beyond the override's length (e.g. a door anim that poses + /// only the panel parts, not the BSP-less frame header). + /// + /// The raw dat motion table (wire MotionTableId). + /// Animation loader (production: + /// id => dats.Get<Animation>(id)). + public static IReadOnlyList? DefaultStatePartFrames( + MotionTable mt, + Func loadAnimation) + { + if (mt is null) return null; + + // SetDefaultState: StyleDefaults[DefaultStyle] → the default substate. + if (!mt.StyleDefaults.TryGetValue(mt.DefaultStyle, out var defaultSubstateCmd)) + return null; + + // LookupCycle key (CMotionTable.cs:683 — same wrap semantics). + uint style = (uint)mt.DefaultStyle; + uint substate = (uint)defaultSubstateCmd; + int key = (int)((style << 16) | (substate & 0xFFFFFFu)); + + if (!mt.Cycles.TryGetValue(key, out var cycle) || cycle.Anims.Count == 0) + return null; + + var animRef = cycle.Anims[0]; + var anim = loadAnimation(animRef.AnimId); + if (anim is null || anim.PartFrames.Count == 0) return null; + + int idx = Math.Clamp((int)animRef.LowFrame, 0, anim.PartFrames.Count - 1); + var frames = anim.PartFrames[idx].Frames; + return frames.Count > 0 ? frames : null; + } +} diff --git a/src/AcDream.Core/Physics/Motion/MoveToManager.cs b/src/AcDream.Core/Physics/Motion/MoveToManager.cs new file mode 100644 index 00000000..ac943c80 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MoveToManager.cs @@ -0,0 +1,1634 @@ +using System; +using System.Collections.Generic; +using System.Numerics; + +namespace AcDream.Core.Physics.Motion; + +// ───────────────────────────────────────────────────────────────────────────── +// MoveToManager — R4-V2 verbatim port of retail's MoveToManager +// (acclient.h:31473, struct #3462; docs/research/2026-07-03-r4-moveto/ +// r4-moveto-decomp.md, all 33 members, addresses 0x00529010-0x0052a987). +// +// Retail chain this class stands in for (r4-port-plan.md §4): +// MovementManager::PerformMovement (types 6-9) → MoveToManager::PerformMovement +// → MoveToManager entry points (MoveToObject/MoveToPosition/TurnToObject/ +// TurnToHeading) → node plan (pending_actions) → BeginNextNode → +// BeginMoveForward/BeginTurnToHeading → _DoMotion/_StopMotion → +// CMotionInterp.adjust_motion → DoInterpretedMotion/StopInterpretedMotion. +// +// MovementManager itself is R5 scope (r4-port-plan.md §5 "do-not-invent") — +// this class is bound DIRECTLY to the owning entity's MotionInterpreter by the +// (future) V4/V5 orchestrator; the type-6..9 dispatch stays at the existing +// GameWindow/controller call sites until R5 grows the relay. +// +// TargetManager / StickyManager / ConstraintManager / PositionManager::StickTo +// bodies were NOT extracted (call shapes only, decomp §9f/§9g) — R5 scope. +// This class exposes them as ctor-injected seams (Action/Func delegates), +// matching the MotionInterpreter Action? seam convention +// (UnstickFromObject/InterruptCurrentMovement/RemoveLinkAnimations/ +// InitializeMotionTables/CheckForCompletedMotions). +// ───────────────────────────────────────────────────────────────────────────── + +/// +/// R4-V2 — verbatim port of retail's MoveToManager (acclient.h:31473, +/// struct #3462). Drives an entity's chase/flee/turn-to/turn-to-heading +/// state machine: builds a small node plan (, +/// pending_actions), steps it every tick via , +/// and issues the resulting motion commands through the SAME +/// / +/// +/// seam every other interpreted motion uses (_DoMotion/_StopMotion, +/// §7a/§7b — MoveToManager NEVER calls DoMotion, set_hold_run, or +/// any raw-state API directly). +/// +/// +/// Construction contract (r4-port-plan.md §4): ctor-injected with the +/// entity's (the _DoMotion target) plus +/// a set of seam delegates standing in for retail's CPhysicsObj +/// position/heading/body-shape accessors and the not-yet-ported +/// TargetManager/StickyManager (R5). All seam delegates are REQUIRED +/// (non-nullable) except the three explicitly retail-optional ones +/// (, , ) +/// which mirror the no-op-until-bound convention already used by +/// / +/// . +/// +/// +/// +/// The "no physics_obj" guard. Retail gates almost every member on +/// this->physics_obj != 0 (a raw pointer that can be null before +/// SetPhysicsObject is called, or after the owning CPhysicsObj +/// is destroyed). This port models the SAME guard via +/// (settable, defaults true) rather than requiring callers to pass a nullable +/// body reference through every seam — the seam delegates themselves are +/// assumed valid whenever is true (matching +/// retail's single non-null pointer covering the whole entry-point family). +/// +/// +public sealed class MoveToManager +{ + private readonly MotionInterpreter _interp; + + // ── seam delegates (ctor-injected; r4-port-plan.md §4) ───────────────── + + /// Retail CPhysicsObj::StopCompletely — routes through + /// MovementStruct{type=5} to the SAME interp + /// ( pre-R5; direct call is + /// the same body). + private readonly Action _stopCompletely; + + /// Retail physics_obj->m_position read (world position + /// + cell id) — the CURRENT position, sampled fresh every call site that + /// reads myPos/curPos. + private readonly Func _getPosition; + + /// Retail CPhysicsObj::get_heading — current compass + /// heading, degrees (P5 convention). + private readonly Func _getHeading; + + /// Retail CPhysicsObj::set_heading(heading, send) — the + /// ONE heading snap in the whole family + /// ('s arrival snap, decomp §6c + /// @0052a146). send flags the outbound network echo (remotes: + /// no-op send per the wiring contract). + private readonly Action _setHeading; + + /// Retail CPhysicsObj::GetRadius — the MOVER's own + /// radius (feeds 's cylinder-distance + /// own-side argument). + private readonly Func _getOwnRadius; + + /// Retail CPhysicsObj::GetHeight — the MOVER's own + /// height. + private readonly Func _getOwnHeight; + + /// Retail physics_obj->transient_state & 1 — + /// CONTACT bit ('s tick gate, decomp §6a). + private readonly Func _contact; + + /// Retail CPhysicsObj::IsInterpolating → + /// PositionManager::IsInterpolating — consumed by the + /// fail-progress stall tests (decomp §6b/§6c). + private readonly Func _isInterpolating; + + /// Retail CPhysicsObj::get_velocity — feeds the Phase-3 + /// TargetManager quantum retune (decomp §6b Phase 3). + private readonly Func _getVelocity; + + /// Retail physics_obj->id — the mover's own object id + /// (self-target detection in MoveToObject/TurnToObject, §3b/§3d). + private readonly Func _getSelfId; + + /// Retail CPhysicsObj::set_target(context_id, object_id, + /// radius, quantum) → TargetManager::SetTarget (call shape + /// only, decomp §9f — R5 owns the body). MoveToManager always passes + /// (0, top_level_object_id, 0.5f, 0.0). + private readonly Action _setTarget; + + /// Retail CPhysicsObj::clear_target → + /// TargetManager::ClearTarget (call shape only). + private readonly Action _clearTarget; + + /// Retail CPhysicsObj::get_target_quantum (call shape + /// only; ACE: returns TargetInfo.Quantum, default 0). + private readonly Func _getTargetQuantum; + + /// Retail CPhysicsObj::set_target_quantum → + /// TargetManager::SetTargetQuantum (call shape only). + private readonly Action _setTargetQuantum; + + /// Retail CPhysicsObj::unstick_from_object → + /// PositionManager::UnStick (call shape only, R5 body). Called at + /// the head of every (§3a). Optional — + /// null is a silent no-op, matching + /// 's convention. + public Action? Unstick { get; set; } + + /// Retail PositionManager::StickTo(object_id, radius, + /// height) (call shape only, R5 StickyManager body) — the sticky + /// arrival handoff in (§4b). Optional — + /// null is a silent no-op. + public Action? StickTo { get; set; } + + /// + /// CLIENT ADDITION — NOT retail (decomp §7e / do-not-invent list): + /// CleanUpAndCallWeenie contains no weenie call in this build + /// (the name is vestigial; body ≡ CleanUp + StopCompletely), and retail + /// notifies NOTHING on arrival (§4b's empty-queue completion is inline + /// CleanUp + StopCompletely). This seam stands in for ACE's server-side + /// OnMoveComplete notification so the App layer can re-anchor + /// AD-27 (Use/PickUp re-send on arrival). Fires with + /// on NATURAL COMPLETION — the + /// empty-queue exits (both sticky and + /// non-sticky) and 's instant-success + /// path — and NEVER from /plain + /// (a cancel is not an arrival; AD-27's re-send + /// must not fire on user interrupt). Optional — null is a silent no-op. + /// + public Action? MoveToComplete { get; set; } + + /// Retail Timer::cur_time — injectable clock (tests drive + /// this explicitly; production binds to the real wall/game clock). + /// Defaults to a monotonically-increasing stub if not overridden via the + /// ctor (every call site needs SOME value; production always supplies + /// one). + private readonly Func _curTime; + + /// + /// Retail's physics_obj != 0 guard, modeled as a settable flag + /// (see the class-level "no physics_obj" doc). Defaults true — most + /// production entities always have a body by construction time. + /// + public bool HasPhysicsObj { get; set; } = true; + + public MoveToManager( + MotionInterpreter interp, + Action stopCompletely, + Func getPosition, + Func getHeading, + Action setHeading, + Func getOwnRadius, + Func getOwnHeight, + Func contact, + Func isInterpolating, + Func getVelocity, + Func getSelfId, + Action setTarget, + Action clearTarget, + Func getTargetQuantum, + Action setTargetQuantum, + Func? curTime = null) + { + _interp = interp ?? throw new ArgumentNullException(nameof(interp)); + _stopCompletely = stopCompletely ?? throw new ArgumentNullException(nameof(stopCompletely)); + _getPosition = getPosition ?? throw new ArgumentNullException(nameof(getPosition)); + _getHeading = getHeading ?? throw new ArgumentNullException(nameof(getHeading)); + _setHeading = setHeading ?? throw new ArgumentNullException(nameof(setHeading)); + _getOwnRadius = getOwnRadius ?? throw new ArgumentNullException(nameof(getOwnRadius)); + _getOwnHeight = getOwnHeight ?? throw new ArgumentNullException(nameof(getOwnHeight)); + _contact = contact ?? throw new ArgumentNullException(nameof(contact)); + _isInterpolating = isInterpolating ?? throw new ArgumentNullException(nameof(isInterpolating)); + _getVelocity = getVelocity ?? throw new ArgumentNullException(nameof(getVelocity)); + _getSelfId = getSelfId ?? throw new ArgumentNullException(nameof(getSelfId)); + _setTarget = setTarget ?? throw new ArgumentNullException(nameof(setTarget)); + _clearTarget = clearTarget ?? throw new ArgumentNullException(nameof(clearTarget)); + _getTargetQuantum = getTargetQuantum ?? throw new ArgumentNullException(nameof(getTargetQuantum)); + _setTargetQuantum = setTargetQuantum ?? throw new ArgumentNullException(nameof(setTargetQuantum)); + + double t = 0.0; + _curTime = curTime ?? (() => t += 1.0 / 30.0); + + InitializeLocalVariables(); + } + + // ── state block (retail acclient.h:31473 field-for-field) ────────────── + + /// +0x00 movement_type. + public MovementType MovementTypeState { get; private set; } = MovementType.Invalid; + + /// + /// Retail's default-constructed Position (identity + /// CellFrame, cell id 0) — NOT C#'s default(Position), + /// whose default(Quaternion) is the ZERO quaternion (0,0,0,0), + /// not the identity rotation (0,0,0,1). GetHeading on a zero + /// quaternion is degenerate (does not read as "heading 0" — the + /// underlying Vector3.Transform collapses to zero). Retail's + /// ctor (§1a) and (§1c) both + /// reset these fields to a genuine identity frame. + /// + private static readonly Position IdentityPosition = new(0u, Vector3.Zero, Quaternion.Identity); + + /// +0x04 sought_position. + public Position SoughtPosition { get; private set; } = IdentityPosition; + + /// +0x4C current_target_position. + public Position CurrentTargetPosition { get; private set; } = IdentityPosition; + + /// +0x94 starting_position. + public Position StartingPosition { get; private set; } = IdentityPosition; + + /// +0xDC movement_params (the 10-field copy every entry + /// point performs). + public MovementParameters Params { get; private set; } = new(); + + /// +0x108 previous_heading. + public float PreviousHeading { get; private set; } + + /// +0x10C previous_distance. + public float PreviousDistance { get; private set; } + + /// +0x110 previous_distance_time. + public double PreviousDistanceTime { get; private set; } + + /// +0x118 original_distance. + public float OriginalDistance { get; private set; } + + /// +0x120 original_distance_time. + public double OriginalDistanceTime { get; private set; } + + /// +0x128 fail_progress_count — WRITE-ONLY (decomp §8; + /// do-not-invent: no give-up threshold exists in retail). Exposed for + /// conformance-test inspection only. + public uint FailProgressCount { get; private set; } + + /// +0x12C sought_object_id. + public uint SoughtObjectId { get; private set; } + + /// +0x130 top_level_object_id. + public uint TopLevelObjectId { get; private set; } + + /// +0x134 sought_object_radius. + public float SoughtObjectRadius { get; private set; } + + /// +0x138 sought_object_height. + public float SoughtObjectHeight { get; private set; } + + /// +0x13C current_command. + public uint CurrentCommand { get; private set; } + + /// +0x140 aux_command. + public uint AuxCommand { get; private set; } + + /// +0x144 moving_away. + public bool MovingAway { get; private set; } + + /// +0x148 initialized. + public bool Initialized { get; private set; } + + /// +0x14C/+0x150 pending_actions (DLList) — ported as a + /// managed of , tail-append + /// / head-pop (matching InsertAfter/RemovePendingActionsHead + /// shape). Exposed read-only for conformance tests. + private readonly LinkedList _pendingActions = new(); + + /// Read-only inspection surface (tests): the node queue in + /// head-to-tail order. + public IEnumerable PendingActions => _pendingActions; + + // ── 1. Creation / lifecycle ───────────────────────────────────────────── + + /// + /// Retail MoveToManager::InitializeLocalVariables + /// (00529250, raw 306490-306534). VERBATIM per decomp §1c: zeroes + /// (Invalid) and the params BITFIELD + + /// CONTEXT ID ONLY (movement_params.__inner0 = 0; + /// movement_params.context_id = 0; — NOT ACE's A2/A3 + /// full-struct-reset transposition; the scalar param fields keep their + /// STALE values because every entry point copies all ten fields anyway), + /// resets both progress-clock pairs to FLT_MAX/now ( + /// /), + /// =0, =0, + /// /=0, + /// /=false, resets + /// / to + /// cell 0 + identity frame ( is NOT + /// touched here), and zeroes / + /// // + /// . Does NOT drain + /// — callers (/ + /// ) drain first. + /// + public void InitializeLocalVariables() + { + MovementTypeState = MovementType.Invalid; + + // movement_params.__inner0 = 0 (bitfield CLEARED, not re-defaulted); + // movement_params.context_id = 0. Scalars stay whatever they were — + // model this by clearing only the bitfield-backed bools + ContextId + // on the EXISTING Params instance (do not replace it — a replace + // would also reset the scalars, diverging from retail's field-level + // clear). + Params.CanWalk = false; + Params.CanRun = false; + Params.CanSidestep = false; + Params.CanWalkBackwards = false; + Params.CanCharge = false; + Params.FailWalk = false; + Params.UseFinalHeading = false; + Params.Sticky = false; + Params.MoveAway = false; + Params.MoveTowards = false; + Params.UseSpheres = false; + Params.SetHoldKey = false; + Params.Autonomous = false; + Params.ModifyRawState = false; + Params.ModifyInterpretedState = false; + Params.CancelMoveTo = false; + Params.StopCompletelyFlag = false; + Params.DisableJumpDuringLink = false; + Params.ContextId = 0; + + PreviousDistance = float.MaxValue; + PreviousDistanceTime = _curTime(); + OriginalDistance = float.MaxValue; + OriginalDistanceTime = _curTime(); + + PreviousHeading = 0f; + FailProgressCount = 0; + CurrentCommand = 0; + AuxCommand = 0; + MovingAway = false; + Initialized = false; + + SoughtPosition = IdentityPosition; + CurrentTargetPosition = IdentityPosition; + + SoughtObjectId = 0; + TopLevelObjectId = 0; + SoughtObjectRadius = 0f; + SoughtObjectHeight = 0f; + } + + /// + /// Retail MoveToManager::Destroy (005294b0, raw + /// 306618-306663): drains then tailcalls + /// . + /// + public void Destroy() + { + _pendingActions.Clear(); + InitializeLocalVariables(); + } + + /// + /// Retail MoveToManager::is_moving_to (00529220, raw + /// 306464-306470): movement_type != Invalid. + /// + public bool IsMovingTo() => MovementTypeState != MovementType.Invalid; + + // ── 3. Entry points (movement_type setters) ───────────────────────────── + + /// + /// Retail MoveToManager::PerformMovement (0052a900, raw + /// 307871-307904). VERBATIM per decomp §3a: cancels any in-flight moveto + /// ( with + /// 0x36) and unsticks FIRST, unconditionally, before the 4-way type + /// dispatch (MoveToObject/MoveToPosition/TurnToObject/TurnToHeading). + /// Always returns — moveto errors surface + /// via , never via this return value (decomp + /// §2b note, carried through §3a). + /// + public WeenieError PerformMovement(MovementStruct mvs) + { + CancelMoveTo(WeenieError.ActionCancelled); + Unstick?.Invoke(); + + switch (mvs.Type) + { + case MovementType.MoveToObject: + MoveToObject(mvs.ObjectId, mvs.TopLevelId, mvs.Radius, mvs.Height, mvs.Params ?? new MovementParameters()); + break; + case MovementType.MoveToPosition: + MoveToPosition(mvs.Pos, mvs.Params ?? new MovementParameters()); + break; + case MovementType.TurnToObject: + TurnToObject(mvs.ObjectId, mvs.TopLevelId, mvs.Params ?? new MovementParameters()); + break; + case MovementType.TurnToHeading: + TurnToHeading(mvs.Params ?? new MovementParameters()); + break; + } + + return WeenieError.None; + } + + /// + /// Retail MoveToManager::MoveToObject (00529680, raw + /// 306756-306817). VERBATIM per decomp §3b: StopCompletely, snapshot + /// , store sought object id/radius/height, + /// set =MoveToObject, + /// , copy all ten + /// fields into , =false. + /// Self-target ( == the mover's own id) → + /// + StopCompletely (degenerate instant no-op). + /// Otherwise → (0, topLevelId, 0.5f, 0.0) — the + /// P4 TargetTracker seam. NO nodes are queued yet — object moves are + /// deferred until the first callback + /// (§6). NOTE: is PRESERVED here + /// (unlike position/turn-heading moves, which force it off — §3c/§3e). + /// + public void MoveToObject(uint objectId, uint topLevelId, float radius, float height, MovementParameters p) + { + if (!HasPhysicsObj) return; + + _stopCompletely(); + StartingPosition = _getPosition(); + SoughtObjectId = objectId; + SoughtObjectRadius = radius; + SoughtObjectHeight = height; + MovementTypeState = MovementType.MoveToObject; + TopLevelObjectId = topLevelId; + CopyParams(p); + Initialized = false; + + if (topLevelId == _getSelfId()) + { + CleanUp(); + _stopCompletely(); + } + else + { + _setTarget(0, TopLevelObjectId, 0.5f, 0.0); + } + } + + /// + /// Retail MoveToManager::MoveToPosition (0052a240, raw + /// 307521-307593). VERBATIM per decomp §3c: StopCompletely, snapshot + /// =, + /// =0, compute + /// , compute the heading-to-target minus + /// current heading (epsilon-snapped/wrapped, same [0,360) normalization + /// used throughout), to see + /// if ANY motion is needed — if so, queue + /// [TurnToHeading(face target)] → [MoveToPosition]. If + /// (0x40) is set, ALSO + /// queue a final TurnToHeading(desired_heading) (absolute, unlike + /// 's relative form). Then snapshot + /// /, set + /// =MoveToPosition, copy all ten + /// fields into , CLEAR the + /// sticky bit (0x80 — position moves and heading turns can never stick; + /// only object moves preserve it), then . + /// + /// + /// Reads the ARGUMENT's + /// (), NOT a stale member — the do-not-invent list's + /// "A1 stale-member UseFinalHeading read" ACE-ism is explicitly NOT + /// copied here. + /// + /// + public void MoveToPosition(Position target, MovementParameters p) + { + if (!HasPhysicsObj) return; + + _stopCompletely(); + CurrentTargetPosition = target; + SoughtObjectRadius = 0f; + + float dist = GetCurrentDistance(); + + Vector3 myPos = _getPosition().Frame.Origin; + Vector3 targetPos = target.Frame.Origin; + float toTargetHeading = MoveToMath.PositionHeading(myPos, targetPos); + float headingDiff = toTargetHeading - _getHeading(); + if (MathF.Abs(headingDiff) < MoveToMath.Epsilon) headingDiff = 0f; + if (headingDiff < -MoveToMath.Epsilon) headingDiff += 360f; + + p.GetCommand(dist, headingDiff, out uint cmd, out _, out _); + if (cmd != 0) + { + AddTurnToHeadingNode(toTargetHeading); + AddMoveToPositionNode(); + } + + if (p.UseFinalHeading) + { + AddTurnToHeadingNode(p.DesiredHeading); + } + + SoughtPosition = target; + StartingPosition = _getPosition(); + MovementTypeState = MovementType.MoveToPosition; + CopyParams(p); + Params.Sticky = false; // __inner0 &= 0xffffff7f + + BeginNextNode(); + } + + /// + /// Retail MoveToManager::TurnToObject (005297d0, raw + /// 306820-306882). VERBATIM per decomp §3d, INCLUDING the desired-heading + /// clobber quirk: .StopCompletelyFlag's underlying bit + /// (0x10000) — here, — + /// gates the StopCompletely call CONDITIONALLY (unlike MoveToObject/ + /// MoveToPosition's UNCONDITIONAL stop). Seeds + /// current_target_position.frame's heading from + /// .DesiredHeading — but this write is DISCARDED: + /// later overwrites + /// wholesale and reads + /// 's heading instead (which is 0 after + /// for a fresh manager). This is a + /// RETAIL QUIRK (ACE MoveToManager.cs:246 matches verbatim) — do NOT + /// "fix" it; the effective final heading is simply "face the object". + /// Self-target → + StopCompletely. Otherwise → + /// =false + (0, + /// topLevelId, 0.5f, 0.0). Deferred like MoveToObject — no nodes queued + /// here; queues on the first target + /// callback. + /// + public void TurnToObject(uint objectId, uint topLevelId, MovementParameters p) + { + if (!HasPhysicsObj) return; + + if (p.StopCompletelyFlag) + { + _stopCompletely(); + } + + MovementTypeState = MovementType.TurnToObject; + SoughtObjectId = objectId; + + // Frame::set_heading(¤t_target_position.frame, desired_heading) + // — clobbered before any read; see the quirk note above. + CurrentTargetPosition = CurrentTargetPosition with + { + Frame = new CellFrame( + CurrentTargetPosition.Frame.Origin, + MoveToMath.SetHeading(CurrentTargetPosition.Frame.Orientation, p.DesiredHeading)), + }; + + TopLevelObjectId = topLevelId; + CopyParams(p); + + if (topLevelId == _getSelfId()) + { + CleanUp(); + _stopCompletely(); + } + else + { + Initialized = false; + _setTarget(0, topLevelId, 0.5f, 0.0); + } + } + + /// + /// Retail MoveToManager::TurnToHeading (0052a630, raw + /// 307706-307772). VERBATIM per decomp §3e: conditional StopCompletely + /// (0x10000 stop_completely bit, same shape as + /// ), copy all ten fields, + /// CLEAR sticky (0x80), seed 's frame heading + /// from .DesiredHeading, set + /// =TurnToHeading, queue ONE + /// (type TurnToHeading, heading=DesiredHeading) + /// directly (inlined AddTurnToHeadingNode shape — same effect), + /// then IMMEDIATE — unlike ACE's A4 gap + /// (one-tick-late), retail calls BeginNextNode synchronously + /// inside this entry point. is NOT set here + /// (stays whatever it was) — the gate (§6a) passes + /// anyway because is 0 for non-object + /// moves (TurnToHeading never sets it). + /// + public void TurnToHeading(MovementParameters p) + { + if (!HasPhysicsObj) return; + + if (p.StopCompletelyFlag) + { + _stopCompletely(); + } + + CopyParams(p); + Params.Sticky = false; // __inner0 &= 0xffffff7f + + SoughtPosition = SoughtPosition with + { + Frame = new CellFrame( + SoughtPosition.Frame.Origin, + MoveToMath.SetHeading(SoughtPosition.Frame.Orientation, p.DesiredHeading)), + }; + + MovementTypeState = MovementType.TurnToHeading; + + _pendingActions.AddLast(new MoveToNode(MovementType.TurnToHeading, p.DesiredHeading)); + + BeginNextNode(); + } + + // ── 4. Node stepping ───────────────────────────────────────────────────── + + /// + /// Retail MoveToManager::AddTurnToHeadingNode (00529530, + /// raw 306667-306685): tail-append a TurnToHeading node. + /// + public void AddTurnToHeadingNode(float heading) + => _pendingActions.AddLast(new MoveToNode(MovementType.TurnToHeading, heading)); + + /// + /// Retail MoveToManager::AddMoveToPositionNode (00529580, + /// raw 306689-306706): tail-append a MoveToPosition node (heading + /// unused). + /// + public void AddMoveToPositionNode() + => _pendingActions.AddLast(new MoveToNode(MovementType.MoveToPosition, 0f)); + + /// + /// Retail MoveToManager::RemovePendingActionsHead + /// (00529380, raw 306538-306550): unlink + delete the head node. + /// + public void RemovePendingActionsHead() + { + if (_pendingActions.First is not null) + _pendingActions.RemoveFirst(); + } + + /// + /// Retail MoveToManager::BeginNextNode (00529cb0, raw + /// 307123-307171). VERBATIM per decomp §4b — THE STICKY HANDOFF: if a + /// node exists, tailcall (type + /// MoveToPosition) or (type + /// TurnToHeading); an unknown node type stalls (defensive, matches the + /// raw's if/if shape — no else fallthrough). Empty queue = + /// moveto complete: if (byte0 + /// sign bit 0x80) is set, READ / + /// / + /// BEFORE (which zeroes them), THEN CleanUp, THEN + /// StopCompletely, THEN hand off to (R5 + /// StickyManager seam) with the pre-CleanUp values. Non-sticky empty + /// queue: CleanUp + StopCompletely only. + /// + public void BeginNextNode() + { + if (_pendingActions.First is not null) + { + MovementType type = _pendingActions.First.Value.Type; + if (type == MovementType.MoveToPosition) + { + BeginMoveForward(); + return; + } + if (type == MovementType.TurnToHeading) + { + BeginTurnToHeading(); + return; + } + return; // unknown node type: stall (defensive) + } + + if (Params.Sticky) + { + float height = SoughtObjectHeight; + float radius = SoughtObjectRadius; + uint tlid = TopLevelObjectId; + + CleanUp(); + if (HasPhysicsObj) _stopCompletely(); + + StickTo?.Invoke(tlid, radius, height); + // CLIENT ADDITION (see MoveToComplete doc): natural completion. + // Reentrancy-safe: CleanUp reset movement_type to Invalid BEFORE + // the stop, so the stop's interrupt→CancelMoveTo chain no-oped. + MoveToComplete?.Invoke(WeenieError.None); + return; + } + + CleanUp(); + if (HasPhysicsObj) _stopCompletely(); + // CLIENT ADDITION (see MoveToComplete doc): natural completion. + MoveToComplete?.Invoke(WeenieError.None); + } + + /// + /// Retail MoveToManager::BeginMoveForward (00529a00, raw + /// 306957-307042). VERBATIM per decomp §4c: no physics_obj → + /// (). + /// Compute distance + heading-diff-to-target (same epsilon + /// snap/normalize as ), then + /// . If no motion is needed + /// (already in range) — pop the head node and + /// . Otherwise build a fresh LOCAL params + /// (defaults; CLEARED so + /// _DoMotion doesn't cancel THIS moveto; speed copied from + /// ), issue via — on error, + /// with that error and return. On success, + /// record /, write + /// the CHOSEN hold key BACK to the stored + /// (HoldKeyToApply), and seed BOTH progress-clock pairs + /// (/ = dist, + /// both times = now). + /// + public void BeginMoveForward() + { + if (!HasPhysicsObj) + { + CancelMoveTo(WeenieError.NoPhysicsObject); + return; + } + + float dist = GetCurrentDistance(); + + Vector3 myPos = _getPosition().Frame.Origin; + Vector3 targetPos = CurrentTargetPosition.Frame.Origin; + float heading = MoveToMath.PositionHeading(myPos, targetPos) - _getHeading(); + if (MathF.Abs(heading) < MoveToMath.Epsilon) heading = 0f; + if (heading < -MoveToMath.Epsilon) heading += 360f; + + Params.GetCommand(dist, heading, out uint cmd, out HoldKey holdKey, out bool movingAway); + + if (cmd == 0) + { + RemovePendingActionsHead(); + BeginNextNode(); + return; + } + + var localParams = new MovementParameters + { + HoldKeyToApply = holdKey, + CancelMoveTo = false, // bitfield &= 0xffff7fff + Speed = Params.Speed, + }; + + WeenieError err = _DoMotion(cmd, localParams); + if (err != WeenieError.None) + { + CancelMoveTo(err); + return; + } + + CurrentCommand = cmd; + MovingAway = movingAway; + Params.HoldKeyToApply = holdKey; + PreviousDistance = dist; + PreviousDistanceTime = _curTime(); + OriginalDistance = dist; + OriginalDistanceTime = _curTime(); + } + + /// + /// Retail MoveToManager::BeginTurnToHeading (00529b90, raw + /// 307046-307120). VERBATIM per decomp §4d: empty queue OR no + /// physics_obj → (NoPhysicsObject, per A10 — + /// NOT ACE's throw). If animations are still pending + /// (), WAIT (return — do + /// not start the turn yet). Otherwise read the head node's heading, call + /// with the CONSTANT + /// (mirror explicitly disabled — + /// direction pick uses the raw ≤180 test, not the mirrored value): + /// diff > 180 → check "already there" (diff + eps >= + /// 360) and pop+advance if so, else TurnLeft; diff <= 180 + /// → check "already there" (diff <= eps) and pop+advance if + /// so, else TurnRight. Issue the turn via with a + /// fresh local params (CancelMoveTo cleared, speed + hold_key copied + /// from ) — on error, . On + /// success, record and store the REMAINING + /// DIFF (not a heading!) into — THE QUIRK: + /// 's progress test then compares a + /// live HEADING against this DIFF-shaped seed on its first tick. Keep + /// verbatim (ACE matches: PreviousHeading = diff). + /// + public void BeginTurnToHeading() + { + if (_pendingActions.First is null || !HasPhysicsObj) + { + CancelMoveTo(WeenieError.NoPhysicsObject); + return; + } + + if (_interp.MotionsPending()) + { + return; + } + + float targetHeading = _pendingActions.First.Value.Heading; + float diff = MoveToMath.HeadingDiff(targetHeading, _getHeading(), MotionCommand.TurnRight); + + uint turn; + if (diff > 180f) + { + if (diff + MoveToMath.Epsilon >= 360f) + { + RemovePendingActionsHead(); + BeginNextNode(); + return; + } + turn = MotionCommand.TurnLeft; + } + else + { + if (diff <= MoveToMath.Epsilon) + { + RemovePendingActionsHead(); + BeginNextNode(); + return; + } + turn = MotionCommand.TurnRight; + } + + var localParams = new MovementParameters + { + CancelMoveTo = false, + Speed = Params.Speed, + HoldKeyToApply = Params.HoldKeyToApply, + }; + + WeenieError err = _DoMotion(turn, localParams); + if (err != WeenieError.None) + { + CancelMoveTo(err); + return; + } + + CurrentCommand = turn; + PreviousHeading = diff; // NOTE: the remaining DIFF, not a heading — retail quirk, keep verbatim. + } + + // ── 5. Distance / progress / command-selection helpers ───────────────── + + /// + /// Retail MoveToManager::GetCurrentDistance (005291b0, raw + /// 306435-306460). VERBATIM per decomp §5a: no physics_obj → 0 (retail's + /// x87-garbled void return; modeled as 0 since every caller only uses + /// this when is already known true). When + /// (0x400) is NOT set → plain + /// center (Euclidean) distance to . + /// When SET → using the + /// mover's own radius/height (/ + /// ) vs the stored + /// / — + /// object moves (which set sought radius/height and get use_spheres on + /// the wire) use edge-to-edge distance; position moves use center + /// distance. + /// + public float GetCurrentDistance() + { + if (!HasPhysicsObj) return 0f; + + Vector3 myPos = _getPosition().Frame.Origin; + Vector3 targetPos = CurrentTargetPosition.Frame.Origin; + + if (!Params.UseSpheres) + { + return Vector3.Distance(myPos, targetPos); + } + + return MoveToMath.CylinderDistance( + _getOwnRadius(), _getOwnHeight(), myPos, + SoughtObjectRadius, SoughtObjectHeight, targetPos); + } + + /// + /// Retail MoveToManager::CheckProgressMade (005290f0, raw + /// 306385-306431). VERBATIM per decomp §5b: evaluated only after a + /// 1-SECOND window since (before that, + /// returns true — "OK, too soon to judge"). Progress = distance closed + /// (or opened, when ) since the last checkpoint; + /// requires BOTH the incremental rate (since + /// ) AND the overall rate (since + /// ) to be ≥ 0.25 units/second. The + /// incremental checkpoint (/ + /// ) only advances when the + /// incremental rate passes. + /// + public bool CheckProgressMade(float currentDistance) + { + double elapsed = _curTime() - PreviousDistanceTime; + if (elapsed <= 1.0) return true; + + float progress = MovingAway + ? currentDistance - PreviousDistance + : PreviousDistance - currentDistance; + + if (progress / (float)elapsed >= 0.25f) + { + PreviousDistance = currentDistance; + PreviousDistanceTime = _curTime(); + + float total = MovingAway + ? currentDistance - OriginalDistance + : OriginalDistance - currentDistance; + float totalRate = total / (float)(_curTime() - OriginalDistanceTime); + + if (totalRate >= 0.25f) return true; + } + + return false; + } + + // ── 6. Per-tick drivers + target updates ──────────────────────────────── + + /// + /// Retail MoveToManager::UseTime (0052a780, raw + /// 307776-307798) — THE TICK GATE. VERBATIM per decomp §6a: three gates, + /// ALL must pass: (1) grounded — () (CONTACT + /// transient-state bit; no moveto progress mid-air, + /// resumes on landing); (2) a pending node exists; (3) object-moves + /// ( != 0 AND + /// != Invalid) must be + /// — i.e. the first target update has arrived. + /// Dispatches to (node type 7) or + /// (node type 9). + /// + public void UseTime() + { + if (!HasPhysicsObj || !_contact()) return; + + if (_pendingActions.First is null) return; + + bool objectMoveGate = TopLevelObjectId == 0 || MovementTypeState == MovementType.Invalid || Initialized; + if (!objectMoveGate) return; + + MovementType type = _pendingActions.First.Value.Type; + if (type == MovementType.MoveToPosition) + { + HandleMoveToPosition(); + } + else if (type == MovementType.TurnToHeading) + { + HandleTurnToHeading(); + } + } + + /// + /// Retail MoveToManager::HandleMoveToPosition (00529d80, + /// raw 307187-307438) — the big per-tick driver. VERBATIM per decomp + /// §6b, three phases: + /// + /// Phase 1 — aux turn steering (only when NOT + /// animating, i.e. is + /// false): compute the desired heading + /// ( offset + + /// heading-to-target, wrapped [0,360)) minus current heading + /// (epsilon-snapped/normalized). If inside the [0,20]∪[340,360) deadband, + /// stop any active aux turn. Otherwise pick TurnLeft (diff ≥ 180) or + /// TurnRight, and issue it via ONLY if it differs + /// from the currently-running (no redundant + /// re-issue). While animating, stop any active aux turn instead (can't + /// steer mid-animation). + /// Phase 2 — arrival / progress: compute + /// distance, run . On NO progress + /// (returns false): increment (write-only, + /// §8) ONLY if neither interpolating nor animating (a stall is only + /// "real" when nothing else explains the lack of motion). On progress + /// (true): reset the fail counter, then test arrival — + /// moving_away ? dist >= MinDistance : dist <= DistanceToObject. + /// NOT arrived: check against + /// the distance traveled from — + /// (0x3D) if exceeded. ARRIVED: + /// pop the head node, stop the current+aux motions, clear both command + /// fields, . + /// Phase 3 — TargetManager quantum retune + /// (object moves only, gated the SAME way as the UseTime object-move + /// gate): while chasing an object faster than 0.1 units/s, retune the + /// tracker's update quantum to the estimated time-to-arrival + /// (distance/speed) whenever it drifts ≥1 second from the current + /// quantum. + /// + /// ACE-divergence trap (do-not-invent): retail has NO + /// set_heading call anywhere in this method (ACE's "custom: sync + /// for server ticrate" addition is NOT ported). + /// + public void HandleMoveToPosition() + { + if (!HasPhysicsObj) + { + CancelMoveTo(WeenieError.NoPhysicsObject); + return; + } + + Vector3 curPos = _getPosition().Frame.Origin; + + var localParams = new MovementParameters + { + Speed = Params.Speed, + CancelMoveTo = false, + HoldKeyToApply = Params.HoldKeyToApply, + }; + + // ---- PHASE 1: aux turn steering ---- + if (_interp.MotionsPending()) + { + if (AuxCommand != 0) + { + _StopMotion(AuxCommand, localParams); + AuxCommand = 0; + } + } + else + { + Vector3 targetPos = CurrentTargetPosition.Frame.Origin; + float toTargetHeading = MoveToMath.PositionHeading(curPos, targetPos); + float heading = Params.GetDesiredHeading(CurrentCommand, MovingAway) + toTargetHeading; + if (heading >= 360f) heading -= 360f; + + float diff = heading - _getHeading(); + if (MathF.Abs(diff) < MoveToMath.Epsilon) diff = 0f; + if (diff < -MoveToMath.Epsilon) diff += 360f; + + if (diff <= 20f || diff >= 340f) + { + if (AuxCommand != 0) + { + _StopMotion(AuxCommand, localParams); + AuxCommand = 0; + } + } + else + { + uint turn = diff >= 180f ? MotionCommand.TurnLeft : MotionCommand.TurnRight; + if (turn != AuxCommand) + { + _DoMotion(turn, localParams); + AuxCommand = turn; + } + } + } + + // ---- PHASE 2: arrival / progress ---- + float dist = GetCurrentDistance(); + if (!CheckProgressMade(dist)) + { + if (!_isInterpolating() && !_interp.MotionsPending()) + { + FailProgressCount += 1; + } + } + else + { + FailProgressCount = 0; + + bool arrived = MovingAway + ? dist >= Params.MinDistance + : dist <= Params.DistanceToObject; + + if (!arrived) + { + float startDist = Vector3.Distance(StartingPosition.Frame.Origin, _getPosition().Frame.Origin); + if (startDist > Params.FailDistance) + { + CancelMoveTo(WeenieError.YouChargedTooFar); + } + } + else + { + RemovePendingActionsHead(); + _StopMotion(CurrentCommand, localParams); + CurrentCommand = 0; + if (AuxCommand != 0) + { + _StopMotion(AuxCommand, localParams); + AuxCommand = 0; + } + BeginNextNode(); + } + } + + // ---- PHASE 3: TargetManager quantum retune (object moves only) ---- + if (TopLevelObjectId != 0 && MovementTypeState != MovementType.Invalid) + { + Vector3 v = _getVelocity(); + float speed = v.Length(); + if (speed > 0.1) + { + float eta = dist / speed; + if (MathF.Abs(eta - (float)_getTargetQuantum()) >= 1.0f) + { + _setTargetQuantum(eta); + } + } + } + } + + /// + /// Retail MoveToManager::HandleTurnToHeading (0052a0c0, raw + /// 307442-307517). VERBATIM per decomp §6c: no physics_obj → + /// (NoPhysicsObject). If NOT currently turning + /// ( isn't TurnLeft/TurnRight) — re-enter + /// (arms the turn). Otherwise: if + /// says the current heading has + /// PASSED the node's target heading (direction-aware per + /// ) — reset the fail counter, SNAP the + /// heading to the node's exact value via + /// (send:true — THE ONE heading snap in the whole family, decomp + /// §6c @0052a146), pop the node, stop the current motion, clear + /// , . Otherwise — + /// still turning: compute between + /// the LIVE current heading and (the + /// quirk-seeded DIFF from ), passing the + /// LIVE (can be TurnLeft — the mirror DOES + /// apply here, P3). If the result is inside (eps, 180) — rotational + /// progress was made: reset fail counter, update + /// to the LIVE heading. Otherwise — no + /// progress: update anyway, then increment + /// ONLY if neither interpolating nor + /// animating. + /// + public void HandleTurnToHeading() + { + if (!HasPhysicsObj) + { + CancelMoveTo(WeenieError.NoPhysicsObject); + return; + } + + uint cmd = CurrentCommand; + if (cmd != MotionCommand.TurnLeft && cmd != MotionCommand.TurnRight) + { + BeginTurnToHeading(); + return; + } + + MoveToNode head = _pendingActions.First!.Value; + float heading = _getHeading(); + + if (MoveToMath.HeadingGreater(heading, head.Heading, cmd)) + { + FailProgressCount = 0; + _setHeading(head.Heading, true); + RemovePendingActionsHead(); + + var localParams = new MovementParameters + { + CancelMoveTo = false, + HoldKeyToApply = Params.HoldKeyToApply, + }; + _StopMotion(CurrentCommand, localParams); + CurrentCommand = 0; + BeginNextNode(); + return; + } + + float diff = MoveToMath.HeadingDiff(heading, PreviousHeading, cmd); + if (diff < 180f && diff > MoveToMath.Epsilon) + { + FailProgressCount = 0; + PreviousHeading = heading; + return; + } + + PreviousHeading = heading; + if (!_isInterpolating() && !_interp.MotionsPending()) + { + FailProgressCount += 1; + } + } + + /// + /// Retail MoveToManager::HandleUpdateTarget (0052a7d0, raw + /// 307802-307867). VERBATIM per decomp §6d — the P4 TargetTracker feed + /// point: arrives at CONTEXT 0 only (the caller's + /// responsibility — CPhysicsObj::HandleUpdateTarget gates on + /// context_id == 0 before relaying, decomp §9f; not re-checked + /// here). No physics_obj → (NoPhysicsObject). + /// Ignore updates for any target other than + /// . TWO paths: + /// + /// Deferred start ( + /// false — the FIRST callback): self-target → snapshot both positions to + /// the mover's own current position and + /// (None) — instant success. Non-OK + /// status → ( + /// 0x38 — the target never resolved). Otherwise build the node plan via + /// (MoveToObject) or + /// (TurnToObject). + /// Retarget while running + /// ( true): non-OK status → + /// ( 0x37 — + /// was tracked, now gone). Otherwise, for MoveToObject ONLY: update + /// =interpolated, + /// =target, and RESET both + /// progress-clock pairs to FLT_MAX/now. Does NOT requeue nodes — the + /// running MoveToPosition node keeps steering toward the moved + /// each tick (Phase 1 of + /// ). TurnToObject gets NO retarget + /// handling (heading was frozen at the initial + /// callback). + /// + /// + public void HandleUpdateTarget(TargetInfo info) + { + if (!HasPhysicsObj) + { + CancelMoveTo(WeenieError.NoPhysicsObject); + return; + } + + if (TopLevelObjectId != info.ObjectId) return; + + if (!Initialized) + { + if (TopLevelObjectId == _getSelfId()) + { + Position selfPos = _getPosition(); + SoughtPosition = selfPos; + CurrentTargetPosition = selfPos; + CleanUpAndCallWeenie(WeenieError.None); + return; + } + + if (info.Status != TargetStatus.Ok) + { + CancelMoveTo(WeenieError.NoObject); + return; + } + + if (MovementTypeState == MovementType.MoveToObject) + { + MoveToObject_Internal(info.TargetPosition, info.InterpolatedPosition); + } + else if (MovementTypeState == MovementType.TurnToObject) + { + TurnToObject_Internal(info.TargetPosition); + } + } + else + { + if (info.Status != TargetStatus.Ok) + { + CancelMoveTo(WeenieError.ObjectGone); + return; + } + + if (MovementTypeState == MovementType.MoveToObject) + { + SoughtPosition = info.InterpolatedPosition; + CurrentTargetPosition = info.TargetPosition; + PreviousDistance = float.MaxValue; + PreviousDistanceTime = _curTime(); + OriginalDistance = float.MaxValue; + OriginalDistanceTime = _curTime(); + } + } + } + + /// + /// Retail MoveToManager::HitGround (00529d70, raw + /// 307175-307183): no-op when is Invalid; + /// otherwise tailcall — re-arm the moveto + /// state machine after landing (mirrors the UseTime CONTACT gate, which + /// blocks all progress while airborne). + /// + public void HitGround() + { + if (MovementTypeState == MovementType.Invalid) return; + BeginNextNode(); + } + + // ── 6f/6g. Deferred-start internals (first HandleUpdateTarget callback) ─ + + /// + /// Retail MoveToManager::MoveToObject_Internal (0052a400, + /// raw 307597-307663). VERBATIM per decomp §6f: no physics_obj → + /// (NoPhysicsObject). Snapshot + /// =, + /// =. Compute + /// heading toward the INTERPOLATED position (not the raw target — the + /// smoother tracking point) minus current heading, epsilon-snapped/ + /// normalized. against + /// (now valid — CurrentTargetPosition is + /// set) — if motion is needed, queue + /// [TurnToHeading(face interpolated)] → [MoveToPosition] (SAME + /// node plan shape as , but aimed at the + /// interpolated point). If + /// — queue a FINAL turn to heading-to-interpolated + + /// DesiredHeading (RELATIVE, unlike 's + /// absolute final heading). Set =true, then + /// . + /// + public void MoveToObject_Internal(Position target, Position interpolated) + { + if (!HasPhysicsObj) + { + CancelMoveTo(WeenieError.NoPhysicsObject); + return; + } + + SoughtPosition = interpolated; + CurrentTargetPosition = target; + + Vector3 myPos = _getPosition().Frame.Origin; + Vector3 interpPos = interpolated.Frame.Origin; + float iHeading = MoveToMath.PositionHeading(myPos, interpPos); + + float dist = GetCurrentDistance(); + + float diff = iHeading - _getHeading(); + if (MathF.Abs(diff) < MoveToMath.Epsilon) diff = 0f; + if (diff < -MoveToMath.Epsilon) diff += 360f; + + Params.GetCommand(dist, diff, out uint cmd, out _, out _); + if (cmd != 0) + { + AddTurnToHeadingNode(iHeading); + AddMoveToPositionNode(); + } + + if (Params.UseFinalHeading) + { + float final = iHeading + Params.DesiredHeading; + if (final >= 360f) final -= 360f; + AddTurnToHeadingNode(final); + } + + Initialized = true; + BeginNextNode(); + } + + /// + /// Retail MoveToManager::TurnToObject_Internal (0052a550, + /// raw 307667-307702). VERBATIM per decomp §6g: no physics_obj → + /// (NoPhysicsObject). Snapshot + /// =. Read + /// 's CURRENT heading (with §3d's quirk, this + /// is 0 for a fresh manager — the desired-heading write TurnToObject + /// seeded landed on instead and was + /// overwritten just above). Compute heading-to-target, add the sought + /// heading, fmod 360 — the final heading. Write it back into + /// 's frame, queue ONE TurnToHeading node + /// (inlined AddTurnToHeadingNode shape), set + /// =true, . With the + /// §3d quirk, the effective final heading is simply "face the object" — + /// ACE matches verbatim (MoveToManager.cs:246 + 271-276). + /// + public void TurnToObject_Internal(Position target) + { + if (!HasPhysicsObj) + { + CancelMoveTo(WeenieError.NoPhysicsObject); + return; + } + + CurrentTargetPosition = target; + + float soughtHeading = MoveToMath.GetHeading(SoughtPosition.Frame.Orientation); + + Vector3 myPos = _getPosition().Frame.Origin; + Vector3 targetPos = CurrentTargetPosition.Frame.Origin; + float targetHeading = MoveToMath.PositionHeading(myPos, targetPos); + + float final = (targetHeading + soughtHeading) % 360f; + if (final < 0f) final += 360f; + + SoughtPosition = SoughtPosition with + { + Frame = new CellFrame(SoughtPosition.Frame.Origin, MoveToMath.SetHeading(SoughtPosition.Frame.Orientation, final)), + }; + + _pendingActions.AddLast(new MoveToNode(MovementType.TurnToHeading, final)); + + Initialized = true; + BeginNextNode(); + } + + // ── 7. Motion issuing + cleanup family ────────────────────────────────── + + /// + /// Retail MoveToManager::_DoMotion (00529010, raw + /// 306351-306364). VERBATIM per decomp §7a: no physics_obj → 0x08 + /// (NoPhysicsObject); no motion interpreter → 0x0B + /// (NoMotionInterpreter — modeled as always-present since + /// is a required ctor field, so this branch is + /// unreachable in this port; kept in the doc for parity). Calls + /// EXPLICITLY (mutates + /// /.Speed in place — e.g. + /// promotes WalkForward+HoldKey.Run → RunForward×runRate) THEN tailcalls + /// + /// with the ADJUSTED motion id. THIS IS THE ENTIRE CMotionInterp SEAM — + /// MoveToManager never calls the raw-command DoMotion, + /// set_hold_run, or any raw-state API directly. + /// + private WeenieError _DoMotion(uint motion, MovementParameters p) + { + if (!HasPhysicsObj) return WeenieError.NoPhysicsObject; + + float speed = p.Speed; + _interp.adjust_motion(ref motion, ref speed, p.HoldKeyToApply); + p.Speed = speed; + + return _interp.DoInterpretedMotion(motion, p); + } + + /// + /// Retail MoveToManager::_StopMotion (00529080, raw + /// 306368-306381). Identical shape to : calls + /// then tailcalls + /// + /// with the ADJUSTED motion id. + /// + private WeenieError _StopMotion(uint motion, MovementParameters p) + { + if (!HasPhysicsObj) return WeenieError.NoPhysicsObject; + + float speed = p.Speed; + _interp.adjust_motion(ref motion, ref speed, p.HoldKeyToApply); + p.Speed = speed; + + return _interp.StopInterpretedMotion(motion, p); + } + + /// + /// Retail MoveToManager::CancelMoveTo (00529930, raw + /// 306886-306940). VERBATIM per decomp §7c: no-op when + /// is already Invalid (reentrancy guard — + /// see the class doc's reentrancy invariant). Otherwise: drain + /// , , then + /// StopCompletely. The argument is NEVER READ + /// in retail's body (every call site's error code is dropped in this + /// build, decomp §7c) — kept for parity/logging/tests only; NO behavior + /// depends on its value. + /// + public void CancelMoveTo(WeenieError error) + { + _ = error; // retail: never read in the body (decomp §7c) — kept for parity/logging. + + if (MovementTypeState == MovementType.Invalid) return; + + _pendingActions.Clear(); + CleanUp(); + if (HasPhysicsObj) _stopCompletely(); + } + + /// + /// Retail MoveToManager::CleanUp (005295c0, raw + /// 306710-306736). VERBATIM per decomp §7d: build a local params + /// (hold_key copied from , CancelMoveTo cleared), + /// then if a physics_obj exists: stop the current command (if any), stop + /// the aux command (if any), and — if this was an object move + /// ( != 0 AND + /// != Invalid) — () + /// (the P4 TargetTracker unsubscribe). Finally + /// . Does NOT drain + /// — / + /// do that first. + /// + public void CleanUp() + { + var localParams = new MovementParameters + { + HoldKeyToApply = Params.HoldKeyToApply, + CancelMoveTo = false, + }; + + if (HasPhysicsObj) + { + if (CurrentCommand != 0) _StopMotion(CurrentCommand, localParams); + if (AuxCommand != 0) _StopMotion(AuxCommand, localParams); + if (TopLevelObjectId != 0 && MovementTypeState != MovementType.Invalid) + { + _clearTarget(); + } + } + + InitializeLocalVariables(); + } + + /// + /// Retail MoveToManager::CleanUpAndCallWeenie (00529650, + /// raw 306740-306752). Despite the name, contains NO weenie call in this + /// build (decomp §7e — the compiled-out server-side callback; body ≡ + /// + StopCompletely). + /// is a documented CLIENT ADDITION (see its doc) firing here and at + /// 's empty-queue completion, standing in for + /// ACE's server-side OnMoveComplete — do NOT present it as retail + /// behavior. + /// + public void CleanUpAndCallWeenie(WeenieError error) + { + CleanUp(); + if (HasPhysicsObj) _stopCompletely(); + MoveToComplete?.Invoke(error); + } + + // ── internal helper: the 10-field MovementParameters copy every entry + // point performs (§3b/§3c/§3d/§3e all do this identically) ────────── + + private void CopyParams(MovementParameters p) + { + Params.CanWalk = p.CanWalk; + Params.CanRun = p.CanRun; + Params.CanSidestep = p.CanSidestep; + Params.CanWalkBackwards = p.CanWalkBackwards; + Params.CanCharge = p.CanCharge; + Params.FailWalk = p.FailWalk; + Params.UseFinalHeading = p.UseFinalHeading; + Params.Sticky = p.Sticky; + Params.MoveAway = p.MoveAway; + Params.MoveTowards = p.MoveTowards; + Params.UseSpheres = p.UseSpheres; + Params.SetHoldKey = p.SetHoldKey; + Params.Autonomous = p.Autonomous; + Params.ModifyRawState = p.ModifyRawState; + Params.ModifyInterpretedState = p.ModifyInterpretedState; + Params.CancelMoveTo = p.CancelMoveTo; + Params.StopCompletelyFlag = p.StopCompletelyFlag; + Params.DisableJumpDuringLink = p.DisableJumpDuringLink; + + Params.DistanceToObject = p.DistanceToObject; + Params.MinDistance = p.MinDistance; + Params.DesiredHeading = p.DesiredHeading; + Params.Speed = p.Speed; + Params.FailDistance = p.FailDistance; + Params.WalkRunThreshhold = p.WalkRunThreshhold; + Params.ContextId = p.ContextId; + Params.HoldKeyToApply = p.HoldKeyToApply; + Params.ActionStamp = p.ActionStamp; + } +} + +/// +/// Retail TargetInfo (acclient.h:31591, struct #3482) — the callback +/// payload consumes AND the wire +/// record the R5 voyeur system exchanges between +/// hosts (SendVoyeurUpdate → receive_target_update → +/// ). +/// +/// R5 EXTENDED this from the R4 4-field callback shape to the full retail +/// 10-field struct. The extra fields (, +/// , , +/// , , +/// ) default to zero, so the existing 4-argument +/// new TargetInfo(id, status, tp, ip) call sites (MoveToManager tests, +/// the AP-79 adapter pre-V2) still compile unchanged. +/// only reads +/// //; +/// the extra fields are consumed by the voyeur system. +/// +/// Retail object_id — matched against +/// ; a mismatch is silently +/// ignored (decomp §6d). +/// Retail status — see . +/// Retail target_position — the raw +/// (possibly jittery) target position. +/// Retail interpolated_position — +/// the smoothed tracking point +/// steers toward. +/// Retail context_id — the tracking context +/// (0 = the movement context; CPhysicsObj::HandleUpdateTarget only fans +/// out context 0). +/// Retail radius — the voyeur's send-on-move +/// threshold (game units). +/// Retail quantum — the dead-reckoning lookahead +/// horizon (seconds) for GetInterpolatedPosition. +/// Retail interpolated_heading — +/// normalized self→target direction (falls back to +Z when degenerate). +/// Retail velocity — the target's velocity at +/// send time. +/// Retail last_update_time — receipt +/// timestamp (drives the 10 s staleness timeout). +public readonly record struct TargetInfo( + uint ObjectId, + TargetStatus Status, + Position TargetPosition, + Position InterpolatedPosition, + uint ContextId = 0, + float Radius = 0f, + double Quantum = 0.0, + Vector3 InterpolatedHeading = default, + Vector3 Velocity = default, + double LastUpdateTime = 0.0); + +/// +/// Retail TargetStatus (acclient.h:7264). Only vs +/// non- is behaviorally distinguished by +/// in this build (decomp §6d) +/// — the other values are carried for parity with the P4 TargetTracker +/// contract (V0-pins.md §P4). +/// +public enum TargetStatus +{ + /// 0 — undefined/uninitialized. + Undefined = 0, + /// 1 — target resolved and tracked normally. + Ok = 1, + /// 2 — target left the world (despawned). + ExitWorld = 2, + /// 3 — target teleported. + Teleported = 3, + /// 4 — target became contained (picked up / stowed). + Contained = 4, + /// 5 — target became parented (e.g. mounted/wielded). + Parented = 5, + /// 6 — tracker timed out without an update. + TimedOut = 6, +} diff --git a/src/AcDream.Core/Physics/Motion/MoveToMath.cs b/src/AcDream.Core/Physics/Motion/MoveToMath.cs new file mode 100644 index 00000000..e7365edb --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MoveToMath.cs @@ -0,0 +1,306 @@ +using System; +using System.Numerics; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R4-V1 — pure-math free functions consumed by the (future) MoveToManager +/// port: heading_diff, heading_greater, Position::heading +/// / Frame::get_heading / Frame::set_heading, and +/// Position::cylinder_distance. No GL/App dependency — Core-only, +/// per the Code Structure Rules. NAME WATCH: this file (not +/// MoveToManager.cs, per r4-port-plan.md §3 "New code target") is the +/// R4-V1 deliverable; the manager itself is R4-V2. +/// +public static class MoveToMath +{ + /// + /// Universal heading/distance epsilon (same literal as R3's A5/A6 — + /// r4-moveto-decomp.md §12 constants inventory). + /// + public const float Epsilon = 0.000199999995f; + + /// + /// Retail heading_diff (0x00528fb0, free function, raw + /// 306327-306347), PINNED by direct disassembly of the PDB-matched + /// retail binary (ghidra-confirmations.md §P3 — the strongest evidence + /// tier in the R4 pin set): + /// + /// d = h1 - h2; + /// if (fabs(h1 - h2) < F_EPSILON) d = 0; + /// if (d < -F_EPSILON) d += 360; + /// if (F_EPSILON < d && turnCmd != TurnRight) d = 360 - d; // the mirror + /// return d; + /// + /// The mirror gates on the turn command NOT being TurnRight + /// (0x6500000d) — TurnLeft (and any other command) measures the + /// COMPLEMENTARY angle. This CONTRADICTS r4-moveto-decomp.md §5g's + /// "arg3 UNUSED" claim, which the Ghidra disassembly pin overrides + /// (V0-pins.md §P3 adjudication). Call sites: BeginTurnToHeading + /// passes the CONSTANT TurnRight (mirror explicitly disabled — the + /// direction pick stays the ≤180 test elsewhere); HandleTurnToHeading + /// passes the LIVE current_command (can be TurnLeft). + /// + /// First heading, degrees. + /// Second heading, degrees. + /// The active turn command id — gates the mirror. + /// Normalized heading difference, degrees. + public static float HeadingDiff(float h1, float h2, uint turnCmd) + { + float d = h1 - h2; + if (MathF.Abs(h1 - h2) < Epsilon) + { + d = 0f; + } + if (d < -Epsilon) + { + d += 360f; + } + if (Epsilon < d && turnCmd != MotionCommand.TurnRight) + { + d = 360f - d; + } + return d; + } + + /// + /// Retail heading_greater (00528f60, free function, raw + /// 306281-306323), verbatim per r4-moveto-decomp.md §5f: + /// + /// if (fabs(a - b) > 180) greater = (b > a); // wrapped case: compare flipped + /// else greater = (a > b); + /// if (turnCmd == TurnRight) return greater; + /// return !greater; // TurnLeft (and any other cmd): inverted + /// + /// "Has the turn passed the target heading" — direction-aware, + /// 360°-wrap-aware. The visible TurnRight-arg idiom: the gate is + /// == TurnRight (not != TurnRight as in + /// 's mirror) — every OTHER command inverts, + /// not just TurnLeft specifically. + /// + public static bool HeadingGreater(float a, float b, uint turnCmd) + { + bool greater = MathF.Abs(a - b) > 180f + ? b > a + : a > b; + + return turnCmd == MotionCommand.TurnRight ? greater : !greater; + } + + /// + /// Retail Position::heading(from, to) (0x005a9520, raw + /// 438288-438290), PINNED per V0-pins.md §P5: compass degrees, 0 = + /// North (+Y), 90 = East (+X), CLOCKWISE, range [0,360). + /// + /// heading(from, to) = (450 - atan2Deg(dy, dx)) % 360 + /// + /// Golden cardinals: N(0,+1)→0, E(+1,0)→90, S(0,-1)→180, W(-1,0)→270. + /// Horizontal (X/Y) only — Z (height) does not participate, matching + /// retail's compass-heading semantics. An in-tree twin of this formula + /// already exists at SceneryHelpers.cs:75 (render-side, + /// independently verified — not reused directly to keep this file + /// GL-free per the Code Structure Rules, but the formula is identical). + /// + public static float PositionHeading(Vector3 from, Vector3 to) + { + float dx = to.X - from.X; + float dy = to.Y - from.Y; + float headingDeg = 450f - MathF.Atan2(dy, dx) * (180f / MathF.PI); + headingDeg %= 360f; + if (headingDeg < 0f) headingDeg += 360f; + return headingDeg; + } + + /// + /// Retail Frame::get_heading (0x00535760, raw 319781) — + /// extracts the compass heading (P5 convention) from a body orientation + /// quaternion. The packer-reuse trap (V0-pins §P5 correction): + /// acdream's outbound packer (GameWindow.YawToAcQuaternion) is + /// wire-correct at the QUATERNION level but its internal scalar + /// intermediate (headingDeg = 180 - yawDeg) is holtburger's + /// SHIFTED convention, not retail's. This method uses the CORRECT + /// scalar bridge derived from acdream's own body convention + /// (PlayerMovementController.cs:1022-1025: Orientation = + /// AxisAngle(Z, Yaw - PI/2), local-forward = +Y, Yaw=0 faces +X): + /// world-forward = (cos Yaw, sin Yaw), so + /// YawDeg = atan2Deg(forward.Y, forward.X) and + /// heading = (90 - YawDeg) mod 360 — the exact inverse of + /// . Identity quaternion (Yaw=PI/2, i.e. facing + /// +Y/North) → heading 0, matching P5's "identity quaternion faces + /// heading 0" pin. + /// + public static float GetHeading(Quaternion orientation) + { + var forward = Vector3.Transform(new Vector3(0f, 1f, 0f), orientation); + float yawDeg = MathF.Atan2(forward.Y, forward.X) * (180f / MathF.PI); + float headingDeg = 90f - yawDeg; + headingDeg %= 360f; + if (headingDeg < 0f) headingDeg += 360f; + return headingDeg; + } + + /// + /// Retail Frame::set_heading (0x00535e40, raw + /// 320055-320066) — builds a body orientation quaternion facing + /// (P5 compass convention), preserving + /// acdream's body-orientation convention (rotation about world Z only; + /// 's pitch/roll, if any, is + /// discarded — matching retail's set_heading, which is a pure + /// yaw-about-Z setter). Exact inverse of : + /// YawDeg = 90 - headingDeg, then Orientation = + /// AxisAngle(Z, Yaw - PI/2) per + /// PlayerMovementController.cs:1025's convention. + /// + /// Unused beyond signature parity with + /// the render-side SceneryHelpers.SetHeading twin — retail's + /// set_heading is a pure yaw-about-Z setter with no dependency + /// on the prior orientation's roll/pitch component in the body-frame + /// convention this port uses. + /// Desired compass heading, degrees. + public static Quaternion SetHeading(Quaternion baseOrientation, float headingDeg) + { + _ = baseOrientation; + float yawDeg = 90f - headingDeg; + float yaw = yawDeg * (MathF.PI / 180f); + return Quaternion.CreateFromAxisAngle(Vector3.UnitZ, yaw - MathF.PI / 2f); + } + + /// + /// R4-V5: the scalar leg of for bodies whose + /// authoritative facing is a yaw ANGLE rather than a quaternion (the + /// local player: PlayerMovementController.Yaw, radians, Yaw=0 + /// faces +X, re-synced into the body quaternion every Update). Same P5 + /// bridge: heading = (90 - yawDeg) mod 360. + /// + public static float HeadingFromYaw(float yawRad) + { + float headingDeg = 90f - yawRad * (180f / MathF.PI); + headingDeg %= 360f; + if (headingDeg < 0f) headingDeg += 360f; + return headingDeg; + } + + /// + /// R4-V5: exact inverse of — the + /// set_heading seam for yaw-authoritative bodies (the local + /// player's heading snap must write Yaw, NOT the body + /// quaternion, which the controller re-derives from Yaw every frame). + /// Returns radians wrapped to [-π, π] matching the controller's own + /// wrap discipline. + /// + public static float YawFromHeading(float headingDeg) + { + float yaw = (90f - headingDeg) * (MathF.PI / 180f); + while (yaw > MathF.PI) yaw -= 2f * MathF.PI; + while (yaw < -MathF.PI) yaw += 2f * MathF.PI; + return yaw; + } + + /// + /// Retail Position::cylinder_distance, the pure-math shape + /// consumed by MoveToManager::GetCurrentDistance + /// (005291b0, r4-moveto-decomp.md §5a) when use_spheres + /// (wire bit 0x400) is set — object moves use edge-to-edge cylinder + /// distance; position moves use plain center (Euclidean) distance + /// instead (not ported here — Vector3.Distance already covers + /// it). BN garbles the x87 plumbing in the raw, so the exact + /// radius-combination arithmetic is not directly visible; ported per + /// the PDB argument ORDER (own radius/height/position, target + /// radius/height/position) with the standard cylinder-distance shape: + /// planar (X/Y) center distance minus the sum of both radii, clamped + /// at zero (overlapping cylinders report 0, never negative). Height is + /// accepted for signature parity with the retail call (own/target + /// height feed the caller's contact-plane logic elsewhere) but does + /// NOT participate in this edge-to-edge planar computation — matching + /// retail's use of cylinder_distance purely for the horizontal arrival + /// gate. + /// + public static float CylinderDistance( + float ownRadius, float ownHeight, Vector3 ownPos, + float targetRadius, float targetHeight, Vector3 targetPos) + { + _ = ownHeight; + _ = targetHeight; + + float dx = targetPos.X - ownPos.X; + float dy = targetPos.Y - ownPos.Y; + float centerDist = MathF.Sqrt(dx * dx + dy * dy); + + float edgeDist = centerDist - ownRadius - targetRadius; + return edgeDist > 0f ? edgeDist : 0f; + } + + /// + /// Retail Position::cylinder_distance_no_z — the signed + /// horizontal (X/Y) edge-to-edge distance between two cylinders: + /// centerDist − ownRadius − targetRadius. Unlike + /// (the arrival-gate variant, which CLAMPS at + /// 0), this variant is NOT clamped — overlapping cylinders report a NEGATIVE + /// value. StickyManager::adjust_offset (0x00555430) relies on the + /// sign: when the follower is inside the desired 0.3 m stick gap the + /// distance goes negative, the per-tick delta inverts, and the mover backs + /// off to restore the gap (ACE StickyManager.cs:156). + /// + public static float CylinderDistanceNoZ( + float ownRadius, Vector3 ownPos, float targetRadius, Vector3 targetPos) + { + float dx = targetPos.X - ownPos.X; + float dy = targetPos.Y - ownPos.Y; + float centerDist = MathF.Sqrt(dx * dx + dy * dy); + return centerDist - ownRadius - targetRadius; + } + + /// + /// Retail AC1Legacy::Vector3::normalize_check_small — normalize + /// in place, returning true if the vector was + /// too small to normalize (near-zero) and leaving it unchanged in that + /// case. Consumed by StickyManager::adjust_offset (don't chase + /// jitter when already at the target) and + /// (interpolated-heading + /// fallback). A public shared twin of the private helper in + /// ParticleSystem; same 1e-8 near-zero length guard. + /// + /// true = too small (left unchanged); false = + /// normalized. + public static bool NormalizeCheckSmall(ref Vector3 v) + { + float length = v.Length(); + if (length < 1e-8f) + return true; + v /= length; + return false; + } + + /// + /// Retail Position::globaltolocalvec — rotate a WORLD-space vector + /// into a frame's LOCAL coordinates by the inverse of the frame's + /// orientation. Consumed by StickyManager::adjust_offset + /// (0x00555430) to express the self→target offset in the mover's own frame + /// before flattening Z and steering. Pure rotation (no translation) — + /// is a direction/offset, not a point. + /// + public static Vector3 GlobalToLocalVec(Quaternion frameOrientation, Vector3 worldVec) + => Vector3.Transform(worldVec, Quaternion.Conjugate(frameOrientation)); + + /// + /// Landblock-local wire origin → world space (verbatim relocation from + /// the deleted RemoteMoveToDriver.OriginToWorld, R4-V4): MoveTo / + /// TurnTo packets carry positions block-local; acdream's streaming world + /// re-centers on a live-center landblock grid. + /// + public static Vector3 OriginToWorld( + uint originCellId, + float originX, + float originY, + float originZ, + int liveCenterLandblockX, + int liveCenterLandblockY) + { + int lbX = (int)((originCellId >> 24) & 0xFFu); + int lbY = (int)((originCellId >> 16) & 0xFFu); + return new Vector3( + originX + (lbX - liveCenterLandblockX) * 192f, + originY + (lbY - liveCenterLandblockY) * 192f, + originZ); + } +} diff --git a/src/AcDream.Core/Physics/Motion/MoveToNode.cs b/src/AcDream.Core/Physics/Motion/MoveToNode.cs new file mode 100644 index 00000000..06052c0f --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MoveToNode.cs @@ -0,0 +1,47 @@ +namespace AcDream.Core.Physics.Motion; + +/// +/// R4-V2 — verbatim port of retail's MoveToManager::MovementNode +/// (acclient.h:57702, struct #6350): +/// +/// struct __cppobj MoveToManager::MovementNode : DLListData +/// { // +0 dllist_next, +4 dllist_prev (DLListData) +/// MovementTypes::Type type; // +8 — only 7 (MoveToPosition) and 9 (TurnToHeading) ever queued +/// float heading; // +0xc — only meaningful for type 9 +/// }; +/// +/// +/// +/// NAME WATCH (r4-port-plan.md §3 "New code target"): named +/// MoveToNode, NOT MovementNode, to avoid colliding with R2's +/// (the UNRELATED CMotionInterp::pending_motions +/// node — a different queue on a different class; see the AD-34 register +/// wording on both node types' shared "managed collection standing in for +/// retail's intrusive DLList/LList" pattern). +/// +/// +/// +/// Retail allocates these with operator new(0x10) and links them onto +/// MoveToManager::pending_actions (a DLList — doubly-linked, +/// unlike CMotionInterp's singly-linked LList) via +/// DLListBase::InsertAfter (tail-append; r4-moveto-decomp.md §4a). +/// Ported as a managed +/// of this value type — same pattern as 's port +/// (AD-34 wording): node identity semantics preserved via +/// LinkedListNode<MoveToNode> references rather than raw +/// prev/next pointers, FIFO order preserved via tail-append + +/// RemoveFirst. +/// +/// +/// Retail type (+8) — only +/// (7) and +/// (9) are ever queued +/// (r4-moveto-decomp.md §4a: AddMoveToPositionNode / +/// AddTurnToHeadingNode are the only two producers; +/// 's dispatch is a defensive +/// if/if, not a full switch — an unknown type stalls rather than +/// throwing, matching the raw's shape). +/// Retail heading (+0xc) — only meaningful for +/// nodes; zero/unused for +/// nodes. +public readonly record struct MoveToNode(MovementType Type, float Heading); diff --git a/src/AcDream.Core/Physics/Motion/MovementManager.cs b/src/AcDream.Core/Physics/Motion/MovementManager.cs new file mode 100644 index 00000000..7666dbd0 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MovementManager.cs @@ -0,0 +1,171 @@ +using System; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R5-V5 — retail MovementManager (acclient.h /* 3463 */, 0x10 +/// bytes / four pointers): the ONE per-entity owner of the movement pipeline's +/// two managers. Decomp extract: +/// docs/research/2026-07-03-r5-managers/r5-movementmanager-decomp.md. +/// +/// +/// struct MovementManager { +/// CMotionInterp *motion_interpreter; // +0x0 → Minterp +/// MoveToManager *moveto_manager; // +0x4 → MoveTo (lazy) +/// CPhysicsObj *physics_obj; // +0x8 ┐ carried by the children + +/// CWeenieObject *weenie_obj; // +0xc ┘ the MoveToFactory closure +/// }; +/// +/// +/// Construction mapping. Retail lazily creates BOTH children +/// (CMotionInterp::Create + enter_default_state at every entry +/// point; MoveToManager::Create via ). +/// acdream constructs the interp eagerly at entity construction +/// (RemoteMotion / PlayerMovementController ctors — the lazy +/// window is never observable; register TS-38 already covers the +/// Initted side of this) and hands it to this ctor. The moveto side +/// keeps retail's lazy mechanism: retail +/// constructs from the physics_obj/weenie_obj backpointers; +/// acdream's closure is the stand-in for those +/// two fields, carrying the full seam wiring (set once at the bind site — +/// EnsureRemoteMotionBindings / EnterPlayerModeNow / the chase +/// harness — which then calls immediately, +/// preserving the pre-facade eager timing; the ctor is side-effect-free so +/// the timing is unobservable either way). +/// +/// Deliberately NOT absorbed here (the R5-V5 slice keeps these +/// at their current owners): unpack_movement 0x00524440 ≡ the +/// GameWindow UM path + RouteServerMoveTo (Core.Net wire types stay +/// out of Core.Physics); move_to_interpreted_state 0x00524170 ≡ the +/// funnel's MotionInterpreter.MoveToInterpretedState call sites; +/// MotionDone 0x005242d0 ≡ the sequencer's MotionDoneTarget +/// seam (register AD-36); LeaveGround 0x00524320's moveto half is a +/// COMDAT no-op (see PlayerMovementController's landing comment) so +/// call sites keep invoking Minterp.LeaveGround() directly; +/// EnterDefaultState/HandleEnterWorld/ReportExhaustion/ +/// SetWeenieObject/Destroy have no acdream caller yet — +/// get_minterp 0x005242a0 ≡ the property. +/// +/// PerformMovement's set_active(1) head +/// (0x005240d9) is not re-asserted here: acdream bodies assert the Active +/// transient bit at spawn (RemoteMotion ctor) and the pre-facade +/// route never re-asserted it — status quo preserved (zero-behavior-change +/// slice), not a new deviation. +/// +public sealed class MovementManager +{ + /// Retail motion_interpreter (+0x0). Always present in + /// acdream (eager construction — see the class doc); direct child access + /// for interp-specific ops mirrors retail's get_minterp + /// (0x005242a0) callers. + public MotionInterpreter Minterp { get; } + + /// Retail moveto_manager (+0x4) — null until + /// (or a type-6..9 + /// ) creates it. + public MoveToManager? MoveTo { get; private set; } + + /// The acdream stand-in for retail's physics_obj/ + /// weenie_obj backpointers (+0x8/+0xc): the creation recipe + /// invokes. Set exactly once at the bind + /// site; the closure carries the MoveToManager's seam wiring (and the + /// StickTo/Unstick/MoveToComplete binds) that retail reads off + /// CPhysicsObj. + public Func? MoveToFactory { get; set; } + + public MovementManager(MotionInterpreter minterp) + { + Minterp = minterp ?? throw new ArgumentNullException(nameof(minterp)); + } + + /// + /// Retail MovementManager::MakeMoveToManager (0x00524000): + /// lazy-construct if null; no-op if already present. + /// No-op (instead of retail's unconditional create) when no factory has + /// been bound yet — acdream's seams arrive from the bind site, and every + /// consumer path runs after binding. + /// + public void MakeMoveToManager() + { + if (MoveTo is null && MoveToFactory is not null) + MoveTo = MoveToFactory(); + } + + /// + /// Retail MovementManager::PerformMovement (0x005240d0): the + /// type-1..9 two-way dispatch. (type - 1) > 8 (type 0 + /// underflows unsigned) → 0x47; types 1-5 → CMotionInterp:: + /// PerformMovement (return propagated); types 6-9 → + /// + MoveToManager::PerformMovement + /// whose return is NOT propagated (@0052414f return 0) — the + /// facade reports for that path. + /// + public WeenieError PerformMovement(MovementStruct mvs) + { + switch (mvs.Type) + { + case MovementType.RawCommand: + case MovementType.InterpretedCommand: + case MovementType.StopRawCommand: + case MovementType.StopInterpretedCommand: + case MovementType.StopCompletely: + return Minterp.PerformMovement(mvs); + + case MovementType.MoveToObject: + case MovementType.MoveToPosition: + case MovementType.TurnToObject: + case MovementType.TurnToHeading: + MakeMoveToManager(); + if (MoveTo is null) + // acdream-only guard: a type-6..9 event before the bind + // site set MoveToFactory (unreachable in production — + // EnsureRemoteMotionBindings / EnterPlayerModeNow bind + // before any route can fire). Retail would Create here. + return WeenieError.GeneralMovementFailure; + MoveTo.PerformMovement(mvs); + return WeenieError.None; + + default: + return WeenieError.GeneralMovementFailure; // 0x47 + } + } + + /// Retail MovementManager::UseTime (0x005242f0): relay + /// to ONLY (does not touch the interp, does not + /// lazy-create); no-op while null. + public void UseTime() => MoveTo?.UseTime(); + + /// Retail MovementManager::HitGround (0x00524300): fan + /// to BOTH children if present — CMotionInterp::HitGround FIRST + /// (the falling-pose exit re-apply), then MoveToManager::HitGround + /// (re-arms a moveto suspended by the airborne UseTime contact + /// gate). + public void HitGround() + { + Minterp.HitGround(); + MoveTo?.HitGround(); + } + + /// Retail MovementManager::HandleExitWorld (0x00524350): + /// interp ONLY (drains pending_motions); does not touch + /// . + public void HandleExitWorld() => Minterp.HandleExitWorld(); + + /// Retail MovementManager::CancelMoveTo (0x005241b0): + /// relay to ; no-op while null. The retail + /// interrupt_current_movement → MovementManager::CancelMoveTo(0x36) + /// chain lands here. + public void CancelMoveTo(WeenieError error) => MoveTo?.CancelMoveTo(error); + + /// Retail MovementManager::HandleUpdateTarget + /// (0x00524790): relay to ; no-op while null. The + /// CPhysicsObj::HandleUpdateTarget fan (0x00512bc0) calls this + /// leg first, then the PositionManager's (host order — + /// EntityPhysicsHost.HandleUpdateTarget). + public void HandleUpdateTarget(TargetInfo info) => MoveTo?.HandleUpdateTarget(info); + + /// Retail MovementManager::IsMovingTo (0x00524260): + /// true iff exists AND reports an armed + /// move. + public bool IsMovingTo() => MoveTo?.IsMovingTo() ?? false; +} diff --git a/src/AcDream.Core/Physics/Motion/MovementParameters.cs b/src/AcDream.Core/Physics/Motion/MovementParameters.cs new file mode 100644 index 00000000..8e648f55 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/MovementParameters.cs @@ -0,0 +1,472 @@ +using AcDream.Core.Physics; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R3-W1 — verbatim port of retail's MovementParameters +/// (acclient.h:31453, struct #3460; bitfield struct +/// acclient.h:31423-31443): +/// +/// struct __cppobj MovementParameters : PackObj +/// { +/// union { unsigned int bitfield; ... } ___u1; +/// float distance_to_object; +/// float min_distance; +/// float desired_heading; +/// float speed; +/// float fail_distance; +/// float walk_run_threshhold; +/// unsigned int context_id; +/// HoldKey hold_key_to_apply; +/// unsigned int action_stamp; +/// }; +/// +/// +/// +/// The bitfield's absolute mask table is pinned in +/// docs/research/2026-07-02-r3-motioninterp/W0-pins.md §A4 (bit-for-bit +/// identical to ACE's MovementParamFlags): +/// +/// +/// 0x1CanWalk +/// 0x2CanRun +/// 0x4CanSidestep +/// 0x8CanWalkBackwards +/// 0x10CanCharge +/// 0x20FailWalk +/// 0x40UseFinalHeading +/// 0x80Sticky +/// 0x100MoveAway +/// 0x200MoveTowards +/// 0x400UseSpheres +/// 0x800SetHoldKey +/// 0x1000Autonomous +/// 0x2000ModifyRawState +/// 0x4000ModifyInterpretedState +/// 0x8000CancelMoveTo +/// 0x10000StopCompletely +/// 0x20000DisableJumpDuringLink +/// +/// +/// +/// Ctor default (raw 300510-300534, 0x00524380): +/// (bitfield & 0xfffdee0f) | 0x1ee0f → 0x1EE0F sets +/// {CanWalk, CanRun, CanSidestep, CanWalkBackwards, MoveTowards, UseSpheres, +/// SetHoldKey, ModifyRawState, ModifyInterpretedState, CancelMoveTo, +/// StopCompletely}; clears {CanCharge, FailWalk, UseFinalHeading, Sticky, +/// MoveAway, Autonomous, DisableJumpDuringLink}. +/// Scalars: min_distance=0, distance_to_object=0.6, +/// fail_distance=FLT_MAX, desired_heading=0, speed=1, +/// walk_run_threshhold=15 (NOT ACE's 1.0 — W0-pins A4 divergence trap), +/// context_id=0, hold_key_to_apply=HoldKey.Invalid, +/// action_stamp=0. +/// +/// +/// +/// ACE-divergence traps (W0-pins A4, do not copy): ACE's +/// MovementParameters ctor sets CanCharge = true +/// (MovementParameters.cs:58) — retail's default has bit 0x10 CLEAR; +/// this port defaults CanCharge = false. ACE also changed +/// Default_WalkRunThreshold to 1.0 (L50) vs retail's literal 15.0 +/// (@300519) — this port defaults WalkRunThreshhold = 15f. +/// +/// +/// +/// Named bool properties per plan (no ToBitfield()/FromBitfield() +/// pair — the wire never carries this struct raw; RawMotionState::Pack +/// serializes the STATE, not this transient parameter block. If a future +/// slice needs the packed form, add the pair then with a cited call site). +/// +/// +public sealed class MovementParameters +{ + // ── bitfield flags (retail 0x1EE0F default; W0-pins A4) ─────────────── + + /// Mask 0x1 — default true. + public bool CanWalk { get; set; } = true; + + /// Mask 0x2 — default true. + public bool CanRun { get; set; } = true; + + /// Mask 0x4 — default true. + public bool CanSidestep { get; set; } = true; + + /// Mask 0x8 — default true. + public bool CanWalkBackwards { get; set; } = true; + + /// + /// Mask 0x10 — default FALSE. ACE-divergence trap (W0-pins A4): ACE's + /// ctor sets this true (MovementParameters.cs:58); retail's 0x1EE0F + /// default has bit 0x10 CLEAR. Do not "fix" this to true. + /// + public bool CanCharge { get; set; } + + /// Mask 0x20 — default false. + public bool FailWalk { get; set; } + + /// Mask 0x40 — default false. + public bool UseFinalHeading { get; set; } + + /// Mask 0x80 — default false. + public bool Sticky { get; set; } + + /// Mask 0x100 — default false. + public bool MoveAway { get; set; } + + /// Mask 0x200 — default true. + public bool MoveTowards { get; set; } = true; + + /// Mask 0x400 — default true. + public bool UseSpheres { get; set; } = true; + + /// Mask 0x800 — default true. DoMotion @306188: byte1&8 + /// requests a SetHoldKey call before adjust_motion. + public bool SetHoldKey { get; set; } = true; + + /// + /// Mask 0x1000 — default FALSE. Not the same virtual as + /// IWeenieObject.IsThePlayer (W0-pins A3) — this is the + /// per-call "was this an autonomous (locally-predicted) action?" flag. + /// + public bool Autonomous { get; set; } + + /// Mask 0x2000 — default true. DoMotion @306213: byte1&0x20 + /// mirrors the applied motion into RawMotionState via + /// ApplyMotion/RemoveMotion. + public bool ModifyRawState { get; set; } = true; + + /// Mask 0x4000 — default true. Mirrors into + /// InterpretedMotionState. + public bool ModifyInterpretedState { get; set; } = true; + + /// Mask 0x8000 — default true. Bitfield high-byte sign bit; + /// DoMotion/StopMotion @306183/@305684: triggers + /// interrupt_current_movement before the rest of the call. + public bool CancelMoveTo { get; set; } = true; + + /// Mask 0x10000 — default true. + public bool StopCompletelyFlag { get; set; } = true; + + /// + /// Mask 0x20000 — default FALSE. DoInterpretedMotion @305597: when set, + /// forces the computed jump_error_code to 0x48 (A1: jump + /// BLOCKED by motion/position) regardless of what + /// motion_allows_jump would have said. + /// + public bool DisableJumpDuringLink { get; set; } + + // ── scalar fields (retail ctor 0x00524380 defaults) ─────────────────── + + /// Retail default 0.6. + public float DistanceToObject { get; set; } = 0.6f; + + /// Retail default 0. + public float MinDistance { get; set; } + + /// Retail default 0. + public float DesiredHeading { get; set; } + + /// Retail default 1. + public float Speed { get; set; } = 1f; + + /// Retail default FLT_MAX. + public float FailDistance { get; set; } = float.MaxValue; + + /// + /// Retail default 15.0 (@300519). ACE-divergence trap (W0-pins A4): ACE + /// changed Default_WalkRunThreshold to 1.0 — do not copy. + /// + public float WalkRunThreshhold { get; set; } = 15f; + + /// Retail default 0. + public uint ContextId { get; set; } + + /// Retail default . + public HoldKey HoldKeyToApply { get; set; } = HoldKey.Invalid; + + /// Retail default 0. + public uint ActionStamp { get; set; } + + // ── R4-V1: command-selection family (closes M2-mechanics) ───────────── + + /// + /// Retail MovementParameters::get_command (0x0052aa00, + /// raw 307946-308012), VERBATIM per + /// docs/research/2026-07-03-r4-moveto/r4-moveto-decomp.md §5c. Picks the + /// motion command + moving-away flag from the towards/away bitfield + /// combination, THEN the walk-vs-run cascade. + /// + /// + /// Command pick (mirrors towards_and_away's bands but is + /// NOT identical — see the asymmetry note on ): + /// + /// MoveTowards && MoveAway → delegate + /// to (the three-band form). + /// MoveTowards only (or neither flag set — + /// retail's else if falls through to the SAME branch): plain + /// towards — dist > DistanceToObject → WalkForward, + /// !movingAway; else idle (cmd 0). + /// MoveAway only: pure away — + /// dist < MinDistance → WalkForward, movingAway=true (the + /// heading flips +180 via — turn-around, + /// NOT WalkBackwards, unlike 's min-band); + /// else idle. + /// + /// + /// + /// + /// THE walk-vs-run rule (confirms + /// feedback_autowalk_cancharge_bit — port RETAIL's version of + /// BOTH the fast-path ACE dropped and the threshold-close-walk pair): + /// HoldKey.Run ⇐ CanCharge set (the fast-path — wins + /// regardless of CanRun/CanWalk/distance), OR (CanRun set AND + /// (CanWalk clear OR dist - DistanceToObject > + /// WalkRunThreshhold)). HoldKey.None (walk) ⇐ no CanRun, or + /// walk-capable within the threshold (INCLUSIVE ≤ — the raw's + /// test ah,0x41 after the fcom is the not-greater-than reading, + /// §5c @308003). + /// + /// + /// Current distance-to-target (retail's + /// GetCurrentDistance result — center or cylinder distance per + /// ). + /// Heading-to-target minus current heading, + /// normalized [0,360) — UNUSED by get_command itself (the raw + /// signature carries it for parity with the caller's local; retail's + /// body never reads arg3 in this build). Kept as a parameter for + /// call-site symmetry with BeginMoveForward (§4c), which computes + /// it immediately before calling get_command. + /// Chosen motion command id, or 0 if no movement + /// is needed (already in range). + /// Chosen hold key (walk vs run). + /// True if the chosen motion moves the mover + /// AWAY from the target (feeds and the + /// arrival predicate's polarity). + public void GetCommand(float dist, float headingDiff, out uint motion, out HoldKey holdKey, out bool movingAway) + { + _ = headingDiff; // retail's arg3 — unread in this build's body (§5c) + + // ── command + moving_away pick ────────────────────────────────── + if (MoveTowards && MoveAway) + { + TowardsAndAway(dist, out motion, out movingAway); + } + else if (MoveAway && !MoveTowards) + { + // pure AWAY: dist < min_distance → WalkForward, moving away + // (turn-around; heading flips +180 via GetDesiredHeading). + if (dist < MinDistance) + { + motion = MotionCommand.WalkForward; + movingAway = true; + } + else + { + motion = 0u; + movingAway = false; + } + } + else + { + // plain TOWARDS (MoveTowards set, or neither flag set — retail's + // `else if ((flags & 0x100) == 0)` falls to the same label). + if (dist > DistanceToObject) + { + motion = MotionCommand.WalkForward; + movingAway = false; + } + else + { + motion = 0u; + movingAway = false; + } + } + + // ── walk-vs-run HoldKey cascade ───────────────────────────────── + if (CanCharge) + { + // THE fast-path ACE dropped: can_charge short-circuits straight + // to Run regardless of CanRun/CanWalk/distance. + holdKey = HoldKey.Run; + return; + } + if (!CanRun) + { + holdKey = HoldKey.None; + return; + } + if (CanWalk && (dist - DistanceToObject) <= WalkRunThreshhold) + { + holdKey = HoldKey.None; + return; + } + holdKey = HoldKey.Run; + } + + /// + /// Retail MovementParameters::towards_and_away + /// (0x0052a9a0, raw 307917-307942), VERBATIM per + /// r4-moveto-decomp.md §5d. Three bands: + /// + /// dist > DistanceToObject → WalkForward, + /// towards (not moving away). + /// dist - MinDistance < F_EPSILON (inside + /// the min-distance band) → WalkBackward, moving away. NOTE the + /// asymmetry vs 's pure-away branch: this backs + /// up with WalkBackwards (no turn-around), not WalkForward+heading-flip + /// (r4-moveto-decomp.md :656). + /// otherwise (strictly inside [MinDistance, + /// DistanceToObject]) → idle (cmd 0). + /// + /// + /// Current distance-to-target. + /// Chosen motion command, or 0 if already in the dead + /// band. + /// True only for the WalkBackward (min-band) + /// case. + public void TowardsAndAway(float dist, out uint cmd, out bool movingAway) + { + const float epsilon = 0.000199999995f; + + if (dist > DistanceToObject) + { + cmd = MotionCommand.WalkForward; + movingAway = false; + return; + } + if (dist - MinDistance < epsilon) + { + cmd = MotionCommand.WalkBackward; + movingAway = true; + return; + } + cmd = 0u; + movingAway = false; + } + + /// + /// Retail MovementParameters::get_desired_heading + /// (0x0052aad0), PINNED by direct Ghidra decompile of + /// patchmem.gpr (fetched live during V0 — see + /// docs/research/2026-07-03-r4-moveto/ghidra-confirmations.md §P2, + /// ACE-shaped constants CONFIRMED exact, superseding the earlier + /// BN-garble-based "high confidence" pin): + /// + /// __thiscall get_desired_heading(command, movingAway) + /// { + /// if (command == RunForward || command == WalkForward) { + /// if (!movingAway) return 0.0f; + /// } else { + /// if (command != WalkBackward) return 0.0f; + /// if (movingAway) return 0.0f; + /// } + /// return 180.0f; + /// } + /// + /// Truth table: forward/run + towards → 0°; forward/run + away → 180°; + /// backward + towards → 180°; backward + away → 0°; any other command + /// → 0°. This is the heading OFFSET added to the raw heading-to-target + /// so an "away" walk faces away and an "away" backstep faces the + /// target. + /// + public float GetDesiredHeading(uint command, bool movingAway) + { + if (command == MotionCommand.RunForward || command == MotionCommand.WalkForward) + { + if (!movingAway) return 0f; + } + else + { + if (command != MotionCommand.WalkBackward) return 0f; + if (movingAway) return 0f; + } + return 180f; + } + + // ── R4-V1: wire factory (closes M15/wire-exposure groundwork) ───────── + + /// + /// Factory for the retail MovementParameters::UnPackNet 7-dword + /// MoveTo wire form (0x0052ac50, 0x1c bytes, raw 308118-308205 — + /// r4-moveto-decomp.md §2g): bitfield, distance_to_object, + /// min_distance, fail_distance, speed, walk_run_threshhold, + /// desired_heading. Used by MoveToObject (type 6) and + /// MoveToPosition (type 7) wire payloads — the SAME field order + /// UpdateMotion.TryParseMoveToPayload already reads + /// (UpdateMotion.cs:328-341). The bitfield fully OVERWRITES every named + /// flag (UnPackNet does not merge with ctor defaults — every bit not + /// present in resolves to false); the wire + /// bitfield carries can_charge (0x10), the walk-vs-run answer + /// consumed by (cross-ref + /// feedback_autowalk_cancharge_bit). + /// + public static MovementParameters FromWire( + uint bitfield, + float distanceToObject, + float minDistance, + float failDistance, + float speed, + float walkRunThreshhold, + float desiredHeading) + { + var p = new MovementParameters(); + ApplyBitfield(p, bitfield); + p.DistanceToObject = distanceToObject; + p.MinDistance = minDistance; + p.FailDistance = failDistance; + p.Speed = speed; + p.WalkRunThreshhold = walkRunThreshhold; + p.DesiredHeading = desiredHeading; + return p; + } + + /// + /// Factory for the retail MovementParameters::UnPackNet 3-dword + /// TurnTo wire form (0xc bytes, r4-moveto-decomp.md §2g): bitfield, + /// speed, desired_heading. Used by TurnToObject (type 8) and + /// TurnToHeading (type 9) wire payloads. Distance-related scalars + /// (DistanceToObject/MinDistance/FailDistance/ + /// WalkRunThreshhold) are NOT on this wire form and keep the + /// ctor defaults — retail's UnPackNet + /// for this form only ever writes the three fields named here. + /// + public static MovementParameters FromWireTurnTo( + uint bitfield, + float speed, + float desiredHeading) + { + var p = new MovementParameters(); + ApplyBitfield(p, bitfield); + p.Speed = speed; + p.DesiredHeading = desiredHeading; + return p; + } + + /// + /// Decode the A4-pinned bitfield masks onto the named bool properties. + /// Shared by / — the + /// wire bitfield always fully overwrites (retail's UnPackNet assigns + /// the raw dword straight into this->bitfield, no merge). + /// + private static void ApplyBitfield(MovementParameters p, uint bitfield) + { + p.CanWalk = (bitfield & 0x1u) != 0; + p.CanRun = (bitfield & 0x2u) != 0; + p.CanSidestep = (bitfield & 0x4u) != 0; + p.CanWalkBackwards = (bitfield & 0x8u) != 0; + p.CanCharge = (bitfield & 0x10u) != 0; + p.FailWalk = (bitfield & 0x20u) != 0; + p.UseFinalHeading = (bitfield & 0x40u) != 0; + p.Sticky = (bitfield & 0x80u) != 0; + p.MoveAway = (bitfield & 0x100u) != 0; + p.MoveTowards = (bitfield & 0x200u) != 0; + p.UseSpheres = (bitfield & 0x400u) != 0; + p.SetHoldKey = (bitfield & 0x800u) != 0; + p.Autonomous = (bitfield & 0x1000u) != 0; + p.ModifyRawState = (bitfield & 0x2000u) != 0; + p.ModifyInterpretedState = (bitfield & 0x4000u) != 0; + p.CancelMoveTo = (bitfield & 0x8000u) != 0; + p.StopCompletelyFlag = (bitfield & 0x10000u) != 0; + p.DisableJumpDuringLink = (bitfield & 0x20000u) != 0; + } +} diff --git a/src/AcDream.Core/Physics/Motion/PositionManager.cs b/src/AcDream.Core/Physics/Motion/PositionManager.cs new file mode 100644 index 00000000..0ed02f04 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/PositionManager.cs @@ -0,0 +1,102 @@ +using System; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R5 — port of retail's PositionManager facade (acclient.h:30952, +/// struct #3468; decomp 0x00555160-0x005553d0, +/// r5-positionmanager-sticky-decomp.md). A thin fan-out over three +/// sub-managers: Interpolation, Sticky, Constraint. Owned 1:1 by the entity's +/// (retail CPhysicsObj::position_manager, +/// lazily created). +/// +/// Interpolation note: retail's adjust_offset chains +/// Interpolation → Sticky → Constraint. acdream's interpolation stage lives in +/// (the R5-renamed remote-motion combiner, +/// formerly the misnamed Physics.PositionManager) and is NOT chained +/// here in V1 — this facade owns only the two R5 targets (Sticky retires TS-39; +/// Constraint is structural — see ). Folding the +/// combiner in as the interp stage is a wiring-slice cleanup. +/// +public sealed class PositionManager +{ + private readonly IPhysicsObjHost _host; + + // Lazily created (retail: sticky on first StickTo, constraint on first + // ConstrainTo — 0x00555230 / 0x00555280). + private StickyManager? _sticky; + private ConstraintManager? _constraint; + + public PositionManager(IPhysicsObjHost host) + => _host = host ?? throw new ArgumentNullException(nameof(host)); + + /// Exposed for wiring/tests — the lazily-created sub-managers + /// (null until first use). + public StickyManager? Sticky => _sticky; + public ConstraintManager? Constraint => _constraint; + + /// Retail PositionManager::StickTo (0x00555230) — lazily + /// create the and begin following + /// . + public void StickTo(uint objectId, float radius, float height) + { + _sticky ??= new StickyManager(_host); + _sticky.StickTo(objectId, radius, height); + } + + /// Retail PositionManager::UnStick (0x005551e0) — forward + /// to the sticky sub-manager if it exists. + public void UnStick() => _sticky?.UnStick(); + + /// Retail PositionManager::GetStickyObjectID + /// (0x00555270). + public uint GetStickyObjectId() => _sticky?.TargetId ?? 0u; + + /// Retail PositionManager::ConstrainTo (0x00555280) — + /// lazily create the and arm the leash. + /// (Unused in acdream — no arming call site; see + /// .) + public void ConstrainTo(Position anchor, float startDistance, float maxDistance) + { + _constraint ??= new ConstraintManager(_host); + _constraint.ConstrainTo(anchor, startDistance, maxDistance); + } + + /// Retail PositionManager::UnConstrain + /// (0x005552b0). + public void UnConstrain() => _constraint?.UnConstrain(); + + /// Retail PositionManager::IsFullyConstrained + /// (0x005552c0) — false when no constraint sub-manager exists. + public bool IsFullyConstrained() => _constraint?.IsFullyConstrained() ?? false; + + /// + /// Retail PositionManager::HandleUpdateTarget (0x005553d0) — only + /// the sticky sub-manager cares about live target positions (interpolation + /// and constraint don't). Fanned out from + /// CPhysicsObj::HandleUpdateTarget. + /// + public void HandleUpdateTarget(TargetInfo info) => _sticky?.HandleUpdateTarget(info); + + /// + /// Retail PositionManager::adjust_offset (0x00555190) — chains the + /// sub-managers' contributions into the SAME + /// accumulator, in retail order. Retail runs Interpolation → Sticky → + /// Constraint; acdream's interpolation stays in the separate remote-motion + /// combiner (see class note), so this chains Sticky → Constraint only. + /// Constraint is LAST because it clamps the already-composed displacement. + /// + public void AdjustOffset(MotionDeltaFrame offset, double quantum) + { + _sticky?.AdjustOffset(offset, quantum); + _constraint?.AdjustOffset(offset, quantum); + } + + /// + /// Retail PositionManager::UseTime (0x00555160) — per-tick pump. + /// Retail order Interpolation → Constraint → Sticky; acdream runs the two + /// owned managers (constraint's UseTime is a retail no-op, so effectively + /// just the sticky 1 s watchdog). + /// + public void UseTime() => _sticky?.UseTime(); +} diff --git a/src/AcDream.Core/Physics/Motion/StickyManager.cs b/src/AcDream.Core/Physics/Motion/StickyManager.cs new file mode 100644 index 00000000..1646ce97 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/StickyManager.cs @@ -0,0 +1,276 @@ +using System; +using System.Numerics; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R5 — verbatim port of retail's StickyManager (acclient.h:31518, +/// struct #3466; decomp block 0x00555400-0x00555866, +/// r5-positionmanager-sticky-decomp.md). Makes the owning object +/// FOLLOW a target object at a bounded gap: each tick +/// steers the mover horizontally toward the +/// target's live (or last-known) position and turns it to face the target, +/// speed- and turn-rate-limited. A 1-second watchdog () +/// drops the stick if no target-position update arrives. +/// +/// Owned by (lazily created on first +/// ). Establishes its target-tracking +/// subscription through the owning 's +/// set_target (→ ); receives the target's +/// live position back through , fanned out from +/// CPhysicsObj::HandleUpdateTarget → . +/// +/// The dense x87 back half of retail's adjust_offset is decoded +/// against ACE's StickyManager.cs (the two constants +/// =0.3 and =1.0 are ACE's, +/// verified against the retail mush structure — see the port-plan §2a). +/// +public sealed class StickyManager +{ + /// Retail StickyRadius const (ACE: 0.3f) — the desired + /// follow gap subtracted from the cylinder distance. + public const float StickyRadius = 0.3f; + + /// Retail StickyTime const (ACE: 1.0f) — the one-shot grace + /// window: if no target update refreshes the stick within this many + /// seconds of , drops it. + public const float StickyTime = 1.0f; + + /// Retail get_max_speed multiplier for the follow speed + /// (ACE: ×5 — the follower catches up faster than a normal walk/run). + private const float FollowSpeedFactor = 5.0f; + + /// Retail fallback follow speed when no motion interpreter exists + /// (ACE: 15.0f, i.e. the MAX_VELOCITY constant the mush loads). + private const float FallbackFollowSpeed = 15.0f; + + private readonly IPhysicsObjHost _host; + + /// +0x00 retail target_id — the object we are stuck to + /// (0 = not stuck). + public uint TargetId { get; private set; } + + /// +0x04 retail target_radius — the target's cylinder + /// radius (from CPartArray::GetRadius of the stuck-to object). + public float TargetRadius { get; private set; } + + /// +0x08 retail target_position — last-known target + /// position (from ), used when the live + /// GetObjectA resolve fails. + public Position TargetPosition { get; private set; } + + /// +0x54 retail initialized — false until the first + /// Ok target update arrives (gates and + /// the timeout). + public bool Initialized { get; private set; } + + /// +0x58 retail sticky_timeout_time — the wall-clock + /// deadline set once at time (now + 1 s). + public double StickyTimeoutTime { get; private set; } + + public StickyManager(IPhysicsObjHost host) + => _host = host ?? throw new ArgumentNullException(nameof(host)); + + /// + /// Retail StickyManager::UnStick (0x00555400). No-op if not stuck; + /// otherwise the standard 4-step teardown: clear + + /// , tell the host to clear_target (drop + /// the voyeur subscription), then interrupt_current_movement. + /// + public void UnStick() + { + if (TargetId == 0) + return; + + if (PhysicsDiagnostics.ProbeStickyEnabled) + Console.WriteLine(FormattableString.Invariant( + $"[sticky] guid=0x{_host.Id:X8} UNSTICK target=0x{TargetId:X8}")); + + TargetId = 0; + Initialized = false; + _host.ClearTarget(); + _host.InterruptCurrentMovement(); + } + + /// + /// Retail StickyManager::StickTo (0x00555710). Begin following + /// . If already stuck, tears the old stick down + /// first (same 4-step sequence as ). Sets the 1 s + /// timeout deadline and registers as a voyeur of the target via the host's + /// set_target(context=0, objectId, radius=0.5, quantum=0.5) — the + /// live target position then arrives asynchronously through + /// . + /// + /// Retail arg2 — target object id. + /// Retail arg3 — the target's cylinder + /// radius (feeds 's distance math). + /// Retail arg4 — accepted for call-shape + /// parity but UNUSED in the body (matches retail + ACE; the height feeds + /// the caller-side geometry only). + public void StickTo(uint objectId, float targetRadius, float targetHeight) + { + _ = targetHeight; // retail/ACE: arg4 is read nowhere in this body. + + if (TargetId != 0) + { + // Inlined 4-step teardown of the previous stick (retail 0x00555716). + TargetId = 0; + Initialized = false; + _host.ClearTarget(); + _host.InterruptCurrentMovement(); + } + + TargetRadius = targetRadius; + TargetId = objectId; + Initialized = false; + StickyTimeoutTime = _host.CurTime + StickyTime; + + if (PhysicsDiagnostics.ProbeStickyEnabled) + Console.WriteLine(FormattableString.Invariant( + $"[sticky] guid=0x{_host.Id:X8} STICK target=0x{objectId:X8} tgtR={targetRadius:F2} ownR={_host.Radius:F2} lease={StickyTime:F1}s")); + + // set_target(context_id=0, objectId, radius=0.5, quantum=0.5). + _host.SetTarget(0, objectId, 0.5f, 0.5); + } + + /// + /// Retail StickyManager::UseTime (0x00555610). The 1 s watchdog: if + /// Timer::cur_time >= sticky_timeout_time, force-unstick (same + /// 4-step teardown). The deadline is set once in and + /// NOT refreshed by (retail + ACE) — a + /// stick survives at most 1 s of wall-clock unless re-issued. + /// + public void UseTime() + { + if (TargetId == 0) + return; + + // Strictly AFTER the deadline (retail 0x00555626 `test ah,0x41` — + // C0|C3 clear = cur_time > timeout; ACE `>` too), not >=. + if (_host.CurTime > StickyTimeoutTime) + { + if (PhysicsDiagnostics.ProbeStickyEnabled) + Console.WriteLine(FormattableString.Invariant( + $"[sticky] guid=0x{_host.Id:X8} LEASE-EXPIRE target=0x{TargetId:X8}")); + + TargetId = 0; + Initialized = false; + _host.ClearTarget(); + _host.InterruptCurrentMovement(); + } + } + + /// + /// Retail StickyManager::HandleUpdateTarget (0x00555780). The + /// target-position callback (fanned out from + /// CPhysicsObj::HandleUpdateTarget → ). + /// Ignores updates whose doesn't match + /// our . On : cache the + /// target position and mark . On any other status + /// (lost/exit/teleport): tear the stick down (4-step). + /// + public void HandleUpdateTarget(TargetInfo info) + { + if (info.ObjectId != TargetId) + return; + + if (info.Status == TargetStatus.Ok) + { + Initialized = true; + TargetPosition = info.TargetPosition; + return; + } + + if (TargetId != 0) + { + if (PhysicsDiagnostics.ProbeStickyEnabled) + Console.WriteLine(FormattableString.Invariant( + $"[sticky] guid=0x{_host.Id:X8} TARGET-{info.Status} teardown target=0x{TargetId:X8}")); + + TargetId = 0; + Initialized = false; + _host.ClearTarget(); + _host.InterruptCurrentMovement(); + } + } + + /// + /// Retail StickyManager::adjust_offset (0x00555430). Writes this + /// tick's follow steering into the shared + /// accumulator: a speed-clamped horizontal position delta toward the + /// target plus a bounded turn to face it. No-op unless stuck AND + /// initialized. See port-plan §2a for the x87-mush decode. + /// + /// The per-tick delta frame + /// ('s shared accumulator). + /// Elapsed time this tick, seconds. + public void AdjustOffset(MotionDeltaFrame offset, double quantum) + { + if (TargetId == 0 || !Initialized) + return; + + var self = _host.Position; + var target = _host.GetObjectA(TargetId); + var targetPos = target != null ? target.Position : TargetPosition; + + // offset = local-frame, Z-flattened vector from self to target. + Vector3 worldOffset = targetPos.Frame.Origin - self.Frame.Origin; // Position::get_offset + Vector3 local = MoveToMath.GlobalToLocalVec(self.Frame.Orientation, worldOffset); + local.Z = 0f; + offset.Origin = local; + + // Signed horizontal cylinder distance past the 0.3 m stick gap. + float dist = MoveToMath.CylinderDistanceNoZ( + _host.Radius, self.Frame.Origin, TargetRadius, targetPos.Frame.Origin) - StickyRadius; + + if (MoveToMath.NormalizeCheckSmall(ref offset.Origin)) + offset.Origin = Vector3.Zero; + + // Follow speed = 5× own max locomotion speed (catch up), fallback 15. + float speed = 0f; + float? maxSpeed = _host.MinterpMaxSpeed; + if (maxSpeed.HasValue) + speed = maxSpeed.Value * FollowSpeedFactor; + if (speed < MoveToMath.Epsilon) + speed = FallbackFollowSpeed; + + // Don't overshoot: clamp the per-tick step to the remaining (signed) + // distance — a negative dist inverts the direction (back off). + // + // DEEP-OVERLAP SIGN PIN (#171 gate-3, register AP row): ACE's literal + // line is only `if (delta >= |dist|) delta = dist;` — when the + // overlap is DEEPER than one tick's step, delta keeps its positive + // sign and steers TOWARD the target center, a runaway whose + // equilibrium is centers-coincident (gate-3 probe: 1661 deep-overlap + // ticks, all inward, monsters converged to centerDist≈0 — the + // "monster inside the player" report; retail side-by-side shows + // separation). ACE servers essentially never reach that branch + // (quantum ≥1/30 × speed ≈31 → threshold ~1 m); at render-rate + // quanta the threshold is ~0.13 m and pack jostle trips it + // constantly. The BN mush (0x00555554-0x00555597) is unreadable on + // exactly this compare; the sign-correct clamp below is the minimal + // interpretation consistent with the mush structure AND observed + // retail — identical to ACE everywhere except deep-overlap, where it + // backs off rate-limited instead of creeping inward. + float delta = speed * (float)quantum; + if (delta >= MathF.Abs(dist)) + delta = dist; + else if (dist < 0f) + delta = -delta; + offset.Origin *= delta; + + // Bounded turn to face the target (relative heading this tick). + float curHeading = MoveToMath.GetHeading(self.Frame.Orientation); + float targetHeading = MoveToMath.PositionHeading(self.Frame.Origin, targetPos.Frame.Origin); + float heading = targetHeading - curHeading; + if (MathF.Abs(heading) < MoveToMath.Epsilon) + heading = 0f; + if (heading < -MoveToMath.Epsilon) + heading += 360f; + offset.SetHeading(heading); + + if (PhysicsDiagnostics.ProbeStickyEnabled) + Console.WriteLine(FormattableString.Invariant( + $"[sticky] guid=0x{_host.Id:X8} ADJ dist={dist:F3} delta={delta:F3} speed={speed:F1} hdgDelta={heading:F1} live={(target is not null ? 1 : 0)}")); + } +} diff --git a/src/AcDream.Core/Physics/Motion/TargetManager.cs b/src/AcDream.Core/Physics/Motion/TargetManager.cs new file mode 100644 index 00000000..1567f979 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/TargetManager.cs @@ -0,0 +1,300 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Numerics; + +namespace AcDream.Core.Physics.Motion; + +/// +/// R5 — port of retail's TargetManager (acclient.h:31024, struct #3484; +/// decomp 0x0051a370-0x0051ad90, r5-targetmanager-decomp.md). A +/// peer-to-peer voyeur subscription system with two roles per object: +/// +/// +/// Watcher (): +/// registers this object as a voyeur ON a target; the target's per-tick +/// pushes position updates back here via +/// , which fans them to the owning host's +/// MoveToManager + PositionManager (sticky) through +/// . +/// Watched (): other objects' +/// subscribe to THIS object; each tick +/// → sends a +/// dead-reckoned update to any subscriber the object has drifted past the +/// subscriber's radius from. +/// +/// +/// This REPLACES the AP-79 minimal TargetTracker adapter (GameWindow +/// polling the entity table). It is a faithful superset: the same +/// move-to tracking (distance > radius → HandleUpdateTarget(Ok)) plus the +/// correct sticky, 10 s timeout, and exit/teleport event handling. +/// +/// Owned 1:1 by an (retail +/// CPhysicsObj::target_manager, lazily created on first +/// set_target/add_voyeur). The two throttle constants +/// (=0.5, =10) are +/// ACE's, verified against the retail x87 mush — port-plan §2d. +/// +public sealed class TargetManager +{ + /// Retail HandleTargetting per-tick throttle (ACE: 0.5s) — + /// the voyeur sweep runs at most this often. + public const double ThrottleSeconds = 0.5; + + /// Retail target-info staleness timeout (ACE: 10.0s) — an + /// Undefined-status target with no update for this long is marked + /// TimedOut. + public const double StalenessSeconds = 10.0; + + private readonly IPhysicsObjHost _host; + + private TargetInfo? _targetInfo; // retail target_info (watcher role) + private Dictionary? _voyeurTable; // retail voyeur_table (watched role) + private double _lastUpdateTime; // retail last_update_time (throttle base) + + public TargetManager(IPhysicsObjHost host) + => _host = host ?? throw new ArgumentNullException(nameof(host)); + + /// The current watched-target info, or null when tracking + /// nothing. + public TargetInfo? TargetInfo => _targetInfo; + + /// The subscriber table (null until the first + /// ). + public IReadOnlyDictionary? VoyeurTable => _voyeurTable; + + /// Retail get_target_quantum — the current target's + /// quantum, 0 when tracking nothing. + public double GetTargetQuantum() => _targetInfo?.Quantum ?? 0.0; + + // ── watcher role ─────────────────────────────────────────────────────── + + /// + /// Retail TargetManager::SetTarget (0x0051ac30). Tear down any + /// existing target, then: if is 0, synthesize a + /// TimedOut clear-update to the host and leave + /// null; otherwise create a fresh (status + /// Undefined) and subscribe as a voyeur ON the target + /// (target.add_voyeur(self.id, radius, quantum)). The target's live + /// position arrives asynchronously via . + /// + public void SetTarget(uint contextId, uint objectId, float radius, double quantum) + { + ClearTarget(); + + if (objectId == 0) + { + // Clear/cancel: report a TimedOut update carrying the context, + // leave _targetInfo null. (Retail var_10_1 = 6 = TimedOut.) + var cleared = new TargetInfo( + ObjectId: 0, Status: TargetStatus.TimedOut, + TargetPosition: default, InterpolatedPosition: default, + ContextId: contextId); + _host.HandleUpdateTarget(cleared); + return; + } + + _targetInfo = new TargetInfo( + ObjectId: objectId, Status: TargetStatus.Undefined, + TargetPosition: default, InterpolatedPosition: default, + ContextId: contextId, Radius: radius, Quantum: quantum, + LastUpdateTime: _host.CurTime); + + var target = _host.GetObjectA(objectId); + target?.AddVoyeur(_host.Id, radius, quantum); + } + + /// + /// Retail TargetManager::SetTargetQuantum (0x0051a4a0). Update the + /// current target's resend interval and re-register the voyeur subscription + /// on the target with the new quantum. + /// + public void SetTargetQuantum(double quantum) + { + if (_targetInfo is not { } ti) + return; + + _targetInfo = ti with { Quantum = quantum }; + var target = _host.GetObjectA(ti.ObjectId); + target?.AddVoyeur(_host.Id, ti.Radius, quantum); + } + + /// + /// Retail TargetManager::ClearTarget (0x0051a7e0). Unsubscribe from + /// the current target's voyeur table and drop . + /// + public void ClearTarget() + { + if (_targetInfo is not { } ti) + return; + + var target = _host.GetObjectA(ti.ObjectId); + target?.RemoveVoyeur(_host.Id); + _targetInfo = null; + } + + /// + /// Retail TargetManager::ReceiveUpdate (0x0051a930). The inbound + /// handler when a target we watch sends us its position (via + /// SendVoyeurUpdate → receive_target_update). Ignores updates + /// for anything but our current target. Copies the payload, stamps receipt + /// time, recomputes the self→target interpolated heading (falls back to +Z + /// when degenerate), fans the snapshot to the host, and drops the + /// subscription on an ExitWorld status. + /// + public void ReceiveUpdate(TargetInfo update) + { + if (_targetInfo is not { } ti || ti.ObjectId != update.ObjectId) + return; + + // Copy radius/quantum/positions/velocity/status from the wire; keep our + // object_id; stamp receipt time. + Vector3 interpHeading = update.InterpolatedPosition.Frame.Origin + - _host.Position.Frame.Origin; + if (MoveToMath.NormalizeCheckSmall(ref interpHeading)) + interpHeading = Vector3.UnitZ; + + var updated = ti with + { + Radius = update.Radius, + Quantum = update.Quantum, + TargetPosition = update.TargetPosition, + InterpolatedPosition = update.InterpolatedPosition, + Velocity = update.Velocity, + Status = update.Status, + InterpolatedHeading = interpHeading, + LastUpdateTime = _host.CurTime, + }; + _targetInfo = updated; + + _host.HandleUpdateTarget(updated); + + if (update.Status == TargetStatus.ExitWorld) + ClearTarget(); + } + + // ── watched role ─────────────────────────────────────────────────────── + + /// + /// Retail TargetManager::AddVoyeur (0x0051a830). A subscriber + /// registers to watch this object. If already subscribed, updates its + /// radius/quantum in place (no immediate send); otherwise creates the entry + /// and pushes an immediate initial snapshot (Ok). + /// + public void AddVoyeur(uint watcherId, float radius, double quantum) + { + _voyeurTable ??= new Dictionary(); + + if (_voyeurTable.TryGetValue(watcherId, out var existing)) + { + existing.Radius = radius; + existing.Quantum = quantum; + return; + } + + var voyeur = new TargettedVoyeurInfo(watcherId, radius, quantum); + _voyeurTable[watcherId] = voyeur; + SendVoyeurUpdate(voyeur, _host.Position, TargetStatus.Ok); + } + + /// Retail TargetManager::RemoveVoyeur (0x0051ad90). + public bool RemoveVoyeur(uint watcherId) + => _voyeurTable?.Remove(watcherId) ?? false; + + /// + /// Retail TargetManager::HandleTargetting (0x0051aa90). THE per-tick + /// driver (no separate UseTime): self-throttled to + /// , promotes a stale target to TimedOut after + /// , then sweeps every subscriber through + /// . + /// + public void HandleTargetting() + { + if (_host.PhysicsTimerTime - _lastUpdateTime < ThrottleSeconds) + return; + + if (_targetInfo is { } ti) + { + if (ti.Status == TargetStatus.Undefined + && ti.LastUpdateTime + StalenessSeconds < _host.CurTime) + { + var timedOut = ti with { Status = TargetStatus.TimedOut }; + _targetInfo = timedOut; + _host.HandleUpdateTarget(timedOut); + } + } + + if (_voyeurTable != null) + { + foreach (var voyeur in _voyeurTable.Values.ToList()) + CheckAndUpdateVoyeur(voyeur); + } + + _lastUpdateTime = _host.PhysicsTimerTime; + } + + /// + /// Retail TargetManager::CheckAndUpdateVoyeur (0x0051a650). Push an + /// update to only if this object's dead-reckoned + /// position has drifted more than the voyeur's radius since the last send. + /// + public void CheckAndUpdateVoyeur(TargettedVoyeurInfo voyeur) + { + Position newPos = GetInterpolatedPosition(voyeur.Quantum); + float drift = Vector3.Distance( + newPos.Frame.Origin, voyeur.LastSentPosition.Frame.Origin); + if (drift > voyeur.Radius) + SendVoyeurUpdate(voyeur, newPos, TargetStatus.Ok); + } + + /// + /// Retail TargetManager::GetInterpolatedPosition (0x0051a5e0). + /// Dead-reckon this object's position forward by + /// seconds using its current velocity. + /// + public Position GetInterpolatedPosition(double quantum) + { + var pos = _host.Position; + Vector3 origin = pos.Frame.Origin + _host.Velocity * (float)quantum; + return new Position(pos.ObjCellId, origin, pos.Frame.Orientation); + } + + /// + /// Retail TargetManager::SendVoyeurUpdate (0x0051a4f0). Record the + /// sent position on the voyeur, build a carrying + /// this object's CURRENT authoritative position + the extrapolated + /// + velocity + status, and deliver it to the + /// subscriber's (via its host). + /// + public void SendVoyeurUpdate(TargettedVoyeurInfo voyeur, Position pos, TargetStatus status) + { + voyeur.LastSentPosition = pos; + + var info = new TargetInfo( + ObjectId: _host.Id, + Status: status, + TargetPosition: _host.Position, // current authoritative + InterpolatedPosition: pos, // the extrapolated position + ContextId: 0, + Radius: voyeur.Radius, + Quantum: voyeur.Quantum, + Velocity: _host.Velocity); + + var voyeurObj = _host.GetObjectA(voyeur.ObjectId); + voyeurObj?.ReceiveTargetUpdate(info); + } + + /// + /// Retail TargetManager::NotifyVoyeurOfEvent (0x0051a6f0). Broadcast + /// a discrete status event (e.g. ExitWorld, Teleported) to every subscriber + /// with this object's CURRENT position — no distance gate. + /// + public void NotifyVoyeurOfEvent(TargetStatus status) + { + if (_voyeurTable == null) + return; + + foreach (var voyeur in _voyeurTable.Values.ToList()) + SendVoyeurUpdate(voyeur, _host.Position, status); + } +} diff --git a/src/AcDream.Core/Physics/Motion/TargettedVoyeurInfo.cs b/src/AcDream.Core/Physics/Motion/TargettedVoyeurInfo.cs new file mode 100644 index 00000000..10631681 --- /dev/null +++ b/src/AcDream.Core/Physics/Motion/TargettedVoyeurInfo.cs @@ -0,0 +1,36 @@ +namespace AcDream.Core.Physics.Motion; + +/// +/// R5 — port of retail's TargettedVoyeurInfo (acclient.h:52807, +/// struct #5801). One entry in a 's voyeur table: +/// a subscriber watching THIS object, the send-on-move +/// threshold it registered, its dead-reckoning , and the +/// already delivered to it (the delta baseline +/// CheckAndUpdateVoyeur compares against). Mutable class (retail heap +/// record updated in place by AddVoyeur/SendVoyeurUpdate). +/// +public sealed class TargettedVoyeurInfo +{ + /// +0x00 retail object_id — the subscriber's guid. + public uint ObjectId { get; } + + /// +0x04 retail quantum — the subscriber's dead-reckoning + /// lookahead horizon (seconds). + public double Quantum { get; set; } + + /// +0x10 retail radius — the send-on-move threshold: an + /// update is pushed only when the tracked object drifts more than this from + /// . + public float Radius { get; set; } + + /// +0x14 retail last_sent_position — the position last + /// delivered to this subscriber (updated by SendVoyeurUpdate). + public Position LastSentPosition { get; set; } + + public TargettedVoyeurInfo(uint objectId, float radius, double quantum) + { + ObjectId = objectId; + Radius = radius; + Quantum = quantum; + } +} diff --git a/src/AcDream.Core/Physics/MotionCommandResolver.cs b/src/AcDream.Core/Physics/MotionCommandResolver.cs index 016d8e16..ce16c4b9 100644 --- a/src/AcDream.Core/Physics/MotionCommandResolver.cs +++ b/src/AcDream.Core/Physics/MotionCommandResolver.cs @@ -1,12 +1,8 @@ -using System; -using System.Collections.Generic; -using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand; - namespace AcDream.Core.Physics; /// -/// Reconstructs the 32-bit retail value from -/// a 16-bit wire value broadcast in InterpretedMotionState.Commands[]. +/// Reconstructs the 32-bit retail MotionCommand value from a 16-bit wire +/// value broadcast in InterpretedMotionState.Commands[]. /// /// /// The server serializes MotionCommands as u16 (ACE @@ -19,11 +15,19 @@ namespace AcDream.Core.Physics; /// /// /// -/// This is implemented as an eager lookup table built from all values of -/// via reflection. If the wire value matches -/// more than one enum value (different class bits), we prefer the -/// lowest-class-numbered variant that has a non-zero class byte — roughly -/// matching retail priority (Action < Modifier < SubState < Style). +/// As of the L.1b command-catalog slice, this static facade delegates to a +/// single shared instance — the +/// runtime-default catalog built from the DatReaderWriter +/// MotionCommand enum (matches ACE + the local DATs). All ~10 +/// existing runtime callers (AnimationCommandRouter, +/// CombatAnimationPlanner, 8x GameWindow) are unaffected by +/// this refactor — the public signature and behavior for the ACE/runtime +/// path is unchanged. A second catalog, +/// , is available for +/// conformance/reference work against the Sept 2013 EoR decomp's own +/// (differently-numbered) command table; callers that need that catalog +/// must construct it directly via the +/// seam — this facade only ever returns ACE/runtime values. /// /// /// @@ -42,66 +46,26 @@ namespace AcDream.Core.Physics; /// docs/research/deepdives/r03-motion-animation.md §3 — complete /// command catalogue. /// +/// +/// docs/research/2026-06-26-ace-vs-2013-motion-command-gap.md — +/// the ACE-vs-2013 catalog divergence that motivated the dual-catalog +/// seam (the shift begins at SnowAngelState, 0x43000115 -> +/// 0x43000118, not at AllegianceHometownRecall). +/// /// /// /// public static class MotionCommandResolver { - // Lookup table built eagerly at type-init. Sparse: only values that - // appear in the DRW enum (which came from the generated protocol XML) - // are present. ~450 entries typical. - private static readonly Dictionary s_lookup = BuildLookup(); + private static readonly AceModernCommandCatalog s_aceModern = new(); /// /// Given a 16-bit wire value, return the full 32-bit MotionCommand - /// (class byte restored). Returns 0 if no matching enum value exists. + /// (class byte restored) per the ACE/runtime catalog. Returns 0 if no + /// matching value exists. /// public static uint ReconstructFullCommand(ushort wireCommand) { - if (wireCommand == 0) return 0u; - s_lookup.TryGetValue(wireCommand, out var full); - return full; - } - - private static Dictionary BuildLookup() - { - var result = new Dictionary(512); - var values = Enum.GetValues(typeof(DRWMotionCommand)); - foreach (DRWMotionCommand v in values) - { - uint full = (uint)v; - ushort lo = (ushort)(full & 0xFFFFu); - if (lo == 0) continue; // Invalid / unmappable - - // If a value with this low-16-bit already exists, keep the one - // with the lower class byte (Action=0x10 beats SubState=0x41 - // beats Style=0x80). This matches retail: the server tends to - // emit Actions and ChatEmotes far more often than Styles, so - // the Action-class reconstruction is the common case. - if (!result.TryGetValue(lo, out var existing) - || (full >> 24) < (existing >> 24)) - { - result[lo] = full; - } - } - - ApplyNamedRetailOverrides(result); - return result; - } - - private static void ApplyNamedRetailOverrides(Dictionary result) - { - // The generated DRW enum is shifted by three entries starting at - // AllegianceHometownRecall. The named Sept 2013 retail command_ids - // table is authoritative here: - // named-retail/acclient_2013_pseudo_c.txt lines 1017626-1017658 - // and command-name table lines 1068272-1068313. - // - // These values cover recall, offhand, attack 4-6, and fast/slow punch - // actions. Without the override, wire command 0x0170 reconstructs to - // IssueSlashCommand instead of OffhandSlashHigh, so offhand swing - // animations route as UI commands and never play. - for (ushort lo = 0x016E; lo <= 0x0197; lo++) - result[lo] = 0x10000000u | lo; + return s_aceModern.ReconstructFullCommand(wireCommand); } } diff --git a/src/AcDream.Core/Physics/MotionInterpreter.cs b/src/AcDream.Core/Physics/MotionInterpreter.cs index ec1006e1..d5e1dd73 100644 --- a/src/AcDream.Core/Physics/MotionInterpreter.cs +++ b/src/AcDream.Core/Physics/MotionInterpreter.cs @@ -1,5 +1,7 @@ using System; +using System.Collections.Generic; using System.Numerics; +using AcDream.Core.Physics.Motion; namespace AcDream.Core.Physics; @@ -13,11 +15,15 @@ namespace AcDream.Core.Physics; // FUN_00528960 get_state_velocity — compute world-space velocity for current motion // FUN_00529210 apply_current_movement — apply interpreted motion as velocity // FUN_00529390 jump — initiate jump: validate, record extent, leave ground -// FUN_005286b0 get_jump_v_z — get vertical jump velocity -// FUN_00528cd0 get_leave_ground_velocity — compose full 3D launch vector -// FUN_00528ec0 jump_is_allowed — can we jump? +// FUN_005286b0 GetJumpVZ — get vertical jump velocity (R3-W3 rename) +// FUN_00528cd0 GetLeaveGroundVelocity — compose full 3D launch vector (R3-W3 rename) +// FUN_00528ec0 jump_is_allowed — can we jump? (R3-W3: full verbatim chain) // FUN_00528dd0 contact_allows_move — slope angle / contact state check // +// R3-W3 jump-family addresses (docs/research/2026-07-02-r3-motioninterp/): +// 0x00527a50 JumpChargeIsAllowed +// 0x005281c0 ChargeJump — the ONLY place StandingLongJump arms (closes J6) +// // Cross-checked against ACE MotionInterp.cs. // ───────────────────────────────────────────────────────────────────────────── @@ -89,11 +95,31 @@ public static class MotionCommand } /// -/// Movement type passed in PerformMovement's switch statement. -/// Matches the 5-case switch at FUN_00529a90. +/// Movement type passed in PerformMovement's switch statement. Matches +/// retail's MovementTypes::Type (acclient.h:2856, enum #229) in full. +/// +/// +/// R4-V1 widening (closes M11). Values 1-5 dispatch through +/// CMotionInterp (the 5-case switch at FUN_00529a90, unchanged since +/// R1-R3); values 6-9 dispatch through MoveToManager +/// (MovementManager::PerformMovement, r4-moveto-decomp.md §2b: +/// (type - 1) > 8 → 0x47, case 0-4 → CMotionInterp, case 5-8 → +/// MoveToManager). Invalid=0 and values > 9 both fail with +/// (0x47) at the +/// MovementManager level — no consumer wiring changes in this slice +/// (mechanical, additive-only; MoveToManager itself is R4-V2+). +/// /// public enum MovementType { + /// + /// 0 — no movement in progress / uninitialized. R4-V1 addition (M11). + /// MoveToManager::InitializeLocalVariables resets + /// movement_type to this value; MovementManager::PerformMovement + /// rejects it with 0x47 (§2b: (type - 1) > 8 underflows to a + /// huge unsigned value for type 0, which is always > 8). + /// + Invalid = 0, /// case 1 — raw motion command (DoMotion). RawCommand = 1, /// case 2 — interpreted motion command (DoInterpretedMotion). @@ -104,65 +130,190 @@ public enum MovementType StopInterpretedCommand = 4, /// case 5 — stop completely (StopCompletely). StopCompletely = 5, + /// + /// 6 — MoveToObject. R4-V1 addition (M11). Dispatches to + /// MoveToManager::MoveToObject (r4-moveto-decomp.md §3b); uses + /// // + /// /. + /// + MoveToObject = 6, + /// + /// 7 — MoveToPosition. R4-V1 addition (M11). Dispatches to + /// MoveToManager::MoveToPosition (§3c); uses + /// . + /// + MoveToPosition = 7, + /// + /// 8 — TurnToObject. R4-V1 addition (M11). Dispatches to + /// MoveToManager::TurnToObject (§3d); uses + /// /. + /// + TurnToObject = 8, + /// + /// 9 — TurnToHeading. R4-V1 addition (M11). Dispatches to + /// MoveToManager::TurnToHeading (§3e); uses + /// 's DesiredHeading. + /// + TurnToHeading = 9, } /// -/// WeenieError codes returned by CMotionInterp methods. -/// Values are the hex constants used directly in the decompiled C code. +/// WeenieError-shaped codes returned by CMotionInterp methods. Values are +/// the hex constants used directly in the decompiled C code. +/// +/// +/// R3-W1 renumber (closes J16-codes/A10). Prior to this slice, the +/// names were shuffled relative to retail's actual numeric semantics +/// (GeneralMovementFailure was assigned 0x24 and used at the +/// airborne-jump gate, but retail's 0x24 means "not grounded / no contact" +/// and retail's 0x47 is the general-movement-failure code; 0x48 meant +/// "cannot jump while in the air" here, but retail's 0x48 means "jump +/// blocked by the CURRENT MOTION OR POSITION" — a blocklist check +/// (motion_allows_jump), not an airborne check). Renumbered per the +/// definitive, exhaustively-swept table in +/// docs/research/2026-07-02-r3-motioninterp/W0-pins.md §A10 (19 +/// return sites + 1 store site over raw 304908-306277 + 300150-300540). +/// These codes are LOCAL-ONLY — never serialized to the wire — so the +/// renumber is safe (verified: no consumer outside +/// MotionInterpreter.cs pattern-matches on the numeric value). +/// /// public enum WeenieError : uint { /// 0x00 — success. None = 0x00, - /// 0x08 — PhysicsObj is null. + /// + /// 0x08 — no physics_obj. Sites (A10): StopCompletely @305214; + /// DoInterpretedMotion @305579; StopInterpretedMotion @305639; + /// StopMotion @305680; jump @305798; DoMotion @306165. + /// NoPhysicsObject = 0x08, - /// 0x24 — general movement failure. - GeneralMovementFailure = 0x24, - /// 0x47 — cannot jump from this position (motion state blocks it). - YouCantJumpFromThisPosition = 0x47, - /// 0x48 — cannot jump while in the air. - YouCantJumpWhileInTheAir = 0x48, - /// 0x49 — loaded down / weenie blocked the jump. + /// + /// 0x0B — NoMotionInterpreter. R4-V1 addition (M12), per + /// docs/research/2026-07-03-r4-moveto/r4-moveto-decomp.md §12 constants + /// inventory (8, 0xb, 0x36, 0x37, 0x38, 0x3d, 0x47). ACE name; + /// the retail sites that store this code were not individually + /// extracted in the R4 pass (no MoveToManager consumer in this slice — + /// V1 pins the numeric value only). + /// + NoMotionInterpreter = 0x0B, + /// + /// 0x24 — not grounded / no contact. Sites (A10): + /// jump_is_allowed @305570 (gravity-active creature without + /// Contact+OnWalkable; also the physics_obj == null case, which + /// falls out to this same code per the A10 note — NOT 8); + /// DoInterpretedMotion @305622-305623 (action-class motion + /// blocked by contact_allows_move). + /// + NotGrounded = 0x24, + /// + /// 0x3f — Crouch (0x41000012) rejected while in combat stance. Site: + /// DoMotion @306196. + /// + CrouchInCombatStance = 0x3f, + /// + /// 0x40 — Sitting (0x41000013) rejected while in combat stance. Site: + /// DoMotion @306199. + /// + SitInCombatStance = 0x40, + /// + /// 0x41 — Sleeping (0x41000014) rejected while in combat stance. Site: + /// DoMotion @306202. + /// + SleepInCombatStance = 0x41, + /// + /// 0x42 — motion & 0x2000000 (the chat-emote bit) rejected + /// outside NonCombat (0x8000003d). Site: DoMotion @306205. + /// + ChatEmoteOutsideNonCombat = 0x42, + /// + /// 0x36 — ActionCancelled. R4-V1 addition (M12). Site: + /// MoveToManager::PerformMovement (r4-moveto-decomp.md §3a + /// @0052a901) — every new moveto cancels the previous one with this + /// code before dispatching; also CPhysicsObj::interrupt_current_movement + /// → MovementManager::CancelMoveTo(0x36) (§9e — the TS-36 cancel + /// entry). Per §7c, MoveToManager::CancelMoveTo's WeenieError arg + /// is NEVER READ in this build's body — kept for parity/logging only. + /// + ActionCancelled = 0x36, + /// + /// 0x37 — ObjectGone. R4-V1 addition (M12). Site: + /// MoveToManager::HandleUpdateTarget (§6d @307866-307867) — a + /// RETARGET delivery arrives with a non-OK target status (the target + /// object was already being tracked, then went away). + /// + ObjectGone = 0x37, + /// + /// 0x38 — NoObject. R4-V1 addition (M12). Site: + /// MoveToManager::HandleUpdateTarget (§6d @307857-307858) — the + /// FIRST target callback arrives with a non-OK status (the target never + /// resolved in the first place). + /// + NoObject = 0x38, + /// + /// 0x45 — action-queue depth cap: an action-class motion (bit + /// 0x10000000) with GetNumActions() >= 6 pending. Site: + /// DoMotion @306209. + /// + ActionDepthExceeded = 0x45, + /// + /// 0x47 — general movement failure. Sites (A10): + /// jump_is_allowed @305525 (IsFullyConstrained); + /// @305549+305556 (JumpStaminaCost refusal); + /// CMotionInterp::PerformMovement @306227 (dispatch type-1 > 4); + /// MovementManager::PerformMovement @300201 (dispatch type-1 > 8). + /// + GeneralMovementFailure = 0x47, + /// + /// 0x48 — jump BLOCKED by the current motion or position (A1: the + /// motion_allows_jump literal-range blocklist — NOT an airborne + /// check; airborne is 0x24). Sites (A10): + /// motion_allows_jump @304930; jump_charge_is_allowed + /// @304948 (Fallen or Crouch..Sleeping); charge_jump @305459 + /// (same predicate); STORED (not returned) as the queue node's + /// jump_error_code in DoInterpretedMotion @305605 when + /// disable_jump_during_link is set. + /// + YouCantJumpFromThisPosition = 0x48, + /// + /// 0x49 — the weenie's CanJump(jump_extent) virtual refused + /// (e.g. stamina/burden gate). Sites: jump_charge_is_allowed + /// @304941; charge_jump @305454. + /// CantJumpLoadedDown = 0x49, + /// + /// 0x3D — YouChargedTooFar. R4-V1 addition (M12). Site: + /// MoveToManager::HandleMoveToPosition Phase 2 arrival check + /// (r4-moveto-decomp.md §6b) — the fail_distance progress gate + /// exceeded (CheckProgressMade §5b failing for >1s AND the + /// mover overshot fail_distance). NOTE: numerically out of A10's + /// increasing order (0x3D < 0x3F/0x40/0x41/0x42/0x45) because it was + /// not part of the CMotionInterp jump-family sweep this code sits + /// beside — it belongs to the MoveToManager family instead (§7c, §12). + /// + YouChargedTooFar = 0x3D, } // ── Motion state structs ─────────────────────────────────────────────────────── /// -/// Raw (network-derived) motion state for the local player. -/// Struct layout in chunk_00520000 starts at offset +0x14 (struct field +0x20 = -/// ForwardCommand, +0x28 = ForwardSpeed, etc.). -/// -public struct RawMotionState -{ - /// Forward/backward motion command (offset +0x20). - public uint ForwardCommand; - /// Speed scalar for forward motion (offset +0x28). - public float ForwardSpeed; - /// Sidestep command (offset +0x2C). - public uint SideStepCommand; - /// Speed scalar for sidestep (offset +0x34, inferred from ACE). - public float SideStepSpeed; - /// Turn command (offset +0x38). - public uint TurnCommand; - /// Speed scalar for turn (offset +0x40, inferred). - public float TurnSpeed; - - /// Initialize to the idle/ready state (1.0 speed, Ready command). - public static RawMotionState Default() => new() - { - ForwardCommand = MotionCommand.Ready, - ForwardSpeed = 1.0f, - SideStepCommand = 0, - SideStepSpeed = 1.0f, - TurnCommand = 0, - TurnSpeed = 1.0f, - }; -} - -/// -/// Interpreted motion state, derived from the raw state. +/// Interpreted motion state, derived from the raw state (retail +/// InterpretedMotionState, ctor 0x0051e8d0, decomp 293418-293431). /// Struct layout: starts at offset +0x44 (ForwardCommand at +0x4C, ForwardSpeed at +0x50). +/// +/// +/// R3-W1 (closes J2): gains retail's action FIFO +/// (/// +/// /) — previously this was +/// a flat 6-field struct with no action tracking, so +/// DoMotion's GetNumActions() >= 6 depth cap and +/// MotionDone's action-class RemoveAction pop had nothing to +/// operate on. The action list is backed by a private +/// lazily created on first mutation (defensive +/// against a bare default(InterpretedMotionState), which C# structs +/// permit even though every constructor in this file routes through +/// ). +/// /// public struct InterpretedMotionState { @@ -178,6 +329,20 @@ public struct InterpretedMotionState public uint TurnCommand; /// Speed scalar for turn (offset +0x60). public float TurnSpeed; + /// Current style / stance (retail current_style). Adopted from + /// the raw state's style channel; NOT part of retail's + /// InterpretedMotionState::ApplyMotion dispatch itself (that + /// writes this->current_style only via the negative-motion + /// branch — see ). Default NonCombat + /// 0x8000003D. + public uint CurrentStyle; + + private List? _actions; + + /// Action FIFO in retail order (oldest first). Empty (never + /// null) when read — the private field is lazily created. + public readonly IReadOnlyList Actions + => (IReadOnlyList?)_actions ?? Array.Empty(); /// Initialize to the idle/ready state. public static InterpretedMotionState Default() => new() @@ -188,18 +353,180 @@ public struct InterpretedMotionState SideStepSpeed = 1.0f, TurnCommand = 0, TurnSpeed = 1.0f, + CurrentStyle = 0x8000003Du, }; + + /// + /// InterpretedMotionState::AddAction (0x0051e9e0, decomp + /// 293500-293527): unconditional tail-append of + /// {motion, speed, action_stamp, autonomous}. Identical shape to + /// — retail duplicates the + /// LListData append logic per state type rather than sharing it. + /// + public void AddAction(uint motion, float speed, uint actionStamp, bool autonomous) + { + _actions ??= new List(); + _actions.Add(new RawMotionAction( + Command: (ushort)motion, + Stamp: (ushort)actionStamp, + Autonomous: autonomous, + Speed: speed)); + } + + /// + /// InterpretedMotionState::RemoveAction (0x0051ead0, decomp + /// 293568-293586): pop the FIFO head unconditionally, returning its + /// motion field (0 when empty). + /// + public uint RemoveAction() + { + if (_actions is null || _actions.Count == 0) + return 0; + var head = _actions[0]; + _actions.RemoveAt(0); + return head.Command; + } + + /// + /// InterpretedMotionState::GetNumActions (0x0051eb00, decomp + /// 293590-293603): count the FIFO by walking it (retail has no O(1) + /// count field on the LList). + /// + public readonly uint GetNumActions() => (uint)(_actions?.Count ?? 0); + + /// + /// InterpretedMotionState::ApplyMotion (0x0051ea40, decomp + /// 293531-293564). Verbatim dispatch, quoted from the raw named decomp: + /// + /// if (arg2 == 0x6500000d) { turn_command = arg2; turn_speed = params.speed; return; } + /// if (arg2 == 0x6500000f) { sidestep_command = arg2; sidestep_speed = params.speed; return; } + /// if ((arg2 & 0x40000000) != 0) { forward_command = arg2; forward_speed = params.speed; return; } + /// if (arg2 < 0) { forward_command = 0x41000003; current_style = arg2; return; } + /// if ((arg2 & 0x10000000) != 0) + /// AddAction(arg2, params.speed, params.action_stamp, (params.bitfield>>0xc)&1); + /// + /// Note only TurnRight (0x6500000d) and SideStepRight (0x6500000f) are + /// tested here — unlike , the + /// LEFT variants (TurnLeft/SideStepLeft) are NOT separately cased; + /// retail's adjust_motion normalizes Left→Right upstream before + /// this ever runs, so this asymmetry is verbatim, not a gap. + /// + /// Retail arg2 — the motion id AFTER + /// adjust_motion normalization (the ADJUSTED id, unlike + /// which takes the ORIGINAL). + /// Retail arg3 (MovementParameters const*). + public void ApplyMotion(uint motion, MovementParameters p) + { + if (motion == 0x6500000du) // TurnRight + { + TurnCommand = motion; + TurnSpeed = p.Speed; + return; + } + if (motion == 0x6500000fu) // SideStepRight + { + SideStepCommand = motion; + SideStepSpeed = p.Speed; + return; + } + if ((motion & 0x40000000u) != 0) + { + ForwardCommand = motion; + ForwardSpeed = p.Speed; + return; + } + if (motion >= 0x80000000u) // arg2 < 0 as signed int32 + { + ForwardCommand = 0x41000003u; + CurrentStyle = motion; + return; + } + if ((motion & 0x10000000u) != 0) + AddAction(motion, p.Speed, p.ActionStamp, p.Autonomous); + } + + /// + /// InterpretedMotionState::RemoveMotion (0x0051e790, decomp + /// 293315-293340): + /// + /// if (arg2 == 0x6500000d) { turn_command = 0; return; } + /// if (arg2 == 0x6500000f) { sidestep_command = 0; return; } + /// if ((arg2 & 0x40000000) == 0) { + /// if (arg2 < 0 && arg2 == current_style) current_style = 0x8000003d; + /// } else if (arg2 == forward_command) { + /// forward_command = 0x41000003; forward_speed = 1f; + /// } + /// + /// Note the asymmetric range test vs + /// (which uses (arg2 - 0x6500000d) > 3 covering all four + /// turn/sidestep ids) — this one only special-cases the RIGHT variants + /// by exact equality; TurnLeft/SideStepLeft fall through to the + /// style/forward-command branch below. Verbatim, not a gap (mirrors + /// retail's own asymmetry between the two RemoveMotion bodies). + /// + /// Retail arg2. + public void RemoveMotion(uint motion) + { + if (motion == 0x6500000du) + { + TurnCommand = 0; + return; + } + if (motion == 0x6500000fu) + { + SideStepCommand = 0; + return; + } + if ((motion & 0x40000000u) == 0) + { + if (motion >= 0x80000000u && motion == CurrentStyle) + CurrentStyle = 0x8000003du; + } + else if (motion == ForwardCommand) + { + ForwardCommand = 0x41000003u; + ForwardSpeed = 1f; + } + } } /// /// Lightweight struct passed into PerformMovement. /// Fields correspond to what the retail dispatcher read from param_1 (the movement packet struct). +/// +/// +/// R4-V1 widening (closes M11). Retail's full MovementStruct +/// (acclient.h:38069, struct #4067): +/// +/// struct __cppobj MovementStruct +/// { +/// MovementTypes::Type type; +/// unsigned int motion; // types 1-4 only +/// unsigned int object_id; // types 6, 8 +/// unsigned int top_level_id; // types 6, 8 +/// Position pos; // type 7 +/// float radius; // type 6 +/// float height; // type 6 +/// MovementParameters *params; // types 1-4, 6-9 +/// }; +/// +/// /// +/// // are the +/// R4-V1 additions — additive only, no consumer wiring in this slice +/// (MoveToManager itself is R4-V2). The pre-R4 fields (/ +/// /// +/// /) are +/// untouched. uses acdream's +/// (ObjCellId + CellFrame) rather than retail's block-local Position — +/// V0-pins.md §P5: distances are equivalent after rebase in acdream's +/// streaming-world space. +/// /// public struct MovementStruct { - /// Which of the 5 motion types to dispatch. + /// Which movement type to dispatch (retail MovementTypes::Type, full 0-9 range). public MovementType Type; - /// Motion command ID (e.g. WalkForward). + /// Motion command ID (e.g. WalkForward). Types 1-4 only. public uint Motion; /// Speed scalar for this motion. public float Speed; @@ -209,6 +536,35 @@ public struct MovementStruct public bool ModifyInterpretedState; /// Whether to modify the raw state. public bool ModifyRawState; + + /// + /// R4-V1 — retail object_id. Types 6 (MoveToObject), 8 + /// (TurnToObject) only. + /// + public uint ObjectId; + /// + /// R4-V1 — retail top_level_id. Types 6 (MoveToObject), 8 + /// (TurnToObject) only. + /// + public uint TopLevelId; + /// + /// R4-V1 — retail pos (world position + cell). Type 7 + /// (MoveToPosition) only. + /// + public Position Pos; + /// + /// R4-V1 — retail radius. Type 6 (MoveToObject) only. + /// + public float Radius; + /// + /// R4-V1 — retail height. Type 6 (MoveToObject) only. + /// + public float Height; + /// + /// R4-V1 — retail params (a pointer in retail; a reference + /// here). Types 1-4 and 6-9. + /// + public Motion.MovementParameters? Params; } // ── Optional WeenieObject interface ────────────────────────────────────────── @@ -226,6 +582,47 @@ public interface IWeenieObject bool InqRunRate(out float rate); /// vtable +0x3C — CanJump. Returns true if the weenie can jump at this extent. bool CanJump(float extent); + + /// + /// Retail CWeenieObject::IsCreature. Non-creature weenies bypass + /// the ground-contact gate in contact_allows_move (0x00528240), + /// the run remap in adjust_motion (wired R3-W4, closes J18 — + /// register TS-34 retired), and the / + /// creature gates. Players, NPCs, and + /// monsters are creatures — default true keeps existing implementers + /// retail-correct. + /// + bool IsCreature() => true; + + /// + /// Retail ACCWeenieObject::IsThePlayer (vtable +0x14, + /// 0x0058C3D0): this->id == SmartBox::smartbox->player_id. + /// PINNED (W0-pins.md A3, adversarially verified) as the dual-dispatch + /// gate for apply_current_movement/ReportExhaustion/ + /// SetWeenieObject/SetPhysicsObject — NOT IsCreature + /// (a remote player is a creature but not the player; ACE's server-side + /// IsCreature gate is a genuine divergence, not a reading to + /// copy). Default false; only the local player's weenie returns true. + /// No consumer in R3-W3 — the W4 dual-dispatch port is the first reader. + /// + bool IsThePlayer() => false; + + /// + /// Retail CWeenieObject::JumpStaminaCost (vtable +0x44, referenced + /// from jump_is_allowed raw 305549-305556): given the charge + /// , returns whether the weenie can afford the + /// stamina cost of this jump and writes the cost to + /// . jump_is_allowed treats a false + /// return as (0x47). + /// Default true / cost 0 — real stamina gating stays TS-5-deferred (the + /// same register row that already covers CanJump always-true; + /// this extends it to JumpStaminaCost until stat plumbing lands). + /// + bool JumpStaminaCost(float extent, out int cost) + { + cost = 0; + return true; + } } // ── MotionInterpreter ───────────────────────────────────────────────────────── @@ -235,23 +632,74 @@ public interface IWeenieObject /// /// Owns the raw and interpreted motion states for a physics object and /// translates network movement commands into PhysicsBody velocity calls. +/// +/// +/// R3-W2 (closes J1, J17): implements — +/// the entity's MotionTableManager (R2-Q3) binds its animation-done +/// callback here, standing in for retail's null-guarded relay chain +/// CPhysicsObj::MotionDone 0x0050fdb0 → MovementManager::MotionDone +/// 0x005242d0 → CMotionInterp::MotionDone 0x00527ec0 (r3-port-plan.md +/// §4). This adds the pending_motions queue (retail +/// CMotionInterp::pending_motions, a singly-linked LList — +/// ported as a managed per the AD-34 managed-list +/// register wording) that the funnel's dispatch/stop producers populate and +/// / drain. +/// /// -public sealed class MotionInterpreter +public sealed class MotionInterpreter : IMotionDoneSink { // ── animation speed constants (from ACE / confirmed by decompile globals) ─ - /// Walk animation base speed (_DAT_007c96e4 family). - public const float WalkAnimSpeed = 3.12f; + /// Walk animation base speed. Retail-exact (.rdata 0x007c891c = + /// 3.11999989f); unified for both and + /// 's sidestep scale in D6.2. + public const float WalkAnimSpeed = 3.11999989f; /// Run animation base speed (_DAT_007c96e0 family). public const float RunAnimSpeed = 4.0f; /// Sidestep animation base speed (_DAT_007c96e8 family). public const float SidestepAnimSpeed = 1.25f; - /// Minimum jump extent before get_jump_v_z bothers computing (_DAT_007c9734). - public const float JumpExtentEpsilon = 0.001f; + /// + /// Minimum jump extent before get_jump_v_z bothers computing + /// (_DAT_007c9734). R3-W3 (closes J16-epsilons, A5/A6): retail's exact + /// literal is 0.000199999995f (raw @304959: + /// ((long double)0.000199999995f)), NOT the previous 0.001 + /// approximation. Used by both and + /// (three times there, one per + /// axis — A6). + /// + public const float JumpVzEpsilon = 0.000199999995f; /// Fallback vertical jump velocity when WeenieObj is absent (_DAT_0079c6d4). public const float DefaultJumpVz = 10.0f; /// Maximum jump extent clamped by get_jump_v_z (_DAT_007938b0 = 1.0f). public const float MaxJumpExtent = 1.0f; + /// + /// Backward-speed multiplier applied by when + /// remapping WalkBackward → WalkForward (retail .rdata 0x007c8910). + /// Retail-exact value; do not round to 0.65f. + /// + public const float BackwardsFactor = 0.649999976f; + + /// + /// Turn speed multiplier applied by for + /// TurnRight when the hold key is Run (retail apply_run_to_command, no + /// run-rate scaling and no clamp — just a flat ×1.5). + /// + public const float RunTurnFactor = 1.5f; + + /// + /// Symmetric clamp on sidestep interpreted speed applied by + /// for SideStepRight when running + /// (retail apply_run_to_command SideStepRight clamp, ±3.0). + /// + public const float MaxSidestepAnimRate = 3.0f; + + /// + /// Retail-exact sidestep scale factor used by + /// when remapping to SideStepRight (retail SidestepFactor = 0.5). + /// + public const float SidestepFactor = 0.5f; + + // ── fields (matching struct layout from acclient_function_map.md) ───────── /// The physics body this interpreter controls (struct offset +0x08). @@ -260,7 +708,17 @@ public sealed class MotionInterpreter /// Optional WeenieObject for stamina / run-rate queries (struct offset +0x04). public IWeenieObject? WeenieObj { get; set; } - /// Raw (network-derived) motion state (struct offsets +0x14..+0x44). + /// + /// Raw (network-derived) motion state (struct offsets +0x14..+0x44). + /// + /// + /// R3-W1 fold (closes J2): this now holds the SAME retail-faithful, + /// full-field type the outbound + /// wire packer reads from — the former flat LegacyRawMotionState + /// struct (no action FIFO, no ApplyMotion/RemoveMotion) + /// is deleted. One raw-state type end to end. + /// + /// public RawMotionState RawState; /// Interpreted motion state derived from raw (struct offsets +0x44..+0x7C). @@ -272,9 +730,154 @@ public sealed class MotionInterpreter /// Stored run rate from last successful InqRunRate call (offset +0x7C). public float MyRunRate = 1.0f; + /// + /// The physics object's currently-held movement key (retail + /// this->raw_state.current_holdkey). + /// falls back to this property when the per-channel holdKey argument + /// passed in is . R3-W6: an ALIAS of + /// — retail's adjust_motion + /// reads raw_state.current_holdkey directly; the former shadow + /// field only synced on the raw dispatch branch, so an edge-driven + /// set_hold_run followed by DoMotion read a stale None and lost the + /// run promotion (the W6 cutover surfaced this). + /// + public HoldKey CurrentHoldKey => RawState.CurrentHoldKey; + /// True when crouching-in-place for a standing long jump (offset +0x70). public bool StandingLongJump; + /// + /// R3-W2 — retail CMotionInterp::pending_motions (offset last in + /// the struct, a singly-linked LList<MotionNode>). Ported as + /// a managed — the AD-34 register wording + /// ("retail's intrusive DLList/LList is ported as a managed LinkedList of + /// value nodes; node identity semantics are preserved via + /// LinkedListNode<T> references rather than raw prev/next + /// pointers") applies here exactly as it does to + /// MotionTableManager._pendingAnimations — this is the OTHER, + /// never-merged queue (movement side, waiting for a MotionDone callback, + /// vs the manager's animation side, waiting for a tick countdown; see + /// r3-port-plan.md §4 rule 1). Exposed read-only; mutated only through + /// / / + /// . + /// + private readonly LinkedList _pendingMotions = new(); + + /// Read-only inspection surface (tests + future callers): the + /// pending motion queue in head-to-tail order. + public IEnumerable PendingMotions => _pendingMotions; + + /// + /// R3-W2 no-op seam standing in for retail CPhysicsObj::unstick_from_object + /// (called from / when + /// the popped queue head is action-class, i.e. Motion & 0x10000000 + /// is set). Register row: releases a "stuck to object" sticky-manager + /// attachment — R5 wires the real StickyManager; until then this is an + /// optional callback the App layer may bind, matching the existing + /// Action? seam convention (see MotionTableDispatchSink.TurnStopped). + /// + public Action? UnstickFromObject { get; set; } + + /// + /// R3-W3 no-op seam standing in for retail CPhysicsObj::interrupt_current_movement + /// (called unconditionally at the top of , raw @305800, + /// and by per A9). Register row: retail + /// cancels any in-flight MoveToManager transition before starting a new + /// movement action; R4 wires the real cancel_moveto once + /// MoveToManager exists. Until then this is an optional callback the App + /// layer may bind, matching the seam + /// convention. + /// + public Action? InterruptCurrentMovement { get; set; } + + /// + /// R3-W4 seam standing in for retail CPhysicsObj::RemoveLinkAnimations + /// (0x0050fe20, decomp §9 summary table) → CPartArray → + /// CSequence::remove_all_link_animations — called from + /// / (§4a/4b) whenever + /// the ground-transition body actually runs. This is retail's REAL + /// mechanism for "leaving the ground strips any pending link + /// animation so Falling engages instantly" — the K-fix18 App-side + /// forced-SetCycle(skipTransitionLink:true) hack this seam + /// replaces is deleted in the orchestrator's App-side half (register + /// row retirement rides with that deletion, not this commit — Core + /// has no K-fix18 code to remove). The App layer binds this to the + /// entity's AnimationSequencer/CSequence core + /// (RemoveAllLinkAnimations-equivalent) per entity, matching the + /// existing / + /// Action? seam convention. Optional — a null binding is a + /// silent no-op (safe default for tests and for any physics body with + /// no sequencer attached yet). + /// + public Action? RemoveLinkAnimations { get; set; } + + /// + /// R3-W4 no-op seam standing in for retail + /// CPhysicsObj::InitializeMotionTables, called from + /// (§4d, raw @306124: + /// CPhysicsObj::InitializeMotionTables(this->physics_obj);). + /// This re-seeds the physics object's MotionTableManager/motion + /// table stack — a manager-side (App-bound) concern, not something + /// MotionInterpreter itself owns state for. Register row: no-op + /// until the App layer binds it to the entity's motion-table + /// initialization; matches the seam + /// convention. + /// + public Action? InitializeMotionTables { get; set; } + + /// + /// R3-W5 seam standing in for retail CPhysicsObj::CheckForCompletedMotions + /// (0x0050fe30, decomp §7d @277925) → CPartArray::CheckForCompletedMotions + /// → MotionTableManager::CheckForCompletedMotions (the SECOND call + /// site of the shared animation-completion driver, §7b) — called by + /// after EVERY dispatched op (raw + /// 306234/306241/306248/306255/306262, §2/§7d), synchronously draining + /// any already-elapsed (0-duration) animation-table node right after the + /// motion is applied, in case the newly-applied motion table entry + /// completes immediately. The App layer binds this to the entity's + /// MotionTableManager.CheckForCompletedMotions (R2-Q3 object), + /// matching the existing / + /// Action? seam convention. A null + /// binding is a silent no-op (safe default for tests and for any physics + /// body with no MotionTableManager attached yet). + /// + public Action? CheckForCompletedMotions { get; set; } + + /// + /// R3-W4 — retail CMotionInterp::initted (set by + /// , raw @306152: this->initted = + /// 1;). Gates and + /// 's entry (A3: physics_obj != 0 + /// && initted != 0). + /// + /// + /// Constructor default is true, NOT retail's false + /// (see the final-report note on this divergence). Retail's + /// CMotionInterp is never used standalone — every real + /// construction path (MovementManager::PerformMovement's + /// lazy-create, MovementManager::Create) immediately calls + /// (retail's enter_default_state) + /// before the interpreter is exposed to any caller, so initted + /// is always 1 by the time application code can observe it. + /// acdream's MotionInterpreter constructor is used directly by + /// ~40 pre-existing tests AND by both App call sites + /// (PlayerMovementController, GameWindow) as a + /// complete, immediately-usable object with no separate + /// "enter default state" step — porting retail's literal + /// false default would silently no-op every one of those + /// call sites' apply_current_movement/ReportExhaustion + /// calls until something remembers to call + /// (which nothing currently does). + /// Defaulting true here is the C# equivalent of "the + /// constructor already did what enter_default_state would have + /// done to this flag" — remains the + /// verbatim, fully-testable retail method for callers (tests, and a + /// future App reset-to-idle path) that need the REST of its behavior + /// (state reset, sentinel enqueue, tail). + /// + /// + public bool Initted { get; set; } = true; + /// /// Optional accessor for the owning entity's current animation cycle /// velocity (AnimationSequencer.CurrentVelocity, i.e. MotionData.Velocity @@ -318,7 +921,7 @@ public sealed class MotionInterpreter public MotionInterpreter() { - RawState = RawMotionState.Default(); + RawState = new RawMotionState(); InterpretedState = InterpretedMotionState.Default(); } @@ -326,7 +929,7 @@ public sealed class MotionInterpreter { PhysicsObj = physicsObj; WeenieObj = weenieObj; - RawState = RawMotionState.Default(); + RawState = new RawMotionState(); InterpretedState = InterpretedMotionState.Default(); } @@ -344,193 +947,316 @@ public sealed class MotionInterpreter /// case 5: StopCompletely() /// default: return 0x47 /// } - /// FUN_00510900() — CheckForCompletedMotions (animation flush, not simulated here) + /// FUN_0050fe30 — CPhysicsObj::CheckForCompletedMotions, called after EVERY + /// dispatched op (raw 306234/306241/306248/306255/306262, R3-W5 closes J14). /// public WeenieError PerformMovement(MovementStruct mvs) { + var p = new MovementParameters + { + Speed = mvs.Speed, + ModifyInterpretedState = mvs.ModifyInterpretedState, + ModifyRawState = mvs.ModifyRawState, + }; + + bool dispatched = true; WeenieError result = mvs.Type switch { - MovementType.RawCommand => DoMotion(mvs.Motion, mvs.Speed), - MovementType.InterpretedCommand => DoInterpretedMotion(mvs.Motion, mvs.Speed, mvs.ModifyInterpretedState), - MovementType.StopRawCommand => StopMotion(mvs.Motion), - MovementType.StopInterpretedCommand => StopInterpretedMotion(mvs.Motion, mvs.ModifyInterpretedState), + MovementType.RawCommand => DoMotion(mvs.Motion, p), + MovementType.InterpretedCommand => DoInterpretedMotion(mvs.Motion, p), + MovementType.StopRawCommand => StopMotion(mvs.Motion, p), + MovementType.StopInterpretedCommand => StopInterpretedMotion(mvs.Motion, p), MovementType.StopCompletely => StopCompletely(), - _ => WeenieError.GeneralMovementFailure, + _ => Invalid(out dispatched), }; - // FUN_00510900 — CheckForCompletedMotions is an animation system flush; - // no simulation state to update here. + + // R3-W5 (closes J14): CPhysicsObj::CheckForCompletedMotions fires + // after EVERY dispatched op — a synchronous zero-tick flush so a + // newly-applied motion-table entry that completes IMMEDIATELY + // (0-duration node) gets its MotionDone callback in the same call, + // not on the next tick. The type-dispatch failure path (bad + // MovementStruct.type, 0x47) never reaches a dispatch, so it must + // NOT flush — matches retail's raw 306227 early-return before the + // switch even begins. + if (dispatched) + CheckForCompletedMotions?.Invoke(); + return result; + + static WeenieError Invalid(out bool dispatched) + { + dispatched = false; + return WeenieError.GeneralMovementFailure; + } } // ── FUN_00529930 — DoMotion ─────────────────────────────────────────────── /// - /// Process one raw motion command from a network packet. - /// - /// Decompiled logic (FUN_00529930): - /// Copy packet fields into local variables (at local_24..local_4). - /// If the speed byte in flags is negative → call FUN_00510cc0 (cancel moveto). - /// If 0x800 flag → FUN_005297c0 (set hold key from packet). - /// FUN_00528c20 — adjust_motion (raw→interpreted adjustments). - /// Guard against special mid-animation states (returns 0x3F/0x40/0x41/0x42). - /// If Action bit (0x10000000) set and num_actions ≥ 6 → return 0x45. - /// Call DoInterpretedMotion(motion, movementParams). - /// - /// Our simplified port focuses on the state fields and physics side-effects. + /// CMotionInterp::DoMotion (0x00528d20, decomp §2 @306159, FULL + /// BODY, R3-W5, closes J3). App-facing 2-arg compat overload — + /// PlayerMovementController's call sites pass a raw + /// (uint motion, float speed) pair; this builds a + /// default-constructed (retail's own + /// UnPack/CommandInterpreter callers build one the same way for a bare + /// raw command) with overridden, + /// then delegates to the verbatim overload below. /// public WeenieError DoMotion(uint motion, float speed = 1.0f) - { - if (PhysicsObj is null) - return WeenieError.NoPhysicsObject; - - // Record the new raw forward command and speed. - // In the decompile, local_24 = *(param_3+8) = ForwardCommand, - // local_18 = ForwardSpeed, etc. - RawState.ForwardCommand = motion; - RawState.ForwardSpeed = speed; - - // Delegate to the interpreted path. DoMotion ultimately calls - // DoInterpretedMotion after adjust_motion in the retail client. - return DoInterpretedMotion(motion, speed, modifyInterpretedState: true); - } - - // ── DoInterpretedMotion ──────────────────────────────────────────────────── + => DoMotion(motion, new MovementParameters { Speed = speed }); /// - /// Core animation-state-machine entry point (FUN_00528f70). + /// CMotionInterp::DoMotion (0x00528d20, decomp §2 @306159, FULL + /// BODY, R3-W5, closes J3). /// - /// In the full retail engine this runs the animation sequencer. In this - /// physics-only port we update the InterpretedState and call - /// apply_current_movement so that the velocity is immediately reflected. + /// + /// Verbatim (raw 306159-306221): + /// + /// if (physics_obj == 0) return 8; + /// ebp = arg2; // ORIGINAL motion id, unmutated + /// snapshot every MovementParameters field onto the stack; + /// var_2c = fresh local MovementParameters(); // re-default + /// if (bitfield sign bit) interrupt_current_movement(physics_obj); + /// if (bitfield & 0x800 /*SetHoldKey*/) + /// SetHoldKey(hold_key_to_apply, (bitfield>>0xf)&1 /*cancel_moveto bit, A4*/); + /// adjust_motion(&arg2, &speed, hold_key_to_apply); // mutates arg2/speed in place + /// if (interpreted_state.current_style != 0x8000003d) { // combat/special stance + /// if (ebp == 0x41000012) return 0x3f; + /// if (ebp == 0x41000013) return 0x40; + /// if (ebp == 0x41000014) return 0x41; + /// if (ebp & 0x2000000) return 0x42; + /// } + /// if ((ebp & 0x10000000) && GetNumActions() >= 6) return 0x45; + /// result = DoInterpretedMotion(arg2 /*ADJUSTED*/, &var_2c /*fresh local params*/); + /// if (result == 0 && bitfield & 0x2000 /*ModifyRawState*/) + /// RawMotionState::ApplyMotion(ebp /*ORIGINAL*/, arg3 /*CALLER's params, not var_2c*/); + /// return result; + /// + /// + /// + /// + /// Two mirror-discipline details, both verbatim: (1) the + /// call + /// receives a FRESH local (re-defaulted, + /// only Speed/HoldKeyToApply carried through + /// adjust_motion's mutation) — the caller's own + /// distance/heading/fail-distance fields are + /// discarded for the interpreted call, matching retail's explicit + /// re-construction of var_2c. (2) the raw-state mirror at the + /// bottom reads the ORIGINAL arg3 () — NOT + /// var_2c — for / + /// /, + /// per RawMotionState::ApplyMotion's own signature + /// (const MovementParameters*) receiving the same pointer + /// DoMotion was called with. + /// /// - public WeenieError DoInterpretedMotion(uint motion, float speed = 1.0f, bool modifyInterpretedState = false) + /// Retail arg2 (the ORIGINAL, pre-adjustment + /// motion id — ebp). + /// Retail arg3. + public WeenieError DoMotion(uint motion, MovementParameters p) { if (PhysicsObj is null) return WeenieError.NoPhysicsObject; - if (!contact_allows_move(motion)) + uint originalMotion = motion; + float speed = p.Speed; + var local = new MovementParameters(); // var_2c — fresh re-default + + if (p.CancelMoveTo) // bitfield high-byte sign bit + InterruptCurrentMovement?.Invoke(); + + if (p.SetHoldKey) // bitfield & 0x800 + SetHoldKey(p.HoldKeyToApply, p.CancelMoveTo); // A4: 2nd arg IS the cancel_moveto bit + + adjust_motion(ref motion, ref speed, p.HoldKeyToApply); // mutates motion/speed in place + + if (InterpretedState.CurrentStyle != 0x8000003du) // not MotionStance_NonCombat { - // Action commands (bit 0x10000000) are blocked mid-air. - if ((motion & 0x10000000u) != 0) - return WeenieError.YouCantJumpWhileInTheAir; - // Non-action motions are queued silently; state still updates. + if (originalMotion == MotionCommand.Crouch) + return WeenieError.CrouchInCombatStance; // 0x3f + if (originalMotion == MotionCommand.Sitting) + return WeenieError.SitInCombatStance; // 0x40 + if (originalMotion == MotionCommand.Sleeping) + return WeenieError.SleepInCombatStance; // 0x41 + if ((originalMotion & 0x2000000u) != 0) + return WeenieError.ChatEmoteOutsideNonCombat; // 0x42 } - if (modifyInterpretedState) - ApplyMotionToInterpretedState(motion, speed); + if ((originalMotion & 0x10000000u) != 0 && InterpretedState.GetNumActions() >= 6) + return WeenieError.ActionDepthExceeded; // 0x45 - apply_current_movement(cancelMoveTo: false, allowJump: true); - return WeenieError.None; + local.Speed = speed; + local.HoldKeyToApply = p.HoldKeyToApply; + + WeenieError result = DoInterpretedMotion(motion, local); // ADJUSTED id, fresh local params + + if (result == WeenieError.None && p.ModifyRawState) // bitfield & 0x2000 + RawState.ApplyMotion(originalMotion, p); // ORIGINAL id, CALLER's params (arg3, not var_2c) + + return result; } // ── StopMotion ──────────────────────────────────────────────────────────── /// - /// Stop a specific raw motion (FUN_00529140 → StopInterpretedMotion). + /// App-facing compat overload for StopMotion (0x00528530, decomp + /// §5b @305674). Builds a default-constructed + /// and delegates to the verbatim overload below. /// public WeenieError StopMotion(uint motion) - { - if (PhysicsObj is null) - return WeenieError.NoPhysicsObject; - - if (RawState.ForwardCommand == motion) - { - RawState.ForwardCommand = MotionCommand.Ready; - RawState.ForwardSpeed = 1.0f; - } - if (RawState.SideStepCommand == motion) - { - RawState.SideStepCommand = 0; - RawState.SideStepSpeed = 1.0f; - } - if (RawState.TurnCommand == motion) - { - RawState.TurnCommand = 0; - RawState.TurnSpeed = 1.0f; - } - - return StopInterpretedMotion(motion, modifyInterpretedState: true); - } - - // ── StopInterpretedMotion ──────────────────────────────────────────────── + => StopMotion(motion, new MovementParameters()); /// - /// Stop a specific interpreted motion (FUN_00529080). - /// - public WeenieError StopInterpretedMotion(uint motion, bool modifyInterpretedState = false) - { - if (PhysicsObj is null) - return WeenieError.NoPhysicsObject; - - if (modifyInterpretedState) - { - if (InterpretedState.ForwardCommand == motion) - { - InterpretedState.ForwardCommand = MotionCommand.Ready; - InterpretedState.ForwardSpeed = 1.0f; - } - if (InterpretedState.SideStepCommand == motion) - { - InterpretedState.SideStepCommand = 0; - InterpretedState.SideStepSpeed = 1.0f; - } - if (InterpretedState.TurnCommand == motion) - { - InterpretedState.TurnCommand = 0; - InterpretedState.TurnSpeed = 1.0f; - } - } - - apply_current_movement(cancelMoveTo: false, allowJump: false); - return WeenieError.None; - } - - // ── FUN_00528a50 — StopCompletely ───────────────────────────────────────── - - /// - /// Reset both raw and interpreted states to Ready/idle, then push zero velocity. + /// CMotionInterp::StopMotion (0x00528530, decomp §5b @305674, FULL + /// BODY, R3-W5, closes J3's StopMotion leg). The DoMotion mirror: + /// same defaulting/reconstruction pattern, same optional + /// interrupt_current_movement, same adjust_motion + /// reinterpretation — but NO combat-stance or action-depth gating (those + /// are DoMotion-only). /// - /// Decompiled logic (FUN_00528a50): - /// if (PhysicsObj == null) return 8 - /// FUN_00510cc0() — cancel moveto - /// uVar1 = FUN_005285e0(InterpretedState.ForwardCommand) — motion_allows_jump - /// *(+0x20) = 0x41000003 (RawState.ForwardCommand = Ready) - /// *(+0x28) = 0x3f800000 (RawState.ForwardSpeed = 1.0f) - /// *(+0x2c) = 0 (RawState.SideStepCommand = 0) - /// *(+0x38) = 0 (RawState.TurnCommand = 0) - /// *(+0x4c) = 0x41000003 (InterpretedState.ForwardCommand = Ready) - /// *(+0x50) = 0x3f800000 (InterpretedState.ForwardSpeed = 1.0f) - /// *(+0x54) = 0 (InterpretedState.SideStepCommand = 0) - /// *(+0x5c) = 0 (InterpretedState.TurnCommand = 0) - /// FUN_0050f5a0() — StopCompletely_Internal (zero velocity on PhysicsObj) - /// FUN_00528790(…) — add_to_queue - /// if (PhysicsObj != null && CurCell == null) → FUN_005108f0 (RemoveLinkAnimations) - /// return 0 + /// + /// Verbatim (raw 305674-305706): snapshot fields, + /// build a fresh local , optional + /// interrupt on the sign bit, adjust_motion(&arg3, &speed, + /// hold_key_to_apply) (mutates the motion id in place — note retail + /// reuses the arg3 register slot for the motion id here, not a + /// separate local), delegate to + /// StopInterpretedMotion(adjusted, &local); on success AND + /// bit 0x2000 (ModifyRawState), mirror via + /// RawMotionState::RemoveMotion(ORIGINAL motion) — using the + /// ORIGINAL unmutated id, matching DoMotion's equivalent + /// ApplyMotion(ebp, arg3) mirror discipline. + /// + /// + /// Retail arg2 (the ORIGINAL motion id). + /// Retail arg3. + public WeenieError StopMotion(uint motion, MovementParameters p) + { + if (PhysicsObj is null) + return WeenieError.NoPhysicsObject; + + uint originalMotion = motion; + float speed = p.Speed; + var local = new MovementParameters(); // fresh re-default + + if (p.CancelMoveTo) + InterruptCurrentMovement?.Invoke(); + + adjust_motion(ref motion, ref speed, p.HoldKeyToApply); + + local.Speed = speed; + local.HoldKeyToApply = p.HoldKeyToApply; + + WeenieError result = StopInterpretedMotion(motion, local); // ADJUSTED id + + if (result == WeenieError.None && p.ModifyRawState) + RawState.RemoveMotion(originalMotion); // ORIGINAL id + + return result; + } + + // ── FUN_00527e40 — StopCompletely ───────────────────────────────────────── + + /// + /// CMotionInterp::StopCompletely (0x00527e40, decomp §5a @305208, + /// FULL BODY, R3-W5, closes J9). W0-pins.md A9 — ported INCLUDING the + /// jump-snapshot quirk. + /// + /// + /// Verbatim (raw 305208-305236): + /// + /// if (physics_obj == 0) return 8; + /// interrupt_current_movement(physics_obj); + /// eax_2 = motion_allows_jump(interpreted_state.forward_command); // OLD fwd, BEFORE overwrite + /// raw_state.forward_command = 0x41000003; raw_state.forward_speed = 1f; + /// raw_state.sidestep_command = 0; raw_state.turn_command = 0; + /// interpreted_state.forward_command = 0x41000003; interpreted_state.forward_speed = 1f; + /// interpreted_state.sidestep_command = 0; interpreted_state.turn_command = 0; + /// StopCompletely_Internal(physics_obj); + /// add_to_queue(0, 0x41000003, eax_2); // eax_2 = the PRE-overwrite snapshot + /// if (physics_obj != 0 && physics_obj->cell == 0) RemoveLinkAnimations(physics_obj); + /// return 0; + /// + /// + /// + /// + /// A9 quirk: motion_allows_jump is evaluated on the OLD + /// interpreted_state.forward_command BEFORE it gets overwritten + /// two lines later — the queued node's JumpErrorCode reflects the + /// PRE-stop command, not the post-stop Ready command (which would always + /// pass). J9: retail touches ONLY the forward command/speed plus + /// the sidestep/turn COMMANDS — it does NOT write sidestep_speed + /// or turn_speed on either state. The pre-R3 acdream divergence + /// (unconditional 1.0 speed resets on all four speed fields) is REMOVED + /// here. + /// + /// + /// + /// StopCompletely_Internal (0x0050f5a0, CPhysicsObj-side) stands + /// in as (Zero) — register row, + /// kept (full port is physics-layer scope, r3-port-plan.md §2 KEEP + /// LIST). CurCell proxy: .ObjCellId + /// == 0 (unseeded/detached body — matches cell == 0). + /// /// public WeenieError StopCompletely() { if (PhysicsObj is null) return WeenieError.NoPhysicsObject; - // Reset raw state + InterruptCurrentMovement?.Invoke(); + + // A9: snapshot BEFORE the overwrite below. + WeenieError jumpSnapshot = MotionAllowsJump(InterpretedState.ForwardCommand); + + // J9: forward cmd/speed + sidestep/turn COMMANDS only — speeds untouched. RawState.ForwardCommand = MotionCommand.Ready; RawState.ForwardSpeed = 1.0f; - RawState.SideStepCommand = 0; - RawState.SideStepSpeed = 1.0f; + RawState.SidestepCommand = 0; RawState.TurnCommand = 0; - RawState.TurnSpeed = 1.0f; - // Reset interpreted state InterpretedState.ForwardCommand = MotionCommand.Ready; InterpretedState.ForwardSpeed = 1.0f; InterpretedState.SideStepCommand = 0; - InterpretedState.SideStepSpeed = 1.0f; InterpretedState.TurnCommand = 0; - InterpretedState.TurnSpeed = 1.0f; - // Zero the body velocity (FUN_0050f5a0 = StopCompletely_Internal) + // StopCompletely_Internal — R4-V5 wedge-fix CORRECTION of the R3 + // misread: retail's body (0x0050ead0, tailcall + // CPartArray::StopCompletelyInternal 0x00518890) is + // MotionTableManager::PerformMovement(type 5) through the ANIMATION + // stack — NOT a physics-side velocity zero (the "0x0050f5a0" the R3 + // note cited is a different function's interior). The manager + // queues its type-5 pending_animations entry UNCONDITIONALLY, and + // that entry's AnimationDone → MotionDone is the matched pop for + // the A9 pending_motions node queued below. Without this dispatch + // every StopCompletely (login/teleport SetPosition + every + // MoveToManager PerformMovement head) left an orphan node, + // MotionsPending never drained at idle, and BeginTurnToHeading's + // wait-for-anims gate wedged every armed moveto (the 2026-07-03 + // live door bug — server walked the player, the local body never + // moved, rubber-band on the next input). + DefaultSink?.StopCompletely(); + + // Immediate velocity zero: kept from the R3 stand-in. Retail + // reaches zero through the Ready state's next velocity apply; + // acdream's controller altitude performs that apply in its grounded + // section-2 write, so the immediate zero preserves the established + // teleport/stop behavior for same-frame readers. PhysicsObj.set_velocity(Vector3.Zero); + AddToQueue(contextId: 0, MotionCommand.Ready, (uint)jumpSnapshot); + + // R4-V5 door-swing fix (2026-07-03): retail's guard is + // physics_obj->cell == 0 — DETACHED objects only (raw @305627). + // The old proxy (CellPosition.ObjCellId == 0, #145 machinery seeded + // only by the local player's SnapToCell) read every REMOTE body as + // detached, so every dispatch stripped the just-appended transition + // link (door swings snapped; remote walk↔run links died) — see + // PhysicsBody.InWorld (register row). + if (!PhysicsObj.InWorld) + RemoveLinkAnimations?.Invoke(); + return WeenieError.None; } @@ -635,26 +1361,334 @@ public sealed class MotionInterpreter return velocity; } - // ── FUN_00529210 — apply_current_movement ───────────────────────────────── + // ── FUN_00528010 — adjust_motion ────────────────────────────────────────── /// - /// Apply the current interpreted motion state as a local velocity to the PhysicsBody. + /// Normalize one raw motion channel (forward, sidestep, or turn) into its + /// canonical interpreted form: fold the "negative" commands (WalkBackward, + /// TurnLeft, SideStepLeft) into their positive counterpart with a negated/ + /// scaled speed, then apply the Run hold-key promotion. /// - /// Decompiled logic (FUN_00529210): - /// if PhysicsObj == null: return - /// FUN_00524f80() — internal animation state update - /// If ForwardCommand == RunForward: update MyRunRate = ForwardSpeed - /// Then delegates to DoInterpretedMotion for each active command, - /// which ultimately calls set_local_velocity via FUN_00528960. + /// + /// Decompiled logic (FUN_00528010, docs/research/named-retail/ + /// acclient_2013_pseudo_c.txt:305343-305400): + /// + /// if weenie != null and !weenie.IsCreature(): return + /// switch cmd: + /// RunForward: return // no scale, NO holdkey path + /// WalkBackwards: cmd = WalkForward; speed *= -BackwardsFactor + /// TurnLeft: cmd = TurnRight; speed *= -1 + /// SideStepLeft: cmd = SideStepRight; speed *= -1 + /// if cmd == SideStepRight: + /// speed *= SidestepFactor * (WalkAnimSpeed / SidestepAnimSpeed) // ≈ 1.24799995 + /// if holdKey == Invalid: holdKey = raw.current_holdkey + /// if holdKey == Run: apply_run_to_command(ref cmd, ref speed) + /// + /// /// - /// In our physics-only port we compute the body-local velocity via - /// get_state_velocity() and push it directly to PhysicsBody.set_local_velocity. + /// + /// GOTCHA: RunForward early-returns before the sidestep scale AND before + /// the hold-key path — a running forward command is already normalized + /// and must not be touched again. The sidestep negate (SideStepLeft → + /// SideStepRight, ×-1) happens BEFORE the ×1.248 anim-rate scale, so the + /// net multiplier for SideStepLeft is -1.248×speed, not -1×(1.248×speed) + /// applied out of order (same result here, but the ORDER matters once + /// apply_run_to_command's sign-dependent clamp is layered on top). + /// + /// + /// + /// R3-W4 (closes J18, retires register TS-34): creature guard WIRED. + /// Retail (raw @305343): if (weenie != 0 && weenie->IsCreature() == 0) + /// return; — a weenie present whose IsCreature() returns + /// false short-circuits the ENTIRE function (no normalization, no + /// hold-key path). has existed + /// since W3; this was the one caller left un-gated. + /// + /// + /// Raw motion command, normalized in place. + /// Raw motion speed, normalized in place. + /// + /// The hold key for THIS channel (forward/sidestep/turn each carry their + /// own hold key in the retail raw state). Pass + /// to fall back to . + /// + public void adjust_motion(ref uint motion, ref float speed, HoldKey holdKey) + { + if (WeenieObj is not null && !WeenieObj.IsCreature()) + return; + + switch (motion) + { + case MotionCommand.RunForward: + // Already normalized; no scale, no hold-key path. + return; + case MotionCommand.WalkBackward: + motion = MotionCommand.WalkForward; + speed *= -BackwardsFactor; + break; + case MotionCommand.TurnLeft: + motion = MotionCommand.TurnRight; + speed *= -1f; + break; + case MotionCommand.SideStepLeft: + motion = MotionCommand.SideStepRight; + speed *= -1f; + break; + } + + if (motion == MotionCommand.SideStepRight) + speed *= SidestepFactor * (WalkAnimSpeed / SidestepAnimSpeed); + + if (holdKey == HoldKey.Invalid) + holdKey = CurrentHoldKey; + + if (holdKey == HoldKey.Run) + apply_run_to_command(ref motion, ref speed); + } + + // ── FUN_00527be0 — apply_run_to_command ─────────────────────────────────── + + /// + /// Apply the Run hold-key promotion/scale to an already-normalized + /// (positive-form) motion command. + /// + /// + /// Decompiled logic (FUN_00527be0, docs/research/named-retail/ + /// acclient_2013_pseudo_c.txt:305062-305123): + /// + /// speedMod = 1.0 + /// if weenie != null: speedMod = weenie.InqRunRate(out r) ? r : MyRunRate + /// switch cmd: + /// WalkForward: + /// if speed > 0: cmd = RunForward // promote ONLY when moving forward + /// speed *= speedMod // UNCONDITIONAL — applies to backward too + /// TurnRight: + /// speed *= RunTurnFactor // ×1.5, no run-rate, no clamp + /// SideStepRight: + /// speed *= speedMod + /// if abs(speed) > MaxSidestepAnimRate: speed = speed > 0 ? Max : -Max + /// + /// + /// + /// + /// GOTCHA: the WalkForward speed *= speedMod is unconditional — + /// it applies even when speed is negative (backward), even though the + /// command is NOT promoted to RunForward in that case (the promotion is + /// sign-gated, the scale is not). + /// + /// + public void apply_run_to_command(ref uint motion, ref float speed) + { + float speedMod = 1.0f; + if (WeenieObj is not null) + speedMod = WeenieObj.InqRunRate(out float rate) ? rate : MyRunRate; + + switch (motion) + { + case MotionCommand.WalkForward: + if (speed > 0f) + motion = MotionCommand.RunForward; + speed *= speedMod; + break; + case MotionCommand.TurnRight: + speed *= RunTurnFactor; + break; + case MotionCommand.SideStepRight: + speed *= speedMod; + if (MathF.Abs(speed) > MaxSidestepAnimRate) + speed = speed > 0f ? MaxSidestepAnimRate : -MaxSidestepAnimRate; + break; + } + } + + // ── 0x005287e0 — apply_raw_movement ─────────────────────────────────────── + + /// + /// Retail CMotionInterp::apply_raw_movement orchestrator + /// (0x005287e0, docs/research/named-retail/acclient_2013_pseudo_c.txt:305817-305834). + /// Copies the raw motion state into the interpreted state, then normalizes + /// each of the three channels (forward / sidestep / turn) IN PLACE via + /// using that channel's own hold key. + /// + /// + /// After this call, yields correct velocity + /// for ALL directions — backward (WalkBackward→WalkForward, ×-0.65) and + /// strafe-left (SideStepLeft→SideStepRight, ×-1×1.248) are normalized here, + /// which is the D6 fix that retires the hand-mirrored controller formulas + /// (register TS-22). Callers must pass RAW speeds (forward_speed = 1.0), NOT + /// pre-run-scaled speeds — applies the run + /// rate, so a pre-scaled input would double-scale. + /// + /// + public void apply_raw_movement(RawMotionState raw) + { + // R3-W6: CurrentHoldKey is now an alias of RawState.CurrentHoldKey; + // keep the interpreter's raw state authoritative when a snapshot + // arrives through this legacy overload. + RawState.CurrentHoldKey = raw.CurrentHoldKey; + + // Copy raw -> interpreted. Retail copies 7 fields; our + // InterpretedMotionState omits current_style (velocity doesn't use it). + InterpretedState.ForwardCommand = raw.ForwardCommand; + InterpretedState.ForwardSpeed = raw.ForwardSpeed; + InterpretedState.SideStepCommand = raw.SidestepCommand; + InterpretedState.SideStepSpeed = raw.SidestepSpeed; + InterpretedState.TurnCommand = raw.TurnCommand; + InterpretedState.TurnSpeed = raw.TurnSpeed; + + // Normalize each channel with its OWN per-channel hold key. + uint fCmd = InterpretedState.ForwardCommand; float fSpd = InterpretedState.ForwardSpeed; + adjust_motion(ref fCmd, ref fSpd, raw.ForwardHoldKey); + InterpretedState.ForwardCommand = fCmd; InterpretedState.ForwardSpeed = fSpd; + + uint sCmd = InterpretedState.SideStepCommand; float sSpd = InterpretedState.SideStepSpeed; + adjust_motion(ref sCmd, ref sSpd, raw.SidestepHoldKey); + InterpretedState.SideStepCommand = sCmd; InterpretedState.SideStepSpeed = sSpd; + + uint tCmd = InterpretedState.TurnCommand; float tSpd = InterpretedState.TurnSpeed; + adjust_motion(ref tCmd, ref tSpd, raw.TurnHoldKey); + InterpretedState.TurnCommand = tCmd; InterpretedState.TurnSpeed = tSpd; + } + + // ── FUN_00528870 — apply_current_movement ───────────────────────────────── + + /// + /// CMotionInterp::apply_current_movement (0x00528870, decomp §4e, + /// W0-pins.md A3, FULL BODY dual dispatch — replaces the pre-W4 + /// direct-velocity approximation). + /// + /// + /// Verbatim (raw 305838-305857): + /// + /// if (physics_obj != 0 && initted != 0) { + /// if (weenie_obj != 0) eax_2 = weenie_obj->IsThePlayer(); + /// if ((weenie_obj == 0 || eax_2 != 0) + /// && movement_is_autonomous(physics_obj) != 0) { + /// apply_raw_movement(this, arg2, arg3); + /// return; + /// } + /// apply_interpreted_movement(this, arg2, arg3); + /// } + /// + /// + /// + /// + /// A3: the dispatch gate is IsThePlayer (no weenie = treat as + /// the player), NOT IsCreature — a remote player weenie + /// (IsThePlayer()==false, IsCreature()==true) routes + /// INTERPRETED even when movement_is_autonomous is true. This is + /// the genuine divergence from ACE's server-side IsCreature gate + /// (ACE MotionInterp.cs:430-438) — do not copy. + /// /// public void apply_current_movement(bool cancelMoveTo, bool allowJump) + { + if (PhysicsObj is null || !Initted) + return; + + bool isThePlayer = WeenieObj is null || WeenieObj.IsThePlayer(); + if (isThePlayer && PhysicsObj.LastMoveWasAutonomous) + { + apply_raw_movement(cancelMoveTo, allowJump); + return; + } + + ApplyCurrentMovementInterpreted(cancelMoveTo, allowJump); + } + + /// + /// CMotionInterp::apply_raw_movement (0x005287e0, decomp §4e + /// referenced body, raw 305817-305834), the (cancelMoveTo, + /// allowJump)-arg overload reached from + /// 's dual dispatch (A3's + /// "IsThePlayer + autonomous" branch), , + /// , and . + /// + /// + /// Verbatim: copy the SEVEN raw-state fields (style + all three + /// axis command/speed pairs) into , + /// normalize each of the three axes IN PLACE via + /// using THAT axis's own hold key, then + /// tail-call apply_interpreted_movement(this, arg2, arg3) — the + /// SAME retail function (0x00528600) as + /// (the funnel producer). This is NOT a new function: it is the + /// existing overload's + /// body (the D6.2a raw-state-orchestrator port), reached here with + /// itself as the source instead of an externally + /// supplied snapshot, plus the previously-missing + /// apply_interpreted_movement(arg2, arg3) tail call this + /// dispatch site needs. + /// + /// + public void apply_raw_movement(bool cancelMoveTo, bool allowJump) { if (PhysicsObj is null) return; + apply_raw_movement(RawState); + ApplyCurrentMovementInterpreted(cancelMoveTo, allowJump); + } + + /// + /// The retail apply_interpreted_movement tail reached from BOTH + /// dual-dispatch branches of (raw + /// 305855/305832 — CMotionInterp::apply_interpreted_movement, + /// 0x00528600, the SAME function as the funnel's + /// , per the raw's identical call + /// target at every one of its six call sites). + /// + /// + /// Physics-only-port body (pre-W4 approximation, SURVIVES per the + /// plan's "less invasive" choice — see the final-report note): this + /// port has no wired at this call + /// site (retail's real body drives DoInterpretedMotion/ + /// StopInterpretedMotion through the animation-table backend, + /// exactly like already does for + /// the INBOUND funnel path — but that path always has a sink available + /// from its caller, while apply_current_movement's callers + /// (// + /// /hold-key toggles/jump) do not thread + /// one through). Kept as the pre-existing direct + /// get_state_velocity → grounded set_local_velocity write + /// — an acdream adaptation of root-motion-driven velocity, register row + /// added same commit — until R6 (root motion drives the body directly + /// and this local-only fallback retires in favor of a real sink here + /// too). + /// + /// + /// + /// R3-W4 (App-bound): the entity's persistent animation-dispatch sink. + /// When set, routes the + /// REAL (retail + /// apply_interpreted_movement 0x00528600 — the same function the + /// inbound funnel drives), so HitGround/LeaveGround/hold-key re-applies + /// dispatch cycles (the airborne-Falling engage) through the + /// motion-table backend exactly as retail does. Null (the local player + /// until R3-W6, interp-less entities) → the AP-77 physics-only tail. + /// + public IInterpretedMotionSink? DefaultSink { get; set; } + + private void ApplyCurrentMovementInterpreted(bool cancelMoveTo, bool allowJump) + { + if (PhysicsObj is null) + return; + + // R3-W4: with a persistent sink bound (remotes), this IS retail's + // apply_interpreted_movement — full dispatch through the funnel + // body (style → forward-or-Falling → sidestep → turn), which is + // what makes LeaveGround engage Falling without the deleted + // K-fix18 forced-SetCycle. Without a sink, fall through to the + // AP-77 physics-only adaptation below. + if (DefaultSink is not null) + { + ApplyInterpretedMovement(InterpretedState.CurrentStyle, DefaultSink, + cancelMoveTo, allowJump); + return; + } + + _ = cancelMoveTo; + _ = allowJump; + // Decompile writes back MyRunRate when in run state (offset +0x7C). if (InterpretedState.ForwardCommand == MotionCommand.RunForward) MyRunRate = InterpretedState.ForwardSpeed; @@ -668,32 +1702,317 @@ public sealed class MotionInterpreter if (PhysicsObj.OnWalkable) { var localVelocity = get_state_velocity(); - PhysicsObj.set_local_velocity(localVelocity); + // AP-77: this adaptation's fallback write has no real opinion on + // "was this move autonomous" (retail's real set_local_velocity + // call for this dispatch path lives deep inside the animation + // backend this stand-in doesn't have — see the seam's doc + // comment). Preserve whatever LastMoveWasAutonomous already + // holds rather than resetting it, so a caller like LeaveGround + // (which just set it true via its OWN direct set_local_velocity + // call, autonomous=1 per raw @305763-305765) isn't clobbered by + // this immediately-following re-sync tail call. + PhysicsObj.set_local_velocity(localVelocity, PhysicsObj.LastMoveWasAutonomous); } } - // ── FUN_00529390 — jump ─────────────────────────────────────────────────── + // ── FUN_005288d0 — ReportExhaustion ──────────────────────────────────────── + + /// + /// CMotionInterp::ReportExhaustion (0x005288d0, decomp §4c + /// @305861, FULL BODY, W0-pins.md A3). Identical entry gate and + /// dual-dispatch predicate to , + /// with HARDCODED (0, 0) dispatch args (raw 305874/305878) — + /// the retail caller (CPhysicsObj::report_exhaustion 0x0050fdd0 + /// → MovementManager::ReportExhaustion 0x00524360) passes no + /// per-call parameters through. + /// + /// + /// Verbatim (raw 305861-305880): + /// + /// if (physics_obj != 0 && initted != 0) { + /// if (weenie_obj != 0) eax_2 = weenie_obj->IsThePlayer(); + /// if ((weenie_obj == 0 || eax_2 != 0) + /// && movement_is_autonomous(physics_obj) != 0) { + /// apply_raw_movement(this, 0, 0); + /// return; + /// } + /// apply_interpreted_movement(this, 0, 0); + /// } + /// + /// + /// + public void ReportExhaustion() + { + if (PhysicsObj is null || !Initted) + return; + + bool isThePlayer = WeenieObj is null || WeenieObj.IsThePlayer(); + if (isThePlayer && PhysicsObj.LastMoveWasAutonomous) + { + // Raw (0, 0): arg3 is DisableJumpDuringLink → allowJump: true + // (#161 polarity decode; consumed since the apply-pass params + // became real). + apply_raw_movement(cancelMoveTo: false, allowJump: true); + return; + } + + ApplyCurrentMovementInterpreted(cancelMoveTo: false, allowJump: true); + } + + // ── FUN_00528920 / FUN_00528970 — SetWeenieObject / SetPhysicsObject ─────── + + /// + /// CMotionInterp::SetWeenieObject (0x00528920, decomp §4f + /// @305884, FULL BODY, W0-pins.md A3). Assigns , + /// then — if already physics-bound AND — re-applies + /// movement via the SAME dual-dispatch predicate as + /// , EXCEPT the weenie tested for + /// IsThePlayer is the INCOMING (not + /// post-assignment — they're the same value + /// here, but retail's raw makes the incoming-arg read explicit: a null + /// incoming weenie takes the SAME branch as a non-null-but-IsThePlayer + /// weenie, both via goto label_528946). Dispatch args are + /// hardcoded (1, 0). + /// + /// + /// Verbatim (raw 305884-305907): + /// + /// bool noPhysics = (physics_obj == 0); + /// weenie_obj = arg2; + /// if (!noPhysics && initted != 0) { + /// if (arg2 == 0) { + /// label_528946: + /// if (movement_is_autonomous(physics_obj) != 0) { + /// apply_raw_movement(this, 1, 0); + /// return; + /// } + /// } else if (arg2->IsThePlayer() != 0) + /// goto label_528946; + /// apply_interpreted_movement(this, 1, 0); + /// } + /// + /// + /// + public void SetWeenieObject(IWeenieObject? weenie) + { + WeenieObj = weenie; + + if (PhysicsObj is null || !Initted) + return; + + bool isThePlayer = weenie is null || weenie.IsThePlayer(); + if (isThePlayer && PhysicsObj.LastMoveWasAutonomous) + { + // Raw (1, 0): cancelMoveTo set, DisableJumpDuringLink clear → + // allowJump: true (#161 polarity decode). + apply_raw_movement(cancelMoveTo: true, allowJump: true); + return; + } + + ApplyCurrentMovementInterpreted(cancelMoveTo: true, allowJump: true); + } + + /// + /// CMotionInterp::SetPhysicsObject (0x00528970, decomp §4g + /// @305911, FULL BODY, W0-pins.md A3). Assigns + /// unconditionally FIRST, then — if the incoming + /// is non-null AND — + /// re-applies movement via the standard dual-dispatch predicate (this + /// time reading , unchanged by this call). + /// Dispatch args are hardcoded (1, 0), matching + /// . + /// + /// + /// Verbatim (raw 305911-305932): + /// + /// this->physics_obj = arg2; + /// if (arg2 != 0 && initted != 0) { + /// if (weenie_obj != 0) eax_1 = weenie_obj->IsThePlayer(); + /// if ((weenie_obj == 0 || eax_1 != 0) + /// && movement_is_autonomous(physics_obj) != 0) { + /// apply_raw_movement(this, 1, 0); + /// return; + /// } + /// apply_interpreted_movement(this, 1, 0); + /// } + /// + /// Note the entry gate is on the INCOMING arg2 (not the + /// just-assigned this->physics_obj — same value, but the raw + /// tests the parameter register directly), unlike + /// 's entry gate which tests the + /// PRE-assignment physics_obj snapshot (noPhysics). + /// + /// + public void SetPhysicsObject(PhysicsBody? physicsObj) + { + PhysicsObj = physicsObj; + + if (physicsObj is null || !Initted) + return; + + bool isThePlayer = WeenieObj is null || WeenieObj.IsThePlayer(); + if (isThePlayer && physicsObj.LastMoveWasAutonomous) + { + // Raw (1, 0) → allowJump: true (#161 polarity decode). + apply_raw_movement(cancelMoveTo: true, allowJump: true); + return; + } + + ApplyCurrentMovementInterpreted(cancelMoveTo: true, allowJump: true); + } + + // ── FUN_00527a50 — jump_charge_is_allowed ───────────────────────────────── + + /// + /// CMotionInterp::jump_charge_is_allowed (0x00527a50, decomp §3b + /// @304935, W0-pins.md A1 polarity). Gate consulted while the jump + /// charge is accumulating (spacebar held) — NOT the same gate as + /// 's ground check. + /// + /// + /// Verbatim (raw 304940-304948): + /// + /// weenie_obj = this->weenie_obj; + /// if (weenie_obj != 0 && weenie_obj.CanJump(this->jump_extent) == 0) + /// return 0x49; + /// forward_command = this->interpreted_state.forward_command; + /// if (forward_command != 0x40000008 + /// && (forward_command <= 0x41000011 || forward_command > 0x41000014)) + /// return 0; + /// return 0x48; + /// + /// + /// + public WeenieError JumpChargeIsAllowed(float extent) + { + if (WeenieObj is not null && !WeenieObj.CanJump(extent)) + return WeenieError.CantJumpLoadedDown; // 0x49 + + uint forward = InterpretedState.ForwardCommand; + if (forward != MotionCommand.Fallen + && (forward <= MotionCommand.CrouchLowerBound || forward > MotionCommand.Sleeping)) + return WeenieError.None; + + return WeenieError.YouCantJumpFromThisPosition; // 0x48 + } + + // ── FUN_005281c0 — charge_jump ──────────────────────────────────────────── + + /// + /// CMotionInterp::charge_jump (0x005281c0, decomp §3e @305448, + /// W0-pins.md A1 polarity). R3-W3 (closes J6): the ONLY place retail + /// arms — the old + /// contact_allows_move side effect (:1139-1148 pre-W3 numbering) + /// is DELETED (see 's doc comment). + /// + /// + /// Verbatim (raw 305453-305466): + /// + /// weenie_obj = this->weenie_obj; + /// if (weenie_obj != 0 && weenie_obj.CanJump(this->jump_extent) == 0) + /// return 0x49; + /// forward_command = this->interpreted_state.forward_command; + /// if (forward_command == 0x40000008 + /// || (forward_command > 0x41000011 && forward_command <= 0x41000014)) + /// return 0x48; + /// transient_state = physics_obj->transient_state; + /// if ((transient_state & 1) != 0 && (transient_state & 2) != 0 + /// && forward_command == 0x41000003 + /// && interpreted_state.sidestep_command == 0 + /// && interpreted_state.turn_command == 0) + /// this->standing_longjump = 1; + /// return 0; + /// + /// + /// + /// + /// Note the inverted-but-equivalent posture test vs + /// : that function's PASS condition is + /// forward <= 0x41000011 || forward > 0x41000014; this + /// function's BLOCK condition is forward == 0x40000008 || + /// (forward > 0x41000011 && forward <= 0x41000014) — the + /// same Fallen-exact / Crouch..Sleeping-range predicate, just phrased as + /// its own negation plus the explicit Fallen exact-match up front. + /// Ported literally rather than reusing + /// to keep each function's control flow traceable to its own raw + /// address. + /// + /// + /// + /// Caller (outside CMotionInterp, raw line 376144, 0x0056afac — the + /// player-input/SmartBox layer, out of R3 scope): drives the charge + /// accumulation loop while spacebar is held. acdream's charge + /// accumulation stays controller-side (AP-24 register row survives); + /// PlayerMovementController may call this once wired (W4/W6 — no + /// regression today since nothing calls ChargeJump yet, so + /// remotes/local both continue unaffected). + /// + /// + public WeenieError ChargeJump() + { + if (WeenieObj is not null && !WeenieObj.CanJump(JumpExtent)) + return WeenieError.CantJumpLoadedDown; // 0x49 + + uint forward = InterpretedState.ForwardCommand; + if (forward == MotionCommand.Fallen + || (forward > MotionCommand.CrouchLowerBound && forward <= MotionCommand.Sleeping)) + return WeenieError.YouCantJumpFromThisPosition; // 0x48 + + if (PhysicsObj is not null) + { + bool onGround = PhysicsObj.TransientState.HasFlag(TransientStateFlags.Contact) + && PhysicsObj.TransientState.HasFlag(TransientStateFlags.OnWalkable); + if (onGround + && forward == MotionCommand.Ready + && InterpretedState.SideStepCommand == 0 + && InterpretedState.TurnCommand == 0) + { + StandingLongJump = true; + } + } + + return WeenieError.None; + } + + // ── FUN_00528780 — jump ─────────────────────────────────────────────────── /// /// Initiate a jump: validate, store jump extent, leave the ground. /// - /// Decompiled logic (FUN_00529390): - /// if (PhysicsObj == null) return 8 - /// FUN_00510cc0() — cancel moveto - /// iVar1 = FUN_00528ec0(extent, stamina) ← jump_is_allowed - /// if (iVar1 == 0): - /// *(+0x74) = extent ← JumpExtent - /// FUN_00511de0(0) ← PhysicsObj.set_on_walkable(false) - /// return 0 - /// *(+0x70) = 0 ← StandingLongJump = false - /// return iVar1 + /// + /// Verbatim (0x00528780, decomp §3f @305792): + /// + /// physics_obj = this->physics_obj; + /// if (physics_obj == 0) return 8; + /// interrupt_current_movement(physics_obj); + /// result = jump_is_allowed(this, arg2, arg3); + /// if (result != 0) { + /// this->standing_longjump = 0; + /// return result; + /// } + /// this->jump_extent = arg2; + /// set_on_walkable(physics_obj, 0); + /// return result; // == 0 + /// + /// + /// + /// + /// R3-W3 (closes J7-interp-side): interrupt_current_movement is + /// now called UNCONDITIONALLY before , via + /// the no-op seam (register row — + /// R4 wires the real cancel_moveto). is + /// cleared ONLY on the failure path — a successful jump leaves it + /// untouched (the caller/LeaveGround owns clearing it on success). + /// /// public WeenieError jump(float extent, int adjustStamina = 0) { if (PhysicsObj is null) return WeenieError.NoPhysicsObject; - var result = jump_is_allowed(extent, adjustStamina); + InterruptCurrentMovement?.Invoke(); + + var result = jump_is_allowed(extent, out _); if (result == WeenieError.None) { JumpExtent = extent; @@ -705,25 +2024,29 @@ public sealed class MotionInterpreter return result; } - // ── FUN_005286b0 — get_jump_v_z ────────────────────────────────────────── + // ── FUN_00527aa0 — get_jump_v_z ────────────────────────────────────────── /// /// Get the vertical (Z) component of jump velocity. /// - /// Decompiled logic (FUN_005286b0): - /// local_4 = *(+0x74) ← JumpExtent - /// if local_4 < _DAT_007c9734 (epsilon): return _DAT_00796344 (0.0) - /// if local_4 > _DAT_007938b0 (1.0): local_4 = 1.0 - /// if WeenieObj == null: return _DAT_0079c6d4 (10.0) — default jump v_z - /// cVar1 = InqJumpVelocity(local_4, &local_4) — vtable +0x30 - /// if (cVar1 != 0): return local_4 - /// return _DAT_00796344 (0.0) + /// + /// Verbatim (0x00527aa0, decomp §3c @304953, W0-pins.md A5 — the BN text + /// is x87-flag garbled; ACE's clean-room reading adjudicates): + /// + /// extent = this->jump_extent; + /// if (extent < 0.000199999995f) return 0.0f; + /// if (extent > 1.0f) extent = 1.0f; + /// if (this->weenie_obj == 0) return 10.0f; + /// if (weenie_obj.InqJumpVelocity(extent, &extent) != 0) return extent; + /// return 0.0f; + /// + /// /// - public float get_jump_v_z() + public float GetJumpVZ() { float extent = JumpExtent; - if (extent < JumpExtentEpsilon) + if (extent < JumpVzEpsilon) return 0.0f; if (extent > MaxJumpExtent) @@ -738,34 +2061,31 @@ public sealed class MotionInterpreter return 0.0f; } - // ── FUN_00528cd0 — get_leave_ground_velocity ────────────────────────────── + // ── FUN_005280c0 — get_leave_ground_velocity ────────────────────────────── /// /// Compose the full 3D body-local launch velocity when leaving the ground. /// - /// Decompiled logic (FUN_00528cd0): - /// FUN_00528960(velocity) ← get_state_velocity (XY components) - /// velocity.Z = get_jump_v_z() - /// If all three components are < epsilon (nearly zero velocity): - /// Apply the orientation matrix rows of PhysicsObj to the current - /// world-space velocity (rotate world vel into body-local frame). - /// This preserves momentum direction when jumping while stationary. - /// return velocity - /// - /// The "near-zero" fast path uses the body's current velocity transformed - /// back into local space, which in our port is - /// Vector3.Transform(Velocity, Quaternion.Inverse(Orientation)). + /// + /// Verbatim (0x005280c0, decomp §3d @305404, W0-pins.md A6): body order + /// is get_state_velocity(esi) → esi.z = get_jump_v_z() → + /// fallback fires ONLY when |x| AND |y| AND |z| are ALL + /// < 0.000199999995f (epsilon tested three times, one per + /// component), and then OVERWRITES ALL THREE components (including the + /// z the function just computed) with + /// globaltolocal(physics_obj->m_velocityVector) — decisively + /// pinned as GLOBAL→LOCAL by the row-linear match against + /// Frame::globaltolocalvec (A6). The existing + /// Vector3.Transform(Velocity, Quaternion.Inverse(Orientation)) + /// transform already IS global→local — kept unchanged. + /// /// - public Vector3 get_leave_ground_velocity() + public Vector3 GetLeaveGroundVelocity() { var velocity = get_state_velocity(); - velocity.Z = get_jump_v_z(); + velocity.Z = GetJumpVZ(); - // If the lateral + vertical components are all tiny, fall back to the - // current world velocity projected into body-local space so that an - // airborne nudge preserves direction (retail decompile: matrix multiply - // of the orientation column vectors against the world velocity). - float eps = JumpExtentEpsilon; + float eps = JumpVzEpsilon; if (MathF.Abs(velocity.X) < eps && MathF.Abs(velocity.Y) < eps && MathF.Abs(velocity.Z) < eps && PhysicsObj is not null) { @@ -776,46 +2096,116 @@ public sealed class MotionInterpreter return velocity; } - // ── FUN_00528ec0 — jump_is_allowed ──────────────────────────────────────── + // ── FUN_005282b0 — jump_is_allowed ──────────────────────────────────────── /// - /// Determine whether a jump is currently permitted. + /// Determine whether a jump is currently permitted. R3-W3 (closes J5): + /// FULL verbatim chain replacing the pre-W3 15-line approximation — + /// entry shape, IsFullyConstrained, the pending-head peek (A2), + /// the charge→motion→stamina chain, all now present. /// - /// Decompiled logic (FUN_00528ec0): - /// if PhysicsObj == null: return 0x24 - /// if WeenieObj == null: proceed (no weenie check) - /// elif WeenieObj.IsCreature() returns false: proceed - /// iVar2 = PhysicsObj - /// if Gravity flag NOT set OR (Contact AND OnWalkable): ← grounded or no gravity - /// return 0x24 (GeneralMovementFailure) - /// if FUN_0050f730() (IsFullyConstrained) != 0: return 0x47 - /// if pending queue action has non-zero jump error: return that error - /// iVar2 = FUN_00528660() (jump_charge_is_allowed) - /// if iVar2 == 0: - /// iVar2 = FUN_005285e0(InterpretedState.ForwardCommand) (motion_allows_jump) - /// if iVar2 == 0 AND WeenieObj != null: - /// cVar1 = WeenieObj.CanJump(extent, stamina) → vtable +0x40 - /// if cVar1 == 0: return 0x47 - /// return iVar2 + /// + /// Verbatim (0x005282b0, decomp §3h, W0-pins.md A2/A10): + /// + /// if (physics_obj != 0) { + /// if (weenie_obj != 0) eax_2 = weenie_obj.IsCreature(); + /// if (weenie_obj != 0 && eax_2 == 0) goto shared_gate; // non-creature weenie skips ground gate + /// if (physics_obj == 0 || (state bit 0x400) == 0) goto shared_gate; // gravity-state off skips ground gate + /// if (Contact && OnWalkable) goto shared_gate; // grounded also reaches shared gate + /// } + /// return 0x24; // gravity-bound creature, not grounded + /// + /// shared_gate: + /// if (IsFullyConstrained(physics_obj) != 0) return 0x47; + /// head = pending_motions.head_; + /// if (head != 0) eax_6 = head.jump_error_code; // +0xc + /// if (head == 0 || eax_6 == 0) { + /// eax_6 = jump_charge_is_allowed(this); + /// if (eax_6 == 0) { + /// eax_7 = motion_allows_jump(this, interpreted_state.forward_command); + /// if (eax_7 != 0) return eax_7; + /// if (weenie_obj_1 == 0) return eax_7; // == 0 (success, no weenie to consult) + /// eax_6 = 0x47; + /// if (weenie_obj_1.JumpStaminaCost(arg2, arg3) != 0) return eax_7; // == 0 (afforded) + /// // JumpStaminaCost returned false -> falls out, eax_6 stays 0x47 + /// } + /// } + /// return eax_6; + /// + /// + /// + /// + /// A10 note: physics_obj == null returns 0x24 (NotGrounded), + /// NOT 8 — the "8 = no physics obj" convention that holds + /// everywhere else in CMotionInterp does not hold here (the + /// if (physics_obj != 0) {...} wrapper falls out to + /// return 0x24 when physics_obj is null, same as the grounded-check + /// failure path). + /// /// - public WeenieError jump_is_allowed(float extent, int staminaCost) + /// Jump charge fraction, forwarded to + /// JumpStaminaCost. + /// Out-param mirroring retail's arg3 + /// (int32_t*) — the stamina cost JumpStaminaCost computed, + /// 0 when the chain never reaches that call. + public WeenieError jump_is_allowed(float extent, out int staminaCost) { - if (PhysicsObj is null) - return WeenieError.GeneralMovementFailure; + staminaCost = 0; - // Must have gravity and be grounded (Contact + OnWalkable) to start a jump. - bool hasGravity = PhysicsObj.State.HasFlag(PhysicsStateFlags.Gravity); - bool isGrounded = PhysicsObj.TransientState.HasFlag(TransientStateFlags.Contact) - && PhysicsObj.TransientState.HasFlag(TransientStateFlags.OnWalkable); + if (PhysicsObj is not null) + { + bool nonCreatureWeenie = WeenieObj is not null && !WeenieObj.IsCreature(); + bool gravityStateOff = !PhysicsObj.State.HasFlag(PhysicsStateFlags.Gravity); + bool grounded = PhysicsObj.TransientState.HasFlag(TransientStateFlags.Contact) + && PhysicsObj.TransientState.HasFlag(TransientStateFlags.OnWalkable); - if (!hasGravity || !isGrounded) - return WeenieError.YouCantJumpWhileInTheAir; + if (nonCreatureWeenie || gravityStateOff || grounded) + return JumpIsAllowedSharedGate(extent, ref staminaCost); + } - // Delegate jump eligibility to WeenieObj if present. - if (WeenieObj is not null && !WeenieObj.CanJump(extent)) - return WeenieError.CantJumpLoadedDown; + return WeenieError.NotGrounded; // 0x24 — gravity-bound creature, not grounded (also physics_obj == null) + } - return WeenieError.None; + /// + /// The shared_gate label inside + /// (raw 305524-305556) — split out only for C# readability; retail + /// reaches this point via three different goto sites, all folded + /// into one function here since C# has no goto-into-shared-tail idiom + /// as clean as retail's. + /// + private WeenieError JumpIsAllowedSharedGate(float extent, ref int staminaCost) + { + if (PhysicsObj is not null && PhysicsObj.IsFullyConstrained) + return WeenieError.GeneralMovementFailure; // 0x47 + + // A2: peek the pending_motions head WHENEVER non-empty — no Count>1 + // gate. A nonzero head.JumpErrorCode short-circuits the whole + // charge/motion/stamina chain below. + var head = _pendingMotions.First; + uint peeked = head is not null ? head.Value.JumpErrorCode : 0; + + if (head is null || peeked == 0) + { + WeenieError chargeResult = JumpChargeIsAllowed(extent); + if (chargeResult == WeenieError.None) + { + WeenieError motionResult = MotionAllowsJump(InterpretedState.ForwardCommand); + if (motionResult != WeenieError.None) + return motionResult; + + if (WeenieObj is null) + return motionResult; // == None + + if (!WeenieObj.JumpStaminaCost(extent, out staminaCost)) + return WeenieError.GeneralMovementFailure; // 0x47 — can't afford + + return motionResult; // == None (success) + } + + return chargeResult; + } + + return (WeenieError)peeked; } // ── FUN_00528dd0 — contact_allows_move ──────────────────────────────────── @@ -823,115 +2213,512 @@ public sealed class MotionInterpreter /// /// Determine whether the current contact state allows this motion command. /// - /// Decompiled logic (FUN_00528dd0): - /// if WeenieObj != null AND WeenieObj.CanJump(JumpExtent) returns false: - /// return 0x49 - /// uVar1 = InterpretedState.ForwardCommand - /// if uVar1 == 0x40000008 (Fallen) OR uVar1 == 0x40000011 (Dead): - /// return 0x48 - /// if 0x41000011 < uVar1 < 0x41000015 (crouch/sit/sleep range): - /// return 0x48 - /// uVar2 = PhysicsObj.TransientState - /// if (Contact AND OnWalkable) AND ForwardCommand == Ready - /// AND SideStepCommand == 0 AND TurnCommand == 0: - /// StandingLongJump = true - /// return 0 + /// + /// Decompiled logic (0x00528240, pseudo-C 305471): allowed (1) when — + /// motion is TurnRight/TurnLeft (0x6500000D/0E), OR motion is Falling + /// (0x40000015) or Dead-class (0x40000011), OR the weenie exists and is + /// NOT a creature, OR gravity is off, OR the body has Contact + + /// OnWalkable. Everything else (a gravity-bound creature without ground + /// contact) is blocked — this is the real mechanism behind "airborne + /// remotes keep their cycle" (K-fix17's empirical guard). + /// /// - /// The return type in the decompile is undefined4 (int), but ACE models it - /// as bool (0 = allowed, non-zero = blocked). We model it as bool here for - /// cleaner call sites, treating any non-zero return as "blocked". + /// + /// The return type in the decompile is undefined4 (int), but ACE models + /// it as bool (0 = allowed, non-zero = blocked). We model it as bool + /// here for cleaner call sites, treating any non-zero return as + /// "blocked". + /// + /// + /// + /// R3-W3 (closes J6): the StandingLongJump side effect that used to + /// live here is DELETED. The S2a port had flagged it explicitly as + /// "PRE-EXISTING acdream side effect (not part of 0x00528240)" — a + /// misattribution: retail's contact_allows_move (0x00528240) + /// never reads or writes standing_longjump at all. The real + /// arming site is (0x005281c0, decomp §3e), + /// which now owns the identical grounded+idle predicate exclusively. + /// Consequence of the OLD bug this retires: every grounded idle contact + /// check (i.e. every frame the player stood still, since + /// ApplyInterpretedMovement calls this every dispatch) flipped + /// the flag regardless of whether a jump charge was ever started — + /// is the only path that can arm it now. + /// /// public bool contact_allows_move(uint motion) { if (PhysicsObj is null) return false; - // Turn commands are always allowed regardless of ground contact. - // (Decompile doesn't explicitly early-return for turns here, but - // ACE and the general shape of the code confirm they bypass the block.) - if (motion == MotionCommand.TurnRight || motion == MotionCommand.TurnLeft) - return true; - - // Dead or Fallen forward-command blocks movement. - uint fwd = InterpretedState.ForwardCommand; - if (fwd == MotionCommand.Fallen || fwd == MotionCommand.Dead) - return false; - - // Crouch / sit / sleep range (0x41000011 < fwd < 0x41000015). - if (fwd > MotionCommand.CrouchLowerBound && fwd < MotionCommand.CrouchUpperExclusive) - return false; - - // Need Gravity flag + Contact + OnWalkable for ground-based motion. - if (!PhysicsObj.State.HasFlag(PhysicsStateFlags.Gravity)) - return true; // no gravity → object can always move (swimming, flying) - - bool contact = PhysicsObj.TransientState.HasFlag(TransientStateFlags.Contact); - bool onWalkable = PhysicsObj.TransientState.HasFlag(TransientStateFlags.OnWalkable); - - if (!contact) - return false; - - if (!onWalkable) - return false; - - // Grounded and idle — flag as standing-long-jump candidate. - if (fwd == MotionCommand.Ready - && InterpretedState.SideStepCommand == 0 - && InterpretedState.TurnCommand == 0) + if (motion > 0x40000015u) { - StandingLongJump = true; + if (motion is MotionCommand.TurnRight or MotionCommand.TurnLeft) + return true; + } + else if (motion == MotionCommand.Falling || motion == 0x40000011u) + { + return true; } - return true; + if (WeenieObj is not null && !WeenieObj.IsCreature()) + return true; + + if (!PhysicsObj.State.HasFlag(PhysicsStateFlags.Gravity)) + return true; + + bool grounded = PhysicsObj.TransientState.HasFlag(TransientStateFlags.Contact) + && PhysicsObj.TransientState.HasFlag(TransientStateFlags.OnWalkable); + + return grounded; } - // ── FUN_00529710 — LeaveGround ──────────────────────────────────────────── + // ── R3-W2 — pending_motions lifecycle ───────────────────────────────── + // docs/research/2026-07-02-r3-motioninterp/r3-motioninterp-decomp.md §1. /// - /// Called when the body becomes airborne. Applies the leave-ground velocity - /// and resets the jump state. + /// CMotionInterp::add_to_queue (0x00527b80, decomp §1a @305032): + /// allocate a and append it to the tail of + /// (retail: append at tail; if the queue was + /// empty, head and tail both point at the new node — the C# + /// gives this for free via + /// AddLast). + /// + /// Retail arg2 — MotionNode.context_id. + /// Retail arg3 — MotionNode.motion. + /// Retail arg4 — MotionNode.jump_error_code. + public void AddToQueue(uint contextId, uint motion, uint jumpErrorCode) + { + _pendingMotions.AddLast(new MotionNode(contextId, motion, jumpErrorCode)); + } + + /// + /// CMotionInterp::motions_pending (0x00527fe0, decomp §1b + /// @305322): pending_motions.head_ != null. + /// + public bool MotionsPending() => _pendingMotions.First is not null; + + /// + /// CMotionInterp::MotionDone (0x00527ec0, decomp §1c @305238, + /// FULL BODY). A7 (W0-pins.md): and + /// are read into locals by the decompiled + /// relay chain but NEVER actually used by this build's body — the queue + /// head is popped UNCONDITIONALLY, never matched by motion id. Params + /// are kept for R5 signature parity with the real + /// MovementManager::MotionDone relay. /// - /// Decompiled logic (FUN_00529710): - /// if PhysicsObj == null: return - /// velocity = get_leave_ground_velocity() - /// PhysicsObj.set_local_velocity(velocity) - /// StandingLongJump = false - /// JumpExtent = 0 + /// + /// Body (verbatim): no-op if is null or the + /// queue is empty. Peek the HEAD: if head.Motion & 0x10000000 + /// (the action-class bit) is set, fire + /// then pop the head of BOTH + /// 's and 's action + /// FIFOs. Then unconditionally dequeue the pending_motions head. + /// + /// + public void MotionDone(uint motion, bool success) + { + if (PhysicsObj is null) + return; + + var head = _pendingMotions.First; + if (head is null) + return; + + if ((head.Value.Motion & 0x10000000u) != 0) + { + UnstickFromObject?.Invoke(); + InterpretedState.RemoveAction(); + RawState.RemoveAction(); + } + + // Re-peek per retail's structure (head__1 = this->pending_motions.head_, + // a fresh read after the action-class branch above) — functionally + // the same node since nothing else can mutate the queue mid-call. + var head1 = _pendingMotions.First; + if (head1 is not null) + { + _pendingMotions.RemoveFirst(); + } + } + + /// + /// CMotionInterp::HandleExitWorld (0x00527f30, decomp §1d): + /// identical body to 's single-pop logic, looped + /// until drains — world exit flushes all + /// pending motion callbacks unconditionally, since no more + /// animation-completion events will arrive. + /// + /// + /// Ambiguity resolved (not in W0-pins.md — found while porting): + /// the raw decompile's loop condition is head_ != 0 + /// (re-read every iteration), but the pop only happens inside a NESTED + /// if (physics_obj != 0 && head_ != 0) guard — a literal + /// translation would infinite-loop if were null + /// with a non-empty queue (the loop variable never advances). This is + /// dead code in retail: a live CMotionInterp::HandleExitWorld call + /// only ever happens on an interp already bound to a physics_obj + /// (retail's CMotionInterp lifetime is physics-object-scoped) — + /// the null check exists defensively, not as a real "still drain, but + /// skip the pop" branch. Porting a genuine infinite loop is not + /// "faithful", it's a bug retail never actually exercises; this port + /// drains unconditionally regardless of (same + /// choice / already + /// make — they too are called before a physics_obj may exist during + /// interp construction/testing). + /// + /// + public void HandleExitWorld() + { + while (_pendingMotions.First is not null) + { + var head = _pendingMotions.First!; + if ((head.Value.Motion & 0x10000000u) != 0) + { + UnstickFromObject?.Invoke(); + InterpretedState.RemoveAction(); + RawState.RemoveAction(); + } + + _pendingMotions.RemoveFirst(); + } + } + + /// + /// CMotionInterp::is_standing_still (0x00527fa0, decomp @305309): + /// on-ground (Contact + OnWalkable) AND ForwardCommand == Ready AND + /// SideStepCommand == 0 AND TurnCommand == 0. + /// + public bool IsStandingStill() + { + if (PhysicsObj is null) + return false; + + bool grounded = PhysicsObj.TransientState.HasFlag(TransientStateFlags.Contact) + && PhysicsObj.TransientState.HasFlag(TransientStateFlags.OnWalkable); + if (!grounded) + return false; + + return InterpretedState.ForwardCommand == MotionCommand.Ready + && InterpretedState.SideStepCommand == 0 + && InterpretedState.TurnCommand == 0; + } + + /// + /// CMotionInterp::motion_allows_jump (0x005279e0, decomp §3a + /// @304908, __pure). A1 (W0-pins.md, adversarially verified): + /// PINNED as a BLOCKLIST — 0 = jump allowed (pass), 0x48 = + /// jump BLOCKED. Ported as literal uint range comparisons mirroring the + /// decomp's exact branch algebra (NOT enum-ordinal ranges — the whole + /// point of A1 is that ACE's enum-order dependence is fragile). + /// + /// + /// Blocklist (definitive table, W0-pins.md §A1): + /// + /// [0x1000006f, 0x10000078] — MagicPowerUp01..MagicPowerUp10. + /// [0x10000128, 0x10000131] — TripleThrustLow..MagicPowerUp07Purple. + /// 0x40000008 exact — Fallen (NOT Falling; ACE mis-transcribed this). + /// [0x40000016, 0x40000018] — Reload, Unload, Pickup. + /// [0x4000001e, 0x40000039] — AimLevel..MagicPray. + /// [0x41000012, 0x41000014] — Crouch, Sitting, Sleeping. + /// + /// Everything else — including Falling 0x40000015, Ready + /// 0x41000003, Dead 0x40000011, all turn/sidestep ids — PASSES. + /// + /// + /// + /// This is a pure function (no instance state) — retail's this + /// parameter is unused in the body (the decomp's __pure + /// attribute confirms it doesn't read this). + /// + /// + /// Retail arg2 — the motion id to test. + public static WeenieError MotionAllowsJump(uint motion) + { + // Verbatim branch algebra from raw 304908-304931 (W0-pins.md §A1): + // if (arg2 > 0x40000018) { + // if (arg2 > 0x41000014) return 0; + // if (arg2 < 0x41000012 && (arg2 < 0x4000001e || arg2 > 0x40000039)) return 0; + // } else if (arg2 < 0x40000016) { + // if (arg2 > 0x10000131) { + // if (arg2 != 0x40000008) return 0; + // } else if (arg2 < 0x10000128 && (arg2 < 0x1000006f || arg2 > 0x10000078)) return 0; + // } + // return 0x48; + // + // The middle band [0x40000016, 0x40000018] satisfies NEITHER outer + // branch (not > 0x40000018, not < 0x40000016) and falls straight to + // `return 0x48` — a genuine "no early return" gap in the middle. + if (motion > 0x40000018u) + { + if (motion > 0x41000014u) + return WeenieError.None; + if (motion < 0x41000012u && (motion < 0x4000001eu || motion > 0x40000039u)) + return WeenieError.None; + } + else if (motion < 0x40000016u) + { + if (motion > 0x10000131u) + { + if (motion != 0x40000008u) + return WeenieError.None; + } + else if (motion < 0x10000128u && (motion < 0x1000006fu || motion > 0x10000078u)) + { + return WeenieError.None; + } + } + + return WeenieError.YouCantJumpFromThisPosition; + } + + // ── FUN_00528b00 — LeaveGround ──────────────────────────────────────────── + + /// + /// CMotionInterp::LeaveGround (0x00528b00, decomp §4b @306022, + /// FULL BODY — replaces the pre-W4 approximation, closes J8's + /// LeaveGround leg). Called when the body becomes airborne (also + /// tail-called unconditionally from , + /// §4d). + /// + /// + /// Verbatim (raw 306022-306040, quoted in full in the final-report): + /// creature gate (weenie_obj == 0 || IsCreature() != 0) AND + /// state-0x400 (Gravity) gate — SAME shape as . + /// When both pass: compute the launch velocity via + /// , apply it with + /// set_local_velocity(&v, autonomous=1) (the literal + /// 1 arg — + /// becomes true), reset and + /// to their zero/false defaults (the jump + /// charge is consumed the instant you actually leave the ground), then + /// + apply_current_movement(0, + /// 0) (the same re-sync performs). + /// /// public void LeaveGround() { if (PhysicsObj is null) return; - var velocity = get_leave_ground_velocity(); - PhysicsObj.set_local_velocity(velocity); + bool isCreature = WeenieObj is null || WeenieObj.IsCreature(); + if (!isCreature) + return; + + if (!PhysicsObj.State.HasFlag(PhysicsStateFlags.Gravity)) + return; + + var velocity = GetLeaveGroundVelocity(); + PhysicsObj.set_local_velocity(velocity, autonomous: true); StandingLongJump = false; JumpExtent = 0f; + + RemoveLinkAnimations?.Invoke(); + // Raw (0, 0) → allowJump: true (#161 polarity decode). + apply_current_movement(cancelMoveTo: false, allowJump: true); } - // ── FUN_005296d0 — HitGround ────────────────────────────────────────────── + // ── FUN_00528ac0 — HitGround ────────────────────────────────────────────── /// - /// Called when the body lands on a walkable surface. + /// CMotionInterp::HitGround (0x00528ac0, decomp §4a @305996, + /// FULL BODY — replaces the pre-W4 approximation, closes J8's + /// HitGround leg). Called when the body lands on a walkable surface. /// - /// Decompiled logic (FUN_005296d0): - /// if PhysicsObj == null: return - /// if WeenieObj != null AND NOT creature: return - /// if Gravity flag not set: return - /// apply_current_movement(false, true) + /// + /// Verbatim (raw 305996-306014): + /// + /// if (physics_obj != 0) { + /// if (weenie_obj != 0) eax_2 = weenie_obj->IsCreature(); + /// if (weenie_obj == 0 || eax_2 != 0) { + /// if (physics_obj != 0 && (state & 0x400) != 0) { + /// RemoveLinkAnimations(physics_obj); + /// apply_current_movement(this, 0, 0); + /// } + /// } + /// } + /// + /// + /// + /// + /// A3 note: this creature gate uses IsCreature (vtable +0x2c), + /// NOT IsThePlayer (+0x14) — the anti-artifact proof for A3's + /// pin (BN distinguishes the two slots locally, ~0x250 bytes from the + /// IsThePlayer-gated functions). + /// /// public void HitGround() { if (PhysicsObj is null) return; + bool isCreature = WeenieObj is null || WeenieObj.IsCreature(); + if (!isCreature) + return; + if (!PhysicsObj.State.HasFlag(PhysicsStateFlags.Gravity)) return; + RemoveLinkAnimations?.Invoke(); + // Raw (0, 0) → allowJump: true (#161 polarity decode). The + // re-apply dispatches the PRESERVED interpreted forward command + // (the apply pass never writes it — ModifyInterpretedState=false) + // — this IS the falling-pose exit on landing. apply_current_movement(cancelMoveTo: false, allowJump: true); } + // ── FUN_00528c80 — enter_default_state ──────────────────────────────────── + + /// + /// CMotionInterp::enter_default_state (0x00528c80, decomp §4d + /// @306124, FULL BODY, W0-pins.md A8, closes J10). Resets both motion + /// states to fresh defaults, re-initializes the physics object's + /// motion tables, APPENDS the canonical {0, Ready, 0} sentinel + /// to (NO drain — pre-existing queued + /// nodes survive, A8), marks , then tail-calls + /// unconditionally. + /// + /// + /// Verbatim (raw 306124-306154): + /// + /// raw_state = RawMotionState(); // fresh ctor defaults + /// interpreted_state = InterpretedMotionState(); // fresh ctor defaults + /// CPhysicsObj::InitializeMotionTables(physics_obj); + /// node = new MotionNode { context_id=0, motion=0x41000003, jump_error_code=0 }; + /// pending_motions.append(node); // tail-splice, NO clear + /// initted = 1; + /// LeaveGround(this); + /// + /// + /// + /// + /// Retail's real construction paths (MovementManager::Create + + /// the lazy-create guard at every MovementManager entry point) + /// call this exactly once (or twice on the lazy-create double-call — + /// §6g, genuine retail, not "fixed") before exposing the interpreter to + /// any caller. acdream's constructors default to + /// true directly (see that property's doc comment) rather than + /// routing every construction through this method, so this port is the + /// verbatim, fully-testable "reset to default/idle state" operation — + /// callers that want retail's FULL reset semantics (state defaults + + /// sentinel + LeaveGround tail), not just the Initted flag, call + /// this explicitly. + /// + /// + public void EnterDefaultState() + { + RawState = new RawMotionState(); + InterpretedState = InterpretedMotionState.Default(); + + InitializeMotionTables?.Invoke(); + + AddToQueue(contextId: 0, MotionCommand.Ready, jumpErrorCode: 0); + + Initted = true; + + LeaveGround(); + } + + // ── FUN_00528b70 / FUN_00528bb0 — set_hold_run / SetHoldKey ──────────────── + + /// + /// CMotionInterp::set_hold_run (0x00528b70, decomp §5c @306053, + /// FULL BODY, closes J13's set_hold_run leg). XOR toggle guard: only + /// acts when actually FLIPS the current + /// effective hold-run state (skip redundant re-application). + /// + /// + /// Verbatim (raw 306053-306070): + /// + /// eax = (arg2 == 0); // "run key is up" + /// edx = (raw_state.current_holdkey != Run); + /// if (eax != edx) { // XOR: state actually changes + /// raw_state.current_holdkey = (arg2 != 0) + 1; // false->1(None), true->2(Run) + /// apply_current_movement(this, arg3, 0); + /// } + /// + /// + /// + /// Retail arg2 — nonzero = the run key + /// is currently held down. + /// Retail arg3 — passed through as + /// apply_current_movement's cancelMoveTo arg. + public void set_hold_run(bool holdingRun, bool interrupt) + { + bool runKeyUp = !holdingRun; + bool notCurrentlyRun = RawState.CurrentHoldKey != HoldKey.Run; + + if (runKeyUp != notCurrentlyRun) + { + RawState.CurrentHoldKey = holdingRun ? HoldKey.Run : HoldKey.None; + // Raw (arg3, 0) → allowJump: true (#161 polarity decode). + apply_current_movement(cancelMoveTo: interrupt, allowJump: true); + } + } + + /// + /// CMotionInterp::SetHoldKey (0x00528bb0, decomp §5d @306072, + /// FULL BODY, closes J13's SetHoldKey leg). No-op if + /// already equals . + /// Setting only takes effect (and + /// re-applies movement) if the CURRENT hold key is + /// — requesting None while already something + /// else (e.g. Invalid) is silently ignored. Setting + /// takes effect whenever the current key + /// isn't already Run. + /// + /// + /// Verbatim (raw 306072-306095): + /// + /// current = raw_state.current_holdkey; + /// if (arg2 != current) { + /// if (arg2 == HoldKey_None) { + /// if (current == HoldKey_Run) { + /// raw_state.current_holdkey = HoldKey_None; + /// apply_current_movement(this, arg3, 0); + /// } + /// } else if (arg2 == HoldKey_Run && current != HoldKey_Run) { + /// raw_state.current_holdkey = HoldKey_Run; + /// apply_current_movement(this, arg3, 0); + /// } + /// } + /// + /// + /// + /// + /// This is the function DoMotion (W5) calls when bit + /// 0x800 (SetHoldKey) of the incoming MovementParameters + /// requests a hold-key change, and what + /// reads back via (mirrored + /// onto — see the field doc) to decide + /// whether fires. + /// + /// + /// Retail arg2. + /// Retail arg3 — passed through as + /// apply_current_movement's cancelMoveTo arg. + public void SetHoldKey(HoldKey key, bool cancelMoveTo) + { + HoldKey current = RawState.CurrentHoldKey; + if (key == current) + return; + + if (key == HoldKey.None) + { + if (current == HoldKey.Run) + { + RawState.CurrentHoldKey = HoldKey.None; + // Raw (arg3, 0) → allowJump: true (#161 polarity decode). + apply_current_movement(cancelMoveTo, allowJump: true); + } + } + else if (key == HoldKey.Run && current != HoldKey.Run) + { + RawState.CurrentHoldKey = HoldKey.Run; + apply_current_movement(cancelMoveTo, allowJump: true); + } + } + // ── CMotionInterp::get_max_speed (0x00527cb0) ───────────────────────────── /// @@ -979,40 +2766,541 @@ public sealed class MotionInterpreter return RunAnimSpeed * rate; } - // ── private helper ──────────────────────────────────────────────────────── + // R3-W5: the former `ApplyMotionToInterpretedState` private helper + // (a hand-rolled switch approximating InterpretedMotionState.ApplyMotion) + // is DELETED per the plan (closes J3/J4) — the merged DoInterpretedMotion + // below calls the verbatim InterpretedMotionState.ApplyMotion(motion, p) + // directly (already ported, W1). + + // ══ L.2g S2 — the inbound CMotionInterp funnel (DEV-1) ════════════════ + // Spec: docs/research/2026-07-02-s2-inbound-funnel-pseudocode.md. + // Dispatch order validated against the LIVE retail-observer cdb trace + // (tools/cdb/l2g-observer.cdb): style → forward → sidestep(-stop) → + // turn(-stop) → actions, wholesale per UM. /// - /// Apply a motion command to the interpreted state fields. - /// Mirrors the InterpretedState.ApplyMotion logic in ACE. + /// True when this interpreter belongs to the LOCAL player. Retail skips + /// replaying AUTONOMOUS actions on the local player (they are its own + /// echo — move_to_interpreted_state 305977) but applies them on remotes. /// - private void ApplyMotionToInterpretedState(uint motion, float speed) + public bool IsLocalPlayer; + + /// + /// CMotionInterp::server_action_stamp — 15-bit wraparound stamp + /// of the last applied inbound action (move_to_interpreted_state + /// 305953-305989). + /// + public int ServerActionStamp; + + /// + /// CMotionInterp::move_to_interpreted_state (0x005289c0, + /// pseudo-C 305936): adopt the style into the raw state, FLAT-copy the + /// incoming interpreted state (copy_movement_from 0x0051e750 — + /// every axis overwritten, defaults included), re-apply the whole + /// movement through the sink, then replay fresh actions under the + /// 15-bit stamp gate. + /// + /// + /// R3-W4 (Adjacent finding, W0-pins.md): raw 305946-305949 + /// computes eax_2 = motion_allows_jump(this->interpreted_state.forward_command) + /// — the OLD forward command, BEFORE copy_movement_from + /// overwrites two lines later — then + /// calls apply_current_movement(this, 1, allowJump) where + /// allowJump = (eax_2 == 0) (the raw's own + /// -((esi_1 - esi_1)) is decompiler noise for that same + /// boolean). Ported here as on the + /// PRE-overwrite .ForwardCommand, + /// snapshotted before the flat-copy below. Passed through to + /// per its TODO(W5) — this + /// funnel calls the interpreted body directly (not the + /// dual-dispatch gate), matching + /// the existing S2 architecture: inbound funnel state is always + /// server-authoritative, so it always wants the interpreted path + /// regardless of IsThePlayer/autonomous. + /// + /// + public int MoveToInterpretedState(in InboundInterpretedState ims, IInterpretedMotionSink? sink = null) { - switch (motion) + if (PhysicsObj is null) return 0; + + RawState.CurrentStyle = ims.CurrentStyle; + + // motion_allows_jump on the OLD forward_command, BEFORE the + // flat-copy below overwrites it (Adjacent finding). + bool allowJump = MotionAllowsJump(InterpretedState.ForwardCommand) == WeenieError.None; + + // copy_movement_from — flat overwrite, no per-field presence checks. + // current_style is the FIRST copied field (raw 0051e757) — it is + // what HitGround/LeaveGround re-applies as the style dispatch + // (#161: previously omitted, so the landing re-apply read a stale + // interpreted style). + InterpretedState.CurrentStyle = ims.CurrentStyle; + InterpretedState.ForwardCommand = ims.ForwardCommand; + InterpretedState.ForwardSpeed = ims.ForwardSpeed; + InterpretedState.SideStepCommand = ims.SideStepCommand; + InterpretedState.SideStepSpeed = ims.SideStepSpeed; + InterpretedState.TurnCommand = ims.TurnCommand; + InterpretedState.TurnSpeed = ims.TurnSpeed; + + ApplyInterpretedMovement(ims.CurrentStyle, sink, cancelMoveTo: true, allowJump: allowJump); + + if (ims.Actions is { } actions) { - case MotionCommand.WalkForward: - case MotionCommand.RunForward: - case MotionCommand.WalkBackward: - InterpretedState.ForwardCommand = motion; - InterpretedState.ForwardSpeed = speed; - break; - case MotionCommand.SideStepRight: - case MotionCommand.SideStepLeft: - InterpretedState.SideStepCommand = motion; - InterpretedState.SideStepSpeed = speed; - break; - case MotionCommand.TurnRight: - case MotionCommand.TurnLeft: - InterpretedState.TurnCommand = motion; - InterpretedState.TurnSpeed = speed; - break; - case MotionCommand.Ready: - InterpretedState.ForwardCommand = MotionCommand.Ready; - InterpretedState.ForwardSpeed = 1.0f; - InterpretedState.SideStepCommand = 0; - InterpretedState.SideStepSpeed = 1.0f; - InterpretedState.TurnCommand = 0; - InterpretedState.TurnSpeed = 1.0f; - break; + foreach (var a in actions) + { + // 15-bit wraparound "newer" gate vs server_action_stamp: + // abs diff > 0x3fff flips the comparison (305955-305969). + int incoming = a.Stamp & 0x7FFF; + int stored = ServerActionStamp & 0x7FFF; + int diff = incoming >= stored ? incoming - stored : stored - incoming; + bool newer = diff <= 0x3FFF ? stored < incoming : incoming < stored; + if (!newer) continue; + + // Local player skips its own autonomous echoes (305977). + if (IsLocalPlayer && a.Autonomous) continue; + + ServerActionStamp = incoming; + DispatchInterpretedMotion(a.Command, a.Speed, a.Autonomous, sink); + } } + + return 1; } + + /// + /// CMotionInterp::apply_interpreted_movement (0x00528600, + /// pseudo-C 305713): cache my_run_rate from a RunForward speed, + /// then dispatch style / forward-or-Falling / sidestep-or-stop / + /// turn-or-stop in retail order. A non-zero turn EARLY-RETURNS (no + /// turn-stop, no idle bookkeeping). + /// + /// + /// R3-W2 producer (closes J1's apply_interpreted_movement leg): + /// the tail turn-stop call (raw 305766-305785) is retail's + /// CPhysicsObj::StopInterpretedMotion(physics_obj, 0x6500000d, &var_2c) + /// — our call below IS + /// that dispatch. On success (eax_10 == 0, i.e. the sink accepted + /// the stop — this port has no failure signal from + /// , so it is treated as + /// always-succeeding, matching every real sink implementation which is + /// void), retail immediately re-queues the canonical "return to none" + /// node: add_to_queue(this, var_c /*uninitialized local in the raw + /// decompile — see the final-report contextId note*/, 0x41000003, eax_10) + /// where eax_10 (the stop's own return value) becomes the queued + /// node's jump_error_code — since the stop succeeded, that value + /// is 0. + /// + /// + /// + /// #161 (2026-07-03, closes R3-W4's TODO(W5)): retail builds ONE + /// MovementParameters for the whole pass + /// (MovementParameters::MovementParameters(&var_2c) @305719) + /// and then rewrites its bitfield: the "garbled tail expression" at raw + /// 305778 is the BN decompiler smearing that store into its single read + /// site — (word & 0x37ff) | (arg2&1)<<15 | + /// (arg3&1)<<17 clears bits 11/14/15 (SetHoldKey / + /// ModifyInterpretedState / CancelMoveTo), re-sets bit 15 + /// from arg2 (= ) and bit 17 from + /// arg3 (= DisableJumpDuringLink, so + /// = arg3 == 0). ACE + /// MotionInterp.cs:444-449 confirms independently. The load-bearing bit + /// is ModifyInterpretedState = false: NO dispatch issued by this + /// pass writes — the airborne Falling + /// substitution leaves the wire's forward command intact, which is what + /// lets 's re-apply dispatch the PRESERVED + /// pre-fall command (the motion table then plays the Falling→X landing + /// link — the falling-pose exit needs no wire input). The previous + /// revision dispatched with ctor-default params + /// (ModifyInterpretedState = true) — the #161 stuck-falling-pose + /// root cause, and the true mechanism behind the W6 "press W and stop + /// instantly" regression (the style dispatch could never have clobbered + /// forward_command in retail; the entry-cache workaround this body used + /// to carry is deleted — with no mid-pass state writes possible, live + /// field reads ARE retail's semantics). + /// + /// + public void ApplyInterpretedMovement( + uint currentStyle, IInterpretedMotionSink? sink, + bool cancelMoveTo = false, bool allowJump = false) + { + if (PhysicsObj is null) return; + + // Retail's rewritten var_2c (raw 305778 decoded; ACE 444-449): + // Speed is re-set per axis below, everything else rides the pass. + var p = new MovementParameters + { + SetHoldKey = false, + ModifyInterpretedState = false, + CancelMoveTo = cancelMoveTo, + DisableJumpDuringLink = !allowJump, + }; + + if (InterpretedState.ForwardCommand == MotionCommand.RunForward) + MyRunRate = InterpretedState.ForwardSpeed; + + p.Speed = 1.0f; + DoInterpretedMotion(currentStyle, p, sink); + + if (!contact_allows_move(InterpretedState.ForwardCommand)) + { + p.Speed = 1.0f; // raw 305728: var_18_2 = 0x3f800000 + DoInterpretedMotion(MotionCommand.Falling, p, sink); + } + else if (StandingLongJump) + { + p.Speed = 1.0f; + DoInterpretedMotion(MotionCommand.Ready, p, sink); + StopInterpretedMotion(MotionCommand.SideStepRight, p, sink); + } + else + { + p.Speed = InterpretedState.ForwardSpeed; + DoInterpretedMotion(InterpretedState.ForwardCommand, p, sink); + if (InterpretedState.SideStepCommand == 0) + { + StopInterpretedMotion(MotionCommand.SideStepRight, p, sink); + } + else + { + p.Speed = InterpretedState.SideStepSpeed; + DoInterpretedMotion(InterpretedState.SideStepCommand, p, sink); + } + } + + if (InterpretedState.TurnCommand != 0) + { + p.Speed = InterpretedState.TurnSpeed; + DoInterpretedMotion(InterpretedState.TurnCommand, p, sink); + return; // retail early return — no idle-stop this call + } + + // Tail (raw 305766-305786): unconditional StopInterpretedMotion(TurnRight, + // params) — the merged StopInterpretedMotion ITSELF performs the + // add_to_queue(context, Ready, 0) on success; with the pass params' + // ModifyInterpretedState=false the RemoveMotion(TurnRight) state + // clear does NOT fire (retail identical — ACE 497-498). + StopInterpretedMotion(MotionCommand.TurnRight, p, sink); + } + + /// + /// CMotionInterp::DoInterpretedMotion (0x00528360, raw + /// 305575-305631, FULL BODY, R3-W5, closes J4). THE ONE + /// DoInterpretedMotion — merges the former legacy + /// (uint, float, bool) overload's state-management with the S2a + /// funnel's DispatchInterpretedMotion sink-dispatch backend. + /// + /// + /// Verbatim (raw 305577-305631): + /// + /// if (physics_obj == 0) return 8; + /// if (contact_allows_move(arg2)) { + /// if (standing_longjump != 0 + /// && (arg2 == WalkForward || arg2 == RunForward || arg2 == SideStepRight)) + /// goto label_528440; // StandingLongJump: state-only, no dispatch, no queue + /// if (arg2 == 0x40000011 /*Dead*/) RemoveLinkAnimations(physics_obj); + /// result = sink.ApplyMotion(arg2, arg3); // CPhysicsObj::DoInterpretedMotion stand-in + /// if (result == 0) { + /// if ((arg3->bitfield & 0x20000) == 0) { // NOT DisableJumpDuringLink + /// eax_5 = motion_allows_jump(arg2); + /// if (eax_5 == 0 && (arg2 & 0x10000000) == 0) + /// eax_5 = motion_allows_jump(interpreted_state.forward_command); + /// } else eax_5 = 0x48; // DisableJumpDuringLink FORCES blocked + /// add_to_queue(arg3->context_id, arg2, eax_5); + /// if (arg3->bitfield & 0x4000 /*ModifyInterpretedState*/) + /// InterpretedMotionState::ApplyMotion(arg2, arg3); + /// } + /// } else if ((arg2 & 0x10000000) == 0) { + /// label_528440: + /// if (arg3->bitfield & 0x4000) InterpretedMotionState::ApplyMotion(arg2, arg3); + /// result = 0; + /// } else result = 0x24; + /// if (physics_obj != 0 && physics_obj->cell == 0) RemoveLinkAnimations(physics_obj); + /// return result; + /// + /// + /// + /// + /// R3-W5 finding (not in the original W0 pins — discovered while + /// porting): 's + /// bool return IS retail's result == 0 test gating the + /// queue/state-write block. This is load-bearing, not cosmetic: the + /// VERY FIRST dispatch of every apply_interpreted_movement call + /// is the style/stance id (current_style, always + /// >= 0x80000000), which has no locomotion MotionData + /// entry in the dat — CMotionTable::DoObjectMotion genuinely + /// fails for it. If that failure isn't propagated (an earlier revision + /// of this port treated the sink as a void, always-succeeding + /// call), InterpretedMotionState::ApplyMotion's negative-motion + /// branch (arg2 < 0 → forward_command = 0x41000003) clobbers + /// BEFORE the very + /// next line reads it for the real forward dispatch — regressed 74/183 + /// cases of the live retail-observer conformance suite + /// (RetailObserverTraceConformanceTests) until the interface was + /// fixed to return the real result. + /// + /// + /// + /// Note the ACTUAL animation-table dispatch (the sink call) happens + /// through — the entity's persistent + /// IInterpretedMotionSink binding (R2-Q5's + /// MotionTableDispatchSink in production). This is the SAME sink + /// already routes through + /// for the apply_current_movement dual-dispatch tail — retail has + /// exactly one CPhysicsObj per CMotionInterp, so there is + /// only ever one dispatch target per entity, matching + /// 's single-binding shape. + /// + /// + /// Retail arg2. + /// Retail arg3. + public WeenieError DoInterpretedMotion(uint motion, MovementParameters p) + => DoInterpretedMotion(motion, p, DefaultSink); + + /// + /// Sink-parameterized core shared by the public + /// (which + /// always dispatches through , matching + /// retail's one-sink-per-CPhysicsObj shape) and the internal + /// + /// primitive (which needs an EXPLICIT per-call sink for + /// 's remote-entity callers). Same + /// verbatim body either way — only the dispatch target varies. + /// + private WeenieError DoInterpretedMotion(uint motion, MovementParameters p, IInterpretedMotionSink? sink) + { + if (PhysicsObj is null) + return WeenieError.NoPhysicsObject; + + WeenieError result; + + if (contact_allows_move(motion)) + { + bool standingLongJumpStateOnly = StandingLongJump + && (motion == MotionCommand.WalkForward + || motion == MotionCommand.RunForward + || motion == MotionCommand.SideStepRight); + + if (standingLongJumpStateOnly) + { + // label_528440 — state-only: no dispatch, no queue. + if (p.ModifyInterpretedState) + InterpretedState.ApplyMotion(motion, p); + return WeenieError.None; + } + + if (motion == MotionCommand.Dead) + RemoveLinkAnimations?.Invoke(); + + // sink.ApplyMotion stands in for CPhysicsObj::DoInterpretedMotion + // — its bool return IS retail's `result == 0` (a null sink, no + // dispatch backend wired, is treated as succeeding — matches + // every call site that doesn't care about the animation-table + // backend, e.g. bare unit tests exercising queue/state behavior + // only). A FAILED dispatch (the motion table found no cycle for + // this id — genuinely the case for style/stance ids) skips BOTH + // the queue AND the state-write, exactly like the "blocked, + // non-action" apply-only path below — but WITHOUT writing state. + bool dispatchOk = sink?.ApplyMotion(motion, p.Speed) ?? true; + + if (!dispatchOk) + { + // Retail: `result = CPhysicsObj::DoInterpretedMotion(...)` is + // whatever the failed dispatch returned (raw 305591-305593; + // no `else` branch — `result` simply isn't overwritten by + // the `if (result == 0)` block), so DoInterpretedMotion's + // OWN return value on a failed sink dispatch is that + // nonzero code, NOT 0. The exact numeric value is sink- + // internal (MotionTableManagerError.MotionFailed = 0x43, + // not one of CMotionInterp's own WeenieError codes) — no + // CMotionInterp-level WeenieError constant maps to it + // 1:1, so this port surfaces the closest existing local + // analog (GeneralMovementFailure, 0x47) rather than + // inventing a new enum member for a sink-internal code + // that's never queued or otherwise observed by any + // CMotionInterp caller. Flagged as an ambiguity — no test + // in this repo asserts DoInterpretedMotion's return value + // on a failed dispatch (only the queue/state SIDE EFFECTS, + // which correctly do NOT run here). + result = WeenieError.GeneralMovementFailure; + } + else + { + WeenieError jumpErr; + if (!p.DisableJumpDuringLink) + { + jumpErr = MotionAllowsJump(motion); + if (jumpErr == WeenieError.None && (motion & 0x10000000u) == 0) + jumpErr = MotionAllowsJump(InterpretedState.ForwardCommand); + } + else + { + jumpErr = WeenieError.YouCantJumpFromThisPosition; // 0x48 — forced BLOCKED + } + + AddToQueue(p.ContextId, motion, (uint)jumpErr); + + if (p.ModifyInterpretedState) + InterpretedState.ApplyMotion(motion, p); + + result = WeenieError.None; + } + } + else if ((motion & 0x10000000u) == 0) + { + // label_528440 (reached without the StandingLongJump goto) — + // apply-only: state kept, no cycle change, no queue. This is + // retail's real mechanism behind "airborne remotes keep their + // Falling cycle". + if (p.ModifyInterpretedState) + InterpretedState.ApplyMotion(motion, p); + result = WeenieError.None; + } + else + { + result = WeenieError.NotGrounded; // 0x24 (A10) — blocked action-class motion + } + + // R4-V5 door-swing fix (2026-07-03): retail's guard is + // physics_obj->cell == 0 — DETACHED objects only (raw @305627). + // The old proxy (CellPosition.ObjCellId == 0, #145 machinery seeded + // only by the local player's SnapToCell) read every REMOTE body as + // detached, so every dispatch stripped the just-appended transition + // link (door swings snapped; remote walk↔run links died) — see + // PhysicsBody.InWorld (register row). + if (!PhysicsObj.InWorld) + RemoveLinkAnimations?.Invoke(); + + return result; + } + + /// + /// CMotionInterp::StopInterpretedMotion (0x00528470, raw + /// 305635-305670, FULL BODY, R3-W5, closes J4's StopInterpretedMotion + /// leg). THE ONE StopInterpretedMotion — merges the former legacy + /// overload with the funnel's bare sink.StopMotion call. + /// + /// + /// Verbatim (raw 305638-305670): + /// + /// if (physics_obj == 0) return 8; + /// if (contact_allows_move(arg2) == 0 + /// || (standing_longjump != 0 + /// && (arg2 == WalkForward || arg2 == RunForward || arg2 == SideStepRight))) { + /// if (arg3->bitfield & 0x4000) InterpretedMotionState::RemoveMotion(arg2); + /// result = 0; + /// } else { + /// result = sink.StopMotion(arg2, arg3); // CPhysicsObj::StopInterpretedMotion stand-in + /// if (result == 0) { + /// add_to_queue(arg3->context_id, 0x41000003, result); // result == 0 here + /// if (arg3->bitfield & 0x4000) InterpretedMotionState::RemoveMotion(arg2); + /// } + /// } + /// if (physics_obj != 0 && physics_obj->cell == 0) RemoveLinkAnimations(physics_obj); + /// return result; + /// + /// + /// + /// + /// R3-W5 (post-fix): + /// returns a real success signal (see that interface member's doc for + /// why a void sink broke the 183-case live retail conformance + /// suite on the analogous DoInterpretedMotion path) — a FAILED + /// stop dispatch skips both the add_to_queue node and the + /// InterpretedMotionState::RemoveMotion state clear, matching + /// retail's if (result == 0) { ... } gate exactly. On success, + /// the queued node's JumpErrorCode is always 0 (the stop's + /// own "return value" that becomes the queued error code is + /// result, which is 0 on that path). + /// + /// + /// Retail arg2. + /// Retail arg3. + public WeenieError StopInterpretedMotion(uint motion, MovementParameters p) + => StopInterpretedMotion(motion, p, DefaultSink); + + /// + /// Sink-parameterized core shared by the public + /// and the + /// internal primitive — same + /// split rationale as + /// . + /// + private WeenieError StopInterpretedMotion(uint motion, MovementParameters p, IInterpretedMotionSink? sink) + { + if (PhysicsObj is null) + return WeenieError.NoPhysicsObject; + + WeenieError result; + + bool standingLongJumpStateOnly = StandingLongJump + && (motion == MotionCommand.WalkForward + || motion == MotionCommand.RunForward + || motion == MotionCommand.SideStepRight); + + if (!contact_allows_move(motion) || standingLongJumpStateOnly) + { + if (p.ModifyInterpretedState) + InterpretedState.RemoveMotion(motion); + result = WeenieError.None; + } + else + { + // sink.StopMotion stands in for CPhysicsObj::StopInterpretedMotion + // — its bool return IS retail's `result == 0`. A null sink (no + // dispatch backend wired) is treated as succeeding, matching + // DoInterpretedMotion's identical posture. + bool dispatchOk = sink?.StopMotion(motion) ?? true; + + if (!dispatchOk) + { + // See DoInterpretedMotion's identical ambiguity note: retail + // returns the sink's own nonzero code here (raw 305652-305653, + // no `else` — `result` keeps whatever CPhysicsObj::StopInterpretedMotion + // returned); ported as the closest local analog. + result = WeenieError.GeneralMovementFailure; + } + else + { + result = WeenieError.None; + + AddToQueue(p.ContextId, MotionCommand.Ready, (uint)result); + + if (p.ModifyInterpretedState) + InterpretedState.RemoveMotion(motion); + } + } + + // R4-V5 door-swing fix (2026-07-03): retail's guard is + // physics_obj->cell == 0 — DETACHED objects only (raw @305627). + // The old proxy (CellPosition.ObjCellId == 0, #145 machinery seeded + // only by the local player's SnapToCell) read every REMOTE body as + // detached, so every dispatch stripped the just-appended transition + // link (door swings snapped; remote walk↔run links died) — see + // PhysicsBody.InWorld (register row). + if (!PhysicsObj.InWorld) + RemoveLinkAnimations?.Invoke(); + + return result; + } + + /// + /// R3-W5 internal dispatch primitive (formerly the S2a funnel's public + /// surface), now used ONLY by 's + /// action-replay loop — retail's action dispatches (raw 305983) use the + /// UM apply's ctor-default var_2c (notably + /// ModifyInterpretedState = true, so replayed actions DO enter the + /// interpreted actions list via InterpretedMotionState::AddAction), + /// unlike the apply pass's rewritten params (see + /// ). R5-V4 (#164): the params' + /// Autonomous bit (0x1000) is spliced from the ACTION's autonomy + /// flag — retail raw 305982: + /// var_28 ^= ((action.autonomous << 0xc) ^ var_28) & 0x1000 + /// — so a replayed action enters the state lists + /// (AddAction(motion, speed, stamp, autonomous)) with its real + /// autonomy instead of the ctor-default false. + /// + private WeenieError DispatchInterpretedMotion( + uint motion, float speed, bool autonomous, IInterpretedMotionSink? sink) + => DoInterpretedMotion( + motion, new MovementParameters { Speed = speed, Autonomous = autonomous }, sink); } diff --git a/src/AcDream.Core/Physics/MotionSequenceGate.cs b/src/AcDream.Core/Physics/MotionSequenceGate.cs new file mode 100644 index 00000000..55461768 --- /dev/null +++ b/src/AcDream.Core/Physics/MotionSequenceGate.cs @@ -0,0 +1,119 @@ +using System; + +namespace AcDream.Core.Physics; + +/// +/// Per-entity staleness gate for inbound movement events (0xF74C), ported +/// from retail (L.2g S1, closes deviation DEV-6 for the UM path). +/// +/// Retail keeps a update_times[NUM_PHYSICS_TS] array of u16 +/// stamps on every CPhysicsObj (acclient.h:6084 — +/// PhysicsTimeStamp) and rejects out-of-order network events with a +/// wraparound-aware compare. Three of those stamps gate movement events: +/// +/// +/// INSTANCE_TS (8) — checked at dispatch +/// (ACSmartBox::DispatchSmartBoxEvent case 0xF74C, +/// acclient_2013_pseudo_c.txt:357214-357239): an event stamped with an +/// OLDER object incarnation than the one we know is dropped before any +/// other stamp is touched. Retail additionally QUEUES events for a NEWER +/// incarnation (SmartBox::QueueBlobForObject) until that object +/// version exists; acdream adopts-and-applies instead — register row +/// AD-32 records the divergence. +/// MOVEMENT_TS (1) — CPhysics::SetObjectMovement +/// (0x00509690, acclient_2013_pseudo_c.txt:271370) applies an event only +/// when its movement sequence is STRICTLY newer than the stored stamp +/// (equal = duplicate delivery = drop), and stamps BEFORE evaluating the +/// server-control gate — a movement sequence is consumed even when the +/// event is subsequently dropped for stale server control. +/// SERVER_CONTROLLED_MOVE_TS (5) — same function: the event is +/// dropped when the STORED server-control stamp is strictly newer than +/// the incoming one (a newer server-control era has already been seen); +/// equal passes and re-stamps. +/// +/// +/// The compare itself is CPhysicsObj::is_newer (0x00451ad0); +/// the Binary Ninja pseudo-C mangles its setcc returns, so the port follows +/// ACE's verbatim PhysicsObj.is_newer (PhysicsObj.cs:2853-2859), +/// cross-checked against the decomp's branch structure. +/// +public sealed class MotionSequenceGate +{ + private ushort _instanceTs; // update_times[INSTANCE_TS = 8] + private ushort _movementTs; // update_times[MOVEMENT_TS = 1] + private ushort _serverControlTs; // update_times[SERVER_CONTROLLED_MOVE_TS = 5] + private bool _seeded; + + /// + /// CPhysicsObj::is_newer (0x00451ad0): true when + /// is newer than + /// under u16 wraparound — when the absolute difference exceeds 0x7fff + /// the numerically SMALLER value is the newer one (the counter wrapped). + /// + public static bool IsNewer(ushort oldStamp, ushort newStamp) + { + if (Math.Abs(newStamp - oldStamp) > short.MaxValue) + return newStamp < oldStamp; + return oldStamp < newStamp; + } + + /// + /// Seed the stamps from the entity's CreateObject PhysicsDesc timestamp + /// block. Retail initializes update_times wholesale from the 9 + /// u16s at the tail of PhysicsDesc (ACE + /// WorldObject_Networking.cs:411-420 writes them in + /// PhysicsTimeStamp enum order); without this, an entity whose movement + /// sequence is already past 0x8000 at spawn would have every subsequent + /// movement event judged stale against a zero stamp. + /// + /// The first Seed adopts the stamps wholesale (fresh object); + /// subsequent Seeds only move stamps FORWARD. This makes the #138 + /// rehydrate path (which replays a RETAINED CreateObject through the + /// spawn handler) a no-op instead of a stamp regression, while a genuine + /// wire re-create (server sequences only advance) still seeds correctly. + /// Retail has no equivalent replay path — its objects keep their stamps + /// for their whole lifetime — so advance-only is the faithful mapping. + /// + public void Seed(ushort instanceSeq, ushort movementSeq, ushort serverControlSeq) + { + if (!_seeded) + { + _instanceTs = instanceSeq; + _movementTs = movementSeq; + _serverControlTs = serverControlSeq; + _seeded = true; + return; + } + + if (IsNewer(_instanceTs, instanceSeq)) _instanceTs = instanceSeq; + if (IsNewer(_movementTs, movementSeq)) _movementTs = movementSeq; + if (IsNewer(_serverControlTs, serverControlSeq)) _serverControlTs = serverControlSeq; + } + + /// + /// Apply the retail three-stamp gate to an inbound movement event. + /// Returns true when the event should be applied (stamps updated), + /// false when it must be dropped as stale/duplicate/superseded. + /// + public bool TryAcceptMovementEvent(ushort instanceSeq, ushort movementSeq, ushort serverControlSeq) + { + // Dispatch-level incarnation gate — runs before any other stamp is + // touched (retail drops at DispatchSmartBoxEvent, never reaching + // SetObjectMovement). + if (IsNewer(instanceSeq, _instanceTs)) + return false; + _instanceTs = instanceSeq; // adopt equal-or-newer (AD-32; retail queues newer) + + // Gate 1: movement sequence must be strictly newer. + if (!IsNewer(_movementTs, movementSeq)) + return false; + _movementTs = movementSeq; // stamped BEFORE the server-control gate, per retail + + // Gate 2: drop when a newer server-control era has already been seen. + if (IsNewer(serverControlSeq, _serverControlTs)) + return false; + _serverControlTs = serverControlSeq; + + return true; + } +} diff --git a/src/AcDream.Core/Physics/PhysicsBody.cs b/src/AcDream.Core/Physics/PhysicsBody.cs index 32d4b928..9bd67c5c 100644 --- a/src/AcDream.Core/Physics/PhysicsBody.cs +++ b/src/AcDream.Core/Physics/PhysicsBody.cs @@ -66,6 +66,12 @@ public enum TransientStateFlags : uint Contact = 0x00000001, // bit 0 — touching any surface OnWalkable = 0x00000002, // bit 1 — standing on a walkable surface Sliding = 0x00000004, // bit 2 — carry sliding normal into next transition + // retail frames_stationary_fall carried across frames: transition() seeds fsf from + // these bits before the sweep (pc:280940-947); handle_all_collisions re-encodes fsf + // into them at the end of the frame (pc:282743/282749/282753). + StationaryFall = 0x00000010, // bit 4 — fsf == 1 + StationaryStop = 0x00000020, // bit 5 — fsf == 2 + StationaryStuck = 0x00000040, // bit 6 — fsf == 3 Active = 0x00000080, // bit 7 — object needs per-frame update } @@ -115,6 +121,22 @@ public sealed class PhysicsBody /// public Position CellPosition { get; private set; } + /// + /// R4-V5 (the door-swing snap fix, 2026-07-03): the retail + /// physics_obj->cell != 0 "placed in the world" truth (register + /// row). CMotionInterp's dispatch tails strip link animations for + /// DETACHED objects only (if (cell == 0) RemoveLinkAnimations, + /// raw @305627); the previous proxy — .ObjCellId + /// == 0 — was seeded ONLY by the local player's + /// (#145 machinery), so every REMOTE body read "detached" forever and + /// every dispatched transition link (door swings, walk↔run links) was + /// stripped the same tick it was appended. Set by + /// (local player placement) and by RemoteMotion construction (remotes + /// exist only for world entities). Default false = detached, matching + /// retail's pre-enter_world state. + /// + public bool InWorld { get; set; } + /// /// Placement: set the world position AND seed from the /// wire's (cell, local) — NO streaming center, NO delta. For an OUTDOOR cell the @@ -137,6 +159,7 @@ public sealed class PhysicsBody if ((cellId & 0xFFFFu) is >= 1u and <= 0x40u) LandDefs.AdjustToOutside(ref cell, ref local); CellPosition = new Position(cell, new CellFrame(local, Orientation)); + InWorld = true; // retail: enter_world / set_cell assigns physics_obj->cell } // Mirror a world-position translation into the cell-relative frame. Velocity is @@ -162,9 +185,28 @@ public sealed class PhysicsBody /// Orientation quaternion (struct offsets 0x60–0x80 column matrix). public Quaternion Orientation { get; set; } = Quaternion.Identity; - /// World-space velocity (+0xE0/E4/E8). + /// World-space velocity (+0xE0/E4/E8) — retail m_velocityVector: the INTENDED + /// velocity that the integrator advances (gravity, friction, MaxVelocity clamp) and that + /// drives the collision sweep. Zeroed by handle_all_collisions when + /// > 1 (the "bleed on block"). public Vector3 Velocity { get; set; } + /// Retail cached_velocity — a SEPARATE field from : the + /// REALIZED velocity (resolved displacement / dt) written after each transition in + /// UpdateObjectInternal (0x005158cb-005158ff, pc:283693). Read only for reporting / + /// dead-reckoning / camera slope-align (get_velocity 0x005113c0); it is NEVER fed back + /// into or the integrator. Kept separate per the verified retail + /// two-velocity model — do not collapse the two. + public Vector3 CachedVelocity { get; set; } + + /// Retail collision_info.frames_stationary_fall carried on the body between + /// frames. ValidateTransition increments it (0→1→2→3) when the sphere fails to advance and + /// resets it to 0 when it moves; at fsf≥2 an upward contact plane is manufactured; + /// handle_all_collisions zeros when fsf>1 (the airborne-stuck + /// bleed). Round-trips across frames via the Stationary* transient bits. validate_transition + /// pc:272625-656; handle_all_collisions pc:282695. + public int FramesStationaryFall { get; set; } + /// World-space acceleration (+0xEC/F0/F4). public Vector3 Acceleration { get; set; } @@ -231,6 +273,38 @@ public sealed class PhysicsBody /// Last simulation time used to compute dt (+0xD8). public double LastUpdateTime { get; set; } + /// + /// R3-W3 stub for retail CPhysicsObj::IsFullyConstrained + /// (0x0050f730), read by CMotionInterp::jump_is_allowed (raw + /// 305524-305525: if (IsFullyConstrained(physics_obj) != 0) return + /// 0x47;). Retail's body walks per-cell contact-plane constraints + /// (a mover pinned between opposing walkable surfaces / doorway + /// jamming); acdream has no equivalent constraint-tracking yet. + /// Register row: stubbed false (never fires) — a real port needs the + /// per-cell shadow-list contact accounting the physics digest tracks. + /// See docs/architecture/retail-divergence-register.md (added same + /// commit as this field). + /// + public bool IsFullyConstrained { get; set; } + + /// + /// R3-W4 — retail CPhysicsObj::last_move_was_autonomous, read by + /// CPhysicsObj::movement_is_autonomous (0x0050eb30, decomp §7a + /// @276443: return this->last_move_was_autonomous;). Gates the + /// A3 dual-dispatch predicate in MotionInterpreter.apply_current_movement/ + /// ReportExhaustion/SetWeenieObject/SetPhysicsObject: + /// true means the last motion on this body was locally-simulated + /// (player input / local prediction), false means it was a + /// server-driven dead-reckoning update. Set true at the local-player + /// input chokepoint (App layer — PlayerMovementController); + /// left false (the safe default — routes to + /// apply_interpreted_movement) for DR-applied remote updates. + /// also sets this true + /// itself: retail's set_local_velocity(&var_c, 1) call passes + /// the autonomous flag literal 1 (raw @305763-305765). + /// + public bool LastMoveWasAutonomous { get; set; } + // ── convenience helpers ──────────────────────────────────────────────── public bool HasGravity => State.HasFlag(PhysicsStateFlags.Gravity); @@ -310,10 +384,23 @@ public sealed class PhysicsBody /// worldY = col0.y*localX + col1.y*localY + col2.y*localZ /// worldZ = col0.z*localX + col1.z*localY + col2.z*localZ /// We replicate this as a Quaternion rotation, which is equivalent. + /// + /// + /// R3-W4: retail's set_local_velocity takes a second + /// autonomous arg (CPhysicsObj::set_local_velocity, + /// stores it to — read by + /// CPhysicsObj::movement_is_autonomous, the A3 dual-dispatch + /// predicate). Defaults to false to preserve every pre-W4 call + /// site's behavior (server/interpreted-driven callers never asserted + /// autonomy); is the one + /// caller that passes true (raw @305763-305765, + /// set_local_velocity(&var_c, 1)). + /// /// - public void set_local_velocity(Vector3 localVelocity) + public void set_local_velocity(Vector3 localVelocity, bool autonomous = false) { var worldVelocity = Vector3.Transform(localVelocity, Orientation); + LastMoveWasAutonomous = autonomous; set_velocity(worldVelocity); } @@ -435,11 +522,12 @@ public sealed class PhysicsBody calc_friction(dt, velocityMag2); - // If velocity fell below the "small" threshold after friction, stop. - // Only apply when grounded — while airborne, gravity must accumulate - // even when velocity is near zero (e.g., at jump apex). - if (velocityMag2 - SmallVelocitySquared < 0.0002f - && TransientState.HasFlag(TransientStateFlags.OnWalkable)) + // Retail UpdatePhysicsInternal (0x005107be): zero velocity below 0.25 m/s + // UNCONDITIONALLY — NOT gated on OnWalkable. At the jump apex this zeros the + // residual horizontal drift; the unconditional `Velocity += Acceleration * dt` + // below immediately re-applies gravity, so the fall still accumulates. (The old + // OnWalkable gate was an acdream divergence; the verbatim rebuild removes it.) + if (velocityMag2 - SmallVelocitySquared < 0.0002f) Velocity = Vector3.Zero; // Euler integration: position += v*dt + 0.5*a*dt² diff --git a/src/AcDream.Core/Physics/PhysicsDiagnostics.cs b/src/AcDream.Core/Physics/PhysicsDiagnostics.cs index 1412249c..c8a1ba3f 100644 --- a/src/AcDream.Core/Physics/PhysicsDiagnostics.cs +++ b/src/AcDream.Core/Physics/PhysicsDiagnostics.cs @@ -80,6 +80,20 @@ public static class PhysicsDiagnostics public static bool ProbeCellSetEnabled { get; set; } = Environment.GetEnvironmentVariable("ACDREAM_PROBE_CELLSET") == "1"; + /// + /// R5-V3 #171 residuals (2026-07-04) — sticky-melee timeline probe. + /// One [sticky] line per StickyManager lifecycle event (STICK / + /// UNSTICK / LEASE-EXPIRE / TARGET-status teardown) and per armed + /// AdjustOffset tick (guid, signed gap distance, applied delta, + /// heading delta), plus [sticky-snap-skip] lines at the NPC + /// UpdatePosition handler when a server hard-snap is suppressed because + /// the entity is stuck. Heavy while a pack is stuck (~60 Hz × stuck + /// count); capture-session only. All lines carry the guid + /// (feedback_probe_identity_attribution). + /// + public static bool ProbeStickyEnabled { get; set; } + = Environment.GetEnvironmentVariable("ACDREAM_PROBE_STICKY") == "1"; + public static void LogCellSetBuild( uint seedCellId, System.Numerics.Vector3 sphereCenter, @@ -562,6 +576,7 @@ public static class PhysicsDiagnostics ProbeCellEnabled = false; ProbeBuildingEnabled = false; ProbeCellSetEnabled = false; + ProbeStickyEnabled = false; ProbeAutoWalkEnabled = false; ProbeUseabilityFallbackEnabled= false; DumpSteepRoofEnabled = false; diff --git a/src/AcDream.Core/Physics/PhysicsEngine.cs b/src/AcDream.Core/Physics/PhysicsEngine.cs index 1090559e..7b072fc5 100644 --- a/src/AcDream.Core/Physics/PhysicsEngine.cs +++ b/src/AcDream.Core/Physics/PhysicsEngine.cs @@ -971,6 +971,11 @@ public sealed class PhysicsEngine // (matches non-player movement, all targets collide). transition.ObjectInfo.State |= moverFlags; + // frames_stationary_fall gate input: retail reads the mover's GRAVITY state bit + // (object_info.object->state & 0x400, pc:272625). Seed it from the body so the ladder + // in ValidateTransition runs for gravity movers (the player) and not floating props. + transition.ObjectInfo.MoverHasGravity = body?.HasGravity ?? false; + if (isOnGround) transition.ObjectInfo.State |= ObjectInfoState.Contact | ObjectInfoState.OnWalkable; @@ -1043,6 +1048,19 @@ public sealed class PhysicsEngine body.WalkableUp); } + // Seed collision_info.frames_stationary_fall from the body's carried Stationary* + // transient bits — retail transition() 0x00512dc0 seeds fsf from transient_state + // 0x40/0x20/0x10 AFTER init_path and immediately BEFORE find_valid_position + // (pc:280939-949). Placed here (post-InitPath) so InitPath's CollisionInfo reset + // doesn't wipe the seed. + if (body is not null) + { + transition.CollisionInfo.FramesStationaryFall = + body.TransientState.HasFlag(TransientStateFlags.StationaryStuck) ? 3 : + body.TransientState.HasFlag(TransientStateFlags.StationaryStop) ? 2 : + body.TransientState.HasFlag(TransientStateFlags.StationaryFall) ? 1 : 0; + } + bool ok = transition.FindTransitionalPosition(this); var sp = transition.SpherePath; @@ -1072,6 +1090,23 @@ public sealed class PhysicsEngine body.ContactPlaneValid = false; } + // Publish frames_stationary_fall + carry it to the next frame via the Stationary* + // transient bits. Retail encodes these bits in handle_all_collisions (pc:282737-758); + // acdream co-locates the encode with the fsf writeback here (STRUCTURAL ADAPTATION, + // register) so the round-trip (seed→ladder→writeback→seed) is self-contained in Core. + // handle_all_collisions (PhysicsObjUpdate) then only READS body.FramesStationaryFall. + body.FramesStationaryFall = ci.FramesStationaryFall; + body.TransientState &= ~(TransientStateFlags.StationaryFall + | TransientStateFlags.StationaryStop + | TransientStateFlags.StationaryStuck); + body.TransientState |= ci.FramesStationaryFall switch + { + 1 => TransientStateFlags.StationaryFall, + 2 => TransientStateFlags.StationaryStop, + 3 => TransientStateFlags.StationaryStuck, + _ => TransientStateFlags.None, + }; + if (sp.HasLastWalkablePolygon && sp.LastWalkableVertices is not null) { body.WalkablePolygonValid = true; @@ -1085,16 +1120,27 @@ public sealed class PhysicsEngine body.WalkableVertices = null; } - if (ci.SlidingNormalValid - && ci.SlidingNormal.LengthSquared() > PhysicsGlobals.EpsilonSq) + // Retail persists sliding state to the body ONLY on transition + // SUCCESS: CPhysicsObj::SetPositionInternal copies the normal at + // 0x005154c2 and syncs SLIDING_TS (bit 4) from the transition's + // final sliding_normal_valid at 0x005154e1 — and SetPositionInternal + // is unreachable when find_valid_position fails (the transition is + // discarded whole; the body keeps its prior state). #137 mechanism + // 2: an unconditional writeback here could persist a normal retail + // would discard. + if (ok) { - body.SlidingNormal = ci.SlidingNormal; - body.TransientState |= TransientStateFlags.Sliding; - } - else - { - body.SlidingNormal = Vector3.Zero; - body.TransientState &= ~TransientStateFlags.Sliding; + if (ci.SlidingNormalValid + && ci.SlidingNormal.LengthSquared() > PhysicsGlobals.EpsilonSq) + { + body.SlidingNormal = ci.SlidingNormal; + body.TransientState |= TransientStateFlags.Sliding; + } + else + { + body.SlidingNormal = Vector3.Zero; + body.TransientState &= ~TransientStateFlags.Sliding; + } } // L.4 retail-strict (2026-04-30): apply OBJECTINFO::kill_velocity. diff --git a/src/AcDream.Core/Physics/PhysicsObjUpdate.cs b/src/AcDream.Core/Physics/PhysicsObjUpdate.cs new file mode 100644 index 00000000..a1daa04d --- /dev/null +++ b/src/AcDream.Core/Physics/PhysicsObjUpdate.cs @@ -0,0 +1,78 @@ +using System.Numerics; + +namespace AcDream.Core.Physics; + +/// +/// Verbatim port of the collision-response tail of retail +/// CPhysicsObj::UpdateObjectInternal: the velocity decision that +/// SetPositionInternal (0x00515330) drives through +/// handle_all_collisions (0x00514780, pc:282647). Kept as a pure function over a +/// + the resolve outcome so the whole decision is unit-testable +/// in Core, independent of the App per-frame loop. The transition INTERNALS +/// (ResolveWithTransition and below) are untouched. +/// +public static class PhysicsObjUpdate +{ + /// + /// retail handle_all_collisions (0x00514780). Reflects or zeros the body's + /// (retail m_velocityVector) based on + /// : + /// + /// fsf ≤ 1 → reflect the into-surface component + /// (v += -(v·n)(elasticity+1)·n, pc:282712) when we should reflect and a + /// collision normal is valid; an INELASTIC mover zeros instead (pc:282720). + /// fsf > 1 → v = 0 entirely (pc:282729) — the "bleed on block" that + /// lets gravity resume so a blocked jump falls/glides off (fixes the #182 + /// airborne-stuck wedge). + /// + /// The Stationary* transient-bit round-trip (pc:282737-758) is owned by the Core resolve + /// writeback (PhysicsEngine.ResolveWithTransition), not re-encoded here. + /// + /// The mover. + /// Was a wall/creature collision normal recorded this resolve. + /// Outward collision normal (points away from the surface). + /// Whether the body had Contact BEFORE this resolve committed + /// (retail arg3 — reserved for environment-collision reporting; unused today). + /// Whether the body was OnWalkable before this resolve (retail arg4). + /// Whether the body is OnWalkable after this resolve. + public static void HandleAllCollisions( + PhysicsBody body, + bool collisionNormalValid, Vector3 collisionNormal, + bool prevContact, bool prevOnWalkable, bool nowOnWalkable) + { + // var_10_1 (pc:282653-282657): reflect UNLESS the mover stays on walkable ground + // (and is not sledding). This restores retail's broader rule — the AD-25 airborne-only + // suppression is retired: the landing-snap fragility it guarded is gone (landing state + // is now owned by the SetPositionInternal-derived contact flags, not a Velocity.Z<=0 + // gate). A grounded corridor wall-slide keeps its tangential velocity (should_reflect + // false), exactly as retail. + bool sledding = body.State.HasFlag(PhysicsStateFlags.Sledding); + bool shouldReflect = !(prevOnWalkable && nowOnWalkable && !sledding); + + if (body.FramesStationaryFall <= 1) + { + if (shouldReflect && collisionNormalValid) + { + if (body.State.HasFlag(PhysicsStateFlags.Inelastic)) + { + body.Velocity = Vector3.Zero; // pc:282720-282722 + } + else + { + float dot = Vector3.Dot(body.Velocity, collisionNormal); + if (dot < 0f) // moving INTO the surface + { + float k = -(dot * (body.Elasticity + 1f)); // pc:282712 + body.Velocity += collisionNormal * k; + } + } + } + } + else + { + body.Velocity = Vector3.Zero; // fsf>1 → THE BLEED (pc:282729) + } + + _ = prevContact; // retail report_environment_collision(arg3) — weenie collision events, later. + } +} diff --git a/src/AcDream.Core/Physics/PlayerWeenie.cs b/src/AcDream.Core/Physics/PlayerWeenie.cs index 014c96a8..3d1ab62d 100644 --- a/src/AcDream.Core/Physics/PlayerWeenie.cs +++ b/src/AcDream.Core/Physics/PlayerWeenie.cs @@ -43,6 +43,24 @@ public sealed class PlayerWeenie : IWeenieObject public bool CanJump(float extent) => true; // burden/stamina checks deferred + /// + /// R3-W3 (W0-pins.md A3): the local player's weenie is THE player. + /// Feeds W4's apply_current_movement/ReportExhaustion + /// dual-dispatch gate — no consumer yet in W3. + /// + public bool IsThePlayer() => true; + + /// + /// TS-5 (extended): stamina cost gating deferred pending stat plumbing — + /// always affordable, cost 0. Matches 's existing + /// always-true stance. + /// + public bool JumpStaminaCost(float extent, out int cost) + { + cost = 0; + return true; + } + /// /// RunRate = (burdenMod * (runSkill / (runSkill + 200)) * 11 + 4) / 4 /// Capped at 4.5 when runSkill >= 800. diff --git a/src/AcDream.Core/Physics/RawMotionState.cs b/src/AcDream.Core/Physics/RawMotionState.cs new file mode 100644 index 00000000..315ee1ff --- /dev/null +++ b/src/AcDream.Core/Physics/RawMotionState.cs @@ -0,0 +1,322 @@ +using AcDream.Core.Physics.Motion; + +namespace AcDream.Core.Physics; + +/// +/// Retail hold-key enum (acclient.h enum HoldKey, line 3394). +/// +public enum HoldKey : uint +{ + Invalid = 0x0, + None = 0x1, + Run = 0x2, +} + +/// +/// One entry in — a discrete motion +/// event (jump, attack, etc.) layered on top of the continuous +/// forward/sidestep/turn axes. +/// +/// +/// Retail's in-memory action node (RawMotionState::AddAction, +/// 0x0051e840, and InterpretedMotionState::AddAction, 0x0051e9e0 — +/// both a 0x14-byte LListData-derived node) carries FOUR fields: +/// motion (+4), speed (+8), action_stamp (+0xc), +/// autonomous (+0x10). is the in-memory-only +/// field the R3-W1 action FIFO needs for ApplyMotion's velocity +/// bookkeeping; it is NOT part of the wire encoding. +/// +/// +/// +/// Retail packs each action ON THE WIRE as u16 command then +/// u16 ((stamp & 0x7FFF) | (autonomous ? 0x8000 : 0)) +/// (RawMotionState::Pack, 0x0051ed10, decomp lines ~293998-294010) +/// — // are +/// exactly the packed triple; reads only +/// those three. +/// +/// +public readonly record struct RawMotionAction( + ushort Command, + ushort Stamp, + bool Autonomous, + float Speed = 1f); + +/// +/// R3-W1 — verbatim, full-field port of retail's RawMotionState +/// (acclient.h RawMotionState::PackBitfield, line 46474; ctor +/// RawMotionState::RawMotionState, 0x0051e7f0, decomp lines +/// 293344-293361; packer at RawMotionState::Pack, 0x0051ed10). +/// +/// +/// R3-W1 fold (closes J2): this type now ALSO serves as +/// MotionInterpreter.RawState — the former LegacyRawMotionState +/// (a flat 7-field struct with no action FIFO) is deleted. One raw-state +/// type end to end: the physics-side motion interpreter mutates it via +/// // +/// /, and the SAME +/// instance's is read by +/// when building the outbound wire packet. Previously the packer's action +/// list was always empty (register TS-24) because nothing populated it — +/// starting R3-W2 (the add_to_queue/MotionDone port), +/// CMotionInterp populates this list locally exactly like retail +/// does, so the packed bytes will start reflecting real queued actions. +/// W1 itself does not change what gets packed (no caller invokes +/// yet) — only adds the capability + tests. +/// +/// +/// +/// PURE DATA: no PacketWriter / GL / Net dependency. Lives in +/// AcDream.Core.Physics so the motion interpreter, which is +/// also Core.Physics, can populate it without taking a Core.Net dependency +/// (Code Structure Rule #2). +/// +/// +public sealed class RawMotionState +{ + /// Retail current_holdkey (ctor default HoldKey_None). + public HoldKey CurrentHoldKey { get; set; } = HoldKey.None; + /// Retail current_style (ctor default 0x8000003D, NonCombat). + public uint CurrentStyle { get; set; } = 0x8000003Du; + /// Retail forward_command (ctor default 0x41000003, Ready). + public uint ForwardCommand { get; set; } = 0x41000003u; + /// Retail forward_holdkey (ctor default HoldKey_Invalid). + public HoldKey ForwardHoldKey { get; set; } = HoldKey.Invalid; + /// Retail forward_speed (ctor default 1.0). + public float ForwardSpeed { get; set; } = 1.0f; + /// Retail sidestep_command (ctor default 0). + public uint SidestepCommand { get; set; } + /// Retail sidestep_holdkey (ctor default HoldKey_Invalid). + public HoldKey SidestepHoldKey { get; set; } = HoldKey.Invalid; + /// Retail sidestep_speed (ctor default 1.0). + public float SidestepSpeed { get; set; } = 1.0f; + /// Retail turn_command (ctor default 0). + public uint TurnCommand { get; set; } + /// Retail turn_holdkey (ctor default HoldKey_Invalid). + public HoldKey TurnHoldKey { get; set; } = HoldKey.Invalid; + /// Retail turn_speed (ctor default 1.0). + public float TurnSpeed { get; set; } = 1.0f; + + private readonly List _actions = new(); + + /// + /// Discrete action FIFO (retail actions, an LListData + /// tail-append queue). Retail packs num_actions (count, not the + /// values) into bits 11-15 of the flags dword, then emits each action's + /// command+stamp pair unconditionally after the continuous-axis fields + /// (). + /// + /// + /// Settable via object-initializer for test fixtures / the wire-packer + /// call sites that build a one-shot snapshot; assigning replaces the + /// whole FIFO. / are + /// the retail-faithful mutators for live FIFO discipline. + /// + /// + public IReadOnlyList Actions + { + get => _actions; + set + { + _actions.Clear(); + _actions.AddRange(value); + } + } + + /// + /// Retail defaults — a field bit is set in the packed flags dword ONLY + /// when the live value differs from these (RawMotionState::Pack, + /// 0x0051ed10). NEVER mutate this shared instance. + /// + public static readonly RawMotionState Default = new(); + + /// + /// RawMotionState::AddAction (0x0051e840, decomp 293365-293392): + /// unconditional tail-append of + /// {motion, speed, action_stamp, autonomous}. + /// + /// Retail arg2 — the action motion id. + /// Retail arg3. + /// Retail arg4. + /// Retail arg5 (nonzero = autonomous). + public void AddAction(uint motion, float speed, uint actionStamp, bool autonomous) + { + _actions.Add(new RawMotionAction( + Command: (ushort)motion, + Stamp: (ushort)actionStamp, + Autonomous: autonomous, + Speed: speed)); + } + + /// + /// RawMotionState::RemoveAction (0x0051e8a0, decomp 293396-293414): + /// pop the FIFO head unconditionally, returning its motion field + /// (0 when empty — retail returns *(head+4), i.e. the stored + /// arg2/Command, widened; the C# port returns the widened + /// as a uint). + /// + public uint RemoveAction() + { + if (_actions.Count == 0) + return 0; + var head = _actions[0]; + _actions.RemoveAt(0); + return head.Command; + } + + /// + /// RawMotionState::ApplyMotion (0x0051eb60, decomp 293630-293703). + /// Verbatim dispatch, quoted from the raw named decomp: + /// + /// if ((arg2 - 0x6500000d) > 3) { // outside [0x6500000d, 0x65000010] + /// if ((arg2 & 0x40000000) == 0) { // NOT forward-class + /// if (arg2 >= 0) { // NOT style-class (high bit clear) + /// if ((arg2 & 0x10000000) != 0) + /// AddAction(arg2, params.speed, params.action_stamp, (params.bitfield>>0xc)&1); + /// } else if (current_style != arg2) { + /// forward_command = 0x41000003; current_style = arg2; + /// } + /// } else if (arg2 != 0x44000007) { // forward-class, NOT RunForward + /// forward_command = arg2; + /// if (params.bitfield byte1 & 8 != 0) { forward_holdkey = Invalid; forward_speed = params.speed; } + /// else { forward_holdkey = params.hold_key_to_apply; forward_speed = params.speed; } + /// } + /// // arg2 == 0x44000007 (RunForward) with the forward-class bit set: falls through, no write. + /// return; + /// } + /// switch (arg2) { + /// case 0x6500000d: case 0x6500000e: // TurnRight/TurnLeft + /// turn_command = arg2; + /// if (SetHoldKey bit) { turn_holdkey = Invalid; turn_speed = params.speed; } + /// else { turn_holdkey = params.hold_key_to_apply; turn_speed = params.speed; } + /// return; + /// case 0x6500000f: case 0x65000010: // SideStepRight/SideStepLeft + /// sidestep_command = arg2; + /// if (SetHoldKey bit) { sidestep_holdkey = Invalid; sidestep_speed = params.speed; } + /// else { sidestep_holdkey = params.hold_key_to_apply; sidestep_speed = params.speed; } + /// return; + /// } + /// + /// The arg2 == 0x44000007 (RunForward) no-write fallthrough on the + /// forward-class branch is a genuine retail quirk (RunForward bit + /// 0x40000000 IS set, but the `else if (arg2 != 0x44000007)` guard + /// excludes it) — ported verbatim, not "fixed". + /// + /// Retail arg2 — the ORIGINAL (pre-adjustment) + /// motion id per the DoMotion/StopMotion mirror-discipline callers. + /// Retail arg3 (MovementParameters const*). + public void ApplyMotion(uint motion, MovementParameters p) + { + if (motion - 0x6500000du > 3u) + { + if ((motion & 0x40000000u) == 0) + { + if (motion < 0x80000000u) // arg2 >= 0 as signed int32 + { + if ((motion & 0x10000000u) != 0) + AddAction(motion, p.Speed, p.ActionStamp, p.Autonomous); + } + else if (CurrentStyle != motion) + { + ForwardCommand = 0x41000003u; + CurrentStyle = motion; + } + } + else if (motion != 0x44000007u) + { + ForwardCommand = motion; + if (p.SetHoldKey) + { + ForwardHoldKey = HoldKey.Invalid; + ForwardSpeed = p.Speed; + } + else + { + ForwardHoldKey = p.HoldKeyToApply; + ForwardSpeed = p.Speed; + } + } + return; + } + + switch (motion) + { + case 0x6500000du: // TurnRight + case 0x6500000eu: // TurnLeft + TurnCommand = motion; + if (p.SetHoldKey) + { + TurnHoldKey = HoldKey.Invalid; + TurnSpeed = p.Speed; + } + else + { + TurnHoldKey = p.HoldKeyToApply; + TurnSpeed = p.Speed; + } + return; + case 0x6500000fu: // SideStepRight + case 0x65000010u: // SideStepLeft + SidestepCommand = motion; + if (p.SetHoldKey) + { + SidestepHoldKey = HoldKey.Invalid; + SidestepSpeed = p.Speed; + } + else + { + SidestepHoldKey = p.HoldKeyToApply; + SidestepSpeed = p.Speed; + } + return; + } + } + + /// + /// RawMotionState::RemoveMotion (0x0051e6e0, decomp 293252-293288): + /// + /// if ((arg2 - 0x6500000d) > 3) { + /// if ((arg2 & 0x40000000) == 0) { + /// if (arg2 < 0 && arg2 == current_style) current_style = 0x8000003d; + /// } else if (arg2 == forward_command) { + /// forward_command = 0x41000003; forward_speed = 1f; + /// } + /// return; + /// } + /// switch (arg2) { + /// case 0x6500000d: case 0x6500000e: turn_command = 0; return; + /// case 0x6500000f: case 0x65000010: sidestep_command = 0; return; + /// } + /// + /// + /// Retail arg2 — the ORIGINAL motion id. + public void RemoveMotion(uint motion) + { + if (motion - 0x6500000du > 3u) + { + if ((motion & 0x40000000u) == 0) + { + if (motion >= 0x80000000u && motion == CurrentStyle) + CurrentStyle = 0x8000003du; + } + else if (motion == ForwardCommand) + { + ForwardCommand = 0x41000003u; + ForwardSpeed = 1f; + } + return; + } + + switch (motion) + { + case 0x6500000du: + case 0x6500000eu: + TurnCommand = 0; + return; + case 0x6500000fu: + case 0x65000010u: + SidestepCommand = 0; + return; + } + } +} diff --git a/src/AcDream.Core/Physics/PositionManager.cs b/src/AcDream.Core/Physics/RemoteMotionCombiner.cs similarity index 91% rename from src/AcDream.Core/Physics/PositionManager.cs rename to src/AcDream.Core/Physics/RemoteMotionCombiner.cs index e3ff2aec..eaf86fe1 100644 --- a/src/AcDream.Core/Physics/PositionManager.cs +++ b/src/AcDream.Core/Physics/RemoteMotionCombiner.cs @@ -17,8 +17,16 @@ namespace AcDream.Core.Physics; /// active locomotion cycle). We rotate that by the body's orientation /// to get a world-space delta, then add the InterpolationManager's /// world-space correction. +/// +/// Renamed R5 (was PositionManager): this class is only the +/// InterpolationManager-composition portion of retail's +/// PositionManager::adjust_offset — NOT the retail PositionManager +/// facade. The faithful facade (Sticky/Constraint, owned per entity) is +/// . The name was freed to remove the +/// ambiguity that broke every file importing both +/// AcDream.Core.Physics and AcDream.Core.Physics.Motion. /// -public sealed class PositionManager +public sealed class RemoteMotionCombiner { /// /// Compute the per-frame world-space delta to add to body.Position. diff --git a/src/AcDream.Core/Physics/RemoteMoveToDriver.cs b/src/AcDream.Core/Physics/RemoteMoveToDriver.cs deleted file mode 100644 index bc1e6d51..00000000 --- a/src/AcDream.Core/Physics/RemoteMoveToDriver.cs +++ /dev/null @@ -1,340 +0,0 @@ -using System; -using System.Numerics; - -namespace AcDream.Core.Physics; - -/// -/// Per-tick steering for server-controlled remote creatures while a -/// MoveToObject (movementType 6) or MoveToPosition (movementType 7) packet -/// is the active locomotion source. -/// -/// -/// Replaces the 882a07c-era "hold body Velocity at zero during MoveTo" -/// stabilizer. With the full MoveTo path payload now captured on -/// , -/// the body solver has the destination + heading + thresholds it needs to -/// run the retail per-tick loop instead of waiting for sparse -/// UpdatePosition snap corrections. -/// -/// -/// -/// Retail references: -/// -/// -/// MoveToManager::HandleMoveToPosition (0x00529d80) — the -/// per-tick driver. Computes heading-to-target, fires an aux -/// TurnLeft/TurnRight command when |delta| > 20°, snaps -/// orientation when within tolerance, and tests arrival via -/// dist <= min_distance (chase) or -/// dist >= distance_to_object (flee). -/// -/// -/// MoveToManager::_DoMotion / _StopMotion route turn -/// commands through CMotionInterp::DoInterpretedMotion — i.e. -/// MoveToManager itself does NOT touch the body. The body's actual -/// velocity comes from CMotionInterp::apply_current_movement -/// reading InterpretedState.ForwardCommand = RunForward and -/// emitting velocity.Y = RunAnimSpeed × speedMod, transformed by -/// the body's orientation. -/// -/// -/// -/// -/// -/// Acdream port scope: minimum viable subset. We skip target re-tracking -/// (server re-emits MoveTo every ~1 s with refreshed Origin), sticky/ -/// StickTo, fail-distance progress detector, and the sphere-cylinder -/// distance variant — all server-side concerns the local body doesn't need -/// to model. We DO port heading-to-target, the ±20° aux-turn tolerance -/// (with ACE's set_heading(true) snap-on-aligned fudge), and -/// arrival detection via min_distance. -/// -/// -/// -/// ACE divergence: ACE swaps the chase/flee arrival predicates -/// (dist <= DistanceToObject vs retail's dist <= MinDistance). -/// We follow retail. -/// -/// -public static class RemoteMoveToDriver -{ - /// - /// Heading tolerance below which we snap orientation directly to the - /// target heading (ACE's set_heading(target, true) - /// server-tic-rate fudge). Above tolerance we rotate at - /// . Retail value (line 307251 of - /// acclient_2013_pseudo_c.txt) is 20°. - /// - public const float HeadingSnapToleranceRad = 20.0f * MathF.PI / 180.0f; - - /// - /// Default angular rate for in-motion heading correction when delta - /// exceeds . Picked to match - /// ACE's TurnSpeed default of π/2 rad/s for monsters; - /// when the per-creature value differs, the future port can wire it - /// in via the TurnSpeed field on InterpretedMotionState. - /// - public const float TurnRateRadPerSec = MathF.PI / 2.0f; - - /// - /// Retail base turn rate for the player Humanoid when turn_speed - /// scalar = 1.0. Convention default omega.z = ±π/2 rad/s - /// derived from add_motion at 0x005224b0 + the - /// HasOmega-cleared MotionData fallback documented in - /// AnimationSequencer.cs:734-741. ~90°/s. - /// - public const float BaseTurnRateRadPerSec = MathF.PI / 2.0f; - - /// - /// Retail's run_turn_factor constant at 0x007c8914 - /// (PDB-named). CMotionInterp::apply_run_to_command - /// equivalent (decomp 0x00527be0, line 305098 of - /// acclient_2013_pseudo_c.txt) multiplies turn_speed - /// by 1.5 when HoldKey.Run is active on a TurnRight/TurnLeft - /// command. Effect: running rotation is 50 % faster than walking. - /// - public const float RunTurnFactor = 1.5f; - - /// - /// Retail-faithful local-player turn rate. - /// - /// Walking: BaseTurnRateRadPerSec ≈ 90°/s. - /// Running: BaseTurnRateRadPerSec × RunTurnFactor - /// ≈ 135°/s. - /// - /// Replaces the fixed TurnRateRadPerSec for paths that have - /// access to the player's run/walk state (keyboard A/D, auto-walk - /// overlay turn-first). NPC/monster remotes that lack the - /// information continue to use the constant which equals - /// BaseTurnRateRadPerSec. - /// - public static float TurnRateFor(bool running) - => running ? BaseTurnRateRadPerSec * RunTurnFactor - : BaseTurnRateRadPerSec; - - /// - /// Float-comparison slack for the arrival predicate. With - /// min_distance == 0 in a chase packet, exact equality is - /// unreachable due to integration wobble; this epsilon prevents the - /// driver from over-shooting by a sub-meter and snap-flipping back. - /// - public const float ArrivalEpsilon = 0.05f; - - /// - /// Maximum staleness (seconds) of the most recent MoveTo packet - /// before the driver gives up steering. ACE re-emits MoveTo at ~1 Hz - /// during active chase; if no fresh packet arrives for this long, - /// the entity has likely either left our streaming view, switched - /// to a non-MoveTo motion the server's broadcast didn't reach us - /// for, or had its move cancelled server-side without our seeing - /// the cancel UM. In any of those cases, continuing to drive the - /// body toward a stale destination produces the "monster runs in - /// place after popping back into view" symptom (2026-04-28). - /// 1.5 s gives us comfortable margin over the ~1 s emit cadence - /// while still failing fast on real loss-of-state. - /// - public const double StaleDestinationSeconds = 1.5; - - public enum DriveResult - { - /// Within arrival window — caller should zero velocity. - Arrived, - /// Steering active — caller should let - /// apply_current_movement set body velocity from the cycle. - Steering, - } - - /// - /// Steer body orientation toward - /// and report whether the body has arrived or should keep running. - /// Pure function — emits the updated orientation via - /// (the input is not mutated; the - /// caller assigns the new value back to its body). - /// - /// - /// min_distance from the wire's MovementParameters block — - /// retail's HandleMoveToPosition chase-arrival threshold. - /// - /// - /// distance_to_object from the wire — ACE's chase-arrival - /// threshold (default 0.6 m, the melee range). The actual arrival - /// gate is max(minDistance, distanceToObject): retail-faithful - /// when retail sends min_distance > 0, ACE-compatible when - /// ACE puts the value in distance_to_object with - /// min_distance == 0. Without this, ACE's min_distance==0 - /// chase packets never arrive — the body keeps re-targeting around - /// the player at melee range and visibly oscillates between facings, - /// which is the user-reported "monster keeps running in different - /// directions when it should be attacking" symptom (2026-04-28). - /// - public static DriveResult Drive( - Vector3 bodyPosition, - Quaternion bodyOrientation, - Vector3 destinationWorld, - float minDistance, - float distanceToObject, - float dt, - bool moveTowards, - out Quaternion newOrientation) - { - // Horizontal distance only — server owns Z, our body Z is - // hard-snapped to the latest UpdatePosition. - float dx = destinationWorld.X - bodyPosition.X; - float dy = destinationWorld.Y - bodyPosition.Y; - float dist = MathF.Sqrt(dx * dx + dy * dy); - - // Arrival predicate per retail MoveToManager::HandleMoveToPosition - // (acclient_2013_pseudo_c.txt:307289-307320) and ACE - // MoveToManager.cs:476: - // - // chase (MoveTowards): dist <= distance_to_object - // flee (MoveAway): dist >= min_distance - // - // (My earlier max(MinDistance, DistanceToObject) was a - // defensive guess; cross-checked with two independent research - // agents against the named retail decomp + ACE port + holtburger, - // the chase threshold is unambiguously DistanceToObject — - // MinDistance is the FLEE arrival threshold. ACE's wire defaults - // give MinDistance=0, DistanceToObject=0.6 — the body should stop - // at melee range, not run to zero.) - float arrivalThreshold = moveTowards ? distanceToObject : minDistance; - if (moveTowards && dist <= arrivalThreshold + ArrivalEpsilon) - { - newOrientation = bodyOrientation; - return DriveResult.Arrived; - } - if (!moveTowards && dist >= arrivalThreshold - ArrivalEpsilon) - { - newOrientation = bodyOrientation; - return DriveResult.Arrived; - } - - // Degenerate — already on target horizontally; preserve heading. - if (dist < 1e-4f) - { - newOrientation = bodyOrientation; - return DriveResult.Steering; - } - - // Body's local-forward is +Y (see MotionInterpreter.get_state_velocity - // at line 605-616: velocity.Y = (Walk/Run)AnimSpeed × ForwardSpeed). - // World forward = Transform((0,1,0), orientation). Yaw extracted - // via atan2(-worldFwd.X, worldFwd.Y) so yaw = 0 ↔ orientation = Identity. - var localForward = new Vector3(0f, 1f, 0f); - var worldForward = Vector3.Transform(localForward, bodyOrientation); - float currentYaw = MathF.Atan2(-worldForward.X, worldForward.Y); - - // Desired heading: face the target. (dx, dy) is the world-space - // offset to the target. With local-forward=+Y we want yaw such - // that Transform((0,1,0), R_Z(yaw)) = (dx, dy)/dist; that solves - // to yaw = atan2(-dx, dy). - float desiredYaw = MathF.Atan2(-dx, dy); - float delta = WrapPi(desiredYaw - currentYaw); - - if (MathF.Abs(delta) <= HeadingSnapToleranceRad) - { - // ACE's set_heading(target, true) — sync to server-tic-rate. - // We have the same sparse-UP problem ACE does, so the same - // fudge applies. - newOrientation = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, desiredYaw); - } - else - { - // Retail BeginTurnToHeading / HandleMoveToPosition aux turn: - // rotate at TurnRate clamped to dt, in the shorter direction. - float maxStep = TurnRateRadPerSec * dt; - float step = MathF.Sign(delta) * MathF.Min(MathF.Abs(delta), maxStep); - // Apply incremental yaw around world +Z (preserving any - // server-supplied pitch/roll from the latest UpdatePosition). - var deltaQuat = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, step); - newOrientation = Quaternion.Normalize(deltaQuat * bodyOrientation); - } - - return DriveResult.Steering; - } - - /// - /// Convert a landblock-local Origin from a MoveTo packet - /// () - /// into acdream's render world space using the same arithmetic as - /// OnLivePositionUpdated: shift by the landblock-grid offset - /// from the live-mode center. - /// - public static Vector3 OriginToWorld( - uint originCellId, - float originX, - float originY, - float originZ, - int liveCenterLandblockX, - int liveCenterLandblockY) - { - int lbX = (int)((originCellId >> 24) & 0xFFu); - int lbY = (int)((originCellId >> 16) & 0xFFu); - return new Vector3( - originX + (lbX - liveCenterLandblockX) * 192f, - originY + (lbY - liveCenterLandblockY) * 192f, - originZ); - } - - /// - /// Cap horizontal velocity so the body lands exactly at - /// rather than overshooting past - /// it during the final tick of approach. Without this clamp, a body - /// running at RunAnimSpeed × speedMod ≈ 4 m/s can overshoot - /// the 0.6 m arrival window by up to one tick's advance (~6 cm at - /// 60 fps) — visible as the creature "running slightly through" the - /// player it's about to attack (user-reported 2026-04-28). - /// - /// - /// The clamp is a strict scale-down of the horizontal component - /// (X/Y); the vertical component (Z) is left to gravity / terrain - /// handling. false (flee branch) is a - /// no-op since fleeing has no overshoot risk — the body wants to - /// move AWAY from the destination. - /// - /// - public static Vector3 ClampApproachVelocity( - Vector3 bodyPosition, - Vector3 currentVelocity, - Vector3 destinationWorld, - float arrivalThreshold, - float dt, - bool moveTowards) - { - if (!moveTowards || dt <= 0f) return currentVelocity; - - float dx = destinationWorld.X - bodyPosition.X; - float dy = destinationWorld.Y - bodyPosition.Y; - float dist = MathF.Sqrt(dx * dx + dy * dy); - float remaining = MathF.Max(0f, dist - arrivalThreshold); - - float vxy = MathF.Sqrt(currentVelocity.X * currentVelocity.X - + currentVelocity.Y * currentVelocity.Y); - if (vxy < 1e-3f) return currentVelocity; - - float advance = vxy * dt; - if (advance <= remaining) return currentVelocity; - - // Already inside or right at the threshold: zero horizontal - // velocity, keep Z. (The arrival predicate in Drive() should - // have fired this tick, but this is the belt-and-braces guard.) - if (remaining < 1e-3f) - return new Vector3(0f, 0f, currentVelocity.Z); - - float scale = remaining / advance; - return new Vector3( - currentVelocity.X * scale, - currentVelocity.Y * scale, - currentVelocity.Z); - } - - /// Wrap an angle in radians to [-π, π]. - private static float WrapPi(float r) - { - const float TwoPi = MathF.PI * 2f; - r %= TwoPi; - if (r > MathF.PI) r -= TwoPi; - if (r < -MathF.PI) r += TwoPi; - return r; - } -} diff --git a/src/AcDream.Core/Physics/RemoteWeenie.cs b/src/AcDream.Core/Physics/RemoteWeenie.cs new file mode 100644 index 00000000..6d6aedb9 --- /dev/null +++ b/src/AcDream.Core/Physics/RemoteWeenie.cs @@ -0,0 +1,54 @@ +namespace AcDream.Core.Physics; + +/// +/// R4-V5 (#160 fix, 2026-07-03): the minimal weenie every REMOTE entity's +/// carries — standing in for retail's +/// per-object ACCWeenieObject, which every placed physics object has. +/// +/// +/// The load-bearing behavior is the RUN-RATE FALLBACK CHAIN: +/// apply_run_to_command (0x00527be0, raw 305062-305076) reads +/// weenie ? (InqRunRate() ?: my_run_rate) : 1.0. Remote weenies in +/// retail FAIL InqRunRate (no local skill data), landing on +/// my_run_rate — exactly the field the mt-6/7 unpack writes with the +/// wire's MoveToRunRate (M13). Our remote interps previously had NO +/// weenie at all, taking the degenerate else 1.0 branch retail +/// reserves for detached objects — so an observer-side moveto dispatched +/// RunForward at speed 1.0 instead of the wire rate: the run cycle played +/// in slow motion and the chase velocity crawled (walk was unaffected — +/// walk speed isn't rate-scaled). +/// +/// +/// +/// stays default false — the A3 +/// dual dispatch routes remotes through apply_interpreted_movement, ending +/// the fragile "null weenie counts as the player" reading of that gate. +/// stays default true; static +/// animated objects (doors) also carry this weenie — retail would say +/// non-creature there, but their RemoteMotion bodies force-assert Contact, +/// so the creature ground-gate is satisfied either way (noted, not a +/// behavior difference today). +/// +/// +public sealed class RemoteWeenie : IWeenieObject +{ + /// Remote objects have no local skill data — fail, so the + /// retail fallback chain lands on + /// (the wire-fed rate). + public bool InqRunRate(out float rate) + { + rate = 0f; + return false; + } + + /// Remotes never locally compute jump arcs (server-broadcast + /// VectorUpdate velocities drive them). + public bool InqJumpVelocity(float extent, out float vz) + { + vz = 0f; + return false; + } + + /// Remotes never locally initiate jumps. + public bool CanJump(float extent) => true; +} diff --git a/src/AcDream.Core/Physics/Retail2013CommandCatalog.cs b/src/AcDream.Core/Physics/Retail2013CommandCatalog.cs new file mode 100644 index 00000000..78a48c51 --- /dev/null +++ b/src/AcDream.Core/Physics/Retail2013CommandCatalog.cs @@ -0,0 +1,113 @@ +namespace AcDream.Core.Physics; + +/// +/// Conformance/reference built from the +/// Sept 2013 EoR retail decomp's full command_ids[0x198] table — a +/// direct index from 16-bit wire low-word to the 32-bit MotionCommand the +/// 2013 client itself would reconstruct. NOT the runtime default (ACE / the +/// local DATs use a later-client numbering — see +/// ); this catalog exists to prove and +/// pin the 2013 decomp's behavior for conformance tests. +/// +/// +/// Provenance: docs/research/named-retail/acclient_2013_pseudo_c.txt, +/// uint32_t const command_ids[0x198] at address 0x007c73e8, +/// table body starting at source line 1017259 +/// ([0x000] = 0x80000000) through line 1017667 +/// ([0x197] = 0x10000197), closing brace at line 1017668. Extracted +/// programmatically (regex over [0xNNN] = 0xVVVVVVVV, not hand-typed) +/// and verified against the anchor values cited inline below. +/// +/// +/// +/// Caution — two look-alike tables exist elsewhere in the same file +/// (around source lines 1017962 and 1068315, both also declared +/// command_ids[0x198]). Only the table at line 1017259 / +/// address 0x007c73e8 is used here; do not conflate with the others. +/// +/// +public sealed class Retail2013CommandCatalog : IMotionCommandCatalog +{ + public uint ReconstructFullCommand(ushort wireCommand) + { + return wireCommand < CommandIds.Length ? CommandIds[wireCommand] : 0u; + } + + // acclient_2013_pseudo_c.txt:1017259-1017667, address 0x007c73e8. + // 0x198 (408) entries, indices 0x000..0x197, verbatim from the decomp. + // Anchors verified at extraction time: + // [0x000]=0x80000000 [0x003]=0x41000003 [0x005]=0x45000005 + // [0x007]=0x44000007 [0x00d]=0x6500000d [0x150]=0x10000150 + // [0x153]=0x09000153 + private static readonly uint[] CommandIds = + { + 0x80000000u, 0x85000001u, 0x85000002u, 0x41000003u, 0x40000004u, 0x45000005u, + 0x45000006u, 0x44000007u, 0x40000008u, 0x40000009u, 0x4000000Au, 0x4000000Bu, + 0x4000000Cu, 0x6500000Du, 0x6500000Eu, 0x6500000Fu, 0x65000010u, 0x40000011u, + 0x41000012u, 0x41000013u, 0x41000014u, 0x40000015u, 0x40000016u, 0x40000017u, + 0x40000018u, 0x40000019u, 0x4000001Au, 0x4000001Bu, 0x4000001Cu, 0x4000001Du, + 0x4000001Eu, 0x4000001Fu, 0x40000020u, 0x40000021u, 0x40000022u, 0x40000023u, + 0x40000024u, 0x40000025u, 0x40000026u, 0x40000027u, 0x40000028u, 0x40000029u, + 0x4000002Au, 0x4000002Bu, 0x4000002Cu, 0x4000002Du, 0x4000002Eu, 0x4000002Fu, + 0x40000030u, 0x40000031u, 0x40000032u, 0x40000033u, 0x40000034u, 0x40000035u, + 0x40000036u, 0x40000037u, 0x40000038u, 0x40000039u, 0x2000003Au, 0x2500003Bu, + 0x8000003Cu, 0x8000003Du, 0x8000003Eu, 0x8000003Fu, 0x80000040u, 0x80000041u, + 0x80000042u, 0x80000043u, 0x80000044u, 0x80000045u, 0x80000046u, 0x80000047u, + 0x80000048u, 0x80000049u, 0x1000004Au, 0x1000004Bu, 0x1300004Cu, 0x1000004Du, + 0x1000004Eu, 0x1000004Fu, 0x10000050u, 0x10000051u, 0x10000052u, 0x10000053u, + 0x10000054u, 0x10000055u, 0x10000056u, 0x10000057u, 0x10000058u, 0x10000059u, + 0x1000005Au, 0x1000005Bu, 0x1000005Cu, 0x1000005Du, 0x1000005Eu, 0x1000005Fu, + 0x10000060u, 0x10000061u, 0x10000062u, 0x10000063u, 0x10000064u, 0x10000065u, + 0x10000066u, 0x10000067u, 0x10000068u, 0x10000069u, 0x1000006Au, 0x1000006Bu, + 0x1000006Cu, 0x1000006Du, 0x1000006Eu, 0x1000006Fu, 0x10000070u, 0x10000071u, + 0x10000072u, 0x10000073u, 0x10000074u, 0x10000075u, 0x10000076u, 0x10000077u, + 0x10000078u, 0x13000079u, 0x1300007Au, 0x1300007Bu, 0x1300007Cu, 0x1300007Du, + 0x1300007Eu, 0x1300007Fu, 0x13000080u, 0x13000081u, 0x13000082u, 0x13000083u, + 0x13000084u, 0x13000085u, 0x13000086u, 0x13000087u, 0x13000088u, 0x13000089u, + 0x1300008Au, 0x1300008Bu, 0x1300008Cu, 0x1300008Du, 0x1300008Eu, 0x1300008Fu, + 0x13000090u, 0x13000091u, 0x13000092u, 0x13000093u, 0x13000094u, 0x13000095u, + 0x13000096u, 0x13000097u, 0x13000098u, 0x13000099u, 0x1300009Au, 0x1200009Bu, + 0x1000009Cu, 0x1000009Du, 0x1000009Eu, 0x1000009Fu, 0x100000A0u, 0x100000A1u, + 0x080000A2u, 0x090000A3u, 0x090000A4u, 0x090000A5u, 0x090000A6u, 0x090000A7u, + 0x090000A8u, 0x080000A9u, 0x090000AAu, 0x090000ABu, 0x090000ACu, 0x090000ADu, + 0x090000AEu, 0x090000AFu, 0x090000B0u, 0x090000B1u, 0x0D0000B2u, 0x0D0000B3u, + 0x0D0000B4u, 0x080000B5u, 0x080000B6u, 0x080000B7u, 0x090000B8u, 0x090000B9u, + 0x0D0000BAu, 0x0D0000BBu, 0x0D0000BCu, 0x0D0000BDu, 0x0D0000BEu, 0x0D0000BFu, + 0x090000C0u, 0x0C0000C1u, 0x090000C2u, 0x090000C3u, 0x090000C4u, 0x0D0000C5u, + 0x090000C6u, 0x090000C7u, 0x090000C8u, 0x090000C9u, 0x130000CAu, 0x130000CBu, + 0x130000CCu, 0x100000CDu, 0x100000CEu, 0x100000CFu, 0x100000D0u, 0x100000D1u, + 0x100000D2u, 0x400000D3u, 0x120000D4u, 0x090000D5u, 0x090000D6u, 0x090000D7u, + 0x090000D8u, 0x090000D9u, 0x090000DAu, 0x090000DBu, 0x090000DCu, 0x090000DDu, + 0x090000DEu, 0x120000DFu, 0x400000E0u, 0x400000E1u, 0x100000E2u, 0x100000E3u, + 0x400000E4u, 0x400000E5u, 0x400000E6u, 0x090000E7u, 0x800000E8u, 0x800000E9u, + 0x430000EAu, 0x430000EBu, 0x430000ECu, 0x430000EDu, 0x430000EEu, 0x430000EFu, + 0x430000F0u, 0x430000F1u, 0x430000F2u, 0x430000F3u, 0x430000F4u, 0x430000F5u, + 0x430000F6u, 0x430000F7u, 0x430000F8u, 0x420000F9u, 0x430000FAu, 0x430000FBu, + 0x430000FCu, 0x430000FDu, 0x090000FEu, 0x090000FFu, 0x09000100u, 0x09000101u, + 0x09000102u, 0x09000103u, 0x09000104u, 0x09000105u, 0x09000106u, 0x09000107u, + 0x09000108u, 0x09000109u, 0x0900010Au, 0x0900010Bu, 0x0900010Cu, 0x0900010Du, + 0x1000010Eu, 0x0900010Fu, 0x09000110u, 0x09000111u, 0x09000112u, 0x09000113u, + 0x09000114u, 0x43000115u, 0x13000116u, 0x43000117u, 0x43000118u, 0x43000119u, + 0x0900011Au, 0x1000011Bu, 0x1000011Cu, 0x1000011Du, 0x1000011Eu, 0x1000011Fu, + 0x10000120u, 0x10000121u, 0x10000122u, 0x10000123u, 0x10000124u, 0x10000125u, + 0x10000126u, 0x10000127u, 0x10000128u, 0x10000129u, 0x1000012Au, 0x1000012Bu, + 0x1000012Cu, 0x1000012Du, 0x1000012Eu, 0x1000012Fu, 0x10000130u, 0x10000131u, + 0x13000132u, 0x40000133u, 0x40000134u, 0x40000135u, 0x40000136u, 0x10000137u, + 0x80000138u, 0x80000139u, 0x4300013Au, 0x4300013Bu, 0x4300013Cu, 0x4300013Du, + 0x4300013Eu, 0x4300013Fu, 0x43000140u, 0x43000141u, 0x43000142u, 0x43000143u, + 0x43000144u, 0x43000145u, 0x43000146u, 0x13000147u, 0x13000148u, 0x13000149u, + 0x1300014Au, 0x1300014Bu, 0x1300014Cu, 0x1300014Du, 0x1300014Eu, 0x1300014Fu, + 0x10000150u, 0x09000151u, 0x09000152u, 0x09000153u, 0x09000154u, 0x09000155u, + 0x09000156u, 0x09000157u, 0x09000158u, 0x09000159u, 0x0900015Au, 0x0900015Bu, + 0x0900015Cu, 0x0900015Du, 0x0900015Eu, 0x0900015Fu, 0x09000160u, 0x09000161u, + 0x10000162u, 0x10000163u, 0x10000164u, 0x09000165u, 0x09000166u, 0x09000167u, + 0x09000168u, 0x09000169u, 0x0900016Au, 0x0900016Bu, 0x0900016Cu, 0x0900016Du, + 0x1000016Eu, 0x1000016Fu, 0x10000170u, 0x10000171u, 0x10000172u, 0x10000173u, + 0x10000174u, 0x10000175u, 0x10000176u, 0x10000177u, 0x10000178u, 0x10000179u, + 0x1000017Au, 0x1000017Bu, 0x1000017Cu, 0x1000017Du, 0x1000017Eu, 0x1000017Fu, + 0x10000180u, 0x10000181u, 0x10000182u, 0x10000183u, 0x10000184u, 0x10000185u, + 0x10000186u, 0x10000187u, 0x10000188u, 0x10000189u, 0x1000018Au, 0x1000018Bu, + 0x1000018Cu, 0x1000018Du, 0x1000018Eu, 0x1000018Fu, 0x10000190u, 0x10000191u, + 0x10000192u, 0x10000193u, 0x10000194u, 0x10000195u, 0x10000196u, 0x10000197u, + }; +} diff --git a/src/AcDream.Core/Physics/ServerControlledLocomotion.cs b/src/AcDream.Core/Physics/ServerControlledLocomotion.cs index af4d14dd..6444b3da 100644 --- a/src/AcDream.Core/Physics/ServerControlledLocomotion.cs +++ b/src/AcDream.Core/Physics/ServerControlledLocomotion.cs @@ -32,24 +32,10 @@ public static class ServerControlledLocomotion public const float MinSpeedMod = 0.25f; public const float MaxSpeedMod = 3.00f; - // Retail MoveToManager::BeginMoveForward -> MovementParameters::get_command - // (0x0052AA00) seeds forward motion before the next position update. - public static LocomotionCycle PlanMoveToStart( - float moveToSpeed = 1f, - float runRate = 1f, - bool canRun = true) - { - moveToSpeed = SanitizePositive(moveToSpeed); - runRate = SanitizePositive(runRate); - - if (!canRun) - return new LocomotionCycle(MotionCommand.WalkForward, moveToSpeed, true); - - return new LocomotionCycle( - MotionCommand.RunForward, - moveToSpeed * runRate, - true); - } + // R4-V4: PlanMoveToStart DELETED - MoveTo UMs route to the verbatim + // MoveToManager (BeginMoveForward -> get_command -> _DoMotion produces + // the cycle through the same sink every other motion uses). + // PlanFromVelocity below survives (M16 register row, retires in R6). public static LocomotionCycle PlanFromVelocity(Vector3 worldVelocity) { diff --git a/src/AcDream.Core/Physics/ShadowShapeBuilder.cs b/src/AcDream.Core/Physics/ShadowShapeBuilder.cs index 5d8d8ee6..a0e28ff3 100644 --- a/src/AcDream.Core/Physics/ShadowShapeBuilder.cs +++ b/src/AcDream.Core/Physics/ShadowShapeBuilder.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Numerics; +using AcDream.Core.World; using DatReaderWriter.DBObjs; using DatReaderWriter.Enums; using DatReaderWriter.Types; @@ -38,10 +39,22 @@ public static class ShadowShapeBuilder /// every radius, height, and local offset. /// Predicate: does the GfxObj with this id /// have a non-null PhysicsBSP? Production: id => cache.GetGfxObj(id)?.BSP?.Root is not null. + /// #175: per-part pose override for the + /// BSP part shapes — the entity's motion-table DEFAULT-STATE pose (the + /// closed pose for doors). Retail collision tests each part's LIVE + /// CPhysicsPart pose, which for an idle entity is the motion + /// table's default state, NOT the Setup's placement frame — the two + /// differ on e.g. the Facility Hub double door (Setup 0x02000C9D: + /// placement poses the panels AJAR at yaw −150°/−30°, y −0.44 m; the + /// closed pose is straight). Null / short lists fall back to the + /// placement frame per part (entities with no motion table, and the + /// CylSphere/Sphere shapes, are unaffected — retail poses those from + /// the setup too). public static IReadOnlyList FromSetup( Setup setup, float entScale, - Func hasPhysicsBsp) + Func hasPhysicsBsp, + IReadOnlyList? partPoseOverride = null) { if (setup is null) throw new ArgumentNullException(nameof(setup)); if (hasPhysicsBsp is null) throw new ArgumentNullException(nameof(hasPhysicsBsp)); @@ -84,15 +97,21 @@ public static class ShadowShapeBuilder } // 3. Parts — one BSP shape per part with a non-null PhysicsBSP. + // Pose priority per part: partPoseOverride (the motion-table + // default-state pose, #175) → placement frame → identity. AnimationFrame? placementFrame = ResolvePlacementFrame(setup); for (int i = 0; i < setup.Parts.Count; i++) { uint gfxId = (uint)setup.Parts[i]; if (!hasPhysicsBsp(gfxId)) continue; - Frame partFrame = placementFrame is not null && i < placementFrame.Frames.Count - ? placementFrame.Frames[i] - : new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }; + Frame partFrame; + if (partPoseOverride is not null && i < partPoseOverride.Count) + partFrame = partPoseOverride[i]; + else if (placementFrame is not null && i < placementFrame.Frames.Count) + partFrame = placementFrame.Frames[i]; + else + partFrame = new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }; // BSP radius default; caller substitutes the real BoundingSphere.Radius // at registration time when available. Loose-but-safe broadphase value. @@ -111,6 +130,84 @@ public static class ShadowShapeBuilder return result; } + /// + /// #185: build BSP shapes for a landblock-baked multi-part entity (buildings, + /// stair runs, fences, rock clusters) from its per-part s, + /// for registration via + /// under the entity's SINGLE unique id. + /// + /// + /// Replaces the former per-part Register(entity.Id * 256u + partIndex) + /// (GameWindow.cs) whose * 256u OVERFLOWED uint32 for class-prefixed + /// landblock ids (0x40/0x80/0xC0…): the overflow dropped + /// the prefix byte, so different-class entities sharing the low 24 bits + /// collided on one shadow part-id and Register's deregister-then-insert + /// silently overwrote one entity's collision geometry — the #185 "invisible + /// wall half-way up the stairs" (rendered steps with no collision). + /// + /// + /// + /// Retail anchor: a multi-part object is one CPhysicsObj + CPartArray; + /// CPhysicsObj::add_shadows_to_cells (0x00514ae0) → CPartArray::AddPartsShadow + /// walks the part array under the single object — no synthetic per-part id. + /// + /// + /// + /// Each part's local transform comes from its + /// (root-relative), decomposed to LocalPosition/LocalRotation/Scale; + /// RegisterMultiPart reconstructs the world placement identically + /// (entityWorldPos + rotate(LocalPosition, entityWorldRot)). Building + /// shells are excluded — they collide via the per-LandCell building channel + /// (CSortCell::find_collisions), not as shadow objects. + /// + /// + /// The entity's per-part mesh references. + /// True for LandBlockInfo.Buildings[] shells. + /// Resolves a GfxObj id to its cached physics (BSP + + /// bounding sphere). Production: id => cache.GetGfxObj(id). + public static List FromLandblockBspParts( + IReadOnlyList meshRefs, + bool isBuildingShell, + Func getGfxObj) + { + if (getGfxObj is null) throw new ArgumentNullException(nameof(getGfxObj)); + + var shapes = new List(); + // Building shells collide via the building channel (retail), not shadow objects. + if (isBuildingShell || meshRefs is null) return shapes; + + foreach (var meshRef in meshRefs) + { + var phys = getGfxObj(meshRef.GfxObjId); + if (phys?.BSP?.Root is null) continue; // no physics BSP → nothing to collide + + // PartTransform is root-relative; decompose to local pos/rot/scale. + if (!Matrix4x4.Decompose(meshRef.PartTransform, + out var pScale, out var pRot, out var pPos)) + { + pScale = Vector3.One; + pRot = Quaternion.Identity; + pPos = new Vector3(meshRef.PartTransform.M41, + meshRef.PartTransform.M42, + meshRef.PartTransform.M43); + } + + float partScale = pScale.X > 0f ? pScale.X : 1f; // AC objects are uniformly scaled + float localRadius = phys.BoundingSphere?.Radius ?? 1f; + + shapes.Add(new ShadowShape( + GfxObjId: meshRef.GfxObjId, + LocalPosition: pPos, + LocalRotation: pRot, + Scale: partScale, + CollisionType: ShadowCollisionType.BSP, + Radius: localRadius * partScale, + CylHeight: 0f)); + } + + return shapes; + } + /// Resolve the placement frame in priority Resting → Default → /// first available. Mirrors SetupMesh.Flatten's convention. private static AnimationFrame? ResolvePlacementFrame(Setup setup) diff --git a/src/AcDream.Core/Physics/TransitionTypes.cs b/src/AcDream.Core/Physics/TransitionTypes.cs index a633efd4..e7b67b11 100644 --- a/src/AcDream.Core/Physics/TransitionTypes.cs +++ b/src/AcDream.Core/Physics/TransitionTypes.cs @@ -69,6 +69,16 @@ public sealed class ObjectInfo /// public uint SelfEntityId; + /// + /// The moving object has the retail GRAVITY state bit (PhysicsStateFlags.Gravity 0x400). + /// Seeded from the body at get_object_info time. Retail's frames_stationary_fall + /// ladder is gated on the mover having gravity (object_info.object->state & 0x400, + /// validate_transition pc:272625; ACE ObjectInfo.Object.State.HasFlag(Gravity) + /// Transition.cs:1031) — a floating/gravity-less prop never accumulates a stuck-fall. + /// Default false so table-less/one-shot callers don't run the ladder. + /// + public bool MoverHasGravity; + // Convenience flag checks public bool Contact => State.HasFlag(ObjectInfoState.Contact); public bool OnWalkable => State.HasFlag(ObjectInfoState.OnWalkable); @@ -770,8 +780,19 @@ public sealed class Transition return false; // ------------------------------------------------------------------ - // Step subdivision: each sub-step travels at most one sphere radius - // to prevent tunnelling through thin surfaces. + // Step subdivision (retail CTransition::calc_num_steps 0x0050a0b0, + // pseudocode docs/research/2026-07-06-viewer-step-subdivision-pseudocode.md). + // Two shapes: + // - VIEWER (the camera sweep, state & 4): steps of EXACTLY one radius, + // anchored at the start — numSteps = floor(len/r) + 1, with the final + // step recomputed in the loop as the exact remainder. The anchored + // grid is invariant under mm-scale target drift, which is what makes + // retail's wall-pressed camera a fixed point ("rock steady"); the + // pre-#181 equal-slice grid reshuffled every boundary per frame and + // the camera orbited a ~0.5 mm/frame limit cycle instead + // (Issue181WallPressEquilibriumTests). + // - non-viewer: equal slices of ~one radius (TRANSITIONAL_PERCENT_OF_ + // RADIUS = 1.0 at 0x007c6874) — unchanged, matches retail. // ------------------------------------------------------------------ Vector3 offset = sp.EndPos - sp.BeginPos; float dist = offset.Length(); @@ -781,25 +802,41 @@ public sealed class Transition if (radius <= PhysicsGlobals.EPSILON) return false; - float step = dist / radius; - int numSteps; Vector3 offsetPerStep; - if (step > 1.0f) + if (ObjectInfo.IsViewer) { - numSteps = (int)MathF.Ceiling(step); - offsetPerStep = offset * (1f / numSteps); - } - else if (offset != Vector3.Zero) - { - numSteps = 1; - offsetPerStep = offset; + if (dist > PhysicsGlobals.EPSILON) + { + offsetPerStep = offset * (radius / dist); // radius-length steps + numSteps = (int)MathF.Floor(dist / radius) + 1; + } + else + { + numSteps = 0; + offsetPerStep = Vector3.Zero; + } } else { - numSteps = 0; - offsetPerStep = Vector3.Zero; + float step = dist / radius; + + if (step > 1.0f) + { + numSteps = (int)MathF.Ceiling(step); + offsetPerStep = offset * (1f / numSteps); + } + else if (offset != Vector3.Zero) + { + numSteps = 1; + offsetPerStep = offset; + } + else + { + numSteps = 0; + offsetPerStep = Vector3.Zero; + } } // Retail safety cap (30 steps). Viewer/sight objects bypass it, matching @@ -843,6 +880,13 @@ public sealed class Transition for (int i = 0; i < numSteps; i++) { + // Viewer last-step remainder (retail find_transitional_position + // 0x0050bdf0: on i == numSteps−1 for state&4, the step offset is + // recomputed as offset · (len − (numSteps−1)·r)/len — the sweep + // ends exactly at EndPos, never overshooting the anchored grid). + if (ObjectInfo.IsViewer && i == numSteps - 1 && dist > PhysicsGlobals.EPSILON) + offsetPerStep = offset * ((dist - (numSteps - 1) * radius) / dist); + Vector3 requestedOffset = offsetPerStep; // Per ACE order: AdjustOffset FIRST (uses state from previous step), @@ -859,8 +903,13 @@ public sealed class Transition } // Abort if adjusted offset is negligible (stuck against a wall - // with no slide tangent available). - if (sp.GlobalOffset.LengthSquared() < PhysicsGlobals.EpsilonSq) + // with no slide tangent available). NON-VIEWER-ONLY per retail + // (find_transitional_position 0x0050bdf0: `(state & 4) == 0 && + // |global_offset|² < F_EPSILON²`) — a pressed camera keeps + // stepping through sub-epsilon adjusted offsets so its remainder + // step still lands exactly on the sought (#181 equilibrium). + if (!ObjectInfo.IsViewer + && sp.GlobalOffset.LengthSquared() < PhysicsGlobals.EpsilonSq) { if (stepWalkProbe) { @@ -917,8 +966,13 @@ public sealed class Transition transitionState); } - // PathClipped objects stop at the first collision. - if (CollisionInfo.CollisionNormalValid && ObjectInfo.PathClipped) + // retail find_valid_position (pc:273745): stop the sweep as soon as the mover is + // flagged stuck (frames_stationary_fall != 0) OR a PathClipped object took its + // first collision. The fsf break is load-bearing — without it a later advancing + // sub-step in the SAME frame resets fsf, so the counter can never escalate across + // frames (ACE Transition.cs:587 `if (CollisionInfo.FramesStationaryFall > 0) break`). + if (CollisionInfo.FramesStationaryFall != 0 + || (CollisionInfo.CollisionNormalValid && ObjectInfo.PathClipped)) break; } @@ -1804,6 +1858,21 @@ public sealed class Transition { if (cellId == sp.CheckCellId) continue; + // #137 seam shake (2026-07-06): a mid-loop query can MOVE the + // sphere — a Path-5 full hit dispatches step_sphere_up, and a + // successful climb lifts the foot (the 0.6 mm ramp-slab lift at + // the Facility Hub boundaries) yet returns OK, so the loop + // continues. Retail's check_other_cells reads the LIVE + // sphere_path.global_sphere for every cell (each cell's + // find_collisions receives the transition itself, pc:272717+); + // querying the remaining cells with the pre-climb center re-tests + // the boundary ~0.4 mm inside the floor slab and grazes the + // under-room's CEILING (the slab underside) — the neg-poly + // step-up-with-a-downward-normal chain that shook the player at + // every corridor seam. Same lesson as the P2 cellar-lip fix + // (RunCheckOtherCellsAndAdvance's entry refresh), one loop deeper. + footCenter = sp.GlobalSphere[0].Origin; + if ((cellId & 0xFFFFu) < 0x0100u) { var terrainWalkable = engine.SampleTerrainWalkable(footCenter.X, footCenter.Y); @@ -2738,7 +2807,13 @@ public sealed class Transition continue; } - result = SphereCollision(obj, sp); + // Retail var_8_1 (pc:276846; ACE PhysicsObj.cs:409): the target is + // a creature OR a missile (state & MISSILE_PS 0x40). Gates OFF the + // "stand-on / land-on" branches (2 and 5) of the CSphere family — + // you push against a creature horizontally but never rest on it. + bool isCreature = (obj.State & 0x40u) != 0 + || (obj.Flags & EntityCollisionFlags.IsCreature) != 0; + result = SphereCollision(obj, sp, engine, isCreature); } else { @@ -2811,9 +2886,12 @@ public sealed class Transition // Effect (pc:276973-276977): // state_3 = OK_TS ← force passable // collision_normal_valid = 0 ← clear stale slide normal - // Note: Cylinder and Sphere shapes already return OK from their own - // obstruction_ethereal early-out, so this clause only fires in practice - // for the BSP branch, but is written unconditionally as retail does. + // Note: the BSP branch AND (since the 2026-07-05 CCylSphere family + // port) the Cylinder branch rely on this clause for ethereal + // passability — CylinderCollision's branch 1 returns Collided on + // overlap like retail, and THIS override clears it for non-static + // targets. Only the Sphere branch still early-outs on + // obstruction_ethereal (consume site 1). if (result != TransitionState.OK && sp.ObstructionEthereal && !sp.StepDown @@ -3060,279 +3138,790 @@ public sealed class Transition } /// - /// Sphere collision test for objects. - /// Uses a true 3-D sphere-sphere overlap test — no height clamp, no XY-only - /// distance — matching retail's CSphere::intersects_sphere @ 0x00537A80. + /// Retail CSphere::intersects_sphere dispatcher — port of + /// 0x00537A80 (acclient_2013_pseudo_c.txt:321678). Full family: + /// collides_with_sphere 0x005369e0, step_sphere_up 0x00537900, + /// slide_sphere 0x00537440, land_on_sphere 0x005379a0, + /// collide_with_point 0x00537230, step_sphere_down 0x00536d20. + /// Pseudocode + settled ambiguities + ACE cross-reference: + /// docs/research/2026-07-07-csphere-collision-family-pseudocode.md. /// /// - /// Implements the subset of the 6-path dispatcher needed for static/placed - /// Sphere objects: static overlap check (obstruction_ethereal / check_walkable / - /// Contact-grounded paths), plus a 3-D outward push-back for the slide response. - /// The swept quadratic from - /// is used for the narrow-phase; the slide response mirrors the cylinder's - /// wall-slide but pushes outward in 3-D (not XY-only). + /// Player↔humanoid-creature collision runs HERE: humanoid Setups carry body + /// Spheres (no CylSpheres) → + /// emits . Replaces the pre-2026-07-07 + /// hand-rolled 3-D wall-slide (register TS-45, retired here): that + /// approximation shaved no ε, force-pushed the mover RADIALLY out to a fixed + /// combinedR + 1 cm shell every contact, ignored the head sphere, and + /// always returned Slid — so a player packed by a crowd of body-sphere + /// creatures wedged (opposing radial pushes cancel) instead of shuffling out + /// along the contact crease. The faithful family routes the grounded slide + /// through the shared (the Ghidra-confirmed + /// CSphere::slide_sphere 0x00537440 crease projection — #116), giving + /// retail's tangential wiggle room. Driving repro: the user's live + /// crowd-collision report, 2026-07-07. /// /// /// - /// ACE oracle: Sphere.IntersectsSphere in - /// ACE.Server/Physics/Sphere.cs — particularly the - /// ObstructionEthereal/Placement, CheckWalkable, and - /// Contact branches. Retail decomp cross-reference: - /// acclient_2013_pseudo_c.txt:321678. + /// The already carries the wrapper overload's + /// (0x00537fd0) work: Position = globalized center (entity frame at + /// registration), Radius pre-scaled; CSphere uses full 3-D distance (no + /// height clamp — unlike CCylSphere). Ethereal targets keep the existing + /// early-OK consume site 1 (retail's void ethereal branch produces no block); + /// the caller's Layer-2 override is the door passability mechanism, and the + /// step-down pass never reaches here for ethereal targets (pc:276799 skip). /// /// - private TransitionState SphereCollision(ShadowEntry obj, SpherePath sp) + /// Retail var_8_1 (pc:276846; ACE + /// PhysicsObj.cs:409): the target is a creature OR a missile + /// (state & MISSILE_PS 0x40). Gates OFF the "stand-on / land-on" + /// branches (2 and 5) — you push against a creature horizontally but never + /// rest on it. Computed by the caller. + private TransitionState SphereCollision(ShadowEntry obj, SpherePath sp, PhysicsEngine engine, bool isCreature) { // Consume site 1 — CSphere::intersects_sphere @ 0x00537ae4 (pc:321692). - // When obstruction_ethereal is set (target is ETHEREAL-alone, state & 0x4), - // the retail function is void and all paths in the ethereal branch return - // without producing a COLLIDED/Slid result — the player is fully passable. - // We mirror this by returning OK immediately, skipping all blocking paths. - // Retail ref: acclient_2013_pseudo_c.txt:321692. - if (sp.ObstructionEthereal) - return TransitionState.OK; - - var ci = CollisionInfo; - Vector3 sphereCurrPos = sp.GlobalCurrCenter[0].Origin; - Vector3 sphereCheckPos = sp.GlobalSphere[0].Origin; - float sphRadius = sp.GlobalSphere[0].Radius; - Vector3 sphMovement = sphereCheckPos - sphereCurrPos; - - // 3-D distance from check position to target sphere centre. - // Unlike CCylSphere (which clips to a height range and uses XY-only - // distance), CSphere uses the full 3-D Euclidean distance. - // Retail anchor: CSphere::intersects_sphere @ 0x00537A80 — - // the displacement vector is the full (x,y,z) delta, not XY-only. - float dx = sphereCheckPos.X - obj.Position.X; - float dy = sphereCheckPos.Y - obj.Position.Y; - float dz = sphereCheckPos.Z - obj.Position.Z; - float distSq = dx * dx + dy * dy + dz * dz; - float combinedR = sphRadius + obj.Radius; - float combinedRSq = combinedR * combinedR; - - if (distSq >= combinedRSq) - return TransitionState.OK; // not overlapping at check position - - // ── Overlap detected — compute 3-D outward collision normal ────── - float dist = MathF.Sqrt(distSq); - Vector3 collisionNormal; - if (dist < PhysicsGlobals.EPSILON) - { - // Sphere centers coincide — push back along reverse movement. - float mLen = sphMovement.Length(); - if (mLen > PhysicsGlobals.EPSILON) - collisionNormal = -sphMovement / mLen; - else - collisionNormal = Vector3.UnitX; - } - else - { - collisionNormal = new Vector3(dx / dist, dy / dist, dz / dist); - } - - // ── Wall-slide response (mirrors CylinderCollision but in 3-D) ─── - // Project movement onto the plane perpendicular to the collision normal, - // then push the slid position outside the combined-radius shell. - float movementIntoWall = Vector3.Dot(sphMovement, collisionNormal); - Vector3 projectedMovement = sphMovement - collisionNormal * movementIntoWall; - - Vector3 slidPos = sphereCurrPos + projectedMovement; - - // Ensure slid position is outside combined radius (3-D push). - float sdx = slidPos.X - obj.Position.X; - float sdy = slidPos.Y - obj.Position.Y; - float sdz = slidPos.Z - obj.Position.Z; - float sDistSq = sdx * sdx + sdy * sdy + sdz * sdz; - float minDist = combinedR + 0.01f; - if (sDistSq < minDist * minDist) - { - float sDist = MathF.Sqrt(sDistSq); - if (sDist < PhysicsGlobals.EPSILON) - { - slidPos.X = obj.Position.X + collisionNormal.X * minDist; - slidPos.Y = obj.Position.Y + collisionNormal.Y * minDist; - slidPos.Z = obj.Position.Z + collisionNormal.Z * minDist; - } - else - { - float pushDist = minDist - sDist; - slidPos.X += (sdx / sDist) * pushDist; - slidPos.Y += (sdy / sDist) * pushDist; - slidPos.Z += (sdz / sDist) * pushDist; - } - } - - Vector3 delta = slidPos - sphereCheckPos; - sp.AddOffsetToCheckPos(delta); - - ci.SetCollisionNormal(collisionNormal); - ci.SetSlidingNormal(collisionNormal); - return TransitionState.Slid; - } - - /// - /// Cylinder collision test for CylSphere objects (tree trunks, rock pillars, NPCs, - /// door foot-colliders). For Contact-grounded movers, attempts to step over short - /// cylinders (retail-faithful CCylSphere::step_sphere_up). For airborne movers, - /// movers already stepping, or cylinders too tall to step over, applies a - /// horizontal wall-slide response. - /// - /// - /// A6.P6 (2026-05-25): the step-over path matches retail's - /// CCylSphere::step_sphere_up at - /// acclient_2013_pseudo_c.txt:324516-324538. The door's foot - /// cylinder (h=0.20m, r=0.10m) is too tall for the static slide to - /// produce smooth sliding along the slab — the radial push-out - /// fires as a "phantom collision" at the door's center when the - /// sphere is touching the slab face and the cyl is just within reach. - /// Retail steps the sphere over the cyl (succeeds when - /// step_up_height >= sphere.radius + cyl.height - offset.z), - /// which lets the sphere walk past the cyl without the radial push. - /// On step-up failure (cyl too tall, no walkable surface beyond), - /// falls back to step_up_slide — the same crease-projection - /// slide the BSP path uses, which produces smoother behavior than - /// the radial push. - /// - /// - private TransitionState CylinderCollision(ShadowEntry obj, SpherePath sp, PhysicsEngine engine) - { - // Consume site 2 — CCylSphere::intersects_sphere @ 0x0053b4a0 (pc:324573). - // When obstruction_ethereal is set (target is ETHEREAL-alone, state & 0x4), - // the retail function is void and all paths in the ethereal branch return - // without producing a COLLIDED/Slid result — the player is fully passable. - // We mirror this by returning OK immediately, skipping all blocking paths. - // Retail ref: acclient_2013_pseudo_c.txt:324573. + // Ethereal-alone (state & 0x4): retail's void ethereal branch returns + // without a blocking result. Mirror by returning OK immediately — the + // caller's Layer-2 override handles non-static ethereal passability for + // the other shape branches; only the Sphere branch early-outs here. + // Unchanged from the pre-port behavior → every ethereal/door test stays + // identical. if (sp.ObstructionEthereal) return TransitionState.OK; var ci = CollisionInfo; var oi = ObjectInfo; - Vector3 sphereCurrPos = sp.GlobalCurrCenter[0].Origin; - Vector3 sphereCheckPos = sp.GlobalSphere[0].Origin; - float sphRadius = sp.GlobalSphere[0].Radius; - Vector3 sphMovement = sphereCheckPos - sphereCurrPos; + var s0 = sp.GlobalSphere[0]; + Vector3 disp0 = s0.Origin - obj.Position; + // radsum: ε shaved ONCE (0x00537acd). Resting flush against a monster is + // a NON-overlap, so a shuffle that ends touching settles instead of + // re-colliding every frame — the first wiggle-room ingredient TS-45 lost. + float radsum = s0.Radius + obj.Radius - PhysicsGlobals.EPSILON; - // Vertical check: does sphere reach the cylinder's height range at all? - float cylTop = obj.CylHeight > 0 ? obj.CylHeight : obj.Radius * 4f; - float checkZ = sphereCheckPos.Z; - if (checkZ - sphRadius > obj.Position.Z + cylTop || - checkZ + sphRadius < obj.Position.Z) + bool hasHead = sp.NumSphere > 1; + Vector3 disp1 = default; + if (hasHead) + disp1 = sp.GlobalSphere[1].Origin - obj.Position; + + // ── Branch 1 (0x00537ae4): placement — detection only. ── + if (sp.InsertType == InsertType.Placement) + { + if (SphereCollidesWithSphere(disp0, radsum)) + return TransitionState.Collided; + if (hasHead && SphereCollidesWithSphere(disp1, radsum)) + return TransitionState.Collided; + return TransitionState.OK; + } + + // ── Branch 2 (0x00537af5): step-down probe — land on the top. ── + if (sp.StepDown) + { + if (isCreature) + return TransitionState.OK; // §8.1 — never stand ON a creature/missile + return SphereStepSphereDown(obj, sp, disp0, radsum); + } + + // ── Branch 3 (0x00537b27): walkable probe — occupancy blocks. ── + if (sp.CheckWalkable) + { + if (SphereCollidesWithSphere(disp0, radsum)) + return TransitionState.Collided; + if (hasHead && SphereCollidesWithSphere(disp1, radsum)) + return TransitionState.Collided; + return TransitionState.OK; + } + + if (!sp.Collide) + { + // ── Branch 4 (0x00537de8): normal transition sweep. ── + if ((oi.State & (ObjectInfoState.Contact | ObjectInfoState.OnWalkable)) != 0) + { + // Grounded: foot hit → step over / slide; head hit → slide. + if (SphereCollidesWithSphere(disp0, radsum)) + return SphereStepSphereUp(obj, sp, engine, disp0, radsum); + if (hasHead && SphereCollidesWithSphere(disp1, radsum)) + return SphereSlideSphere(obj, sp, 1); + } + else if ((oi.State & ObjectInfoState.PathClipped) != 0) + { + if (SphereCollidesWithSphere(disp0, radsum)) + return SphereCollideWithPoint(obj, sp, s0, radsum, 0); + } + else + { + // Airborne: foot hit → land on the sphere top; head hit → point hit. + if (SphereCollidesWithSphere(disp0, radsum)) + return SphereLandOnSphere(obj, sp); + if (hasHead && SphereCollidesWithSphere(disp1, radsum)) + return SphereCollideWithPoint(obj, sp, sp.GlobalSphere[1], radsum, 1); + } + return TransitionState.OK; + } + + // ── Branch 5 (0x00537b80): collide-flag re-test — exact-TOI landing on a + // sphere's curved top (a TILTED contact plane by the sphere-to-sphere + // direction, unlike the cylinder's flat disc). Creature/missile-gated OFF; + // in M1.5 only non-creature Sphere-shape statics reach it (rare — statics + // are CylSphere/BSP). Ported per ACE Sphere.cs:369-414. + if (isCreature) + return TransitionState.OK; // §8.1 + + bool hit0 = SphereCollidesWithSphere(disp0, radsum); + if (!hit0 && !(hasHead && SphereCollidesWithSphere(disp1, radsum))) return TransitionState.OK; - // XY distance from sphere check position to cylinder axis. - float dxCheck = sphereCheckPos.X - obj.Position.X; - float dyCheck = sphereCheckPos.Y - obj.Position.Y; - float distSqCheck = dxCheck * dxCheck + dyCheck * dyCheck; - float combinedR = sphRadius + obj.Radius; - float combinedRSq = combinedR * combinedR; + // Block offset = 0 (continuous world frame; same note as SlideSphere's gDelta). + Vector3 movement = sp.GlobalCurrCenter[0].Origin - s0.Origin; + float radsumEps = radsum + PhysicsGlobals.EPSILON; + float lenSq = movement.LengthSquared(); + if (MathF.Abs(lenSq) < PhysicsGlobals.EPSILON) + return TransitionState.Collided; + float diff = -Vector3.Dot(movement, disp0); + float disc = diff * diff - (disp0.LengthSquared() - radsumEps * radsumEps) * lenSq; + if (disc < 0f) + return TransitionState.Collided; // defensive: retail reaches the TOI only via a colliding sphere (disc≥0) + float tt = MathF.Sqrt(disc) + diff; + if (tt > 1f) tt = diff * 2f - tt; + float time = tt / lenSq; + float timecheck = (1f - time) * sp.WalkInterp; + if (timecheck >= sp.WalkInterp || timecheck < -0.1f) + return TransitionState.Collided; + movement *= time; + Vector3 dispN = (disp0 + movement) / radsumEps; + if (dispN.Z <= sp.WalkableAllowance) // !is_walkable_allowable — sphere top too steep to rest on + return TransitionState.OK; + Vector3 restPt = s0.Origin - dispN * s0.Radius; + // is_water=1 verbatim retail (0x00536ecf). Do not "fix". + var contactPlane = new Plane(dispN, -Vector3.Dot(dispN, restPt)); + ci.SetContactPlane(contactPlane, sp.CheckCellId, isWater: true); + sp.WalkInterp = timecheck; + sp.AddOffsetToCheckPos(movement); + return TransitionState.Adjusted; + } - if (distSqCheck >= combinedRSq) - return TransitionState.OK; // not overlapping at check position + /// + /// Retail CSphere::collides_with_sphere (0x005369e0, pc:320964): pure + /// 3-D overlap — |disp|² <= radsum². = the + /// mover sphere center − target center. No XY/Z-band split — that's the + /// cylinder. + /// + private static bool SphereCollidesWithSphere(Vector3 disp, float radsum) + => disp.LengthSquared() <= radsum * radsum; - // ─── Overlap detected ───────────────────────────────────── - // Horizontal outward normal from the cylinder axis to the sphere - // check position. For the degenerate case where the sphere center - // is exactly on the axis, use the movement direction as a fallback - // (pushes the sphere back out along the way it came in). - float distCheck = MathF.Sqrt(distSqCheck); - Vector3 collisionNormal; - if (distCheck < PhysicsGlobals.EPSILON) + /// + /// Retail CSphere::step_sphere_up (0x00537900, pc:321611). Too tall to + /// step over → slide; otherwise the generic step-up ( = + /// CTransition::step_up). Unlike the cylinder path, retail passes the + /// UNNORMALIZED global_curr_center − center and does NOT rotate by the + /// target frame (a sphere has no orientation, 0x0053794e). For a full-height + /// creature the head clearance far exceeds step_up_height, so this always + /// slides — the grounded-crowd path. + /// + private TransitionState SphereStepSphereUp(ShadowEntry obj, SpherePath sp, + PhysicsEngine engine, Vector3 disp0, float radsum) + { + // radsum += ε here (dispatcher shaved it once; net = s0.r + obj.r) — + // retail 0x0053790a / ACE Sphere.cs:688. + float radsumEps = radsum + PhysicsGlobals.EPSILON; + if (ObjectInfo.StepUpHeight < radsumEps - disp0.Z) + return SphereSlideSphere(obj, sp, 0); + + // Unnormalized center-to-center (retail 0x0053794e passes var_c raw). + Vector3 n = sp.GlobalCurrCenter[0].Origin - obj.Position; + + // engine==null only in bare unit-test transitions with no step-up + // machinery — the retail-faithful fallback is the slide. + if (engine is not null && DoStepUp(n, engine)) + return TransitionState.OK; + + return sp.StepUpSlide(this); + } + + /// + /// Retail CSphere::slide_sphere (0x00537440 core via the 0x00537a10 + /// wrapper, pc:321403/321660): collision normal = + /// global_curr_center[sphereNum] − center (normalized), then the shared + /// crease projection (). THE wiggle-room primitive — + /// the mover slides ALONG the tangent where the monster's side meets the + /// ground, toward the gap, instead of being force-pushed radially out. + /// + private TransitionState SphereSlideSphere(ShadowEntry obj, SpherePath sp, int sphereNum) + { + Vector3 n = sp.GlobalCurrCenter[sphereNum].Origin - obj.Position; + if (NormalizeCheckSmall(ref n)) + return TransitionState.Collided; + return SlideSphere(n, sp.GlobalCurrCenter[sphereNum].Origin, sphereNum); + } + + /// + /// Retail CSphere::land_on_sphere (0x005379a0, pc:321642): airborne + /// foot hit — arm the Collide re-test (backup + flag) and relax the walkable + /// allowance to LandingZ. The NEXT attempt's branch 5 rests the sphere on the + /// top with the exact time-of-impact. Identical shape to + /// . + /// + private TransitionState SphereLandOnSphere(ShadowEntry obj, SpherePath sp) + { + Vector3 n = sp.GlobalCurrCenter[0].Origin - obj.Position; + if (NormalizeCheckSmall(ref n)) + return TransitionState.Collided; + sp.SetCollide(n); + sp.WalkableAllowance = PhysicsGlobals.LandingZ; // 0.0871557 (0x005379f2) + return TransitionState.Adjusted; + } + + /// + /// Retail CSphere::collide_with_point (0x00537230, pc:321327): + /// PathClipped movers + airborne head-sphere hits. Non-PerfectClip records the + /// center-to-center collision normal and hard-stops (the M1.5 load-bearing + /// path — players never set PerfectClip). PerfectClip gets the exact + /// time-of-impact reposition (missiles only — AP-84, dead in M1.5, ported per + /// ACE Sphere.cs:175-210; re-verify vs Ghidra before missiles ship). + /// + private TransitionState SphereCollideWithPoint(ShadowEntry obj, SpherePath sp, + Sphere checkSphere, float radsum, int sphereNum) + { + Vector3 gCenter = sp.GlobalCurrCenter[sphereNum].Origin; + Vector3 globalOffset = gCenter - obj.Position; + + if (!ObjectInfo.State.HasFlag(ObjectInfoState.PerfectClip)) { - // Sphere center on cylinder axis — push along reverse movement. - float mxy = MathF.Sqrt(sphMovement.X * sphMovement.X + sphMovement.Y * sphMovement.Y); - if (mxy > PhysicsGlobals.EPSILON) - collisionNormal = new Vector3(-sphMovement.X / mxy, -sphMovement.Y / mxy, 0f); - else - collisionNormal = Vector3.UnitX; - } - else - { - collisionNormal = new Vector3(dxCheck / distCheck, dyCheck / distCheck, 0f); + if (!NormalizeCheckSmall(ref globalOffset)) + CollisionInfo.SetCollisionNormal(globalOffset); + return TransitionState.Collided; } - // A6.P6 (2026-05-25): retail-faithful CCylSphere::step_sphere_up for - // Contact-grounded movers. acclient_2013_pseudo_c.txt:324516-324538. - // - // Retail check: step_up_height must clear (sphere.radius + cyl.height - // - offset.z) where offset.z is sphere center Z minus cyl low_pt Z. - // Geometrically: the height we need to lift the sphere to clear the - // cyl's top, less the sphere center's current height above the cyl - // base, equals cyl top minus sphere bottom (positive when sphere - // currently below cyl top). - // - // For the door's foot cyl (h=0.20m, sphere radius 0.48m, step_up 0.60m) - // at standing height (offset.z ~0.38m): cyl_clearance = - // 0.48 + 0.20 - 0.38 = 0.30m, step_up_height = 0.60m → step over OK. - if (oi.Contact && !sp.StepUp && !sp.StepDown && engine is not null) - { - float offsetZ = sphereCheckPos.Z - obj.Position.Z; - float cylClearance = sphRadius + cylTop - offsetZ; + // PerfectClip exact time-of-impact (AP-84 — dead in M1.5). Block offset = 0. + Vector3 checkOffset = checkSphere.Origin - gCenter; + double toi = FindSphereTimeOfCollision(checkOffset, globalOffset, radsum + PhysicsGlobals.EPSILON); + if (toi < PhysicsGlobals.EPSILON || toi > 1.0) + return TransitionState.Collided; + Vector3 collisionOffset = checkOffset * (float)toi - checkOffset; + Vector3 oldDisp = collisionOffset + checkSphere.Origin - obj.Position; + CollisionInfo.SetCollisionNormal(oldDisp / radsum); + sp.AddOffsetToCheckPos(oldDisp); + return TransitionState.Adjusted; + } - if (oi.StepUpHeight >= cylClearance) + /// + /// Retail CSphere::step_sphere_down (0x00536d20, pc:321133): during a + /// step-down probe, land the foot sphere on a sphere's curved top — contact + /// plane tilted by the sphere-to-sphere direction (unlike the cylinder's flat + /// disc). Creature/missile-gated OFF at the dispatcher (branch 2). Ported per + /// ACE Sphere.cs:617-664. + /// + private TransitionState SphereStepSphereDown(ShadowEntry obj, SpherePath sp, + Vector3 disp0, float radsum) + { + bool hit = SphereCollidesWithSphere(disp0, radsum); + if (!hit && sp.NumSphere > 1) + { + Vector3 disp1 = sp.GlobalSphere[1].Origin - obj.Position; + hit = SphereCollidesWithSphere(disp1, radsum); + } + if (!hit) + return TransitionState.OK; + + float stepDown = sp.StepDownAmt * sp.WalkInterp; + if (MathF.Abs(stepDown) < PhysicsGlobals.EPSILON) + return TransitionState.Collided; + + float radsumEps = radsum + PhysicsGlobals.EPSILON; + // Curved-top height at this XY offset (the sphere equation solved for z). + float underRoot = radsumEps * radsumEps - (disp0.X * disp0.X + disp0.Y * disp0.Y); + if (underRoot < 0f) + return TransitionState.Collided; // defensive: XY already outside radsum + float val = MathF.Sqrt(underRoot); + float scaledStep = (val - disp0.Z) / stepDown; + float timecheck = (1f - scaledStep) * sp.WalkInterp; + if (timecheck >= sp.WalkInterp || timecheck < -0.1f) + return TransitionState.Collided; + + float interp = stepDown * scaledStep; + Vector3 dispN = new Vector3(disp0.X, disp0.Y, disp0.Z + interp) / radsumEps; + if (dispN.Z <= sp.WalkableAllowance) + return TransitionState.OK; + + // Contact point on the TARGET sphere surface (retail 0x00536e9a: + // this.center + this.radius·disp). + Vector3 restPt = obj.Position + dispN * obj.Radius; + var restPlane = new Plane(dispN, -Vector3.Dot(dispN, restPt)); + CollisionInfo.SetContactPlane(restPlane, sp.CheckCellId, isWater: true); + sp.WalkInterp = timecheck; + sp.AddOffsetToCheckPos(new Vector3(0f, 0f, interp)); + return TransitionState.Adjusted; + } + + /// + /// Sphere-vs-sphere swept time-of-collision (retail + /// CSphere::FindTimeOfCollision; ACE Sphere.cs:232). Returns a 0-1 + /// fraction along , or -1 for no forward hit. Used + /// only by the (M1.5-dead) PerfectClip branch of + /// . + /// + private static double FindSphereTimeOfCollision(Vector3 movement, Vector3 spherePos, float radSum) + { + float distSq = movement.LengthSquared(); + if (distSq < PhysicsGlobals.EPSILON) return -1; + float nonCollide = spherePos.LengthSquared() - radSum * radSum; + if (nonCollide < PhysicsGlobals.EPSILON) return -1; + float similar = -Vector3.Dot(spherePos, movement); + double nonCollideB = (double)similar * similar - (double)nonCollide * distSq; + if (nonCollideB < 0) return -1; + double cDist = Math.Sqrt(nonCollideB); + if (similar - cDist < 0) + return -1 * (cDist + similar) / distSq; + return -1 * (similar - cDist) / distSq; + } + + /// + /// Retail CCylSphere::intersects_sphere dispatcher — verbatim port + /// of 0x0053b440 (acclient_2013_pseudo_c.txt:324558). Full family: + /// collides_with_sphere 0x0053a880, normal_of_collision + /// 0x0053ab50, collide_with_point 0x0053acb0, slide_sphere + /// 0x0053b2a0, step_sphere_up 0x0053b310, land_on_cylinder + /// 0x0053b3d0, step_sphere_down 0x0053a9b0. Pseudocode + settled + /// BN ambiguities + ACE cross-reference notes: + /// docs/research/2026-07-05-ccylsphere-collision-family-pseudocode.md. + /// + /// + /// Replaces the pre-2026-07-05 hand-rolled approximation (A6.P6 step-up + /// gate + radial wall-slide) which had NO cylinder-TOP support: a + /// grounded mover stepping up onto a WIDE cylinder (the Holtburg + /// town-network portal platform, Setup 0x020019E3, r=2.597 m h=0.256 m) + /// could never validate a landing — the step-up's internal step-down + /// probe needs branch 2 (step_sphere_down → contact plane ON the flat + /// top) — so DoStepUp failed into StepUpSlide and the player orbited the + /// rim forever. Airborne landings on tops (land_on_cylinder + the + /// collide-flag exact-TOI branch) were likewise missing. + /// + /// + /// + /// The already carries the wrapper overload's + /// (0x0053b8f0) work: Position = globalized low_pt (entity frame applied + /// at registration), Radius/CylHeight pre-scaled; the cylinder axis stays + /// world-Z. Ethereal targets: branch 1 returns Collided on overlap and + /// the caller's Layer-2 override (pc:276961-276989) clears it for + /// non-static targets — the retail passability mechanism (#150); the + /// step-down pass never reaches here for ethereal targets (pc:276799 + /// skip). + /// + /// + private TransitionState CylinderCollision(ShadowEntry obj, SpherePath sp, PhysicsEngine engine) + { + // Degenerate dat heights: registration sites apply the same fallback; + // kept for entries registered before it (pre-dates this port). + float cylHeight = obj.CylHeight > 0f ? obj.CylHeight : obj.Radius * 4f; + + var s0 = sp.GlobalSphere[0]; + Vector3 disp0 = s0.Origin - obj.Position; + // radsum: ε shaved ONCE in the dispatcher preamble (0x0053b48e) — + // this is what lets a sphere REST exactly on the top without + // re-colliding every frame. + float radsum = obj.Radius - PhysicsGlobals.EPSILON + s0.Radius; + + bool hasHead = sp.NumSphere > 1; + Vector3 disp1 = default; + float headRadius = 0f; + if (hasHead) + { + disp1 = sp.GlobalSphere[1].Origin - obj.Position; + headRadius = sp.GlobalSphere[1].Radius; + } + + // ── Branch 1 (0x0053b4a0): placement / ethereal — detection only. ── + if (sp.InsertType == InsertType.Placement || sp.ObstructionEthereal) + { + if (CylCollidesWithSphere(disp0, radsum, cylHeight, s0.Radius)) + return TransitionState.Collided; + if (hasHead && CylCollidesWithSphere(disp1, radsum, cylHeight, headRadius)) + return TransitionState.Collided; + return TransitionState.OK; + } + + // ── Branch 2 (0x0053b4c0): step-down probe — land on the top. ── + if (sp.StepDown) + return CylStepSphereDown(obj, sp, cylHeight, disp0, radsum); + + // ── Branch 3 (0x0053b4d7): walkable probe — occupancy blocks. ── + if (sp.CheckWalkable) + { + if (CylCollidesWithSphere(disp0, radsum, cylHeight, s0.Radius)) + return TransitionState.Collided; + if (hasHead && CylCollidesWithSphere(disp1, radsum, cylHeight, headRadius)) + return TransitionState.Collided; + return TransitionState.OK; + } + + var oi = ObjectInfo; + + if (!sp.Collide) + { + // ── Branch 4 (0x0053b701): normal transition sweep. ── + if ((oi.State & (ObjectInfoState.Contact | ObjectInfoState.OnWalkable)) != 0) { - // Try step-up over the cyl (DoStepUp probes upward by - // step_up_height, then step-down for walkable surface). - // On success: sphere is repositioned past/over the cyl, - // ContactPlane updated, returns OK. - if (DoStepUp(collisionNormal, engine)) - return TransitionState.OK; - - // Step-up failed — sphere couldn't find a walkable surface - // beyond the cyl (e.g., a wall behind it). Fall back to - // step_up_slide which uses the SlideSphereInternal crease - // projection — smoother than the radial push-out below - // because it follows the contact-plane / cyl-normal crease - // direction. - return sp.StepUpSlide(this); + // Grounded mover: foot hit → step over / onto; head hit → slide. + if (CylCollidesWithSphere(disp0, radsum, cylHeight, s0.Radius)) + return CylStepSphereUp(obj, sp, engine, cylHeight, disp0, radsum); + if (hasHead && CylCollidesWithSphere(disp1, radsum, cylHeight, headRadius)) + // Retail 0x0053b843 passes the HEAD disp (its x_2); ACE's + // port passes the foot disp here — retail wins (pseudocode + // doc §8.2). + return CylSlideSphere(obj, sp, cylHeight, disp1, radsum, 1); } - // else: cyl too tall to step over — fall through to radial slide - } - - // ─── Fallback: airborne / non-Contact / cyl-too-tall — wall-slide ─── - - // Wall-slide position (in world space): - // curr = sphereCurrPos (pre-step) - // movement = sphMovement - // projected = movement - (movement · normal) * normal - // slidPos = curr + projected - // Then push outward if still inside the cylinder radius. - Vector3 horizMovement = new Vector3(sphMovement.X, sphMovement.Y, 0f); - float movementIntoWall = Vector3.Dot(horizMovement, collisionNormal); - Vector3 projectedMovement = horizMovement - collisionNormal * movementIntoWall; - // Preserve vertical movement component (jumping/falling). - projectedMovement.Z = sphMovement.Z; - - Vector3 slidPos = sphereCurrPos + projectedMovement; - - // Ensure slid position is outside the cylinder radius horizontally. - float sdx = slidPos.X - obj.Position.X; - float sdy = slidPos.Y - obj.Position.Y; - float sDistSq = sdx * sdx + sdy * sdy; - float minDist = combinedR + 0.01f; - if (sDistSq < minDist * minDist) - { - float sDist = MathF.Sqrt(sDistSq); - if (sDist < PhysicsGlobals.EPSILON) + else if ((oi.State & ObjectInfoState.PathClipped) != 0) { - // Degenerate: push out along collisionNormal - slidPos.X = obj.Position.X + collisionNormal.X * minDist; - slidPos.Y = obj.Position.Y + collisionNormal.Y * minDist; + if (CylCollidesWithSphere(disp0, radsum, cylHeight, s0.Radius)) + return CylCollideWithPoint(obj, sp, cylHeight, s0, disp0, radsum, 0); } else { - float pushDist = (minDist - sDist); - slidPos.X += (sdx / sDist) * pushDist; - slidPos.Y += (sdy / sDist) * pushDist; + // Airborne: foot hit → land on the top; head hit → point hit. + if (CylCollidesWithSphere(disp0, radsum, cylHeight, s0.Radius)) + return CylLandOnCylinder(obj, sp, cylHeight, disp0, radsum); + if (hasHead && CylCollidesWithSphere(disp1, radsum, cylHeight, headRadius)) + return CylCollideWithPoint(obj, sp, cylHeight, sp.GlobalSphere[1], disp1, radsum, 1); } + return TransitionState.OK; } - // Apply the offset (difference between slid and current CheckPos) - Vector3 delta = slidPos - sphereCheckPos; - sp.AddOffsetToCheckPos(delta); + // ── Branch 5 (0x0053b525): collide-flag re-test — exact-TOI cap landing. ── + // Runs on the attempt after land_on_cylinder set sp.Collide: rewinds + // the sphere along the REVERSE movement to rest exactly on the top, + // sets the contact plane, and consumes walk_interp. + if (CylCollidesWithSphere(disp0, radsum, cylHeight, s0.Radius) + || (hasHead && CylCollidesWithSphere(disp1, radsum, cylHeight, headRadius))) + { + // movement = curr − check. Retail subtracts the cur→check + // landblock offset (get_curr_pos_check_pos_block_offset); our + // physics frame is continuous world-space → zero (same standing + // adaptation as SlideSphere's gDelta). + Vector3 movement = sp.GlobalCurrCenter[0].Origin - s0.Origin; + if (MathF.Abs(movement.Z) < PhysicsGlobals.EPSILON) + return TransitionState.Collided; - ci.SetCollisionNormal(collisionNormal); - ci.SetSlidingNormal(collisionNormal); - return TransitionState.Slid; + float timecheck = (cylHeight + s0.Radius - disp0.Z) / movement.Z; + Vector3 offset = movement * timecheck; + + Vector3 sum = offset + disp0; + if (radsum * radsum < sum.X * sum.X + sum.Y * sum.Y) + return TransitionState.OK; // rewound point is off the cap — not a top landing + + float t = (1f - timecheck) * sp.WalkInterp; + if (t >= sp.WalkInterp || t < -0.1f) + return TransitionState.Collided; + + Vector3 pt = s0.Origin + offset; + pt.Z -= s0.Radius; + // is_water=1 is verbatim retail (0x0053b6b9 → set_contact_plane + // arg3 = contact_plane_is_water, 0x00509db1). Do not "fix". + var contactPlane = new Plane(Vector3.UnitZ, -pt.Z); + CollisionInfo.SetContactPlane(contactPlane, sp.CheckCellId, isWater: true); + sp.WalkInterp = t; + sp.AddOffsetToCheckPos(offset); + return TransitionState.Adjusted; + } + + return TransitionState.OK; + } + + /// + /// Retail CCylSphere::collides_with_sphere (0x0053a880, + /// pc:323943): XY overlap against radsum, then Z-band overlap against the + /// cylinder's [0, height] extent. = sphere center + /// − cylinder base point. + /// + private static bool CylCollidesWithSphere(Vector3 disp, float radsum, float cylHeight, float sphereRadius) + { + if (disp.X * disp.X + disp.Y * disp.Y <= radsum * radsum) + { + float halfH = cylHeight * 0.5f; + if (sphereRadius - PhysicsGlobals.EPSILON + halfH >= MathF.Abs(halfH - disp.Z)) + return true; + } + return false; + } + + /// + /// Retail CCylSphere::normal_of_collision (0x0053ab50, pc:324102). + /// Discriminates on where the sphere was at the START of the step + /// (GlobalCurrCenter): XY-outside the combined radius → radial side + /// normal; XY-inside the footprint → cap normal (descending → top +Z, + /// ascending → underside −Z; polarity settled by ACE + geometry — BN's + /// x87 branch rendering is untrustworthy here). Returns "definite": + /// false when a radial contact could actually be a diagonal cap hit + /// (curr was outside the Z band AND there is vertical movement) — + /// consumed only by . + /// + private bool CylNormalOfCollision(ShadowEntry obj, SpherePath sp, float cylHeight, + Vector3 dispCheck, float radsum, float sphereRadius, int sphereNum, out Vector3 normal) + { + Vector3 dispCurr = sp.GlobalCurrCenter[sphereNum].Origin - obj.Position; + if (radsum * radsum < dispCurr.X * dispCurr.X + dispCurr.Y * dispCurr.Y) + { + normal = new Vector3(dispCurr.X, dispCurr.Y, 0f); + float halfH = cylHeight * 0.5f; + bool zBandOverlapAtCurr = + sphereRadius - PhysicsGlobals.EPSILON + halfH >= MathF.Abs(halfH - dispCurr.Z); + bool noZMovement = MathF.Abs(dispCurr.Z - dispCheck.Z) <= PhysicsGlobals.EPSILON; + return zBandOverlapAtCurr || noZMovement; + } + normal = new Vector3(0f, 0f, dispCheck.Z - dispCurr.Z <= 0f ? 1f : -1f); + return true; + } + + /// + /// Retail AC1Legacy::Vector3::normalize_check_small: returns true + /// (degenerate — caller yields Collided) when |v| < F_EPSILON, else + /// normalizes in place. + /// + private static bool NormalizeCheckSmall(ref Vector3 v) + { + float mag = v.Length(); + if (mag < PhysicsGlobals.EPSILON) + return true; + v /= mag; + return false; + } + + /// + /// Retail CCylSphere::step_sphere_up (0x0053b310, pc:324516). + /// Too-tall cylinders slide; otherwise the generic step-up + /// ( = CTransition::step_up) runs — its internal + /// step-down probe lands on the cylinder top via + /// (branch 2), which is what makes + /// stepping ONTO a wide cylinder possible. + /// + private TransitionState CylStepSphereUp(ShadowEntry obj, SpherePath sp, PhysicsEngine engine, + float cylHeight, Vector3 disp0, float radsum) + { + var s0 = sp.GlobalSphere[0]; + + // step_up_height must clear (sphere.radius + height − disp.z) — the + // lift needed so the sphere bottom rests on the top (0x0053b323). + if (ObjectInfo.StepUpHeight < s0.Radius + cylHeight - disp0.Z) + return CylSlideSphere(obj, sp, cylHeight, disp0, radsum, 0); + + // Retail computes the normal and ignores the definite flag here. + CylNormalOfCollision(obj, sp, cylHeight, disp0, radsum, s0.Radius, 0, out var n); + if (NormalizeCheckSmall(ref n)) + return TransitionState.Collided; + + // Retail rotates the normal by the target OBJECT's frame + // (localtoglobalvec via the wrapper's cached localspace_pos, + // 0x0053b38d) before CTransition::step_up. Yaw-only AC frames leave + // vertical normals unchanged; radial normals pick up the yaw. + var nWorld = Vector3.Transform(n, obj.Rotation); + + // engine==null only in bare unit-test transitions — no step-up + // machinery available; the retail-faithful fallback is the slide. + if (engine is not null && DoStepUp(nWorld, engine)) + return TransitionState.OK; + + return sp.StepUpSlide(this); + } + + /// + /// Retail CCylSphere::step_sphere_down (0x0053a9b0, pc:324032): + /// during a step-down probe, land the foot sphere ON the cylinder's flat + /// top — contact plane (0,0,1) through the top, walk_interp consumed, + /// CheckPos lifted so the sphere bottom rests exactly on it. THE piece + /// whose absence made every step-up onto a wide cylinder fail (the + /// portal-platform rim orbit). + /// + private TransitionState CylStepSphereDown(ShadowEntry obj, SpherePath sp, + float cylHeight, Vector3 disp0, float radsum) + { + var s0 = sp.GlobalSphere[0]; + + bool hit = CylCollidesWithSphere(disp0, radsum, cylHeight, s0.Radius); + if (!hit && sp.NumSphere > 1) + { + Vector3 disp1 = sp.GlobalSphere[1].Origin - obj.Position; + hit = CylCollidesWithSphere(disp1, radsum, cylHeight, sp.GlobalSphere[1].Radius); + } + if (!hit) + return TransitionState.OK; + + float stepScale = sp.StepDownAmt * sp.WalkInterp; + if (MathF.Abs(stepScale) < PhysicsGlobals.EPSILON) + return TransitionState.Collided; + + // Lift so the foot sphere's bottom rests on the top disc. The + // (1 − deltaZ/stepScale) divisor is stepScale — BN garbled it; + // settled via ACE CylSphere.StepSphereDown (pseudocode doc §4). + float deltaZ = cylHeight + s0.Radius - disp0.Z; + float interp = (1f - deltaZ / stepScale) * sp.WalkInterp; + if (interp >= sp.WalkInterp || interp < -0.1f) + return TransitionState.Collided; + + float topZ = s0.Origin.Z + deltaZ - s0.Radius; + // is_water=1 verbatim retail (0x0053aae2). Do not "fix". + var contactPlane = new Plane(Vector3.UnitZ, -topZ); + CollisionInfo.SetContactPlane(contactPlane, sp.CheckCellId, isWater: true); + sp.WalkInterp = interp; + sp.AddOffsetToCheckPos(new Vector3(0f, 0f, deltaZ)); + return TransitionState.Adjusted; + } + + /// + /// Retail CCylSphere::slide_sphere (0x0053b2a0, pc:324502): + /// normal_of_collision → CSphere::slide_sphere (our + /// ) with the sliding sphere's own curr center. + /// + private TransitionState CylSlideSphere(ShadowEntry obj, SpherePath sp, + float cylHeight, Vector3 disp, float radsum, int sphereNum) + { + CylNormalOfCollision(obj, sp, cylHeight, disp, radsum, + sp.GlobalSphere[sphereNum].Radius, sphereNum, out var n); + if (NormalizeCheckSmall(ref n)) + return TransitionState.Collided; + + return SlideSphere(n, sp.GlobalCurrCenter[sphereNum].Origin, sphereNum); + } + + /// + /// Retail CCylSphere::land_on_cylinder (0x0053b3d0, pc:324542): + /// airborne foot hit — arm the Collide re-test (backup + flag) and relax + /// the walkable allowance to LandingZ. The NEXT attempt's branch 5 then + /// rests the sphere on the top with the exact time-of-impact. + /// + private TransitionState CylLandOnCylinder(ShadowEntry obj, SpherePath sp, + float cylHeight, Vector3 disp0, float radsum) + { + CylNormalOfCollision(obj, sp, cylHeight, disp0, radsum, + sp.GlobalSphere[0].Radius, 0, out var n); + if (NormalizeCheckSmall(ref n)) + return TransitionState.Collided; + + sp.SetCollide(n); + sp.WalkableAllowance = PhysicsGlobals.LandingZ; // 0.0871557 (0x0053b41f) + return TransitionState.Adjusted; + } + + /// + /// Retail CCylSphere::collide_with_point (0x0053acb0, pc:324173): + /// PathClipped movers + airborne head-sphere hits. Non-PerfectClip movers + /// record the collision normal and hard-stop; PerfectClip movers get the + /// exact time-of-impact reposition. TOI sub-branches ported per ACE + /// CylSphere.CollideWithPoint (BN mush too heavy in 0x0053adb6+); no + /// PerfectClip mover exists in M1.5 (players never set it), so only the + /// Collided path is load-bearing today — revisit against Ghidra if + /// missiles ever arm PerfectClip (pseudocode doc §7). + /// + private TransitionState CylCollideWithPoint(ShadowEntry obj, SpherePath sp, + float cylHeight, Sphere checkSphere, Vector3 disp, float radsum, int sphereNum) + { + bool definite = CylNormalOfCollision(obj, sp, cylHeight, disp, radsum, + checkSphere.Radius, sphereNum, out var n); + if (NormalizeCheckSmall(ref n)) + return TransitionState.Collided; + + if (!ObjectInfo.State.HasFlag(ObjectInfoState.PerfectClip)) + { + CollisionInfo.SetCollisionNormal(n); + return TransitionState.Collided; + } + + // Retail reads global_curr_center[0] even for the head hit + // (0x0053ad26; ACE agrees) — verbatim. + Vector3 globCenter = sp.GlobalCurrCenter[0].Origin; + // Block offset = 0 (continuous world frame; see branch 5 note). + Vector3 movement = checkSphere.Origin - globCenter; + Vector3 oldDisp = globCenter - obj.Position; + float radsumEps = radsum + PhysicsGlobals.EPSILON; + + float xyMoveLenSq = movement.X * movement.X + movement.Y * movement.Y; + float dot2d = movement.X * oldDisp.X + movement.Y * oldDisp.Y; + float xyDiff = -dot2d; + float oldDispXYSq = oldDisp.X * oldDisp.X + oldDisp.Y * oldDisp.Y; + float diffSq = xyDiff * xyDiff - (oldDispXYSq - radsumEps * radsumEps) * xyMoveLenSq; + + float time; + Vector3 scaledMovement; + + if (!definite) + { + if (MathF.Abs(movement.Z) < PhysicsGlobals.EPSILON) + return TransitionState.Collided; + if (movement.Z > 0f) + { + n = new Vector3(0f, 0f, -1f); + time = (movement.Z + checkSphere.Radius) / movement.Z * -1f; + } + else + { + n = new Vector3(0f, 0f, 1f); + time = (checkSphere.Radius + cylHeight - movement.Z) / movement.Z; + } + scaledMovement = movement * time; + + Vector3 landed = scaledMovement + oldDisp; + if (landed.X * landed.X + landed.Y * landed.Y >= radsumEps * radsumEps) + { + if (MathF.Abs(xyMoveLenSq) < PhysicsGlobals.EPSILON) + return TransitionState.Collided; + if (diffSq >= 0f && xyMoveLenSq > PhysicsGlobals.EPSILON) + { + float diff = MathF.Sqrt(diffSq); + time = xyDiff - diff < 0f + ? (diff - dot2d) / xyMoveLenSq + : (xyDiff - diff) / xyMoveLenSq; + scaledMovement = movement * time; + } + n = (scaledMovement + globCenter - obj.Position) / radsumEps; + n.Z = 0f; + } + + if (time < 0f || time > 1f) + return TransitionState.Collided; + + Vector3 offsetOut = globCenter - scaledMovement - checkSphere.Origin; + sp.AddOffsetToCheckPos(offsetOut); + CollisionInfo.SetCollisionNormal(n); + return TransitionState.Adjusted; + } + + if (n.Z != 0f) + { + if (MathF.Abs(movement.Z) < PhysicsGlobals.EPSILON) + return TransitionState.Collided; + + time = movement.Z > 0f + ? -((oldDisp.Z + checkSphere.Radius) / movement.Z) + : (checkSphere.Radius + cylHeight - oldDisp.Z) / movement.Z; + scaledMovement = movement * time; + + if (time < 0f || time > 1f) + return TransitionState.Collided; + + Vector3 offsetOut = globCenter + scaledMovement - checkSphere.Origin; + sp.AddOffsetToCheckPos(offsetOut); + CollisionInfo.SetCollisionNormal(n); + return TransitionState.Adjusted; + } + + if (diffSq < 0f || xyMoveLenSq < PhysicsGlobals.EPSILON) + return TransitionState.Collided; + + { + float diff = MathF.Sqrt(diffSq); + time = xyDiff - diff < 0f + ? (diff - dot2d) / xyMoveLenSq + : (xyDiff - diff) / xyMoveLenSq; + scaledMovement = movement * time; + + if (time < 0f || time > 1f) + return TransitionState.Collided; + + n = (scaledMovement + globCenter - obj.Position) / radsumEps; + n.Z = 0f; + + Vector3 offsetOut = globCenter + scaledMovement - checkSphere.Origin; + sp.AddOffsetToCheckPos(offsetOut); + CollisionInfo.SetCollisionNormal(n); + return TransitionState.Adjusted; + } } // ----------------------------------------------------------------------- @@ -3356,7 +3945,11 @@ public sealed class Transition internal TransitionState SlideSphereInternal(Vector3 collisionNormal, Vector3 currPos) => SlideSphere(collisionNormal, currPos); - private TransitionState SlideSphere(Vector3 collisionNormal, Vector3 currPos) + /// Which path sphere is sliding (retail + /// CSphere::slide_sphere's this is the sphere instance — the head + /// sphere slides by its OWN displacement, 0x0053b843 passes + /// global_sphere[1]). Default 0 preserves every existing call site. + private TransitionState SlideSphere(Vector3 collisionNormal, Vector3 currPos, int sphereNum = 0) { var sp = SpherePath; var ci = CollisionInfo; @@ -3364,7 +3957,7 @@ public sealed class Transition // Degenerate case: zero collision normal — nudge halfway. if (collisionNormal.LengthSquared() < PhysicsGlobals.EpsilonSq) { - Vector3 halfOffset = (currPos - sp.GlobalSphere[0].Origin) * 0.5f; + Vector3 halfOffset = (currPos - sp.GlobalSphere[sphereNum].Origin) * 0.5f; sp.AddOffsetToCheckPos(halfOffset); return TransitionState.Adjusted; } @@ -3374,7 +3967,7 @@ public sealed class Transition // gDelta: displacement from currPos to the current check sphere center. // In the retail code this includes a block offset for cross-landblock // transitions; for outdoor single-landblock movement this is zero. - Vector3 gDelta = sp.GlobalSphere[0].Origin - currPos; + Vector3 gDelta = sp.GlobalSphere[sphereNum].Origin - currPos; // Get the contact plane (prefer current, fall back to last known). System.Numerics.Plane contactPlane; @@ -3438,15 +4031,25 @@ public sealed class Transition return TransitionState.Slid; } - // Opposing normals: give up, reverse direction. - // Retail returns OK here to allow retry with the reversed normal. + // Opposing normals (collision normal anti-parallel to the contact + // plane, e.g. a ceiling-facing normal while grounded): record the + // REVERSED displacement as the collision normal and return COLLIDED. + // Retail CSphere::slide_sphere 0x00537440 @0x005375d7-0x0053762c: + // `*normal = -gDelta; normalize_check_small; set_collision_normal; + // return 2 (COLLIDED_TS)`. #137 (2026-07-06): this previously + // returned OK ("to allow retry with the reversed normal" — a decomp + // misread), which let the step complete as-is carrying a SYNTHETIC + // reversed-movement collision normal — the live corridor hit's + // `n=(-1.00,0.03,-0.03)` (= the negated run direction) matched no + // dat polygon; validate's epilogue then turned it into a persisted + // sliding normal and wedged all forward motion. Vector3 reversed = -gDelta; if (reversed.LengthSquared() > PhysicsGlobals.EpsilonSq) { reversed = Vector3.Normalize(reversed); ci.SetCollisionNormal(reversed); } - return TransitionState.OK; + return TransitionState.Collided; } // ----------------------------------------------------------------------- @@ -3990,6 +4593,11 @@ public sealed class Transition var ci = CollisionInfo; var oi = ObjectInfo; + // retail validate_transition arg3 / ACE _redo: was this a CLEAN advance (an OK step + // that actually moved)? Captured BEFORE the collision branch below reverts CurPos and + // rewrites transitionState to OK. Feeds the frames_stationary_fall ladder at the tail. + bool cleanAdvance = transitionState == TransitionState.OK && sp.CheckPos != sp.CurPos; + if (transitionState == TransitionState.OK && sp.CheckPos != sp.CurPos) { // Movement succeeded: accept the new position. @@ -4130,6 +4738,64 @@ public sealed class Transition oi.State &= ~(ObjectInfoState.Contact | ObjectInfoState.OnWalkable); } + // ── frames_stationary_fall ladder (retail validate_transition pc:272625-656; + // ACE Transition.cs:1029-1061). Retires the TS-3 stub. Detects a gravity mover + // that CANNOT advance (blocked) for successive frames and (a) escalates the counter + // and (b) at fsf≥3 manufactures an UPWARD contact plane so the mover "stands on" the + // obstacle (glide onto a crowd top). handle_all_collisions later zeros the velocity + // when fsf>1 (the airborne-stuck bleed). + // + // STRUCTURAL ADAPTATION (register): ACE interleaves this between the LKCP-restore + // and the contact-marking, using its `_redo`. acdream fused those into the contact + // block above (the L.2.3c/L.2.4/A6.P3 contact-retention divergences), so the ladder + // runs HERE, after the marking, and derives the same signal as `cleanAdvance || + // oi.OnWalkable` (a grounded wall-slide is not a stuck-fall) — semantically equal to + // ACE's _redo. The manufacture case re-marks grounding itself (ACE's post-fsf D block). + // Gate: not the camera viewer AND the mover has gravity (pc:272625). + if (!oi.IsViewer && oi.MoverHasGravity) + { + bool redo = cleanAdvance || oi.OnWalkable; + if (!redo) + { + int fsf = ci.FramesStationaryFall; + if (fsf > 0) + { + if (fsf > 1) + { + ci.FramesStationaryFall = 3; + + // UP plane through the sphere bottom: d = radius − center.Z + // (up=(0,0,1) so dot(center,up)=center.Z). pc:272639-643 / ACE 1040-1044. + var up = Vector3.UnitZ; + float d = sp.GlobalSphere[0].Radius - sp.GlobalSphere[0].Origin.Z; + ci.SetContactPlane(new Plane(up, d), sp.CheckCellId, isWater: false); + + // Only record the environment hit if not ALREADY in contact + // (pc:272647 / ACE 1046) — read Contact before we set it below. + if (!oi.Contact) + { + ci.SetCollisionNormal(up); + ci.CollidedWithEnvironment = true; + } + + // acdream runs the ladder after the fused contact-marking, so apply the + // manufactured grounding + LKCP save that ACE's post-fsf D block would. + oi.State |= ObjectInfoState.Contact | ObjectInfoState.OnWalkable; + ci.LastKnownContactPlaneValid = true; + ci.LastKnownContactPlane = ci.ContactPlane; + ci.LastKnownContactPlaneCellId = ci.ContactPlaneCellId; + ci.LastKnownContactPlaneIsWater = ci.ContactPlaneIsWater; + } + else + ci.FramesStationaryFall = 2; + } + else + ci.FramesStationaryFall = 1; + } + else + ci.FramesStationaryFall = 0; + } + return transitionState; } } diff --git a/src/AcDream.Core/Rendering/RenderingDiagnostics.cs b/src/AcDream.Core/Rendering/RenderingDiagnostics.cs index 872285e4..889f5517 100644 --- a/src/AcDream.Core/Rendering/RenderingDiagnostics.cs +++ b/src/AcDream.Core/Rendering/RenderingDiagnostics.cs @@ -271,6 +271,129 @@ public static class RenderingDiagnostics public static bool ProbeLightEnabled { get; set; } = Environment.GetEnvironmentVariable("ACDREAM_PROBE_LIGHT") == "1"; + /// + /// A7.L1 (2026-07-06) light-pool SET-COMPOSITION probe — the apparatus the + /// [light] counts could not provide (the #176/#177 discriminator: the bug + /// lived in set MEMBERSHIP, not counts). When true, + /// LightManager.BuildPointLightSnapshot emits ONE rate-limited + /// [indoor-light] line describing the point-light pool + /// (see ): + /// + /// [indoor-light] pool=<M> cellLess=<K> registered=<R> capped=<R-M> + /// byCell=[0x<id>:<count>,...] + /// + /// #176 correction (2026-07-06): the pool became retail's RESIDENT-cell + /// collection capped nearest-the-PLAYER — the earlier gaze-coupled scoping + /// (rebuilding the pool from a freshly re-flooded CAMERA-seeded set, + /// c500912b) was the #176 flicker mechanism and was deleted. + /// A7.L1 (2026-07-09): visible-cell scoping is BACK, but sourced differently — + /// LightManager.BuildPointLightSnapshot now takes an optional + /// visibleCells filter that GameWindow feeds from LAST FRAME's + /// already-rendered RetailPViewFrameResult.DrawableCells (one frame of + /// latency, no independent re-flood, no callback threaded into DrawInside) — + /// fixes the Town Network starvation case (463 fixtures, a wall-adjacent + /// corridor's fixtures out-ranking the player's own room in raw Euclidean + /// distance) without reproducing the #176 mechanism. byCell shows which + /// cells' lights are pooled; cellLess==pool in a fixture-rich room still + /// means cell tagging FAILED (ParentCellId not flowing). + /// Output-only, inert when off. Initial state from ACDREAM_PROBE_INDOOR_LIGHT=1. + /// + public static bool ProbeIndoorLightEnabled { get; set; } = + Environment.GetEnvironmentVariable("ACDREAM_PROBE_INDOOR_LIGHT") == "1"; + + /// + /// #176 seam-floor flicker decisive probe (2026-07-06). RenderDoc pixel-history + /// is infeasible on this pipeline (RenderDoc does not support + /// GL_ARB_bindless_texture and hides it from the app → our mandatory-modern + /// startup gate throws), so this is the in-engine equivalent at draw + /// granularity: every draw route that can put geometry at the corridor seam + /// floor reports itself, plus the per-cell light sets ACTUALLY applied. + /// When set, four line families emit (all change-deduped, Console): + /// + /// [seam-cell] — EnvCellRenderer.Render + /// (opaque pass): per target cell — in-filter flag, per-gfx instance count + + /// transform translation (shows the +0.02 shell lift), per-batch + /// cull/translucency, and the cell's 8-light set RESOLVED to identities + /// (owner cell + intensity — raw snapshot indices shuffle when the pool + /// rebuilds, so identities are the stable signature). Two instances of one + /// (cell,gfx) = the runtime double-draw; light identities flipping with the + /// flood = the snapshot-scope mechanism. + /// [seam-snap] — the point-light snapshot's HOT + /// subset (intensity ≥ 50: the portal purples; fixtures are ~1–2, the viewer + /// fill 2.25) with owner cells, emitted with the block. + /// [seam-ent] — WbDrawDispatcher: any entity + /// parented to a target cell — position, culled/slot, resolved light set. A + /// floor-coincident entity (plate/static) would be the z-fight's second draw; + /// the player entity doubles as the probe's positive control. + /// [seam-mask] — GameWindow.DrawRetailPViewPortalDepthWrite: + /// every portal depth fan drawn in a target cell. A sealed dungeon must show + /// ZERO (seals fire only for OtherCellId==0xFFFF) — any line is a finding. + /// + /// Value 1 = the default Facility Hub target set (corridor 0x8A020164 + + /// seam neighbors 0165/016E/017A + under-hall 011E + portal-light cells + /// 0118/0119); a comma-separated hex cell-id list overrides it. Throwaway + /// apparatus — strip when #176 closes. Initial state from + /// ACDREAM_PROBE_SEAMDRAW. + /// + public static bool ProbeSeamDrawEnabled { get; set; } = + !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("ACDREAM_PROBE_SEAMDRAW")); + + /// Target cell ids for the #176 seam-draw probe (see + /// ). Full 32-bit cell ids. + public static IReadOnlySet SeamDrawTargetCells { get; } = + ParseSeamDrawTargets(Environment.GetEnvironmentVariable("ACDREAM_PROBE_SEAMDRAW")); + + /// + /// #176 stripe-hunt shader isolation mode (ACDREAM_LIGHT_DEBUG) — + /// throwaway diagnostic, uploaded as uLightDebug by EnvCellRenderer + + /// WbDrawDispatcher each pass. 0 = off; 1 = ambient-only vertex lighting + /// (all point/sun contributions killed); 2 = DYNAMIC point lights killed + /// (the intensity-100 portal purples + the viewer fill off; statics stay); + /// 3 = raw vLit visualization in the fragment shader (texture ignored). + /// Discriminates lighting-driven stripes (gone at 1/2, visible in the field + /// at 3) from texture/per-pixel machinery (survive 1). Settable for a + /// future DebugPanel mirror. + /// + public static int LightDebugMode { get; set; } = + int.TryParse(Environment.GetEnvironmentVariable("ACDREAM_LIGHT_DEBUG"), out var ldm) ? ldm : 0; + + /// + /// #176 stripe-hunt isolation (ACDREAM_CLIP_DEBUG=1) — throwaway + /// diagnostic. When true, the EnvCell SHELL pass maps every instance to clip + /// slot 0 (the reserved no-clip region) instead of its cell's portal-slice + /// region — i.e. shells draw WHOLE, retail's shape (retail never clips cell + /// geometry; aperture exactness comes from the seal/punch depth writes + + /// far→near order, PView::DrawCells 0x005a4840). Discriminator for the + /// camera-against-wall stripe/hatch pattern: a knife-edge slice region (eye + /// on a portal plane / inside a wall) yields a clip plane near-parallel to + /// large surfaces → interpolated gl_ClipDistance ≈ 0 across them → per-pixel + /// sign dither = the hatch. Stripes gone with this on = the shell trim is + /// the mechanism. Entity/dispatcher clip routing is NOT affected. + /// + public static bool ClipDebugNoShellTrim { get; set; } = + Environment.GetEnvironmentVariable("ACDREAM_CLIP_DEBUG") == "1"; + + /// Parse ACDREAM_PROBE_SEAMDRAW: "1"/"true"/empty → the default #176 + /// Facility Hub set; otherwise a comma-separated hex cell-id list (same forgiving + /// grammar as ). Internal for unit tests. + internal static IReadOnlySet ParseSeamDrawTargets(string? raw) + { + // Default: the corridor + the coplanar-sweep seed neighbors + the under-hall + // + the two portal-weenie cells whose intensity-100 purple lights are the + // wedge's source (handoff 2026-07-06-176-seam-floor-zfight-handoff.md). + var defaults = new HashSet + { + 0x8A020164u, 0x8A020165u, 0x8A02016Eu, 0x8A02017Au, + 0x8A02011Eu, 0x8A020118u, 0x8A020119u, + }; + if (string.IsNullOrWhiteSpace(raw)) return defaults; + var trimmed = raw.Trim(); + if (trimmed == "1" || trimmed.Equals("true", StringComparison.OrdinalIgnoreCase)) + return defaults; + var parsed = ParseDumpEntityIds(raw); + return parsed.Count > 0 ? parsed : defaults; + } + // Cell-change gate for EmitVis. The probe fires once per distinct root cell // so launch.log stays readable under motion (the per-frame call is a no-op // when the root is unchanged). Sentinel 0 = "no root yet" — the first real @@ -444,13 +567,73 @@ public static class RenderingDiagnostics float dist = ls.DistSq >= 0f ? MathF.Sqrt(ls.DistSq) : 0f; Console.WriteLine(string.Format(ci, - "[light-detail] kind={0} range={1:0.###} intensity={2:0.###} cone={3:0.####} color=({4:0.###},{5:0.###},{6:0.###}) distToViewer={7:0.###}", + "[light-detail] kind={0} range={1:0.###} intensity={2:0.###} cone={3:0.####} color=({4:0.###},{5:0.###},{6:0.###}) distToViewer={7:0.###} owner=0x{8:X8} cell=0x{9:X8} dyn={10}", ls.Kind, ls.Range, ls.Intensity, ls.ConeAngle, - ls.ColorLinear.X, ls.ColorLinear.Y, ls.ColorLinear.Z, dist)); + ls.ColorLinear.X, ls.ColorLinear.Y, ls.ColorLinear.Z, dist, + ls.OwnerId, ls.CellId, ls.IsDynamic ? 1 : 0)); shown++; } } + // Wall-clock rate-limit gate for EmitIndoorLight (shares the 1 s interval). + private static long _lastIndoorLightEmitTicks; + + /// + /// A7.L1 — emit ONE rate-limited [indoor-light] line describing the + /// point-light pool: the SET COMPOSITION the [light] counts can't show. + /// Cheap no-op when is false; otherwise + /// fires at most once per second. Called from + /// LightManager.BuildPointLightSnapshot — + /// already reflects any last-frame visible-cell scoping (A7.L1, 2026-07-09). + /// + /// Every registered light (LightManager._all). + /// The point-light pool just built. + public static void EmitIndoorLight( + IReadOnlyList allRegistered, + IReadOnlyList scopedSnapshot) + { + if (!ProbeIndoorLightEnabled) return; + + long now = DateTime.UtcNow.Ticks; + if (_lastIndoorLightEmitTicks != 0 && (now - _lastIndoorLightEmitTicks) < LightEmitIntervalTicks) + return; + _lastIndoorLightEmitTicks = now; + + int registeredLitPoints = 0; + foreach (var l in allRegistered) + if (l.IsLit && l.Kind != AcDream.Core.Lighting.LightKind.Directional) registeredLitPoints++; + + int pool = scopedSnapshot.Count; + int cellLess = 0; + var hist = new Dictionary(); + foreach (var l in scopedSnapshot) + { + if (l.CellId == 0) cellLess++; + hist.TryGetValue(l.CellId, out var c); + hist[l.CellId] = c + 1; + } + + var sb = new StringBuilder(220); + sb.Append("[indoor-light] pool=").Append(pool); + sb.Append(" cellLess=").Append(cellLess); + sb.Append(" registered=").Append(registeredLitPoints); + // Lights dropped by the MaxGlobalLights nearest-player cap (0 in Hub-scale + // rooms for dynamics — statics beyond the 128th-nearest are out of range). + sb.Append(" capped=").Append(registeredLitPoints - pool); + sb.Append(" byCell=["); + const int MaxCells = 12; + int shown = 0; + foreach (var kv in hist) + { + if (shown >= MaxCells) { sb.Append(",..."); break; } + if (shown > 0) sb.Append(','); + sb.Append("0x").Append(kv.Key.ToString("X8")).Append(':').Append(kv.Value); + shown++; + } + sb.Append(']'); + Console.WriteLine(sb.ToString()); + } + private static bool _probeEnvCellEnabled = Environment.GetEnvironmentVariable("ACDREAM_PROBE_ENVCELL") == "1"; @@ -567,4 +750,21 @@ public static class RenderingDiagnostics /// public static bool ShouldRenderIndoor(uint playerCellId, bool renderRootResolved) => renderRootResolved && IsEnvCellId(playerCellId); + + /// + /// MP0 (2026-07-05) — master toggle for the permanent frame profiler + /// (AcDream.App.Diagnostics.FrameProfiler): CPU frame time + /// (swap-to-swap), whole-frame GPU time, per-stage CPU attribution, + /// per-frame allocation counters, reported as one [frame-prof] + /// line every ~5 s. Permanent apparatus (every MP-track gate reads it) — + /// do NOT strip with session probes. The whole-frame GPU query is + /// self-disabled while ACDREAM_WB_DIAG=1 (GL forbids nested + /// TimeElapsed queries; WbDrawDispatcher owns per-pass queries under + /// that flag — the 2026-06-23 "separate flags" measurement lesson). + /// Initial state from ACDREAM_FRAME_PROF=1; runtime-toggleable + /// via the DebugPanel mirror (DebugVM.FrameProf). + /// Spec: docs/superpowers/specs/2026-07-05-modern-pipeline-design.md §5. + /// + public static bool FrameProfEnabled { get; set; } = + Environment.GetEnvironmentVariable("ACDREAM_FRAME_PROF") == "1"; } diff --git a/src/AcDream.Core/Rendering/TranslucencyFadeManager.cs b/src/AcDream.Core/Rendering/TranslucencyFadeManager.cs new file mode 100644 index 00000000..58be5c04 --- /dev/null +++ b/src/AcDream.Core/Rendering/TranslucencyFadeManager.cs @@ -0,0 +1,167 @@ +using System; +using System.Collections.Generic; + +namespace AcDream.Core.Rendering; + +/// +/// #188 — per-(entity, Setup-part) translucency ramp state. Ports retail's +/// FPHook TRANSLUCENCY / PART_TRANSLUCENCY interpolation +/// (CPhysicsObj::SetPartTranslucency 0x00511730, +/// FPHook::Execute 0x0051baa0, CPhysicsObj::process_fp_hook +/// 0x005135c0): a linear ramp from Start to End over +/// Time seconds, ticked every frame rather than retail's per-object +/// physics tick (behaviorally identical — both re-evaluate the same +/// elapsed/duration ratio every simulated step). +/// +/// +/// Retail's translucency scale is the OPPOSITE of "opacity": 0 = fully +/// solid/opaque, 1 = fully invisible (CMaterial::SetTranslucencySimple +/// 0x005396f0: alpha = 1 - translucency). Values here are stored on +/// that same [0,1] translucency scale — callers convert to an alpha/opacity +/// multiplier at the point of use. +/// +/// +/// +/// Retail's instant-apply shortcut: if the hook's Time is at or below +/// ~0.2 ms, the target value is applied immediately with no ramp +/// (SetPartTranslucency's epsilon check). +/// is that exact retail constant. +/// +/// +public sealed class TranslucencyFadeManager +{ + /// + /// Retail's exact epsilon (CPhysicsObj::SetPartTranslucency + /// 0x00511730): a hook Time at or below this is applied + /// instantly, no ramp. + /// + public const float TranslucencyInstantEpsilon = 0.000199999995f; + + private sealed class Fade + { + public float Elapsed; + public float Duration; + public float Start; + public float End; + } + + // entityId -> partIndex -> in-flight ramp. + private readonly Dictionary> _activeFades = new(); + + // entityId -> partIndex -> current committed translucency value + // ([0,1], retail scale). Persists after a fade completes so later + // frames keep reading the settled value. + private readonly Dictionary> _committed = new(); + + /// + /// Start (or replace) a translucency ramp for one Setup part of one + /// entity. Mirrors CPhysicsObj::SetPartTranslucency: a + /// near-zero applies + /// immediately; otherwise the value ramps from + /// to across + /// seconds, advanced by . + /// + public void StartPartFade(uint entityId, uint partIndex, float start, float end, float time) + { + if (time <= TranslucencyInstantEpsilon) + { + if (_activeFades.TryGetValue(entityId, out var activeForEntity)) + activeForEntity.Remove(partIndex); + Commit(entityId, partIndex, end); + return; + } + + if (!_activeFades.TryGetValue(entityId, out var fades)) + { + fades = new Dictionary(); + _activeFades[entityId] = fades; + } + fades[partIndex] = new Fade { Elapsed = 0f, Duration = time, Start = start, End = end }; + + // FPHook's first Execute call (at elapsed=0) already reports + // value=start — commit it now so a reader on the same frame the + // hook fired sees the ramp's starting value, not the stale prior one. + Commit(entityId, partIndex, start); + } + + /// + /// Advance every in-flight fade by seconds + /// (plain linear interpolation, no easing — matches + /// FPHook::Execute). A fade that reaches its duration commits + /// the bitwise-exact End value and stops advancing (retail + /// deletes the FPHook at that point); the committed value stays + /// readable via . + /// + public void AdvanceAll(float dt) + { + if (_activeFades.Count == 0) return; + + List? emptyEntities = null; + foreach (var (entityId, fades) in _activeFades) + { + List? finished = null; + foreach (var (partIndex, fade) in fades) + { + fade.Elapsed += dt; + float t = fade.Duration <= TranslucencyInstantEpsilon + ? 1f + : Math.Clamp(fade.Elapsed / fade.Duration, 0f, 1f); + + float value = t >= 1f ? fade.End : fade.Start + (fade.End - fade.Start) * t; + Commit(entityId, partIndex, value); + + if (t >= 1f) + { + finished ??= new List(); + finished.Add(partIndex); + } + } + + if (finished is not null) + { + foreach (var partIndex in finished) + fades.Remove(partIndex); + if (fades.Count == 0) + { + emptyEntities ??= new List(); + emptyEntities.Add(entityId); + } + } + } + + if (emptyEntities is not null) + foreach (var entityId in emptyEntities) + _activeFades.Remove(entityId); + } + + /// + /// Read the current committed translucency value ([0,1], retail + /// scale — 0 opaque, 1 invisible) for one entity part. Returns false + /// if this part has never had a fade start (caller should fall back + /// to the dat-authored default — a no-op). + /// + public bool TryGetCurrentValue(uint entityId, uint partIndex, out float value) + { + if (_committed.TryGetValue(entityId, out var parts) && parts.TryGetValue(partIndex, out value)) + return true; + value = 0f; + return false; + } + + /// Drop all fade state for an entity (despawn / unload). + public void ClearEntity(uint entityId) + { + _activeFades.Remove(entityId); + _committed.Remove(entityId); + } + + private void Commit(uint entityId, uint partIndex, float value) + { + if (!_committed.TryGetValue(entityId, out var parts)) + { + parts = new Dictionary(); + _committed[entityId] = parts; + } + parts[partIndex] = value; + } +} diff --git a/src/AcDream.Core/Rendering/TranslucencyHookSink.cs b/src/AcDream.Core/Rendering/TranslucencyHookSink.cs new file mode 100644 index 00000000..ee39c8b7 --- /dev/null +++ b/src/AcDream.Core/Rendering/TranslucencyHookSink.cs @@ -0,0 +1,38 @@ +using System; +using System.Numerics; +using AcDream.Core.Physics; +using DatReaderWriter.Types; + +namespace AcDream.Core.Rendering; + +/// +/// #188 — routes animation hooks to a +/// . Retail's +/// TransparentPartHook::Execute (0x00526cc0) is a one-liner calling +/// CPhysicsObj::SetPartTranslucency(obj, part, start, end, time) — +/// this sink is that same one-line forward. +/// +/// +/// Whole-object and +/// are deliberately NOT handled here. Retail's EtherealHook::Execute +/// (0x00526bc0) touches only CPhysicsObj::set_ethereal — collision +/// state, zero rendering coupling — and acdream's collision-passthrough +/// already applies server-authoritative via the SetState wire +/// message, independent of this hook firing client-side. +/// +/// +public sealed class TranslucencyHookSink : IAnimationHookSink +{ + private readonly TranslucencyFadeManager _fades; + + public TranslucencyHookSink(TranslucencyFadeManager fades) + { + _fades = fades ?? throw new ArgumentNullException(nameof(fades)); + } + + public void OnHook(uint entityId, Vector3 entityWorldPosition, AnimationHook hook) + { + if (hook is not TransparentPartHook tph) return; + _fades.StartPartFade(entityId, tph.PartIndex, tph.Start, tph.End, tph.Time); + } +} diff --git a/src/AcDream.Core/Vfx/ParticleSystem.cs b/src/AcDream.Core/Vfx/ParticleSystem.cs index 53c5d700..40090d92 100644 --- a/src/AcDream.Core/Vfx/ParticleSystem.cs +++ b/src/AcDream.Core/Vfx/ParticleSystem.cs @@ -158,17 +158,104 @@ public sealed class ParticleSystem : IParticleSystem } } - public IEnumerable<(ParticleEmitter Emitter, int Index)> EnumerateLive() - { - foreach (var handle in _handleOrder) - { - if (!_byHandle.TryGetValue(handle, out var em)) - continue; + /// + /// Enumerate every live particle across every active emitter as + /// (emitter, particle-index) pairs, in emitter-spawn order. + /// + /// + /// MP-Alloc (2026-07-05): this used to be a C# iterator block (a + /// compiler-generated heap-allocated state machine, `yield return`), + /// allocated fresh on every call. + /// calls this once per pass and there are up to ~11 passes per frame + /// (sky pre/post, scene, per-visible-cell, dynamics, unattached), so + /// this was 11 iterator allocations per frame even with zero particles + /// on screen. Returns a struct + /// instead: `foreach` over it uses the struct enumerator directly (no + /// allocation), while LINQ / test callers that need + /// (`.ToList()`, `.Single()`, etc.) still + /// work via the explicit interface implementation — those call sites + /// are test-only, not the per-frame render path this task targets. + /// + /// + public LiveParticleEnumerable EnumerateLive() => new(this); - for (int i = 0; i < em.Particles.Length; i++) + /// + /// Struct enumerable returned by . Wraps the + /// owning so foreach gets a + /// zero-allocation struct enumerator; falls back to a boxed iterator + /// only when consumed through the surface + /// (LINQ, test helpers). + /// + public readonly struct LiveParticleEnumerable : IEnumerable<(ParticleEmitter Emitter, int Index)> + { + private readonly ParticleSystem _owner; + internal LiveParticleEnumerable(ParticleSystem owner) => _owner = owner; + + public Enumerator GetEnumerator() => new(_owner); + + IEnumerator<(ParticleEmitter Emitter, int Index)> IEnumerable<(ParticleEmitter Emitter, int Index)>.GetEnumerator() + => EnumerateLiveBoxed(_owner).GetEnumerator(); + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + => EnumerateLiveBoxed(_owner).GetEnumerator(); + + private static IEnumerable<(ParticleEmitter Emitter, int Index)> EnumerateLiveBoxed(ParticleSystem owner) + { + foreach (var handle in owner._handleOrder) { - if (em.Particles[i].Alive) - yield return (em, i); + if (!owner._byHandle.TryGetValue(handle, out var em)) + continue; + + for (int i = 0; i < em.Particles.Length; i++) + { + if (em.Particles[i].Alive) + yield return (em, i); + } + } + } + + /// Zero-allocation struct enumerator for the `foreach` fast path. + public struct Enumerator + { + private readonly ParticleSystem _owner; + private int _handleIdx; + private ParticleEmitter? _currentEmitter; + private int _particleIdx; + + internal Enumerator(ParticleSystem owner) + { + _owner = owner; + _handleIdx = -1; + _currentEmitter = null; + _particleIdx = -1; + } + + public (ParticleEmitter Emitter, int Index) Current => (_currentEmitter!, _particleIdx); + + public bool MoveNext() + { + while (true) + { + if (_currentEmitter is not null) + { + for (_particleIdx++; _particleIdx < _currentEmitter.Particles.Length; _particleIdx++) + { + if (_currentEmitter.Particles[_particleIdx].Alive) + return true; + } + _currentEmitter = null; + } + + _handleIdx++; + if (_handleIdx >= _owner._handleOrder.Count) + return false; + + if (!_owner._byHandle.TryGetValue(_owner._handleOrder[_handleIdx], out var em)) + continue; + + _currentEmitter = em; + _particleIdx = -1; + } } } } diff --git a/src/AcDream.Core/World/InteriorEntityIdAllocator.cs b/src/AcDream.Core/World/InteriorEntityIdAllocator.cs new file mode 100644 index 00000000..cc4cecff --- /dev/null +++ b/src/AcDream.Core/World/InteriorEntityIdAllocator.cs @@ -0,0 +1,49 @@ +namespace AcDream.Core.World; + +/// +/// Packs a stable, collision-free id base for a landblock's dat-hydrated +/// EnvCell-interior entities. +/// +/// +/// Why this exists (#190, 2026-07-09). The id space is +/// 0x4X XXXXX — the top NIBBLE fixed at 4, distinguishing interior +/// statics from live weenies (ids < 0x40000000), procedural scenery +/// (0x80000000+, bit 31 set), and landblock stabs (0xC0000000+). Nothing +/// decodes a landblock's X/Y back out of an entity id — every consumer +/// (GameWindow.cs's _isOutdoorMesh/_isLandblockStab +/// classification) reads only a THRESHOLD or a full-byte PREFIX — so the +/// internal field widths below are free to change without touching any +/// consumer. +/// +/// +/// +/// 28 remaining bits split X(8) / Y(8) / counter(12). X and Y stay at a +/// full byte each to match AC's 0-255 landblock grid — shrinking either +/// reintroduces #119's cross-landblock aliasing (two DIFFERENT landblocks +/// sharing one id space). The prior split (X8/Y8/counter8, "0x40XXYY##") +/// fixed #119 but left only 256 ids for ONE landblock's entire interior +/// static population. The Town Network hub (205 cells, one landblock) +/// already reached 248 before the #79/#93 A7.L1 light-carrier hydration +/// fix, which pushed it to 277 — PAST the 8-bit boundary, silently +/// aliasing into the NEXT landblock's reserved Y-byte (id 0x40000815 read +/// back as landblock Y=0x08, not the true Y=0x07): the exact #119 bug, +/// reincarnated by entity COUNT instead of a computation bug. Shrinking +/// the fixed prefix from a full byte (0x40) to its top nibble (0x4_) frees +/// 4 bits for the counter (8→12 bits, 256→4096 capacity) — ~15x headroom +/// over the observed count. +/// +/// +public static class InteriorEntityIdAllocator +{ + /// Per-landblock counter budget (12 bits). A landblock hydrating + /// more interior entities than this would alias into the next Y-slot — + /// exactly the #190 bug, just at a higher threshold. Callers should log + /// loudly (never silently wrap) if this is ever exceeded. + public const uint MaxCounter = 0xFFFu; + + /// The first id in this landblock's reserved range (counter=0). + /// Add a counter in [0, MaxCounter] to allocate a unique entity id + /// within the landblock. + public static uint Base(uint landblockX, uint landblockY) + => 0x40000000u | ((landblockX & 0xFFu) << 20) | ((landblockY & 0xFFu) << 12); +} diff --git a/src/AcDream.Core/World/StreamingReadinessGate.cs b/src/AcDream.Core/World/StreamingReadinessGate.cs new file mode 100644 index 00000000..9030734e --- /dev/null +++ b/src/AcDream.Core/World/StreamingReadinessGate.cs @@ -0,0 +1,51 @@ +namespace AcDream.Core.World; + +/// +/// Should the streaming/render pipeline be allowed to run this frame? +/// +/// +/// Why this exists (#192, 2026-07-09). Login to a non-Holtburg position +/// sometimes showed stabs/scenery floating in the wrong place. Root cause: the +/// old gate opened as soon as WorldSession reached InWorld — but +/// InWorld fires immediately after the login handshake completes +/// (WorldSession.cs:608), BEFORE the player's own spawn CreateObject +/// (which carries their real position) has even arrived over the network. Any +/// landblock streamed in that window baked its world offset from +/// GameWindow._liveCenterX/Y's startup placeholder (Holtburg, 0xA9B4) — a +/// real position, not a "not known yet" sentinel — because the streaming worker +/// reads that field fresh at build time with no way to know it's still a guess. +/// That stale-baked geometry still got applied once its build finished, landing +/// wherever the guess put it relative to whatever streamed in afterward using the +/// corrected center. +/// +/// +/// +/// The fix is not "pick a better placeholder" — any placeholder racing against +/// the real answer reproduces the same bug. It's gating on whether the real +/// position is actually known yet (, set true +/// exactly when the player's own spawn is processed), independent of session +/// state. alone is deliberately no longer +/// sufficient in live mode. +/// +/// +public static class StreamingReadinessGate +{ + /// Whether a live ACE session is configured at all. + /// False (offline / fly-camera) always streams — there is no real position to + /// wait for, so no race exists. + /// Latches true the first time chase mode + /// engages and stays true for the rest of the session — well past the login + /// race window. + /// The live session has completed the login handshake + /// (WorldSession.State.InWorld). Necessary but NOT sufficient on its + /// own — see class remarks. + /// The player's own spawn CreateObject has + /// been received and processed, so _liveCenterX/Y reflects a real, + /// server-confirmed position rather than the startup placeholder. + public static bool ShouldStream( + bool liveModeEnabled, bool chaseModeEverEntered, bool liveInWorld, bool liveCenterKnown) + { + bool isWaitingForLogin = liveModeEnabled && !chaseModeEverEntered; + return !isWaitingForLogin || (liveInWorld && liveCenterKnown); + } +} diff --git a/src/AcDream.UI.Abstractions/Panels/Debug/DebugPanel.cs b/src/AcDream.UI.Abstractions/Panels/Debug/DebugPanel.cs index 6593f90c..01292581 100644 --- a/src/AcDream.UI.Abstractions/Panels/Debug/DebugPanel.cs +++ b/src/AcDream.UI.Abstractions/Panels/Debug/DebugPanel.cs @@ -254,6 +254,12 @@ public sealed class DebugPanel : IPanel if (r.Checkbox("Probe auto-walk (ACDREAM_PROBE_AUTOWALK)", ref probeAutoWalk)) _vm.ProbeAutoWalk = probeAutoWalk; + // MP0 (2026-07-05): permanent frame profiler toggle — not a + // throwaway investigation probe, so it lives with the other + // always-available diagnostics rather than a dated section. + bool frameProf = _vm.FrameProf; + if (r.Checkbox("Frame profiler ([frame-prof])", ref frameProf)) _vm.FrameProf = frameProf; + // ── Indoor rendering diagnostics (2026-05-19) ─────────────── // Pinpoint where the EnvCell rendering chain breaks for // hypothesis-driven Phase 2 fix. Spec: diff --git a/src/AcDream.UI.Abstractions/Panels/Debug/DebugVM.cs b/src/AcDream.UI.Abstractions/Panels/Debug/DebugVM.cs index d7801f46..bf4123f8 100644 --- a/src/AcDream.UI.Abstractions/Panels/Debug/DebugVM.cs +++ b/src/AcDream.UI.Abstractions/Panels/Debug/DebugVM.cs @@ -291,6 +291,17 @@ public sealed class DebugVM set => PhysicsDiagnostics.ProbeAutoWalkEnabled = value; } + /// + /// Runtime mirror of RenderingDiagnostics.FrameProfEnabled + /// (env var ACDREAM_FRAME_PROF). Toggling here starts/stops the + /// [frame-prof] 5-second report live — no relaunch required. + /// + public bool FrameProf + { + get => RenderingDiagnostics.FrameProfEnabled; + set => RenderingDiagnostics.FrameProfEnabled = value; + } + // ── Indoor rendering diagnostics (2026-05-19) ─────────────────── // Mirror RenderingDiagnostics statics so DebugPanel checkbox toggles // take effect on the next render frame without relaunching. diff --git a/tests/AcDream.App.Tests/FrameProfilerReportTests.cs b/tests/AcDream.App.Tests/FrameProfilerReportTests.cs new file mode 100644 index 00000000..1a087074 --- /dev/null +++ b/tests/AcDream.App.Tests/FrameProfilerReportTests.cs @@ -0,0 +1,49 @@ +using AcDream.App.Diagnostics; +using Xunit; + +namespace AcDream.App.Tests; + +public class FrameProfilerReportTests +{ + [Fact] + public void FormatReport_IsInvariantAndComplete() + { + var cpu = new FrameStatsBuffer(16); + var gpu = new FrameStatsBuffer(16); + var alloc = new FrameStatsBuffer(16); + var stages = new[] { new FrameStatsBuffer(16), new FrameStatsBuffer(16), new FrameStatsBuffer(16) }; + for (long i = 1; i <= 10; i++) + { + cpu.Push(i * 1000); // 1..10 ms in µs + gpu.Push(i * 100); + alloc.Push(i * 1024); // bytes + stages[0].Push(i * 200); + stages[1].Push(i * 50); + stages[2].Push(i * 10); + } + + string line = FrameProfiler.FormatReport( + frameCount: 10, cpu: cpu, gpu: gpu, gpuActive: true, + alloc: alloc, gc0: 3, gc1: 1, gc2: 0, stages: stages); + + Assert.StartsWith("[frame-prof]", line); + Assert.Contains("n=10", line); + Assert.Contains("cpu_ms p50=5.0 p95=10.0 p99=10.0 max=10.0", line); + Assert.Contains("gpu_ms p50=0.5", line); + Assert.Contains("alloc_kb p50=5.0 max=10.0", line); + Assert.Contains("gc=3/1/0", line); + Assert.Contains("upd p50=1.0", line); // stage 0: 200µs·5 = 1.0 ms + Assert.DoesNotContain(",0", line.Replace("gc=3/1/0", "")); // no comma decimals (invariant culture) + } + + [Fact] + public void FormatReport_GpuInactive_SaysWhy() + { + var empty = new FrameStatsBuffer(4); + string line = FrameProfiler.FormatReport( + frameCount: 0, cpu: empty, gpu: empty, gpuActive: false, + alloc: empty, gc0: 0, gc1: 0, gc2: 0, + stages: new[] { empty, empty, empty }); + Assert.Contains("gpu=off(wbdiag)", line); + } +} diff --git a/tests/AcDream.App.Tests/FrameStatsBufferTests.cs b/tests/AcDream.App.Tests/FrameStatsBufferTests.cs new file mode 100644 index 00000000..725f370c --- /dev/null +++ b/tests/AcDream.App.Tests/FrameStatsBufferTests.cs @@ -0,0 +1,59 @@ +using AcDream.App.Diagnostics; +using Xunit; + +namespace AcDream.App.Tests; + +public class FrameStatsBufferTests +{ + [Fact] + public void Percentiles_OnKnownDistribution_AreExact() + { + var buf = new FrameStatsBuffer(capacity: 100); + // 1..100 µs — p50 = 50, p95 = 95, p99 = 99, max = 100. + for (long i = 1; i <= 100; i++) buf.Push(i); + + Assert.Equal(50, buf.Percentile(0.50)); + Assert.Equal(95, buf.Percentile(0.95)); + Assert.Equal(99, buf.Percentile(0.99)); + Assert.Equal(100, buf.Max()); + } + + [Fact] + public void Push_PastCapacity_KeepsOnlyNewestWindow() + { + var buf = new FrameStatsBuffer(capacity: 4); + foreach (long v in new long[] { 1000, 1000, 1000, 1000, 1, 2, 3, 4 }) + buf.Push(v); + // The four 1000s were overwritten; window is {1,2,3,4}. + Assert.Equal(4, buf.Count); + Assert.Equal(4, buf.Max()); + Assert.Equal(2, buf.Percentile(0.50)); + } + + [Fact] + public void Percentile_Empty_ReturnsZero() + { + var buf = new FrameStatsBuffer(capacity: 8); + Assert.Equal(0, buf.Percentile(0.95)); + Assert.Equal(0, buf.Max()); + Assert.Equal(0, buf.Count); + } + + [Fact] + public void Reset_ClearsWindow() + { + var buf = new FrameStatsBuffer(capacity: 8); + buf.Push(5); buf.Push(7); + buf.Reset(); + Assert.Equal(0, buf.Count); + Assert.Equal(0, buf.Percentile(0.5)); + } + + [Fact] + public void Max_AllNegative_ReturnsTrueMax() + { + var buf = new FrameStatsBuffer(capacity: 4); + buf.Push(-5); buf.Push(-2); buf.Push(-9); + Assert.Equal(-2, buf.Max()); + } +} diff --git a/tests/AcDream.App.Tests/Rendering/CornerFloodReplayTests.cs b/tests/AcDream.App.Tests/Rendering/CornerFloodReplayTests.cs index c6b137fe..d5a0c004 100644 --- a/tests/AcDream.App.Tests/Rendering/CornerFloodReplayTests.cs +++ b/tests/AcDream.App.Tests/Rendering/CornerFloodReplayTests.cs @@ -88,7 +88,6 @@ public class CornerFloodReplayTests var portals = new List(); var clipPlanes = new List(); var portalPolygons = new List(); - var centroid = (boundsMin + boundsMax) * 0.5f; foreach (var portal in envCell.CellPortals) { @@ -106,10 +105,13 @@ public class CornerFloodReplayTests var p2 = new Vector3(v2.Origin.X, v2.Origin.Y, v2.Origin.Z); var normal = Vector3.Normalize(Vector3.Cross(p1 - p0, p2 - p0)); float d = -Vector3.Dot(normal, p0); - float centroidDot = Vector3.Dot(normal, centroid) + d; + // InsideSide from the dat PortalSide bit — mirrors the production fix + // (GameWindow.BuildLoadedCell): retail InitCell (0x005a4b70) + physics + // CellTransit use the dat bit; the old AABB-centroid guess mis-sided thin + // connectors (#186). Kept identical here so this replay stays a faithful mirror. clipPlanes.Add(new PortalClipPlane { - Normal = normal, D = d, InsideSide = centroidDot >= 0 ? 0 : 1, + Normal = normal, D = d, InsideSide = ((ushort)portal.Flags & 0x2) == 0 ? 1 : 0, }); } else diff --git a/tests/AcDream.App.Tests/Rendering/Issue113MeetingHallFloodTests.cs b/tests/AcDream.App.Tests/Rendering/Issue113MeetingHallFloodTests.cs index 8b63aedc..205a3034 100644 --- a/tests/AcDream.App.Tests/Rendering/Issue113MeetingHallFloodTests.cs +++ b/tests/AcDream.App.Tests/Rendering/Issue113MeetingHallFloodTests.cs @@ -77,7 +77,6 @@ public class Issue113MeetingHallFloodTests var portals = new List(); var clipPlanes = new List(); var portalPolygons = new List(); - var centroid = (boundsMin + boundsMax) * 0.5f; foreach (var portal in envCell.CellPortals) { @@ -95,10 +94,13 @@ public class Issue113MeetingHallFloodTests var p2 = new Vector3(v2.Origin.X, v2.Origin.Y, v2.Origin.Z); var normal = Vector3.Normalize(Vector3.Cross(p1 - p0, p2 - p0)); float d = -Vector3.Dot(normal, p0); - float centroidDot = Vector3.Dot(normal, centroid) + d; + // InsideSide from the dat PortalSide bit — mirrors the production fix + // (GameWindow.BuildLoadedCell): retail InitCell (0x005a4b70) + physics + // CellTransit use the dat bit; the old AABB-centroid guess mis-sided thin + // connectors (#186). Kept identical here so this replay stays a faithful mirror. clipPlanes.Add(new PortalClipPlane { - Normal = normal, D = d, InsideSide = centroidDot >= 0 ? 0 : 1, + Normal = normal, D = d, InsideSide = ((ushort)portal.Flags & 0x2) == 0 ? 1 : 0, }); } else diff --git a/tests/AcDream.App.Tests/Rendering/Issue176177FacilityHubFloodReplayTests.cs b/tests/AcDream.App.Tests/Rendering/Issue176177FacilityHubFloodReplayTests.cs new file mode 100644 index 00000000..0bc52627 --- /dev/null +++ b/tests/AcDream.App.Tests/Rendering/Issue176177FacilityHubFloodReplayTests.cs @@ -0,0 +1,280 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using AcDream.App.Rendering; +using DatReaderWriter; +using DatReaderWriter.Options; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.App.Tests.Rendering; + +/// +/// #176 (purple flashing at corridor seams, camera-angle dependent) + #177 +/// (stairs pop in/out) — headless portal-flood replay in the Facility Hub +/// landblock 0x8A02. The unified hypothesis after the dat + draw-path reads: +/// both artifacts are FLOOD ADMISSION instability (a cell dropping out of +/// PortalVisibilityBuilder's admitted set paints the fog-purple clear color +/// where its geometry was; stair cells failing admission = the pop). +/// +/// Production-matched inputs: Build(root, eye, lookup, viewProj, +/// buildingMembership: null, drawLiftZ: ShellDrawLiftZ) — the drawLiftZ +/// mirrors RetailPViewRenderer.DrawInside. +/// +/// Scenarios: +/// A. #177 approach — stand in corridor 0x0178, look +X at the stair ramp +/// (0x0182) and the lower cell (0x0183): are they admitted? +/// B. #177 descent — eye path down the ramp crossing into 0x0183: does +/// 0x0182 (the ramp geometry's owner) drop near the transit? +/// C. #176 gaze sweep — eye parked in 0x016E near the 0x017A seam, yaw +/// sweep at several pitches: any cell admitted at angle k, gone at k+1, +/// back at k+2 (the bistability signature)? +/// D. #176 walk — eye tracks down the corridor across two seams, gaze +/// locked +X: per-step admitted-set diffs (drop-for-one-step churn). +/// +public class Issue176177FacilityHubFloodReplayTests +{ + private const uint FacilityHub = 0x8A020000u; + + private readonly ITestOutputHelper _out; + public Issue176177FacilityHubFloodReplayTests(ITestOutputHelper output) => _out = output; + + private static Matrix4x4 ViewProjFor(Vector3 eye, Vector3 gazeDir) + { + var view = Matrix4x4.CreateLookAt(eye, eye + gazeDir, Vector3.UnitZ); + var proj = Matrix4x4.CreatePerspectiveFieldOfView(1.2f, 1280f / 720f, 0.1f, 5000f); + return view * proj; + } + + private static List Flood( + Dictionary cells, uint rootId, Vector3 eye, Vector3 gazeDir) + { + Func lookup = id => cells.TryGetValue(id, out var c) ? c : null; + var frame = PortalVisibilityBuilder.Build( + cells[rootId], eye, lookup, ViewProjFor(eye, gazeDir), + buildingMembership: null, + drawLiftZ: PortalVisibilityBuilder.ShellDrawLiftZ); + var result = new List(frame.OrderedVisibleCells); + result.Sort(); + return result; + } + + private static string CellSetString(IEnumerable ids) + => string.Join(" ", ids.Select(id => $"{id & 0xFFFFu:X4}")); + + [Fact] + public void ScenarioA_StairApproach_AdmissionsFromCorridor() + { + var datDir = CornerFloodReplayTests.ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var cells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + Assert.True(cells.ContainsKey(FacilityHub | 0x0178u), "0x0178 not loaded"); + + // 0x0178 spans x<=95 at z −6..−3 (floor −6); the ramp cell 0x0182 runs + // x 95→98.33 descending; 0x0183 continues at z −9 beyond x=98.33. + // Eye at standing height (~1.7 m above the −6 floor), approaching the + // stair portal at x=95, gazing +X with a slight downward pitch (the + // natural look at a descending stair). + foreach (float eyeX in new[] { 88f, 90f, 92f, 94f, 94.9f }) + { + var eye = new Vector3(eyeX, -40f, -4.3f); + foreach (var (gaze, label) in new (Vector3, string)[] + { + (new Vector3(1f, 0f, 0f), "level"), + (Vector3.Normalize(new Vector3(1f, 0f, -0.35f)), "pitch-19"), + (Vector3.Normalize(new Vector3(1f, 0f, -0.7f)), "pitch-35"), + }) + { + var visible = Flood(cells, FacilityHub | 0x0178u, eye, gaze); + bool ramp = visible.Contains(FacilityHub | 0x0182u); + bool lower = visible.Contains(FacilityHub | 0x0183u); + _out.WriteLine($"eyeX={eyeX,5:F1} gaze={label,-8} flood={visible.Count,2} " + + $"ramp0182={(ramp ? "Y" : "MISSING")} lower0183={(lower ? "Y" : "MISSING")} " + + $"[{CellSetString(visible)}]"); + } + } + } + + [Fact] + public void ScenarioB_StairDescent_RampCellRetention() + { + var datDir = CornerFloodReplayTests.ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var cells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + + // Descend the ramp: floor z goes −6 (x=95) → −9 (x=98.33), then flat. + // Eye rides ~1.7 m above the local floor. Root = the cell containing + // the eye by x-range (0x0178 x<95, ramp 0x0182 95..98.33, 0x0183 after). + // Gaze: forward and slightly down (running down stairs). + var gazeDir = Vector3.Normalize(new Vector3(1f, 0f, -0.4f)); + List? prev = null; + for (float x = 94.0f; x <= 100.5f; x += 0.1f) + { + float floorZ = x < 95f ? -6f + : x < 98.333f ? -6f - 3f * (x - 95f) / 3.333f + : -9f; + var eye = new Vector3(x, -40f, floorZ + 1.7f); + uint rootId = x < 95f ? FacilityHub | 0x0178u + : x < 98.333f ? FacilityHub | 0x0182u + : FacilityHub | 0x0183u; + + var visible = Flood(cells, rootId, eye, gazeDir); + bool ramp = visible.Contains(FacilityHub | 0x0182u); + bool upper = visible.Contains(FacilityHub | 0x0178u); + + string diff = ""; + if (prev is not null) + { + var removed = prev.Except(visible).ToList(); + var added = visible.Except(prev).ToList(); + if (removed.Count > 0) diff += $" REMOVED=[{CellSetString(removed)}]"; + if (added.Count > 0) diff += $" added=[{CellSetString(added)}]"; + } + _out.WriteLine($"x={x,6:F1} root={rootId & 0xFFFFu:X4} eyeZ={eye.Z,6:F2} flood={visible.Count,2} " + + $"ramp0182={(ramp ? "Y" : "MISSING")} up0178={(upper ? "Y" : "-")}{diff}"); + prev = visible; + } + } + + [Fact] + public void ScenarioC_CorridorSeamGazeSweep_Bistability() + { + var datDir = CornerFloodReplayTests.ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var cells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + + // Parked eye in 0x016E near the 0x017A seam (x=85), standing height. + var eye = new Vector3(83.5f, -40f, -4.3f); + uint rootId = FacilityHub | 0x016Eu; + + int churnEvents = 0; + foreach (float pitchZ in new[] { 0f, -0.35f, -0.75f, -1.2f }) + { + List? prevSet = null; + float prevYaw = 0f; + var perYawSets = new List<(float yaw, List set)>(); + for (float yawDeg = -180f; yawDeg <= 180f; yawDeg += 2f) + { + float rad = yawDeg * MathF.PI / 180f; + var gaze = Vector3.Normalize(new Vector3(MathF.Cos(rad), MathF.Sin(rad), pitchZ)); + var visible = Flood(cells, rootId, eye, gaze); + perYawSets.Add((yawDeg, visible)); + + if (prevSet is not null) + { + var removed = prevSet.Except(visible).ToList(); + var added = visible.Except(prevSet).ToList(); + if (removed.Count > 0 || added.Count > 0) + { + _out.WriteLine($"pitch={pitchZ,5:F2} yaw {prevYaw,6:F0}->{yawDeg,6:F0}: " + + $"flood {prevSet.Count}->{visible.Count}" + + (removed.Count > 0 ? $" REMOVED=[{CellSetString(removed)}]" : "") + + (added.Count > 0 ? $" added=[{CellSetString(added)}]" : "")); + } + } + prevSet = visible; + prevYaw = yawDeg; + } + + // Bistability: a cell present at yaw k, absent at k+1, present at k+2. + for (int i = 2; i < perYawSets.Count; i++) + { + var flicker = perYawSets[i - 2].set + .Intersect(perYawSets[i].set) + .Except(perYawSets[i - 1].set) + .ToList(); + if (flicker.Count > 0) + { + churnEvents++; + _out.WriteLine($">>> BISTABLE pitch={pitchZ:F2} yaw={perYawSets[i - 1].yaw:F0}: " + + $"cells [{CellSetString(flicker)}] dropped for ONE 2-degree step"); + } + } + } + _out.WriteLine($"bistable one-step drop events: {churnEvents}"); + } + + /// + /// THE production lag-window scenario (from launch-137-gate2.log + /// [cell-transit] lines): membership transits fire 0.1–0.6 m PAST the + /// portal plane in the travel direction (016E→017A at x=85.33–85.47 vs + /// the plane at x=85.00; 0182→0183 at 98.56–98.64 vs 98.33). The render + /// root (viewer cell, same membership machinery) therefore holds the OLD + /// cell while the camera eye is already beyond the boundary portal's + /// plane. This scenario reproduces exactly that window: root=old cell, + /// eye stepped across and past the plane, gaze forward. If the forward + /// chain (the next corridor cells) drops inside the window, that is #176 + /// (purple = fog clear color where the forward cells' geometry was) and + /// #177(a)/(c) at the stair transit. + /// + [Theory] + [InlineData(0x016Eu, 0x017Au, 85.00f, -4.3f)] // corridor seam, plane x=85 + [InlineData(0x0182u, 0x0183u, 98.333f, -7.3f)] // stair-bottom transit, plane x=98.33 + public void ScenarioE_RootLagWindow_ForwardChainRetention( + uint rootLow, uint forwardLow, float planeX, float eyeZ) + { + var datDir = CornerFloodReplayTests.ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var cells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + + uint rootId = FacilityHub | rootLow; + uint forwardId = FacilityHub | forwardLow; + var gazeDir = Vector3.Normalize(new Vector3(1f, 0f, -0.3f)); + + _out.WriteLine($"root=0x{rootLow:X4} forward=0x{forwardLow:X4} plane x={planeX:F2} " + + "(eye sweeps across; root HELD at the old cell = the production lag window)"); + foreach (float dx in new[] { -0.30f, -0.10f, -0.02f, 0.00f, 0.02f, 0.05f, 0.10f, 0.20f, 0.30f, 0.45f, 0.60f }) + { + var eye = new Vector3(planeX + dx, -40f, eyeZ); + var visible = Flood(cells, rootId, eye, gazeDir); + bool fwd = visible.Contains(forwardId); + _out.WriteLine($" eyeX=plane{(dx >= 0 ? "+" : "")}{dx:F2} flood={visible.Count,2} " + + $"forward={(fwd ? "Y" : ">>> DROPPED <<<")} [{CellSetString(visible)}]"); + } + } + + [Fact] + public void ScenarioD_CorridorWalk_PerStepChurn() + { + var datDir = CornerFloodReplayTests.ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var cells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + + // Walk 0x0165 → 0x016E → 0x017A along y=−40 (seams at x=75 and x=85), + // gaze locked +X, slight downward pitch (the running view). Root flips + // by x-range at the seams (the camera transits the same portals). + var gazeDir = Vector3.Normalize(new Vector3(1f, 0f, -0.3f)); + List? prev = null; + int churn = 0; + for (float x = 71f; x <= 89f; x += 0.05f) + { + uint rootId = x < 75f ? FacilityHub | 0x0165u + : x < 85f ? FacilityHub | 0x016Eu + : FacilityHub | 0x017Au; + if (!cells.ContainsKey(rootId)) continue; + var eye = new Vector3(x, -40f, -4.3f); + var visible = Flood(cells, rootId, eye, gazeDir); + + if (prev is not null) + { + var removed = prev.Except(visible).ToList(); + var added = visible.Except(prev).ToList(); + if (removed.Count > 0 || added.Count > 0) + { + churn++; + _out.WriteLine($"x={x,6:F2} root={rootId & 0xFFFFu:X4} flood={visible.Count,2}" + + (removed.Count > 0 ? $" REMOVED=[{CellSetString(removed)}]" : "") + + (added.Count > 0 ? $" added=[{CellSetString(added)}]" : "")); + } + } + prev = visible; + } + _out.WriteLine($"admitted-set change events over the walk: {churn}"); + } +} diff --git a/tests/AcDream.App.Tests/Rendering/Issue177StairDescentCameraFloodTests.cs b/tests/AcDream.App.Tests/Rendering/Issue177StairDescentCameraFloodTests.cs new file mode 100644 index 00000000..2652301b --- /dev/null +++ b/tests/AcDream.App.Tests/Rendering/Issue177StairDescentCameraFloodTests.cs @@ -0,0 +1,560 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Numerics; +using AcDream.App.Rendering; +using AcDream.Core.Physics; +using AcDream.Core.Rendering; +using DatReaderWriter; +using DatReaderWriter.Options; +using DatEnvCell = DatReaderWriter.DBObjs.EnvCell; +using DatEnvironment = DatReaderWriter.DBObjs.Environment; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.App.Tests.Rendering; + +/// +/// #177 decisive full-chain replay: drive the REAL +/// + REAL down the Facility Hub +/// staircase against the REAL BSP, then feed the swept (ViewerCellId, eye, +/// View*Projection) into — exactly +/// the production coupling (GameWindow ~9055-9065 + RetailPViewRenderer.DrawInside). +/// +/// The earlier Issue176177 replays fed SYNTHETIC (root, eye) pairs: Scenario A +/// admitted the stairs fine from a coherent corridor root, Scenario E collapsed +/// the flood 12->1 but only because it HELD the root at the old cell while the +/// eye crossed a portal plane. This test removes the assumption: the root IS the +/// swept camera cell, the eye IS the swept camera eye, both from the same sweep. +/// If the stairs still collapse, #177 is a production root/eye coupling defect +/// and the printed per-portal side-test D names the failing gate. If they stay +/// admitted, the flood is exonerated and the artifact lives downstream. +/// +public class Issue177StairDescentCameraFloodTests +{ + private const uint FacilityHub = 0x8A020000u; + + private readonly ITestOutputHelper _out; + public Issue177StairDescentCameraFloodTests(ITestOutputHelper output) => _out = output; + + private static string? ResolveDatDir() + { + var fromEnv = Environment.GetEnvironmentVariable("ACDREAM_DAT_DIR"); + if (!string.IsNullOrWhiteSpace(fromEnv) && Directory.Exists(fromEnv)) return fromEnv; + var def = Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + return Directory.Exists(def) ? def : null; + } + + private static PhysicsEngine BuildHubEngine(DatCollection dats) + { + var cache = new PhysicsDataCache(); + var engine = new PhysicsEngine { DataCache = cache }; + for (uint low = 0x0100u; low <= 0x01FFu; low++) + { + uint id = FacilityHub | low; + var datCell = dats.Get(id); + if (datCell is null) continue; + var environment = dats.Get(0x0D000000u | datCell.EnvironmentId); + if (environment is null) continue; + if (!environment.Cells.TryGetValue(datCell.CellStructure, out var cellStruct) || cellStruct is null) + continue; + var world = Matrix4x4.CreateFromQuaternion(datCell.Position.Orientation) * + Matrix4x4.CreateTranslation(datCell.Position.Origin); + cache.CacheCellStruct(id, datCell, cellStruct, world); + } + var heights = new byte[81]; + var heightTable = new float[256]; + for (int i = 0; i < 256; i++) heightTable[i] = -1000f; + engine.AddLandblock(FacilityHub, new TerrainSurface(heights, heightTable), + Array.Empty(), Array.Empty(), 0f, 0f); + return engine; + } + + // Analytic ramp floor from Scenario B: flat -6 (x<95), descends to -9 across + // x 95..98.333, then flat -9. + private static float FloorZ(float x) + => x < 95f ? -6f + : x < 98.333f ? -6f - 3f * (x - 95f) / 3.333f + : -9f; + + // Replicated side test (PortalVisibilityBuilder.CameraOnInteriorSide is private). + private const float PortalSideEpsilon = 0.01f; + private static bool EyeInteriorSide(LoadedCell cell, int i, Vector3 eye) + { + if (i >= cell.ClipPlanes.Count) return true; + var pl = cell.ClipPlanes[i]; + if (pl.Normal.LengthSquared() < 1e-8f) return true; + var local = Vector3.Transform(eye, cell.InverseWorldTransform); + float dot = Vector3.Dot(pl.Normal, local) + pl.D; + return pl.InsideSide == 0 ? dot >= -PortalSideEpsilon : dot <= PortalSideEpsilon; + } + private static float SideD(LoadedCell cell, int i, Vector3 eye) + { + if (i >= cell.ClipPlanes.Count) return float.NaN; + var pl = cell.ClipPlanes[i]; + if (pl.Normal.LengthSquared() < 1e-8f) return float.NaN; + var local = Vector3.Transform(eye, cell.InverseWorldTransform); + return Vector3.Dot(pl.Normal, local) + pl.D; + } + + private static string CellSet(IEnumerable ids) + => string.Join(" ", ids.Select(id => $"{id & 0xFFFFu:X4}")); + + [Fact] + public void StairCellComposition_ShellVsStatics() + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + foreach (uint low in new uint[] { 0x01C8, 0x01C4, 0x01C9, 0x0210, 0x020E, 0x01C1, 0x01C0 }) + { + uint id = FacilityHub | low; + var envCell = dats.Get(id); + if (envCell is null) { _out.WriteLine($"0x{low:X4}: (no dat cell)"); continue; } + var environment = dats.Get(0x0D000000u | envCell.EnvironmentId); + environment!.Cells.TryGetValue(envCell.CellStructure, out var cs); + + int polys = cs?.Polygons.Count ?? -1; + int verts = cs?.VertexArray.Vertices.Count ?? -1; + var mn = new Vector3(float.MaxValue); var mx = new Vector3(float.MinValue); + if (cs is not null) + foreach (var kv in cs.VertexArray.Vertices) + { var o = kv.Value.Origin; var v = new Vector3(o.X, o.Y, o.Z); mn = Vector3.Min(mn, v); mx = Vector3.Max(mx, v); } + + int statics = envCell.StaticObjects?.Count ?? 0; + bool seenOut = (envCell.Flags & DatReaderWriter.Enums.EnvCellFlags.SeenOutside) != 0; + _out.WriteLine(FormattableString.Invariant( + $"0x{low:X4} env=0x{envCell.EnvironmentId:X4} struct={envCell.CellStructure} shellPolys={polys} shellVerts={verts} bounds=[{mn.X:F1},{mn.Y:F1},{mn.Z:F1}]..[{mx.X:F1},{mx.Y:F1},{mx.Z:F1}] portals={envCell.CellPortals.Count} statics={statics} seenOut={seenOut}")); + if (envCell.StaticObjects is not null) + foreach (var stab in envCell.StaticObjects) + { + var o = stab.Frame.Origin; + _out.WriteLine(FormattableString.Invariant( + $" static Id=0x{stab.Id:X8} kind={(stab.Id >> 24 == 0x02 ? "Setup" : stab.Id >> 24 == 0x01 ? "GfxObj" : "?")} pos=({o.X:F2},{o.Y:F2},{o.Z:F2})")); + } + + // Portal normals (local space) — horizontal (|Nz|~1) = FLOOR/CEILING portal + // (the edge-on-clip suspect); vertical (|Nz|~0) = wall/doorway portal. + var lc = renderLookup(id); + if (lc is not null) + for (int i = 0; i < lc.Portals.Count; i++) + { + var n = i < lc.ClipPlanes.Count ? lc.ClipPlanes[i].Normal : Vector3.Zero; + string kind = MathF.Abs(n.Z) > 0.7f ? "FLOOR/CEIL" : MathF.Abs(n.Z) < 0.3f ? "wall" : "slope"; + _out.WriteLine(FormattableString.Invariant( + $" portal[{i}]->0x{lc.Portals[i].OtherCellId:X4} N=({n.X:F2},{n.Y:F2},{n.Z:F2}) {kind} inside={lc.ClipPlanes[i].InsideSide}")); + } + } + + LoadedCell? renderLookup(uint id) + { + try { return CornerFloodReplayTests.LoadCell(dats, id); } + catch (InvalidOperationException) { return null; } + } + } + + /// + /// #177 re-diagnosis (fix#1 failed the visual gate): the vanish flips on a SLIGHT turn + + /// depends on zoom, so it is a gaze/eye knife-edge, not the eye-squarely-in-opening case + /// fix#1 handled. Drive the REAL camera at a fixed player spot on the 015F stairs, sweep + /// yaw FINELY at two zooms, and print the viewer cell + stair-cell admission each step to + /// locate the knife-edge and which cell flips. + /// + [Fact] + public void RealStaircase_FineYawZoomSweep_FindKnifeEdge() + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var renderCells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + var engine = BuildHubEngine(dats); + Func lookup = id => renderCells.TryGetValue(id, out var c) ? c : null; + + bool sC = CameraDiagnostics.CollideCamera; bool sA = CameraDiagnostics.AlignToSlope; + try + { + CameraDiagnostics.CollideCamera = true; CameraDiagnostics.AlignToSlope = true; + CameraDiagnostics.TranslationStiffness = 0.45f; CameraDiagnostics.RotationStiffness = 0.45f; + + uint[] stair = { 0x015Eu, 0x015Fu, 0x01C1u, 0x01C0u, 0x020Fu }; + // Player standing mid-015F stairs, eye near the ceiling boundary (per the sweep char). + foreach (var playerPos in new[] { new Vector3(60.5f, -46f, -2.5f), new Vector3(60.5f, -47f, -3.0f) }) + foreach (float dist in new[] { 2.61f, 12.0f }) + { + _out.WriteLine(FormattableString.Invariant( + $"=== player=({playerPos.X:F1},{playerPos.Y:F1},{playerPos.Z:F1}) zoom={dist} ===")); + var cam = new RetailChaseCamera + { + CollisionProbe = new PhysicsCameraCollisionProbe(engine), + FovY = MathF.PI / 3f, Aspect = 16f / 9f, Distance = dist, + }; + uint prevViewer = 0; string prevAdmit = ""; + for (float yawDeg = 0f; yawDeg < 360f; yawDeg += 6f) + { + float yaw = yawDeg * MathF.PI / 180f; + var (pcell, _) = engine.AdjustPosition(FacilityHub | 0x015Fu, playerPos + new Vector3(0, 0, 0.1f)); + for (int i = 0; i < 160; i++) + cam.Update(playerPos, yaw, Vector3.Zero, true, Vector3.UnitZ, 1f / 60f, pcell, 0x5000000A); + var eye = cam.Position; uint viewer = cam.ViewerCellId; + string admit = "?"; + if (viewer != 0u && renderCells.TryGetValue(viewer, out var rc)) + { + var f = PortalVisibilityBuilder.Build(rc, eye, lookup, cam.View * cam.Projection, null, PortalVisibilityBuilder.ShellDrawLiftZ); + var s = f.OrderedVisibleCells; + admit = string.Concat(stair.Select(low => (s.Contains(FacilityHub | low) ? "1" : "0"))); + } + // Print only when viewer or the admit pattern CHANGES (knife-edges). + if (viewer != prevViewer || admit != prevAdmit) + { + _out.WriteLine(FormattableString.Invariant( + $" yaw={yawDeg,3:F0} eye=({eye.X,6:F2},{eye.Y,6:F2},{eye.Z,6:F2}) viewer=0x{viewer & 0xFFFF:X4} stair[5E,5F,C1,C0,0F]={admit}")); + prevViewer = viewer; prevAdmit = admit; + } + } + } + } + finally { CameraDiagnostics.CollideCamera = sC; CameraDiagnostics.AlignToSlope = sA; } + } + + /// + /// #177 retail-vs-us flood DEPTH: retail's cdb capture shows PView cell_draw_num reaching 26 + /// cells from camera cell 015E (avg 14.3) looking down the spiral shaft. Sweep OUR real camera + /// from 015E over many gaze/zoom poses and report the max/avg OrderedVisibleCells — if ours + /// caps well below retail's 26, our flood truncates the spiral (the vanish). + /// + [Fact] + public void FloodDepthFrom015E_VsRetail26() + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var renderCells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + var engine = BuildHubEngine(dats); + Func lookup = id => renderCells.TryGetValue(id, out var c) ? c : null; + + bool sC = CameraDiagnostics.CollideCamera; bool sA = CameraDiagnostics.AlignToSlope; + try + { + CameraDiagnostics.CollideCamera = true; CameraDiagnostics.AlignToSlope = true; + CameraDiagnostics.TranslationStiffness = 0.45f; CameraDiagnostics.RotationStiffness = 0.45f; + int maxCells = 0; uint bestViewer = 0; double sum = 0; int n = 0; string bestSet = ""; + foreach (var playerPos in new[] { new Vector3(61f, -42f, -4f), new Vector3(60f, -41f, -5f), new Vector3(62f, -43f, -4f) }) + foreach (float dist in new[] { 2.61f, 4f, 8f }) + foreach (float pitch in new[] { 0.291f, 0.7f, -0.2f }) + { + var cam = new RetailChaseCamera { CollisionProbe = new PhysicsCameraCollisionProbe(engine), FovY = MathF.PI / 3f, Aspect = 16f / 9f, Distance = dist, Pitch = pitch }; + for (float yawDeg = 0f; yawDeg < 360f; yawDeg += 10f) + { + float yaw = yawDeg * MathF.PI / 180f; + var (pcell, _) = engine.AdjustPosition(FacilityHub | 0x015Eu, playerPos + new Vector3(0, 0, 0.1f)); + for (int i = 0; i < 140; i++) cam.Update(playerPos, yaw, Vector3.Zero, true, Vector3.UnitZ, 1f / 60f, pcell, 0x5000000A); + uint viewer = cam.ViewerCellId; + if (viewer == 0u || !renderCells.TryGetValue(viewer, out var rc)) continue; + var f = PortalVisibilityBuilder.Build(rc, cam.Position, lookup, cam.View * cam.Projection, null, PortalVisibilityBuilder.ShellDrawLiftZ); + int c = f.OrderedVisibleCells.Count; sum += c; n++; + if (c > maxCells) { maxCells = c; bestViewer = viewer; bestSet = CellSet(f.OrderedVisibleCells.OrderBy(v => v)); } + } + } + _out.WriteLine(FormattableString.Invariant( + $"OUR flood from 015E-area: maxCells={maxCells} (retail max=26) avg={sum / Math.Max(1, n):F1} (retail avg=14.3) bestViewer=0x{bestViewer & 0xFFFF:X4}")); + _out.WriteLine($" best set: [{bestSet}]"); + } + finally { CameraDiagnostics.CollideCamera = sC; CameraDiagnostics.AlignToSlope = sA; } + } + + private static Matrix4x4 ViewProj(Vector3 eye, Vector3 dir) + => Matrix4x4.CreateLookAt(eye, eye + Vector3.Normalize(dir), Vector3.UnitZ) + * Matrix4x4.CreatePerspectiveFieldOfView(MathF.PI / 3f, 16f / 9f, 0.1f, 5000f); + + // Signed distance of a WORLD point to a render cell's portal[i] plane (local-space plane). + private static float PortalPlaneDistance(LoadedCell cell, int i, Vector3 worldPt) + { + var pl = cell.ClipPlanes[i]; + var local = Vector3.Transform(worldPt, cell.InverseWorldTransform); + return Vector3.Dot(pl.Normal, local) + pl.D; + } + + /// + /// #177 THE decisive experiment. Reproduce the captured failing frame — camera in + /// cell 0x015F with the eye sitting IN the ceiling-portal plane (production [flap]: + /// root=015F eye=(60.47,-46.57,-0.00), p->01C1 clip=0) — and confirm the upper + /// stair cell 01C1 drops from the flood. Then move the SAME eye 0.4 m off that + /// plane (into the cell interior) and confirm 01C1 is re-admitted. If the contrast + /// holds, #177's fix is a viewpoint-off-the-portal-plane rule, and the load-bearing + /// clip (#119/#181) is correct as-is. + /// + [Fact] + public void EdgeOnCeilingPortal_DropsUpperCell_OffPlaneReadmits() + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var cells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + Func lookup = id => cells.TryGetValue(id, out var c) ? c : null; + + var root = cells[FacilityHub | 0x015Fu]; + uint upperId = FacilityHub | 0x01C1u; + + // Find 015F's portal to 01C1 (the ceiling/up portal) + report its normal. + int upIdx = -1; + for (int i = 0; i < root.Portals.Count; i++) + if (root.Portals[i].OtherCellId == 0x01C1u) { upIdx = i; break; } + Assert.True(upIdx >= 0, "015F has no portal to 01C1"); + var upN = root.ClipPlanes[upIdx].Normal; + _out.WriteLine(FormattableString.Invariant( + $"015F portal[{upIdx}]->01C1 localN=({upN.X:F2},{upN.Y:F2},{upN.Z:F2})")); + + // Look UP the stairs so the ceiling portal + 01C1 land on screen. + var gaze = new Vector3(0f, -0.3f, 1f); + + // Captured FAILING eye — in the ceiling-portal plane (world z ~0). + var eyeEdgeOn = new Vector3(60.47f, -46.57f, -0.00f); + // Same eye, pulled 0.4 m DOWN (off the ceiling portal, into 015F's interior). + var eyeOffPlane = eyeEdgeOn + new Vector3(0f, 0f, -0.40f); + + foreach (var (label, eye) in new[] { ("edge-on(captured)", eyeEdgeOn), ("off-plane(-0.4z)", eyeOffPlane) }) + { + float d = PortalPlaneDistance(root, upIdx, eye); + var frame = PortalVisibilityBuilder.Build( + root, eye, lookup, ViewProj(eye, gaze), + buildingMembership: null, drawLiftZ: PortalVisibilityBuilder.ShellDrawLiftZ); + var vis = frame.OrderedVisibleCells.OrderBy(v => v).ToList(); + bool up = vis.Contains(upperId); + string admit = up ? "ADMITTED" : "DROPPED"; + _out.WriteLine(FormattableString.Invariant( + $"{label,-18} eye=({eye.X,6:F2},{eye.Y,6:F2},{eye.Z,6:F2}) D->01C1={d,6:F3} 01C1={admit} flood={vis.Count} [{CellSet(vis)}]")); + } + + // #177 CHARACTERIZATION (fix#1 reverted — this edge-on-in-plane case was NOT the + // production mechanism; the real vanish is a grazing/sliver flood collapse in the + // spiral, root 0x01C8, portals off-screen/sliver, camera NOT collision-jammed). + // Kept as a mechanism pin: an eye exactly in the ceiling-portal plane drops the upper + // cell (edge-on → <3 clip), an eye 0.4 m off admits it via the normal clip. + var fEdge = PortalVisibilityBuilder.Build(root, eyeEdgeOn, lookup, ViewProj(eyeEdgeOn, gaze), null, PortalVisibilityBuilder.ShellDrawLiftZ); + var fOff = PortalVisibilityBuilder.Build(root, eyeOffPlane, lookup, ViewProj(eyeOffPlane, gaze), null, PortalVisibilityBuilder.ShellDrawLiftZ); + Assert.DoesNotContain(upperId, fEdge.OrderedVisibleCells); // edge-on drops (mechanism) + Assert.Contains(upperId, fOff.OrderedVisibleCells); // off-plane admits (control) + } + + /// + /// #177 sweep characterization: place the player on the 015F staircase and drive the + /// REAL chase camera + collision sweep, reporting where the eye lands relative to the + /// 015F ceiling-portal plane (world z=0). If the eye rests AT the plane (|D|~0) the + /// flood collapses (see EdgeOnCeilingPortal test); this shows whether that is a swept + /// contact leaving the eye on the surface vs free-space boom geometry. + /// + [Fact] + public void StaircaseSweep_EyeClearanceFromCeilingPortal() + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var renderCells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + var engine = BuildHubEngine(dats); + var root015F = renderCells[FacilityHub | 0x015Fu]; + int upIdx = 0; // portal[0]->01C1 (ceiling) + + bool sC = CameraDiagnostics.CollideCamera; bool sA = CameraDiagnostics.AlignToSlope; + try + { + CameraDiagnostics.CollideCamera = true; CameraDiagnostics.AlignToSlope = true; + CameraDiagnostics.TranslationStiffness = 0.45f; CameraDiagnostics.RotationStiffness = 0.45f; + + // Player on the 015F stairs (world y~-46, ceiling portal at world z~0), swept + // at a range of heights + facings (up-stairs = -Y, down-stairs = +Y). + foreach (float pz in new[] { -1.0f, -1.5f, -2.0f, -2.5f, -3.0f, -3.5f }) + foreach (var (fLabel, yaw) in new (string, float)[] { ("up(-Y)", -MathF.PI / 2f), ("down(+Y)", MathF.PI / 2f) }) + { + var playerPos = new Vector3(60.5f, -46f, pz); + var (pcell, _) = engine.AdjustPosition(FacilityHub | 0x015Fu, playerPos + new Vector3(0, 0, 0.1f)); + var cam = new RetailChaseCamera + { + CollisionProbe = new PhysicsCameraCollisionProbe(engine), + FovY = MathF.PI / 3f, Aspect = 16f / 9f, + }; + for (int i = 0; i < 300; i++) + cam.Update(playerPos, yaw, Vector3.Zero, true, Vector3.UnitZ, 1f / 60f, pcell, 0x5000000A); + + var eye = cam.Position; + uint viewer = cam.ViewerCellId; + // D from the eye to 015F's ceiling-portal plane (only meaningful if viewer==015F). + float dCeil = PortalPlaneDistance(root015F, upIdx, eye); + _out.WriteLine(FormattableString.Invariant( + $"playerZ={pz,5:F1} face={fLabel,-8} pcell=0x{pcell & 0xFFFF:X4} eye=({eye.X,6:F2},{eye.Y,6:F2},{eye.Z,6:F2}) viewer=0x{viewer & 0xFFFF:X4} D->ceilPortal={dCeil,6:F3}")); + } + } + finally { CameraDiagnostics.CollideCamera = sC; CameraDiagnostics.AlignToSlope = sA; } + } + + [Theory] + // spot label, player x, player cell, description + [InlineData(90.0f, 0x0178u, "TOP corridor 0178 (approach view)")] + [InlineData(100.0f, 0x0183u, "BOTTOM room 0183 (look-back view)")] + public void ParkedYawZoomSweep_StairAdmission(float px, uint pcell, string label) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var renderCells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + var engine = BuildHubEngine(dats); + Func lookup = id => renderCells.TryGetValue(id, out var c) ? c : null; + + bool sC = CameraDiagnostics.CollideCamera; bool sA = CameraDiagnostics.AlignToSlope; + float sT = CameraDiagnostics.TranslationStiffness, sR = CameraDiagnostics.RotationStiffness; + try + { + CameraDiagnostics.CollideCamera = true; CameraDiagnostics.AlignToSlope = true; + CameraDiagnostics.TranslationStiffness = 0.45f; CameraDiagnostics.RotationStiffness = 0.45f; + + var playerPos = new Vector3(px, -40f, FloorZ(px)); + uint playerCell = FacilityHub | pcell; + _out.WriteLine($"=== {label} @ ({px:F1},-40,{FloorZ(px):F2}) ==="); + foreach (float dist in new[] { 2.61f, 8.0f }) + { + _out.WriteLine($" -- zoom Distance={dist} --"); + var cam = new RetailChaseCamera + { + CollisionProbe = new PhysicsCameraCollisionProbe(engine), + FovY = MathF.PI / 3f, Aspect = 16f / 9f, Distance = dist, + }; + for (float yawDeg = 0f; yawDeg < 360f; yawDeg += 30f) + { + float yaw = yawDeg * MathF.PI / 180f; + // Settle at this yaw (static player). + for (int i = 0; i < 200; i++) + cam.Update(playerPos, yaw, Vector3.Zero, true, Vector3.UnitZ, 1f / 60f, playerCell, 0x5000000A); + Vector3 eye = cam.Position; uint viewer = cam.ViewerCellId; + var vp = cam.View * cam.Projection; + if (viewer != 0u && renderCells.TryGetValue(viewer, out var rootCell)) + { + var f = PortalVisibilityBuilder.Build(rootCell, eye, lookup, vp, null, PortalVisibilityBuilder.ShellDrawLiftZ); + var vis = f.OrderedVisibleCells.OrderBy(v => v).ToList(); + string flags = $"0178={(vis.Contains(FacilityHub | 0x0178u) ? "Y" : "-")} 0182={(vis.Contains(FacilityHub | 0x0182u) ? "Y" : "-")} 0183={(vis.Contains(FacilityHub | 0x0183u) ? "Y" : "-")} 0181={(vis.Contains(FacilityHub | 0x0181u) ? "Y" : "-")}"; + _out.WriteLine(FormattableString.Invariant( + $" yaw={yawDeg,3:F0} eye=({eye.X,6:F2},{eye.Y,6:F2},{eye.Z,6:F2}) viewer=0x{viewer & 0xFFFF:X4} {flags} flood={vis.Count} [{CellSet(vis)}]")); + } + else + _out.WriteLine(FormattableString.Invariant($" yaw={yawDeg,3:F0} eye=({eye.X,6:F2},{eye.Y,6:F2},{eye.Z,6:F2}) viewer=0x{viewer:X8} ROOT-MISSING")); + } + } + } + finally + { + CameraDiagnostics.CollideCamera = sC; CameraDiagnostics.AlignToSlope = sA; + CameraDiagnostics.TranslationStiffness = sT; CameraDiagnostics.RotationStiffness = sR; + } + } + + [Fact] + public void Descent_RealCameraSweep_StairCellRetention() + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var renderCells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + var engine = BuildHubEngine(dats); + Func lookup = id => renderCells.TryGetValue(id, out var c) ? c : null; + + bool savedColl = CameraDiagnostics.CollideCamera; + bool savedAlign = CameraDiagnostics.AlignToSlope; + float savedT = CameraDiagnostics.TranslationStiffness; + float savedR = CameraDiagnostics.RotationStiffness; + try + { + CameraDiagnostics.CollideCamera = true; + CameraDiagnostics.AlignToSlope = true; + CameraDiagnostics.TranslationStiffness = 0.45f; + CameraDiagnostics.RotationStiffness = 0.45f; + + var cam = new RetailChaseCamera + { + CollisionProbe = new PhysicsCameraCollisionProbe(engine), + FovY = MathF.PI / 3f, + Aspect = 16f / 9f, + }; + + const float yaw = 0f; // facing +X, descending + const float speed = 3.0f; // m/s run + const float dt = 1f / 60f; + float startX = 88f, endX = 101.5f; + + // Seat the player + settle the camera at the start pose. + uint playerCell = FacilityHub | 0x0178u; + Vector3 P(float x) => new Vector3(x, -40f, FloorZ(x)); + for (int i = 0; i < 400; i++) + cam.Update(P(startX), yaw, Vector3.Zero, true, Vector3.UnitZ, dt, playerCell, 0x5000000A); + + _out.WriteLine("x playerCell eye=(x,y,z) viewerCell coh flood stairs rootPortalsPastPlane"); + float x = startX; + uint prevViewer = cam.ViewerCellId; + int collapses = 0, incoherentFrames = 0; + while (x <= endX) + { + var playerPos = P(x); + // Track player membership like production: AdjustPosition carry-forward. + var (pc, found) = engine.AdjustPosition(playerCell, playerPos + new Vector3(0, 0, 0.1f)); + if (found) playerCell = pc; + + cam.Update(playerPos, yaw, new Vector3(speed, 0, 0), true, Vector3.UnitZ, dt, playerCell, 0x5000000A); + + Vector3 eye = cam.Position; + uint viewer = cam.ViewerCellId; + var viewProj = cam.View * cam.Projection; + + string floodStr, stairs, coh, past; + if (viewer != 0u && renderCells.TryGetValue(viewer, out var rootCell)) + { + var frame = PortalVisibilityBuilder.Build( + rootCell, eye, lookup, viewProj, + buildingMembership: null, drawLiftZ: PortalVisibilityBuilder.ShellDrawLiftZ); + var vis = frame.OrderedVisibleCells.OrderBy(v => v).ToList(); + floodStr = $"{vis.Count,2} [{CellSet(vis)}]"; + bool ramp = vis.Contains(FacilityHub | 0x0182u); + bool lower = vis.Contains(FacilityHub | 0x0183u); + stairs = $"r{(ramp ? "Y" : "-")}l{(lower ? "Y" : "-")}"; + + // Coherence: is the eye on the interior side of ALL of root's portals? + // If not, the eye is outside root -> the crossed portal's subtree drops. + var pastList = new List(); + bool coherent = true; + for (int i = 0; i < rootCell.Portals.Count && i < rootCell.ClipPlanes.Count; i++) + { + if (!EyeInteriorSide(rootCell, i, eye)) + { + coherent = false; + pastList.Add($"p{i}->0x{rootCell.Portals[i].OtherCellId:X4}(D={SideD(rootCell, i, eye):F3})"); + } + } + coh = coherent ? "IN " : "OUT"; + past = pastList.Count == 0 ? "-" : string.Join(",", pastList); + if (!coherent) incoherentFrames++; + if (vis.Count <= 1) collapses++; + } + else + { + floodStr = "root-missing/0"; stairs = "--"; coh = "?"; past = $"viewer=0x{viewer:X8}"; + } + + bool viewerFlip = viewer != prevViewer; + prevViewer = viewer; + _out.WriteLine(FormattableString.Invariant( + $"{x,6:F2} 0x{playerCell:X8} ({eye.X,7:F3},{eye.Y,7:F3},{eye.Z,7:F3}) 0x{viewer:X8} {coh} {floodStr} {stairs} {(viewerFlip ? "FLIP " : "")}{past}")); + + x += speed * dt; + } + _out.WriteLine($"SUMMARY: collapses(flood<=1)={collapses} incoherentFrames(eye-outside-root)={incoherentFrames}"); + } + finally + { + CameraDiagnostics.CollideCamera = savedColl; + CameraDiagnostics.AlignToSlope = savedAlign; + CameraDiagnostics.TranslationStiffness = savedT; + CameraDiagnostics.RotationStiffness = savedR; + } + } +} diff --git a/tests/AcDream.App.Tests/Rendering/Issue181CameraParkStabilityTests.cs b/tests/AcDream.App.Tests/Rendering/Issue181CameraParkStabilityTests.cs new file mode 100644 index 00000000..3e2950db --- /dev/null +++ b/tests/AcDream.App.Tests/Rendering/Issue181CameraParkStabilityTests.cs @@ -0,0 +1,100 @@ +using System; +using System.Numerics; +using AcDream.App.Rendering; +using AcDream.Core.Rendering; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.App.Tests.Rendering; + +/// +/// #181 excitation probe — the live parked camera wanders ~0.9 mm/frame +/// (launch-176-leakfix.log [flap-sweep]: 19,889 distinct sought values in 20k +/// parked sweeps), which keeps the portal flood's knife-edge admissions +/// flapping. Retail's parked viewer is a bit-exact fixed point (UpdateCamera +/// dead-band `return viewer`). +/// +/// This test drives RetailChaseCamera.Update with BIT-IDENTICAL inputs at the +/// live frame rate: if the camera parks bit-stable here, the live wobble comes +/// from its INPUTS (player position/yaw jitter out of GameWindow); if it +/// wobbles here, the camera loop itself fails to reach the fixed point. +/// +public class Issue181CameraParkStabilityTests +{ + private readonly ITestOutputHelper _out; + public Issue181CameraParkStabilityTests(ITestOutputHelper output) => _out = output; + + private sealed class PassthroughProbe : ICameraCollisionProbe + { + public CameraSweepResult SweepEye(Vector3 pivot, Vector3 desiredEye, uint cellId, uint selfEntityId, Vector3 playerPos) + => new(desiredEye, cellId); + } + + [Fact] + public void ParkedCamera_StaticInputs_ReachesBitStableFixedPoint() + { + bool savedAlign = CameraDiagnostics.AlignToSlope; + bool savedColl = CameraDiagnostics.CollideCamera; + float savedT = CameraDiagnostics.TranslationStiffness; + float savedR = CameraDiagnostics.RotationStiffness; + try + { + CameraDiagnostics.AlignToSlope = true; // production default + CameraDiagnostics.CollideCamera = true; + CameraDiagnostics.TranslationStiffness = 0.45f; + CameraDiagnostics.RotationStiffness = 0.45f; + + var cam = new RetailChaseCamera { CollisionProbe = new PassthroughProbe() }; + + // Live-like parked pose: static player, static yaw, zero velocity, + // grounded on a flat contact plane, ~1500 fps. + var playerPos = new Vector3(49.5f, -39.9f, -5.9f); + float yaw = 1.83f; + float dt = 1f / 1500f; + + void Step() => cam.Update( + playerPosition: playerPos, + playerYaw: yaw, + playerVelocity: Vector3.Zero, + isOnGround: true, + contactPlaneNormal: Vector3.UnitZ, + dt: dt, + cellId: 0x8A020142u, + selfEntityId: 0x5); + + // Converge: at α≈0.003/frame the boom needs a few thousand frames + // to settle from the init pose into the dead-band. + for (int i = 0; i < 20000; i++) Step(); + + Vector3 a = cam.Position; + var fwdA = cam.View; // full view matrix — includes the forward half + + // 2000 further frames with bit-identical inputs: every one must be + // the exact fixed point (retail parks verbatim). + float maxDelta = 0f; + Vector3 prev = a; + bool viewChanged = false; + for (int i = 0; i < 2000; i++) + { + Step(); + maxDelta = MathF.Max(maxDelta, Vector3.Distance(cam.Position, prev)); + prev = cam.Position; + if (cam.View != fwdA) viewChanged = true; + } + + _out.WriteLine(FormattableString.Invariant( + $"post-convergence maxConsecDelta={maxDelta * 1e6f:F2}um viewChanged={viewChanged} pos=({cam.Position.X:F7},{cam.Position.Y:F7},{cam.Position.Z:F7})")); + + Assert.True(maxDelta == 0f, + $"parked camera must be a bit-exact fixed point, wandered up to {maxDelta * 1e6f:F1}um/frame"); + Assert.False(viewChanged, "view matrix must be frozen at park"); + } + finally + { + CameraDiagnostics.AlignToSlope = savedAlign; + CameraDiagnostics.CollideCamera = savedColl; + CameraDiagnostics.TranslationStiffness = savedT; + CameraDiagnostics.RotationStiffness = savedR; + } + } +} diff --git a/tests/AcDream.App.Tests/Rendering/Issue181VisFlapReplayTests.cs b/tests/AcDream.App.Tests/Rendering/Issue181VisFlapReplayTests.cs new file mode 100644 index 00000000..d026eb4d --- /dev/null +++ b/tests/AcDream.App.Tests/Rendering/Issue181VisFlapReplayTests.cs @@ -0,0 +1,164 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using AcDream.App.Rendering; +using DatReaderWriter; +using DatReaderWriter.Options; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.App.Tests.Rendering; + +/// +/// #181 — the portal-flood admitted set flaps 31↔32 on MICRON eye noise at a +/// parked camera (live: launch-176-leakfix.log, root 0x8A020142, vis flips +/// every ~100–200 frames for 517k frames; the swept eye carries ~7 µm +/// float-roundtrip noise). The flapping cell's visibility-scoped lights + the +/// union-AABB scissor rect strobe = the #176 washed-region flicker. +/// +/// This replay hunts the knife edge headlessly: at the live parked eye +/// (49.15, −38.62, −3.98), sweep gazes and perturb the eye by ±0.5 mm per +/// axis; ANY admitted-set difference at sub-mm perturbation is the #181 +/// instability, and the symmetric difference names the flapping cell. +/// +public class Issue181VisFlapReplayTests +{ + private const uint FacilityHub = 0x8A020000u; + private const uint LiveRoot = FacilityHub | 0x0142u; + + private static readonly Vector3 LiveEye = new(49.15f, -38.62f, -3.98f); + + private readonly ITestOutputHelper _out; + public Issue181VisFlapReplayTests(ITestOutputHelper output) => _out = output; + + private static Matrix4x4 ViewProjFor(Vector3 eye, Vector3 gazeDir) + { + var view = Matrix4x4.CreateLookAt(eye, eye + gazeDir, Vector3.UnitZ); + var proj = Matrix4x4.CreatePerspectiveFieldOfView(MathF.PI / 3f, 16f / 9f, 0.1f, 5000f); + return view * proj; + } + + private static List Flood( + Dictionary cells, uint rootId, Vector3 eye, Vector3 gazeDir) + { + Func lookup = id => cells.TryGetValue(id, out var c) ? c : null; + var frame = PortalVisibilityBuilder.Build( + cells[rootId], eye, lookup, ViewProjFor(eye, gazeDir), + buildingMembership: null, + drawLiftZ: PortalVisibilityBuilder.ShellDrawLiftZ); + var result = new List(frame.OrderedVisibleCells); + result.Sort(); + return result; + } + + private static string CellSetString(IEnumerable ids) + => string.Join(" ", ids.Select(id => $"{id & 0xFFFFu:X4}")); + + [Fact] + public void Diagnostic_FlappingCellViewRegion_SliverOrLarge() + { + var datDir = CornerFloodReplayTests.ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var cells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + uint flapper = FacilityHub | 0x0181u; + + // The most unstable pose from the perturbation sweep. + float yaw = 15f * MathF.PI / 180f, pitch = -20f * MathF.PI / 180f; + var gaze = new Vector3( + MathF.Cos(pitch) * MathF.Cos(yaw), + MathF.Cos(pitch) * MathF.Sin(yaw), + MathF.Sin(pitch)); + + Func lookup = id => cells.TryGetValue(id, out var c) ? c : null; + + foreach (var (label, eye) in new (string, Vector3)[] + { + ("base ", LiveEye), + ("+0.5mm x ", LiveEye + new Vector3(0.0005f, 0, 0)), + ("-0.5mm x ", LiveEye - new Vector3(0.0005f, 0, 0)), + ("+5mm x ", LiveEye + new Vector3(0.005f, 0, 0)), + ("-5mm x ", LiveEye - new Vector3(0.005f, 0, 0)), + ("+2cm z ", LiveEye + new Vector3(0, 0, 0.02f)), + ("-2cm z ", LiveEye - new Vector3(0, 0, 0.02f)), + }) + { + var frame = PortalVisibilityBuilder.Build( + cells[LiveRoot], eye, lookup, ViewProjFor(eye, gaze), + buildingMembership: null, + drawLiftZ: PortalVisibilityBuilder.ShellDrawLiftZ); + + if (!frame.CellViews.TryGetValue(flapper, out var view) || view.IsEmpty) + { + _out.WriteLine($"{label}: 0181 NOT ADMITTED"); + continue; + } + + // NDC shoelace area of the admitted region (screen is 4.0 NDC-units total). + float area = 0f; int polys = 0, verts = 0; + foreach (var vp in view.Polygons) + { + var v = vp.Vertices; + polys++; verts += v.Length; + float a = 0f; + for (int i = 0; i < v.Length; i++) + { + var p = v[i]; var q = v[(i + 1) % v.Length]; + a += p.X * q.Y - q.X * p.Y; + } + area += MathF.Abs(a) * 0.5f; + } + _out.WriteLine(FormattableString.Invariant( + $"{label}: 0181 admitted polys={polys} verts={verts} ndcArea={area:F4} ({area / 4f * 100f:F1}% of screen)")); + } + } + + [Fact] + public void Diagnostic_SubMillimeterEyePerturbation_MustNotChangeAdmission() + { + var datDir = CornerFloodReplayTests.ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var cells = Issue120ReciprocalPingPongTests.LoadAllInteriorCells(dats, FacilityHub); + Assert.True(cells.ContainsKey(LiveRoot), "live root 0x0142 not loaded"); + + // ±0.5 mm per axis — an order of magnitude above the live µm noise, well + // below anything visually meaningful. + var perturbations = new[] + { + new Vector3( 0.0005f, 0, 0), new Vector3(-0.0005f, 0, 0), + new Vector3(0, 0.0005f, 0), new Vector3(0, -0.0005f, 0), + new Vector3(0, 0, 0.0005f), new Vector3(0, 0, -0.0005f), + }; + + int unstableGazes = 0; + for (int yawDeg = 0; yawDeg < 360; yawDeg += 15) + { + foreach (float pitchDeg in new[] { 0f, -20f, -35f }) + { + float yaw = yawDeg * MathF.PI / 180f, pitch = pitchDeg * MathF.PI / 180f; + var gaze = new Vector3( + MathF.Cos(pitch) * MathF.Cos(yaw), + MathF.Cos(pitch) * MathF.Sin(yaw), + MathF.Sin(pitch)); + + var baseline = Flood(cells, LiveRoot, LiveEye, gaze); + foreach (var d in perturbations) + { + var perturbed = Flood(cells, LiveRoot, LiveEye + d, gaze); + if (perturbed.SequenceEqual(baseline)) continue; + + unstableGazes++; + var removed = baseline.Except(perturbed).ToList(); + var added = perturbed.Except(baseline).ToList(); + _out.WriteLine(FormattableString.Invariant( + $"UNSTABLE yaw={yawDeg} pitch={pitchDeg} d=({d.X * 1000:F1},{d.Y * 1000:F1},{d.Z * 1000:F1})mm base={baseline.Count} pert={perturbed.Count} removed=[{CellSetString(removed)}] added=[{CellSetString(added)}]")); + } + } + } + + _out.WriteLine($"unstable (gaze, perturbation) pairs: {unstableGazes}"); + // Diagnostic first: report, don't assert — the fix turns this into a hard pin. + } +} diff --git a/tests/AcDream.App.Tests/Rendering/Issue181WallPressEquilibriumTests.cs b/tests/AcDream.App.Tests/Rendering/Issue181WallPressEquilibriumTests.cs new file mode 100644 index 00000000..bd57825b --- /dev/null +++ b/tests/AcDream.App.Tests/Rendering/Issue181WallPressEquilibriumTests.cs @@ -0,0 +1,188 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Numerics; +using AcDream.App.Rendering; +using AcDream.Core.Physics; +using AcDream.Core.Rendering; +using DatReaderWriter; +using DatReaderWriter.Options; +using DatEnvCell = DatReaderWriter.DBObjs.EnvCell; +using DatEnvironment = DatReaderWriter.DBObjs.Environment; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.App.Tests.Rendering; + +/// +/// #181 excitation, isolated headlessly — the WALL-PRESS equilibrium. Live +/// evidence: a camera pressed into corridor walls/openings never reaches a +/// fixed point (sought steps α·gap into the wall per frame; the sweep clips it +/// back within adjust_to_plane's parametric 0.02 window) → the published eye +/// wanders ~1 mm/frame, and when the wander straddles a cell boundary the +/// VIEWER CELL flaps (launch-181-pressed.log: viewer≠player on 85.5% of +/// frames, one-frame A→B→A root flips) — each flip re-roots the whole +/// visibility frame (the #176/#181 flicker). +/// +/// This test runs the REAL RetailChaseCamera + the REAL +/// PhysicsCameraCollisionProbe against the REAL Facility Hub BSP with a +/// static player backed against the corridor wall, and measures the +/// steady-state eye wander + ViewerCellId stability over 20k frames. +/// Diagnostic (reporting) first; the equilibrium fix turns the wander/flap +/// numbers into hard pins. +/// +public class Issue181WallPressEquilibriumTests +{ + private const uint FacilityHubLandblock = 0x8A020000u; + + private readonly ITestOutputHelper _out; + public Issue181WallPressEquilibriumTests(ITestOutputHelper output) => _out = output; + + // Mirrors AcDream.Core.Tests Conformance.ConformanceDats (not referencable + // from App.Tests): resolve the dat dir + load real EnvCells into the cache. + private static string? ResolveDatDir() + { + var fromEnv = Environment.GetEnvironmentVariable("ACDREAM_DAT_DIR"); + if (!string.IsNullOrWhiteSpace(fromEnv) && Directory.Exists(fromEnv)) return fromEnv; + var def = Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + return Directory.Exists(def) ? def : null; + } + + private static (PhysicsEngine, PhysicsDataCache) BuildCorridorEngine(DatCollection dats) + { + var cache = new PhysicsDataCache(); + var engine = new PhysicsEngine { DataCache = cache }; + for (uint low = 0x0100u; low <= 0x01FFu; low++) + { + uint id = FacilityHubLandblock | low; + var datCell = dats.Get(id); + if (datCell is null) continue; + var environment = dats.Get(0x0D000000u | datCell.EnvironmentId); + if (environment is null) continue; + if (!environment.Cells.TryGetValue(datCell.CellStructure, out var cellStruct) || cellStruct is null) + continue; + var world = Matrix4x4.CreateFromQuaternion(datCell.Position.Orientation) * + Matrix4x4.CreateTranslation(datCell.Position.Origin); + cache.CacheCellStruct(id, datCell, cellStruct, world); + } + var heights = new byte[81]; + var heightTable = new float[256]; + for (int i = 0; i < 256; i++) heightTable[i] = -1000f; + engine.AddLandblock(FacilityHubLandblock, new TerrainSurface(heights, heightTable), + Array.Empty(), Array.Empty(), 0f, 0f); + return (engine, cache); + } + + [Fact] + public void Diagnostic_WallPressedCamera_EyeWanderAndViewerCellStability() + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: dats unavailable"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var (engine, _) = BuildCorridorEngine(dats); + + bool savedAlign = CameraDiagnostics.AlignToSlope; + bool savedColl = CameraDiagnostics.CollideCamera; + float savedT = CameraDiagnostics.TranslationStiffness; + float savedR = CameraDiagnostics.RotationStiffness; + try + { + CameraDiagnostics.AlignToSlope = true; + CameraDiagnostics.CollideCamera = true; + CameraDiagnostics.TranslationStiffness = 0.45f; + CameraDiagnostics.RotationStiffness = 0.45f; + + // The live parked spot from the leak-fix log: player at the corridor + // spawn (cell 0x0142), backed near the +Y wall so the full boom is + // blocked (live [resolve]: hit=yes n=(0,-1,0) every frame). + var playerPos = new Vector3(50.331f, -39.357f, -5.90f); + // Live [resolve]: the sweep target headed (-2.13,+1.32,+0.75) from the + // pivot and hit the n=(0,-1,0) wall — so the player faces (+X,-Y)-ish + // and the boom presses -X+Y into that wall. yaw = atan2(-0.53, 0.85). + float yaw = -0.556f; + uint cellId = 0x8A020142u; + float dt = 1f / 1500f; + + var cam = new RetailChaseCamera + { + CollisionProbe = new PhysicsCameraCollisionProbe(engine), + }; + + void Step() => cam.Update( + playerPosition: playerPos, + playerYaw: yaw, + playerVelocity: Vector3.Zero, + isOnGround: true, + contactPlaneNormal: Vector3.UnitZ, + dt: dt, + cellId: cellId, + selfEntityId: 0x5); + + // Settle into the wall-press equilibrium. + for (int i = 0; i < 5000; i++) Step(); + + // Measure 20k steady-state frames. + var eyes = new List(20000); + var cells = new HashSet(); + int cellTransitions = 0; + uint prevCell = cam.ViewerCellId; + Vector3 prevEye = cam.Position; + float maxStep = 0f; double sumStep = 0; + for (int i = 0; i < 20000; i++) + { + Step(); + float d = Vector3.Distance(cam.Position, prevEye); + maxStep = MathF.Max(maxStep, d); + sumStep += d; + prevEye = cam.Position; + eyes.Add(cam.Position); + cells.Add(cam.ViewerCellId); + if (cam.ViewerCellId != prevCell) { cellTransitions++; prevCell = cam.ViewerCellId; } + } + + // Wander bounding box. + Vector3 mn = eyes[0], mx = eyes[0]; + foreach (var e in eyes) { mn = Vector3.Min(mn, e); mx = Vector3.Max(mx, e); } + var span = mx - mn; + + _out.WriteLine(FormattableString.Invariant( + $"steady-state: avgStep={sumStep / 20000 * 1e6:F1}um maxStep={maxStep * 1e6:F1}um wanderBox=({span.X * 1000:F2},{span.Y * 1000:F2},{span.Z * 1000:F2})mm")); + _out.WriteLine(FormattableString.Invariant( + $"viewer cells seen: {cells.Count} transitions={cellTransitions} eye=({cam.Position.X:F6},{cam.Position.Y:F6},{cam.Position.Z:F6}) cell=0x{cam.ViewerCellId:X8}")); + + // Orbit structure: 16 consecutive frames at 6dp, with the sweep's + // own [flap-sweep] lines captured for the same frames. + bool savedFlap = RenderingDiagnostics.ProbeFlapEnabled; + var savedOut = Console.Out; + try + { + RenderingDiagnostics.ProbeFlapEnabled = true; + using var writer = new StringWriter(); + Console.SetOut(writer); + for (int i = 0; i < 16; i++) + { + Step(); + writer.WriteLine(FormattableString.Invariant( + $"orbit[{i:D2}] eye=({cam.Position.X:F6},{cam.Position.Y:F6},{cam.Position.Z:F6})")); + } + Console.SetOut(savedOut); + foreach (var line in writer.ToString().Split('\n')) + if (line.Length > 1) _out.WriteLine(line.TrimEnd()); + } + finally + { + Console.SetOut(savedOut); + RenderingDiagnostics.ProbeFlapEnabled = savedFlap; + } + } + finally + { + CameraDiagnostics.AlignToSlope = savedAlign; + CameraDiagnostics.CollideCamera = savedColl; + CameraDiagnostics.TranslationStiffness = savedT; + CameraDiagnostics.RotationStiffness = savedR; + } + } +} diff --git a/tests/AcDream.App.Tests/Rendering/RetailChaseCameraTests.cs b/tests/AcDream.App.Tests/Rendering/RetailChaseCameraTests.cs index d4e60347..db57c369 100644 --- a/tests/AcDream.App.Tests/Rendering/RetailChaseCameraTests.cs +++ b/tests/AcDream.App.Tests/Rendering/RetailChaseCameraTests.cs @@ -579,31 +579,233 @@ public class RetailChaseCameraTests } [Fact] - public void Update_CollisionDoesNotCorruptDampedState() + public void Update_AfterClampReleases_EyeReExtendsGradually() { - // Regression for the wall-press vibration: the sweep must NOT write its - // clamped result back into the damped "sought" eye (retail keeps - // viewer_sought_position separate from viewer). Frame 1 clamps the eye - // near the pivot; frame 2 releases. With the damp state kept clean, the - // published eye returns straight to the (constant) target on frame 2; if - // it were corrupted, frame 2 would only lerp ~7.5% back from the clamp - // and stay pinned near it. - CameraDiagnostics.CollideCamera = true; - var probe = new ClampThenReleaseProbe { ClampEye = new Vector3(0f, 0f, 2f) }; - var cam = new RetailChaseCamera { CollisionProbe = probe }; + // #180: retail's sought position is STATEFUL — CameraManager::UpdateCamera + // (0x00456660) interpolates from the CURRENT SWEPT VIEWER toward the desired + // pose, so after an obstruction clears the eye re-extends at the stiffness + // rate (τ ≈ 0.22 s), NOT in one jump. (The previous pin here asserted the + // instant full re-extension — the exact divergence that re-rolled the + // full-length knife-edge boom ray per frame and produced the strobe.) + bool savedColl = CameraDiagnostics.CollideCamera; + float savedT = CameraDiagnostics.TranslationStiffness; + float savedR = CameraDiagnostics.RotationStiffness; + try + { + CameraDiagnostics.CollideCamera = true; + CameraDiagnostics.TranslationStiffness = 0.45f; + CameraDiagnostics.RotationStiffness = 0.45f; - void Step() => cam.Update( - playerPosition: Vector3.Zero, playerYaw: 0f, playerVelocity: Vector3.Zero, - isOnGround: true, contactPlaneNormal: Vector3.UnitZ, dt: 1f / 60f, - cellId: 0x100, selfEntityId: 0x5); + var probe = new ClampThenReleaseProbe { ClampEye = new Vector3(0f, 0f, 2f) }; + var cam = new RetailChaseCamera { CollisionProbe = probe }; - Step(); // frame 1: clamps to (0,0,2) - Step(); // frame 2: releases + void Step() => cam.Update( + playerPosition: Vector3.Zero, playerYaw: 0f, playerVelocity: Vector3.Zero, + isOnGround: true, contactPlaneNormal: Vector3.UnitZ, dt: 1f / 60f, + cellId: 0x100, selfEntityId: 0x5); - // Constant pose → target eye ≈ (-2.5, 0, 2.25). Full recovery means - // Position.X is near the target (< -2), not pinned near the clamp (X≈0). - Assert.True(cam.Position.X < -2f, - $"published eye should fully recover to the target after release, got {cam.Position}"); + Step(); // frame 1: clamps to (0,0,2) — the viewer sits at the clamp + Step(); // frame 2: releases + + // Constant pose → target eye ≈ (-2.5, 0, 2.25). Frame 2's eye is one + // 7.5% lerp step off the clamp (X ≈ -0.19) — near the clamp, NOT the + // full target. + Assert.True(cam.Position.X > -0.5f, + $"eye must re-extend gradually from the contact, got {cam.Position}"); + + // ...and converges onto the target over the following seconds. + for (int i = 0; i < 200; i++) Step(); + Assert.True(cam.Position.X < -2.4f, + $"eye should converge to the target after release, got {cam.Position}"); + } + finally + { + CameraDiagnostics.CollideCamera = savedColl; + CameraDiagnostics.TranslationStiffness = savedT; + CameraDiagnostics.RotationStiffness = savedR; + } + } + + // Probe that records every requested sweep target and clamps the eye to a + // fixed contact point (a wall the boom is pressed into). + private sealed class RecordingClampProbe : ICameraCollisionProbe + { + public readonly System.Collections.Generic.List Requests = new(); + public Vector3 ClampEye; + public CameraSweepResult SweepEye(Vector3 pivot, Vector3 desiredEye, uint cellId, uint selfEntityId, Vector3 playerPos) + { + Requests.Add(desiredEye); + return new CameraSweepResult(ClampEye, cellId); + } + } + + [Fact] + public void Update_SweepTargetConvergesOntoContact_NotTheFullBoom() + { + // THE #180 structural pin. Retail sweeps pivot → viewer_sought_position + // (SmartBox::update_viewer 0x00453ce0), and the sought derives from the + // swept viewer — so while pressed against a wall the requested sweep + // target sits ONE interpolation step past the contact. acdream's old shape + // re-requested the full-length ideal boom every frame; with mm input drift + // that full ray grazed distant geometry at r±ε and flipped its first-contact + // solution 0.27 m along the boom every few frames (the #176 stripes). + bool savedColl = CameraDiagnostics.CollideCamera; + float savedT = CameraDiagnostics.TranslationStiffness; + float savedR = CameraDiagnostics.RotationStiffness; + try + { + CameraDiagnostics.CollideCamera = true; + CameraDiagnostics.TranslationStiffness = 0.45f; + CameraDiagnostics.RotationStiffness = 0.45f; + + var wall = new Vector3(0f, 0f, 2f); + var probe = new RecordingClampProbe { ClampEye = wall }; + var cam = new RetailChaseCamera { CollisionProbe = probe }; + + void Step() => cam.Update( + playerPosition: Vector3.Zero, playerYaw: 0f, playerVelocity: Vector3.Zero, + isOnGround: true, contactPlaneNormal: Vector3.UnitZ, dt: 1f / 60f, + cellId: 0x100, selfEntityId: 0x5); + + Step(); // frame 1: init requests the full boom (AD-38), eye clamps to the wall + Step(); // frame 2: the request must now derive from the CLAMPED viewer + + // Frame 1 documents the contrast: the init request is the full-length + // target, ~2.5 m from the contact. + Assert.True(Vector3.Distance(probe.Requests[0], wall) > 2f, + $"frame-1 init request should be the full boom, got {probe.Requests[0]}"); + + // Frame 2's request = one 7.5% lerp step off the wall (~0.19 m) — the + // knife-edge full-length ray is never re-rolled. + float reach = Vector3.Distance(probe.Requests[1], wall); + Assert.True(reach < 0.3f, + $"frame-2 sweep target must sit one step past the contact, got {reach:F3} m past it"); + } + finally + { + CameraDiagnostics.CollideCamera = savedColl; + CameraDiagnostics.TranslationStiffness = savedT; + CameraDiagnostics.RotationStiffness = savedR; + } + } + + // Probe that fails entirely on the FIRST call (retail set_viewer(player_pos, 1): + // eye = player, viewer_cell = 0), then releases; records requests. + private sealed class FallbackThenReleaseProbe : ICameraCollisionProbe + { + public readonly System.Collections.Generic.List Requests = new(); + public int Calls; + public CameraSweepResult SweepEye(Vector3 pivot, Vector3 desiredEye, uint cellId, uint selfEntityId, Vector3 playerPos) + { + Calls++; + Requests.Add(desiredEye); + return Calls == 1 + ? new CameraSweepResult(playerPos, 0u) // total fallback (pc:92886) + : new CameraSweepResult(desiredEye, cellId); + } + } + + [Fact] + public void Update_TotalFallback_ReExtendsFromThePlayer() + { + // After the total sweep failure retail resets viewer AND sought to the + // player's position (set_viewer(player_pos, reset_sought=1)) — the camera + // re-extends outward from the head, so the next sweep target is NEAR THE + // PLAYER, not the full-length boom. + bool savedColl = CameraDiagnostics.CollideCamera; + float savedT = CameraDiagnostics.TranslationStiffness; + float savedR = CameraDiagnostics.RotationStiffness; + try + { + CameraDiagnostics.CollideCamera = true; + CameraDiagnostics.TranslationStiffness = 0.45f; + CameraDiagnostics.RotationStiffness = 0.45f; + + var probe = new FallbackThenReleaseProbe(); + var cam = new RetailChaseCamera { CollisionProbe = probe }; + + void Step() => cam.Update( + playerPosition: Vector3.Zero, playerYaw: 0f, playerVelocity: Vector3.Zero, + isOnGround: true, contactPlaneNormal: Vector3.UnitZ, dt: 1f / 60f, + cellId: 0x100, selfEntityId: 0x5); + + Step(); // frame 1: total fallback — viewer snaps to the player, cell 0 + Assert.Equal(Vector3.Zero, cam.Position); + Assert.Equal(0u, cam.ViewerCellId); + + Step(); // frame 2: the sweep target re-extends FROM the player + float reach = Vector3.Distance(probe.Requests[1], Vector3.Zero); + Assert.True(reach < 0.3f, + $"post-fallback sweep target must re-extend from the player, got {reach:F3} m out"); + } + finally + { + CameraDiagnostics.CollideCamera = savedColl; + CameraDiagnostics.TranslationStiffness = savedT; + CameraDiagnostics.RotationStiffness = savedR; + } + } + + // First-contact model of an infinite wall plane at X = WallX: requests whose + // ray from the pivot crosses the plane stop AT the plane; others pass through. + private sealed class WallPlaneProbe : ICameraCollisionProbe + { + public float WallX = -1f; + public CameraSweepResult SweepEye(Vector3 pivot, Vector3 desiredEye, uint cellId, uint selfEntityId, Vector3 playerPos) + { + if (desiredEye.X >= WallX || desiredEye.X - pivot.X >= -1e-6f) + return new CameraSweepResult(desiredEye, cellId); + float t = (WallX - pivot.X) / (desiredEye.X - pivot.X); + return new CameraSweepResult(pivot + (desiredEye - pivot) * t, cellId); + } + } + + [Fact] + public void Update_PressedAgainstWall_EyeGlidesStably() + { + // The wall-press equilibrium: the sought parks one step past the contact, + // the sweep clips it back, and the published eye stays glued to the wall + // with no oscillation — retail's glide. (This was the fear behind the old + // "must not feed back" comment; the retail shape is stable by construction + // because the sweep target converges instead of fighting the full boom.) + bool savedColl = CameraDiagnostics.CollideCamera; + float savedT = CameraDiagnostics.TranslationStiffness; + float savedR = CameraDiagnostics.RotationStiffness; + try + { + CameraDiagnostics.CollideCamera = true; + CameraDiagnostics.TranslationStiffness = 0.45f; + CameraDiagnostics.RotationStiffness = 0.45f; + + var cam = new RetailChaseCamera { CollisionProbe = new WallPlaneProbe { WallX = -1f } }; + + void Step() => cam.Update( + playerPosition: Vector3.Zero, playerYaw: 0f, playerVelocity: Vector3.Zero, + isOnGround: true, contactPlaneNormal: Vector3.UnitZ, dt: 1f / 60f, + cellId: 0x100, selfEntityId: 0x5); + + // Settle a few frames, then watch 30 frames for per-frame jumps. + for (int i = 0; i < 5; i++) Step(); + Vector3 prev = cam.Position; + float maxDelta = 0f; + for (int i = 0; i < 30; i++) + { + Step(); + maxDelta = MathF.Max(maxDelta, Vector3.Distance(cam.Position, prev)); + prev = cam.Position; + } + + Assert.True(MathF.Abs(cam.Position.X - (-1f)) < 1e-3f, + $"eye should sit on the wall plane, got {cam.Position}"); + Assert.True(maxDelta < 1e-3f, + $"pressed against a wall the eye must not jump frame-to-frame, max delta {maxDelta:F5} m"); + } + finally + { + CameraDiagnostics.CollideCamera = savedColl; + CameraDiagnostics.TranslationStiffness = savedT; + CameraDiagnostics.RotationStiffness = savedR; + } } // ── Convergence snap (Part 1: kills the at-rest boom drift) ──────── diff --git a/tests/AcDream.Bake.Tests/AcDream.Bake.Tests.csproj b/tests/AcDream.Bake.Tests/AcDream.Bake.Tests.csproj new file mode 100644 index 00000000..d67af0e8 --- /dev/null +++ b/tests/AcDream.Bake.Tests/AcDream.Bake.Tests.csproj @@ -0,0 +1,29 @@ + + + + net10.0 + enable + enable + false + latest + true + + + + + + + + + + + + + + + + + + + diff --git a/tests/AcDream.Bake.Tests/BakeDeterminismTests.cs b/tests/AcDream.Bake.Tests/BakeDeterminismTests.cs new file mode 100644 index 00000000..5902fd68 --- /dev/null +++ b/tests/AcDream.Bake.Tests/BakeDeterminismTests.cs @@ -0,0 +1,79 @@ +using System; +using System.Collections.Generic; +using System.IO; +using AcDream.Bake; + +namespace AcDream.Bake.Tests; + +/// +/// Dat-gated byte-reproducibility gate for the bake pipeline (review finding +/// 1): the plan's "bakes must be byte-reproducible run-to-run" is a whole- +/// FILE property, so it must be tested through the REAL BakeRunner — the +/// serializer-level determinism tests in Content.Tests can't see thread- +/// completion-order effects in the blob region. Skips cleanly when the dats +/// are absent (CI), same convention as +/// tests/AcDream.Core.Tests/Conformance/DatConcurrencyStressTests. +/// +public sealed class BakeDeterminismTests : IDisposable { + private readonly List _tempFiles = new(); + + private string NewTempPakPath() { + var path = Path.Combine(Path.GetTempPath(), $"acdream-baketest-{Guid.NewGuid():N}.pak"); + _tempFiles.Add(path); + return path; + } + + public void Dispose() { + foreach (var f in _tempFiles) { + try { if (File.Exists(f)) File.Delete(f); } catch { /* best effort cleanup */ } + } + } + + private static string? ResolveDatDir() { + // Mirrors ConformanceDats.ResolveDatDir (env var, then the well-known + // Documents fallback); duplicated because test projects can't + // reference each other's helpers. + var fromEnv = Environment.GetEnvironmentVariable("ACDREAM_DAT_DIR"); + if (!string.IsNullOrWhiteSpace(fromEnv) && Directory.Exists(fromEnv)) return fromEnv; + + var def = Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + return Directory.Exists(def) ? def : null; + } + + [Fact] + public void Bake_SameIdSet_DifferentThreadCounts_ByteIdenticalPaks() { + var datDir = ResolveDatDir(); + if (datDir is null) return; // dats absent (CI) — skip, matching suite convention + + // Small mixed fixture: GfxObjs (incl. the #119 tricky ids), Setups + // (door setup carries emitters -> exercises the side-staged preload + // path), and a Holtburg EnvCell. Big enough to span multiple asset + // types; small enough to run in seconds. + var ids = new HashSet { + 0x01000001u, 0x010002B4u, 0x010008A8u, 0x010014C3u, + 0x02000001u, 0x020019FFu, 0x020005D8u, + 0xA9B40100u, 0xA9B40101u, + }; + + var pathA = NewTempPakPath(); + var pathB = NewTempPakPath(); + + // DIFFERENT thread counts on purpose: thread-completion order was the + // nondeterminism source the sorted-batching fix removes — identical + // bytes must hold regardless of parallelism. + int rcA = BakeRunner.Run(new BakeOptions { DatDir = datDir, OutPath = pathA, IdFilter = ids, Threads = 8 }); + int rcB = BakeRunner.Run(new BakeOptions { DatDir = datDir, OutPath = pathB, IdFilter = ids, Threads = 3 }); + + Assert.Equal(0, rcA); + Assert.Equal(0, rcB); + + var bytesA = File.ReadAllBytes(pathA); + var bytesB = File.ReadAllBytes(pathB); + Assert.True(bytesA.Length == bytesB.Length, + $"pak sizes differ between runs: {bytesA.Length} vs {bytesB.Length} bytes"); + Assert.True(bytesA.AsSpan().SequenceEqual(bytesB), + "two bakes of the same id set produced different bytes — the sorted-batching determinism guarantee is broken"); + } +} diff --git a/tests/AcDream.Content.Tests/AcDream.Content.Tests.csproj b/tests/AcDream.Content.Tests/AcDream.Content.Tests.csproj new file mode 100644 index 00000000..dc64fa3c --- /dev/null +++ b/tests/AcDream.Content.Tests/AcDream.Content.Tests.csproj @@ -0,0 +1,28 @@ + + + + net10.0 + enable + enable + false + latest + true + + + + + + + + + + + + + + + + + + + diff --git a/tests/AcDream.Content.Tests/ContentConformanceDats.cs b/tests/AcDream.Content.Tests/ContentConformanceDats.cs new file mode 100644 index 00000000..c8ce4e21 --- /dev/null +++ b/tests/AcDream.Content.Tests/ContentConformanceDats.cs @@ -0,0 +1,38 @@ +using System; +using System.IO; +using Microsoft.Extensions.Logging; + +namespace AcDream.Content.Tests; + +/// +/// Dat-dir resolution for the Content.Tests dat-gated equivalence suite. +/// Mirrors the exact pattern used by +/// tests/AcDream.Core.Tests/Conformance/ConformanceDats.ResolveDatDir and +/// tests/AcDream.Core.Tests/Conformance/DatConcurrencyStressTests +/// ("dats absent (CI) -- skip, matching suite convention"). Content.Tests +/// cannot reference AcDream.Core.Tests (a test project, not a library), so +/// this is a deliberate small duplication of the resolution logic — not a +/// new convention. +/// +public static class ContentConformanceDats { + public static string? ResolveDatDir() { + var fromEnv = Environment.GetEnvironmentVariable("ACDREAM_DAT_DIR"); + if (!string.IsNullOrWhiteSpace(fromEnv) && Directory.Exists(fromEnv)) return fromEnv; + + var def = Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + return Directory.Exists(def) ? def : null; + } +} + +/// Minimal ILogger writing to Console — surfaces MeshExtractor failures during the equivalence sweep instead of silently swallowing them (NullLogger would hide the exact failure this suite exists to catch). +internal sealed class TestConsoleLogger : ILogger { + public IDisposable? BeginScope(TState state) where TState : notnull => null; + public bool IsEnabled(LogLevel logLevel) => logLevel >= LogLevel.Warning; + public void Log(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func formatter) { + if (!IsEnabled(logLevel)) return; + Console.WriteLine($"[{logLevel}] MeshExtractor: {formatter(state, exception)}"); + if (exception is not null) Console.WriteLine(exception); + } +} diff --git a/tests/AcDream.Content.Tests/Crc32Tests.cs b/tests/AcDream.Content.Tests/Crc32Tests.cs new file mode 100644 index 00000000..3ab7897c --- /dev/null +++ b/tests/AcDream.Content.Tests/Crc32Tests.cs @@ -0,0 +1,31 @@ +using System.Text; +using AcDream.Content.Pak; + +namespace AcDream.Content.Tests; + +/// +/// Known-answer vectors for the hand-rolled CRC-32 (IEEE 802.3 / zip / PNG +/// variant). Without these the suite is blind to a self-consistent-but-wrong +/// implementation: writer and reader would agree with each other while +/// producing values no external tool could reproduce (review finding 6). +/// +public class Crc32Tests { + [Fact] + public void KnownAnswer_123456789_IsCBF43926() { + // THE standard CRC-32 check value: CRC of the ASCII string + // "123456789" is 0xCBF43926 for the reflected 0xEDB88320 polynomial. + var input = Encoding.ASCII.GetBytes("123456789"); + Assert.Equal(0xCBF43926u, Crc32.Compute(input)); + } + + [Fact] + public void KnownAnswer_EmptyInput_IsZero() { + Assert.Equal(0x00000000u, Crc32.Compute(ReadOnlySpan.Empty)); + } + + [Fact] + public void KnownAnswer_SingleZeroByte() { + // CRC-32 of a single 0x00 byte is 0xD202EF8D (standard vector). + Assert.Equal(0xD202EF8Du, Crc32.Compute(new byte[] { 0x00 })); + } +} diff --git a/tests/AcDream.Content.Tests/ObjectMeshDataEquality.cs b/tests/AcDream.Content.Tests/ObjectMeshDataEquality.cs new file mode 100644 index 00000000..717f048c --- /dev/null +++ b/tests/AcDream.Content.Tests/ObjectMeshDataEquality.cs @@ -0,0 +1,221 @@ +using System.Linq; +using Chorizite.Core.Render.Enums; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +namespace AcDream.Content.Tests; + +/// +/// Field-by-field deep-equality comparator for and +/// its whole family (, , +/// , ). Used by both the +/// round-trip tests (Task 3) and the dat-gated equivalence suite (Task 6) so a +/// mismatch always names the exact field that diverged instead of just +/// "objects not equal". +/// +public static class ObjectMeshDataEquality { + public static void AssertEqual(ObjectMeshData? expected, ObjectMeshData? actual, string path = "root") { + if (expected is null && actual is null) return; + Assert.True(expected is not null, $"{path}: expected null but actual was non-null"); + Assert.True(actual is not null, $"{path}: expected non-null but actual was null"); + + Assert.True(expected.ObjectId == actual.ObjectId, $"{path}.ObjectId: expected 0x{expected.ObjectId:X16}, got 0x{actual.ObjectId:X16}"); + Assert.True(expected.IsSetup == actual.IsSetup, $"{path}.IsSetup: expected {expected.IsSetup}, got {actual.IsSetup}"); + AssertVerticesEqual(expected.Vertices, actual.Vertices, $"{path}.Vertices"); + + Assert.True(expected.Batches.Count == actual.Batches.Count, + $"{path}.Batches.Count: expected {expected.Batches.Count}, got {actual.Batches.Count}"); + for (int i = 0; i < expected.Batches.Count; i++) + AssertBatchEqual(expected.Batches[i], actual.Batches[i], $"{path}.Batches[{i}]"); + + Assert.True(expected.UploadAttempts == actual.UploadAttempts, + $"{path}.UploadAttempts: expected {expected.UploadAttempts}, got {actual.UploadAttempts}"); + + AssertEqual(expected.EnvCellGeometry, actual.EnvCellGeometry, $"{path}.EnvCellGeometry"); + + Assert.True(expected.SetupParts.Count == actual.SetupParts.Count, + $"{path}.SetupParts.Count: expected {expected.SetupParts.Count}, got {actual.SetupParts.Count}"); + for (int i = 0; i < expected.SetupParts.Count; i++) { + var (eId, eT) = expected.SetupParts[i]; + var (aId, aT) = actual.SetupParts[i]; + Assert.True(eId == aId, $"{path}.SetupParts[{i}].GfxObjId: expected 0x{eId:X16}, got 0x{aId:X16}"); + AssertMatrixEqual(eT, aT, $"{path}.SetupParts[{i}].Transform"); + } + + Assert.True(expected.ParticleEmitters.Count == actual.ParticleEmitters.Count, + $"{path}.ParticleEmitters.Count: expected {expected.ParticleEmitters.Count}, got {actual.ParticleEmitters.Count}"); + for (int i = 0; i < expected.ParticleEmitters.Count; i++) + AssertStagedEmitterEqual(expected.ParticleEmitters[i], actual.ParticleEmitters[i], $"{path}.ParticleEmitters[{i}]"); + + AssertTextureBatchesEqual(expected.TextureBatches, actual.TextureBatches, $"{path}.TextureBatches"); + + AssertBoundingBoxEqual(expected.BoundingBox, actual.BoundingBox, $"{path}.BoundingBox"); + AssertVector3Equal(expected.SortCenter, actual.SortCenter, $"{path}.SortCenter"); + Assert.True(expected.DIDDegrade == actual.DIDDegrade, $"{path}.DIDDegrade: expected {expected.DIDDegrade}, got {actual.DIDDegrade}"); + + AssertSphereEqual(expected.SelectionSphere, actual.SelectionSphere, $"{path}.SelectionSphere"); + AssertVector3ArrayEqual(expected.EdgeLines, actual.EdgeLines, $"{path}.EdgeLines"); + } + + private static void AssertVerticesEqual(VertexPositionNormalTexture[] expected, VertexPositionNormalTexture[] actual, string path) { + Assert.True(expected.Length == actual.Length, $"{path}.Length: expected {expected.Length}, got {actual.Length}"); + for (int i = 0; i < expected.Length; i++) { + AssertVector3Equal(expected[i].Position, actual[i].Position, $"{path}[{i}].Position"); + AssertVector3Equal(expected[i].Normal, actual[i].Normal, $"{path}[{i}].Normal"); + Assert.True(BitEqual(expected[i].UV, actual[i].UV), $"{path}[{i}].UV: expected {expected[i].UV}, got {actual[i].UV}"); + } + } + + private static void AssertBatchEqual(MeshBatchData expected, MeshBatchData actual, string path) { + Assert.True(expected.Indices.SequenceEqual(actual.Indices), + $"{path}.Indices: expected [{string.Join(",", expected.Indices)}], got [{string.Join(",", actual.Indices)}]"); + Assert.True(expected.TextureFormat == actual.TextureFormat, + $"{path}.TextureFormat: expected {expected.TextureFormat}, got {actual.TextureFormat}"); + AssertTextureKeyEqual(expected.TextureKey, actual.TextureKey, $"{path}.TextureKey"); + Assert.True(expected.TextureIndex == actual.TextureIndex, + $"{path}.TextureIndex: expected {expected.TextureIndex}, got {actual.TextureIndex}"); + Assert.True(expected.TextureData.SequenceEqual(actual.TextureData), + $"{path}.TextureData: length expected {expected.TextureData.Length}, got {actual.TextureData.Length}"); + Assert.True(expected.UploadPixelFormat == actual.UploadPixelFormat, + $"{path}.UploadPixelFormat: expected {expected.UploadPixelFormat}, got {actual.UploadPixelFormat}"); + Assert.True(expected.UploadPixelType == actual.UploadPixelType, + $"{path}.UploadPixelType: expected {expected.UploadPixelType}, got {actual.UploadPixelType}"); + Assert.True(expected.CullMode == actual.CullMode, + $"{path}.CullMode: expected {expected.CullMode}, got {actual.CullMode}"); + } + + private static void AssertTextureBatchDataEqual(TextureBatchData expected, TextureBatchData actual, string path) { + AssertTextureKeyEqual(expected.Key, actual.Key, $"{path}.Key"); + Assert.True(expected.TextureData.SequenceEqual(actual.TextureData), + $"{path}.TextureData: length expected {expected.TextureData.Length}, got {actual.TextureData.Length}"); + Assert.True(expected.UploadPixelFormat == actual.UploadPixelFormat, + $"{path}.UploadPixelFormat: expected {expected.UploadPixelFormat}, got {actual.UploadPixelFormat}"); + Assert.True(expected.UploadPixelType == actual.UploadPixelType, + $"{path}.UploadPixelType: expected {expected.UploadPixelType}, got {actual.UploadPixelType}"); + Assert.True(expected.Indices.SequenceEqual(actual.Indices), + $"{path}.Indices: expected [{string.Join(",", expected.Indices)}], got [{string.Join(",", actual.Indices)}]"); + Assert.True(expected.CullMode == actual.CullMode, $"{path}.CullMode: expected {expected.CullMode}, got {actual.CullMode}"); + Assert.True(expected.IsTransparent == actual.IsTransparent, $"{path}.IsTransparent: expected {expected.IsTransparent}, got {actual.IsTransparent}"); + Assert.True(expected.IsAdditive == actual.IsAdditive, $"{path}.IsAdditive: expected {expected.IsAdditive}, got {actual.IsAdditive}"); + Assert.True(expected.HasWrappingUVs == actual.HasWrappingUVs, $"{path}.HasWrappingUVs: expected {expected.HasWrappingUVs}, got {actual.HasWrappingUVs}"); + } + + private static void AssertTextureBatchesEqual( + System.Collections.Generic.Dictionary<(int Width, int Height, TextureFormat Format), System.Collections.Generic.List> expected, + System.Collections.Generic.Dictionary<(int Width, int Height, TextureFormat Format), System.Collections.Generic.List> actual, + string path) { + Assert.True(expected.Count == actual.Count, $"{path}.Count: expected {expected.Count}, got {actual.Count}"); + foreach (var key in expected.Keys) { + Assert.True(actual.ContainsKey(key), $"{path}: missing key {key}"); + var expList = expected[key]; + var actList = actual[key]; + Assert.True(expList.Count == actList.Count, $"{path}[{key}].Count: expected {expList.Count}, got {actList.Count}"); + for (int i = 0; i < expList.Count; i++) + AssertTextureBatchDataEqual(expList[i], actList[i], $"{path}[{key}][{i}]"); + } + } + + private static void AssertStagedEmitterEqual(StagedEmitter expected, StagedEmitter actual, string path) { + Assert.True(expected.PartIndex == actual.PartIndex, $"{path}.PartIndex: expected {expected.PartIndex}, got {actual.PartIndex}"); + AssertMatrixEqual(expected.Offset, actual.Offset, $"{path}.Offset"); + AssertParticleEmitterEqual(expected.Emitter, actual.Emitter, $"{path}.Emitter"); + } + + private static void AssertParticleEmitterEqual(ParticleEmitter? expected, ParticleEmitter? actual, string path) { + if (expected is null && actual is null) return; + Assert.True(expected is not null, $"{path}: expected null but actual was non-null"); + Assert.True(actual is not null, $"{path}: expected non-null but actual was null"); + + Assert.True(expected.Id == actual.Id, $"{path}.Id: expected 0x{expected.Id:X8}, got 0x{actual.Id:X8}"); + Assert.True(expected.DataCategory == actual.DataCategory, $"{path}.DataCategory: expected {expected.DataCategory}, got {actual.DataCategory}"); + Assert.True(expected.Unknown == actual.Unknown, $"{path}.Unknown: expected {expected.Unknown}, got {actual.Unknown}"); + Assert.True(expected.EmitterType == actual.EmitterType, $"{path}.EmitterType: expected {expected.EmitterType}, got {actual.EmitterType}"); + Assert.True(expected.ParticleType == actual.ParticleType, $"{path}.ParticleType: expected {expected.ParticleType}, got {actual.ParticleType}"); + Assert.True(expected.GfxObjId.DataId == actual.GfxObjId.DataId, $"{path}.GfxObjId: expected 0x{expected.GfxObjId.DataId:X8}, got 0x{actual.GfxObjId.DataId:X8}"); + Assert.True(expected.HwGfxObjId.DataId == actual.HwGfxObjId.DataId, $"{path}.HwGfxObjId: expected 0x{expected.HwGfxObjId.DataId:X8}, got 0x{actual.HwGfxObjId.DataId:X8}"); + Assert.True(BitEqual(expected.Birthrate, actual.Birthrate), $"{path}.Birthrate: expected {expected.Birthrate}, got {actual.Birthrate}"); + Assert.True(expected.MaxParticles == actual.MaxParticles, $"{path}.MaxParticles: expected {expected.MaxParticles}, got {actual.MaxParticles}"); + Assert.True(expected.InitialParticles == actual.InitialParticles, $"{path}.InitialParticles: expected {expected.InitialParticles}, got {actual.InitialParticles}"); + Assert.True(expected.TotalParticles == actual.TotalParticles, $"{path}.TotalParticles: expected {expected.TotalParticles}, got {actual.TotalParticles}"); + Assert.True(BitEqual(expected.TotalSeconds, actual.TotalSeconds), $"{path}.TotalSeconds: expected {expected.TotalSeconds}, got {actual.TotalSeconds}"); + Assert.True(BitEqual(expected.Lifespan, actual.Lifespan), $"{path}.Lifespan: expected {expected.Lifespan}, got {actual.Lifespan}"); + Assert.True(BitEqual(expected.LifespanRand, actual.LifespanRand), $"{path}.LifespanRand: expected {expected.LifespanRand}, got {actual.LifespanRand}"); + AssertVector3Equal(expected.OffsetDir, actual.OffsetDir, $"{path}.OffsetDir"); + Assert.True(BitEqual(expected.MinOffset, actual.MinOffset), $"{path}.MinOffset: expected {expected.MinOffset}, got {actual.MinOffset}"); + Assert.True(BitEqual(expected.MaxOffset, actual.MaxOffset), $"{path}.MaxOffset: expected {expected.MaxOffset}, got {actual.MaxOffset}"); + AssertVector3Equal(expected.A, actual.A, $"{path}.A"); + Assert.True(BitEqual(expected.MinA, actual.MinA), $"{path}.MinA: expected {expected.MinA}, got {actual.MinA}"); + Assert.True(BitEqual(expected.MaxA, actual.MaxA), $"{path}.MaxA: expected {expected.MaxA}, got {actual.MaxA}"); + AssertVector3Equal(expected.B, actual.B, $"{path}.B"); + Assert.True(BitEqual(expected.MinB, actual.MinB), $"{path}.MinB: expected {expected.MinB}, got {actual.MinB}"); + Assert.True(BitEqual(expected.MaxB, actual.MaxB), $"{path}.MaxB: expected {expected.MaxB}, got {actual.MaxB}"); + AssertVector3Equal(expected.C, actual.C, $"{path}.C"); + Assert.True(BitEqual(expected.MinC, actual.MinC), $"{path}.MinC: expected {expected.MinC}, got {actual.MinC}"); + Assert.True(BitEqual(expected.MaxC, actual.MaxC), $"{path}.MaxC: expected {expected.MaxC}, got {actual.MaxC}"); + Assert.True(BitEqual(expected.StartScale, actual.StartScale), $"{path}.StartScale: expected {expected.StartScale}, got {actual.StartScale}"); + Assert.True(BitEqual(expected.FinalScale, actual.FinalScale), $"{path}.FinalScale: expected {expected.FinalScale}, got {actual.FinalScale}"); + Assert.True(BitEqual(expected.ScaleRand, actual.ScaleRand), $"{path}.ScaleRand: expected {expected.ScaleRand}, got {actual.ScaleRand}"); + Assert.True(BitEqual(expected.StartTrans, actual.StartTrans), $"{path}.StartTrans: expected {expected.StartTrans}, got {actual.StartTrans}"); + Assert.True(BitEqual(expected.FinalTrans, actual.FinalTrans), $"{path}.FinalTrans: expected {expected.FinalTrans}, got {actual.FinalTrans}"); + Assert.True(BitEqual(expected.TransRand, actual.TransRand), $"{path}.TransRand: expected {expected.TransRand}, got {actual.TransRand}"); + Assert.True(expected.IsParentLocal == actual.IsParentLocal, $"{path}.IsParentLocal: expected {expected.IsParentLocal}, got {actual.IsParentLocal}"); + } + + private static void AssertTextureKeyEqual(TextureKey expected, TextureKey actual, string path) { + Assert.True(expected.Equals(actual), + $"{path}: expected SurfaceId=0x{expected.SurfaceId:X8} PaletteId=0x{expected.PaletteId:X8} Stippling={expected.Stippling} IsSolid={expected.IsSolid}, " + + $"got SurfaceId=0x{actual.SurfaceId:X8} PaletteId=0x{actual.PaletteId:X8} Stippling={actual.Stippling} IsSolid={actual.IsSolid}"); + } + + private static void AssertBoundingBoxEqual(Chorizite.Core.Lib.BoundingBox expected, Chorizite.Core.Lib.BoundingBox actual, string path) { + AssertVector3Equal(expected.Min, actual.Min, $"{path}.Min"); + AssertVector3Equal(expected.Max, actual.Max, $"{path}.Max"); + } + + private static void AssertSphereEqual(Sphere? expected, Sphere? actual, string path) { + if (expected is null && actual is null) return; + Assert.True(expected is not null, $"{path}: expected null but actual was non-null"); + Assert.True(actual is not null, $"{path}: expected non-null but actual was null"); + AssertVector3Equal(expected.Origin, actual.Origin, $"{path}.Origin"); + Assert.True(BitEqual(expected.Radius, actual.Radius), $"{path}.Radius: expected {expected.Radius}, got {actual.Radius}"); + } + + private static void AssertVector3Equal(System.Numerics.Vector3 expected, System.Numerics.Vector3 actual, string path) { + Assert.True(BitEqual(expected, actual), $"{path}: expected {expected}, got {actual}"); + } + + private static void AssertVector3ArrayEqual(System.Numerics.Vector3[] expected, System.Numerics.Vector3[] actual, string path) { + Assert.True(expected.Length == actual.Length, $"{path}.Length: expected {expected.Length}, got {actual.Length}"); + for (int i = 0; i < expected.Length; i++) + AssertVector3Equal(expected[i], actual[i], $"{path}[{i}]"); + } + + private static void AssertMatrixEqual(System.Numerics.Matrix4x4 expected, System.Numerics.Matrix4x4 actual, string path) { + Assert.True(BitEqual(expected, actual), $"{path}: expected {expected}, got {actual}"); + } + + // ---- bitwise float equality ---------------------------------------------- + // The pak stores raw IEEE-754 bits, so "round-trip preserved the field" + // means BIT equality, not `==` semantics: `==` is false for NaN==NaN + // (a NaN payload surviving the round-trip would FAIL a correct + // serializer) and true for -0.0==+0.0 (a sign-bit flip would silently + // PASS). Review finding 9. + + private static bool BitEqual(float a, float b) => + BitConverter.SingleToInt32Bits(a) == BitConverter.SingleToInt32Bits(b); + + private static bool BitEqual(double a, double b) => + BitConverter.DoubleToInt64Bits(a) == BitConverter.DoubleToInt64Bits(b); + + private static bool BitEqual(System.Numerics.Vector2 a, System.Numerics.Vector2 b) => + BitEqual(a.X, b.X) && BitEqual(a.Y, b.Y); + + private static bool BitEqual(System.Numerics.Vector3 a, System.Numerics.Vector3 b) => + BitEqual(a.X, b.X) && BitEqual(a.Y, b.Y) && BitEqual(a.Z, b.Z); + + private static bool BitEqual(System.Numerics.Matrix4x4 a, System.Numerics.Matrix4x4 b) => + BitEqual(a.M11, b.M11) && BitEqual(a.M12, b.M12) && BitEqual(a.M13, b.M13) && BitEqual(a.M14, b.M14) && + BitEqual(a.M21, b.M21) && BitEqual(a.M22, b.M22) && BitEqual(a.M23, b.M23) && BitEqual(a.M24, b.M24) && + BitEqual(a.M31, b.M31) && BitEqual(a.M32, b.M32) && BitEqual(a.M33, b.M33) && BitEqual(a.M34, b.M34) && + BitEqual(a.M41, b.M41) && BitEqual(a.M42, b.M42) && BitEqual(a.M43, b.M43) && BitEqual(a.M44, b.M44); +} diff --git a/tests/AcDream.Content.Tests/ObjectMeshDataSerializerTests.cs b/tests/AcDream.Content.Tests/ObjectMeshDataSerializerTests.cs new file mode 100644 index 00000000..8df8a0c6 --- /dev/null +++ b/tests/AcDream.Content.Tests/ObjectMeshDataSerializerTests.cs @@ -0,0 +1,297 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Numerics; +using AcDream.Content.Pak; +using Chorizite.Core.Lib; +using Chorizite.Core.Render.Enums; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; +using CullMode = DatReaderWriter.Enums.CullMode; +using StipplingType = DatReaderWriter.Enums.StipplingType; +using EmitterType = DatReaderWriter.Enums.EmitterType; +using ParticleType = DatReaderWriter.Enums.ParticleType; + +namespace AcDream.Content.Tests; + +public class ObjectMeshDataSerializerTests { + // ---- fixture builders --------------------------------------------------- + + private static ObjectMeshData EmptyObject() => new() { + ObjectId = 0x0100_0001u, + IsSetup = false, + }; + + private static ObjectMeshData VerticesAndIndicesOnly() { + var data = new ObjectMeshData { + ObjectId = 0x0100_0002u, + IsSetup = false, + Vertices = new[] { + new VertexPositionNormalTexture(new Vector3(1, 2, 3), new Vector3(0, 0, 1), new Vector2(0, 0)), + new VertexPositionNormalTexture(new Vector3(4, 5, 6), new Vector3(0, 1, 0), new Vector2(1, 0)), + new VertexPositionNormalTexture(new Vector3(7, 8, 9), new Vector3(1, 0, 0), new Vector2(1, 1)), + }, + BoundingBox = new BoundingBox(new Vector3(1, 2, 3), new Vector3(7, 8, 9)), + SortCenter = new Vector3(4, 5, 6), + DIDDegrade = 0x11223344, + }; + data.Batches.Add(new MeshBatchData { + Indices = new ushort[] { 0, 1, 2 }, + TextureFormat = (64, 64, TextureFormat.RGBA8), + TextureKey = new TextureKey { SurfaceId = 0x08000001, PaletteId = 0x04000001, Stippling = StipplingType.Both, IsSolid = true }, + TextureIndex = 0, + TextureData = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }, + UploadPixelFormat = AcDream.Content.UploadPixelFormat.Rgba, + UploadPixelType = AcDream.Content.UploadPixelType.UnsignedByte, + CullMode = CullMode.Clockwise, + }); + return data; + } + + private static ObjectMeshData MultipleTextureBatchGroups() { + var data = EmptyObject(); + data.ObjectId = 0x0100_0003u; + + TextureBatchData Batch(uint surfaceId, string tag) => new() { + Key = new TextureKey { SurfaceId = surfaceId, PaletteId = 1, Stippling = StipplingType.Positive, IsSolid = false }, + TextureData = System.Text.Encoding.ASCII.GetBytes(tag), + UploadPixelFormat = AcDream.Content.UploadPixelFormat.Rgba, + UploadPixelType = AcDream.Content.UploadPixelType.UnsignedByte, + Indices = new List { 0, 1, 2, 2, 3, 0 }, + CullMode = CullMode.CounterClockwise, + IsTransparent = true, + IsAdditive = false, + HasWrappingUVs = true, + }; + + data.TextureBatches[(32, 32, TextureFormat.RGBA8)] = new List { Batch(1, "a"), Batch(2, "b") }; + data.TextureBatches[(64, 64, TextureFormat.DXT5)] = new List { Batch(3, "c") }; + data.TextureBatches[(16, 16, TextureFormat.A8)] = new List { Batch(4, "d"), Batch(5, "e"), Batch(6, "f") }; + return data; + } + + private static ObjectMeshData SetupWithParts() { + var data = EmptyObject(); + data.ObjectId = 0x0200_0001u; + data.IsSetup = true; + data.SetupParts.Add((0x0100_0010u, Matrix4x4.CreateTranslation(1, 2, 3))); + data.SetupParts.Add((0x0100_0011u, Matrix4x4.CreateFromYawPitchRoll(0.1f, 0.2f, 0.3f))); + return data; + } + + private static ParticleEmitter BuildEmitter(uint id) => new() { + Id = id, + DataCategory = 0x2A, + Unknown = 7, + EmitterType = EmitterType.BirthratePerSec, + ParticleType = ParticleType.Explode, + GfxObjId = new QualifiedDataId { DataId = 0x0100_0099u }, + HwGfxObjId = new QualifiedDataId { DataId = 0x0100_009Au }, + Birthrate = 2.5, + MaxParticles = 40, + InitialParticles = 5, + TotalParticles = 100, + TotalSeconds = 3.0, + Lifespan = 1.5, + LifespanRand = 0.25, + OffsetDir = new Vector3(0, 0, 1), + MinOffset = 0.1f, + MaxOffset = 0.5f, + A = new Vector3(1, 0, 0), + MinA = 0.9f, + MaxA = 1.1f, + B = new Vector3(0, 1, 0), + MinB = 0.8f, + MaxB = 1.2f, + C = new Vector3(0, 0, 1), + MinC = 0.7f, + MaxC = 1.3f, + StartScale = 0.5f, + FinalScale = 1.5f, + ScaleRand = 0.05f, + StartTrans = 1f, + FinalTrans = 0f, + TransRand = 0.1f, + IsParentLocal = true, + }; + + private static ObjectMeshData WithEmitters() { + var data = EmptyObject(); + data.ObjectId = 0x0200_0002u; + data.IsSetup = true; + data.ParticleEmitters.Add(new StagedEmitter { + Emitter = BuildEmitter(0x2A00_0001u), + PartIndex = 3, + Offset = Matrix4x4.CreateTranslation(10, 20, 30), + }); + data.ParticleEmitters.Add(new StagedEmitter { + Emitter = BuildEmitter(0x2A00_0002u), + PartIndex = 0, + Offset = Matrix4x4.Identity, + }); + return data; + } + + private static ObjectMeshData WithNullableFieldsPresent() { + var data = EmptyObject(); + data.ObjectId = 0x0300_0001u; + data.SelectionSphere = new Sphere { Origin = new Vector3(1, 1, 1), Radius = 2.5f }; + data.Batches.Add(new MeshBatchData { + Indices = new ushort[] { 0 }, + UploadPixelFormat = AcDream.Content.UploadPixelFormat.Rgba, + UploadPixelType = AcDream.Content.UploadPixelType.UnsignedByte, + }); + return data; + } + + private static ObjectMeshData WithNullableFieldsAbsent() { + var data = EmptyObject(); + data.ObjectId = 0x0300_0002u; + data.SelectionSphere = null; + data.Batches.Add(new MeshBatchData { + Indices = new ushort[] { 0 }, + UploadPixelFormat = null, + UploadPixelType = null, + }); + return data; + } + + private static ObjectMeshData WithEdgeLines() { + var data = EmptyObject(); + data.ObjectId = 0x0400_0001u; + data.EdgeLines = new[] { + new Vector3(0, 0, 0), new Vector3(1, 0, 0), + new Vector3(1, 0, 0), new Vector3(1, 1, 0), + }; + return data; + } + + private static ObjectMeshData WithNestedEnvCellGeometry() { + var data = EmptyObject(); + data.ObjectId = 0x0D00_0001_0000_0100u | (1UL << 32); + data.IsSetup = true; + data.EnvCellGeometry = VerticesAndIndicesOnly(); + return data; + } + + public static IEnumerable AllFixtures() { + yield return new object[] { EmptyObject() }; + yield return new object[] { VerticesAndIndicesOnly() }; + yield return new object[] { MultipleTextureBatchGroups() }; + yield return new object[] { SetupWithParts() }; + yield return new object[] { WithEmitters() }; + yield return new object[] { WithNullableFieldsPresent() }; + yield return new object[] { WithNullableFieldsAbsent() }; + yield return new object[] { WithEdgeLines() }; + yield return new object[] { WithNestedEnvCellGeometry() }; + } + + // ---- round-trip tests ---------------------------------------------------- + + [Theory] + [MemberData(nameof(AllFixtures))] + public void RoundTrip_PreservesEveryField(ObjectMeshData original) { + using var ms = new MemoryStream(); + ObjectMeshDataSerializer.Write(original, ms); + var bytes = ms.ToArray(); + + var readBack = ObjectMeshDataSerializer.Read(bytes); + + ObjectMeshDataEquality.AssertEqual(original, readBack); + } + + // ---- determinism ----------------------------------------------------- + + [Fact] + public void Serialize_SameInstanceTwice_ByteIdentical() { + var data = MultipleTextureBatchGroups(); + + using var ms1 = new MemoryStream(); + ObjectMeshDataSerializer.Write(data, ms1); + + using var ms2 = new MemoryStream(); + ObjectMeshDataSerializer.Write(data, ms2); + + Assert.Equal(ms1.ToArray(), ms2.ToArray()); + } + + [Fact] + public void Serialize_DictionaryInsertedInDifferentOrders_ByteIdentical() { + TextureBatchData Batch(uint surfaceId) => new() { + Key = new TextureKey { SurfaceId = surfaceId, PaletteId = 1, Stippling = StipplingType.None, IsSolid = false }, + TextureData = new byte[] { (byte)surfaceId }, + Indices = new List { 0, 1, 2 }, + CullMode = CullMode.None, + }; + + var a = EmptyObject(); + a.ObjectId = 0x0500_0001u; + a.TextureBatches[(32, 32, TextureFormat.RGBA8)] = new List { Batch(1) }; + a.TextureBatches[(64, 64, TextureFormat.DXT5)] = new List { Batch(2) }; + a.TextureBatches[(16, 16, TextureFormat.A8)] = new List { Batch(3) }; + + var b = EmptyObject(); + b.ObjectId = 0x0500_0001u; + // Insert in a completely different order. + b.TextureBatches[(16, 16, TextureFormat.A8)] = new List { Batch(3) }; + b.TextureBatches[(32, 32, TextureFormat.RGBA8)] = new List { Batch(1) }; + b.TextureBatches[(64, 64, TextureFormat.DXT5)] = new List { Batch(2) }; + + using var msA = new MemoryStream(); + ObjectMeshDataSerializer.Write(a, msA); + using var msB = new MemoryStream(); + ObjectMeshDataSerializer.Write(b, msB); + + Assert.Equal(msA.ToArray(), msB.ToArray()); + } + + [Fact] + public void Write_SortsTextureBatchesByWidthHeightFormatKeyTuple() { + // Insert in scrambled order; the serialized bytes must reflect the + // KEY-sorted order (Width, Height, Format), not insertion order. + var data = EmptyObject(); + data.ObjectId = 0x0600_0001u; + + // Each batch's TextureData is a distinctive multi-byte marker (not a + // single ambiguous byte value that could collide with unrelated + // length-prefix / width / height bytes elsewhere in the stream). + TextureBatchData Batch(byte[] marker) => new() { + Key = default, + TextureData = marker, + Indices = new List(), + CullMode = CullMode.None, + }; + + byte[] markerA = { 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA }; + byte[] markerB = { 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB }; + byte[] markerC = { 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC }; + + data.TextureBatches[(100, 1, TextureFormat.RGBA8)] = new List { Batch(markerC) }; + data.TextureBatches[(1, 1, TextureFormat.RGBA8)] = new List { Batch(markerA) }; + data.TextureBatches[(1, 100, TextureFormat.RGBA8)] = new List { Batch(markerB) }; + + using var ms = new MemoryStream(); + ObjectMeshDataSerializer.Write(data, ms); + var bytes = ms.ToArray(); + + // markerA (width=1,height=1) < markerB (width=1,height=100) < + // markerC (width=100,height=1) in ascending (Width, Height) order. + int iA = IndexOfSequence(bytes, markerA); + int iB = IndexOfSequence(bytes, markerB); + int iC = IndexOfSequence(bytes, markerC); + Assert.True(iA >= 0 && iB >= 0 && iC >= 0, "all three markers must appear in the stream"); + Assert.True(iA < iB, $"markerA (width=1,height=1) must precede markerB (width=1,height=100): iA={iA} iB={iB}"); + Assert.True(iB < iC, $"markerB (width=1,height=100) must precede markerC (width=100,height=1): iB={iB} iC={iC}"); + } + + private static int IndexOfSequence(byte[] haystack, byte[] needle) { + for (int i = 0; i <= haystack.Length - needle.Length; i++) { + bool match = true; + for (int j = 0; j < needle.Length; j++) { + if (haystack[i + j] != needle[j]) { match = false; break; } + } + if (match) return i; + } + return -1; + } +} diff --git a/tests/AcDream.Content.Tests/PakEquivalenceTests.cs b/tests/AcDream.Content.Tests/PakEquivalenceTests.cs new file mode 100644 index 00000000..e42567f3 --- /dev/null +++ b/tests/AcDream.Content.Tests/PakEquivalenceTests.cs @@ -0,0 +1,161 @@ +using System.Collections.Generic; +using System.IO; +using System.Linq; +using AcDream.Content.Pak; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; + +namespace AcDream.Content.Tests; + +/// +/// MP1b Task 6: dat-gated live-vs-pak equivalence suite. Runs MeshExtractor +/// LIVE and bakes the SAME ids to a temp pak, reads the pak back, and deep- +/// compares field-by-field via the Task 3 comparator. Because the bake tool +/// and the live client drive the identical MeshExtractor code (MP1a), this +/// test is proving the pak ROUND-TRIP (serialize/deserialize) preserves +/// what extraction actually produces on real content — not re-verifying the +/// extraction algorithm itself (that's the existing Conformance suite's job). +/// +/// Skips cleanly when the real dats are absent (CI), matching +/// DatConcurrencyStressTests' convention. +/// +public sealed class PakEquivalenceTests { + // Known-tricky GfxObj ids reused from existing conformance fixtures: + // 0x010002B4 / 0x010008A8 — #119 "[up-null] upload returned null" dump + // targets (Issue119UpNullGfxObjDumpTests). + // 0x010014C3 — the #113-saga Holtburg meeting-hall shell + // (Issue119UpNullGfxObjDumpTests.ShellModel_NoTexturedPolyIsDropped). + private static readonly uint[] KnownTrickyGfxObjIds = { 0x010002B4u, 0x010008A8u, 0x010014C3u }; + + // Setup ids reused from existing physics/conformance fixtures: + // 0x020019FF — the door setup (DoorBugTrajectoryReplayTests, + // DoorSetupGfxObjInspectionTests, DoorCollisionApparatusTests). + // 0x020005D8 / 0x020003F2 — Issue119TowerDumpTests fixtures. + private static readonly uint[] SetupIds = { 0x020019FFu, 0x020005D8u, 0x020003F2u }; + + private const uint HoltburgLandblock = 0xA9B40000u; // ConformanceDats.HoltburgLandblock + + [Fact] + public void LiveExtraction_MatchesPakRoundTrip_OnFixtureIdSet() { + var datDir = ContentConformanceDats.ResolveDatDir(); + if (datDir is null) return; // dats absent (CI) — skip, matching suite convention + + using var dats = new DatCollection(datDir, DatAccessType.Read); + // The unified AcDream.Content.DatCollectionAdapter — same class the + // client and the bake tool use (MP1b review finding 7). + using var datReaderWriter = new DatCollectionAdapter(dats); + var logger = new TestConsoleLogger(); + + var sideStaged = new List(); + var extractor = new MeshExtractor(datReaderWriter, logger, data => sideStaged.Add(data)); + + var gfxObjIds = BuildGfxObjIdSet(dats); + var setupIds = SetupIds.ToList(); + var envCellIds = BuildEnvCellIdSet(dats, HoltburgLandblock, minCount: 5); + + Assert.True(gfxObjIds.Count >= 10, $"fixture GfxObj id set unexpectedly small ({gfxObjIds.Count})"); + Assert.True(setupIds.Count >= 3, $"fixture Setup id set unexpectedly small ({setupIds.Count})"); + Assert.True(envCellIds.Count >= 5, $"fixture EnvCell id set unexpectedly small ({envCellIds.Count})"); + + var work = new List<(PakAssetType Type, uint FileId, ulong ExtractorId, bool IsSetup)>(); + work.AddRange(gfxObjIds.Select(id => (PakAssetType.GfxObjMesh, id, (ulong)id, false))); + work.AddRange(setupIds.Select(id => (PakAssetType.SetupMesh, id, (ulong)id, true))); + // isSetup: false for EnvCell — matches the runtime's own request sites + // (WbMeshAdapter.IncrementRefCount/EnsureLoaded pass isSetup: false for + // every MeshRef id, incl. cell-geometry ids) and BakeRunner's call site. + // (Review finding 10 — the two call sites previously disagreed.) + work.AddRange(envCellIds.Select(id => (PakAssetType.EnvCellMesh, id, id | 0x1_0000_0000UL, false))); + + // ---- LIVE extraction (golden) ---- + var golden = new Dictionary<(PakAssetType, uint), ObjectMeshData>(); + var extractionFailures = new List(); + foreach (var (type, fileId, extractorId, isSetup) in work) { + var data = extractor.PrepareMeshData(extractorId, isSetup); + if (data is null) { + extractionFailures.Add($"{type} 0x{fileId:X8}: live extraction returned null"); + continue; + } + golden[(type, fileId)] = data; + } + + Assert.True(extractionFailures.Count == 0, + $"{extractionFailures.Count} fixture ids failed LIVE extraction (fixture assumption broke): " + + string.Join(" | ", extractionFailures)); + + // ---- bake the SAME ids to a temp pak ---- + var pakPath = Path.Combine(Path.GetTempPath(), $"acdream-equivtest-{System.Guid.NewGuid():N}.pak"); + try { + var header = new PakHeader { + FormatVersion = 1, + PortalIteration = (uint)dats.Portal.Iteration!.CurrentIteration, + CellIteration = (uint)dats.Cell.Iteration!.CurrentIteration, + HighResIteration = (uint)dats.HighRes.Iteration!.CurrentIteration, + LanguageIteration = (uint)dats.Local.Iteration!.CurrentIteration, + BakeToolVersion = 1, + }; + using (var writer = new PakWriter(pakPath, header)) { + foreach (var ((type, fileId), data) in golden) { + writer.AddBlob(PakKey.Compose(type, fileId), data); + } + writer.Finish(); + } + + // ---- read back and deep-compare ---- + using var reader = new PakReader(pakPath); + var mismatches = new List(); + foreach (var ((type, fileId), expected) in golden) { + var key = PakKey.Compose(type, fileId); + if (!reader.TryReadObjectMeshData(key, out var actual)) { + mismatches.Add($"{type} 0x{fileId:X8}: pak read failed (missing or CRC mismatch)"); + continue; + } + try { + ObjectMeshDataEquality.AssertEqual(expected, actual); + } + catch (Xunit.Sdk.XunitException ex) { + mismatches.Add($"{type} 0x{fileId:X8}: {ex.Message}"); + } + } + + Assert.True(mismatches.Count == 0, + $"{mismatches.Count}/{golden.Count} fixture ids mismatched between live extraction and pak round-trip:\n" + + string.Join("\n", mismatches)); + } + finally { + if (File.Exists(pakPath)) File.Delete(pakPath); + } + } + + /// + /// Known-tricky ids (#119/#113 dump fixtures) plus enough additional + /// GfxObjs (deterministically, the first N ids in dat order after the + /// tricky set) to reach at least 10 total. + /// + private static List BuildGfxObjIdSet(DatCollection dats) { + var ids = new List(KnownTrickyGfxObjIds); + var seen = new HashSet(ids); + + foreach (var id in dats.GetAllIdsOfType()) { + if (ids.Count >= 10) break; + if (seen.Add(id)) ids.Add(id); + } + return ids; + } + + /// Walks the Holtburg landblock's LandBlockInfo.NumCells range (mirrors StipplingSurfaceEquivalenceTests' enumeration) to get at least real EnvCell ids. + private static List BuildEnvCellIdSet(DatCollection dats, uint landblockId, int minCount) { + var ids = new List(); + var lbInfo = dats.Get(landblockId | 0xFFFEu); + Assert.True(lbInfo is not null, $"LandBlockInfo for landblock 0x{landblockId:X8} not found — fixture assumption broke"); + Assert.True(lbInfo!.NumCells >= minCount, + $"landblock 0x{landblockId:X8} has only {lbInfo.NumCells} cells — fixture assumption broke (need >= {minCount})"); + + uint firstCellId = landblockId | 0x0100u; + for (uint offset = 0; offset < lbInfo.NumCells && ids.Count < minCount; offset++) { + uint envCellId = firstCellId + offset; + if (dats.Get(envCellId) is not null) ids.Add(envCellId); + } + return ids; + } +} diff --git a/tests/AcDream.Content.Tests/PakFormatTests.cs b/tests/AcDream.Content.Tests/PakFormatTests.cs new file mode 100644 index 00000000..4eb1181d --- /dev/null +++ b/tests/AcDream.Content.Tests/PakFormatTests.cs @@ -0,0 +1,145 @@ +using System.IO; +using AcDream.Content.Pak; + +namespace AcDream.Content.Tests; + +public class PakFormatTests { + [Fact] + public void Header_Size_Is64Bytes() { + Assert.Equal(64, PakHeader.Size); + } + + [Fact] + public void TocEntry_Size_Is24Bytes() { + Assert.Equal(24, PakTocEntry.Size); + } + + [Fact] + public void Header_Magic_IsAcpkLittleEndian() { + // 'A'=0x41 'C'=0x43 'P'=0x50 'K'=0x4B — little-endian dword reads + // back as 0x4B504341 per the normative spec. + Assert.Equal(0x4B504341u, PakHeader.MagicValue); + } + + [Fact] + public void Header_WriteThenRead_RoundTripsEveryField() { + var header = new PakHeader { + FormatVersion = 1, + PortalIteration = 111, + CellIteration = 222, + HighResIteration = 333, + LanguageIteration = 444, + TocOffset = 0x1_0000_0002UL, + TocCount = 777, + BakeToolVersion = 1, + }; + + using var ms = new MemoryStream(); + header.WriteTo(ms); + Assert.Equal(PakHeader.Size, ms.Length); + + ms.Position = 0; + var readBack = PakHeader.ReadFrom(ms); + + Assert.Equal(PakHeader.MagicValue, readBack.Magic); + Assert.Equal(header.FormatVersion, readBack.FormatVersion); + Assert.Equal(header.PortalIteration, readBack.PortalIteration); + Assert.Equal(header.CellIteration, readBack.CellIteration); + Assert.Equal(header.HighResIteration, readBack.HighResIteration); + Assert.Equal(header.LanguageIteration, readBack.LanguageIteration); + Assert.Equal(header.TocOffset, readBack.TocOffset); + Assert.Equal(header.TocCount, readBack.TocCount); + Assert.Equal(header.BakeToolVersion, readBack.BakeToolVersion); + } + + [Fact] + public void Header_ReadFrom_Span_RoundTrips() { + var header = new PakHeader { + FormatVersion = 1, + PortalIteration = 5, + CellIteration = 6, + HighResIteration = 7, + LanguageIteration = 8, + TocOffset = 999, + TocCount = 3, + BakeToolVersion = 1, + }; + Span buf = stackalloc byte[PakHeader.Size]; + header.WriteTo(buf); + var readBack = PakHeader.ReadFrom((ReadOnlySpan)buf); + Assert.Equal(header.CellIteration, readBack.CellIteration); + Assert.Equal(header.TocOffset, readBack.TocOffset); + } + + [Fact] + public void Header_ReservedBytes_AreZero() { + var header = new PakHeader { FormatVersion = 1, BakeToolVersion = 1 }; + Span buf = stackalloc byte[PakHeader.Size]; + header.WriteTo(buf); + // offset 40, length 24 per the normative layout + for (int i = 40; i < 64; i++) { + Assert.Equal(0, buf[i]); + } + } + + [Fact] + public void Header_FieldOffsets_MatchNormativeLayout() { + var header = new PakHeader { + FormatVersion = 0x11111111, + PortalIteration = 0x22222222, + CellIteration = 0x33333333, + HighResIteration = 0x44444444, + LanguageIteration = 0x55555555, + TocOffset = 0x6666666677777777UL, + TocCount = 0x88888888, + BakeToolVersion = 0x99999999, + }; + Span buf = stackalloc byte[PakHeader.Size]; + header.WriteTo(buf); + + Assert.Equal(PakHeader.MagicValue, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buf[0..4])); + Assert.Equal(0x11111111u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buf[4..8])); + Assert.Equal(0x22222222u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buf[8..12])); + Assert.Equal(0x33333333u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buf[12..16])); + Assert.Equal(0x44444444u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buf[16..20])); + Assert.Equal(0x55555555u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buf[20..24])); + Assert.Equal(0x6666666677777777UL, System.Buffers.Binary.BinaryPrimitives.ReadUInt64LittleEndian(buf[24..32])); + Assert.Equal(0x88888888u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buf[32..36])); + Assert.Equal(0x99999999u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buf[36..40])); + } + + [Fact] + public void TocEntry_WriteThenRead_RoundTrips() { + var entry = new PakTocEntry { + Key = PakKey.Compose(PakAssetType.GfxObjMesh, 0x010002B4u), + Offset = 0x4000, + Length = 12345, + Crc32 = 0xDEADBEEF, + }; + Span buf = stackalloc byte[PakTocEntry.Size]; + entry.WriteTo(buf); + var readBack = PakTocEntry.ReadFrom((ReadOnlySpan)buf); + + Assert.Equal(entry.Key, readBack.Key); + Assert.Equal(entry.Offset, readBack.Offset); + Assert.Equal(entry.Length, readBack.Length); + Assert.Equal(entry.Crc32, readBack.Crc32); + } + + [Fact] + public void TocEntry_FieldOffsets_MatchNormativeLayout() { + var entry = new PakTocEntry { + Key = 0x1111111122222222UL, + Offset = 0x3333333344444444UL, + Length = 0x55555555, + Crc32 = 0x66666666, + }; + Span buf = stackalloc byte[PakTocEntry.Size]; + entry.WriteTo(buf); + + Assert.Equal(0x1111111122222222UL, System.Buffers.Binary.BinaryPrimitives.ReadUInt64LittleEndian(buf[0..8])); + Assert.Equal(0x3333333344444444UL, System.Buffers.Binary.BinaryPrimitives.ReadUInt64LittleEndian(buf[8..16])); + Assert.Equal(0x55555555u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buf[16..20])); + Assert.Equal(0x66666666u, System.Buffers.Binary.BinaryPrimitives.ReadUInt32LittleEndian(buf[20..24])); + } +} diff --git a/tests/AcDream.Content.Tests/PakKeyTests.cs b/tests/AcDream.Content.Tests/PakKeyTests.cs new file mode 100644 index 00000000..ba527ac5 --- /dev/null +++ b/tests/AcDream.Content.Tests/PakKeyTests.cs @@ -0,0 +1,75 @@ +using AcDream.Content.Pak; + +namespace AcDream.Content.Tests; + +public class PakKeyTests { + [Theory] + [InlineData(PakAssetType.GfxObjMesh, 0u)] + [InlineData(PakAssetType.GfxObjMesh, 0x01000001u)] + [InlineData(PakAssetType.SetupMesh, 0x020019FFu)] + [InlineData(PakAssetType.EnvCellMesh, 0xA9B40100u)] + [InlineData(PakAssetType.GfxObjMesh, 0xFFFFFFFFu)] // max fileId + [InlineData(PakAssetType.EnvCellMesh, 0xFFFFFFFFu)] + public void ComposeDecompose_RoundTrips(PakAssetType type, uint fileId) { + ulong key = PakKey.Compose(type, fileId); + var (decodedType, decodedFileId) = PakKey.Decompose(key); + Assert.Equal(type, decodedType); + Assert.Equal(fileId, decodedFileId); + } + + [Fact] + public void Compose_LowFourBytesReserved() { + // Low 24 bits are reserved (zero in v1) — fileId << 24 must not spill + // into them, and the reserved region must actually read back as zero. + ulong key = PakKey.Compose(PakAssetType.GfxObjMesh, 0xFFFFFFFFu); + Assert.Equal(0u, (uint)(key & 0xFFFFFFu)); + } + + [Fact] + public void Compose_TypeOccupiesTopByte() { + ulong key = PakKey.Compose(PakAssetType.SetupMesh, 0u); + Assert.Equal((byte)PakAssetType.SetupMesh, (byte)(key >> 56)); + } + + [Theory] + [InlineData(PakAssetType.GfxObjMesh, 1)] + [InlineData(PakAssetType.SetupMesh, 2)] + [InlineData(PakAssetType.EnvCellMesh, 3)] + public void AssetType_NumericValuesAreStable(PakAssetType type, byte expected) { + // These values are a wire format — pin them so a future refactor can't + // silently renumber the enum and corrupt existing paks. + Assert.Equal(expected, (byte)type); + } + + [Fact] + public void KeyOrdering_MatchesTypeThenFileIdOrdering() { + // Ascending key order must equal ascending (type, fileId) tuple order — + // this is what makes the TOC's binary search over raw u64 keys valid. + var pairs = new (PakAssetType Type, uint FileId)[] { + (PakAssetType.GfxObjMesh, 0u), + (PakAssetType.GfxObjMesh, 1u), + (PakAssetType.GfxObjMesh, 0xFFFFFFFFu), + (PakAssetType.SetupMesh, 0u), + (PakAssetType.SetupMesh, 0x020019FFu), + (PakAssetType.EnvCellMesh, 0u), + (PakAssetType.EnvCellMesh, 0xA9B40100u), + }; + + var keys = pairs.Select(p => PakKey.Compose(p.Type, p.FileId)).ToArray(); + + // keys[] as generated must already be strictly ascending since pairs[] + // is in ascending tuple order. + for (int i = 1; i < keys.Length; i++) { + Assert.True(keys[i] > keys[i - 1], + $"key[{i}]=0x{keys[i]:X16} should be > key[{i - 1}]=0x{keys[i - 1]:X16} " + + $"for tuple order ({pairs[i - 1]}) < ({pairs[i]})"); + } + + // Sorting the keys numerically must reproduce the same order as sorting + // the tuples lexicographically by (Type, FileId). + var numericSorted = keys.OrderBy(k => k).ToArray(); + var tupleSorted = pairs.OrderBy(p => (byte)p.Type).ThenBy(p => p.FileId) + .Select(p => PakKey.Compose(p.Type, p.FileId)).ToArray(); + Assert.Equal(tupleSorted, numericSorted); + } +} diff --git a/tests/AcDream.Content.Tests/PakRoundTripTests.cs b/tests/AcDream.Content.Tests/PakRoundTripTests.cs new file mode 100644 index 00000000..48ec18fc --- /dev/null +++ b/tests/AcDream.Content.Tests/PakRoundTripTests.cs @@ -0,0 +1,478 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Numerics; +using AcDream.Content.Pak; + +namespace AcDream.Content.Tests; + +public class PakRoundTripTests : IDisposable { + private readonly List _tempFiles = new(); + + private string NewTempPakPath() { + var path = Path.Combine(Path.GetTempPath(), $"acdream-paktest-{Guid.NewGuid():N}.pak"); + _tempFiles.Add(path); + return path; + } + + public void Dispose() { + foreach (var f in _tempFiles) { + try { if (File.Exists(f)) File.Delete(f); } catch { /* best effort cleanup */ } + } + } + + private static ObjectMeshData MakeSyntheticData(uint fileId, int vertexCount) { + var vertices = new VertexPositionNormalTexture[vertexCount]; + for (int i = 0; i < vertexCount; i++) { + vertices[i] = new VertexPositionNormalTexture( + new Vector3(i, i * 2, i * 3), + new Vector3(0, 0, 1), + new Vector2(i * 0.1f, i * 0.2f)); + } + return new ObjectMeshData { + ObjectId = fileId, + IsSetup = false, + Vertices = vertices, + DIDDegrade = fileId + 1, + }; + } + + private static (PakAssetType Type, uint FileId, ObjectMeshData Data)[] MakeBlobSet(int n) { + var result = new (PakAssetType, uint, ObjectMeshData)[n]; + for (int i = 0; i < n; i++) { + var type = (PakAssetType)((i % 3) + 1); + uint fileId = 0x0100_0000u + (uint)i; + result[i] = (type, fileId, MakeSyntheticData(fileId, i + 1)); + } + return result; + } + + private static PakHeader WritePak(string path, (PakAssetType Type, uint FileId, ObjectMeshData Data)[] blobs) { + var header = new PakHeader { + FormatVersion = 1, + PortalIteration = 10, + CellIteration = 20, + HighResIteration = 30, + LanguageIteration = 40, + BakeToolVersion = 1, + }; + using var writer = new PakWriter(path, header); + foreach (var (type, fileId, data) in blobs) { + writer.AddBlob(PakKey.Compose(type, fileId), data); + } + writer.Finish(); + return header; + } + + [Fact] + public void WriteThenOpen_HeaderFieldsMatch() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(5); + var written = WritePak(path, blobs); + + using var reader = new PakReader(path); + Assert.Equal(written.FormatVersion, reader.Header.FormatVersion); + Assert.Equal(written.PortalIteration, reader.Header.PortalIteration); + Assert.Equal(written.CellIteration, reader.Header.CellIteration); + Assert.Equal(written.HighResIteration, reader.Header.HighResIteration); + Assert.Equal(written.LanguageIteration, reader.Header.LanguageIteration); + Assert.Equal(written.BakeToolVersion, reader.Header.BakeToolVersion); + Assert.Equal((uint)blobs.Length, reader.Header.TocCount); + } + + [Fact] + public void WriteThenOpen_EveryKeyFound() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(20); + WritePak(path, blobs); + + using var reader = new PakReader(path); + foreach (var (type, fileId, _) in blobs) { + Assert.True(reader.ContainsKey(PakKey.Compose(type, fileId)), + $"key for type={type} fileId=0x{fileId:X8} should be found"); + } + } + + [Fact] + public void WriteThenOpen_BlobsDeserializeToDeepEqualObjects() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(8); + WritePak(path, blobs); + + using var reader = new PakReader(path); + foreach (var (type, fileId, expected) in blobs) { + var key = PakKey.Compose(type, fileId); + Assert.True(reader.TryReadObjectMeshData(key, out var actual), $"expected key 0x{key:X16} to read successfully"); + ObjectMeshDataEquality.AssertEqual(expected, actual); + } + } + + [Fact] + public void MissingKey_ReturnsFalse() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(3); + WritePak(path, blobs); + + using var reader = new PakReader(path); + var missingKey = PakKey.Compose(PakAssetType.GfxObjMesh, 0xFFFF_FFFEu); + Assert.False(reader.ContainsKey(missingKey)); + Assert.False(reader.TryReadObjectMeshData(missingKey, out var data)); + Assert.Null(data); + } + + [Fact] + public void CorruptedBlob_CrcMismatch_TreatedAsMissing() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(4); + WritePak(path, blobs); + + // Flip one byte inside the FIRST blob's region (right after the 64-byte header). + using (var fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite)) { + fs.Position = PakHeader.Size + 4; // a few bytes into the first blob's payload + int b = fs.ReadByte(); + fs.Position = PakHeader.Size + 4; + fs.WriteByte((byte)(b ^ 0xFF)); + } + + using var reader = new PakReader(path); + var key = PakKey.Compose(blobs[0].Type, blobs[0].FileId); + Assert.False(reader.TryReadObjectMeshData(key, out var data), + "a CRC-mismatched blob must be treated as missing"); + Assert.Null(data); + } + + [Fact] + public void CorruptedBlob_DoesNotAffectOtherBlobs() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(4); + WritePak(path, blobs); + + using (var fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite)) { + fs.Position = PakHeader.Size + 4; + int b = fs.ReadByte(); + fs.Position = PakHeader.Size + 4; + fs.WriteByte((byte)(b ^ 0xFF)); + } + + using var reader = new PakReader(path); + // blobs[1..] should still read fine. + for (int i = 1; i < blobs.Length; i++) { + var key = PakKey.Compose(blobs[i].Type, blobs[i].FileId); + Assert.True(reader.TryReadObjectMeshData(key, out var actual), $"blob {i} should be unaffected by corruption in blob 0"); + ObjectMeshDataEquality.AssertEqual(blobs[i].Data, actual); + } + } + + [Fact] + public void Blobs_Are64ByteAligned() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(6); + WritePak(path, blobs); + + using var reader = new PakReader(path); + foreach (var (type, fileId, _) in blobs) { + var offset = reader.GetBlobOffsetForTest(PakKey.Compose(type, fileId)); + Assert.True(offset % 64 == 0, $"blob offset {offset} for type={type} fileId=0x{fileId:X8} must be 64-byte aligned"); + } + } + + [Fact] + public void TocBinarySearch_MatchesLinearScan() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(50); + WritePak(path, blobs); + + using var reader = new PakReader(path); + var allKeys = blobs.Select(b => PakKey.Compose(b.Type, b.FileId)).ToArray(); + foreach (var key in allKeys) { + bool binarySearchFound = reader.ContainsKey(key); + bool linearScanFound = reader.DebugLinearScanContainsKey(key); + Assert.Equal(linearScanFound, binarySearchFound); + } + + // Also verify a handful of keys NOT present agree between both paths. + var absentKeys = new[] { + PakKey.Compose(PakAssetType.GfxObjMesh, 0xDEAD_0000u), + PakKey.Compose(PakAssetType.SetupMesh, 0xDEAD_0001u), + PakKey.Compose(PakAssetType.EnvCellMesh, 0xDEAD_0002u), + }; + foreach (var key in absentKeys) { + Assert.Equal(reader.DebugLinearScanContainsKey(key), reader.ContainsKey(key)); + Assert.False(reader.ContainsKey(key)); + } + } + + [Fact] + public void EmptyPak_OpensCleanly_NoKeysFound() { + var path = NewTempPakPath(); + WritePak(path, Array.Empty<(PakAssetType, uint, ObjectMeshData)>()); + + using var reader = new PakReader(path); + Assert.Equal(0u, reader.Header.TocCount); + Assert.False(reader.ContainsKey(PakKey.Compose(PakAssetType.GfxObjMesh, 1))); + } + + // ---- format-version enforcement (review finding 2) --------------------- + + [Fact] + public void Writer_StampsFormatVersion_IgnoringTemplate() { + // The default-0 footgun: a caller building a header template without + // setting FormatVersion must still produce a CURRENT-version pak. + var path = NewTempPakPath(); + using (var writer = new PakWriter(path, new PakHeader { BakeToolVersion = 1 })) { + writer.AddBlob(PakKey.Compose(PakAssetType.GfxObjMesh, 1), MakeSyntheticData(1, 1)); + writer.Finish(); + } + + using var reader = new PakReader(path); + Assert.Equal(PakFormat.CurrentFormatVersion, reader.Header.FormatVersion); + } + + [Theory] + [InlineData(0u)] + [InlineData(2u)] + public void Reader_RejectsWrongFormatVersion(uint wrongVersion) { + var path = NewTempPakPath(); + WritePak(path, MakeBlobSet(2)); + + // Patch the header's formatVersion dword (offset 4) in place. + using (var fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite)) { + fs.Position = 4; + Span buf = stackalloc byte[4]; + System.Buffers.Binary.BinaryPrimitives.WriteUInt32LittleEndian(buf, wrongVersion); + fs.Write(buf); + } + + var ex = Assert.Throws(() => new PakReader(path)); + Assert.Contains($"version {wrongVersion}", ex.Message); + Assert.Contains($"version {PakFormat.CurrentFormatVersion}", ex.Message); + } + + // ---- reader robustness (review finding 3) ------------------------------- + + [Fact] + public void CorruptTocEntry_TreatedAsMissing_SiblingsUnaffected_NoThrow() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(4); + WritePak(path, blobs); + + // Patch the FIRST victim entry's length field (entry offset +16) to a + // value that runs past the file end. + var victimKey = PakKey.Compose(blobs[0].Type, blobs[0].FileId); + long entryPos = FindTocEntryPosition(path, victimKey); + using (var fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite)) { + fs.Position = entryPos + 16; + Span buf = stackalloc byte[4]; + System.Buffers.Binary.BinaryPrimitives.WriteUInt32LittleEndian(buf, 0x7FFF_FFF0u); + fs.Write(buf); + } + + using var reader = new PakReader(path); // must NOT throw — corrupt entry = missing + Assert.False(reader.ContainsKey(victimKey)); + Assert.False(reader.TryReadObjectMeshData(victimKey, out var data)); + Assert.Null(data); + + for (int i = 1; i < blobs.Length; i++) { + var key = PakKey.Compose(blobs[i].Type, blobs[i].FileId); + Assert.True(reader.TryReadObjectMeshData(key, out var sibling), $"sibling blob {i} should be unaffected"); + ObjectMeshDataEquality.AssertEqual(blobs[i].Data, sibling); + } + } + + [Fact] + public void TruncatedPak_RefusedAtOpen() { + var path = NewTempPakPath(); + WritePak(path, MakeBlobSet(4)); + + // Chop the file mid-TOC: the header claims 4 entries the file no + // longer holds — a structural fault, refused at open. + using (var fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite)) { + fs.SetLength(fs.Length - PakTocEntry.Size - 4); + } + + var ex = Assert.Throws(() => new PakReader(path)); + Assert.Contains("truncated", ex.Message); + } + + [Fact] + public void HalfWrittenPak_UnfinalizedHeader_RefusedAtOpen() { + var path = NewTempPakPath(); + // Simulate a bake crash between the placeholder-header write and + // Finish(): current-version header with TocOffset still 0, blob bytes + // behind it. + using (var fs = new FileStream(path, FileMode.Create, FileAccess.Write)) { + new PakHeader { FormatVersion = PakFormat.CurrentFormatVersion }.WriteTo(fs); + var junk = new byte[256]; + new Random(42).NextBytes(junk); + fs.Write(junk); + } + + var ex = Assert.Throws(() => new PakReader(path)); + Assert.Contains("unfinalized", ex.Message); + } + + [Fact] + public void MalformedBlobBehindValidCrc_TreatedAsMissing_SiblingsUnaffected() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(3); + WritePak(path, blobs); + + // Corrupt the FIRST blob's STRUCTURE (vertices count:i32 at blob + // offset 9 -> -1) and then RE-COMPUTE the CRC over the tampered bytes + // so the CRC tripwire passes — only the deserialization catch can + // save the read now. + var victimKey = PakKey.Compose(blobs[0].Type, blobs[0].FileId); + long entryPos = FindTocEntryPosition(path, victimKey); + using (var fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite)) { + // Read the victim entry to get offset+length. + fs.Position = entryPos; + var entryBuf = new byte[PakTocEntry.Size]; + fs.ReadExactly(entryBuf); + var entry = PakTocEntry.ReadFrom((ReadOnlySpan)entryBuf); + + // Tamper: vertices count -> -1 (ObjectId u64 + IsSetup byte = offset 9). + fs.Position = (long)entry.Offset + 9; + Span negOne = stackalloc byte[4]; + System.Buffers.Binary.BinaryPrimitives.WriteInt32LittleEndian(negOne, -1); + fs.Write(negOne); + + // Recompute CRC over the tampered blob region. + fs.Position = (long)entry.Offset; + var blobBytes = new byte[entry.Length]; + fs.ReadExactly(blobBytes); + uint newCrc = Crc32.Compute(blobBytes); + + // Patch the TOC entry's crc32 field (entry offset +20). + fs.Position = entryPos + 20; + Span crcBuf = stackalloc byte[4]; + System.Buffers.Binary.BinaryPrimitives.WriteUInt32LittleEndian(crcBuf, newCrc); + fs.Write(crcBuf); + } + + using var reader = new PakReader(path); + Assert.False(reader.TryReadObjectMeshData(victimKey, out var data), + "a structurally-malformed blob behind a matching CRC must be treated as missing"); + Assert.Null(data); + // Second read: still missing, no throw (verdict cached). + Assert.False(reader.TryReadObjectMeshData(victimKey, out _)); + + for (int i = 1; i < blobs.Length; i++) { + var key = PakKey.Compose(blobs[i].Type, blobs[i].FileId); + Assert.True(reader.TryReadObjectMeshData(key, out var sibling), $"sibling blob {i} should be unaffected"); + ObjectMeshDataEquality.AssertEqual(blobs[i].Data, sibling); + } + } + + // ---- writer disposal safety (review finding 5) --------------------------- + + [Fact] + public void WriterDisposedAfterAddBlobException_ReleasesFileHandle() { + var path = NewTempPakPath(); + var data = MakeSyntheticData(1, 1); + var key = PakKey.Compose(PakAssetType.GfxObjMesh, 1); + + var writer = new PakWriter(path, new PakHeader { BakeToolVersion = 1 }); + writer.AddBlob(key, data); + Assert.Throws(() => writer.AddBlob(key, data)); // duplicate key mid-AddBlob + writer.Dispose(); + + // The stream must be closed even after the AddBlob exception: the + // file is deletable (no leaked/locked handle). + File.Delete(path); + Assert.False(File.Exists(path)); + } + + // ---- on-disk TOC sortedness (review finding 8) --------------------------- + + [Fact] + public void OnDiskToc_IsSortedAscendingByKey_RegardlessOfAddOrder() { + var path = NewTempPakPath(); + // Add blobs in DESCENDING key order — the on-disk TOC must still come + // out ascending (the reader's binary-search precondition, asserted + // here against the raw bytes, not through the reader). + var blobs = MakeBlobSet(12).OrderByDescending(b => PakKey.Compose(b.Type, b.FileId)).ToArray(); + WritePak(path, blobs); + + var fileBytes = File.ReadAllBytes(path); + var header = PakHeader.ReadFrom((ReadOnlySpan)fileBytes); + Assert.Equal((uint)blobs.Length, header.TocCount); + + ulong previousKey = 0; + for (uint i = 0; i < header.TocCount; i++) { + int pos = checked((int)((long)header.TocOffset + i * PakTocEntry.Size)); + var entry = PakTocEntry.ReadFrom(fileBytes.AsSpan(pos, PakTocEntry.Size)); + Assert.True(entry.Key > previousKey || i == 0, + $"TOC entry {i} key 0x{entry.Key:X16} is not strictly greater than its predecessor 0x{previousKey:X16}"); + previousKey = entry.Key; + } + } + + // ---- corruption logged once (review finding 8) ---------------------------- + + [Fact] + public void CorruptBlob_RepeatedReads_LogExactlyOnce() { + var path = NewTempPakPath(); + var blobs = MakeBlobSet(2); + WritePak(path, blobs); + + // Flip a byte in the first blob (plain CRC corruption). + using (var fs = new FileStream(path, FileMode.Open, FileAccess.ReadWrite)) { + fs.Position = PakHeader.Size + 4; + int b = fs.ReadByte(); + fs.Position = PakHeader.Size + 4; + fs.WriteByte((byte)(b ^ 0xFF)); + } + + var victimKey = PakKey.Compose(blobs[0].Type, blobs[0].FileId); + var originalError = Console.Error; + var capture = new StringWriter(); + try { + Console.SetError(capture); + using var reader = new PakReader(path); + // Hammer the corrupt entry through BOTH public paths, repeatedly. + Assert.False(reader.TryReadObjectMeshData(victimKey, out _)); + Assert.False(reader.TryReadObjectMeshData(victimKey, out _)); + Assert.False(reader.ContainsKey(victimKey)); + Assert.False(reader.ContainsKey(victimKey)); + Assert.False(reader.TryReadObjectMeshData(victimKey, out _)); + } + finally { + Console.SetError(originalError); + } + + string logged = capture.ToString(); + int occurrences = CountOccurrences(logged, $"0x{victimKey:X16}"); + Assert.True(occurrences == 1, + $"expected exactly ONE [pak-corrupt] line for key 0x{victimKey:X16} across 5 reads, got {occurrences}:\n{logged}"); + } + + private static int CountOccurrences(string haystack, string needle) { + int count = 0, index = 0; + while ((index = haystack.IndexOf(needle, index, StringComparison.Ordinal)) >= 0) { + count++; + index += needle.Length; + } + return count; + } + + // ---- helpers ------------------------------------------------------------- + + /// Locates the on-disk file position of the TOC entry for by raw parsing. + private static long FindTocEntryPosition(string path, ulong key) { + using var fs = new FileStream(path, FileMode.Open, FileAccess.Read); + var headerBuf = new byte[PakHeader.Size]; + fs.ReadExactly(headerBuf); + var header = PakHeader.ReadFrom((ReadOnlySpan)headerBuf); + + var entryBuf = new byte[PakTocEntry.Size]; + for (uint i = 0; i < header.TocCount; i++) { + long pos = (long)header.TocOffset + i * PakTocEntry.Size; + fs.Position = pos; + fs.ReadExactly(entryBuf); + var entry = PakTocEntry.ReadFrom((ReadOnlySpan)entryBuf); + if (entry.Key == key) return pos; + } + throw new InvalidOperationException($"TOC entry for key 0x{key:X16} not found"); + } +} diff --git a/tests/AcDream.Core.Net.Tests/Messages/AutonomousPositionTests.cs b/tests/AcDream.Core.Net.Tests/Messages/AutonomousPositionTests.cs index 630cae6f..9652f3e1 100644 --- a/tests/AcDream.Core.Net.Tests/Messages/AutonomousPositionTests.cs +++ b/tests/AcDream.Core.Net.Tests/Messages/AutonomousPositionTests.cs @@ -122,6 +122,69 @@ public class AutonomousPositionTests Assert.Equal(0, body[52]); } + [Fact] + public void Build_TimestampOrder_MatchesAutonomousPositionPackPack() + { + // AutonomousPositionPack::Pack (0x00516af0, confirmed via Ghidra + // decompile-by-address during this slice 2026-06-30): after + // Position::Pack (32 bytes), four u16 timestamps in order + // instance_timestamp, server_control_timestamp, teleport_timestamp, + // force_position_ts — then a CONTACT-ONLY byte (no longjump bit; + // that bit only exists in MoveToStatePack), then ALIGN_PTR. + var body = AutonomousPosition.Build( + gameActionSequence: 8, + cellId: 0xA9B40001u, + position: Vector3.Zero, + rotation: Quaternion.Identity, + instanceSequence: 0x1111, + serverControlSequence: 0x2222, + teleportSequence: 0x3333, + forcePositionSequence: 0x4444); + + // 12 (envelope) + 32 (Position) = 44. + int tsOffset = 44; + ushort instance = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset)); + ushort serverControl = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset + 2)); + ushort teleport = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset + 4)); + ushort forcePosition = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset + 6)); + + Assert.Equal((ushort)0x1111, instance); + Assert.Equal((ushort)0x2222, serverControl); + Assert.Equal((ushort)0x3333, teleport); + Assert.Equal((ushort)0x4444, forcePosition); + } + + [Fact] + public void Build_ContactByte_IsContactOnly_NoLongjumpBit() + { + // contact != 0 -> byte = 1 (bool cast, not an OR'd bitmask like MTS). + var bodyOnGround = AutonomousPosition.Build( + gameActionSequence: 9, + cellId: 0xA9B40001u, + position: Vector3.Zero, + rotation: Quaternion.Identity, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0, + lastContact: 1); + + Assert.Equal(1, bodyOnGround[52]); + + var bodyAirborne = AutonomousPosition.Build( + gameActionSequence: 10, + cellId: 0xA9B40001u, + position: Vector3.Zero, + rotation: Quaternion.Identity, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0, + lastContact: 0); + + Assert.Equal(0, bodyAirborne[52]); + } + [Fact] public void Build_ContainsIdentityRotation_AfterPosition() { diff --git a/tests/AcDream.Core.Net.Tests/Messages/CreateObjectTests.cs b/tests/AcDream.Core.Net.Tests/Messages/CreateObjectTests.cs index 5c5f2cec..e7fef4e1 100644 --- a/tests/AcDream.Core.Net.Tests/Messages/CreateObjectTests.cs +++ b/tests/AcDream.Core.Net.Tests/Messages/CreateObjectTests.cs @@ -440,6 +440,21 @@ public sealed class CreateObjectTests Assert.Equal(7.5f, p.Workmanship); } + [Fact] + public void TryParse_MovementSequence_SurfacedFromTimestampBlock() + { + // L.2g S1 (DEV-6): index 1 of the 9-u16 PhysicsDesc timestamp block + // is ObjectMovement (ACE WorldObject_Networking.cs:412) — it seeds + // MotionSequenceGate's MOVEMENT_TS so post-spawn UpdateMotion events + // are judged against the entity's live sequence, not zero. + byte[] body = BuildMinimalCreateObjectWithWeenieHeader( + guid: 0x50000030u, name: "Runner", itemType: 0x10u, + movementSeq: 0x9000); + var parsed = CreateObject.TryParse(body); + Assert.NotNull(parsed); + Assert.Equal((ushort)0x9000, parsed!.Value.MovementSequence); + } + [Fact] public void TryParse_MidTailFieldsSet_StillReachesIconOverlay() { @@ -484,7 +499,8 @@ public sealed class CreateObjectTests uint? validLocations = null, uint? currentWieldedLocation = null, uint? priority = null, - float? workmanship = null) + float? workmanship = null, + ushort movementSeq = 0) { var bytes = new List(); WriteU32(bytes, CreateObject.Opcode); @@ -496,11 +512,12 @@ public sealed class CreateObjectTests bytes.Add(0); bytes.Add(0); - // PhysicsData: physics flags = 0, then PhysicsState u32, then 9 seq stamps. + // PhysicsData: physics flags = 0, then PhysicsState u32, then 9 seq stamps + // (PhysicsTimeStamp enum order; index 1 = ObjectMovement). WriteU32(bytes, 0); WriteU32(bytes, physicsState); for (int i = 0; i < 9; i++) - WriteU16(bytes, 0); + WriteU16(bytes, i == 1 ? movementSeq : (ushort)0); Align4(bytes); // Fixed WeenieHeader prefix per ACE SerializeCreateObject. diff --git a/tests/AcDream.Core.Net.Tests/Messages/JumpActionTests.cs b/tests/AcDream.Core.Net.Tests/Messages/JumpActionTests.cs new file mode 100644 index 00000000..779ab40c --- /dev/null +++ b/tests/AcDream.Core.Net.Tests/Messages/JumpActionTests.cs @@ -0,0 +1,170 @@ +using System; +using System.Buffers.Binary; +using System.Numerics; +using AcDream.Core.Net.Messages; +using Xunit; + +namespace AcDream.Core.Net.Tests.Messages; + +/// +/// Golden-byte tests for the retail-faithful +/// layout, porting JumpPack::Pack (0x00516d10, decomp lines +/// ~284934-284963). Confirmed verbatim against the Ghidra decompile-by-address +/// bridge (http://127.0.0.1:8081/decompile_function?address=0x00516d10) +/// during this slice (2026-06-30): +/// +/// +/// extent (f32), velocity.x/y/z (f32 x3), Position::Pack (cellId + Frame), +/// instance_timestamp (u16), server_control_timestamp (u16), +/// teleport_timestamp (u16), force_position_ts (u16), ALIGN_PTR. +/// +/// +/// D4: retail does NOT pack an objectGuid or spellId. The pre-slice acdream +/// code wrote two spurious trailing u32 0 fields and omitted Position +/// entirely — both are fixed here. +/// +public class JumpActionTests +{ + [Fact] + public void Build_ProducesValidGameAction() + { + var body = JumpAction.Build( + gameActionSequence: 9, + extent: 0.5f, + velocity: new Vector3(1f, 2f, 3f), + cellId: 0xA9B40001u, + position: new Vector3(96f, 96f, 50f), + rotation: Quaternion.Identity, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0); + + uint opcode = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(0)); + Assert.Equal(0xF7B1u, opcode); + + uint seq = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(4)); + Assert.Equal(9u, seq); + + uint actionType = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(8)); + Assert.Equal(0xF61Bu, actionType); + } + + [Fact] + public void Build_ExtentAndVelocity_FollowEnvelope() + { + var body = JumpAction.Build( + gameActionSequence: 1, + extent: 0.75f, + velocity: new Vector3(1.5f, -2.5f, 9.81f), + cellId: 0xA9B40001u, + position: Vector3.Zero, + rotation: Quaternion.Identity, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0); + + // 12-byte envelope, then extent(4), vx(4), vy(4), vz(4). + float extent = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(12)); + float vx = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(16)); + float vy = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(20)); + float vz = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(24)); + + Assert.Equal(0.75f, extent); + Assert.Equal(1.5f, vx); + Assert.Equal(-2.5f, vy); + Assert.Equal(9.81f, vz); + } + + [Fact] + public void Build_PositionFollowsVelocity_CellIdThenOriginThenQuaternion() + { + var body = JumpAction.Build( + gameActionSequence: 2, + extent: 0f, + velocity: Vector3.Zero, + cellId: 0xDEADBEEFu, + position: new Vector3(12.5f, 34.0f, 56.75f), + rotation: Quaternion.Identity, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0); + + // 12 (envelope) + 4 (extent) + 12 (velocity) = offset 28 -> Position::Pack. + int positionOffset = 28; + uint cellId = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(positionOffset)); + float x = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(positionOffset + 4)); + float y = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(positionOffset + 8)); + float z = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(positionOffset + 12)); + float qw = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(positionOffset + 16)); + float qx = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(positionOffset + 20)); + float qy = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(positionOffset + 24)); + float qz = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(positionOffset + 28)); + + Assert.Equal(0xDEADBEEFu, cellId); + Assert.Equal(12.5f, x); + Assert.Equal(34.0f, y); + Assert.Equal(56.75f, z); + Assert.Equal(1.0f, qw); + Assert.Equal(0.0f, qx); + Assert.Equal(0.0f, qy); + Assert.Equal(0.0f, qz); + } + + [Fact] + public void Build_TimestampsFollowPosition_InRetailOrder() + { + var body = JumpAction.Build( + gameActionSequence: 3, + extent: 0f, + velocity: Vector3.Zero, + cellId: 0xA9B40001u, + position: Vector3.Zero, + rotation: Quaternion.Identity, + instanceSequence: 0x1111, + serverControlSequence: 0x2222, + teleportSequence: 0x3333, + forcePositionSequence: 0x4444); + + // Position::Pack is 32 bytes (cellId + Frame). Timestamps start at + // 28 (extent/velocity/envelope) + 32 = 60. + int tsOffset = 60; + ushort instance = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset)); + ushort serverControl = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset + 2)); + ushort teleport = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset + 4)); + ushort forcePosition = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset + 6)); + + Assert.Equal((ushort)0x1111, instance); + Assert.Equal((ushort)0x2222, serverControl); + Assert.Equal((ushort)0x3333, teleport); + Assert.Equal((ushort)0x4444, forcePosition); + } + + [Fact] + public void Build_NoObjectGuidOrSpellId_JumpPackBodyLengthIs56() + { + // JumpPack::Pack body (everything AFTER the 12-byte GameAction + // envelope): extent(4) + velocity(12) + Position(32) + + // 4x u16 timestamps(8) = 56 bytes, already a multiple of 4 -> no + // align padding. Total wire length = 12 (envelope) + 56 = 68. + // Retail's JumpPack has NO objectGuid/spellId fields (D4) — the + // pre-slice code's two spurious trailing u32 writes are gone. + var body = JumpAction.Build( + gameActionSequence: 4, + extent: 0f, + velocity: Vector3.Zero, + cellId: 0xA9B40001u, + position: Vector3.Zero, + rotation: Quaternion.Identity, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0); + + Assert.Equal(56, body.Length - 12); + Assert.Equal(68, body.Length); + Assert.Equal(0, body.Length % 4); + } +} diff --git a/tests/AcDream.Core.Net.Tests/Messages/MoveToStateGoldenTests.cs b/tests/AcDream.Core.Net.Tests/Messages/MoveToStateGoldenTests.cs new file mode 100644 index 00000000..83c0bd19 --- /dev/null +++ b/tests/AcDream.Core.Net.Tests/Messages/MoveToStateGoldenTests.cs @@ -0,0 +1,254 @@ +using System; +using System.Buffers.Binary; +using System.Numerics; +using AcDream.Core.Net.Messages; +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Net.Tests.Messages; + +/// +/// Full-message golden-byte tests for the refactored +/// (D1 default-difference RawMotionState packing + D3 trailing byte), porting +/// MoveToStatePack::Pack (0x005168f0, decomp lines ~284694-284722). +/// Confirmed verbatim against the Ghidra decompile-by-address bridge during +/// this slice (2026-06-30): +/// +/// +/// MoveToStatePack::Pack: +/// RawMotionState::Pack(...) +/// Position::Pack(...) +/// instance_timestamp(u16), server_control_timestamp(u16), +/// teleport_timestamp(u16), force_position_ts(u16) +/// trailing byte = ((longjump_mode != 0) ? 0x02 : 0) | (contact != 0 ? 0x01 : 0) +/// ALIGN_PTR +/// +/// +public class MoveToStateGoldenTests +{ + private static readonly Vector3 Pos = new(96f, 96f, 50f); + private static readonly Quaternion Rot = Quaternion.Identity; + + [Fact] + public void Build_DefaultRawMotionState_FlagsAreZero_EnvelopePlusPositionPlusTimestampsPlusTrailingByte() + { + var body = MoveToState.Build( + gameActionSequence: 1, + rawMotionState: RawMotionState.Default, + cellId: 0xA9B40001u, + position: Pos, + rotation: Rot, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0, + contact: true, + standingLongjump: false); + + // 12 (envelope) + 4 (flags=0, no fields) + 32 (Position) + 8 (timestamps) + // + 1 (trailing byte) = 57, aligned to 60. + Assert.Equal(60, body.Length); + + uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(12)); + Assert.Equal(0u, flags); + + uint cellId = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(16)); + Assert.Equal(0xA9B40001u, cellId); + + // trailing byte at 12+4+32+8 = 56: contact=true, longjump=false -> 0x01 + Assert.Equal(0x01, body[56]); + } + + [Fact] + public void Build_WalkForward_OmitsForwardSpeedDefault() + { + // Walk-forward at default speed 1.0 -> forward_speed bit OMITTED (D1 fix). + var state = new RawMotionState + { + CurrentHoldKey = HoldKey.None, // default, omitted + ForwardCommand = 0x45000005u, // WalkForward + ForwardHoldKey = HoldKey.None, // differs from Invalid -> set + ForwardSpeed = 1.0f, // default, omitted + }; + + var body = MoveToState.Build( + gameActionSequence: 2, + rawMotionState: state, + cellId: 0xA9B40001u, + position: Pos, + rotation: Rot, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0, + contact: true, + standingLongjump: false); + + uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(12)); + Assert.Equal(0x0000000Cu, flags); // ForwardCommand | ForwardHoldKey only + + // RawMotionState body = flags(4) + fwd_cmd(4) + fwd_holdkey(4) = 12. + uint cellId = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(12 + 12)); + Assert.Equal(0xA9B40001u, cellId); + } + + [Fact] + public void Build_RunForward_IncludesHoldKeyAndSpeed() + { + var state = new RawMotionState + { + CurrentHoldKey = HoldKey.Run, + ForwardCommand = 0x44000007u, // RunForward + ForwardHoldKey = HoldKey.Run, + ForwardSpeed = 2.94f, + }; + + var body = MoveToState.Build( + gameActionSequence: 3, + rawMotionState: state, + cellId: 0xA9B40001u, + position: Pos, + rotation: Rot, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0, + contact: true, + standingLongjump: false); + + uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(12)); + Assert.Equal(0x0000001Du, flags); // holdkey | fwd_cmd | fwd_holdkey | fwd_speed + + // RawMotionState body = flags(4) + holdkey(4) + fwd_cmd(4) + fwd_holdkey(4) + fwd_speed(4) = 20. + uint cellId = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(12 + 20)); + Assert.Equal(0xA9B40001u, cellId); + } + + [Fact] + public void Build_Sidestep_SetsSidestepBitsOnly() + { + var state = new RawMotionState + { + SidestepCommand = 0x6500000Fu, // SideStepRight + SidestepHoldKey = HoldKey.None, + SidestepSpeed = 1.0f, // default -> omitted + }; + + var body = MoveToState.Build( + gameActionSequence: 4, + rawMotionState: state, + cellId: 0xA9B40001u, + position: Pos, + rotation: Rot, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0, + contact: true, + standingLongjump: false); + + uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(12)); + Assert.Equal(0x00000060u, flags); // SidestepCommand(0x20) | SidestepHoldKey(0x40) + } + + [Fact] + public void Build_Turn_SetsTurnBitsOnly() + { + var state = new RawMotionState + { + TurnCommand = 0x6500000Du, // TurnRight + TurnHoldKey = HoldKey.None, + TurnSpeed = 1.0f, // default -> omitted + }; + + var body = MoveToState.Build( + gameActionSequence: 5, + rawMotionState: state, + cellId: 0xA9B40001u, + position: Pos, + rotation: Rot, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0, + contact: true, + standingLongjump: false); + + uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(12)); + Assert.Equal(0x00000300u, flags); // TurnCommand(0x100) | TurnHoldKey(0x200) + } + + [Theory] + [InlineData(false, false, 0x00)] + [InlineData(true, false, 0x01)] + [InlineData(false, true, 0x02)] + [InlineData(true, true, 0x03)] + public void Build_TrailingByte_AllFourContactLongjumpCombinations(bool contact, bool standingLongjump, byte expected) + { + // MoveToStatePack::Pack trailing byte: + // ((longjump_mode != 0) ? 0x02 : 0) | (contact != 0 ? 0x01 : 0) + var body = MoveToState.Build( + gameActionSequence: 6, + rawMotionState: RawMotionState.Default, + cellId: 0xA9B40001u, + position: Pos, + rotation: Rot, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0, + contact: contact, + standingLongjump: standingLongjump); + + // flags(4) + Position(32) + timestamps(8) = 44; trailing byte at 12+44=56. + Assert.Equal(expected, body[56]); + } + + [Fact] + public void Build_TimestampOrder_MatchesMoveToStatePackPack() + { + var body = MoveToState.Build( + gameActionSequence: 7, + rawMotionState: RawMotionState.Default, + cellId: 0xA9B40001u, + position: Pos, + rotation: Rot, + instanceSequence: 0x1111, + serverControlSequence: 0x2222, + teleportSequence: 0x3333, + forcePositionSequence: 0x4444, + contact: true, + standingLongjump: false); + + // 12 (envelope) + 4 (flags) + 32 (Position) = 48. + int tsOffset = 48; + ushort instance = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset)); + ushort serverControl = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset + 2)); + ushort teleport = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset + 4)); + ushort forcePosition = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(tsOffset + 6)); + + Assert.Equal((ushort)0x1111, instance); + Assert.Equal((ushort)0x2222, serverControl); + Assert.Equal((ushort)0x3333, teleport); + Assert.Equal((ushort)0x4444, forcePosition); + } + + [Fact] + public void Build_IsAlignedTo4Bytes() + { + var body = MoveToState.Build( + gameActionSequence: 8, + rawMotionState: RawMotionState.Default, + cellId: 0xA9B40001u, + position: Pos, + rotation: Rot, + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0, + contact: true, + standingLongjump: false); + + Assert.Equal(0, body.Length % 4); + } +} diff --git a/tests/AcDream.Core.Net.Tests/Messages/MoveToStateTests.cs b/tests/AcDream.Core.Net.Tests/Messages/MoveToStateTests.cs index 53f95d60..d5729940 100644 --- a/tests/AcDream.Core.Net.Tests/Messages/MoveToStateTests.cs +++ b/tests/AcDream.Core.Net.Tests/Messages/MoveToStateTests.cs @@ -2,26 +2,36 @@ using System; using System.Buffers.Binary; using System.Numerics; using AcDream.Core.Net.Messages; +using AcDream.Core.Physics; using Xunit; namespace AcDream.Core.Net.Tests.Messages; +/// +/// Envelope + structural tests for . Golden +/// byte-layout tests for the RawMotionState default-difference packing (D1) +/// and the trailing contact/longjump byte (D3) live in +/// and . +/// +/// D1/D3 refactor (2026-06-30): Build now takes a +/// snapshot (matching retail's +/// CPhysicsObj::InqRawMotionState()) instead of flat nullable +/// per-axis params, plus explicit contact/standingLongjump +/// booleans for the trailing byte — see MoveToStatePack::Pack +/// (0x005168f0). +/// public class MoveToStateTests { + private static readonly Vector3 Pos = new(96f, 96f, 50f); + [Fact] public void Build_IdleState_ProducesValidGameAction() { var body = MoveToState.Build( gameActionSequence: 1, - forwardCommand: null, - forwardSpeed: null, - sidestepCommand: null, - sidestepSpeed: null, - turnCommand: null, - turnSpeed: null, - holdKey: null, + rawMotionState: RawMotionState.Default, cellId: 0xA9B40001u, - position: new Vector3(96f, 96f, 50f), + position: Pos, rotation: Quaternion.Identity, instanceSequence: 0, serverControlSequence: 0, @@ -42,31 +52,33 @@ public class MoveToStateTests } [Fact] - public void Build_WalkForward_IncludesForwardCommandInFlags() + public void Build_WalkForward_DefaultSpeedOmitted_OnlyCommandAndHoldKeyFlagsSet() { + // D1 fix: forward_speed == 1.0 (the retail default) is OMITTED from + // the flags, unlike the pre-slice presence-based packer which always + // set the ForwardSpeed bit whenever a caller supplied a value. + var state = new RawMotionState + { + ForwardCommand = 0x45000005u, // WalkForward + ForwardHoldKey = HoldKey.None, // differs from Invalid -> set + ForwardSpeed = 1.0f, // default -> omitted + }; + var body = MoveToState.Build( gameActionSequence: 2, - forwardCommand: 0x45000005u, // WalkForward - forwardSpeed: 1.0f, - sidestepCommand: null, - sidestepSpeed: null, - turnCommand: null, - turnSpeed: null, - holdKey: null, + rawMotionState: state, cellId: 0xA9B40001u, - position: new Vector3(96f, 96f, 50f), + position: Pos, rotation: Quaternion.Identity, instanceSequence: 0, serverControlSequence: 0, teleportSequence: 0, forcePositionSequence: 0); - // After the 12-byte GameAction header comes RawMotionState. - // First u32 is the packed flags word. ForwardCommand flag = 0x4. uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(12)); Assert.True((flags & 0x4u) != 0, "ForwardCommand flag (0x4) should be set"); - // ForwardSpeed flag = 0x10 - Assert.True((flags & 0x10u) != 0, "ForwardSpeed flag (0x10) should be set"); + Assert.True((flags & 0x8u) != 0, "ForwardHoldKey flag (0x8) should be set"); + Assert.False((flags & 0x10u) != 0, "ForwardSpeed flag (0x10) must be OMITTED at the retail default 1.0"); } [Fact] @@ -74,13 +86,7 @@ public class MoveToStateTests { var body = MoveToState.Build( gameActionSequence: 3, - forwardCommand: null, - forwardSpeed: null, - sidestepCommand: null, - sidestepSpeed: null, - turnCommand: null, - turnSpeed: null, - holdKey: null, + rawMotionState: RawMotionState.Default, cellId: 0xA9B40001u, position: Vector3.Zero, rotation: Quaternion.Identity, @@ -94,19 +100,14 @@ public class MoveToStateTests } [Fact] - public void Build_IdleState_WorldPositionFollowsMotionState() + public void Build_IdleState_WorldPositionFollowsZeroFlagMotionState() { - // With no motion state, flags = 0 and no conditional fields are written. - // So WorldPosition starts at offset 12 (envelope) + 4 (flags) = 16. + // With the default raw motion state, flags = 0 and no conditional + // fields are written. So WorldPosition starts at offset 12 + // (envelope) + 4 (flags) = 16. var body = MoveToState.Build( gameActionSequence: 4, - forwardCommand: null, - forwardSpeed: null, - sidestepCommand: null, - sidestepSpeed: null, - turnCommand: null, - turnSpeed: null, - holdKey: null, + rawMotionState: RawMotionState.Default, cellId: 0xDEADBEEFu, position: Vector3.Zero, rotation: Quaternion.Identity, @@ -124,13 +125,7 @@ public class MoveToStateTests { var body = MoveToState.Build( gameActionSequence: 5, - forwardCommand: null, - forwardSpeed: null, - sidestepCommand: null, - sidestepSpeed: null, - turnCommand: null, - turnSpeed: null, - holdKey: null, + rawMotionState: RawMotionState.Default, cellId: 0xA9B40001u, position: Vector3.Zero, rotation: Quaternion.Identity, @@ -143,17 +138,11 @@ public class MoveToStateTests } [Fact] - public void Build_UsesExplicitAirborneContactByte() + public void Build_UsesExplicitAirborneContact() { var body = MoveToState.Build( gameActionSequence: 7, - forwardCommand: null, - forwardSpeed: null, - sidestepCommand: null, - sidestepSpeed: null, - turnCommand: null, - turnSpeed: null, - holdKey: null, + rawMotionState: RawMotionState.Default, cellId: 0xA9B40001u, position: Vector3.Zero, rotation: Quaternion.Identity, @@ -161,23 +150,20 @@ public class MoveToStateTests serverControlSequence: 0, teleportSequence: 0, forcePositionSequence: 0, - contactLongJump: 0); + contact: false); + // flags(4) + Position(32) + timestamps(8) = 44; trailing byte at 12+44=56. Assert.Equal(0, body[56]); } [Fact] public void Build_WithHoldKey_IncludesHoldKeyFlag() { + var state = new RawMotionState { CurrentHoldKey = HoldKey.Run }; + var body = MoveToState.Build( gameActionSequence: 6, - forwardCommand: null, - forwardSpeed: null, - sidestepCommand: null, - sidestepSpeed: null, - turnCommand: null, - turnSpeed: null, - holdKey: 2u, // Run + rawMotionState: state, cellId: 0xA9B40001u, position: Vector3.Zero, rotation: Quaternion.Identity, diff --git a/tests/AcDream.Core.Net.Tests/Messages/PositionPackTests.cs b/tests/AcDream.Core.Net.Tests/Messages/PositionPackTests.cs new file mode 100644 index 00000000..95d8d983 --- /dev/null +++ b/tests/AcDream.Core.Net.Tests/Messages/PositionPackTests.cs @@ -0,0 +1,63 @@ +using System.Buffers.Binary; +using System.Numerics; +using AcDream.Core.Net.Messages; +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Net.Tests.Messages; + +/// +/// Pins the shared WorldPosition/Position block byte order used by +/// , , and +/// : Position::Pack (0x005a9640) wraps +/// cellId(u32) then Frame::Pack (0x00535130) = +/// origin.x/y/z(f32) then qw/qx/qy/qz(f32). Confirmed verbatim +/// against the Ghidra decompile-by-address bridge during this slice +/// (2026-06-30): +/// +/// +/// Position::Pack: objcell_id(u32), Frame::Pack(...) +/// Frame::Pack: m_fOrigin.x/y/z(f32 x3), qw(f32), qx(f32), qy(f32), qz(f32) +/// +/// +/// 32 bytes total (4 + 12 + 16). This was already correct pre-slice — these +/// tests lock the byte order with a golden-value assertion rather than +/// changing behavior. +/// +public class PositionPackTests +{ + [Fact] + public void MoveToState_PositionBlock_OrderIsCellIdThenOriginThenQuaternion() + { + var body = MoveToState.Build( + gameActionSequence: 1, + rawMotionState: RawMotionState.Default, + cellId: 0xA9B40001u, + position: new Vector3(1.5f, 2.5f, 3.5f), + rotation: new Quaternion(0.1f, 0.2f, 0.3f, 0.9f), // X,Y,Z,W ctor order + instanceSequence: 0, + serverControlSequence: 0, + teleportSequence: 0, + forcePositionSequence: 0); + + // No motion state -> flags(4) only before the Position block at offset 16. + int off = 12 + 4; + uint cellId = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(off)); + float x = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(off + 4)); + float y = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(off + 8)); + float z = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(off + 12)); + float qw = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(off + 16)); + float qx = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(off + 20)); + float qy = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(off + 24)); + float qz = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(off + 28)); + + Assert.Equal(0xA9B40001u, cellId); + Assert.Equal(1.5f, x); + Assert.Equal(2.5f, y); + Assert.Equal(3.5f, z); + Assert.Equal(0.9f, qw); + Assert.Equal(0.1f, qx); + Assert.Equal(0.2f, qy); + Assert.Equal(0.3f, qz); + } +} diff --git a/tests/AcDream.Core.Net.Tests/Messages/RawMotionStatePackTests.cs b/tests/AcDream.Core.Net.Tests/Messages/RawMotionStatePackTests.cs new file mode 100644 index 00000000..29025841 --- /dev/null +++ b/tests/AcDream.Core.Net.Tests/Messages/RawMotionStatePackTests.cs @@ -0,0 +1,212 @@ +using System.Buffers.Binary; +using AcDream.Core.Net.Messages; +using AcDream.Core.Net.Packets; +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Net.Tests.Messages; + +/// +/// Golden-byte tests for , porting +/// retail's RawMotionState::Pack (0x0051ed10, decomp lines +/// ~293761-294013; bitfield layout acclient.h RawMotionState::PackBitfield, +/// line 46474). Confirmed verbatim against the Ghidra decompile-by-address +/// bridge (http://127.0.0.1:8081/decompile_function?address=0x0051ed10) +/// during this slice (2026-06-30). +/// +/// +/// Retail compares every field against its DEFAULT and only sets the +/// matching bit (and emits the field) when the live value DIFFERS. This is +/// the D1 fix — the old presence-based packer over-sent defaulted fields. +/// +/// +public class RawMotionStatePackTests +{ + private static byte[] Pack(RawMotionState state) + { + var w = new PacketWriter(64); + RawMotionStatePacker.Pack(w, state); + return w.ToArray(); + } + + [Fact] + public void Pack_DefaultState_EmitsOnlyZeroFlags() + { + // Every field equals its retail default -> flags dword is 0, + // no conditional fields, no actions. 4 bytes total. + var body = Pack(RawMotionState.Default); + + Assert.Equal(new byte[] { 0x00, 0x00, 0x00, 0x00 }, body); + } + + [Fact] + public void Pack_ShiftWalk_OmitsForwardSpeedAndCurrentHoldKey() + { + // Shift-walk: current_holdkey stays None (default omitted), + // forward_command = WalkForward (0x45000005), forward_holdkey = + // None (1) -- DIFFERS from default Invalid(0) so IS sent -- + // forward_speed stays 1.0 (default, omitted). Rest default. + // + // Flags expected: ForwardCommand(0x004) | ForwardHoldKey(0x008) = 0x00C. + // Body: flags(u32) + forward_command(u32) + forward_holdkey(u32). + var state = new RawMotionState + { + CurrentHoldKey = HoldKey.None, // default -> omitted + ForwardCommand = 0x45000005u, // WalkForward -> differs -> set + ForwardHoldKey = HoldKey.None, // differs from Invalid -> set + ForwardSpeed = 1.0f, // default -> omitted (the D1 fix) + }; + + var body = Pack(state); + + Assert.Equal(12, body.Length); + + uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(0)); + Assert.Equal(0x0000000Cu, flags); + + uint fwdCommand = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(4)); + Assert.Equal(0x45000005u, fwdCommand); + + uint fwdHoldKey = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(8)); + Assert.Equal(1u, fwdHoldKey); // HoldKey.None + + byte[] expected = + { + 0x0C, 0x00, 0x00, 0x00, + 0x05, 0x00, 0x00, 0x45, + 0x01, 0x00, 0x00, 0x00, + }; + Assert.Equal(expected, body); + } + + [Fact] + public void Pack_RunForward_SetsHoldKeyForwardCommandHoldKeyAndSpeed() + { + // Run-forward: current_holdkey = Run(2) (differs from None -> set), + // forward_command = RunForward-ish 0x44000007 (differs -> set), + // forward_holdkey = Run(2) (differs from Invalid -> set), + // forward_speed = 3.0 (differs from 1.0 -> set). + // + // Flags expected: CurrentHoldKey(0x001) | ForwardCommand(0x004) | + // ForwardHoldKey(0x008) | ForwardSpeed(0x010) = 0x01D. + var state = new RawMotionState + { + CurrentHoldKey = HoldKey.Run, + ForwardCommand = 0x44000007u, + ForwardHoldKey = HoldKey.Run, + ForwardSpeed = 3.0f, + }; + + var body = Pack(state); + + Assert.Equal(20, body.Length); + + uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(0)); + Assert.Equal(0x0000001Du, flags); + + byte[] expected = + { + 0x1D, 0x00, 0x00, 0x00, // flags + 0x02, 0x00, 0x00, 0x00, // current_holdkey = Run(2) + 0x07, 0x00, 0x00, 0x44, // forward_command = 0x44000007 + 0x02, 0x00, 0x00, 0x00, // forward_holdkey = Run(2) + 0x00, 0x00, 0x40, 0x40, // forward_speed = 3.0f (0x40400000 LE) + }; + Assert.Equal(expected, body); + } + + [Fact] + public void Pack_NonDefaultCurrentStyle_SetsStyleBitAndEmitsValue() + { + // current_style differs from 0x8000003D -> bit 0x002 set, value emitted + // immediately after the flags dword (bit order: holdkey, style, ...). + var state = new RawMotionState + { + CurrentStyle = 0x80000042u, + }; + + var body = Pack(state); + + uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(0)); + Assert.Equal(0x002u, flags); + + uint style = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(4)); + Assert.Equal(0x80000042u, style); + + Assert.Equal(8, body.Length); + } + + [Fact] + public void Pack_PopulatedActionsList_SetsNumActionsBitsAndEmitsPairs() + { + // num_actions occupies bits 11-15 (mask 0xF800) of the flags dword. + // Two actions -> num_actions = 2 -> bits = 2 << 11 = 0x1000. + // Each action emits u16 command then u16 (stamp & 0x7FFF) | + // (autonomous ? 0x8000 : 0) (decomp ~293998-294010). + var state = new RawMotionState + { + Actions = new[] + { + new RawMotionAction(Command: 0x0150, Stamp: 0x0001, Autonomous: false), + new RawMotionAction(Command: 0x0163, Stamp: 0x7FFF, Autonomous: true), + }, + }; + + var body = Pack(state); + + uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(0)); + Assert.Equal(0x1000u, flags); // num_actions=2 << 11, no continuous-axis bits + + // Body: flags(4) + action0(4) + action1(4) = 12 bytes. + Assert.Equal(12, body.Length); + + ushort cmd0 = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(4)); + ushort stamp0 = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(6)); + Assert.Equal((ushort)0x0150, cmd0); + Assert.Equal((ushort)0x0001, stamp0); // autonomous=false -> 0x8000 bit clear + + ushort cmd1 = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(8)); + ushort stamp1 = BinaryPrimitives.ReadUInt16LittleEndian(body.AsSpan(10)); + Assert.Equal((ushort)0x0163, cmd1); + Assert.Equal((ushort)0xFFFF, stamp1); // (0x7FFF & 0x7FFF) | 0x8000 = 0xFFFF + } + + [Fact] + public void Pack_SidestepAndTurnNonDefault_SetExpectedBitsInOrder() + { + // sidestep_command(0x020), sidestep_holdkey(0x040), sidestep_speed(0x080), + // turn_command(0x100), turn_holdkey(0x200), turn_speed(0x400) all non-default. + var state = new RawMotionState + { + SidestepCommand = 0x44000009u, + SidestepHoldKey = HoldKey.Run, + SidestepSpeed = 1.248f, + TurnCommand = 0x4400000Du, + TurnHoldKey = HoldKey.Run, + TurnSpeed = 1.5f, + }; + + var body = Pack(state); + + uint flags = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(0)); + Assert.Equal(0x000007E0u, flags); // 0x20|0x40|0x80|0x100|0x200|0x400 + + // Body order after flags: sidestep_command, sidestep_holdkey, + // sidestep_speed, turn_command, turn_holdkey, turn_speed. + uint ssCmd = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(4)); + uint ssHold = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(8)); + float ssSpeed = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(12)); + uint turnCmd = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(16)); + uint turnHold = BinaryPrimitives.ReadUInt32LittleEndian(body.AsSpan(20)); + float turnSpeed = BinaryPrimitives.ReadSingleLittleEndian(body.AsSpan(24)); + + Assert.Equal(0x44000009u, ssCmd); + Assert.Equal(2u, ssHold); + Assert.Equal(1.248f, ssSpeed); + Assert.Equal(0x4400000Du, turnCmd); + Assert.Equal(2u, turnHold); + Assert.Equal(1.5f, turnSpeed); + + Assert.Equal(28, body.Length); + } +} diff --git a/tests/AcDream.Core.Net.Tests/Messages/UpdateMotionTests.cs b/tests/AcDream.Core.Net.Tests/Messages/UpdateMotionTests.cs index 09f9eb96..70feca2c 100644 --- a/tests/AcDream.Core.Net.Tests/Messages/UpdateMotionTests.cs +++ b/tests/AcDream.Core.Net.Tests/Messages/UpdateMotionTests.cs @@ -1,6 +1,7 @@ using System; using System.Buffers.Binary; using AcDream.Core.Net.Messages; +using AcDream.Core.Physics.Motion; using Xunit; namespace AcDream.Core.Net.Tests.Messages; @@ -303,6 +304,37 @@ public class UpdateMotionTests Assert.Equal(1.25f, result.Value.MotionState.ForwardSpeed); } + [Fact] + public void ParsesSequenceNumbersAndAutonomyFlag() + { + // L.2g S1 (DEV-6): the three staleness stamps + autonomy flag must + // survive parsing — retail gates every 0xF74C on them + // (INSTANCE_TS at dispatch, MOVEMENT_TS + SERVER_CONTROLLED_MOVE_TS + // in CPhysics::SetObjectMovement 0x00509690, which also stores + // last_move_was_autonomous). + var body = new byte[4 + 4 + 2 + 6 + 4 + 4]; + int p = 0; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xF74Cu); p += 4; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x50001234u); p += 4; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0x0102); p += 2; // instanceSeq + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0x0304); p += 2; // movementSeq + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0x0506); p += 2; // serverControlSeq + body[p++] = 1; // isAutonomous + p += 1; // Align(4) pad + body[p++] = 0; // movementType = Invalid + body[p++] = 0; // motionFlags + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0x003D); p += 2; // outer stance + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0u); p += 4; // no IMS flags + + var result = UpdateMotion.TryParse(body); + + Assert.NotNull(result); + Assert.Equal((ushort)0x0102, result!.Value.InstanceSequence); + Assert.Equal((ushort)0x0304, result.Value.MovementSequence); + Assert.Equal((ushort)0x0506, result.Value.ServerControlSequence); + Assert.True(result.Value.IsAutonomous); + } + [Fact] public void ParsesMoveToObjectTargetGuidAndOrigin() { @@ -351,4 +383,336 @@ public class UpdateMotionTests Assert.Equal(7f, path.OriginZ); Assert.Equal(1.25f, result.Value.MotionState.MoveToRunRate); } + + // ───────────────────────────────────────────────────────────────── + // R4-V3 (closes M7): mt 8 (TurnToObject) / mt 9 (TurnToHeading). + // + // Golden bytes assembled from ACE's own writers (V0-pins.md P6): + // MovementDataExtensions.Write (references/ACE/Source/ACE.Server/ + // Network/Motion/MovementData.cs:184-229) writes the common header + // (movementType u8, motionFlags u8, currentStyle u16) then dispatches + // on MovementType to: + // TurnToObjectExtensions.Write (TurnToObject.cs:25-30): + // writer.WriteGuid(Target); // u32 + // writer.Write(DesiredHeading); // f32 — the STANDALONE + // // "wire_heading" field + // writer.Write(TurnToParameters); // 3-dword UnPackNet form + // TurnToParametersExtensions.Write (TurnToParameters.cs:23-28): + // writer.Write((uint)MovementParams); // u32 bitfield + // writer.Write(Speed); // f32 + // writer.Write(DesiredHeading); // f32 — TurnToParameters' + // // OWN desired_heading + // TurnToHeadingExtensions.Write (TurnToHeading.cs:18-21): + // writer.Write(TurnToParameters); // 3-dword UnPackNet form only + // + // P6's fixture caveat: ACE always populates field2 (TurnToObject. + // DesiredHeading) and field5 (TurnToParameters.DesiredHeading) from the + // SAME motion.DesiredHeading source, so a byte-faithful ACE capture + // would have field2 == field5. To prove the parser distinguishes the + // two fields by OFFSET (not by coincidentally-equal value), these + // fixtures hand-vary the two headings. + // ───────────────────────────────────────────────────────────────── + + [Fact] + public void ParsesTurnToObject_GuidWireHeadingAndParams() + { + // Header (20 bytes) + guid (4) + wireHeading (4) + TurnToParameters (12) = 40. + var body = new byte[20 + 4 + 4 + 12]; + int p = 0; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xF74Cu); p += 4; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x80005678u); p += 4; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; + p += 6; // MovementData header padding + + body[p++] = 8; // TurnToObject + body[p++] = 0; // motionFlags + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0x003D); p += 2; + + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x80009999u); p += 4; // target guid + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 42.0f); p += 4; // standalone wire_heading (field2) + + const uint flags = 0x1u | 0x2u | 0x200u; // can_walk | can_run | move_towards + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), flags); p += 4; // TurnToParameters.bitfield + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 1.5f); p += 4; // TurnToParameters.speed + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 199.0f); p += 4; // TurnToParameters.desired_heading (field5) — DELIBERATELY != field2 + + var result = UpdateMotion.TryParse(body); + + Assert.NotNull(result); + Assert.Equal((byte)8, result!.Value.MotionState.MovementType); + Assert.True(result.Value.MotionState.IsServerControlledTurnTo); + Assert.False(result.Value.MotionState.IsServerControlledMoveTo); + Assert.NotNull(result.Value.MotionState.TurnToPath); + + var path = result.Value.MotionState.TurnToPath!.Value; + Assert.Equal(0x80009999u, path.TargetGuid); + Assert.Equal(42.0f, path.WireHeading); // field2 — distinguished by OFFSET + Assert.Equal(flags, path.Bitfield); + Assert.Equal(1.5f, path.Speed); + Assert.Equal(199.0f, path.DesiredHeading); // field5 — distinct from field2 + + // The consumer feeds this straight into FromWireTurnTo (App-layer, + // out of scope here) — verify the fixture is round-trippable. + var mp = MovementParameters.FromWireTurnTo(path.Bitfield, path.Speed, path.DesiredHeading); + Assert.True(mp.CanRun); + Assert.Equal(1.5f, mp.Speed); + Assert.Equal(199.0f, mp.DesiredHeading); + } + + [Fact] + public void ParsesTurnToObject_UnresolvableFallback_BothHeadingsSurvivedDistinctly() + { + // Retail's degrade-to-TurnToHeading fallback (decomp §2f case 8) only + // fires when GetObjectA(object_id) == 0 — a runtime/consumer-side + // resolution the wire parser has no visibility into. The parser's + // job is just to expose BOTH heading fields so the (future) V4/V5 + // consumer can implement: "if unresolvable, params.DesiredHeading = + // wireHeading, then degrade to TurnToHeading". Confirm both survive + // even when they'd trigger the fallback (i.e. even when they differ). + var body = new byte[20 + 4 + 4 + 12]; + int p = 0; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xF74Cu); p += 4; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x8000AAAAu); p += 4; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; + p += 6; + + body[p++] = 8; + body[p++] = 0; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; + + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xDEADBEEFu); p += 4; // unresolvable guid + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 270.0f); p += 4; // wire_heading — the fallback source + + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x1u); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 1.0f); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 0.0f); p += 4; // params.desired_heading (would be overwritten by wire_heading on fallback) + + var result = UpdateMotion.TryParse(body); + + Assert.NotNull(result); + var path = result!.Value.MotionState.TurnToPath!.Value; + Assert.Equal(0xDEADBEEFu, path.TargetGuid); + Assert.Equal(270.0f, path.WireHeading); + Assert.Equal(0.0f, path.DesiredHeading); + Assert.NotEqual(path.WireHeading, path.DesiredHeading); + } + + [Fact] + public void ParsesTurnToHeading_ThreeDwordFormOnly_NoGuidOrWireHeading() + { + // Header (20 bytes) + TurnToParameters (12) = 32. No guid, no + // standalone heading field — TurnToHeadingExtensions.Write emits + // ONLY the 3-dword UnPackNet form (TurnToHeading.cs:18-21). + var body = new byte[20 + 12]; + int p = 0; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xF74Cu); p += 4; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x8000BBBBu); p += 4; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; + p += 6; + + body[p++] = 9; // TurnToHeading + body[p++] = 0; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0x003D); p += 2; + + const uint flags = 0x2u | 0x800u; // can_run | set_hold_key + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), flags); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 2.0f); p += 4; // speed + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 315.0f); p += 4; // desired_heading + + var result = UpdateMotion.TryParse(body); + + Assert.NotNull(result); + Assert.Equal((byte)9, result!.Value.MotionState.MovementType); + Assert.True(result.Value.MotionState.IsServerControlledTurnTo); + Assert.NotNull(result.Value.MotionState.TurnToPath); + + var path = result.Value.MotionState.TurnToPath!.Value; + Assert.Null(path.TargetGuid); + Assert.Null(path.WireHeading); + Assert.Equal(flags, path.Bitfield); + Assert.Equal(2.0f, path.Speed); + Assert.Equal(315.0f, path.DesiredHeading); + } + + [Theory] + [InlineData(0u)] // no flags + [InlineData(0x1u | 0x2u)] // can_walk | can_run + [InlineData(0x10u)] // can_charge (fast-path bit) + [InlineData(0x3FFFFu)] // every A4 bit through 0x20000 + public void ParsesTurnToHeading_FlagPermutations_BitfieldRoundTrips(uint bitfield) + { + var body = new byte[20 + 12]; + int p = 0; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xF74Cu); p += 4; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x80001111u); p += 4; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; + p += 6; + + body[p++] = 9; + body[p++] = 0; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; + + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), bitfield); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 1.0f); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 0.0f); p += 4; + + var result = UpdateMotion.TryParse(body); + + Assert.NotNull(result); + Assert.Equal(bitfield, result!.Value.MotionState.TurnToPath!.Value.Bitfield); + } + + // ───────────────────────────────────────────────────────────────── + // R4-V3 deliverable B: mt 6/7 widened exposure. MoveToPathData already + // carries every UnPackNet field (V0/V1 shipped that); this proves the + // fixture round-trips end-to-end through MovementParameters.FromWire — + // i.e. that ALL seven UnPackNet fields (not just the three ad-hoc bool + // properties MoveToCanRun/MoveTowards/CanCharge) reach a consumer. + // ───────────────────────────────────────────────────────────────── + + [Fact] + public void MoveToPositionPath_FeedsFromWire_AllSevenFieldsSurvive() + { + var body = new byte[20 + 16 + 28 + 4]; + int p = 0; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xF74Cu); p += 4; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x80002222u); p += 4; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; + p += 6; + + body[p++] = 7; // MoveToPosition + body[p++] = 0; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0x003D); p += 2; + + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xA8B4000Eu); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 11f); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 22f); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 33f); p += 4; + + const uint flags = 0x1u | 0x2u | 0x4u | 0x8u | 0x10u | 0x200u | 0x400u; // incl. can_charge + use_spheres + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), flags); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 0.6f); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 0.1f); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 50.0f); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 1.25f); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 15.0f); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 123.0f); p += 4; + BinaryPrimitives.WriteSingleLittleEndian(body.AsSpan(p), 2.75f); p += 4; // runRate + + var result = UpdateMotion.TryParse(body); + Assert.NotNull(result); + var path = result!.Value.MotionState.MoveToPath!.Value; + + var mp = MovementParameters.FromWire( + flags, + path.DistanceToObject, + path.MinDistance, + path.FailDistance, + result.Value.MotionState.MoveToSpeed!.Value, + path.WalkRunThreshold, + path.DesiredHeading); + + Assert.True(mp.CanWalk); + Assert.True(mp.CanRun); + Assert.True(mp.CanSidestep); + Assert.True(mp.CanWalkBackwards); + Assert.True(mp.CanCharge); + Assert.True(mp.MoveTowards); + Assert.True(mp.UseSpheres); + Assert.Equal(0.6f, mp.DistanceToObject); + Assert.Equal(0.1f, mp.MinDistance); + Assert.Equal(50.0f, mp.FailDistance); + Assert.Equal(1.25f, mp.Speed); + Assert.Equal(15.0f, mp.WalkRunThreshhold); + Assert.Equal(123.0f, mp.DesiredHeading); + Assert.Equal(2.75f, result.Value.MotionState.MoveToRunRate); + } + + // ───────────────────────────────────────────────────────────────── + // R4-V3 deliverable C: the 0xF74C motionFlags sticky-guid trailer + // (mt=0/Invalid only — ACE MovementInvalid.Write gates the trailing + // guid on MotionFlags.StickToObject 0x1; decomp §2f case 0 + // @0052455d). Cursor-honesty test: bytes AFTER the trailer must still + // parse correctly (i.e. the trailer's 4 bytes were actually consumed, + // not left dangling / double-read). + // ───────────────────────────────────────────────────────────────── + + [Fact] + public void ParsesStickyGuidTrailer_WhenMotionFlagsBitSet() + { + // motionFlags byte1&0x1 (StickToObject) set; InterpretedMotionState + // flags = 0 (no fields), so the sticky guid dword immediately + // follows the packed flags dword. + var body = new byte[4 + 4 + 2 + 6 + 4 + 4 + 4]; + int p = 0; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xF74Cu); p += 4; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x80003333u); p += 4; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; + p += 6; + + body[p++] = 0; // movementType = Invalid + body[p++] = 0x1; // motionFlags = StickToObject + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0x003D); p += 2; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0u); p += 4; // no IMS flags + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x80004444u); p += 4; // sticky object guid + + var result = UpdateMotion.TryParse(body); + + Assert.NotNull(result); + Assert.Equal(0x80004444u, result!.Value.MotionState.StickyObjectGuid); + } + + [Fact] + public void SkipsStickyGuidTrailer_WhenMotionFlagsBitClear() + { + var body = new byte[4 + 4 + 2 + 6 + 4 + 4]; + int p = 0; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xF74Cu); p += 4; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x80005555u); p += 4; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; + p += 6; + + body[p++] = 0; // movementType = Invalid + body[p++] = 0; // motionFlags = none + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0x003D); p += 2; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0u); p += 4; // no IMS flags + + var result = UpdateMotion.TryParse(body); + + Assert.NotNull(result); + Assert.Null(result!.Value.MotionState.StickyObjectGuid); + } + + [Fact] + public void ParsesStickyGuidTrailer_CursorHonesty_BytesAfterTrailerStillParseCorrectly() + { + // Sticky trailer with the ForwardCommand flag ALSO set, so there are + // bytes both BEFORE (forwardCommand u16) and the sticky dword AFTER + // the flags dword — the trailer must be read at the right offset + // (after ForwardCommand + its own 2-byte read), not glued onto the + // packed-flags dword itself. Cross-checks against ACE's actual field + // order: MovementInvalid.Write emits `State` (the whole + // InterpretedMotionState, incl. Commands list) THEN the sticky guid + // — decomp confirms the same order (UnPack first, sticky guid read + // after, r4-moveto-decomp.md:274-275). + var body = new byte[4 + 4 + 2 + 6 + 4 + 4 + 2 + 4]; + int p = 0; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0xF74Cu); p += 4; + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x80006666u); p += 4; + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; + p += 6; + + body[p++] = 0; // movementType = Invalid + body[p++] = 0x1; // motionFlags = StickToObject + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0); p += 2; // outer stance + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x2u); p += 4; // IMS flags = ForwardCommand only + BinaryPrimitives.WriteUInt16LittleEndian(body.AsSpan(p), 0x0007); p += 2; // ForwardCommand = RunForward + BinaryPrimitives.WriteUInt32LittleEndian(body.AsSpan(p), 0x80007777u); p += 4; // sticky object guid — AFTER ForwardCommand + + var result = UpdateMotion.TryParse(body); + + Assert.NotNull(result); + Assert.Equal((ushort)0x0007, result!.Value.MotionState.ForwardCommand); + Assert.Equal(0x80007777u, result.Value.MotionState.StickyObjectGuid); + } } diff --git a/tests/AcDream.Core.Tests/Combat/CombatAnimationPlannerTests.cs b/tests/AcDream.Core.Tests/Combat/CombatAnimationPlannerTests.cs index 7a4a9a1f..3a178756 100644 --- a/tests/AcDream.Core.Tests/Combat/CombatAnimationPlannerTests.cs +++ b/tests/AcDream.Core.Tests/Combat/CombatAnimationPlannerTests.cs @@ -9,12 +9,12 @@ public sealed class CombatAnimationPlannerTests [Theory] [InlineData(0x10000058u, CombatAnimationKind.MeleeSwing)] // ThrustMed [InlineData(0x1000005Bu, CombatAnimationKind.MeleeSwing)] // SlashHigh - [InlineData(0x1000017Du, CombatAnimationKind.MeleeSwing)] // OffhandDoubleThrustMed - [InlineData(0x1000018Eu, CombatAnimationKind.MeleeSwing)] // PunchFastLow + [InlineData(0x1000017Du, CombatAnimationKind.MeleeSwing)] // OffhandTripleSlashMed (DRW) + [InlineData(0x1000018Eu, CombatAnimationKind.CreatureAttack)] // AttackLow6 (DRW) — was mislabelled PunchFastLow under 2013 numbering [InlineData(0x10000061u, CombatAnimationKind.MissileAttack)] // Shoot - [InlineData(0x100000D4u, CombatAnimationKind.MissileAttack)] // Reload + [InlineData(0x40000016u, CombatAnimationKind.MissileAttack)] // Reload (DRW SubState) — was the dead 2013 value 0x100000D4 [InlineData(0x10000062u, CombatAnimationKind.CreatureAttack)] // AttackHigh1 - [InlineData(0x1000018Bu, CombatAnimationKind.CreatureAttack)] // AttackLow6 + [InlineData(0x1000018Bu, CombatAnimationKind.CreatureAttack)] // AttackLow5 (DRW) [InlineData(0x400000D3u, CombatAnimationKind.SpellCast)] // CastSpell [InlineData(0x400000E0u, CombatAnimationKind.SpellCast)] // UseMagicStaff [InlineData(0x10000051u, CombatAnimationKind.HitReaction)] // Twitch1 @@ -30,11 +30,16 @@ public sealed class CombatAnimationPlannerTests Assert.Equal(expected, CombatAnimationPlanner.ClassifyMotionCommand(command)); } + // These pin the RESOLVER (wire u16 -> full 32-bit) against the DRW enum, + // independent of the planner. wire 0x0170 is IssueSlashCommand = 0x09000170 + // (class 0x09, UI command) — there is no Action-class (0x10) entry at that + // wire; the real OffhandSlashHigh is 0x10000173 (the 2013 decomp numbers it + // 0x10000170, +3 low). See docs/research/2026-06-26-ace-vs-2013-motion-command-gap.md. [Theory] - [InlineData(0x0170, 0x10000170u)] // OffhandSlashHigh - [InlineData(0x017D, 0x1000017Du)] // OffhandDoubleThrustMed - [InlineData(0x018B, 0x1000018Bu)] // AttackLow6 - [InlineData(0x018E, 0x1000018Eu)] // PunchFastLow + [InlineData(0x0170, 0x09000170u)] // IssueSlashCommand (UI class), NOT OffhandSlashHigh + [InlineData(0x017D, 0x1000017Du)] // OffhandTripleSlashMed + [InlineData(0x018B, 0x1000018Bu)] // AttackLow5 + [InlineData(0x018E, 0x1000018Eu)] // AttackLow6 public void MotionCommandResolver_UsesNamedRetailLateCombatCommands( ushort wireCommand, uint expectedFullCommand) @@ -42,6 +47,50 @@ public sealed class CombatAnimationPlannerTests Assert.Equal(expectedFullCommand, MotionCommandResolver.ReconstructFullCommand(wireCommand)); } + // #159 parity: the full wire -> resolve -> classify pipeline for the + // late-combat block, which ACE/DRW numbers +3 above the 2013 decomp. + // CombatAnimationMotionCommands is now derived directly from + // DatReaderWriter.Enums.MotionCommand, so these ACE wire values must both + // reconstruct to their DRW full value AND classify into the right kind. + // (Expected full/kind pairs cross-checked against the DRW MotionCommand + // enum, Chorizite.DatReaderWriter 2.1.7.) + [Theory] + [InlineData((ushort)0x0173, 0x10000173u, CombatAnimationKind.MeleeSwing)] // OffhandSlashHigh + [InlineData((ushort)0x0175, 0x10000175u, CombatAnimationKind.MeleeSwing)] // OffhandSlashLow + [InlineData((ushort)0x0176, 0x10000176u, CombatAnimationKind.MeleeSwing)] // OffhandThrustHigh + [InlineData((ushort)0x017E, 0x1000017Eu, CombatAnimationKind.MeleeSwing)] // OffhandTripleSlashHigh + [InlineData((ushort)0x0182, 0x10000182u, CombatAnimationKind.MeleeSwing)] // OffhandTripleThrustLow + [InlineData((ushort)0x0185, 0x10000185u, CombatAnimationKind.MeleeSwing)] // OffhandKick + [InlineData((ushort)0x0186, 0x10000186u, CombatAnimationKind.CreatureAttack)] // AttackHigh4 + [InlineData((ushort)0x0188, 0x10000188u, CombatAnimationKind.CreatureAttack)] // AttackLow4 + [InlineData((ushort)0x018C, 0x1000018Cu, CombatAnimationKind.CreatureAttack)] // AttackHigh6 + [InlineData((ushort)0x018E, 0x1000018Eu, CombatAnimationKind.CreatureAttack)] // AttackLow6 + [InlineData((ushort)0x018F, 0x1000018Fu, CombatAnimationKind.MeleeSwing)] // PunchFastHigh + [InlineData((ushort)0x0191, 0x10000191u, CombatAnimationKind.MeleeSwing)] // PunchFastLow + [InlineData((ushort)0x0197, 0x10000197u, CombatAnimationKind.MeleeSwing)] // OffhandPunchFastLow + [InlineData((ushort)0x019A, 0x1000019Au, CombatAnimationKind.MeleeSwing)] // OffhandPunchSlowLow + public void PlanFromWireCommand_LateCombatBlock_UsesAceDrwNumbering( + ushort wireCommand, + uint expectedFullCommand, + CombatAnimationKind expectedKind) + { + var plan = CombatAnimationPlanner.PlanFromWireCommand(wireCommand); + Assert.Equal(expectedFullCommand, plan.MotionCommand); + Assert.Equal(expectedKind, plan.Kind); + } + + // #159: Reload is the DRW SubState 0x40000016 (wire 0x0016), not the dead + // 2013 value 0x100000D4 the planner used to hold (absent from DRW entirely). + [Fact] + public void PlanFromWireCommand_Reload_UsesDrwSubStateValue() + { + var plan = CombatAnimationPlanner.PlanFromWireCommand(0x0016); + + Assert.Equal(0x40000016u, plan.MotionCommand); + Assert.Equal(CombatAnimationKind.MissileAttack, plan.Kind); + Assert.Equal(AnimationCommandRouteKind.SubState, plan.RouteKind); + } + [Fact] public void PlanFromWireCommand_Swing_IsActionOverlay() { diff --git a/tests/AcDream.Core.Tests/Conformance/Issue119UpNullGfxObjDumpTests.cs b/tests/AcDream.Core.Tests/Conformance/Issue119UpNullGfxObjDumpTests.cs index be5e4413..0b123199 100644 --- a/tests/AcDream.Core.Tests/Conformance/Issue119UpNullGfxObjDumpTests.cs +++ b/tests/AcDream.Core.Tests/Conformance/Issue119UpNullGfxObjDumpTests.cs @@ -16,9 +16,11 @@ namespace AcDream.Core.Tests.Conformance; /// invisible)` at startup (t5-gate-launch.log:33-34); the old tower shows /// missing stair parts (visible in retail — user axiom). UploadGfxObjMeshData /// returns null only when the PREPARE phase produced ZERO vertices -/// (ObjectMeshManager.cs:1780), so the upload is innocent — some extraction +/// (ObjectMeshManager.UploadGfxObjMeshData's empty-vertices guard), so the +/// upload is innocent — some extraction /// gate dropped every polygon. This dump prints the raw dat facts per polygon -/// and replicates PrepareGfxObjMeshData's gates (ObjectMeshManager.cs:1040-1058) +/// and replicates MeshExtractor.PrepareGfxObjMeshData's gates (moved from +/// ObjectMeshManager in MP1a) /// so the zeroing gate reads directly off the output. /// public sealed class Issue119UpNullGfxObjDumpTests diff --git a/tests/AcDream.Core.Tests/Conformance/StipplingSurfaceEquivalenceTests.cs b/tests/AcDream.Core.Tests/Conformance/StipplingSurfaceEquivalenceTests.cs index 721a0ca1..db553c80 100644 --- a/tests/AcDream.Core.Tests/Conformance/StipplingSurfaceEquivalenceTests.cs +++ b/tests/AcDream.Core.Tests/Conformance/StipplingSurfaceEquivalenceTests.cs @@ -16,8 +16,8 @@ namespace AcDream.Core.Tests.Conformance; /// (0x2) and BASE1_CLIPMAP (0x4) are skipped (D3DPolyRender inner draw, /// Ghidra 0x0059d4a0; default on @0x00820e30). acdream suppresses them at /// BUILD time via Stippling.NoPos in all four extraction paths -/// (ObjectMeshManager.PrepareGfxObjMeshData:1046 + PrepareCellStructMeshData -/// :1394, CellMesh.Build:44, GfxObjMesh.Build:71). +/// (MeshExtractor.PrepareGfxObjMeshData + PrepareCellStructMeshData +/// [moved from ObjectMeshManager in MP1a], CellMesh.Build:44, GfxObjMesh.Build:71). /// /// These criteria are equivalent ONLY if NoPos ⇔ untextured-surface holds on /// the content. This sweep pins both directions across the populated diff --git a/tests/AcDream.Core.Tests/Fixtures/issue185/0x01000AC5.gfxobj.json b/tests/AcDream.Core.Tests/Fixtures/issue185/0x01000AC5.gfxobj.json new file mode 100644 index 00000000..d6633e26 --- /dev/null +++ b/tests/AcDream.Core.Tests/Fixtures/issue185/0x01000AC5.gfxobj.json @@ -0,0 +1,221 @@ +{ + "GfxObjId": 16779973, + "BoundingSphereOrigin": { + "X": -0.0486506, + "Y": -0.0466059, + "Z": 0.244318 + }, + "BoundingSphereRadius": 1.05416, + "ResolvedPolygons": [ + { + "Id": 0, + "NumPoints": 4, + "SidesType": 0, + "Plane": { + "Normal": { + "X": 0, + "Y": -1, + "Z": 0 + }, + "D": -0.75 + }, + "Vertices": [ + { + "X": 0.25, + "Y": -0.75, + "Z": 0.6 + }, + { + "X": -0.25, + "Y": -0.75, + "Z": 0.2 + }, + { + "X": -0.25, + "Y": -0.75, + "Z": -0.4 + }, + { + "X": 0.25, + "Y": -0.75, + "Z": 2.38419E-08 + } + ] + }, + { + "Id": 1, + "NumPoints": 4, + "SidesType": 0, + "Plane": { + "Normal": { + "X": -1, + "Y": 0, + "Z": 0 + }, + "D": -0.25 + }, + "Vertices": [ + { + "X": -0.25, + "Y": -0.75, + "Z": 0.2 + }, + { + "X": -0.25, + "Y": 0.75, + "Z": 0.2 + }, + { + "X": -0.25, + "Y": 0.75, + "Z": -0.4 + }, + { + "X": -0.25, + "Y": -0.75, + "Z": -0.4 + } + ] + }, + { + "Id": 2, + "NumPoints": 4, + "SidesType": 0, + "Plane": { + "Normal": { + "X": 0, + "Y": 1, + "Z": 0 + }, + "D": -0.75 + }, + "Vertices": [ + { + "X": -0.25, + "Y": 0.75, + "Z": 0.2 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 0.6 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 2.38419E-08 + }, + { + "X": -0.25, + "Y": 0.75, + "Z": -0.4 + } + ] + }, + { + "Id": 3, + "NumPoints": 4, + "SidesType": 0, + "Plane": { + "Normal": { + "X": 1, + "Y": 0, + "Z": 0 + }, + "D": -0.25 + }, + "Vertices": [ + { + "X": 0.25, + "Y": 0.75, + "Z": 0.6 + }, + { + "X": 0.25, + "Y": -0.75, + "Z": 0.6 + }, + { + "X": 0.25, + "Y": -0.75, + "Z": 2.38419E-08 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 2.38419E-08 + } + ] + }, + { + "Id": 4, + "NumPoints": 4, + "SidesType": 0, + "Plane": { + "Normal": { + "X": -0.62469506, + "Y": 0, + "Z": 0.78086877 + }, + "D": -0.31234753 + }, + "Vertices": [ + { + "X": 0.25, + "Y": -0.75, + "Z": 0.6 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 0.6 + }, + { + "X": -0.25, + "Y": 0.75, + "Z": 0.2 + }, + { + "X": -0.25, + "Y": -0.75, + "Z": 0.2 + } + ] + }, + { + "Id": 5, + "NumPoints": 4, + "SidesType": 0, + "Plane": { + "Normal": { + "X": 0.62469506, + "Y": 0, + "Z": -0.78086877 + }, + "D": -0.15617374 + }, + "Vertices": [ + { + "X": -0.25, + "Y": 0.75, + "Z": -0.4 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 2.38419E-08 + }, + { + "X": 0.25, + "Y": -0.75, + "Z": 2.38419E-08 + }, + { + "X": -0.25, + "Y": -0.75, + "Z": -0.4 + } + ] + } + ] +} \ No newline at end of file diff --git a/tests/AcDream.Core.Tests/Fixtures/issue185/0x01000ACA.gfxobj.json b/tests/AcDream.Core.Tests/Fixtures/issue185/0x01000ACA.gfxobj.json new file mode 100644 index 00000000..0667d129 --- /dev/null +++ b/tests/AcDream.Core.Tests/Fixtures/issue185/0x01000ACA.gfxobj.json @@ -0,0 +1,226 @@ +{ + "GfxObjId": 16779978, + "BoundingSphereOrigin": { + "X": -0.125, + "Y": 0, + "Z": 0.3 + }, + "BoundingSphereRadius": 0.900576, + "ResolvedPolygons": [ + { + "Id": 0, + "NumPoints": 3, + "SidesType": 0, + "Plane": { + "Normal": { + "X": 0, + "Y": -1, + "Z": 0 + }, + "D": -0.75 + }, + "Vertices": [ + { + "X": 0.25, + "Y": -0.75, + "Z": 0.6 + }, + { + "X": -0.5, + "Y": -0.75, + "Z": 1.78814E-08 + }, + { + "X": 0.25, + "Y": -0.75, + "Z": 2.38419E-08 + } + ] + }, + { + "Id": 1, + "NumPoints": 3, + "SidesType": 0, + "Plane": { + "Normal": { + "X": 0, + "Y": 1, + "Z": 0 + }, + "D": -0.75 + }, + "Vertices": [ + { + "X": -0.5, + "Y": 0.75, + "Z": 1.78814E-08 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 0.6 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 2.38419E-08 + } + ] + }, + { + "Id": 2, + "NumPoints": 3, + "SidesType": 0, + "Plane": { + "Normal": { + "X": 1, + "Y": 0, + "Z": 0 + }, + "D": -0.25 + }, + "Vertices": [ + { + "X": 0.25, + "Y": 0.75, + "Z": 0.6 + }, + { + "X": 0.25, + "Y": -0.75, + "Z": 0.6 + }, + { + "X": 0.25, + "Y": -0.75, + "Z": 2.38419E-08 + } + ] + }, + { + "Id": 3, + "NumPoints": 4, + "SidesType": 0, + "Plane": { + "Normal": { + "X": -0.62469506, + "Y": 0, + "Z": 0.7808688 + }, + "D": -0.31234753 + }, + "Vertices": [ + { + "X": 0.25, + "Y": -0.75, + "Z": 0.6 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 0.6 + }, + { + "X": -0.5, + "Y": 0.75, + "Z": 1.78814E-08 + }, + { + "X": -0.5, + "Y": -0.75, + "Z": 1.78814E-08 + } + ] + }, + { + "Id": 4, + "NumPoints": 3, + "SidesType": 0, + "Plane": { + "Normal": { + "X": 7.947333E-09, + "Y": 0, + "Z": -1 + }, + "D": 2.1855065E-08 + }, + "Vertices": [ + { + "X": 0.25, + "Y": -0.75, + "Z": 2.38419E-08 + }, + { + "X": -0.5, + "Y": -0.75, + "Z": 1.78814E-08 + }, + { + "X": -0.5, + "Y": 0.75, + "Z": 1.78814E-08 + } + ] + }, + { + "Id": 5, + "NumPoints": 3, + "SidesType": 0, + "Plane": { + "Normal": { + "X": 1, + "Y": 0, + "Z": 0 + }, + "D": -0.25 + }, + "Vertices": [ + { + "X": 0.25, + "Y": -0.75, + "Z": 2.38419E-08 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 2.38419E-08 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 0.6 + } + ] + }, + { + "Id": 6, + "NumPoints": 3, + "SidesType": 0, + "Plane": { + "Normal": { + "X": 7.947333E-09, + "Y": 0, + "Z": -1 + }, + "D": 2.1855065E-08 + }, + "Vertices": [ + { + "X": -0.5, + "Y": 0.75, + "Z": 1.78814E-08 + }, + { + "X": 0.25, + "Y": 0.75, + "Z": 2.38419E-08 + }, + { + "X": 0.25, + "Y": -0.75, + "Z": 2.38419E-08 + } + ] + } + ] +} \ No newline at end of file diff --git a/tests/AcDream.Core.Tests/Fixtures/l2g-observer-trace.log b/tests/AcDream.Core.Tests/Fixtures/l2g-observer-trace.log new file mode 100644 index 00000000..2a69c1fa --- /dev/null +++ b/tests/AcDream.Core.Tests/Fixtures/l2g-observer-trace.log @@ -0,0 +1,2953 @@ +Opened log file 'C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\l2g-observer-trace.log' +0:018> .sympath C:\Users\erikn\source\repos\acdream\refs +Symbol search path is: C:\Users\erikn\source\repos\acdream\refs +Expanded Symbol search path is: c:\users\erikn\source\repos\acdream\refs + +************* Path validation summary ************** +Response Time (ms) Location +OK C:\Users\erikn\source\repos\acdream\refs +0:018> .symopt+ 0x40 +Symbol options are 0xB0367: + 0x00000001 - SYMOPT_CASE_INSENSITIVE + 0x00000002 - SYMOPT_UNDNAME + 0x00000004 - SYMOPT_DEFERRED_LOADS + 0x00000020 - SYMOPT_OMAP_FIND_NEAREST + 0x00000040 - SYMOPT_LOAD_ANYTHING + 0x00000100 - SYMOPT_NO_UNQUALIFIED_LOADS + 0x00000200 - SYMOPT_FAIL_CRITICAL_ERRORS + 0x00010000 - SYMOPT_AUTO_PUBLICS + 0x00020000 - SYMOPT_NO_IMAGE_SEARCH + 0x00080000 - SYMOPT_NO_PROMPTS +0:018> .reload /f acclient.exe +0:018> +0:018> x acclient!CPhysics::SetObjectMovement +00509790 acclient!CPhysics::SetObjectMovement (class CPhysicsObj *, void *, unsigned int) +00509690 acclient!CPhysics::SetObjectMovement (class CPhysicsObj *, void *, unsigned int, unsigned short, unsigned short, int) +0:018> x acclient!MovementManager::unpack_movement +00524440 acclient!MovementManager::unpack_movement (void **, unsigned int) +0:018> x acclient!CMotionInterp::move_to_interpreted_state +005289c0 acclient!CMotionInterp::move_to_interpreted_state (class InterpretedMotionState *) +0:018> x acclient!CMotionInterp::DoInterpretedMotion +00528360 acclient!CMotionInterp::DoInterpretedMotion (unsigned long, class MovementParameters *) +0:018> +00528360 acclient!CMotionInterp::DoInterpretedMotion (unsigned long, class MovementParameters *) +0:018> r $t0 = 0 +0:018> bp acclient!CPhysics::SetObjectMovement "r $t0 = @$t0 + 1; .printf \"\\n[SOM %d] obj=%p movSeq=%x scSeq=%x auto=%x id: \", @$t0, poi(@esp+4), poi(@esp+10)&0xffff, poi(@esp+14)&0xffff, poi(@esp+18); dt acclient!CPhysicsObj poi(@esp+4) id; .if (@$t0 >= 250) { .detach } .else { gc }" +Matched: 00509790 acclient!CPhysics::SetObjectMovement (class CPhysicsObj *, void *, unsigned int) +Matched: 00509690 acclient!CPhysics::SetObjectMovement (class CPhysicsObj *, void *, unsigned int, unsigned short, unsigned short, int) +Ambiguous symbol error at 'acclient!CPhysics::SetObjectMovement "r $t0 = @$t0 + 1; .printf \"\\n[SOM %d] obj=%p movSeq=%x scSeq=%x auto=%x id: \", @$t0, poi(@esp+4), poi(@esp+10)&0xffff, poi(@esp+14)&0xffff, poi(@esp+18); dt acclient!CPhysicsObj poi(@esp+4) id; .if (@$t0 >= 250) { .detach } .else { gc }"' +0:018> bp acclient!MovementManager::unpack_movement ".printf \"[UNPACK] mm=%p\\n\", @ecx; gc" +0:018> bp acclient!CMotionInterp::move_to_interpreted_state ".printf \"[MTIS] minterp=%p ims:\\n\", @ecx; dt acclient!InterpretedMotionState poi(@esp+4); gc" +0:018> bp acclient!CMotionInterp::apply_interpreted_movement ".printf \"[AIM] minterp=%p\\n\", @ecx; gc" +0:018> bp acclient!CMotionInterp::apply_raw_movement ".printf \"[ARM] minterp=%p\\n\", @ecx; gc" +0:018> bp acclient!CMotionInterp::DoInterpretedMotion ".printf \"[DIM] minterp=%p motion=%08x\\n\", @ecx, poi(@esp+4); gc" +0:018> g +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000054 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000054 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000052 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[DIM] minterp=14fc2e00 motion=6500000d +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000052 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000052 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000053 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000052 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000053 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=40000015 +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=40000015 +[UNPACK] mm=196e1718 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=40000015 +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=14fc2e00 motion=6500000d +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000053 +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000053 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000053 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000052 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000054 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000054 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000052 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : -1.854302526 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0x6500000f + +0x014 sidestep_speed : -3 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000f +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0x6500000f + +0x014 sidestep_speed : 3 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000f +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000053 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000053 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000054 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000054 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000052 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000053 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000052 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000053 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000054 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000054 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000053 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000053 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000052 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000054 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000054 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000052 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[DIM] minterp=29ec56b8 motion=6500000d +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=6500000d +[DIM] minterp=14fc2e00 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[DIM] minterp=29ec56b8 motion=6500000d +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : -2.924999952 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=45000005 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 4.5 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=44000007 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=45000005 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 4.5 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=44000007 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[DIM] minterp=29ec56b8 motion=6500000d +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[DIM] minterp=29ec56b8 motion=6500000d +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 4.5 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=44000007 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=45000005 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 4.5 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=44000007 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 4.5 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=44000007 +[DIM] minterp=29ec56b8 motion=6500000d +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[DIM] minterp=29ec56b8 motion=6500000d +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 4.5 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=44000007 +[DIM] minterp=29ec56b8 motion=6500000d +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000052 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[DIM] minterp=29ec56b8 motion=6500000d +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[DIM] minterp=29ec56b8 motion=6500000d +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 4.5 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=44000007 +[DIM] minterp=29ec56b8 motion=6500000d +[UNPACK] mm=2a225778 +[DIM] minterp=29ec56b8 motion=80000000 +[MTIS] minterp=29ec56b8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000053 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : -1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x45000005 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=45000005 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000052 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0x6500000d + +0x01c turn_speed : 1.5 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=6500000d +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x44000007 + +0x00c forward_speed : 2.85277319 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=44000007 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000053 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=10000053 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=2a167f90 +[MTIS] minterp=29ebfd48 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=41000003 +[UNPACK] mm=196e1718 +[DIM] minterp=18e8b0f8 motion=80000000 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[UNPACK] mm=196e1718 +[MTIS] minterp=18e8b0f8 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=41000003 +[DIM] minterp=18e8b0f8 motion=1000011e +[DIM] minterp=14fc2e00 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[DIM] minterp=14fc2e00 motion=41000003 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x10000052 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=10000052 +[UNPACK] mm=2a222e50 +[MTIS] minterp=29ec3b28 ims: + +0x000 __VFN_table : 0x007c7a60 + +0x004 current_style : 0x8000003d + +0x008 forward_command : 0x41000003 + +0x00c forward_speed : 1 + +0x010 sidestep_command : 0 + +0x014 sidestep_speed : 1 + +0x018 turn_command : 0 + +0x01c turn_speed : 1 + +0x020 actions : LList +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=41000003 +[AIM] minterp=18e8b0f8 +[DIM] minterp=18e8b0f8 motion=8000003d +[DIM] minterp=18e8b0f8 motion=40000015 +[DIM] minterp=14fc2e00 motion=41000003 +[AIM] minterp=298cf070 +[DIM] minterp=298cf070 motion=8000003d +[DIM] minterp=298cf070 motion=40000015 +[AIM] minterp=14fc2e00 +[DIM] minterp=14fc2e00 motion=8000003d +[DIM] minterp=14fc2e00 motion=40000015 +[AIM] minterp=1705c458 +[DIM] minterp=1705c458 motion=8000003d +[DIM] minterp=1705c458 motion=40000015 +[AIM] minterp=29ebc6b8 +[DIM] minterp=29ebc6b8 motion=8000003d +[DIM] minterp=29ebc6b8 motion=40000015 +[AIM] minterp=29ec56b8 +[DIM] minterp=29ec56b8 motion=8000003d +[DIM] minterp=29ec56b8 motion=40000015 +[AIM] minterp=298cdcc0 +[DIM] minterp=298cdcc0 motion=8000003d +[DIM] minterp=298cdcc0 motion=40000015 +[AIM] minterp=298d6330 +[DIM] minterp=298d6330 motion=8000003d +[DIM] minterp=298d6330 motion=40000015 +[AIM] minterp=16e5c030 +[DIM] minterp=16e5c030 motion=8000003d +[DIM] minterp=16e5c030 motion=40000015 +[AIM] minterp=298d6720 +[DIM] minterp=298d6720 motion=8000003d +[DIM] minterp=298d6720 motion=40000015 +[AIM] minterp=17056788 +[DIM] minterp=17056788 motion=8000003d +[DIM] minterp=17056788 motion=40000015 +[AIM] minterp=298d5eb0 +[DIM] minterp=298d5eb0 motion=8000003d +[DIM] minterp=298d5eb0 motion=40000015 +[AIM] minterp=1788f350 +[DIM] minterp=1788f350 motion=8000003d +[DIM] minterp=1788f350 motion=40000015 +[AIM] minterp=298d99c0 +[DIM] minterp=298d99c0 motion=8000003d +[DIM] minterp=298d99c0 motion=40000015 +[AIM] minterp=1788f980 +[DIM] minterp=1788f980 motion=8000003d +[DIM] minterp=1788f980 motion=40000015 +[AIM] minterp=178917e0 +[DIM] minterp=178917e0 motion=8000003d +[DIM] minterp=178917e0 motion=40000015 +[AIM] minterp=1788ac70 +[DIM] minterp=1788ac70 motion=8000003d +[DIM] minterp=1788ac70 motion=40000015 +[AIM] minterp=1788b330 +[DIM] minterp=1788b330 motion=8000003d +[DIM] minterp=1788b330 motion=40000015 +[AIM] minterp=11209dc0 +[DIM] minterp=11209dc0 motion=8000003d +[DIM] minterp=11209dc0 motion=40000015 +[AIM] minterp=16e5bc40 +[DIM] minterp=16e5bc40 motion=8000003d +[DIM] minterp=16e5bc40 motion=40000015 +[AIM] minterp=298d0390 +[DIM] minterp=298d0390 motion=8000003d +[DIM] minterp=298d0390 motion=40000015 +[AIM] minterp=1788c770 +[DIM] minterp=1788c770 motion=8000003d +[DIM] minterp=1788c770 motion=40000015 +[AIM] minterp=16e550d0 +[DIM] minterp=16e550d0 motion=8000003d +[DIM] minterp=16e550d0 motion=40000015 +[AIM] minterp=19ad15c8 +[DIM] minterp=19ad15c8 motion=8000003d +[DIM] minterp=19ad15c8 motion=40000015 +[AIM] minterp=19ad3398 +[DIM] minterp=19ad3398 motion=8000003d +[DIM] minterp=19ad3398 motion=40000015 +[AIM] minterp=19ac4d88 +[DIM] minterp=19ac4d88 motion=8000003d +[DIM] minterp=19ac4d88 motion=40000015 +[AIM] minterp=17057868 +[DIM] minterp=17057868 motion=8000003d +[DIM] minterp=17057868 motion=40000015 +[AIM] minterp=29ec3b28 +[DIM] minterp=29ec3b28 motion=8000003d +[DIM] minterp=29ec3b28 motion=40000015 +[AIM] minterp=29ebdd38 +[DIM] minterp=29ebdd38 motion=8000003d +[DIM] minterp=29ebdd38 motion=40000015 +[AIM] minterp=19ac81d8 +[DIM] minterp=19ac81d8 motion=8000003d +[DIM] minterp=19ac81d8 motion=40000015 +[AIM] minterp=1788cfe0 +[DIM] minterp=1788cfe0 motion=8000003d +[DIM] minterp=1788cfe0 motion=40000015 +[AIM] minterp=29ebfd48 +[DIM] minterp=29ebfd48 motion=8000003d +[DIM] minterp=29ebfd48 motion=40000015 +[AIM] minterp=172f0070 +[DIM] minterp=172f0070 motion=8000003d +[DIM] minterp=172f0070 motion=40000015 +[AIM] minterp=172f1ed0 +[DIM] minterp=172f1ed0 motion=8000003d +[DIM] minterp=172f1ed0 motion=40000015 +[AIM] minterp=298c9dc0 +[DIM] minterp=298c9dc0 motion=8000003d +[DIM] minterp=298c9dc0 motion=40000015 +[AIM] minterp=298cc520 +[DIM] minterp=298cc520 motion=8000003d +[DIM] minterp=298cc520 motion=40000015 +[AIM] minterp=17056668 +[DIM] minterp=17056668 motion=8000003d +[DIM] minterp=17056668 motion=40000015 +[AIM] minterp=17059488 +[DIM] minterp=17059488 motion=8000003d +[DIM] minterp=17059488 motion=40000015 +[AIM] minterp=16e57710 +[DIM] minterp=16e57710 motion=8000003d +[DIM] minterp=16e57710 motion=40000015 +[AIM] minterp=16e59210 +[DIM] minterp=16e59210 motion=8000003d +[DIM] minterp=16e59210 motion=40000015 +[AIM] minterp=298d4170 +[DIM] minterp=298d4170 motion=8000003d +[DIM] minterp=298d4170 motion=40000015 +[AIM] minterp=1705cc38 +[DIM] minterp=1705cc38 motion=8000003d +[DIM] minterp=1705cc38 motion=40000015 +[AIM] minterp=298d4050 +[DIM] minterp=298d4050 motion=8000003d +[DIM] minterp=298d4050 motion=40000015 +[AIM] minterp=298d2c10 +[DIM] minterp=298d2c10 motion=8000003d +[DIM] minterp=298d2c10 motion=40000015 +[AIM] minterp=298d2dc0 +[DIM] minterp=298d2dc0 motion=8000003d +[DIM] minterp=298d2dc0 motion=40000015 +eax=00000000 ebx=77e57240 ecx=00000000 edx=00000000 esi=00000000 edi=00000000 +eip=77d99d8c esp=001afdcc ebp=001afea4 iopl=0 nv up ei pl nz na pe nc +cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00200206 +ntdll!NtTerminateProcess+0xc: +77d99d8c c20800 ret 8 diff --git a/tests/AcDream.Core.Tests/Input/PlayerMoveToCutoverTests.cs b/tests/AcDream.Core.Tests/Input/PlayerMoveToCutoverTests.cs new file mode 100644 index 00000000..1a32b33d --- /dev/null +++ b/tests/AcDream.Core.Tests/Input/PlayerMoveToCutoverTests.cs @@ -0,0 +1,386 @@ +using System; +using System.Numerics; +using AcDream.App.Input; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand; +using Position = AcDream.Core.Physics.Position; + +namespace AcDream.Core.Tests.Input; + +/// +/// R4-V5 — local-player MoveTo cutover: a bound +/// to the controller exactly the way GameWindow.EnterPlayerModeNow +/// binds it (Yaw-authoritative heading seams via the P5 bridge, Contact +/// transient bit, SimTimeSeconds clock) drives the player's body through +/// with NO user input — the +/// manager's _DoMotion dispatches land in InterpretedState and the +/// controller's per-frame sections turn them into Yaw rotation + body +/// velocity. Also pins the TS-36 retirement: any input edge (movement key, +/// jump) cancels the moveto through the retail +/// InterruptCurrentMovement → CancelMoveTo chain, and a cancel never fires +/// the MoveToComplete completion seam (AD-27's deferred-Use contract). +/// +public class PlayerMoveToCutoverTests +{ + private const uint NC = 0x8000003Du; + private const uint Ready = 0x41000003u; + private const uint Walk = 0x45000005u; + private const uint Run = 0x44000007u; + private const uint TurnRight = 0x6500000Du; + + private sealed class Loader : IAnimationLoader + { + private readonly System.Collections.Generic.Dictionary _anims = new(); + public void Register(uint id, Animation anim) => _anims[id] = anim; + public Animation? LoadAnimation(uint id) => _anims.TryGetValue(id, out var a) ? a : null; + } + + private static Animation MakeAnim(int frames) + { + var anim = new Animation(); + for (int f = 0; f < frames; f++) + { + var pf = new AnimationFrame(1); + pf.Frames.Add(new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }); + anim.PartFrames.Add(pf); + } + return anim; + } + + private static MotionData MakeMd(uint animId) + { + var md = new MotionData(); + QualifiedDataId qid = animId; + md.Anims.Add(new AnimData { AnimId = qid, LowFrame = 0, HighFrame = -1, Framerate = 30f }); + return md; + } + + private static AnimationSequencer MakeSequencer() + { + var setup = new Setup(); + setup.Parts.Add(0x01000000u); + setup.DefaultScale.Add(Vector3.One); + + var loader = new Loader(); + loader.Register(0x300u, MakeAnim(4)); + loader.Register(0x301u, MakeAnim(6)); + loader.Register(0x302u, MakeAnim(6)); + loader.Register(0x303u, MakeAnim(6)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NC }; + mt.StyleDefaults[(DRWMotionCommand)NC] = (DRWMotionCommand)Ready; + mt.Cycles[(int)((NC << 16) | (Ready & 0xFFFFFFu))] = MakeMd(0x300u); + mt.Cycles[(int)((NC << 16) | (Walk & 0xFFFFFFu))] = MakeMd(0x301u); + mt.Cycles[(int)((NC << 16) | (Run & 0xFFFFFFu))] = MakeMd(0x302u); + // The MoveToManager's aux-turn steering / TurnToHeading nodes + // dispatch TurnRight (adjust_motion normalizes TurnLeft into it) — + // without a table cycle the real sink's false return becomes a + // _DoMotion error and the manager cancels the moveto (retail + // dispatch-failure semantics), so the fixture needs one. + mt.Cycles[(int)((NC << 16) | (TurnRight & 0xFFFFFFu))] = MakeMd(0x303u); + return new AnimationSequencer(setup, mt, loader); + } + + private static PhysicsEngine MakeFlatEngine() + { + var engine = new PhysicsEngine(); + var heights = new byte[81]; + Array.Fill(heights, (byte)50); + var heightTable = new float[256]; + for (int i = 0; i < 256; i++) heightTable[i] = i * 1f; + var terrain = new TerrainSurface(heights, heightTable); + engine.AddLandblock(0xA9B4FFFFu, terrain, Array.Empty(), + Array.Empty(), worldOffsetX: 0f, worldOffsetY: 0f); + return engine; + } + + private sealed class Rig + { + public required PlayerMovementController Controller; + public required MoveToManager MoveTo; + public int MoveToCompleteCount; + public WeenieError LastCompleteError; + } + + /// The EnterPlayerModeNow bind set, verbatim shape: real sink, + /// Yaw-authoritative heading seams (P5 bridge), Contact bit, false + /// isInterpolating, SimTimeSeconds clock, TS-36 interrupt binding. + private static Rig MakeRig() => MakeRig(out _); + + private static Rig MakeRig(out AnimationSequencer seqOut) + { + var controller = new PlayerMovementController(MakeFlatEngine()); + var seq = MakeSequencer(); + seqOut = seq; + // Production (EnterPlayerModeNow) order: the sink binds BEFORE the + // initial SetPosition — SetPosition → StopCompletely needs the sink + // for its type-5 motion-table dispatch, the completable partner of + // the A9 pending_motions node (a null sink orphans it and the + // MoveToManager wait-for-anims gate never opens — the live stall). + controller.Motion.DefaultSink = new MotionTableDispatchSink(seq); + // #174: production wiring — HandleEnterWorld (strip + drain), not + // the bare sequence strip (which orphaned pending manager nodes). + controller.Motion.RemoveLinkAnimations = () => seq.Manager.HandleEnterWorld(); + controller.Motion.InitializeMotionTables = () => seq.Manager.InitializeState(); + controller.Motion.CheckForCompletedMotions = seq.Manager.CheckForCompletedMotions; + controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001); + controller.Yaw = 0f; // heading 90 = facing +X + + var rig = new Rig { Controller = controller, MoveTo = null! }; + var moveTo = new MoveToManager( + controller.Motion, + stopCompletely: () => controller.Motion.StopCompletely(), + getPosition: () => new Position( + controller.CellId, controller.Position, controller.BodyOrientation), + getHeading: () => MoveToMath.HeadingFromYaw(controller.Yaw), + setHeading: (h, _) => controller.Yaw = MoveToMath.YawFromHeading(h), + getOwnRadius: () => 0f, + getOwnHeight: () => 0f, + contact: () => controller.BodyInContact, + isInterpolating: () => false, + getVelocity: () => controller.BodyVelocity, + getSelfId: () => 0x5000000Au, + setTarget: (_, _, _, _) => { }, + clearTarget: () => { }, + getTargetQuantum: () => 0.0, + setTargetQuantum: _ => { }, + curTime: () => controller.SimTimeSeconds); + moveTo.MoveToComplete = err => + { + rig.MoveToCompleteCount++; + rig.LastCompleteError = err; + }; + controller.MoveTo = moveTo; + controller.Motion.InterruptCurrentMovement = + () => moveTo.CancelMoveTo(WeenieError.ActionCancelled); + rig.MoveTo = moveTo; + return rig; + } + + /// Stands in for the player sequencer's MotionDone feed (bound + /// in production via the R3-W2 MotionTableManager seam) — without it, + /// pending_motions never drains in this fixture and the manager's + /// wait-for-anims gates wedge. + private static void Drain(PlayerMovementController c) + { + while (c.Motion.MotionsPending()) + c.Motion.MotionDone(0, true); + } + + [Fact] + public void ServerMoveToPosition_WalksToArrival_WithNoUserInput() + { + var rig = MakeRig(); + var c = rig.Controller; + var dest = new Vector3(104f, 96f, 50f); // 8 m dead ahead (heading 90) + + // Mirrors the GameWindow wire path's P1 unpack store (00509730): + // a server moveto arrives with IsAutonomous=false, routing the + // per-tick pump's A3 dual dispatch to the interpreted branch. + rig.Controller.SetLastMoveWasAutonomous(false); + rig.MoveTo.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(c.CellId, dest, Quaternion.Identity), + Params = new MovementParameters { UseSpheres = false, DistanceToObject = 0.6f }, + }); + Drain(c); + Assert.True(rig.MoveTo.IsMovingTo()); + + for (int f = 0; f < 1200 && rig.MoveTo.IsMovingTo(); f++) + { + var result = c.Update(1f / 60f, new MovementInput()); + // The #75 invariant, now by construction: manager-driven motion + // never registers as a user motion-state change, so no outbound + // MoveToState is built mid-moveto. + Assert.False(result.MotionStateChanged, + $"manager-driven frame {f} must not flag MotionStateChanged"); + Drain(c); + } + + Assert.False(rig.MoveTo.IsMovingTo(), "moveto must arrive within the frame budget"); + float distLeft = Vector2.Distance( + new Vector2(c.Position.X, c.Position.Y), new Vector2(dest.X, dest.Y)); + Assert.True(distLeft <= 1.0f, + $"body must stop at the arrival radius; {distLeft:F2} m left"); + Assert.Equal(1, rig.MoveToCompleteCount); + Assert.Equal(WeenieError.None, rig.LastCompleteError); + Assert.Equal(Ready, c.Motion.InterpretedState.ForwardCommand); + } + + [Fact] + public void ServerTurnToHeading_RotatesYaw_AndSnapsExact() + { + var rig = MakeRig(); + var c = rig.Controller; + + // Mirrors the GameWindow wire path's P1 unpack store (00509730): + // a server moveto arrives with IsAutonomous=false, routing the + // per-tick pump's A3 dual dispatch to the interpreted branch. + rig.Controller.SetLastMoveWasAutonomous(false); + rig.MoveTo.PerformMovement(new MovementStruct + { + Type = MovementType.TurnToHeading, + Params = new MovementParameters { DesiredHeading = 180f }, // South = -Y + }); + Drain(c); + Assert.True(rig.MoveTo.IsMovingTo()); + + for (int f = 0; f < 600 && rig.MoveTo.IsMovingTo(); f++) + { + c.Update(1f / 60f, new MovementInput()); + Drain(c); + } + + Assert.False(rig.MoveTo.IsMovingTo(), "turn-to must complete within the frame budget"); + // HandleTurnToHeading's arrival snap (the ONE heading snap in the + // family, 0052a146) writes through the Yaw seam: heading 180 → yaw + // -π/2 per the P5 bridge. + Assert.Equal(MoveToMath.YawFromHeading(180f), c.Yaw, 3); + Assert.Equal(1, rig.MoveToCompleteCount); + } + + [Fact] + public void MovementKeyEdge_CancelsMoveTo_WithoutFiringComplete() + { + var rig = MakeRig(); + var c = rig.Controller; + + // Mirrors the GameWindow wire path's P1 unpack store (00509730): + // a server moveto arrives with IsAutonomous=false, routing the + // per-tick pump's A3 dual dispatch to the interpreted branch. + rig.Controller.SetLastMoveWasAutonomous(false); + rig.MoveTo.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(c.CellId, new Vector3(150f, 96f, 50f), Quaternion.Identity), + Params = new MovementParameters { UseSpheres = false }, + }); + Drain(c); + Assert.True(rig.MoveTo.IsMovingTo()); + c.Update(1f / 60f, new MovementInput()); + Drain(c); + Assert.True(rig.MoveTo.IsMovingTo()); + + // W press edge → DoMotion(ctor-default params, CancelMoveTo bit set) + // → InterruptCurrentMovement → CancelMoveTo(ActionCancelled). + var result = c.Update(1f / 60f, new MovementInput { Forward = true }); + + Assert.False(rig.MoveTo.IsMovingTo(), "user input must cancel the moveto (TS-36)"); + Assert.Equal(0, rig.MoveToCompleteCount); + // The cancel-frame's state change IS user intent — it must go on + // the wire (the former !IsServerAutoWalking guard is gone). + Assert.True(result.MotionStateChanged); + } + + [Fact] + public void LoginQueue_DrainsToEmpty_UnderProductionFeed() + { + // The second live stall (2026-07-03, [autowalk-gate] probe): ONE + // immortal Ready node in pending_motions — login SetPosition's + // StopCompletely fired before the sink bind, orphaning its A9 node + // (no completable partner). Head-pop-any relabels but never empties + // a queue with an orphan, and MotionsPending==true wedges every + // subsequent moveto. This pins the invariant: after login (rig + // construction, production bind order) the queue must reach EMPTY + // under the production completion feed. + var rig = MakeRig(out var seq); + var c = rig.Controller; + seq.MotionDoneTarget = (m, ok) => c.Motion.MotionDone(m, ok); + + for (int f = 0; f < 300 && c.Motion.MotionsPending(); f++) + { + c.Update(1f / 60f, new MovementInput()); + seq.Advance(1f / 60f); + } + + Assert.False(c.Motion.MotionsPending(), + "login pending_motions must drain to empty under the production feed"); + } + + [Fact] + public void ServerMoveToPosition_ProductionCompletionFeed_WalksToArrival() + { + // The 2026-07-03 live wedge repro: same scenario as + // ServerMoveToPosition_WalksToArrival_WithNoUserInput, but the + // pending_motions queue drains the way PRODUCTION drains it — the + // sequencer's Advance() fires MotionDoneTarget → Motion.MotionDone + // (the TickAnimations R3-W2 bind) — instead of this suite's + // force-drain. Live symptom: the moveto armed (movingTo=True) but + // the body never moved; BeginTurnToHeading's wait-for-anims gate + // (MotionsPending) never opened because the player's queue never + // emptied (launch.log: pending=True on 92/94 player MOTIONDONE + // pops; remotes 0/40). + var rig = MakeRig(out var seq); + var c = rig.Controller; + seq.MotionDoneTarget = (m, ok) => c.Motion.MotionDone(m, ok); + var dest = new Vector3(104f, 96f, 50f); // 8 m dead ahead (heading 90) + + // A few idle frames first — production always has render ticks + // between login (SetPosition → StopCompletely queues the A9 node + // with NO dispatch) and the first Use. + for (int f = 0; f < 30; f++) + { + c.Update(1f / 60f, new MovementInput()); + seq.Advance(1f / 60f); + } + + // Mirrors the GameWindow wire path's P1 unpack store (00509730): + // a server moveto arrives with IsAutonomous=false, routing the + // per-tick pump's A3 dual dispatch to the interpreted branch. + rig.Controller.SetLastMoveWasAutonomous(false); + rig.MoveTo.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(c.CellId, dest, Quaternion.Identity), + Params = new MovementParameters { UseSpheres = false, DistanceToObject = 0.6f }, + }); + Assert.True(rig.MoveTo.IsMovingTo()); + + for (int f = 0; f < 1200 && rig.MoveTo.IsMovingTo(); f++) + { + c.Update(1f / 60f, new MovementInput()); + seq.Advance(1f / 60f); + } + + string queueDump = string.Join(", ", + System.Linq.Enumerable.Select(c.Motion.PendingMotions, n => $"0x{n.Motion:X8}")); + Assert.False(rig.MoveTo.IsMovingTo(), + $"moveto wedged: pending_motions never drained under the production " + + $"completion feed (queue: [{queueDump}])"); + Assert.Equal(1, rig.MoveToCompleteCount); + } + + [Fact] + public void JumpRelease_CancelsMoveTo() + { + var rig = MakeRig(); + var c = rig.Controller; + + // Mirrors the GameWindow wire path's P1 unpack store (00509730): + // a server moveto arrives with IsAutonomous=false, routing the + // per-tick pump's A3 dual dispatch to the interpreted branch. + rig.Controller.SetLastMoveWasAutonomous(false); + rig.MoveTo.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(c.CellId, new Vector3(150f, 96f, 50f), Quaternion.Identity), + Params = new MovementParameters { UseSpheres = false }, + }); + Drain(c); + Assert.True(rig.MoveTo.IsMovingTo()); + + // Charge one frame, release the next — jump() fires on the release + // edge and its interrupt site cancels the moveto (the exact + // silent-double-motion failure the TS-36 register row predicted). + c.Update(1f / 60f, new MovementInput { Jump = true }); + c.Update(1f / 60f, new MovementInput()); + + Assert.False(rig.MoveTo.IsMovingTo(), "jump must cancel the moveto (TS-36)"); + Assert.Equal(0, rig.MoveToCompleteCount); + } +} diff --git a/tests/AcDream.Core.Tests/Input/W6EdgeDrivenMovementTests.cs b/tests/AcDream.Core.Tests/Input/W6EdgeDrivenMovementTests.cs new file mode 100644 index 00000000..aa80104e --- /dev/null +++ b/tests/AcDream.Core.Tests/Input/W6EdgeDrivenMovementTests.cs @@ -0,0 +1,202 @@ +using System; +using System.Numerics; +using AcDream.App.Input; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand; + +namespace AcDream.Core.Tests.Input; + +/// +/// R3-W6 regression suite for the edge-driven local player — specifically +/// the "press W and stop instantly" bug (2026-07-03): the funnel's apply +/// pass let its own style dispatch's ApplyMotion(style) state-write +/// reset forward to Ready (raw 0051ea6c). The original W6 fix entry-cached +/// the axis fields; #161 replaced that with the TRUE retail mechanism — +/// the apply pass's MovementParameters carry +/// ModifyInterpretedState = false (retail's smeared bitfield store +/// at raw 305778, mask 0x37ff; ACE MotionInterp.cs:447), so NO dispatch in +/// the pass can write InterpretedState at all and live field reads +/// are retail semantics. These tests pin the user-visible invariant either +/// way: pressing W keeps you moving. +/// +/// These tests bind the REAL over a +/// real sequencer (a fake sink's return values can mask state-write gating +/// — the lesson that created this file). +/// +public class W6EdgeDrivenMovementTests +{ + private const uint NC = 0x8000003Du; + private const uint Ready = 0x41000003u; + private const uint Walk = 0x45000005u; + private const uint Run = 0x44000007u; + + private sealed class Loader : IAnimationLoader + { + private readonly System.Collections.Generic.Dictionary _anims = new(); + public void Register(uint id, Animation anim) => _anims[id] = anim; + public Animation? LoadAnimation(uint id) => _anims.TryGetValue(id, out var a) ? a : null; + } + + private static Animation MakeAnim(int frames) + { + var anim = new Animation(); + for (int f = 0; f < frames; f++) + { + var pf = new AnimationFrame(1); + pf.Frames.Add(new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }); + anim.PartFrames.Add(pf); + } + return anim; + } + + private static MotionData MakeMd(uint animId) + { + var md = new MotionData(); + QualifiedDataId qid = animId; + md.Anims.Add(new AnimData { AnimId = qid, LowFrame = 0, HighFrame = -1, Framerate = 30f }); + return md; + } + + private static AnimationSequencer MakeSequencer() + { + var setup = new Setup(); + setup.Parts.Add(0x01000000u); + setup.DefaultScale.Add(Vector3.One); + + var loader = new Loader(); + loader.Register(0x300u, MakeAnim(4)); + loader.Register(0x301u, MakeAnim(6)); + loader.Register(0x302u, MakeAnim(6)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NC }; + mt.StyleDefaults[(DRWMotionCommand)NC] = (DRWMotionCommand)Ready; + mt.Cycles[(int)((NC << 16) | (Ready & 0xFFFFFFu))] = MakeMd(0x300u); + mt.Cycles[(int)((NC << 16) | (Walk & 0xFFFFFFu))] = MakeMd(0x301u); + mt.Cycles[(int)((NC << 16) | (Run & 0xFFFFFFu))] = MakeMd(0x302u); + return new AnimationSequencer(setup, mt, loader); + } + + private static PhysicsEngine MakeFlatEngine() + { + var engine = new PhysicsEngine(); + var heights = new byte[81]; + Array.Fill(heights, (byte)50); + var heightTable = new float[256]; + for (int i = 0; i < 256; i++) heightTable[i] = i * 1f; + var terrain = new TerrainSurface(heights, heightTable); + engine.AddLandblock(0xA9B4FFFFu, terrain, Array.Empty(), + Array.Empty(), worldOffsetX: 0f, worldOffsetY: 0f); + return engine; + } + + private static PlayerMovementController MakeControllerWithRealSink(out AnimationSequencer seq) + { + var controller = new PlayerMovementController(MakeFlatEngine()); + seq = MakeSequencer(); + // The full W6 GameWindow bind set (EnterPlayerModeNow equivalent) — + // sink binds BEFORE SetPosition, matching the R4-V5 stall-fix order + // (SetPosition → StopCompletely needs the sink for its type-5 + // dispatch, else its A9 pending_motions node is orphaned). + controller.Motion.DefaultSink = new MotionTableDispatchSink(seq); + var s = seq; + // #174: production wiring — HandleEnterWorld (strip + drain), not + // the bare sequence strip (which orphaned pending manager nodes). + controller.Motion.RemoveLinkAnimations = () => s.Manager.HandleEnterWorld(); + controller.Motion.InitializeMotionTables = () => s.Manager.InitializeState(); + controller.Motion.CheckForCompletedMotions = s.Manager.CheckForCompletedMotions; + controller.SetPosition(new Vector3(96f, 96f, 50f), 0x0001); + controller.Yaw = 0f; + return controller; + } + + /// + /// The full apply pass the W6b live bug rode in on. Pre-R4-V5 the + /// trigger was ApplyServerRunRate (the ACE autonomous-echo tap); + /// V5's P1 gate drops that echo before it reaches the player, and the + /// tap is deleted — but the regression these tests pin lives in + /// ApplyInterpretedMovement's pass-params state protection + /// (ModifyInterpretedState=false since #161), which any + /// apply_current_movement pass (HitGround re-apply, future R6 per-tick + /// order) still exercises. Same two statements the deleted tap ran. + /// + private static void RunApplyPass(PlayerMovementController controller, float forwardSpeed) + { + controller.Motion.InterpretedState.ForwardSpeed = forwardSpeed; + controller.Motion.apply_current_movement(cancelMoveTo: false, allowJump: false); + } + + [Fact] + public void ApplyPass_WithRealSink_ForwardSelfHeals() + { + // The distilled bug: a full apply pass (style dispatch included) + // against the REAL sink must leave the interpreted forward exactly + // where it started — the style apply's Ready reset is re-applied + // over by the entry-cached fwd dispatch (retail self-heal). + var controller = MakeControllerWithRealSink(out _); + var input = new MovementInput { Forward = true, Run = true }; + controller.Update(1f / 60f, input); // W press edge -> RunForward + + Assert.Equal(Run, controller.Motion.InterpretedState.ForwardCommand); + + // The live killer: a full apply pass mid-hold (was the ~10Hz + // UM-echo tap pre-V5; see RunApplyPass). + RunApplyPass(controller, 4.5f); + + Assert.Equal(Run, controller.Motion.InterpretedState.ForwardCommand); + Assert.True(controller.Motion.get_state_velocity().Length() > 1f, + "state velocity must survive the apply pass"); + } + + [Fact] + public void HoldW_WithRealSink_AndEchoes_BodyKeepsMoving() + { + var controller = MakeControllerWithRealSink(out _); + var input = new MovementInput { Forward = true, Run = true }; + + float startX = 96f; + Vector3 pos = new(startX, 96f, 50f); + for (int f = 0; f < 120; f++) + { + if (f % 6 == 3) + RunApplyPass(controller, 4.5f); // ex-ACE-echo cadence + pos = controller.Update(1f / 60f, input).Position; + } + + // 2 seconds of held-W running (post-fix ~9.5 m/s) must cover + // meters, not centimeters. Pre-fix this stalled at ~one tick of + // travel (the echo pass reset forward to Ready). + Assert.True(pos.X - startX > 5f, + $"expected sustained forward motion, got {pos.X - startX:F2} m"); + } + + [Fact] + public void ShiftToggle_MidHold_WalkRunTransitionSurvivesEcho() + { + var controller = MakeControllerWithRealSink(out _); + + // Hold W at run for 30 frames. + for (int f = 0; f < 30; f++) + controller.Update(1f / 60f, new MovementInput { Forward = true, Run = true }); + Assert.Equal(Run, controller.Motion.InterpretedState.ForwardCommand); + + // Shift pressed (walk) — the set_hold_run edge demotes to walk. + for (int f = 0; f < 30; f++) + { + if (f == 10) RunApplyPass(controller, 1.0f); // apply pass mid-walk + controller.Update(1f / 60f, new MovementInput { Forward = true, Run = false }); + } + Assert.Equal(Walk, controller.Motion.InterpretedState.ForwardCommand); + + // Shift released — promote back to run; survives another echo. + for (int f = 0; f < 30; f++) + { + if (f == 10) RunApplyPass(controller, 4.5f); + controller.Update(1f / 60f, new MovementInput { Forward = true, Run = true }); + } + Assert.Equal(Run, controller.Motion.InterpretedState.ForwardCommand); + } +} diff --git a/tests/AcDream.Core.Tests/Lighting/LightManagerTests.cs b/tests/AcDream.Core.Tests/Lighting/LightManagerTests.cs index 264c498c..f8eec97c 100644 --- a/tests/AcDream.Core.Tests/Lighting/LightManagerTests.cs +++ b/tests/AcDream.Core.Tests/Lighting/LightManagerTests.cs @@ -1,3 +1,4 @@ +using System.Collections.Generic; using System.Numerics; using AcDream.Core.Lighting; using Xunit; @@ -6,7 +7,7 @@ namespace AcDream.Core.Tests.Lighting; public sealed class LightManagerTests { - private static LightSource MakePoint(Vector3 pos, float range, uint ownerId = 0, bool lit = true) + private static LightSource MakePoint(Vector3 pos, float range, uint ownerId = 0, bool lit = true, uint cellId = 0) => new LightSource { Kind = LightKind.Point, @@ -14,6 +15,18 @@ public sealed class LightManagerTests Range = range, IsLit = lit, OwnerId = ownerId, + CellId = cellId, + }; + + private static LightSource MakeDynamic(Vector3 pos, float range, uint cellId = 0) + => new LightSource + { + Kind = LightKind.Point, + WorldPosition = pos, + Range = range, + IsLit = true, + IsDynamic = true, + CellId = cellId, }; [Fact] @@ -176,6 +189,148 @@ public sealed class LightManagerTests Assert.Equal(1f, mgr.PointSnapshot[1].WorldPosition.X, 3); } + // ── Resident collection (#176 corrected reading, 2026-07-06) ─────────────── + // Retail collects the pool from ALL RESIDENT EnvCells each frame: + // CEnvCell::add_dynamic_lights (0x0052d410) walks the WHOLE static + // CEnvCell::visible_cell_table — the loaded-cell registry add_visible_cell + // (0x0052de40) fills from each activated cell + its dat visible-cell list. It + // is NOT the per-frame portal flood; camera gaze cannot change the pool. The + // earlier flood-scoped port (c500912b) made the under-room portal purples + // enter/leave the pool as the camera turned — the #176 seam-floor blink. + + [Fact] + public void PointSnapshot_ResidentCollection_CellTagDoesNotFilter() + { + var mgr = new LightManager(); + mgr.Register(MakePoint(new Vector3(1, 0, 0), 5f, cellId: 0xAAAA0101u)); // "visible" room + mgr.Register(MakePoint(new Vector3(2, 0, 0), 5f, cellId: 0xAAAA0102u)); // under-room + mgr.Register(MakePoint(new Vector3(3, 0, 0), 5f, cellId: 0u)); // cell-less (viewer fill) + + mgr.BuildPointLightSnapshot(Vector3.Zero); + + // ALL resident lights are candidates. The under-room portal light reaching + // the corridor's pool is retail-correct — the live cdb capture + // (tools/cdb/issue176-floor-light.cdb) showed retail applying the + // intensity-100 purples to EVERY Hub cell; the faceted purple wedge is + // faithful, only its gaze-coupled blinking was ours. + Assert.Equal(3, mgr.PointSnapshot.Count); + } + + [Fact] + public void PointSnapshot_OverCap_DynamicsNeverEvictedByNearerStatics() + { + var mgr = new LightManager(); + // More statics than the cap, ALL nearer the player than every dynamic. + for (int i = 0; i < LightManager.MaxGlobalLights + 20; i++) + mgr.Register(MakePoint(new Vector3(i * 0.01f, 0, 0), 5f, ownerId: (uint)(i + 1))); + // 7 dynamics farther out (retail's dynamics live in their own 7-slot pool — + // Render::add_dynamic_light 0x0054d420 — statics can never crowd them out). + var dyns = new LightSource[7]; + for (int i = 0; i < dyns.Length; i++) + { + dyns[i] = MakeDynamic(new Vector3(50f + i, 0, 0), range: 9f); + mgr.Register(dyns[i]); + } + + mgr.BuildPointLightSnapshot(Vector3.Zero); + + Assert.Equal(LightManager.MaxGlobalLights, mgr.PointSnapshot.Count); + foreach (var d in dyns) + Assert.Contains(d, mgr.PointSnapshot); + } + + [Fact] + public void PointSnapshot_OverCap_KeepsNearestThePlayer() + { + var mgr = new LightManager(); + // A big cluster far from the player (where a chase camera might sit) and + // one torch beside the player. Retail sorts by distance to + // Render::player_pos (insert_light 0x0054d1b0) — the near-player torch + // must survive the cap no matter how many far lights exist. + for (int i = 0; i < LightManager.MaxGlobalLights + 50; i++) + mgr.Register(MakePoint(new Vector3(200f + i * 0.05f, 0, 0), 5f, ownerId: (uint)(i + 1))); + var torch = MakePoint(new Vector3(2f, 0, 0), range: 15f, ownerId: 0xF00Du); + mgr.Register(torch); + + mgr.BuildPointLightSnapshot(playerWorldPos: Vector3.Zero); + + Assert.Contains(torch, mgr.PointSnapshot); + } + + // ── Visible-cell scoping (A7.L1, 2026-07-09 — the Town Network starvation fix) ── + // BuildPointLightSnapshot's player-nearest cap sorts by raw Euclidean distance, + // which is not a reliable proxy for "same room" in a dense, maze-like hub: a + // fixture on the other side of a wall can be geometrically closer than the + // player's own room's torches. The Town Network fountain room (463 registered + // fixtures, cap 128) went dark because far-denser, closer-in-a-straight-line + // corridor fixtures won the cap over the room's own lights. Filtering candidacy + // by the frame's actual visible-cell set (the render already computes this) + // fixes it without touching the distance-sort anchor (still the PLAYER, per the + // #176 correction — camera anchoring is what caused the earlier flicker). + + [Fact] + public void BuildPointLightSnapshot_VisibleCellScoping_RoomLightsSurviveOverEuclideanCloserInvisibleCell() + { + var mgr = new LightManager(); + + // A different, NOT-visible cell packed with fixtures that are, in raw + // straight-line distance, closer to the player than the room's own + // torches (e.g. a corridor on the other side of a wall). + const uint otherCellId = 0xAAAA0102u; + for (int i = 0; i < LightManager.MaxGlobalLights + 50; i++) + mgr.Register(MakePoint(new Vector3(1f + i * 0.001f, 1f, 0), range: 5f, ownerId: (uint)(i + 1), cellId: otherCellId)); + + // The player's own room: a handful of torches, each FARTHER in raw + // distance than every "other cell" fixture above, but the only cell + // actually visible from the player's viewpoint this frame. + const uint roomCellId = 0xAAAA0101u; + var roomTorches = new LightSource[5]; + for (int i = 0; i < roomTorches.Length; i++) + { + roomTorches[i] = MakePoint(new Vector3(50f + i, 0, 0), range: 15f, cellId: roomCellId); + mgr.Register(roomTorches[i]); + } + + var visibleCells = new HashSet { roomCellId }; + mgr.BuildPointLightSnapshot(playerWorldPos: Vector3.Zero, visibleCells); + + foreach (var torch in roomTorches) + Assert.Contains(torch, mgr.PointSnapshot); + } + + [Fact] + public void BuildPointLightSnapshot_VisibleCellScoping_CellLessLightAlwaysIncluded() + { + // The viewer fill light (CellId==0) must survive scoping unconditionally — + // retail's per-frame add_dynamic_light(&viewer_light, ...) is unconditional + // (LightManager.UpdateViewerLight's doc comment). + var mgr = new LightManager(); + var viewerFill = MakePoint(new Vector3(0, 0, 2), range: 15f, cellId: 0u); + mgr.Register(viewerFill); + var otherRoom = MakePoint(new Vector3(2, 0, 0), range: 5f, cellId: 0xBEEFu); + mgr.Register(otherRoom); + + var visibleCells = new HashSet { 0xF00Du }; // neither light's cell + mgr.BuildPointLightSnapshot(Vector3.Zero, visibleCells); + + Assert.Contains(viewerFill, mgr.PointSnapshot); + Assert.DoesNotContain(otherRoom, mgr.PointSnapshot); + } + + [Fact] + public void BuildPointLightSnapshot_NoVisibleCellsArg_UnscopedLegacyBehavior() + { + // Outdoor / no-clipRoot callers omit visibleCells — every registered lit + // light stays a candidate, exactly the pre-A7.L1 behavior. + var mgr = new LightManager(); + mgr.Register(MakePoint(new Vector3(1, 0, 0), 5f, cellId: 0xAAAAu)); + mgr.Register(MakePoint(new Vector3(2, 0, 0), 5f, cellId: 0xBBBBu)); + + mgr.BuildPointLightSnapshot(Vector3.Zero); + + Assert.Equal(2, mgr.PointSnapshot.Count); + } + [Fact] public void SelectForObject_EmptySnapshot_ReturnsZero() { @@ -256,4 +411,117 @@ public sealed class LightManagerTests Assert.Equal(na, nb); Assert.Equal(a[0], b[0]); } + + // ── SelectForCell — retail minimize_envcell_lighting (all dynamics on every cell) ── + + [Fact] + public void SelectForCell_AppliesAllDynamicLights_EvenOutOfReach() + { + // Retail enables the WHOLE dynamic subset for every cell (cdb-verified: the same + // portal lights on every Facility Hub cell) — including ones that don't reach it, + // since the shader's range cutoff zeroes those. Static lights still cull by reach. + var snapshot = new[] + { + MakePoint(new Vector3(1, 0, 0), range: 5f), // 0: static, reaches + MakeDynamic(new Vector3(100, 0, 0), range: 5f), // 1: dynamic, FAR (out of reach) + MakeDynamic(new Vector3(2, 0, 0), range: 5f), // 2: dynamic, near + MakePoint(new Vector3(50, 0, 0), range: 5f), // 3: static, far (out of reach) + }; + Span sel = stackalloc int[LightManager.MaxLightsPerObject]; + int n = LightManager.SelectForCell(snapshot, Vector3.Zero, radius: 1f, sel); + + bool d1 = false, d2 = false, s0 = false, s3 = false; + for (int i = 0; i < n; i++) + { + if (sel[i] == 1) d1 = true; + if (sel[i] == 2) d2 = true; + if (sel[i] == 0) s0 = true; + if (sel[i] == 3) s3 = true; + } + Assert.True(d1, "the FAR dynamic light must still be applied — retail enables all dynamics"); + Assert.True(d2, "the near dynamic light is applied"); + Assert.True(s0, "the near static light reaches the cell → selected"); + Assert.False(s3, "the far static light doesn't reach → not selected"); + } + + [Fact] + public void SelectForCell_SameDynamicSet_ForCellsFarApart_NoFlap() + { + // The stability retail has and we lacked: two cells far apart get the SAME dynamic + // set. A per-cell sphere-overlap cull of dynamics (the old SelectForObject path) let + // that set differ/flip as the flood shifted → the floor lighting FLAPPED (#176). + var snapshot = new[] + { + MakeDynamic(new Vector3(0, 0, 0), range: 5f), + MakeDynamic(new Vector3(100, 0, 0), range: 5f), + }; + Span a = stackalloc int[8]; + Span b = stackalloc int[8]; + int na = LightManager.SelectForCell(snapshot, new Vector3(0, 0, 0), 1f, a); + int nb = LightManager.SelectForCell(snapshot, new Vector3(500, 0, 0), 1f, b); + + Assert.Equal(2, na); // both dynamics on the near cell + Assert.Equal(2, nb); // both dynamics on the far cell too — identical, no flap + } + + /// + /// #176/#177 (2026-07-06, corrected same day) — the end-state pin. The pool is + /// retail's RESIDENT collection anchored at the PLAYER: a light in range of an + /// object near the player is selected no matter where a chase camera sits, + /// because the camera is not an input to BuildPointLightSnapshot at all + /// (the two prior camera-coupled pools — nearest-camera cap, then frame-flood + /// scoping c500912b — were each a #176 flicker mechanism). Here the + /// player stands by the torch while 400 fixtures cluster 200 m away where a + /// camera might look: the torch must always survive the cap and light the + /// object. See docs/research/2026-07-06-a7-per-cell-lighting-pseudocode.md + /// (corrected §1.3) — CEnvCell::visible_cell_table is the resident-cell + /// registry, and Render::insert_light (0x0054d1b0) sorts by distance to + /// Render::player_pos. + /// + [Fact] + public void PointSnapshot_HubScaleLightCount_ObjectSelectionIsCameraInvariant() + { + var mgr = new LightManager(); + + // 400 fixtures clustered far away (in the direction a camera might sit), + // all in another cell. Under either old camera-coupled pool these could + // displace or gate the player-side torch; under the player anchor they are + // simply the farthest candidates. + const uint farRoom = 0xAAAA0102u; + for (int i = 0; i < 400; i++) + mgr.Register(MakePoint(new Vector3(200f + i * 0.05f, 0, 0), range: 5f, ownerId: (uint)(i + 1), cellId: farRoom)); + + // The target torch: beside the player, in the player's room. + const uint playerRoom = 0xAAAA0101u; + var torch = MakePoint(new Vector3(2f, 0, 0), range: 15f, ownerId: 0xF00DF00Du, cellId: playerRoom); + mgr.Register(torch); + + Span sel = stackalloc int[LightManager.MaxLightsPerObject]; + + // The player (the ONLY positional input) stands at the origin. Rebuild + // twice to mirror consecutive frames of a rotating camera — the pool and + // the selection must be identical (no camera input exists to vary). + mgr.BuildPointLightSnapshot(playerWorldPos: Vector3.Zero); + int n1 = LightManager.SelectForObject(mgr.PointSnapshot, new Vector3(0f, 0, 0), 6f, sel); + bool torchSelected1 = SelectedContains(mgr.PointSnapshot, sel, n1, torch); + + mgr.BuildPointLightSnapshot(playerWorldPos: Vector3.Zero); + int n2 = LightManager.SelectForObject(mgr.PointSnapshot, new Vector3(0f, 0, 0), 6f, sel); + bool torchSelected2 = SelectedContains(mgr.PointSnapshot, sel, n2, torch); + + Assert.True(torchSelected1, + "an in-range light beside the player was evicted from the pool — " + + "per-cell lighting would pop (the #176/#177 mechanism)"); + Assert.True(torchSelected2, "consecutive same-player builds must select identically"); + Assert.Equal(LightManager.MaxGlobalLights, mgr.PointSnapshot.Count); // cap applied to the far cluster + + static bool SelectedContains( + System.Collections.Generic.IReadOnlyList snapshot, + Span indices, int count, LightSource target) + { + for (int i = 0; i < count; i++) + if (ReferenceEquals(snapshot[indices[i]], target)) return true; + return false; + } + } } diff --git a/tests/AcDream.Core.Tests/Meshing/EntityHydrationRulesTests.cs b/tests/AcDream.Core.Tests/Meshing/EntityHydrationRulesTests.cs new file mode 100644 index 00000000..ab2c5660 --- /dev/null +++ b/tests/AcDream.Core.Tests/Meshing/EntityHydrationRulesTests.cs @@ -0,0 +1,38 @@ +using AcDream.Core.Meshing; +using Xunit; + +namespace AcDream.Core.Tests.Meshing; + +/// +/// #79/#93 (2026-07-09) — the Town Network fountain room's only dat-authored +/// light (Setup 0x02000365, a ceiling fixture) never registered: its sole +/// visual part is a #136-class runtime-hidden marker, so it flattens to zero +/// mesh refs, and GameWindow.cs's hydration loop dropped the ENTIRE entity — +/// light included — whenever meshRefs was empty. Retail's light registration +/// (CObjCell::add_light, CEnvCell::UnPack) is entirely independent of a +/// fixture's own mesh visibility; the mesh-empty gate must not also swallow +/// a Setup's Lights. +/// +public class EntityHydrationRulesTests +{ + [Fact] + public void ShouldKeepEntity_NoMeshNoLights_False() + { + Assert.False(EntityHydrationRules.ShouldKeepEntity(meshRefCount: 0, setupLightCount: 0)); + } + + [Fact] + public void ShouldKeepEntity_NoMeshWithLights_True() + { + // The exact fountain-room case: a mesh-less "light attach point" must + // still survive hydration so its Lights can be registered. + Assert.True(EntityHydrationRules.ShouldKeepEntity(meshRefCount: 0, setupLightCount: 1)); + } + + [Fact] + public void ShouldKeepEntity_HasMesh_TrueRegardlessOfLights() + { + Assert.True(EntityHydrationRules.ShouldKeepEntity(meshRefCount: 1, setupLightCount: 0)); + Assert.True(EntityHydrationRules.ShouldKeepEntity(meshRefCount: 3, setupLightCount: 2)); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/AnimationCommandRouterTests.cs b/tests/AcDream.Core.Tests/Physics/AnimationCommandRouterTests.cs index 83ca7d07..767265f1 100644 --- a/tests/AcDream.Core.Tests/Physics/AnimationCommandRouterTests.cs +++ b/tests/AcDream.Core.Tests/Physics/AnimationCommandRouterTests.cs @@ -1,5 +1,6 @@ using AcDream.Core.Physics; using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; using Xunit; namespace AcDream.Core.Tests.Physics; @@ -24,7 +25,13 @@ public sealed class AnimationCommandRouterTests [Fact] public void RouteWireCommand_SubState_UsesSetCycle() { - var seq = MakeEmptySequencer(); + // R2-Q4: retail-mandatory StyleDefaults (SetDefaultState 0x005230a0) + // — GetObjectSequence also refuses substate==0, so the MotionTable + // needs both a StyleDefaults entry AND cycles for the style's default + // substate (Ready, installed by initialize_state) and for the routed + // Dead substate, or the whole dispatch chain silently no-ops and + // CurrentStyle/CurrentMotion stay at their zero defaults. + var seq = MakeRoutableSequencer(); var route = AnimationCommandRouter.RouteWireCommand(seq, NonCombat, 0x0011); @@ -59,8 +66,66 @@ public sealed class AnimationCommandRouterTests return new AnimationSequencer(new Setup(), new MotionTable(), new NullAnimationLoader()); } + /// + /// R2-Q4: a MotionTable that can actually complete a SubState dispatch — + /// StyleDefaults[NonCombat]=Ready (required by initialize_state's + /// SetDefaultState) plus cycles for both Ready (the installed baseline) + /// and Dead (the substate this test routes to). One shared part/anim is + /// enough; RouteWireCommand only inspects CurrentStyle/CurrentMotion. + /// + private static AnimationSequencer MakeRoutableSequencer() + { + const uint Ready = 0x41000003u; + const uint Dead = 0x40000011u; + const uint AnimId = 0x03000001u; + + var setup = new Setup(); + setup.Parts.Add(0x01000000u); + setup.DefaultScale.Add(System.Numerics.Vector3.One); + + var mt = new MotionTable + { + DefaultStyle = (DatReaderWriter.Enums.MotionCommand)NonCombat, + }; + mt.StyleDefaults[(DatReaderWriter.Enums.MotionCommand)NonCombat] = + (DatReaderWriter.Enums.MotionCommand)Ready; + + int ReadyKey = (int)((NonCombat << 16) | (Ready & 0xFFFFFFu)); + int DeadKey = (int)((NonCombat << 16) | (Dead & 0xFFFFFFu)); + mt.Cycles[ReadyKey] = MakeMotionData(AnimId); + mt.Cycles[DeadKey] = MakeMotionData(AnimId); + + var loader = new NullAnimationLoader(); + loader.Register(AnimId, MakeAnim()); + + return new AnimationSequencer(setup, mt, loader); + } + + private static MotionData MakeMotionData(uint animId) + { + var md = new MotionData(); + QualifiedDataId qid = animId; + md.Anims.Add(new AnimData { AnimId = qid, LowFrame = 0, HighFrame = -1, Framerate = 30f }); + return md; + } + + private static Animation MakeAnim() + { + var anim = new Animation(); + var pf = new AnimationFrame(1); + pf.Frames.Add(new Frame + { + Origin = System.Numerics.Vector3.Zero, + Orientation = System.Numerics.Quaternion.Identity, + }); + anim.PartFrames.Add(pf); + return anim; + } + private sealed class NullAnimationLoader : IAnimationLoader { - public Animation? LoadAnimation(uint id) => null; + private readonly System.Collections.Generic.Dictionary _anims = new(); + public void Register(uint id, Animation anim) => _anims[id] = anim; + public Animation? LoadAnimation(uint id) => _anims.TryGetValue(id, out var a) ? a : null; } } diff --git a/tests/AcDream.Core.Tests/Physics/AnimationSequencerCutoverTraceTests.cs b/tests/AcDream.Core.Tests/Physics/AnimationSequencerCutoverTraceTests.cs new file mode 100644 index 00000000..1af00c11 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/AnimationSequencerCutoverTraceTests.cs @@ -0,0 +1,388 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using System.Text; +using AcDream.Core.Physics; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; +using Xunit; + +using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand; + +namespace AcDream.Core.Tests.Physics; + +// ───────────────────────────────────────────────────────────────────────────── +// R2-Q4 adapter-cutover trace conformance (r2-port-plan.md §3 Q4). +// +// These scenarios were CAPTURED against the PRE-cutover adapter (the legacy +// SetCycle/PlayAction with the fast-path, Fix B, stop-anim fallback, and G17 +// gate) at commit aa65990a, then replayed against the PerformMovement-hosted +// adapter. Golden strings assert the post-Q4 behavior; every place the cutover +// INTENTIONALLY changed the outcome carries an `EXPECTED-DIFF(Q4)` comment +// with the pre-cutover value and the retail rationale. Everything without an +// annotation is byte-identical across the cutover — that is the parity bar. +// +// Snapshot format (Describe): comma-joined node list in queue order, each node +// `@` with suffix `*` = first_cyclic, `^` = curr_anim; +// then ` | frame= vel=(x,y,z F2) om=(x,y,z F2) style= motion= +// mod=`. +// ───────────────────────────────────────────────────────────────────────────── + +internal sealed class TraceLoader : IAnimationLoader +{ + private readonly Dictionary _anims = new(); + private readonly Dictionary _ids = new(); + + public void Register(uint id, Animation anim) + { + _anims[id] = anim; + _ids[anim] = id; + } + + public Animation? LoadAnimation(uint id) => + _anims.TryGetValue(id, out var a) ? a : null; + + public uint IdOf(Animation anim) => _ids.TryGetValue(anim, out var id) ? id : 0; +} + +public sealed class AnimationSequencerCutoverTraceTests +{ + // Styles (FULL command words, as GameWindow passes them). + private const uint NC = 0x8000003Du; // NonCombat + private const uint Style2 = 0x8000004Cu; // synthetic second style + + // Substates / cycles. + private const uint Ready = 0x41000003u; + private const uint Walk = 0x45000005u; + private const uint WalkBack = 0x45000006u; + private const uint Run = 0x44000007u; + private const uint Falling = 0x40000015u; + + // Action / modifier class ids. + private const uint EmoteAction = 0x10000062u; + private const uint TurnMod = 0x6500000Du; + + // Anim resource ids. + private const uint ReadyAnim = 0x100u; // 4 frames + private const uint WalkAnim = 0x101u; // 6 frames + private const uint RunAnim = 0x102u; // 6 frames + private const uint ReadyToWalkLink = 0x103u; // 2 frames + private const uint ReadyToRunLink = 0x104u; // 2 frames + private const uint WalkToReadyLink = 0x105u; // 3 frames + private const uint RunToReadyLink = 0x108u; // 3 frames + private const uint TurnModAnim = 0x109u; // 2 frames + private const uint ReadyToStyle2Link = 0x10Au; // 2 frames + private const uint ReadyToEmoteLink = 0x10Bu; // 5 frames + private const uint FallAnim = 0x10Cu; // 4 frames + private const uint Style2ReadyAnim = 0x107u; // 4 frames + + private static Animation MakeAnim(int numFrames, int numParts = 1) + { + var anim = new Animation(); + for (int f = 0; f < numFrames; f++) + { + var pf = new AnimationFrame((uint)numParts); + for (int p = 0; p < numParts; p++) + pf.Frames.Add(new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }); + anim.PartFrames.Add(pf); + } + return anim; + } + + private static MotionData MakeMd(uint animId, float framerate = 30f, + Vector3? velocity = null, Vector3? omega = null) + { + var md = new MotionData(); + QualifiedDataId qid = animId; + md.Anims.Add(new AnimData + { + AnimId = qid, + LowFrame = 0, + HighFrame = -1, + Framerate = framerate, + }); + if (velocity is { } v) + { + md.Velocity = v; + md.Flags |= DatReaderWriter.Enums.MotionDataFlags.HasVelocity; + } + if (omega is { } o) + { + md.Omega = o; + md.Flags |= DatReaderWriter.Enums.MotionDataFlags.HasOmega; + } + return md; + } + + private static void AddLink(MotionTable mt, uint style, uint from, uint to, MotionData md) + { + int outer = (int)((style << 16) | (from & 0xFFFFFFu)); + if (!mt.Links.TryGetValue(outer, out var cmd)) + { + cmd = new MotionCommandData(); + mt.Links[outer] = cmd; + } + cmd.MotionData[(int)to] = md; + } + + private static (Setup, MotionTable, TraceLoader) BuildFixture() + { + var setup = new Setup(); + setup.Parts.Add(0x01000000u); + setup.DefaultScale.Add(Vector3.One); + + var loader = new TraceLoader(); + loader.Register(ReadyAnim, MakeAnim(4)); + loader.Register(WalkAnim, MakeAnim(6)); + loader.Register(RunAnim, MakeAnim(6)); + loader.Register(ReadyToWalkLink, MakeAnim(2)); + loader.Register(ReadyToRunLink, MakeAnim(2)); + loader.Register(WalkToReadyLink, MakeAnim(3)); + loader.Register(RunToReadyLink, MakeAnim(3)); + loader.Register(TurnModAnim, MakeAnim(2)); + loader.Register(ReadyToStyle2Link, MakeAnim(2)); + loader.Register(ReadyToEmoteLink, MakeAnim(5)); + loader.Register(FallAnim, MakeAnim(4)); + loader.Register(Style2ReadyAnim, MakeAnim(4)); + + var mt = new MotionTable + { + DefaultStyle = (DRWMotionCommand)NC, + }; + mt.StyleDefaults[(DRWMotionCommand)NC] = (DRWMotionCommand)Ready; + mt.StyleDefaults[(DRWMotionCommand)Style2] = (DRWMotionCommand)Ready; + + int CycleKey(uint style, uint substate) => (int)((style << 16) | (substate & 0xFFFFFFu)); + mt.Cycles[CycleKey(NC, Ready)] = MakeMd(ReadyAnim); + mt.Cycles[CycleKey(NC, Walk)] = MakeMd(WalkAnim, velocity: new Vector3(0f, 3.12f, 0f)); + mt.Cycles[CycleKey(NC, Run)] = MakeMd(RunAnim, velocity: new Vector3(0f, 4.0f, 0f)); + mt.Cycles[CycleKey(NC, Falling)] = MakeMd(FallAnim); + mt.Cycles[CycleKey(Style2, Ready)] = MakeMd(Style2ReadyAnim); + + AddLink(mt, NC, Ready, Walk, MakeMd(ReadyToWalkLink)); + AddLink(mt, NC, Ready, Run, MakeMd(ReadyToRunLink)); + AddLink(mt, NC, Walk, Ready, MakeMd(WalkToReadyLink)); + AddLink(mt, NC, Run, Ready, MakeMd(RunToReadyLink)); + AddLink(mt, NC, Ready, EmoteAction, MakeMd(ReadyToEmoteLink)); + AddLink(mt, NC, Ready, Style2, MakeMd(ReadyToStyle2Link)); + + // Modifier: styled key (styleMasked<<16 | low24). + int modKey = (int)((NC << 16) | (TurnMod & 0xFFFFFFu)); + mt.Modifiers[modKey] = MakeMd(TurnModAnim, omega: new Vector3(0f, 0f, 1.5f)); + + return (setup, mt, loader); + } + + private static string Describe(AnimationSequencer seq, TraceLoader loader) + { + var core = seq.Core; + var sb = new StringBuilder(); + bool first = true; + for (var n = core.AnimList.First; n is not null; n = n.Next) + { + if (!first) sb.Append(','); + first = false; + uint id = n.Value.Anim is null ? 0u : loader.IdOf(n.Value.Anim); + sb.Append($"{id:X}@{n.Value.Framerate:F1}"); + if (ReferenceEquals(n, core.FirstCyclicNode)) sb.Append('*'); + if (ReferenceEquals(n, core.CurrAnimNode)) sb.Append('^'); + } + var v = core.Velocity; + var o = core.Omega; + sb.Append($" | frame={core.FrameNumber:F1}"); + sb.Append($" vel=({v.X:F2},{v.Y:F2},{v.Z:F2})"); + sb.Append($" om=({o.X:F2},{o.Y:F2},{o.Z:F2})"); + sb.Append($" style={seq.CurrentStyle:X8} motion={seq.CurrentMotion:X8} mod={seq.CurrentSpeedMod:F2}"); + return sb.ToString(); + } + + private static AnimationSequencer NewSeq(out TraceLoader loader) + { + var (setup, mt, l) = BuildFixture(); + loader = l; + return new AnimationSequencer(setup, mt, l); + } + + // ── Scenarios ─────────────────────────────────────────────────────────── + + [Fact] + public void S1_SpawnIdle() + { + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + Assert.Equal( + "100@30.0*^ | frame=0.0 vel=(0.00,0.00,0.00) om=(0.00,0.00,0.00) style=8000003D motion=41000003 mod=1.00", + Describe(seq, loader)); + } + + [Fact] + public void S2_IdleToWalk_LinkThenCycle() + { + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + seq.SetCycle(NC, Walk, 1.0f); + Assert.Equal( + "103@30.0^,101@30.0* | frame=0.0 vel=(0.00,3.12,0.00) om=(0.00,0.00,0.00) style=8000003D motion=45000005 mod=1.00", + Describe(seq, loader)); + } + + [Fact] + public void S2b_LinkDrain_FiresOneAnimDoneSentinel() + { + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + seq.SetCycle(NC, Walk, 1.0f); + + // Drain the 2-frame link at fr=30: 2 frames / 30fps < 0.1s. Advance + // enough to cross into the cycle. + int animDone = 0; + for (int i = 0; i < 10; i++) + { + seq.Advance(0.02f); + foreach (var h in seq.ConsumePendingHooks()) + if (h is DatReaderWriter.Types.AnimationDoneHook) + animDone++; + } + Assert.Equal(1, animDone); + } + + [Fact] + public void S3_WalkToRun_CyclicToCyclic() + { + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + seq.SetCycle(NC, Walk, 1.0f); + seq.SetCycle(NC, Run, 2.0f); + // EXPECTED-DIFF(Q4): pre-cutover Fix B stripped every link leaving + // "102@60.0*^". The verbatim GetObjectSequence (Branch 2, no direct + // Walk->Run link in this fixture) routes the DOUBLE-HOP: Walk->Ready + // settle (105 at the OLD substate mod) + Ready->Run windup (104 at + // the new speed) + the Run cycle; the old Ready->Walk link (103) + // keeps draining first (pending-queue discipline). Rapid same-motion + // re-issues now collapse via remove_redundant_links (the retail + // Fix B), not an adapter locomotion special case. + Assert.Equal( + "103@30.0^,105@30.0,104@60.0,102@60.0* | frame=0.0 vel=(0.00,8.00,0.00) om=(0.00,0.00,0.00) style=8000003D motion=44000007 mod=2.00", + Describe(seq, loader)); + } + + [Fact] + public void S4_RunReSpeed_FastPath() + { + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + seq.SetCycle(NC, Walk, 1.0f); + seq.SetCycle(NC, Run, 2.0f); + seq.SetCycle(NC, Run, 2.5f); + // EXPECTED-DIFF(Q4): inherits S3's double-hop list; the re-speed + // itself is the verbatim Branch-2 fast path (change_cycle_speed + // scales ONLY first_cyclic..tail: 102 60->75; links untouched; + // velocity via subtract_motion(2.0)+combine_motion(2.5)). + Assert.Equal( + "103@30.0^,105@30.0,104@60.0,102@75.0* | frame=0.0 vel=(0.00,10.00,0.00) om=(0.00,0.00,0.00) style=8000003D motion=44000007 mod=2.50", + Describe(seq, loader)); + } + + [Fact] + public void S5_WalkBackward_RemapNegativeSpeed() + { + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + seq.SetCycle(NC, WalkBack, 1.0f); + // Node list BYTE-IDENTICAL to pre-cutover: the reversed-key get_link + // resolves the Walk->Ready link (0x105) played in reverse (fr=-19.5 = + // 30 x -0.65 BackwardsFactor); cursor at the reverse starting frame + // (HighFrame+1 = 3). + // EXPECTED-DIFF(Q4), mirrors only: CurrentMotion now reads the + // POST-adjust_motion substate (45000005, was 45000006) and + // CurrentSpeedMod the signed mod (-0.65, was 1.00) - MotionState owns + // the state and retail's interpreted state is post-adjustment. The + // om=(-0.00,...) is IEEE negative zero from add_motion's + // zero-omega x negative-speed multiply (numerically equal to 0). + Assert.Equal( + "105@-19.5^,101@-19.5* | frame=3.0 vel=(0.00,-2.03,0.00) om=(-0.00,-0.00,-0.00) style=8000003D motion=45000005 mod=-0.65", + Describe(seq, loader)); + } + + [Fact] + public void S6_WalkBackToReady_StopSettleFallback() + { + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + seq.SetCycle(NC, WalkBack, 1.0f); + seq.SetCycle(NC, Ready, 1.0f); + // EXPECTED-DIFF(Q4): pre-cutover the stop-anim low-byte fallback + // re-keyed the settle as 105@30 (forward). The verbatim get_link + // (SubstateMod=-0.65 routes the REVERSED-key branch) resolves the + // Ready->Walk windup (103) played in REVERSE (fr=-30) - retail's + // actual backward-walk settle. The old reversed link (105@-19.5, + // mid-drain) still drains first, unchanged from pre-cutover. + Assert.Equal( + "105@-19.5^,103@-30.0,100@30.0* | frame=3.0 vel=(0.00,0.00,0.00) om=(0.00,0.00,0.00) style=8000003D motion=41000003 mod=1.00", + Describe(seq, loader)); + } + + [Fact] + public void S7_EmoteAction_MidReady() + { + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + seq.PlayAction(EmoteAction, 1.0f); + Assert.Equal( + "10B@30.0^,100@30.0* | frame=0.0 vel=(0.00,0.00,0.00) om=(0.00,0.00,0.00) style=8000003D motion=41000003 mod=1.00", + Describe(seq, loader)); + } + + [Fact] + public void S8_LeaveGroundLinkStrip_FallingEngagesInstantly() + { + // EXPECTED-DIFF(R3-W4): the K-fix18 skipTransitionLink flag is + // DELETED. The instant-Falling engage is retail's own mechanism: + // MotionInterpreter.LeaveGround (0x00528b00) fires the + // RemoveLinkAnimations seam — bound to this sequencer's + // RemoveAllLinkAnimations (CPhysicsObj::RemoveLinkAnimations + // 0x0050fe20 → CSequence::remove_all_link_animations) — after the + // Falling dispatch. Same final state the flag produced. + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + seq.SetCycle(NC, Walk, 1.0f); + seq.SetCycle(NC, Falling, 1.0f); + seq.RemoveAllLinkAnimations(); // = LeaveGround's seam firing + Assert.Equal( + "10C@30.0*^ | frame=0.0 vel=(0.00,0.00,0.00) om=(0.00,0.00,0.00) style=8000003D motion=40000015 mod=1.00", + Describe(seq, loader)); + } + + [Fact] + public void S9_TurnModifier() + { + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + seq.SetCycle(NC, Walk, 1.0f); + seq.PlayAction(TurnMod, 1.0f); + // EXPECTED-DIFF(Q4): pre-cutover PlayAction INSERTED the modifier's + // anim (109) before the cyclic tail - an acdream invention. Retail + // Branch 4 is PHYSICS-ONLY combine_motion (the AP-73 mechanism): the + // walk cycle's frames are untouched, the modifier contributes omega + // (0,0,1.5) and is tracked on the MotionState modifier stack. + Assert.Equal( + "103@30.0^,101@30.0* | frame=0.0 vel=(0.00,3.12,0.00) om=(0.00,0.00,1.50) style=8000003D motion=45000005 mod=1.00", + Describe(seq, loader)); + } + + [Fact] + public void S10_StyleChange() + { + var seq = NewSeq(out var loader); + seq.SetCycle(NC, Ready); + seq.SetCycle(Style2, Ready, 1.0f); + // EXPECTED-DIFF(Q4): pre-cutover switched cycles bare ("107@30.0*^"). + // GetObjectSequence Branch 1 (style-change) plays the cross-style + // entry link (10A = Ready->Style2) before the target style's default + // cycle - retail's stance-transition animation. + Assert.Equal( + "10A@30.0^,107@30.0* | frame=0.0 vel=(0.00,0.00,0.00) om=(0.00,0.00,0.00) style=8000004C motion=41000003 mod=1.00", + Describe(seq, loader)); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/AnimationSequencerTests.cs b/tests/AcDream.Core.Tests/Physics/AnimationSequencerTests.cs index e911d21d..ed63ef8e 100644 --- a/tests/AcDream.Core.Tests/Physics/AnimationSequencerTests.cs +++ b/tests/AcDream.Core.Tests/Physics/AnimationSequencerTests.cs @@ -224,32 +224,16 @@ public sealed class AnimationSequencerTests } [Fact] - public void HasCycle_PresentInTable_ReturnsTrue() + public void SetCycle_MissingCycle_LeavesSequenceAndStateUntouched() { - // Phase L.1c followup (2026-04-28): regression guard for - // "torso on the ground" — caller (GameWindow MoveTo path) needs - // to query the table before SetCycle to avoid the - // ClearCyclicTail wipe on a missing cycle. - const uint Style = 0x003Cu; // HandCombat - const uint Motion = 0x0003u; // Ready - const uint AnimId = 0x03000001u; - - var setup = Fixtures.MakeSetup(2); - var mt = Fixtures.MakeMtable(Style, Motion, AnimId); - var loader = new FakeLoader(); - loader.Register(AnimId, Fixtures.MakeTwoFrameAnim(2, Vector3.Zero, Quaternion.Identity, Vector3.Zero, Quaternion.Identity)); - var seq = new AnimationSequencer(setup, mt, loader); - - // Caller passes the SAME shape SetCycle expects: full style with - // class byte (0x80000000) and full motion (0x40000000 / 0x10000000). - Assert.True(seq.HasCycle(0x8000003Cu, 0x41000003u)); - } - - [Fact] - public void HasCycle_MissingFromTable_ReturnsFalse() - { - const uint Style = 0x003Cu; - const uint ReadyMotion = 0x0003u; + // R2-Q5: HasCycle + the caller-side fallback chains are DELETED. + // The retail mechanism replacing the L.1c "torso on the ground" + // guard: GetObjectSequence (0x00522860) checks the cycle BEFORE any + // list surgery — a missing cycle leaves the sequence AND MotionState + // untouched, so whatever was playing (here the initialize_state + // default) keeps playing. + const uint Style = 0x8000003Cu; // HandCombat (full command) + const uint ReadyMotion = 0x41000003u; const uint AnimId = 0x03000001u; var setup = Fixtures.MakeSetup(2); @@ -258,9 +242,17 @@ public sealed class AnimationSequencerTests loader.Register(AnimId, Fixtures.MakeTwoFrameAnim(2, Vector3.Zero, Quaternion.Identity, Vector3.Zero, Quaternion.Identity)); var seq = new AnimationSequencer(setup, mt, loader); - // RunForward (0x44000007) is NOT in the table — caller should - // see false and fall back to a known motion (WalkForward / Ready). - Assert.False(seq.HasCycle(0x8000003Cu, 0x44000007u)); + seq.InitializeState(); + Assert.Equal(ReadyMotion, seq.CurrentMotion); + int nodesBefore = seq.QueueCount; + + // RunForward (0x44000007) is NOT in the table — the dispatch fails + // and nothing changes (no cyclic-tail wipe, no state overwrite). + seq.SetCycle(Style, 0x44000007u); + + Assert.Equal(ReadyMotion, seq.CurrentMotion); + Assert.Equal(nodesBefore, seq.QueueCount); + Assert.True(seq.HasCurrentNode); } [Fact] @@ -333,13 +325,21 @@ public sealed class AnimationSequencerTests [Fact] public void SetCycle_WithTransitionLink_PrependLinkFrames() { - // Two animations: link (2 frames at Y=1) and cycle (4 frames at X=1). - const uint Style = 0x003Du; - const uint IdleMotion = 0x0003u; - const uint WalkMotion = 0x0005u; + // R2-Q4: GetObjectSequence gates Branch 2 (cyclic substates) on the + // 0x40000000 class bit and Branch 1 (style change) on the top bit — + // bare low-word ids like the pre-cutover 0x0003/0x0005 never satisfy + // those gates and the dispatch silently fails. Tag Style/IdleMotion/ + // WalkMotion with their class bits (masking to the low 24 bits for + // the cycle/link key hash is unaffected — CMotionTable keys on + // `id & 0xFFFFFF`). + const uint Style = 0x8000003Du; + const uint IdleMotion = 0x40000003u; + const uint WalkMotion = 0x40000005u; + const uint IdleAnim = 0x03000012u; const uint CycleAnim = 0x03000010u; const uint LinkAnim = 0x03000011u; + var idleAnim = Fixtures.MakeAnim(1, 1, Vector3.Zero, Quaternion.Identity); var cycleAnim = Fixtures.MakeAnim(4, 1, new Vector3(1, 0, 0), Quaternion.Identity); var linkAnim = Fixtures.MakeAnim(2, 1, new Vector3(0, 1, 0), Quaternion.Identity); @@ -352,15 +352,26 @@ public sealed class AnimationSequencerTests fromMotion: IdleMotion, toMotion: WalkMotion, linkAnimId: LinkAnim); + // R2-Q4: retail-mandatory StyleDefaults (SetDefaultState 0x005230a0) — + // route it at IdleMotion (the state this test "was already playing" + // before priming) and give IdleMotion its own cycle so the real + // SetCycle(Style, IdleMotion) priming call below actually dispatches. + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)IdleMotion; + int idleKey = (int)((Style << 16) | (IdleMotion & 0xFFFFFFu)); + mt.Cycles[idleKey] = Fixtures.MakeMotionData(IdleAnim, framerate: 30f); var loader = new FakeLoader(); + loader.Register(IdleAnim, idleAnim); loader.Register(CycleAnim, cycleAnim); loader.Register(LinkAnim, linkAnim); var seq = new AnimationSequencer(setup, mt, loader); - // Prime the sequencer as if it was already playing IdleMotion. - SetCurrentMotion(seq, Style, IdleMotion); + // Prime the sequencer as if it was already playing IdleMotion — a + // real SetCycle call now that CurrentStyle/CurrentMotion are + // read-only mirrors of MotionState (R2-Q4; reflection SetValue no + // longer works, "Property set method not found"). + seq.SetCycle(Style, IdleMotion); seq.SetCycle(Style, WalkMotion); @@ -382,9 +393,13 @@ public sealed class AnimationSequencerTests // link's starting pose at the link→cycle boundary. Symptoms: door // swing-open flap (frame 0 = closed); player run-stop twitch // (frame 0 = mid-stride). - const uint Style = 0x003Du; - const uint IdleMotion = 0x0003u; - const uint WalkMotion = 0x0005u; + // R2-Q4: class-bit-tagged ids (GetObjectSequence gates Branch 1/2 on + // the 0x80000000/0x40000000 bits) — masking to the low 24 bits for + // the cycle/link key hash is unaffected. + const uint Style = 0x8000003Du; + const uint IdleMotion = 0x40000003u; + const uint WalkMotion = 0x40000005u; + const uint IdleAnim = 0x03000082u; const uint CycleAnim = 0x03000080u; const uint LinkAnim = 0x03000081u; @@ -402,6 +417,7 @@ public sealed class AnimationSequencerTests // Cycle anim: single frame at Y=0 (the "open" / "idle" rest pose). var cycleAnim = Fixtures.MakeAnim(1, 1, new Vector3(0, 0, 0), Quaternion.Identity); + var idleAnim = Fixtures.MakeAnim(1, 1, Vector3.Zero, Quaternion.Identity); var setup = Fixtures.MakeSetup(1); var mt = Fixtures.MakeMtable( @@ -412,13 +428,23 @@ public sealed class AnimationSequencerTests toMotion: WalkMotion, linkAnimId: LinkAnim, framerate: 30f); + // R2-Q4: retail-mandatory StyleDefaults (SetDefaultState 0x005230a0) + // — route it at IdleMotion (the state we prime through below) with + // its own cycle so the priming SetCycle call actually dispatches. + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)IdleMotion; + int idleKey = (int)((Style << 16) | (IdleMotion & 0xFFFFFFu)); + mt.Cycles[idleKey] = Fixtures.MakeMotionData(IdleAnim, framerate: 30f); var loader = new FakeLoader(); + loader.Register(IdleAnim, idleAnim); loader.Register(CycleAnim, cycleAnim); loader.Register(LinkAnim, linkAnim); var seq = new AnimationSequencer(setup, mt, loader); - SetCurrentMotion(seq, Style, IdleMotion); + // Prime the sequencer as if it was already playing IdleMotion — a + // real SetCycle call (reflection SetValue no longer works against + // the now-read-only CurrentStyle/CurrentMotion mirrors). + seq.SetCycle(Style, IdleMotion); seq.SetCycle(Style, WalkMotion); // Advance to _framePosition ≈ 2.5 — past the last integer frame (2) @@ -440,53 +466,71 @@ public sealed class AnimationSequencerTests [Fact] public void SetCycle_StopFromWalkBackward_FallsBackToWalkForwardStopLink() { - // Stop-anim asymmetry: the Humanoid motion table only authors a - // "stop walking" link under WalkForward (low byte 0x05). Stopping - // from WalkBackward (0x06) without a fallback returns null linkData - // and the cycle snaps to Ready with no settle blend. Fix: when the - // primary GetLink lookup fails, retry with WalkBackward's low byte - // remapped to WalkForward. - const uint Style = 0x003Du; - const uint WalkForwardCmd = 0x0005u; - const uint WalkBackCmd = 0x0006u; - const uint ReadyCmd = 0x0003u; + // R2-Q4 EXPECTED-DIFF (mirrors AnimationSequencerCutoverTraceTests. + // S6_WalkBackToReady_StopSettleFallback): the pre-cutover adapter had + // an invented "stop-anim low-byte fallback" that re-keyed a + // WalkForward->Ready link when a WalkBackward->Ready lookup missed. + // Retail has no such fallback — CMotionTable.GetLink's verbatim + // reversed-key branch (Q0-pins A1) does the real job: adjust_motion + // remaps WalkBackward to WalkForward with a NEGATIVE SubstateMod, so + // stopping from it drives GetLink's "either speed negative -> swapped + // keys" path, which resolves the link stored FROM the style default + // (Ready) TO WalkForward and plays it IN REVERSE (the Ready->Walk + // windup run backward as a settle). The fixture below stores that + // link under Links[(style,Ready)][WalkForward] — the opposite + // direction from the old WalkForward->Ready fallback entry — because + // that's the key GetLink's reversed branch actually probes. + const uint Style = 0x8000003Du; + const uint WalkForwardCmd = 0x40000005u; + const uint WalkBackCmd = 0x40000006u; + const uint ReadyCmd = 0x40000003u; const uint CycleAnim = 0x03000090u; // Ready cycle (Y=0) - const uint LinkAnim = 0x03000091u; // stop-link (Y=7) + const uint LinkAnim = 0x03000091u; // Ready->Walk windup (Y=7), played reversed as the settle var cycleAnim = Fixtures.MakeAnim(1, 1, new Vector3(0, 0, 0), Quaternion.Identity); var linkAnim = Fixtures.MakeAnim(4, 1, new Vector3(0, 7, 0), Quaternion.Identity); var setup = Fixtures.MakeSetup(1); - // Table: Ready cycle + WalkForward→Ready link. NO WalkBackward→Ready link. + // Table: Ready cycle + Ready->WalkForward windup link (probed + // REVERSED by GetLink's swapped-key branch when settling out of a + // negative-SubstateMod substate). No forward WalkBackward cycle is + // needed — adjust_motion remaps WalkBackward to WalkForward with a + // negated + BackwardsFactor-scaled speed before dispatch ever sees it. var mt = Fixtures.MakeMtable( style: Style, motion: ReadyCmd, cycleAnimId: CycleAnim, - fromMotion: WalkForwardCmd, - toMotion: ReadyCmd, + fromMotion: ReadyCmd, + toMotion: WalkForwardCmd, linkAnimId: LinkAnim, framerate: 30f); + // WalkForward also needs a cycle — adjust_motion's WalkBackward remap + // dispatches WalkForward's cycle (with the negated/scaled speed) as + // part of entering "backward" motion below. + int walkKey = (int)((Style << 16) | (WalkForwardCmd & 0xFFFFFFu)); + mt.Cycles[walkKey] = Fixtures.MakeMotionData(CycleAnim, framerate: 30f); var loader = new FakeLoader(); loader.Register(CycleAnim, cycleAnim); loader.Register(LinkAnim, linkAnim); var seq = new AnimationSequencer(setup, mt, loader); - // Simulate "we were walking backward" — substate = WalkBackward, - // substateSpeed = +1 (the original speedMod stored by SetCycle). - SetCurrentMotion(seq, Style, WalkBackCmd); + // Enter WalkBackward for real — SetCycle's adjust_motion head remaps + // this to WalkForward with SubstateMod = -0.65 (BackwardsFactor), + // which is what makes the SUBSEQUENT stop-to-Ready call route + // GetLink's reversed-key branch. + seq.SetCycle(Style, WalkBackCmd, 1.0f); seq.SetCycle(Style, ReadyCmd); - // Advance a tiny dt — should land on link frame 0 (Y=7), not the - // cycle (Y=0). Without the fallback, linkData is null, only the - // Ready cycle is enqueued, and we read Y=0 immediately. + // Advance a tiny dt — should land on the reversed windup link + // (Y=7), not the Ready cycle (Y=0). var transforms = seq.Advance(0.001f); Assert.Single(transforms); Assert.True(transforms[0].Origin.Y > 5f, - $"Stop-from-backward should fall back to WalkForward→Ready link " - + $"(expect Y≈7 from link); got Y={transforms[0].Origin.Y} " - + "(Y=0 means linkData was null and we snapped to Ready cycle)."); + $"Stop-from-backward should resolve GetLink's reversed-key branch " + + $"(expect Y≈7 from the reversed windup link); got Y={transforms[0].Origin.Y} " + + "(Y=0 means the link didn't resolve and we snapped to the Ready cycle)."); } [Fact] @@ -581,10 +625,14 @@ public sealed class AnimationSequencerTests // with negated speed, so the animation plays in reverse. // We verify this by checking CurrentMotion is still TurnLeft (the // original command), but the sequencer internally uses TurnRight's anim. + // R2-Q4: Style needs the 0x80000000 top bit and TurnRight/TurnLeft the + // 0x40000000 cycle-class bit — GetObjectSequence's entry/branch gates + // (see CurrentVelocity_ExposedFromMotionData_WhenHasVelocity) test the + // FULL command word, not just the low 16 bits adjust_motion remaps. - const uint Style = 0x003Du; // NonCombat - const uint TurnRight = 0x0045000Du; // bit pattern for TurnRight in NonCombat - const uint TurnLeft = 0x0045000Eu; // bit pattern for TurnLeft + const uint Style = 0x8000003Du; // NonCombat + const uint TurnRight = 0x4045000Du; // bit pattern for TurnRight in NonCombat + const uint TurnLeft = 0x4045000Eu; // bit pattern for TurnLeft const uint AnimId = 0x03000050u; // 4-frame animation; each frame has a distinct Z-origin so we can tell @@ -600,6 +648,11 @@ public sealed class AnimationSequencerTests var setup = Fixtures.MakeSetup(1); var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + // R2-Q4: retail-mandatory StyleDefaults (SetDefaultState 0x005230a0) + // — route the default straight at TurnRight (the only cycle this + // fixture defines) so initialize_state's baseline install succeeds + // and state.Style/Substate are non-zero before the explicit dispatch. + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)TurnRight; // Register TurnRight cycle (adjusted motion, not TurnLeft). int cycleKey = (int)((Style << 16) | (TurnRight & 0xFFFFFFu)); @@ -611,29 +664,47 @@ public sealed class AnimationSequencerTests var seq = new AnimationSequencer(setup, mt, loader); seq.SetCycle(Style, TurnLeft, speedMod: 1f); - // CurrentMotion should record the original TurnLeft command. - Assert.Equal(TurnLeft, seq.CurrentMotion); + // R2-Q4 EXPECTED-DIFF (mirrors AnimationSequencerCutoverTraceTests. + // S5_WalkBackward_RemapNegativeSpeed's "mirrors only" diff): + // CurrentMotion is now a GET-ONLY mirror of MotionState.Substate, + // and MotionState owns the POST-adjust_motion substate — retail's + // interpreted state IS the adjusted one (TurnRight played reversed), + // not the raw TurnLeft the caller passed in. Pre-cutover the adapter + // kept its own separate CurrentMotion field and never overwrote it + // with the adjusted id; that field no longer exists. + Assert.Equal(TurnRight, seq.CurrentMotion); + Assert.Equal(-1f, seq.CurrentSpeedMod, 3); - // Without swap: StartFrame=0, EndFrame=3 (original range preserved). - // GetStartFramePosition for negative speed = (EndFrame+1)-eps = (3+1)-eps ≈ 3.99999. - // The cursor starts near the HIGH end and counts DOWN toward StartFrame(=0). + // R1-P5 (2026-07-02): pre-cutover this pinned the ACE-fabricated + // epsilon boundary ((EndFrame+1)-eps ~= 3.99999). Retail's + // AnimSequenceNode.GetStartingFrame (0x00525c80) returns a BARE INT + // for reverse playback: HighFrame + 1 (gap map G1 — "NO epsilon"). + // LowFrame=0, HighFrame=3 (no swap at append time; the swap only + // happens inside MultiplyFramerate for an in-place resign, which + // this path doesn't take), so the retail-exact start position is + // exactly 4.0, not "near but under" 4.0. The cursor starts at the + // boundary and counts DOWN toward LowFrame(=0) on the next Advance. double pos = GetFramePosition(seq); - Assert.True(pos > 3.9 && pos < 4.0, - $"Expected framePosition near 3.99999 (reverse start near EndFrame+1) but got {pos}"); + Assert.True(pos == 4.0, + $"Expected framePosition == 4 (bare-int reverse start = HighFrame+1, " + + $"retail AnimSequenceNode.GetStartingFrame 0x00525c80 has NO epsilon — G1); got {pos}"); } [Fact] public void Advance_NegativeSpeed_FramePositionDecreases() { // Verify that a cycle loaded with negative framerate counts downward. - const uint Style = 0x003Du; - const uint Motion = 0x0003u; + // R2-Q4: retail-mandatory StyleDefaults + the 0x40000000 cycle-class + // bit on Motion (see CurrentVelocity_ExposedFromMotionData_WhenHasVelocity). + const uint Style = 0x8000003Du; + const uint Motion = 0x40000003u; const uint AnimId = 0x03000060u; var anim = Fixtures.MakeAnim(8, 1, Vector3.Zero, Quaternion.Identity); var setup = Fixtures.MakeSetup(1); var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)Motion; // Register cycle with NEGATIVE framerate to simulate reverse playback. int cycleKey = (int)((Style << 16) | (Motion & 0xFFFFFFu)); @@ -719,9 +790,11 @@ public sealed class AnimationSequencerTests { // Queue: [linkNode (2 frames, 10fps, non-looping)] → [cycleNode (4 frames, looping)] // Advance enough to exhaust the link node, then verify we're in the cycle. - const uint Style = 0x003Du; - const uint IdleMotion = 0x0003u; - const uint WalkMotion = 0x0005u; + // R2-Q4: class-bit-tagged ids (see SetCycle_WithTransitionLink_PrependLinkFrames). + const uint Style = 0x8000003Du; + const uint IdleMotion = 0x40000003u; + const uint WalkMotion = 0x40000005u; + const uint IdleAnim = 0x03000082u; const uint CycleAnim = 0x03000080u; const uint LinkAnim = 0x03000081u; @@ -729,6 +802,7 @@ public sealed class AnimationSequencerTests var linkAnim = Fixtures.MakeAnim(2, 1, new Vector3(0, 5, 0), Quaternion.Identity); // Cycle anim: 4 frames, X=9 (distinct marker). var cycleAnim = Fixtures.MakeAnim(4, 1, new Vector3(9, 0, 0), Quaternion.Identity); + var idleAnim = Fixtures.MakeAnim(1, 1, Vector3.Zero, Quaternion.Identity); var setup = Fixtures.MakeSetup(1); var mt = Fixtures.MakeMtable( @@ -739,13 +813,22 @@ public sealed class AnimationSequencerTests toMotion: WalkMotion, linkAnimId: LinkAnim, framerate: 10f); + // R2-Q4: retail-mandatory StyleDefaults (SetDefaultState 0x005230a0) + // — route it at IdleMotion with its own cycle so the priming + // SetCycle call below actually dispatches. + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)IdleMotion; + int idleKey = (int)((Style << 16) | (IdleMotion & 0xFFFFFFu)); + mt.Cycles[idleKey] = Fixtures.MakeMotionData(IdleAnim, framerate: 10f); var loader = new FakeLoader(); + loader.Register(IdleAnim, idleAnim); loader.Register(CycleAnim, cycleAnim); loader.Register(LinkAnim, linkAnim); var seq = new AnimationSequencer(setup, mt, loader); - SetCurrentMotion(seq, Style, IdleMotion); + // Prime as if already playing IdleMotion — real SetCycle call + // (reflection SetValue no longer works, see WithTransitionLink test). + seq.SetCycle(Style, IdleMotion); seq.SetCycle(Style, WalkMotion); // Link node is 2 frames at 10fps → 0.2s to exhaust. @@ -916,8 +999,11 @@ public sealed class AnimationSequencerTests public void Advance_ForwardHookDoesNotFire_OnReversePlayback() { // A hook tagged Direction.Forward should NOT fire when playback is reversed. - const uint Style = 0x003Du; - const uint Motion = 0x0003u; + // R2-Q4: class-bit-tagged ids + retail-mandatory StyleDefaults — the bare + // ids made this test pass VACUOUSLY (dispatch silently failed, no anim + // played, so "hook did not fire" held for the wrong reason). + const uint Style = 0x8000003Du; + const uint Motion = 0x40000003u; const uint AnimId = 0x03000103u; var anim = Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity); @@ -930,6 +1016,7 @@ public sealed class AnimationSequencerTests var setup = Fixtures.MakeSetup(1); var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)Motion; int cycleKey = (int)((Style << 16) | (Motion & 0xFFFFFFu)); var md = new MotionData(); QualifiedDataId qid = AnimId; @@ -944,7 +1031,10 @@ public sealed class AnimationSequencerTests seq.ConsumePendingHooks(); // Reverse playback: cursor starts near frame 4 and counts down. - seq.Advance(0.15f); + // 0.25s at -10fps = -2.5 frames → crosses the 3→2 boundary, so the + // hooked frame IS reached (same advance as the Backward sibling test + // — the direction filter, not distance, is what's under test). + seq.Advance(0.25f); var hooks = seq.ConsumePendingHooks(); // Forward-only hook on frame 2 should NOT fire on reverse playback. @@ -954,8 +1044,10 @@ public sealed class AnimationSequencerTests [Fact] public void Advance_BackwardHook_FiresOnReversePlayback() { - const uint Style = 0x003Du; - const uint Motion = 0x0003u; + // R2-Q4: retail-mandatory StyleDefaults + the 0x40000000 cycle-class + // bit on Motion (see CurrentVelocity_ExposedFromMotionData_WhenHasVelocity). + const uint Style = 0x8000003Du; + const uint Motion = 0x40000003u; const uint AnimId = 0x03000104u; var anim = Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity); @@ -968,6 +1060,7 @@ public sealed class AnimationSequencerTests var setup = Fixtures.MakeSetup(1); var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)Motion; int cycleKey = (int)((Style << 16) | (Motion & 0xFFFFFFu)); var md = new MotionData(); QualifiedDataId qid = AnimId; @@ -990,13 +1083,17 @@ public sealed class AnimationSequencerTests Assert.Contains(hooks, h => h is SoundHook sh && (uint)sh.Id == 0x0A000005u); } - // ── PosFrames root motion (Phase E.1) ──────────────────────────────────── + // ── PosFrames root motion (R1-P6: the wired Frame path, gap map G7) ─────── [Fact] - public void Advance_WithPosFrames_AccumulatesRootMotion() + public void Advance_WithRootMotionFrame_AccumulatesPosFrameDeltas() { - // Animation with PosFrames flag and per-frame origin deltas should - // surface a non-zero root motion delta after Advance. + // R1-P6 (2026-07-02): root motion flows through retail's actual + // contract — CSequence::update(quantum, Frame*) (0x00525b80): + // every crossed integer frame combines the node's pos_frame into + // the caller-supplied Frame (update_internal 0x005255d0). The old + // adapter-side accumulator (ConsumeRootMotionDelta) is DELETED — + // this is the seam R6's per-tick order consumes. const uint Style = 0x003Du; const uint Motion = 0x0003u; const uint AnimId = 0x03000110u; @@ -1020,27 +1117,27 @@ public sealed class AnimationSequencerTests var seq = new AnimationSequencer(setup, mt, loader); seq.SetCycle(Style, Motion); - seq.ConsumeRootMotionDelta(); // clear - // Advance 0.25s → 2.5 frames → 2 crossings (0→1, 1→2) → 2 posFrame deltas applied. - seq.Advance(0.25f); - var (pos, _) = seq.ConsumeRootMotionDelta(); + // Advance 0.25s @10fps → 2.5 frames → 2 crossings (0→1, 1→2), each + // combining +1 X of pos_frame origin into the supplied Frame. + var rootFrame = new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }; + seq.Advance(0.25f, rootFrame); - // Each crossing adds +X origin → total X should be 2. - Assert.True(pos.X >= 1.8f && pos.X <= 2.2f, - $"Expected ~2.0 root motion X after 2 crossings, got {pos.X}"); - - // A subsequent consume with no advance should return zero (drained). - var (pos2, _) = seq.ConsumeRootMotionDelta(); - Assert.Equal(Vector3.Zero, pos2); + Assert.True(rootFrame.Origin.X >= 1.8f && rootFrame.Origin.X <= 2.2f, + $"Expected ~2.0 root motion X after 2 crossings via the wired Frame, got {rootFrame.Origin.X}"); } [Fact] public void CurrentVelocity_ExposedFromMotionData_WhenHasVelocity() { // MotionData with HasVelocity flag should surface via CurrentVelocity. - const uint Style = 0x003Du; - const uint Motion = 0x0003u; + // R2-Q4: retail-mandatory StyleDefaults (SetDefaultState 0x005230a0) — + // without it, initialize_state's SetDefaultState fails, state.Style + // stays 0, and GetObjectSequence's entry guard rejects every + // dispatch. Route the default straight at Motion (the cycle this + // test cares about). + const uint Style = 0x8000003Du; + const uint Motion = 0x40000003u; const uint AnimId = 0x03000120u; var anim = Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity); @@ -1048,6 +1145,7 @@ public sealed class AnimationSequencerTests var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)Motion; int cycleKey = (int)((Style << 16) | (Motion & 0xFFFFFFu)); var md = new MotionData { @@ -1071,8 +1169,12 @@ public sealed class AnimationSequencerTests [Fact] public void CurrentVelocity_ScaledBySpeedMod() { - const uint Style = 0x003Du; - const uint Motion = 0x0003u; + // R2-Q4: retail-mandatory StyleDefaults, and Motion needs its + // 0x40000000 cycle-class bit — the same-motion re-speed fast path + // (Branch 2, target==substate) still requires the class-bit gate to + // be reached in the first place. + const uint Style = 0x8000003Du; + const uint Motion = 0x40000003u; const uint AnimId = 0x03000121u; var anim = Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity); @@ -1080,6 +1182,7 @@ public sealed class AnimationSequencerTests var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)Motion; int cycleKey = (int)((Style << 16) | (Motion & 0xFFFFFFu)); var md = new MotionData { @@ -1106,27 +1209,37 @@ public sealed class AnimationSequencerTests // When a non-cyclic link node exhausts and we advance_to_next_animation, // an AnimationDoneHook should be queued so consumers can react (e.g. UI // wake-on-idle-complete). - const uint Style = 0x003Du; - const uint IdleMotion = 0x0003u; - const uint WalkMotion = 0x0005u; + // R2-Q4: class-bit-tagged ids (see SetCycle_WithTransitionLink_PrependLinkFrames). + const uint Style = 0x8000003Du; + const uint IdleMotion = 0x40000003u; + const uint WalkMotion = 0x40000005u; + const uint IdleAnim = 0x03000132u; const uint CycleAnim = 0x03000130u; const uint LinkAnim = 0x03000131u; var linkAnim = Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity); var cycleAnim = Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity); + var idleAnim = Fixtures.MakeAnim(1, 1, Vector3.Zero, Quaternion.Identity); var setup = Fixtures.MakeSetup(1); var mt = Fixtures.MakeMtable( style: Style, motion: WalkMotion, cycleAnimId: CycleAnim, fromMotion: IdleMotion, toMotion: WalkMotion, linkAnimId: LinkAnim, framerate: 10f); + // R2-Q4: retail-mandatory StyleDefaults — route it at IdleMotion with + // its own cycle so the priming SetCycle call below actually dispatches. + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)IdleMotion; + int idleKey = (int)((Style << 16) | (IdleMotion & 0xFFFFFFu)); + mt.Cycles[idleKey] = Fixtures.MakeMotionData(IdleAnim, framerate: 10f); var loader = new FakeLoader(); + loader.Register(IdleAnim, idleAnim); loader.Register(CycleAnim, cycleAnim); loader.Register(LinkAnim, linkAnim); var seq = new AnimationSequencer(setup, mt, loader); - SetCurrentMotion(seq, Style, IdleMotion); + // Prime as if already playing IdleMotion — real SetCycle call. + seq.SetCycle(Style, IdleMotion); seq.SetCycle(Style, WalkMotion); seq.ConsumePendingHooks(); @@ -1144,8 +1257,11 @@ public sealed class AnimationSequencerTests { // A 10-frame cycle at 10 fps = 1.0s per loop. If we halve the playback // rate (factor 0.5), advancing 1.0s should produce half a loop (5 frames). - const uint Style = 0x003Du; - const uint Motion = 0x0007u; // RunForward + // R2-Q4: Motion needs the 0x40000000 cycle-class bit — GetObjectSequence + // Branch 2 (and its same-motion fast re-speed path) never triggers on + // a bare low-word id (see CurrentVelocity_ExposedFromMotionData_WhenHasVelocity). + const uint Style = 0x8000003Du; + const uint Motion = 0x40000007u; // RunForward const uint AnimId = 0x03000401u; // Unique per-frame Z so we can tell where the cursor lands. @@ -1171,6 +1287,11 @@ public sealed class AnimationSequencerTests Framerate = 10f, }); mt.Cycles[cycleKey] = md; + // R2-Q4: the dispatch stack needs the retail-mandatory StyleDefaults + // entry (SetDefaultState 0x005230a0 requires StyleDefaults[DefaultStyle]; + // GetObjectSequence refuses a zero style/substate). Real dat tables + // always carry it. + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)Motion; var loader = new FakeLoader(); loader.Register(AnimId, anim); @@ -1178,8 +1299,11 @@ public sealed class AnimationSequencerTests var seq = new AnimationSequencer(setup, mt, loader); seq.SetCycle(Style, Motion, speedMod: 1f); - // Halve the playback rate. - seq.MultiplyCyclicFramerate(0.5f); + // R2-Q4: halve the playback rate via the retail same-motion re-speed + // (GetObjectSequence Branch-2 fast path: change_cycle_speed + + // subtract_motion(old) + combine_motion(new), decomp §5) — the old + // MultiplyCyclicFramerate adapter composite is deleted. + seq.SetCycle(Style, Motion, speedMod: 0.5f); // 10 frames at 5 fps = 2.0s per loop. Advance 1.0s → cursor ~= frame 5. seq.Advance(1.0f); @@ -1187,7 +1311,8 @@ public sealed class AnimationSequencerTests Assert.Single(frames); Assert.InRange(frames[0].Origin.Z, 4f, 6f); - // Velocity also scales: originally (0,4,0), now (0,2,0). + // Velocity also scales: originally (0,4,0), now (0,2,0) + // (subtract_motion(1.0) + combine_motion(0.5) = ×0.5 net). Assert.Equal(2f, seq.CurrentVelocity.Y, 1); } @@ -1196,8 +1321,11 @@ public sealed class AnimationSequencerTests { // Changing speed mid-cycle must NOT reset the frame cursor — the // animation keeps playing from where it was, just faster/slower. - const uint Style = 0x003Du; - const uint Motion = 0x0007u; + // R2-Q4: class-bit-tagged ids — the bare ids made this test pass + // VACUOUSLY (dispatch silently failed; "cursor unchanged" held + // because nothing moved at all). + const uint Style = 0x8000003Du; + const uint Motion = 0x40000007u; const uint AnimId = 0x03000402u; var anim = new Animation(); @@ -1213,6 +1341,9 @@ public sealed class AnimationSequencerTests mt.DefaultStyle = (DRWMotionCommand)Style; int cycleKey = (int)((Style << 16) | (Motion & 0xFFFFFFu)); mt.Cycles[cycleKey] = Fixtures.MakeMotionData(AnimId, framerate: 10f); + // R2-Q4: retail-mandatory StyleDefaults entry (see + // MultiplyCyclicFramerate_HalvesPlaybackRate). + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)Motion; var loader = new FakeLoader(); loader.Register(AnimId, anim); @@ -1222,7 +1353,9 @@ public sealed class AnimationSequencerTests seq.Advance(0.3f); // cursor ~ frame 3 double before = GetFramePosition(seq); - seq.MultiplyCyclicFramerate(2.0f); + // R2-Q4: mid-cycle re-speed via the retail Branch-2 fast path — must + // not touch the cursor (change_cycle_speed scales framerates only). + seq.SetCycle(Style, Motion, speedMod: 2.0f); double after = GetFramePosition(seq); Assert.Equal(before, after, 5); @@ -1235,8 +1368,10 @@ public sealed class AnimationSequencerTests // NOT reset the cursor — it should call MultiplyCyclicFramerate to // keep the run loop smooth (retail behavior for a mid-run RunRate // broadcast). Mirror of ACE MotionTable.cs:132-139 fast-path. - const uint Style = 0x003Du; - const uint Motion = 0x0007u; + // R2-Q4: Motion needs the 0x40000000 cycle-class bit — see + // CurrentVelocity_ExposedFromMotionData_WhenHasVelocity. + const uint Style = 0x8000003Du; + const uint Motion = 0x40000007u; const uint AnimId = 0x03000403u; var anim = Fixtures.MakeAnim(10, 1, Vector3.Zero, Quaternion.Identity); @@ -1267,14 +1402,17 @@ public sealed class AnimationSequencerTests // surface as (0,4,0) at speedMod=1.0, (0,6,0) at 1.5×, (0,2,0) at // 0.5×. The dead-reckoning integrator in TickAnimations reads // CurrentVelocity each tick, so this has to be accurate. - const uint Style = 0x003Du; - const uint Motion = 0x0007u; + // R2-Q4: retail-mandatory StyleDefaults + the 0x40000000 cycle-class + // bit on Motion (see CurrentVelocity_ExposedFromMotionData_WhenHasVelocity). + const uint Style = 0x8000003Du; + const uint Motion = 0x40000007u; const uint AnimId = 0x03000405u; var anim = Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity); var setup = Fixtures.MakeSetup(1); var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)Motion; int cycleKey = (int)((Style << 16) | (Motion & 0xFFFFFFu)); var md = new MotionData { Flags = MotionDataFlags.HasVelocity, Velocity = new Vector3(0, 4, 0) }; @@ -1310,8 +1448,10 @@ public sealed class AnimationSequencerTests { // Guard: the new speed-path must not break the classic // "identical call = no state change" behavior. - const uint Style = 0x003Du; - const uint Motion = 0x0007u; + // R2-Q4: Motion needs the 0x40000000 cycle-class bit — see + // CurrentVelocity_ExposedFromMotionData_WhenHasVelocity. + const uint Style = 0x8000003Du; + const uint Motion = 0x40000007u; const uint AnimId = 0x03000404u; var anim = Fixtures.MakeAnim(10, 1, Vector3.Zero, Quaternion.Identity); @@ -1338,14 +1478,17 @@ public sealed class AnimationSequencerTests // A turn cycle with MotionData.Omega = (0, 0, 1) rad/sec (yaw) // should surface as CurrentOmega = (0, 0, 1) after SetCycle. // Scales with speedMod exactly like Velocity. - const uint Style = 0x003Du; - const uint Motion = 0x000Du; // TurnRight + // R2-Q4: retail-mandatory StyleDefaults + the 0x40000000 cycle-class + // bit on Motion (see CurrentVelocity_ExposedFromMotionData_WhenHasVelocity). + const uint Style = 0x8000003Du; + const uint Motion = 0x4000000Du; // TurnRight const uint AnimId = 0x03000701u; var anim = Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity); var setup = Fixtures.MakeSetup(1); var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)Motion; int cycleKey = (int)((Style << 16) | (Motion & 0xFFFFFFu)); var md = new MotionData { Flags = MotionDataFlags.HasOmega, Omega = new Vector3(0, 0, 1.0f) }; @@ -1374,19 +1517,27 @@ public sealed class AnimationSequencerTests // reads the cycle's run-speed and moves the entity smoothly. // Crucial: otherwise remote entities would stutter at every stance // transition while the link plays. - const uint Style = 0x003Du; - const uint IdleMotion = 0x0003u; - const uint WalkMotion = 0x0005u; + // R2-Q4: class-bit-tagged ids (see SetCycle_WithTransitionLink_PrependLinkFrames). + const uint Style = 0x8000003Du; + const uint IdleMotion = 0x40000003u; + const uint WalkMotion = 0x40000005u; + const uint IdleAnim = 0x03000603u; const uint CycleAnim = 0x03000601u; const uint LinkAnim = 0x03000602u; var cycleAnim = Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity); var linkAnim = Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity); + var idleAnim = Fixtures.MakeAnim(1, 1, Vector3.Zero, Quaternion.Identity); var setup = Fixtures.MakeSetup(1); var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; - mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)WalkMotion; + // R2-Q4: retail-mandatory StyleDefaults (SetDefaultState 0x005230a0) + // — route it at IdleMotion (the state we prime through below). + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)IdleMotion; + + int idleKey = (int)((Style << 16) | (IdleMotion & 0xFFFFFFu)); + mt.Cycles[idleKey] = Fixtures.MakeMotionData(IdleAnim, framerate: 10f); int cycleKey = (int)((Style << 16) | (WalkMotion & 0xFFFFFFu)); var cycleMd = new MotionData { Flags = MotionDataFlags.HasVelocity, Velocity = new Vector3(0, 3.12f, 0) }; @@ -1404,11 +1555,13 @@ public sealed class AnimationSequencerTests mt.Links[linkOuter] = linkCmdData; var loader = new FakeLoader(); + loader.Register(IdleAnim, idleAnim); loader.Register(CycleAnim, cycleAnim); loader.Register(LinkAnim, linkAnim); var seq = new AnimationSequencer(setup, mt, loader); - SetCurrentMotion(seq, Style, IdleMotion); + // Prime as if already playing IdleMotion — real SetCycle call. + seq.SetCycle(Style, IdleMotion); seq.SetCycle(Style, WalkMotion); // We just enqueued [link(0)][cycle(3.12 forward)]. Current node is @@ -1432,7 +1585,11 @@ public sealed class AnimationSequencerTests // An Action-class command (mask 0x10) resolves via the Links dict // keyed by (style, currentSubstate) → motion. Example: a ThrustMed // attack while in SwordCombat stance. - const uint Style = 0x003Eu; // SwordCombat + // R2-Q4: Style needs the 0x80000000 top bit + a StyleDefaults entry + // (SetDefaultState 0x005230a0 is retail-mandatory — GetObjectSequence + // refuses style==0/substate==0, see + // CurrentVelocity_ExposedFromMotionData_WhenHasVelocity). + const uint Style = 0x8000003Eu; // SwordCombat const uint IdleMotion = 0x41000003u; // Ready const uint ActionMotion = 0x10000058u; // ThrustMed (Action class) const uint IdleAnimId = 0x03000501u; @@ -1445,6 +1602,7 @@ public sealed class AnimationSequencerTests var setup = Fixtures.MakeSetup(1); var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)IdleMotion; int cycleKey = (int)((Style << 16) | (IdleMotion & 0xFFFFFFu)); mt.Cycles[cycleKey] = Fixtures.MakeMotionData(IdleAnimId, framerate: 10f); @@ -1478,7 +1636,9 @@ public sealed class AnimationSequencerTests // values followed by Ready. Retail keeps currState.Substate at Ready // while the action link drains, so the Ready echo must not abort the // in-flight swing. - const uint Style = 0x003Du; + // R2-Q4: Style needs the 0x80000000 top bit + a StyleDefaults entry + // (see PlayAction_Action_ResolvesFromLinksDict). + const uint Style = 0x8000003Du; const uint IdleMotion = 0x41000003u; const uint AttackMotion = 0x10000052u; const uint IdleAnimId = 0x03000503u; @@ -1486,6 +1646,7 @@ public sealed class AnimationSequencerTests var setup = Fixtures.MakeSetup(1); var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)Style }; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)IdleMotion; int cycleKey = (int)((Style << 16) | (IdleMotion & 0xFFFFFFu)); mt.Cycles[cycleKey] = Fixtures.MakeMotionData(IdleAnimId, framerate: 10f); @@ -1513,11 +1674,19 @@ public sealed class AnimationSequencerTests [Fact] public void PlayAction_Modifier_ResolvesFromModifiersDict() { - // A Modifier-class command (mask 0x20) — like Jump (0x2500003B) — - // resolves from the Modifiers dict, first with style-specific key - // then with unstyled fallback. Empirically: the modifier's anim - // plays on top of the current cycle. - const uint Style = 0x003Du; + // R2-Q4 EXPECTED-DIFF (mirrors AnimationSequencerCutoverTraceTests. + // S9_TurnModifier): a Modifier-class command (mask 0x20) — like Jump + // (0x2500003B) or a turn-while-moving overlay — resolves from the + // Modifiers dict, first with style-specific key then with unstyled + // fallback (CMotionTable.GetObjectSequence Branch 4). Pre-cutover the + // adapter INSERTED the modifier's anim before the cyclic tail — an + // acdream invention. Retail Branch 4 is PHYSICS-ONLY combine_motion: + // the base cycle's anim list is untouched (no new nodes), and the + // modifier contributes velocity/omega on top of the cycle's own, + // tracked on the MotionState modifier stack (AP-73 mechanism). + // R2-Q4: Style needs the 0x80000000 top bit + a StyleDefaults entry + // (see PlayAction_Action_ResolvesFromLinksDict). + const uint Style = 0x8000003Du; const uint IdleMotion = 0x41000003u; const uint JumpMotion = 0x2500003Bu; // Modifier class const uint IdleAnimId = 0x03000510u; @@ -1529,12 +1698,18 @@ public sealed class AnimationSequencerTests var setup = Fixtures.MakeSetup(1); var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)IdleMotion; int cycleKey = (int)((Style << 16) | (IdleMotion & 0xFFFFFFu)); mt.Cycles[cycleKey] = Fixtures.MakeMotionData(IdleAnimId, framerate: 10f); - // Modifier: (Style, Jump) + // Modifier: (Style, Jump) — carries an omega contribution (a jump + // kick's angular nudge) rather than an anim payload, since Branch 4 + // never touches the anim list. int modKey = (int)((Style << 16) | (JumpMotion & 0xFFFFFFu)); - mt.Modifiers[modKey] = Fixtures.MakeMotionData(JumpAnimId, framerate: 10f); + var jumpMd = Fixtures.MakeMotionData(JumpAnimId, framerate: 10f); + jumpMd.Flags = MotionDataFlags.HasOmega; + jumpMd.Omega = new Vector3(0f, 0f, 2.5f); + mt.Modifiers[modKey] = jumpMd; var loader = new FakeLoader(); loader.Register(IdleAnimId, idleAnim); @@ -1542,12 +1717,15 @@ public sealed class AnimationSequencerTests var seq = new AnimationSequencer(setup, mt, loader); seq.SetCycle(Style, IdleMotion); + int queueBefore = seq.QueueCount; seq.PlayAction(JumpMotion); - var fr = seq.Advance(0.01f); - Assert.Single(fr); - Assert.Equal(77f, fr[0].Origin.Z, 1); + // No anim nodes inserted — the queue is unchanged from before the + // modifier fired. + Assert.Equal(queueBefore, seq.QueueCount); + // The modifier's omega is combined onto the sequence's physics. + Assert.Equal(2.5f, seq.CurrentOmega.Z, 3); } [Fact] @@ -1557,7 +1735,9 @@ public sealed class AnimationSequencerTests // Action(0x10) | ChatEmote(0x02) | Mappable(0x01). Because the // Action bit is set, they route through the Links-dict lookup just // like attacks. Verifies the class-bit math. - const uint Style = 0x003Du; + // R2-Q4: Style needs the 0x80000000 top bit + a StyleDefaults entry + // (see PlayAction_Action_ResolvesFromLinksDict). + const uint Style = 0x8000003Du; const uint IdleMotion = 0x41000003u; const uint WaveMotion = 0x13000087u; const uint IdleAnimId = 0x03000520u; @@ -1569,6 +1749,7 @@ public sealed class AnimationSequencerTests var setup = Fixtures.MakeSetup(1); var mt = new MotionTable(); mt.DefaultStyle = (DRWMotionCommand)Style; + mt.StyleDefaults[(DRWMotionCommand)Style] = (DRWMotionCommand)IdleMotion; int cycleKey = (int)((Style << 16) | (IdleMotion & 0xFFFFFFu)); mt.Cycles[cycleKey] = Fixtures.MakeMotionData(IdleAnimId, framerate: 10f); @@ -1624,14 +1805,27 @@ public sealed class AnimationSequencerTests // ── Helpers ────────────────────────────────────────────────────────────── - /// Expose _framePosition (double) via reflection (test-only). + /// + /// Expose the core CSequence's FrameNumber via reflection (test-only). + /// R1-P5 rehost (2026-07-02): _framePosition lived directly on + /// AnimationSequencer pre-cutover; it now lives on the private _core + /// (CSequence) field as the public FrameNumber. Two-hop reflection: + /// grab _core, then its FrameNumber field. + /// private static double GetFramePosition(AnimationSequencer seq) { - var field = typeof(AnimationSequencer) - .GetField("_framePosition", + var coreField = typeof(AnimationSequencer) + .GetField("_core", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); - return field is null ? -1.0 : (double)field.GetValue(seq)!; + var core = coreField?.GetValue(seq); + if (core is null) return -1.0; + + var frameNumberField = core.GetType() + .GetField("FrameNumber", + System.Reflection.BindingFlags.Public | + System.Reflection.BindingFlags.Instance); + return frameNumberField is null ? -1.0 : (double)frameNumberField.GetValue(core)!; } /// diff --git a/tests/AcDream.Core.Tests/Physics/BSPQueryTests.cs b/tests/AcDream.Core.Tests/Physics/BSPQueryTests.cs index c2474e4e..be9b279a 100644 --- a/tests/AcDream.Core.Tests/Physics/BSPQueryTests.cs +++ b/tests/AcDream.Core.Tests/Physics/BSPQueryTests.cs @@ -699,8 +699,13 @@ public class BSPQueryTests // Regression guard for the FULL-HIT case in the same Path 5 branch. // Sphere overlaps wall AND moves INTO it: moveDot < 0, cull does NOT // reject, pos_hits_sphere returns 1, Path 5 takes the `if (hit0)` - // branch. With engine=null we fall through to the slide fallback - // (SetCollisionNormal + SetSlidingNormal + return Slid). + // branch. With engine=null we fall through to the real slide + // (CSphere::slide_sphere via Transition.SlideSphereInternal). No + // contact plane is seeded on this bare Transition, so the slide takes + // the wall-only branch (project out the into-wall displacement, + // return Slid) — and per retail it must NOT write the sliding normal + // (#137 mechanism 2; validate_transition 0x0050ac21 is the only + // in-transition writer). var (root, resolved) = BuildSingleWallBsp(); var transition = new Transition(); @@ -731,6 +736,9 @@ public class BSPQueryTests Assert.Equal(TransitionState.Slid, state); Assert.True(transition.CollisionInfo.CollisionNormalValid, "Full hit should set the collision normal (slide fallback)."); + Assert.False(transition.CollisionInfo.SlidingNormalValid, + "find_collisions must not write the sliding normal — retail's " + + "only in-transition writer is validate_transition (#137)."); Assert.False(transition.SpherePath.NegPolyHit, "Full hit should NOT also fire NegPolyHit — that's the near-miss " + "path only. Retail at acclient_2013_pseudo_c.txt:0053a647 returns " + diff --git a/tests/AcDream.Core.Tests/Physics/CylSphereFamilyTests.cs b/tests/AcDream.Core.Tests/Physics/CylSphereFamilyTests.cs new file mode 100644 index 00000000..57f405a4 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/CylSphereFamilyTests.cs @@ -0,0 +1,287 @@ +using System; +using System.Numerics; +using AcDream.Core.Physics; +using Xunit; +using Xunit.Abstractions; +using Plane = System.Numerics.Plane; + +namespace AcDream.Core.Tests.Physics; + +/// +/// Conformance tests for the retail CCylSphere collision family port +/// (2026-07-05) — dispatcher 0x0053b440 + step_sphere_down +/// 0x0053a9b0 + step_sphere_up 0x0053b310 + +/// land_on_cylinder 0x0053b3d0. Pseudocode: +/// docs/research/2026-07-05-ccylsphere-collision-family-pseudocode.md. +/// +/// +/// The driving repro: the Holtburg town-network portal platform (stab +/// 0xC0A9B465, Setup 0x020019E3) registers a WIDE LOW cylinder +/// (r=2.597 m, h=0.256 m). Retail steps a grounded player UP ONTO its flat +/// top; the pre-port approximation could only radial-slide, so the player +/// orbited the rim forever (launch-137-repro.log, 2026-07-05). These tests +/// pin the three retail behaviors the family provides: grounded +/// step-up-onto-top, too-tall side slide, and the airborne top landing. +/// Synthetic cylinders only — no dat dependency. +/// +/// +public class CylSphereFamilyTests +{ + private readonly ITestOutputHelper _out; + public CylSphereFamilyTests(ITestOutputHelper output) => _out = output; + + private const uint TestLandblockId = 0xA9B40000u; + private const uint TestCellId = TestLandblockId | 0x0001u; // landcell (0,0) + + private const float SphereRadius = 0.48f; // retail player capsule radius + private const float SphereHeight = 1.20f; + private const float StepUpHeight = 0.60f; + private const float StepDownHeight = 0.04f; + + // The live platform's registered shape ([cyl-test] launch-137-repro.log). + private const float PlatformRadius = 2.597f; + private const float PlatformHeight = 0.256f; + + /// + /// The portal-platform repro: a grounded player walking into the wide low + /// cylinder must STEP UP onto its flat top (retail + /// grounded branch → step_sphere_up → CTransition::step_up, whose + /// step-down probe lands via step_sphere_down's top-disc contact plane) — + /// not slide around the rim. + /// + [Fact] + public void Grounded_WalkIntoWideLowCylinder_StepsUpOntoTop() + { + var engine = BuildEngine(out _); + RegisterCylinder(engine, entityId: 0xCAFEu, + worldPos: new Vector3(12f, 14f, 0f), + radius: PlatformRadius, height: PlatformHeight); + + var body = MakeGroundedBody(new Vector3(12f, 10.4f, 0f)); + Vector3 pos = body.Position; + uint cellId = TestCellId; + bool grounded = true; + var perTick = new Vector3(0f, 0.10f, 0f); + + for (int tick = 0; tick < 40; tick++) + { + var result = engine.ResolveWithTransition( + pos, pos + perTick, cellId, + SphereRadius, SphereHeight, StepUpHeight, StepDownHeight, + grounded, + body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide, + movingEntityId: 0); + + body.Position = result.Position; + pos = result.Position; + cellId = result.CellId; + grounded = result.IsOnGround; + } + + _out.WriteLine($"final pos=({pos.X:F3},{pos.Y:F3},{pos.Z:F3}) grounded={grounded}"); + + // Rim contact is at Y ≈ 14 − 2.597 − 0.48 = 10.92. Pre-port the player + // pinned there (Z stayed 0, Y never passed the rim). Post-port the + // player must be standing ON the platform top. + Assert.True(pos.Y > 11.5f, + $"Player must advance past the rim contact (pre-port it pinned at Y≈10.9); got Y={pos.Y:F3}"); + Assert.True(MathF.Abs(pos.Z - PlatformHeight) < 0.05f, + $"Player must stand ON the platform top (Z≈{PlatformHeight:F3}); got Z={pos.Z:F3}"); + Assert.True(grounded, "Player must remain grounded after stepping onto the platform"); + } + + /// + /// A tall thin cylinder (the Holtburg torch shape, r=0.2 h=2.2 — #149) + /// exceeds step_up_height: the grounded dead-center approach must NOT + /// step up and must NOT pass through — retail slides (dead-center the + /// crease projection degenerates to a hard stop). + /// + [Fact] + public void Grounded_WalkIntoTallCylinder_BlocksBeforeAxis() + { + var engine = BuildEngine(out _); + RegisterCylinder(engine, entityId: 0xF00Du, + worldPos: new Vector3(12f, 14f, 0f), + radius: 0.2f, height: 2.2f); + + var body = MakeGroundedBody(new Vector3(12f, 12.6f, 0f)); + Vector3 pos = body.Position; + uint cellId = TestCellId; + bool grounded = true; + var perTick = new Vector3(0f, 0.10f, 0f); + + for (int tick = 0; tick < 30; tick++) + { + var result = engine.ResolveWithTransition( + pos, pos + perTick, cellId, + SphereRadius, SphereHeight, StepUpHeight, StepDownHeight, + grounded, + body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide, + movingEntityId: 0); + + body.Position = result.Position; + pos = result.Position; + cellId = result.CellId; + grounded = result.IsOnGround; + } + + _out.WriteLine($"final pos=({pos.X:F3},{pos.Y:F3},{pos.Z:F3}) grounded={grounded}"); + + // Surface contact at Y = 14 − 0.2 − 0.48 = 13.32. + Assert.True(pos.Y < 13.4f, + $"Tall cylinder must block the dead-center approach; got Y={pos.Y:F3}"); + Assert.True(pos.Z < 0.5f, + $"Player must NOT end up on top of a 2.2 m cylinder; got Z={pos.Z:F3}"); + } + + /// + /// Airborne landing: a falling sphere over the platform center must land + /// ON the flat top (land_on_cylinder → Collide re-test → branch-5 + /// exact-TOI rest + top-disc contact plane), not fall through to the + /// terrain inside the footprint. + /// + [Fact] + public void Airborne_FallOntoWideCylinder_LandsOnTop() + { + var engine = BuildEngine(out _); + RegisterCylinder(engine, entityId: 0xCAFEu, + worldPos: new Vector3(12f, 14f, 0f), + radius: PlatformRadius, height: PlatformHeight); + + Vector3 pos = new(12f, 14f, 1.0f); // 1 m above the base, over the center + uint cellId = TestCellId; + bool grounded = false; + var perTick = new Vector3(0f, 0f, -0.25f); + + int landedTick = -1; + for (int tick = 0; tick < 20; tick++) + { + var result = engine.ResolveWithTransition( + pos, pos + perTick, cellId, + SphereRadius, SphereHeight, StepUpHeight, StepDownHeight, + grounded, + body: null, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide, + movingEntityId: 0); + + pos = result.Position; + cellId = result.CellId; + grounded = result.IsOnGround; + + if (grounded) { landedTick = tick; break; } + } + + _out.WriteLine($"final pos=({pos.X:F3},{pos.Y:F3},{pos.Z:F3}) grounded={grounded} landedTick={landedTick}"); + + Assert.True(grounded, "Falling sphere must land (ground) on the platform top"); + Assert.True(MathF.Abs(pos.Z - PlatformHeight) < 0.05f, + $"Landing must rest on the top disc (Z≈{PlatformHeight:F3}), not the terrain " + + $"(Z=0) inside the footprint; got Z={pos.Z:F3}"); + } + + /// + /// Ethereal cylinders stay fully passable through the caller's Layer-2 + /// override (pc:276961-276989) — branch 1 detects, the override clears. + /// Guards the #150 door behavior against the branch-1 change from the + /// old early-OK consume. + /// + [Fact] + public void Grounded_EtherealCylinder_IsFullyPassable() + { + var engine = BuildEngine(out _); + RegisterCylinder(engine, entityId: 0xE7E7u, + worldPos: new Vector3(12f, 14f, 0f), + radius: 0.2f, height: 2.2f, + state: 0x4u); // ETHEREAL_PS, non-static + + var body = MakeGroundedBody(new Vector3(12f, 12.6f, 0f)); + Vector3 pos = body.Position; + uint cellId = TestCellId; + bool grounded = true; + var perTick = new Vector3(0f, 0.10f, 0f); + + for (int tick = 0; tick < 30; tick++) + { + var result = engine.ResolveWithTransition( + pos, pos + perTick, cellId, + SphereRadius, SphereHeight, StepUpHeight, StepDownHeight, + grounded, + body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide, + movingEntityId: 0); + + body.Position = result.Position; + pos = result.Position; + cellId = result.CellId; + grounded = result.IsOnGround; + } + + _out.WriteLine($"final pos=({pos.X:F3},{pos.Y:F3},{pos.Z:F3})"); + + Assert.True(pos.Y > 14.5f, + $"Ethereal cylinder must not block (walked from 12.6 to past the axis); got Y={pos.Y:F3}"); + } + + // ─────────────────────────────────────────────────────────────── + // Harness + // ─────────────────────────────────────────────────────────────── + + private static PhysicsEngine BuildEngine(out PhysicsDataCache cache) + { + cache = new PhysicsDataCache(); + var engine = new PhysicsEngine { DataCache = cache }; + + // Flat terrain at Z=0 across the whole landblock. + var heights = new byte[81]; + var heightTable = new float[256]; // all zero → terrain Z = 0 + engine.AddLandblock( + landblockId: TestLandblockId, + terrain: new TerrainSurface(heights, heightTable), + cells: Array.Empty(), + portals: Array.Empty(), + worldOffsetX: 0f, + worldOffsetY: 0f); + + return engine; + } + + private static void RegisterCylinder(PhysicsEngine engine, uint entityId, + Vector3 worldPos, float radius, float height, uint state = 0u) + { + engine.ShadowObjects.Register( + entityId, gfxObjId: 0u, + worldPos, Quaternion.Identity, radius, + worldOffsetX: 0f, worldOffsetY: 0f, landblockId: TestLandblockId, + collisionType: ShadowCollisionType.Cylinder, + cylHeight: height, + state: state); + } + + private static PhysicsBody MakeGroundedBody(Vector3 position) + { + var floorPlane = new Plane(Vector3.UnitZ, 0f); + var floorVerts = new[] + { + new Vector3(-100f, -100f, 0f), + new Vector3( 100f, -100f, 0f), + new Vector3( 100f, 100f, 0f), + new Vector3(-100f, 100f, 0f), + }; + + return new PhysicsBody + { + Position = position, + Orientation = Quaternion.Identity, + ContactPlaneValid = true, + ContactPlane = floorPlane, + ContactPlaneCellId = TestCellId, + WalkablePolygonValid = true, + WalkablePlane = floorPlane, + WalkableVertices = floorVerts, + WalkableUp = Vector3.UnitZ, + TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable, + }; + } +} diff --git a/tests/AcDream.Core.Tests/Physics/FramesStationaryFallTests.cs b/tests/AcDream.Core.Tests/Physics/FramesStationaryFallTests.cs new file mode 100644 index 00000000..b5059a76 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/FramesStationaryFallTests.cs @@ -0,0 +1,149 @@ +using System; +using System.Numerics; +using AcDream.Core.Physics; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.Core.Tests.Physics; + +/// +/// Conformance tests for the retail frames_stationary_fall (fsf) round-trip +/// (validate_transition 0x0050aa70 pc:272625-656; transition seed pc:280940-947; +/// ACE Transition.cs:1029-1061). Retires the TS-3 stub. +/// +/// +/// The ladder detects a gravity mover that CANNOT advance for successive frames — the +/// #182 airborne "stuck in the falling animation" wedge (a jump into a monster crowd +/// where the near-horizontal creature normal blocks upward motion). fsf escalates +/// 0→1→2→3 while blocked and resets to 0 the moment the mover advances; at fsf≥3 an +/// upward contact plane is manufactured so the mover stands on the obstacle. The counter +/// round-trips across frames through the Stationary* transient bits (seed→ladder→writeback). +/// The velocity "bleed on block" (fsf>1 → v=0) lives in handle_all_collisions (see +/// ); this file proves the counter itself. +/// +/// +public class FramesStationaryFallTests +{ + private readonly ITestOutputHelper _out; + public FramesStationaryFallTests(ITestOutputHelper output) => _out = output; + + private const uint Lb = 0xA9B40000u; + private const uint Cell = Lb | 0x0001u; + private const float R = 0.48f, H = 1.835f, StepUp = 0.60f, StepDown = 0.04f; + + private static PhysicsEngine BuildEngine() + { + var engine = new PhysicsEngine { DataCache = new PhysicsDataCache() }; + engine.AddLandblock( + landblockId: Lb, + terrain: new TerrainSurface(new byte[81], new float[256]), // flat terrain at Z=0 + cells: Array.Empty(), + portals: Array.Empty(), + worldOffsetX: 0f, worldOffsetY: 0f); + return engine; + } + + // A creature body sphere at an ARBITRARY height (elevated well above the terrain so the + // airborne player never finds a floor and stays airborne — the crowd-jump geometry). + private static void RegisterCreatureAt(PhysicsEngine e, uint id, Vector3 center, float radius = R) + { + e.ShadowObjects.Register( + id, gfxObjId: 0u, center, Quaternion.Identity, radius, + worldOffsetX: 0f, worldOffsetY: 0f, landblockId: Lb, + collisionType: ShadowCollisionType.Sphere, + cylHeight: 0f, scale: 1f, state: 0u, + flags: EntityCollisionFlags.IsCreature, isStatic: false); + } + + private static PhysicsBody AirborneBody(Vector3 pos) => new PhysicsBody + { + Position = pos, + Orientation = Quaternion.Identity, + State = PhysicsStateFlags.Gravity | PhysicsStateFlags.ReportCollisions, + TransientState = TransientStateFlags.None, // airborne: no Contact / no OnWalkable + }; + + private ResolveResult Push(PhysicsEngine engine, PhysicsBody body, Vector3 delta, uint cell) + => engine.ResolveWithTransition( + body.Position, body.Position + delta, cell, + R, H, StepUp, StepDown, isOnGround: false, body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide); + + [Fact] + public void AirborneJumpBlockedOverhead_FsfClimbsTo3_ThenResetsWhenAdvancing() + { + // The #182 airborne-stuck geometry, distilled: an airborne mover with a persistent + // UPWARD intent (a jump) into a creature directly overhead. The collision normal is + // vertical, so — unlike a purely-horizontal push, whose sliding normal absorbs the + // whole offset and aborts the sweep before the ladder — the up-intent survives every + // frame, the sweep runs, and fsf escalates 0→1→2→3 via the Stationary* bit round-trip. + var engine = BuildEngine(); + RegisterCreatureAt(engine, 0xC0B0u, new Vector3(12f, 10f, 4.5f)); // directly overhead + + // Start BELOW the creature so the first frames rise freely (fsf stays 0), then wedge. + var body = AirborneBody(new Vector3(12f, 10f, 1f)); + uint cell = Cell; + var up = new Vector3(0f, 0f, 0.6f); // persistent jump intent + + int firstFrameFsf = -1, maxFsf = 0; + for (int i = 0; i < 14; i++) + { + var r = Push(engine, body, up, cell); + body.Position = r.Position; cell = r.CellId; + if (i == 0) firstFrameFsf = body.FramesStationaryFall; + maxFsf = Math.Max(maxFsf, body.FramesStationaryFall); + _out.WriteLine($"frame{i,2}: z={body.Position.Z:F3} fsf={body.FramesStationaryFall} " + + $"ts=0x{(uint)body.TransientState:X} onGround={r.IsOnGround}"); + } + + // The first frame rose freely (well below the creature) — advancing keeps fsf at 0. + Assert.Equal(0, firstFrameFsf); + // Once wedged under the creature, fsf escalated to 3. + Assert.True(maxFsf == 3, $"fsf must escalate to 3 while the jump is blocked overhead; got {maxFsf}"); + // At fsf 3 the ladder manufactured an upward contact plane → grounded on the obstacle + // (the retail "glide onto the crowd top"). + Assert.True(body.ContactPlaneValid, "fsf≥3 should manufacture a contact plane"); + Assert.True(body.ContactPlane.Normal.Z > 0.99f, "manufactured contact plane points up"); + } + + [Fact] + public void GroundedWallSlide_DoesNotAccumulateFsf() + { + // A GROUNDED mover pushed into an obstacle is not a "stuck fall" — retail keeps fsf=0 + // (ACE _redo=1 via the OnWalkable path), so a grounded crowd-jam slides rather than + // getting its velocity zeroed. Guards against the fsf-zero breaking grounded wall-slide. + var engine = BuildEngine(); + RegisterCreatureAt(engine, 0xC0C0u, new Vector3(12f, 11.5f, R)); // foot-height creature + + var floor = new Plane(Vector3.UnitZ, 0f); + var verts = new[] + { + new Vector3(-100f, -100f, 0f), new Vector3(100f, -100f, 0f), + new Vector3(100f, 100f, 0f), new Vector3(-100f, 100f, 0f), + }; + var body = new PhysicsBody + { + Position = new Vector3(12f, 10f, 0f), + Orientation = Quaternion.Identity, + State = PhysicsStateFlags.Gravity | PhysicsStateFlags.ReportCollisions, + ContactPlaneValid = true, ContactPlane = floor, ContactPlaneCellId = Cell, + WalkablePolygonValid = true, WalkablePlane = floor, WalkableVertices = verts, + WalkableUp = Vector3.UnitZ, + TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable, + }; + uint cell = Cell; + + int maxFsf = 0; + for (int i = 0; i < 40; i++) + { + var r = engine.ResolveWithTransition( + body.Position, body.Position + new Vector3(0f, 0.08f, 0f), cell, + R, H, StepUp, StepDown, isOnGround: true, body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide); + body.Position = r.Position; cell = r.CellId; + maxFsf = Math.Max(maxFsf, body.FramesStationaryFall); + } + _out.WriteLine($"grounded push maxFsf={maxFsf}"); + Assert.Equal(0, maxFsf); // a grounded mover never accumulates a stuck-fall + } +} diff --git a/tests/AcDream.Core.Tests/Physics/HandleAllCollisionsTests.cs b/tests/AcDream.Core.Tests/Physics/HandleAllCollisionsTests.cs new file mode 100644 index 00000000..9fdb8187 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/HandleAllCollisionsTests.cs @@ -0,0 +1,111 @@ +using System.Numerics; +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// Conformance tests for — the port of +/// retail CPhysicsObj::handle_all_collisions (0x00514780, pc:282647). This is the +/// velocity "bleed on block" decision: reflect (fsf≤1) vs zero (fsf>1). +/// +public class HandleAllCollisionsTests +{ + private static PhysicsBody Airborne(Vector3 v, int fsf = 0) => new PhysicsBody + { + State = PhysicsStateFlags.Gravity | PhysicsStateFlags.ReportCollisions, + TransientState = TransientStateFlags.None, + Velocity = v, + FramesStationaryFall = fsf, + }; + + [Fact] + public void Fsf0_AirborneWallHit_ReflectsIntoWallComponent() + { + var b = Airborne(new Vector3(3f, 0f, 0f)); // moving +X into a wall whose outward normal is -X + var n = new Vector3(-1f, 0f, 0f); + PhysicsObjUpdate.HandleAllCollisions(b, + collisionNormalValid: true, collisionNormal: n, + prevContact: false, prevOnWalkable: false, nowOnWalkable: false); + // dot = 3*-1 = -3 < 0 → k = -(-3*(0.05+1)) = 3.15 → v += (-1,0,0)*3.15 → x = 3 - 3.15 = -0.15 + Assert.Equal(-0.15f, b.Velocity.X, precision: 3); + } + + [Fact] + public void Fsf0_MovingAwayFromSurface_DoesNotReflect() + { + var b = Airborne(new Vector3(0f, 0f, 2f)); // moving up, normal also up (already separating) + var n = new Vector3(0f, 0f, 1f); + PhysicsObjUpdate.HandleAllCollisions(b, + collisionNormalValid: true, collisionNormal: n, + prevContact: false, prevOnWalkable: false, nowOnWalkable: false); + Assert.Equal(2f, b.Velocity.Z); // dot = +2 >= 0 → no reflection + } + + [Fact] + public void Fsf2_ZeroesVelocity_TheAirborneStuckBleed() + { + // The #182 case: a straight-up jump blocked by a near-horizontal creature normal. + // At fsf>1 the whole velocity is zeroed so gravity resumes → the player falls/glides off. + var b = Airborne(new Vector3(0f, 0f, 18f), fsf: 2); + var n = new Vector3(-0.96f, -0.25f, -0.15f); + PhysicsObjUpdate.HandleAllCollisions(b, + collisionNormalValid: true, collisionNormal: n, + prevContact: false, prevOnWalkable: false, nowOnWalkable: false); + Assert.Equal(Vector3.Zero, b.Velocity); + } + + [Fact] + public void Fsf3_ZeroesVelocity_EvenWithoutCollisionNormal() + { + var b = Airborne(new Vector3(1f, 2f, 18f), fsf: 3); + PhysicsObjUpdate.HandleAllCollisions(b, + collisionNormalValid: false, collisionNormal: default, + prevContact: false, prevOnWalkable: false, nowOnWalkable: false); + Assert.Equal(Vector3.Zero, b.Velocity); + } + + [Fact] + public void StayingOnWalkable_DoesNotReflect_CorridorWallSlidePreserved() + { + // Grounded before AND after → should_reflect is false → the tangential wall-slide + // velocity is preserved (retail's rule; the corridor shuffle, not a sticky bounce). + var b = new PhysicsBody + { + Velocity = new Vector3(3f, 0f, 0f), + TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable, + FramesStationaryFall = 0, + }; + var n = new Vector3(-1f, 0f, 0f); + PhysicsObjUpdate.HandleAllCollisions(b, + collisionNormalValid: true, collisionNormal: n, + prevContact: true, prevOnWalkable: true, nowOnWalkable: true); + Assert.Equal(3f, b.Velocity.X); + } + + [Fact] + public void Inelastic_ZeroesInsteadOfReflecting() + { + var b = Airborne(new Vector3(3f, 0f, 0f)); + b.State |= PhysicsStateFlags.Inelastic; // spell projectile / missile + var n = new Vector3(-1f, 0f, 0f); + PhysicsObjUpdate.HandleAllCollisions(b, + collisionNormalValid: true, collisionNormal: n, + prevContact: false, prevOnWalkable: false, nowOnWalkable: false); + Assert.Equal(Vector3.Zero, b.Velocity); + } + + [Fact] + public void LandingReflects_RetailRuleRestored_NotSuppressed() + { + // prev airborne → now grounded (a landing). Retail reflects here too (AD-25 retired); + // at elasticity 0.05 the effect is a tiny, imperceptible deflection. + var b = Airborne(new Vector3(0f, 0f, -5f)); // falling + var n = new Vector3(0f, 0f, 1f); // floor normal up + PhysicsObjUpdate.HandleAllCollisions(b, + collisionNormalValid: true, collisionNormal: n, + prevContact: false, prevOnWalkable: false, nowOnWalkable: true); + // dot = -5 < 0 → k = -(-5*1.05) = 5.25 → v.z = -5 + 5.25 = 0.25 (tiny bounce) + Assert.Equal(0.25f, b.Velocity.Z, precision: 3); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/InWorldLinkGuardTests.cs b/tests/AcDream.Core.Tests/Physics/InWorldLinkGuardTests.cs new file mode 100644 index 00000000..c6733aed --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/InWorldLinkGuardTests.cs @@ -0,0 +1,78 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// R4-V5 door-swing fix (2026-07-03, register TS-40): CMotionInterp's +/// dispatch tails strip link animations for DETACHED objects only (retail +/// if (physics_obj->cell == 0) RemoveLinkAnimations, raw @305627). +/// The old proxy (CellPosition.ObjCellId == 0) was seeded only by +/// the local player's SnapToCell, so every REMOTE body read "detached" and +/// every dispatched transition link (door open/close swings, remote +/// walk↔run links) was stripped the same tick it was appended — the pose +/// snapped straight to the new cycle. These pin the corrected +/// guard polarity. +/// +public class InWorldLinkGuardTests +{ + [Fact] + public void InWorldBody_DispatchKeepsTransitionLinks() + { + var body = new PhysicsBody + { + InWorld = true, + TransientState = TransientStateFlags.Contact + | TransientStateFlags.OnWalkable + | TransientStateFlags.Active, + }; + var interp = new MotionInterpreter(body); + int strips = 0; + interp.RemoveLinkAnimations = () => strips++; + + interp.DoInterpretedMotion(MotionCommand.WalkForward, new MovementParameters()); + + Assert.Equal(0, strips); + } + + [Fact] + public void DetachedBody_DispatchStripsLinks_RetailGuard() + { + var body = new PhysicsBody + { + // InWorld left false — retail's pre-enter_world detached state. + TransientState = TransientStateFlags.Contact + | TransientStateFlags.OnWalkable + | TransientStateFlags.Active, + }; + var interp = new MotionInterpreter(body); + int strips = 0; + interp.RemoveLinkAnimations = () => strips++; + + interp.DoInterpretedMotion(MotionCommand.WalkForward, new MovementParameters()); + + Assert.Equal(1, strips); + } + + [Fact] + public void RemoteShapedBody_StopCompletely_KeepsLinksToo() + { + // The other two guard sites (StopCompletely / StopInterpretedMotion) + // share the same InWorld polarity. + var body = new PhysicsBody + { + InWorld = true, + TransientState = TransientStateFlags.Contact + | TransientStateFlags.OnWalkable + | TransientStateFlags.Active, + }; + var interp = new MotionInterpreter(body); + int strips = 0; + interp.RemoveLinkAnimations = () => strips++; + + interp.StopCompletely(); + + Assert.Equal(0, strips); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Issue137CorridorSeamInspectionTests.cs b/tests/AcDream.Core.Tests/Physics/Issue137CorridorSeamInspectionTests.cs new file mode 100644 index 00000000..f901d4ca --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Issue137CorridorSeamInspectionTests.cs @@ -0,0 +1,518 @@ +using System; +using System.IO; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; +using Xunit; +using Xunit.Abstractions; +using Env = System.Environment; + +namespace AcDream.Core.Tests.Physics; + +/// +/// #137 corridor-seam inspection (2026-07-05, Facility Hub). Live probe +/// evidence (launch-175-verify2.log:42858): crossing corridor cells +/// 0x8A02016E → 0x8A02017A at world x≈85.25 records a wall hit with normal +/// (−1,0,0) — pointing straight back against the movement — after which the +/// stale sliding normal wedges all forward motion (ok=False hit=no, offset +/// projected to zero). Question this dump answers: does cell 0x8A02017A's +/// PHYSICS polygon set contain a portal-spanning polygon at its entry plane +/// (normal ≈ ±X at the portal's local X) — i.e., are portal-sealing polys in +/// our collision set where retail filters them? +/// +public class Issue137CorridorSeamInspectionTests +{ + private readonly ITestOutputHelper _out; + public Issue137CorridorSeamInspectionTests(ITestOutputHelper output) => _out = output; + + [Theory] + [InlineData(0x8A02016Eu)] + [InlineData(0x8A02017Au)] + [InlineData(0x8A02011Eu)] // the under-floor room the corridor's floor-portals lead to + [InlineData(0x8A020179u)] // the ramp corridor cell with the window (the #137 window-climb repro) + [InlineData(0x8A02017Eu)] // the cell beyond the window the player climbed into + public void CorridorCell_PhysicsPolysAndPortals_DatInspection(uint envCellId) + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + if (!Directory.Exists(datDir)) + { + _out.WriteLine($"SKIP: dat directory not found at {datDir}"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var envCell = dats.Get(envCellId); + Assert.NotNull(envCell); + _out.WriteLine($"=== EnvCell 0x{envCellId:X8} ==="); + _out.WriteLine($" pos=({envCell!.Position.Origin.X:F2},{envCell.Position.Origin.Y:F2},{envCell.Position.Origin.Z:F2}) " + + $"rot=({envCell.Position.Orientation.X:F3},{envCell.Position.Orientation.Y:F3},{envCell.Position.Orientation.Z:F3},{envCell.Position.Orientation.W:F3})"); + _out.WriteLine($" EnvironmentId=0x{envCell.EnvironmentId:X4} CellStructure={envCell.CellStructure}"); + _out.WriteLine($" CellPortals={envCell.CellPortals.Count}"); + foreach (var p in envCell.CellPortals) + _out.WriteLine($" portal poly={p.PolygonId} other=0x{p.OtherCellId:X4} flags={p.Flags}"); + + var environment = dats.Get(0x0D000000u | envCell.EnvironmentId); + Assert.NotNull(environment); + Assert.True(environment!.Cells.TryGetValue(envCell.CellStructure, out var cs)); + + _out.WriteLine($" PhysicsPolygons={cs!.PhysicsPolygons.Count} (portal-relevant normals below)"); + foreach (var (id, poly) in cs.PhysicsPolygons) + { + // Compute the face normal from the vertex fan (same math as + // PhysicsDataCache.ResolvePolygons). + var verts = poly.VertexIds; + if (verts.Count < 3) continue; + if (!cs.VertexArray.Vertices.TryGetValue((ushort)verts[0], out var v0)) continue; + if (!cs.VertexArray.Vertices.TryGetValue((ushort)verts[1], out var v1)) continue; + if (!cs.VertexArray.Vertices.TryGetValue((ushort)verts[2], out var v2)) continue; + var n = System.Numerics.Vector3.Normalize(System.Numerics.Vector3.Cross( + v1.Origin - v0.Origin, v2.Origin - v0.Origin)); + + // Only print near-horizontal-normal polys (walls) — the seam wall + // candidates; floors/ceilings are noise here. + if (MathF.Abs(n.Z) > 0.3f) continue; + _out.WriteLine($" poly {id}: n=({n.X:F2},{n.Y:F2},{n.Z:F2}) v0=({v0.Origin.X:F2},{v0.Origin.Y:F2},{v0.Origin.Z:F2}) verts={verts.Count} sides={poly.SidesType} stip={poly.Stippling}"); + } + + // The portal polygons live in the VISUAL polygon set — print their + // ids so overlap with the physics set (same id space?) is visible. + _out.WriteLine($" VisualPolygons={cs.Polygons.Count}"); + foreach (var p in envCell.CellPortals) + { + if (cs.Polygons.TryGetValue((ushort)p.PolygonId, out var vp)) + { + _out.WriteLine($" portal-poly {p.PolygonId} IS in the visual set (verts={vp.VertexIds.Count})"); + bool inPhysics = cs.PhysicsPolygons.ContainsKey((ushort)p.PolygonId); + _out.WriteLine($" portal-poly {p.PolygonId} in PHYSICS set: {inPhysics}"); + } + } + } + + /// + /// Mechanism-1 follow-up (2026-07-06): being in the CellStruct's + /// PhysicsPolygons TABLE does not mean the physics BSP ever tests a + /// polygon — retail's BSPLEAF::sphere_intersects_poly (0x0053d580) + /// iterates the LEAF's in_polys index list (leaf construction + /// 0x0053d4a0: in_polys[i] = &pack_poly[index]), and our + /// BSPQuery walks the dat's PhysicsBSP leaves the same way. This dump + /// answers: do the physics-BSP LEAVES of the corridor cells reference the + /// portal polygons? If yes, retail's own BSP query would test them too + /// (→ the passable mechanism must be transit/approach-side — the cdb + /// question). If no, our collision is testing polys retail never reaches + /// (→ a desk-fixable acdream divergence). + /// + [Theory] + [InlineData(0x8A02016Eu)] + [InlineData(0x8A02017Au)] + public void CorridorCell_PhysicsBspLeafMembership_OfPortalPolys(uint envCellId) + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + if (!Directory.Exists(datDir)) + { + _out.WriteLine($"SKIP: dat directory not found at {datDir}"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var envCell = dats.Get(envCellId); + Assert.NotNull(envCell); + var environment = dats.Get(0x0D000000u | envCell!.EnvironmentId); + Assert.NotNull(environment); + Assert.True(environment!.Cells.TryGetValue(envCell.CellStructure, out var cs)); + + var portalPolyIds = new System.Collections.Generic.HashSet(); + foreach (var p in envCell.CellPortals) + portalPolyIds.Add((ushort)p.PolygonId); + + _out.WriteLine($"=== EnvCell 0x{envCellId:X8} — physics BSP leaf membership ==="); + _out.WriteLine($" Env=0x{envCell.EnvironmentId:X4} struct={envCell.CellStructure} " + + $"portalPolyIds=[{string.Join(",", portalPolyIds)}] " + + $"physicsTable=[{string.Join(",", cs!.PhysicsPolygons.Keys)}]"); + + var root = cs.PhysicsBSP?.Root; + Assert.NotNull(root); + + int leafCount = 0; + var leafPolyIds = new System.Collections.Generic.HashSet(); + var portalPolyLeafHits = new System.Collections.Generic.List(); + var stack = new System.Collections.Generic.Stack<(DatReaderWriter.Types.PhysicsBSPNode Node, string Path)>(); + stack.Push((root!, "R")); + while (stack.Count > 0) + { + var (n, path) = stack.Pop(); + if (n.Polygons is { Count: > 0 }) + { + leafCount++; + foreach (var pid in n.Polygons) + { + leafPolyIds.Add(pid); + if (portalPolyIds.Contains(pid)) + portalPolyLeafHits.Add($"poly {pid} in leaf@{path} (type={n.Type}, polys=[{string.Join(",", n.Polygons)}])"); + } + } + if (n.PosNode is not null) stack.Push((n.PosNode, path + "+")); + if (n.NegNode is not null) stack.Push((n.NegNode, path + "-")); + } + + _out.WriteLine($" BSP leaves-with-polys={leafCount} distinctLeafPolyIds=[{string.Join(",", leafPolyIds)}]"); + var tableNotInLeaves = new System.Collections.Generic.List(); + foreach (var pid in cs.PhysicsPolygons.Keys) + if (!leafPolyIds.Contains(pid)) + tableNotInLeaves.Add(pid); + _out.WriteLine($" physics-table polys NOT referenced by any BSP leaf: [{string.Join(",", tableNotInLeaves)}]"); + + if (portalPolyLeafHits.Count == 0) + { + _out.WriteLine(" >>> NO portal polygon is referenced by any physics-BSP leaf — " + + "retail's sphere_intersects_poly never tests them from this cell's BSP."); + } + else + { + foreach (var hit in portalPolyLeafHits) + _out.WriteLine($" >>> PORTAL POLY IN PHYSICS LEAF: {hit}"); + } + } + + /// + /// #137 window climb: the dat truth for the player's collision spheres. + /// Our InitPath places the head sphere at (sphereHeight − radius) = 0.72 + /// (capsule top 1.2 m); retail collides with the Setup's SPHERE LIST + /// verbatim (CPhysicsObj::transition → init_sphere(GetNumSphere, + /// GetSphere, scale)). Print human Setup 0x02000001's spheres. + /// + [Fact] + public void HumanSetup_CollisionSpheres_DatTruth() + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + if (!Directory.Exists(datDir)) + { + _out.WriteLine($"SKIP: dat directory not found at {datDir}"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + var setup = dats.Get(0x02000001u); + Assert.NotNull(setup); + + _out.WriteLine($"Setup 0x02000001: Height={setup!.Height:F3} Radius={setup.Radius:F3} " + + $"StepUp={setup.StepUpHeight:F3} StepDown={setup.StepDownHeight:F3}"); + _out.WriteLine($"Spheres ({setup.Spheres.Count}):"); + foreach (var s in setup.Spheres) + _out.WriteLine($" origin=({s.Origin.X:F3},{s.Origin.Y:F3},{s.Origin.Z:F3}) r={s.Radius:F3}"); + _out.WriteLine($"CylSpheres ({setup.CylSpheres.Count}):"); + foreach (var c in setup.CylSpheres) + _out.WriteLine($" origin=({c.Origin.X:F3},{c.Origin.Y:F3},{c.Origin.Z:F3}) r={c.Radius:F3} h={c.Height:F3}"); + } + + /// + /// #137 window-climb geometry (2026-07-06): full world-space vertex dump + /// of the shaft cell 0x8A02017E (all physics polys) and 0x8A020179's + /// south-wall family — the opening's lintel/ceiling spans decide where + /// retail blocks the head. + /// + [Fact] + public void WindowShaft_FullPolyDump() + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + if (!Directory.Exists(datDir)) + { + _out.WriteLine($"SKIP: dat directory not found at {datDir}"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + foreach (var cellId in new[] { 0x8A02017Eu, 0x8A020179u }) + { + var envCell = dats.Get(cellId); + Assert.NotNull(envCell); + var environment = dats.Get(0x0D000000u | envCell!.EnvironmentId); + Assert.True(environment!.Cells.TryGetValue(envCell.CellStructure, out var cs)); + + var rot = new System.Numerics.Quaternion( + envCell.Position.Orientation.X, envCell.Position.Orientation.Y, + envCell.Position.Orientation.Z, envCell.Position.Orientation.W); + var world = System.Numerics.Matrix4x4.CreateFromQuaternion(rot) + * System.Numerics.Matrix4x4.CreateTranslation( + envCell.Position.Origin.X, envCell.Position.Origin.Y, envCell.Position.Origin.Z); + + _out.WriteLine($"=== 0x{cellId:X8} full physics polys (world verts) ==="); + foreach (var (id, poly) in cs!.PhysicsPolygons) + { + var verts = poly.VertexIds; + if (verts.Count < 3) continue; + var w = new System.Collections.Generic.List(); + foreach (var vid in verts) + if (cs.VertexArray.Vertices.TryGetValue((ushort)vid, out var v)) + w.Add(System.Numerics.Vector3.Transform(v.Origin, world)); + var n = System.Numerics.Vector3.Normalize( + System.Numerics.Vector3.Cross(w[1] - w[0], w[2] - w[0])); + + // 017E: everything. 0179: south-wall family + ceilings only. + if (cellId == 0x8A020179u && MathF.Abs(n.Y) < 0.3f && n.Z > -0.3f) continue; + + var vs = string.Join(" ", w.ConvertAll(p => $"({p.X:F2},{p.Y:F2},{p.Z:F2})")); + _out.WriteLine($" poly {id}: n=({n.X:F2},{n.Y:F2},{n.Z:F2}) verts={vs}"); + } + } + } + + /// + /// Mechanism-1 re-characterization (2026-07-06): the live hit normal + /// (−1.00, 0.03, −0.03) at world (85.253, −39.776, −5.992) matches NO + /// physics polygon of either corridor cell — 0x8A02016E (identity + /// rotation) and 0x8A02017A (180° Z) both have only ±Y-normal wall polys, + /// and the PortalSide portals to 0x011E (polys 1/3/5) are ±Y planes + /// 1.4 m north of the player's track, perpendicular to the +X run — the + /// pos_hits_sphere directional cull rejects them for this movement. This + /// sweep hunts the ACTUAL culprit: every physics poly of the seam cell + + /// all portal-adjacent neighbors, world-transformed, scored against the + /// hit point + normal. + /// + [Fact] + public void CorridorSeam_FindPolygonMatchingLiveHit() + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + if (!Directory.Exists(datDir)) + { + _out.WriteLine($"SKIP: dat directory not found at {datDir}"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + // Live evidence (launch-175-verify2.log:42858). + var hitPoint = new System.Numerics.Vector3(85.253f, -39.776f, -5.992f); + var hitNormal = new System.Numerics.Vector3(-1.00f, 0.03f, -0.03f); + hitNormal = System.Numerics.Vector3.Normalize(hitNormal); + const float sphereRadius = 0.48f; + + // Seam cells + every portal-adjacent neighbor of both. + var cellIds = new System.Collections.Generic.HashSet + { + 0x8A02016Eu, 0x8A02017Au, + }; + foreach (var seed in new[] { 0x8A02016Eu, 0x8A02017Au }) + { + var seedCell = dats.Get(seed); + if (seedCell is null) continue; + foreach (var p in seedCell.CellPortals) + cellIds.Add(0x8A020000u | p.OtherCellId); + } + + foreach (var cellId in cellIds) + { + var envCell = dats.Get(cellId); + if (envCell is null) { _out.WriteLine($"cell 0x{cellId:X8}: NOT FOUND"); continue; } + var environment = dats.Get(0x0D000000u | envCell.EnvironmentId); + if (environment is null || !environment.Cells.TryGetValue(envCell.CellStructure, out var cs)) + continue; + + var rot = new System.Numerics.Quaternion( + envCell.Position.Orientation.X, envCell.Position.Orientation.Y, + envCell.Position.Orientation.Z, envCell.Position.Orientation.W); + var world = System.Numerics.Matrix4x4.CreateFromQuaternion(rot) + * System.Numerics.Matrix4x4.CreateTranslation( + envCell.Position.Origin.X, envCell.Position.Origin.Y, envCell.Position.Origin.Z); + + var portalPolyIds = new System.Collections.Generic.HashSet(); + foreach (var p in envCell.CellPortals) portalPolyIds.Add((ushort)p.PolygonId); + + foreach (var (id, poly) in cs!.PhysicsPolygons) + { + var verts = poly.VertexIds; + if (verts.Count < 3) continue; + if (!cs.VertexArray.Vertices.TryGetValue((ushort)verts[0], out var v0)) continue; + if (!cs.VertexArray.Vertices.TryGetValue((ushort)verts[1], out var v1)) continue; + if (!cs.VertexArray.Vertices.TryGetValue((ushort)verts[2], out var v2)) continue; + + var w0 = System.Numerics.Vector3.Transform(v0.Origin, world); + var w1 = System.Numerics.Vector3.Transform(v1.Origin, world); + var w2 = System.Numerics.Vector3.Transform(v2.Origin, world); + var n = System.Numerics.Vector3.Normalize( + System.Numerics.Vector3.Cross(w1 - w0, w2 - w0)); + + float align = System.Numerics.Vector3.Dot(n, hitNormal); + // |align|: the vertex-fan winding convention can flip the + // computed normal vs the physics plane's true facing — accept + // both signs (2026-07-06 sweep flaw fix). + if (MathF.Abs(align) < 0.95f) continue; // within ~18° of the recorded normal + + // Plane distance from the hit point. + float d = -System.Numerics.Vector3.Dot(n, w0); + float dist = System.Numerics.Vector3.Dot(n, hitPoint) + d; + if (MathF.Abs(dist) > sphereRadius + 0.1f) continue; + + // Rough proximity: hit point near the polygon's vertex span. + float minX = MathF.Min(w0.X, MathF.Min(w1.X, w2.X)) - 1f; + float maxX = MathF.Max(w0.X, MathF.Max(w1.X, w2.X)) + 1f; + float minY = MathF.Min(w0.Y, MathF.Min(w1.Y, w2.Y)) - 1f; + float maxY = MathF.Max(w0.Y, MathF.Max(w1.Y, w2.Y)) + 1f; + if (hitPoint.X < minX || hitPoint.X > maxX || + hitPoint.Y < minY || hitPoint.Y > maxY) continue; + + _out.WriteLine( + $">>> CANDIDATE cell=0x{cellId:X8} poly={id} " + + $"worldN=({n.X:F3},{n.Y:F3},{n.Z:F3}) align={align:F3} planeDist={dist:F3} " + + $"isPortalPoly={portalPolyIds.Contains(id)} " + + $"w0=({w0.X:F2},{w0.Y:F2},{w0.Z:F2}) w1=({w1.X:F2},{w1.Y:F2},{w1.Z:F2}) w2=({w2.X:F2},{w2.Y:F2},{w2.Z:F2}) " + + $"verts={verts.Count} sides={poly.SidesType} stip={poly.Stippling}"); + } + } + _out.WriteLine("(sweep complete)"); + } + + /// + /// Entry-poly hunt: the synthetic reversed-movement collision normal is + /// produced by slide_sphere's opposing-normals branch, which needs an + /// INPUT collision normal anti-parallel to the grounded contact plane — + /// i.e., a DOWNWARD-facing polygon (lintel / arch underside). Those were + /// filtered out of the wall dump (|n.Z| > 0.3). Sweep both corridor + /// cells for downward polys near the seam column and print where their + /// planes sit relative to the player's head sphere. + /// + [Fact] + public void CorridorSeam_DownwardPolysNearSeam() + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + if (!Directory.Exists(datDir)) + { + _out.WriteLine($"SKIP: dat directory not found at {datDir}"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + foreach (var cellId in new[] { 0x8A02016Eu, 0x8A02017Au }) + { + var envCell = dats.Get(cellId); + Assert.NotNull(envCell); + var environment = dats.Get(0x0D000000u | envCell!.EnvironmentId); + Assert.NotNull(environment); + Assert.True(environment!.Cells.TryGetValue(envCell.CellStructure, out var cs)); + + var rot = new System.Numerics.Quaternion( + envCell.Position.Orientation.X, envCell.Position.Orientation.Y, + envCell.Position.Orientation.Z, envCell.Position.Orientation.W); + var world = System.Numerics.Matrix4x4.CreateFromQuaternion(rot) + * System.Numerics.Matrix4x4.CreateTranslation( + envCell.Position.Origin.X, envCell.Position.Origin.Y, envCell.Position.Origin.Z); + + _out.WriteLine($"=== 0x{cellId:X8} downward physics polys (n.Z < -0.3) ==="); + foreach (var (id, poly) in cs!.PhysicsPolygons) + { + var verts = poly.VertexIds; + if (verts.Count < 3) continue; + if (!cs.VertexArray.Vertices.TryGetValue((ushort)verts[0], out var v0)) continue; + if (!cs.VertexArray.Vertices.TryGetValue((ushort)verts[1], out var v1)) continue; + if (!cs.VertexArray.Vertices.TryGetValue((ushort)verts[2], out var v2)) continue; + + var w0 = System.Numerics.Vector3.Transform(v0.Origin, world); + var w1 = System.Numerics.Vector3.Transform(v1.Origin, world); + var w2 = System.Numerics.Vector3.Transform(v2.Origin, world); + var n = System.Numerics.Vector3.Normalize( + System.Numerics.Vector3.Cross(w1 - w0, w2 - w0)); + if (n.Z > -0.3f) continue; + + // Only near the seam column the player crossed. + float minX = MathF.Min(w0.X, MathF.Min(w1.X, w2.X)); + float maxX = MathF.Max(w0.X, MathF.Max(w1.X, w2.X)); + if (maxX < 83.5f || minX > 87.0f) continue; + + var allW = new System.Collections.Generic.List(); + foreach (var vid in verts) + if (cs.VertexArray.Vertices.TryGetValue((ushort)vid, out var vv)) + allW.Add(System.Numerics.Vector3.Transform(vv.Origin, world)); + float minZ = float.MaxValue, maxZ = float.MinValue, minY = float.MaxValue, maxY = float.MinValue; + foreach (var w in allW) + { + minZ = MathF.Min(minZ, w.Z); maxZ = MathF.Max(maxZ, w.Z); + minY = MathF.Min(minY, w.Y); maxY = MathF.Max(maxY, w.Y); + } + + _out.WriteLine( + $" poly {id}: worldN=({n.X:F2},{n.Y:F2},{n.Z:F2}) x=[{minX:F2},{maxX:F2}] " + + $"y=[{minY:F2},{maxY:F2}] z=[{minZ:F2},{maxZ:F2}] verts={verts.Count} " + + $"sides={poly.SidesType} stip={poly.Stippling}"); + } + } + _out.WriteLine("(downward sweep complete)"); + } + + /// + /// 2026-07-06 gate-session follow-up: seam crossings SUCCEED at + /// y≈−40.8..−41.2 and BLOCK at y≈−39.5..−39.8 (cell-transit log, + /// launch-137-corridor-gate.log). A y-dependent boundary with no physics + /// polygon culprit points at the PORTAL POLYGONS — if the doorway + /// openings don't span the full corridor width, the transit/membership + /// machinery only hands the sphere to the neighbor inside the portal + /// poly's span. Dump every portal polygon's world-space vertex extent. + /// + [Theory] + [InlineData(0x8A02016Eu)] + [InlineData(0x8A02017Au)] + public void CorridorCell_PortalPolygonWorldSpans(uint envCellId) + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + if (!Directory.Exists(datDir)) + { + _out.WriteLine($"SKIP: dat directory not found at {datDir}"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var envCell = dats.Get(envCellId); + Assert.NotNull(envCell); + var environment = dats.Get(0x0D000000u | envCell!.EnvironmentId); + Assert.NotNull(environment); + Assert.True(environment!.Cells.TryGetValue(envCell.CellStructure, out var cs)); + + var rot = new System.Numerics.Quaternion( + envCell.Position.Orientation.X, envCell.Position.Orientation.Y, + envCell.Position.Orientation.Z, envCell.Position.Orientation.W); + var world = System.Numerics.Matrix4x4.CreateFromQuaternion(rot) + * System.Numerics.Matrix4x4.CreateTranslation( + envCell.Position.Origin.X, envCell.Position.Origin.Y, envCell.Position.Origin.Z); + + _out.WriteLine($"=== 0x{envCellId:X8} portal polygons (world spans) ==="); + foreach (var p in envCell.CellPortals) + { + if (!cs!.Polygons.TryGetValue((ushort)p.PolygonId, out var poly)) + { + _out.WriteLine($" portal poly {p.PolygonId} -> 0x{p.OtherCellId:X4} {p.Flags}: NOT in visual set"); + continue; + } + + var min = new System.Numerics.Vector3(float.MaxValue); + var max = new System.Numerics.Vector3(float.MinValue); + foreach (var vid in poly.VertexIds) + { + if (!cs.VertexArray.Vertices.TryGetValue((ushort)vid, out var v)) continue; + var w = System.Numerics.Vector3.Transform(v.Origin, world); + min = System.Numerics.Vector3.Min(min, w); + max = System.Numerics.Vector3.Max(max, w); + } + _out.WriteLine( + $" portal poly {p.PolygonId} -> 0x{p.OtherCellId:X4} [{p.Flags}] " + + $"x=[{min.X:F2},{max.X:F2}] y=[{min.Y:F2},{max.Y:F2}] z=[{min.Z:F2},{max.Z:F2}] " + + $"verts={poly.VertexIds.Count}"); + } + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Issue137CorridorSeamReplayTests.cs b/tests/AcDream.Core.Tests/Physics/Issue137CorridorSeamReplayTests.cs new file mode 100644 index 00000000..3724db77 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Issue137CorridorSeamReplayTests.cs @@ -0,0 +1,500 @@ +using System; +using System.IO; +using System.Numerics; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; +using AcDream.Core.Physics; +using Xunit; +using Xunit.Abstractions; +using Env = System.Environment; +using Plane = System.Numerics.Plane; + +namespace AcDream.Core.Tests.Physics; + +/// +/// #137 corridor-seam replay (2026-07-06) — dat-backed reproduction of the +/// Facility Hub phantom hit (launch-175-verify2.log:42858): running +X down +/// the corridor, crossing 0x8A02016E → 0x8A02017A at x≈85.25, the live +/// client recorded `ok=True hit=yes n=(−1.00,0.03,−0.03)` with full advance, +/// persisted the sliding normal, and every later forward resolve absorbed to +/// zero (`ok=False hit=no`). +/// +/// +/// Dat facts pinned by : +/// neither corridor cell (nor any portal-adjacent neighbor) has a physics +/// polygon whose plane matches that normal near the hit point — the recorded +/// normal is SYNTHETIC (the negated movement direction), which is exactly +/// what slide_sphere's opposing-normals branch records. Retail +/// (CSphere::slide_sphere 0x00537440 @0x0053762c) returns +/// COLLIDED_TS from that branch; our port returned OK — letting the step +/// complete with full advance and the synthetic normal persisted. +/// +/// +/// +/// This replay drives the real engine over the real dat cells with the +/// live-log positions and player dimensions, and pins: the seam crossing +/// must complete WITHOUT persisting a sliding normal, and continued forward +/// running must keep advancing (no absorbing wedge). +/// +/// +public class Issue137CorridorSeamReplayTests +{ + private readonly ITestOutputHelper _out; + public Issue137CorridorSeamReplayTests(ITestOutputHelper output) => _out = output; + + private const uint SeamCellWest = 0x8A02016Eu; + private const uint SeamCellEast = 0x8A02017Au; + + private static string? FindDatDir() + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + return Directory.Exists(datDir) ? datDir : null; + } + + /// + /// Hydrate the two seam cells + every portal-adjacent neighbor into a + /// PhysicsEngine, exactly as the streaming path does (CacheCellStruct + /// with the dat world transform). + /// + private static PhysicsEngine BuildCorridorEngine(DatCollection dats) + { + var engine = new PhysicsEngine(); + engine.DataCache = new PhysicsDataCache(); + + var toLoad = new System.Collections.Generic.HashSet { SeamCellWest, SeamCellEast }; + foreach (var seed in new[] { SeamCellWest, SeamCellEast }) + { + var seedCell = dats.Get(seed); + Assert.NotNull(seedCell); + foreach (var p in seedCell!.CellPortals) + toLoad.Add(0x8A020000u | p.OtherCellId); + } + + // Expand three portal rings — the live collision cell array reaches + // cells three hops out (0x8A020166, the under-ramp room whose ceiling + // is the ramp slab's underside, is ring-3 in the 2026-07-06 + // seam-shake trace; with only two rings the offline flood can never + // add it and the shake does not reproduce). + for (int ring = 0; ring < 3; ring++) + { + foreach (var known in new System.Collections.Generic.List(toLoad)) + { + var cell = dats.Get(known); + if (cell is null) continue; + foreach (var p in cell.CellPortals) + toLoad.Add(0x8A020000u | p.OtherCellId); + } + } + + foreach (var cellId in toLoad) + { + var envCell = dats.Get(cellId); + if (envCell is null) continue; + var environment = dats.Get(0x0D000000u | envCell.EnvironmentId); + if (environment is null) continue; + if (!environment.Cells.TryGetValue(envCell.CellStructure, out var cs)) continue; + + var rot = new Quaternion( + envCell.Position.Orientation.X, envCell.Position.Orientation.Y, + envCell.Position.Orientation.Z, envCell.Position.Orientation.W); + var world = Matrix4x4.CreateFromQuaternion(rot) + * Matrix4x4.CreateTranslation( + envCell.Position.Origin.X, envCell.Position.Origin.Y, envCell.Position.Origin.Z); + + engine.DataCache.CacheCellStruct(cellId, envCell, cs!, world); + } + + return engine; + } + + private static PhysicsBody GroundedBody() + { + var body = new PhysicsBody(); + body.ContactPlaneValid = true; + // Corridor floor at world z = −6 → n·p + d = 0 with n = +Z, d = 6. + body.ContactPlane = new Plane(Vector3.UnitZ, 6f); + body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable; + // The live session carried a walkable polygon (walkable=True on every + // [resolve] line) — seed the corridor floor slab so the transition's + // SetWalkable path runs like live. + body.WalkablePolygonValid = true; + body.WalkablePlane = new Plane(Vector3.UnitZ, 6f); + body.WalkableUp = Vector3.UnitZ; + body.WalkableVertices = new[] + { + new Vector3(75f, -41.67f, -6f), + new Vector3(85f, -41.67f, -6f), + new Vector3(85f, -38.33f, -6f), + new Vector3(75f, -38.33f, -6f), + }; + return body; + } + + private ResolveResult Resolve(PhysicsEngine engine, PhysicsBody body, + Vector3 from, Vector3 to, uint cellId) + => engine.ResolveWithTransition( + currentPos: from, + targetPos: to, + cellId: cellId, + sphereRadius: 0.48f, // human player, PlayerMovementController:885 + sphereHeight: 1.2f, // human player, PlayerMovementController:886 + stepUpHeight: 0.4f, // PlayerMovementController defaults + stepDownHeight: 0.4f, + isOnGround: true, + body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide); + + /// + /// 2026-07-06 seam-shake repro, snapshot-exact (probe session + /// launch-137-seam-probes.log + resolve-137-seam-capture.jsonl tick 4101, + /// repeated ×46): running WEST across the x=75 boundary + /// (0x8A02016E → 0x8A020165, the ramp cell) from (75.287, −40.035, −6) + /// toward (74.685, −39.988, −6), the resolve blocks with the SYNTHETIC + /// reversed-movement normal (0.997, −0.078, −0.002) and out==in — every + /// frame — the "shaking at the seam" report. + /// + /// + /// Probe-traced chain: the foot sphere (tangent to the floor) crosses + /// onto 0165's ramp floor; the ramp slab is double-faced and the + /// UNDERSIDE face (poly 0, n=(−0.03,0,−1)) grazes the sphere within the + /// hit threshold → recorded as a foot near-miss → neg-poly step-up + /// dispatch with a downward normal → the nested step-up's walkable probe + /// rejects the exactly-tangent ramp floor ([walkable-nearest] + /// gap=−0.0000 overlapsSphere=False) → StepUpSlide → + /// slide_sphere(downward normal vs up-facing contact plane) → the + /// opposing-normals branch → Collided → revert. Repeat. + /// + /// + [Fact] + public void SeamShake_WestBoundary_SnapshotExact_Advances() + { + var datDir = FindDatDir(); + if (datDir is null) + { + _out.WriteLine("SKIP: dat directory not found"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + var engine = BuildCorridorEngine(dats); + + // Body seeded EXACTLY from the capture's bodyBefore (tick 4101). + var body = new PhysicsBody(); + body.ContactPlaneValid = true; + body.ContactPlane = new Plane(Vector3.UnitZ, 6f); + body.ContactPlaneCellId = SeamCellWest; + body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable; + body.WalkablePolygonValid = true; + body.WalkablePlane = new Plane(Vector3.UnitZ, 6f); + body.WalkableUp = Vector3.UnitZ; + body.WalkableVertices = new[] + { + new Vector3(75f, -38.33333f, -6f), + new Vector3(75f, -41.66667f, -6f), + new Vector3(78.33333f, -41.66667f, -6f), + new Vector3(78.33333f, -38.33333f, -6f), + }; + + var from = new Vector3(75.28674f, -40.03537f, -6f); + var to = new Vector3(74.6854f, -39.988018f, -6f); + + // Emit the same step-level probes the live session logged so the + // offline trace can be line-diffed against launch-137-seam-probes.log + // — the first divergent line names the state the replay is missing. + var probeBuffer = new System.IO.StringWriter(); + var prevOut = Console.Out; + ResolveResult r1; + try + { + Console.SetOut(probeBuffer); + PhysicsDiagnostics.ProbeStepWalkEnabled = true; + PhysicsDiagnostics.ProbePushBackEnabled = true; + PhysicsDiagnostics.ProbeIndoorBspEnabled = true; + + r1 = engine.ResolveWithTransition( + currentPos: from, + targetPos: to, + cellId: SeamCellWest, + sphereRadius: 0.48f, + sphereHeight: 1.2f, + stepUpHeight: 0.6f, // live Setup values from the capture + stepDownHeight: 1.5f, + isOnGround: true, + body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide); + } + finally + { + PhysicsDiagnostics.ProbeStepWalkEnabled = false; + PhysicsDiagnostics.ProbePushBackEnabled = false; + PhysicsDiagnostics.ProbeIndoorBspEnabled = false; + Console.SetOut(prevOut); + } + _out.WriteLine(probeBuffer.ToString()); + + _out.WriteLine($"r1: ok={r1.Ok} out=({r1.Position.X:F3},{r1.Position.Y:F3},{r1.Position.Z:F3}) " + + $"cell=0x{r1.CellId:X8} hit={r1.CollisionNormalValid} " + + $"n=({r1.CollisionNormal.X:F2},{r1.CollisionNormal.Y:F2},{r1.CollisionNormal.Z:F2}) " + + $"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)}"); + + Assert.True(r1.Position.X < from.X - 0.3f, + $"The westward boundary crossing onto the ramp must advance " + + $"({from.X:F3} → {r1.Position.X:F3}, target {to.X:F3}); zero " + + $"advance with the reversed-movement normal = the seam shake."); + } + + /// + /// #137 window-climb repro (2026-07-06 gate 2, launch-137-gate2.log): + /// running from the ramp top in 0x8A020179 into the corridor-end opening + /// (the portal to the 0x8A02017E shaft, wall plane world y=−41.67), the + /// player stepped INTO the niche — `in=(89.531,−41.506,−5.112) → + /// out=(90.209,−41.774,−5.209) cell=0x8A02017E` — ending with the head + /// (and camera) through the opening's roof. The opening is ~1.3 m tall + /// (z −5.2..−3.9); a 1.68 m character cannot fit — retail blocks entry + /// (the raised probe's HEAD sphere hits the lintel/ceiling). User axiom: + /// "should not be able to run into it". + /// + [Fact] + public void WindowOpening_HeadCannotFit_EntryBlocked() + { + var datDir = FindDatDir(); + if (datDir is null) + { + _out.WriteLine("SKIP: dat directory not found"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + var engine = BuildCorridorEngine(dats); + + var body = new PhysicsBody(); + body.ContactPlaneValid = true; + body.ContactPlane = new Plane(Vector3.UnitZ, 5.112f); // ramp-top level + body.ContactPlaneCellId = 0x8A020179u; + body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable; + + // Walk the live approach (ramp-top toward the corridor-end opening) + // so the engine self-accumulates its contact-plane/walkable state, + // then push into the opening for several held-key frames (the live + // climb happened under a held key, not a single resolve). + var pos = new Vector3(88.60f, -41.10f, -5.05f); + uint cell = 0x8A020179u; + ResolveResult r = default; + bool probeFrames = Env.GetEnvironmentVariable("ACDREAM_TEST_WINDOW_PROBE") == "1"; + for (int i = 0; i < 22; i++) + { + var dir = Vector3.Normalize(new Vector3(90.209f, -41.809f, 0f) - new Vector3(pos.X, pos.Y, 0f)); + var step = new Vector3(dir.X, dir.Y, 0f) * 0.13f; + + var probeBuffer = new System.IO.StringWriter(); + var prevOut = Console.Out; + try + { + if (probeFrames && i >= 9) + { + Console.SetOut(probeBuffer); + PhysicsDiagnostics.ProbeStepWalkEnabled = true; + PhysicsDiagnostics.ProbeIndoorBspEnabled = true; + } + r = engine.ResolveWithTransition( + currentPos: pos, + targetPos: pos + step, + cellId: cell, + sphereRadius: 0.48f, + // #137: the corrected capsule top (dat Setup 0x02000001, + // head sphere center 1.350 → top 1.830; Height 1.835). + // The live climb happened under the old 1.2f (head top + // 1.2 m — no head collision at the lintel). + sphereHeight: 1.835f, + stepUpHeight: 0.6f, + stepDownHeight: 1.5f, + isOnGround: true, + body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide); + } + finally + { + if (probeFrames && i >= 9) + { + PhysicsDiagnostics.ProbeStepWalkEnabled = false; + PhysicsDiagnostics.ProbeIndoorBspEnabled = false; + Console.SetOut(prevOut); + } + } + if (probeFrames && i >= 9 && i <= 10) + _out.WriteLine(probeBuffer.ToString()); + _out.WriteLine($"r{i}: ok={r.Ok} out=({r.Position.X:F3},{r.Position.Y:F3},{r.Position.Z:F3}) " + + $"cell=0x{r.CellId:X8} hit={r.CollisionNormalValid} " + + $"n=({r.CollisionNormal.X:F2},{r.CollisionNormal.Y:F2},{r.CollisionNormal.Z:F2})"); + pos = r.Position; + cell = r.CellId; + + Assert.NotEqual(0x8A02017Eu, r.CellId); + Assert.True(r.Position.Y > -41.6f, + $"A 1.68 m character must not enter the 1.3 m-tall opening " + + $"(wall plane y=−41.67); frame {i} got Y={r.Position.Y:F3} " + + $"cell=0x{r.CellId:X8} (live bug: ended at −41.774 inside " + + $"0x8A02017E, head through the roof)."); + } + } + + /// + /// The window-climb's placement half, pinned at the exact site: at the + /// step-up's raised position on the alcove sill (foot −5.019), the HEAD + /// sphere (center −3.339, span −3.82..−2.86) pokes ~6 cm past the south + /// wall plane into the SOLID rock above the alcove ceiling (0x8A020179's + /// lintel band, polys 14/15 at y=−41.67 z∈[−3.90,−3.00]). Retail's + /// step-down placement insert (CTransition::step_down 0x0050b3b3 → + /// placement transitional_insert → BSPTREE::sphere_intersects_solid + /// 0x0053d5f0) REJECTS — that's what makes the 0.7 m sill unclimbable. + /// Our placement passed (the live + offline climb), so our Path-1 solid + /// test misses the head-vs-solid overlap. + /// + [Fact] + public void WindowAlcove_RaisedPlacement_HeadInLintelSolid_Collides() + { + var datDir = FindDatDir(); + if (datDir is null) + { + _out.WriteLine("SKIP: dat directory not found"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + var engine = BuildCorridorEngine(dats); + + var cell = engine.DataCache!.GetCellStruct(0x8A020179u); + Assert.NotNull(cell); + Assert.NotNull(cell!.BSP?.Root); + + // The raised (post-sill-climb) pose from the offline repro's r9. + var footWorld = new Vector3(89.683f, -41.247f, -4.539f); // foot sphere CENTER + var headWorld = new Vector3(89.683f, -41.247f, -3.339f); // head sphere CENTER + + var footLocal = Vector3.Transform(footWorld, cell.InverseWorldTransform); + var headLocal = Vector3.Transform(headWorld, cell.InverseWorldTransform); + + var t = new Transition(); + t.SpherePath.InitPath( + new Vector3(89.683f, -41.247f, -5.019f), + new Vector3(89.683f, -41.247f, -5.019f), + 0x8A020179u, 0.48f, 1.2f); + t.SpherePath.InsertType = InsertType.Placement; + + Matrix4x4.Decompose(cell.WorldTransform, out _, out var cellRot, out var cellOrigin); + + var result = BSPQuery.FindCollisions( + cell.BSP!.Root, + cell.Resolved, + t, + new DatReaderWriter.Types.Sphere { Origin = footLocal, Radius = 0.48f }, + new DatReaderWriter.Types.Sphere { Origin = headLocal, Radius = 0.48f }, + footLocal, + Vector3.UnitZ, + 1.0f, + cellRot, + engine, + worldOrigin: cellOrigin); + + _out.WriteLine($"placement result={result} footLocal=({footLocal.X:F3},{footLocal.Y:F3},{footLocal.Z:F3}) " + + $"headLocal=({headLocal.X:F3},{headLocal.Y:F3},{headLocal.Z:F3})"); + + Assert.Equal(TransitionState.Collided, result); + } + + /// + /// 2026-07-06 gate session repro (launch-137-corridor-gate.log): standing + /// at (84.851, −39.764, −6.000) — the foot sphere already straddling the + /// x=85 cell boundary by 0.33 m — the first move attempt toward + /// (85.453, −39.782) blocked with the synthetic reversed-movement normal + /// (−1.00, 0.03, −0.02), out==in, cp lost (cp=none), and repeated every + /// frame (the "shaking at the seam" report). The deeper straddle start is + /// what the original replay frame (84.638 → 85.253) didn't cover. + /// + [Fact] + public void SeamCrossing_FromDeepStraddleStart_Advances() + { + var datDir = FindDatDir(); + if (datDir is null) + { + _out.WriteLine("SKIP: dat directory not found"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + var engine = BuildCorridorEngine(dats); + var body = GroundedBody(); + + var from = new Vector3(84.851f, -39.764f, -6.000f); + var to = new Vector3(85.453f, -39.782f, -6.000f); + + var r1 = Resolve(engine, body, from, to, SeamCellWest); + _out.WriteLine($"r1: ok={r1.Ok} out=({r1.Position.X:F3},{r1.Position.Y:F3},{r1.Position.Z:F3}) " + + $"cell=0x{r1.CellId:X8} hit={r1.CollisionNormalValid} " + + $"n=({r1.CollisionNormal.X:F2},{r1.CollisionNormal.Y:F2},{r1.CollisionNormal.Z:F2}) " + + $"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)} " + + $"bodyCpValid={body.ContactPlaneValid}"); + + Assert.True(r1.Position.X > from.X + 0.2f, + $"The straddling-start seam crossing must advance " + + $"({from.X:F3} → {r1.Position.X:F3}); zero advance with a " + + $"reversed-movement normal = the 2026-07-06 seam shake."); + } + + [Fact] + public void SeamCrossing_DoesNotPersistSyntheticSlidingNormal_AndRunContinues() + { + var datDir = FindDatDir(); + if (datDir is null) + { + _out.WriteLine("SKIP: dat directory not found"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + var engine = BuildCorridorEngine(dats); + var body = GroundedBody(); + + // ── The live hit frame verbatim (launch-175-verify2.log:42858) ── + var from = new Vector3(84.638f, -39.758f, -6.000f); + var to = new Vector3(85.253f, -39.776f, -6.000f); + + var r1 = Resolve(engine, body, from, to, SeamCellWest); + _out.WriteLine($"r1: ok={r1.Ok} out=({r1.Position.X:F3},{r1.Position.Y:F3},{r1.Position.Z:F3}) " + + $"cell=0x{r1.CellId:X8} hit={r1.CollisionNormalValid} " + + $"n=({r1.CollisionNormal.X:F2},{r1.CollisionNormal.Y:F2},{r1.CollisionNormal.Z:F2}) " + + $"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)} " + + $"slidingN=({body.SlidingNormal.X:F2},{body.SlidingNormal.Y:F2},{body.SlidingNormal.Z:F2})"); + + // The corridor is straight and open: the crossing must not leave the + // body carrying a sliding normal (there is no wall to slide on — + // Issue137CorridorSeamInspectionTests proved no polygon matches the + // live-recorded normal; retail's slide_sphere opposing branch returns + // COLLIDED and its validate handling never lets a synthetic + // reversed-movement normal survive a clean corridor run). + Assert.False(body.TransientState.HasFlag(TransientStateFlags.Sliding), + "Crossing the open corridor seam must not persist a sliding " + + "normal — the live wedge's entry state (#137 mechanism 2)."); + + // ── Keep running +X (the live session's held-W frames) ────────── + var pos = r1.Position; + var cell = r1.CellId; + for (int i = 0; i < 6; i++) + { + var step = new Vector3(0.13f, -0.004f, 0f); // ~run speed per tick, same heading + var r = Resolve(engine, body, pos, pos + step, cell); + _out.WriteLine($"r{i + 2}: ok={r.Ok} out=({r.Position.X:F3},{r.Position.Y:F3},{r.Position.Z:F3}) " + + $"cell=0x{r.CellId:X8} hit={r.CollisionNormalValid} " + + $"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)}"); + Assert.True(r.Position.X > pos.X + 0.05f, + $"Forward run must keep advancing through the open corridor " + + $"(frame {i + 2}: {pos.X:F3} → {r.Position.X:F3}) — zero advance " + + $"= the #137 absorbing wedge."); + pos = r.Position; + cell = r.CellId; + } + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Issue137SlidingNormalLifecycleTests.cs b/tests/AcDream.Core.Tests/Physics/Issue137SlidingNormalLifecycleTests.cs new file mode 100644 index 00000000..98406131 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Issue137SlidingNormalLifecycleTests.cs @@ -0,0 +1,343 @@ +using System; +using System.Collections.Generic; +using System.Numerics; +using DatReaderWriter.Enums; +using DatReaderWriter.Types; +using AcDream.Core.Physics; +using Xunit; +using Plane = System.Numerics.Plane; + +namespace AcDream.Core.Tests.Physics; + +/// +/// #137 mechanism 2 — the sliding-normal absorbing wedge (2026-07-06). +/// +/// +/// Retail's in-transition collision_info.sliding_normal has exactly ONE +/// writer besides the per-frame seed: CTransition::validate_transition +/// (0x0050ac21-ac30, "if collision_normal_valid → set_sliding_normal"). The +/// BSP collision layer NEVER writes it — BSPTREE::find_collisions' +/// Contact branch dispatches full hits to step_sphere_up (foot, +/// 0x0053a719) / BSPTREE::slide_sphere (head, 0x0053a697), and +/// CSphere::slide_sphere (0x00537440) slides IN-FRAME via +/// add_offset_to_check_pos without touching sliding_normal +/// (grep-verified: zero sliding_normal references between 0x005155 and +/// 0x00841f in acclient_2013_pseudo_c.txt). ACE mirrors this: the only +/// SetSlidingNormal call sites are CollisionInfo.cs:58 (the setter) and +/// Transition.cs:1027 (validate). The body-side persistence +/// (CPhysicsObj::SetPositionInternal 0x005154c2, SLIDING_TS bit-4 sync +/// at 0x005154e1) runs only on transition SUCCESS. +/// +/// +/// +/// acdream's BSPQuery Contact branch carried stub fallbacks +/// (SetCollisionNormal + SetSlidingNormal + return Slid) instead of the real +/// slide. The leaked sliding normal survived to the transition end, the +/// unconditional body writeback persisted it, and the next frame's seed +/// projected an exactly-anti-parallel push to zero — aborting at step 0 +/// BEFORE any collision test could refresh the state. Live shape: the +/// Facility Hub corridor phantom (launch-175-verify2.log:42858 — one wall +/// hit at the 0x8A02016E→0x8A02017A seam, then endless ok=False hit=no +/// zero-advance resolves; strafe escapes). +/// +/// +public class Issue137SlidingNormalLifecycleTests +{ + // ========================================================================= + // Site-level pins — BSPQuery.FindCollisions Contact branch must not write + // the transition's sliding normal (retail: only validate_transition does). + // ========================================================================= + + /// + /// Contact foot-sphere FULL HIT with the step-up recursion unavailable + /// (engine=null / step-up already in progress) must dispatch the real + /// sphere slide — never the SetSlidingNormal stub. + /// + /// + /// Retail: a blocked step-up funnels to SPHEREPATH::step_up_slide → + /// CSphere::slide_sphere (ACE SpherePath.cs:316 → Sphere.cs:558) — + /// in-frame slide, no sliding_normal write. Face-on into a vertical wall + /// while grounded: the crease projection (cross(wallN, floorN)) has no + /// component along the movement, the slide offset is degenerate + /// (< F_EPSILON), and slide_sphere returns COLLIDED_TS (0x00537735). + /// + /// + [Fact] + public void ContactFootFullHit_StepUpUnavailable_RealSlide_NoSlidingNormalWrite() + { + var (root, resolved) = BSPStepUpFixtures.TallWall(); + + // Grounded mover pushing face-on (+X) into the 5 m wall at x=0.5 + // (normal −X). Sphere center reach 0.35+0.2=0.55 penetrates the wall. + var from = new Vector3(0.10f, 0f, BSPStepUpFixtures.SphereRadius); + var to = new Vector3(0.35f, 0f, BSPStepUpFixtures.SphereRadius); + var t = BSPStepUpFixtures.MakeGroundedTransition(from, to); + + var localSphere = new DatReaderWriter.Types.Sphere + { + Origin = to, + Radius = BSPStepUpFixtures.SphereRadius, + }; + + var result = BSPQuery.FindCollisions( + root, resolved, t, localSphere, null, + from, Vector3.UnitZ, 1.0f); + + Assert.False(t.CollisionInfo.SlidingNormalValid, + "find_collisions must not write collision_info.sliding_normal — " + + "retail's only in-transition writer is validate_transition " + + "(0x0050ac21). A sliding normal leaked here survives to the body " + + "writeback and absorbs the next frame's forward offset (#137)."); + Assert.True(t.CollisionInfo.CollisionNormalValid, + "The real slide records the collision normal (CSphere::slide_sphere " + + "→ set_collision_normal)."); + Assert.Equal(TransitionState.Collided, result); + } + + /// + /// Contact HEAD-sphere FULL HIT must dispatch BSPTREE::slide_sphere + /// (retail 0x0053a697; ACE BSPTree.cs:202 → 310-316: the real + /// Sphere.SlideSphere on GlobalSphere[0]) — never the stub. + /// The corridor phantom's portal-side polys span head height; this is the + /// path that recorded the (−1,0,0) normal the wedge absorbed on. + /// + [Fact] + public void ContactHeadFullHit_RealSlide_NoSlidingNormalWrite() + { + // Raised wall: z ∈ [0.6, 5] at x=0.5, normal −X. The foot sphere + // (center z=0.2, r=0.2 → z-span [0, 0.4]) passes under it; the head + // sphere (center z=0.8 → z-span [0.6, 1.0]) fully hits it. + var resolved = new Dictionary(); + + var floorVerts = new[] + { + new Vector3(-2f, -1f, 0f), new Vector3(2f, -1f, 0f), + new Vector3(2f, 1f, 0f), new Vector3(-2f, 1f, 0f), + }; + resolved[1] = new ResolvedPolygon + { + Vertices = floorVerts, + Plane = new Plane(Vector3.UnitZ, 0f), + NumPoints = 4, + SidesType = CullMode.None, + }; + + var wallNormal = new Vector3(-1f, 0f, 0f); + var wallVerts = new[] + { + new Vector3(0.5f, -1f, 0.6f), + new Vector3(0.5f, -1f, 5f), + new Vector3(0.5f, 1f, 5f), + new Vector3(0.5f, 1f, 0.6f), + }; + resolved[2] = new ResolvedPolygon + { + Vertices = wallVerts, + Plane = new Plane(wallNormal, 0.5f), // n·p + d = 0 at x=0.5 + NumPoints = 4, + SidesType = CullMode.None, + }; + + var leaf = new PhysicsBSPNode + { + Type = BSPNodeType.Leaf, + BoundingSphere = new DatReaderWriter.Types.Sphere { Origin = new Vector3(0f, 0f, 2.5f), Radius = 10f }, + }; + leaf.Polygons.Add(1); + leaf.Polygons.Add(2); + + var from = new Vector3(0.10f, 0f, BSPStepUpFixtures.SphereRadius); + var to = new Vector3(0.35f, 0f, BSPStepUpFixtures.SphereRadius); + var t = BSPStepUpFixtures.MakeGroundedTransition(from, to); + + var footSphere = new DatReaderWriter.Types.Sphere + { + Origin = to, + Radius = BSPStepUpFixtures.SphereRadius, + }; + var headSphere = new DatReaderWriter.Types.Sphere + { + Origin = new Vector3(to.X, to.Y, 0.8f), + Radius = BSPStepUpFixtures.SphereRadius, + }; + + var result = BSPQuery.FindCollisions( + leaf, resolved, t, footSphere, headSphere, + from, Vector3.UnitZ, 1.0f); + + Assert.False(t.CollisionInfo.SlidingNormalValid, + "Head full hit must go through the real BSPTREE::slide_sphere — " + + "no sliding_normal write at the BSP layer (retail 0x0053a697)."); + Assert.True(t.CollisionInfo.CollisionNormalValid); + Assert.Equal(TransitionState.Collided, result); + } + + /// + /// CSphere::slide_sphere's opposing-normals branch (collision + /// normal anti-parallel to the contact plane — e.g. a ceiling-facing + /// normal while grounded) records the REVERSED displacement as the + /// collision normal and returns COLLIDED_TS — retail 0x00537440 + /// @0x005375d7-0x0053762c: *normal = −gDelta; normalize; + /// set_collision_normal; return 2. Our port returned OK (its comment + /// even claimed "retail returns OK here"), letting the step complete + /// as-is with a synthetic reversed-movement collision normal — the exact + /// signature of the live corridor hit (`hit=yes n=(−1.00,0.03,−0.03)` = + /// the negated run direction, matching NO dat polygon). + /// + [Fact] + public void SlideSphere_OpposingNormals_ReturnsCollided_WithReversedDisplacementNormal() + { + var t = new Transition(); + t.SpherePath.InitPath( + new Vector3(0f, 0f, 0.2f), new Vector3(0.3f, 0f, 0.2f), + 0xA9B40001u, BSPStepUpFixtures.SphereRadius); + t.CollisionInfo.SetContactPlane(new Plane(Vector3.UnitZ, 0f), 0xA9B40001u, false); + + // Make gDelta exactly (0.4, 0, 0): currPos = check sphere − (0.4,0,0). + var currPos = t.SpherePath.GlobalSphere[0].Origin - new Vector3(0.4f, 0f, 0f); + + // Downward collision normal vs the +Z contact plane → cross ≈ 0 + // (parallel), dot = −1 < 0 (opposing) → the reverse branch. + var result = t.SlideSphereInternal(new Vector3(0f, 0f, -1f), currPos); + + Assert.Equal(TransitionState.Collided, result); + Assert.True(t.CollisionInfo.CollisionNormalValid); + Assert.True(t.CollisionInfo.CollisionNormal.X < -0.99f, + $"Collision normal must be the normalized reversed displacement " + + $"(−1,0,0); got ({t.CollisionInfo.CollisionNormal.X:F3}," + + $"{t.CollisionInfo.CollisionNormal.Y:F3},{t.CollisionInfo.CollisionNormal.Z:F3})."); + } + + // ========================================================================= + // Engine-level lifecycle pin — the retail persist/absorb/clear cycle at a + // REAL wall. Guards the fix against regressing wall behavior, and + // documents where retail CLEARS the body's sliding state (the successful + // transition's writeback, when no step re-records a collision). + // ========================================================================= + + private const uint CellId = 0xA9B40157u; + + private static PhysicsEngine BuildWallEngine() + { + var (wallRoot, wallResolved) = BSPStepUpFixtures.TallWall(); + + var cell = new CellPhysics + { + BSP = new PhysicsBSPTree { Root = wallRoot }, + WorldTransform = Matrix4x4.Identity, + InverseWorldTransform = Matrix4x4.Identity, + Resolved = wallResolved, + CellBSP = new CellBSPTree + { + Root = new CellBSPNode { Type = BSPNodeType.Leaf }, + }, + }; + + var engine = new PhysicsEngine(); + engine.DataCache = new PhysicsDataCache(); + + // Flat terrain strip so the outdoor fall-through has something to + // sample if it ever fires (same shape as FindEnvCollisionsMultiCellTests). + var heights = new byte[81]; + Array.Fill(heights, (byte)0); + engine.AddLandblock(0xA9B4FFFFu, new TerrainSurface(heights, BuildHeightTable()), + Array.Empty(), Array.Empty(), + worldOffsetX: 0f, worldOffsetY: 0f); + + engine.DataCache.RegisterCellStructForTest(CellId, cell); + return engine; + } + + private static float[] BuildHeightTable() + { + var ht = new float[256]; + for (int i = 0; i < 256; i++) ht[i] = i * 1.0f; + return ht; + } + + private static PhysicsBody GroundedBody() + { + var body = new PhysicsBody(); + body.ContactPlaneValid = true; + body.ContactPlane = new Plane(Vector3.UnitZ, 0f); + body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable; + return body; + } + + private ResolveResult ResolveForward(PhysicsEngine engine, PhysicsBody body, + Vector3 from, Vector3 to) + => engine.ResolveWithTransition( + currentPos: from, + targetPos: to, + cellId: CellId, + sphereRadius: BSPStepUpFixtures.SphereRadius, + sphereHeight: 0f, // single sphere — keeps the scenario deterministic + stepUpHeight: 0.04f, // cannot scale the 5 m wall + stepDownHeight: 0.04f, + isOnGround: true, + body: body); + + /// + /// The full retail lifecycle at a real wall: + /// (1) a blocked face-on push persists the validate-recorded sliding + /// normal via the SUCCESS writeback (SetPositionInternal bit-4 sync, + /// 0x005154e1); + /// (2) the next exactly-anti-parallel push is absorbed by the seed + /// (get_object_info 0x00511d44 → adjust_offset projects to zero → + /// find_transitional_position's step-0 small-offset abort) — the + /// retail cache semantics: "still pressed against this wall"; + /// (3) an oblique push escapes along the wall tangent, the step runs + /// without re-recording a collision, and the successful writeback + /// CLEARS the body's sliding state (sliding_normal_valid==0 → bit + /// 4 cleared). + /// + [Fact] + public void WallLifecycle_PersistOnBlock_AbsorbExactAntiParallel_ClearOnEscape() + { + var engine = BuildWallEngine(); + var body = GroundedBody(); + + // ── 1. Face-on +X into the wall at x=0.5 (normal −X) ───────────── + var r1 = ResolveForward(engine, body, + from: new Vector3(0.10f, 0f, 0f), + to: new Vector3(0.35f, 0f, 0f)); + + Assert.True(body.TransientState.HasFlag(TransientStateFlags.Sliding), + "A blocked push must persist the validate-recorded sliding normal " + + "(retail SetPositionInternal 0x005154c2 on transition success)."); + Assert.True(body.SlidingNormal.X < -0.9f, + $"Persisted normal should face the mover (−X); got {body.SlidingNormal}."); + Assert.True(r1.Position.X + BSPStepUpFixtures.SphereRadius + <= 0.5f + PhysicsGlobals.EPSILON * 20f, + $"The 5 m wall must block the sphere; reach={r1.Position.X + BSPStepUpFixtures.SphereRadius:F4}."); + + // ── 2. Exactly-anti-parallel push again: absorbed frame ────────── + var r2 = ResolveForward(engine, body, + from: r1.Position, + to: r1.Position + new Vector3(0.15f, 0f, 0f)); + + Assert.False(r2.Ok, + "The seeded sliding normal projects the exactly-anti-parallel " + + "offset to zero → step-0 abort (retail find_transitional_position " + + "0050bfb7/0050c0ef). Faithful absorbed frame at a REAL wall."); + Assert.True(body.TransientState.HasFlag(TransientStateFlags.Sliding), + "A failed transition leaves the body's sliding state untouched " + + "(retail: SetPositionInternal never runs on failure)."); + + // ── 3. Oblique push escapes and CLEARS the persisted state ─────── + var r3 = ResolveForward(engine, body, + from: r2.Position, + to: r2.Position + new Vector3(0.10f, 0.15f, 0f)); + + Assert.True(r3.Ok, "Oblique push must escape along the wall tangent."); + Assert.True(r3.Position.Y > r2.Position.Y + 0.05f, + $"Expected tangential advance along +Y; got Y={r3.Position.Y:F4} " + + $"(from {r2.Position.Y:F4})."); + Assert.False(body.TransientState.HasFlag(TransientStateFlags.Sliding), + "A successful transition whose steps re-record no collision must " + + "CLEAR the body's sliding state (retail SetPositionInternal " + + "0x005154e1: bit 4 synced from the transition's final " + + "sliding_normal_valid, which each step clears before its insert)."); + Assert.Equal(Vector3.Zero, body.SlidingNormal); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Issue175HubDoorPoseInspectionTests.cs b/tests/AcDream.Core.Tests/Physics/Issue175HubDoorPoseInspectionTests.cs new file mode 100644 index 00000000..6cd9bf4f --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Issue175HubDoorPoseInspectionTests.cs @@ -0,0 +1,265 @@ +using System; +using System.IO; +using System.Linq; +using System.Numerics; +using AcDream.Core.Physics; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; +using DatReaderWriter.Types; +using Xunit; +using Xunit.Abstractions; +using Env = System.Environment; +using Placement = DatReaderWriter.Enums.Placement; + +namespace AcDream.Core.Tests.Physics; + +/// +/// #175 (2026-07-05) — read-only dat inspection for the Facility Hub door +/// (Setup 0x02000C9D, guid 0x78A020C7 in the live session). User report: +/// the door's COLLISION sits displaced to the far side of the VISUAL panel +/// (embed from one side deep enough to camera-clip; a phantom wall on the +/// other side that can push the player out of use radius). +/// +/// Hypothesis under test: collision registers from the Setup's +/// PlacementFrames (ShadowShapeBuilder.FromSetup — Resting|Default|first) +/// while the rendered panel poses from the motion table's default/closed +/// state through the sequencer; retail tests the part's LIVE pose +/// (CPhysicsPart), so a door whose placement frame differs from its +/// motion-table closed pose shows exactly this offset. This test dumps both +/// poses so the divergence (or its absence) is a dat fact, not a theory. +/// +/// SKIP when the dat directory is absent (CI); local runs have it. +/// +public class Issue175HubDoorPoseInspectionTests +{ + private readonly ITestOutputHelper _out; + public Issue175HubDoorPoseInspectionTests(ITestOutputHelper output) => _out = output; + + private const uint HubDoorSetupId = 0x02000C9Du; + + [Fact] + public void HubDoorSetup_PlacementVsMotionPose_DatInspection() + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + if (!Directory.Exists(datDir)) + { + _out.WriteLine($"SKIP: dat directory not found at {datDir}"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var setup = dats.Get(HubDoorSetupId); + Assert.NotNull(setup); + + _out.WriteLine($"=== Setup 0x{HubDoorSetupId:X8} ==="); + _out.WriteLine($" Flags = {setup!.Flags} (0x{(uint)setup.Flags:X8})"); + _out.WriteLine($" Parts = {setup.Parts.Count}"); + for (int i = 0; i < setup.Parts.Count; i++) + _out.WriteLine($" [{i}] gfxObj=0x{setup.Parts[i]:X8}"); + _out.WriteLine($" DefaultAnimation = 0x{setup.DefaultAnimation:X8}"); + _out.WriteLine($" DefaultScript = 0x{setup.DefaultScript:X8}"); + _out.WriteLine($" DefaultMotionTable = 0x{setup.DefaultMotionTable:X8}"); + _out.WriteLine($" CylSpheres={setup.CylSpheres.Count} Spheres={setup.Spheres.Count} Radius={setup.Radius:F3}"); + foreach (var c in setup.CylSpheres) + _out.WriteLine($" cyl r={c.Radius:F3} h={c.Height:F3} origin=({c.Origin.X:F3},{c.Origin.Y:F3},{c.Origin.Z:F3})"); + + _out.WriteLine($" PlacementFrames = {setup.PlacementFrames.Count}"); + foreach (var kv in setup.PlacementFrames) + { + _out.WriteLine($" [{kv.Key}] frames={kv.Value.Frames.Count}"); + for (int i = 0; i < kv.Value.Frames.Count; i++) + { + var f = kv.Value.Frames[i]; + _out.WriteLine( + $" part[{i}] pos=({f.Origin.X:F3},{f.Origin.Y:F3},{f.Origin.Z:F3}) " + + $"rot=({f.Orientation.X:F3},{f.Orientation.Y:F3},{f.Orientation.Z:F3},{f.Orientation.W:F3})"); + } + } + + // Part 0's physics BSP bounds — where the slab actually is in + // PART-LOCAL space (composed with the poses above for world). + foreach (uint gfxId in setup.Parts.Distinct()) + { + var gfx = dats.Get(gfxId); + _out.WriteLine($"=== GfxObj 0x{gfxId:X8} ==="); + if (gfx is null) { _out.WriteLine(" NULL"); continue; } + var root = gfx.PhysicsBSP?.Root; + _out.WriteLine($" PhysicsBSP.Root = {(root is null ? "NULL" : "non-null")}"); + if (root?.BoundingSphere is { } bs) + _out.WriteLine($" BSP bounds = ({bs.Origin.X:F3},{bs.Origin.Y:F3},{bs.Origin.Z:F3}) r={bs.Radius:F3}"); + if (gfx.PhysicsPolygons is { } pp && gfx.VertexArray?.Vertices is { } verts) + { + float minX = float.MaxValue, maxX = float.MinValue; + float minY = float.MaxValue, maxY = float.MinValue; + float minZ = float.MaxValue, maxZ = float.MinValue; + foreach (var poly in pp.Values) + foreach (var vid in poly.VertexIds) + { + if (!verts.TryGetValue((ushort)vid, out var sv)) continue; + minX = Math.Min(minX, sv.Origin.X); maxX = Math.Max(maxX, sv.Origin.X); + minY = Math.Min(minY, sv.Origin.Y); maxY = Math.Max(maxY, sv.Origin.Y); + minZ = Math.Min(minZ, sv.Origin.Z); maxZ = Math.Max(maxZ, sv.Origin.Z); + } + _out.WriteLine($" Physics AABB (part-local) = X[{minX:F3},{maxX:F3}] Y[{minY:F3},{maxY:F3}] Z[{minZ:F3},{maxZ:F3}]"); + } + } + + // The motion-table default (closed) pose, if the setup names one: + // frame 0 of the default style's default cycle — what the sequencer + // renders for an idle closed door. + if (setup.DefaultMotionTable != 0) + { + var mt = dats.Get(setup.DefaultMotionTable); + _out.WriteLine($"=== MotionTable 0x{setup.DefaultMotionTable:X8} ==="); + if (mt is null) { _out.WriteLine(" NULL"); return; } + _out.WriteLine($" DefaultStyle = 0x{(uint)mt.DefaultStyle:X8}"); + if (mt.Cycles.TryGetValue((int)mt.DefaultStyle, out var defCycle) + && defCycle.Anims.Count > 0) + { + var animRef = defCycle.Anims[0]; + _out.WriteLine($" default cycle anim[0] id=0x{animRef.AnimId:X8} lo={animRef.LowFrame} hi={animRef.HighFrame}"); + var anim = dats.Get(animRef.AnimId); + if (anim is not null && anim.PartFrames.Count > 0) + { + var f0 = anim.PartFrames[Math.Clamp((int)animRef.LowFrame, 0, anim.PartFrames.Count - 1)]; + for (int i = 0; i < f0.Frames.Count; i++) + { + var f = f0.Frames[i]; + _out.WriteLine( + $" anim frame0 part[{i}] pos=({f.Origin.X:F3},{f.Origin.Y:F3},{f.Origin.Z:F3}) " + + $"rot=({f.Orientation.X:F3},{f.Orientation.Y:F3},{f.Orientation.Z:F3},{f.Orientation.W:F3})"); + } + } + else + { + _out.WriteLine(" anim NULL or no PartFrames"); + } + } + else + { + _out.WriteLine(" no default-style cycle"); + } + } + else + { + _out.WriteLine("=== no DefaultMotionTable on the setup ==="); + } + } + + /// + /// #175 derivation conformance — REAL-DAT pin for + /// . + /// The first cut of the derivation looked up Cycles[DefaultStyle] + /// with the bare style word; the dictionary is keyed by the COMBINED + /// (style << 16) | substate word (CMotionTable.cs:683), so it + /// always missed and the #175 fix silently no-oped. This pin loads the + /// human motion table (0x09000001 — guaranteed present, default state + /// NonCombat/Ready) and asserts the derivation actually resolves a pose. + /// + [Fact] + public void MotionTablePose_DefaultState_ResolvesOnRealTable() + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + if (!Directory.Exists(datDir)) + { + _out.WriteLine($"SKIP: dat directory not found at {datDir}"); + return; + } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + var mt = dats.Get(0x09000001u); + Assert.NotNull(mt); + + var pose = AcDream.Core.Physics.Motion.MotionTablePose.DefaultStatePartFrames( + mt!, id => dats.Get(id)); + + Assert.NotNull(pose); + _out.WriteLine($"human MT default pose parts={pose!.Count} " + + $"part0=({pose[0].Origin.X:F3},{pose[0].Origin.Y:F3},{pose[0].Origin.Z:F3})"); + Assert.True(pose.Count >= 1); + } + + // ── #175 fix pins: ShadowShapeBuilder partPoseOverride ────────────── + + private static Setup MakeTwoPartSetup() + { + var setup = new Setup(); + setup.Parts.Add(0x01000001u); + setup.Parts.Add(0x01000002u); + var placement = new AnimationFrame(2); + placement.Frames.Clear(); + placement.Frames.Add(new Frame { Origin = new Vector3(0.88f, -0.44f, 1.37f), + Orientation = new Quaternion(0f, 0f, -0.966f, 0.259f) }); + placement.Frames.Add(new Frame { Origin = new Vector3(-0.88f, -0.44f, 1.37f), + Orientation = new Quaternion(0f, 0f, -0.259f, 0.966f) }); + setup.PlacementFrames[Placement.Default] = placement; + return setup; + } + + /// + /// With a motion-table pose override, the BSP part shapes must use it — + /// the closed pose, not the ajar placement pose (the #175 offset). + /// + [Fact] + public void FromSetup_PartPoseOverride_ReplacesPlacementFrames() + { + var setup = MakeTwoPartSetup(); + var closed = new[] + { + new Frame { Origin = new Vector3(0.85f, 0f, 1.37f), Orientation = Quaternion.Identity }, + new Frame { Origin = new Vector3(-0.85f, 0f, 1.37f), Orientation = Quaternion.Identity }, + }; + + var shapes = ShadowShapeBuilder.FromSetup( + setup, entScale: 1f, hasPhysicsBsp: _ => true, partPoseOverride: closed); + + Assert.Equal(2, shapes.Count); + Assert.Equal(new Vector3(0.85f, 0f, 1.37f), shapes[0].LocalPosition); + Assert.Equal(Quaternion.Identity, shapes[0].LocalRotation); + Assert.Equal(new Vector3(-0.85f, 0f, 1.37f), shapes[1].LocalPosition); + } + + /// + /// Null override (no motion table) keeps the pre-#175 placement-frame + /// behavior — landblock statics and table-less entities unchanged. + /// + [Fact] + public void FromSetup_NoOverride_KeepsPlacementFrames() + { + var setup = MakeTwoPartSetup(); + + var shapes = ShadowShapeBuilder.FromSetup( + setup, entScale: 1f, hasPhysicsBsp: _ => true); + + Assert.Equal(2, shapes.Count); + Assert.Equal(new Vector3(0.88f, -0.44f, 1.37f), shapes[0].LocalPosition); + Assert.Equal(new Quaternion(0f, 0f, -0.966f, 0.259f), shapes[0].LocalRotation); + } + + /// + /// A short override (fewer frames than parts) falls back to placement + /// frames — a mismatched motion table must not misplace collision. + /// + [Fact] + public void FromSetup_ShortOverride_FallsBackPerPart() + { + var setup = MakeTwoPartSetup(); + var shortOverride = new[] + { + new Frame { Origin = new Vector3(0.85f, 0f, 1.37f), Orientation = Quaternion.Identity }, + }; + + var shapes = ShadowShapeBuilder.FromSetup( + setup, entScale: 1f, hasPhysicsBsp: _ => true, partPoseOverride: shortOverride); + + Assert.Equal(2, shapes.Count); + Assert.Equal(new Vector3(0.85f, 0f, 1.37f), shapes[0].LocalPosition); // override + Assert.Equal(new Vector3(-0.88f, -0.44f, 1.37f), shapes[1].LocalPosition); // placement fallback + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Issue176177SeamTransitLagTests.cs b/tests/AcDream.Core.Tests/Physics/Issue176177SeamTransitLagTests.cs new file mode 100644 index 00000000..33bf9952 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Issue176177SeamTransitLagTests.cs @@ -0,0 +1,157 @@ +using System; +using System.IO; +using System.Numerics; +using AcDream.Core.Physics; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; +using Xunit; +using Xunit.Abstractions; +using Env = System.Environment; + +namespace AcDream.Core.Tests.Physics; + +/// +/// #176/#177 membership half: production [cell-transit] lines +/// (launch-137-gate2.log) fire 0.1–0.6 m PAST the portal plane in the travel +/// direction (016E→017A at x=85.33–85.47 vs the plane at x=85.00), while the +/// dat CellBSP volumes partition EXACTLY at the plane +/// (Issue176177DungeonSeamInspectionTests.SeamCells_CellBspContainment) — +/// retail's center-only point_in_cell flips at the plane. The render root +/// (viewer cell) resolves through the same machinery; while it lags, the +/// portal flood correctly refuses the boundary portal the eye has already +/// crossed and the whole forward chain drops (the purple seam flash / +/// stair pop). This replay measures OUR resolver's flip point across the +/// x=85 seam in a controlled run. +/// +public class Issue176177SeamTransitLagTests +{ + private const uint SeamCellWest = 0x8A02016Eu; // x 75..85 + private const uint SeamCellEast = 0x8A02017Au; // x 85..88.33 + + private readonly ITestOutputHelper _out; + public Issue176177SeamTransitLagTests(ITestOutputHelper output) => _out = output; + + private static string? ResolveDatDir() + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + return Directory.Exists(datDir) ? datDir : null; + } + + private static PhysicsEngine BuildEngine(DatCollection dats) + { + var engine = new PhysicsEngine(); + engine.DataCache = new PhysicsDataCache(); + + var toLoad = new System.Collections.Generic.HashSet { SeamCellWest, SeamCellEast }; + for (int ring = 0; ring < 3; ring++) + { + foreach (var known in new System.Collections.Generic.List(toLoad)) + { + var cell = dats.Get(known); + if (cell is null) continue; + foreach (var p in cell.CellPortals) + toLoad.Add(0x8A020000u | p.OtherCellId); + } + } + + foreach (var cellId in toLoad) + { + var envCell = dats.Get(cellId); + if (envCell is null) continue; + var environment = dats.Get(0x0D000000u | envCell.EnvironmentId); + if (environment is null) continue; + if (!environment.Cells.TryGetValue(envCell.CellStructure, out var cs)) continue; + + var rot = new Quaternion( + envCell.Position.Orientation.X, envCell.Position.Orientation.Y, + envCell.Position.Orientation.Z, envCell.Position.Orientation.W); + var world = Matrix4x4.CreateFromQuaternion(rot) + * Matrix4x4.CreateTranslation( + envCell.Position.Origin.X, envCell.Position.Origin.Y, envCell.Position.Origin.Z); + + engine.DataCache.CacheCellStruct(cellId, envCell, cs!, world); + } + return engine; + } + + private static PhysicsBody GroundedBody() + { + var body = new PhysicsBody(); + body.ContactPlaneValid = true; + body.ContactPlane = new Plane(Vector3.UnitZ, 6f); + body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable; + body.WalkablePolygonValid = true; + body.WalkablePlane = new Plane(Vector3.UnitZ, 6f); + body.WalkableUp = Vector3.UnitZ; + body.WalkableVertices = new[] + { + new Vector3(75f, -41.67f, -6f), + new Vector3(85f, -41.67f, -6f), + new Vector3(85f, -38.33f, -6f), + new Vector3(75f, -38.33f, -6f), + }; + return body; + } + + /// + /// Run +X across the x=85 seam at run-speed tick steps (13.5 cm/tick ≈ + /// 4 m/s at 30 Hz) and record where ResolveWithTransition's CellId flips. + /// Retail (center-only point_in_cell, exact-partition CellBSP) flips on + /// the first tick whose END position is past x=85.00 — any flip later + /// than one step past the plane is OUR lag. + /// + [Theory] + [InlineData(+1)] // west → east across x=85 + [InlineData(-1)] // east → west back across + public void RunAcrossSeam_CellFlipPosition(int direction) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + var engine = BuildEngine(dats); + var body = GroundedBody(); + + const float step = 0.135f; + float startX = direction > 0 ? 83.8f : 86.2f; + uint cell = direction > 0 ? SeamCellWest : SeamCellEast; + var pos = new Vector3(startX, -40f, -6f); + + float? flipX = null; + for (int tick = 0; tick < 26; tick++) + { + var target = pos + new Vector3(direction * step, 0f, 0f); + var r = engine.ResolveWithTransition( + currentPos: pos, + targetPos: target, + cellId: cell, + sphereRadius: 0.48f, + sphereHeight: 1.835f, + stepUpHeight: 0.4f, + stepDownHeight: 0.4f, + isOnGround: true, + body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide); + + bool flipped = r.CellId != cell; + _out.WriteLine($"tick={tick,2} pos=({r.Position.X:F3},{r.Position.Y:F3},{r.Position.Z:F3}) " + + $"cell=0x{r.CellId:X8} ok={r.Ok}{(flipped ? " <<< FLIP" : "")}"); + if (flipped && flipX is null) + flipX = r.Position.X; + + cell = r.CellId; + pos = r.Position; + if (direction > 0 && pos.X > 86.4f) break; + if (direction < 0 && pos.X < 83.6f) break; + } + + Assert.NotNull(flipX); + float lag = direction > 0 ? flipX!.Value - 85.00f : 85.00f - flipX!.Value; + _out.WriteLine($"flip at x={flipX:F3} → lag past the plane = {lag:F3} m " + + $"(one-tick quantization bound = {step:F3} m)"); + // Diagnostic, not a pin: the finding is the printed lag. A lag beyond + // one tick step is the divergence under investigation. + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Issue180CorridorSweepHysteresisReplayTests.cs b/tests/AcDream.Core.Tests/Physics/Issue180CorridorSweepHysteresisReplayTests.cs new file mode 100644 index 00000000..8a8ddb46 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Issue180CorridorSweepHysteresisReplayTests.cs @@ -0,0 +1,150 @@ +using System; +using System.Collections.Generic; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Tests.Conformance; +using DatReaderWriter; +using DatReaderWriter.Options; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.Core.Tests.Physics; + +/// +/// #180 residual — the camera-sweep SAWTOOTH in the Facility Hub corridor +/// (0x8A020164), root-caused to a dead BSPQuery.AdjustToPlane: +/// acdream (via ACE's misdecoded port) had the PerfectClip exact-contact +/// machinery structurally inverted so it ALWAYS failed, and every PathClipped +/// camera stop reverted to the previous transition-step boundary instead of +/// the contact point. Live signature (launch-180-verify.log): the stateful +/// sought re-extends ~3 mm/frame, the sweep passes silently until the step +/// containing the contact, then clips a whole step (~0.27 m) back — a ~19 Hz +/// sawtooth; the pre-stateful camera flipped 1-step vs 2-step backoffs +/// (pulledIn 0.27 ↔ 0.53) — the ORIGINAL #176 stripe strobe. +/// +/// This replay walks sweep targets along the exact captured ray +/// (pivot → the [flap-sweep] in= of idx 28882) across the wall behind the +/// spawn camera, against the REAL cell BSP. It pins the retail-faithful +/// stop behavior (BSPTREE::adjust_to_plane 0x00539bf0, pseudocode +/// docs/research/2026-07-06-adjust-to-plane-pseudocode.md): +/// +/// 1. targets short of first touch pass unclipped (the wall plane is +/// genuinely ~1.61 m out along this ray: dist(center,plane) > r); +/// 2. every target past first touch CONTACTS (no silent pass-through +/// band — pre-fix, targets embedded up to ~0.25 m passed); +/// 3. the clipped eye is the CONSTANT surface-contact point (pre-fix it +/// tracked the target one step back: eyeBack = s − ~0.27). +/// +public class Issue180CorridorSweepHysteresisReplayTests +{ + private readonly ITestOutputHelper _out; + public Issue180CorridorSweepHysteresisReplayTests(ITestOutputHelper output) => _out = output; + + private const float ViewerSphereRadius = 0.3f; // retail viewer_sphere (acclient :93314) + + private const uint FacilityHubLandblock = 0x8A020000u; + private const uint CorridorCell = 0x8A020164u; + + // [flap-cam] player=(70.58,-40.16,-5.90) (parked spawn) + PivotHeight 1.5. + private static readonly Vector3 Pivot = new(70.58f, -40.16f, -4.40f); + + // [flap-sweep] idx 28882: the captured in= that clipped (the sawtooth's deep edge). + private static readonly Vector3 THit = new(70.366051f, -38.628315f, -3.935829f); + + private static (PhysicsEngine, PhysicsDataCache) BuildCorridorEngine(DatCollection dats) + { + var cache = new PhysicsDataCache(); + var engine = new PhysicsEngine { DataCache = cache }; + for (uint low = 0x0100u; low <= 0x01FFu; low++) + { + uint id = FacilityHubLandblock | low; + try { ConformanceDats.LoadEnvCell(dats, cache, id); } + catch (InvalidOperationException) { /* cell id not present in this dungeon */ } + } + + var heights = new byte[81]; + var heightTable = new float[256]; + for (int i = 0; i < 256; i++) heightTable[i] = -1000f; + engine.AddLandblock(FacilityHubLandblock, new TerrainSurface(heights, heightTable), + Array.Empty(), Array.Empty(), 0f, 0f); + return (engine, cache); + } + + /// Mirror of PhysicsCameraCollisionProbe.SweepEye's transition call. + private static ResolveResult SweepViewer(PhysicsEngine engine, Vector3 pivot, Vector3 desiredEye, uint cellId) + { + uint startCell = cellId; + if ((cellId & 0xFFFFu) >= 0x0100u) + { + var (pivotCell, found) = engine.AdjustPosition(cellId, pivot); + if (found) startCell = pivotCell; + } + + Vector3 begin = pivot - new Vector3(0f, 0f, ViewerSphereRadius); + Vector3 end = desiredEye - new Vector3(0f, 0f, ViewerSphereRadius); + + return engine.ResolveWithTransition( + currentPos: begin, + targetPos: end, + cellId: startCell, + sphereRadius: ViewerSphereRadius, + sphereHeight: 0f, + stepUpHeight: 0f, + stepDownHeight: 0f, + isOnGround: false, + body: null, + moverFlags: ObjectInfoState.IsViewer | ObjectInfoState.PathClipped + | ObjectInfoState.FreeRotate | ObjectInfoState.PerfectClip, + movingEntityId: 0); + } + + [Fact] + public void ClippedStop_IsTheContactPoint_NotAStepBoundary() + { + var datDir = ConformanceDats.ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: dats unavailable"); return; } + + using var dats = new DatCollection(datDir, DatAccessType.Read); + var (engine, _) = BuildCorridorEngine(dats); + + Vector3 dir = Vector3.Normalize(THit - Pivot); + + var clippedEyeBacks = new List(); + for (float s = 1.20f; s <= 1.75f; s += 0.025f) + { + Vector3 target = Pivot + dir * s; + var r = SweepViewer(engine, Pivot, target, CorridorCell); + Vector3 eye = r.Position + new Vector3(0f, 0f, ViewerSphereRadius); + float eyeBack = Vector3.Distance(Pivot, eye); + _out.WriteLine(FormattableString.Invariant( + $"s={s:F3} eyeBack={eyeBack:F3} collNorm={r.CollisionNormalValid}")); + + if (s <= 1.55f) + { + // (1) Short of first touch (~1.61 m): the sweep must reach the target. + Assert.False(r.CollisionNormalValid, + $"s={s:F3}: no wall within reach, sweep must not clip"); + Assert.True(MathF.Abs(eyeBack - s) < 0.01f, + $"s={s:F3}: unclipped sweep must reach the target, got eyeBack={eyeBack:F3}"); + } + else if (s >= 1.65f) + { + // (2) Past first touch: every target must contact — the pre-fix + // defect passed targets embedded up to ~0.25 m unclipped. + Assert.True(r.CollisionNormalValid, + $"s={s:F3}: target past the wall must clip"); + clippedEyeBacks.Add(eyeBack); + } + } + + // (3) The clipped stop is the constant surface-contact point. Pre-fix the + // stop tracked the target one step back (eyeBack = s − ~0.27, spread + // ≈ 0.10 m over this range); retail's adjust_to_plane commits the + // last-clear time within a 0.02 window of the contact. + Assert.True(clippedEyeBacks.Count >= 4, "expected several clipped samples"); + float min = float.MaxValue, max = float.MinValue; + foreach (var e in clippedEyeBacks) { min = MathF.Min(min, e); max = MathF.Max(max, e); } + Assert.True(max - min < 0.03f, + $"clipped stops must be one contact point, got spread {max - min:F3} m ({min:F3}..{max:F3})"); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Issue182CrowdJumpTests.cs b/tests/AcDream.Core.Tests/Physics/Issue182CrowdJumpTests.cs new file mode 100644 index 00000000..278b5e33 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Issue182CrowdJumpTests.cs @@ -0,0 +1,110 @@ +using System; +using System.Numerics; +using AcDream.Core.Physics; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.Core.Tests.Physics; + +/// +/// End-to-end (Core) proof of the #182 airborne-stuck fix: a jump velocity blocked by a +/// creature BLEEDS to zero within a few frames so gravity can resume — the player falls / +/// glides off instead of hanging in the falling animation. Chains the same steps the +/// PlayerMovementController per-frame loop runs, minus the App layer: +/// integrate (UpdatePhysicsInternal + gravity) → ResolveWithTransition → apply → +/// handle_all_collisions (PhysicsObjUpdate). +/// Before the rebuild the velocity persisted (only an airborne-only reflect that barely +/// touched +Z against a near-horizontal normal); now fs>1 zeros it. +/// +public class Issue182CrowdJumpTests +{ + private readonly ITestOutputHelper _out; + public Issue182CrowdJumpTests(ITestOutputHelper output) => _out = output; + + private const uint Lb = 0xA9B40000u; + private const uint Cell = Lb | 0x0001u; + private const float R = 0.48f, H = 1.835f, StepUp = 0.60f, StepDown = 0.04f; + private const float Dt = 1f / 30f; // one physics quantum + + private static PhysicsEngine BuildEngine() + { + var engine = new PhysicsEngine { DataCache = new PhysicsDataCache() }; + engine.AddLandblock(Lb, new TerrainSurface(new byte[81], new float[256]), + Array.Empty(), Array.Empty(), 0f, 0f); + return engine; + } + + private static void RegisterCreatureAt(PhysicsEngine e, uint id, Vector3 c) + => e.ShadowObjects.Register(id, 0u, c, Quaternion.Identity, R, + 0f, 0f, Lb, ShadowCollisionType.Sphere, 0f, 1f, 0u, + EntityCollisionFlags.IsCreature, isStatic: false); + + [Fact] + public void BlockedJump_VelocityBleedsToZero_ThenGravityResumes() + { + var engine = BuildEngine(); + RegisterCreatureAt(engine, 0xC0B0u, new Vector3(12f, 10f, 4.5f)); // creature overhead + + var body = new PhysicsBody + { + Position = new Vector3(12f, 10f, 3.0f), + Orientation = Quaternion.Identity, + State = PhysicsStateFlags.Gravity | PhysicsStateFlags.ReportCollisions, + TransientState = TransientStateFlags.None, // airborne + Velocity = new Vector3(0f, 0f, 12f), // a jump: moving straight up + }; + uint cell = Cell; + + bool bled = false; + for (int frame = 0; frame < 20; frame++) + { + // 1) integrate velocity + gravity into a candidate (mirrors the controller's §4). + var pre = body.Position; + body.calc_acceleration(); + body.UpdatePhysicsInternal(Dt); + var post = body.Position; + bool candidateMoved = post != pre; // retail candidate != m_position gate + + // 2) resolve the candidate against the crowd. + var r = engine.ResolveWithTransition(pre, post, cell, R, H, StepUp, StepDown, + isOnGround: false, body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide); + + // 3) apply + contact determination (mirrors the controller's SetPositionInternal). + bool prevOnWalkable = body.OnWalkable; + body.Position = r.Position; + cell = r.CellId; + if (r.IsOnGround && body.Velocity.Z <= 0f) + { + body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable; + body.calc_acceleration(); + if (body.Velocity.Z < 0f) body.Velocity = new Vector3(body.Velocity.X, body.Velocity.Y, 0f); + } + else + { + body.TransientState &= ~(TransientStateFlags.Contact | TransientStateFlags.OnWalkable); + body.calc_acceleration(); + } + + // 4) handle_all_collisions: reflect (fsf<=1) or zero (fsf>1) — but ONLY when the + // candidate moved (retail skips SetPositionInternal otherwise), so gravity can + // rebuild the velocity after the bleed instead of it being re-zeroed each frame. + if (candidateMoved) + PhysicsObjUpdate.HandleAllCollisions(body, + r.CollisionNormalValid, r.CollisionNormal, + prevContact: false, prevOnWalkable, nowOnWalkable: body.OnWalkable); + + _out.WriteLine($"frame{frame,2}: z={body.Position.Z:F3} vz={body.Velocity.Z:F3} " + + $"fsf={body.FramesStationaryFall}"); + + // The upward jump velocity must collapse to ~0 (or reverse to falling) within a few + // frames of being blocked — the bleed. Before the fix it persisted near +12. + if (frame >= 1 && frame <= 6 && body.Velocity.Z <= 0.5f) + bled = true; + } + + Assert.True(bled, "the blocked jump velocity must bleed to ~0 within a few frames (fsf>1 → v=0)"); + // After bleeding, gravity has taken over — the body is no longer being shoved upward. + Assert.True(body.Velocity.Z <= 0.5f, $"velocity should not persist upward; got vz={body.Velocity.Z:F3}"); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Issue185OutdoorStairsSeamReplayTests.cs b/tests/AcDream.Core.Tests/Physics/Issue185OutdoorStairsSeamReplayTests.cs new file mode 100644 index 00000000..ec210cbf --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Issue185OutdoorStairsSeamReplayTests.cs @@ -0,0 +1,192 @@ +using System; +using System.IO; +using System.Numerics; +using AcDream.Core.Physics; +using Xunit; +using Xunit.Abstractions; +using Plane = System.Numerics.Plane; + +namespace AcDream.Core.Tests.Physics; + +/// +/// #185 outdoor-stairs phantom (2026-07-08) — dat-free reproduction of the +/// house-on-stilts staircase jam. The stairs are a continuous, COPLANAR +/// 38.7° ramp built from stacked step-box objects (gfxObj 0x01000AC5); the +/// tread quads abut at 0.5 m seams that fall on object boundaries. Walking +/// up, at one seam the grounded forward move loses its contact plane and the +/// step-down recovery cannot reach the coplanar (at-level) continuation, so +/// EdgeSlideAfterStepDownFailed → PrecipiceSlide fabricates the +/// tread-edge normal (0,±0.78,±0.62), which SetSlidingNormal +/// horizontalises to (0,±1,0) — absorbing the +Y up-stairs motion into +/// a pure sideways slide (the #137 / TS-4 family). A jump's +Z clears it. +/// +/// +/// Fixtures captured live this session: the player pins at world +/// (131.71, 77.914, 61.485) with slidingNormal=(0,1,0) and a +/// re-fabricated collisionNormal=(0,0.78,0.62); the tread the player is +/// grounded on has world verts (132.75,77.495,61.015)…. The step-box +/// geometry is hydrated from the captured gfxobj dump +/// (Fixtures/issue185/0x01000AC5.gfxobj.json) so the test is +/// self-contained (no dat) and CI-runnable. +/// +/// +/// +/// The step origins march +0.5 world-Y / +0.4 world-Z (matching every observed +/// [resolve-bldg] origin: 75.2/75.7/76.2/76.7/77.2). The player's tread +/// (k=4) is pinned to origin (132.0, 77.245, 60.415) by the captured +/// walkable verts. k=0..7 are registered to span the jam seam + the +/// continuation the player must climb onto. +/// +/// +public class Issue185OutdoorStairsSeamReplayTests +{ + private readonly ITestOutputHelper _out; + public Issue185OutdoorStairsSeamReplayTests(ITestOutputHelper output) => _out = output; + + private const uint StairCellId = 0xF682002Cu; // outdoor landcell (low16 = 0x2C < 0x100) + private const uint StairLandblock = 0xF6820000u; + private const uint StepGfxObjId = 0x01000AC5u; + private const int StepCount = 8; + + // A +90°-about-Z-rotated step-box maps its local tread normal + // (-0.625,0,0.781) → world (0,-0.625,0.781) (the captured tread plane). + private static readonly Quaternion StepRot = + Quaternion.CreateFromAxisAngle(Vector3.UnitZ, MathF.PI / 2f); + + // k=4 tread lands at the captured walkable verts when the step origin is + // (132.0, 77.245, 60.415); step k origin = this + k·(0, 0.5, 0.4), k−4 offset. + private static readonly Vector3 Step0Origin = new(132.0f, 75.245f, 58.815f); + + private static PhysicsEngine BuildStairEngine() + { + var cache = new PhysicsDataCache(); + var engine = new PhysicsEngine { DataCache = cache }; + + // Hydrate the step-box collision geometry from the captured dump. + var dumpPath = Path.Combine(SolutionRoot(), "tests", "AcDream.Core.Tests", + "Fixtures", "issue185", "0x01000AC5.gfxobj.json"); + Assert.True(File.Exists(dumpPath), $"Missing fixture: {dumpPath}"); + var physics = GfxObjDumpSerializer.Hydrate(GfxObjDumpSerializer.Read(dumpPath)); + cache.RegisterGfxObjForTest(StepGfxObjId, physics); + float bspR = physics.BoundingSphere?.Radius ?? 1.06f; + + // Stub landblock (terrain far below Z=61) so the outdoor context resolves + // without the player's grounding ever seeing terrain — it stands on the treads. + var heights = new byte[81]; + var heightTable = new float[256]; + for (int i = 0; i < 256; i++) heightTable[i] = -1000f; + engine.AddLandblock( + landblockId: StairLandblock, + terrain: new TerrainSurface(heights, heightTable), + cells: Array.Empty(), + portals: Array.Empty(), + worldOffsetX: 0f, + worldOffsetY: 0f); + + for (int k = 0; k < StepCount; k++) + { + var origin = Step0Origin + new Vector3(0f, 0.5f * k, 0.4f * k); + engine.ShadowObjects.Register( + entityId: 0xF6820100u + (uint)k, + gfxObjId: StepGfxObjId, + worldPos: origin, + rotation: StepRot, + radius: bspR, + worldOffsetX: 0f, + worldOffsetY: 0f, + landblockId: StairLandblock, + collisionType: ShadowCollisionType.BSP, + scale: 1.0f, + seedCellId: StairCellId); + } + + return engine; + } + + private static PhysicsBody GroundedOnTread() + { + var tread = new Plane(new Vector3(0f, -0.62469506f, 0.78086877f), 0.765995f); + return new PhysicsBody + { + Position = new Vector3(131.72375f, 77.49132f, 61.146755f), + Orientation = Quaternion.Identity, + ContactPlaneValid = true, + ContactPlane = tread, + ContactPlaneCellId = StairCellId, + WalkablePolygonValid = true, + WalkablePlane = tread, + WalkableUp = Vector3.UnitZ, + WalkableVertices = new[] + { + new Vector3(132.75f, 77.495f, 61.015f), + new Vector3(131.25f, 77.495f, 61.015f), + new Vector3(131.25f, 76.995f, 60.615f), + new Vector3(132.75f, 76.995f, 60.615f), + }, + TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable, + }; + } + + /// + /// Drive a held-forward run up the ramp (flat +Y target each tick, physics + /// climbs Z via contact projection — as the movement controller sends it). + /// The player must climb PAST the tread seam (Y > 78.1); pre-fix it pins + /// at ~77.9 and persists a horizontal sliding normal = the wedge. + /// + [Fact] + public void OutdoorStairs_ForwardRun_ClimbsPastSeam_NoWedge() + { + var engine = BuildStairEngine(); + var body = GroundedOnTread(); + + var pos = body.Position; + uint cell = StairCellId; + ResolveResult r = default; + + for (int i = 0; i < 12; i++) + { + var target = new Vector3(pos.X, pos.Y + 0.2f, pos.Z); // flat +Y; physics climbs + r = engine.ResolveWithTransition( + currentPos: pos, + targetPos: target, + cellId: cell, + sphereRadius: 0.48f, + sphereHeight: 1.835f, + stepUpHeight: 0.6f, + stepDownHeight: 1.5f, + isOnGround: true, + body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide, + movingEntityId: 0x01000000u); + + _out.WriteLine( + $"f{i}: out=({r.Position.X:F3},{r.Position.Y:F3},{r.Position.Z:F3}) cell=0x{r.CellId:X8} " + + $"cnV={r.CollisionNormalValid} cn=({r.CollisionNormal.X:F2},{r.CollisionNormal.Y:F2},{r.CollisionNormal.Z:F2}) " + + $"sliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)} " + + $"sN=({body.SlidingNormal.X:F2},{body.SlidingNormal.Y:F2},{body.SlidingNormal.Z:F2})"); + + pos = r.Position; + cell = r.CellId; + body.Position = pos; + } + + Assert.True(pos.Y > 78.10f, + $"Player must climb past the tread seam (reached Y={pos.Y:F3}); pinned at ~77.9 = the " + + $"#185 fabricated-precipice wedge (PrecipiceSlide horizontal sliding normal absorbs +Y)."); + Assert.False(body.TransientState.HasFlag(TransientStateFlags.Sliding), + "A continuous walkable ramp seam must not persist a horizontal sliding normal (#137 family)."); + } + + private static string SolutionRoot() + { + var dir = AppContext.BaseDirectory; + while (!string.IsNullOrEmpty(dir)) + { + if (File.Exists(Path.Combine(dir, "AcDream.slnx"))) + return dir; + dir = Path.GetDirectoryName(dir); + } + throw new InvalidOperationException( + "Could not locate AcDream.slnx from " + AppContext.BaseDirectory); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Issue186ConnectorCellGeometryInspectionTests.cs b/tests/AcDream.Core.Tests/Physics/Issue186ConnectorCellGeometryInspectionTests.cs new file mode 100644 index 00000000..57e86e70 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Issue186ConnectorCellGeometryInspectionTests.cs @@ -0,0 +1,197 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Numerics; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; +using Xunit; +using Xunit.Abstractions; +using Env = System.Environment; + +namespace AcDream.Core.Tests.Physics; + +/// +/// #186 diagnostic (report-only): dump the render-shell + collision geometry of the +/// connecting-room grey-flap cells (0xF6820116 player room, 0xF6820117 next room, +/// 0xF6820118 the connector root where the frame greys). Answers: is 0118 a CLOSED +/// shell (walls/floor/ceiling covering every direction bar the portal apertures) or a +/// bare connector? And does it carry collision geometry (so the camera sweep would +/// hard-stop) or none (so the boom coasts to a degenerate spot)? Skips without the dat. +/// +public class Issue186ConnectorCellGeometryInspectionTests +{ + private readonly ITestOutputHelper _out; + public Issue186ConnectorCellGeometryInspectionTests(ITestOutputHelper output) => _out = output; + + private static string? DatDir() + { + var d = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), "Documents", "Asheron's Call"); + return Directory.Exists(d) ? d : null; + } + + [Fact] + public void Dump_ConnectorCells_ShellAndCollision() + { + var datDir = DatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + foreach (uint cellId in new[] { 0xF6820116u, 0xF6820117u, 0xF6820118u }) + { + var env = dats.Get(cellId); + if (env is null) { _out.WriteLine($"cell 0x{cellId:X8}: EnvCell NOT FOUND"); continue; } + + var environment = dats.Get(0x0D000000u | env.EnvironmentId); + environment!.Cells.TryGetValue(env.CellStructure, out var cs); + + var portals = env.CellPortals?.Select(p => $"0x{(0xF6820000u | p.OtherCellId):X8}") ?? Enumerable.Empty(); + _out.WriteLine($"=== cell 0x{cellId:X8} envId=0x{env.EnvironmentId:X4} struct={env.CellStructure} " + + $"pos=({env.Position.Origin.X:F2},{env.Position.Origin.Y:F2},{env.Position.Origin.Z:F2}) ==="); + _out.WriteLine($" CellPortals -> [{string.Join(",", portals)}] VisibleCells={env.VisibleCells?.Count ?? 0}"); + + if (cs is null) { _out.WriteLine(" CellStruct: NULL"); continue; } + + int renderPolys = cs.Polygons?.Count ?? 0; + int physPolys = cs.PhysicsPolygons?.Count ?? 0; + bool physBsp = cs.PhysicsBSP?.Root is not null; + bool cellBsp = cs.CellBSP?.Root is not null; + _out.WriteLine($" renderPolys={renderPolys} physicsPolys={physPolys} physicsBSP={(physBsp ? "YES" : "NO")} cellBSP={(cellBsp ? "YES" : "NO")}"); + + // Render-shell normal coverage: bucket each render poly's local normal by + // dominant axis to see whether the shell encloses (has +/-X,+/-Y,+/-Z faces). + if (cs.Polygons is not null && cs.VertexArray?.Vertices is not null) + { + var buckets = new Dictionary(); + foreach (var poly in cs.Polygons.Values) + { + var n = PolyNormal(poly, cs.VertexArray); + if (n is null) continue; + buckets.TryGetValue(DomAxis(n.Value), out int c); + buckets[DomAxis(n.Value)] = c + 1; + } + _out.WriteLine(" render-shell normal buckets: " + + string.Join(" ", buckets.OrderBy(k => k.Key).Select(k => $"{k.Key}={k.Value}"))); + } + } + } + + /// + /// #186 root-cause probe (report-only): for every portal of the three connector + /// cells, reproduce acdream's RENDER side test (centroid-derived InsideSide, + /// GameWindow.cs:7425-7438 + PortalVisibilityBuilder.cs:857-864) and compare it to + /// the dat PortalSide bit that retail's PView::InitCell (0x005a4b70) and + /// acdream's own PHYSICS path (CellTransit.cs:190) use. Evaluates each at the live + /// retail/acdream grey-pose eye. The retail cdb trace proved retail ADMITS 0118->0116 + /// at this eye; acdream CULLs it. This dump shows whether the centroid InsideSide + /// disagrees with the dat PortalSide for 0118->0116 (the fix) and AGREES elsewhere + /// (so the fix is surgical, not a global side-test change). + /// + [Fact] + public void PortalSide_CentroidVsDatBit_AtGreyEye() + { + var datDir = DatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + // Live grey-pose eye (fresh HEAD capture + retail cdb trace both ~here). + var eyeWorld = new Vector3(135.51f, 83.32f, 69.16f); + + var disagreements = new List(); // portals where centroid != dat bit + bool sawConnectorBackPortal = false; // the 0118->0116 case + bool connectorCentroidCulls = false, connectorDatAdmits = false; + + foreach (uint cellId in new[] { 0xF6820116u, 0xF6820117u, 0xF6820118u }) + { + var env = dats.Get(cellId); + if (env is null) { _out.WriteLine($"cell 0x{cellId:X8}: EnvCell NOT FOUND"); continue; } + var environment = dats.Get(0x0D000000u | env.EnvironmentId); + if (environment is null || !environment.Cells.TryGetValue(env.CellStructure, out var cs) || cs is null) + { _out.WriteLine($"cell 0x{cellId:X8}: no CellStruct"); continue; } + + var origin = new Vector3(env.Position.Origin.X, env.Position.Origin.Y, env.Position.Origin.Z); + var orient = new Quaternion(env.Position.Orientation.X, env.Position.Orientation.Y, + env.Position.Orientation.Z, env.Position.Orientation.W); + var world = Matrix4x4.CreateFromQuaternion(orient) * Matrix4x4.CreateTranslation(origin); + Matrix4x4.Invert(world, out var inverse); + var localEye = Vector3.Transform(eyeWorld, inverse); + + // Centroid = AABB center over ALL cell verts (GameWindow.cs:7373-7394). + var bmin = new Vector3(float.MaxValue); var bmax = new Vector3(float.MinValue); + foreach (var kv in cs.VertexArray!.Vertices) + { var p = new Vector3(kv.Value.Origin.X, kv.Value.Origin.Y, kv.Value.Origin.Z); + bmin = Vector3.Min(bmin, p); bmax = Vector3.Max(bmax, p); } + var centroid = (bmin + bmax) * 0.5f; + + _out.WriteLine($"=== cell 0x{cellId:X8} localEye=({localEye.X:F2},{localEye.Y:F2},{localEye.Z:F2}) ==="); + foreach (var portal in env.CellPortals!) + { + if (!cs.Polygons!.TryGetValue(portal.PolygonId, out var poly) || poly.VertexIds is null || poly.VertexIds.Count < 3) + { _out.WriteLine($" p->0x{portal.OtherCellId:X4}: no poly"); continue; } + Vector3 V(int k) { var v = cs.VertexArray.Vertices[(ushort)poly.VertexIds[k]]; return new Vector3(v.Origin.X, v.Origin.Y, v.Origin.Z); } + var p0 = V(0); var p1 = V(1); var p2 = V(2); + var normal = Vector3.Normalize(Vector3.Cross(p1 - p0, p2 - p0)); + float d = -Vector3.Dot(normal, p0); + + float centroidDot = Vector3.Dot(normal, centroid) + d; + int centroidInside = centroidDot >= 0 ? 0 : 1; + + ushort flags = (ushort)portal.Flags; + bool portalSide = (flags & 0x2) == 0; // PortalInfo.cs:44 / CellPortal.cs:24 + int datInside = portalSide ? 1 : 0; // mapping derived from retail InitCell + physics CellTransit + + float eyeDot = Vector3.Dot(normal, localEye) + d; + const float eps = 0.01f; + bool admitCentroid = centroidInside == 0 ? eyeDot >= -eps : eyeDot <= eps; + bool admitDat = datInside == 0 ? eyeDot >= -eps : eyeDot <= eps; + + if (centroidInside != datInside) + disagreements.Add($"0x{cellId & 0xFFFF:X4}->0x{portal.OtherCellId:X4}"); + if (cellId == 0xF6820118u && portal.OtherCellId == 0x0116) + { + sawConnectorBackPortal = true; + connectorCentroidCulls = !admitCentroid; + connectorDatAdmits = admitDat; + } + + string flag = centroidInside != datInside ? " <<< DISAGREE" : ""; + string verdict = admitCentroid != admitDat ? $" centroid={(admitCentroid ? "ADMIT" : "CULL")} dat={(admitDat ? "ADMIT" : "CULL")}" : ""; + _out.WriteLine($" p->0x{portal.OtherCellId:X4} flags=0x{flags:X2} PortalSide={portalSide,-5} " + + $"centroidInside={centroidInside} datInside={datInside} eyeDot={eyeDot,7:F3} " + + $"admit[centroid={admitCentroid,-5} dat={admitDat,-5}]{flag}{verdict}"); + } + } + + // Root cause + fix pins (the retail cdb trace is the oracle: retail draws 0116 + // from the 0118 root at this eye; acdream's centroid rule culled it → grey). + Assert.True(sawConnectorBackPortal, "0xF6820118->0116 portal not found in the dat"); + Assert.True(connectorCentroidCulls, "the OLD centroid rule should CULL 0118->0116 at the grey eye (the bug)"); + Assert.True(connectorDatAdmits, "the dat PortalSide bit should ADMIT 0118->0116 at the grey eye (the fix, matches retail)"); + // Surgical: the ONLY portal across these three cells where the centroid rule + // disagrees with the dat bit is the one #186 breaks. If this list ever grows, + // the centroid→dat-bit switch is no longer a no-op for the working portals. + Assert.Equal(new[] { "0x0118->0x0116" }, disagreements.ToArray()); + } + + private static Vector3? PolyNormal(DatReaderWriter.Types.Polygon poly, DatReaderWriter.Types.VertexArray va) + { + if (poly.VertexIds is null || poly.VertexIds.Count < 3) return null; + if (!va.Vertices.TryGetValue((ushort)poly.VertexIds[0], out var a)) return null; + if (!va.Vertices.TryGetValue((ushort)poly.VertexIds[1], out var b)) return null; + if (!va.Vertices.TryGetValue((ushort)poly.VertexIds[2], out var c)) return null; + var n = Vector3.Cross( + new Vector3(b.Origin.X, b.Origin.Y, b.Origin.Z) - new Vector3(a.Origin.X, a.Origin.Y, a.Origin.Z), + new Vector3(c.Origin.X, c.Origin.Y, c.Origin.Z) - new Vector3(a.Origin.X, a.Origin.Y, a.Origin.Z)); + return n.LengthSquared() < 1e-9f ? (Vector3?)null : Vector3.Normalize(n); + } + + private static string DomAxis(Vector3 n) + { + float ax = MathF.Abs(n.X), ay = MathF.Abs(n.Y), az = MathF.Abs(n.Z); + if (ax >= ay && ax >= az) return n.X >= 0 ? "+X" : "-X"; + if (ay >= ax && ay >= az) return n.Y >= 0 ? "+Y" : "-Y"; + return n.Z >= 0 ? "+Z" : "-Z"; + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Issue188FadingDoorMotionTableInspectionTests.cs b/tests/AcDream.Core.Tests/Physics/Issue188FadingDoorMotionTableInspectionTests.cs new file mode 100644 index 00000000..289c97c4 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Issue188FadingDoorMotionTableInspectionTests.cs @@ -0,0 +1,168 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Reflection; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; +using DatReaderWriter.Types; +using Xunit; +using Xunit.Abstractions; +using Env = System.Environment; + +namespace AcDream.Core.Tests.Physics; + +/// +/// #188 root-cause evidence (report-only): decode the REAL dat MotionTable +/// for the "Pedestal Weak Spot" fading-wall entity identified live +/// (guid 0x7C95B03B, MotionTableId 0x090000F9, Setup 0x02000D55). CONFIRMED: +/// its open cycle carries EtherealHook + TransparentPartHook + SoundTableHook +/// — a translucency-fade effect, not part-transform motion — and acdream has +/// no registered that consumes Transparent/ +/// NoDraw/Ethereal/ReplaceObject/Scale hooks (only Particle/Lighting/Audio are +/// wired). Kept as a reusable decoder for any future "why doesn't this +/// animate" question — swap the MotionTableId. +/// +public class Issue188FadingDoorMotionTableInspectionTests +{ + private readonly ITestOutputHelper _out; + public Issue188FadingDoorMotionTableInspectionTests(ITestOutputHelper output) => _out = output; + + private static string? DatDir() + { + var d = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), "Documents", "Asheron's Call"); + return Directory.Exists(d) ? d : null; + } + + [Fact] + public void Reflect_DatReaderWriter_HookTypes() + { + // Dump the DatReaderWriter assembly's hook-related type shapes so the + // real data-walk test below uses correct field names (no guessing). + var asm = typeof(MotionTable).Assembly; + _out.WriteLine($"assembly: {asm.FullName}"); + + foreach (var t in asm.GetTypes().Where(t => t.Name.Contains("Hook", StringComparison.OrdinalIgnoreCase))) + { + _out.WriteLine($"=== type {t.FullName} (base={t.BaseType?.Name}) ==="); + foreach (var p in t.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)) + _out.WriteLine($" [prop] {p.PropertyType.Name} {p.Name}"); + foreach (var f in t.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)) + _out.WriteLine($" [field] {f.FieldType.Name} {f.Name}"); + } + + void DumpMembers(Type t, string label) + { + _out.WriteLine($"=== {label} ({t.FullName}) ==="); + foreach (var p in t.GetProperties(BindingFlags.Public | BindingFlags.Instance)) + _out.WriteLine($" [prop] {p.PropertyType} {p.Name}"); + foreach (var f in t.GetFields(BindingFlags.Public | BindingFlags.Instance)) + _out.WriteLine($" [field] {f.FieldType} {f.Name}"); + } + + DumpMembers(typeof(MotionData), "MotionData"); + DumpMembers(asm.GetTypes().First(t => t.Name == "AnimData"), "AnimData"); + DumpMembers(typeof(Animation), "Animation"); + var frameType = asm.GetTypes().FirstOrDefault(t => t.Name is "AnimationFrame" or "AnimFrame"); + if (frameType is not null) DumpMembers(frameType, frameType.Name); + var qdiType = asm.GetTypes().FirstOrDefault(t => t.Name.StartsWith("QualifiedDataId")); + if (qdiType is not null) DumpMembers(qdiType, qdiType.Name); + } + + [Fact] + public void Dump_PedestalWeakSpot_MotionTable_HookContents() + { + var datDir = DatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + const uint MotionTableId = 0x090000F9u; // live-captured from the Pedestal Weak Spot entity + var mtable = dats.Get(MotionTableId); + if (mtable is null) { _out.WriteLine($"MotionTable 0x{MotionTableId:X8} NOT FOUND"); return; } + + _out.WriteLine($"MotionTable 0x{MotionTableId:X8}: DefaultStyle=0x{(uint)mtable.DefaultStyle:X8}"); + + var allMotionData = new List<(string source, MotionData md)>(); + foreach (var kv in mtable.Cycles) allMotionData.Add(($"Cycles[{kv.Key:X}]", kv.Value)); + foreach (var kv in mtable.Modifiers) allMotionData.Add(($"Modifiers[{kv.Key:X}]", kv.Value)); + foreach (var linkKv in mtable.Links) + foreach (var innerKv in linkKv.Value.MotionData) + allMotionData.Add(($"Links[{linkKv.Key:X}][{innerKv.Key:X}]", innerKv.Value)); + + _out.WriteLine($"total MotionData entries: {allMotionData.Count}"); + + var animIdsSeen = new HashSet(); + var hookTypesSeen = new SortedSet(); + + foreach (var (source, md) in allMotionData) + { + if (md?.Anims is null) continue; + foreach (var animData in md.Anims) + { + uint animId = GetAnimId(animData); + if (animId == 0 || !animIdsSeen.Add(animId)) continue; + + var anim = dats.Get(animId); + if (anim is null) { _out.WriteLine($" [{source}] anim 0x{animId:X8} NOT FOUND"); continue; } + + int frameCount = 0, hookCount = 0; + int frameIdx = 0; + foreach (var frame in GetFrames(anim)) + { + frameCount++; + foreach (var hook in GetHooks(frame)) + { + hookCount++; + hookTypesSeen.Add(hook.GetType().Name); + // Dump every field's actual VALUE for this specific hook instance + // (not just the type) -- what alpha/duration retail authored. + var fieldDump = string.Join(" ", hook.GetType() + .GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) + .Select(f => $"{f.Name}={f.GetValue(hook)}")); + _out.WriteLine($" frame[{frameIdx}] {hook.GetType().Name}: {fieldDump}"); + } + frameIdx++; + } + _out.WriteLine($" [{source}] anim 0x{animId:X8}: frames={frameCount} hooks={hookCount}"); + } + } + + _out.WriteLine($"=== DISTINCT HOOK TYPES ACROSS ENTIRE TABLE: {(hookTypesSeen.Count == 0 ? "(none)" : string.Join(", ", hookTypesSeen))} ==="); + } + + private static object? GetMember(object obj, string name) + { + var t = obj.GetType(); + var prop = t.GetProperty(name, BindingFlags.Public | BindingFlags.Instance); + if (prop is not null) return prop.GetValue(obj); + var field = t.GetField(name, BindingFlags.Public | BindingFlags.Instance); + return field?.GetValue(obj); + } + + private static uint GetAnimId(object animData) + { + var val = GetMember(animData, "AnimId") ?? GetMember(animData, "Id"); + if (val is null) return 0; + var dataId = GetMember(val, "DataId") ?? GetMember(val, "Id"); + return dataId switch { uint u => u, int i => (uint)i, ulong ul => (uint)ul, _ => 0 }; + } + + private static IEnumerable GetFrames(Animation anim) + { + var frames = (GetMember(anim, "PartFrames") ?? GetMember(anim, "Frames")) as IEnumerable; + if (frames is null) yield break; + foreach (var f in frames) + if (f is not null) yield return f; + } + + private static IEnumerable GetHooks(object frame) + { + var hooks = GetMember(frame, "Hooks") as IEnumerable; + if (hooks is null) yield break; + foreach (var h in hooks) + if (h is not null) yield return h; + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/AnimSequenceNodeTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/AnimSequenceNodeTests.cs new file mode 100644 index 00000000..2452d153 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/AnimSequenceNodeTests.cs @@ -0,0 +1,209 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R1-P1 — verbatim AnimSequenceNode (Phase R plan, gap-map items +/// G1/G2/G16/G18). Oracle: r1-csequence-decomp.md §25-28 (ctors 0x00525d30 / +/// 0x00525f90, set_animation_id 0x00525d60, get_starting_frame 0x00525c80, +/// get_ending_frame 0x00525cb0, multiply_framerate 0x00525be0, get_pos_frame +/// 0x005247b0 / 0x00525c10). +/// +/// KEY RETAIL SEMANTICS UNDER TEST: +/// - boundary pair is DIRECTION-AWARE and returns BARE INTS with NO epsilon +/// (ACE's epsilon subtraction is an ACE fabrication — P0-pins.md); +/// - multiply_framerate SWAPS low/high on a negative factor; +/// - set_animation_id clamps in a fixed order (high<0 → num−1; +/// low≥num → num−1; high≥num → num−1; low>high → high=low). +/// +public class AnimSequenceNodeTests +{ + private sealed class FakeLoader : IAnimationLoader + { + private readonly Animation? _anim; + public FakeLoader(Animation? anim) => _anim = anim; + public Animation? LoadAnimation(uint id) => _anim; + } + + private static Animation MakeAnim(int numFrames, bool posFrames = false) + { + var anim = new Animation(); + for (int f = 0; f < numFrames; f++) + { + var pf = new AnimationFrame(1u); + pf.Frames.Add(new Frame { Origin = new Vector3(f, 0, 0), Orientation = Quaternion.Identity }); + anim.PartFrames.Add(pf); + if (posFrames) + anim.PosFrames.Add(new Frame { Origin = new Vector3(0, f, 0), Orientation = Quaternion.Identity }); + } + return anim; + } + + [Fact] + public void DefaultCtor_RetailDefaults() + { + // 0x00525d30: framerate=30f, low=-1, high=-1, anim=null. + var n = new AnimSequenceNode(); + Assert.Equal(30f, n.Framerate); + Assert.Equal(-1, n.LowFrame); + Assert.Equal(-1, n.HighFrame); + Assert.False(n.HasAnim); + } + + [Fact] + public void SetAnimationId_Zero_LeavesAnimNullAndFramesUnclamped() + { + // 0x00525d60: arg2==0 → anim=null; the clamp block is gated on + // anim != null, so low/high stay at their raw values. + var n = new AnimSequenceNode(); + n.SetAnimationId(0, new FakeLoader(MakeAnim(10))); + Assert.False(n.HasAnim); + Assert.Equal(-1, n.LowFrame); + Assert.Equal(-1, n.HighFrame); + } + + [Theory] + // low, high (pre-clamp), numFrames, expectedLow, expectedHigh + [InlineData(0, -1, 10, 0, 9)] // high<0 → num-1 ("play to end") + [InlineData(12, -1, 10, 9, 9)] // high<0 first, then low>=num → num-1 + [InlineData(3, 15, 10, 3, 9)] // high>=num → num-1 + [InlineData(15, 15, 10, 9, 9)] // both clamp to num-1 + [InlineData(5, 2, 10, 5, 5)] // low>high after clamps → high=low + [InlineData(2, 7, 10, 2, 7)] // in-range untouched + public void SetAnimationId_ClampOrder(int low, int high, int numFrames, int expLow, int expHigh) + { + var n = new AnimSequenceNode { LowFrame = low, HighFrame = high }; + n.SetAnimationId(0x0300ABCDu, new FakeLoader(MakeAnim(numFrames))); + Assert.True(n.HasAnim); + Assert.Equal(expLow, n.LowFrame); + Assert.Equal(expHigh, n.HighFrame); + } + + [Theory] + // framerate, low, high, expectedStart, expectedEnd — BARE INTS, no epsilon + [InlineData(30f, 2, 7, 2, 8)] // forward: start=low, end=high+1 + [InlineData(-30f, 2, 7, 8, 2)] // reverse: start=high+1, end=low + [InlineData(0f, 2, 7, 2, 8)] // zero framerate is NOT < 0 → forward + [InlineData(30f, 0, 0, 0, 1)] // single-frame forward + [InlineData(-30f, 0, 0, 1, 0)] // single-frame reverse + public void BoundaryPair_DirectionAware_BareInts( + float framerate, int low, int high, int expStart, int expEnd) + { + var n = new AnimSequenceNode { Framerate = framerate, LowFrame = low, HighFrame = high }; + Assert.Equal(expStart, n.GetStartingFrame()); + Assert.Equal(expEnd, n.GetEndingFrame()); + } + + [Fact] + public void MultiplyFramerate_Positive_NoSwap() + { + var n = new AnimSequenceNode { Framerate = 30f, LowFrame = 2, HighFrame = 7 }; + n.MultiplyFramerate(2f); + Assert.Equal(60f, n.Framerate); + Assert.Equal(2, n.LowFrame); + Assert.Equal(7, n.HighFrame); + } + + [Fact] + public void MultiplyFramerate_Negative_SwapsLowHigh() + { + // 0x00525be0: factor < 0 → swap(low_frame, high_frame), then + // framerate *= factor. Coupled with the direction-aware boundary + // pair (framerate now negative reads the swapped fields). + var n = new AnimSequenceNode { Framerate = 30f, LowFrame = 2, HighFrame = 7 }; + n.MultiplyFramerate(-1f); + Assert.Equal(-30f, n.Framerate); + Assert.Equal(7, n.LowFrame); + Assert.Equal(2, n.HighFrame); + // Reverse playback boundaries against the SWAPPED fields: + // start = high_frame(2)+1 = 3?? — no: framerate<0 → start = high+1 + // where high_frame is now 2 → 3; end = low_frame = 7. + Assert.Equal(3, n.GetStartingFrame()); + Assert.Equal(7, n.GetEndingFrame()); + } + + [Fact] + public void MultiplyFramerate_DoubleNegative_RoundTrips() + { + var n = new AnimSequenceNode { Framerate = 30f, LowFrame = 2, HighFrame = 7 }; + n.MultiplyFramerate(-1f); + n.MultiplyFramerate(-1f); + Assert.Equal(30f, n.Framerate); + Assert.Equal(2, n.LowFrame); + Assert.Equal(7, n.HighFrame); + } + + [Fact] + public void GetPosFrame_NullAnim_ReturnsNull() + { + var n = new AnimSequenceNode(); + Assert.Null(n.GetPosFrame(0)); + } + + [Fact] + public void GetPosFrame_OutOfRange_ReturnsNull() + { + // 0x00525c10: retail returns NULL out of range (ACE returns identity + // — an ACE-ism, gap G18: port the null). + var n = new AnimSequenceNode(); + n.SetAnimationId(1, new FakeLoader(MakeAnim(3, posFrames: true))); + Assert.Null(n.GetPosFrame(-1)); + Assert.Null(n.GetPosFrame(3)); + Assert.NotNull(n.GetPosFrame(2)); + } + + [Fact] + public void GetPosFrame_DoubleOverload_Floors() + { + // 0x005247b0: floor(double) → int overload. + var n = new AnimSequenceNode(); + n.SetAnimationId(1, new FakeLoader(MakeAnim(3, posFrames: true))); + var f = n.GetPosFrame(1.99); + Assert.NotNull(f); + Assert.Equal(1f, f!.Origin.Y); // frame index 1, not 2 + } + + [Fact] + public void GetPosFrame_AnimWithoutPosFrames_ReturnsNull() + { + var n = new AnimSequenceNode(); + n.SetAnimationId(1, new FakeLoader(MakeAnim(3, posFrames: false))); + Assert.Null(n.GetPosFrame(0)); + } + + [Fact] + public void GetPartFrame_BoundsAndValue() + { + var n = new AnimSequenceNode(); + n.SetAnimationId(1, new FakeLoader(MakeAnim(3))); + Assert.Null(n.GetPartFrame(-1)); + Assert.Null(n.GetPartFrame(3)); + var pf = n.GetPartFrame(2); + Assert.NotNull(pf); + Assert.Equal(2f, pf!.Frames[0].Origin.X); + } + + [Fact] + public void CtorFromAnimData_CopiesThenClamps() + { + // 0x00525f90: copies framerate/low/high from AnimData then runs + // set_animation_id (which clamps against the resolved anim). + QualifiedDataId qid = 0x03001234u; + var ad = new AnimData + { + AnimId = qid, + LowFrame = 0, + HighFrame = -1, + Framerate = 15f, + }; + var n = new AnimSequenceNode(ad, new FakeLoader(MakeAnim(5))); + Assert.Equal(15f, n.Framerate); + Assert.Equal(0, n.LowFrame); + Assert.Equal(4, n.HighFrame); // -1 sentinel clamped to num-1 + Assert.True(n.HasAnim); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/CMotionTableTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/CMotionTableTests.cs new file mode 100644 index 00000000..e123e3a1 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/CMotionTableTests.cs @@ -0,0 +1,1045 @@ +using System.Linq; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Enums; +using DatReaderWriter.Types; + +using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand; + +namespace AcDream.Core.Tests.Physics.Motion; + +// ───────────────────────────────────────────────────────────────────────────── +// CMotionTableTests — R2-Q2 conformance harness for the verbatim +// CMotionTable::GetObjectSequence dispatcher (r2-port-plan.md §3 Q2). +// +// Every test is labeled with the gap id(s) it pins per the plan's REQUIRED +// case list. Fixture convention matches AnimationSequencerTests.cs's +// Fixtures class (file-local, replicated here per the task's instruction to +// keep this file self-contained). +// +// Command-word constants below are real DatReaderWriter.Enums.MotionCommand +// values (verified via reflection against Chorizite.DatReaderWriter 2.1.7, +// 2026-07-02) — NOT synthetic bit patterns — so the class-bit dispatch +// (cycle/modifier/action/style) exercises the same bit layout retail ships: +// Ready = 0x41000003 (cycle) +// WalkForward = 0x45000005 (cycle) +// RunForward = 0x44000007 (cycle) +// TurnRight = 0x6500000D (cycle AND modifier — both bits set; +// the AP-73 run-while-turning mechanism test +// depends on this real dual-class shape) +// Jump = 0x2500003B (modifier only) +// ThrustMed = 0x10000058 (action only) +// HandCombat = 0x8000003C (style; top bit set) +// NonCombat = 0x8000003D (style) +// ───────────────────────────────────────────────────────────────────────────── + +file static class Fixtures +{ + public static Animation MakeAnim(int numFrames, int numParts, Vector3 origin, Quaternion orientation) + { + var anim = new Animation(); + for (int f = 0; f < numFrames; f++) + { + var pf = new AnimationFrame((uint)numParts); + for (int p = 0; p < numParts; p++) + pf.Frames.Add(new Frame { Origin = origin, Orientation = orientation }); + anim.PartFrames.Add(pf); + } + return anim; + } + + public static AnimData MakeAnimData(uint animId, float framerate) + => new() + { + AnimId = (QualifiedDataId)animId, + LowFrame = 0, + HighFrame = -1, + Framerate = framerate, + }; + + public static MotionData MakeMotionData(uint animId, float framerate, byte bitfield = 0, + Vector3? velocity = null, Vector3? omega = null) + { + var md = new MotionData { Bitfield = bitfield }; + md.Anims.Add(MakeAnimData(animId, framerate)); + if (velocity is { } v) + { + md.Velocity = v; + md.Flags |= MotionDataFlags.HasVelocity; + } + if (omega is { } w) + { + md.Omega = w; + md.Flags |= MotionDataFlags.HasOmega; + } + return md; + } + + /// MotionData with N AnimData entries (for outTicks sum tests, A3). + public static MotionData MakeMultiAnimMotionData(uint firstAnimId, int count, float framerate) + { + var md = new MotionData(); + for (int i = 0; i < count; i++) + md.Anims.Add(MakeAnimData(firstAnimId + (uint)i, framerate)); + return md; + } + + public static void AddLink(MotionTable mt, uint style, uint fromSubstate, uint toSubstate, MotionData data) + { + int outerKey = (int)((style << 16) | (fromSubstate & 0xFFFFFFu)); + if (!mt.Links.TryGetValue(outerKey, out var cmd)) + { + cmd = new MotionCommandData(); + mt.Links[outerKey] = cmd; + } + cmd.MotionData[(int)toSubstate] = data; + } + + public static void AddCycle(MotionTable mt, uint style, uint substate, MotionData data) + { + int key = (int)((style << 16) | (substate & 0xFFFFFFu)); + mt.Cycles[key] = data; + } + + public static void AddModifier(MotionTable mt, uint style, uint modifier, MotionData data, bool styleSpecific = true) + { + int key = styleSpecific ? (int)((style << 16) | (modifier & 0xFFFFFFu)) : (int)(modifier & 0xFFFFFFu); + mt.Modifiers[key] = data; + } +} + +public sealed class CMotionTableTests +{ + // Real retail command words (DatReaderWriter.Enums.MotionCommand). + private const uint Ready = 0x41000003u; + private const uint WalkForward = 0x45000005u; + private const uint RunForward = 0x44000007u; + private const uint TurnRight = 0x6500000Du; // cycle AND modifier class + private const uint Jump = 0x2500003Bu; // modifier only + private const uint ThrustMed = 0x10000058u; // action only + + private const uint HandCombatStyle = 0x8000003Cu; // style, top bit set + private const uint NonCombatStyle = 0x8000003Du; // style, top bit set + + // ── Ready→Walk link+cycle chain shape (H1, base dispatcher) ──────── + + [Fact] + public void GetObjectSequence_ReadyToWalk_BuildsLinkThenCycleChain() + { + var loader = new FakeLoader(); + uint readyAnim = 0x03000001u, walkAnim = 0x03000002u, linkAnim = 0x03000003u; + loader.Register(readyAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(walkAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(linkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + + var readyCycle = Fixtures.MakeMotionData(readyAnim, 30f); + Fixtures.AddCycle(mt, NonCombatStyle, Ready, readyCycle); + + var walkCycle = Fixtures.MakeMotionData(walkAnim, 30f); + Fixtures.AddCycle(mt, NonCombatStyle, WalkForward, walkCycle); + + var link = Fixtures.MakeMotionData(linkAnim, 30f); + Fixtures.AddLink(mt, NonCombatStyle, Ready, WalkForward, link); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(loader); + + bool ok = cmt.GetObjectSequence(WalkForward, state, seq, 1f, out uint outTicks, stopCall: false); + + Assert.True(ok); + Assert.Equal(WalkForward, state.Substate); + Assert.Equal(NonCombatStyle, state.Style); + Assert.Equal(1f, state.SubstateMod); + // list shape: link then cycle (2 nodes total). + Assert.Equal(2, seq.Count); + // A3: outTicks = link.num_anims + cycle.num_anims - 1 = 1 + 1 - 1 = 1 + Assert.Equal(1u, outTicks); + } + + [Fact] + public void GetObjectSequence_ReadyToWalk_FirstCyclicIsTheCycleNotTheLink() + { + var loader = new FakeLoader(); + uint linkAnim = 0x03000010u, cycleAnim = 0x03000011u; + loader.Register(linkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(cycleAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, Ready, Fixtures.MakeMotionData(0x03000012u, 30f)); + Fixtures.AddCycle(mt, NonCombatStyle, WalkForward, Fixtures.MakeMotionData(cycleAnim, 30f)); + Fixtures.AddLink(mt, NonCombatStyle, Ready, WalkForward, Fixtures.MakeMotionData(linkAnim, 30f)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(loader); + + Assert.True(cmt.GetObjectSequence(WalkForward, state, seq, 1f, out _, stopCall: false)); + + Assert.NotNull(seq.FirstCyclic); + Assert.NotNull(seq.CurrAnim); + // The cyclic tail is the LAST appended node (append_animation slides + // first_cyclic on every call, R1 G10) — that's the cycle, not the link. + Assert.Equal(2, seq.Count); + } + + // ── walk↔run same-substate re-speed fast path (H8) ───────────────── + + [Fact] + public void GetObjectSequence_SameSubstateSameSignFasterSpeed_TakesReSpeedFastPath_NoListChange() + { + var loader = new FakeLoader(); + uint walkAnim = 0x03000020u; + loader.Register(walkAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + var walkCycle = Fixtures.MakeMotionData(walkAnim, 30f, velocity: new Vector3(0, 3.12f, 0)); + Fixtures.AddCycle(mt, NonCombatStyle, WalkForward, walkCycle); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = WalkForward, SubstateMod = 1f }; + var seq = new CSequence(loader); + + // Seed the sequence as if WalkForward is already playing at speed 1.0. + Assert.True(cmt.DoObjectMotion(WalkForward, state, seq, 1f, out _)); + int countBefore = seq.Count; + var firstCyclicBefore = seq.FirstCyclic; + var velBefore = seq.Velocity; + + // Re-issue WalkForward at speed 2.0 (same substate, same sign). + bool ok = cmt.GetObjectSequence(WalkForward, state, seq, 2f, out uint outTicks, stopCall: false); + + Assert.True(ok); + Assert.Equal(2f, state.SubstateMod); + // NO list change — fast path never calls remove_cyclic_anims/add_motion chain. + Assert.Equal(countBefore, seq.Count); + Assert.Same(firstCyclicBefore, seq.FirstCyclic); + // velocity = subtract-old(1x) + combine-new(2x) => net velocity scales to 2x the base. + Assert.Equal(velBefore * 2f, seq.Velocity); + // outTicks stays 0 on the fast path (retail: *arg6=0 at entry, never reassigned + // before the early `return 1`). + Assert.Equal(0u, outTicks); + } + + [Fact] + public void GetObjectSequence_SameSubstateSameSignFastPath_RescalesFramerates() + { + var loader = new FakeLoader(); + uint walkAnim = 0x03000021u; + loader.Register(walkAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, WalkForward, Fixtures.MakeMotionData(walkAnim, 10f)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = WalkForward, SubstateMod = 1f }; + var seq = new CSequence(loader); + + Assert.True(cmt.DoObjectMotion(WalkForward, state, seq, 1f, out _)); + double frBefore = seq.CurrAnim!.Framerate; + + Assert.True(cmt.GetObjectSequence(WalkForward, state, seq, 2.5f, out _, stopCall: false)); + + double frAfter = seq.CurrAnim!.Framerate; + Assert.Equal(frBefore * 2.5, frAfter, 3); + } + + // ── sign-flip Walk(+)→Walk(-) routes the style-default double-hop (A2) ── + + [Fact] + public void GetObjectSequence_SignFlipSameSubstate_RoutesStyleDefaultDoubleHop() + { + // Walk(+1.0) -> Walk(-1.0): same substate id, OPPOSITE sign. This must + // NOT take the re-speed fast path (same_sign gate fails) and must NOT + // take the direct-link path (no link registered substate->substate); + // it routes via the style-default double-hop: + // hop1: get_link(style, substate, oldSpeed, styleDefaultSubstate, 1f) + // hop2: get_link(style, styleDefaultSubstate, 1f, substate, newSpeed) + var loader = new FakeLoader(); + uint walkAnim = 0x03000030u, hop1Anim = 0x03000031u, hop2Anim = 0x03000032u; + loader.Register(walkAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(hop1Anim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(hop2Anim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, WalkForward, Fixtures.MakeMotionData(walkAnim, 30f)); + // hop1: WalkForward -> Ready (style default), hop2: Ready -> WalkForward + Fixtures.AddLink(mt, NonCombatStyle, WalkForward, Ready, Fixtures.MakeMotionData(hop1Anim, 30f)); + Fixtures.AddLink(mt, NonCombatStyle, Ready, WalkForward, Fixtures.MakeMotionData(hop2Anim, 30f)); + + var cmt = new CMotionTable(mt); + // Seed state DIRECTLY (bypassing GetObjectSequence) so state.Substate + // starts at WalkForward WITHOUT the seeding call itself tripping the + // WalkForward->WalkForward double-hop routing this fixture's own + // links would otherwise trigger (both hop links target/originate at + // WalkForward, which would also satisfy a same-substate rebuild). + var state = new MotionState { Style = NonCombatStyle, Substate = WalkForward, SubstateMod = 1f }; + var seq = new CSequence(loader); + CMotionTable.AddMotion(seq, Fixtures.MakeMotionData(walkAnim, 30f), 1f); + Assert.Equal(1, seq.Count); + + bool ok = cmt.GetObjectSequence(WalkForward, state, seq, -1f, out uint outTicks, stopCall: false); + + Assert.True(ok); + Assert.Equal(-1f, state.SubstateMod); + Assert.Equal(WalkForward, state.Substate); + // Rebuild happened (not the fast path): list = hop1(1) + hop2(1) + cycle(1) = 3 nodes. + Assert.Equal(3, seq.Count); + } + + // ── stance change → Branch 1 chain (H14) ──────────────────────────── + + [Fact] + public void GetObjectSequence_StyleChange_BuildsExitLinkPlusStyleLinkPlusNewCycle() + { + var loader = new FakeLoader(); + uint exitAnim = 0x03000040u, styleLinkAnim = 0x03000041u, newCycleAnim = 0x03000042u; + loader.Register(exitAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(styleLinkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(newCycleAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + mt.StyleDefaults[(DRWMotionCommand)HandCombatStyle] = (DRWMotionCommand)Ready; + + // Current: NonCombat, playing WalkForward (NOT the style default). + Fixtures.AddCycle(mt, NonCombatStyle, WalkForward, Fixtures.MakeMotionData(0x03000043u, 30f)); + // exit-link: WalkForward -> NonCombat's default (Ready) + Fixtures.AddLink(mt, NonCombatStyle, WalkForward, Ready, Fixtures.MakeMotionData(exitAnim, 30f)); + // style-to-style link: NonCombat's default (Ready) -> HandCombat's default (Ready) + Fixtures.AddLink(mt, NonCombatStyle, Ready, HandCombatStyle, Fixtures.MakeMotionData(styleLinkAnim, 30f)); + // HandCombat's default cycle (Ready) + Fixtures.AddCycle(mt, HandCombatStyle, Ready, Fixtures.MakeMotionData(newCycleAnim, 30f)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = WalkForward, SubstateMod = 1f }; + var seq = new CSequence(loader); + + Assert.True(cmt.DoObjectMotion(WalkForward, state, seq, 1f, out _)); + + bool ok = cmt.GetObjectSequence(HandCombatStyle, state, seq, 1f, out uint outTicks, stopCall: false); + + Assert.True(ok); + Assert.Equal(HandCombatStyle, state.Style); + Assert.Equal(Ready, state.Substate); // committed to the TARGET style's default substate + // exit-link(1) + style-link(1) + new cycle(1) = 3 nodes + Assert.Equal(3, seq.Count); + } + + [Fact] + public void GetObjectSequence_StyleChange_AlreadyInTargetStyle_IsNoOp() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(new NullLoader()); + + bool ok = cmt.GetObjectSequence(NonCombatStyle, state, seq, 1f, out uint outTicks, stopCall: false); + + Assert.True(ok); + Assert.Equal(0u, outTicks); + Assert.Equal(0, seq.Count); // untouched + } + + // ── emote-while-running Branch 3 out-and-back (A4-#1) ─────────────── + + [Fact] + public void GetObjectSequence_ActionDirectLink_QueuesActionAndReAddsBaseCycle() + { + var loader = new FakeLoader(); + uint cycleAnim = 0x03000050u, actionAnim = 0x03000051u; + loader.Register(cycleAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(actionAnim, Fixtures.MakeAnim(3, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, RunForward, Fixtures.MakeMotionData(cycleAnim, 30f)); + Fixtures.AddLink(mt, NonCombatStyle, RunForward, ThrustMed, Fixtures.MakeMotionData(actionAnim, 30f)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = RunForward, SubstateMod = 1f }; + var seq = new CSequence(loader); + + Assert.True(cmt.DoObjectMotion(RunForward, state, seq, 1f, out _)); + + bool ok = cmt.GetObjectSequence(ThrustMed, state, seq, 1f, out uint outTicks, stopCall: false); + + Assert.True(ok); + // Direct-link action path: action(1) + re-added base cycle(1) = 2 nodes. + Assert.Equal(2, seq.Count); + // Action queued onto the FIFO. + Assert.Single(state.Actions); + Assert.Equal(ThrustMed, state.Actions.First().Motion); + // Base substate is NOT changed by an action (state.Substate stays RunForward). + Assert.Equal(RunForward, state.Substate); + // A3: outTicks = action's num_anims (1) only, direct-link path. + Assert.Equal(1u, outTicks); + } + + [Fact] + public void GetObjectSequence_ActionNoDirectLink_FourLayerOutAndBack_BaseCycleAtOldSubstateMod() + { + var loader = new FakeLoader(); + uint cycleAnim = 0x03000060u, outHopAnim = 0x03000061u, actionAnim = 0x03000062u, returnHopAnim = 0x03000063u; + loader.Register(cycleAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(outHopAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(actionAnim, Fixtures.MakeAnim(3, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(returnHopAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, RunForward, Fixtures.MakeMotionData(cycleAnim, 30f)); + // NO direct RunForward -> ThrustMed link. Route via style default (Ready). + Fixtures.AddLink(mt, NonCombatStyle, RunForward, Ready, Fixtures.MakeMotionData(outHopAnim, 30f)); + Fixtures.AddLink(mt, NonCombatStyle, Ready, ThrustMed, Fixtures.MakeMotionData(actionAnim, 30f)); + Fixtures.AddLink(mt, NonCombatStyle, Ready, RunForward, Fixtures.MakeMotionData(returnHopAnim, 30f)); + + var cmt = new CMotionTable(mt); + // Running at a NON-default speed so we can assert the base cycle is + // re-added at the OLD substate_mod (A4-#1), not the action's speed. + // Seed state DIRECTLY (bypassing GetObjectSequence) — this fixture's + // RunForward<->Ready links would otherwise make a DoObjectMotion(RunForward) + // seeding call itself take the double-hop rebuild path (RunForward + // requested while already at RunForward, no direct self-link, empty + // sequence so no fast-path) and pre-populate 3 nodes before the real + // action call under test even runs. + var state = new MotionState { Style = NonCombatStyle, Substate = RunForward, SubstateMod = 1.5f }; + var seq = new CSequence(loader); + CMotionTable.AddMotion(seq, Fixtures.MakeMotionData(cycleAnim, 30f), 1.5f); + Assert.Equal(1, seq.Count); + + bool ok = cmt.GetObjectSequence(ThrustMed, state, seq, 1f, out uint outTicks, stopCall: false); + + Assert.True(ok); + // outHop(1) + action(1) + returnHop(1) + base cycle(1) = 4 nodes. + Assert.Equal(4, seq.Count); + Assert.Equal(RunForward, state.Substate); // action doesn't change base substate + Assert.Equal(1.5f, state.SubstateMod); // untouched — base cycle re-added at OLD speed + + // Base cycle (the last-appended / cyclic tail node) keeps the OLD + // substate_mod's framerate scale (1.5x of the dat's 30f == 45f). + Assert.NotNull(seq.FirstCyclic); + Assert.Equal(45.0, seq.FirstCyclic!.Framerate, 3); + + // A4-#1: outTicks = outHop.num_anims + action.num_anims + returnHop.num_anims + // (NEVER the base cycle, NEVER double-counted — ACE's bug, not retail's). + Assert.Equal(3u, outTicks); + } + + // ── turn-in-place (Branch 2 cycle) ────────────────────────────────── + + [Fact] + public void GetObjectSequence_TurnInPlace_ResolvesAsCycleFromReady() + { + var loader = new FakeLoader(); + uint readyAnim = 0x03000070u, turnAnim = 0x03000071u, linkAnim = 0x03000072u; + loader.Register(readyAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(turnAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(linkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, Ready, Fixtures.MakeMotionData(readyAnim, 30f)); + // TurnRight is NOT gated (bitfield=0) in this fixture, isolating the + // "resolves as a normal Branch-2 cycle" behavior from is_allowed gating + // (that's the SEPARATE run-while-turning test below). + Fixtures.AddCycle(mt, NonCombatStyle, TurnRight, Fixtures.MakeMotionData(turnAnim, 30f, bitfield: 0)); + Fixtures.AddLink(mt, NonCombatStyle, Ready, TurnRight, Fixtures.MakeMotionData(linkAnim, 30f)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(loader); + + bool ok = cmt.GetObjectSequence(TurnRight, state, seq, 1f, out _, stopCall: false); + + Assert.True(ok); + Assert.Equal(TurnRight, state.Substate); + Assert.Equal(2, seq.Count); // link + cycle + } + + // ── run-while-turning: is_allowed rejects gated turn cycle → Branch 4 ── + // (AP-73 mechanism test, gap H4/H13) + + [Fact] + public void GetObjectSequence_RunWhileTurning_GatedTurnCycleRejected_FallsToModifierPhysicsOnlyCombine() + { + var loader = new FakeLoader(); + uint runAnim = 0x03000080u, turnAnim = 0x03000081u; + loader.Register(runAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(turnAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + + var runVelocity = new Vector3(0, 4.0f, 0); + Fixtures.AddCycle(mt, NonCombatStyle, RunForward, Fixtures.MakeMotionData(runAnim, 30f, velocity: runVelocity)); + + // TurnRight AS A CYCLE is bitfield&2 gated (substate-checked) — + // is_allowed will reject it because current substate (RunForward) != + // TurnRight and != the style default. + Fixtures.AddCycle(mt, NonCombatStyle, TurnRight, Fixtures.MakeMotionData(turnAnim, 30f, bitfield: 2)); + // TurnRight AS A MODIFIER: physics-only turn omega, resolved from the + // Modifiers dict once Branch 2 falls through. + var turnOmega = new Vector3(0, 0, -(MathF.PI / 2f)); + Fixtures.AddModifier(mt, NonCombatStyle, TurnRight, Fixtures.MakeMotionData(0, 0f, omega: turnOmega)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = RunForward, SubstateMod = 1f }; + var seq = new CSequence(loader); + + Assert.True(cmt.DoObjectMotion(RunForward, state, seq, 1f, out _)); + int countBefore = seq.Count; + var cyclicBefore = seq.FirstCyclic; + var currBefore = seq.CurrAnim; + + bool ok = cmt.GetObjectSequence(TurnRight, state, seq, 1f, out _, stopCall: false); + + Assert.True(ok); + // Run anims UNTOUCHED — Branch 4 is physics-only, no add/remove of anim nodes. + Assert.Equal(countBefore, seq.Count); + Assert.Equal(cyclicBefore, seq.FirstCyclic); + Assert.Equal(currBefore, seq.CurrAnim); + // Base substate stays RunForward (a modifier doesn't replace the cycle). + Assert.Equal(RunForward, state.Substate); + // TurnRight now tracked as an active modifier. + Assert.Contains(state.Modifiers, m => m.Motion == TurnRight); + // Physics combined: velocity untouched (turn modifier carries no + // velocity), omega now includes the turn contribution. + Assert.Equal(runVelocity, seq.Velocity); + Assert.Equal(turnOmega, seq.Omega); + } + + // ── modifier stop = subtract + unlink ─────────────────────────────── + + [Fact] + public void StopSequenceMotion_Modifier_SubtractsPhysicsAndUnlinksFromModifierChain() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + var jumpOmega = new Vector3(0, 0, 5f); + Fixtures.AddModifier(mt, NonCombatStyle, Jump, Fixtures.MakeMotionData(0, 0f, omega: jumpOmega)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(new NullLoader()); + + // Activate the modifier directly (bypassing GetObjectSequence's gate logic). + state.AddModifierNoCheck(Jump, 1f); + seq.CombinePhysics(Vector3.Zero, jumpOmega); + Assert.Equal(jumpOmega, seq.Omega); + + bool ok = cmt.StopSequenceMotion(Jump, 1f, state, seq, out uint outTicks); + + Assert.True(ok); + Assert.Equal(Vector3.Zero, seq.Omega); // subtracted back out + Assert.DoesNotContain(state.Modifiers, m => m.Motion == Jump); // unlinked + Assert.Equal(0u, outTicks); + } + + [Fact] + public void StopSequenceMotion_UnknownModifier_ReturnsFalse_NoOp() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(new NullLoader()); + + bool ok = cmt.StopSequenceMotion(Jump, 1f, state, seq, out uint outTicks); + + Assert.False(ok); + Assert.Equal(0u, outTicks); + } + + // ── StopObjectCompletely drains modifiers then re-drives to style default (A4-#4) ── + + [Fact] + public void StopObjectCompletely_DrainsAllModifiers_ThenRedrivesToStyleDefault() + { + var loader = new FakeLoader(); + uint runAnim = 0x03000090u, readyAnim = 0x03000091u, exitLinkAnim = 0x03000092u; + loader.Register(runAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(readyAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(exitLinkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, RunForward, Fixtures.MakeMotionData(runAnim, 30f)); + Fixtures.AddCycle(mt, NonCombatStyle, Ready, Fixtures.MakeMotionData(readyAnim, 30f)); + Fixtures.AddLink(mt, NonCombatStyle, RunForward, Ready, Fixtures.MakeMotionData(exitLinkAnim, 30f)); + + var jumpOmega = new Vector3(1, 0, 0); + Fixtures.AddModifier(mt, NonCombatStyle, Jump, Fixtures.MakeMotionData(0, 0f, omega: jumpOmega)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = RunForward, SubstateMod = 1f }; + var seq = new CSequence(loader); + + Assert.True(cmt.DoObjectMotion(RunForward, state, seq, 1f, out _)); + state.AddModifierNoCheck(Jump, 1f); + seq.CombinePhysics(Vector3.Zero, jumpOmega); + + bool ok = cmt.StopObjectCompletely(state, seq, out _); + + Assert.True(ok); + Assert.Empty(state.Modifiers); // drained + Assert.Equal(Ready, state.Substate); // re-driven to style default + // The turn/jump physics contribution is gone (subtracted during drain). + Assert.Equal(Vector3.Zero, seq.Omega); + } + + // ── missing cycle → return false, sequence UNTOUCHED (H5) ─────────── + + [Fact] + public void GetObjectSequence_MissingCycle_ReturnsFalse_SequenceUntouched() + { + var loader = new FakeLoader(); + uint readyAnim = 0x030000A0u; + loader.Register(readyAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, Ready, Fixtures.MakeMotionData(readyAnim, 30f)); + // Deliberately NO RunForward cycle anywhere (not under NonCombatStyle, + // not under DefaultStyle) — the default_style retry also misses. + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(loader); + + Assert.True(cmt.DoObjectMotion(Ready, state, seq, 1f, out _)); + int countBefore = seq.Count; + var velBefore = seq.Velocity; + var omegaBefore = seq.Omega; + uint substateBefore = state.Substate; + + bool ok = cmt.GetObjectSequence(RunForward, state, seq, 1f, out uint outTicks, stopCall: false); + + Assert.False(ok); + Assert.Equal(0u, outTicks); + Assert.Equal(countBefore, seq.Count); // list untouched + Assert.Equal(velBefore, seq.Velocity); + Assert.Equal(omegaBefore, seq.Omega); + Assert.Equal(substateBefore, state.Substate); // state untouched + } + + // ── entry guards ───────────────────────────────────────────────────── + + [Fact] + public void GetObjectSequence_ZeroStyle_ReturnsFalse() + { + var mt = new MotionTable(); + var cmt = new CMotionTable(mt); + var state = new MotionState(); // Style=0, Substate=0 (default ctor) + var seq = new CSequence(new NullLoader()); + + bool ok = cmt.GetObjectSequence(WalkForward, state, seq, 1f, out uint outTicks, stopCall: false); + + Assert.False(ok); + Assert.Equal(0u, outTicks); + } + + [Fact] + public void GetObjectSequence_ZeroSubstate_ReturnsFalse() + { + var mt = new MotionTable(); + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = 0 }; + var seq = new CSequence(new NullLoader()); + + bool ok = cmt.GetObjectSequence(WalkForward, state, seq, 1f, out uint outTicks, stopCall: false); + + Assert.False(ok); + Assert.Equal(0u, outTicks); + } + + // ── modifier-class no-op fast path ────────────────────────────────── + + [Fact] + public void GetObjectSequence_ModifierClassTargetEqualsStyleDefault_NotStopCall_IsNoOp() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Jump; // contrived: style default == Jump (modifier-class id) + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Jump, SubstateMod = 1f }; + var seq = new CSequence(new NullLoader()); + + bool ok = cmt.GetObjectSequence(Jump, state, seq, 1f, out uint outTicks, stopCall: false); + + Assert.True(ok); + Assert.Equal(0u, outTicks); + Assert.Equal(0, seq.Count); // no-op, nothing built + } + + // ── re_modify replays the modifier stack after a substate change ──── + + [Fact] + public void ReModify_ReplaysActiveModifiers_ThroughGetObjectSequence() + { + var loader = new FakeLoader(); + uint runAnim = 0x030000B0u; + loader.Register(runAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, RunForward, Fixtures.MakeMotionData(runAnim, 30f)); + var jumpOmega = new Vector3(0, 0, 9f); + Fixtures.AddModifier(mt, NonCombatStyle, Jump, Fixtures.MakeMotionData(0, 0f, omega: jumpOmega)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = RunForward, SubstateMod = 1f }; + var seq = new CSequence(loader); + + Assert.True(cmt.DoObjectMotion(RunForward, state, seq, 1f, out _)); + + // Active modifier BEFORE the transition that calls re_modify. + state.AddModifierNoCheck(Jump, 1f); + seq.ClearPhysics(); // simulate a fresh rebuild wiping physics + + cmt.ReModify(seq, state); + + // re_modify replayed Jump through GetObjectSequence -> combine_motion + // re-applies its omega contribution. + Assert.Equal(jumpOmega, seq.Omega); + // Modifier chain popped-and-readded during replay; net membership unchanged. + Assert.Contains(state.Modifiers, m => m.Motion == Jump); + } + + [Fact] + public void ReModify_EmptyModifierChain_IsNoOp() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(new NullLoader()); + + cmt.ReModify(seq, state); // must not throw; no modifiers to replay + + Assert.Empty(state.Modifiers); + Assert.Equal(0, seq.Count); + } + + // ── free-function unit coverage ───────────────────────────────────── + + [Theory] + [InlineData(1f, 1f, true)] + [InlineData(-1f, -1f, true)] + [InlineData(1f, -1f, false)] + [InlineData(-1f, 1f, false)] + [InlineData(0f, 1f, true)] + [InlineData(0f, -1f, false)] + public void SameSign_MatchesRetailSemantics(float a, float b, bool expected) + { + Assert.Equal(expected, CMotionTable.SameSign(a, b)); + } + + [Fact] + public void ChangeCycleSpeed_RescalesFramerate_ByRatio() + { + var loader = new FakeLoader(); + uint animId = 0x030000C0u; + loader.Register(animId, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + var seq = new CSequence(loader); + seq.AppendAnimation(Fixtures.MakeAnimData(animId, 10f)); + + var md = Fixtures.MakeMotionData(animId, 10f); + CMotionTable.ChangeCycleSpeed(seq, md, oldSpeed: 1f, newSpeed: 2f); + + Assert.Equal(20.0, seq.CurrAnim!.Framerate, 3); + } + + [Fact] + public void ChangeCycleSpeed_OldSpeedNearZero_NewSpeedNearZero_ZeroesFramerate() + { + // A4-#2: retail's own gap, ported verbatim — when BOTH old and new + // speed are ~0, the framerate is explicitly zeroed. + var loader = new FakeLoader(); + uint animId = 0x030000C1u; + loader.Register(animId, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + var seq = new CSequence(loader); + seq.AppendAnimation(Fixtures.MakeAnimData(animId, 10f)); + + var md = Fixtures.MakeMotionData(animId, 10f); + CMotionTable.ChangeCycleSpeed(seq, md, oldSpeed: 0.0001f, newSpeed: 0.0001f); + + Assert.Equal(0.0, seq.CurrAnim!.Framerate, 5); + } + + [Fact] + public void ChangeCycleSpeed_OldSpeedNearZero_NewSpeedNonZero_SilentNoOp_A4Gap() + { + // A4-#2 gap, PORTED VERBATIM (retail bug, not ours to fix): when + // old speed ~0 but new speed is NOT ~0, retail's fabsl(arg4) branch + // structure suppresses the rescale entirely — framerate is left + // exactly as-is (no zeroing, no rescale). Leave this test failing + // rather than fudge the assertion if the decomp's fall-through is + // ever re-read differently. + var loader = new FakeLoader(); + uint animId = 0x030000C2u; + loader.Register(animId, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + var seq = new CSequence(loader); + seq.AppendAnimation(Fixtures.MakeAnimData(animId, 10f)); + + var md = Fixtures.MakeMotionData(animId, 10f); + CMotionTable.ChangeCycleSpeed(seq, md, oldSpeed: 0.0001f, newSpeed: 5f); + + Assert.Equal(10.0, seq.CurrAnim!.Framerate, 5); + } + + [Fact] + public void AddMotion_NullMotionData_IsNoOp() + { + var seq = new CSequence(new NullLoader()); + CMotionTable.AddMotion(seq, null, 1f); + Assert.Equal(0, seq.Count); + Assert.Equal(Vector3.Zero, seq.Velocity); + } + + [Fact] + public void AddMotion_SetsVelocityOmega_Unconditionally_EvenWhenZero() + { + // G17 core: add_motion is UNCONDITIONAL (retail 0x005224b0) — no + // HasVelocity/HasOmega gate. A MotionData with a non-zero existing + // sequence velocity gets overwritten with the dat-silent zero. + var loader = new FakeLoader(); + uint animId = 0x030000D0u; + loader.Register(animId, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + var seq = new CSequence(loader); + seq.SetVelocity(new Vector3(9, 9, 9)); + + var md = Fixtures.MakeMotionData(animId, 10f); // no HasVelocity flag -> Velocity field is default(Vector3.Zero) + CMotionTable.AddMotion(seq, md, 1f); + + Assert.Equal(Vector3.Zero, seq.Velocity); // overwritten with zero, not left at (9,9,9) + } + + [Fact] + public void CombineMotion_AddsToExistingPhysics_AnimsUntouched() + { + var seq = new CSequence(new NullLoader()); + seq.SetVelocity(new Vector3(1, 0, 0)); + var md = Fixtures.MakeMotionData(0, 0f, velocity: new Vector3(2, 0, 0)); + + CMotionTable.CombineMotion(seq, md, 1f); + + Assert.Equal(new Vector3(3, 0, 0), seq.Velocity); + Assert.Equal(0, seq.Count); // combine_motion never touches anims + } + + [Fact] + public void SubtractMotion_RemovesFromExistingPhysics_AnimsUntouched() + { + var seq = new CSequence(new NullLoader()); + seq.SetVelocity(new Vector3(5, 0, 0)); + var md = Fixtures.MakeMotionData(0, 0f, velocity: new Vector3(2, 0, 0)); + + CMotionTable.SubtractMotion(seq, md, 1f); + + Assert.Equal(new Vector3(3, 0, 0), seq.Velocity); + Assert.Equal(0, seq.Count); + } + + // ── GetLink / IsAllowed direct unit coverage ──────────────────────── + + [Fact] + public void GetLink_ForwardDirection_LooksUpBySubstateThenMotion() + { + var mt = new MotionTable(); + var link = Fixtures.MakeMotionData(0x030000E0u, 30f); + Fixtures.AddLink(mt, NonCombatStyle, Ready, WalkForward, link); + var cmt = new CMotionTable(mt); + + var result = cmt.GetLink(NonCombatStyle, Ready, 1f, WalkForward, 1f); + + Assert.Same(link, result); + } + + [Fact] + public void GetLink_ReversedDirection_EitherSpeedNegative_SwapsKeys() + { + // A1 pin: EITHER speed negative -> swapped-key branch (link stored + // FROM motion TO substate). + var mt = new MotionTable(); + var reversedLink = Fixtures.MakeMotionData(0x030000E1u, 30f); + Fixtures.AddLink(mt, NonCombatStyle, WalkForward, Ready, reversedLink); + var cmt = new CMotionTable(mt); + + // fromSubstate=Ready(+1), toSubstate=WalkForward but NEGATIVE speed. + var result = cmt.GetLink(NonCombatStyle, Ready, 1f, WalkForward, -1f); + + Assert.Same(reversedLink, result); + } + + [Fact] + public void IsAllowed_UngatedMotionData_AlwaysAllowed() + { + var mt = new MotionTable(); + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready }; + var md = Fixtures.MakeMotionData(0x030000F0u, 30f, bitfield: 0); + + Assert.True(cmt.IsAllowed(WalkForward, md, state)); + } + + [Fact] + public void IsAllowed_GatedMotionData_CandidateEqualsCurrentSubstate_Allowed() + { + var mt = new MotionTable(); + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = TurnRight }; + var md = Fixtures.MakeMotionData(0x030000F1u, 30f, bitfield: 2); + + Assert.True(cmt.IsAllowed(TurnRight, md, state)); + } + + [Fact] + public void IsAllowed_GatedMotionData_CurrentSubstateIsStyleDefault_Allowed() + { + var mt = new MotionTable(); + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready }; + var md = Fixtures.MakeMotionData(0x030000F2u, 30f, bitfield: 2); + + Assert.True(cmt.IsAllowed(TurnRight, md, state)); + } + + [Fact] + public void IsAllowed_GatedMotionData_CurrentSubstateMismatch_Rejected() + { + var mt = new MotionTable(); + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = RunForward }; // neither TurnRight nor Ready + var md = Fixtures.MakeMotionData(0x030000F3u, 30f, bitfield: 2); + + Assert.False(cmt.IsAllowed(TurnRight, md, state)); + } + + [Fact] + public void IsAllowed_NullMotionData_Rejected() + { + var mt = new MotionTable(); + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready }; + + Assert.False(cmt.IsAllowed(TurnRight, null, state)); + } + + // ── SetDefaultState (hard reset) ───────────────────────────────────── + + [Fact] + public void SetDefaultState_ResetsToTableDefaultStyleAndSubstate_ClearAnimationsHardReset() + { + var loader = new FakeLoader(); + uint readyAnim = 0x03000100u, junkAnim = 0x03000101u; + loader.Register(readyAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(junkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, Ready, Fixtures.MakeMotionData(readyAnim, 30f)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = HandCombatStyle, Substate = RunForward, SubstateMod = 3f }; + state.AddModifierNoCheck(Jump, 1f); + state.AddAction(ThrustMed, 1f); + + var seq = new CSequence(loader); + seq.AppendAnimation(Fixtures.MakeAnimData(junkAnim, 5f)); // stale junk node + + bool ok = cmt.SetDefaultState(state, seq, out uint outTicks); + + Assert.True(ok); + Assert.Equal(NonCombatStyle, state.Style); + Assert.Equal(Ready, state.Substate); + Assert.Equal(1f, state.SubstateMod); + Assert.Empty(state.Modifiers); // clear_modifiers + Assert.Empty(state.Actions); // clear_actions + // clear_animations hard reset: the stale junk node is gone; only the + // fresh Ready cycle remains. + Assert.Equal(1, seq.Count); + // outTicks = cyclic.num_anims - 1 = 1 - 1 = 0 (decomp §8: *arg4 = node->motionData->num_anims - 1). + Assert.Equal(0u, outTicks); + } + + [Fact] + public void SetDefaultState_TableHasNoDefaultStyleEntry_ReturnsFalse() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + // No StyleDefaults entry registered for NonCombatStyle. + var cmt = new CMotionTable(mt); + var state = new MotionState(); + var seq = new CSequence(new NullLoader()); + + bool ok = cmt.SetDefaultState(state, seq, out uint outTicks); + + Assert.False(ok); + Assert.Equal(0u, outTicks); + } + + // ── DoObjectMotion / StopObjectMotion thin-wrapper coverage ────────── + + [Fact] + public void DoObjectMotion_ForcesStopFlagFalse_DelegatesToGetObjectSequence() + { + var loader = new FakeLoader(); + uint animId = 0x03000110u; + loader.Register(animId, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, Ready, Fixtures.MakeMotionData(animId, 30f)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(loader); + + bool ok = cmt.DoObjectMotion(Ready, state, seq, 1f, out _); + + Assert.True(ok); + Assert.Equal(1, seq.Count); + } + + [Fact] + public void StopObjectMotion_DelegatesToStopSequenceMotion() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + var jumpOmega = new Vector3(0, 0, 3f); + Fixtures.AddModifier(mt, NonCombatStyle, Jump, Fixtures.MakeMotionData(0, 0f, omega: jumpOmega)); + + var cmt = new CMotionTable(mt); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + state.AddModifierNoCheck(Jump, 1f); + var seq = new CSequence(new NullLoader()); + seq.CombinePhysics(Vector3.Zero, jumpOmega); + + bool ok = cmt.StopObjectMotion(Jump, 1f, state, seq, out _); + + Assert.True(ok); + Assert.Equal(Vector3.Zero, seq.Omega); + } +} + +/// In-memory that never resolves. +file sealed class NullLoader : IAnimationLoader +{ + public Animation? LoadAnimation(uint id) => null; +} + +/// In-memory test double. +file sealed class FakeLoader : IAnimationLoader +{ + private readonly System.Collections.Generic.Dictionary _anims = new(); + public void Register(uint id, Animation anim) => _anims[id] = anim; + public Animation? LoadAnimation(uint id) => _anims.TryGetValue(id, out var a) ? a : null; +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/CSequencePhysicsTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/CSequencePhysicsTests.cs new file mode 100644 index 00000000..a1d4c972 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/CSequencePhysicsTests.cs @@ -0,0 +1,142 @@ +using System; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.Types; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R1-P3 — CSequence::apply_physics (0x00524ab0) + +/// Frame::rotate/grotate (0x004525b0/0x005357a0) verbatim +/// (gap G7's math half). Oracle: r1-csequence-decomp.md §19 + raw decomp +/// reads of rotate/grotate this session. +/// +/// KEY SEMANTICS: +/// - apply_physics takes MAGNITUDE from arg3 and SIGN from arg4 +/// (copysign): origin += velocity·signed; rotate(omega·signed); +/// - rotate() maps the LOCAL rotation vector through the frame's +/// orientation to GLOBAL, then grotate premultiplies the axis-angle +/// quaternion (rotation applied in world space); +/// - grotate skips rotations with |v|² < F_EPSILON² (0.000199999995²). +/// +public class CSequencePhysicsTests +{ + private sealed class NullLoader : IAnimationLoader + { + public DatReaderWriter.DBObjs.Animation? LoadAnimation(uint id) => null; + } + + private static void AssertVec(Vector3 expected, Vector3 actual, float tol = 1e-5f) + { + Assert.True((expected - actual).Length() < tol, + $"expected {expected}, got {actual}"); + } + + [Fact] + public void ApplyPhysics_PositiveSign_AddsVelocityTimesQuantum() + { + var seq = new CSequence(new NullLoader()); + seq.SetVelocity(new Vector3(2, 0, 0)); + var frame = new Frame { Origin = new Vector3(1, 1, 1), Orientation = Quaternion.Identity }; + + seq.ApplyPhysics(frame, quantum: 0.5, signSource: 1.0); + + AssertVec(new Vector3(2, 1, 1), frame.Origin); + } + + [Fact] + public void ApplyPhysics_CopySign_MagnitudeFromQuantum_SignFromSource() + { + // signed_quantum = copysign(fabs(quantum), sign_source): a NEGATIVE + // quantum with a POSITIVE sign source still moves forward; a + // negative sign source reverses. + var seq = new CSequence(new NullLoader()); + seq.SetVelocity(new Vector3(2, 0, 0)); + + var f1 = new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }; + seq.ApplyPhysics(f1, quantum: -0.5, signSource: 1.0); + AssertVec(new Vector3(1, 0, 0), f1.Origin); + + var f2 = new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }; + seq.ApplyPhysics(f2, quantum: 0.5, signSource: -1.0); + AssertVec(new Vector3(-1, 0, 0), f2.Origin); + } + + [Fact] + public void ApplyPhysics_OmegaRotatesFrame_GlobalZ() + { + // omega = (0,0,π) for 0.5s → 90° about global Z: local +X maps to +Y. + var seq = new CSequence(new NullLoader()); + seq.SetOmega(new Vector3(0, 0, MathF.PI)); + var frame = new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }; + + seq.ApplyPhysics(frame, quantum: 0.5, signSource: 1.0); + + AssertVec(new Vector3(0, 1, 0), Vector3.Transform(Vector3.UnitX, frame.Orientation)); + } + + [Fact] + public void GRotate_ComposesInGlobalSpace() + { + // Frame already rotated 90° about Z; grotate 90° about GLOBAL X. + // local +X: q maps it to +Y; global X-rot then maps +Y to +Z. + var frame = new Frame + { + Origin = Vector3.Zero, + Orientation = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, MathF.PI / 2f), + }; + + FrameOps.GRotate(frame, new Vector3(MathF.PI / 2f, 0, 0)); + + AssertVec(new Vector3(0, 0, 1), Vector3.Transform(Vector3.UnitX, frame.Orientation)); + } + + [Fact] + public void Rotate_LocalVector_MappedThroughOrientation() + { + // Frame rotated 90° about Z: a LOCAL X-axis rotation is a GLOBAL + // Y-axis rotation. rotate(local πX/2) on this frame must equal + // grotate(global πY/2). + var q0 = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, MathF.PI / 2f); + var viaLocal = new Frame { Origin = Vector3.Zero, Orientation = q0 }; + FrameOps.Rotate(viaLocal, new Vector3(MathF.PI / 2f, 0, 0)); + + var viaGlobal = new Frame { Origin = Vector3.Zero, Orientation = q0 }; + FrameOps.GRotate(viaGlobal, new Vector3(0, MathF.PI / 2f, 0)); + + AssertVec( + Vector3.Transform(Vector3.UnitX, viaGlobal.Orientation), + Vector3.Transform(Vector3.UnitX, viaLocal.Orientation)); + AssertVec( + Vector3.Transform(Vector3.UnitZ, viaGlobal.Orientation), + Vector3.Transform(Vector3.UnitZ, viaLocal.Orientation)); + } + + [Fact] + public void GRotate_TinyRotation_Skipped() + { + // |v|² < F_EPSILON² → no-op (0x005357a0 early return). + var frame = new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }; + FrameOps.GRotate(frame, new Vector3(1e-5f, 0, 0)); + Assert.Equal(Quaternion.Identity, frame.Orientation); + } + + [Fact] + public void ApplyPhysics_ZeroPhysics_NoChange() + { + var seq = new CSequence(new NullLoader()); + var frame = new Frame + { + Origin = new Vector3(3, 4, 5), + Orientation = Quaternion.CreateFromAxisAngle(Vector3.UnitY, 0.3f), + }; + var beforeO = frame.Origin; + var beforeQ = frame.Orientation; + + seq.ApplyPhysics(frame, 1.0, 1.0); + + Assert.Equal(beforeO, frame.Origin); + Assert.Equal(beforeQ, frame.Orientation); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/CSequenceTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/CSequenceTests.cs new file mode 100644 index 00000000..62f66e60 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/CSequenceTests.cs @@ -0,0 +1,323 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R1-P2 — verbatim CSequence container + list surgery (gap-map +/// G10/G11/G12/G14/G15/G20). Oracle: r1-csequence-decomp.md §1-§17, §20, +/// §24 (ctor 0x005249f0, clear 0x005255b0, clear_animations 0x00524dc0, +/// clear_physics 0x00524d50, remove_cyclic_anims 0x00524e40, +/// remove_link_animations 0x00524be0, remove_all_link_animations +/// 0x00524ca0, apricot 0x00524b40, append_animation 0x00525510, +/// set/combine/subtract physics 0x00524880-0x00524900, +/// multiply_cyclic_animation_fr 0x00524940, placement family +/// 0x00524970-0x005249d0). +/// +/// KEY RETAIL SEMANTICS UNDER TEST: +/// - append_animation slides first_cyclic to the JUST-APPENDED node on +/// EVERY call (G10) and seeds curr_anim=head + frame_number=starting +/// only when curr_anim was null; +/// - remove_cyclic_anims snaps a removed curr_anim BACK to the previous +/// node at its get_ending_frame() (or 0.0 when none); +/// - remove_link_animations snaps a removed curr_anim FORWARD to +/// first_cyclic at its get_starting_frame(); +/// - apricot trims consumed head nodes bounded by curr_anim AND +/// first_cyclic; +/// - clear (0x005255b0 raw body) resets placement_frame/id too — the +/// "2-instruction clear" note in the gap map was wrong, the raw body +/// is authority; +/// - physics accumulators live on the SEQUENCE (replace/combine/subtract); +/// - multiply_cyclic_animation_fr touches node framerates ONLY (G13). +/// +public class CSequenceTests +{ + private sealed class MapLoader : IAnimationLoader + { + private readonly Dictionary _map = new(); + public void Add(uint id, Animation anim) => _map[id] = anim; + public Animation? LoadAnimation(uint id) => _map.TryGetValue(id, out var a) ? a : null; + } + + private static Animation MakeAnim(int numFrames) + { + var anim = new Animation(); + for (int f = 0; f < numFrames; f++) + { + var pf = new AnimationFrame(1u); + pf.Frames.Add(new Frame { Origin = new Vector3(f, 0, 0), Orientation = Quaternion.Identity }); + anim.PartFrames.Add(pf); + } + return anim; + } + + private static AnimData Ad(uint animId, int low = 0, int high = -1, float framerate = 30f) + { + QualifiedDataId qid = animId; + return new AnimData { AnimId = qid, LowFrame = low, HighFrame = high, Framerate = framerate }; + } + + private static (CSequence seq, MapLoader loader) NewSeq(params (uint id, int frames)[] anims) + { + var loader = new MapLoader(); + foreach (var (id, frames) in anims) + loader.Add(id, MakeAnim(frames)); + return (new CSequence(loader), loader); + } + + // ── append_animation (G10) ────────────────────────────────────────── + + [Fact] + public void Append_First_SeedsCurrAnimAndFrameNumber() + { + var (seq, _) = NewSeq((1u, 10)); + seq.AppendAnimation(Ad(1u, low: 3)); + + Assert.Equal(1, seq.Count); + Assert.NotNull(seq.CurrAnim); + Assert.Same(seq.CurrAnim, seq.FirstCyclic); + Assert.Equal(3.0, seq.FrameNumber); // head.get_starting_frame() + } + + [Fact] + public void Append_SlidesFirstCyclicToNewTail_EveryCall() + { + var (seq, _) = NewSeq((1u, 10), (2u, 5), (3u, 4)); + seq.AppendAnimation(Ad(1u)); + seq.AppendAnimation(Ad(2u)); + seq.AppendAnimation(Ad(3u)); + + Assert.Equal(3, seq.Count); + Assert.Equal(4 - 1, seq.FirstCyclic!.HighFrame); // the LAST appended (anim 3, 4 frames) + Assert.Equal(10 - 1, seq.CurrAnim!.HighFrame); // curr stays at head (anim 1) + Assert.Equal(0.0, seq.FrameNumber); + } + + [Fact] + public void Append_UnresolvableAnim_Discarded() + { + var (seq, _) = NewSeq((1u, 10)); + seq.AppendAnimation(Ad(999u)); // not in loader + Assert.Equal(0, seq.Count); + Assert.Null(seq.CurrAnim); + Assert.False(seq.HasAnims()); + } + + // ── remove_cyclic_anims (G11) ─────────────────────────────────────── + + [Fact] + public void RemoveCyclicAnims_CurrOutsideTail_KeepsCurr_FirstCyclicToNewTail() + { + // A (link) + B (cycle): first_cyclic == B, curr == A (head). + var (seq, _) = NewSeq((1u, 10), (2u, 5)); + seq.AppendAnimation(Ad(1u)); + seq.AppendAnimation(Ad(2u)); + + seq.RemoveCyclicAnims(); + + Assert.Equal(1, seq.Count); // B deleted + Assert.Equal(9, seq.CurrAnim!.HighFrame); // still A + Assert.Same(seq.CurrAnim, seq.FirstCyclic); // first_cyclic = new tail (A) + } + + [Fact] + public void RemoveCyclicAnims_CurrInsideTail_SnapsBackToPrevAtEndingFrame() + { + var (seq, _) = NewSeq((1u, 10), (2u, 5)); + seq.AppendAnimation(Ad(1u)); + seq.AppendAnimation(Ad(2u)); + seq.SetCurrAnimForTest(1); // curr = B (index 1, inside cyclic tail) + + seq.RemoveCyclicAnims(); + + Assert.Equal(1, seq.Count); + Assert.Equal(9, seq.CurrAnim!.HighFrame); // snapped back to A + Assert.Equal(10.0, seq.FrameNumber); // A.get_ending_frame() = high+1 = 10 + } + + [Fact] + public void RemoveCyclicAnims_SingleNode_EmptiesAndZeroes() + { + var (seq, _) = NewSeq((1u, 10)); + seq.AppendAnimation(Ad(1u)); + + seq.RemoveCyclicAnims(); + + Assert.Equal(0, seq.Count); + Assert.Null(seq.CurrAnim); + Assert.Null(seq.FirstCyclic); + Assert.Equal(0.0, seq.FrameNumber); + } + + // ── remove_link_animations / remove_all_link_animations (G11) ────── + + [Fact] + public void RemoveLinkAnimations_RemovesPredecessorsOfFirstCyclic() + { + var (seq, _) = NewSeq((1u, 10), (2u, 5), (3u, 4)); + seq.AppendAnimation(Ad(1u)); // A + seq.AppendAnimation(Ad(2u)); // B + seq.AppendAnimation(Ad(3u)); // C = first_cyclic + + seq.RemoveLinkAnimations(1); // removes B (immediate predecessor) + + Assert.Equal(2, seq.Count); + Assert.Equal(9, seq.CurrAnim!.HighFrame); // A untouched (curr was A) + Assert.Equal(3, seq.FirstCyclic!.HighFrame); // C untouched + } + + [Fact] + public void RemoveLinkAnimations_CurrRemoved_SnapsForwardToFirstCyclicStart() + { + var (seq, _) = NewSeq((1u, 10), (2u, 5)); + seq.AppendAnimation(Ad(1u)); // A (curr) + seq.AppendAnimation(Ad(2u)); // B = first_cyclic + + seq.RemoveLinkAnimations(1); // removes A == curr + + Assert.Equal(1, seq.Count); + Assert.Same(seq.FirstCyclic, seq.CurrAnim); + Assert.Equal(0.0, seq.FrameNumber); // B.get_starting_frame() = low = 0 + } + + [Fact] + public void RemoveAllLinkAnimations_RemovesEverythingBeforeFirstCyclic() + { + var (seq, _) = NewSeq((1u, 10), (2u, 5), (3u, 4)); + seq.AppendAnimation(Ad(1u)); + seq.AppendAnimation(Ad(2u)); + seq.AppendAnimation(Ad(3u)); // first_cyclic + + seq.RemoveAllLinkAnimations(); + + Assert.Equal(1, seq.Count); + Assert.Same(seq.FirstCyclic, seq.CurrAnim); + Assert.Equal(3, seq.CurrAnim!.HighFrame); + } + + // ── apricot (G11/G19) ─────────────────────────────────────────────── + + [Fact] + public void Apricot_HeadIsCurr_NoOp() + { + var (seq, _) = NewSeq((1u, 10), (2u, 5)); + seq.AppendAnimation(Ad(1u)); + seq.AppendAnimation(Ad(2u)); + + seq.Apricot(); + + Assert.Equal(2, seq.Count); + } + + [Fact] + public void Apricot_TrimsConsumedHeads_StopsAtCurr() + { + var (seq, _) = NewSeq((1u, 10), (2u, 5), (3u, 4)); + seq.AppendAnimation(Ad(1u)); // A (consumed) + seq.AppendAnimation(Ad(2u)); // B (curr) + seq.AppendAnimation(Ad(3u)); // C = first_cyclic + seq.SetCurrAnimForTest(1); // curr = B + + seq.Apricot(); + + Assert.Equal(2, seq.Count); // A trimmed + Assert.Equal(4, seq.CurrAnim!.HighFrame); // B still curr + } + + [Fact] + public void Apricot_BoundedByFirstCyclic_EvenIfCurrBeyond() + { + var (seq, _) = NewSeq((1u, 10), (2u, 5), (3u, 4)); + seq.AppendAnimation(Ad(1u)); // A + seq.AppendAnimation(Ad(2u)); // B + seq.AppendAnimation(Ad(3u)); // C = first_cyclic = curr target + seq.SetCurrAnimForTest(2); // curr = C + + seq.Apricot(); + + Assert.Equal(1, seq.Count); // A and B trimmed; stops at first_cyclic + Assert.Equal(3, seq.CurrAnim!.HighFrame); + } + + // ── physics accumulators (G12) ────────────────────────────────────── + + [Fact] + public void Physics_SetCombineSubtract() + { + var (seq, _) = NewSeq(); + seq.SetVelocity(new Vector3(1, 2, 3)); + seq.SetOmega(new Vector3(0, 0, 1)); + seq.CombinePhysics(new Vector3(1, 0, 0), new Vector3(0, 0, 0.5f)); + Assert.Equal(new Vector3(2, 2, 3), seq.Velocity); + Assert.Equal(new Vector3(0, 0, 1.5f), seq.Omega); + seq.SubtractPhysics(new Vector3(2, 2, 3), new Vector3(0, 0, 1.5f)); + Assert.Equal(Vector3.Zero, seq.Velocity); + Assert.Equal(Vector3.Zero, seq.Omega); + } + + // ── multiply_cyclic_animation_fr (G13) ────────────────────────────── + + [Fact] + public void MultiplyCyclicFramerate_TouchesOnlyCyclicTailFramerates() + { + var (seq, _) = NewSeq((1u, 10), (2u, 5)); + seq.AppendAnimation(Ad(1u, framerate: 30f)); // A (link, pre-cyclic after next append) + seq.AppendAnimation(Ad(2u, framerate: 30f)); // B = first_cyclic + + seq.MultiplyCyclicAnimationFramerate(2f); + + Assert.Equal(30f, seq.CurrAnim!.Framerate); // A untouched + Assert.Equal(60f, seq.FirstCyclic!.Framerate); // B scaled + // Velocity/Omega untouched (retail scales those via + // subtract/combine_motion in R2, never here). + Assert.Equal(Vector3.Zero, seq.Velocity); + } + + // ── clear family (G20 corrected) ──────────────────────────────────── + + [Fact] + public void Clear_WipesAnimsPhysicsAndPlacement() + { + var (seq, _) = NewSeq((1u, 10)); + seq.AppendAnimation(Ad(1u)); + seq.SetVelocity(new Vector3(1, 1, 1)); + var pf = new AnimationFrame(1u); + seq.SetPlacementFrame(pf, 0x65u); + + seq.Clear(); + + Assert.Equal(0, seq.Count); + Assert.Null(seq.CurrAnim); + Assert.Equal(0.0, seq.FrameNumber); + Assert.Equal(Vector3.Zero, seq.Velocity); + Assert.Null(seq.PlacementFrame); // raw 0x005255b0 resets placement too + Assert.Equal(0u, seq.PlacementFrameId); + } + + // ── placement + accessors (G14) ───────────────────────────────────── + + [Fact] + public void GetCurrAnimframe_PlacementFallback_WhenNoCurrAnim() + { + var (seq, _) = NewSeq(); + var pf = new AnimationFrame(1u); + seq.SetPlacementFrame(pf, 0x65u); + Assert.Same(pf, seq.GetCurrAnimframe()); + } + + [Fact] + public void GetCurrAnimframe_FlooredFrameLookup() + { + var (seq, _) = NewSeq((1u, 10)); + seq.AppendAnimation(Ad(1u)); + seq.FrameNumber = 2.9; + var frame = seq.GetCurrAnimframe(); + Assert.NotNull(frame); + Assert.Equal(2f, frame!.Frames[0].Origin.X); // frame index 2 + + Assert.Equal(2, seq.GetCurrFrameNumber()); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/CSequenceUpdateTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/CSequenceUpdateTests.cs new file mode 100644 index 00000000..4b486bb1 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/CSequenceUpdateTests.cs @@ -0,0 +1,269 @@ +using System.Collections.Generic; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Enums; +using DatReaderWriter.Types; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R1-P4 — the frame-advance core: update_internal (0x005255d0), +/// update (0x00525b80), advance_to_next_animation +/// (0x005252b0), execute_hooks (0x00524830) — gaps +/// G3/G4/G5/G6/G8/G9/G19. +/// +/// Skeleton per the ACE-verified structure (P0-pins.md): overshoot → +/// clamp to the RAW high/low frame + leftover carry + animDone → +/// per-crossed-frame pose/physics/hook loop → AnimDone gate +/// (list HEAD != first_cyclic) → advance (pose-out both directions, +/// forward wraps to first_cyclic, reverse wraps to the LIST TAIL) → +/// carry the leftover (P0 pin) → loop. NO safety cap, NO boundary +/// epsilon. +/// +public class CSequenceUpdateTests +{ + private sealed class MapLoader : IAnimationLoader + { + private readonly Dictionary _map = new(); + public void Add(uint id, Animation anim) => _map[id] = anim; + public Animation? LoadAnimation(uint id) => _map.TryGetValue(id, out var a) ? a : null; + } + + private sealed class RecordingHookQueue : IAnimHookQueue + { + public readonly List Events = new(); + public void AddAnimHook(AnimationHook hook) + => Events.Add($"hook:{((TaggedHook)hook).Tag}:{hook.Direction}"); + public void AddAnimDoneHook() => Events.Add("ANIMDONE"); + } + + /// Hook subclass carrying a test tag (frame index). + private sealed class TaggedHook : AnimationHook + { + public string Tag = ""; + public override AnimationHookType HookType => (AnimationHookType)0; + } + + /// numFrames frames; one Forward-direction tagged hook per frame. + private static Animation MakeAnim(int numFrames, bool posFrames = false, string hookPrefix = "f") + { + var anim = new Animation(); + for (int f = 0; f < numFrames; f++) + { + var pf = new AnimationFrame(1u); + pf.Frames.Add(new Frame { Origin = new Vector3(f, 0, 0), Orientation = Quaternion.Identity }); + pf.Hooks.Add(new TaggedHook { Tag = $"{hookPrefix}{f}", Direction = AnimationHookDir.Both }); + anim.PartFrames.Add(pf); + if (posFrames) + anim.PosFrames.Add(new Frame { Origin = new Vector3(1, 0, 0), Orientation = Quaternion.Identity }); + } + return anim; + } + + private static AnimData Ad(uint animId, float framerate = 30f, int low = 0, int high = -1) + { + QualifiedDataId qid = animId; + return new AnimData { AnimId = qid, LowFrame = low, HighFrame = high, Framerate = framerate }; + } + + private static (CSequence seq, RecordingHookQueue hooks) Cyclic(int frames, float framerate = 30f) + { + var loader = new MapLoader(); + loader.Add(1u, MakeAnim(frames)); + var seq = new CSequence(loader); + var hooks = new RecordingHookQueue(); + seq.HookObj = hooks; + seq.AppendAnimation(Ad(1u, framerate)); + return (seq, hooks); + } + + // ── forward advance basics (G3) ───────────────────────────────────── + + [Fact] + public void Forward_SingleTick_AdvancesOneFrame_FiresExitedFrameHook() + { + var (seq, hooks) = Cyclic(5); + + seq.Update(1.0 / 30.0, null); + + Assert.Equal(1.0, seq.FrameNumber, 9); + Assert.Equal(new[] { "hook:f0:Both" }, hooks.Events); + } + + [Fact] + public void Forward_ExactBoundaryLanding_NoAdvance() + { + // Boundary test is STRICT (>): landing exactly at high_frame+0.0 + // integer positions must NOT advance (the G3 bug class: acdream's + // old epsilon-shifted boundary reclassified these). + var (seq, hooks) = Cyclic(5); + seq.FrameNumber = 3.5; + + seq.Update(0.5 / 30.0, null); // lands exactly at 4.0 == high_frame + + Assert.Equal(4.0, seq.FrameNumber, 9); + Assert.Equal(new[] { "hook:f3:Both" }, hooks.Events); // crossed 3→4 + Assert.DoesNotContain("ANIMDONE", hooks.Events); + } + + [Fact] + public void Forward_CyclicWrap_NoAnimDone_RestartsAtStartingFrame() + { + // Single cyclic node: overshoot wraps to itself via first_cyclic; + // head == first_cyclic → NO AnimDoneHook (G5's structural gate). + var (seq, hooks) = Cyclic(3); + seq.FrameNumber = 2.0; + + seq.Update(1.0 / 30.0, null); // 2→3 > high(2) → clamp, advance, wrap + + Assert.Equal(0.0, seq.FrameNumber, 9); + Assert.DoesNotContain("ANIMDONE", hooks.Events); + Assert.Same(seq.FirstCyclic, seq.CurrAnim); + } + + // ── multi-node fast-forward + the P0-pinned carry (G3/G5) ─────────── + + [Fact] + public void Forward_LinkToCycle_FiresAnimDone_AndCarriesLeftover() + { + // link (2 frames) + cycle (4 frames): a 0.1s tick (3 frames at + // 30fps) exhausts the link (2 frames) and carries 1 frame of time + // into the cycle. Retail order: link's crossed-frame hooks → + // AnimDoneHook (head != first_cyclic) → cycle's crossed hooks. + var loader = new MapLoader(); + loader.Add(1u, MakeAnim(2, hookPrefix: "link")); + loader.Add(2u, MakeAnim(4, hookPrefix: "cyc")); + var seq = new CSequence(loader); + var hooks = new RecordingHookQueue(); + seq.HookObj = hooks; + seq.AppendAnimation(Ad(1u)); // link — first_cyclic slides… + seq.AppendAnimation(Ad(2u)); // …to the cycle + + seq.Update(0.1, null); // 3 frames of time + + // link: FrameNumber 0→3, clamp to high(1), leftover = 1 frame; + // crossing fires link f0 only (floor(1)>0), then AnimDone, then + // advance → cycle at starting(0); carry 1/30 → cycle 0→1 fires cyc f0. + Assert.Equal(new[] { "hook:link0:Both", "ANIMDONE", "hook:cyc0:Both" }, hooks.Events); + Assert.Equal(1.0, seq.FrameNumber, 6); // the carry (P0 pin) — zeroing would leave 0.0 + Assert.Same(seq.FirstCyclic, seq.CurrAnim); // now inside the cycle + } + + // ── reverse playback (G3/G9) ──────────────────────────────────────── + + [Fact] + public void Reverse_DescendingHooks_BackwardDirection() + { + // Natively-reverse node (framerate −30): seeded at starting = + // high+1 = 5. Each tick fires the hook of the frame being LEFT + // (the pre-tick floor index), descending; the very first tick's + // index (5 = high+1) is OOB → null part frame → no hook, exactly + // the retail structure. + var (seq, hooks) = Cyclic(5, framerate: -30f); + Assert.Equal(5.0, seq.FrameNumber, 9); // get_starting_frame = high+1 + + seq.Update(1.0 / 30.0, null); // 5→4 (leaves OOB index 5 — nothing) + seq.Update(1.0 / 30.0, null); // 4→3 (leaves frame 4) + seq.Update(1.0 / 30.0, null); // 3→2 (leaves frame 3) + + Assert.Equal(2.0, seq.FrameNumber, 9); + Assert.Equal(new[] { "hook:f4:Both", "hook:f3:Both" }, hooks.Events); + } + + [Fact] + public void Reverse_AdvanceWrapsToListTail() + { + // Two nodes A(reverse),B(forward): exhausting A backward wraps + // curr_anim to the LIST TAIL (B) — retail's asymmetric wrap (G9). + var loader = new MapLoader(); + loader.Add(1u, MakeAnim(3, hookPrefix: "a")); + loader.Add(2u, MakeAnim(4, hookPrefix: "b")); + var seq = new CSequence(loader); + var hooks = new RecordingHookQueue(); + seq.HookObj = hooks; + seq.AppendAnimation(Ad(1u, framerate: -30f)); // A — curr seeds here + seq.AppendAnimation(Ad(2u)); // B = first_cyclic = tail + seq.FrameNumber = 0.5; // mid-window of A + + seq.Update(0.02, null); // frametime = −0.6 → crosses low(0) + + // After the reverse advance, curr must have left A via the TAIL + // wrap (B), whatever the carry then does within B. + Assert.NotNull(seq.CurrAnim); + Assert.Equal(3, seq.CurrAnim!.HighFrame); // B (4 frames → high 3) + } + + // ── stationary / degenerate (G8 + else-branch) ────────────────────── + + [Fact] + public void ZeroFramerate_PhysicsOnlyAndReturn() + { + var (seq, hooks) = Cyclic(3, framerate: 0f); + seq.SetVelocity(new Vector3(2, 0, 0)); + var frame = new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }; + + seq.Update(0.5, frame); + + // frametime == 0 → apply_physics(frame, elapsed, elapsed) then return. + Assert.Equal(1.0f, frame.Origin.X, 5); + Assert.Empty(hooks.Events); + Assert.Equal(0.0, seq.FrameNumber, 9); + } + + [Fact] + public void EmptyList_Update_AppliesAccumulatedPhysics() + { + // update (0x00525b80): empty anim_list + frame != null → + // apply_physics(frame, elapsed, elapsed) — free-fall/knockback + // with no animation (G8). + var seq = new CSequence(new MapLoader()); + seq.SetVelocity(new Vector3(0, 3, 0)); + var frame = new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }; + + seq.Update(2.0, frame); + + Assert.Equal(6.0f, frame.Origin.Y, 5); + } + + // ── root motion into the caller Frame (G7 wiring half) ────────────── + + [Fact] + public void Forward_PosFrames_CombinedIntoCallerFrame() + { + // Each crossed frame combines the node's pos_frame into the caller + // Frame (retail root motion): 2 crossed frames → +2 X. + var loader = new MapLoader(); + loader.Add(1u, MakeAnim(5, posFrames: true)); + var seq = new CSequence(loader); + seq.AppendAnimation(Ad(1u)); + var frame = new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }; + + seq.Update(2.0 / 30.0, frame); // crosses frames 0 and 1 + + Assert.Equal(2.0f, frame.Origin.X, 5); + Assert.Equal(2.0, seq.FrameNumber, 9); + } + + // ── update entry contract (G19) ───────────────────────────────────── + + [Fact] + public void Update_RunsApricot_TrimmingConsumedLinkNodes() + { + // After the link→cycle advance, apricot (called by update) frees + // the consumed link node. + var loader = new MapLoader(); + loader.Add(1u, MakeAnim(2, hookPrefix: "link")); + loader.Add(2u, MakeAnim(4, hookPrefix: "cyc")); + var seq = new CSequence(loader); + seq.AppendAnimation(Ad(1u)); + seq.AppendAnimation(Ad(2u)); + Assert.Equal(2, seq.Count); + + seq.Update(0.1, null); // exhausts the link, advances into the cycle + + Assert.Equal(1, seq.Count); // link trimmed by apricot + Assert.Same(seq.FirstCyclic, seq.CurrAnim); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/ConstraintManagerTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/ConstraintManagerTests.cs new file mode 100644 index 00000000..2e844c60 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/ConstraintManagerTests.cs @@ -0,0 +1,133 @@ +using System.Collections.Generic; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R5 conformance — (retail 0x00556090-…). +/// The leash-band taper + the 90 % IsFullyConstrained jump gate (port-plan §2b/§2c). +/// +public sealed class ConstraintManagerTests +{ + private static (R5Host host, ConstraintManager cm) Setup() + { + var world = new Dictionary(); + var host = new R5Host(10u, world); + return (host, new ConstraintManager(host)); + } + + private static Position Anchor(float x) => new(1u, new Vector3(x, 0f, 0f), Quaternion.Identity); + + [Fact] + public void ConstrainTo_InitializesOffsetToCurrentDistanceFromAnchor() + { + var (host, cm) = Setup(); + host.SetOrigin(Vector3.Zero); + + cm.ConstrainTo(Anchor(5f), startDistance: 2f, maxDistance: 10f); + + Assert.True(cm.IsConstrained); + Assert.Equal(5f, cm.ConstraintPosOffset, 3); // distance(anchor(5,0,0), self(0,0,0)) + } + + [Fact] + public void IsFullyConstrained_TrueOnlyBeyond90PercentOfMax() + { + var (host, cm) = Setup(); + host.SetOrigin(Vector3.Zero); + + cm.ConstrainTo(Anchor(8f), 2f, 10f); // offset 8, 90% of 10 = 9 → 8 < 9 + Assert.False(cm.IsFullyConstrained()); + + cm.ConstrainTo(Anchor(9.5f), 2f, 10f); // offset 9.5 > 9 + Assert.True(cm.IsFullyConstrained()); + } + + [Fact] + public void IsFullyConstrained_FalseWhenNotConstrainedYet() + { + var (_, cm) = Setup(); + Assert.False(cm.IsFullyConstrained()); // max 0 → 0 < 0 is false + } + + [Fact] + public void AdjustOffset_InBand_AppliesLinearTaper() + { + var (host, cm) = Setup(); + host.SetOrigin(Vector3.Zero); + host.InContact = true; + cm.ConstrainTo(Anchor(5f), startDistance: 2f, maxDistance: 10f); // offset 5 in (2,10) + + var frame = new MotionDeltaFrame { Origin = new Vector3(1f, 0f, 0f) }; + cm.AdjustOffset(frame, 0.1); + + // taper = (10-5)/(10-2) = 5/8 = 0.625. + Assert.Equal(0.625f, frame.Origin.X, 3); + Assert.Equal(0.625f, cm.ConstraintPosOffset, 3); // recomputed = |offset| + } + + [Fact] + public void AdjustOffset_PastMax_HardClampsToZero() + { + var (host, cm) = Setup(); + host.SetOrigin(Vector3.Zero); + host.InContact = true; + cm.ConstrainTo(Anchor(20f), 2f, 10f); // offset 20 >= max 10 + + var frame = new MotionDeltaFrame { Origin = new Vector3(1f, 0f, 0f) }; + cm.AdjustOffset(frame, 0.1); + + Assert.Equal(Vector3.Zero, frame.Origin); + } + + [Fact] + public void AdjustOffset_BelowStart_PassesThrough() + { + var (host, cm) = Setup(); + host.SetOrigin(Vector3.Zero); + host.InContact = true; + cm.ConstrainTo(Anchor(1f), startDistance: 2f, maxDistance: 10f); // offset 1 < start 2 + + var frame = new MotionDeltaFrame { Origin = new Vector3(1f, 0f, 0f) }; + cm.AdjustOffset(frame, 0.1); + + Assert.Equal(1f, frame.Origin.X, 3); // unscaled + Assert.Equal(1f, cm.ConstraintPosOffset, 3); + } + + [Fact] + public void AdjustOffset_Airborne_SkipsClampButStillTracksLength() + { + var (host, cm) = Setup(); + host.SetOrigin(Vector3.Zero); + host.InContact = false; // airborne + cm.ConstrainTo(Anchor(20f), 2f, 10f); // would clamp if grounded + + var frame = new MotionDeltaFrame { Origin = new Vector3(3f, 4f, 0f) }; + cm.AdjustOffset(frame, 0.1); + + Assert.Equal(new Vector3(3f, 4f, 0f), frame.Origin); // untouched while airborne + Assert.Equal(5f, cm.ConstraintPosOffset, 3); // |(3,4,0)| = 5, still updated + } + + [Fact] + public void AdjustOffset_NotConstrained_IsNoOp() + { + var (host, cm) = Setup(); + var frame = new MotionDeltaFrame { Origin = new Vector3(7f, 0f, 0f) }; + cm.AdjustOffset(frame, 0.1); + Assert.Equal(new Vector3(7f, 0f, 0f), frame.Origin); + } + + [Fact] + public void UnConstrain_ClearsFlag() + { + var (host, cm) = Setup(); + cm.ConstrainTo(Anchor(5f), 2f, 10f); + cm.UnConstrain(); + Assert.False(cm.IsConstrained); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/InterpretedMotionStateActionFifoTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/InterpretedMotionStateActionFifoTests.cs new file mode 100644 index 00000000..68420929 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/InterpretedMotionStateActionFifoTests.cs @@ -0,0 +1,217 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R3-W1 — action FIFO discipline + ApplyMotion/RemoveMotion +/// field effects on (closes J2). Oracle: +/// docs/research/named-retail/acclient_2013_pseudo_c.txt — verbatim bodies +/// quoted in MotionInterpreter.cs doc comments: +/// InterpretedMotionState::AddAction (0x0051e9e0), RemoveAction +/// (0x0051ead0), GetNumActions (0x0051eb00), ApplyMotion +/// (0x0051ea40), RemoveMotion (0x0051e790). +/// +public sealed class InterpretedMotionStateActionFifoTests +{ + [Fact] + public void Default_HasEmptyActionsAndZeroCount() + { + var ims = InterpretedMotionState.Default(); + Assert.Empty(ims.Actions); + Assert.Equal(0u, ims.GetNumActions()); + } + + // ── AddAction / RemoveAction / GetNumActions FIFO discipline ────────── + + [Fact] + public void AddAction_AppendsInOrder_GetNumActionsCounts() + { + var ims = InterpretedMotionState.Default(); + ims.AddAction(0x1000004Bu, 1.0f, 1, autonomous: false); + ims.AddAction(0x10000050u, 1.5f, 2, autonomous: true); + + Assert.Equal(2u, ims.GetNumActions()); + Assert.Equal((ushort)0x004Bu, ims.Actions[0].Command); + Assert.Equal((ushort)0x0050u, ims.Actions[1].Command); + } + + [Fact] + public void RemoveAction_PopsHeadFirst_FifoOrder() + { + var ims = InterpretedMotionState.Default(); + ims.AddAction(0x1000004Bu, 1.0f, 1, autonomous: false); + ims.AddAction(0x10000050u, 1.5f, 2, autonomous: true); + + uint first = ims.RemoveAction(); + uint second = ims.RemoveAction(); + + Assert.Equal(0x004Bu, first); + Assert.Equal(0x0050u, second); + Assert.Equal(0u, ims.GetNumActions()); + } + + [Fact] + public void RemoveAction_Empty_ReturnsZero() + { + var ims = InterpretedMotionState.Default(); + Assert.Equal(0u, ims.RemoveAction()); + } + + [Fact] + public void GetNumActions_DefaultStruct_NoNullRef() + { + // Defensive: a bare default(InterpretedMotionState) (bypassing + // .Default()) must not NRE on GetNumActions/Actions/RemoveAction — + // the lazy-list field starts null. + InterpretedMotionState bare = default; + Assert.Equal(0u, bare.GetNumActions()); + Assert.Empty(bare.Actions); + Assert.Equal(0u, bare.RemoveAction()); + } + + // ── DoMotion's depth-cap gate consumes this directly (documentation) ── + + [Fact] + public void GetNumActions_SixQueued_MeetsDoMotionDepthCapThreshold() + { + // DoMotion (0x00528d20 @306159) rejects with 0x45 when an + // action-class motion arrives AND GetNumActions() >= 6. W1 only + // proves the counter is correct; the gate itself lands in W5. + var ims = InterpretedMotionState.Default(); + for (uint i = 0; i < 6; i++) + ims.AddAction(0x10000000u + i, 1.0f, i, false); + + Assert.Equal(6u, ims.GetNumActions()); + Assert.True(ims.GetNumActions() >= 6); + } + + // ── ApplyMotion field effects (0x0051ea40) ───────────────────────────── + + [Fact] + public void ApplyMotion_TurnRight_SetsTurnCommandAndSpeed() + { + var ims = InterpretedMotionState.Default(); + var p = new MovementParameters { Speed = 1.5f }; + + ims.ApplyMotion(0x6500000du, p); + + Assert.Equal(0x6500000du, ims.TurnCommand); + Assert.Equal(1.5f, ims.TurnSpeed); + } + + [Fact] + public void ApplyMotion_SideStepRight_SetsSideStepCommandAndSpeed() + { + var ims = InterpretedMotionState.Default(); + var p = new MovementParameters { Speed = 1.248f }; + + ims.ApplyMotion(0x6500000fu, p); + + Assert.Equal(0x6500000fu, ims.SideStepCommand); + Assert.Equal(1.248f, ims.SideStepSpeed); + } + + [Fact] + public void ApplyMotion_ForwardClassMotion_SetsForwardCommandAndSpeed() + { + // Unlike RawMotionState::ApplyMotion, InterpretedMotionState's + // forward-class branch has NO RunForward exclusion — every + // forward-class id (bit 0x40000000) writes forward_command. + var ims = InterpretedMotionState.Default(); + var p = new MovementParameters { Speed = 2.94f }; + + ims.ApplyMotion(0x44000007u, p); // RunForward + + Assert.Equal(0x44000007u, ims.ForwardCommand); + Assert.Equal(2.94f, ims.ForwardSpeed); + } + + [Fact] + public void ApplyMotion_StyleClassMotion_ResetsForwardToReady_SetsCurrentStyle() + { + var ims = InterpretedMotionState.Default(); + ims.ForwardCommand = 0x45000005u; + var p = new MovementParameters(); + + ims.ApplyMotion(0x80000042u, p); + + Assert.Equal(0x41000003u, ims.ForwardCommand); + Assert.Equal(0x80000042u, ims.CurrentStyle); + } + + [Fact] + public void ApplyMotion_ActionClassMotion_AddsAction() + { + var ims = InterpretedMotionState.Default(); + var p = new MovementParameters { Speed = 1.0f, ActionStamp = 7u, Autonomous = true }; + + ims.ApplyMotion(0x1000004Bu, p); + + Assert.Equal(1u, ims.GetNumActions()); + var a = ims.Actions[0]; + Assert.Equal((ushort)0x004Bu, a.Command); + Assert.Equal(1.0f, a.Speed); + Assert.Equal((ushort)7u, a.Stamp); + Assert.True(a.Autonomous); + } + + // ── RemoveMotion field effects (0x0051e790) ──────────────────────────── + + [Fact] + public void RemoveMotion_TurnRightExact_ClearsTurnCommand() + { + var ims = InterpretedMotionState.Default(); + ims.TurnCommand = 0x6500000du; + ims.RemoveMotion(0x6500000du); + Assert.Equal(0u, ims.TurnCommand); + } + + [Fact] + public void RemoveMotion_TurnLeftExact_DoesNotMatchTurnBranch_FallsThroughToStyleCheck() + { + // Asymmetric vs RawMotionState::RemoveMotion: InterpretedMotionState + // only exact-matches 0x6500000d (TurnRight) for the turn branch, NOT + // 0x6500000e (TurnLeft) — verbatim per the raw decomp. + var ims = InterpretedMotionState.Default(); + ims.TurnCommand = 0x6500000eu; + ims.RemoveMotion(0x6500000eu); + // Falls through: bit 0x40000000 clear, arg2 (0x6500000e) is not + // negative and != current_style (0x8000003D default) -> no-op. + Assert.Equal(0x6500000eu, ims.TurnCommand); // untouched + } + + [Fact] + public void RemoveMotion_SideStepRightExact_ClearsSideStepCommand() + { + var ims = InterpretedMotionState.Default(); + ims.SideStepCommand = 0x6500000fu; + ims.RemoveMotion(0x6500000fu); + Assert.Equal(0u, ims.SideStepCommand); + } + + [Fact] + public void RemoveMotion_ForwardClassMotion_MatchingCommand_ResetsToReady() + { + var ims = InterpretedMotionState.Default(); + ims.ForwardCommand = 0x45000005u; + ims.ForwardSpeed = 3.0f; + + ims.RemoveMotion(0x45000005u); + + Assert.Equal(0x41000003u, ims.ForwardCommand); + Assert.Equal(1f, ims.ForwardSpeed); + } + + [Fact] + public void RemoveMotion_StyleClassMotion_MatchingCurrentStyle_ResetsToNonCombat() + { + var ims = InterpretedMotionState.Default(); + ims.CurrentStyle = 0x80000042u; + + ims.RemoveMotion(0x80000042u); + + Assert.Equal(0x8000003du, ims.CurrentStyle); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/Issue174LinkStripDrainTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/Issue174LinkStripDrainTests.cs new file mode 100644 index 00000000..dadba9a3 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/Issue174LinkStripDrainTests.cs @@ -0,0 +1,97 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.Core.Tests.Physics.Motion; + +// ───────────────────────────────────────────────────────────────────────────── +// #174 pin (2026-07-05): the RemoveLinkAnimations seam must be retail +// CPhysicsObj::RemoveLinkAnimations 0x0050fe20 — a TAILCALL to +// CPartArray::HandleEnterWorld 0x00517d70 → MotionTableManager:: +// HandleEnterWorld 0x0051bdd0: CSequence::remove_all_link_animations PLUS a +// full pending_animations drain (`while (head) AnimationDone(0)`), each pop +// relaying MotionDone → CMotionInterp pops its pending_motions node in +// lockstep. +// +// The pre-fix binding was the bare sequence strip: every LeaveGround (jump) +// removed the link animations that queued MotionTableManager nodes were +// counting down on, orphaning them (NumAnims > 0, animations gone). Both +// queues then dammed permanently — MotionsPending() never drained at rest — +// and BeginTurnToHeading/BeginMoveForward (retail 0x00529b90 motions_pending +// gate) starved every armed moveto: ACE's walk-to-door mt-6 armed but the +// body never walked; the close-range Use turn never completed so the +// deferred action was silently eaten. Live evidence: launch-174-autowalk.log +// (last player pending=False at the first MovementJump press; old jump +// motions still completing at rest minutes later). +// ───────────────────────────────────────────────────────────────────────────── +public class Issue174LinkStripDrainTests +{ + private readonly ITestOutputHelper _out; + public Issue174LinkStripDrainTests(ITestOutputHelper output) => _out = output; + + /// + /// The jam repro: queue motions (link + cycle nodes land in BOTH the + /// interp's pending_motions and the manager's pending_animations), then + /// fire the LeaveGround-side seam. With the retail HandleEnterWorld + /// binding both queues drain to empty; the pre-fix bare-strip binding + /// left both non-empty forever. + /// + [Fact] + public void RemoveLinkAnimationsSeam_DrainsBothQueues() + { + var h = new RemoteChaseHarness(_out); + + // Drive a motion burst — walk, run, stop — the shape a player's + // pre-jump input produces. Each successful dispatch pairs an interp + // node with a manager node. + var p = new MovementParameters(); + h.Interp.DoMotion(MotionCommand.WalkForward, p); + h.Interp.set_hold_run(true, interrupt: false); + h.Interp.StopMotion(MotionCommand.WalkForward, p); + + Assert.True(h.Interp.MotionsPending(), + "precondition: the burst must leave pending interp nodes"); + Assert.NotEmpty(h.Seq.Manager.PendingAnimations); + + // The LeaveGround seam (retail CMotionInterp::LeaveGround 0x00528b00 + // fires CPhysicsObj::RemoveLinkAnimations). + h.Interp.RemoveLinkAnimations!.Invoke(); + + Assert.False(h.Interp.MotionsPending(), + "HandleEnterWorld's drain must pop every pending interp node " + + "(retail: each AnimationDone(0) relays MotionDone)"); + Assert.Empty(h.Seq.Manager.PendingAnimations); + } + + /// + /// The post-jump livability pin: after the seam fires mid-activity, a + /// NEW moveto-style dispatch must be able to queue and complete — the + /// #174 symptom was that BeginTurnToHeading's motions_pending gate never + /// re-opened after a jump, permanently starving armed movetos. + /// + [Fact] + public void AfterSeamDrain_NewMotionsQueueAndComplete() + { + var h = new RemoteChaseHarness(_out); + var p = new MovementParameters(); + + // Pre-jump activity, then the jump's LeaveGround strip+drain. + h.Interp.DoMotion(MotionCommand.WalkForward, p); + h.Interp.RemoveLinkAnimations!.Invoke(); + Assert.False(h.Interp.MotionsPending()); + + // A fresh dispatch (the armed moveto's turn) queues... + h.Interp.DoMotion(MotionCommand.TurnRight, p); + Assert.True(h.Interp.MotionsPending()); + + // ...and the normal completion path (the manager's queue feeding + // MotionDone) drains it — the gate re-opens. + while (h.Seq.Manager.PendingAnimations.GetEnumerator() is var e && e.MoveNext()) + h.Seq.Manager.AnimationDone(success: true); + + h.Seq.Manager.CheckForCompletedMotions(); + Assert.False(h.Interp.MotionsPending(), + "the normal AnimationDone → MotionDone chain must drain the new node"); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MotionNodeTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MotionNodeTests.cs new file mode 100644 index 00000000..78fa2bcf --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MotionNodeTests.cs @@ -0,0 +1,33 @@ +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R3-W1 — CMotionInterp::MotionNode shape pin. Oracle: +/// acclient.h:53293 (struct #5857). W2 consumes this as the +/// pending_motions element type; W1 only ports the shape. +/// +public sealed class MotionNodeTests +{ + [Fact] + public void Ctor_StoresAllThreeFields() + { + var node = new MotionNode(ContextId: 7u, Motion: 0x41000003u, JumpErrorCode: 0x48u); + + Assert.Equal(7u, node.ContextId); + Assert.Equal(0x41000003u, node.Motion); + Assert.Equal(0x48u, node.JumpErrorCode); + } + + [Fact] + public void Equality_IsValueBased() + { + var a = new MotionNode(1u, 2u, 3u); + var b = new MotionNode(1u, 2u, 3u); + var c = new MotionNode(1u, 2u, 4u); + + Assert.Equal(a, b); + Assert.NotEqual(a, c); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MotionStateTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MotionStateTests.cs new file mode 100644 index 00000000..41c51f98 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MotionStateTests.cs @@ -0,0 +1,145 @@ +using System.Linq; +using AcDream.Core.Physics.Motion; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R2-Q1 — verbatim MotionState (gap H2). Oracle: +/// r2-motiontable-decomp.md §13 (ctor 0x00525fd0, add_modifier_no_check +/// 0x00525ff0, add_modifier 0x00526340, remove_modifier 0x00526040, +/// clear_modifiers 0x00526070, add_action 0x005260a0, clear_actions +/// 0x005260f0, remove_action_head 0x00526120) + §14 (one node struct, +/// two independent chains: modifier PUSH-FRONT STACK vs action TAIL-APPEND +/// FIFO) + Q0-pins A4-#5 (deep-copy ctor clones both chains — re_modify's +/// snapshot is a termination bound, never shared state). +/// +public class MotionStateTests +{ + [Fact] + public void Defaults_MatchRetailCtor() + { + var ms = new MotionState(); + Assert.Equal(0u, ms.Style); + Assert.Equal(0u, ms.Substate); + Assert.Equal(1f, ms.SubstateMod); + Assert.Empty(ms.Modifiers); + Assert.Empty(ms.Actions); + } + + [Fact] + public void Modifiers_ArePushFrontStack() + { + var ms = new MotionState(); + ms.AddModifierNoCheck(0x0Du, 1.0f); + ms.AddModifierNoCheck(0x0Fu, 1.5f); + + // Newest first — retail pushes onto modifier_head. + Assert.Equal(new uint[] { 0x0Fu, 0x0Du }, ms.Modifiers.Select(m => m.Motion).ToArray()); + } + + [Fact] + public void Actions_AreTailAppendFifo() + { + var ms = new MotionState(); + ms.AddAction(0x62u, 1.0f); + ms.AddAction(0x63u, 1.25f); + + Assert.Equal(new uint[] { 0x62u, 0x63u }, ms.Actions.Select(a => a.Motion).ToArray()); + } + + [Fact] + public void AddModifier_RejectsDuplicate() + { + var ms = new MotionState(); + Assert.True(ms.AddModifier(0x0Du, 1.0f)); + Assert.False(ms.AddModifier(0x0Du, 2.0f)); // already present → caller must stop-then-re-add + Assert.Single(ms.Modifiers); + Assert.Equal(1.0f, ms.Modifiers.First().SpeedMod); // original untouched + } + + [Fact] + public void AddModifier_RefusesCurrentSubstate() + { + var ms = new MotionState { Substate = 0x45000005u }; + Assert.False(ms.AddModifier(0x45000005u, 1.0f)); + Assert.Empty(ms.Modifiers); + } + + [Fact] + public void AddModifierNoCheck_SkipsBothGuards() + { + var ms = new MotionState { Substate = 0x45000005u }; + ms.AddModifierNoCheck(0x45000005u, 1.0f); + ms.AddModifierNoCheck(0x45000005u, 2.0f); // duplicate allowed too + Assert.Equal(2, ms.Modifiers.Count()); + } + + [Fact] + public void RemoveModifier_ByNodeIdentity() + { + var ms = new MotionState(); + ms.AddModifierNoCheck(0x0Du, 1.0f); + ms.AddModifierNoCheck(0x0Fu, 1.5f); + var target = ms.Modifiers.First(m => m.Motion == 0x0Du); + + ms.RemoveModifier(target); + + Assert.Single(ms.Modifiers); + Assert.Equal(0x0Fu, ms.Modifiers.First().Motion); + } + + [Fact] + public void RemoveActionHead_PopsFifo_ReturnsMotion_ZeroWhenEmpty() + { + var ms = new MotionState(); + ms.AddAction(0x62u, 1f); + ms.AddAction(0x63u, 1f); + + Assert.Equal(0x62u, ms.RemoveActionHead()); + Assert.Equal(0x63u, ms.RemoveActionHead()); + Assert.Equal(0u, ms.RemoveActionHead()); // empty → 0 (retail returns 0) + Assert.Empty(ms.Actions); + + // Tail cleared with the last pop — a fresh append works normally. + ms.AddAction(0x64u, 1f); + Assert.Equal(new uint[] { 0x64u }, ms.Actions.Select(a => a.Motion).ToArray()); + } + + [Fact] + public void ClearModifiers_And_ClearActions_AreIndependentChains() + { + var ms = new MotionState(); + ms.AddModifierNoCheck(0x0Du, 1f); + ms.AddAction(0x62u, 1f); + + ms.ClearModifiers(); + Assert.Empty(ms.Modifiers); + Assert.Single(ms.Actions); + + ms.ClearActions(); + Assert.Empty(ms.Actions); + } + + [Fact] + public void DeepCopy_ClonesChains_NoSharedState() + { + // A4-#5: re_modify's snapshot is a DEEP copy used as a termination + // bound — mutating the original must not touch the snapshot. + var ms = new MotionState { Style = 0x8000003Du, Substate = 0x44000007u, SubstateMod = 2.85f }; + ms.AddModifierNoCheck(0x0Du, 1.5f); + ms.AddAction(0x62u, 1f); + + var snap = new MotionState(ms); + + ms.ClearModifiers(); + ms.RemoveActionHead(); + ms.Substate = 0x41000003u; + + Assert.Equal(0x8000003Du, snap.Style); + Assert.Equal(0x44000007u, snap.Substate); + Assert.Equal(2.85f, snap.SubstateMod); + Assert.Single(snap.Modifiers); + Assert.Equal(0x0Du, snap.Modifiers.First().Motion); + Assert.Single(snap.Actions); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MotionTableDispatchSinkTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MotionTableDispatchSinkTests.cs new file mode 100644 index 00000000..192927a6 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MotionTableDispatchSinkTests.cs @@ -0,0 +1,167 @@ +using System.Linq; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; + +using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R2-Q5 — : the funnel's dispatches go +/// straight into (no axis +/// collection, no priority pick, no fallback chain — GetObjectSequence +/// 0x00522860 + is_allowed decide) with the TurnApplied/TurnStopped +/// ObservedOmega seam. +/// +public class MotionTableDispatchSinkTests +{ + private const uint NC = 0x8000003Du; + private const uint Ready = 0x41000003u; + private const uint Walk = 0x45000005u; + private const uint TurnRight = 0x6500000Du; + + private const uint ReadyAnim = 0x200u; + private const uint WalkAnim = 0x201u; + + private sealed class Loader : IAnimationLoader + { + private readonly System.Collections.Generic.Dictionary _anims = new(); + public void Register(uint id, Animation anim) => _anims[id] = anim; + public Animation? LoadAnimation(uint id) => _anims.TryGetValue(id, out var a) ? a : null; + } + + private static Animation MakeAnim(int frames) + { + var anim = new Animation(); + for (int f = 0; f < frames; f++) + { + var pf = new AnimationFrame(1); + pf.Frames.Add(new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }); + anim.PartFrames.Add(pf); + } + return anim; + } + + private static MotionData MakeMd(uint animId, Vector3? omega = null) + { + var md = new MotionData(); + QualifiedDataId qid = animId; + md.Anims.Add(new AnimData { AnimId = qid, LowFrame = 0, HighFrame = -1, Framerate = 30f }); + if (omega is { } o) + { + md.Omega = o; + md.Flags |= DatReaderWriter.Enums.MotionDataFlags.HasOmega; + } + return md; + } + + private static AnimationSequencer MakeSequencer(bool withTurnModifier = true) + { + var setup = new Setup(); + setup.Parts.Add(0x01000000u); + setup.DefaultScale.Add(Vector3.One); + + var loader = new Loader(); + loader.Register(ReadyAnim, MakeAnim(4)); + loader.Register(WalkAnim, MakeAnim(6)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NC }; + mt.StyleDefaults[(DRWMotionCommand)NC] = (DRWMotionCommand)Ready; + mt.Cycles[(int)((NC << 16) | (Ready & 0xFFFFFFu))] = MakeMd(ReadyAnim); + mt.Cycles[(int)((NC << 16) | (Walk & 0xFFFFFFu))] = MakeMd(WalkAnim); + if (withTurnModifier) + { + mt.Modifiers[(int)((NC << 16) | (TurnRight & 0xFFFFFFu))] = + MakeMd(ReadyAnim, omega: new Vector3(0f, 0f, 1.2f)); + } + + return new AnimationSequencer(setup, mt, loader); + } + + [Fact] + public void ApplyMotion_CycleClass_InstallsSubstate_LazyInitialized() + { + var seq = MakeSequencer(); + var sink = new MotionTableDispatchSink(seq); + + // Fresh sequencer: the first dispatch lazily runs initialize_state + // (retail lazy-create, r3-motioninterp-decomp §6g) then installs + // the requested substate. + sink.ApplyMotion(Walk, 2.0f); + + Assert.Equal(Walk, seq.CurrentMotion); + Assert.Equal(2.0f, seq.CurrentSpeedMod); + // Locomotion velocity synthesis ran in the passthrough (AP-75). + Assert.Equal(MotionInterpreter.WalkAnimSpeed * 2.0f, seq.CurrentVelocity.Y, 3); + } + + [Fact] + public void ApplyMotion_Turn_Branch4Modifier_FiresTurnApplied_NoCycleChange() + { + var seq = MakeSequencer(); + uint? turnMotion = null; + float turnSpeed = 0f; + var sink = new MotionTableDispatchSink(seq) + { + TurnApplied = (m, s) => { turnMotion = m; turnSpeed = s; }, + }; + + sink.ApplyMotion(Walk, 1.0f); + sink.ApplyMotion(TurnRight, 1.5f); + + // The AP-73 mechanism for real: substate cycle untouched, the turn + // is a MotionState modifier with its dat omega combined. + Assert.Equal(Walk, seq.CurrentMotion); + Assert.Equal((TurnRight, 1.5f), (turnMotion!.Value, turnSpeed)); + Assert.Equal(1.2f * 1.5f, seq.CurrentOmega.Z, 3); + } + + [Fact] + public void StopMotion_Turn_FiresTurnStopped_UnwindsModifierPhysics() + { + var seq = MakeSequencer(); + bool stopped = false; + var sink = new MotionTableDispatchSink(seq) { TurnStopped = () => stopped = true }; + + sink.ApplyMotion(Walk, 1.0f); + sink.ApplyMotion(TurnRight, 1.5f); + sink.StopMotion(TurnRight); + + Assert.True(stopped); + // StopSequenceMotion Case B (0x00522fc0): subtract_motion of the dat + // omega + modifier unlinked. + Assert.Equal(0f, seq.CurrentOmega.Z, 3); + } + + [Fact] + public void StopMotion_CurrentSubstate_ReDrivesToStyleDefault() + { + var seq = MakeSequencer(); + var sink = new MotionTableDispatchSink(seq); + + sink.ApplyMotion(Walk, 1.0f); + sink.StopMotion(Walk); + + // StopSequenceMotion Case A: stopping the active cycle re-drives + // GetObjectSequence toward the style default (Ready). + Assert.Equal(Ready, seq.CurrentMotion); + } + + [Fact] + public void ApplyMotion_MissingEverywhere_NoOp_DefaultKeepsPlaying() + { + var seq = MakeSequencer(withTurnModifier: false); + var sink = new MotionTableDispatchSink(seq); + + sink.ApplyMotion(Walk, 1.0f); + // 0x44000007 RunForward: no cycle, no modifier -> dispatch fails, + // sequence + state untouched (no fallback chain — H4/H5). + sink.ApplyMotion(0x44000007u, 2.0f); + + Assert.Equal(Walk, seq.CurrentMotion); + Assert.Equal(1.0f, seq.CurrentSpeedMod); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MotionTableManagerTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MotionTableManagerTests.cs new file mode 100644 index 00000000..ab4f44d5 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MotionTableManagerTests.cs @@ -0,0 +1,1018 @@ +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; +using Xunit; + +using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand; + +namespace AcDream.Core.Tests.Physics.Motion; + +// ───────────────────────────────────────────────────────────────────────────── +// MotionTableManagerTests — R2-Q3 conformance harness for the verbatim +// MotionTableManager pending-animation queue + tick-countdown completion +// machinery (r2-port-plan.md §3 Q3; oracle +// docs/research/2026-07-02-r2-motiontable/r2-motiontable-decomp.md §11). +// +// Fixture convention matches CMotionTableTests.cs's file-local Fixtures +// class. Most tests exercise MotionTableManager directly via its +// PendingAnimations/AnimationCounter inspection surface + a RecordingSink, +// bypassing GetObjectSequence entirely so the queue mechanics are pinned in +// isolation from the selection dispatcher (already covered by +// CMotionTableTests.cs). +// ───────────────────────────────────────────────────────────────────────────── + +file static class Fixtures +{ + public static Animation MakeAnim(int numFrames, int numParts, Vector3 origin, Quaternion orientation) + { + var anim = new Animation(); + for (int f = 0; f < numFrames; f++) + { + var pf = new AnimationFrame((uint)numParts); + for (int p = 0; p < numParts; p++) + pf.Frames.Add(new Frame { Origin = origin, Orientation = orientation }); + anim.PartFrames.Add(pf); + } + return anim; + } + + public static AnimData MakeAnimData(uint animId, float framerate) + => new() + { + AnimId = (QualifiedDataId)animId, + LowFrame = 0, + HighFrame = -1, + Framerate = framerate, + }; + + public static MotionData MakeMotionData(uint animId, float framerate, byte bitfield = 0) + { + var md = new MotionData { Bitfield = bitfield }; + md.Anims.Add(MakeAnimData(animId, framerate)); + return md; + } + + public static void AddLink(MotionTable mt, uint style, uint fromSubstate, uint toSubstate, MotionData data) + { + int outerKey = (int)((style << 16) | (fromSubstate & 0xFFFFFFu)); + if (!mt.Links.TryGetValue(outerKey, out var cmd)) + { + cmd = new MotionCommandData(); + mt.Links[outerKey] = cmd; + } + cmd.MotionData[(int)toSubstate] = data; + } + + public static void AddCycle(MotionTable mt, uint style, uint substate, MotionData data) + { + int key = (int)((style << 16) | (substate & 0xFFFFFFu)); + mt.Cycles[key] = data; + } +} + +/// Records every call in order. +internal sealed class RecordingSink : IMotionDoneSink +{ + public readonly List<(uint Motion, bool Success)> Calls = new(); + public void MotionDone(uint motion, bool success) => Calls.Add((motion, success)); +} + +/// In-memory that never resolves. +file sealed class NullLoader : IAnimationLoader +{ + public Animation? LoadAnimation(uint id) => null; +} + +/// In-memory test double. +file sealed class FakeLoader : IAnimationLoader +{ + private readonly Dictionary _anims = new(); + public void Register(uint id, Animation anim) => _anims[id] = anim; + public Animation? LoadAnimation(uint id) => _anims.TryGetValue(id, out var a) ? a : null; +} + +public sealed class MotionTableManagerTests +{ + // Real retail command words (DatReaderWriter.Enums.MotionCommand), + // matching CMotionTableTests.cs's fixture conventions. + private const uint Ready = 0x41000003u; // cycle, == ReadySentinel + private const uint WalkForward = 0x45000005u; // cycle + private const uint RunForward = 0x44000007u; // cycle + private const uint ThrustMed = 0x10000058u; // action only + private const uint NonCombatStyle = 0x8000003Du; // style, top bit set + private const uint HandCombatStyle = 0x8000003Cu; // style, top bit set + + private static (MotionTableManager mgr, RecordingSink sink, MotionState state, CSequence seq) MakeManager(CMotionTable? table = null) + { + var sink = new RecordingSink(); + var state = new MotionState(); + var seq = new CSequence(new NullLoader()); + var mgr = new MotionTableManager(table, state, seq, sink); + return (mgr, sink, state, seq); + } + + // ── add_to_queue / basic queueing ─────────────────────────────────── + + [Fact] + public void AddToQueue_AppendsNode_InOrder() + { + var (mgr, _, _, _) = MakeManager(); + + mgr.AddToQueue(WalkForward, 3); + mgr.AddToQueue(RunForward, 5); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(2, list.Count); + Assert.Equal(WalkForward, list[0].Motion); + Assert.Equal(3u, list[0].NumAnims); + Assert.Equal(RunForward, list[1].Motion); + Assert.Equal(5u, list[1].NumAnims); + } + + // ── countdown-chain: ONE AnimationDone completing MULTIPLE entries ── + + [Fact] + public void AnimationDone_CounterRollover_CompletesMultipleQueuedEntries_InOneCall() + { + // Two zero-duration-relative-to-each-other entries stacked so a + // single tick (counter=1) pops BOTH: first has NumAnims=1 (<=1 on + // the first increment), and after popping it counter -= 1 => back to + // 0... but decomp's while-loop re-tests the NEW head against the + // SAME counter value within the same AnimationDone call (no re- + // increment between pops) — so a second entry with NumAnims<=0 + // (i.e. 0) also pops in the same call. + var (mgr, sink, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 1); // pops when counter reaches 1 + mgr.AddToQueue(RunForward, 0); // zero-duration -> pops same call once counter>=0 + + mgr.AnimationDone(true); + + Assert.Equal(2, sink.Calls.Count); + Assert.Equal((WalkForward, true), sink.Calls[0]); + Assert.Equal((RunForward, true), sink.Calls[1]); + Assert.Empty(mgr.PendingAnimations); + // Drained-list counter reset. + Assert.Equal(0, mgr.AnimationCounter); + } + + [Fact] + public void AnimationDone_MultiTickCountdown_PopsOnlyWhenCounterReachesDuration() + { + var (mgr, sink, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 3); // needs counter >= 3 to pop + + mgr.AnimationDone(true); // counter=1 + Assert.Empty(sink.Calls); + Assert.Single(mgr.PendingAnimations); + Assert.Equal(1, mgr.AnimationCounter); + + mgr.AnimationDone(true); // counter=2 + Assert.Empty(sink.Calls); + Assert.Equal(2, mgr.AnimationCounter); + + mgr.AnimationDone(true); // counter=3 -> pops, counter -= 3 -> 0, list drains -> reset stays 0 + Assert.Single(sink.Calls); + Assert.Equal((WalkForward, true), sink.Calls[0]); + Assert.Empty(mgr.PendingAnimations); + Assert.Equal(0, mgr.AnimationCounter); + } + + [Fact] + public void AnimationDone_LeftoverCounter_ResetOnlyWhenListFullyDrains() + { + // Two entries: first pops on tick 1 (duration 1), second needs + // duration 5. After the first pop, counter = 1 - 1 = 0, but the + // list is NOT empty (second entry remains) -> counter must NOT be + // force-reset to something else; it stays at the algebraic value (0). + var (mgr, sink, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 1); + mgr.AddToQueue(RunForward, 5); + + mgr.AnimationDone(true); // counter=1 -> pops Walk (1<=1), counter -= 1 = 0; Run(5) remains, 0<=5? no. + + Assert.Single(sink.Calls); + Assert.Equal((WalkForward, true), sink.Calls[0]); + Assert.Single(mgr.PendingAnimations); + Assert.Equal(RunForward, mgr.PendingAnimations.First().Motion); + Assert.Equal(0, mgr.AnimationCounter); + } + + [Fact] + public void AnimationDone_EmptyQueue_IsNoOp() + { + var (mgr, sink, _, _) = MakeManager(); + + mgr.AnimationDone(true); + + Assert.Empty(sink.Calls); + Assert.Equal(0, mgr.AnimationCounter); + } + + // ── zero-tick sweep (CheckForCompletedMotions) vs counter sweep (AnimationDone) ── + + [Fact] + public void CheckForCompletedMotions_PopsOnlyZeroTickHeads_NeverIncrementsCounter() + { + var (mgr, sink, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 0); // zero-tick: pops immediately + mgr.AddToQueue(RunForward, 2); // non-zero: stays + + mgr.CheckForCompletedMotions(); + + Assert.Single(sink.Calls); + Assert.Equal((WalkForward, true), sink.Calls[0]); // success hardcoded true + Assert.Single(mgr.PendingAnimations); + Assert.Equal(RunForward, mgr.PendingAnimations.First().Motion); + Assert.Equal(0, mgr.AnimationCounter); // untouched + } + + [Fact] + public void CheckForCompletedMotions_NonZeroHead_DoesNotPop() + { + var (mgr, sink, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 4); + + mgr.CheckForCompletedMotions(); + + Assert.Empty(sink.Calls); + Assert.Single(mgr.PendingAnimations); + } + + [Fact] + public void UseTime_IsAliasFor_CheckForCompletedMotions() + { + var (mgr, sink, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 0); + + mgr.UseTime(); + + Assert.Single(sink.Calls); + Assert.Equal((WalkForward, true), sink.Calls[0]); + } + + [Fact] + public void AnimationDone_Distinguished_FromCheckForCompletedMotions_ByCounterUse() + { + // A node with NumAnims=1 does NOT pop via CheckForCompletedMotions + // (which only pops EXACTLY zero), but DOES pop via one AnimationDone + // tick (counter reaches 1). + var (mgrA, sinkA, _, _) = MakeManager(); + mgrA.AddToQueue(WalkForward, 1); + mgrA.CheckForCompletedMotions(); + Assert.Empty(sinkA.Calls); + Assert.Single(mgrA.PendingAnimations); + + var (mgrB, sinkB, _, _) = MakeManager(); + mgrB.AddToQueue(WalkForward, 1); + mgrB.AnimationDone(true); + Assert.Single(sinkB.Calls); + Assert.Empty(mgrB.PendingAnimations); + } + + // ── action-class completion pops MotionState's action FIFO ────────── + + [Fact] + public void AnimationDone_ActionClassMotion_PopsActionHead() + { + var (mgr, sink, state, _) = MakeManager(); + state.AddAction(ThrustMed, 1f); + Assert.Single(state.Actions); + + mgr.AddToQueue(ThrustMed, 0); // zero-duration -> pops on first tick + + mgr.AnimationDone(true); + + Assert.Empty(state.Actions); // popped + Assert.Single(sink.Calls); + Assert.Equal((ThrustMed, true), sink.Calls[0]); + } + + [Fact] + public void CheckForCompletedMotions_ActionClassMotion_PopsActionHead() + { + var (mgr, sink, state, _) = MakeManager(); + state.AddAction(ThrustMed, 1f); + + mgr.AddToQueue(ThrustMed, 0); + mgr.CheckForCompletedMotions(); + + Assert.Empty(state.Actions); + Assert.Single(sink.Calls); + } + + [Fact] + public void AnimationDone_NonActionClassMotion_DoesNotTouchActionFifo() + { + var (mgr, _, state, _) = MakeManager(); + state.AddAction(ThrustMed, 1f); + + mgr.AddToQueue(WalkForward, 0); // cycle-class, not action-class + mgr.AnimationDone(true); + + Assert.Single(state.Actions); // untouched + } + + // ── enter/exit-world drains fire MotionDone(success=false) ────────── + + [Fact] + public void HandleExitWorld_DrainsEntireQueue_FiringMotionDoneFalse_ForEveryEntry() + { + var (mgr, sink, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 0); + mgr.AddToQueue(RunForward, 0); + mgr.AddToQueue(ThrustMed, 0); + + mgr.HandleExitWorld(); + + Assert.Equal(3, sink.Calls.Count); + Assert.All(sink.Calls, c => Assert.False(c.Success)); + Assert.Empty(mgr.PendingAnimations); + } + + [Fact] + public void HandleExitWorld_NonZeroDurationEntries_StillFullyDrained() + { + // Drain loops AnimationDone(false) until head_==0, incrementing the + // counter each call — even non-zero-duration entries eventually pop. + var (mgr, sink, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 3); + + mgr.HandleExitWorld(); + + Assert.Single(sink.Calls); + Assert.Equal((WalkForward, false), sink.Calls[0]); + Assert.Empty(mgr.PendingAnimations); + } + + [Fact] + public void HandleEnterWorld_DrainsQueue_AndStripsLinkAnimations() + { + var loader = new FakeLoader(); + uint linkAnim = 0x03000200u, cycleAnim = 0x03000201u; + loader.Register(linkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(cycleAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var sink = new RecordingSink(); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(loader); + // Build a link + cyclic tail directly (bypassing GetObjectSequence). + CMotionTable.AddMotion(seq, Fixtures.MakeMotionData(linkAnim, 30f), 1f); + CMotionTable.AddMotion(seq, Fixtures.MakeMotionData(cycleAnim, 30f), 1f); + Assert.Equal(2, seq.Count); + + var mgr = new MotionTableManager(null, state, seq, sink); + mgr.AddToQueue(WalkForward, 0); + + mgr.HandleEnterWorld(); + + // Queue drained, MotionDone(false) fired. + Assert.Single(sink.Calls); + Assert.False(sink.Calls[0].Success); + Assert.Empty(mgr.PendingAnimations); + // Link animation stripped — only the cyclic tail remains. + Assert.Equal(1, seq.Count); + } + + [Fact] + public void HandleEnterWorld_EmptyQueue_StillStripsLinkAnimations_NoOpOnDrain() + { + var loader = new FakeLoader(); + uint linkAnim = 0x03000210u, cycleAnim = 0x03000211u; + loader.Register(linkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(cycleAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var sink = new RecordingSink(); + var state = new MotionState(); + var seq = new CSequence(loader); + CMotionTable.AddMotion(seq, Fixtures.MakeMotionData(linkAnim, 30f), 1f); + CMotionTable.AddMotion(seq, Fixtures.MakeMotionData(cycleAnim, 30f), 1f); + + var mgr = new MotionTableManager(null, state, seq, sink); + + mgr.HandleEnterWorld(); + + Assert.Empty(sink.Calls); + Assert.Equal(1, seq.Count); // link stripped, cyclic tail remains + } + + // ── truncate blocked/allowed matrices for BOTH class masks ────────── + + [Fact] + public void RemoveRedundantLinks_CycleClassTail_EarlierSameMotion_NoBlocker_Truncates() + { + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 5); // earlier same-motion, non-zero + mgr.AddToQueue(WalkForward, 3); // new tail, same motion -> matches the + // earlier node immediately (no + // intervening node to block) -> + // truncate walks tail_..matched + // EXCLUSIVE, so the TAIL node itself + // (this new entry) is in the walked + // range and gets zeroed; the earlier + // matched node (the stop boundary) + // is untouched. + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(2, list.Count); + Assert.Equal(5u, list[0].NumAnims); // matched node (stop boundary) untouched + Assert.Equal(0u, list[1].NumAnims); // the redundant re-issue itself, zeroed + } + + [Fact] + public void RemoveRedundantLinks_CycleClassTail_WithInterveningZeroTickNode_Truncates() + { + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 5); // earlier match + mgr.AddToQueue(ThrustMed, 0); // intervening, ZERO ticks -> does not block (only non-zero blocks) + mgr.AddToQueue(WalkForward, 3); // new tail, same motion + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(3, list.Count); + Assert.Equal(5u, list[0].NumAnims); // matched node (stop boundary) untouched + Assert.Equal(0u, list[1].NumAnims); // already zero (unaffected either way) + Assert.Equal(0u, list[2].NumAnims); // the new tail — ALSO in the truncation range + // (truncate walks tail..matched EXCLUSIVE, so + // the tail itself IS zeroed too) + } + + [Fact] + public void RemoveRedundantLinks_CycleClassTail_InterveningDifferentCycle_NotBlocked_Truncates() + { + // Bit decomposition (verified): 0xb0000000 == STYLE(0x80000000) | + // MODIFIER(0x20000000) | ACTION(0x10000000) — it deliberately + // EXCLUDES the cycle-class bit (0x40000000) itself. So a DIFFERENT + // intervening CYCLE (RunForward) does NOT block a WalkForward + // cycle-tail scan; two cycles naturally supersede each other via the + // base-cycle rebuild mechanism. + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 5); // earlier match candidate + mgr.AddToQueue(RunForward, 4); // intervening, non-zero, CYCLE-class but not in 0xb0000000 -> does not block + mgr.AddToQueue(WalkForward, 3); // new tail, same motion as the earlier node + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(3, list.Count); + Assert.Equal(5u, list[0].NumAnims); // matched (stop boundary), untouched + Assert.Equal(0u, list[1].NumAnims); // truncated — RunForward zeroed + Assert.Equal(0u, list[2].NumAnims); // truncated — the new tail itself zeroed + } + + [Fact] + public void RemoveRedundantLinks_CycleClassTail_BlockedByInterveningNonZeroModifierClassNode() + { + // 0xb0000000 DOES include the modifier-class bit (0x20000000) — a + // pure modifier-class node with non-zero ticks blocks a cycle-tail + // collapse (can't safely erase an active modifier's queue entry). + var (mgr, _, _, _) = MakeManager(); + const uint pureModifier = 0x20000099u; // modifier-class only, no cycle/action/style bits + mgr.AddToQueue(WalkForward, 5); + mgr.AddToQueue(pureModifier, 2); // non-zero, matches 0xb0000000 -> BLOCKS + mgr.AddToQueue(WalkForward, 3); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(3, list.Count); + // Blocked -> nothing truncated, all NumAnims preserved as queued. + Assert.Equal(5u, list[0].NumAnims); + Assert.Equal(2u, list[1].NumAnims); + Assert.Equal(3u, list[2].NumAnims); + } + + [Fact] + public void RemoveRedundantLinks_CycleClassTail_BlockedByInterveningNonZeroActionClassNode() + { + // 0xb0000000 also includes the action-class bit (0x10000000). + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 5); + mgr.AddToQueue(ThrustMed, 2); // non-zero, action-class -> matches 0xb0000000 -> BLOCKS + mgr.AddToQueue(WalkForward, 3); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(3, list.Count); + Assert.Equal(5u, list[0].NumAnims); + Assert.Equal(2u, list[1].NumAnims); // untouched — blocked + Assert.Equal(3u, list[2].NumAnims); // untouched — blocked + } + + [Fact] + public void RemoveRedundantLinks_CycleClassTail_BlockedByInterveningNonZeroStyleClassNode() + { + // 0xb0000000 also includes the style-class top bit (0x80000000). + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 5); + mgr.AddToQueue(HandCombatStyle, 2); // non-zero, style-class -> matches 0xb0000000 -> BLOCKS + mgr.AddToQueue(WalkForward, 3); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(3, list.Count); + Assert.Equal(5u, list[0].NumAnims); + Assert.Equal(2u, list[1].NumAnims); + Assert.Equal(3u, list[2].NumAnims); + } + + [Fact] + public void RemoveRedundantLinks_StyleClassTail_EarlierSameMotion_Truncates() + { + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(HandCombatStyle, 5); // style-class (top bit set), earlier match + mgr.AddToQueue(ThrustMed, 0); // zero-tick intervening, no block + mgr.AddToQueue(HandCombatStyle, 3); // new tail, same style motion + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(3, list.Count); + Assert.Equal(5u, list[0].NumAnims); + Assert.Equal(0u, list[1].NumAnims); + Assert.Equal(0u, list[2].NumAnims); + } + + [Fact] + public void RemoveRedundantLinks_StyleClassTail_BlockedByInterveningNonZeroModifierClassNode() + { + // Style-class tail scan blocks on the WIDER 0x70000000 mask + // (cycle|action|modifier) -- a pure modifier-class node DOES block + // here, unlike the cycle-class tail scan above. + var (mgr, _, _, _) = MakeManager(); + const uint pureModifier = 0x20000099u; + mgr.AddToQueue(HandCombatStyle, 5); + mgr.AddToQueue(pureModifier, 2); // non-zero, matches 0x70000000 -> BLOCKS + mgr.AddToQueue(HandCombatStyle, 3); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(3, list.Count); + Assert.Equal(5u, list[0].NumAnims); + Assert.Equal(2u, list[1].NumAnims); // untouched — blocked + Assert.Equal(3u, list[2].NumAnims); // untouched — blocked + } + + [Fact] + public void RemoveRedundantLinks_StyleClassTail_BlockedByInterveningNonZeroCycleClassNode() + { + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(HandCombatStyle, 5); + mgr.AddToQueue(WalkForward, 4); // non-zero, cycle-class -> matches 0x70000000 too -> BLOCKS + mgr.AddToQueue(HandCombatStyle, 3); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(3, list.Count); + Assert.Equal(5u, list[0].NumAnims); + Assert.Equal(4u, list[1].NumAnims); + Assert.Equal(3u, list[2].NumAnims); + } + + [Fact] + public void RemoveRedundantLinks_NoEarlierMatch_ScanExhausts_NoTruncation() + { + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(RunForward, 4); + mgr.AddToQueue(WalkForward, 3); // no earlier WalkForward anywhere + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(2, list.Count); + Assert.Equal(4u, list[0].NumAnims); + Assert.Equal(3u, list[1].NumAnims); + } + + [Fact] + public void RemoveRedundantLinks_TrailingZeroTickNodesSkipped_BeforeScanning() + { + // Tail itself is zero-tick -> skip backward past it to find the + // "effective tail" for the class dispatch. + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 5); + mgr.AddToQueue(WalkForward, 0); // trailing zero-tick — skipped as "effective tail" search + + var list = mgr.PendingAnimations.ToList(); + // Effective tail (after skip) = list[0] (WalkForward, 5) itself — + // scanning backward from it finds nothing earlier -> no truncation. + Assert.Equal(2, list.Count); + Assert.Equal(5u, list[0].NumAnims); + Assert.Equal(0u, list[1].NumAnims); + } + + [Fact] + public void RemoveRedundantLinks_AllZeroTickNodes_ScanBottomsOut_ReturnsQuietly() + { + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 0); + mgr.AddToQueue(RunForward, 0); + + // Must not throw; nothing to truncate. + mgr.RemoveRedundantLinks(); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(2, list.Count); + Assert.Equal(0u, list[0].NumAnims); + Assert.Equal(0u, list[1].NumAnims); + } + + [Fact] + public void RemoveRedundantLinks_EmptyQueue_IsNoOp() + { + var (mgr, _, _, _) = MakeManager(); + mgr.RemoveRedundantLinks(); // must not throw + Assert.Empty(mgr.PendingAnimations); + } + + [Fact] + public void RemoveRedundantLinks_ModifierOrActionClassTail_NoScanPerformed() + { + // A pure modifier-class or action-class tail motion takes NEITHER + // the cycle-tail nor the style-tail branch in retail -> no scan, no + // truncation, regardless of what precedes it. + var (mgr, _, _, _) = MakeManager(); + const uint pureModifier = 0x20000099u; + mgr.AddToQueue(pureModifier, 5); + mgr.AddToQueue(pureModifier, 3); // same motion id repeated, but tail is modifier-class -> no truncation path + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(2, list.Count); + Assert.Equal(5u, list[0].NumAnims); + Assert.Equal(3u, list[1].NumAnims); + } + + // ── truncate_animation_list: zeroes in place, nodes stay queued ───── + + [Fact] + public void Truncate_ViaRedundantCollapse_NodesStayQueued_OnlyNumAnimsZeroed() + { + // RunForward is a DIFFERENT cycle-class motion — not in the + // 0xb0000000 cycle-tail block mask (which excludes the cycle bit) — + // so it does not block WalkForward's re-match scan and gets + // truncated (zeroed in place, still queued) along with the tail. + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 5); + mgr.AddToQueue(RunForward, 2); // will get zeroed but not removed + mgr.AddToQueue(WalkForward, 3); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(3, list.Count); // node count UNCHANGED — truncate never unlinks + Assert.Equal(RunForward, list[1].Motion); // motion id preserved, only NumAnims zeroed + Assert.Equal(0u, list[1].NumAnims); + } + + [Fact] + public void Truncate_StripsLinkAnimationsFromSequence_ByTotalRemovedTicks() + { + var loader = new FakeLoader(); + uint link1 = 0x03000300u, link2 = 0x03000301u, cyc = 0x03000302u; + loader.Register(link1, Fixtures.MakeAnim(1, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(link2, Fixtures.MakeAnim(1, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(cyc, Fixtures.MakeAnim(1, 1, Vector3.Zero, Quaternion.Identity)); + + var sink = new RecordingSink(); + var state = new MotionState(); + var seq = new CSequence(loader); + // Build a 3-node sequence: link1, link2 (both before first_cyclic-ish), + // cyc (the cyclic tail — append_animation slides first_cyclic to it). + CMotionTable.AddMotion(seq, Fixtures.MakeMotionData(link1, 30f), 1f); + CMotionTable.AddMotion(seq, Fixtures.MakeMotionData(link2, 30f), 1f); + CMotionTable.AddMotion(seq, Fixtures.MakeMotionData(cyc, 30f), 1f); + Assert.Equal(3, seq.Count); + + var mgr = new MotionTableManager(null, state, seq, sink); + mgr.AddToQueue(WalkForward, 2); // earlier match, non-zero + mgr.AddToQueue(WalkForward, 2); // new tail, same motion -> truncates the earlier + // one's successor range (which is just this + // node itself, ticks=2) -> RemoveLinkAnimations(2) + + // RemoveLinkAnimations(2) removes up to 2 predecessors of first_cyclic + // (link2, then link1) from the live sequence. + Assert.Equal(1, seq.Count); // only the cyclic tail (cyc) remains + } + + // ── rapid same-motion re-issue -> collapse (Fix B replacement proof) ── + + [Fact] + public void RapidSameMotionReissue_ThroughAddToQueue_CollapsesRedundantMiddleNodes() + { + // Enqueue walk, run, walk, run quickly. Bit decomposition of the + // cycle-tail block mask (0xb0000000 = STYLE|MODIFIER|ACTION, + // deliberately EXCLUDING the cycle bit 0x40000000): a DIFFERENT + // real cycle in between does NOT block a cycle-tail scan, so: + // 1. add W(5) -> [W5] + // 2. add R(4): tail=R, scan W5 -> no match (diff motion), no + // block (W not in 0xb0000000) -> scan exhausts -> [W5,R4] + // 3. add W(3): tail=W, scan R4 -> no match, no block -> scan W5 + // -> MATCH (same motion, non-zero) -> truncate(W5..tail + // exclusive) zeroes R4 and this new W3 -> [W5, R0, W0] + // 4. add R(2): tail=R, scan W0(NumAnims=0, fails the non-zero + // match requirement) -> no block (0 ticks) -> scan R0 + // (NumAnims=0, fails non-zero match requirement too) -> no + // block -> scan W5 -> no match (diff motion), no block -> + // scan exhausts -> nothing new truncated -> [W5, R0, W0, R2] + // This is the Fix-B-replacement proof: the FIRST redundant + // walk->run->walk sequence collapses down to just the original + // WalkForward(5) plus the freshly-added RunForward(2) — matching + // "rapid re-issue of the same locomotion collapses" without + // inventing a bespoke locomotion-low-byte special case (H6). + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 5); + mgr.AddToQueue(RunForward, 4); + mgr.AddToQueue(WalkForward, 3); + mgr.AddToQueue(RunForward, 2); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(4, list.Count); + Assert.Equal(5u, list[0].NumAnims); // original WalkForward — the surviving anchor + Assert.Equal(0u, list[1].NumAnims); // RunForward — truncated by step 3's collapse + Assert.Equal(0u, list[2].NumAnims); // WalkForward (re-issue) — truncated by step 3's collapse + Assert.Equal(2u, list[3].NumAnims); // newest RunForward — survives (its own scan found no match) + } + + [Fact] + public void RapidSameMotionReissue_ZeroTickIntervening_DoesCollapse() + { + // When the intervening entries are ZERO-tick (already-instant / a + // fast-path re-speed that queued 0 outTicks), the scan is NOT + // blocked (only non-zero nodes block) and the collapse proceeds — + // this IS the realistic Fix-B-replacement shape: rapid re-speeds of + // the SAME cycle produce zero-outTicks entries between the real + // queue events. + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 5); + mgr.AddToQueue(WalkForward, 0); // e.g. a fast-path re-speed, zero outTicks + mgr.AddToQueue(WalkForward, 3); // new tail, same motion + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(3, list.Count); + Assert.Equal(5u, list[0].NumAnims); // matched node preserved + Assert.Equal(0u, list[1].NumAnims); // already zero + Assert.Equal(0u, list[2].NumAnims); // truncated + } + + // ── the 2026-05-03 golden: cyclic->cyclic walk->run, truncate NOT firing ── + + [Fact] + public void Golden_CyclicToCyclicWalkThenRun_BothNodesQueued_TruncateNotFiring() + { + // Quoted golden (Fix B comment block, r2-port-plan.md H6): cyclic-> + // cyclic transitions produce add_to_queue(0x45000005) [WalkForward] + // followed by add_to_queue(0x44000007) [RunForward], with truncate + // NOT firing (different motion ids -> remove_redundant_links' match + // test never succeeds). + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 3); + mgr.AddToQueue(RunForward, 4); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(2, list.Count); + Assert.Equal(WalkForward, list[0].Motion); + Assert.Equal(3u, list[0].NumAnims); // untouched — no truncation + Assert.Equal(RunForward, list[1].Motion); + Assert.Equal(4u, list[1].NumAnims); // untouched + } + + // ── initialize_state ────────────────────────────────────────────── + + [Fact] + public void InitializeState_QueuesReadySentinel_WithSetDefaultStateOutTicks() + { + var loader = new FakeLoader(); + uint readyAnim = 0x03000400u; + loader.Register(readyAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, Ready, Fixtures.MakeMotionData(readyAnim, 30f)); + + var cmt = new CMotionTable(mt); + var sink = new RecordingSink(); + var state = new MotionState(); + var seq = new CSequence(loader); + var mgr = new MotionTableManager(cmt, state, seq, sink); + + mgr.InitializeState(); + + Assert.Equal(NonCombatStyle, state.Style); + Assert.Equal(Ready, state.Substate); + Assert.Single(mgr.PendingAnimations); + var node = mgr.PendingAnimations.First(); + Assert.Equal(MotionTableManager.ReadySentinel, node.Motion); + // SetDefaultState outTicks = cyclic.num_anims - 1 = 1 - 1 = 0. + Assert.Equal(0u, node.NumAnims); + } + + [Fact] + public void InitializeState_NoTableLoaded_QueuesSentinelWithZeroTicks_NoThrow() + { + var sink = new RecordingSink(); + var state = new MotionState(); + var seq = new CSequence(new NullLoader()); + var mgr = new MotionTableManager(null, state, seq, sink); + + mgr.InitializeState(); + + Assert.Single(mgr.PendingAnimations); + Assert.Equal(MotionTableManager.ReadySentinel, mgr.PendingAnimations.First().Motion); + Assert.Equal(0u, mgr.PendingAnimations.First().NumAnims); + } + + // ── PerformMovement error-code matrix ──────────────────────────────── + + [Fact] + public void PerformMovement_NoTableLoaded_ReturnsError7() + { + var (mgr, _, _, _) = MakeManager(table: null); + + uint result = mgr.PerformMovement(MotionTableMovement.Interpreted(WalkForward, 1f)); + + Assert.Equal(MotionTableManagerError.NoTable, result); + Assert.Equal(7u, result); + } + + [Fact] + public void PerformMovement_InterpretedCommand_Success_QueuesMotionWithOutTicks_ReturnsZero() + { + var loader = new FakeLoader(); + uint readyAnim = 0x03000500u, walkAnim = 0x03000501u, linkAnim = 0x03000502u; + loader.Register(readyAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(walkAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(linkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, Ready, Fixtures.MakeMotionData(readyAnim, 30f)); + Fixtures.AddCycle(mt, NonCombatStyle, WalkForward, Fixtures.MakeMotionData(walkAnim, 30f)); + Fixtures.AddLink(mt, NonCombatStyle, Ready, WalkForward, Fixtures.MakeMotionData(linkAnim, 30f)); + + var cmt = new CMotionTable(mt); + var sink = new RecordingSink(); + var state = new MotionState { Style = NonCombatStyle, Substate = Ready, SubstateMod = 1f }; + var seq = new CSequence(loader); + var mgr = new MotionTableManager(cmt, state, seq, sink); + + uint result = mgr.PerformMovement(MotionTableMovement.Interpreted(WalkForward, 1f)); + + Assert.Equal(MotionTableManagerError.Success, result); + Assert.Equal(WalkForward, state.Substate); + Assert.Single(mgr.PendingAnimations); + Assert.Equal(WalkForward, mgr.PendingAnimations.First().Motion); + // outTicks = link(1) + cycle(1) - 1 = 1 + Assert.Equal(1u, mgr.PendingAnimations.First().NumAnims); + } + + [Fact] + public void PerformMovement_InterpretedCommand_Failure_ReturnsError0x43_NoQueue() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + // No cycles registered at all -> DoObjectMotion fails. + var cmt = new CMotionTable(mt); + var (mgr, _, state, _) = MakeManager(cmt); + state.Style = NonCombatStyle; + state.Substate = Ready; + state.SubstateMod = 1f; + + uint result = mgr.PerformMovement(MotionTableMovement.Interpreted(WalkForward, 1f)); + + Assert.Equal(MotionTableManagerError.MotionFailed, result); + Assert.Equal(0x43u, result); + Assert.Empty(mgr.PendingAnimations); + } + + [Fact] + public void PerformMovement_StopInterpretedCommand_Success_QueuesReadySentinel() + { + var loader = new FakeLoader(); + uint runAnim = 0x03000510u, readyAnim = 0x03000511u, exitLinkAnim = 0x03000512u; + loader.Register(runAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(readyAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(exitLinkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, RunForward, Fixtures.MakeMotionData(runAnim, 30f)); + Fixtures.AddCycle(mt, NonCombatStyle, Ready, Fixtures.MakeMotionData(readyAnim, 30f)); + Fixtures.AddLink(mt, NonCombatStyle, RunForward, Ready, Fixtures.MakeMotionData(exitLinkAnim, 30f)); + + var cmt = new CMotionTable(mt); + var sink = new RecordingSink(); + var state = new MotionState { Style = NonCombatStyle, Substate = RunForward, SubstateMod = 1f }; + var seq = new CSequence(loader); + var mgr = new MotionTableManager(cmt, state, seq, sink); + Assert.True(cmt.DoObjectMotion(RunForward, state, seq, 1f, out _)); + + uint result = mgr.PerformMovement(MotionTableMovement.StopInterpreted(RunForward, 1f)); + + Assert.Equal(MotionTableManagerError.Success, result); + Assert.Equal(Ready, state.Substate); // re-driven to style default + Assert.Single(mgr.PendingAnimations); + Assert.Equal(MotionTableManager.ReadySentinel, mgr.PendingAnimations.First().Motion); + } + + [Fact] + public void PerformMovement_StopInterpretedCommand_Failure_ReturnsError0x43_NoQueue() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + var cmt = new CMotionTable(mt); + var (mgr, _, state, _) = MakeManager(cmt); + // No modifier and no matching current substate -> StopObjectMotion fails. + state.Style = NonCombatStyle; + state.Substate = Ready; + state.SubstateMod = 1f; + const uint unrelatedModifier = 0x20000099u; + + uint result = mgr.PerformMovement(MotionTableMovement.StopInterpreted(unrelatedModifier, 1f)); + + Assert.Equal(MotionTableManagerError.MotionFailed, result); + Assert.Empty(mgr.PendingAnimations); + } + + [Fact] + public void PerformMovement_StopCompletely_UnconditionallyQueuesReadySentinel_EvenOnNoOpStop() + { + // Even when StopObjectCompletely finds nothing to stop (returns + // false), PerformMovement STILL queues the Ready sentinel + // unconditionally (decomp §11 note) and returns success. + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + // No StyleDefaults entry -> the final StopSequenceMotion(substate=0,...) + // call inside StopObjectCompletely can't resolve a style default either, + // but that's fine: Case A requires substate==0x40000000-class AND == + // state.Substate; with Substate=0 (default MotionState ctor) neither + // stop mechanism matches anything -> both return false -> overall false. + var cmt = new CMotionTable(mt); + var (mgr, _, state, _) = MakeManager(cmt); + // state.Substate stays 0 (default) -> StopObjectCompletely no-ops. + + uint result = mgr.PerformMovement(MotionTableMovement.StopCompletely()); + + Assert.Equal(MotionTableManagerError.Success, result); + Assert.Single(mgr.PendingAnimations); + Assert.Equal(MotionTableManager.ReadySentinel, mgr.PendingAnimations.First().Motion); + } + + [Fact] + public void PerformMovement_StopCompletely_DrainsModifiers_QueuesReadySentinel() + { + var loader = new FakeLoader(); + uint runAnim = 0x03000520u, readyAnim = 0x03000521u, exitLinkAnim = 0x03000522u; + loader.Register(runAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(readyAnim, Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity)); + loader.Register(exitLinkAnim, Fixtures.MakeAnim(2, 1, Vector3.Zero, Quaternion.Identity)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + mt.StyleDefaults[(DRWMotionCommand)NonCombatStyle] = (DRWMotionCommand)Ready; + Fixtures.AddCycle(mt, NonCombatStyle, RunForward, Fixtures.MakeMotionData(runAnim, 30f)); + Fixtures.AddCycle(mt, NonCombatStyle, Ready, Fixtures.MakeMotionData(readyAnim, 30f)); + Fixtures.AddLink(mt, NonCombatStyle, RunForward, Ready, Fixtures.MakeMotionData(exitLinkAnim, 30f)); + + var cmt = new CMotionTable(mt); + var sink = new RecordingSink(); + var state = new MotionState { Style = NonCombatStyle, Substate = RunForward, SubstateMod = 1f }; + var seq = new CSequence(loader); + var mgr = new MotionTableManager(cmt, state, seq, sink); + Assert.True(cmt.DoObjectMotion(RunForward, state, seq, 1f, out _)); + + uint result = mgr.PerformMovement(MotionTableMovement.StopCompletely()); + + Assert.Equal(MotionTableManagerError.Success, result); + Assert.Equal(Ready, state.Substate); + Assert.Single(mgr.PendingAnimations); + Assert.Equal(MotionTableManager.ReadySentinel, mgr.PendingAnimations.First().Motion); + } + + [Fact] + public void PerformMovement_UnhandledType_ReturnsNotHandled_NoQueue() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + var cmt = new CMotionTable(mt); + var (mgr, _, _, _) = MakeManager(cmt); + + uint result = mgr.PerformMovement(new MotionTableMovement(MovementType.RawCommand, WalkForward, 1f)); + + Assert.Equal(MotionTableManagerError.NotHandled, result); + Assert.Empty(mgr.PendingAnimations); + } + + [Fact] + public void PerformMovement_StopRawCommand_ReturnsNotHandled() + { + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombatStyle }; + var cmt = new CMotionTable(mt); + var (mgr, _, _, _) = MakeManager(cmt); + + uint result = mgr.PerformMovement(new MotionTableMovement(MovementType.StopRawCommand, WalkForward, 1f)); + + Assert.Equal(MotionTableManagerError.NotHandled, result); + } + + // ── AddToQueue calls RemoveRedundantLinks immediately (opportunistic) ── + + [Fact] + public void AddToQueue_CallsRemoveRedundantLinks_Immediately_NotDeferred() + { + var (mgr, _, _, _) = MakeManager(); + mgr.AddToQueue(WalkForward, 5); + mgr.AddToQueue(ThrustMed, 0); + + // Adding a third same-motion WalkForward should IMMEDIATELY trigger + // the collapse as part of THIS AddToQueue call (not deferred to a + // later explicit RemoveRedundantLinks() call). + mgr.AddToQueue(WalkForward, 3); + + var list = mgr.PendingAnimations.ToList(); + Assert.Equal(0u, list[1].NumAnims); // already truncated by the time AddToQueue returns + Assert.Equal(0u, list[2].NumAnims); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerArrivalAndProgressTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerArrivalAndProgressTests.cs new file mode 100644 index 00000000..7d9fcc0a --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerArrivalAndProgressTests.cs @@ -0,0 +1,295 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — HandleMoveToPosition Phase 2 (00529d80, raw +/// 307283-307331) and CheckProgressMade (005290f0, raw +/// 306385-306431), per r4-moveto-decomp.md §6b/§5b: arrival predicate +/// (chase dist <= DistanceToObject vs flee +/// dist >= MinDistance), fail-distance ( +/// 0x3D), and the 1-second / 0.25-units-per-second progress window (BOTH +/// incremental AND overall rates). +/// +public sealed class MoveToManagerArrivalAndProgressTests +{ + // ── CheckProgressMade — the progress-clock table (§5b) ───────────────── + + [Fact] + public void CheckProgressMade_WithinOneSecondWindow_AlwaysTrue_TooSoonToJudge() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters { UseSpheres = false }); + + h.Advance(0.5); // < 1.0s since PreviousDistanceTime + + Assert.True(h.Manager.CheckProgressMade(currentDistance: 19.9f)); + } + + [Fact] + public void CheckProgressMade_ExactlyOneSecond_StillTooSoon_Inclusive() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters { UseSpheres = false }); + + h.Advance(1.0); // elapsed <= 1.0 -> still true (§5b: "elapsed <= 1.0 -> return 1") + + Assert.True(h.Manager.CheckProgressMade(currentDistance: 19.9f)); + } + + [Fact] + public void CheckProgressMade_AfterWindow_SufficientIncrementalAndOverallRate_True() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters { UseSpheres = false }); + + // PreviousDistance/OriginalDistance seeded to 20 at t=0. + h.Advance(2.0); // 2s elapsed + + // Closed 1 unit/s over 2s = 2 units closed -> rate 1.0 >= 0.25 both ways. + bool progress = h.Manager.CheckProgressMade(currentDistance: 18f); + + Assert.True(progress); + Assert.Equal(0u, h.Manager.FailProgressCount); + Assert.Equal(18f, h.Manager.PreviousDistance, 2); // incremental checkpoint advanced + } + + [Fact] + public void CheckProgressMade_InsufficientIncrementalRate_False_CheckpointDoesNotAdvance() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters { UseSpheres = false }); + + h.Advance(2.0); + + // Closed only 0.1 unit over 2s -> rate 0.05 < 0.25 -> no progress; + // checkpoint (PreviousDistance) must NOT advance. + bool progress = h.Manager.CheckProgressMade(currentDistance: 19.9f); + + Assert.False(progress); + Assert.Equal(20f, h.Manager.PreviousDistance, 2); // unchanged + } + + [Fact] + public void CheckProgressMade_GoodIncrementalButBadOverallRate_False() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters { UseSpheres = false }); + + // OriginalDistance/OriginalDistanceTime were seeded to (20, t=0) by + // BeginMoveForward and NEVER move again except on arrival/retarget — + // only PreviousDistance (the incremental checkpoint) advances on a + // passing tick. Simulate a long slow crawl: many small incremental + // passes that each individually clear 0.25/s over their own 1s+ + // window, but the OVERALL rate since t=0 stays under 0.25/s because + // the total elapsed time dominates. + h.Advance(2.0); + Assert.True(h.Manager.CheckProgressMade(19f)); // incremental 0.5/s since t=0 — overall also 0.5/s here, still passes. + + // Now advance a huge amount of time with only a tiny further close — + // incremental since the LAST checkpoint (t=2, dist=19) is healthy + // relative to its own short window, but overall since t=0 (dist 20) + // over the huge elapsed time is far under 0.25/s. + h.Advance(200.0); + bool progress = h.Manager.CheckProgressMade(18.9f); // incremental: 0.1/200s -> fails incremental too in this construction; assert false either way (both gates must independently pass). + + Assert.False(progress); + } + + [Fact] + public void CheckProgressMade_MovingAway_UsesOpeningDistance() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + // pure-away move: MoveTowards=false, MoveAway=true, MinDistance large + // so get_command picks WalkForward+movingAway. + var p = new MovementParameters { MoveTowards = false, MoveAway = true, MinDistance = 50f, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), p); + Assert.True(h.Manager.MovingAway); + + h.Advance(2.0); + // Distance to the (now-behind) target GREW from ~20 to 25 -> opening + // at 2.5/s -> progress (moving_away: progress = curr - previous). + bool progress = h.Manager.CheckProgressMade(25f); + + Assert.True(progress); + } + + // ── Arrival predicate (§6b Phase 2) — chase vs flee ──────────────────── + + [Fact] + public void HandleMoveToPosition_Chase_ArrivesWhenDistLessOrEqualDto() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + var p = new MovementParameters { DistanceToObject = 5f, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), p); + h.DrainPendingMotions(); + + // Walk the mover to within DistanceToObject and let enough time pass + // for CheckProgressMade to evaluate true. + h.WorldPosition = new Position(1u, new Vector3(16f, 0f, 0f), Quaternion.Identity); // dist=4 <= dto(5) + h.Advance(2.0); + + h.Manager.HandleMoveToPosition(); + + // Arrival -> node popped, CurrentCommand cleared, BeginNextNode ran + // (queue now empty, non-sticky) -> CleanUp + StopCompletely -> + // MovementTypeState back to Invalid. + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void HandleMoveToPosition_Chase_NotArrivedYet_StaysActive() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + var p = new MovementParameters { DistanceToObject = 0.6f, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), p); + h.DrainPendingMotions(); + + h.WorldPosition = new Position(1u, new Vector3(5f, 0f, 0f), Quaternion.Identity); // dist=15, still far + h.Advance(2.0); + + h.Manager.HandleMoveToPosition(); + + Assert.Equal(MovementType.MoveToPosition, h.Manager.MovementTypeState); + } + + [Fact] + public void HandleMoveToPosition_Flee_ArrivesWhenDistGreaterOrEqualMinDistance() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + var p = new MovementParameters { MoveTowards = false, MoveAway = true, MinDistance = 10f, UseSpheres = false }; + // Start close (dist=5 < MinDistance=10) so get_command picks + // WalkForward+movingAway (pure-away band, §5c). + h.Manager.MoveToPosition(new Position(1u, new Vector3(5f, 0f, 0f), Quaternion.Identity), p); + Assert.True(h.Manager.MovingAway); + h.DrainPendingMotions(); + + // Mover has fled to distance 12 (>= MinDistance 10) -> arrived. + h.WorldPosition = new Position(1u, new Vector3(-7f, 0f, 0f), Quaternion.Identity); // dist to (5,0,0) = 12 + h.Advance(2.0); + + h.Manager.HandleMoveToPosition(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + // ── Fail-distance (§6b, WeenieError.YouChargedTooFar) ────────────────── + + [Fact] + public void HandleMoveToPosition_ProgressMadeButOverFailDistance_CancelsAsYouChargedTooFar() + { + // §6b Phase 2 ordering: the fail_distance check lives INSIDE the + // "CheckProgressMade == true, but not yet arrived" branch — a + // no-progress tick never reaches it at all (that tick only + // increments FailProgressCount). So the fail-distance trigger + // requires: progress WAS made (rate >= 0.25 both ways) toward the + // target, arrival not yet reached, AND total displacement from + // StartingPosition exceeds FailDistance — e.g. the mover overshot + // past the target along a path that looped far from the start. + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + var p = new MovementParameters { DistanceToObject = 0.6f, FailDistance = 5f, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), p); + h.DrainPendingMotions(); + + // Mover advanced to (8,0,0): 12 units closed toward the target over + // 2s (rate 6/s, passes both incremental+overall) but has traveled + // 8 units from StartingPosition(0,0,0) — over FailDistance(5) — + // while still 12 units short of arrival (dto=0.6). + h.WorldPosition = new Position(1u, new Vector3(8f, 0f, 0f), Quaternion.Identity); + h.Advance(2.0); + + h.Manager.HandleMoveToPosition(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void HandleMoveToPosition_NoProgressButWithinFailDistance_StaysActive_NoCancel() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + var p = new MovementParameters { DistanceToObject = 0.6f, FailDistance = 100f, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), p); + h.DrainPendingMotions(); + + h.WorldPosition = new Position(1u, new Vector3(0f, 1f, 0f), Quaternion.Identity); // 1 unit from start, well under FailDistance + h.Advance(2.0); + + h.Manager.HandleMoveToPosition(); + + Assert.Equal(MovementType.MoveToPosition, h.Manager.MovementTypeState); + } + + // ── FailProgressCount write-only bookkeeping (§8, do-not-invent) ─────── + + [Fact] + public void FailProgressCount_IncrementsOnStall_ButNoGiveUpThresholdExists() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + var p = new MovementParameters { DistanceToObject = 0.6f, FailDistance = float.MaxValue, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), p); + h.DrainPendingMotions(); + + // Stall many times (no progress, not interpolating, not animating) — + // FailProgressCount should climb with NO cap and NO resulting + // cancellation, since the counter is write-only in retail (§8). + for (int i = 0; i < 20; i++) + { + h.Advance(2.0); + h.Manager.HandleMoveToPosition(); + } + + Assert.True(h.Manager.FailProgressCount >= 20); + Assert.Equal(MovementType.MoveToPosition, h.Manager.MovementTypeState); // still active, no give-up + } + + [Fact] + public void FailProgressCount_NotIncremented_WhenInterpolating() + { + var h = new MoveToManagerHarness { IsInterpolatingValue = true }; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + var p = new MovementParameters { DistanceToObject = 0.6f, FailDistance = float.MaxValue, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), p); + h.DrainPendingMotions(); + + h.Advance(2.0); + h.Manager.HandleMoveToPosition(); + + Assert.Equal(0u, h.Manager.FailProgressCount); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerAuxTurnTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerAuxTurnTests.cs new file mode 100644 index 00000000..2fadd0f8 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerAuxTurnTests.cs @@ -0,0 +1,147 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — HandleMoveToPosition Phase 1 aux-turn steering +/// (00529d80, raw 307187-307280) per r4-moveto-decomp.md §6b: the +/// 20°/340° deadband, direction pick (diff ≥ 180 → TurnLeft else TurnRight), +/// no-redundant-reissue, and the "stop aux while animating" branch. +/// +public sealed class MoveToManagerAuxTurnTests +{ + /// Drives a manager into an active MoveToPosition (heading + /// already settled so BeginMoveForward runs on the first BeginNextNode), + /// then drains the interp's pending_motions queue via a synthetic + /// MotionDone callback — standing in for "the WalkForward/RunForward + /// animation-table dispatch cycle has started/completed" the way a real + /// AnimationSequencer would signal it. Without this, MotionsPending() + /// stays true forever (BeginMoveForward's own _DoMotion dispatch + /// enqueues a node that nothing else in this bare harness ever pops), + /// and HandleMoveToPosition's Phase 1 would perpetually take the + /// "animating, stop aux" branch — never exercising the deadband/turn + /// logic this test file targets. + private static MoveToManagerHarness ArmMoving(float initialHeading, Vector3 targetXY) + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = initialHeading; + + var p = new MovementParameters { DistanceToObject = 0.6f, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, targetXY, Quaternion.Identity), p); + + h.DrainPendingMotions(); + + return h; + } + + [Fact] + public void WithinDeadband_NoAuxTurnIssued() + { + // Target due east (heading 90); mover already facing 85 -> diff 5, + // inside [0,20] deadband. + var h = ArmMoving(initialHeading: 90f, targetXY: new Vector3(20f, 0f, 0f)); + h.Heading = 85f; // simulate drift after the initial turn-to-face completed + + h.Manager.HandleMoveToPosition(); + + Assert.Equal(0u, h.Manager.AuxCommand); + } + + [Fact] + public void JustOutsideDeadband_Positive_IssuesTurnRight() + { + var h = ArmMoving(initialHeading: 90f, targetXY: new Vector3(20f, 0f, 0f)); + h.Heading = 40f; // diff = 90-40 = 50 -> outside [0,20]∪[340,360) + + h.Manager.HandleMoveToPosition(); + + Assert.Equal(MotionCommand.TurnRight, h.Manager.AuxCommand); + } + + [Fact] + public void DiffAtOrAbove180_IssuesTurnLeft() + { + var h = ArmMoving(initialHeading: 90f, targetXY: new Vector3(20f, 0f, 0f)); + h.Heading = 300f; // diff = 90-300 = -210 -> +360 = 150... need >=180 for TurnLeft; pick 260. + h.Heading = 260f; // diff = 90-260=-170 -> +360=190 (>=180) -> TurnLeft + + h.Manager.HandleMoveToPosition(); + + Assert.Equal(MotionCommand.TurnLeft, h.Manager.AuxCommand); + } + + [Fact] + public void DeadbandUpperBoundary_340_NoTurn() + { + var h = ArmMoving(initialHeading: 0f, targetXY: new Vector3(0f, 20f, 0f)); // target heading 0 + h.Heading = 20f; // diff = 0-20=-20 -> +360=340 -> boundary INCLUSIVE (diff >= 340) + + h.Manager.HandleMoveToPosition(); + + Assert.Equal(0u, h.Manager.AuxCommand); + } + + [Fact] + public void DeadbandLowerBoundary_20_NoTurn() + { + var h = ArmMoving(initialHeading: 0f, targetXY: new Vector3(0f, 20f, 0f)); // target heading 0 + h.Heading = -20f % 360f; // normalize below + h.Heading = 340f; // diff = 0-340 = -340 -> +360=20 -> boundary INCLUSIVE (diff <= 20) + + h.Manager.HandleMoveToPosition(); + + Assert.Equal(0u, h.Manager.AuxCommand); + } + + [Fact] + public void NoRedundantReissue_SameDirectionTwice_DoesNotRedispatch() + { + var h = ArmMoving(initialHeading: 90f, targetXY: new Vector3(20f, 0f, 0f)); + h.Heading = 40f; // outside deadband -> TurnRight + + h.Manager.HandleMoveToPosition(); + uint firstAux = h.Manager.AuxCommand; + Assert.Equal(MotionCommand.TurnRight, firstAux); + + // Drain the interp's pending_motions queue (the TurnRight dispatch + // just enqueued a node) so Phase 1's "not animating" branch runs + // again on the second tick — otherwise MotionsPending() would stay + // true and Phase 1 would take the "animating, stop aux" branch + // instead of exercising the redundant-reissue guard this test + // targets. + h.DrainPendingMotions(); + + int stopCallsBefore = h.StopCompletelyCalls; // unrelated counter, just for isolation + + // Second tick, still outside deadband, same direction -> _DoMotion + // should NOT be re-issued (turn != AuxCommand test fails since + // AuxCommand already equals TurnRight) — assert AuxCommand is + // unchanged (still TurnRight) as the observable proxy. + h.Manager.HandleMoveToPosition(); + + Assert.Equal(MotionCommand.TurnRight, h.Manager.AuxCommand); + Assert.Equal(stopCallsBefore, h.StopCompletelyCalls); + } + + [Fact] + public void AnimatingMotionsPending_StopsAuxTurn_DoesNotStartNew() + { + var h = ArmMoving(initialHeading: 90f, targetXY: new Vector3(20f, 0f, 0f)); + h.Heading = 40f; + h.Manager.HandleMoveToPosition(); + Assert.Equal(MotionCommand.TurnRight, h.Manager.AuxCommand); + + // Simulate an animation-table motion still pending by queueing a + // node onto the REAL MotionInterpreter's pending_motions. + h.Interp.AddToQueue(0, MotionCommand.WalkForward, 0); + Assert.True(h.Interp.MotionsPending()); + + h.Manager.HandleMoveToPosition(); + + Assert.Equal(0u, h.Manager.AuxCommand); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerBeginMoveForwardTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerBeginMoveForwardTests.cs new file mode 100644 index 00000000..9535c870 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerBeginMoveForwardTests.cs @@ -0,0 +1,157 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — MoveToManager::BeginMoveForward (00529a00, raw +/// 306957-307042) per r4-moveto-decomp.md §4c: dispatched motion id / hold +/// key, the write-back to the STORED params, and the progress-clock seed. +/// Also exercises the run→walk demote inside WalkRunThreshhold (the +/// R3 visual-pass expected-diff this closes). +/// +public sealed class MoveToManagerBeginMoveForwardTests +{ + [Fact] + public void FarFromTarget_CanRunCanWalk_DispatchesRunForward() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; // already facing target — no aux turn needed + + var p = new MovementParameters { DistanceToObject = 0.6f, WalkRunThreshhold = 15f }; + // Distance far beyond threshold+dto -> Run. + h.Manager.MoveToPosition(new Position(1u, new Vector3(100f, 0f, 0f), Quaternion.Identity), p); + + // MoveToPosition's node plan queues [TurnToHeading(face)] first since + // heading(0->target)=90 != current heading is not tested here (we + // set Heading=90 already so diff=0, GetCommand still picks motion + // because distance is huge, so a turn node is queued anyway — but + // since diff==0 the queued turn will complete immediately in + // BeginNextNode's synchronous dispatch, landing directly on + // BeginMoveForward). + // ForwardCommand (post-adjust_motion, dispatched to the interp) is + // RunForward; CurrentCommand (the manager's OWN field) stores the + // PRE-adjust command GetCommand chose — get_command's own body only + // ever returns WalkForward/WalkBackward/0 (§5c) — the Run promotion + // happens downstream, inside adjust_motion (_DoMotion §7a), and is + // never written back into CurrentCommand. + Assert.Equal(MotionCommand.RunForward, h.ForwardCommand); + Assert.Equal(HoldKey.Run, h.Manager.Params.HoldKeyToApply); + Assert.Equal(MotionCommand.WalkForward, h.Manager.CurrentCommand); + } + + [Fact] + public void WithinWalkRunThreshold_DemotesToWalk() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + var p = new MovementParameters { DistanceToObject = 0.6f, WalkRunThreshhold = 15f }; + // dist - dto = 10 - 0.6 = 9.4 <= 15 -> walk. + h.Manager.MoveToPosition(new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity), p); + + Assert.Equal(MotionCommand.WalkForward, h.ForwardCommand); + Assert.Equal(HoldKey.None, h.Manager.Params.HoldKeyToApply); + } + + [Fact] + public void CanCharge_FastPathWins_RunsEvenWhenClose() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + var p = new MovementParameters { DistanceToObject = 0.6f, WalkRunThreshhold = 15f, CanCharge = true }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(2f, 0f, 0f), Quaternion.Identity), p); + + Assert.Equal(MotionCommand.RunForward, h.ForwardCommand); + Assert.Equal(HoldKey.Run, h.Manager.Params.HoldKeyToApply); + } + + [Fact] + public void HoldKeyWriteBack_ToStoredParams_NotJustLocalCopy() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + var p = new MovementParameters { DistanceToObject = 0.6f, WalkRunThreshhold = 15f, HoldKeyToApply = HoldKey.Invalid }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(100f, 0f, 0f), Quaternion.Identity), p); + + Assert.Equal(HoldKey.Run, h.Manager.Params.HoldKeyToApply); + } + + [Fact] + public void ProgressClockSeeded_PreviousAndOriginalEqualCurrentDistance() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.CurTime = 5.0; + + // UseSpheres defaults true on a fresh MovementParameters, and + // MoveToPosition's own params (copied into Params BEFORE + // BeginMoveForward runs) drive GetCurrentDistance's use_spheres + // branch: cylinder distance = center distance - ownRadius(0.5) - + // targetRadius(0, position moves always zero SoughtObjectRadius). + var p = new MovementParameters { DistanceToObject = 0.6f, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), p); + + Assert.Equal(20f, h.Manager.PreviousDistance, 2); + Assert.Equal(20f, h.Manager.OriginalDistance, 2); + Assert.Equal(5.0, h.Manager.PreviousDistanceTime, 3); + Assert.Equal(5.0, h.Manager.OriginalDistanceTime, 3); + } + + [Fact] + public void ProgressClockSeeded_UseSpheresDefault_UsesCylinderDistance() + { + var h = new MoveToManagerHarness { OwnRadius = 0.5f }; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.CurTime = 5.0; + + var p = new MovementParameters { DistanceToObject = 0.6f }; // UseSpheres=true (default) + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), p); + + // center distance 20 - ownRadius 0.5 - targetRadius 0 (position + // moves zero SoughtObjectRadius, §3c) = 19.5. + Assert.Equal(19.5f, h.Manager.PreviousDistance, 2); + Assert.Equal(19.5f, h.Manager.OriginalDistance, 2); + } + + [Fact] + public void CancelMoveToBit_ClearedOnLocalParams_DoesNotSelfCancel() + { + // If the 0x8000 CancelMoveTo bit were NOT cleared on the local + // params passed into _DoMotion, InterruptCurrentMovement-style + // cancellation logic downstream could tear down THIS moveto before + // it starts. We assert the observable effect: the manager is still + // MovingTo after BeginMoveForward dispatches. + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + + Assert.True(h.Manager.IsMovingTo()); + } + + [Fact] + public void NoPhysicsObj_CancelsWithNoPhysicsObjectCode() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + Assert.True(h.Manager.IsMovingTo()); + + h.Manager.HasPhysicsObj = false; + h.Manager.BeginMoveForward(); + + Assert.False(h.Manager.IsMovingTo()); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerCompletionSeamTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerCompletionSeamTests.cs new file mode 100644 index 00000000..572f1865 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerCompletionSeamTests.cs @@ -0,0 +1,123 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V5 — the MoveToComplete CLIENT-ADDITION seam contract (see the +/// seam's doc on ): fires with +/// on NATURAL COMPLETION (the +/// empty-queue exits, both sticky +/// and non-sticky, plus CleanUpAndCallWeenie's instant-success path) +/// and NEVER on . The App layer's +/// AD-27 re-anchor (deferred Use/PickUp re-send on arrival) depends on +/// exactly this split: arrival fires the deferred action once; a user-input +/// cancel must not. +/// +public sealed class MoveToManagerCompletionSeamTests +{ + /// Arms a position move 5 m dead ahead (heading 90 = +X, + /// facing it) and drives the scripted body to arrival via UseTime. + private static MoveToManagerHarness DriveToArrival() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.Manager.MoveToPosition( + new Position(1u, new Vector3(5f, 0f, 0f), Quaternion.Identity), + new MovementParameters { UseSpheres = false, DistanceToObject = 0.6f }); + h.DrainPendingMotions(); + + for (int i = 0; i < 200 && h.Manager.IsMovingTo(); i++) + { + h.Tick(); + var cur = h.WorldPosition.Frame.Origin; + h.WorldPosition = new Position( + 1u, cur + new Vector3(0.2f, 0f, 0f), Quaternion.Identity); + h.Manager.UseTime(); + h.DrainPendingMotions(); + } + + Assert.False(h.Manager.IsMovingTo(), + "scripted drive must reach arrival within the tick budget"); + return h; + } + + [Fact] + public void NaturalArrival_FiresMoveToComplete_OnceWithNone() + { + var h = DriveToArrival(); + + Assert.Single(h.MoveToCompleteCalls); + Assert.Equal(WeenieError.None, h.MoveToCompleteCalls[0]); + } + + [Fact] + public void AfterArrival_ExtraUseTimeTicks_DoNotRefire() + { + var h = DriveToArrival(); + + for (int i = 0; i < 10; i++) + { + h.Tick(); + h.Manager.UseTime(); + } + + Assert.Single(h.MoveToCompleteCalls); + } + + [Fact] + public void CancelMoveTo_DoesNotFireMoveToComplete() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.Manager.MoveToPosition( + new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), + new MovementParameters { UseSpheres = false }); + Assert.True(h.Manager.IsMovingTo()); + + h.Manager.CancelMoveTo(WeenieError.ActionCancelled); + + Assert.False(h.Manager.IsMovingTo()); + Assert.Empty(h.MoveToCompleteCalls); + } + + [Fact] + public void StickyCompletion_FiresMoveToComplete_AfterStickToHandoff() + { + // In-range sticky object move: MoveToObject arms the tracker; the + // first Ok callback finds the target already inside + // DistanceToObject, so no motion nodes are needed and BeginNextNode + // lands straight on the empty-queue STICKY exit — StickTo gets the + // pre-CleanUp tlid/radius/height, then the completion seam fires. + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.Manager.MoveToObject( + objectId: 0x1000u, topLevelId: 0x1000u, radius: 0.5f, height: 1f, + new MovementParameters { Sticky = true, DistanceToObject = 5f }); + h.DrainPendingMotions(); + + var target = new Position(1u, new Vector3(1f, 0f, 0f), Quaternion.Identity); + h.Manager.HandleUpdateTarget( + new TargetInfo(0x1000u, TargetStatus.Ok, target, target)); + h.DrainPendingMotions(); + + // Some builds need the turn/settle nodes ticked through first. + for (int i = 0; i < 50 && h.Manager.IsMovingTo(); i++) + { + h.Tick(); + h.Manager.UseTime(); + h.DrainPendingMotions(); + } + + Assert.False(h.Manager.IsMovingTo()); + Assert.Single(h.StickToCalls); + Assert.Equal((0x1000u, 0.5f, 1f), h.StickToCalls[0]); + Assert.Single(h.MoveToCompleteCalls); + Assert.Equal(WeenieError.None, h.MoveToCompleteCalls[0]); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerEndToEndTableDriveTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerEndToEndTableDriveTests.cs new file mode 100644 index 00000000..59647fb7 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerEndToEndTableDriveTests.cs @@ -0,0 +1,154 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — scripted end-to-end table drive (r4-port-plan.md §3 V2 test +/// list): positions fed per tick -> expected node pops + dispatched motion +/// ids/hold keys, including the run-to-walk demote as the mover closes to +/// within WalkRunThreshhold of the target — the exact R3 visual-pass +/// expected-diff this closes ("auto-walk-at-run walk-pace legs (R4)"). +/// +public sealed class MoveToManagerEndToEndTableDriveTests +{ + [Fact] + public void ChaseSequence_TurnFirst_ThenRun_ThenDemoteToWalk_ThenArrive() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; // facing NORTH; target is due EAST -> a turn-to-face node is required first. + + var p = new MovementParameters { DistanceToObject = 0.6f, WalkRunThreshhold = 15f, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(100f, 0f, 0f), Quaternion.Identity), p); + + // Step 1: node plan = [TurnToHeading(90), MoveToPosition]. Heading + // diff (0->90) is large -> BeginTurnToHeading armed a real turn + // (not the "already there" early-out). + Assert.Equal(2, System.Linq.Enumerable.Count(h.Manager.PendingActions)); + Assert.Equal(MotionCommand.TurnRight, h.Manager.CurrentCommand); + h.DrainPendingMotions(); + + // Step 2: the turn completes (heading snaps to 90 via + // HandleTurnToHeading's arrival branch) -> BeginNextNode pops to the + // MoveToPosition node -> BeginMoveForward dispatches. Far from the + // target (100 units, minus threshold 15 well exceeded) -> RunForward. + h.Heading = 91f; // "passed" 90 + h.Manager.HandleTurnToHeading(); + h.DrainPendingMotions(); + + Assert.Equal(MovementType.MoveToPosition, h.Manager.MovementTypeState); + Assert.Single(h.Manager.PendingActions); + Assert.Equal(MotionCommand.RunForward, h.ForwardCommand); + Assert.Equal(HoldKey.Run, h.Manager.Params.HoldKeyToApply); + + // Step 3: close the distance to just inside the walk/run threshold. + // Phase 2 of HandleMoveToPosition doesn't re-run get_command; only + // BeginMoveForward does (dispatched once per node, on arm) — so the + // walk-demote re-evaluation requires a fresh moveto issue. Route it + // through PerformMovement (NOT a direct MoveToPosition call) — this + // is the retail-faithful re-issue shape (§3a: cancel current + + // unstick FIRST, THEN dispatch) and avoids stacking a stale node + // onto the still-populated queue the way a bare second + // MoveToPosition call would (MoveToPosition itself does not drain; + // only PerformMovement's CancelMoveTo call does). + h.WorldPosition = new Position(1u, new Vector3(90f, 0f, 0f), Quaternion.Identity); // 10 units from target + h.Heading = 90f; // already facing it + var pClose = new MovementParameters { DistanceToObject = 0.6f, WalkRunThreshhold = 15f, UseSpheres = false }; + h.Manager.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(1u, new Vector3(100f, 0f, 0f), Quaternion.Identity), + Params = pClose, + }); + // PerformMovement's CancelMoveTo (§3a) stops the in-flight motion + // FIRST, which itself enqueues a pending_motions node -- so + // BeginTurnToHeading's wait-for-anims gate (§4d) defers the "already + // facing it" early-out to the NEXT drain, not synchronously inside + // this call. Drain twice: once for the cancel's own stop dispatch, + // once more for whatever BeginTurnToHeading/BeginMoveForward issues + // once armed. + h.DrainPendingMotions(); + h.Manager.BeginNextNode(); // re-check the head node now that anims have drained + h.DrainPendingMotions(); + + Assert.Single(h.Manager.PendingActions); // the stale queue was drained by PerformMovement's CancelMoveTo; the "already facing it" turn completed instantly once anims cleared. + + // dist=10, dto=0.6 -> dist-dto=9.4 <= 15 -> WALK. + Assert.Equal(MotionCommand.WalkForward, h.ForwardCommand); + Assert.Equal(HoldKey.None, h.Manager.Params.HoldKeyToApply); + + // Step 4: arrive. + h.WorldPosition = new Position(1u, new Vector3(99.7f, 0f, 0f), Quaternion.Identity); + h.Advance(2.0); + h.Manager.HandleMoveToPosition(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + Assert.Empty(h.Manager.PendingActions); + } + + [Fact] + public void FleeSequence_WalksBackward_InsideMinBand_ArrivesWhenFarEnough() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, new Vector3(3f, 0f, 0f), Quaternion.Identity); + h.Heading = 270f; // facing the threat (target) which is behind at origin -- WalkBackward needs no turn. + + // towards_and_away band: dist(3) inside [MinDistance(5)... wait need + // dist < min for the inside-band WalkBackward pick]. Use MinDistance + // 5 with mover at distance 3 from the target (origin) -> inside + // band -> WalkBackward, no turn node queued (§5d asymmetry). + var p = new MovementParameters { MoveTowards = true, MoveAway = true, MinDistance = 5f, DistanceToObject = 8f, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, Vector3.Zero, Quaternion.Identity), p); + + Assert.True(h.Manager.MovingAway); + Assert.Equal(MotionCommand.WalkBackward, h.Manager.CurrentCommand); // pre-adjust id (get_command's own return) + // adjust_motion normalizes WalkBackward -> WalkForward with a + // negative BackwardsFactor-scaled speed, dispatched as ForwardCommand. + Assert.Equal(MotionCommand.WalkForward, h.ForwardCommand); + Assert.True(h.ForwardSpeed < 0f); + h.DrainPendingMotions(); + + // Flee to distance 6 (>= MinDistance 5) -> arrived. + h.WorldPosition = new Position(1u, new Vector3(6f, 0f, 0f), Quaternion.Identity); + h.Advance(2.0); + h.Manager.HandleMoveToPosition(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void TurnToObjectSequence_DeferredStart_ThenRetargetIgnored_ThenArrivesOnHeadingPass() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; + + const uint targetId = 0x5000CCCCu; + h.Manager.TurnToObject(targetId, targetId, new MovementParameters()); + Assert.Empty(h.Manager.PendingActions); // deferred (§3d) + + var target = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); // heading 90 + h.Manager.HandleUpdateTarget(new TargetInfo(targetId, TargetStatus.Ok, target, target)); + + Assert.True(h.Manager.Initialized); + Assert.Single(h.Manager.PendingActions); + Assert.Equal(MotionCommand.TurnRight, h.Manager.CurrentCommand); + h.DrainPendingMotions(); + + // Retarget while running: TurnToObject gets no handling (heading frozen). + var target2 = new Position(1u, new Vector3(0f, 10f, 0f), Quaternion.Identity); // heading 0 + h.Manager.HandleUpdateTarget(new TargetInfo(targetId, TargetStatus.Ok, target2, target2)); + var soughtBefore = h.Manager.SoughtPosition; + Assert.Equal(soughtBefore, h.Manager.SoughtPosition); // sanity: unchanged by its own read + + // Complete the turn toward the ORIGINAL (frozen) heading (90), not target2's. + h.Heading = 91f; + h.Manager.HandleTurnToHeading(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + Assert.Equal(90f, h.Heading, 2); // snapped to the frozen heading, unaffected by the retarget. + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerHandleUpdateTargetTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerHandleUpdateTargetTests.cs new file mode 100644 index 00000000..255c77fd --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerHandleUpdateTargetTests.cs @@ -0,0 +1,158 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — HandleUpdateTarget (0052a7d0, raw 307802-307867, +/// decomp §6d): the P4 TargetTracker feed's deferred-start lifecycle +/// (Initialized=false = the first callback vs true = an in-flight retarget), +/// context/target-id filtering, self-target instant success, NoObject vs +/// ObjectGone status handling, and the retarget progress-clock reset. +/// +public sealed class MoveToManagerHandleUpdateTargetTests +{ + private const uint TargetId = 0x50004444u; + + private static MoveToManagerHarness ArmMoveToObject(float ownRadius = 0.5f, float ownHeight = 2f) + { + var h = new MoveToManagerHarness { OwnRadius = ownRadius, OwnHeight = ownHeight }; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; + h.Manager.MoveToObject(TargetId, TargetId, radius: 1f, height: 2f, new MovementParameters()); + return h; + } + + [Fact] + public void IgnoresUpdate_ForADifferentTarget() + { + var h = ArmMoveToObject(); + var wrongTargetPos = new Position(1u, new Vector3(5f, 5f, 0f), Quaternion.Identity); + + h.Manager.HandleUpdateTarget(new TargetInfo(0x59999999u, TargetStatus.Ok, wrongTargetPos, wrongTargetPos)); + + Assert.False(h.Manager.Initialized); + Assert.Empty(h.Manager.PendingActions); + } + + [Fact] + public void FirstCallback_NonOkStatus_CancelsAsNoObject() + { + var h = ArmMoveToObject(); + var pos = new Position(1u, Vector3.Zero, Quaternion.Identity); + + h.Manager.HandleUpdateTarget(new TargetInfo(TargetId, TargetStatus.ExitWorld, pos, pos)); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void FirstCallback_OkStatus_BuildsNodePlan_SetsInitialized() + { + var h = ArmMoveToObject(); + var target = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); + + h.Manager.HandleUpdateTarget(new TargetInfo(TargetId, TargetStatus.Ok, target, target)); + + Assert.True(h.Manager.Initialized); + Assert.NotEmpty(h.Manager.PendingActions); + } + + [Fact] + public void FirstCallback_OrdinaryTarget_DoesNotFireMoveToComplete() + { + // MoveToObject's OWN self-target branch (§3b) already short-circuits + // via CleanUp+StopCompletely BEFORE any HandleUpdateTarget ever + // fires for a same-id target — so HandleUpdateTarget's self-target + // instant-success path (§6d: "top_level_object_id == + // physics_obj->id") is reachable only in the deferred-start window, + // and is covered by construction in + // MoveToManagerNodePlanTests.MoveToObject_SelfTarget_* + // (MoveToObject never even reaches SetTarget for a self-id, so the + // callback path is dead in practice — retail's redundant guard). + // This test isolates the ORDINARY path: MoveToComplete's only + // trigger is CleanUpAndCallWeenie, never a plain node-plan build. + var h = ArmMoveToObject(); + var target = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); + + h.Manager.HandleUpdateTarget(new TargetInfo(TargetId, TargetStatus.Ok, target, target)); + + Assert.Empty(h.MoveToCompleteCalls); + } + + [Fact] + public void Retarget_NonOkStatus_CancelsAsObjectGone() + { + var h = ArmMoveToObject(); + var target = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); + h.Manager.HandleUpdateTarget(new TargetInfo(TargetId, TargetStatus.Ok, target, target)); + Assert.True(h.Manager.Initialized); + + h.Manager.HandleUpdateTarget(new TargetInfo(TargetId, TargetStatus.ExitWorld, target, target)); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void Retarget_UpdatesPositions_ResetsProgressClock_DoesNotRequeueNodes() + { + var h = ArmMoveToObject(); + var target1 = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); + h.Manager.HandleUpdateTarget(new TargetInfo(TargetId, TargetStatus.Ok, target1, target1)); + int nodeCountAfterFirst = System.Linq.Enumerable.Count(h.Manager.PendingActions); + Assert.True(nodeCountAfterFirst > 0); + + h.Advance(3.0); // simulate time passing, progress clock advanced by BeginMoveForward + + var target2 = new Position(1u, new Vector3(20f, 5f, 0f), Quaternion.Identity); + var interp2 = new Position(1u, new Vector3(19f, 5f, 0f), Quaternion.Identity); + h.Manager.HandleUpdateTarget(new TargetInfo(TargetId, TargetStatus.Ok, target2, interp2)); + + Assert.Equal(target2, h.Manager.CurrentTargetPosition); + Assert.Equal(interp2, h.Manager.SoughtPosition); + Assert.Equal(float.MaxValue, h.Manager.PreviousDistance); + Assert.Equal(float.MaxValue, h.Manager.OriginalDistance); + + // Node count unchanged by the retarget itself (no requeue) — the + // running MoveToPosition node keeps steering toward the moved + // CurrentTargetPosition on its own next tick. + Assert.Equal(nodeCountAfterFirst, System.Linq.Enumerable.Count(h.Manager.PendingActions)); + } + + [Fact] + public void Retarget_TurnToObject_GetsNoRetargetHandling_HeadingFrozen() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; + h.Manager.TurnToObject(TargetId, TargetId, new MovementParameters()); + + var target1 = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); // heading 90 + h.Manager.TurnToObject_Internal(target1); // first callback (direct, mirrors deferred-start call shape) + Assert.True(h.Manager.Initialized); + var soughtAfterFirst = h.Manager.SoughtPosition; + + // A retarget-shaped HandleUpdateTarget call for a TurnToObject + // manager: since Initialized is already true, this takes the + // "retarget" branch, which only updates state for MoveToObject — + // TurnToObject gets NO handling at all (decomp §6d note). + var target2 = new Position(1u, new Vector3(0f, 10f, 0f), Quaternion.Identity); // heading 0 + h.Manager.HandleUpdateTarget(new TargetInfo(TargetId, TargetStatus.Ok, target2, target2)); + + Assert.Equal(soughtAfterFirst, h.Manager.SoughtPosition); // untouched + } + + [Fact] + public void NoPhysicsObj_CancelsWithNoPhysicsObjectCode() + { + var h = ArmMoveToObject(); + h.Manager.HasPhysicsObj = false; + + var target = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); + h.Manager.HandleUpdateTarget(new TargetInfo(TargetId, TargetStatus.Ok, target, target)); + + Assert.False(h.Manager.IsMovingTo()); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerLifecycleTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerLifecycleTests.cs new file mode 100644 index 00000000..fa4527e6 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerLifecycleTests.cs @@ -0,0 +1,100 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — MoveToManager construction / InitializeLocalVariables +/// (00529250, raw 306490-306534) / Destroy (005294b0) / +/// is_moving_to (00529220). Per r4-moveto-decomp.md §1: the ctor +/// zeroes the FLAGS WORD + context_id only (NOT ACE's A2/A3 full-struct-reset +/// transposition — scalar param fields keep stale values since every entry +/// point copies all ten fields anyway), resets both progress-clock pairs to +/// FLT_MAX/now, and resets Sought/CurrentTarget positions but NOT +/// StartingPosition. +/// +public sealed class MoveToManagerLifecycleTests +{ + [Fact] + public void FreshManager_MovementTypeIsInvalid() + { + var h = new MoveToManagerHarness(); + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + Assert.False(h.Manager.IsMovingTo()); + } + + [Fact] + public void FreshManager_ProgressClocksAreFltMax() + { + var h = new MoveToManagerHarness(); + Assert.Equal(float.MaxValue, h.Manager.PreviousDistance); + Assert.Equal(float.MaxValue, h.Manager.OriginalDistance); + } + + [Fact] + public void FreshManager_BitfieldFlagsAllClear_ScalarsUntouchedByCtorReset() + { + // InitializeLocalVariables clears ONLY the bitfield + context_id. + // The scalar fields (DistanceToObject etc.) are NOT part of that + // clear — but since Params starts as `new MovementParameters()` + // (retail ctor defaults), the scalars already hold their defaults + // here; the "stale values survive InitializeLocalVariables" claim is + // exercised by MoveToManagerCancelAndCleanupTests (a scalar surviving + // a CleanUp/InitializeLocalVariables round-trip after being changed + // by an entry point). + var h = new MoveToManagerHarness(); + Assert.False(h.Manager.Params.CanWalk); + Assert.False(h.Manager.Params.CanRun); + Assert.False(h.Manager.Params.MoveTowards); + Assert.False(h.Manager.Params.CancelMoveTo); + Assert.Equal(0u, h.Manager.Params.ContextId); + } + + [Fact] + public void FreshManager_SoughtPositionAndCurrentTargetAreIdentityFrameAtCellZero() + { + // NOT default(Position) — default(Quaternion) is the ZERO + // quaternion, not identity. Retail resets to a genuine identity + // frame (decomp §1c) at cell id 0. + var h = new MoveToManagerHarness(); + var expected = new Position(0u, System.Numerics.Vector3.Zero, System.Numerics.Quaternion.Identity); + Assert.Equal(expected, h.Manager.SoughtPosition); + Assert.Equal(expected, h.Manager.CurrentTargetPosition); + Assert.Equal(0f, MoveToMath.GetHeading(h.Manager.SoughtPosition.Frame.Orientation)); + } + + [Fact] + public void FreshManager_PendingActionsEmpty() + { + var h = new MoveToManagerHarness(); + Assert.Empty(h.Manager.PendingActions); + } + + [Fact] + public void Destroy_DrainsPendingActions_ThenReInitializes() + { + var h = new MoveToManagerHarness(); + h.Manager.AddMoveToPositionNode(); + h.Manager.AddTurnToHeadingNode(90f); + Assert.Equal(2, System.Linq.Enumerable.Count(h.Manager.PendingActions)); + + h.Manager.Destroy(); + + Assert.Empty(h.Manager.PendingActions); + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void IsMovingTo_TrueAfterMoveToPosition_FalseAfterCancel() + { + var h = new MoveToManagerHarness(); + h.Manager.MoveToPosition(new Position(1u, new System.Numerics.Vector3(10f, 0f, 0f), System.Numerics.Quaternion.Identity), new MovementParameters()); + + Assert.True(h.Manager.IsMovingTo()); + + h.Manager.CancelMoveTo(WeenieError.ActionCancelled); + + Assert.False(h.Manager.IsMovingTo()); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerNodePlanTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerNodePlanTests.cs new file mode 100644 index 00000000..53f1af49 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerNodePlanTests.cs @@ -0,0 +1,306 @@ +using System.Linq; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — node-plan goldens for each movement type. Per r4-moveto-decomp.md +/// §3c (MoveToPosition), §6f (MoveToObject_Internal), §3e (TurnToHeading), +/// §6g (TurnToObject_Internal): the SHAPE of pending_actions right +/// after the entry point (deferred moves) or the internal builder (object +/// moves, first target callback) runs. +/// +public sealed class MoveToManagerNodePlanTests +{ + // ── MoveToPosition (§3c): [TurnToHeading(face)] → [MoveToPosition] ──── + + [Fact] + public void MoveToPosition_NeedsMotion_QueuesTurnThenMove() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; + + // Target due east (+X) -> heading 90. Far enough that get_command + // says motion is needed (default DistanceToObject=0.6). + h.Manager.MoveToPosition(new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + + var nodes = h.Manager.PendingActions.ToList(); + Assert.Equal(2, nodes.Count); + Assert.Equal(MovementType.TurnToHeading, nodes[0].Type); + Assert.Equal(90f, nodes[0].Heading, 2); + Assert.Equal(MovementType.MoveToPosition, nodes[1].Type); + } + + [Fact] + public void MoveToPosition_AlreadyInRange_NoMotionNodesQueued() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + + // Target within default DistanceToObject (0.6) -> get_command idles. + h.Manager.MoveToPosition(new Position(1u, new Vector3(0.1f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + + Assert.Empty(h.Manager.PendingActions); + } + + [Fact] + public void MoveToPosition_UseFinalHeading_AppendsAbsoluteFinalTurnNode() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + + var p = new MovementParameters { UseFinalHeading = true, DesiredHeading = 270f }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity), p); + + var nodes = h.Manager.PendingActions.ToList(); + // Turn-to-face(90) -> MoveToPosition -> Turn-to-final(270, ABSOLUTE). + Assert.Equal(3, nodes.Count); + Assert.Equal(MovementType.TurnToHeading, nodes[2].Type); + Assert.Equal(270f, nodes[2].Heading, 2); + } + + [Fact] + public void MoveToPosition_UseFinalHeadingOnly_NoMotionNeeded_QueuesOnlyFinalTurn() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + + var p = new MovementParameters { UseFinalHeading = true, DesiredHeading = 45f }; + // Already in range -> no move/turn-to-face nodes, only the final turn. + h.Manager.MoveToPosition(new Position(1u, new Vector3(0.1f, 0f, 0f), Quaternion.Identity), p); + + var nodes = h.Manager.PendingActions.ToList(); + Assert.Single(nodes); + Assert.Equal(MovementType.TurnToHeading, nodes[0].Type); + Assert.Equal(45f, nodes[0].Heading, 2); + } + + [Fact] + public void MoveToPosition_ClearsStickyBit_EvenIfArgumentRequestedIt() + { + var h = new MoveToManagerHarness(); + var p = new MovementParameters { Sticky = true }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(0.1f, 0f, 0f), Quaternion.Identity), p); + + Assert.False(h.Manager.Params.Sticky); + } + + [Fact] + public void MoveToPosition_MovementTypeAndStartingPositionSet() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(2u, new Vector3(1f, 2f, 3f), Quaternion.Identity); + + // Distance 10 (> default DistanceToObject 0.6) so the move plan + // actually queues motion and MovementTypeState stays MoveToPosition + // instead of completing instantly via the empty-queue BeginNextNode + // path (see MoveToPosition_AlreadyInRange_NoMotionNodesQueued for + // that degenerate case). + h.Manager.MoveToPosition(new Position(2u, new Vector3(1f, 12f, 3f), Quaternion.Identity), new MovementParameters()); + + Assert.Equal(MovementType.MoveToPosition, h.Manager.MovementTypeState); + Assert.Equal(h.WorldPosition, h.Manager.StartingPosition); + } + + // ── TurnToHeading (§3e): ONE node, immediate BeginNextNode ───────────── + + [Fact] + public void TurnToHeading_QueuesExactlyOneNode_WithDesiredHeading() + { + var h = new MoveToManagerHarness(); + h.Heading = 0f; + + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 123f }); + + var nodes = h.Manager.PendingActions.ToList(); + // BeginNextNode ran immediately and BeginTurnToHeading may have + // already popped the node if heading matched (it won't here — 123 + // != 0), so the node should still be present as "in flight" (its + // dispatch doesn't remove it — only arrival does). We assert via + // CurrentCommand instead of raw queue count, since BeginNextNode + // does run synchronously. + Assert.Equal(MovementType.TurnToHeading, h.Manager.MovementTypeState); + Assert.NotEqual(0u, h.Manager.CurrentCommand); + Assert.Single(nodes); + Assert.Equal(123f, nodes[0].Heading, 2); + } + + [Fact] + public void TurnToHeading_ClearsStickyBit() + { + var h = new MoveToManagerHarness(); + h.Manager.TurnToHeading(new MovementParameters { Sticky = true, DesiredHeading = 45f }); + Assert.False(h.Manager.Params.Sticky); + } + + [Fact] + public void TurnToHeading_AlreadyFacingTarget_BeginNextNodeCompletesImmediately() + { + var h = new MoveToManagerHarness(); + h.Heading = 90f; + + // DesiredHeading == current heading -> BeginTurnToHeading's + // "already there" branch pops + BeginNextNode -> empty queue, + // non-sticky -> CleanUp + StopCompletely -> back to Invalid. + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 90f }); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + Assert.Empty(h.Manager.PendingActions); + Assert.True(h.StopCompletelyCalls >= 1); + } + + // ── MoveToObject deferred start (§3b + §6f via HandleUpdateTarget) ───── + + [Fact] + public void MoveToObject_NoNodesQueuedUntilTargetCallback() + { + var h = new MoveToManagerHarness(); + h.Manager.MoveToObject(objectId: 0x50002222u, topLevelId: 0x50002222u, radius: 1f, height: 2f, new MovementParameters()); + + Assert.Empty(h.Manager.PendingActions); + Assert.Equal(MovementType.MoveToObject, h.Manager.MovementTypeState); + Assert.False(h.Manager.Initialized); + Assert.Single(h.SetTargetCalls); + Assert.Equal((0u, 0x50002222u, 0.5f, 0.0), h.SetTargetCalls[0]); + } + + [Fact] + public void MoveToObject_PreservesStickyBit_UnlikePositionMoves() + { + var h = new MoveToManagerHarness(); + var p = new MovementParameters { Sticky = true }; + h.Manager.MoveToObject(0x50002222u, 0x50002222u, 1f, 2f, p); + + Assert.True(h.Manager.Params.Sticky); + } + + [Fact] + public void MoveToObject_FirstTargetCallback_BuildsNodePlanViaInternal() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; + + h.Manager.MoveToObject(0x50002222u, 0x50002222u, radius: 0.5f, height: 2f, new MovementParameters()); + + var target = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); + h.Manager.HandleUpdateTarget(new TargetInfo(0x50002222u, TargetStatus.Ok, target, target)); + + Assert.True(h.Manager.Initialized); + var nodes = h.Manager.PendingActions.ToList(); + Assert.Equal(2, nodes.Count); + Assert.Equal(MovementType.TurnToHeading, nodes[0].Type); + Assert.Equal(90f, nodes[0].Heading, 2); + Assert.Equal(MovementType.MoveToPosition, nodes[1].Type); + } + + [Fact] + public void MoveToObject_UseFinalHeading_RelativeToInterpolatedHeading() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; + + var p = new MovementParameters { UseFinalHeading = true, DesiredHeading = 10f }; + h.Manager.MoveToObject(0x50002222u, 0x50002222u, 0.5f, 2f, p); + + var target = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); // heading 90 + h.Manager.HandleUpdateTarget(new TargetInfo(0x50002222u, TargetStatus.Ok, target, target)); + + var nodes = h.Manager.PendingActions.ToList(); + Assert.Equal(3, nodes.Count); + // RELATIVE: iHeading(90) + desired(10) = 100 -- unlike MoveToPosition's absolute form. + Assert.Equal(100f, nodes[2].Heading, 2); + } + + [Fact] + public void MoveToObject_SelfTarget_CleansUpImmediately_NoSetTarget() + { + var h = new MoveToManagerHarness(); + h.Manager.MoveToObject(h.SelfId, h.SelfId, 1f, 2f, new MovementParameters()); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + Assert.Empty(h.SetTargetCalls); + } + + // ── TurnToObject deferred start (§3d + §6g) ──────────────────────────── + + [Fact] + public void TurnToObject_NoNodesQueuedUntilTargetCallback() + { + var h = new MoveToManagerHarness(); + h.Manager.TurnToObject(0x50003333u, 0x50003333u, new MovementParameters()); + + Assert.Empty(h.Manager.PendingActions); + Assert.False(h.Manager.Initialized); + Assert.Single(h.SetTargetCalls); + } + + [Fact] + public void TurnToObject_FirstCallback_QueuesExactlyOneTurnNode_FacingObject() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; // already facing north — target due EAST forces an actual turn to queue. + + // DesiredHeading is clobbered (§3d quirk) — it should NOT appear in + // the final node heading; the final heading is purely "face the + // object" (soughtHeading is 0 for a fresh manager). + h.Manager.TurnToObject(0x50003333u, 0x50003333u, new MovementParameters { DesiredHeading = 200f }); + + var target = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); // heading 90 (east) + h.Manager.TurnToObject_Internal(target); + + var nodes = h.Manager.PendingActions.ToList(); + Assert.Single(nodes); + Assert.Equal(MovementType.TurnToHeading, nodes[0].Type); + Assert.Equal(90f, nodes[0].Heading, 2); // face-the-object (east), NOT 200 + Assert.True(h.Manager.Initialized); + } + + [Fact] + public void TurnToObject_FirstCallback_AlreadyFacingObject_CompletesImmediately() + { + // When soughtHeading(0) + targetHeading already equals the current + // heading, BeginTurnToHeading's "already there" branch consumes the + // node on the SAME call — the queue is empty by the time + // TurnToObject_Internal returns, but the manager still passed + // through Initialized=true and the CleanUp/StopCompletely tail. + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; + + h.Manager.TurnToObject(0x50003333u, 0x50003333u, new MovementParameters()); + var target = new Position(1u, new Vector3(0f, 10f, 0f), Quaternion.Identity); // heading 0 (north) — already facing it. + h.Manager.TurnToObject_Internal(target); + + Assert.Empty(h.Manager.PendingActions); + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void TurnToObject_SelfTarget_CleansUpImmediately() + { + var h = new MoveToManagerHarness(); + h.Manager.TurnToObject(h.SelfId, h.SelfId, new MovementParameters()); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + Assert.Empty(h.SetTargetCalls); + } + + [Fact] + public void TurnToObject_StopCompletelyOnlyWhenBitSet() + { + var h1 = new MoveToManagerHarness(); + h1.Manager.TurnToObject(0x50003333u, 0x50003333u, new MovementParameters { StopCompletelyFlag = false }); + Assert.Equal(0, h1.StopCompletelyCalls); + + var h2 = new MoveToManagerHarness(); + h2.Manager.TurnToObject(0x50003333u, 0x50003333u, new MovementParameters { StopCompletelyFlag = true }); + Assert.Equal(1, h2.StopCompletelyCalls); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerStickyAndCancelTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerStickyAndCancelTests.cs new file mode 100644 index 00000000..2f89d999 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerStickyAndCancelTests.cs @@ -0,0 +1,295 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — BeginNextNode's sticky handoff (00529cb0, raw +/// 307123-307171, decomp §4b) and CancelMoveTo +/// (00529930, raw 306886-306940, decomp §7c) including the +/// reentrancy invariant (r4-port-plan.md §4: CancelMoveTo → +/// CleanUpAndCallWeenie → StopCompletely → InterruptCurrentMovement → +/// CancelMoveTo no-ops on Invalid). +/// +public sealed class MoveToManagerStickyAndCancelTests +{ + // ── Sticky handoff (§4b) — read BEFORE CleanUp, then StickTo ─────────── + + [Fact] + public void StickyArrival_ReadsRadiusHeightTlidBeforeCleanUp_ThenCallsStickTo() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; + + var p = new MovementParameters { Sticky = true }; + h.Manager.MoveToObject(0x50005555u, 0x50005555u, radius: 1.5f, height: 2.5f, p); + Assert.True(h.Manager.Params.Sticky); // preserved by MoveToObject (§3b) + + var target = new Position(1u, new Vector3(0.1f, 0f, 0f), Quaternion.Identity); // inside default dto -> arrives instantly + h.Manager.HandleUpdateTarget(new TargetInfo(0x50005555u, TargetStatus.Ok, target, target)); + + Assert.Single(h.StickToCalls); + Assert.Equal((0x50005555u, 1.5f, 2.5f), h.StickToCalls[0]); + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); // CleanUp ran + } + + [Fact] + public void NonStickyArrival_NoStickToCall_JustCleanUpAndStop() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; + + var p = new MovementParameters { Sticky = false }; + h.Manager.MoveToObject(0x50005555u, 0x50005555u, radius: 1.5f, height: 2.5f, p); + + var target = new Position(1u, new Vector3(0.1f, 0f, 0f), Quaternion.Identity); + h.Manager.HandleUpdateTarget(new TargetInfo(0x50005555u, TargetStatus.Ok, target, target)); + + Assert.Empty(h.StickToCalls); + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void MoveToPosition_NeverSticks_EvenIfRequested() + { + // §3c: MoveToPosition force-clears the sticky bit — so even an + // arrival that WOULD have stuck (had it been an object move) just + // completes plainly. + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 0f; + + var p = new MovementParameters { Sticky = true, DistanceToObject = 0.6f, UseSpheres = false }; + h.Manager.MoveToPosition(new Position(1u, new Vector3(0.1f, 0f, 0f), Quaternion.Identity), p); // already in range -> instant complete + + Assert.Empty(h.StickToCalls); + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void StickyHandoff_UsesSoughtRadiusHeight_NotOwnRadiusHeight() + { + var h = new MoveToManagerHarness { OwnRadius = 99f, OwnHeight = 99f }; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + + var p = new MovementParameters { Sticky = true }; + h.Manager.MoveToObject(0x50006666u, 0x50006666u, radius: 3f, height: 4f, p); + + var target = new Position(1u, new Vector3(0.1f, 0f, 0f), Quaternion.Identity); + h.Manager.HandleUpdateTarget(new TargetInfo(0x50006666u, TargetStatus.Ok, target, target)); + + Assert.Equal((0x50006666u, 3f, 4f), h.StickToCalls[0]); // the TARGET's radius/height, not the mover's own. + } + + // ── CancelMoveTo (§7c) — drain + CleanUp + Stop; reentrancy ──────────── + + [Fact] + public void CancelMoveTo_OnInvalidState_IsANoOp() + { + var h = new MoveToManagerHarness(); + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + + h.Manager.CancelMoveTo(WeenieError.ActionCancelled); + + Assert.Equal(0, h.StopCompletelyCalls); // no-op: never even called StopCompletely + Assert.Equal(0, h.ClearTargetCalls); + } + + [Fact] + public void CancelMoveTo_DrainsPendingActions() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + Assert.NotEmpty(h.Manager.PendingActions); + + h.Manager.CancelMoveTo(WeenieError.ActionCancelled); + + Assert.Empty(h.Manager.PendingActions); + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void CancelMoveTo_ErrorArgument_NeverReadInBody_SameBehaviorForAnyCode() + { + // §7c: the WeenieError arg is NEVER read — every code produces + // identical observable behavior (drain + CleanUp + Stop). + var h1 = new MoveToManagerHarness(); + h1.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h1.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + h1.Manager.CancelMoveTo(WeenieError.YouChargedTooFar); + + var h2 = new MoveToManagerHarness(); + h2.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h2.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + h2.Manager.CancelMoveTo(WeenieError.NoObject); + + Assert.Equal(h1.Manager.MovementTypeState, h2.Manager.MovementTypeState); + Assert.Equal(h1.StopCompletelyCalls, h2.StopCompletelyCalls); + } + + [Fact] + public void CancelMoveTo_ClearsTarget_ForObjectMoves() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Manager.MoveToObject(0x50007777u, 0x50007777u, 1f, 2f, new MovementParameters()); + Assert.Single(h.SetTargetCalls); + + h.Manager.CancelMoveTo(WeenieError.ActionCancelled); + + Assert.Equal(1, h.ClearTargetCalls); + } + + [Fact] + public void CancelMoveTo_DoesNotClearTarget_ForPositionMoves() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + + h.Manager.CancelMoveTo(WeenieError.ActionCancelled); + + Assert.Equal(0, h.ClearTargetCalls); // TopLevelObjectId is 0 for a position move -> the clear_target gate never fires. + } + + [Fact] + public void Reentrancy_StopCompletelyCallback_ReenteringCancelMoveTo_NoOps() + { + // r4-port-plan.md §4 reentrancy invariant: the StopCompletely tail + // of CancelMoveTo/CleanUpAndCallWeenie can re-enter + // InterruptCurrentMovement -> CancelMoveTo (this is exactly what + // happens in production: MotionInterpreter.StopCompletely() + // invokes InterruptCurrentMovement, which V5 binds to + // entity.MoveTo.CancelMoveTo). This must no-op because CleanUp + // already reset movement_type to Invalid BEFORE StopCompletely + // runs. Wire the reentrant callback DIRECTLY (bypassing the shared + // harness, which doesn't expose this seam post-construction) to + // prove the invariant against the real CancelMoveTo/CleanUp + // ordering. + var interp = new MotionInterpreter(); + var body = new PhysicsBody { TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable | TransientStateFlags.Active }; + interp.PhysicsObj = body; + + Position worldPosition = new(1u, Vector3.Zero, Quaternion.Identity); + int stopCompletelyCalls = 0; + int reentrantCancelCalls = 0; + MoveToManager? mgr = null; + + mgr = new MoveToManager( + interp, + stopCompletely: () => + { + stopCompletely_body(); + }, + getPosition: () => worldPosition, + getHeading: () => 0f, + setHeading: (h, send) => { }, + getOwnRadius: () => 0.5f, + getOwnHeight: () => 2f, + contact: () => true, + isInterpolating: () => false, + getVelocity: () => Vector3.Zero, + getSelfId: () => 0x50000001u, + setTarget: (a, b, c, d) => { }, + clearTarget: () => { }, + getTargetQuantum: () => 0.0, + setTargetQuantum: q => { }); + + void stopCompletely_body() + { + stopCompletelyCalls++; + // Re-enter: exactly the retail chain + // interp.StopCompletely() -> InterruptCurrentMovement?.Invoke() + // -> entity.MoveTo.CancelMoveTo(ActionCancelled) (V5 binding). + reentrantCancelCalls++; + mgr!.CancelMoveTo(WeenieError.ActionCancelled); + } + + mgr.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + int stopCallsAfterArm = stopCompletelyCalls; // MoveToPosition's own unconditional stop (§3c) — 1 call, no reentrancy (MovementTypeState was already Invalid before this call started, so its OWN reentrant CancelMoveTo-from-StopCompletely no-ops too). + + mgr.CancelMoveTo(WeenieError.ActionCancelled); + + // CancelMoveTo's own StopCompletely fires exactly once more (its + // reentrant CancelMoveTo call finds MovementTypeState already + // Invalid — CleanUp ran first — so it no-ops and does NOT trigger a + // THIRD StopCompletely call). + Assert.Equal(stopCallsAfterArm + 1, stopCompletelyCalls); + Assert.Equal(2, reentrantCancelCalls); // one from MoveToPosition's own stop, one from CancelMoveTo's stop + Assert.Equal(MovementType.Invalid, mgr.MovementTypeState); + } + + [Fact] + public void CleanUpAndCallWeenie_FiresMoveToComplete_WithGivenError() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + + h.Manager.CleanUpAndCallWeenie(WeenieError.None); + + Assert.Single(h.MoveToCompleteCalls); + Assert.Equal(WeenieError.None, h.MoveToCompleteCalls[0]); + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void CleanUpAndCallWeenie_Ordering_MovementTypeAlreadyInvalid_WhenStopCompletelyFires() + { + // §7e: CleanUpAndCallWeenie = CleanUp() THEN StopCompletely() — + // reentrancy-safe ordering (the same ordering CancelMoveTo uses). + // Directly observe MovementTypeState AT THE MOMENT StopCompletely + // is invoked by wiring a probe into the seam. + var interp = new MotionInterpreter(); + var body = new PhysicsBody { TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable | TransientStateFlags.Active }; + interp.PhysicsObj = body; + Position worldPosition = new(1u, Vector3.Zero, Quaternion.Identity); + MovementType? stateDuringStopCompletely = null; + MoveToManager? mgr = null; + + mgr = new MoveToManager( + interp, + stopCompletely: () => stateDuringStopCompletely = mgr!.MovementTypeState, + getPosition: () => worldPosition, + getHeading: () => 0f, + setHeading: (h, send) => { }, + getOwnRadius: () => 0.5f, + getOwnHeight: () => 2f, + contact: () => true, + isInterpolating: () => false, + getVelocity: () => Vector3.Zero, + getSelfId: () => 0x50000001u, + setTarget: (a, b, c, d) => { }, + clearTarget: () => { }, + getTargetQuantum: () => 0.0, + setTargetQuantum: q => { }); + + mgr.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + + mgr.CleanUpAndCallWeenie(WeenieError.None); + + Assert.Equal(MovementType.Invalid, stateDuringStopCompletely); + } + + [Fact] + public void CleanUp_StopsCurrentAndAuxCommands_ClearsTargetForObjectMoves_ThenReinitializes() + { + var h = new MoveToManagerHarness(); + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Manager.MoveToObject(0x50008888u, 0x50008888u, 1f, 2f, new MovementParameters()); + var target = new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity); + h.Manager.HandleUpdateTarget(new TargetInfo(0x50008888u, TargetStatus.Ok, target, target)); + Assert.NotEqual(0u, h.Manager.CurrentCommand); + + h.Manager.CleanUp(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + Assert.Equal(1, h.ClearTargetCalls); + Assert.Equal(0u, h.Manager.CurrentCommand); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerTestHarness.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerTestHarness.cs new file mode 100644 index 00000000..9a3a96c1 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerTestHarness.cs @@ -0,0 +1,138 @@ +using System; +using System.Collections.Generic; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — shared scripted fake interp-sink/provider harness for +/// conformance tests (r4-port-plan.md §3 V2: +/// "Use a scripted fake interp-sink/provider harness — NO real sequencer +/// needed; the manager drives the interp seams; assert the call sequences +/// + state"). Wraps a REAL bound to a +/// minimal always-grounded (so +/// _DoMotion/_StopMotion's adjust_motion + +/// DoInterpretedMotion/StopInterpretedMotion chain runs for +/// real, dispatch treated as always-succeeding since no +/// is wired — matching +/// DoInterpretedMotion's documented null-sink posture), and exposes +/// every ctor seam as a mutable, inspectable +/// field so tests can script position/heading/contact/target-tracker +/// behavior and assert on call sequences. +/// +internal sealed class MoveToManagerHarness +{ + public readonly MotionInterpreter Interp = new(); + public readonly PhysicsBody Body = new(); + + /// Scripted world position + cell (defaults to cell 1, origin). + public Position WorldPosition = new(1u, Vector3.Zero, Quaternion.Identity); + + /// Scripted compass heading, degrees (P5 convention). + public float Heading; + + /// Records every SetHeading(heading, send) call. + public readonly List<(float Heading, bool Send)> SetHeadingCalls = new(); + + public float OwnRadius = 0.5f; + public float OwnHeight = 2.0f; + + public bool ContactValue = true; + public bool IsInterpolatingValue; + public Vector3 Velocity = Vector3.Zero; + + public uint SelfId = 0x50000001u; + + /// Records every StopCompletely() call (count only — + /// retail's CPhysicsObj::StopCompletely takes no args at this + /// seam level). + public int StopCompletelyCalls; + + public readonly List<(uint ContextId, uint ObjectId, float Radius, double Quantum)> SetTargetCalls = new(); + public int ClearTargetCalls; + public double TargetQuantum; + public readonly List SetTargetQuantumCalls = new(); + + public int UnstickCalls; + public readonly List<(uint Tlid, float Radius, float Height)> StickToCalls = new(); + public readonly List MoveToCompleteCalls = new(); + + /// Scripted clock — advances by only + /// when a test calls ; reading CurTime alone + /// (e.g. multiple reads within one manager call) does NOT advance it, + /// matching retail's Timer::cur_time being a stable snapshot for + /// the duration of one dispatch. + public double CurTime; + public const double TickSeconds = 1.0 / 30.0; + + public readonly MoveToManager Manager; + + public MoveToManagerHarness() + { + Interp.PhysicsObj = Body; + Body.TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable | TransientStateFlags.Active; + + Manager = new MoveToManager( + Interp, + stopCompletely: () => StopCompletelyCalls++, + getPosition: () => WorldPosition, + getHeading: () => Heading, + setHeading: (h, send) => { SetHeadingCalls.Add((h, send)); Heading = h; }, + getOwnRadius: () => OwnRadius, + getOwnHeight: () => OwnHeight, + contact: () => ContactValue, + isInterpolating: () => IsInterpolatingValue, + getVelocity: () => Velocity, + getSelfId: () => SelfId, + setTarget: (ctx, obj, radius, quantum) => SetTargetCalls.Add((ctx, obj, radius, quantum)), + clearTarget: () => ClearTargetCalls++, + getTargetQuantum: () => TargetQuantum, + setTargetQuantum: q => { TargetQuantum = q; SetTargetQuantumCalls.Add(q); }, + curTime: () => CurTime); + + Manager.StickTo = (tlid, radius, height) => StickToCalls.Add((tlid, radius, height)); + Manager.MoveToComplete = err => MoveToCompleteCalls.Add(err); + Manager.Unstick = () => UnstickCalls++; + } + + /// Advance the scripted clock by one physics tick (1/30 s). + public void Tick() => CurTime += TickSeconds; + + /// Advance the scripted clock by an arbitrary amount. + public void Advance(double seconds) => CurTime += seconds; + + /// + /// Drains the REAL 's + /// pending_motions queue via synthetic MotionDone + /// callbacks — standing in for "the dispatched motion's animation-table + /// cycle finished", which a live AnimationSequencer/ + /// MotionTableManager would signal in production. Every + /// _DoMotion/_StopMotion call that succeeds enqueues a + /// node (retail AddToQueue, decomp's DoInterpretedMotion + /// body); without draining, + /// stays true forever in this bare harness, which would wedge + /// 's wait-for-anims gate + /// and Phase 1's + /// "animating, stop aux" branch permanently. Call after any manager + /// method that dispatches a motion, before asserting on the NEXT tick's + /// behavior. + /// + public void DrainPendingMotions() + { + while (Interp.MotionsPending()) + Interp.MotionDone(0, true); + } + + /// Current interpreted forward command — the observable proxy + /// for "what motion did MoveToManager just dispatch via _DoMotion", + /// since + /// writes through to + /// when ModifyInterpretedState is set (default true). + public uint ForwardCommand => Interp.InterpretedState.ForwardCommand; + + public uint TurnCommand => Interp.InterpretedState.TurnCommand; + + public float ForwardSpeed => Interp.InterpretedState.ForwardSpeed; +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerTurnToHeadingTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerTurnToHeadingTests.cs new file mode 100644 index 00000000..bb536d16 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerTurnToHeadingTests.cs @@ -0,0 +1,240 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — BeginTurnToHeading (00529b90, raw 307046-307120, +/// decomp §4d) and HandleTurnToHeading (0052a0c0, raw +/// 307442-307517, decomp §6c) — the direction-pick table (TurnRight ≤180 vs +/// TurnLeft >180), the "already there" early-outs, the +/// MotionsPending wait gate, the arrival snap +/// ( + the ONE set_heading in +/// the whole family), and the PreviousHeading DIFF-seed quirk. +/// +public sealed class MoveToManagerTurnToHeadingTests +{ + // ── BeginTurnToHeading direction pick (§4d) ──────────────────────────── + + [Theory] + [InlineData(0f, 90f, MotionCommand.TurnRight)] // diff=90 <=180 -> TurnRight + [InlineData(0f, 170f, MotionCommand.TurnRight)] // diff=170 <=180 -> TurnRight + [InlineData(0f, 190f, MotionCommand.TurnLeft)] // diff=190 >180 -> TurnLeft + [InlineData(0f, 270f, MotionCommand.TurnLeft)] // diff=270 >180 -> TurnLeft + public void DirectionPick_Table(float currentHeading, float targetHeading, uint expectedTurn) + { + var h = new MoveToManagerHarness(); + h.Heading = currentHeading; + + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = targetHeading }); + + Assert.Equal(expectedTurn, h.Manager.CurrentCommand); + } + + [Fact] + public void DirectionPick_ExactlyAt180_TurnRight_NotStrictlyGreater() + { + // diff > 180 is the TurnLeft gate (strict); exactly 180 stays TurnRight. + var h = new MoveToManagerHarness(); + h.Heading = 0f; + + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 180f }); + + Assert.Equal(MotionCommand.TurnRight, h.Manager.CurrentCommand); + } + + [Fact] + public void AlreadyThere_DiffLessThanOrEqualEpsilon_PopsImmediately_NoDispatch() + { + var h = new MoveToManagerHarness(); + h.Heading = 90f; + + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 90f }); + + Assert.Equal(0u, h.Manager.CurrentCommand); + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + Assert.Empty(h.Manager.PendingActions); + } + + [Fact] + public void AlreadyThere_WrappedNearFullCircle_PopsImmediately() + { + // diff > 180 branch's OWN "already there" check: diff + eps >= 360. + var h = new MoveToManagerHarness(); + h.Heading = 0.0001f; + + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 0f }); + + // diff computed via HeadingDiff(0, 0.0001, TurnRight) ~ -0.0001 -> wraps to ~359.9999 + // which is > 180 -> TurnLeft branch -> diff+eps >= 360 check. + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void WaitsForPendingAnimations_BeforeArmingTurn() + { + var h = new MoveToManagerHarness(); + h.Heading = 0f; + + // Simulate an in-flight animation-table motion BEFORE the turn is armed. + h.Interp.AddToQueue(0, MotionCommand.WalkForward, 0); + Assert.True(h.Interp.MotionsPending()); + + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 90f }); + + // BeginNextNode -> BeginTurnToHeading saw MotionsPending() true and + // returned WITHOUT dispatching — CurrentCommand stays 0, the node + // stays queued. + Assert.Equal(0u, h.Manager.CurrentCommand); + Assert.Single(h.Manager.PendingActions); + Assert.Equal(MovementType.TurnToHeading, h.Manager.MovementTypeState); + } + + [Fact] + public void EmptyQueue_CancelsWithNoPhysicsObjectCode() + { + var h = new MoveToManagerHarness(); + // Calling BeginTurnToHeading directly with no queued node -> CancelMoveTo(NoPhysicsObject, per A10). + h.Manager.BeginTurnToHeading(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void PreviousHeadingSeededWithDiff_NotAHeading() + { + var h = new MoveToManagerHarness(); + h.Heading = 0f; + + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 90f }); + + // The quirk: PreviousHeading stores the REMAINING DIFF (90), not the + // target heading value coincidentally equal to it here — verify via + // a case where they'd differ. + Assert.Equal(90f, h.Manager.PreviousHeading, 2); + } + + [Fact] + public void PreviousHeadingSeed_DiffersFromTargetHeading_ProvingItsADiffNotAHeading() + { + var h = new MoveToManagerHarness(); + h.Heading = 30f; + + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 90f }); + + // diff = HeadingDiff(90, 30, TurnRight) = 60 -- NOT 90 (the target + // heading) and NOT 30 (current heading) -- proves PreviousHeading + // stores the DIFF. + Assert.Equal(60f, h.Manager.PreviousHeading, 2); + } + + // ── HandleTurnToHeading (§6c): arrival snap + progress test ──────────── + + [Fact] + public void HandleTurnToHeading_NotCurrentlyTurning_ReArmsViaBeginTurnToHeading() + { + var h = new MoveToManagerHarness(); + h.Heading = 0f; + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 90f }); + h.DrainPendingMotions(); // clear the dispatch so a bare HandleTurnToHeading call doesn't hit the "still turning" path unexpectedly + + // Force CurrentCommand to something that isn't a turn (simulating an + // external interrupt that cleared it without popping the node) — + // exercised via CancelMoveTo would drop everything, so instead just + // confirm the normal flow already armed a turn command. + Assert.True(h.Manager.CurrentCommand is MotionCommand.TurnRight or MotionCommand.TurnLeft); + } + + [Fact] + public void HandleTurnToHeading_Arrival_SnapsHeadingAndSendsTrue() + { + var h = new MoveToManagerHarness(); + h.Heading = 0f; + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 90f }); + h.DrainPendingMotions(); + Assert.Equal(MotionCommand.TurnRight, h.Manager.CurrentCommand); + + // Advance heading to just past the target (heading_greater says we + // passed it) -- simulates the turn animation having rotated us there. + h.Heading = 91f; + + h.Manager.HandleTurnToHeading(); + + // The ONE heading snap in the whole family: SetHeading(90, send:true). + Assert.Contains((90f, true), h.SetHeadingCalls); + Assert.Equal(90f, h.Heading, 2); // snapped to the EXACT node heading, not 91. + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); // queue drained -> complete. + } + + [Fact] + public void HandleTurnToHeading_StillTurning_RotationalProgress_ResetsFailCounter() + { + // The first post-BeginTurnToHeading tick compares the LIVE heading + // (still 0, unmoved) against PreviousHeading's quirk-seeded DIFF + // value (170, not a heading) — HeadingDiff(0,170,TurnRight)=190, + // outside (eps,180), so tick 1 reads as NO progress (a numeric + // artifact of the seed, not a real stall) and FailProgressCount + // increments once. From tick 2 onward PreviousHeading holds a REAL + // heading and steady rotation reads as genuine progress. + var h = new MoveToManagerHarness(); + h.Heading = 0f; + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 170f }); + h.DrainPendingMotions(); + Assert.Equal(MotionCommand.TurnRight, h.Manager.CurrentCommand); + Assert.Equal(170f, h.Manager.PreviousHeading, 2); // diff-seeded (quirk) + + h.Manager.HandleTurnToHeading(); // tick 1 (heading unmoved) -- the seed artifact tick + Assert.Equal(1u, h.Manager.FailProgressCount); + Assert.Equal(0f, h.Manager.PreviousHeading, 2); + + h.Heading = 90f; // tick 2: rotated 90 deg toward the 170 target, hasn't passed it. + h.Manager.HandleTurnToHeading(); + + Assert.Equal(0u, h.Manager.FailProgressCount); // reset by genuine progress + Assert.Equal(90f, h.Manager.PreviousHeading, 2); // updated to the live heading + } + + [Fact] + public void HandleTurnToHeading_NoRotationalProgress_IncrementsFailCounter_WhenNotAnimating() + { + var h = new MoveToManagerHarness(); + h.Heading = 0f; + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 170f }); + h.DrainPendingMotions(); + + // Heading did not move at all -> HeadingDiff(0, 170, TurnRight): + // seeded PreviousHeading was 170; live heading still 0 -> diff = + // HeadingDiff(0, 170, TurnRight) = -170 -> +360 = 190; the progress + // window is (eps,180) exclusive on the high end -- 190 fails it -> + // no progress -> counter increments (not interpolating, not animating). + h.Manager.HandleTurnToHeading(); + + Assert.Equal(1u, h.Manager.FailProgressCount); + } + + [Fact] + public void HandleTurnToHeading_TurnLeftDirection_UsesMirroredHeadingDiff() + { + var h = new MoveToManagerHarness(); + h.Heading = 0f; + // diff = HeadingDiff(190,0,TurnRight) = 190 > 180 -> TurnLeft chosen. + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 190f }); + h.DrainPendingMotions(); + Assert.Equal(MotionCommand.TurnLeft, h.Manager.CurrentCommand); + + // Rotate counter-clockwise (heading decreasing toward the target + // from the TurnLeft direction) -- heading_greater(-, node.Heading=190, TurnLeft) + // needs the mirror-aware diff test to register progress correctly. + h.Heading = 350f; // moved 10 deg counter-clockwise from 0 (i.e. toward 190 the "left" way) + + h.Manager.HandleTurnToHeading(); + + // Just verifying no crash / a sane FailProgressCount either way — + // the mirror's behavioral effect is dead in retail (§8, P3 + // adjudication: the mirror only affects fail_progress_count + // reset-vs-increment, which is write-only) so this is a smoke test + // for the TurnLeft code path executing without throwing. + Assert.True(h.Manager.FailProgressCount is 0 or 1); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerUseTimeGateTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerUseTimeGateTests.cs new file mode 100644 index 00000000..0fb21e48 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToManagerUseTimeGateTests.cs @@ -0,0 +1,150 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V2 — UseTime (0052a780, raw 307776-307798, decomp §6a): +/// the three-gate tick matrix (grounded / node-exists / object-move +/// initialized), including the uninitialized type-6 stall case from the +/// port plan's V2 test list. +/// +public sealed class MoveToManagerUseTimeGateTests +{ + [Fact] + public void NoNodeQueued_UseTimeIsANoOp() + { + var h = new MoveToManagerHarness(); + // Fresh manager: no active move, no nodes. + h.Manager.UseTime(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + [Fact] + public void NotGrounded_ContactFalse_UseTimeDoesNothing_EvenWithNodesQueued() + { + var h = new MoveToManagerHarness { ContactValue = false }; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; // face the target so BeginMoveForward runs (no turn-to-face node needed) + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters()); + h.DrainPendingMotions(); + uint commandBefore = h.Manager.CurrentCommand; + + // Move the mover without letting UseTime process it (Contact=false blocks the gate). + h.WorldPosition = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity); + h.Advance(5.0); + h.Manager.UseTime(); + + // State machine did not advance -- still the same command, same type. + Assert.Equal(commandBefore, h.Manager.CurrentCommand); + Assert.Equal(MovementType.MoveToPosition, h.Manager.MovementTypeState); + } + + [Fact] + public void Grounded_MoveToPositionNode_DispatchesToHandleMoveToPosition() + { + var h = new MoveToManagerHarness { ContactValue = true }; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; // face the target so BeginMoveForward runs (no turn-to-face node needed) + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters { DistanceToObject = 0.6f, UseSpheres = false }); + h.DrainPendingMotions(); + + // Arrived: move the mover close to the TARGET (20,0,0), well within + // DistanceToObject, and advance time so CheckProgressMade evaluates + // true and the arrival branch pops. + h.WorldPosition = new Position(1u, new Vector3(19.7f, 0f, 0f), Quaternion.Identity); + h.Advance(2.0); + + h.Manager.UseTime(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); // HandleMoveToPosition ran and completed the move. + } + + [Fact] + public void Grounded_TurnToHeadingNode_DispatchesToHandleTurnToHeading() + { + var h = new MoveToManagerHarness { ContactValue = true }; + h.Heading = 0f; + h.Manager.TurnToHeading(new MovementParameters { DesiredHeading = 90f }); + h.DrainPendingMotions(); + Assert.Equal(MotionCommand.TurnRight, h.Manager.CurrentCommand); + + h.Heading = 91f; // "passed" the target + h.Manager.UseTime(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); // HandleTurnToHeading ran and completed the turn. + } + + [Fact] + public void ObjectMove_UninitializedType6_StallsUntilFirstTargetCallback() + { + // The port plan's named "uninitialized type-6 stall" case: a + // MoveToObject manager with TopLevelObjectId != 0 and + // MovementTypeState != Invalid, but Initialized still false (no + // HandleUpdateTarget callback has arrived yet) -- and CRITICALLY, + // no node is queued yet either (MoveToObject defers node-building + // to the first callback, §3b), so UseTime's node-exists gate (gate + // 2) already blocks it. This test proves the stall holds even if a + // node WERE somehow present (defense in depth for gate 3). + var h = new MoveToManagerHarness { ContactValue = true }; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Manager.MoveToObject(0x5000AAAAu, 0x5000AAAAu, 1f, 2f, new MovementParameters()); + + Assert.False(h.Manager.Initialized); + Assert.Empty(h.Manager.PendingActions); // gate 2 alone already stalls it + + h.Manager.UseTime(); + + // No crash, no state change -- the manager is still waiting. + Assert.Equal(MovementType.MoveToObject, h.Manager.MovementTypeState); + Assert.False(h.Manager.Initialized); + } + + [Fact] + public void ObjectMove_Initialized_PassesGate3_ProcessesNormally() + { + var h = new MoveToManagerHarness { ContactValue = true }; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; // face the target so the internal node plan skips the turn-to-face step + h.Manager.MoveToObject(0x5000BBBBu, 0x5000BBBBu, radius: 0.5f, height: 2f, new MovementParameters { UseSpheres = false }); + + var target = new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity); + h.Manager.HandleUpdateTarget(new TargetInfo(0x5000BBBBu, TargetStatus.Ok, target, target)); + Assert.True(h.Manager.Initialized); + h.DrainPendingMotions(); + + h.WorldPosition = new Position(1u, new Vector3(19.5f, 0f, 0f), Quaternion.Identity); // within DistanceToObject default 0.6 + h.Advance(2.0); + + h.Manager.UseTime(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); // completed via UseTime -> HandleMoveToPosition. + } + + [Fact] + public void NonObjectMove_TopLevelIdZero_Gate3AlwaysPasses_RegardlessOfInitialized() + { + // Gate 3: (top_level_object_id == 0 || movement_type == Invalid) || + // initialized. Position/heading moves never set TopLevelObjectId, + // so the FIRST disjunct alone always satisfies gate 3 -- Initialized + // staying false (as it does for MoveToPosition/TurnToHeading, per + // §3c/§3e's notes) never blocks them. + var h = new MoveToManagerHarness { ContactValue = true }; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + h.Manager.MoveToPosition(new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), new MovementParameters { DistanceToObject = 0.6f, UseSpheres = false }); + h.DrainPendingMotions(); + + Assert.Equal(0u, h.Manager.TopLevelObjectId); + Assert.False(h.Manager.Initialized); + + h.WorldPosition = new Position(1u, new Vector3(19.7f, 0f, 0f), Quaternion.Identity); + h.Advance(2.0); + h.Manager.UseTime(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); // gate 3 passed via the first disjunct. + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathCylinderDistanceTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathCylinderDistanceTests.cs new file mode 100644 index 00000000..eb21d692 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathCylinderDistanceTests.cs @@ -0,0 +1,91 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V1 — Position::cylinder_distance, the pure-math shape per +/// r4-moveto-decomp.md §5a (MoveToManager::GetCurrentDistance, +/// 005291b0): edge-to-edge distance between two vertical cylinders +/// (own radius/height, target radius/height, both positions). Object moves +/// (use_spheres set on the wire) use this; position moves use plain +/// Euclidean Position::distance (§5a: "position moves use center +/// distance" — is the object-move +/// variant only; center distance is Vector3.Distance, already +/// available, not re-ported here). +/// +/// +/// The retail signature's exact combination math for radius/height beyond +/// "edge-to-edge, own+target cylinders" is not spelled out in the raw (BN +/// garbles the x87 plumbing) — ported per the PDB argument ORDER +/// (own radius/height, own position, target radius/height, target +/// position) with the standard cylinder-distance shape: horizontal +/// (planar) distance minus the sum of the two radii (clamped at 0), since +/// that is the only shape consistent with "edge-to-edge" and with +/// distance_to_object's ctor default of 0.6 (melee range from +/// surface to surface, not center to center). +/// +/// +public sealed class MoveToMathCylinderDistanceTests +{ + [Fact] + public void TwoCylinders_HorizontallySeparated_SubtractsBothRadii() + { + // centers 10 units apart on X, radii 1 and 2 → edge distance = 10-1-2=7 + float d = MoveToMath.CylinderDistance( + ownRadius: 1f, ownHeight: 2f, ownPos: Vector3.Zero, + targetRadius: 2f, targetHeight: 2f, targetPos: new Vector3(10f, 0f, 0f)); + + Assert.Equal(7f, d, 3); + } + + [Fact] + public void TwoCylinders_Overlapping_ClampsAtZero_NoNegativeDistance() + { + // centers 1 unit apart, radii 5 and 5 → would be -9, clamps to 0 + float d = MoveToMath.CylinderDistance( + ownRadius: 5f, ownHeight: 2f, ownPos: Vector3.Zero, + targetRadius: 5f, targetHeight: 2f, targetPos: new Vector3(1f, 0f, 0f)); + + Assert.Equal(0f, d, 3); + } + + [Fact] + public void TwoCylinders_ZeroRadii_ReducesToCenterDistance() + { + float d = MoveToMath.CylinderDistance( + ownRadius: 0f, ownHeight: 2f, ownPos: Vector3.Zero, + targetRadius: 0f, targetHeight: 2f, targetPos: new Vector3(3f, 4f, 0f)); + + Assert.Equal(5f, d, 3); // 3-4-5 triangle + } + + [Fact] + public void TwoCylinders_IgnoresVerticalSeparation_PlanarOnly() + { + // Same X/Y, large Z separation — cylinder_distance in retail's own + // callers (GetCurrentDistance) is used for horizontal arrival gates; + // the Z axis is height, not part of the radial edge-to-edge gap. + float d1 = MoveToMath.CylinderDistance( + ownRadius: 1f, ownHeight: 2f, ownPos: new Vector3(0, 0, 0), + targetRadius: 1f, targetHeight: 2f, targetPos: new Vector3(5f, 0f, 0f)); + float d2 = MoveToMath.CylinderDistance( + ownRadius: 1f, ownHeight: 2f, ownPos: new Vector3(0, 0, 50f), + targetRadius: 1f, targetHeight: 2f, targetPos: new Vector3(5f, 0f, -50f)); + + Assert.Equal(d1, d2, 3); + Assert.Equal(3f, d1, 3); // 5 - 1 - 1 + } + + [Fact] + public void SamePosition_ZeroDistance_ClampsNotNegative() + { + float d = MoveToMath.CylinderDistance( + ownRadius: 0.5f, ownHeight: 2f, ownPos: Vector3.Zero, + targetRadius: 0.5f, targetHeight: 2f, targetPos: Vector3.Zero); + + Assert.Equal(0f, d, 3); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathHeadingDiffTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathHeadingDiffTests.cs new file mode 100644 index 00000000..1159642b --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathHeadingDiffTests.cs @@ -0,0 +1,164 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V1 — heading_diff (0x00528fb0), PINNED by direct +/// disassembly of the PDB-matched retail binary (see +/// docs/research/2026-07-03-r4-moveto/ghidra-confirmations.md §P3 — this is +/// the strongest evidence tier in the whole R4 pin set, one level above a +/// Ghidra decompile). Verbatim body: +/// +/// d = h1 - h2; +/// if (fabs(h1 - h2) < F_EPSILON) d = 0; +/// if (d < -F_EPSILON) d += 360; +/// if (F_EPSILON < d && turnCmd != TurnRight) d = 360 - d; // the mirror +/// return d; +/// +/// F_EPSILON = 0.000199999995f. The mirror gates on the turn command being +/// NOT TurnRight (0x6500000d) — TurnLeft (and any other command) measures +/// the COMPLEMENTARY angle. This contradicts r4-moveto-decomp.md §5g's +/// "arg3 UNUSED" claim, which the Ghidra pin overrides (adjudicated in +/// V0-pins.md). +/// +public sealed class MoveToMathHeadingDiffTests +{ + private const float Eps = 0.000199999995f; + private const uint TurnRight = MotionCommand.TurnRight; + private const uint TurnLeft = MotionCommand.TurnLeft; + + // ── basic subtraction, TurnRight (no mirror) ─────────────────────────── + + [Fact] + public void TurnRight_SimplePositiveDiff_NoWrap() + { + float d = MoveToMath.HeadingDiff(90f, 30f, TurnRight); + Assert.Equal(60f, d, 3); + } + + [Fact] + public void TurnRight_NegativeDiff_WrapsBy360() + { + // h1 - h2 = 30 - 90 = -60 → wraps to 300 + float d = MoveToMath.HeadingDiff(30f, 90f, TurnRight); + Assert.Equal(300f, d, 3); + } + + [Fact] + public void TurnRight_ZeroDiff_IsZero() + { + float d = MoveToMath.HeadingDiff(45f, 45f, TurnRight); + Assert.Equal(0f, d, 3); + } + + // ── epsilon boundary (both sides) ────────────────────────────────────── + + [Fact] + public void EpsilonBoundary_ExactlyAtEpsilon_NotSnappedToZero() + { + // fabs(d) < EPSILON is a STRICT less-than — exactly at epsilon does + // NOT snap to zero. + float d = MoveToMath.HeadingDiff(Eps, 0f, TurnRight); + Assert.NotEqual(0f, d); + Assert.Equal(Eps, d, 6); + } + + [Fact] + public void EpsilonBoundary_JustBelowEpsilon_SnapsToZero() + { + float d = MoveToMath.HeadingDiff(Eps * 0.5f, 0f, TurnRight); + Assert.Equal(0f, d); + } + + [Fact] + public void EpsilonBoundary_NegativeJustBelowNegEpsilon_WrapsBy360() + { + // d = -Eps * 1.5 < -Eps → wraps + float raw = -Eps * 1.5f; + float d = MoveToMath.HeadingDiff(raw, 0f, TurnRight); + Assert.Equal(raw + 360f, d, 3); + } + + [Fact] + public void EpsilonBoundary_NegativeExactlyAtNegEpsilon_DoesNotWrap() + { + // d < -EPSILON is STRICT — exactly -EPSILON does not wrap. + float d = MoveToMath.HeadingDiff(-Eps, 0f, TurnRight); + Assert.Equal(-Eps, d, 6); + } + + // ── the mirror (TurnLeft / not-TurnRight) ────────────────────────────── + + [Fact] + public void TurnLeft_PositiveDiffAboveEpsilon_MirroredTo360MinusD() + { + float d = MoveToMath.HeadingDiff(90f, 30f, TurnLeft); + // raw = 60; mirror: 360 - 60 = 300 + Assert.Equal(300f, d, 3); + } + + [Fact] + public void TurnLeft_NegativeDiff_WrapsThenMirrors() + { + // h1-h2 = 30-90 = -60 → wraps to 300 → mirror gate (300 > EPS, not + // TurnRight) → 360 - 300 = 60 + float d = MoveToMath.HeadingDiff(30f, 90f, TurnLeft); + Assert.Equal(60f, d, 3); + } + + [Fact] + public void TurnLeft_ZeroDiff_MirrorGateDoesNotFire_StaysZero() + { + // d == 0 does not satisfy `d > EPSILON`, so the mirror never fires + // regardless of turn command. + float d = MoveToMath.HeadingDiff(45f, 45f, TurnLeft); + Assert.Equal(0f, d); + } + + [Fact] + public void TurnLeft_AtEpsilonBoundary_MirrorGateIsStrictGreaterThan() + { + // d > EPSILON is STRICT: exactly at EPSILON does NOT mirror. + float d = MoveToMath.HeadingDiff(Eps, 0f, TurnLeft); + Assert.Equal(Eps, d, 6); + } + + [Fact] + public void TurnLeft_JustAboveEpsilon_Mirrors() + { + float raw = Eps * 2f; + float d = MoveToMath.HeadingDiff(raw, 0f, TurnLeft); + Assert.Equal(360f - raw, d, 3); + } + + [Fact] + public void AnyNonTurnRightCommand_AlsoMirrors() + { + // The gate is "!= TurnRight", not "== TurnLeft" — any other command + // (e.g. 0, WalkForward) also triggers the mirror. + float d = MoveToMath.HeadingDiff(90f, 30f, 0u); + Assert.Equal(300f, d, 3); + + float d2 = MoveToMath.HeadingDiff(90f, 30f, MotionCommand.WalkForward); + Assert.Equal(300f, d2, 3); + } + + // ── 360-wrap combined with the mirror ────────────────────────────────── + + [Fact] + public void TurnRight_FullCircleInputs_NormalizeCorrectly() + { + float d = MoveToMath.HeadingDiff(350f, 10f, TurnRight); + Assert.Equal(340f, d, 3); + } + + [Fact] + public void TurnLeft_FullCircleInputs_MirroredAfterNormalize() + { + // raw = 350-10 = 340 (no wrap needed, positive); mirror: 360-340=20 + float d = MoveToMath.HeadingDiff(350f, 10f, TurnLeft); + Assert.Equal(20f, d, 3); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathHeadingGreaterTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathHeadingGreaterTests.cs new file mode 100644 index 00000000..7ab6fdff --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathHeadingGreaterTests.cs @@ -0,0 +1,82 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V1 — heading_greater (00528f60, raw 306281-306323), per +/// r4-moveto-decomp.md §5f: +/// +/// if (fabs(a - b) > 180) greater = (b > a); // wrapped case: compare flipped +/// else greater = (a > b); +/// if (turnCmd == TurnRight) return greater; +/// return !greater; // TurnLeft: inverted +/// +/// "Has the turn passed the target heading" — direction-aware, wrap-aware. +/// +public sealed class MoveToMathHeadingGreaterTests +{ + private const uint TurnRight = MotionCommand.TurnRight; + private const uint TurnLeft = MotionCommand.TurnLeft; + + [Fact] + public void TurnRight_UnwrappedCase_SimpleGreater() + { + Assert.True(MoveToMath.HeadingGreater(90f, 30f, TurnRight)); + Assert.False(MoveToMath.HeadingGreater(30f, 90f, TurnRight)); + } + + [Fact] + public void TurnRight_WrappedCase_ComparisonFlips() + { + // |350 - 10| = 340 > 180 → wrapped: greater = (b > a) = (10 > 350) = false + Assert.False(MoveToMath.HeadingGreater(350f, 10f, TurnRight)); + // |10 - 350| = 340 > 180 → wrapped: greater = (b > a) = (350 > 10) = true + Assert.True(MoveToMath.HeadingGreater(10f, 350f, TurnRight)); + } + + [Fact] + public void TurnRight_ExactlyAt180Delta_UnwrappedBranch() + { + // fabs(a-b) > 180 is STRICT — exactly 180 uses the unwrapped branch. + // a=200,b=20: fabs=180, not >180 → greater = (a>b) = true + Assert.True(MoveToMath.HeadingGreater(200f, 20f, TurnRight)); + } + + [Fact] + public void TurnLeft_InvertsTheUnwrappedResult() + { + Assert.False(MoveToMath.HeadingGreater(90f, 30f, TurnLeft)); + Assert.True(MoveToMath.HeadingGreater(30f, 90f, TurnLeft)); + } + + [Fact] + public void TurnLeft_InvertsTheWrappedResult() + { + Assert.True(MoveToMath.HeadingGreater(350f, 10f, TurnLeft)); + Assert.False(MoveToMath.HeadingGreater(10f, 350f, TurnLeft)); + } + + [Fact] + public void EqualHeadings_NotGreater_TurnRight() + { + Assert.False(MoveToMath.HeadingGreater(45f, 45f, TurnRight)); + } + + [Fact] + public void EqualHeadings_InvertedToTrue_TurnLeft() + { + // greater=false for equal headings; TurnLeft inverts → true. + Assert.True(MoveToMath.HeadingGreater(45f, 45f, TurnLeft)); + } + + [Fact] + public void AnyNonTurnRightCommand_AlsoInverts() + { + // The retail gate is `== TurnRight` (not `!= TurnRight` as in + // heading_diff) — every OTHER command, not just TurnLeft, inverts. + Assert.False(MoveToMath.HeadingGreater(90f, 30f, 0u)); + Assert.False(MoveToMath.HeadingGreater(90f, 30f, MotionCommand.WalkForward)); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathPositionHeadingTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathPositionHeadingTests.cs new file mode 100644 index 00000000..cd9fe4f7 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MoveToMathPositionHeadingTests.cs @@ -0,0 +1,127 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V1 — Position::heading / Frame::get_heading / +/// Frame::set_heading, per V0-pins.md §P5 (PINNED — compass degrees, +/// 0 = North (+Y), 90 = East (+X), CLOCKWISE, [0,360); identity quaternion +/// faces heading 0): +/// +/// heading(from, to) = (450 - atan2Deg(dy, dx)) % 360 +/// +/// Golden cardinals: N(0,+1)→0, E(+1,0)→90, S(0,-1)→180, W(-1,0)→270. +/// +/// +/// The packer-reuse trap (V0-pins §P5 correction): acdream's +/// outbound packer (GameWindow.YawToAcQuaternion) is wire-correct at +/// the QUATERNION level but its internal scalar intermediate +/// (headingDeg = 180 - yawDeg) is holtburger's shifted convention, +/// NOT retail's wire convention. must +/// use the CORRECT scalar bridge from acdream yaw (yaw=0 faces +X, per +/// PlayerMovementController.cs:1022-1025): heading = (90 - +/// yawDeg) mod 360 — NOT 180 - yawDeg. +/// +/// +public sealed class MoveToMathPositionHeadingTests +{ + private const float Tol = 0.01f; + + // ── PositionHeading: the four cardinal offsets ───────────────────────── + + [Fact] + public void North_PlusY_IsZero() + { + float h = MoveToMath.PositionHeading(Vector3.Zero, new Vector3(0f, 1f, 0f)); + Assert.Equal(0f, h, 2); + } + + [Fact] + public void East_PlusX_Is90() + { + float h = MoveToMath.PositionHeading(Vector3.Zero, new Vector3(1f, 0f, 0f)); + Assert.Equal(90f, h, 2); + } + + [Fact] + public void South_MinusY_Is180() + { + float h = MoveToMath.PositionHeading(Vector3.Zero, new Vector3(0f, -1f, 0f)); + Assert.Equal(180f, h, 2); + } + + [Fact] + public void West_MinusX_Is270() + { + float h = MoveToMath.PositionHeading(Vector3.Zero, new Vector3(-1f, 0f, 0f)); + Assert.Equal(270f, h, 2); + } + + [Fact] + public void Heading_IsAlways_InZeroToThreeSixtyRange() + { + // NE diagonal + float h = MoveToMath.PositionHeading(Vector3.Zero, new Vector3(1f, 1f, 0f)); + Assert.InRange(h, 0f, 360f); + Assert.Equal(45f, h, 2); + } + + [Fact] + public void Heading_IgnoresZ_HorizontalOnly() + { + float h1 = MoveToMath.PositionHeading(new Vector3(0, 0, 5f), new Vector3(1f, 0f, -10f)); + float h2 = MoveToMath.PositionHeading(new Vector3(0, 0, -3f), new Vector3(1f, 0f, 100f)); + Assert.Equal(h1, h2, 2); + Assert.Equal(90f, h1, 2); + } + + // ── GetHeading: extracts heading from a body orientation quaternion ──── + + [Fact] + public void GetHeading_IdentityQuaternion_FacesHeadingZero() + { + // Identity quaternion → acdream yaw = 0 → +X-facing in our + // convention, which decodes to AC heading 90 per the corrected + // scalar bridge... BUT the identity quaternion in acdream's body + // frame corresponds to yaw = -PI/2 relative to +Y-forward (see + // PlayerMovementController.cs:1025: Orientation = AxisAngle(Yaw - + // PI/2)). GetHeading must invert that exact convention: identity + // orientation (no rotation applied) means Yaw=PI/2 was baked in, + // which is heading 0 — matching P5's "identity quaternion faces + // heading 0" pin. + float h = MoveToMath.GetHeading(Quaternion.Identity); + Assert.Equal(0f, h, 1); + } + + [Fact] + public void GetHeading_SetHeading_RoundTrips_Cardinals() + { + foreach (float heading in new[] { 0f, 90f, 180f, 270f, 45f, 359f }) + { + var q = MoveToMath.SetHeading(Quaternion.Identity, heading); + float back = MoveToMath.GetHeading(q); + float diff = MathF.Abs(back - heading); + if (diff > 180f) diff = 360f - diff; + Assert.True(diff < 0.5f, $"heading {heading} round-tripped to {back}"); + } + } + + [Fact] + public void SetHeading_North_ProducesForwardVectorFacingPlusY() + { + var q = MoveToMath.SetHeading(Quaternion.Identity, 0f); + var forward = Vector3.Transform(new Vector3(0f, 1f, 0f), q); + Assert.True(forward.Y > 0.9f, $"expected +Y forward, got {forward}"); + } + + [Fact] + public void SetHeading_East_ProducesForwardVectorFacingPlusX() + { + var q = MoveToMath.SetHeading(Quaternion.Identity, 90f); + var forward = Vector3.Transform(new Vector3(0f, 1f, 0f), q); + Assert.True(forward.X > 0.9f, $"expected +X forward, got {forward}"); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MovementManagerTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MovementManagerTests.cs new file mode 100644 index 00000000..da8e627d --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MovementManagerTests.cs @@ -0,0 +1,341 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R5-V5 — facade conformance (retail struct +/// acclient.h /* 3463 */; methods 0x00524000-0x00524790, decomp extract +/// docs/research/2026-07-03-r5-managers/r5-movementmanager-decomp.md). +/// The facade is pure relay/ownership — these tests pin the retail call +/// shapes: which child each method touches, the lazy MakeMoveToManager +/// create, the PerformMovement type dispatch, and null-tolerance before the +/// moveto manager exists. Behavior of the children themselves is covered by +/// the MotionInterpreter / MoveToManager suites (UNMODIFIED by R5-V5). +/// +public sealed class MovementManagerTests +{ + /// Non-creature weenie: silences the MotionInterpreter's + /// HitGround/LeaveGround creature gates (retail IsCreature vtable + /// +0x2c) so a test can isolate the facade's MOVETO relay leg. + private sealed class NonCreatureWeenie : IWeenieObject + { + public bool InqJumpVelocity(float extent, out float vz) { vz = 0f; return false; } + public bool InqRunRate(out float rate) { rate = 1f; return false; } + public bool CanJump(float extent) => false; + bool IWeenieObject.IsCreature() => false; + } + + /// Facade over the shared MoveToManagerHarness: the harness's + /// REAL MotionInterpreter is the minterp child; the harness's REAL + /// seam-scripted MoveToManager arrives via + /// (the acdream stand-in for retail's physics_obj/weenie_obj + /// backpointers that MakeMoveToManager constructs from). + private static (MovementManager Mm, MoveToManagerHarness H, int[] FactoryCalls) MakeFacade() + { + var h = new MoveToManagerHarness(); + var factoryCalls = new int[1]; + var mm = new MovementManager(h.Interp) + { + MoveToFactory = () => { factoryCalls[0]++; return h.Manager; }, + }; + return (mm, h, factoryCalls); + } + + // ── MakeMoveToManager — 0x00524000 ────────────────────────────────────── + + [Fact] + public void MakeMoveToManager_CreatesViaFactory_ExactlyOnce() + { + var (mm, h, calls) = MakeFacade(); + Assert.Null(mm.MoveTo); + + mm.MakeMoveToManager(); + Assert.Same(h.Manager, mm.MoveTo); + Assert.Equal(1, calls[0]); + + // Retail: no-op if already present. + mm.MakeMoveToManager(); + Assert.Same(h.Manager, mm.MoveTo); + Assert.Equal(1, calls[0]); + } + + [Fact] + public void MakeMoveToManager_WithoutFactory_IsANoOp() + { + var mm = new MovementManager(new MotionInterpreter()); + mm.MakeMoveToManager(); + Assert.Null(mm.MoveTo); + } + + // ── PerformMovement — 0x005240d0 (the type-1..9 two-way dispatch) ─────── + + [Fact] + public void PerformMovement_InterpTypes_RouteToMinterp_NotMoveTo() + { + var (mm, h, calls) = MakeFacade(); + + var result = mm.PerformMovement(new MovementStruct + { + Type = MovementType.InterpretedCommand, + Motion = MotionCommand.WalkForward, + Speed = 1f, + ModifyInterpretedState = true, + }); + + Assert.Equal(WeenieError.None, result); + Assert.Equal(MotionCommand.WalkForward, h.Interp.InterpretedState.ForwardCommand); + // Types 1-5 never touch the moveto side (jump table 0x0052415c). + Assert.Equal(0, calls[0]); + Assert.Null(mm.MoveTo); + } + + [Fact] + public void PerformMovement_MoveToTypes_LazyCreate_AndRouteToMoveTo() + { + var (mm, h, calls) = MakeFacade(); + + var result = mm.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), + Params = new MovementParameters(), + }); + + // Retail cases 5-8 (types 6-9): MakeMoveToManager first, delegate, + // and the MoveToManager path's return is NOT propagated (@0052414f + // `return 0`) — the facade reports None regardless. + Assert.Equal(WeenieError.None, result); + Assert.Equal(1, calls[0]); + Assert.Equal(MovementType.MoveToPosition, h.Manager.MovementTypeState); + } + + [Fact] + public void PerformMovement_InvalidAndOutOfRangeTypes_Fail0x47() + { + var (mm, _, calls) = MakeFacade(); + + // Retail head: (type - 1) > 8 → 0x47. Type 0 underflows unsigned → + // always > 8; anything above 9 fails the same check. + Assert.Equal(WeenieError.GeneralMovementFailure, + mm.PerformMovement(new MovementStruct { Type = MovementType.Invalid })); + Assert.Equal(WeenieError.GeneralMovementFailure, + mm.PerformMovement(new MovementStruct { Type = (MovementType)10 })); + Assert.Equal(0, calls[0]); + } + + [Fact] + public void PerformMovement_MoveToType_WithoutFactory_Fails0x47() + { + // acdream-only guard for the unreachable-in-production ordering + // (a type-6..9 event before the bind sites set MoveToFactory): + // retail would MoveToManager::Create here; without a factory the + // facade reports the same 0x47 the range check uses. + var mm = new MovementManager(new MotionInterpreter()); + Assert.Equal(WeenieError.GeneralMovementFailure, + mm.PerformMovement(new MovementStruct { Type = MovementType.TurnToHeading })); + } + + // ── UseTime — 0x005242f0 (moveto only; never lazy-creates) ────────────── + + [Fact] + public void UseTime_BeforeMoveToExists_IsANoOp_AndDoesNotCreate() + { + var (mm, _, calls) = MakeFacade(); + mm.UseTime(); + Assert.Equal(0, calls[0]); + Assert.Null(mm.MoveTo); + } + + [Fact] + public void UseTime_RelaysToMoveTo() + { + // The MoveToManagerUseTimeGateTests arrival shape, driven through + // the facade: grounded, facing the target, arrived — one UseTime + // completes the move. + var (mm, h, _) = MakeFacade(); + h.ContactValue = true; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + + mm.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), + Params = new MovementParameters { DistanceToObject = 0.6f, UseSpheres = false }, + }); + h.DrainPendingMotions(); + + h.WorldPosition = new Position(1u, new Vector3(19.7f, 0f, 0f), Quaternion.Identity); + h.Advance(2.0); + mm.UseTime(); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + } + + // ── HitGround — 0x00524300 (minterp FIRST, then moveto) ──────────────── + + [Fact] + public void HitGround_RelaysToMinterp_AndToleratesNullMoveTo() + { + var (mm, h, _) = MakeFacade(); + h.Body.State |= PhysicsStateFlags.Gravity; // CMotionInterp::HitGround gates on state & 0x400 + bool minterpHit = false; + h.Interp.RemoveLinkAnimations = () => minterpHit = true; + + mm.HitGround(); // MoveTo still null — retail's if-present guard + Assert.True(minterpHit); + } + + [Fact] + public void HitGround_RelaysMinterpFirst_ThenMoveTo() + { + var (mm, h, _) = MakeFacade(); + h.Body.State |= PhysicsStateFlags.Gravity; + h.ContactValue = true; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + mm.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), + Params = new MovementParameters(), + }); + h.DrainPendingMotions(); + + // Order pin: the FIRST RemoveLinkAnimations firing belongs to the + // minterp leg (CMotionInterp::HitGround invokes it before any + // dispatch), at which point the moveto leg's BeginNextNode + // re-dispatch has NOT happened yet — the pending queue is still + // drained. Later firings (the moveto dispatch's own TS-40 + // detached-strip at the DoInterpretedMotion tail runs AFTER its + // enqueue) must not overwrite the recording — ??= keeps the first. + bool? queueEmptyAtMinterpLeg = null; + h.Interp.RemoveLinkAnimations = + () => queueEmptyAtMinterpLeg ??= !h.Interp.MotionsPending(); + + mm.HitGround(); + + Assert.True(queueEmptyAtMinterpLeg); // minterp leg ran first + Assert.True(h.Interp.MotionsPending()); // a re-dispatch landed after it + } + + [Fact] + public void HitGround_ReachesMoveTo_WhenMinterpLegIsGated() + { + // Isolate the MOVETO leg: a non-creature weenie makes + // CMotionInterp::HitGround a retail no-op (IsCreature gate), so any + // re-dispatched pending motion can only come from + // MoveToManager::HitGround → BeginNextNode. + var (mm, h, _) = MakeFacade(); + h.Interp.WeenieObj = new NonCreatureWeenie(); + h.ContactValue = true; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + mm.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), + Params = new MovementParameters(), + }); + h.DrainPendingMotions(); + + mm.HitGround(); + + Assert.True(h.Interp.MotionsPending()); + } + + // ── HandleExitWorld — 0x00524350 (minterp ONLY) ───────────────────────── + + [Fact] + public void HandleExitWorld_DrainsMinterp_AndDoesNotTouchMoveTo() + { + var (mm, h, _) = MakeFacade(); + h.ContactValue = true; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + h.Heading = 90f; + mm.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), + Params = new MovementParameters(), + }); + Assert.True(h.Interp.MotionsPending()); // the arm's dispatch is queued + + mm.HandleExitWorld(); + + Assert.False(h.Interp.MotionsPending()); + // Retail HandleExitWorld does NOT touch moveto_manager — the armed + // move survives (its teardown is CancelMoveTo / exit-world at the + // CPhysicsObj layer, not here). + Assert.Equal(MovementType.MoveToPosition, h.Manager.MovementTypeState); + } + + // ── CancelMoveTo — 0x005241b0 / IsMovingTo — 0x00524260 ──────────────── + + [Fact] + public void CancelMoveTo_NullTolerant_AndRelaysToMoveTo() + { + var (mm, h, _) = MakeFacade(); + mm.CancelMoveTo(WeenieError.ActionCancelled); // no moveto yet — no throw + + h.ContactValue = true; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + mm.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = new Position(1u, new Vector3(20f, 0f, 0f), Quaternion.Identity), + Params = new MovementParameters(), + }); + Assert.True(mm.IsMovingTo()); + + mm.CancelMoveTo(WeenieError.ActionCancelled); + + Assert.Equal(MovementType.Invalid, h.Manager.MovementTypeState); + Assert.False(mm.IsMovingTo()); + Assert.True(h.StopCompletelyCalls > 0); + } + + [Fact] + public void IsMovingTo_FalseBeforeMoveToExists() + { + var (mm, _, _) = MakeFacade(); + Assert.False(mm.IsMovingTo()); + } + + // ── HandleUpdateTarget — 0x00524790 (→ moveto) ────────────────────────── + + [Fact] + public void HandleUpdateTarget_NullTolerant_AndFeedsMoveToDeferredStart() + { + var (mm, h, _) = MakeFacade(); + var info = new TargetInfo + { + ObjectId = 0x5000AAAAu, + Status = TargetStatus.Ok, + TargetPosition = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity), + InterpolatedPosition = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity), + }; + mm.HandleUpdateTarget(info); // no moveto yet — no throw + + // The V2 "uninitialized type-6 stall": MoveToObject defers its node + // build to the FIRST HandleUpdateTarget delivery. + h.ContactValue = true; + h.WorldPosition = new Position(1u, Vector3.Zero, Quaternion.Identity); + mm.PerformMovement(new MovementStruct + { + Type = MovementType.MoveToObject, + ObjectId = 0x5000AAAAu, + TopLevelId = 0x5000AAAAu, + Pos = new Position(1u, new Vector3(10f, 0f, 0f), Quaternion.Identity), + Params = new MovementParameters(), + }); + Assert.False(h.Manager.Initialized); + + mm.HandleUpdateTarget(info); + + Assert.True(h.Manager.Initialized); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersFromWireTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersFromWireTests.cs new file mode 100644 index 00000000..6bc46f0d --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersFromWireTests.cs @@ -0,0 +1,186 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V1 — MovementParameters::UnPackNet (0x0052ac50, raw +/// 308118-308205) factory semantics, per +/// docs/research/2026-07-03-r4-moveto/r4-moveto-decomp.md §2g: the 7-dword +/// MoveTo wire form is bitfield, distance_to_object, min_distance, +/// fail_distance, speed, walk_run_threshhold, desired_heading — the SAME +/// field order UpdateMotion.TryParseMoveToPayload already reads off +/// the wire (UpdateMotion.cs:328-341). The A4 bitfield masks +/// (W0-pins.md §A4) decode into the named bool properties; every bit not +/// present on the wire bitfield resolves to false (UnPackNet fully +/// overwrites the bitfield — no ctor-default bits survive). +/// +public sealed class MovementParametersFromWireTests +{ + [Fact] + public void FromWire_AllBitsSet_EveryFlagTrue() + { + var p = MovementParameters.FromWire( + bitfield: 0x3FFFFu, // every A4 bit through 0x20000 + distanceToObject: 1f, + minDistance: 2f, + failDistance: 3f, + speed: 4f, + walkRunThreshhold: 5f, + desiredHeading: 6f); + + Assert.True(p.CanWalk); + Assert.True(p.CanRun); + Assert.True(p.CanSidestep); + Assert.True(p.CanWalkBackwards); + Assert.True(p.CanCharge); + Assert.True(p.FailWalk); + Assert.True(p.UseFinalHeading); + Assert.True(p.Sticky); + Assert.True(p.MoveAway); + Assert.True(p.MoveTowards); + Assert.True(p.UseSpheres); + Assert.True(p.SetHoldKey); + Assert.True(p.Autonomous); + Assert.True(p.ModifyRawState); + Assert.True(p.ModifyInterpretedState); + Assert.True(p.CancelMoveTo); + Assert.True(p.StopCompletelyFlag); + Assert.True(p.DisableJumpDuringLink); + } + + [Fact] + public void FromWire_ZeroBitfield_EveryFlagFalse_NoCtorDefaultsSurvive() + { + var p = MovementParameters.FromWire( + bitfield: 0u, + distanceToObject: 1f, minDistance: 2f, failDistance: 3f, + speed: 4f, walkRunThreshhold: 5f, desiredHeading: 6f); + + Assert.False(p.CanWalk); + Assert.False(p.CanRun); + Assert.False(p.CanSidestep); + Assert.False(p.CanWalkBackwards); + Assert.False(p.CanCharge); + Assert.False(p.MoveTowards); + Assert.False(p.UseSpheres); + Assert.False(p.SetHoldKey); + Assert.False(p.ModifyRawState); + Assert.False(p.ModifyInterpretedState); + Assert.False(p.CancelMoveTo); + Assert.False(p.StopCompletelyFlag); + } + + [Fact] + public void FromWire_CanChargeBit_DecodesIndependently() + { + // The wire bitfield carries can_charge 0x10 — the walk-vs-run answer + // (feedback_autowalk_cancharge_bit). Verify it round-trips on its own. + var p = MovementParameters.FromWire( + bitfield: 0x10u, + distanceToObject: 0f, minDistance: 0f, failDistance: 0f, + speed: 0f, walkRunThreshhold: 0f, desiredHeading: 0f); + + Assert.True(p.CanCharge); + Assert.False(p.CanWalk); + Assert.False(p.CanRun); + } + + [Theory] + [InlineData(0x1u)] + [InlineData(0x2u)] + [InlineData(0x4u)] + [InlineData(0x8u)] + [InlineData(0x10u)] + [InlineData(0x20u)] + [InlineData(0x40u)] + [InlineData(0x80u)] + [InlineData(0x100u)] + [InlineData(0x200u)] + [InlineData(0x400u)] + [InlineData(0x800u)] + [InlineData(0x1000u)] + [InlineData(0x2000u)] + [InlineData(0x4000u)] + [InlineData(0x8000u)] + [InlineData(0x10000u)] + [InlineData(0x20000u)] + public void FromWire_SingleBitMaskRoundTrips(uint mask) + { + var p = MovementParameters.FromWire( + bitfield: mask, + distanceToObject: 0f, minDistance: 0f, failDistance: 0f, + speed: 0f, walkRunThreshhold: 0f, desiredHeading: 0f); + + Assert.Equal(mask, ToBitfield(p)); + } + + [Fact] + public void FromWire_ScalarFields_CopiedInWireOrder() + { + var p = MovementParameters.FromWire( + bitfield: 0u, + distanceToObject: 1.5f, + minDistance: 2.5f, + failDistance: 3.5f, + speed: 4.5f, + walkRunThreshhold: 5.5f, + desiredHeading: 6.5f); + + Assert.Equal(1.5f, p.DistanceToObject); + Assert.Equal(2.5f, p.MinDistance); + Assert.Equal(3.5f, p.FailDistance); + Assert.Equal(4.5f, p.Speed); + Assert.Equal(5.5f, p.WalkRunThreshhold); + Assert.Equal(6.5f, p.DesiredHeading); + } + + [Fact] + public void FromWireTurnTo_ThreeDwordForm_LeavesDistanceFieldsAtDefault() + { + // TurnToObject/TurnToHeading wire form (0xc bytes, 3 dwords): + // bitfield, speed, desired_heading only. distance_to_object / + // min_distance / fail_distance / walk_run_threshhold are NOT on + // this wire form — the factory overload must not touch them + // (they keep the MovementParameters ctor defaults). + var p = MovementParameters.FromWireTurnTo( + bitfield: 0x2u, // can_run + speed: 2f, + desiredHeading: 90f); + + Assert.True(p.CanRun); + Assert.Equal(2f, p.Speed); + Assert.Equal(90f, p.DesiredHeading); + + // ctor defaults, untouched by the 3-dword form: + Assert.Equal(0.6f, p.DistanceToObject); + Assert.Equal(0f, p.MinDistance); + Assert.Equal(float.MaxValue, p.FailDistance); + Assert.Equal(15f, p.WalkRunThreshhold); + } + + private static uint ToBitfield(MovementParameters p) + { + uint bitfield = 0; + if (p.CanWalk) bitfield |= 0x1; + if (p.CanRun) bitfield |= 0x2; + if (p.CanSidestep) bitfield |= 0x4; + if (p.CanWalkBackwards) bitfield |= 0x8; + if (p.CanCharge) bitfield |= 0x10; + if (p.FailWalk) bitfield |= 0x20; + if (p.UseFinalHeading) bitfield |= 0x40; + if (p.Sticky) bitfield |= 0x80; + if (p.MoveAway) bitfield |= 0x100; + if (p.MoveTowards) bitfield |= 0x200; + if (p.UseSpheres) bitfield |= 0x400; + if (p.SetHoldKey) bitfield |= 0x800; + if (p.Autonomous) bitfield |= 0x1000; + if (p.ModifyRawState) bitfield |= 0x2000; + if (p.ModifyInterpretedState) bitfield |= 0x4000; + if (p.CancelMoveTo) bitfield |= 0x8000; + if (p.StopCompletelyFlag) bitfield |= 0x10000; + if (p.DisableJumpDuringLink) bitfield |= 0x20000; + return bitfield; + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersGetCommandTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersGetCommandTests.cs new file mode 100644 index 00000000..885baa2f --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersGetCommandTests.cs @@ -0,0 +1,340 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V1 — MovementParameters::get_command (0x0052aa00, raw +/// 307946-308012), verbatim per +/// docs/research/2026-07-03-r4-moveto/r4-moveto-decomp.md §5c. Covers the +/// command/moving_away pick (plain-towards / plain-away / towards_and_away +/// delegate) crossed with the walk-vs-run HoldKey cascade, INCLUDING the +/// CanCharge 0x10 fast-path ACE dropped (feedback_autowalk_cancharge_bit) +/// and the walk_run_threshhold ≤-vs-< edge (retail: dist - dto ≤ +/// threshold → walk; the raw's `test ah,0x41` is the inclusive ≤ reading, +/// §5c @308003). +/// +public sealed class MovementParametersGetCommandTests +{ + // ── plain TOWARDS (move_towards set, move_away clear) ───────────────── + + [Fact] + public void PlainTowards_DistGreaterThanDto_WalkForward_NotMovingAway() + { + var p = new MovementParameters { DistanceToObject = 0.6f }; + // move_towards=true (default), move_away=false (default) + + p.GetCommand(dist: 5f, headingDiff: 0f, out uint motion, out HoldKey holdKey, out bool movingAway); + + Assert.Equal(MotionCommand.WalkForward, motion); + Assert.False(movingAway); + } + + [Fact] + public void PlainTowards_DistNotGreaterThanDto_Idle() + { + var p = new MovementParameters { DistanceToObject = 0.6f }; + + p.GetCommand(dist: 0.6f, headingDiff: 0f, out uint motion, out _, out bool movingAway); + + Assert.Equal(0u, motion); + Assert.False(movingAway); + } + + [Fact] + public void PlainTowards_DistLessThanDto_Idle() + { + var p = new MovementParameters { DistanceToObject = 0.6f }; + + p.GetCommand(dist: 0.1f, headingDiff: 0f, out uint motion, out _, out _); + + Assert.Equal(0u, motion); + } + + // ── pure AWAY (move_away set, move_towards clear) ───────────────────── + + [Fact] + public void PureAway_DistLessThanMinDistance_WalkForward_MovingAway() + { + var p = new MovementParameters + { + MoveTowards = false, + MoveAway = true, + MinDistance = 5f, + }; + + p.GetCommand(dist: 2f, headingDiff: 0f, out uint motion, out _, out bool movingAway); + + Assert.Equal(MotionCommand.WalkForward, motion); + Assert.True(movingAway); + } + + [Fact] + public void PureAway_DistNotLessThanMinDistance_Idle() + { + var p = new MovementParameters + { + MoveTowards = false, + MoveAway = true, + MinDistance = 5f, + }; + + p.GetCommand(dist: 5f, headingDiff: 0f, out uint motion, out _, out bool movingAway); + + Assert.Equal(0u, motion); + Assert.False(movingAway); + } + + // ── towards_and_away delegate (both move_towards AND move_away set) ─── + + [Fact] + public void TowardsAndAway_DistGreaterThanDto_DelegatesToWalkForwardTowards() + { + var p = new MovementParameters + { + MoveTowards = true, + MoveAway = true, + DistanceToObject = 0.6f, + MinDistance = 0.2f, + }; + + p.GetCommand(dist: 5f, headingDiff: 0f, out uint motion, out _, out bool movingAway); + + Assert.Equal(MotionCommand.WalkForward, motion); + Assert.False(movingAway); + } + + [Fact] + public void TowardsAndAway_InsideMinBand_WalkBackwards_MovingAway() + { + var p = new MovementParameters + { + MoveTowards = true, + MoveAway = true, + DistanceToObject = 0.6f, + MinDistance = 0.2f, + }; + + // dist - min_distance < epsilon → inside the min band + p.GetCommand(dist: 0.2f, headingDiff: 0f, out uint motion, out _, out bool movingAway); + + Assert.Equal(MotionCommand.WalkBackward, motion); + Assert.True(movingAway); + } + + [Fact] + public void TowardsAndAway_InsideDeadband_Idle() + { + var p = new MovementParameters + { + MoveTowards = true, + MoveAway = true, + DistanceToObject = 0.6f, + MinDistance = 0.2f, + }; + + // strictly inside [min, dto] — neither band fires + p.GetCommand(dist: 0.4f, headingDiff: 0f, out uint motion, out _, out _); + + Assert.Equal(0u, motion); + } + + // ── neither towards nor away (both clear) — falls to plain-towards path ── + + [Fact] + public void NeitherTowardsNorAway_FallsToPlainTowardsBranch() + { + var p = new MovementParameters + { + MoveTowards = false, + MoveAway = false, + DistanceToObject = 0.6f, + }; + + p.GetCommand(dist: 5f, headingDiff: 0f, out uint motion, out _, out bool movingAway); + + Assert.Equal(MotionCommand.WalkForward, motion); + Assert.False(movingAway); + } + + // ── walk-vs-run HoldKey cascade ──────────────────────────────────────── + + [Fact] + public void HoldKey_CanChargeSet_AlwaysRun_FastPath() + { + // THE fast-path ACE dropped: can_charge (0x10) short-circuits + // straight to HoldKey_Run regardless of distance/threshold. + var p = new MovementParameters + { + CanCharge = true, + CanRun = false, // even with can_run CLEAR + CanWalk = true, + WalkRunThreshhold = 15f, + DistanceToObject = 0.6f, + }; + + p.GetCommand(dist: 0.6f, headingDiff: 0f, out _, out HoldKey holdKey, out _); + + Assert.Equal(HoldKey.Run, holdKey); + } + + [Fact] + public void HoldKey_CanRunClear_AlwaysWalk_RegardlessOfDistance() + { + var p = new MovementParameters + { + CanCharge = false, + CanRun = false, + CanWalk = true, + WalkRunThreshhold = 15f, + DistanceToObject = 0.6f, + }; + + p.GetCommand(dist: 1000f, headingDiff: 0f, out _, out HoldKey holdKey, out _); + + Assert.Equal(HoldKey.None, holdKey); + } + + [Fact] + public void HoldKey_CanRunSet_CanWalkClear_AlwaysRun_WalkIncapable() + { + // can_walk clear → the "close enough to walk" branch is skipped + // entirely; walk-incapable movers always run when can_run is set. + var p = new MovementParameters + { + CanCharge = false, + CanRun = true, + CanWalk = false, + WalkRunThreshhold = 15f, + DistanceToObject = 0.6f, + }; + + p.GetCommand(dist: 0.6f, headingDiff: 0f, out _, out HoldKey holdKey, out _); + + Assert.Equal(HoldKey.Run, holdKey); + } + + [Fact] + public void HoldKey_CanRunAndCanWalk_WithinThreshold_Walk() + { + var p = new MovementParameters + { + CanCharge = false, + CanRun = true, + CanWalk = true, + WalkRunThreshhold = 15f, + DistanceToObject = 0.6f, + }; + + // dist - dto = 10 <= 15 → walk + p.GetCommand(dist: 10.6f, headingDiff: 0f, out _, out HoldKey holdKey, out _); + + Assert.Equal(HoldKey.None, holdKey); + } + + [Fact] + public void HoldKey_CanRunAndCanWalk_BeyondThreshold_Run() + { + var p = new MovementParameters + { + CanCharge = false, + CanRun = true, + CanWalk = true, + WalkRunThreshhold = 15f, + DistanceToObject = 0.6f, + }; + + // dist - dto = 15.1 > 15 → run + p.GetCommand(dist: 15.7f, headingDiff: 0f, out _, out HoldKey holdKey, out _); + + Assert.Equal(HoldKey.Run, holdKey); + } + + [Fact] + public void HoldKey_ThresholdEdge_ExactlyAtThreshold_IsInclusive_Walk() + { + // retail: (dist - distance_to_object) <= walk_run_threshhold → WALK. + // The raw's `test ah,0x41` after `fcom` renders as an inclusive + // "not greater than" (≤) — the boundary itself walks, not runs. + var p = new MovementParameters + { + CanCharge = false, + CanRun = true, + CanWalk = true, + WalkRunThreshhold = 15f, + DistanceToObject = 0.6f, + }; + + // dist - dto = exactly 15.0 + p.GetCommand(dist: 15.6f, headingDiff: 0f, out _, out HoldKey holdKey, out _); + + Assert.Equal(HoldKey.None, holdKey); + } + + [Fact] + public void HoldKey_ThresholdEdge_JustOverThreshold_Run() + { + var p = new MovementParameters + { + CanCharge = false, + CanRun = true, + CanWalk = true, + WalkRunThreshhold = 15f, + DistanceToObject = 0.6f, + }; + + // dist - dto = 15.0 + epsilon + p.GetCommand(dist: 15.600001f, headingDiff: 0f, out _, out HoldKey holdKey, out _); + + Assert.Equal(HoldKey.Run, holdKey); + } + + [Fact] + public void HoldKey_CanChargeSet_OverridesWalkIncapableAndThreshold() + { + // CanCharge fast-path wins even when every other flag would say walk. + var p = new MovementParameters + { + CanCharge = true, + CanRun = true, + CanWalk = true, + WalkRunThreshhold = 1000f, // would otherwise force walk + DistanceToObject = 0.6f, + }; + + p.GetCommand(dist: 0.6f, headingDiff: 0f, out _, out HoldKey holdKey, out _); + + Assert.Equal(HoldKey.Run, holdKey); + } + + // ── the four capability quadrants × plain-towards distance bands ────── + + [Theory] + // (canRun, canWalk, canCharge, distBeyondThreshold) → expected HoldKey + [InlineData(true, true, false, false, HoldKey.None)] // both capable, close → walk + [InlineData(true, true, false, true, HoldKey.Run)] // both capable, far → run + [InlineData(true, false, false, false, HoldKey.Run)] // run-only, close → still run (no walk branch) + [InlineData(true, false, false, true, HoldKey.Run)] // run-only, far → run + [InlineData(false, true, false, false, HoldKey.None)] // walk-only → always walk + [InlineData(false, true, false, true, HoldKey.None)] // walk-only, far → still walk + [InlineData(false, false, false, false, HoldKey.None)] // neither capable, no charge → walk (falls through) + [InlineData(false, false, true, false, HoldKey.Run)] // can_charge alone → run regardless + public void HoldKey_FourCapabilityQuadrants_MatchRetailCascade( + bool canRun, bool canWalk, bool canCharge, bool distBeyondThreshold, HoldKey expected) + { + var p = new MovementParameters + { + CanRun = canRun, + CanWalk = canWalk, + CanCharge = canCharge, + WalkRunThreshhold = 15f, + DistanceToObject = 0.6f, + }; + + float dist = distBeyondThreshold ? 20f : 5f; // 20-0.6=19.4>15 ; 5-0.6=4.4<=15 + p.GetCommand(dist, headingDiff: 0f, out _, out HoldKey holdKey, out _); + + Assert.Equal(expected, holdKey); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersGetDesiredHeadingTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersGetDesiredHeadingTests.cs new file mode 100644 index 00000000..7931a5f3 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersGetDesiredHeadingTests.cs @@ -0,0 +1,67 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V1 — MovementParameters::get_desired_heading (0x0052aad0), +/// PINNED by direct Ghidra decompile of patchmem.gpr (see +/// docs/research/2026-07-03-r4-moveto/ghidra-confirmations.md §P2 — fetched +/// live during V0, ACE-shaped constants CONFIRMED exact): +/// +/// forward|run + towards → 0 forward|run + away → 180 +/// backward + towards → 180 backward + away → 0 +/// any other command → 0 +/// +/// +public sealed class MovementParametersGetDesiredHeadingTests +{ + [Theory] + [InlineData(false, 0f)] // RunForward, towards → 0 + [InlineData(true, 180f)] // RunForward, away → 180 + public void RunForward_FourQuadrant(bool movingAway, float expected) + { + var p = new MovementParameters(); + float h = p.GetDesiredHeading(MotionCommand.RunForward, movingAway); + Assert.Equal(expected, h); + } + + [Theory] + [InlineData(false, 0f)] // WalkForward, towards → 0 + [InlineData(true, 180f)] // WalkForward, away → 180 + public void WalkForward_FourQuadrant(bool movingAway, float expected) + { + var p = new MovementParameters(); + float h = p.GetDesiredHeading(MotionCommand.WalkForward, movingAway); + Assert.Equal(expected, h); + } + + [Theory] + [InlineData(false, 180f)] // WalkBackward, towards → 180 (face the target while backing up) + [InlineData(true, 0f)] // WalkBackward, away → 0 + public void WalkBackward_FourQuadrant(bool movingAway, float expected) + { + var p = new MovementParameters(); + float h = p.GetDesiredHeading(MotionCommand.WalkBackward, movingAway); + Assert.Equal(expected, h); + } + + [Theory] + [InlineData(false)] + [InlineData(true)] + public void UnknownCommand_DefaultsToZero(bool movingAway) + { + var p = new MovementParameters(); + float h = p.GetDesiredHeading(MotionCommand.TurnRight, movingAway); + Assert.Equal(0f, h); + } + + [Fact] + public void ZeroCommand_DefaultsToZero() + { + var p = new MovementParameters(); + Assert.Equal(0f, p.GetDesiredHeading(0u, movingAway: false)); + Assert.Equal(0f, p.GetDesiredHeading(0u, movingAway: true)); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersTests.cs new file mode 100644 index 00000000..6171f2d2 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersTests.cs @@ -0,0 +1,112 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R3-W1 — MovementParameters ctor-default pins. Oracle: +/// docs/research/2026-07-02-r3-motioninterp/W0-pins.md §A4 (bitfield 0x1EE0F +/// expansion) + r3-motioninterp-decomp.md §0 (scalar ctor, raw 300510-300534, +/// 0x00524380). Every flag asserted individually against the retail +/// 0x1EE0F default so a future bit-numbering slip fails loudly, plus the two +/// ACE-divergence traps (CanCharge, WalkRunThreshhold) get dedicated tests. +/// +public sealed class MovementParametersTests +{ + [Fact] + public void Ctor_SetFlags_MatchRetail0x1EE0FExpansion() + { + var p = new MovementParameters(); + + // Bits SET in 0x1EE0F: 0x1,0x2,0x4,0x8,0x200,0x400,0x800,0x2000,0x4000,0x8000,0x10000 + Assert.True(p.CanWalk); // 0x1 + Assert.True(p.CanRun); // 0x2 + Assert.True(p.CanSidestep); // 0x4 + Assert.True(p.CanWalkBackwards); // 0x8 + Assert.True(p.MoveTowards); // 0x200 + Assert.True(p.UseSpheres); // 0x400 + Assert.True(p.SetHoldKey); // 0x800 + Assert.True(p.ModifyRawState); // 0x2000 + Assert.True(p.ModifyInterpretedState); // 0x4000 + Assert.True(p.CancelMoveTo); // 0x8000 + Assert.True(p.StopCompletelyFlag); // 0x10000 + } + + [Fact] + public void Ctor_ClearFlags_MatchRetail0x1EE0FExpansion() + { + var p = new MovementParameters(); + + // Bits CLEAR in 0x1EE0F: 0x10,0x20,0x40,0x80,0x100,0x1000,0x20000 + Assert.False(p.CanCharge); // 0x10 — ACE-divergence trap + Assert.False(p.FailWalk); // 0x20 + Assert.False(p.UseFinalHeading); // 0x40 + Assert.False(p.Sticky); // 0x80 + Assert.False(p.MoveAway); // 0x100 + Assert.False(p.Autonomous); // 0x1000 + Assert.False(p.DisableJumpDuringLink); // 0x20000 + } + + [Fact] + public void Ctor_Bitfield_ReconstitutesExactly0x1EE0F() + { + var p = new MovementParameters(); + + uint bitfield = 0; + if (p.CanWalk) bitfield |= 0x1; + if (p.CanRun) bitfield |= 0x2; + if (p.CanSidestep) bitfield |= 0x4; + if (p.CanWalkBackwards) bitfield |= 0x8; + if (p.CanCharge) bitfield |= 0x10; + if (p.FailWalk) bitfield |= 0x20; + if (p.UseFinalHeading) bitfield |= 0x40; + if (p.Sticky) bitfield |= 0x80; + if (p.MoveAway) bitfield |= 0x100; + if (p.MoveTowards) bitfield |= 0x200; + if (p.UseSpheres) bitfield |= 0x400; + if (p.SetHoldKey) bitfield |= 0x800; + if (p.Autonomous) bitfield |= 0x1000; + if (p.ModifyRawState) bitfield |= 0x2000; + if (p.ModifyInterpretedState) bitfield |= 0x4000; + if (p.CancelMoveTo) bitfield |= 0x8000; + if (p.StopCompletelyFlag) bitfield |= 0x10000; + if (p.DisableJumpDuringLink) bitfield |= 0x20000; + + Assert.Equal(0x1EE0Fu, bitfield); + } + + [Fact] + public void Ctor_ScalarDefaults_MatchRetail() + { + var p = new MovementParameters(); + + Assert.Equal(0f, p.MinDistance); + Assert.Equal(0.6f, p.DistanceToObject); + Assert.Equal(float.MaxValue, p.FailDistance); + Assert.Equal(0f, p.DesiredHeading); + Assert.Equal(1f, p.Speed); + // ACE-divergence trap: retail is 15.0, NOT ACE's 1.0. + Assert.Equal(15f, p.WalkRunThreshhold); + Assert.Equal(0u, p.ContextId); + Assert.Equal(HoldKey.Invalid, p.HoldKeyToApply); + Assert.Equal(0u, p.ActionStamp); + } + + [Fact] + public void Ctor_CanCharge_DefaultsFalse_NotAceTrue() + { + // Dedicated regression test for the single highest-risk ACE trap: + // ACE's MovementParameters.cs:58 sets CanCharge = true at construction. + // Retail's 0x1EE0F has bit 0x10 CLEAR. + var p = new MovementParameters(); + Assert.False(p.CanCharge); + } + + [Fact] + public void Ctor_WalkRunThreshhold_Is15_NotAce1() + { + var p = new MovementParameters(); + Assert.Equal(15f, p.WalkRunThreshhold); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersTowardsAndAwayTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersTowardsAndAwayTests.cs new file mode 100644 index 00000000..25d942b4 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MovementParametersTowardsAndAwayTests.cs @@ -0,0 +1,84 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V1 — MovementParameters::towards_and_away (0x0052a9a0, +/// raw 307917-307942), verbatim per r4-moveto-decomp.md §5d. Three bands: +/// beyond distance_to_object → WalkForward towards; inside the +/// min_distance epsilon band → WalkBackwards away (no turn, unlike +/// the pure-away branch in §5c which uses WalkForward+turn-around); strictly +/// between → idle (cmd 0). +/// +public sealed class MovementParametersTowardsAndAwayTests +{ + [Fact] + public void DistGreaterThanDto_WalkForward_Towards() + { + var p = new MovementParameters { DistanceToObject = 0.6f, MinDistance = 0.2f }; + + p.TowardsAndAway(dist: 5f, out uint cmd, out bool movingAway); + + Assert.Equal(MotionCommand.WalkForward, cmd); + Assert.False(movingAway); + } + + [Fact] + public void DistExactlyAtDto_NotGreater_FallsToMinBandCheck() + { + var p = new MovementParameters { DistanceToObject = 0.6f, MinDistance = 0.2f }; + + // dist == dto is NOT > dto, so falls through to the min-band test; + // 0.6 - 0.2 = 0.4, not < epsilon → idle. + p.TowardsAndAway(dist: 0.6f, out uint cmd, out _); + + Assert.Equal(0u, cmd); + } + + [Fact] + public void InsideMinDistanceEpsilonBand_WalkBackwards_Away() + { + var p = new MovementParameters { DistanceToObject = 0.6f, MinDistance = 0.2f }; + + // dist - min_distance < 0.000199999995f + p.TowardsAndAway(dist: 0.2f, out uint cmd, out bool movingAway); + + Assert.Equal(MotionCommand.WalkBackward, cmd); + Assert.True(movingAway); + } + + [Fact] + public void InsideMinDistanceEpsilonBand_JustBelowEpsilon_StillWalkBackwards() + { + var p = new MovementParameters { DistanceToObject = 0.6f, MinDistance = 0.2f }; + + p.TowardsAndAway(dist: 0.2f + 0.0001f, out uint cmd, out bool movingAway); + + Assert.Equal(MotionCommand.WalkBackward, cmd); + Assert.True(movingAway); + } + + [Fact] + public void StrictlyBetweenMinAndDto_Idle() + { + var p = new MovementParameters { DistanceToObject = 0.6f, MinDistance = 0.2f }; + + p.TowardsAndAway(dist: 0.4f, out uint cmd, out bool movingAway); + + Assert.Equal(0u, cmd); + Assert.False(movingAway); + } + + [Fact] + public void JustOutsideMinBand_NotYetIdle_Idle() + { + var p = new MovementParameters { DistanceToObject = 0.6f, MinDistance = 0.2f }; + + // dist - min = 0.0003, just over epsilon (0.0002) → NOT in the min band → idle + p.TowardsAndAway(dist: 0.2003f, out uint cmd, out _); + + Assert.Equal(0u, cmd); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MovementStructWideningTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MovementStructWideningTests.cs new file mode 100644 index 00000000..bc9e9b87 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MovementStructWideningTests.cs @@ -0,0 +1,108 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V1 — widening per r4-moveto-decomp.md §0 +/// (acclient.h:38069, struct #4067): +/// +/// struct __cppobj MovementStruct +/// { +/// MovementTypes::Type type; +/// unsigned int motion; // types 1-4 only +/// unsigned int object_id; // types 6, 8 +/// unsigned int top_level_id; // types 6, 8 +/// Position pos; // type 7 +/// float radius; // type 6 +/// float height; // type 6 +/// MovementParameters *params; // types 1-4, 6-9 +/// }; +/// +/// Additive-only (M11, mechanical) — no consumer wires these fields yet; +/// this test just pins the shape exists and round-trips. +/// +public sealed class MovementStructWideningTests +{ + [Fact] + public void ObjectId_TopLevelId_RoundTrip() + { + var mvs = new MovementStruct + { + Type = MovementType.MoveToObject, + ObjectId = 0x50001234u, + TopLevelId = 0x50005678u, + }; + + Assert.Equal(0x50001234u, mvs.ObjectId); + Assert.Equal(0x50005678u, mvs.TopLevelId); + } + + [Fact] + public void Pos_RoundTrips_WorldPositionAndCell() + { + var pos = new Position(0x12340001u, new Vector3(10f, 20f, 3f), Quaternion.Identity); + var mvs = new MovementStruct + { + Type = MovementType.MoveToPosition, + Pos = pos, + }; + + Assert.Equal(pos, mvs.Pos); + Assert.Equal(0x12340001u, mvs.Pos.ObjCellId); + Assert.Equal(new Vector3(10f, 20f, 3f), mvs.Pos.Frame.Origin); + } + + [Fact] + public void Radius_Height_RoundTrip() + { + var mvs = new MovementStruct + { + Type = MovementType.MoveToObject, + Radius = 0.75f, + Height = 1.8f, + }; + + Assert.Equal(0.75f, mvs.Radius); + Assert.Equal(1.8f, mvs.Height); + } + + [Fact] + public void Params_HoldsMovementParametersReference() + { + var p = new MovementParameters { CanCharge = true }; + var mvs = new MovementStruct + { + Type = MovementType.TurnToHeading, + Params = p, + }; + + Assert.Same(p, mvs.Params); + } + + [Fact] + public void ExistingFields_Type_Motion_StillPresent_NoRegression() + { + // The pre-R4 fields (Type/Motion/Speed/Autonomous/ModifyInterpretedState/ + // ModifyRawState) must survive the widening untouched — R4 is + // additive-only per the plan (M11, "no consumer changes"). + var mvs = new MovementStruct + { + Type = MovementType.RawCommand, + Motion = 0x45000005u, + Speed = 1.5f, + Autonomous = true, + ModifyInterpretedState = true, + ModifyRawState = false, + }; + + Assert.Equal(MovementType.RawCommand, mvs.Type); + Assert.Equal(0x45000005u, mvs.Motion); + Assert.Equal(1.5f, mvs.Speed); + Assert.True(mvs.Autonomous); + Assert.True(mvs.ModifyInterpretedState); + Assert.False(mvs.ModifyRawState); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/MovementTypeWideningTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/MovementTypeWideningTests.cs new file mode 100644 index 00000000..ce6f8f05 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/MovementTypeWideningTests.cs @@ -0,0 +1,33 @@ +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R4-V1 — widening to retail's full +/// MovementTypes::Type enum (acclient.h:2856, enum #229): +/// +/// Invalid=0, RawCommand=1, InterpretedCommand=2, StopRawCommand=3, +/// StopInterpretedCommand=4, StopCompletely=5, MoveToObject=6, +/// MoveToPosition=7, TurnToObject=8, TurnToHeading=9 +/// +/// Mechanical, additive-only pin (M11) — the 1-5 values must not shift +/// (they're already load-bearing in MotionInterpreter.PerformMovement's +/// switch). +/// +public sealed class MovementTypeWideningTests +{ + [Theory] + [InlineData(MovementType.Invalid, 0)] + [InlineData(MovementType.RawCommand, 1)] + [InlineData(MovementType.InterpretedCommand, 2)] + [InlineData(MovementType.StopRawCommand, 3)] + [InlineData(MovementType.StopInterpretedCommand, 4)] + [InlineData(MovementType.StopCompletely, 5)] + [InlineData(MovementType.MoveToObject, 6)] + [InlineData(MovementType.MoveToPosition, 7)] + [InlineData(MovementType.TurnToObject, 8)] + [InlineData(MovementType.TurnToHeading, 9)] + public void EnumValues_MatchRetailMovementTypesTypeTable(MovementType value, int expected) + => Assert.Equal(expected, (int)value); +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/PositionManagerFacadeTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/PositionManagerFacadeTests.cs new file mode 100644 index 00000000..6e2bdc62 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/PositionManagerFacadeTests.cs @@ -0,0 +1,114 @@ +using System.Collections.Generic; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R5 conformance — facade (retail +/// 0x00555160-0x005553d0). Lazy sub-manager creation + fan-out. (Test class is +/// suffixed "Facade" to read distinctly from the renamed +/// RemoteMotionCombiner combiner tests.) +/// +public sealed class PositionManagerFacadeTests +{ + private static (R5Host self, R5Host target, PositionManager pm) Setup() + { + var world = new Dictionary(); + var self = new R5Host(10u, world); + var target = new R5Host(20u, world); + return (self, target, new PositionManager(self)); + } + + [Fact] + public void UnStick_BeforeAnyStick_IsNoOp() + { + var (_, _, pm) = Setup(); + pm.UnStick(); // no sticky manager yet — must not throw + Assert.Null(pm.Sticky); + Assert.Equal(0u, pm.GetStickyObjectId()); + } + + [Fact] + public void StickTo_LazilyCreatesSticky_AndForwards() + { + var (self, target, pm) = Setup(); + pm.StickTo(target.Id, radius: 0.5f, height: 1.0f); + + Assert.NotNull(pm.Sticky); + Assert.Equal(target.Id, pm.GetStickyObjectId()); + } + + [Fact] + public void IsFullyConstrained_FalseWhenNoConstraintManager() + { + var (_, _, pm) = Setup(); + Assert.False(pm.IsFullyConstrained()); + Assert.Null(pm.Constraint); + } + + [Fact] + public void ConstrainTo_LazilyCreatesConstraint() + { + var (self, _, pm) = Setup(); + self.SetOrigin(Vector3.Zero); + pm.ConstrainTo(new Position(1u, new Vector3(5f, 0f, 0f), Quaternion.Identity), 2f, 10f); + Assert.NotNull(pm.Constraint); + Assert.True(pm.Constraint!.IsConstrained); + } + + [Fact] + public void HandleUpdateTarget_ForwardsToSticky() + { + var (self, target, pm) = Setup(); + pm.StickTo(target.Id, 0.5f, 1.0f); + + var tp = new Position(1u, new Vector3(2f, 0f, 0f), Quaternion.Identity); + pm.HandleUpdateTarget(new TargetInfo(target.Id, TargetStatus.Ok, tp, tp)); + + Assert.True(pm.Sticky!.Initialized); + } + + [Fact] + public void AdjustOffset_ChainsStickyThenConstraint() + { + var (self, target, pm) = Setup(); + self.Radius = 0.5f; + self.MinterpMaxSpeed = 1.0f; + self.InContact = true; + + // Sticky toward +X: produces an offset the constraint then tapers. + pm.StickTo(target.Id, 0.5f, 1.0f); + target.SetOrigin(new Vector3(5f, 0f, 0f)); + var tp = new Position(1u, new Vector3(5f, 0f, 0f), Quaternion.Identity); + pm.HandleUpdateTarget(new TargetInfo(target.Id, TargetStatus.Ok, tp, tp)); + + // Arm a constraint whose band tapers by 0.5. + self.SetOrigin(Vector3.Zero); + pm.ConstrainTo(new Position(1u, new Vector3(6f, 0f, 0f), Quaternion.Identity), + startDistance: 2f, maxDistance: 10f); // offset 6 → taper (10-6)/(10-2)=0.5 + + var frame = new MotionDeltaFrame(); + pm.AdjustOffset(frame, quantum: 0.1); + + // Sticky writes +0.5 X; constraint tapers by 0.5 → 0.25. + Assert.Equal(0.25f, frame.Origin.X, 3); + } + + [Fact] + public void UseTime_DrivesStickyTimeout() + { + var (self, target, pm) = Setup(); + self.CurTime = 100.0; + pm.StickTo(target.Id, 0.5f, 1.0f); // deadline 101 + + // Strictly past the deadline (retail 0x00555626 keeps the stick AT + // the deadline; teardown is `>` — ACE too). + self.CurTime = 101.001; + pm.UseTime(); + + Assert.Equal(0u, pm.GetStickyObjectId()); // unstuck + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/R5ManagerHarness.cs b/tests/AcDream.Core.Tests/Physics/Motion/R5ManagerHarness.cs new file mode 100644 index 00000000..55701c73 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/R5ManagerHarness.cs @@ -0,0 +1,98 @@ +using System.Collections.Generic; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R5 conformance harness — a scriptable fake +/// backed by a shared so resolves +/// OTHER hosts (the cross-entity seam the voyeur round-trip needs). Each host +/// lazily owns a and a +/// (the two R5 managers under test), and records every +/// the managers fan out so tests can assert on +/// delivery. +/// +/// Position/velocity/radius/contact/max-speed and both clocks are mutable +/// fields tests drive directly (retail's CPhysicsObj accessors). The +/// set_target/clear_target/add_voyeur/remove_voyeur/ +/// receive_target_update seams forward to the owned +/// exactly as retail's CPhysicsObj does. +/// +internal sealed class R5Host : IPhysicsObjHost +{ + public readonly Dictionary World; + + public R5Host(uint id, Dictionary world) + { + Id = id; + World = world; + World[id] = this; + } + + // ── scriptable CPhysicsObj state ─────────────────────────────────────── + public uint Id { get; } + public Position Position { get; set; } = new(1u, Vector3.Zero, Quaternion.Identity); + public Vector3 Velocity { get; set; } = Vector3.Zero; + public float Radius { get; set; } = 0.5f; + public bool InContact { get; set; } = true; + public float? MinterpMaxSpeed { get; set; } = 1.0f; + public double CurTime { get; set; } + public double PhysicsTimerTime { get; set; } + + /// Set to false to simulate a target that isn't currently + /// resolvable (out of streaming view) — returns + /// null for it even while it's in . + public bool Resolvable { get; set; } = true; + + // ── owned R5 managers ────────────────────────────────────────────────── + private TargetManager? _targetManager; + public TargetManager TargetManager => _targetManager ??= new TargetManager(this); + public TargetManager? TargetManagerOrNull => _targetManager; + + private PositionManager? _positionManager; + public PositionManager PositionManager => _positionManager ??= new PositionManager(this); + + // ── recorded fan-outs ────────────────────────────────────────────────── + public readonly List HandleUpdateTargetCalls = new(); + public int InterruptCurrentMovementCalls; + + // ── IPhysicsObjHost ──────────────────────────────────────────────────── + public IPhysicsObjHost? GetObjectA(uint id) + => World.TryGetValue(id, out var h) && h.Resolvable ? h : null; + + public void HandleUpdateTarget(TargetInfo info) + { + HandleUpdateTargetCalls.Add(info); + // Retail CPhysicsObj::HandleUpdateTarget also fans to the position + // manager's sticky sub-manager (context 0). Mirror that so sticky tests + // that rely on the full CPhysicsObj fan-out see the callback. + if (info.ContextId == 0) + _positionManager?.HandleUpdateTarget(info); + } + + public void InterruptCurrentMovement() => InterruptCurrentMovementCalls++; + + public void SetTarget(uint contextId, uint objectId, float radius, double quantum) + => TargetManager.SetTarget(contextId, objectId, radius, quantum); + + public void ClearTarget() => _targetManager?.ClearTarget(); + + public void ReceiveTargetUpdate(TargetInfo info) => _targetManager?.ReceiveUpdate(info); + + public void AddVoyeur(uint watcherId, float radius, double quantum) + => TargetManager.AddVoyeur(watcherId, radius, quantum); + + public void RemoveVoyeur(uint watcherId) => _targetManager?.RemoveVoyeur(watcherId); + + // ── test helpers ─────────────────────────────────────────────────────── + public void SetOrigin(Vector3 origin) + => Position = new Position(Position.ObjCellId, origin, Position.Frame.Orientation); + + public void AdvanceClocks(double seconds) + { + CurTime += seconds; + PhysicsTimerTime += seconds; + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/RawMotionStateActionFifoTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/RawMotionStateActionFifoTests.cs new file mode 100644 index 00000000..cd27ee7c --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/RawMotionStateActionFifoTests.cs @@ -0,0 +1,244 @@ +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R3-W1 — action FIFO discipline + ApplyMotion/RemoveMotion +/// field effects on (closes J2). Oracle: +/// docs/research/named-retail/acclient_2013_pseudo_c.txt — verbatim bodies +/// quoted in RawMotionState.cs doc comments: +/// RawMotionState::AddAction (0x0051e840), RemoveAction +/// (0x0051e8a0), ApplyMotion (0x0051eb60), RemoveMotion +/// (0x0051e6e0). +/// +public sealed class RawMotionStateActionFifoTests +{ + // ── AddAction / RemoveAction / GetNumActions FIFO discipline ────────── + + [Fact] + public void AddAction_AppendsInOrder() + { + var raw = new RawMotionState(); + raw.AddAction(0x1000004Bu, 1.0f, 1, autonomous: false); + raw.AddAction(0x10000050u, 1.5f, 2, autonomous: true); + + Assert.Equal(2, raw.Actions.Count); + Assert.Equal((ushort)0x004Bu, raw.Actions[0].Command); // widened to ushort on wire, verified below + Assert.Equal((ushort)0x0050u, raw.Actions[1].Command); + } + + [Fact] + public void RemoveAction_PopsHeadFirst_FifoOrder() + { + var raw = new RawMotionState(); + raw.AddAction(0x1000004Bu, 1.0f, 1, autonomous: false); + raw.AddAction(0x10000050u, 1.5f, 2, autonomous: true); + + uint first = raw.RemoveAction(); + uint second = raw.RemoveAction(); + + Assert.Equal(0x004Bu, first); // head popped first (FIFO) + Assert.Equal(0x0050u, second); + Assert.Empty(raw.Actions); + } + + [Fact] + public void RemoveAction_Empty_ReturnsZero() + { + var raw = new RawMotionState(); + Assert.Equal(0u, raw.RemoveAction()); + } + + [Fact] + public void AddAction_StoresSpeedStampAutonomous() + { + var raw = new RawMotionState(); + raw.AddAction(0x1000004Bu, speed: 2.5f, actionStamp: 0x7FFFu, autonomous: true); + + var a = raw.Actions[0]; + Assert.Equal(2.5f, a.Speed); + Assert.Equal((ushort)0x7FFFu, a.Stamp); + Assert.True(a.Autonomous); + } + + // ── ApplyMotion field effects (0x0051eb60) ───────────────────────────── + + [Fact] + public void ApplyMotion_TurnRight_SetsTurnCommandAndSpeed_HonorsSetHoldKeyBit() + { + var raw = new RawMotionState(); + var p = new MovementParameters { Speed = 1.5f, SetHoldKey = true }; + + raw.ApplyMotion(0x6500000du, p); // TurnRight + + Assert.Equal(0x6500000du, raw.TurnCommand); + Assert.Equal(1.5f, raw.TurnSpeed); + Assert.Equal(HoldKey.Invalid, raw.TurnHoldKey); // SetHoldKey bit set -> Invalid + } + + [Fact] + public void ApplyMotion_TurnRight_SetHoldKeyClear_UsesHoldKeyToApply() + { + var raw = new RawMotionState(); + var p = new MovementParameters { Speed = 1.5f, SetHoldKey = false, HoldKeyToApply = HoldKey.Run }; + + raw.ApplyMotion(0x6500000du, p); + + Assert.Equal(HoldKey.Run, raw.TurnHoldKey); + } + + [Fact] + public void ApplyMotion_SideStepRight_SetsSidestepCommandAndSpeed() + { + var raw = new RawMotionState(); + var p = new MovementParameters { Speed = 1.248f, SetHoldKey = true }; + + raw.ApplyMotion(0x6500000fu, p); // SideStepRight + + Assert.Equal(0x6500000fu, raw.SidestepCommand); + Assert.Equal(1.248f, raw.SidestepSpeed); + Assert.Equal(HoldKey.Invalid, raw.SidestepHoldKey); + } + + [Fact] + public void ApplyMotion_ForwardClassMotion_SetsForwardCommandAndSpeed() + { + // WalkForward = 0x45000005 has bit 0x40000000 set (forward-class) + // and is NOT 0x44000007 (RunForward) -> the write branch fires. + var raw = new RawMotionState(); + var p = new MovementParameters { Speed = 1.0f, SetHoldKey = true }; + + raw.ApplyMotion(0x45000005u, p); + + Assert.Equal(0x45000005u, raw.ForwardCommand); + Assert.Equal(1.0f, raw.ForwardSpeed); + Assert.Equal(HoldKey.Invalid, raw.ForwardHoldKey); + } + + [Fact] + public void ApplyMotion_RunForwardExactId_ForwardClassButExcluded_NoWrite() + { + // Verbatim retail quirk (0x0051eb60): arg2 == 0x44000007 (RunForward) + // with the forward-class bit (0x40000000) set falls through BOTH + // inner branches — no field write occurs. Port verbatim, not fixed. + var raw = new RawMotionState(); + var before = raw.ForwardCommand; + var p = new MovementParameters { Speed = 3.0f }; + + raw.ApplyMotion(0x44000007u, p); + + Assert.Equal(before, raw.ForwardCommand); // untouched + Assert.Equal(1.0f, raw.ForwardSpeed); // untouched (still ctor default) + } + + [Fact] + public void ApplyMotion_StyleClassMotion_SetsCurrentStyleAndResetsForwardToReady() + { + // High bit set (>= 0x80000000) and current_style differs -> style branch. + var raw = new RawMotionState { ForwardCommand = 0x45000005u }; + var p = new MovementParameters(); + + raw.ApplyMotion(0x80000042u, p); + + Assert.Equal(0x41000003u, raw.ForwardCommand); // reset to Ready + Assert.Equal(0x80000042u, raw.CurrentStyle); + } + + [Fact] + public void ApplyMotion_StyleClassMotion_SameAsCurrentStyle_NoOp() + { + var raw = new RawMotionState { CurrentStyle = 0x80000042u, ForwardCommand = 0x45000005u }; + var p = new MovementParameters(); + + raw.ApplyMotion(0x80000042u, p); + + // current_style already equals arg2 -> the style branch's condition + // (current_style != arg2) is false, so forward_command is untouched. + Assert.Equal(0x45000005u, raw.ForwardCommand); + Assert.Equal(0x80000042u, raw.CurrentStyle); + } + + [Fact] + public void ApplyMotion_ActionClassMotion_AddsAction() + { + // Outside turn/sidestep range, bit 0x40000000 clear, arg2 >= 0 + // (not style-class), bit 0x10000000 set -> AddAction. + var raw = new RawMotionState(); + var p = new MovementParameters { Speed = 1.0f, ActionStamp = 42u, Autonomous = true }; + + raw.ApplyMotion(0x1000004Bu, p); // Jumpup action id + + Assert.Single(raw.Actions); + var a = raw.Actions[0]; + Assert.Equal((ushort)0x004Bu, a.Command); + Assert.Equal(1.0f, a.Speed); + Assert.Equal((ushort)42u, a.Stamp); + Assert.True(a.Autonomous); + } + + // ── RemoveMotion field effects (0x0051e6e0) ──────────────────────────── + + [Fact] + public void RemoveMotion_TurnRange_ClearsTurnCommand() + { + var raw = new RawMotionState { TurnCommand = 0x6500000du }; + raw.RemoveMotion(0x6500000du); + Assert.Equal(0u, raw.TurnCommand); + } + + [Fact] + public void RemoveMotion_TurnLeftRange_ClearsTurnCommand() + { + var raw = new RawMotionState { TurnCommand = 0x6500000eu }; + raw.RemoveMotion(0x6500000eu); + Assert.Equal(0u, raw.TurnCommand); + } + + [Fact] + public void RemoveMotion_SidestepRange_ClearsSidestepCommand() + { + var raw = new RawMotionState { SidestepCommand = 0x6500000fu }; + raw.RemoveMotion(0x6500000fu); + Assert.Equal(0u, raw.SidestepCommand); + } + + [Fact] + public void RemoveMotion_ForwardClassMotion_MatchingCommand_ResetsToReady() + { + var raw = new RawMotionState { ForwardCommand = 0x45000005u, ForwardSpeed = 3.0f }; + raw.RemoveMotion(0x45000005u); + + Assert.Equal(0x41000003u, raw.ForwardCommand); + Assert.Equal(1f, raw.ForwardSpeed); + } + + [Fact] + public void RemoveMotion_ForwardClassMotion_NonMatchingCommand_NoOp() + { + var raw = new RawMotionState { ForwardCommand = 0x45000005u, ForwardSpeed = 3.0f }; + raw.RemoveMotion(0x44000007u); // different forward-class id + + Assert.Equal(0x45000005u, raw.ForwardCommand); // untouched + Assert.Equal(3.0f, raw.ForwardSpeed); + } + + [Fact] + public void RemoveMotion_StyleClassMotion_MatchingCurrentStyle_ResetsToNonCombat() + { + var raw = new RawMotionState { CurrentStyle = 0x80000042u }; + raw.RemoveMotion(0x80000042u); + + Assert.Equal(0x8000003du, raw.CurrentStyle); // reset to NonCombat + } + + [Fact] + public void RemoveMotion_StyleClassMotion_NonMatchingCurrentStyle_NoOp() + { + var raw = new RawMotionState { CurrentStyle = 0x80000042u }; + raw.RemoveMotion(0x80000099u); // different style id + + Assert.Equal(0x80000042u, raw.CurrentStyle); // untouched + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/RemoteChaseDrainBisectTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/RemoteChaseDrainBisectTests.cs new file mode 100644 index 00000000..a52ef8f9 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/RemoteChaseDrainBisectTests.cs @@ -0,0 +1,105 @@ +using System; +using System.Linq; +using System.Text; +using AcDream.Core.Physics; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.Core.Tests.Physics.Motion; + +// ───────────────────────────────────────────────────────────────────────────── +// #170 drain-chain conformance: a stance-change UM's completion must flow +// CSequence link-anim completion → AnimDone hook → ConsumePendingHooks → +// MotionTableManager.AnimationDone countdown → MotionDoneTarget → +// CMotionInterp.MotionDone pop, fully emptying BOTH queues (retail cdb +// invariant: add_to_queue == MotionDone). +// +// History: the first harness run wedged here EXACTLY like the live #170 +// signature ([drainq] q=[0x8000003C ...] stuck) — because the harness body +// was unseeded (InWorld=false), so the TS-40 detached-object guard stripped +// every dispatched transition link while the manager kept counting its ticks. +// With the live-faithful RemoteMotion construction the chain drains in ~1 s. +// Kept as the regression pin for that whole chain (and as the canonical +// demonstration of what a link-strip-without-tick-zeroing wedge looks like). +// ───────────────────────────────────────────────────────────────────────────── +public sealed class RemoteChaseDrainBisectTests +{ + private readonly ITestOutputHelper _out; + public RemoteChaseDrainBisectTests(ITestOutputHelper output) => _out = output; + + [Fact] + public void StanceChange_DrainChain_TickByTick() + { + var h = new RemoteChaseHarness(); + + // settle spawn + for (int i = 0; i < 30; i++) h.Tick(); + DumpState(h, "pre-stance"); + + h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready); + DumpState(h, "post-UM (t=0)"); + + for (int i = 1; i <= 90; i++) + { + TickWithHookTrace(h, i); + if (i % 6 == 0 || i <= 3) + DumpState(h, $"tick {i} (t={i / 60f:F2})"); + if (!h.Interp.MotionsPending() && h.Seq.Manager.PendingAnimations.Any() == false) + { + DumpState(h, $"DRAINED at tick {i}"); + return; // chain healthy + } + } + + DumpState(h, "END — still wedged"); + Assert.Fail("drain chain wedged after stance UM — see output for where"); + } + + private void TickWithHookTrace(RemoteChaseHarness h, int i) + { + // Replicate RemoteChaseHarness.Tick but with hook visibility: we call + // the same phases, intercepting the hook list. + h.Now += RemoteChaseHarness.Dt; + h.Mgr.UseTime(); + if (h.Body.OnWalkable) + h.Body.set_local_velocity(h.Interp.get_state_velocity(), false); + + h.Seq.Advance(RemoteChaseHarness.Dt); + var hooks = h.Seq.ConsumePendingHooks(); + if (hooks.Count > 0) + { + var sb = new StringBuilder(); + sb.Append(FormattableString.Invariant($"tick {i}: hooks=[")); + for (int k = 0; k < hooks.Count; k++) + { + if (k > 0) sb.Append(", "); + sb.Append(hooks[k]?.GetType().Name ?? "null"); + } + sb.Append(']'); + _out.WriteLine(sb.ToString()); + } + for (int k = 0; k < hooks.Count; k++) + { + if (hooks[k] is DatReaderWriter.Types.AnimationDoneHook) + h.Seq.Manager.AnimationDone(success: true); + } + h.Seq.Manager.UseTime(); + } + + private void DumpState(RemoteChaseHarness h, string tag) + { + var mgrQ = string.Join(" ", h.Seq.Manager.PendingAnimations + .Select(p => FormattableString.Invariant($"(0x{p.Motion:X8},t={p.NumAnims})"))); + var core = h.Seq.Core; + var seqList = new StringBuilder(); + for (var n = core.AnimList.First; n is not null; n = n.Next) + { + if (seqList.Length > 0) seqList.Append(','); + seqList.Append(FormattableString.Invariant($"fr={n.Value.Framerate:F0}")); + if (ReferenceEquals(n, core.FirstCyclicNode)) seqList.Append('*'); + if (ReferenceEquals(n, core.CurrAnimNode)) seqList.Append('^'); + } + _out.WriteLine(FormattableString.Invariant( + $"[{tag}] interpPending={h.Interp.MotionsPending()} mgrQ=[{mgrQ}] counter={h.Seq.Manager.AnimationCounter} seq=[{seqList}] frame={core.FrameNumber:F1} substate=0x{h.Seq.Manager.State.Substate:X8} style=0x{h.Seq.Manager.State.Style:X8}")); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/RemoteChaseEndToEndHarnessTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/RemoteChaseEndToEndHarnessTests.cs new file mode 100644 index 00000000..a1480435 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/RemoteChaseEndToEndHarnessTests.cs @@ -0,0 +1,960 @@ +using System; +using System.Collections.Generic; +using System.Numerics; +using System.Text; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Types; +using Xunit; +using Xunit.Abstractions; + +using DRWMotionCommand = DatReaderWriter.Enums.MotionCommand; +using CorePosition = AcDream.Core.Physics.Position; + +namespace AcDream.Core.Tests.Physics.Motion; + +// ───────────────────────────────────────────────────────────────────────────── +// #170 "sustain the run" — full-stack remote-chase harness. +// +// The R4-V2 MoveToManagerHarness scripts Heading directly (setHeading writes +// the scalar) and drains pending_motions synthetically, so the two legs where +// the live #170 residual actually lives have ZERO coverage: +// +// 1. the PHYSICAL turn: _DoMotion(TurnRight) → MotionTableDispatchSink. +// TurnApplied → ObservedOmega → per-tick quaternion integration → +// MoveToMath.GetHeading → HandleTurnToHeading's HeadingGreater test; +// 2. the REAL drain: MotionTableManager pending_animations countdown fed by +// CSequence AnimDone hooks (link-anim completions), popping +// CMotionInterp.pending_motions via the MotionDoneTarget seam. +// +// This harness wires a real MotionInterpreter + AnimationSequencer + +// MotionTableDispatchSink + MoveToManager EXACTLY like GameWindow's +// EnsureRemoteMotionBindings (GameWindow.cs:4251) and ticks them in +// GameWindow.TickAnimations' per-entity order for the grounded branch=MOVETO +// path (GameWindow.cs:9697 HandleTargetting → 9994 TickRemoteMoveTo → +// 10024 get_state_velocity refresh → 10050 manual omega integration → +// 10247 Sequencer.Advance → 10306 AnimationDone per AnimDoneHook → +// 10309 Manager.UseTime). Wire events (aggro stance UM, mt-6 arms, attack +// UMs) replay the exact live sequence captured in launch-drainq.log +// (2026-07-04, guid 0x80000BE5, Mite Scamp chasing the fleeing player). +// +// Retail acceptance bar (live cdb, 2026-07-04 session): BeginMoveForward ≈ +// MoveToObject arms (21/22), pending_motions add == MotionDone exactly, the +// chase turn completes within a couple of seconds and the run SUSTAINS +// between attack swings. +// ───────────────────────────────────────────────────────────────────────────── + +internal sealed class ChaseLoader : IAnimationLoader +{ + private readonly Dictionary _anims = new(); + public void Register(uint id, Animation anim) => _anims[id] = anim; + public Animation? LoadAnimation(uint id) => + _anims.TryGetValue(id, out var a) ? a : null; +} + +/// +/// The full-stack per-entity pipeline replica. Field-for-field mirror of the +/// GameWindow wiring for one grounded remote NPC (branch=MOVETO), plus a +/// scripted stand-in for the TargetManager voyeur delivery (SetTarget → +/// synchronous first delivery + one delivery per quantum thereafter — the +/// live cadence observed in launch-drainq.log: HandleUpdateTarget directly +/// after the arm, then sparse). +/// +internal sealed class RemoteChaseHarness +{ + // Styles / substates (full command words, as the wire produces them). + public const uint NonCombat = 0x8000003Du; + public const uint Combat = 0x8000003Cu; // the aggro stance in the live capture + public const uint Ready = 0x41000003u; + public const uint Walk = 0x45000005u; + public const uint Run = 0x44000007u; + public const uint TurnRight = 0x6500000Du; + public const uint AttackAction = 0x10000063u; // one of the live scamp swings + + public const uint CreatureGuid = 0x80000BE5u; + public const uint PlayerGuid = 0x5000000Au; + + public const float Dt = 1f / 60f; + + // R5-V3 (#171): setup cylsphere radii for the sticky/UseSpheres scenarios + // (GameWindow threads the real values via GetSetupCylinder; these are + // creature-typical stand-ins). + public const float OwnRadius = 0.3f; + public const float StickyTargetRadius = 0.5f; + + // Field-for-field mirror of GameWindow's RemoteMotion construction + // (GameWindow.cs:592-618): Contact+OnWalkable+Active, InWorld=true (the + // R4-V5 door fix — without it the interp's detached-object guard strips + // every dispatched transition link), and the R4-V5 #160 RemoteWeenie + // (null weenie degrades run-rate to 1.0). + public readonly PhysicsBody Body = new() + { + State = PhysicsStateFlags.ReportCollisions, + TransientState = TransientStateFlags.Contact + | TransientStateFlags.OnWalkable + | TransientStateFlags.Active, + InWorld = true, + }; + public readonly MotionInterpreter Interp; + public readonly AnimationSequencer Seq; + public readonly MotionTableDispatchSink Sink; + + /// R5-V5: GameWindow's RemoteMotion.Movement twin — the ONE + /// per-entity MovementManager facade owning Interp + the MoveToManager + /// (retail CPhysicsObj::movement_manager). + public readonly MovementManager Movement; + + /// The moveto child view (RemoteMotion.MoveTo twin) — non-null + /// after the ctor's MakeMoveToManager, kept so test bodies read + /// unchanged. + public MoveToManager Mgr => Movement.MoveTo!; + + /// R5-V3 (#171): the creature's PositionManager facade — the + /// EntityPhysicsHost-owned twin (GameWindow binds MoveToManager.StickTo/ + /// Unstick + MotionInterpreter.UnstickFromObject to it and drives + /// AdjustOffset/UseTime per tick). + public readonly PositionManager Pm; + private readonly CreatureHost _creatureHost; + private readonly TargetHost _playerHost; + + /// GameWindow's RemoteMotion.ObservedOmega twin. + public Vector3 ObservedOmega; + + /// Scripted player (chase target) world position. + public Vector3 PlayerPos; + public Vector3 PlayerVelocity; + + // Scripted targeting stand-in (GameWindow: EntityPhysicsHost/TargetManager). + private bool _targetArmed; + private double _lastDeliveryTime = double.NegativeInfinity; + private double _quantum = 0.5; + public double Now; + + // Counters (the live-probe equivalents). + public int BeginTurnBlocked; + public int BeginTurnUnblocked; + public int RunInstalls; // substate transitions INTO RunForward/Walk fwd + public int TicksInRun; + public int TicksInWalkFwd; + public int TotalTicks; + public int MaxRunStreak; + private int _runStreak; + private uint _prevSubstate; + + public readonly List Trace = new(); + private readonly ITestOutputHelper? _log; + + public RemoteChaseHarness(ITestOutputHelper? log = null) + { + _log = log; + var (setup, mtable, loader) = BuildFixture(); + Seq = new AnimationSequencer(setup, mtable, loader); + + // ── GameWindow spawn path (OnLiveEntitySpawnedLocked ~3781) ── + Seq.InitializeState(); + Seq.SetCycle(NonCombat, Ready); + + Body.Orientation = MoveToMath.SetHeading(Quaternion.Identity, 0f); // face North + Interp = new MotionInterpreter(Body) + { + WeenieObj = new RemoteWeenie(), + }; + + // ── EnsureRemoteMotionBindings (GameWindow.cs:4251) verbatim ── + Sink = new MotionTableDispatchSink(Seq) + { + TurnApplied = (turnMotion, turnSpeed) => + { + float signed = (turnMotion & 0xFFu) == 0x0E + ? -MathF.Abs(turnSpeed) + : turnSpeed; + ObservedOmega = new Vector3(0f, 0f, -(MathF.PI / 2f) * signed); + }, + TurnStopped = () => ObservedOmega = Vector3.Zero, + }; + Interp.DefaultSink = Sink; + // #174: production binds the seam to Manager.HandleEnterWorld + // (strip + full queue drain, retail 0x0050fe20 → 0x0051bdd0) — + // the bare sequence strip orphaned pending manager nodes. + Interp.RemoveLinkAnimations = () => Seq.Manager.HandleEnterWorld(); + Interp.InitializeMotionTables = () => Seq.Manager.InitializeState(); + Interp.CheckForCompletedMotions = Seq.Manager.CheckForCompletedMotions; + + // ── R5-V5: the MovementManager facade owns Interp + the moveto — + // GameWindow's RemoteMotion ctor + EnsureRemoteMotionBindings + // factory shape verbatim (sticky binds inside the factory; + // MakeMoveToManager after the host/Pm exist). ── + Movement = new MovementManager(Interp) + { + MoveToFactory = () => + { + var mtm = new MoveToManager( + Interp, + stopCompletely: () => Interp.StopCompletely(), + getPosition: () => new CorePosition(1u, Body.Position, Body.Orientation), + getHeading: () => MoveToMath.GetHeading(Body.Orientation), + setHeading: (h, _) => Body.Orientation = + MoveToMath.SetHeading(Body.Orientation, h), + getOwnRadius: () => OwnRadius, + getOwnHeight: () => 1f, + contact: () => Body.OnWalkable, + isInterpolating: () => false, + getVelocity: () => Body.Velocity, + getSelfId: () => CreatureGuid, + setTarget: (ctx, tlid, radius, q) => + { + _targetArmed = tlid == PlayerGuid; + // TargetManager delivers the FIRST info synchronously on + // SetTarget (live log: HandleUpdateTarget printed directly + // after the arm, same network phase). + DeliverTargetInfo(); + }, + clearTarget: () => _targetArmed = false, + getTargetQuantum: () => _quantum, + setTargetQuantum: q => _quantum = q, + curTime: () => Now); + // R5-V3 (#171) sticky seam binds (BeginNextNode arrival + // StickTo @0x00529d3a, PerformMovement-head Unstick). + mtm.StickTo = (tlid, radius, height) => Pm.StickTo(tlid, radius, height); + mtm.Unstick = Pm.UnStick; + return mtm; + }, + }; + + // TS-36: interrupt_current_movement → MovementManager::CancelMoveTo + // (the facade relay 0x005241b0) — EnsureRemoteMotionBindings twin. + Interp.InterruptCurrentMovement = + () => Movement.CancelMoveTo(WeenieError.ActionCancelled); + + // ── R5-V3 (#171): the PositionManager/sticky wiring — GameWindow's + // V3 additions verbatim: host-owned facade + the UM-funnel-head + // unstick_from_object bind; then MakeMoveToManager (0x00524000) + // invokes the factory above, mirroring the production bind order. ── + _playerHost = new TargetHost(this); + _creatureHost = new CreatureHost(this); + Pm = new PositionManager(_creatureHost); + Movement.MakeMoveToManager(); + Interp.UnstickFromObject = Pm.UnStick; + + // ── The anim-loop MotionDone binding (GameWindow.cs:10266) ── + Seq.MotionDoneTarget = (m, ok) => Interp.MotionDone(m, ok); + + _prevSubstate = Seq.Manager.State.Substate; + } + + // ── Wire events ───────────────────────────────────────────────────────── + + /// mt-0 UM (funnel apply): interrupt + unstick head, then + /// MoveToInterpretedState — GameWindow.cs:4893 + 5008. + public void UmInterpreted(uint stance, uint forward, float forwardSpeed = 1f, + params InboundMotionAction[] actions) + { + Interp.InterruptCurrentMovement?.Invoke(); + Interp.UnstickFromObject?.Invoke(); + + var ims = new InboundInterpretedState + { + CurrentStyle = stance, + ForwardCommand = forward, + ForwardSpeed = forwardSpeed, + SideStepCommand = 0u, + SideStepSpeed = 1f, + TurnCommand = 0u, + TurnSpeed = 1f, + }; + if (actions.Length > 0) + ims.Actions = new List(actions); + + Interp.MoveToInterpretedState(ims, Sink); + } + + /// mt-6 UM (MoveToObject arm): interrupt + unstick head, then the + /// RouteServerMoveTo MovementStruct — GameWindow.cs:4483-4508. Params match + /// the live scamp chase (spd 2.08, threshold 15, object distance 0.6). + public void UmMoveToObject( + float speed = 2.08f, + float distanceToObject = 0.6f, + float walkRunThreshold = 15f, + bool sticky = false, + bool useSpheres = false, + float targetRadius = 0f, + float targetHeight = 0f, + uint wireStance = 0u) + { + Interp.InterruptCurrentMovement?.Invoke(); + Interp.UnstickFromObject?.Invoke(); + + // R5-V4a: the unpack_movement HEAD style-on-change (GameWindow's + // routing-head mirror — 0x00524440 @00524502-0052452c): fires for + // EVERY movement type, BEFORE the type routing, on CHANGE only. + if (wireStance != 0u) + { + uint wireStyle = 0x80000000u | wireStance; + if (Interp.InterpretedState.CurrentStyle != wireStyle) + Interp.DoMotion(wireStyle, new MovementParameters()); + } + + var mp = new MovementParameters + { + CanWalk = true, + CanRun = true, + CanCharge = true, + CanSidestep = false, + CanWalkBackwards = false, + Speed = speed, + DistanceToObject = distanceToObject, + WalkRunThreshhold = walkRunThreshold, + FailDistance = float.MaxValue, + // R5-V3 (#171): ACE arms every melee chase Sticky + UseSpheres + // (Monster_Navigation.cs:406-419; UseSpheres is the ACE default). + Sticky = sticky, + UseSpheres = useSpheres, + }; + var ms = new MovementStruct + { + Type = MovementType.MoveToObject, + ObjectId = PlayerGuid, + TopLevelId = PlayerGuid, + Pos = new CorePosition(1u, PlayerPos, Quaternion.Identity), + Params = mp, + // R5-V3: the RouteServerMoveTo radius threading twin — retail + // reads the TARGET's PartArray radius/height at the call site. + Radius = targetRadius, + Height = targetHeight, + }; + // R5-V5: RouteServerMoveTo twin — through the facade + // (MovementManager::PerformMovement 0x005240d0). + Movement.PerformMovement(ms); + } + + private void DeliverTargetInfo() + { + if (!_targetArmed) return; + _lastDeliveryTime = Now; + var pos = new CorePosition(1u, PlayerPos, Quaternion.Identity); + var info = new TargetInfo + { + ObjectId = PlayerGuid, + Status = TargetStatus.Ok, + TargetPosition = pos, + InterpolatedPosition = pos, + }; + // R5-V3 fan order (EntityPhysicsHost.HandleUpdateTarget — retail + // CPhysicsObj::HandleUpdateTarget 0x00512bc0): the MovementManager + // relay (@0x00512bf0 → moveto) first, then PositionManager (the + // sticky consumer). + Movement.HandleUpdateTarget(info); + Pm.HandleUpdateTarget(info); + } + + // ── R5-V3 (#171): the IPhysicsObjHost twins of GameWindow's + // EntityPhysicsHost (creature side) and ResolvePhysicsHost's minimal + // target host (player side). ── + + private sealed class CreatureHost : IPhysicsObjHost + { + private readonly RemoteChaseHarness _h; + public CreatureHost(RemoteChaseHarness h) => _h = h; + public uint Id => CreatureGuid; + public CorePosition Position => new(1u, _h.Body.Position, _h.Body.Orientation); + public Vector3 Velocity => _h.Body.Velocity; + public float Radius => OwnRadius; + public bool InContact => _h.Body.OnWalkable; + public float? MinterpMaxSpeed => _h.Interp.GetMaxSpeed(); + public double CurTime => _h.Now; + public double PhysicsTimerTime => _h.Now; + public IPhysicsObjHost? GetObjectA(uint id) + => id == PlayerGuid ? _h._playerHost : null; + + public void HandleUpdateTarget(TargetInfo info) + { + _h.Movement.HandleUpdateTarget(info); + _h.Pm.HandleUpdateTarget(info); + } + + public void InterruptCurrentMovement() + => _h.Movement.CancelMoveTo(WeenieError.ActionCancelled); + + public void SetTarget(uint contextId, uint objectId, float radius, double quantum) + { + // The scripted TargetManager stand-in — StickyManager::StickTo + // subscribes at quantum 0.5 (0x00555710) with a synchronous first + // delivery (the AddVoyeur immediate snapshot). + _h._targetArmed = objectId == PlayerGuid; + _h._quantum = quantum; + _h.DeliverTargetInfo(); + } + + public void ClearTarget() => _h._targetArmed = false; + public void ReceiveTargetUpdate(TargetInfo info) { } + public void AddVoyeur(uint watcherId, float radius, double quantum) { } + public void RemoveVoyeur(uint watcherId) { } + } + + private sealed class TargetHost : IPhysicsObjHost + { + private readonly RemoteChaseHarness _h; + public TargetHost(RemoteChaseHarness h) => _h = h; + public uint Id => PlayerGuid; + public CorePosition Position => new(1u, _h.PlayerPos, Quaternion.Identity); + public Vector3 Velocity => _h.PlayerVelocity; + public float Radius => StickyTargetRadius; + public bool InContact => true; + public float? MinterpMaxSpeed => null; + public double CurTime => _h.Now; + public double PhysicsTimerTime => _h.Now; + public IPhysicsObjHost? GetObjectA(uint id) => null; + public void HandleUpdateTarget(TargetInfo info) { } + public void InterruptCurrentMovement() { } + public void SetTarget(uint contextId, uint objectId, float radius, double quantum) { } + public void ClearTarget() { } + public void ReceiveTargetUpdate(TargetInfo info) { } + public void AddVoyeur(uint watcherId, float radius, double quantum) { } + public void RemoveVoyeur(uint watcherId) { } + } + + // ── The per-tick pipeline (GameWindow.TickAnimations order) ──────────── + + public void Tick() + { + Now += Dt; + TotalTicks++; + + // Player (chase target) moves per its scripted velocity. + PlayerPos += PlayerVelocity * Dt; + + // 1. Voyeur delivery (player host HandleTargetting → this entity's + // HandleUpdateTarget; GameWindow.cs:8094 runs before the per-remote + // loop, 9697 in-loop). + if (_targetArmed && Now - _lastDeliveryTime >= _quantum) + DeliverTargetInfo(); + + // 2. MovementManager drive (TickRemoteMoveTo — the R5-V5 facade + // relay, MovementManager::UseTime 0x005242f0). + Movement.UseTime(); + + // 3. get_state_velocity → body velocity (the d2ccc80e refresh, + // GameWindow.cs:10024). + if (Body.OnWalkable) + Body.set_local_velocity(Interp.get_state_velocity(), false); + + // 4. Manual omega integration (GameWindow.cs:10050-10058 verbatim). + if (ObservedOmega.LengthSquared() > 1e-8f) + { + float omegaMag = ObservedOmega.Length(); + var axis = ObservedOmega / omegaMag; + float angle = omegaMag * Dt; + var deltaRot = Quaternion.CreateFromAxisAngle(axis, angle); + Body.Orientation = Quaternion.Normalize( + Quaternion.Multiply(Body.Orientation, deltaRot)); + } + + // 5. R5-V3 (#171): the sticky steer — GameWindow's legacy-branch slot + // (retail UpdatePositionInternal PositionManager::adjust_offset + // @0x00512d0e, composed BEFORE the velocity integration). Origin is + // mover-local; the rotation carries a RELATIVE heading (identity = + // untouched = no turn). + var pmDelta = new MotionDeltaFrame(); + Pm.AdjustOffset(pmDelta, Dt); + if (pmDelta.Origin != Vector3.Zero) + Body.Position += Vector3.Transform(pmDelta.Origin, Body.Orientation); + if (!pmDelta.Orientation.IsIdentity) + Body.Orientation = MoveToMath.SetHeading( + Body.Orientation, + MoveToMath.GetHeading(Body.Orientation) + pmDelta.GetHeading()); + + // 5b. Position integration (UpdatePhysicsInternal, simplified: grounded, + // no gravity participation for this scenario). + Body.Position += Body.Velocity * Dt; + + // 5c. R5-V3: PositionManager::UseTime (retail UpdateObjectInternal + // tail @0x005159b3) — the sticky 1 s lease watchdog. + Pm.UseTime(); + + // 6. Anim loop (GameWindow.cs:10247-10309): advance, drain AnimDone + // hooks into the manager countdown, zero-tick sweep. + Seq.Advance(Dt); + var hooks = Seq.ConsumePendingHooks(); + for (int i = 0; i < hooks.Count; i++) + { + if (hooks[i] is DatReaderWriter.Types.AnimationDoneHook) + Seq.Manager.AnimationDone(success: true); + } + Seq.Manager.UseTime(); + + // ── Observables ── + uint substate = Seq.Manager.State.Substate; + if (substate == Run) TicksInRun++; + if (substate == Walk) TicksInWalkFwd++; + bool inFwd = substate == Run || substate == Walk; + if (inFwd) + { + _runStreak++; + if (_runStreak > MaxRunStreak) MaxRunStreak = _runStreak; + } + else + { + _runStreak = 0; + } + if (inFwd && _prevSubstate != Run && _prevSubstate != Walk) + RunInstalls++; + _prevSubstate = substate; + } + + public float Heading => MoveToMath.GetHeading(Body.Orientation); + public float DistToPlayer => Vector3.Distance(Body.Position, PlayerPos); + + public void Snapshot(string tag) + { + string line = FormattableString.Invariant( + $"t={Now,6:F2} {tag,-14} mt={Mgr.MovementTypeState,-14} substate=0x{Seq.Manager.State.Substate:X8} heading={Heading,6:F1} dist={DistToPlayer,6:F2} pending={Interp.MotionsPending()} omega.Z={ObservedOmega.Z,6:F3}"); + Trace.Add(line); + _log?.WriteLine(line); + } + + // ── Fixture ───────────────────────────────────────────────────────────── + + private static Animation MakeAnim(int numFrames) + { + var anim = new Animation(); + for (int f = 0; f < numFrames; f++) + { + var pf = new AnimationFrame(1u); + pf.Frames.Add(new Frame { Origin = Vector3.Zero, Orientation = Quaternion.Identity }); + anim.PartFrames.Add(pf); + } + return anim; + } + + private static MotionData MakeMd(uint animId, float framerate = 30f, + Vector3? velocity = null, Vector3? omega = null) + { + var md = new MotionData(); + QualifiedDataId qid = animId; + md.Anims.Add(new AnimData + { + AnimId = qid, + LowFrame = 0, + HighFrame = -1, + Framerate = framerate, + }); + if (velocity is { } v) + { + md.Velocity = v; + md.Flags |= DatReaderWriter.Enums.MotionDataFlags.HasVelocity; + } + if (omega is { } o) + { + md.Omega = o; + md.Flags |= DatReaderWriter.Enums.MotionDataFlags.HasOmega; + } + return md; + } + + private static void AddLink(MotionTable mt, uint style, uint from, uint to, MotionData md) + { + int outer = (int)((style << 16) | (from & 0xFFFFFFu)); + if (!mt.Links.TryGetValue(outer, out var cmd)) + { + cmd = new MotionCommandData(); + mt.Links[outer] = cmd; + } + cmd.MotionData[(int)to] = md; + } + + /// + /// Two-stance creature table shaped like the Mite Scamp's: NonCombat + + /// Combat styles (default substate Ready in both), Walk/Run cycles with + /// entry/exit links (15 frames @30fps = 0.5 s links, the realistic stop/ + /// start durations), a stance-transition link, an attack action link, and + /// a global TurnRight physics-only modifier. + /// + private static (Setup, MotionTable, ChaseLoader) BuildFixture() + { + const uint ReadyAnimNC = 0x200u; + const uint ReadyAnimC = 0x201u; + const uint WalkAnim = 0x202u; + const uint RunAnim = 0x203u; + const uint ReadyToWalk = 0x204u; + const uint WalkToReady = 0x205u; + const uint ReadyToRun = 0x206u; + const uint RunToReady = 0x207u; + const uint StanceLink = 0x208u; // NonCombat.Ready → Combat (draw) + const uint AttackLink = 0x209u; // Combat.Ready → attack swing + const uint TurnAnim = 0x20Au; + + var setup = new Setup(); + setup.Parts.Add(0x01000000u); + setup.DefaultScale.Add(Vector3.One); + + var loader = new ChaseLoader(); + loader.Register(ReadyAnimNC, MakeAnim(30)); + loader.Register(ReadyAnimC, MakeAnim(30)); + loader.Register(WalkAnim, MakeAnim(30)); + loader.Register(RunAnim, MakeAnim(30)); + loader.Register(ReadyToWalk, MakeAnim(15)); + loader.Register(WalkToReady, MakeAnim(15)); + loader.Register(ReadyToRun, MakeAnim(15)); + loader.Register(RunToReady, MakeAnim(15)); + loader.Register(StanceLink, MakeAnim(15)); + loader.Register(AttackLink, MakeAnim(45)); // 1.5 s swing + loader.Register(TurnAnim, MakeAnim(30)); + + var mt = new MotionTable { DefaultStyle = (DRWMotionCommand)NonCombat }; + mt.StyleDefaults[(DRWMotionCommand)NonCombat] = (DRWMotionCommand)Ready; + mt.StyleDefaults[(DRWMotionCommand)Combat] = (DRWMotionCommand)Ready; + + static int CycleKey(uint style, uint substate) + => (int)((style << 16) | (substate & 0xFFFFFFu)); + + mt.Cycles[CycleKey(NonCombat, Ready)] = MakeMd(ReadyAnimNC); + mt.Cycles[CycleKey(Combat, Ready)] = MakeMd(ReadyAnimC); + foreach (uint style in new[] { NonCombat, Combat }) + { + mt.Cycles[CycleKey(style, Walk)] = + MakeMd(WalkAnim, velocity: new Vector3(0f, 3.12f, 0f)); + mt.Cycles[CycleKey(style, Run)] = + MakeMd(RunAnim, velocity: new Vector3(0f, 4.0f, 0f)); + AddLink(mt, style, Ready, Walk, MakeMd(ReadyToWalk)); + AddLink(mt, style, Walk, Ready, MakeMd(WalkToReady)); + AddLink(mt, style, Ready, Run, MakeMd(ReadyToRun)); + AddLink(mt, style, Run, Ready, MakeMd(RunToReady)); + } + AddLink(mt, NonCombat, Ready, Combat, MakeMd(StanceLink)); + AddLink(mt, Combat, Ready, NonCombat, MakeMd(StanceLink)); + AddLink(mt, Combat, Ready, AttackAction, MakeMd(AttackLink)); + + // Global (unstyled) TurnRight modifier — physics-only in Branch 4. + mt.Modifiers[(int)(TurnRight & 0xFFFFFFu)] = MakeMd(TurnAnim); + + return (setup, mt, loader); + } +} + +public sealed class RemoteChaseEndToEndHarnessTests +{ + private readonly ITestOutputHelper _out; + public RemoteChaseEndToEndHarnessTests(ITestOutputHelper output) => _out = output; + + private const float Dt = RemoteChaseHarness.Dt; + + private static int Seconds(float s) => (int)MathF.Round(s / Dt); + + /// + /// The core chase cycle: aggro stance change, one mt-6 arm at a target + /// 90° off the creature's facing, 15 m away, stationary. Retail bar: the + /// stance links play out (~1 s), the chase turn starts, completes at the + /// turn rate (90° at π/2·2.08 rad/s ≈ 0.5 s), and BeginMoveForward + /// installs the forward cycle. Total budget: 4 s of ticks is generous. + /// + [Theory] + [InlineData(90f)] // target to the East → TurnRight path + [InlineData(270f)] // target to the West → TurnLeft path + [InlineData(170f)] // near-reversal → long right turn + public void SingleArm_TurnCompletes_AndForwardInstalls(float bearingDeg) + { + var h = new RemoteChaseHarness(_out); + + float rad = (90f - bearingDeg) * MathF.PI / 180f; // compass → math angle + h.PlayerPos = new Vector3(MathF.Cos(rad), MathF.Sin(rad), 0f) * 15f; + h.PlayerVelocity = Vector3.Zero; + + // settle spawn state + for (int i = 0; i < Seconds(0.5f); i++) h.Tick(); + h.Snapshot("spawned"); + + // aggro: stance UM (the live capture's mt-0 stance=0x3C fwd=Ready) + h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready); + for (int i = 0; i < Seconds(1.5f); i++) h.Tick(); + h.Snapshot("post-stance"); + + // the arm + h.UmMoveToObject(); + h.Snapshot("armed"); + + int installTick = -1; + for (int i = 0; i < Seconds(6f); i++) + { + h.Tick(); + if (installTick < 0 + && (h.Seq.Manager.State.Substate == RemoteChaseHarness.Run + || h.Seq.Manager.State.Substate == RemoteChaseHarness.Walk)) + { + installTick = i; + h.Snapshot("fwd-install"); + } + if (i % Seconds(0.5f) == 0) h.Snapshot("tick"); + } + h.Snapshot("end"); + + Assert.True(installTick >= 0, + $"forward cycle never installed within 6 s of the arm (bearing {bearingDeg}°); " + + $"final: mt={h.Mgr.MovementTypeState} substate=0x{h.Seq.Manager.State.Substate:X8} " + + $"heading={h.Heading:F1} pending={h.Interp.MotionsPending()} omega.Z={h.ObservedOmega.Z:F3}"); + Assert.True(installTick <= Seconds(4f), + $"forward cycle took {installTick * Dt:F2} s to install (bearing {bearingDeg}°) — " + + "retail installs within the turn duration (~1-2 s)"); + } + + /// + /// The live failure scenario: the player FLEES at 4 m/s and ACE re-arms + /// mt-6 every 2 s (launch-drainq.log cadence). Retail bar: BeginMoveForward + /// ≈ one per arm (21/22 in the live cdb trace) and the run is SUSTAINED — + /// the forward substate holds for most of the chase. + /// + [Fact] + public void FleeingTarget_RunSustainedAcrossRearms() + { + var h = new RemoteChaseHarness(_out); + + h.PlayerPos = new Vector3(0f, 10f, 0f); // dead ahead, 10 m + h.PlayerVelocity = new Vector3(0f, 4f, 0f); // fleeing straight away + + h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready); + for (int i = 0; i < Seconds(1.5f); i++) h.Tick(); + + int arms = 0; + int chaseTicks = Seconds(12f); + for (int i = 0; i < chaseTicks; i++) + { + if (i % Seconds(2f) == 0) + { + h.UmMoveToObject(); + arms++; + h.Snapshot($"arm#{arms}"); + } + h.Tick(); + if (i % Seconds(1f) == 0) h.Snapshot("tick"); + } + h.Snapshot("end"); + + int fwdTicks = h.TicksInRun + h.TicksInWalkFwd; + float fwdFraction = fwdTicks / (float)chaseTicks; + _out.WriteLine(FormattableString.Invariant( + $"arms={arms} installs={h.RunInstalls} fwdTicks={fwdTicks}/{chaseTicks} ({fwdFraction:P0}) maxStreak={h.MaxRunStreak * Dt:F2}s")); + + Assert.True(h.RunInstalls >= arms - 1, + $"run installed only {h.RunInstalls}× across {arms} arms — " + + "retail reinstalls per arm (21/22)"); + Assert.True(fwdFraction > 0.5f, + $"forward substate held only {fwdFraction:P0} of the chase — the run is not " + + "sustained (live #170 symptom: short bursts + idle glide)"); + } + + /// + /// Attack interleave: mid-chase, an attack UM (mt-0, action list carrying + /// the swing, fwd=Ready — the wire shape from the live capture) interrupts + /// the moveto (retail-faithful), the swing plays, and the next mt-6 re-arm + /// must reinstall the run. Also asserts the #170 drain criterion: + /// pending_motions fully empties after the swing (add == done — the retail + /// cdb invariant). + /// + [Fact] + public void AttackUm_ThenRearm_RunReinstalls_AndQueueDrains() + { + var h = new RemoteChaseHarness(_out); + + h.PlayerPos = new Vector3(0f, 12f, 0f); + h.PlayerVelocity = Vector3.Zero; + + h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready); + for (int i = 0; i < Seconds(1.5f); i++) h.Tick(); + + h.UmMoveToObject(); + for (int i = 0; i < Seconds(3f); i++) h.Tick(); + h.Snapshot("chasing"); + + // the swing: interrupt + action (stamp 1, autonomous false) + h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready, 1f, + new InboundMotionAction(RemoteChaseHarness.AttackAction, Stamp: 1, + Autonomous: false, Speed: 1f)); + for (int i = 0; i < Seconds(2.5f); i++) h.Tick(); + h.Snapshot("post-swing"); + + Assert.False(h.Interp.MotionsPending(), + "pending_motions did not fully empty after the swing — the #170 " + + "residual (retail: add_to_queue == MotionDone exactly)"); + + // the player breaks away (out of attack range), then ACE re-arms — + // the run must come back + h.PlayerPos += new Vector3(0f, 10f, 0f); + h.UmMoveToObject(); + int installTick = -1; + for (int i = 0; i < Seconds(5f); i++) + { + h.Tick(); + if (installTick < 0 + && (h.Seq.Manager.State.Substate == RemoteChaseHarness.Run + || h.Seq.Manager.State.Substate == RemoteChaseHarness.Walk)) + { + installTick = i; + } + } + h.Snapshot("post-rearm"); + + Assert.True(installTick >= 0, + $"run did not reinstall after the post-swing re-arm; " + + $"mt={h.Mgr.MovementTypeState} substate=0x{h.Seq.Manager.State.Substate:X8} " + + $"pending={h.Interp.MotionsPending()}"); + } + + // ── R5-V3 (#171): sticky melee scenarios ──────────────────────────────── + + private static float AbsHeadingDiff(float a, float b) + { + float d = MathF.Abs(a - b) % 360f; + return d > 180f ? 360f - d : d; + } + + /// + /// The #171 fix's core: ACE arms melee chases Sticky+UseSpheres with the + /// target's real radii; on arrival BeginNextNode hands off to + /// PositionManager::StickTo (0x00529d3a) and StickyManager::adjust_offset + /// (0x00555430) holds a 0.3 m edge gap + live facing against a strafing + /// target — for the 1 s lease, which is set ONCE at StickTo and NOT + /// refreshed by target updates (retail 0x00555710/0x00555610): a stick + /// not re-issued by a fresh server arm tears itself down. + /// + [Fact] + public void StickyArrival_TracksStrafingTarget_ThenLeaseExpires() + { + var h = new RemoteChaseHarness(_out); + h.PlayerPos = new Vector3(0f, 10f, 0f); // dead ahead (North) + h.PlayerVelocity = Vector3.Zero; + + h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready); + for (int i = 0; i < Seconds(1.5f); i++) h.Tick(); + + h.UmMoveToObject(sticky: true, useSpheres: true, + targetRadius: RemoteChaseHarness.StickyTargetRadius, targetHeight: 1.2f); + + int stickTick = -1; + for (int i = 0; i < Seconds(8f) && stickTick < 0; i++) + { + h.Tick(); + if (h.Pm.GetStickyObjectId() == RemoteChaseHarness.PlayerGuid) + stickTick = i; + } + h.Snapshot("stuck"); + Assert.True(stickTick >= 0, + $"sticky never armed within 8 s of the arm; mt={h.Mgr.MovementTypeState} " + + $"dist={h.DistToPlayer:F2}"); + // Arrival cleaned the moveto BEFORE the handoff (BeginNextNode reads + // Sought* pre-CleanUp; CleanUp resets movement_type to Invalid). + Assert.Equal(MovementType.Invalid, h.Mgr.MovementTypeState); + + // The target strafes — the follower must track gap AND facing + // (adjust_offset resolves the LIVE target via GetObjectA per tick). + h.PlayerVelocity = new Vector3(2f, 0f, 0f); + for (int i = 0; i < Seconds(0.8f); i++) h.Tick(); + h.Snapshot("strafed"); + + Assert.Equal(RemoteChaseHarness.PlayerGuid, h.Pm.GetStickyObjectId()); // inside the lease + float gap = MoveToMath.CylinderDistanceNoZ( + RemoteChaseHarness.OwnRadius, h.Body.Position, + RemoteChaseHarness.StickyTargetRadius, h.PlayerPos); + Assert.True(MathF.Abs(gap - StickyManager.StickyRadius) < 0.1f, + $"stick gap {gap:F2} m — expected ≈{StickyManager.StickyRadius:F1} m (StickyRadius)"); + float bearing = MoveToMath.PositionHeading(h.Body.Position, h.PlayerPos); + Assert.True(AbsHeadingDiff(h.Heading, bearing) < 5f, + $"facing {h.Heading:F1}° vs bearing {bearing:F1}° — sticky facing not tracking"); + + // Lease expiry: >1 s since StickTo with no re-arm → the UseTime + // watchdog drops the stick (retail parity — ACE re-arms each attack + // cycle, renewing the stick server-side). + h.PlayerVelocity = Vector3.Zero; + for (int i = 0; i < Seconds(0.5f); i++) h.Tick(); + Assert.Equal(0u, h.Pm.GetStickyObjectId()); + } + + /// + /// The pack-melee reshuffle cycle: every fresh server arm + /// (PerformMovement) tears the previous stick down at the HEAD + /// (unstick_from_object → PositionManager::UnStick — the retail + /// PerformMovement:414 + UM-funnel-head sites), then the new chase + /// re-arrives and re-sticks. + /// + [Fact] + public void NextPerformMovement_Unsticks_ThenRearrivalResticks() + { + var h = new RemoteChaseHarness(_out); + h.PlayerPos = new Vector3(0f, 8f, 0f); + h.PlayerVelocity = Vector3.Zero; + + h.UmInterpreted(RemoteChaseHarness.Combat, RemoteChaseHarness.Ready); + for (int i = 0; i < Seconds(1.5f); i++) h.Tick(); + + h.UmMoveToObject(sticky: true, useSpheres: true, + targetRadius: RemoteChaseHarness.StickyTargetRadius, targetHeight: 1.2f); + for (int i = 0; i < Seconds(8f); i++) + { + h.Tick(); + if (h.Pm.GetStickyObjectId() != 0u) break; + } + Assert.Equal(RemoteChaseHarness.PlayerGuid, h.Pm.GetStickyObjectId()); + + // The target breaks away; ACE re-arms the chase — the arm must + // UNSTICK immediately (stale stick torn down before the new moveto). + h.PlayerPos += new Vector3(0f, 8f, 0f); + h.UmMoveToObject(sticky: true, useSpheres: true, + targetRadius: RemoteChaseHarness.StickyTargetRadius, targetHeight: 1.2f); + Assert.Equal(0u, h.Pm.GetStickyObjectId()); + Assert.Equal(MovementType.MoveToObject, h.Mgr.MovementTypeState); + + // ...and the new chase re-arrives and re-sticks. + int restick = -1; + for (int i = 0; i < Seconds(8f) && restick < 0; i++) + { + h.Tick(); + if (h.Pm.GetStickyObjectId() == RemoteChaseHarness.PlayerGuid) + restick = i; + } + Assert.True(restick >= 0, + $"chase did not re-stick after the re-arm; mt={h.Mgr.MovementTypeState} " + + $"dist={h.DistToPlayer:F2}"); + } + + /// + /// R5-V4a: the unpack-head style-on-change — a chase arm (mt-6) whose UM + /// carries a CHANGED stance applies the stance FIRST (retail + /// unpack_movement @00524502-0052452c dispatches DoMotion(style) before + /// the movement-type switch), so the creature draws into Combat and THEN + /// runs — instead of chasing in the old NonCombat stance until the next + /// mt-0 UM. Closes the RetailObserverTraceConformanceTests "S3 wires the + /// unpack-level style-on-change" exclusion's production gap. + /// + [Fact] + public void ChaseArm_WithStanceChange_AppliesStanceBeforeTheChase() + { + var h = new RemoteChaseHarness(_out); + h.PlayerPos = new Vector3(0f, 12f, 0f); + h.PlayerVelocity = Vector3.Zero; + + // settle in NonCombat — NO prior stance UM (the pre-V4 gap: nothing + // but an mt-0 could change the stance). + for (int i = 0; i < Seconds(0.5f); i++) h.Tick(); + Assert.Equal(RemoteChaseHarness.NonCombat, h.Seq.Manager.State.Style); + + // the arm carries the Combat stance in its UM header (mt-6). + h.UmMoveToObject(wireStance: RemoteChaseHarness.Combat & 0xFFFFu); + + // the stance adopts at the head — before any chase motion completes. + Assert.Equal(RemoteChaseHarness.Combat, h.Interp.InterpretedState.CurrentStyle); + + // ...and the chase still installs its forward cycle normally, now in + // the Combat style family. + int installTick = -1; + for (int i = 0; i < Seconds(6f) && installTick < 0; i++) + { + h.Tick(); + if (h.Seq.Manager.State.Substate == RemoteChaseHarness.Run + || h.Seq.Manager.State.Substate == RemoteChaseHarness.Walk) + installTick = i; + } + Assert.True(installTick >= 0, + $"forward cycle never installed after the stance-carrying arm; " + + $"mt={h.Mgr.MovementTypeState} substate=0x{h.Seq.Manager.State.Substate:X8}"); + Assert.Equal(RemoteChaseHarness.Combat, h.Seq.Manager.State.Style); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/StickyManagerTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/StickyManagerTests.cs new file mode 100644 index 00000000..744785df --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/StickyManagerTests.cs @@ -0,0 +1,247 @@ +using System.Collections.Generic; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R5 conformance — (retail 0x00555400-0x00555866). +/// Lifecycle (StickTo/UnStick/timeout/HandleUpdateTarget) + the decoded +/// adjust_offset steering math (port-plan §2a). +/// +public sealed class StickyManagerTests +{ + private static (R5Host self, R5Host target, StickyManager sticky) Setup( + uint targetId = 20u, float targetRadius = 0.5f) + { + var world = new Dictionary(); + var self = new R5Host(10u, world); + var target = new R5Host(targetId, world); + var sticky = new StickyManager(self); + return (self, target, sticky); + } + + private static StickyManager StuckAndInitialized( + R5Host self, R5Host target, Vector3 targetOrigin, float targetRadius = 0.5f) + { + var sticky = new StickyManager(self); + sticky.StickTo(target.Id, targetRadius, targetHeight: 1.0f); + target.SetOrigin(targetOrigin); + var tp = new Position(1u, targetOrigin, Quaternion.Identity); + sticky.HandleUpdateTarget(new TargetInfo(target.Id, TargetStatus.Ok, tp, tp)); + return sticky; + } + + [Fact] + public void StickTo_SetsTargetAndTimeout_AndSubscribesVoyeurOnTarget() + { + var (self, target, sticky) = Setup(); + self.CurTime = 100.0; + + sticky.StickTo(target.Id, targetRadius: 0.5f, targetHeight: 2.0f); + + Assert.Equal(target.Id, sticky.TargetId); + Assert.Equal(0.5f, sticky.TargetRadius); + Assert.False(sticky.Initialized); + Assert.Equal(101.0, sticky.StickyTimeoutTime); // now + StickyTime(1.0) + // set_target(0, target, 0.5, 0.5) → watcher subscribes ON the target. + Assert.NotNull(target.TargetManagerOrNull); + Assert.True(target.TargetManager.VoyeurTable!.ContainsKey(self.Id)); + } + + [Fact] + public void HandleUpdateTarget_Ok_MarksInitializedAndCachesPosition() + { + var (self, target, sticky) = Setup(); + sticky.StickTo(target.Id, 0.5f, 1.0f); + + var tp = new Position(1u, new Vector3(3f, 0f, 0f), Quaternion.Identity); + sticky.HandleUpdateTarget(new TargetInfo(target.Id, TargetStatus.Ok, tp, tp)); + + Assert.True(sticky.Initialized); + Assert.Equal(new Vector3(3f, 0f, 0f), sticky.TargetPosition.Frame.Origin); + } + + [Fact] + public void HandleUpdateTarget_ForeignObject_Ignored() + { + var (self, target, sticky) = Setup(); + sticky.StickTo(target.Id, 0.5f, 1.0f); + + var tp = new Position(1u, Vector3.Zero, Quaternion.Identity); + sticky.HandleUpdateTarget(new TargetInfo(999u, TargetStatus.Ok, tp, tp)); + + Assert.False(sticky.Initialized); + Assert.Equal(target.Id, sticky.TargetId); // still stuck to the real target + } + + [Fact] + public void HandleUpdateTarget_NonOkStatus_TearsDown() + { + var (self, target, sticky) = Setup(); + sticky.StickTo(target.Id, 0.5f, 1.0f); + int interruptsBefore = self.InterruptCurrentMovementCalls; + + var tp = new Position(1u, Vector3.Zero, Quaternion.Identity); + sticky.HandleUpdateTarget(new TargetInfo(target.Id, TargetStatus.ExitWorld, tp, tp)); + + Assert.Equal(0u, sticky.TargetId); + Assert.False(sticky.Initialized); + Assert.Equal(interruptsBefore + 1, self.InterruptCurrentMovementCalls); + } + + [Fact] + public void UseTime_BeforeDeadline_KeepsStick() + { + var (self, target, sticky) = Setup(); + self.CurTime = 100.0; + sticky.StickTo(target.Id, 0.5f, 1.0f); // deadline 101.0 + + self.CurTime = 100.9; + sticky.UseTime(); + + Assert.Equal(target.Id, sticky.TargetId); + } + + [Fact] + public void UseTime_PastDeadline_UnsticksAndInterrupts() + { + var (self, target, sticky) = Setup(); + self.CurTime = 100.0; + sticky.StickTo(target.Id, 0.5f, 1.0f); // deadline 101.0 + + // AT the deadline the stick survives — retail 0x00555626 tears down + // strictly AFTER it (`test ah,0x41`: C0|C3 = less-or-equal keeps; + // ACE `>` too). The R5-V1 pin of `>=` was the wrong value. + self.CurTime = 101.0; + sticky.UseTime(); + Assert.Equal(target.Id, sticky.TargetId); + + int interruptsBefore = self.InterruptCurrentMovementCalls; + self.CurTime = 101.001; + sticky.UseTime(); + + Assert.Equal(0u, sticky.TargetId); + Assert.Equal(interruptsBefore + 1, self.InterruptCurrentMovementCalls); + } + + [Fact] + public void ReStick_TearsDownPreviousBeforeSettingNew() + { + var world = new Dictionary(); + var self = new R5Host(10u, world); + var a = new R5Host(20u, world); + var b = new R5Host(21u, world); + var sticky = new StickyManager(self); + + sticky.StickTo(a.Id, 0.5f, 1.0f); + int interruptsBefore = self.InterruptCurrentMovementCalls; + sticky.StickTo(b.Id, 0.5f, 1.0f); + + Assert.Equal(b.Id, sticky.TargetId); + Assert.Equal(interruptsBefore + 1, self.InterruptCurrentMovementCalls); // old stick torn down + } + + [Fact] + public void AdjustOffset_NotInitialized_IsNoOp() + { + var (self, target, sticky) = Setup(); + sticky.StickTo(target.Id, 0.5f, 1.0f); // no HandleUpdateTarget → not initialized + + var frame = new MotionDeltaFrame { Origin = new Vector3(9f, 9f, 9f) }; + sticky.AdjustOffset(frame, 0.1); + + Assert.Equal(new Vector3(9f, 9f, 9f), frame.Origin); // untouched + } + + [Fact] + public void AdjustOffset_SteersTowardTarget_ClampedToStep() + { + var world = new Dictionary(); + var self = new R5Host(10u, world) { Radius = 0.5f, MinterpMaxSpeed = 1.0f }; + var target = new R5Host(20u, world); + var sticky = StuckAndInitialized(self, target, new Vector3(5f, 0f, 0f)); + + var frame = new MotionDeltaFrame(); + sticky.AdjustOffset(frame, quantum: 0.1); + + // dir = +X (east); speed = 1.0 * 5 = 5; delta = 5 * 0.1 = 0.5 (< dist 3.7). + Assert.Equal(0.5f, frame.Origin.X, 3); + Assert.Equal(0f, frame.Origin.Y, 3); + Assert.Equal(0f, frame.Origin.Z, 3); // horizontal-only + // heading toward +X (east) = 90° compass. + Assert.Equal(90f, frame.GetHeading(), 1); + } + + [Fact] + public void AdjustOffset_TooClose_BacksOff_SignedDistance() + { + var world = new Dictionary(); + var self = new R5Host(10u, world) { Radius = 0.5f, MinterpMaxSpeed = 1.0f }; + var target = new R5Host(20u, world); + // centerDist 0.9, cyl = 0.9-0.5-0.5 = -0.1, minus 0.3 → dist = -0.4. + var sticky = StuckAndInitialized(self, target, new Vector3(0.9f, 0f, 0f)); + + var frame = new MotionDeltaFrame(); + sticky.AdjustOffset(frame, quantum: 0.1); + + // delta = 5*0.1 = 0.5 >= |dist|=0.4 → delta = dist = -0.4; dir +X * -0.4 → back off (-X). + Assert.Equal(-0.4f, frame.Origin.X, 3); + } + + [Fact] + public void AdjustOffset_DeepOverlap_BacksOff_RateLimited() + { + var world = new Dictionary(); + var self = new R5Host(10u, world) { Radius = 0.5f, MinterpMaxSpeed = 1.0f }; + var target = new R5Host(20u, world); + // centerDist 0.1 → cyl = 0.1-0.5-0.5 = -0.9, minus 0.3 → dist = -1.2 + // (overlap DEEPER than one tick's step). + var sticky = StuckAndInitialized(self, target, new Vector3(0.1f, 0f, 0f)); + + var frame = new MotionDeltaFrame(); + sticky.AdjustOffset(frame, quantum: 0.1); + + // delta = 5*0.1 = 0.5 < |dist|=1.2 — ACE's literal branch kept +0.5 + // here (INWARD: the #171 gate-3 runaway-to-center; 1661 probe ticks, + // all inward, equilibrium at centers-coincident). The sign pin backs + // off rate-limited: dir +X × −0.5. + Assert.Equal(-0.5f, frame.Origin.X, 3); + } + + [Fact] + public void AdjustOffset_UsesCachedPosition_WhenTargetUnresolvable() + { + var world = new Dictionary(); + var self = new R5Host(10u, world) { Radius = 0.5f, MinterpMaxSpeed = 1.0f }; + var target = new R5Host(20u, world); + var sticky = new StickyManager(self); + sticky.StickTo(target.Id, 0.5f, 1.0f); + // Cache a position via HandleUpdateTarget, then make the target vanish. + var tp = new Position(1u, new Vector3(4f, 0f, 0f), Quaternion.Identity); + sticky.HandleUpdateTarget(new TargetInfo(target.Id, TargetStatus.Ok, tp, tp)); + target.Resolvable = false; // GetObjectA(target) → null → fall back to cached + + var frame = new MotionDeltaFrame(); + sticky.AdjustOffset(frame, quantum: 0.1); + + Assert.Equal(0.5f, frame.Origin.X, 3); // still steers toward cached (4,0,0) + } + + [Fact] + public void AdjustOffset_NoMinterp_UsesFallbackSpeed() + { + var world = new Dictionary(); + var self = new R5Host(10u, world) { Radius = 0.5f, MinterpMaxSpeed = null }; + var target = new R5Host(20u, world); + var sticky = StuckAndInitialized(self, target, new Vector3(50f, 0f, 0f)); + + var frame = new MotionDeltaFrame(); + sticky.AdjustOffset(frame, quantum: 0.1); + + // fallback speed 15 → delta = 15 * 0.1 = 1.5 (dist ≈ 49 → not clamped). + Assert.Equal(1.5f, frame.Origin.X, 3); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/Motion/TargetManagerTests.cs b/tests/AcDream.Core.Tests/Physics/Motion/TargetManagerTests.cs new file mode 100644 index 00000000..0fd2130b --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/Motion/TargetManagerTests.cs @@ -0,0 +1,255 @@ +using System.Collections.Generic; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics.Motion; + +/// +/// R5 conformance — voyeur system (retail +/// 0x0051a370-0x0051ad90). Watcher role (SetTarget/ReceiveUpdate/timeout), +/// watched role (AddVoyeur/HandleTargetting/CheckAndUpdateVoyeur), and the full +/// cross-entity round-trip (port-plan §2d/§2e). Replaces the AP-79 adapter. +/// +public sealed class TargetManagerTests +{ + private static (R5Host self, R5Host target, Dictionary world) TwoHosts() + { + var world = new Dictionary(); + var self = new R5Host(10u, world); + var target = new R5Host(20u, world); + return (self, target, world); + } + + // ── watcher role ─────────────────────────────────────────────────────── + + [Fact] + public void SetTarget_SubscribesOnTarget_AndReceivesImmediateSnapshot() + { + var (self, target, _) = TwoHosts(); + target.SetOrigin(new Vector3(3f, 0f, 0f)); + + self.TargetManager.SetTarget(0, target.Id, radius: 1.0f, quantum: 0.0); + + // Watcher subscribed on the target. + Assert.True(target.TargetManager.VoyeurTable!.ContainsKey(self.Id)); + // Immediate Ok snapshot fanned to the watcher's host. + Assert.Single(self.HandleUpdateTargetCalls); + Assert.Equal(TargetStatus.Ok, self.HandleUpdateTargetCalls[0].Status); + Assert.Equal(target.Id, self.HandleUpdateTargetCalls[0].ObjectId); + Assert.Equal(new Vector3(3f, 0f, 0f), + self.HandleUpdateTargetCalls[0].InterpolatedPosition.Frame.Origin); + Assert.Equal(TargetStatus.Ok, self.TargetManager.TargetInfo!.Value.Status); + } + + [Fact] + public void SetTarget_Zero_SynthesizesTimedOut_LeavesTargetInfoNull() + { + var (self, _, _) = TwoHosts(); + self.TargetManager.SetTarget(contextId: 7, objectId: 0, radius: 1.0f, quantum: 0.0); + + Assert.Null(self.TargetManager.TargetInfo); + Assert.Single(self.HandleUpdateTargetCalls); + Assert.Equal(TargetStatus.TimedOut, self.HandleUpdateTargetCalls[0].Status); + Assert.Equal(7u, self.HandleUpdateTargetCalls[0].ContextId); + } + + [Fact] + public void ClearTarget_UnsubscribesFromTarget() + { + var (self, target, _) = TwoHosts(); + self.TargetManager.SetTarget(0, target.Id, 1.0f, 0.0); + Assert.True(target.TargetManager.VoyeurTable!.ContainsKey(self.Id)); + + self.TargetManager.ClearTarget(); + + Assert.Null(self.TargetManager.TargetInfo); + Assert.False(target.TargetManager.VoyeurTable!.ContainsKey(self.Id)); + } + + [Fact] + public void ReceiveUpdate_ForWrongObject_Ignored() + { + var (self, target, _) = TwoHosts(); + self.TargetManager.SetTarget(0, target.Id, 1.0f, 0.0); + int before = self.HandleUpdateTargetCalls.Count; + + var p = new Position(1u, Vector3.Zero, Quaternion.Identity); + self.TargetManager.ReceiveUpdate(new TargetInfo(999u, TargetStatus.Ok, p, p)); + + Assert.Equal(before, self.HandleUpdateTargetCalls.Count); + } + + [Fact] + public void ReceiveUpdate_ExitWorld_ClearsTarget() + { + var (self, target, _) = TwoHosts(); + self.TargetManager.SetTarget(0, target.Id, 1.0f, 0.0); + + var p = new Position(1u, Vector3.Zero, Quaternion.Identity); + self.TargetManager.ReceiveUpdate(new TargetInfo(target.Id, TargetStatus.ExitWorld, p, p)); + + Assert.Null(self.TargetManager.TargetInfo); // cleared + Assert.False(target.TargetManager.VoyeurTable!.ContainsKey(self.Id)); // unsubscribed + } + + [Fact] + public void ReceiveUpdate_ComputesInterpolatedHeadingTowardTarget() + { + var (self, target, _) = TwoHosts(); + self.SetOrigin(Vector3.Zero); + self.TargetManager.SetTarget(0, target.Id, 1.0f, 0.0); + + var tp = new Position(1u, new Vector3(0f, 5f, 0f), Quaternion.Identity); + self.TargetManager.ReceiveUpdate(new TargetInfo(target.Id, TargetStatus.Ok, tp, tp)); + + // self→target interp position (0,5,0) normalized = +Y. + var heading = self.TargetManager.TargetInfo!.Value.InterpolatedHeading; + Assert.Equal(0f, heading.X, 3); + Assert.Equal(1f, heading.Y, 3); + } + + [Fact] + public void HandleTargetting_UndefinedTarget_TimesOutAfter10Seconds() + { + var (self, target, _) = TwoHosts(); + target.Resolvable = false; // no immediate snapshot → status stays Undefined + self.CurTime = 0; + self.PhysicsTimerTime = 0; + self.TargetManager.SetTarget(0, target.Id, 1.0f, 0.0); + Assert.Equal(TargetStatus.Undefined, self.TargetManager.TargetInfo!.Value.Status); + + self.AdvanceClocks(11.0); + self.TargetManager.HandleTargetting(); + + Assert.Equal(TargetStatus.TimedOut, self.TargetManager.TargetInfo!.Value.Status); + Assert.Contains(self.HandleUpdateTargetCalls, c => c.Status == TargetStatus.TimedOut); + } + + // ── watched role + gates ──────────────────────────────────────────────── + + [Fact] + public void HandleTargetting_Throttles_Within500ms() + { + var (self, target, _) = TwoHosts(); + var w = new TargettedVoyeurInfo(self.Id, radius: 0.1f, quantum: 0.0); + // seed a voyeur directly + advance so a sweep WOULD send if not throttled. + target.TargetManager.AddVoyeur(self.Id, 0.1f, 0.0); + target.SetOrigin(new Vector3(10f, 0f, 0f)); // far past radius + + target.PhysicsTimerTime = 0.3; // < 0.5 throttle + int before = self.HandleUpdateTargetCalls.Count; + target.TargetManager.HandleTargetting(); + + Assert.Equal(before, self.HandleUpdateTargetCalls.Count); // throttled, no sweep + } + + [Fact] + public void CheckAndUpdateVoyeur_SendsOnlyPastRadius() + { + var (self, target, _) = TwoHosts(); + // self must have a matching target_info for ReceiveUpdate to record. + self.TargetManager.SetTarget(0, target.Id, radius: 1.0f, quantum: 0.0); + int afterSubscribe = self.HandleUpdateTargetCalls.Count; // includes immediate snapshot + + // small move → within radius → no send + target.SetOrigin(new Vector3(0.5f, 0f, 0f)); + target.AdvanceClocks(1.0); + target.TargetManager.HandleTargetting(); + Assert.Equal(afterSubscribe, self.HandleUpdateTargetCalls.Count); + + // large move → past radius → send + target.SetOrigin(new Vector3(2f, 0f, 0f)); + target.AdvanceClocks(1.0); + target.TargetManager.HandleTargetting(); + Assert.Equal(afterSubscribe + 1, self.HandleUpdateTargetCalls.Count); + var last = self.HandleUpdateTargetCalls[^1]; + Assert.Equal(TargetStatus.Ok, last.Status); + Assert.Equal(2f, last.InterpolatedPosition.Frame.Origin.X, 3); + } + + [Fact] + public void GetInterpolatedPosition_DeadReckonsWithVelocity() + { + var (_, target, _) = TwoHosts(); + target.SetOrigin(new Vector3(1f, 2f, 0f)); + target.Velocity = new Vector3(10f, 0f, 0f); + + var p = target.TargetManager.GetInterpolatedPosition(quantum: 0.5); + + Assert.Equal(new Vector3(6f, 2f, 0f), p.Frame.Origin); // 1 + 10*0.5 = 6 + } + + [Fact] + public void AddVoyeur_Existing_UpdatesInPlace_NoResend() + { + var (self, target, _) = TwoHosts(); + target.SetOrigin(Vector3.Zero); + target.TargetManager.AddVoyeur(self.Id, radius: 1.0f, quantum: 0.0); + var voyeur = target.TargetManager.VoyeurTable![self.Id]; + Assert.Equal(Vector3.Zero, voyeur.LastSentPosition.Frame.Origin); + + target.SetOrigin(new Vector3(5f, 0f, 0f)); + target.TargetManager.AddVoyeur(self.Id, radius: 2.5f, quantum: 0.3); // existing → update only + + Assert.Equal(2.5f, voyeur.Radius); + Assert.Equal(0.3, voyeur.Quantum); + Assert.Equal(Vector3.Zero, voyeur.LastSentPosition.Frame.Origin); // NOT re-sent + } + + [Fact] + public void RemoveVoyeur_RemovesEntry() + { + var (self, target, _) = TwoHosts(); + target.TargetManager.AddVoyeur(self.Id, 1.0f, 0.0); + Assert.True(target.TargetManager.RemoveVoyeur(self.Id)); + Assert.False(target.TargetManager.VoyeurTable!.ContainsKey(self.Id)); + Assert.False(target.TargetManager.RemoveVoyeur(self.Id)); // already gone + } + + [Fact] + public void NotifyVoyeurOfEvent_BroadcastsToAll_NoDistanceGate() + { + var world = new Dictionary(); + var target = new R5Host(20u, world); + var w1 = new R5Host(10u, world); + var w2 = new R5Host(11u, world); + // both watch the target (each gets a target_info via SetTarget) + w1.TargetManager.SetTarget(0, target.Id, 1.0f, 0.0); + w2.TargetManager.SetTarget(0, target.Id, 1.0f, 0.0); + int w1Before = w1.HandleUpdateTargetCalls.Count; + int w2Before = w2.HandleUpdateTargetCalls.Count; + + target.TargetManager.NotifyVoyeurOfEvent(TargetStatus.Teleported); + + Assert.Equal(w1Before + 1, w1.HandleUpdateTargetCalls.Count); + Assert.Equal(w2Before + 1, w2.HandleUpdateTargetCalls.Count); + Assert.Equal(TargetStatus.Teleported, w1.HandleUpdateTargetCalls[^1].Status); + } + + // ── full round-trip ───────────────────────────────────────────────────── + + [Fact] + public void RoundTrip_WatcherTracksMovingTarget() + { + var (self, target, _) = TwoHosts(); + target.SetOrigin(Vector3.Zero); + + // Watcher sets target with a 1.0 radius (moveto-style, quantum 0). + self.TargetManager.SetTarget(0, target.Id, radius: 1.0f, quantum: 0.0); + Assert.Single(self.HandleUpdateTargetCalls); // immediate snapshot at (0,0,0) + + // Target walks to (3,0,0); its per-tick HandleTargetting notices the + // drift and pushes an update the watcher receives. + target.SetOrigin(new Vector3(3f, 0f, 0f)); + target.AdvanceClocks(1.0); + target.TargetManager.HandleTargetting(); + + Assert.Equal(2, self.HandleUpdateTargetCalls.Count); + Assert.Equal(new Vector3(3f, 0f, 0f), + self.HandleUpdateTargetCalls[^1].InterpolatedPosition.Frame.Origin); + // The watcher's cached target position tracks the target. + Assert.Equal(3f, self.TargetManager.TargetInfo!.Value.InterpolatedPosition.Frame.Origin.X, 3); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/MotionCommandCatalogDatTests.cs b/tests/AcDream.Core.Tests/Physics/MotionCommandCatalogDatTests.cs new file mode 100644 index 00000000..da169456 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/MotionCommandCatalogDatTests.cs @@ -0,0 +1,130 @@ +using System.Linq; +using AcDream.Core.Physics; +using AcDream.Core.Tests.Conformance; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// Real-DAT availability tests for the L.1b dual command catalog. A command +/// only actually ANIMATES if the entity's MotionTable has a +/// Links or Modifiers entry for the full 32-bit value — an +/// enum/table value alone proves nothing about whether the local DATs will +/// ever play it. +/// +/// +/// Reproduces the scan from +/// docs/research/2026-06-26-ace-vs-2013-motion-command-gap.md as +/// pinned assertions: a command "exists" for a MotionTable when its full +/// 32-bit value appears as either (a) an outer Links key's low 16 +/// bits (the from-state -> command transition key), (b) an inner +/// Links[...].MotionData key (the actual animation-bearing target), +/// or (c) a Modifiers key. This three-way check is what reproduces +/// the gap doc's hit counts exactly (verified against a live scan of the +/// local client_portal.dat: LifestoneRecall/ACE=19, +/// MarketplaceRecall/ACE=19, AllegianceHometownRecall/ACE=19, +/// OffhandSlashHigh/ACE=31, HouseRecall/ACE=24 tables; all four +/// 2013-numbered equivalents=0 tables; HouseRecall/2013=42 tables, i.e. +/// "both exist" for HouseRecall specifically). +/// +/// +/// +/// Gated the same way as the existing DAT-backed conformance suite — see +/// (also mirrored by +/// DoorBugTrajectoryReplayTests.ResolveDatDir): resolve +/// ACDREAM_DAT_DIR or the default Documents\Asheron's Call +/// path, and skip cleanly (return, no failure) when the dats aren't +/// present (CI has no local AC install). +/// +/// +public class MotionCommandCatalogDatTests +{ + /// + /// True if any local MotionTable can actually animate + /// — the from-state transition key + /// (Links outer, low 16 bits), the animation-bearing inner key + /// (Links[...].MotionData), or a Modifiers entry. + /// + private static bool ExistsInAnyMotionTable(DatCollection dats, uint fullCommand) + { + ushort low16 = (ushort)(fullCommand & 0xFFFFu); + int fullAsInt = unchecked((int)fullCommand); + + foreach (var id in dats.GetAllIdsOfType()) + { + var mt = dats.Get(id); + if (mt is null) continue; + + bool outerLow = mt.Links.Keys.Any(k => (k & 0xFFFF) == low16); + if (outerLow) return true; + + bool innerFull = mt.Links.Values.Any(md => md.MotionData.ContainsKey(fullAsInt)); + if (innerFull) return true; + + if (mt.Modifiers.ContainsKey(fullAsInt)) return true; + } + + return false; + } + + [Fact] + public void AceShiftedRecallCommands_ExistInLocalMotionTables() + { + var datDir = ConformanceDats.ResolveDatDir(); + if (datDir is null) return; + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + Assert.True(ExistsInAnyMotionTable(dats, 0x10000153u), "LifestoneRecall (ACE 0x10000153) must exist in local DAT MotionTables"); + Assert.True(ExistsInAnyMotionTable(dats, 0x1000013Au), "HouseRecall (ACE 0x1000013A) must exist in local DAT MotionTables"); + } + + [Fact] + public void TwoThousandThirteenLifestoneAndHouseRecall_AlsoExist() + { + var datDir = ConformanceDats.ResolveDatDir(); + if (datDir is null) return; + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + // LifestoneRecall's 2013 numbering (0x10000150) does NOT exist locally — + // only the ACE-shifted value animates. HouseRecall's 2013 numbering + // (0x10000137) DOES exist (the gap doc: "both exist; the old value is + // very common"). + Assert.False(ExistsInAnyMotionTable(dats, 0x10000150u), "LifestoneRecall (2013 0x10000150) unexpectedly found"); + Assert.True(ExistsInAnyMotionTable(dats, 0x10000137u), "HouseRecall (2013 0x10000137) must also exist in local DAT MotionTables"); + } + + [Theory] + [InlineData(0x10000166u)] // MarketplaceRecall (ACE) + [InlineData(0x10000171u)] // AllegianceHometownRecall (ACE) + [InlineData(0x10000173u)] // OffhandSlashHigh (ACE) + public void AceOnlyCommands_ExistOnlyUnderShiftedIds(uint aceFullCommand) + { + var datDir = ConformanceDats.ResolveDatDir(); + if (datDir is null) return; + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + Assert.True(ExistsInAnyMotionTable(dats, aceFullCommand), + $"ACE value 0x{aceFullCommand:X8} must exist in local DAT MotionTables"); + } + + [Theory] + [InlineData(0x10000163u)] // MarketplaceRecall (2013) + [InlineData(0x1000016Eu)] // AllegianceHometownRecall (2013) + [InlineData(0x10000170u)] // OffhandSlashHigh (2013) + public void TwoThousandThirteenOnlyValues_HaveZeroLinkHits(uint retail2013FullCommand) + { + var datDir = ConformanceDats.ResolveDatDir(); + if (datDir is null) return; + + using var dats = new DatCollection(datDir, DatAccessType.Read); + + Assert.False(ExistsInAnyMotionTable(dats, retail2013FullCommand), + $"2013 value 0x{retail2013FullCommand:X8} unexpectedly found in local DAT MotionTables"); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/MotionCommandCatalogTests.cs b/tests/AcDream.Core.Tests/Physics/MotionCommandCatalogTests.cs new file mode 100644 index 00000000..7610cd8b --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/MotionCommandCatalogTests.cs @@ -0,0 +1,169 @@ +using System.Collections.Generic; +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// Validates the dual command-catalog seam introduced for the L.1b +/// movement/animation wire-parity slice (IMotionCommandCatalog). +/// +/// +/// Two catalogs exist because the local DATs and ACE's wire protocol use a +/// LATER-client command numbering than the Sept 2013 EoR decomp: +/// (runtime default — matches ACE + +/// local DAT MotionTables) and +/// (conformance/reference — matches the 2013 decomp's +/// command_ids[0x198] table verbatim). See +/// docs/research/2026-06-26-ace-vs-2013-motion-command-gap.md for the +/// full divergence analysis (130 common names with different values; the +/// contiguous low-word "+3" shift that begins at SnowAngelState +/// (0x43000115 -> 0x43000118), NOT at AllegianceHometownRecall as an +/// earlier code comment incorrectly claimed). +/// +/// +public class MotionCommandCatalogTests +{ + private static readonly AceModernCommandCatalog AceModern = new(); + private static readonly Retail2013CommandCatalog Retail2013 = new(); + + // ── ACE mode (AceModernCommandCatalog) ────────────────────────────── + // + // These four wires sit inside the old override range (0x016E-0x0197) + // that MotionCommandResolver used to force-map via a blind per-range + // override. Built cleanly from the DatReaderWriter MotionCommand enum, + // they already resolve correctly with NO override: + // LifestoneRecall = 0x10000153, MarketplaceRecall = 0x10000166, + // AllegianceHometownRecall = 0x10000171, OffhandSlashHigh = 0x10000173 + // (DatReaderWriter.Enums.MotionCommand, Chorizite.DatReaderWriter 2.1.7). + + [Theory] + [InlineData(0x0153, 0x10000153u)] // LifestoneRecall + [InlineData(0x0166, 0x10000166u)] // MarketplaceRecall + [InlineData(0x0171, 0x10000171u)] // AllegianceHometownRecall + [InlineData(0x0173, 0x10000173u)] // OffhandSlashHigh + public void AceModern_ResolvesShiftedRecallAndActionCommands(ushort wire, uint expected) + { + Assert.Equal(expected, AceModern.ReconstructFullCommand(wire)); + } + + // Same matrix as MotionCommandResolverTests.ReconstructsKnownCommands — + // proves AceModernCommandCatalog reproduces the existing resolver's + // behavior for the well-established low end of the command space. + [Theory] + [InlineData(0x0003, 0x41000003u)] // Ready + [InlineData(0x0005, 0x45000005u)] // WalkForward + [InlineData(0x0007, 0x44000007u)] // RunForward + [InlineData(0x0006, 0x45000006u)] // WalkBackward + [InlineData(0x000D, 0x6500000Du)] // TurnRight + [InlineData(0x000E, 0x6500000Eu)] // TurnLeft + [InlineData(0x000F, 0x6500000Fu)] // SideStepRight + [InlineData(0x0015, 0x40000015u)] // Falling + [InlineData(0x0011, 0x40000011u)] // Dead + [InlineData(0x0012, 0x41000012u)] // Crouch + [InlineData(0x0013, 0x41000013u)] // Sitting + [InlineData(0x0014, 0x41000014u)] // Sleeping + [InlineData(0x0057, 0x10000057u)] // Sanctuary (death) + [InlineData(0x0058, 0x10000058u)] // ThrustMed + [InlineData(0x005B, 0x1000005Bu)] // SlashHigh + [InlineData(0x0061, 0x10000061u)] // Shoot + [InlineData(0x004B, 0x1000004Bu)] // Jumpup + [InlineData(0x0050, 0x10000050u)] // FallDown + [InlineData(0x0087, 0x13000087u)] // Wave + [InlineData(0x0080, 0x13000080u)] // Laugh + [InlineData(0x007D, 0x1300007Du)] // BowDeep + public void AceModern_MatchesExistingResolverMatrix(ushort wire, uint expected) + { + Assert.Equal(expected, AceModern.ReconstructFullCommand(wire)); + } + + // ── 2013 mode (Retail2013CommandCatalog) ──────────────────────────── + // + // Direct-index reconstruction from acclient_2013_pseudo_c.txt's + // command_ids[0x198] table at 0x007c73e8 (line 1017259). The 2013 + // decomp's *unshifted* values for the same four logical commands. + + [Theory] + [InlineData(0x0150, 0x10000150u)] // LifestoneRecall (2013 value) + [InlineData(0x0163, 0x10000163u)] // MarketplaceRecall (2013 value) + [InlineData(0x016E, 0x1000016Eu)] // AllegianceHometownRecall (2013 value) + [InlineData(0x0170, 0x10000170u)] // OffhandSlashHigh (2013 value) + public void Retail2013_ResolvesUnshiftedRecallAndActionCommands(ushort wire, uint expected) + { + Assert.Equal(expected, Retail2013.ReconstructFullCommand(wire)); + } + + // Anchor checks straight off the extracted table — these pin the + // extraction itself, independent of the recall-command narrative. + [Theory] + [InlineData(0x0000, 0x80000000u)] + [InlineData(0x0003, 0x41000003u)] + [InlineData(0x0005, 0x45000005u)] + [InlineData(0x0007, 0x44000007u)] + [InlineData(0x000D, 0x6500000Du)] + [InlineData(0x0150, 0x10000150u)] + [InlineData(0x0153, 0x09000153u)] // NOT LifestoneRecall in 2013 numbering — anchor only. + public void Retail2013_AnchorValuesMatchExtractedTable(ushort wire, uint expected) + { + Assert.Equal(expected, Retail2013.ReconstructFullCommand(wire)); + } + + [Fact] + public void Retail2013_OutOfRangeWireReturnsZero() + { + Assert.Equal(0u, Retail2013.ReconstructFullCommand(0xFFFF)); + } + + [Fact] + public void Retail2013_LastInRangeIndexResolves() + { + // [0x197] is the final entry of command_ids[0x198]. + Assert.Equal(0x10000197u, Retail2013.ReconstructFullCommand(0x0197)); + } + + [Fact] + public void Retail2013_FirstOutOfRangeIndexReturnsZero() + { + // 0x198 is one past the table's last valid index. + Assert.Equal(0u, Retail2013.ReconstructFullCommand(0x0198)); + } + + // ── Class-priority collision resolution ───────────────────────────── + // + // Retail's class-byte priority is: lower class byte wins + // (Action 0x10 < ChatEmote 0x12/0x13 < Modifier 0x20 < SubState 0x41 + // < ... < Style 0x80). This is exercised directly against the build + // logic via a small synthetic set of colliding low-words, because the + // CURRENT DatReaderWriter.Enums.MotionCommand enum (2.1.7, 409 distinct + // values) happens to contain zero same-low16 collisions today — so a + // matrix test against the live enum alone wouldn't actually exercise + // the tie-break rule. + + [Fact] + public void ClassPriority_LowerClassByteWins() + { + var candidates = new Dictionary + { + // Same low word (0x0042) claimed by three different classes; + // Action (0x10) must win over Modifier (0x20) and Style (0x80). + [0x0042] = 0u, + }; + + uint[] colliding = { 0x80000042u, 0x20000042u, 0x10000042u }; + uint resolved = AceModernCommandCatalog.ResolveClassPriority(colliding); + + Assert.Equal(0x10000042u, resolved); + } + + [Fact] + public void ClassPriority_OrderOfInputDoesNotMatter() + { + uint[] collidingReversed = { 0x10000099u, 0x41000099u, 0x80000099u }; + uint[] collidingForward = { 0x80000099u, 0x41000099u, 0x10000099u }; + + Assert.Equal( + AceModernCommandCatalog.ResolveClassPriority(collidingForward), + AceModernCommandCatalog.ResolveClassPriority(collidingReversed)); + Assert.Equal(0x10000099u, AceModernCommandCatalog.ResolveClassPriority(collidingForward)); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/MotionInterpreterDoMotionFamilyTests.cs b/tests/AcDream.Core.Tests/Physics/MotionInterpreterDoMotionFamilyTests.cs new file mode 100644 index 00000000..f767a887 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/MotionInterpreterDoMotionFamilyTests.cs @@ -0,0 +1,878 @@ +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +// ───────────────────────────────────────────────────────────────────────────── +// MotionInterpreterDoMotionFamilyTests — R3-W5 (closes J3, J4, J9, J14). +// +// Oracle: docs/research/2026-07-02-r3-motioninterp/r3-motioninterp-decomp.md +// §2 DoMotion 0x00528d20 @306159 +// §5a StopCompletely 0x00527e40 @305208 +// §5b StopMotion 0x00528530 @305674 +// §1a add_to_queue 0x00527b80 @305032 +// docs/research/2026-07-02-r3-motioninterp/W0-pins.md A4 (MovementParameters +// bit table), A9 (StopCompletely jump-snapshot quirk), A10 (combat-stance / +// depth-cap error codes). +// ───────────────────────────────────────────────────────────────────────────── + +/// Fake WeenieObject — IsThePlayer/IsCreature/CanJump independently +/// configurable, matching the ground-lifecycle test file's convention. +file sealed class FakeWeenie : IWeenieObject +{ + public bool IsThePlayerResult; + public bool IsCreatureResult = true; + public bool CanJumpResult = true; + + public bool InqJumpVelocity(float extent, out float vz) { vz = 10f; return true; } + public bool InqRunRate(out float rate) { rate = 1f; return true; } + public bool CanJump(float extent) => CanJumpResult; + public bool IsThePlayer() => IsThePlayerResult; + public bool IsCreature() => IsCreatureResult; +} + +public sealed class MotionInterpreterDoMotionFamilyTests +{ + // ── helpers ─────────────────────────────────────────────────────────────── + + private static PhysicsBody MakeGrounded() + { + var body = new PhysicsBody + { + State = PhysicsStateFlags.Gravity | PhysicsStateFlags.ReportCollisions, + }; + body.TransientState = TransientStateFlags.Contact + | TransientStateFlags.OnWalkable + | TransientStateFlags.Active; + return body; + } + + private static MotionInterpreter MakeInterp(PhysicsBody? body = null, IWeenieObject? weenie = null) + { + body ??= MakeGrounded(); + return new MotionInterpreter(body, weenie); + } + + // ========================================================================= + // DoMotion — 0x00528d20 @306159 + // ========================================================================= + + [Fact] + public void DoMotion_NullPhysicsObj_Returns8() + { + var interp = new MotionInterpreter(); + + var result = interp.DoMotion(MotionCommand.WalkForward, new MovementParameters()); + + Assert.Equal(WeenieError.NoPhysicsObject, result); + } + + [Fact] + public void DoMotion_CancelMoveToBit_FiresInterruptSeam() + { + var interp = MakeInterp(); + bool fired = false; + interp.InterruptCurrentMovement = () => fired = true; + var p = new MovementParameters { CancelMoveTo = true }; + + interp.DoMotion(MotionCommand.WalkForward, p); + + Assert.True(fired, "the sign-bit (CancelMoveTo) must fire InterruptCurrentMovement before adjust_motion"); + } + + [Fact] + public void DoMotion_CancelMoveToClear_DoesNotFireInterruptSeam() + { + var interp = MakeInterp(); + bool fired = false; + interp.InterruptCurrentMovement = () => fired = true; + var p = new MovementParameters { CancelMoveTo = false }; + + interp.DoMotion(MotionCommand.WalkForward, p); + + Assert.False(fired); + } + + [Fact] + public void DoMotion_SetHoldKeyBit_FiresSetHoldKey_WithCancelMoveToBitAsSecondArg() + { + // A4: @306188 SetHoldKey(hold_key_to_apply, ((__inner0_1 >> 0xf) & 1)) — + // the SECOND arg is the cancel_moveto (sign) bit, not a constant. + var interp = MakeInterp(); + var p = new MovementParameters + { + SetHoldKey = true, + CancelMoveTo = true, + HoldKeyToApply = HoldKey.Run, + }; + + interp.DoMotion(MotionCommand.WalkForward, p); + + Assert.Equal(HoldKey.Run, interp.RawState.CurrentHoldKey); + } + + [Fact] + public void DoMotion_SetHoldKeyBit_FiresBeforeAdjustMotion() + { + // SetHoldKey must land BEFORE adjust_motion runs so the new hold-key + // affects the walk/run reinterpretation in THIS same call (Run + // promotion of WalkForward). + var interp = MakeInterp(); + var p = new MovementParameters + { + SetHoldKey = true, + HoldKeyToApply = HoldKey.Run, + }; + + interp.DoMotion(MotionCommand.WalkForward, p); + + // adjust_motion promotes WalkForward -> RunForward only when the + // hold key is (already, as of THIS call) Run. + Assert.Equal(MotionCommand.RunForward, interp.InterpretedState.ForwardCommand); + } + + [Fact] + public void DoMotion_SetHoldKeyBitClear_DoesNotChangeHoldKey() + { + var interp = MakeInterp(); + interp.RawState.CurrentHoldKey = HoldKey.None; + var p = new MovementParameters + { + SetHoldKey = false, + HoldKeyToApply = HoldKey.Run, + }; + + interp.DoMotion(MotionCommand.WalkForward, p); + + Assert.Equal(HoldKey.None, interp.RawState.CurrentHoldKey); + } + + [Fact] + public void DoMotion_ParamsReDefaulted_CallerDistanceHeadingDiscarded() + { + // DoMotion re-derives a canonical local MovementParameters for the + // DoInterpretedMotion call — caller-supplied distance/heading fields + // must not leak into anything the interpreted call reads (the + // params ARE discarded per the decomp; this test pins that a + // caller passing bizarre distance/heading values doesn't change + // dispatch behavior vs the defaults). + var interp1 = MakeInterp(); + var interp2 = MakeInterp(); + var weird = new MovementParameters { DistanceToObject = 999f, DesiredHeading = 12345f, FailDistance = 1f }; + var plain = new MovementParameters(); + + var r1 = interp1.DoMotion(MotionCommand.WalkForward, weird); + var r2 = interp2.DoMotion(MotionCommand.WalkForward, plain); + + Assert.Equal(r2, r1); + Assert.Equal(interp2.InterpretedState.ForwardCommand, interp1.InterpretedState.ForwardCommand); + Assert.Equal(interp2.InterpretedState.ForwardSpeed, interp1.InterpretedState.ForwardSpeed); + } + + // ── combat-stance gate (A10: 0x3f/0x40/0x41/0x42) ────────────────────── + + [Theory] + [InlineData(MotionCommand.Crouch, WeenieError.CrouchInCombatStance)] + [InlineData(MotionCommand.Sitting, WeenieError.SitInCombatStance)] + [InlineData(MotionCommand.Sleeping, WeenieError.SleepInCombatStance)] + public void DoMotion_JumpChargeMotion_RejectedInCombatStance(uint motion, WeenieError expected) + { + var interp = MakeInterp(); + interp.InterpretedState.CurrentStyle = 0x80000001u; // any non-NonCombat stance + + var result = interp.DoMotion(motion, new MovementParameters()); + + Assert.Equal(expected, result); + } + + [Theory] + [InlineData(MotionCommand.Crouch)] + [InlineData(MotionCommand.Sitting)] + [InlineData(MotionCommand.Sleeping)] + public void DoMotion_JumpChargeMotion_AllowedInNonCombatStance(uint motion) + { + var interp = MakeInterp(); + interp.InterpretedState.CurrentStyle = 0x8000003Du; // NonCombat + + var result = interp.DoMotion(motion, new MovementParameters()); + + Assert.NotEqual(WeenieError.CrouchInCombatStance, result); + Assert.NotEqual(WeenieError.SitInCombatStance, result); + Assert.NotEqual(WeenieError.SleepInCombatStance, result); + } + + [Fact] + public void DoMotion_ChatEmoteBit_RejectedInCombatStance() + { + // motion & 0x2000000 outside NonCombat -> 0x42. + var interp = MakeInterp(); + interp.InterpretedState.CurrentStyle = 0x80000001u; + uint motion = 0x10000000u | 0x2000000u; // action-class + chat-emote bit + + var result = interp.DoMotion(motion, new MovementParameters()); + + Assert.Equal(WeenieError.ChatEmoteOutsideNonCombat, result); + } + + [Fact] + public void DoMotion_ChatEmoteBit_AllowedInNonCombatStance() + { + var interp = MakeInterp(); + interp.InterpretedState.CurrentStyle = 0x8000003Du; // NonCombat + uint motion = 0x10000000u | 0x2000000u; + + var result = interp.DoMotion(motion, new MovementParameters()); + + Assert.NotEqual(WeenieError.ChatEmoteOutsideNonCombat, result); + } + + [Fact] + public void DoMotion_NonJumpChargeMotion_NotGatedByCombatStance() + { + // WalkForward (no 0x2000000 bit, not a jump-charge id) must pass + // through the combat-stance gate regardless of stance. + var interp = MakeInterp(); + interp.InterpretedState.CurrentStyle = 0x80000001u; // combat stance + + var result = interp.DoMotion(MotionCommand.WalkForward, new MovementParameters()); + + Assert.Equal(WeenieError.None, result); + } + + // ── action-depth gate (A10: 0x45, GetNumActions >= 6) ────────────────── + + [Fact] + public void DoMotion_ActionClassMotion_DepthBelowSix_Allowed() + { + var interp = MakeInterp(); + for (int i = 0; i < 5; i++) + interp.InterpretedState.AddAction(0x10000050u, 1f, (uint)i, false); + + uint actionMotion = 0x10000060u; // action-class bit set, not itself a jump-charge id + var result = interp.DoMotion(actionMotion, new MovementParameters()); + + Assert.NotEqual(WeenieError.ActionDepthExceeded, result); + } + + [Fact] + public void DoMotion_ActionClassMotion_DepthExactlySix_Rejected() + { + var interp = MakeInterp(); + for (int i = 0; i < 6; i++) + interp.InterpretedState.AddAction(0x10000050u, 1f, (uint)i, false); + + uint actionMotion = 0x10000060u; + var result = interp.DoMotion(actionMotion, new MovementParameters()); + + Assert.Equal(WeenieError.ActionDepthExceeded, result); + } + + [Fact] + public void DoMotion_ActionClassMotion_DepthFive_NotRejected() + { + var interp = MakeInterp(); + for (int i = 0; i < 5; i++) + interp.InterpretedState.AddAction(0x10000050u, 1f, (uint)i, false); + + uint actionMotion = 0x10000060u; + var result = interp.DoMotion(actionMotion, new MovementParameters()); + + Assert.NotEqual(WeenieError.ActionDepthExceeded, result); + } + + [Fact] + public void DoMotion_NonActionClassMotion_IgnoresDepthCap() + { + // Bit 0x10000000 clear -> the depth cap never applies, even with 6+ + // queued actions. + var interp = MakeInterp(); + for (int i = 0; i < 10; i++) + interp.InterpretedState.AddAction(0x10000050u, 1f, (uint)i, false); + + var result = interp.DoMotion(MotionCommand.WalkForward, new MovementParameters()); + + Assert.NotEqual(WeenieError.ActionDepthExceeded, result); + } + + // ── raw mirror discipline: raw gets ORIGINAL id, interpreted gets ADJUSTED ── + + [Fact] + public void DoMotion_ModifyRawStateBit_MirrorsOriginalId_NotAdjusted() + { + // WalkBackward (ORIGINAL) adjusts to WalkForward w/ negated speed + // (interpreted) but RawState.ApplyMotion must be called with the + // ORIGINAL WalkBackward id (ebp), not the adjusted WalkForward id. + var interp = MakeInterp(); + var p = new MovementParameters { ModifyRawState = true, Speed = 1.0f }; + + interp.DoMotion(MotionCommand.WalkBackward, p); + + Assert.Equal(MotionCommand.WalkBackward, interp.RawState.ForwardCommand); + // Interpreted state, meanwhile, adopted the ADJUSTED (WalkForward) id. + Assert.Equal(MotionCommand.WalkForward, interp.InterpretedState.ForwardCommand); + } + + [Fact] + public void DoMotion_ModifyRawStateBitClear_DoesNotMirror() + { + var interp = MakeInterp(); + var p = new MovementParameters { ModifyRawState = false }; + + interp.DoMotion(MotionCommand.WalkForward, p); + + // RawState.ForwardCommand must remain at its ctor default (Ready) — + // no mirror happened. + Assert.Equal(MotionCommand.Ready, interp.RawState.ForwardCommand); + } + + [Fact] + public void DoMotion_FailedDispatch_DoesNotMirrorToRawState() + { + // result == 0 is required for the mirror per @306184 ("if (result == + // 0 && bit0x2000)"). A combat-stance rejection must not mirror. + var interp = MakeInterp(); + interp.InterpretedState.CurrentStyle = 0x80000001u; + var p = new MovementParameters { ModifyRawState = true }; + + var result = interp.DoMotion(MotionCommand.Crouch, p); + + Assert.Equal(WeenieError.CrouchInCombatStance, result); + Assert.Equal(MotionCommand.Ready, interp.RawState.ForwardCommand); // untouched + } + + [Fact] + public void DoMotion_2Arg_AppOverload_StillCompiles_AndDispatches() + { + // App-facing compat overload: DoMotion(uint, float speed = 1.0f). + var interp = MakeInterp(); + + var result = interp.DoMotion(MotionCommand.WalkForward, 0.8f); + + Assert.Equal(WeenieError.None, result); + Assert.Equal(MotionCommand.WalkForward, interp.InterpretedState.ForwardCommand); + } + + // ========================================================================= + // StopMotion — 0x00528530 @305674 (mirror shape, no gates) + // ========================================================================= + + [Fact] + public void StopMotion_NullPhysicsObj_Returns8() + { + var interp = new MotionInterpreter(); + + var result = interp.StopMotion(MotionCommand.WalkForward, new MovementParameters()); + + Assert.Equal(WeenieError.NoPhysicsObject, result); + } + + [Fact] + public void StopMotion_NoCombatStanceGate_CrouchStopsEvenInCombatStance() + { + // Unlike DoMotion, StopMotion has NO combat-stance/depth gating. + var interp = MakeInterp(); + interp.InterpretedState.CurrentStyle = 0x80000001u; + interp.InterpretedState.ForwardCommand = MotionCommand.Crouch; + + var result = interp.StopMotion(MotionCommand.Crouch, new MovementParameters()); + + Assert.Equal(WeenieError.None, result); + } + + [Fact] + public void StopMotion_ModifyRawStateBit_RemovesOriginalId_NotAdjusted() + { + var interp = MakeInterp(); + interp.RawState.ForwardCommand = MotionCommand.WalkBackward; + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + var p = new MovementParameters { ModifyRawState = true }; + + interp.StopMotion(MotionCommand.WalkBackward, p); + + // RemoveMotion(ORIGINAL WalkBackward) hits RawState.ForwardCommand + // via the forward-class branch (adjusted WalkForward would also + // match here in this simple case, but the ORIGINAL id is what must + // be passed — see the mismatch test below for a case that + // distinguishes them). + Assert.Equal(MotionCommand.Ready, interp.RawState.ForwardCommand); + } + + [Fact] + public void StopMotion_ModifyRawStateBitClear_DoesNotMirror() + { + var interp = MakeInterp(); + interp.RawState.ForwardCommand = MotionCommand.WalkForward; + var p = new MovementParameters { ModifyRawState = false }; + + interp.StopMotion(MotionCommand.WalkForward, p); + + Assert.Equal(MotionCommand.WalkForward, interp.RawState.ForwardCommand); // untouched + } + + [Fact] + public void StopMotion_2Arg_AppOverload_StillCompiles() + { + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + + var result = interp.StopMotion(MotionCommand.WalkForward); + + Assert.Equal(WeenieError.None, result); + Assert.Equal(MotionCommand.Ready, interp.InterpretedState.ForwardCommand); + } + + // ========================================================================= + // StopCompletely — 0x00527e40 @305208 (A9 verbatim quirk) + // ========================================================================= + + [Fact] + public void StopCompletely_NullPhysicsObj_Returns8() + { + var interp = new MotionInterpreter(); + + var result = interp.StopCompletely(); + + Assert.Equal(WeenieError.NoPhysicsObject, result); + } + + [Fact] + public void StopCompletely_ZeroesForwardSidestepTurnCommands_OnBothStates() + { + var interp = MakeInterp(); + interp.RawState.ForwardCommand = MotionCommand.RunForward; + interp.RawState.SidestepCommand = MotionCommand.SideStepRight; + interp.RawState.TurnCommand = MotionCommand.TurnRight; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.SideStepCommand = MotionCommand.SideStepRight; + interp.InterpretedState.TurnCommand = MotionCommand.TurnRight; + + interp.StopCompletely(); + + Assert.Equal(MotionCommand.Ready, interp.RawState.ForwardCommand); + Assert.Equal(1.0f, interp.RawState.ForwardSpeed); + Assert.Equal(0u, interp.RawState.SidestepCommand); + Assert.Equal(0u, interp.RawState.TurnCommand); + Assert.Equal(MotionCommand.Ready, interp.InterpretedState.ForwardCommand); + Assert.Equal(1.0f, interp.InterpretedState.ForwardSpeed); + Assert.Equal(0u, interp.InterpretedState.SideStepCommand); + Assert.Equal(0u, interp.InterpretedState.TurnCommand); + } + + [Fact] + public void StopCompletely_DoesNotTouchSidestepOrTurnSpeeds_J9() + { + // A9/J9: retail touches ONLY forward cmd/speed + sidestep/turn + // COMMANDS — it does NOT write sidestep_speed or turn_speed. The + // pre-R3 acdream divergence (1.0 speed resets) must be gone. + var interp = MakeInterp(); + interp.RawState.SidestepSpeed = 2.5f; + interp.RawState.TurnSpeed = 3.5f; + interp.InterpretedState.SideStepSpeed = 4.5f; + interp.InterpretedState.TurnSpeed = 5.5f; + + interp.StopCompletely(); + + Assert.Equal(2.5f, interp.RawState.SidestepSpeed); + Assert.Equal(3.5f, interp.RawState.TurnSpeed); + Assert.Equal(4.5f, interp.InterpretedState.SideStepSpeed); + Assert.Equal(5.5f, interp.InterpretedState.TurnSpeed); + } + + [Fact] + public void StopCompletely_ZerosPhysicsBodyVelocity() + { + var body = MakeGrounded(); + body.set_velocity(new Vector3(5f, 3f, 0f)); + var interp = MakeInterp(body); + + interp.StopCompletely(); + + Assert.Equal(Vector3.Zero, body.Velocity); + } + + [Fact] + public void StopCompletely_InterruptsCurrentMovement() + { + var interp = MakeInterp(); + bool fired = false; + interp.InterruptCurrentMovement = () => fired = true; + + interp.StopCompletely(); + + Assert.True(fired); + } + + [Fact] + public void StopCompletely_QueuedNodeErrorCode_ReflectsPreStopForwardCommand() + { + // A9 golden: motion_allows_jump is evaluated on the OLD (pre-stop) + // interpreted forward_command, snapshotted BEFORE the overwrite, and + // that snapshot becomes the queued node's jump_error_code. Crouch + // (0x41000012) is in the motion_allows_jump BLOCKED range -> 0x48. + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.Crouch; + + interp.StopCompletely(); + + var node = Assert.Single(interp.PendingMotions); + Assert.Equal(0u, node.ContextId); + Assert.Equal(MotionCommand.Ready, node.Motion); + Assert.Equal((uint)WeenieError.YouCantJumpFromThisPosition, node.JumpErrorCode); + } + + [Fact] + public void StopCompletely_QueuedNodeErrorCode_ZeroWhenPreStopCommandAllowsJump() + { + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.Ready; // passes motion_allows_jump + + interp.StopCompletely(); + + var node = Assert.Single(interp.PendingMotions); + Assert.Equal(0u, node.JumpErrorCode); + } + + [Fact] + public void StopCompletely_CellNull_FiresRemoveLinkAnimations() + { + // CurCell proxy: PhysicsObj.CellPosition.ObjCellId == 0 (default/unseeded). + var interp = MakeInterp(); + bool fired = false; + interp.RemoveLinkAnimations = () => fired = true; + + interp.StopCompletely(); + + Assert.True(fired, "physics_obj->cell == 0 must fire RemoveLinkAnimations"); + } + + [Fact] + public void StopCompletely_CellNonNull_DoesNotFireRemoveLinkAnimations() + { + var body = MakeGrounded(); + body.SnapToCell(0x12340001u, Vector3.Zero, Vector3.Zero); + var interp = MakeInterp(body); + bool fired = false; + interp.RemoveLinkAnimations = () => fired = true; + + interp.StopCompletely(); + + Assert.False(fired); + } + + [Fact] + public void StopCompletely_AlwaysReturnsNone_OnceCallExecutes() + { + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.Crouch; // would fail motion_allows_jump + + var result = interp.StopCompletely(); + + Assert.Equal(WeenieError.None, result); // StopCompletely itself always succeeds + } + + // ========================================================================= + // StandingLongJump state-only branch: Walk/Run/SideStepRight while + // charging -> state write, NO dispatch, NO queue node. + // ========================================================================= + + private sealed class RecordingSink : IInterpretedMotionSink + { + public readonly List Calls = new(); + public bool ApplyMotion(uint motion, float speed) + { + Calls.Add($"APPLY {motion:x8}@{speed:F2}"); + return true; + } + public bool StopMotion(uint motion) + { + Calls.Add($"STOP {motion:x8}"); + return true; + } + } + + [Fact] + public void DoInterpretedMotion_StandingLongJumpCharging_WalkForward_StateOnly_NoDispatch_NoQueue() + { + var interp = MakeInterp(); + interp.StandingLongJump = true; + interp.DefaultSink = null; // no App-level sink wired directly on DoInterpretedMotion path + + var before = interp.PendingMotions.Count(); + var result = interp.DoInterpretedMotion(MotionCommand.WalkForward, new MovementParameters()); + + Assert.Equal(WeenieError.None, result); + Assert.Equal(MotionCommand.WalkForward, interp.InterpretedState.ForwardCommand); + Assert.Equal(before, interp.PendingMotions.Count()); + } + + [Fact] + public void DoInterpretedMotion_StandingLongJumpCharging_RunForward_StateOnly_NoDispatch_NoQueue() + { + var interp = MakeInterp(); + interp.StandingLongJump = true; + + var before = interp.PendingMotions.Count(); + var result = interp.DoInterpretedMotion(MotionCommand.RunForward, new MovementParameters()); + + Assert.Equal(WeenieError.None, result); + Assert.Equal(MotionCommand.RunForward, interp.InterpretedState.ForwardCommand); + Assert.Equal(before, interp.PendingMotions.Count()); + } + + [Fact] + public void DoInterpretedMotion_StandingLongJumpCharging_SideStepRight_StateOnly_NoDispatch_NoQueue() + { + var interp = MakeInterp(); + interp.StandingLongJump = true; + + var before = interp.PendingMotions.Count(); + var result = interp.DoInterpretedMotion(MotionCommand.SideStepRight, new MovementParameters()); + + Assert.Equal(WeenieError.None, result); + Assert.Equal(MotionCommand.SideStepRight, interp.InterpretedState.SideStepCommand); + Assert.Equal(before, interp.PendingMotions.Count()); + } + + [Fact] + public void DoInterpretedMotion_StandingLongJumpCharging_OtherMotion_DispatchesNormally() + { + // Only Walk/Run/SideStepRight get the state-only shortcut while + // charging — everything else dispatches through the normal path + // (including queueing). + var interp = MakeInterp(); + interp.StandingLongJump = true; + + var result = interp.DoInterpretedMotion(MotionCommand.TurnRight, new MovementParameters()); + + Assert.Equal(WeenieError.None, result); + Assert.Single(interp.PendingMotions); + } + + [Fact] + public void DoInterpretedMotion_NotCharging_WalkForward_DispatchesNormally_AndQueues() + { + var interp = MakeInterp(); + interp.StandingLongJump = false; + + var result = interp.DoInterpretedMotion(MotionCommand.WalkForward, new MovementParameters()); + + Assert.Equal(WeenieError.None, result); + Assert.Single(interp.PendingMotions); + } + + // ========================================================================= + // DisableJumpDuringLink forces the queued node's jump_error_code to 0x48 + // ========================================================================= + + [Fact] + public void DoInterpretedMotion_DisableJumpDuringLink_ForcesQueuedNodeTo0x48() + { + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.Ready; // would otherwise PASS motion_allows_jump + var p = new MovementParameters { DisableJumpDuringLink = true }; + + interp.DoInterpretedMotion(MotionCommand.WalkForward, p); + + var node = Assert.Single(interp.PendingMotions); + Assert.Equal((uint)WeenieError.YouCantJumpFromThisPosition, node.JumpErrorCode); + } + + [Fact] + public void DoInterpretedMotion_DisableJumpDuringLinkClear_UsesComputedErrorCode() + { + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.Ready; + var p = new MovementParameters { DisableJumpDuringLink = false }; + + interp.DoInterpretedMotion(MotionCommand.WalkForward, p); + + var node = Assert.Single(interp.PendingMotions); + Assert.Equal(0u, node.JumpErrorCode); // WalkForward + Ready both pass motion_allows_jump + } + + // ── Dead -> RemoveLinkAnimations ─────────────────────────────────────── + + [Fact] + public void DoInterpretedMotion_Dead_FiresRemoveLinkAnimations() + { + var interp = MakeInterp(); + bool fired = false; + interp.RemoveLinkAnimations = () => fired = true; + + interp.DoInterpretedMotion(MotionCommand.Dead, new MovementParameters()); + + Assert.True(fired); + } + + // ── ModifyInterpretedState param gates the state write ───────────────── + + [Fact] + public void DoInterpretedMotion_ModifyInterpretedStateClear_DoesNotWriteState() + { + var interp = MakeInterp(); + var p = new MovementParameters { ModifyInterpretedState = false }; + + interp.DoInterpretedMotion(MotionCommand.WalkForward, p); + + Assert.Equal(MotionCommand.Ready, interp.InterpretedState.ForwardCommand); // untouched + } + + [Fact] + public void DoInterpretedMotion_ModifyInterpretedStateSet_WritesState() + { + var interp = MakeInterp(); + var p = new MovementParameters { ModifyInterpretedState = true, Speed = 1.5f }; + + interp.DoInterpretedMotion(MotionCommand.WalkForward, p); + + Assert.Equal(MotionCommand.WalkForward, interp.InterpretedState.ForwardCommand); + } + + // ── CurCell-null tail (proxy: CellPosition.ObjCellId == 0) ────────────── + // NOTE: this is the DoInterpretedMotion success-path CurCell check per + // the plan; the merged function fires RemoveLinkAnimations whenever the + // physics_obj has no cell, mirroring StopCompletely's identical tail. + + [Fact] + public void DoInterpretedMotion_ContactBlocked_ActionClass_Returns0x24() + { + var body = new PhysicsBody { State = PhysicsStateFlags.Gravity }; // airborne, no contact + var interp = MakeInterp(body); + + var result = interp.DoInterpretedMotion(0x10000060u, new MovementParameters()); + + Assert.Equal(WeenieError.NotGrounded, result); + } + + // ========================================================================= + // StopInterpretedMotion — merged verbatim pair + // ========================================================================= + + [Fact] + public void StopInterpretedMotion_NullPhysicsObj_Returns8() + { + var interp = new MotionInterpreter(); + + var result = interp.StopInterpretedMotion(MotionCommand.WalkForward, new MovementParameters()); + + Assert.Equal(WeenieError.NoPhysicsObject, result); + } + + [Fact] + public void StopInterpretedMotion_Success_EnqueuesReturnToNoneNode() + { + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + var p = new MovementParameters { ContextId = 42 }; + + interp.StopInterpretedMotion(MotionCommand.WalkForward, p); + + var node = Assert.Single(interp.PendingMotions); + Assert.Equal(42u, node.ContextId); + Assert.Equal(MotionCommand.Ready, node.Motion); + } + + [Fact] + public void StopInterpretedMotion_ModifyInterpretedStateClear_DoesNotWriteState() + { + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + var p = new MovementParameters { ModifyInterpretedState = false }; + + interp.StopInterpretedMotion(MotionCommand.WalkForward, p); + + Assert.Equal(MotionCommand.WalkForward, interp.InterpretedState.ForwardCommand); // untouched + } + + // ========================================================================= + // PerformMovement — zero-tick CheckForCompletedMotions flush (closes J14) + // ========================================================================= + + [Fact] + public void PerformMovement_RawCommand_FiresCheckForCompletedMotions() + { + var interp = MakeInterp(); + int flushCount = 0; + interp.CheckForCompletedMotions = () => flushCount++; + + interp.PerformMovement(new MovementStruct + { + Type = MovementType.RawCommand, + Motion = MotionCommand.WalkForward, + Speed = 1.0f, + }); + + Assert.Equal(1, flushCount); + } + + [Theory] + [InlineData(MovementType.RawCommand)] + [InlineData(MovementType.InterpretedCommand)] + [InlineData(MovementType.StopRawCommand)] + [InlineData(MovementType.StopInterpretedCommand)] + [InlineData(MovementType.StopCompletely)] + public void PerformMovement_EveryDispatchedOp_FiresFlushExactlyOnce(MovementType type) + { + var interp = MakeInterp(); + int flushCount = 0; + interp.CheckForCompletedMotions = () => flushCount++; + + interp.PerformMovement(new MovementStruct + { + Type = type, + Motion = MotionCommand.WalkForward, + Speed = 1.0f, + }); + + Assert.Equal(1, flushCount); + } + + [Fact] + public void PerformMovement_InvalidType_DoesNotFireFlush() + { + // The type-dispatch failure (0x47, bad MovementStruct.type) happens + // BEFORE any op is dispatched — no flush should fire for it. + var interp = MakeInterp(); + int flushCount = 0; + interp.CheckForCompletedMotions = () => flushCount++; + + var result = interp.PerformMovement(new MovementStruct { Type = (MovementType)99 }); + + Assert.Equal(WeenieError.GeneralMovementFailure, result); + Assert.Equal(0, flushCount); + } + + [Fact] + public void PerformMovement_FlushSeamUnset_DoesNotThrow() + { + var interp = MakeInterp(); + interp.CheckForCompletedMotions = null; + + var result = interp.PerformMovement(new MovementStruct + { + Type = MovementType.StopCompletely, + }); + + Assert.Equal(WeenieError.None, result); + } + + [Fact] + public void PerformMovement_StopCompletely_ResetsToReady_AndFlushes() + { + var interp = MakeInterp(); + interp.RawState.ForwardCommand = MotionCommand.WalkForward; + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + int flushCount = 0; + interp.CheckForCompletedMotions = () => flushCount++; + + interp.PerformMovement(new MovementStruct { Type = MovementType.StopCompletely }); + + Assert.Equal(MotionCommand.Ready, interp.RawState.ForwardCommand); + Assert.Equal(MotionCommand.Ready, interp.InterpretedState.ForwardCommand); + Assert.Equal(1, flushCount); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/MotionInterpreterFunnelTests.cs b/tests/AcDream.Core.Tests/Physics/MotionInterpreterFunnelTests.cs new file mode 100644 index 00000000..7c3cb617 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/MotionInterpreterFunnelTests.cs @@ -0,0 +1,377 @@ +using System.Collections.Generic; +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// L.2g S2 — the inbound CMotionInterp funnel (deviation DEV-1). +/// +/// Oracle: docs/research/2026-07-02-s2-inbound-funnel-pseudocode.md +/// (decomp: move_to_interpreted_state 0x005289c0 @305936, +/// apply_interpreted_movement 0x00528600 @305713) — validated against the +/// LIVE retail-observer cdb trace (l2g-observer-trace.log), which showed the +/// per-UM dispatch order verbatim: style → forward → sidestep(-stop) → +/// turn(-stop). +/// +public class MotionInterpreterFunnelTests +{ + private sealed class RecordingSink : IInterpretedMotionSink + { + public readonly List Calls = new(); + public bool ApplyMotion(uint motion, float speed) + { + Calls.Add($"DIM {motion:x8}@{speed:F2}"); + // R3-W5: a style/stance id (>= 0x80000000, i.e. negative as + // int32) has no locomotion MotionData entry in the dat — retail's + // real CMotionTable::DoObjectMotion genuinely fails for it + // (MotionTableManagerError.MotionFailed). The fake sink mirrors + // that so InterpretedMotionState.ForwardCommand isn't clobbered + // by ApplyMotion's negative-motion branch before the very next + // dispatch reads it — matches the live retail-observer trace. + return motion < 0x80000000u; + } + public bool StopMotion(uint motion) + { + Calls.Add($"STOP {motion:x8}"); + return true; + } + } + + private static MotionInterpreter GroundedInterp() + { + var body = new PhysicsBody(); + body.State |= PhysicsStateFlags.Gravity; + body.TransientState |= TransientStateFlags.Contact + | TransientStateFlags.OnWalkable + | TransientStateFlags.Active; + return new MotionInterpreter(body); + } + + private static InboundInterpretedState Ims( + uint style = 0x8000003Du, + uint fwd = 0x41000003u, float fwdSpd = 1.0f, + uint side = 0u, float sideSpd = 1.0f, + uint turn = 0u, float turnSpd = 1.0f, + IReadOnlyList? actions = null) + => new() + { + CurrentStyle = style, + ForwardCommand = fwd, ForwardSpeed = fwdSpd, + SideStepCommand = side, SideStepSpeed = sideSpd, + TurnCommand = turn, TurnSpeed = turnSpd, + Actions = actions, + }; + + [Fact] + public void EmptyUm_DispatchesStyleThenReadyThenStops_RetailOrder() + { + // The flags=0 "empty" UM: all defaults → a wholesale stop. Live-trace + // golden (actor minterp 18e8b0f8): DIM style, DIM Ready, then the + // sidestep + turn stop notifications. + var mi = GroundedInterp(); + var sink = new RecordingSink(); + + mi.MoveToInterpretedState(Ims(), sink); + + Assert.Equal(new[] + { + "DIM 8000003d@1.00", + "DIM 41000003@1.00", + "STOP 6500000f", + "STOP 6500000d", + }, sink.Calls); + Assert.Equal(0x41000003u, mi.InterpretedState.ForwardCommand); + Assert.Equal(1.0f, mi.InterpretedState.ForwardSpeed); + } + + [Fact] + public void RunUm_DispatchesRunAtWireSpeed_AndCachesMyRunRate() + { + // fwd=RunForward@2.85 — apply_interpreted_movement caches + // my_run_rate from forward_speed BEFORE dispatching (305718). + var mi = GroundedInterp(); + var sink = new RecordingSink(); + + mi.MoveToInterpretedState(Ims(fwd: 0x44000007u, fwdSpd: 2.85f), sink); + + Assert.Equal(new[] + { + "DIM 8000003d@1.00", + "DIM 44000007@2.85", + "STOP 6500000f", + "STOP 6500000d", + }, sink.Calls); + Assert.Equal(2.85f, mi.MyRunRate); + Assert.Equal(0x44000007u, mi.InterpretedState.ForwardCommand); + Assert.Equal(2.85f, mi.InterpretedState.ForwardSpeed); + } + + [Fact] + public void WalkUm_DoesNotTouchMyRunRate() + { + var mi = GroundedInterp(); + mi.MyRunRate = 2.5f; + + mi.MoveToInterpretedState(Ims(fwd: 0x45000005u), new RecordingSink()); + + Assert.Equal(2.5f, mi.MyRunRate); // only RunForward caches + } + + [Fact] + public void RunPlusTurnUm_TurnDispatched_NoTurnStop_NoIdleEnqueue() + { + // turn_command != 0 → DIM(turn) then EARLY RETURN — no turn-stop, + // no idle bookkeeping (305711-305713 early return). + var mi = GroundedInterp(); + var sink = new RecordingSink(); + + mi.MoveToInterpretedState( + Ims(fwd: 0x44000007u, fwdSpd: 2.85f, turn: 0x6500000Du, turnSpd: 1.5f), sink); + + Assert.Equal(new[] + { + "DIM 8000003d@1.00", + "DIM 44000007@2.85", + "STOP 6500000f", + "DIM 6500000d@1.50", + }, sink.Calls); + } + + [Fact] + public void SidestepUm_DispatchedInsteadOfSidestepStop() + { + var mi = GroundedInterp(); + var sink = new RecordingSink(); + + mi.MoveToInterpretedState(Ims(side: 0x6500000Fu, sideSpd: -1.2f), sink); + + Assert.Equal(new[] + { + "DIM 8000003d@1.00", + "DIM 41000003@1.00", + "DIM 6500000f@-1.20", + "STOP 6500000d", + }, sink.Calls); + } + + [Fact] + public void AirborneBody_NoCycleDispatches_OnlyTurnStop() + { + // Airborne (gravity on, no Contact): apply_interpreted_movement + // substitutes DIM(Falling 0x40000015) for the forward block + // (305723-305727), but DoInterpretedMotion's OWN contact gate + // (0x00528360) then takes the apply-only path for style + Falling — + // GetObjectSequence never fires. This is retail's real mechanism + // behind the K-fix17 "preserve the Falling cycle while airborne" + // empirical guard: airborne remotes simply don't re-cycle from UMs. + // Only the unconditional turn-stop notification comes through. + var body = new PhysicsBody(); // no Contact flag + body.State |= PhysicsStateFlags.Gravity; + var mi = new MotionInterpreter(body); + var sink = new RecordingSink(); + + mi.MoveToInterpretedState(Ims(fwd: 0x44000007u, fwdSpd: 2.85f), sink); + + // Falling (0x40000015) is ALWAYS allowed by contact_allows_move + // (0x00528240 early-accept), so it reaches the sink; the style and + // forward dispatches are gate-blocked (apply-only path). + Assert.Equal(new[] { "DIM 40000015@1.00", "STOP 6500000d" }, sink.Calls); + // #161 correction (2026-07-03): the apply pass runs its dispatches + // with ModifyInterpretedState = FALSE — retail constructs var_2c + // then CLEARS bits 11/14/15 (SetHoldKey / ModifyInterpretedState / + // CancelMoveTo) and re-sets 15/17 from the args; the BN pseudo-C + // smears that bitfield store into the mush expression at raw + // 305778 (`(word & 0x37ff) | (arg2&1)<<15 | (arg3&1)<<17`). ACE + // MotionInterp.cs:444-449 confirms independently. So NEITHER the + // blocked style dispatch NOR the Falling substitution writes + // InterpretedState — the wire's forward command survives the + // airborne pass. This is the retail landing-exit mechanism: + // HitGround's re-apply dispatches the PRESERVED command, and the + // motion table plays the Falling→X landing link. (The previous + // revision of this assertion pinned 0x40000015 — the #161 bug + // itself: the ctor-default params let the Falling dispatch clobber + // forward_command, so a stand-still landing re-dispatched Falling + // forever.) + Assert.Equal(0x44000007u, mi.InterpretedState.ForwardCommand); + Assert.Equal(2.85f, mi.InterpretedState.ForwardSpeed); + } + + [Fact] + public void HitGround_AfterFall_RedispatchesPreservedForward_ExitsFalling() + { + // #161 (remote jump landing stuck in the falling pose): the full + // remote lifecycle. Wire says RunForward@2.85 while grounded; the + // body leaves the ground (LeaveGround engages Falling through the + // sink WITHOUT clobbering the interpreted forward command — the + // apply pass's ModifyInterpretedState=false, raw 305778 / ACE + // MotionInterp.cs:447); on touchdown, HitGround (0x00528ac0) — + // called with GRAVITY STILL SET, its verbatim state&0x400 gate — + // re-applies the PRESERVED command, which is what makes + // GetObjectSequence play the Falling→RunForward landing link. No + // wire input is needed to exit the falling pose. + var body = new PhysicsBody(); + body.State |= PhysicsStateFlags.Gravity; + body.TransientState |= TransientStateFlags.Contact + | TransientStateFlags.OnWalkable + | TransientStateFlags.Active; + var mi = new MotionInterpreter(body, new RemoteWeenie()); + var sink = new RecordingSink(); + mi.DefaultSink = sink; // HitGround/LeaveGround re-apply through DefaultSink + + mi.MoveToInterpretedState(Ims(fwd: 0x44000007u, fwdSpd: 2.85f), sink); + Assert.Equal(0x44000007u, mi.InterpretedState.ForwardCommand); + + // Jump start: ground contact drops FIRST (GameWindow's VectorUpdate + // handler order), then LeaveGround re-applies → Falling engages. + body.TransientState &= ~(TransientStateFlags.Contact + | TransientStateFlags.OnWalkable); + sink.Calls.Clear(); + mi.LeaveGround(); + + Assert.Contains(sink.Calls, c => c.StartsWith("DIM 40000015")); + Assert.Equal(0x44000007u, mi.InterpretedState.ForwardCommand); // NOT clobbered + Assert.Equal(2.85f, mi.InterpretedState.ForwardSpeed); + + // Touchdown: contact restored, Gravity still set (the retail + // contract — CMotionInterp::HitGround no-ops without it). + body.TransientState |= TransientStateFlags.Contact + | TransientStateFlags.OnWalkable; + sink.Calls.Clear(); + mi.HitGround(); + + // Retail re-apply order: style (from the copy_movement_from-adopted + // interpreted current_style, raw 0051e757) → preserved forward → + // sidestep-stop → turn-stop. The forward dispatch at the wire + // command IS the falling-pose exit. + Assert.Equal(new[] + { + "DIM 8000003d@1.00", + "DIM 44000007@2.85", + "STOP 6500000f", + "STOP 6500000d", + }, sink.Calls); + } + + [Fact] + public void FlatCopy_OverwritesEveryAxis() + { + // copy_movement_from (0x0051e750) is a FLAT overwrite — a fresh UM + // with defaults clears a previously-set sidestep/turn. + var mi = GroundedInterp(); + mi.MoveToInterpretedState( + Ims(fwd: 0x44000007u, fwdSpd: 2.85f, side: 0x6500000Fu, turn: 0x6500000Du), + new RecordingSink()); + + mi.MoveToInterpretedState(Ims(), new RecordingSink()); + + Assert.Equal(0x41000003u, mi.InterpretedState.ForwardCommand); + Assert.Equal(0u, mi.InterpretedState.SideStepCommand); + Assert.Equal(0u, mi.InterpretedState.TurnCommand); + } + + [Fact] + public void RawStateStyle_AdoptedFromIms() + { + // move_to_interpreted_state head: raw_state.current_style = + // ims.current_style (305944). + var mi = GroundedInterp(); + mi.MoveToInterpretedState(Ims(style: 0x8000003Cu), new RecordingSink()); + Assert.Equal(0x8000003Cu, mi.RawState.CurrentStyle); + } + + // ── action list: 15-bit server_action_stamp gate (305953-305989) ────── + + [Fact] + public void Actions_FreshStamp_DispatchedAfterMovement_AndStampAdopted() + { + var mi = GroundedInterp(); + var sink = new RecordingSink(); + var actions = new[] { new InboundMotionAction(0x10000062u, Stamp: 5, Autonomous: false, Speed: 1.25f) }; + + mi.MoveToInterpretedState(Ims(actions: actions), sink); + + Assert.Equal("DIM 10000062@1.25", sink.Calls[^1]); // after the movement dispatches + Assert.Equal(5, mi.ServerActionStamp); + } + + [Fact] + public void Actions_StaleStamp_Skipped() + { + var mi = GroundedInterp(); + mi.ServerActionStamp = 10; + var sink = new RecordingSink(); + + mi.MoveToInterpretedState( + Ims(actions: new[] { new InboundMotionAction(0x10000062u, 9, false, 1f) }), sink); + + Assert.DoesNotContain(sink.Calls, c => c.StartsWith("DIM 10000062")); + Assert.Equal(10, mi.ServerActionStamp); + } + + [Fact] + public void Actions_StampWrapsAt15Bits() + { + // The compare is 15-bit wraparound (mask 0x7fff, threshold 0x3fff). + var mi = GroundedInterp(); + mi.ServerActionStamp = 0x7FFE; + var sink = new RecordingSink(); + + mi.MoveToInterpretedState( + Ims(actions: new[] { new InboundMotionAction(0x10000062u, 2, false, 1f) }), sink); + + Assert.Contains(sink.Calls, c => c.StartsWith("DIM 10000062")); // 2 is newer than 0x7ffe + Assert.Equal(2, mi.ServerActionStamp); + } + + [Fact] + public void Actions_AutonomousOnLocalPlayer_Skipped() + { + // Retail skips autonomous action replay on the LOCAL player (its own + // echo); remotes always apply (305977-305987). + var body = new PhysicsBody(); + body.TransientState |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable; + var mi = new MotionInterpreter(body) { IsLocalPlayer = true }; + var sink = new RecordingSink(); + + mi.MoveToInterpretedState( + Ims(actions: new[] { new InboundMotionAction(0x10000062u, 5, Autonomous: true, 1f) }), sink); + + Assert.DoesNotContain(sink.Calls, c => c.StartsWith("DIM 10000062")); + } + + [Fact] + public void Actions_ReplayCarriesAutonomyIntoTheInterpretedList() + { + // R5-V4 (#164): retail splices the ACTION's autonomy into the + // dispatch params (bit 0x1000 — raw 305982: + // `var_28 ^= ((action.autonomous << 0xc) ^ var_28) & 0x1000`), so a + // replayed action enters the interpreted actions list + // (InterpretedMotionState::AddAction consumes p.Autonomous) with its + // REAL autonomy. Pre-V4 the replay params were ctor-default → + // Autonomous always false. + var mi = GroundedInterp(); // remote posture: IsLocalPlayer = false + var sink = new RecordingSink(); + + mi.MoveToInterpretedState( + Ims(actions: new[] { new InboundMotionAction(0x10000062u, 5, Autonomous: true, 1f) }), sink); + + var entry = Assert.Single(mi.InterpretedState.Actions, a => a.Command == 0x0062); + Assert.True(entry.Autonomous); + } + + [Fact] + public void InboundState_Defaults_MatchRetailUnPack() + { + // InterpretedMotionState::UnPack absent-field defaults (0x0051f400): + // style NonCombat, fwd Ready, speeds 1.0, side/turn 0. + var d = InboundInterpretedState.Default(); + Assert.Equal(0x8000003Du, d.CurrentStyle); + Assert.Equal(0x41000003u, d.ForwardCommand); + Assert.Equal(1.0f, d.ForwardSpeed); + Assert.Equal(0u, d.SideStepCommand); + Assert.Equal(1.0f, d.SideStepSpeed); + Assert.Equal(0u, d.TurnCommand); + Assert.Equal(1.0f, d.TurnSpeed); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/MotionInterpreterGroundLifecycleTests.cs b/tests/AcDream.Core.Tests/Physics/MotionInterpreterGroundLifecycleTests.cs new file mode 100644 index 00000000..3836fed0 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/MotionInterpreterGroundLifecycleTests.cs @@ -0,0 +1,784 @@ +using System.Linq; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +// ───────────────────────────────────────────────────────────────────────────── +// MotionInterpreterGroundLifecycleTests — R3-W4 (closes J8, J10, J11-shape, +// J12, J13; J18 one-liner rides along). +// +// Oracle: docs/research/2026-07-02-r3-motioninterp/r3-motioninterp-decomp.md +// §4 (HitGround 0x00528ac0 @305996, LeaveGround 0x00528b00 @306022, +// ReportExhaustion 0x005288d0 @305861, enter_default_state 0x00528c80 +// @306124) + §5c/5d (set_hold_run 0x00528b70 @306053, SetHoldKey 0x00528bb0 +// @306072) + raw acclient_2013_pseudo_c.txt:305838-305932 (apply_current_movement +// 0x00528870, SetWeenieObject 0x00528920, SetPhysicsObject 0x00528970) + +// W0-pins.md A3 (dual-dispatch gate) / A8 (enter_default_state no-clear). +// ───────────────────────────────────────────────────────────────────────────── + +/// Fake WeenieObject — IsThePlayer/IsCreature independently +/// configurable, for the A3 dispatch truth table. +file sealed class FakeWeenie : IWeenieObject +{ + public bool IsThePlayerResult; + public bool IsCreatureResult = true; + + public bool InqJumpVelocity(float extent, out float vz) { vz = 10f; return true; } + public bool InqRunRate(out float rate) { rate = 1f; return true; } + public bool CanJump(float extent) => true; + public bool IsThePlayer() => IsThePlayerResult; + public bool IsCreature() => IsCreatureResult; +} + +public sealed class MotionInterpreterGroundLifecycleTests +{ + // ── helpers ─────────────────────────────────────────────────────────────── + + private static PhysicsBody MakeGrounded() + { + var body = new PhysicsBody + { + State = PhysicsStateFlags.Gravity | PhysicsStateFlags.ReportCollisions, + }; + body.TransientState = TransientStateFlags.Contact + | TransientStateFlags.OnWalkable + | TransientStateFlags.Active; + return body; + } + + private static PhysicsBody MakeAirborne() + { + var body = new PhysicsBody + { + State = PhysicsStateFlags.Gravity | PhysicsStateFlags.ReportCollisions, + }; + body.TransientState = TransientStateFlags.Active; + return body; + } + + private static MotionInterpreter MakeInterp(PhysicsBody? body = null, IWeenieObject? weenie = null) + { + body ??= MakeGrounded(); + return new MotionInterpreter(body, weenie); + } + + // ========================================================================= + // HitGround — 0x00528ac0 @305996 + // ========================================================================= + + [Fact] + public void HitGround_NoPhysicsObj_NoOp() + { + var interp = new MotionInterpreter(); + bool called = false; + interp.RemoveLinkAnimations = () => called = true; + + interp.HitGround(); + + Assert.False(called); + } + + [Fact] + public void HitGround_NonCreatureWeenie_NoOp() + { + // raw 305720-305724: (weenie_obj == 0 || eax_2 != 0) -- a WEENIE + // present whose IsCreature() returns false skips the whole body. + var weenie = new FakeWeenie { IsCreatureResult = false }; + var body = MakeGrounded(); + var interp = MakeInterp(body, weenie); + bool called = false; + interp.RemoveLinkAnimations = () => called = true; + + interp.HitGround(); + + Assert.False(called, "a non-creature weenie must skip HitGround's body entirely"); + } + + [Fact] + public void HitGround_NoWeenie_Proceeds() + { + // weenie_obj == 0 -> the OR short-circuits true, body proceeds. + var body = MakeGrounded(); + var interp = MakeInterp(body); + bool called = false; + interp.RemoveLinkAnimations = () => called = true; + + interp.HitGround(); + + Assert.True(called, "no weenie_obj must still proceed (weenie==0 half of the OR)"); + } + + [Fact] + public void HitGround_GravityFlagClear_NoOp() + { + // raw 305726-305730: state bit 0x400 (Gravity) gates the body. + var body = MakeGrounded(); + body.State &= ~PhysicsStateFlags.Gravity; + var interp = MakeInterp(body); + bool called = false; + interp.RemoveLinkAnimations = () => called = true; + + interp.HitGround(); + + Assert.False(called, "HitGround must no-op when the Gravity state flag is clear"); + } + + [Fact] + public void HitGround_CreatureWithGravity_CallsRemoveLinkAnimationsThenReapplies() + { + var weenie = new FakeWeenie { IsCreatureResult = true }; + var body = MakeGrounded(); + var interp = MakeInterp(body, weenie); + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + bool called = false; + interp.RemoveLinkAnimations = () => called = true; + + interp.HitGround(); + + Assert.True(called, "HitGround must call the RemoveLinkAnimations seam"); + // apply_current_movement(false, true) re-syncs velocity from the + // current interpreted state (grounded write, AP-75-adjacent). + Assert.True(body.Velocity.Length() > 0f, "HitGround must re-apply current movement"); + } + + // ========================================================================= + // LeaveGround — 0x00528b00 @306022 + // ========================================================================= + + [Fact] + public void LeaveGround_NoPhysicsObj_NoOp() + { + var interp = new MotionInterpreter(); + bool called = false; + interp.RemoveLinkAnimations = () => called = true; + + interp.LeaveGround(); + + Assert.False(called); + } + + [Fact] + public void LeaveGround_NonCreatureWeenie_NoOp() + { + var weenie = new FakeWeenie { IsCreatureResult = false }; + var body = MakeGrounded(); + var interp = MakeInterp(body, weenie); + interp.StandingLongJump = true; + interp.JumpExtent = 0.7f; + bool called = false; + interp.RemoveLinkAnimations = () => called = true; + + interp.LeaveGround(); + + Assert.False(called); + // Nothing in the body ran -- StandingLongJump/JumpExtent untouched. + Assert.True(interp.StandingLongJump); + Assert.Equal(0.7f, interp.JumpExtent); + } + + [Fact] + public void LeaveGround_GravityFlagClear_NoOp() + { + var body = MakeGrounded(); + body.State &= ~PhysicsStateFlags.Gravity; + var interp = MakeInterp(body); + interp.StandingLongJump = true; + bool called = false; + interp.RemoveLinkAnimations = () => called = true; + + interp.LeaveGround(); + + Assert.False(called); + Assert.True(interp.StandingLongJump); + } + + [Fact] + public void LeaveGround_CreatureWithGravity_SetsVelocityAndResetsJumpState() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.StandingLongJump = true; + interp.JumpExtent = 0.5f; + + interp.LeaveGround(); + + Assert.False(interp.StandingLongJump, "standing_longjump = 0 on leave-ground"); + Assert.Equal(0f, interp.JumpExtent, precision: 5); + } + + [Fact] + public void LeaveGround_CallsRemoveLinkAnimationsThenReapplies() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + bool called = false; + interp.RemoveLinkAnimations = () => called = true; + + interp.LeaveGround(); + + Assert.True(called, "LeaveGround must call the RemoveLinkAnimations seam"); + } + + [Fact] + public void LeaveGround_VelocityCarriesGetLeaveGroundVelocity_WithNonzeroJumpExtent() + { + // A6/A5: get_leave_ground_velocity composes get_state_velocity() + + // z=GetJumpVZ(). With JumpExtent set and a weenie present, the body + // local velocity written must match GetLeaveGroundVelocity()'s Z. + // + // Real call-site precondition: by the time LeaveGround fires, the + // body has ALREADY left the ground (jump() calls set_on_walkable(false) + // before LeaveGround runs; a ledge walk-off similarly clears OnWalkable + // via the physics resolver BEFORE this callback). With OnWalkable + // false, LeaveGround's own tail apply_current_movement(0,0) call + // takes the "airborne -- preserve integrated velocity" branch in the + // AP-77 adaptation (ApplyCurrentMovementInterpreted), so the Z this + // call just set is not immediately clobbered by a resync. + var weenie = new AcDream.Core.Physics.PlayerWeenie(); + var body = MakeGrounded(); + body.set_on_walkable(false); + var interp = MakeInterp(body, weenie); + interp.JumpExtent = 0.5f; + + var expected = interp.GetLeaveGroundVelocity(); + interp.LeaveGround(); + + // set_local_velocity transforms local->world via Orientation + // (Identity in these fixtures), so world == local here. + Assert.Equal(expected.Z, body.Velocity.Z, precision: 3); + } + + [Fact] + public void LeaveGround_SetLocalVelocity_UsesAutonomousFlag() + { + // raw 305763-305765: CPhysicsObj::set_local_velocity(&var_c, 1) -- + // the autonomous=1 arg. PhysicsBody.LastMoveWasAutonomous should + // reflect this after LeaveGround runs (movement_is_autonomous, A3's + // apply_current_movement dispatch reads this same flag). + var body = MakeGrounded(); + body.LastMoveWasAutonomous = false; + var interp = MakeInterp(body); + + interp.LeaveGround(); + + Assert.True(body.LastMoveWasAutonomous, "LeaveGround's set_local_velocity call carries autonomous=1"); + } + + // ========================================================================= + // enter_default_state — 0x00528c80 @306124 (A8: append sentinel, NO drain) + // ========================================================================= + + [Fact] + public void EnterDefaultState_AppendsReadySentinel_WithoutDrainingExistingNodes() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.AddToQueue(1, MotionCommand.RunForward, 0); + interp.AddToQueue(2, MotionCommand.WalkForward, 0x48); + + interp.EnterDefaultState(); + + var nodes = interp.PendingMotions.ToArray(); + Assert.Equal(3, nodes.Length); + Assert.Equal(new MotionNode(1, MotionCommand.RunForward, 0), nodes[0]); + Assert.Equal(new MotionNode(2, MotionCommand.WalkForward, 0x48), nodes[1]); + Assert.Equal(new MotionNode(0, MotionCommand.Ready, 0), nodes[2]); + } + + [Fact] + public void EnterDefaultState_SetsInitted() + { + var interp = new MotionInterpreter { PhysicsObj = MakeGrounded() }; + // Force Initted false to prove EnterDefaultState is what flips it + // (the ctor already defaults it true -- see the Initted-gating + // section below for why). + interp.Initted = false; + + interp.EnterDefaultState(); + + Assert.True(interp.Initted); + } + + [Fact] + public void EnterDefaultState_ResetsRawAndInterpretedStateToCtorDefaults() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.ForwardCommand = MotionCommand.RunForward; + interp.RawState.ForwardSpeed = 2.94f; + interp.RawState.CurrentHoldKey = HoldKey.Run; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.TurnCommand = MotionCommand.TurnRight; + + interp.EnterDefaultState(); + + Assert.Equal(MotionCommand.Ready, interp.RawState.ForwardCommand); + Assert.Equal(1.0f, interp.RawState.ForwardSpeed); + Assert.Equal(HoldKey.None, interp.RawState.CurrentHoldKey); + Assert.Equal(MotionCommand.Ready, interp.InterpretedState.ForwardCommand); + Assert.Equal(0u, interp.InterpretedState.TurnCommand); + } + + [Fact] + public void EnterDefaultState_CallsInitializeMotionTablesSeam() + { + var interp = MakeInterp(); + bool called = false; + interp.InitializeMotionTables = () => called = true; + + interp.EnterDefaultState(); + + Assert.True(called); + } + + [Fact] + public void EnterDefaultState_TailCallsLeaveGround() + { + // enter_default_state's LAST step is an unconditional LeaveGround() + // call (raw @306153). With a grounded creature+gravity body and a + // nonzero JumpExtent pre-seeded, LeaveGround's reset (standing_longjump=0, + // jump_extent=0) must be observable after EnterDefaultState. + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.StandingLongJump = true; + interp.JumpExtent = 0.9f; + + interp.EnterDefaultState(); + + Assert.False(interp.StandingLongJump, "EnterDefaultState's LeaveGround tail must fire"); + Assert.Equal(0f, interp.JumpExtent, precision: 5); + } + + // ========================================================================= + // Initted gating — apply_current_movement / ReportExhaustion (A3 entry gate) + // ========================================================================= + + [Fact] + public void ApplyCurrentMovement_NotInitted_NoOp() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.Initted = false; + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + + interp.apply_current_movement(cancelMoveTo: false, allowJump: false); + + Assert.Equal(System.Numerics.Vector3.Zero, body.Velocity); + } + + [Fact] + public void ApplyCurrentMovement_Initted_Proceeds() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + Assert.True(interp.Initted, "the two-arg constructor defaults Initted=true (see final report)"); + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + + interp.apply_current_movement(cancelMoveTo: false, allowJump: false); + + Assert.True(body.Velocity.Length() > 0f); + } + + [Fact] + public void ReportExhaustion_NotInitted_NoOp() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.Initted = false; + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + + interp.ReportExhaustion(); + + Assert.Equal(System.Numerics.Vector3.Zero, body.Velocity); + } + + [Fact] + public void ReportExhaustion_NoPhysicsObj_NoOp() + { + var interp = new MotionInterpreter(); + // No exception is the assertion -- retail's entry gate is + // physics_obj != 0 && initted != 0, both ANDed. + interp.ReportExhaustion(); + } + + // ========================================================================= + // Dual-dispatch truth table — A3: IsThePlayer && movement_is_autonomous + // gates apply_raw_movement vs apply_interpreted_movement, for + // apply_current_movement AND ReportExhaustion. + // + // Reading raw_movement's effect: apply_raw_movement copies RawState -> + // InterpretedState (see apply_raw_movement's existing doc comment) then + // re-normalizes via adjust_motion. apply_interpreted_movement instead + // reads InterpretedState directly and pushes velocity via + // get_state_velocity/set_local_velocity when grounded. We distinguish + // the two dispatch targets by seeding RawState and InterpretedState with + // DIFFERENT forward commands/speeds and observing which one drove the + // resulting body velocity. + // ========================================================================= + + [Theory] + [InlineData(true, true, /* expectRaw */ true)] // IsThePlayer && autonomous -> raw + [InlineData(true, false, /* expectRaw */ false)] // IsThePlayer but not autonomous -> interpreted + [InlineData(false, true, /* expectRaw */ false)] // autonomous but NOT the player -> interpreted (remote player IS a creature but not "the player") + [InlineData(false, false, /* expectRaw */ false)] // neither -> interpreted + public void ApplyCurrentMovement_DualDispatch_MatchesA3TruthTable( + bool isThePlayer, bool autonomous, bool expectRaw) + { + var weenie = new FakeWeenie { IsThePlayerResult = isThePlayer, IsCreatureResult = true }; + var body = MakeGrounded(); + body.LastMoveWasAutonomous = autonomous; + var interp = MakeInterp(body, weenie); + + // RawState drives WalkForward (speed 1 => WalkAnimSpeed); InterpretedState + // drives RunForward (speed 1 => RunAnimSpeed). WalkAnimSpeed != RunAnimSpeed + // so the resulting body.Velocity.Y distinguishes which path ran. + interp.RawState.ForwardCommand = MotionCommand.WalkForward; + interp.RawState.ForwardSpeed = 1.0f; + interp.RawState.ForwardHoldKey = HoldKey.None; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + + interp.apply_current_movement(cancelMoveTo: false, allowJump: false); + + float expectedY = expectRaw + ? MotionInterpreter.WalkAnimSpeed // apply_raw_movement re-derives from RawState + : MotionInterpreter.RunAnimSpeed; // apply_interpreted_movement reads InterpretedState as-is + Assert.Equal(expectedY, body.Velocity.Y, precision: 2); + } + + [Fact] + public void ApplyCurrentMovement_NoWeenie_Autonomous_DispatchesRaw() + { + // weenie_obj == 0 short-circuits the OR to true (raw 305849: + // weenie_obj == 0 || eax_2 != 0) -- no weenie means "treat as the + // player" for dispatch purposes. + var body = MakeGrounded(); + body.LastMoveWasAutonomous = true; + var interp = MakeInterp(body); // no weenie + + interp.RawState.ForwardCommand = MotionCommand.WalkForward; + interp.RawState.ForwardSpeed = 1.0f; + interp.RawState.ForwardHoldKey = HoldKey.None; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + + interp.apply_current_movement(cancelMoveTo: false, allowJump: false); + + Assert.Equal(MotionInterpreter.WalkAnimSpeed, body.Velocity.Y, precision: 2); + } + + [Fact] + public void ReportExhaustion_DualDispatch_PassesZeroZeroArgs() + { + // A3: ReportExhaustion's dispatch args are hardcoded (0, 0) -- + // distinct from apply_current_movement which passes its own + // (cancelMoveTo, allowJump) through. We can't observe the args + // directly (both paths are void), so this proves ReportExhaustion + // dispatches at all when initted+player+autonomous (raw path) by + // observing the same velocity-divergence trick. + var weenie = new FakeWeenie { IsThePlayerResult = true }; + var body = MakeGrounded(); + body.LastMoveWasAutonomous = true; + var interp = MakeInterp(body, weenie); + interp.RawState.ForwardCommand = MotionCommand.WalkForward; + interp.RawState.ForwardSpeed = 1.0f; + interp.RawState.ForwardHoldKey = HoldKey.None; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + + interp.ReportExhaustion(); + + Assert.Equal(MotionInterpreter.WalkAnimSpeed, body.Velocity.Y, precision: 2); + } + + [Fact] + public void ReportExhaustion_RemotePlayer_DispatchesInterpreted() + { + // The ACE-divergence pin: a remote player weenie (IsThePlayer=false, + // IsCreature=true) must route INTERPRETED, not raw -- even though + // it IS a creature. ACE's IsCreature-gated read would wrongly send + // this down apply_raw_movement. + var weenie = new FakeWeenie { IsThePlayerResult = false, IsCreatureResult = true }; + var body = MakeGrounded(); + body.LastMoveWasAutonomous = true; // even with autonomous=true... + var interp = MakeInterp(body, weenie); + interp.RawState.ForwardCommand = MotionCommand.WalkForward; + interp.RawState.ForwardSpeed = 1.0f; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + + interp.ReportExhaustion(); + + // ...IsThePlayer==false forces the interpreted path. + Assert.Equal(MotionInterpreter.RunAnimSpeed, body.Velocity.Y, precision: 2); + } + + // ========================================================================= + // SetWeenieObject / SetPhysicsObject — 0x00528920 / 0x00528970 re-apply + // ========================================================================= + + [Fact] + public void SetWeenieObject_WhilePhysicsBoundAndInitted_ReappliesMovement() + { + var body = MakeGrounded(); + var interp = new MotionInterpreter { PhysicsObj = body, Initted = true }; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + + interp.SetWeenieObject(new FakeWeenie { IsThePlayerResult = false }); + + Assert.True(body.Velocity.Length() > 0f, "SetWeenieObject must re-apply movement when bound+initted"); + } + + [Fact] + public void SetWeenieObject_NoPhysicsObj_DoesNotReapply() + { + var interp = new MotionInterpreter(); + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + + // Must not throw despite no PhysicsObj. + interp.SetWeenieObject(new FakeWeenie()); + + Assert.Null(interp.PhysicsObj); + } + + [Fact] + public void SetWeenieObject_NotInitted_DoesNotReapply() + { + var body = MakeGrounded(); + var interp = new MotionInterpreter { PhysicsObj = body, Initted = false }; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + + interp.SetWeenieObject(new FakeWeenie()); + + Assert.Equal(System.Numerics.Vector3.Zero, body.Velocity); + } + + [Fact] + public void SetPhysicsObject_BindsAndReappliesWhenInitted() + { + var interp = new MotionInterpreter { Initted = true }; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + var body = MakeGrounded(); + + interp.SetPhysicsObject(body); + + Assert.Same(body, interp.PhysicsObj); + Assert.True(body.Velocity.Length() > 0f); + } + + [Fact] + public void SetPhysicsObject_NullArg_DoesNotReapply() + { + var interp = new MotionInterpreter { Initted = true }; + + // arg2 != 0 gates the reapply -- passing null must not throw and + // must not attempt InterpretedState velocity work (no body to write to). + interp.SetPhysicsObject(null); + + Assert.Null(interp.PhysicsObj); + } + + // ========================================================================= + // set_hold_run — 0x00528b70 @306053 (XOR toggle guard) + // ========================================================================= + + [Fact] + public void SetHoldRun_TogglesFromNoneToRun_WhenHoldingRunKey() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.CurrentHoldKey = HoldKey.None; + + interp.set_hold_run(holdingRun: true, interrupt: false); + + Assert.Equal(HoldKey.Run, interp.RawState.CurrentHoldKey); + } + + [Fact] + public void SetHoldRun_TogglesFromRunToNone_WhenReleasingRunKey() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.CurrentHoldKey = HoldKey.Run; + + interp.set_hold_run(holdingRun: false, interrupt: false); + + Assert.Equal(HoldKey.None, interp.RawState.CurrentHoldKey); + } + + [Fact] + public void SetHoldRun_NoChange_WhenAlreadyInRequestedState_IsANoOp() + { + // XOR guard: eax(=arg2==0) != edx(=current!=Run) is FALSE when + // arg2 requests exactly the state we're already in -- skip. + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.CurrentHoldKey = HoldKey.Run; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + body.Velocity = System.Numerics.Vector3.Zero; + + interp.set_hold_run(holdingRun: true, interrupt: false); + + Assert.Equal(HoldKey.Run, interp.RawState.CurrentHoldKey); + // No re-apply fired (still zero) -- the guard skipped the whole body. + Assert.Equal(System.Numerics.Vector3.Zero, body.Velocity); + } + + [Fact] + public void SetHoldRun_OnChange_CallsApplyCurrentMovementWithInterruptArg() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.CurrentHoldKey = HoldKey.None; + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + + interp.set_hold_run(holdingRun: true, interrupt: true); + + // apply_current_movement(arg3, 0) fired -- observable via the + // grounded velocity re-application (AP-75-adjacent write). + Assert.True(body.Velocity.Length() > 0f); + } + + // ========================================================================= + // SetHoldKey — 0x00528bb0 @306072 (None-only-meaningful-from-Run) + // ========================================================================= + + [Fact] + public void SetHoldKey_None_FromRun_TakesEffect() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.CurrentHoldKey = HoldKey.Run; + + interp.SetHoldKey(HoldKey.None, cancelMoveTo: false); + + Assert.Equal(HoldKey.None, interp.RawState.CurrentHoldKey); + } + + [Fact] + public void SetHoldKey_None_FromInvalid_IsIgnored() + { + // raw @306072: setting None only takes effect from Run. Any other + // starting state (Invalid, or already None) is silently ignored. + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.CurrentHoldKey = HoldKey.Invalid; + + interp.SetHoldKey(HoldKey.None, cancelMoveTo: false); + + Assert.Equal(HoldKey.Invalid, interp.RawState.CurrentHoldKey); + } + + [Fact] + public void SetHoldKey_AlreadyNone_IsNoOp() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.CurrentHoldKey = HoldKey.None; + + interp.SetHoldKey(HoldKey.None, cancelMoveTo: false); + + Assert.Equal(HoldKey.None, interp.RawState.CurrentHoldKey); + } + + [Fact] + public void SetHoldKey_Run_FromNone_TakesEffect() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.CurrentHoldKey = HoldKey.None; + + interp.SetHoldKey(HoldKey.Run, cancelMoveTo: false); + + Assert.Equal(HoldKey.Run, interp.RawState.CurrentHoldKey); + } + + [Fact] + public void SetHoldKey_Run_AlreadyRun_IsNoOp() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.CurrentHoldKey = HoldKey.Run; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + body.Velocity = System.Numerics.Vector3.Zero; + + interp.SetHoldKey(HoldKey.Run, cancelMoveTo: false); + + Assert.Equal(HoldKey.Run, interp.RawState.CurrentHoldKey); + Assert.Equal(System.Numerics.Vector3.Zero, body.Velocity); + } + + [Fact] + public void SetHoldKey_EffectiveChange_ReappliesMovement() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.RawState.CurrentHoldKey = HoldKey.None; + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + + interp.SetHoldKey(HoldKey.Run, cancelMoveTo: false); + + Assert.True(body.Velocity.Length() > 0f, "an effective SetHoldKey change must reapply movement"); + } + + // ========================================================================= + // adjust_motion creature guard — J18 one-liner (retires register TS-34) + // ========================================================================= + + [Fact] + public void AdjustMotion_NonCreatureWeenie_SkipsNormalization() + { + var weenie = new FakeWeenie { IsCreatureResult = false }; + var interp = MakeInterp(weenie: weenie); + uint motion = MotionCommand.WalkBackward; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.Invalid); + + // Retail returns immediately for a non-creature weenie -- WalkBackward + // must NOT be remapped to WalkForward/negated-speed. + Assert.Equal(MotionCommand.WalkBackward, motion); + Assert.Equal(1.0f, speed); + } + + [Fact] + public void AdjustMotion_CreatureWeenie_NormalizesAsBefore() + { + var weenie = new FakeWeenie { IsCreatureResult = true }; + var interp = MakeInterp(weenie: weenie); + uint motion = MotionCommand.WalkBackward; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.Invalid); + + Assert.Equal(MotionCommand.WalkForward, motion); + Assert.Equal(-MotionInterpreter.BackwardsFactor, speed, precision: 5); + } + + [Fact] + public void AdjustMotion_NoWeenie_StillNormalizes() + { + // weenie == null must behave like a creature (the "always creature + // unless proven otherwise" retail idiom -- weenie_obj != 0 gates + // the query at all). + var interp = MakeInterp(); + uint motion = MotionCommand.WalkBackward; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.Invalid); + + Assert.Equal(MotionCommand.WalkForward, motion); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/MotionInterpreterJumpFamilyTests.cs b/tests/AcDream.Core.Tests/Physics/MotionInterpreterJumpFamilyTests.cs new file mode 100644 index 00000000..f32d67e7 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/MotionInterpreterJumpFamilyTests.cs @@ -0,0 +1,955 @@ +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +// ───────────────────────────────────────────────────────────────────────────── +// MotionInterpreterJumpFamilyTests — R3-W3 (closes J5, J6, J7-interp-side, +// J16-epsilons). Pins per docs/research/2026-07-02-r3-motioninterp/W0-pins.md +// (A1, A2, A5, A6, A10) and r3-motioninterp-decomp.md §3a-3h. +// +// Source addresses tested: +// FUN_00527a50 (0x00527a50) jump_charge_is_allowed @304935 +// FUN_005281c0 (0x005281c0) charge_jump @305448 +// FUN_00527aa0 (0x00527aa0) get_jump_v_z @304953 +// FUN_005280c0 (0x005280c0) get_leave_ground_velocity @305404 +// FUN_005282b0 (0x005282b0) jump_is_allowed (full chain) +// FUN_00528780 (0x00528780) jump @305792 +// ───────────────────────────────────────────────────────────────────────────── + +/// Fake WeenieObject for jump-family test isolation. +file sealed class FakeWeenie : IWeenieObject +{ + public float RunRate = 1.0f; + public float JumpVz = 10.0f; + public bool CanJumpResult = true; + public bool InqRunRateResult = true; + public bool InqJumpVelocityResult = true; + + /// Controls the JumpStaminaCost virtual (vtable +0x44 per the + /// raw 305549-305556 shape): true = affordable (pass), false = 0x47. + public bool JumpStaminaCostResult = true; + public int JumpStaminaCostCalls; + + public bool InqJumpVelocity(float extent, out float vz) + { + vz = JumpVz * extent; + return InqJumpVelocityResult; + } + + public bool InqRunRate(out float rate) + { + rate = RunRate; + return InqRunRateResult; + } + + public bool CanJump(float extent) => CanJumpResult; + + public bool JumpStaminaCost(float extent, out int cost) + { + JumpStaminaCostCalls++; + cost = 0; + return JumpStaminaCostResult; + } +} + +public sealed class MotionInterpreterJumpFamilyTests +{ + // ── helpers ─────────────────────────────────────────────────────────────── + + private static PhysicsBody MakeGrounded() + { + var body = new PhysicsBody + { + State = PhysicsStateFlags.Gravity | PhysicsStateFlags.ReportCollisions, + }; + body.TransientState = TransientStateFlags.Contact + | TransientStateFlags.OnWalkable + | TransientStateFlags.Active; + return body; + } + + private static PhysicsBody MakeAirborne() + { + var body = new PhysicsBody + { + State = PhysicsStateFlags.Gravity | PhysicsStateFlags.ReportCollisions, + }; + body.TransientState = TransientStateFlags.Active; + return body; + } + + private static MotionInterpreter MakeInterp(PhysicsBody? body = null, IWeenieObject? weenie = null) + { + body ??= MakeGrounded(); + return new MotionInterpreter(body, weenie); + } + + // ========================================================================= + // jump_charge_is_allowed — 0x00527a50 @304935 + // + // Raw (r3-motioninterp-decomp.md §3b): + // weenie_obj = this->weenie_obj; + // if (weenie_obj != 0 && weenie_obj->vtable->CanJump(this->jump_extent) == 0) + // return 0x49; + // forward_command = this->interpreted_state.forward_command; + // if (forward_command != 0x40000008 + // && (forward_command <= 0x41000011 || forward_command > 0x41000014)) + // return 0; + // return 0x48; + // ========================================================================= + + [Fact] + public void JumpChargeIsAllowed_NoWeenie_ReadyForward_ReturnsNone() + { + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.Ready; + + var result = interp.JumpChargeIsAllowed(0.5f); + + Assert.Equal(WeenieError.None, result); + } + + [Fact] + public void JumpChargeIsAllowed_WeenieCanJumpFalse_ReturnsCantJumpLoadedDown() + { + var weenie = new FakeWeenie { CanJumpResult = false }; + var interp = MakeInterp(weenie: weenie); + interp.InterpretedState.ForwardCommand = MotionCommand.Ready; + + var result = interp.JumpChargeIsAllowed(0.5f); + + Assert.Equal(WeenieError.CantJumpLoadedDown, result); + } + + [Fact] + public void JumpChargeIsAllowed_Fallen_ReturnsYouCantJumpFromThisPosition() + { + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.Fallen; // 0x40000008 + + var result = interp.JumpChargeIsAllowed(0.5f); + + Assert.Equal(WeenieError.YouCantJumpFromThisPosition, result); + } + + [Theory] + [InlineData(MotionCommand.Crouch)] // 0x41000012 + [InlineData(MotionCommand.Sitting)] // 0x41000013 + [InlineData(MotionCommand.Sleeping)] // 0x41000014 + public void JumpChargeIsAllowed_CrouchSitSleepRange_ReturnsYouCantJumpFromThisPosition(uint forward) + { + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = forward; + + var result = interp.JumpChargeIsAllowed(0.5f); + + Assert.Equal(WeenieError.YouCantJumpFromThisPosition, result); + } + + [Fact] + public void JumpChargeIsAllowed_CrouchLowerBoundExact_Passes() + { + // forward_command <= 0x41000011 passes (the gate is a strict + // inequality on the LOWER bound: forward_command > 0x41000011 is + // required to even consider the block). 0x41000011 == CrouchLowerBound + // itself must PASS (not blocked) — verbatim boundary. + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.CrouchLowerBound; // 0x41000011 + + var result = interp.JumpChargeIsAllowed(0.5f); + + Assert.Equal(WeenieError.None, result); + } + + [Fact] + public void JumpChargeIsAllowed_SleepUpperBoundExact_Blocked() + { + // forward_command > 0x41000014 passes; == 0x41000014 (Sleeping) is + // still inside the blocked range (already covered above), but this + // pins the boundary explicitly: 0x41000015 (one past Sleeping) must + // PASS. + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.CrouchUpperExclusive; // 0x41000015 + + var result = interp.JumpChargeIsAllowed(0.5f); + + Assert.Equal(WeenieError.None, result); + } + + [Fact] + public void JumpChargeIsAllowed_Falling_Passes() + { + // Falling (0x40000015) is NOT Fallen (0x40000008) — must pass this + // gate (though jump_is_allowed's separate ground check blocks + // mid-air jumps by a different mechanism — A1 adjudication). + var interp = MakeInterp(); + interp.InterpretedState.ForwardCommand = MotionCommand.Falling; + + var result = interp.JumpChargeIsAllowed(0.5f); + + Assert.Equal(WeenieError.None, result); + } + + [Fact] + public void JumpChargeIsAllowed_CanJumpCheckedBeforePostureCheck() + { + // Raw order: CanJump gate FIRST, forward_command gate SECOND. A + // weenie that refuses CanJump returns 0x49 even in a posture that + // would otherwise pass. + var weenie = new FakeWeenie { CanJumpResult = false }; + var interp = MakeInterp(weenie: weenie); + interp.InterpretedState.ForwardCommand = MotionCommand.Falling; // would pass posture gate + + var result = interp.JumpChargeIsAllowed(0.5f); + + Assert.Equal(WeenieError.CantJumpLoadedDown, result); + } + + // ========================================================================= + // charge_jump — 0x005281c0 @305448 (closes J6) + // + // Raw (r3-motioninterp-decomp.md §3e): + // weenie_obj = this->weenie_obj; + // if (weenie_obj != 0 && weenie_obj->vtable->CanJump(this->jump_extent) == 0) + // return 0x49; + // forward_command = this->interpreted_state.forward_command; + // if (forward_command == 0x40000008 + // || (forward_command > 0x41000011 && forward_command <= 0x41000014)) + // return 0x48; + // transient_state = physics_obj->transient_state; + // if ((transient_state & 1) != 0 && (transient_state & 2) != 0 + // && forward_command == 0x41000003 + // && interpreted_state.sidestep_command == 0 + // && interpreted_state.turn_command == 0) + // standing_longjump = 1; + // return 0; + // ========================================================================= + + [Fact] + public void ChargeJump_GroundedIdle_ArmsStandingLongJump() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.StandingLongJump = false; + // Default interpreted state: ForwardCommand=Ready, SideStep=0, Turn=0. + + var result = interp.ChargeJump(); + + Assert.Equal(WeenieError.None, result); + Assert.True(interp.StandingLongJump, "grounded + idle must arm StandingLongJump"); + } + + [Fact] + public void ChargeJump_GroundedButMoving_DoesNotArmStandingLongJump() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.StandingLongJump = false; + interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; + + var result = interp.ChargeJump(); + + Assert.Equal(WeenieError.None, result); + Assert.False(interp.StandingLongJump, "must not arm while moving forward"); + } + + [Fact] + public void ChargeJump_GroundedIdleButSidestepping_DoesNotArmStandingLongJump() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.StandingLongJump = false; + interp.InterpretedState.ForwardCommand = MotionCommand.Ready; + interp.InterpretedState.SideStepCommand = MotionCommand.SideStepRight; + + var result = interp.ChargeJump(); + + Assert.Equal(WeenieError.None, result); + Assert.False(interp.StandingLongJump, "must not arm while sidestepping"); + } + + [Fact] + public void ChargeJump_GroundedIdleButTurning_DoesNotArmStandingLongJump() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.StandingLongJump = false; + interp.InterpretedState.ForwardCommand = MotionCommand.Ready; + interp.InterpretedState.TurnCommand = MotionCommand.TurnRight; + + var result = interp.ChargeJump(); + + Assert.Equal(WeenieError.None, result); + Assert.False(interp.StandingLongJump, "must not arm while turning"); + } + + [Fact] + public void ChargeJump_Airborne_DoesNotArmStandingLongJump() + { + var body = MakeAirborne(); + var interp = MakeInterp(body); + interp.StandingLongJump = false; + + var result = interp.ChargeJump(); + + Assert.Equal(WeenieError.None, result); + Assert.False(interp.StandingLongJump, "must not arm while airborne (no Contact+OnWalkable)"); + } + + [Fact] + public void ChargeJump_WeenieBlocksCanJump_ReturnsCantJumpLoadedDown_NoArm() + { + var weenie = new FakeWeenie { CanJumpResult = false }; + var body = MakeGrounded(); + var interp = MakeInterp(body, weenie); + interp.StandingLongJump = false; + + var result = interp.ChargeJump(); + + Assert.Equal(WeenieError.CantJumpLoadedDown, result); + Assert.False(interp.StandingLongJump); + } + + [Fact] + public void ChargeJump_Fallen_ReturnsYouCantJumpFromThisPosition_NoArm() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.InterpretedState.ForwardCommand = MotionCommand.Fallen; + interp.StandingLongJump = false; + + var result = interp.ChargeJump(); + + Assert.Equal(WeenieError.YouCantJumpFromThisPosition, result); + Assert.False(interp.StandingLongJump); + } + + [Fact] + public void ChargeJump_CrouchRange_ReturnsYouCantJumpFromThisPosition_NoArm() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.InterpretedState.ForwardCommand = MotionCommand.Sitting; + interp.StandingLongJump = false; + + var result = interp.ChargeJump(); + + Assert.Equal(WeenieError.YouCantJumpFromThisPosition, result); + Assert.False(interp.StandingLongJump); + } + + // ── J6 regression pin: contact_allows_move no longer arms StandingLongJump ── + + [Fact] + public void ContactAllowsMove_GroundedAndIdle_DoesNotArmStandingLongJump() + { + // J6: the S2a-flagged misattribution is DELETED. Only ChargeJump + // arms StandingLongJump now — contact_allows_move must have no side + // effect on this flag at all, in either direction. + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.StandingLongJump = false; + + interp.contact_allows_move(MotionCommand.WalkForward); + + Assert.False(interp.StandingLongJump, + "contact_allows_move must never arm StandingLongJump (J6 — moved to ChargeJump exclusively)"); + } + + [Fact] + public void ContactAllowsMove_GroundedAndIdle_DoesNotClearPreArmedStandingLongJump() + { + // contact_allows_move must not touch the flag at all — verify it + // doesn't clear a flag armed by a prior ChargeJump call either. + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.StandingLongJump = true; + + interp.contact_allows_move(MotionCommand.WalkForward); + + Assert.True(interp.StandingLongJump, + "contact_allows_move must not clear an externally-armed StandingLongJump flag"); + } + + // ========================================================================= + // get_jump_v_z — 0x00527aa0 @304953 (A5; closes J16-epsilons) + // Epsilon: 0.000199999995f (NOT the old 0.001 JumpExtentEpsilon). + // ========================================================================= + + [Fact] + public void GetJumpVZ_EpsilonIsRetailLiteral() + { + Assert.Equal(0.000199999995f, MotionInterpreter.JumpVzEpsilon); + } + + [Fact] + public void GetJumpVZ_JustBelowEpsilon_ReturnsZero() + { + var weenie = new FakeWeenie { JumpVz = 10.0f }; + var interp = MakeInterp(weenie: weenie); + interp.JumpExtent = 0.0001f; // < 0.000199999995f + + Assert.Equal(0f, interp.GetJumpVZ(), precision: 6); + } + + [Fact] + public void GetJumpVZ_JustAboveEpsilon_DelegatesToWeenie() + { + var weenie = new FakeWeenie { JumpVz = 10.0f }; + var interp = MakeInterp(weenie: weenie); + interp.JumpExtent = 0.0003f; // > 0.000199999995f + + float vz = interp.GetJumpVZ(); + + // Not the zero-fallback: delegates to InqJumpVelocity(extent, ...). + Assert.Equal(weenie.JumpVz * 0.0003f, vz, precision: 4); + } + + [Fact] + public void GetJumpVZ_ExactlyOldWrongEpsilon_0_001_IsAboveRetailEpsilon_NotZero() + { + // Regression pin: the OLD (wrong) epsilon was 0.001. At extent = + // 0.0005 the old code would have returned 0 (0.0005 < 0.001), but + // retail's epsilon (0.0002) means 0.0005 must NOT hit the zero path. + var weenie = new FakeWeenie { JumpVz = 10.0f }; + var interp = MakeInterp(weenie: weenie); + interp.JumpExtent = 0.0005f; + + float vz = interp.GetJumpVZ(); + + Assert.NotEqual(0f, vz); + Assert.Equal(weenie.JumpVz * 0.0005f, vz, precision: 4); + } + + [Fact] + public void GetJumpVZ_NoWeenie_ReturnsDefault() + { + var interp = MakeInterp(); + interp.JumpExtent = 0.5f; + + Assert.Equal(MotionInterpreter.DefaultJumpVz, interp.GetJumpVZ(), precision: 4); + } + + [Fact] + public void GetJumpVZ_ExtentClampsAtMax1() + { + var weenie = new FakeWeenie { JumpVz = 10.0f }; + var interp = MakeInterp(weenie: weenie); + interp.JumpExtent = 5.0f; // over-clamped + + float vz = interp.GetJumpVZ(); + + Assert.Equal(10.0f, vz, precision: 4); + } + + [Fact] + public void GetJumpVZ_WeenieRefusesInqJumpVelocity_ReturnsZero() + { + var weenie = new FakeWeenie { InqJumpVelocityResult = false }; + var interp = MakeInterp(weenie: weenie); + interp.JumpExtent = 0.5f; + + Assert.Equal(0f, interp.GetJumpVZ(), precision: 5); + } + + // ========================================================================= + // get_leave_ground_velocity — 0x005280c0 @305404 (A6; closes J16-epsilons) + // ========================================================================= + + [Fact] + public void GetLeaveGroundVelocity_WalkingForward_HasPositiveYAndZ() + { + var weenie = new FakeWeenie { JumpVz = 10.0f }; + var body = MakeGrounded(); + var interp = new MotionInterpreter(body, weenie) + { + JumpExtent = 1.0f, + }; + interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; + interp.InterpretedState.ForwardSpeed = 1.0f; + + var vel = interp.GetLeaveGroundVelocity(); + + Assert.True(vel.Y > 0f, "Y velocity should be positive when walking forward"); + Assert.True(vel.Z > 0f, "Z (jump) velocity should be positive"); + } + + [Fact] + public void GetLeaveGroundVelocity_TrulyZero_FallsBackToWorldVelocityGlobalToLocal() + { + // A6: fallback fires ONLY when |x| AND |y| AND |z| are ALL < + // epsilon. When it fires, ALL THREE components (including the + // just-computed jump v_z) are overwritten with + // globaltolocal(m_velocityVector) — the existing + // Quaternion.Inverse(Orientation) transform IS global->local; keep. + var body = MakeGrounded(); + body.Velocity = new Vector3(2.0f, 3.0f, 0f); // nonzero WORLD velocity (momentum) + body.Orientation = Quaternion.Identity; // identity: local == global for this pin + var interp = new MotionInterpreter(body) + { + JumpExtent = 0f, // below epsilon -> get_jump_v_z returns 0 + }; + // Default interpreted state = Ready (no walk/run/sidestep command) -> XY also 0. + + var vel = interp.GetLeaveGroundVelocity(); + + // Fallback must have fired: velocity now reflects body.Velocity + // (global->local via inverse-identity == identity here), NOT the + // all-zero get_state_velocity()/get_jump_v_z() composition. + Assert.Equal(2.0f, vel.X, precision: 4); + Assert.Equal(3.0f, vel.Y, precision: 4); + Assert.Equal(0.0f, vel.Z, precision: 4); + } + + [Fact] + public void GetLeaveGroundVelocity_TrulyZero_NoWorldVelocity_StaysZero() + { + var body = MakeGrounded(); + body.Velocity = Vector3.Zero; + var interp = new MotionInterpreter(body) + { + JumpExtent = 0f, + }; + + var vel = interp.GetLeaveGroundVelocity(); + + Assert.Equal(0f, vel.X, precision: 5); + Assert.Equal(0f, vel.Y, precision: 5); + Assert.Equal(0f, vel.Z, precision: 5); + } + + [Fact] + public void GetLeaveGroundVelocity_NonzeroXOnly_DoesNotTriggerFallback() + { + // A6: the fallback requires ALL THREE axes below epsilon. A + // sidestep-only launch (nonzero X, zero Y, zero jump Z) must NOT + // trigger the momentum fallback — it should keep the computed X. + var body = MakeGrounded(); + body.Velocity = new Vector3(99f, 99f, 99f); // if fallback wrongly fired, this would show + var interp = new MotionInterpreter(body) + { + JumpExtent = 0f, // jump v_z stays 0 + }; + interp.InterpretedState.SideStepCommand = MotionCommand.SideStepRight; + interp.InterpretedState.SideStepSpeed = 1.0f; + + var vel = interp.GetLeaveGroundVelocity(); + + // X must be the sidestep-derived value, not 99 (fallback did not fire). + Assert.NotEqual(99f, vel.X); + Assert.True(vel.X > 0f, "sidestep should have produced nonzero X from get_state_velocity"); + } + + [Fact] + public void GetLeaveGroundVelocity_EpsilonBoundary_JustBelow_TriggersFallback() + { + var body = MakeGrounded(); + body.Velocity = new Vector3(5f, 0f, 0f); + body.Orientation = Quaternion.Identity; + var interp = new MotionInterpreter(body) + { + JumpExtent = 0.0001f, // < 0.000199999995f -> get_jump_v_z() == 0 + }; + // Default interpreted state -> XY == 0 too. All three axes are + // exactly at the "essentially zero" edge -> fallback fires. + + var vel = interp.GetLeaveGroundVelocity(); + + Assert.Equal(5f, vel.X, precision: 4); + } + + // ========================================================================= + // jump_is_allowed — 0x005282b0 (A2, A10; closes J5) + // + // Raw entry shape (r3-motioninterp-decomp.md §3h): + // if (physics_obj != 0) { + // if (weenie != 0) eax_2 = weenie->IsCreature(); + // if (weenie != 0 && eax_2 == 0) // non-creature weenie + // goto shared_gate; + // if (physics_obj == 0 || (state bit 0x400) == 0) // gravity-state off + // goto shared_gate; + // if (Contact && OnWalkable) // grounded + // goto shared_gate; + // } + // return 0x24; + // + // shared_gate: + // if (IsFullyConstrained) return 0x47; + // head = pending_motions.head_; + // if (head != 0) eax_6 = head.jump_error_code; + // if (head == 0 || eax_6 == 0) { + // eax_6 = jump_charge_is_allowed(); + // if (eax_6 == 0) { + // eax_7 = motion_allows_jump(interpreted_state.forward_command); + // if (eax_7 != 0) return eax_7; + // if (weenie_obj_1 == 0) return eax_7; // == 0 here + // eax_6 = 0x47; + // if (weenie_obj_1->JumpStaminaCost(extent, &cost) != 0) + // return eax_7; // == 0 (success) + // // JumpStaminaCost returned 0 (false) -> falls through, eax_6 stays 0x47 + // } + // } + // return eax_6; + // ========================================================================= + + [Fact] + public void JumpIsAllowed_NullPhysicsObj_ReturnsNotGrounded() + { + var interp = new MotionInterpreter(); + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.NotGrounded, result); + } + + [Fact] + public void JumpIsAllowed_CreatureWeenie_Airborne_GravityState_ReturnsNotGrounded() + { + var body = MakeAirborne(); + var interp = MakeInterp(body); + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.NotGrounded, result); + } + + [Fact] + public void JumpIsAllowed_CreatureWeenie_Grounded_ReturnsNone() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + + var result = interp.jump_is_allowed(0.5f, out int cost); + + Assert.Equal(WeenieError.None, result); + Assert.Equal(0, cost); + } + + [Fact] + public void JumpIsAllowed_NonCreatureWeenie_Airborne_SkipsGroundGate_ReturnsNone() + { + // weenie present && !IsCreature() -> skip the ground check entirely, + // go straight to the shared gate. Airborne here must NOT block. + var weenie = new FakeWeenie(); + var body = MakeAirborne(); + var interp = MakeInterp(body, weenie); + // Non-creature: use an explicit fake that overrides IsCreature. + var nonCreature = new NonCreatureFakeWeenie(); + interp.WeenieObj = nonCreature; + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.None, result); + } + + [Fact] + public void JumpIsAllowed_NoWeenie_GravityStateOff_SkipsGroundGate_ReturnsNone() + { + // "no weenie" -> weenie_obj == 0 branch is fine either way (the + // `weenie != 0 && eax_2 == 0` non-creature-skip only applies when a + // weenie exists); but the SEPARATE gravity-state-off skip + // (state bit 0x400 clear) also reaches the shared gate regardless + // of weenie presence. Pin: no gravity flag -> shared gate, not + // blocked outright. + var body = new PhysicsBody + { + State = PhysicsStateFlags.None, // gravity flag clear + TransientState = TransientStateFlags.None, + }; + var interp = MakeInterp(body); + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.None, result); + } + + [Fact] + public void JumpIsAllowed_IsFullyConstrained_ReturnsGeneralMovementFailure() + { + var body = MakeGrounded(); + body.IsFullyConstrained = true; + var interp = MakeInterp(body); + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.GeneralMovementFailure, result); // 0x47 + } + + [Fact] + public void JumpIsAllowed_IsFullyConstrained_BeatsPendingHeadPeek() + { + // A2 ordering: IsFullyConstrained is checked BEFORE the pending-head + // peek. Even if the head carries a DIFFERENT nonzero error, the + // IsFullyConstrained code (0x47) must win. + var body = MakeGrounded(); + body.IsFullyConstrained = true; + var interp = MakeInterp(body); + interp.AddToQueue(0, MotionCommand.WalkForward, (uint)WeenieError.CantJumpLoadedDown); + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.GeneralMovementFailure, result); + } + + [Fact] + public void JumpIsAllowed_PendingHeadNonzeroError_ShortCircuitsChain() + { + // A2: the peek fires WHENEVER the queue is non-empty (no Count>1 + // gate). A nonzero head.JumpErrorCode is returned VERBATIM, and the + // charge/motion/stamina chain is skipped entirely (proven via the + // weenie's CanJump/JumpStaminaCost never being consulted for THIS + // code path — CanJump would return CantJumpLoadedDown some other + // way, so instead assert JumpStaminaCost, which only the fallthrough + // chain calls, is never invoked). + var weenie = new FakeWeenie(); + var body = MakeGrounded(); + var interp = MakeInterp(body, weenie); + interp.AddToQueue(0, MotionCommand.WalkForward, (uint)WeenieError.YouCantJumpFromThisPosition); + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.YouCantJumpFromThisPosition, result); + Assert.Equal(0, weenie.JumpStaminaCostCalls); + } + + [Fact] + public void JumpIsAllowed_PendingHeadZeroError_FallsThroughToChain() + { + // A2: head exists but JumpErrorCode == 0 -> chain still runs. + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.AddToQueue(0, MotionCommand.WalkForward, jumpErrorCode: 0); + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.None, result); + } + + [Fact] + public void JumpIsAllowed_EmptyQueue_FallsThroughToChain() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + // No AddToQueue call -> head is null -> chain runs normally. + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.None, result); + } + + [Fact] + public void JumpIsAllowed_ChargeBlocked_Fallen_ReturnsYouCantJumpFromThisPosition() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.InterpretedState.ForwardCommand = MotionCommand.Fallen; + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.YouCantJumpFromThisPosition, result); + } + + [Fact] + public void JumpIsAllowed_ChargeBlocked_WeenieCanJumpFalse_ReturnsCantJumpLoadedDown() + { + var weenie = new FakeWeenie { CanJumpResult = false }; + var body = MakeGrounded(); + var interp = MakeInterp(body, weenie); + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.CantJumpLoadedDown, result); + } + + [Fact] + public void JumpIsAllowed_MotionAllowsJumpBlocks_ReturnsYouCantJumpFromThisPosition() + { + // jump_charge_is_allowed passes (Ready forward command), but the + // SEPARATE motion_allows_jump(forward_command) check blocks — use a + // forward command in the [0x4000001e, 0x40000039] blocklist band + // that jump_charge_is_allowed does NOT gate on (only Fallen/Crouch + // range does), so this pins the double-check shape. + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.InterpretedState.ForwardCommand = 0x40000020u; // inside [0x4000001e, 0x40000039] + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.YouCantJumpFromThisPosition, result); + } + + [Fact] + public void JumpIsAllowed_NoWeenie_PassesChain_ReturnsNone() + { + // motion_allows_jump passes and weenie_obj == null -> return eax_7 + // (== 0) directly, skipping the JumpStaminaCost consult entirely. + var body = MakeGrounded(); + var interp = MakeInterp(body); // no weenie + + var result = interp.jump_is_allowed(0.5f, out int cost); + + Assert.Equal(WeenieError.None, result); + Assert.Equal(0, cost); + } + + [Fact] + public void JumpIsAllowed_WeenieJumpStaminaCostRefuses_ReturnsGeneralMovementFailure() + { + var weenie = new FakeWeenie { JumpStaminaCostResult = false }; + var body = MakeGrounded(); + var interp = MakeInterp(body, weenie); + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.GeneralMovementFailure, result); // 0x47 + Assert.Equal(1, weenie.JumpStaminaCostCalls); + } + + [Fact] + public void JumpIsAllowed_WeenieJumpStaminaCostAffords_ReturnsNone() + { + var weenie = new FakeWeenie { JumpStaminaCostResult = true }; + var body = MakeGrounded(); + var interp = MakeInterp(body, weenie); + + var result = interp.jump_is_allowed(0.5f, out _); + + Assert.Equal(WeenieError.None, result); + Assert.Equal(1, weenie.JumpStaminaCostCalls); + } + + /// Fake weenie whose IsCreature() returns false, for the + /// non-creature ground-gate-skip pin. + private sealed class NonCreatureFakeWeenie : IWeenieObject + { + public bool InqJumpVelocity(float extent, out float vz) { vz = 10f; return true; } + public bool InqRunRate(out float rate) { rate = 1f; return true; } + public bool CanJump(float extent) => true; + public bool IsCreature() => false; + } + + // ========================================================================= + // jump — 0x00528780 @305792 (closes J7-interp-side) + // ========================================================================= + + [Fact] + public void Jump_Grounded_SetsJumpExtentAndLeavesWalkable() + { + var body = MakeGrounded(); + var interp = MakeInterp(body); + + var result = interp.jump(0.5f); + + Assert.Equal(WeenieError.None, result); + Assert.Equal(0.5f, interp.JumpExtent, precision: 5); + Assert.False(body.OnWalkable, "Body should no longer be on walkable after jump"); + } + + [Fact] + public void Jump_Airborne_ReturnsNotGrounded() + { + var body = MakeAirborne(); + var interp = MakeInterp(body); + + var result = interp.jump(0.5f); + + Assert.Equal(WeenieError.NotGrounded, result); + } + + [Fact] + public void Jump_WeenieBlocksJump_ClearsStandingLongJump() + { + var weenie = new FakeWeenie { CanJumpResult = false }; + var body = MakeGrounded(); + var interp = MakeInterp(body, weenie); + interp.StandingLongJump = true; + + var result = interp.jump(0.5f); + + Assert.Equal(WeenieError.CantJumpLoadedDown, result); + Assert.False(interp.StandingLongJump, "a failed jump attempt cancels any pending StandingLongJump"); + } + + [Fact] + public void Jump_NullPhysicsObj_ReturnsNoPhysicsObject() + { + var interp = new MotionInterpreter(); + + var result = interp.jump(0.5f); + + Assert.Equal(WeenieError.NoPhysicsObject, result); + } + + [Fact] + public void Jump_Success_DoesNotClearStandingLongJump() + { + // Only the FAILURE path clears StandingLongJump (raw 305800: + // `this->standing_longjump = 0;` sits inside the `if (result != 0)` + // branch only). A successful jump leaves whatever value the flag + // already had. + var body = MakeGrounded(); + var interp = MakeInterp(body); + interp.StandingLongJump = true; + + var result = interp.jump(0.5f); + + Assert.Equal(WeenieError.None, result); + Assert.True(interp.StandingLongJump, "success path must not touch StandingLongJump"); + } + + [Fact] + public void Jump_CallsInterruptCurrentMovementSeam() + { + // J7 / "Adjacent findings": jump() ALWAYS calls + // interrupt_current_movement first (raw @305800), regardless of + // outcome. Register no-op seam until R4's cancel_moveto exists. + var body = MakeGrounded(); + var interp = MakeInterp(body); + bool called = false; + interp.InterruptCurrentMovement = () => called = true; + + interp.jump(0.5f); + + Assert.True(called, "jump() must invoke the InterruptCurrentMovement seam"); + } + + [Fact] + public void Jump_CallsInterruptCurrentMovementSeam_EvenOnFailure() + { + var body = MakeAirborne(); + var interp = MakeInterp(body); + bool called = false; + interp.InterruptCurrentMovement = () => called = true; + + interp.jump(0.5f); + + Assert.True(called, "jump() calls interrupt_current_movement before jump_is_allowed, unconditionally"); + } + + // ========================================================================= + // IWeenieObject.IsThePlayer — default false; PlayerWeenie true (for W4's + // A3 dispatch gate; no consumer yet in W3). + // ========================================================================= + + [Fact] + public void IWeenieObject_IsThePlayer_DefaultsFalse() + { + // Default interface members are only reachable through the + // interface type, not the concrete implementer — call via + // IWeenieObject to exercise the DIM (not a compile error site). + IWeenieObject weenie = new FakeWeenie(); + + Assert.False(weenie.IsThePlayer()); + } + + [Fact] + public void PlayerWeenie_IsThePlayer_ReturnsTrue() + { + var weenie = new PlayerWeenie(); + + Assert.True(weenie.IsThePlayer()); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/MotionInterpreterPendingMotionsTests.cs b/tests/AcDream.Core.Tests/Physics/MotionInterpreterPendingMotionsTests.cs new file mode 100644 index 00000000..ac23a5f0 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/MotionInterpreterPendingMotionsTests.cs @@ -0,0 +1,351 @@ +using System.Collections.Generic; +using System.Linq; +using AcDream.Core.Physics; +using AcDream.Core.Physics.Motion; +using DatReaderWriter.DBObjs; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// R3-W2 — CMotionInterp::pending_motions lifecycle + the +/// MotionDone consumer (closes J1, J17). +/// +/// Oracle: docs/research/2026-07-02-r3-motioninterp/r3-motioninterp-decomp.md +/// §1 (add_to_queue 0x00527b80 @305032, MotionDone 0x00527ec0 @305238, +/// motions_pending 0x00527fe0, HandleExitWorld 0x00527f30, +/// is_standing_still 0x00527fa0 @305309) + §3a (motion_allows_jump +/// 0x005279e0 @304908) + W0-pins.md A1/A7. +/// +public class MotionInterpreterPendingMotionsTests +{ + private static MotionInterpreter GroundedInterp() + { + var body = new PhysicsBody(); + body.State |= PhysicsStateFlags.Gravity; + body.TransientState |= TransientStateFlags.Contact + | TransientStateFlags.OnWalkable + | TransientStateFlags.Active; + return new MotionInterpreter(body); + } + + // ── AddToQueue / MotionsPending — §1a/§1b verbatim ───────────────────── + + [Fact] + public void AddToQueue_AppendsToTail_InOrder() + { + var mi = new MotionInterpreter(); + + mi.AddToQueue(1, 0x41000003u, 0u); + mi.AddToQueue(2, 0x44000007u, 0x48u); + mi.AddToQueue(3, 0x45000005u, 0u); + + Assert.Equal( + new[] + { + new MotionNode(1, 0x41000003u, 0u), + new MotionNode(2, 0x44000007u, 0x48u), + new MotionNode(3, 0x45000005u, 0u), + }, + mi.PendingMotions.ToArray()); + } + + [Fact] + public void MotionsPending_FalseWhenEmpty_TrueWhenNonEmpty() + { + var mi = new MotionInterpreter(); + Assert.False(mi.MotionsPending()); + + mi.AddToQueue(0, MotionCommand.Ready, 0); + Assert.True(mi.MotionsPending()); + } + + // ── MotionDone — §1c verbatim (unconditional head pop, A7) ──────────── + + [Fact] + public void MotionDone_PopsHead_RegardlessOfMotionIdOrSuccessFlag() + { + // A7: motion + success are IGNORED — positional protocol, never + // match-by-id. A queue with a head that does NOT match the + // `motion` parameter must still pop that head. §1c gates the whole + // body on physics_obj != null (covered separately by + // MotionDone_NoPhysicsObj_NoOp), so this needs a grounded interp. + var mi = GroundedInterp(); + mi.AddToQueue(1, 0x44000007u /* RunForward */, 0u); + mi.AddToQueue(2, 0x45000005u /* WalkForward */, 0u); + + // Call MotionDone with a motion id that matches NEITHER queued + // node, and success=false — retail still pops the actual head. + mi.MotionDone(0xDEADBEEFu, false); + + Assert.Single(mi.PendingMotions); + Assert.Equal(0x45000005u, mi.PendingMotions.First().Motion); + } + + [Fact] + public void MotionDone_EmptyQueue_NoOp() + { + var mi = new MotionInterpreter(); + // Should not throw. + mi.MotionDone(0, true); + Assert.False(mi.MotionsPending()); + } + + [Fact] + public void MotionDone_NoPhysicsObj_NoOp() + { + // §1c: `if (physics_obj != 0) { ... }` — the whole body is + // gated on a non-null physics_obj. A queued node must survive + // MotionDone when PhysicsObj is null. + var mi = new MotionInterpreter(); + mi.AddToQueue(0, MotionCommand.Ready, 0); + + mi.MotionDone(MotionCommand.Ready, true); + + Assert.True(mi.MotionsPending()); + } + + [Fact] + public void MotionDone_ActionClassHead_FiresUnstickSeam_AndPopsBothActionFifos() + { + // §1c: head.motion & 0x10000000 != 0 -> unstick_from_object + + // InterpretedState.RemoveAction() + RawState.RemoveAction(), + // THEN the unconditional head pop. + var mi = GroundedInterp(); + mi.InterpretedState.AddAction(0x10000062u, 1.0f, 5, false); + mi.RawState.AddAction(0x10000062u, 1.0f, 5, false); + + bool unstickFired = false; + mi.UnstickFromObject = () => unstickFired = true; + + mi.AddToQueue(0, 0x10000062u /* action-class bit 0x10000000 set */, 0u); + + mi.MotionDone(0x10000062u, true); + + Assert.True(unstickFired); + Assert.Equal(0u, mi.InterpretedState.GetNumActions()); + Assert.Empty(mi.RawState.Actions); + Assert.False(mi.MotionsPending()); + } + + [Fact] + public void MotionDone_NonActionClassHead_DoesNotFireUnstick_OrPopActionFifos() + { + var mi = GroundedInterp(); + mi.InterpretedState.AddAction(0x10000062u, 1.0f, 5, false); + mi.RawState.AddAction(0x10000062u, 1.0f, 5, false); + + bool unstickFired = false; + mi.UnstickFromObject = () => unstickFired = true; + + // Non-action-class motion (no 0x10000000 bit). + mi.AddToQueue(0, MotionCommand.Ready, 0u); + + mi.MotionDone(MotionCommand.Ready, true); + + Assert.False(unstickFired); + Assert.Equal(1u, mi.InterpretedState.GetNumActions()); + Assert.Single(mi.RawState.Actions); + } + + [Fact] + public void MotionDone_ActionClassHead_UnstickSeamUnset_DoesNotThrow() + { + // UnstickFromObject is a no-op seam (register row -> R5 StickyManager) + // until wired — null must not throw. Needs a grounded interp so + // MotionDone's physics_obj != null gate actually pops (§1c). + var mi = GroundedInterp(); + mi.AddToQueue(0, 0x10000062u, 0u); + + mi.MotionDone(0x10000062u, true); + + Assert.False(mi.MotionsPending()); + } + + [Fact] + public void MotionDone_MultipleCalls_PopInFifoOrder() + { + // §1c gates the pop on physics_obj != null. + var mi = GroundedInterp(); + mi.AddToQueue(1, 0x41000003u, 0u); + mi.AddToQueue(2, 0x44000007u, 0u); + mi.AddToQueue(3, 0x45000005u, 0u); + + mi.MotionDone(0, true); + Assert.Equal(new uint[] { 2, 3 }, mi.PendingMotions.Select(n => n.ContextId)); + + mi.MotionDone(0, true); + Assert.Equal(new uint[] { 3 }, mi.PendingMotions.Select(n => n.ContextId)); + + mi.MotionDone(0, true); + Assert.Empty(mi.PendingMotions); + Assert.False(mi.MotionsPending()); + } + + // ── HandleExitWorld — §1d, same body looped ──────────────────────────── + + [Fact] + public void HandleExitWorld_DrainsWholeQueue() + { + var mi = new MotionInterpreter(); + mi.AddToQueue(1, 0x41000003u, 0u); + mi.AddToQueue(2, 0x44000007u, 0u); + mi.AddToQueue(3, 0x10000062u, 0u); // action-class + + mi.HandleExitWorld(); + + Assert.Empty(mi.PendingMotions); + Assert.False(mi.MotionsPending()); + } + + [Fact] + public void HandleExitWorld_ActionClassNodes_PopActionFifosForEach() + { + var mi = GroundedInterp(); + mi.InterpretedState.AddAction(0x10000062u, 1f, 1, false); + mi.InterpretedState.AddAction(0x10000063u, 1f, 2, false); + mi.RawState.AddAction(0x10000062u, 1f, 1, false); + mi.RawState.AddAction(0x10000063u, 1f, 2, false); + + mi.AddToQueue(0, 0x10000062u, 0u); + mi.AddToQueue(0, 0x10000063u, 0u); + + mi.HandleExitWorld(); + + Assert.Equal(0u, mi.InterpretedState.GetNumActions()); + Assert.Empty(mi.RawState.Actions); + } + + [Fact] + public void HandleExitWorld_EmptyQueue_NoOp() + { + var mi = new MotionInterpreter(); + mi.HandleExitWorld(); + Assert.False(mi.MotionsPending()); + } + + // ── is_standing_still — §... 0x00527fa0 verbatim predicate ───────────── + + [Theory] + [InlineData(true, true, MotionCommand.Ready, 0u, 0u, true)] // grounded + idle -> true + [InlineData(true, true, MotionCommand.Ready, 0x6500000fu, 0u, false)] // sidestep set -> false + [InlineData(true, true, MotionCommand.Ready, 0u, 0x6500000du, false)] // turn set -> false + [InlineData(true, true, MotionCommand.RunForward, 0u, 0u, false)] // not Ready -> false + [InlineData(true, false, MotionCommand.Ready, 0u, 0u, false)] // OnWalkable false -> false + [InlineData(false, true, MotionCommand.Ready, 0u, 0u, false)] // Contact false -> false + public void IsStandingStill_TruthTable( + bool contact, bool onWalkable, uint fwd, uint side, uint turn, bool expected) + { + var body = new PhysicsBody(); + body.State |= PhysicsStateFlags.Gravity; + if (contact) body.TransientState |= TransientStateFlags.Contact; + if (onWalkable) body.TransientState |= TransientStateFlags.OnWalkable; + var mi = new MotionInterpreter(body) + { + InterpretedState = + { + ForwardCommand = fwd, + SideStepCommand = side, + TurnCommand = turn, + }, + }; + + Assert.Equal(expected, mi.IsStandingStill()); + } + + [Fact] + public void IsStandingStill_NoPhysicsObj_False() + { + var mi = new MotionInterpreter(); + Assert.False(mi.IsStandingStill()); + } + + // ── MotionAllowsJump — A1 pinned blocklist, exact boundaries ─────────── + + [Theory] + // [0x1000006f, 0x10000078] MagicPowerUp01..10 -> BLOCKED + [InlineData(0x1000006fu, true)] + [InlineData(0x10000070u, true)] + [InlineData(0x10000078u, true)] + [InlineData(0x1000006eu, false)] // just below lower bound -> pass + [InlineData(0x10000079u, false)] // just above upper bound -> pass + // [0x10000128, 0x10000131] -> BLOCKED + [InlineData(0x10000128u, true)] + [InlineData(0x10000130u, true)] + [InlineData(0x10000131u, true)] + [InlineData(0x10000127u, false)] + [InlineData(0x10000132u, false)] + // 0x40000008 (Fallen) exact -> BLOCKED + [InlineData(0x40000008u, true)] + // Falling 0x40000015 -> PASS (the A1 polarity-corrected divergence from ACE) + [InlineData(0x40000015u, false)] + // [0x40000016, 0x40000018] Reload/Unload/Pickup -> BLOCKED + [InlineData(0x40000016u, true)] + [InlineData(0x40000017u, true)] + [InlineData(0x40000018u, true)] + [InlineData(0x40000019u, false)] + // [0x4000001e, 0x40000039] AimLevel..MagicPray -> BLOCKED + [InlineData(0x4000001eu, true)] + [InlineData(0x40000030u, true)] + [InlineData(0x40000039u, true)] + [InlineData(0x4000001du, false)] + [InlineData(0x4000003au, false)] + // [0x41000012, 0x41000014] Crouch/Sitting/Sleeping -> BLOCKED + [InlineData(0x41000012u, true)] + [InlineData(0x41000013u, true)] + [InlineData(0x41000014u, true)] + [InlineData(0x41000011u, false)] + [InlineData(0x41000015u, false)] + // Everything else -> pass + [InlineData(MotionCommand.Ready, false)] + [InlineData(MotionCommand.Dead, false)] + [InlineData(0x6500000du, false)] // TurnRight + [InlineData(0x6500000fu, false)] // SideStepRight + [InlineData(0x44000007u, false)] // RunForward + public void MotionAllowsJump_BlocklistTable(uint motion, bool blocked) + { + var expected = blocked ? WeenieError.YouCantJumpFromThisPosition : WeenieError.None; + Assert.Equal(expected, MotionInterpreter.MotionAllowsJump(motion)); + } + + // ── End-to-end chain: MotionTableManager.AnimationDone -> sink -> interp pops ── + + /// In-memory that never resolves — + /// matches MotionTableManagerTests.cs's fixture convention. + private sealed class NullLoader : IAnimationLoader + { + public Animation? LoadAnimation(uint id) => null; + } + + [Fact] + public void EndToEnd_ManagerAnimationDone_PopsInterpPendingHead_Synchronously() + { + // §4 diagram: MotionTableManager (IMotionDoneSink) -> + // MotionInterpreter.MotionDone -> pops the interp's OWN + // pending_motions queue head. Two DIFFERENT queues (manager's + // pending_animations vs interp's pending_motions) kept in lockstep + // only via this callback — never merged. MotionDone's body is + // gated on physics_obj != null (§1c), so the interp needs one. + var interp = GroundedInterp(); + var state = new MotionState(); + var sequence = new CSequence(new NullLoader()); + var manager = new MotionTableManager(table: null, state, sequence, sink: interp); + + // The interp independently queued its own motion node (as a real + // DispatchInterpretedMotion call would via AddToQueue). + interp.AddToQueue(contextId: 7, motion: 0x44000007u, jumpErrorCode: 0); + + // The manager separately queues a pending animation with a 1-tick + // duration, matching retail's decrementing countdown chain. + manager.AddToQueue(0x44000007u, ticks: 1); + + Assert.True(interp.MotionsPending()); + + manager.AnimationDone(success: true); + + // The manager's own queue drained AND, via the sink callback, the + // interp's independent queue popped in the same call. + Assert.Empty(manager.PendingAnimations); + Assert.False(interp.MotionsPending()); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/MotionInterpreterTests.cs b/tests/AcDream.Core.Tests/Physics/MotionInterpreterTests.cs index e2c4f896..cfecd6a1 100644 --- a/tests/AcDream.Core.Tests/Physics/MotionInterpreterTests.cs +++ b/tests/AcDream.Core.Tests/Physics/MotionInterpreterTests.cs @@ -176,7 +176,7 @@ public sealed class MotionInterpreterTests { var interp = MakeInterp(); interp.RawState.ForwardCommand = MotionCommand.WalkForward; - interp.RawState.SideStepCommand = MotionCommand.SideStepRight; + interp.RawState.SidestepCommand = MotionCommand.SideStepRight; interp.RawState.TurnCommand = MotionCommand.TurnRight; interp.InterpretedState.ForwardCommand = MotionCommand.RunForward; interp.InterpretedState.TurnCommand = MotionCommand.TurnLeft; @@ -186,7 +186,7 @@ public sealed class MotionInterpreterTests Assert.Equal(WeenieError.None, result); Assert.Equal(MotionCommand.Ready, interp.RawState.ForwardCommand); Assert.Equal(1.0f, interp.RawState.ForwardSpeed, precision: 5); - Assert.Equal(0u, interp.RawState.SideStepCommand); + Assert.Equal(0u, interp.RawState.SidestepCommand); Assert.Equal(0u, interp.RawState.TurnCommand); Assert.Equal(MotionCommand.Ready, interp.InterpretedState.ForwardCommand); Assert.Equal(1.0f, interp.InterpretedState.ForwardSpeed, precision: 5); @@ -423,215 +423,20 @@ public sealed class MotionInterpreterTests } // ========================================================================= - // jump (FUN_00529390) + // jump (FUN_00529390) / get_jump_v_z (FUN_005286b0) / + // get_leave_ground_velocity (FUN_00528cd0) / jump_is_allowed (FUN_00528ec0) + // + // R3-W3 (closes J5, J6, J7-interp-side, J16-epsilons): the full jump + // family (jump/GetJumpVZ/GetLeaveGroundVelocity/jump_is_allowed) plus + // jump_charge_is_allowed/ChargeJump now live in + // MotionInterpreterJumpFamilyTests.cs, ported against the verbatim + // decomp (r3-motioninterp-decomp.md §3a-3h) and W0-pins.md (A2/A5/A6/A10) + // instead of this file's pre-W3 approximation-era pins (wrong 0.001 + // epsilon, jump_is_allowed(extent, int) shape, no IsFullyConstrained / + // pending-head-peek / stamina chain). See that file for the full gate + // tables and epsilon-boundary pins. // ========================================================================= - [Fact] - public void Jump_Grounded_SetsJumpExtentAndLeavesWalkable() - { - var body = MakeGrounded(); - var interp = MakeInterp(body); - - var result = interp.jump(0.5f); - - Assert.Equal(WeenieError.None, result); - Assert.Equal(0.5f, interp.JumpExtent, precision: 5); - Assert.False(body.OnWalkable, "Body should no longer be on walkable after jump"); - } - - [Fact] - public void Jump_Airborne_ReturnsYouCantJumpWhileInTheAir() - { - var body = MakeAirborne(); - var interp = MakeInterp(body); - - var result = interp.jump(0.5f); - - Assert.Equal(WeenieError.YouCantJumpWhileInTheAir, result); - } - - [Fact] - public void Jump_WeenieBlocksJump_ClearStandingLongJump() - { - var weenie = new FakeWeenie { CanJumpResult = false }; - var body = MakeGrounded(); - var interp = MakeInterp(body, weenie); - interp.StandingLongJump = true; - - var result = interp.jump(0.5f); - - Assert.Equal(WeenieError.CantJumpLoadedDown, result); - Assert.False(interp.StandingLongJump); - } - - [Fact] - public void Jump_NullPhysicsObj_ReturnsNoPhysicsObject() - { - var interp = new MotionInterpreter(); - - var result = interp.jump(0.5f); - - Assert.Equal(WeenieError.NoPhysicsObject, result); - } - - // ========================================================================= - // get_jump_v_z (FUN_005286b0) - // ========================================================================= - - [Fact] - public void GetJumpVz_ZeroExtent_ReturnsZero() - { - var interp = MakeInterp(); - interp.JumpExtent = 0f; - - Assert.Equal(0f, interp.get_jump_v_z(), precision: 5); - } - - [Fact] - public void GetJumpVz_NoWeenie_ReturnsDefault() - { - var interp = MakeInterp(); - interp.JumpExtent = 0.5f; - - Assert.Equal(MotionInterpreter.DefaultJumpVz, interp.get_jump_v_z(), precision: 4); - } - - [Fact] - public void GetJumpVz_WithWeenie_DelegatesToInqJumpVelocity() - { - var weenie = new FakeWeenie { JumpVz = 8.0f }; - var interp = MakeInterp(weenie: weenie); - interp.JumpExtent = 1.0f; - - float vz = interp.get_jump_v_z(); - - // FakeWeenie returns JumpVz * extent = 8.0 * 1.0 = 8.0 - Assert.Equal(8.0f, vz, precision: 4); - } - - [Fact] - public void GetJumpVz_ExtentClampsAt1() - { - var weenie = new FakeWeenie { JumpVz = 10.0f }; - var interp = MakeInterp(weenie: weenie); - interp.JumpExtent = 5.0f; // over-clamped - - float vz = interp.get_jump_v_z(); - - // Should clamp extent to 1.0: FakeWeenie returns 10.0 * 1.0 = 10.0 - Assert.Equal(10.0f, vz, precision: 4); - } - - [Fact] - public void GetJumpVz_WeenieReturnsFailure_ReturnsZero() - { - var weenie = new FakeWeenie { InqJumpVelocityResult = false }; - var interp = MakeInterp(weenie: weenie); - interp.JumpExtent = 0.5f; - - Assert.Equal(0f, interp.get_jump_v_z(), precision: 5); - } - - // ========================================================================= - // get_leave_ground_velocity (FUN_00528cd0) - // ========================================================================= - - [Fact] - public void GetLeaveGroundVelocity_WalkingForward_HasPositiveYAndZ() - { - var weenie = new FakeWeenie { JumpVz = 10.0f }; - var body = MakeGrounded(); - var interp = new MotionInterpreter(body, weenie) - { - JumpExtent = 1.0f, - }; - interp.InterpretedState.ForwardCommand = MotionCommand.WalkForward; - interp.InterpretedState.ForwardSpeed = 1.0f; - - var vel = interp.get_leave_ground_velocity(); - - Assert.True(vel.Y > 0f, "Y velocity should be positive when walking forward"); - Assert.True(vel.Z > 0f, "Z (jump) velocity should be positive"); - } - - [Fact] - public void GetLeaveGroundVelocity_Standing_ZeroExtent_ReturnsZeroXY() - { - var body = MakeGrounded(); - var interp = new MotionInterpreter(body) - { - JumpExtent = 0f, // below epsilon - }; - // Default interpreted state = Ready (no walk/run command) - - var vel = interp.get_leave_ground_velocity(); - - Assert.Equal(0f, vel.X, precision: 5); - Assert.Equal(0f, vel.Y, precision: 5); - Assert.Equal(0f, vel.Z, precision: 5); - } - - // ========================================================================= - // jump_is_allowed (FUN_00528ec0) - // ========================================================================= - - [Fact] - public void JumpIsAllowed_Grounded_ReturnsNone() - { - var interp = MakeInterp(MakeGrounded()); - - var result = interp.jump_is_allowed(0.5f, 0); - - Assert.Equal(WeenieError.None, result); - } - - [Fact] - public void JumpIsAllowed_Airborne_ReturnsYouCantJumpWhileInTheAir() - { - var interp = MakeInterp(MakeAirborne()); - - var result = interp.jump_is_allowed(0.5f, 0); - - Assert.Equal(WeenieError.YouCantJumpWhileInTheAir, result); - } - - [Fact] - public void JumpIsAllowed_WeenieBlocks_ReturnsCantJumpLoadedDown() - { - var weenie = new FakeWeenie { CanJumpResult = false }; - var interp = MakeInterp(MakeGrounded(), weenie); - - var result = interp.jump_is_allowed(0.5f, 0); - - Assert.Equal(WeenieError.CantJumpLoadedDown, result); - } - - [Fact] - public void JumpIsAllowed_NoGravityFlag_ReturnsYouCantJumpWhileInTheAir() - { - var body = new PhysicsBody - { - State = PhysicsStateFlags.None, // no gravity - TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable, - }; - var interp = MakeInterp(body); - - // No gravity → must be airborne-style - var result = interp.jump_is_allowed(0.5f, 0); - - Assert.Equal(WeenieError.YouCantJumpWhileInTheAir, result); - } - - [Fact] - public void JumpIsAllowed_NullPhysicsObj_ReturnsGeneralFailure() - { - var interp = new MotionInterpreter(); - - var result = interp.jump_is_allowed(0.5f, 0); - - Assert.Equal(WeenieError.GeneralMovementFailure, result); - } - // ========================================================================= // contact_allows_move (FUN_00528dd0) // ========================================================================= @@ -673,35 +478,24 @@ public sealed class MotionInterpreterTests Assert.True(allowLeft); } - [Fact] - public void ContactAllowsMove_FallenState_RejectsMove() - { - var body = MakeGrounded(); - var interp = MakeInterp(body); - interp.InterpretedState.ForwardCommand = MotionCommand.Fallen; - - bool allowed = interp.contact_allows_move(MotionCommand.WalkForward); - - Assert.False(allowed); - } - - [Fact] - public void ContactAllowsMove_DeadState_RejectsMove() - { - var body = MakeGrounded(); - var interp = MakeInterp(body); - interp.InterpretedState.ForwardCommand = MotionCommand.Dead; - - bool allowed = interp.contact_allows_move(MotionCommand.WalkForward); - - Assert.False(allowed); - } + // L.2g S2 (2026-07-02): the posture-rejection tests that used to live + // here pinned a MISATTRIBUTED port — the Fallen/Dead/crouch-range checks + // belong to jump_charge_is_allowed (0x00527a50) / motion_allows_jump + // (0x005279e0), NOT to contact_allows_move. The real contact_allows_move + // (0x00528240, pseudo-C 305471) never reads the forward-command posture: + // a grounded creature in ANY posture may receive motion + // (GetObjectSequence handles the posture→locomotion transition via + // links). Verified against the live retail-observer trace + // (RetailObserverTraceConformanceTests, 183/183 dispatch conformant). [Theory] + [InlineData(MotionCommand.Fallen)] + [InlineData(MotionCommand.Dead)] [InlineData(MotionCommand.Crouch)] [InlineData(MotionCommand.Sitting)] [InlineData(MotionCommand.Sleeping)] - public void ContactAllowsMove_PostureState_RejectsMove(uint postureCommand) + [InlineData(0x41000012u)] // inside the crouch range (0x41000011, 0x41000015) + public void ContactAllowsMove_GroundedPosture_StillAllowsMove(uint postureCommand) { var body = MakeGrounded(); var interp = MakeInterp(body); @@ -709,20 +503,25 @@ public sealed class MotionInterpreterTests bool allowed = interp.contact_allows_move(MotionCommand.WalkForward); - Assert.False(allowed); + Assert.True(allowed); } [Fact] - public void ContactAllowsMove_CrouchRange_RejectsMove() + public void ContactAllowsMove_AirborneCreature_AcceptsFallingAndTurns_BlocksWalk() { - var body = MakeGrounded(); + // Verbatim 0x00528240: Falling (0x40000015) / Dead-class (0x40000011) + // and TurnLeft/TurnRight are ALWAYS allowed; a gravity-bound creature + // without Contact+OnWalkable is blocked for everything else + // (including the style command, which falls through to the gate). + var body = new PhysicsBody { State = PhysicsStateFlags.Gravity }; var interp = MakeInterp(body); - // 0x41000012 is inside (0x41000011, 0x41000015) — crouch state - interp.InterpretedState.ForwardCommand = 0x41000012u; - bool allowed = interp.contact_allows_move(MotionCommand.WalkForward); - - Assert.False(allowed); + Assert.True(interp.contact_allows_move(MotionCommand.Falling)); + Assert.True(interp.contact_allows_move(0x40000011u)); + Assert.True(interp.contact_allows_move(MotionCommand.TurnRight)); + Assert.True(interp.contact_allows_move(MotionCommand.TurnLeft)); + Assert.False(interp.contact_allows_move(MotionCommand.WalkForward)); + Assert.False(interp.contact_allows_move(0x8000003Du)); } [Fact] @@ -742,8 +541,15 @@ public sealed class MotionInterpreterTests } [Fact] - public void ContactAllowsMove_GroundedAndIdle_SetsStandingLongJump() + public void ContactAllowsMove_GroundedAndIdle_DoesNotSetStandingLongJump() { + // R3-W3 (closes J6): the S2a-flagged misattribution is DELETED. + // Retail arms StandingLongJump ONLY in charge_jump (0x005281c0) — + // contact_allows_move (0x00528240) never reads or writes it. See + // MotionInterpreterJumpFamilyTests.ContactAllowsMove_GroundedAndIdle_DoesNotArmStandingLongJump + // for the full regression pin (both arm and no-clear directions) + // and ChargeJump_GroundedIdle_ArmsStandingLongJump for where the + // arming now actually happens. var body = MakeGrounded(); var interp = MakeInterp(body); // All interpreted commands at default (Ready, no sidestep, no turn) @@ -751,7 +557,7 @@ public sealed class MotionInterpreterTests interp.contact_allows_move(MotionCommand.WalkForward); - Assert.True(interp.StandingLongJump, "Should set StandingLongJump when grounded and idle"); + Assert.False(interp.StandingLongJump, "contact_allows_move must never touch StandingLongJump (J6)"); } // ========================================================================= diff --git a/tests/AcDream.Core.Tests/Physics/MotionNormalizationTests.cs b/tests/AcDream.Core.Tests/Physics/MotionNormalizationTests.cs new file mode 100644 index 00000000..415bf828 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/MotionNormalizationTests.cs @@ -0,0 +1,299 @@ +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +// ───────────────────────────────────────────────────────────────────────────── +// MotionNormalizationTests — Phase D6.1: adjust_motion + apply_run_to_command. +// +// Source addresses tested (docs/research/2026-07-01-d6-motion-interp-pseudocode.md): +// FUN_00528010 (0x00528010) CMotionInterp::adjust_motion +// FUN_00527be0 (0x00527be0) CMotionInterp::apply_run_to_command +// +// Golden constants (retail, verified against ACE MotionInterp.cs byte-for-byte): +// BackwardsFactor = 0.649999976 (0x007c8910) +// WalkAnimSpeed = 3.11999989 (0x007c891c, retail-exact — NOT 3.12f) +// SidestepAnimSpeed = 1.25 +// SidestepFactor = 0.5 +// RunTurnFactor = 1.5 +// MaxSidestepAnimRate = 3.0 +// ───────────────────────────────────────────────────────────────────────────── + +/// +/// Fake WeenieObject for injecting a known run rate into apply_run_to_command / +/// adjust_motion without a real weenie. +/// +file sealed class FakeRunRateWeenie : IWeenieObject +{ + public float RunRate; + public bool InqRunRateResult = true; + + public bool InqJumpVelocity(float extent, out float vz) + { + vz = 0f; + return false; + } + + public bool InqRunRate(out float rate) + { + rate = RunRate; + return InqRunRateResult; + } + + public bool CanJump(float extent) => true; +} + +public sealed class MotionNormalizationTests +{ + // Retail-exact sidestep scale: SidestepFactor(0.5) * (3.11999989 / 1.25) ≈ 1.24799995... + private const float SidestepScale = 0.5f * (3.11999989f / MotionInterpreter.SidestepAnimSpeed); + + private static MotionInterpreter MakeInterp(IWeenieObject? weenie = null) + { + return new MotionInterpreter { WeenieObj = weenie }; + } + + // ── adjust_motion: per-command remap + scale ───────────────────────────── + + [Fact] + public void AdjustMotion_WalkBackward_RemapsToWalkForward_NegatesAndScalesSpeed() + { + // 0x00528010: WalkBackwards -> cmd = WalkForward; speed *= -BackwardsFactor + var interp = MakeInterp(); + uint motion = MotionCommand.WalkBackward; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.None); + + Assert.Equal(MotionCommand.WalkForward, motion); + Assert.Equal(-MotionInterpreter.BackwardsFactor, speed, 5); + Assert.Equal(-0.649999976f, speed, 5); + } + + [Fact] + public void AdjustMotion_TurnLeft_RemapsToTurnRight_NegatesSpeed() + { + var interp = MakeInterp(); + uint motion = MotionCommand.TurnLeft; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.None); + + Assert.Equal(MotionCommand.TurnRight, motion); + Assert.Equal(-1.0f, speed, 5); + } + + [Fact] + public void AdjustMotion_SideStepLeft_RemapsToSideStepRight_NegatesBeforeScale() + { + // Negate happens BEFORE the ×1.248 sidestep scale, so the net factor is -1.248. + var interp = MakeInterp(); + uint motion = MotionCommand.SideStepLeft; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.None); + + Assert.Equal(MotionCommand.SideStepRight, motion); + Assert.Equal(-SidestepScale, speed, 5); + Assert.Equal(-1.24799995f, speed, 4); + } + + [Fact] + public void AdjustMotion_SideStepRight_ScalesSpeed_NoNegate() + { + var interp = MakeInterp(); + uint motion = MotionCommand.SideStepRight; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.None); + + Assert.Equal(MotionCommand.SideStepRight, motion); + Assert.Equal(SidestepScale, speed, 5); + Assert.Equal(1.24799995f, speed, 4); + } + + [Fact] + public void AdjustMotion_RunForward_EarlyReturns_NoScaleNoHoldKeyPath() + { + // GOTCHA: RunForward returns immediately -- no scale AND no holdkey promotion, + // even when holdKey == Run (there's nothing left to promote it to, but the + // early-return also means speed is untouched). + var interp = MakeInterp(new FakeRunRateWeenie { RunRate = 2.94f }); + uint motion = MotionCommand.RunForward; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.Run); + + Assert.Equal(MotionCommand.RunForward, motion); + Assert.Equal(1.0f, speed, 5); + } + + [Fact] + public void AdjustMotion_NonSidestepNonTurnNonForward_Unchanged_ExceptHoldKeyPath() + { + // Ready is not one of the switch cases and not SideStepRight after remap, + // so command/speed pass through unchanged when holdKey doesn't promote it. + var interp = MakeInterp(); + uint motion = MotionCommand.Ready; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.None); + + Assert.Equal(MotionCommand.Ready, motion); + Assert.Equal(1.0f, speed, 5); + } + + // ── adjust_motion: holdKey inheritance + Run promotion ─────────────────── + + [Fact] + public void AdjustMotion_HoldKeyInvalid_FallsBackToCurrentHoldKey_PromotesWalkForwardWhenRun() + { + var interp = MakeInterp(); + interp.RawState.CurrentHoldKey = HoldKey.Run; // R3-W6: CurrentHoldKey aliases RawState + uint motion = MotionCommand.WalkForward; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.Invalid); + + // apply_run_to_command: WalkForward + speed>0 -> RunForward; speed *= speedMod (1.0, no weenie). + Assert.Equal(MotionCommand.RunForward, motion); + Assert.Equal(1.0f, speed, 5); + } + + [Fact] + public void AdjustMotion_HoldKeyNone_DoesNotPromote() + { + var interp = MakeInterp(); + interp.RawState.CurrentHoldKey = HoldKey.Run; // R3-W6: CurrentHoldKey aliases RawState + uint motion = MotionCommand.WalkForward; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.None); + + Assert.Equal(MotionCommand.WalkForward, motion); + Assert.Equal(1.0f, speed, 5); + } + + [Fact] + public void AdjustMotion_HoldKeyRunPassedDirectly_PromotesWalkForward() + { + var interp = MakeInterp(new FakeRunRateWeenie { RunRate = 2.75f }); + uint motion = MotionCommand.WalkForward; + float speed = 1.0f; + + interp.adjust_motion(ref motion, ref speed, HoldKey.Run); + + Assert.Equal(MotionCommand.RunForward, motion); + Assert.Equal(2.75f, speed, 5); + } + + // ── apply_run_to_command ────────────────────────────────────────────────── + + [Fact] + public void ApplyRunToCommand_WalkForward_PositiveSpeed_PromotesToRunForward_ScalesByRunRate() + { + var interp = MakeInterp(new FakeRunRateWeenie { RunRate = 2.94f }); + uint motion = MotionCommand.WalkForward; + float speed = 1.0f; + + interp.apply_run_to_command(ref motion, ref speed); + + Assert.Equal(MotionCommand.RunForward, motion); + Assert.Equal(2.94f, speed, 5); + } + + [Fact] + public void ApplyRunToCommand_WalkForward_NegativeSpeed_StaysWalkForward_ScalesUnconditionally() + { + // GOTCHA: speed *= speedMod is UNCONDITIONAL -- backward (negative speed) + // still gets run-scaled even though it is NOT promoted to RunForward. + var interp = MakeInterp(new FakeRunRateWeenie { RunRate = 2.94f }); + uint motion = MotionCommand.WalkForward; + float speed = -0.649999976f; + + interp.apply_run_to_command(ref motion, ref speed); + + Assert.Equal(MotionCommand.WalkForward, motion); + Assert.Equal(-0.649999976f * 2.94f, speed, 4); + } + + [Fact] + public void ApplyRunToCommand_TurnRight_ScalesByRunTurnFactor_NoRunRateNoClamp() + { + var interp = MakeInterp(new FakeRunRateWeenie { RunRate = 2.94f }); + uint motion = MotionCommand.TurnRight; + float speed = 1.0f; + + interp.apply_run_to_command(ref motion, ref speed); + + Assert.Equal(MotionCommand.TurnRight, motion); + Assert.Equal(1.5f, speed, 5); + } + + [Fact] + public void ApplyRunToCommand_SideStepRight_BelowClamp_ScalesByRunRate() + { + var interp = MakeInterp(new FakeRunRateWeenie { RunRate = 2.0f }); + uint motion = MotionCommand.SideStepRight; + float speed = 1.0f; + + interp.apply_run_to_command(ref motion, ref speed); + + Assert.Equal(MotionCommand.SideStepRight, motion); + Assert.Equal(2.0f, speed, 5); + } + + [Fact] + public void ApplyRunToCommand_SideStepRight_AbovePositiveClamp_ClampsToPositiveMax() + { + // runRate 2.94 * speed 1.248 (post adjust_motion sidestep scale) ≈ 3.669 > 3.0 + var interp = MakeInterp(new FakeRunRateWeenie { RunRate = 2.94f }); + uint motion = MotionCommand.SideStepRight; + float speed = 1.24799995f; + + interp.apply_run_to_command(ref motion, ref speed); + + Assert.Equal(MotionCommand.SideStepRight, motion); + Assert.Equal(3.0f, speed, 5); + } + + [Fact] + public void ApplyRunToCommand_SideStepRight_AboveNegativeClamp_ClampsToNegativeMax() + { + var interp = MakeInterp(new FakeRunRateWeenie { RunRate = 2.94f }); + uint motion = MotionCommand.SideStepRight; + float speed = -1.24799995f; + + interp.apply_run_to_command(ref motion, ref speed); + + Assert.Equal(MotionCommand.SideStepRight, motion); + Assert.Equal(-3.0f, speed, 5); + } + + [Fact] + public void ApplyRunToCommand_UsesMyRunRate_WhenInqRunRateFails() + { + var weenie = new FakeRunRateWeenie { RunRate = 999f, InqRunRateResult = false }; + var interp = MakeInterp(weenie); + interp.MyRunRate = 1.5f; + uint motion = MotionCommand.WalkForward; + float speed = 1.0f; + + interp.apply_run_to_command(ref motion, ref speed); + + Assert.Equal(MotionCommand.RunForward, motion); + Assert.Equal(1.5f, speed, 5); + } + + [Fact] + public void ApplyRunToCommand_NoWeenie_SpeedModDefaultsToOne() + { + var interp = MakeInterp(weenie: null); + uint motion = MotionCommand.SideStepRight; + float speed = 1.0f; + + interp.apply_run_to_command(ref motion, ref speed); + + Assert.Equal(1.0f, speed, 5); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/MotionSequenceGateTests.cs b/tests/AcDream.Core.Tests/Physics/MotionSequenceGateTests.cs new file mode 100644 index 00000000..30430faf --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/MotionSequenceGateTests.cs @@ -0,0 +1,175 @@ +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// Covers — the inbound movement-event +/// staleness gate ported from retail (L.2g S1, deviation DEV-6): +/// +/// +/// CPhysicsObj::is_newer (0x00451ad0) — the wraparound u16 +/// timestamp compare (ACE PhysicsObj.is_newer confirms the +/// semantics; the BN pseudo-C return values are setcc-garbled). +/// The 0xF74C dispatch INSTANCE_TS gate +/// (ACSmartBox::DispatchSmartBoxEvent, +/// acclient_2013_pseudo_c.txt:357214-357239): stale incarnation → drop +/// BEFORE any movement stamp is touched. +/// CPhysics::SetObjectMovement (0x00509690, +/// acclient_2013_pseudo_c.txt:271370): MOVEMENT_TS accepts only strictly +/// newer sequences and stamps BEFORE the server-control gate; +/// SERVER_CONTROLLED_MOVE_TS drops when the stored stamp is strictly +/// newer than the incoming one (equal passes). +/// +/// +public class MotionSequenceGateTests +{ + // CPhysicsObj::is_newer(old, new): abs(new-old) > 0x7fff ? new < old : old < new. + [Theory] + [InlineData((ushort)0, (ushort)1, true)] // simple newer + [InlineData((ushort)1, (ushort)0, false)] // simple older + [InlineData((ushort)5, (ushort)5, false)] // equal is not newer + [InlineData((ushort)0, (ushort)0x7FFF, true)] // abs diff exactly 0x7fff → normal compare + [InlineData((ushort)0, (ushort)0x8000, false)] // abs diff 0x8000 → wraparound branch + [InlineData((ushort)0xFFFF, (ushort)0, true)] // 0 is newer than 0xFFFF (wrap) + [InlineData((ushort)0xFFFE, (ushort)2, true)] // newer across the seam + [InlineData((ushort)2, (ushort)0xFFFE, false)] // older across the seam + public void IsNewer_MatchesRetailWraparoundCompare(ushort oldStamp, ushort newStamp, bool expected) + { + Assert.Equal(expected, MotionSequenceGate.IsNewer(oldStamp, newStamp)); + } + + [Fact] + public void FirstEvent_WithFreshMovementSequence_IsAccepted() + { + var gate = new MotionSequenceGate(); + Assert.True(gate.TryAcceptMovementEvent(instanceSeq: 0, movementSeq: 1, serverControlSeq: 0)); + } + + [Fact] + public void DuplicateMovementSequence_IsDropped() + { + // Gate 1 accepts strictly-newer only — an identical movementSeq is a + // duplicate delivery, not a new command. + var gate = new MotionSequenceGate(); + Assert.True(gate.TryAcceptMovementEvent(0, 5, 0)); + Assert.False(gate.TryAcceptMovementEvent(0, 5, 0)); + } + + [Fact] + public void StaleMovementSequence_IsDropped_ThenNewerAccepted() + { + var gate = new MotionSequenceGate(); + Assert.True(gate.TryAcceptMovementEvent(0, 5, 0)); + Assert.False(gate.TryAcceptMovementEvent(0, 4, 0)); // reordered straggler + Assert.True(gate.TryAcceptMovementEvent(0, 6, 0)); + } + + [Fact] + public void MovementSequence_WrapsAroundTheU16Seam() + { + // Stamps live in u16 space and wrap; retail seeds them from the + // CreateObject PhysicsDesc timestamp block, so a gate near the seam + // must accept the post-wrap values as newer. + var gate = new MotionSequenceGate(); + gate.Seed(instanceSeq: 0, movementSeq: 0xFFFD, serverControlSeq: 0); + Assert.True(gate.TryAcceptMovementEvent(0, 0xFFFE, 0)); + Assert.True(gate.TryAcceptMovementEvent(0, 2, 0)); // 2 is newer than 0xFFFE by wrap rule + Assert.False(gate.TryAcceptMovementEvent(0, 0xFFFE, 0)); // and the old stamp is now stale + } + + [Fact] + public void SeededGate_AcceptsNextSequence_RejectsThePast() + { + // The exact case zero-init would break: spawning near a long-lived + // entity whose movement sequence is already past 0x8000. Retail + // seeds update_times from CreateObject's PhysicsDesc timestamps + // (ACE WorldObject_Networking.cs:411-420 writes all 9 in enum + // order), so the first UM after spawn is judged against the + // seeded stamp, not zero. + var gate = new MotionSequenceGate(); + gate.Seed(instanceSeq: 3, movementSeq: 0x9000, serverControlSeq: 2); + Assert.True(gate.TryAcceptMovementEvent(3, 0x9001, 2)); + Assert.False(gate.TryAcceptMovementEvent(3, 0x8FFF, 2)); // pre-spawn straggler + } + + [Fact] + public void Reseed_WithOlderStamps_DoesNotRegress() + { + // The #138 rehydrate path replays RETAINED CreateObject spawns + // through the normal spawn handler (GameWindow.RehydrateServerEntities + // ForLandblock) — re-seeding from that cached spawn must not roll the + // live stamps backward, or a post-rehydrate straggler UM would be + // accepted as fresh. First Seed adopts wholesale (fresh object); + // later Seeds only advance. + var gate = new MotionSequenceGate(); + gate.Seed(instanceSeq: 3, movementSeq: 0x9000, serverControlSeq: 2); + Assert.True(gate.TryAcceptMovementEvent(3, 0x9001, 2)); + + gate.Seed(instanceSeq: 3, movementSeq: 0x8000, serverControlSeq: 2); // stale replay + Assert.False(gate.TryAcceptMovementEvent(3, 0x9001, 2)); // still a duplicate + Assert.True(gate.TryAcceptMovementEvent(3, 0x9002, 2)); + + gate.Seed(instanceSeq: 4, movementSeq: 0x9010, serverControlSeq: 2); // genuine re-create + Assert.False(gate.TryAcceptMovementEvent(3, 0x9011, 2)); // old incarnation stale + Assert.True(gate.TryAcceptMovementEvent(4, 0x9011, 2)); + } + + [Fact] + public void StaleServerControl_Drops_ButMovementStampStillAdvances() + { + // Retail stamps MOVEMENT_TS BEFORE evaluating the server-control gate + // (0x00509690: update_times[1] written at 0x005096dd, the SC compare + // runs after) — a movement event dropped for stale server-control + // still consumes its movement sequence. + var gate = new MotionSequenceGate(); + Assert.True(gate.TryAcceptMovementEvent(0, 1, 5)); + Assert.False(gate.TryAcceptMovementEvent(0, 2, 4)); // sc=4 older than stored 5 → drop + Assert.False(gate.TryAcceptMovementEvent(0, 2, 5)); // movementSeq 2 was consumed by the drop + Assert.True(gate.TryAcceptMovementEvent(0, 3, 5)); // next movementSeq proceeds + } + + [Fact] + public void EqualServerControl_Passes() + { + // The SC gate drops only when the STORED stamp is strictly newer than + // the incoming one; equal means "same server-control era" and applies. + var gate = new MotionSequenceGate(); + Assert.True(gate.TryAcceptMovementEvent(0, 1, 7)); + Assert.True(gate.TryAcceptMovementEvent(0, 2, 7)); + } + + [Fact] + public void StaleInstance_Drops_WithoutConsumingMovementSequence() + { + // The INSTANCE_TS gate runs at dispatch level, BEFORE + // CPhysics::SetObjectMovement — a stale-incarnation event must not + // touch the movement stamps. + var gate = new MotionSequenceGate(); + Assert.True(gate.TryAcceptMovementEvent(2, 1, 0)); + Assert.False(gate.TryAcceptMovementEvent(1, 2, 0)); // stale incarnation + Assert.True(gate.TryAcceptMovementEvent(2, 2, 0)); // seq 2 was NOT consumed by the instance drop + } + + [Fact] + public void NewerInstance_IsAdoptedAndApplied() + { + // DIVERGENCE (register row added with this port): retail queues the + // blob until the newer incarnation exists (SmartBox::QueueBlobForObject, + // dispatch return 4); acdream adopts the newer instance stamp and + // applies immediately. + var gate = new MotionSequenceGate(); + Assert.True(gate.TryAcceptMovementEvent(1, 1, 0)); + Assert.True(gate.TryAcceptMovementEvent(2, 2, 0)); // newer incarnation adopted + Assert.False(gate.TryAcceptMovementEvent(1, 3, 0)); // old incarnation now stale + } + + [Fact] + public void InstanceCompare_WrapsAroundTheU16Seam() + { + var gate = new MotionSequenceGate(); + gate.Seed(instanceSeq: 0xFFFE, movementSeq: 0, serverControlSeq: 0); + Assert.True(gate.TryAcceptMovementEvent(0xFFFE, 1, 0)); + Assert.True(gate.TryAcceptMovementEvent(2, 2, 0)); // instance 2 newer than 0xFFFE by wrap + } +} diff --git a/tests/AcDream.Core.Tests/Physics/MotionVelocityPipelineTests.cs b/tests/AcDream.Core.Tests/Physics/MotionVelocityPipelineTests.cs new file mode 100644 index 00000000..7df939fc --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/MotionVelocityPipelineTests.cs @@ -0,0 +1,217 @@ +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +// ───────────────────────────────────────────────────────────────────────────── +// MotionVelocityPipelineTests — Phase D6.2: the full raw→interpreted→velocity +// pipeline (apply_raw_movement 0x005287e0 → get_state_velocity 0x00527d50). +// +// These pin the retail-faithful LOCAL velocity for every direction — the exact +// behavior the D6.2 controller integration now routes through, replacing the +// hand-mirrored backward/strafe formulas (register TS-22). Golden values are +// derived from the pseudocode doc +// (docs/research/2026-07-01-d6-motion-interp-pseudocode.md) and the retail +// constants on MotionInterpreter. +// +// Notable retail-faithful change vs the old hand-mirror: strafe is now +// 1.25 × (0.5·WalkAnimSpeed/SidestepAnimSpeed) × runRate = ~1.56 × runRate, +// clamped via SideStepSpeed ≤ 3.0 (so |v.X| ≤ 3.75). The old code used +// 1.25 × runRate with no sidestep-scale and no clamp. +// ───────────────────────────────────────────────────────────────────────────── + +file sealed class FakeRunRateWeenie : IWeenieObject +{ + public float RunRate; + public bool InqRunRateResult = true; + public bool InqJumpVelocity(float extent, out float vz) { vz = 0f; return false; } + public bool InqRunRate(out float rate) { rate = RunRate; return InqRunRateResult; } + public bool CanJump(float extent) => true; +} + +public sealed class MotionVelocityPipelineTests +{ + private const float RunRate = 2.75f; // ≈ the +Acdream test char's run rate + + private const float WalkAnim = MotionInterpreter.WalkAnimSpeed; // 3.11999989 + private const float RunAnim = MotionInterpreter.RunAnimSpeed; // 4.0 + private const float SideAnim = MotionInterpreter.SidestepAnimSpeed; // 1.25 + private const float BackFac = MotionInterpreter.BackwardsFactor; // 0.649999976 + private const float MaxSide = MotionInterpreter.MaxSidestepAnimRate;// 3.0 + // adjust_motion sidestep scale: 0.5 * (WalkAnim / SideAnim) ≈ 1.24799995 + private const float SideScale = MotionInterpreter.SidestepFactor * (WalkAnim / SideAnim); + + private static MotionInterpreter MakeInterp(float runRate) + => new() { WeenieObj = new FakeRunRateWeenie { RunRate = runRate } }; + + private static RawMotionState Raw( + uint forward = MotionCommand.Ready, uint sidestep = 0u, uint turn = 0u, + HoldKey hold = HoldKey.None) + => new() + { + CurrentHoldKey = hold, + ForwardCommand = forward, + ForwardHoldKey = forward != MotionCommand.Ready ? hold : HoldKey.Invalid, + ForwardSpeed = 1.0f, + SidestepCommand = sidestep, + SidestepHoldKey = sidestep != 0u ? hold : HoldKey.Invalid, + SidestepSpeed = 1.0f, + TurnCommand = turn, + TurnHoldKey = turn != 0u ? hold : HoldKey.Invalid, + TurnSpeed = 1.0f, + }; + + // ── forward ────────────────────────────────────────────────────────────── + + [Fact] + public void RunForward_VelocityIsRunAnimSpeedTimesRunRate() + { + var interp = MakeInterp(RunRate); + interp.apply_raw_movement(Raw(forward: MotionCommand.WalkForward, hold: HoldKey.Run)); + + // WalkForward + Run → RunForward @ runRate; v.Y = RunAnim * runRate (== maxSpeed, no clamp). + var v = interp.get_state_velocity(); + Assert.Equal(RunAnim * RunRate, v.Y, 3); + Assert.Equal(0f, v.X, 5); + } + + [Fact] + public void WalkForward_NoRun_VelocityIsWalkAnimSpeed() + { + var interp = MakeInterp(RunRate); + interp.apply_raw_movement(Raw(forward: MotionCommand.WalkForward, hold: HoldKey.None)); + + var v = interp.get_state_velocity(); + Assert.Equal(WalkAnim * 1.0f, v.Y, 3); // no run scaling; WalkForward @ 1.0 + } + + // ── backward (the TS-22 fix: no longer zero) ───────────────────────────── + + [Fact] + public void RunBackward_VelocityIsNegativeWalkTimesBackwardFactorTimesRunRate() + { + var interp = MakeInterp(RunRate); + interp.apply_raw_movement(Raw(forward: MotionCommand.WalkBackward, hold: HoldKey.Run)); + + // WalkBackward → WalkForward, speed *= -0.65; Run → *= runRate (unconditional, + // promotion sign-gated so it stays WalkForward). v.Y = WalkAnim * (-0.65 * runRate). + var v = interp.get_state_velocity(); + Assert.Equal(-(WalkAnim * BackFac * RunRate), v.Y, 3); + Assert.True(v.Y < 0f, "backward velocity must be negative"); + // Matches the OLD hand-mirror (WalkAnim * 0.65 * runMul) — backward is unchanged. + } + + // ── strafe (retail-faithful magnitude + ±3.0 clamp) ────────────────────── + + [Fact] + public void RunStrafeRight_ClampsSideStepSpeedToThree_VelocityIs3p75() + { + var interp = MakeInterp(RunRate); // 1.248*2.75 = 3.432 > 3.0 → clamps + interp.apply_raw_movement(Raw(sidestep: MotionCommand.SideStepRight, hold: HoldKey.Run)); + + var v = interp.get_state_velocity(); + Assert.Equal(SideAnim * MaxSide, v.X, 3); // 1.25 * 3.0 = 3.75 + Assert.Equal(3.75f, v.X, 3); + Assert.Equal(0f, v.Y, 5); + } + + [Fact] + public void RunStrafeRight_BelowClamp_VelocityIsScaledSidestep() + { + const float lowRun = 2.0f; // 1.248*2.0 = 2.496 < 3.0 → no clamp + var interp = MakeInterp(lowRun); + interp.apply_raw_movement(Raw(sidestep: MotionCommand.SideStepRight, hold: HoldKey.Run)); + + var v = interp.get_state_velocity(); + // v.X = SideAnim * (SideScale * lowRun) = 1.56 * lowRun ≈ 3.12 + Assert.Equal(SideAnim * SideScale * lowRun, v.X, 3); + } + + [Fact] + public void RunStrafeLeft_NegatedAndClamped_VelocityIsNeg3p75() + { + var interp = MakeInterp(RunRate); + interp.apply_raw_movement(Raw(sidestep: MotionCommand.SideStepLeft, hold: HoldKey.Run)); + + // SideStepLeft → SideStepRight, negated → -1.248; *runRate = -3.432; clamp → -3.0. + var v = interp.get_state_velocity(); + Assert.Equal(-(SideAnim * MaxSide), v.X, 3); // -3.75 + Assert.True(v.X < 0f, "strafe-left velocity must be negative"); + } + + // ── turn (drives the local Yaw omega: base π/2 × TurnSpeed) ─────────────── + + [Fact] + public void RunTurnRight_InterpretedTurnSpeedIsPositiveRunTurnFactor() + { + var interp = MakeInterp(RunRate); + interp.apply_raw_movement(Raw(turn: MotionCommand.TurnRight, hold: HoldKey.Run)); + + Assert.Equal(MotionCommand.TurnRight, interp.InterpretedState.TurnCommand); + Assert.Equal(MotionInterpreter.RunTurnFactor, interp.InterpretedState.TurnSpeed, 5); // +1.5 + } + + [Fact] + public void RunTurnLeft_RemapsToTurnRightWithNegativeRunTurnFactor() + { + var interp = MakeInterp(RunRate); + interp.apply_raw_movement(Raw(turn: MotionCommand.TurnLeft, hold: HoldKey.Run)); + + // TurnLeft → TurnRight, speed *= -1; Run → *= 1.5 → -1.5. + Assert.Equal(MotionCommand.TurnRight, interp.InterpretedState.TurnCommand); + Assert.Equal(-MotionInterpreter.RunTurnFactor, interp.InterpretedState.TurnSpeed, 5); // -1.5 + } + + [Fact] + public void WalkTurn_NoRun_TurnSpeedIsUnity() + { + var interp = MakeInterp(RunRate); + interp.apply_raw_movement(Raw(turn: MotionCommand.TurnRight, hold: HoldKey.None)); + + Assert.Equal(MotionCommand.TurnRight, interp.InterpretedState.TurnCommand); + Assert.Equal(1.0f, interp.InterpretedState.TurnSpeed, 5); // no run factor + } + + // ── idle ───────────────────────────────────────────────────────────────── + + [Fact] + public void Idle_ReadyState_ZeroVelocity() + { + var interp = MakeInterp(RunRate); + interp.apply_raw_movement(Raw()); // Ready, no sidestep/turn + + var v = interp.get_state_velocity(); + Assert.Equal(0f, v.X, 5); + Assert.Equal(0f, v.Y, 5); + } + + // ── attack / non-locomotion forward command (#170) ─────────────────────── + + [Theory] + [InlineData(0x10000062u)] // AttackHigh1 + [InlineData(0x10000063u)] // AttackMed1 + [InlineData(0x10000064u)] // AttackLow1 + [InlineData(0x10000186u)] // AttackHigh4 (shifted late block) + public void AttackForwardCommand_ZeroVelocity(uint attackCommand) + { + // #170: an ATTACK forward command (action-class 0x1000006x/0x100001xx) + // is neither WalkForward (0x45000005) nor RunForward (0x44000007), so + // retail's get_state_velocity (0x00527d50) hits its `else → 0` branch — + // the creature plants its feet instead of coasting at the last run + // velocity. Cross-checked against holtburger grounded_local_velocity + // (`_ => Vector3::zero()`) and the retail decomp. This is the invariant + // the #170 glide fix relies on: GameWindow's remote dead-reckon now + // refreshes the body velocity from get_state_velocity each tick, so a + // creature that switches from a run-chase (ForwardCommand=RunForward) + // to an attack (ForwardCommand=0x1000006x) resolves to zero velocity + // and stops gliding. + var interp = MakeInterp(RunRate); + interp.InterpretedState.ForwardCommand = attackCommand; + interp.InterpretedState.ForwardSpeed = 0.97f; + + var v = interp.get_state_velocity(); + Assert.Equal(0f, v.X, 5); + Assert.Equal(0f, v.Y, 5); + Assert.Equal(0f, v.Z, 5); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/PhysicsBodyTests.cs b/tests/AcDream.Core.Tests/Physics/PhysicsBodyTests.cs index f5593edd..1c936d34 100644 --- a/tests/AcDream.Core.Tests/Physics/PhysicsBodyTests.cs +++ b/tests/AcDream.Core.Tests/Physics/PhysicsBodyTests.cs @@ -162,6 +162,46 @@ public sealed class PhysicsBodyTests Assert.False(body.IsActive); } + [Fact] + public void UpdatePhysicsInternal_zeroes_small_velocity_even_when_airborne() + { + // Retail UpdatePhysicsInternal (0x005107be) zeroes velocity below 0.25 m/s + // UNCONDITIONALLY — NOT gated on OnWalkable. acdream previously gated it on + // OnWalkable; the verbatim rebuild removes the gate. Gravity re-accelerates the + // same frame via the unconditional `Velocity += Acceleration * dt`, so the fall + // still accumulates on Z. + var body = MakeAirborne(); // not Contact, not OnWalkable + body.set_velocity(new Vector3(0.1f, 0f, 0f)); // < 0.25 m/s + body.Acceleration = new Vector3(0f, 0f, PhysicsBody.Gravity); + + body.UpdatePhysicsInternal(1f / 30f); + + Assert.True(MathF.Abs(body.Velocity.X) < 1e-4f, $"X not zeroed: {body.Velocity.X}"); + Assert.True(body.Velocity.Z < 0f, $"gravity did not accumulate: {body.Velocity.Z}"); + } + + // ════════════════════════════════════════════════════════════════════ + // frames_stationary_fall carry state (retail transient_state bits) + // ════════════════════════════════════════════════════════════════════ + + [Fact] + public void TransientStateFlags_has_stationary_bits() + { + // retail transient_state StationaryFall/Stop/Stuck (handle_all_collisions + // pc:282743/282749/282753; seeded back into transition pc:280940-947). + Assert.Equal(0x10u, (uint)TransientStateFlags.StationaryFall); + Assert.Equal(0x20u, (uint)TransientStateFlags.StationaryStop); + Assert.Equal(0x40u, (uint)TransientStateFlags.StationaryStuck); + } + + [Fact] + public void PhysicsBody_has_fsf_and_cached_velocity_defaults() + { + var body = new PhysicsBody(); + Assert.Equal(0, body.FramesStationaryFall); + Assert.Equal(Vector3.Zero, body.CachedVelocity); + } + // ════════════════════════════════════════════════════════════════════ // set_velocity — velocity clamping // ════════════════════════════════════════════════════════════════════ diff --git a/tests/AcDream.Core.Tests/Physics/PhysicsEngineTests.cs b/tests/AcDream.Core.Tests/Physics/PhysicsEngineTests.cs index 26664ad9..b61d4329 100644 --- a/tests/AcDream.Core.Tests/Physics/PhysicsEngineTests.cs +++ b/tests/AcDream.Core.Tests/Physics/PhysicsEngineTests.cs @@ -487,9 +487,20 @@ public class PhysicsEngineTests collisionType: ShadowCollisionType.Cylinder, cylHeight: 1.835f); - // Without the gate (movingEntityId == 0): the sweep must self-push. - // This proves the registry actually causes a collision, so the - // following filtered case is not a vacuous pass. + // Without the gate (movingEntityId == 0): the sweep must be + // INTERFERED WITH by the self-entry. This proves the registry + // actually causes a collision, so the following filtered case is not + // a vacuous pass. + // + // Observable updated for the 2026-07-05 CCylSphere family port: the + // old hand-rolled response radial-pushed the sphere ~1 m sideways + // (the original #42 symptom this test asserted). Retail's dispatcher + // (0x0053b440) resolves this geometry — airborne, dead-center on the + // cylinder axis, moving up — through land_on_cylinder → the Collide + // re-test, whose interp gate hard-stops (COLLIDED); ValidateTransition + // then reverts to a stay-put (no sideways teleport, Ok=true). The + // response-model-independent interference signal is the DENIED +Z + // movement: the sweep must NOT reach the +0.022 target. var unfiltered = engine.ResolveWithTransition( currentPos: bodyPos, targetPos: targetPos, cellId: 0xA9B40039u, @@ -498,11 +509,11 @@ public class PhysicsEngineTests isOnGround: false, movingEntityId: 0u); - float unfilteredXY = MathF.Sqrt( - (unfiltered.Position.X - targetPos.X) * (unfiltered.Position.X - targetPos.X) + - (unfiltered.Position.Y - targetPos.Y) * (unfiltered.Position.Y - targetPos.Y)); - Assert.True(unfilteredXY > 0.5f, - $"Without movingEntityId, sweep should self-push (got XY drift {unfilteredXY:F3}m)"); + Assert.True(unfiltered.Position.Z < targetPos.Z - 0.01f, + $"Without movingEntityId, the sweep must collide with the mover's own " + + $"ShadowEntry and deny the +Z movement (retail: land_on_cylinder → " + + $"Collide re-test → COLLIDED → stay-put). Got Z={unfiltered.Position.Z:F4}, " + + $"target Z={targetPos.Z:F4}"); // With the gate: the sweep must leave XY unchanged. var filtered = engine.ResolveWithTransition( diff --git a/tests/AcDream.Core.Tests/Physics/RemoteDeOverlapMechanismTests.cs b/tests/AcDream.Core.Tests/Physics/RemoteDeOverlapMechanismTests.cs new file mode 100644 index 00000000..b86e25e3 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/RemoteDeOverlapMechanismTests.cs @@ -0,0 +1,457 @@ +using System; +using System.Numerics; +using AcDream.Core.Physics; +using Xunit; +using Xunit.Abstractions; + +namespace AcDream.Core.Tests.Physics; + +/// +/// Mechanism validation for the remote-creature de-overlap redo (#184). +/// +/// The reported symptom: packed monsters interpenetrate in acdream but barely in retail on +/// the SAME ACE. Retail de-overlaps them CLIENT-side by running the collision sweep on every +/// remote creature every tick against its neighbours' LIVE positions (the shadow == the +/// resolved m_position), with the server position a gentle catch-up target. +/// +/// The first attempt (reverted commit 9c0849dd) synced the broadphase shadow to the RAW +/// server position and never to the resolved body — so each creature de-overlapped against a +/// STALE overlapping shadow and any separation was discarded on the next update. These tests +/// prove, in Core, the two load-bearing facts BEFORE wiring GameWindow (so we don't spend +/// another visual gate on an unproven mechanism): +/// +/// 1. catch-up (approach the target) + ResolveWithTransition sweep + shadow-follows-resolved +/// => two converging creatures SETTLE at contact-distance (sum of radii), not overlapping +/// — the PROACTIVE de-overlap (each is stopped short of its overlapping target by its +/// neighbour) and PERSISTENCE (the stopped position holds because the shadow tracks it). +/// +/// 2. the SAME loop WITHOUT the shadow-follows-resolved sync (shadow left at each creature's +/// START / server-truth position) => the creatures OVERLAP — proving the sync is +/// load-bearing, not a residual (all three Slice-1 reviewers flagged this; it was wrongly +/// deferred). +/// +/// Grounded creature-vs-creature, flat terrain, purely-horizontal convergence so the vertical +/// axis is stable and the assertion is about XY separation. Sphere dims = the human Setup +/// (R 0.48, capsule top 1.835 — TS-46). Mirrors the Path B sweep call in GameWindow +/// (isOnGround, EdgeSlide, self-skip via movingEntityId). +/// +public class RemoteDeOverlapMechanismTests +{ + private readonly ITestOutputHelper _out; + public RemoteDeOverlapMechanismTests(ITestOutputHelper output) => _out = output; + + private const uint Lb = 0xA9B40000u; + private const uint Cell = Lb | 0x0001u; + private const float R = 0.48f, H = 1.835f, StepUp = 0.60f, StepDown = 0.60f; + private const float ContactDist = 2f * R; // 0.96 m centre-to-centre when just touching + private const float GroundZ = R; // foot sphere resting on the flat (Z=0) terrain + private const float StepPerTick = 0.03f; // catch-up step magnitude toward the target + // The pair freezes at the first-contact position, so the residual overlap at rest is ~one + // catch-up step (validate_transition restores curr_pos on the step that would deepen the + // overlap). Accept up to ~2 steps of slack; a finer step settles nearer ContactDist. + private const float SettleSlack = 2f * StepPerTick + 0.01f; + + private static PhysicsEngine BuildEngine() + { + var engine = new PhysicsEngine { DataCache = new PhysicsDataCache() }; + engine.AddLandblock(Lb, new TerrainSurface(new byte[81], new float[256]), + Array.Empty(), Array.Empty(), 0f, 0f); + return engine; + } + + private static void RegisterCreatureAt(PhysicsEngine e, uint id, Vector3 c) + => e.ShadowObjects.Register(id, 0u, c, Quaternion.Identity, R, + 0f, 0f, Lb, ShadowCollisionType.Sphere, 0f, 1f, 0u, + EntityCollisionFlags.IsCreature, isStatic: false); + + // #184 Slice 2b: a PLAYER remote's shadow — flagged IsPlayer (BF_PLAYER, + // 0x8 → EntityCollisionFlags.IsPlayer) and IsCreature (a player IS an + // ItemType.Creature). Non-PK (no IsPK/IsPKLite), so the PvP walk-through + // exemption's only live disqualifier would be an IsPlayer *mover* — which + // the production remote sweep never sets (it passes moverFlags: EdgeSlide). + private static void RegisterPlayerAt(PhysicsEngine e, uint id, Vector3 c) + => e.ShadowObjects.Register(id, 0u, c, Quaternion.Identity, R, + 0f, 0f, Lb, ShadowCollisionType.Sphere, 0f, 1f, 0u, + EntityCollisionFlags.IsPlayer | EntityCollisionFlags.IsCreature, isStatic: false); + + private static PhysicsBody GroundedBody(Vector3 pos) => new PhysicsBody + { + Position = pos, + Orientation = Quaternion.Identity, + State = PhysicsStateFlags.ReportCollisions, + TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable + | TransientStateFlags.Active, + Velocity = Vector3.Zero, + }; + + /// One catch-up-step + sweep for one creature (human dims); returns the resolved position. + private Vector3 StepToward(PhysicsEngine engine, uint id, PhysicsBody body, ref uint cell, + Vector3 target) + => StepToward(engine, id, body, ref cell, target, R, H); + + /// One catch-up-step + sweep with an explicit mover radius/height (Slice 3). + private Vector3 StepToward(PhysicsEngine engine, uint id, PhysicsBody body, ref uint cell, + Vector3 target, float radius, float height) + { + Vector3 pre = body.Position; + Vector3 flatTarget = new Vector3(target.X, target.Y, pre.Z); + Vector3 delta = flatTarget - pre; + float dist = delta.Length(); + Vector3 post = dist <= StepPerTick ? flatTarget : pre + delta / dist * StepPerTick; + + var r = engine.ResolveWithTransition(pre, post, cell, radius, height, StepUp, StepDown, + isOnGround: true, body: body, + moverFlags: ObjectInfoState.EdgeSlide, + movingEntityId: id); + + body.Position = r.Position; + if (r.CellId != 0) cell = r.CellId; + return body.Position; + } + + [Fact] + public void ConvergingCreatures_WithShadowFollowingResolved_SettleAtContactDistance() + { + var engine = BuildEngine(); + + // Two creatures 2 m apart (well clear), each catching up toward the SAME centre point + // (10,10) — if either reached it they would coincide (full overlap). The sweep must stop + // each short at contact-distance from the other. + uint idA = 0xA1u, idB = 0xB2u; + var target = new Vector3(10f, 10f, GroundZ); + var a = GroundedBody(new Vector3(9f, 10f, GroundZ)); + var b = GroundedBody(new Vector3(11f, 10f, GroundZ)); + RegisterCreatureAt(engine, idA, a.Position); + RegisterCreatureAt(engine, idB, b.Position); + uint cellA = Cell, cellB = Cell; + + float sepAt = 0f; + for (int tick = 0; tick < 250; tick++) + { + // Creature A: catch-up + sweep against B's CURRENT shadow, then sync A's shadow to + // the resolved body (retail: change_cell from the resolved m_position). + var pa = StepToward(engine, idA, a, ref cellA, target); + engine.ShadowObjects.UpdatePosition(idA, pa, Quaternion.Identity, 0f, 0f, Lb, seedCellId: cellA); + + var pb = StepToward(engine, idB, b, ref cellB, target); + engine.ShadowObjects.UpdatePosition(idB, pb, Quaternion.Identity, 0f, 0f, Lb, seedCellId: cellB); + + float s = Vector2.Distance(new(a.Position.X, a.Position.Y), new(b.Position.X, b.Position.Y)); + if (tick == 200) sepAt = s; // separation snapshot 50 ticks before the end + if (tick % 50 == 0 || tick == 249) + _out.WriteLine($"tick{tick,3}: A=({a.Position.X:F2},{a.Position.Y:F2}) " + + $"B=({b.Position.X:F2},{b.Position.Y:F2}) sep={s:F3}"); + } + + float sep = Vector2.Distance(new(a.Position.X, a.Position.Y), + new(b.Position.X, b.Position.Y)); + _out.WriteLine($"with-sync final sep={sep:F3} m (contact-distance = {ContactDist:F2} m)"); + // The sweep de-overlaps them to a stable equilibrium ~0.10 m inside touching-distance + // ("barely overlapping" — the retail look), from a start where, without the sync, they + // fully coincide. Assert: clearly de-overlapped (>= 0.80 m, i.e. within ~0.16 of contact) ... + Assert.True(sep >= ContactDist - 0.16f, + $"converging creatures must de-overlap to near contact-distance; got {sep:F3} m (contact {ContactDist:F2})"); + // ... and STABLE (not collapsing back into overlap over the last 50 ticks). + Assert.True(MathF.Abs(sep - sepAt) < 0.02f, + $"the de-overlapped separation must be stable; drifted {sepAt:F3} -> {sep:F3}"); + } + + [Fact] + public void ConvergingCreatures_WithoutShadowSync_Overlap_ProvingTheSyncIsLoadBearing() + { + var engine = BuildEngine(); + + uint idA = 0xA1u, idB = 0xB2u; + var target = new Vector3(10f, 10f, GroundZ); + var a = GroundedBody(new Vector3(9f, 10f, GroundZ)); + var b = GroundedBody(new Vector3(11f, 10f, GroundZ)); + RegisterCreatureAt(engine, idA, a.Position); + RegisterCreatureAt(engine, idB, b.Position); + uint cellA = Cell, cellB = Cell; + + // SAME convergence, but the shadow is NEVER re-synced to the resolved body — it stays at + // each creature's START position (the "shadow at server/stale truth" bug). Each creature + // sweeps against where its neighbour WAS, not where it IS, so nothing stops them reaching + // the shared centre => they end up overlapping. + for (int tick = 0; tick < 250; tick++) + { + StepToward(engine, idA, a, ref cellA, target); + StepToward(engine, idB, b, ref cellB, target); + } + + float sep = Vector2.Distance(new(a.Position.X, a.Position.Y), + new(b.Position.X, b.Position.Y)); + _out.WriteLine($"no-sync final sep={sep:F3} m (contact-distance = {ContactDist:F2} m)"); + // Without the sync each creature sweeps against its neighbour's STALE start-position + // shadow, so nothing stops them reaching the shared centre => they pack well inside + // contact-distance. This is the load-bearing contrast with the synced test above. + Assert.True(sep < 0.40f, + $"without the shadow-follows-resolved sync the creatures should heavily OVERLAP (< 0.40 m — both reach " + + $"the shared centre because each sweeps only its neighbour's stale start-shadow); got {sep:F3} m — " + + $"if this fails the sync may not be the mechanism, rethink before wiring"); + } + + /// + /// Integration test through the PRODUCTION catch-up driver (the #184 review's + /// finding-1 gap): the earlier mechanism tests use a synthetic fixed step, but + /// production drives the body from + /// → , which has a STALL-BLIP: when + /// the body is blocked short of an OVERLAPPING server waypoint (exactly the + /// de-overlap equilibrium) it makes no progress, node_fail_counter climbs past 3 + /// over ~5-frame windows, and it fires a blip-to-tail (a jump straight AT the + /// overlap target) then clears the queue. The concern: if the per-tick sweep does + /// not absorb that blip, the monster pops into its neighbour a few times a second. + /// This drives the REAL loop (Enqueue at UP cadence + ComputeOffset + sweep + + /// shadow-sync) for two creatures converging on a shared point and asserts BOTH + /// that they de-overlap AND that no single tick's net move spikes (the sweep + /// absorbs every blip — matching retail, which runs the same interp + collision). + /// + [Fact] + public void ConvergingCreatures_RealInterpLoop_DeOverlapsAndAbsorbsTheStallBlip() + { + var engine = BuildEngine(); + uint idA = 0xA1u, idB = 0xB2u; + var target = new Vector3(10f, 10f, GroundZ); // shared point → coincide if reached + var a = GroundedBody(new Vector3(9f, 10f, GroundZ)); + var b = GroundedBody(new Vector3(11f, 10f, GroundZ)); + RegisterCreatureAt(engine, idA, a.Position); + RegisterCreatureAt(engine, idB, b.Position); + uint cellA = Cell, cellB = Cell; + + var interpA = new InterpolationManager(); + var interpB = new InterpolationManager(); + var combA = new RemoteMotionCombiner(); + var combB = new RemoteMotionCombiner(); + const float maxSpeed = 4f; // motion-table max speed → catch-up ≤ 2× = 8 m/s + const float dt = 1f / 60f; + const int upEvery = 10; // ~6 Hz UpdatePosition cadence + float maxSpikeA = 0f, maxSpikeB = 0f; + + for (int tick = 0; tick < 600; tick++) // 10 s — long enough for many stall-blip cycles + { + if (tick % upEvery == 0) + { + // "UpdatePosition": the server keeps reporting the (overlapping) target — + // MoveOrTeleport near-branch enqueues it for the catch-up to chase. + interpA.Enqueue(target, 0f, isMovingTo: false, currentBodyPosition: a.Position); + interpB.Enqueue(target, 0f, isMovingTo: false, currentBodyPosition: b.Position); + } + + var preA = a.Position; + a.Position += combA.ComputeOffset(dt, a.Position, Vector3.Zero, a.Orientation, interpA, maxSpeed); + var rA = engine.ResolveWithTransition(preA, a.Position, cellA, R, H, StepUp, StepDown, + isOnGround: true, body: a, moverFlags: ObjectInfoState.EdgeSlide, movingEntityId: idA); + a.Position = rA.Position; if (rA.CellId != 0) cellA = rA.CellId; + engine.ShadowObjects.UpdatePosition(idA, a.Position, Quaternion.Identity, 0f, 0f, Lb, seedCellId: cellA); + + var preB = b.Position; + b.Position += combB.ComputeOffset(dt, b.Position, Vector3.Zero, b.Orientation, interpB, maxSpeed); + var rB = engine.ResolveWithTransition(preB, b.Position, cellB, R, H, StepUp, StepDown, + isOnGround: true, body: b, moverFlags: ObjectInfoState.EdgeSlide, movingEntityId: idB); + b.Position = rB.Position; if (rB.CellId != 0) cellB = rB.CellId; + engine.ShadowObjects.UpdatePosition(idB, b.Position, Quaternion.Identity, 0f, 0f, Lb, seedCellId: cellB); + + // Ignore the initial approach (they start 2 m apart and legitimately move + // ~0.13 m/tick); measure the per-tick net move only once they are near the + // equilibrium where the stall-blip fires. + if (tick > 120) + { + maxSpikeA = MathF.Max(maxSpikeA, Vector2.Distance(new(a.Position.X, a.Position.Y), new(preA.X, preA.Y))); + maxSpikeB = MathF.Max(maxSpikeB, Vector2.Distance(new(b.Position.X, b.Position.Y), new(preB.X, preB.Y))); + } + } + + float sep = Vector2.Distance(new(a.Position.X, a.Position.Y), new(b.Position.X, b.Position.Y)); + _out.WriteLine($"real-interp: sep={sep:F3} m, maxSpike A={maxSpikeA:F3} B={maxSpikeB:F3}"); + Assert.True(sep >= ContactDist - 0.16f, + $"real-loop converging creatures must de-overlap to near contact-distance; got {sep:F3} m"); + // The stall-blip must be absorbed by the sweep every time — no tick jumps the body + // more than a large catch-up step (8 m/s × dt ≈ 0.13 m; allow generous headroom). + Assert.True(maxSpikeA < 0.30f && maxSpikeB < 0.30f, + $"a stall-blip escaped the sweep (monster popped into its neighbour): " + + $"maxSpike A={maxSpikeA:F3} B={maxSpikeB:F3} m (limit 0.30)"); + } + + /// + /// Slice 3 (#184): the de-overlap distance must SCALE with the mover's radius — + /// a LARGE creature (bigger Setup sphere) spreads WIDER than a human, a small one + /// tighter. Production now passes each creature's Setup-derived radius/height + /// (GameWindow.GetSetupCylinder × ObjScale) into this exact sweep instead of the + /// hardcoded human 0.48/1.835. Register + sweep two LARGE creatures (R=0.9) and + /// assert they settle near 2×0.9 = 1.8 m — materially wider than the human 0.96 m + /// contact — proving the sweep de-overlaps at the radius it is given (the property + /// Slice 3 relies on). + /// + [Fact] + public void ConvergingLargeCreatures_DeOverlapWiderThanHuman() + { + const float bigR = 0.9f, bigH = 3.2f; + const float bigContact = 2f * bigR; // 1.80 m centre-to-centre when touching + var engine = BuildEngine(); + uint idA = 0xA1u, idB = 0xB2u; + var target = new Vector3(10f, 10f, bigR); // shared centre → coincide if reached + var a = GroundedBody(new Vector3(7.5f, 10f, bigR)); // start well clear (2.5 m each side) + var b = GroundedBody(new Vector3(12.5f, 10f, bigR)); + engine.ShadowObjects.Register(idA, 0u, a.Position, Quaternion.Identity, bigR, + 0f, 0f, Lb, ShadowCollisionType.Sphere, 0f, 1f, 0u, EntityCollisionFlags.IsCreature, isStatic: false); + engine.ShadowObjects.Register(idB, 0u, b.Position, Quaternion.Identity, bigR, + 0f, 0f, Lb, ShadowCollisionType.Sphere, 0f, 1f, 0u, EntityCollisionFlags.IsCreature, isStatic: false); + uint cellA = Cell, cellB = Cell; + + for (int tick = 0; tick < 300; tick++) + { + var pa = StepToward(engine, idA, a, ref cellA, target, bigR, bigH); + engine.ShadowObjects.UpdatePosition(idA, pa, Quaternion.Identity, 0f, 0f, Lb, seedCellId: cellA); + var pb = StepToward(engine, idB, b, ref cellB, target, bigR, bigH); + engine.ShadowObjects.UpdatePosition(idB, pb, Quaternion.Identity, 0f, 0f, Lb, seedCellId: cellB); + } + + float sep = Vector2.Distance(new(a.Position.X, a.Position.Y), new(b.Position.X, b.Position.Y)); + _out.WriteLine($"large-creature sep={sep:F3} m (big contact {bigContact:F2}, human contact {ContactDist:F2})"); + Assert.True(sep >= bigContact - 0.20f, + $"large creatures must de-overlap near their 2R contact ({bigContact:F2} m); got {sep:F3} m"); + Assert.True(sep > ContactDist + 0.4f, + $"large creatures must spread materially WIDER than the human contact ({ContactDist:F2} m); got {sep:F3} m"); + } + + /// + /// #184 Slice 2b — RETAIL PvP: two non-PK PLAYER remotes must WALK THROUGH each + /// other, NOT de-overlap. Slice 2b collapses the remote fork so grounded players + /// run the sweep, but the production remote-player mover carries + /// (mirroring the LOCAL player at + /// PlayerMovementController), so 's PvP + /// block (mover-IsPlayer AND target-IsPlayer, neither PK/PKLite/Impenetrable) + /// EXEMPTS the pair — you can stand inside another non-PK player in AC. Retail + /// sets IsPlayer on every object's own transition (OBJECTINFO::init 0x0050cf30 + /// state |= 0x100 from its weenie IsPlayer()); FindObjCollisions + /// pc:276812 exempts the non-PK pair. This test drives the real interp loop with + /// two IsPlayer movers converging on a shared point and asserts they reach it + /// (pass through, sep < 0.40 m) instead of stopping at contact-distance. The + /// adversarial review of the first 2b draft caught the missing IsPlayer bit — the + /// draft de-overlapped players (MORE solid than retail). + /// + [Fact] + public void ConvergingPlayers_WalkThroughEachOther_PerRetailPvpExemption() + { + var engine = BuildEngine(); + uint idA = 0x50000001u, idB = 0x50000002u; // player guids (0x50…) + var target = new Vector3(10f, 10f, GroundZ); // shared point → coincide if not blocked + var a = GroundedBody(new Vector3(9f, 10f, GroundZ)); + var b = GroundedBody(new Vector3(11f, 10f, GroundZ)); + RegisterPlayerAt(engine, idA, a.Position); + RegisterPlayerAt(engine, idB, b.Position); + uint cellA = Cell, cellB = Cell; + + var interpA = new InterpolationManager(); + var interpB = new InterpolationManager(); + var combA = new RemoteMotionCombiner(); + var combB = new RemoteMotionCombiner(); + const float maxSpeed = 4f; + const float dt = 1f / 60f; + const int upEvery = 10; + // Production remote-PLAYER mover flags (RemotePhysicsUpdater sweep, IsPlayerGuid branch). + const ObjectInfoState playerMover = ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide; + + for (int tick = 0; tick < 600; tick++) + { + if (tick % upEvery == 0) + { + interpA.Enqueue(target, 0f, isMovingTo: false, currentBodyPosition: a.Position); + interpB.Enqueue(target, 0f, isMovingTo: false, currentBodyPosition: b.Position); + } + + var preA = a.Position; + a.Position += combA.ComputeOffset(dt, a.Position, Vector3.Zero, a.Orientation, interpA, maxSpeed); + var rA = engine.ResolveWithTransition(preA, a.Position, cellA, R, H, StepUp, StepDown, + isOnGround: true, body: a, moverFlags: playerMover, movingEntityId: idA); + a.Position = rA.Position; if (rA.CellId != 0) cellA = rA.CellId; + engine.ShadowObjects.UpdatePosition(idA, a.Position, Quaternion.Identity, 0f, 0f, Lb, seedCellId: cellA); + + var preB = b.Position; + b.Position += combB.ComputeOffset(dt, b.Position, Vector3.Zero, b.Orientation, interpB, maxSpeed); + var rB = engine.ResolveWithTransition(preB, b.Position, cellB, R, H, StepUp, StepDown, + isOnGround: true, body: b, moverFlags: playerMover, movingEntityId: idB); + b.Position = rB.Position; if (rB.CellId != 0) cellB = rB.CellId; + engine.ShadowObjects.UpdatePosition(idB, b.Position, Quaternion.Identity, 0f, 0f, Lb, seedCellId: cellB); + } + + float sep = Vector2.Distance(new(a.Position.X, a.Position.Y), new(b.Position.X, b.Position.Y)); + _out.WriteLine($"player-vs-player (PvP exempt): sep={sep:F3} m (contact {ContactDist:F2})"); + // The PvP exemption fires (both movers IsPlayer, non-PK) → nothing stops them + // reaching the shared centre → they coincide, exactly like the without-sync + // creature case. If this asserts >= contact-distance, the mover lost its + // IsPlayer bit and players are wrongly de-overlapping (MORE solid than retail). + Assert.True(sep < 0.40f, + $"two non-PK player remotes must WALK THROUGH each other (retail PvP exemption); " + + $"got sep={sep:F3} m — if this is near contact-distance the remote mover is missing IsPlayer"); + } + + /// + /// #184 Slice 2b — a PLAYER remote DOES collide with (and de-overlap) a MONSTER, + /// and the #40 stall-blip is absorbed on the IsPlayer mover. This is the other + /// half of the PvP story: the exemption only fires player-vs-player, so a player + /// mover (IsPlayer) vs a creature target (IsCreature, not IsPlayer) proceeds to + /// collision. Drives the real interp loop with a player converging on a monster + /// and asserts (a) they de-overlap to near contact-distance and (b) no tick's net + /// move spikes — proving #40 is dead for the player-mover sweep (the reason Path A + /// omitted it), the property the visual gate can't measure. + /// + [Fact] + public void PlayerVsMonster_DeOverlapsAndAbsorbsTheStallBlip() + { + var engine = BuildEngine(); + uint idPlayer = 0x50000001u, idMonster = 0x80000002u; + var target = new Vector3(10f, 10f, GroundZ); + var p = GroundedBody(new Vector3(9f, 10f, GroundZ)); // player + var m = GroundedBody(new Vector3(11f, 10f, GroundZ)); // monster + RegisterPlayerAt(engine, idPlayer, p.Position); + RegisterCreatureAt(engine, idMonster, m.Position); + uint cellP = Cell, cellM = Cell; + + var interpP = new InterpolationManager(); + var interpM = new InterpolationManager(); + var combP = new RemoteMotionCombiner(); + var combM = new RemoteMotionCombiner(); + const float maxSpeed = 4f; + const float dt = 1f / 60f; + const int upEvery = 10; + const ObjectInfoState playerMover = ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide; + float maxSpikeP = 0f, maxSpikeM = 0f; + + for (int tick = 0; tick < 600; tick++) + { + if (tick % upEvery == 0) + { + interpP.Enqueue(target, 0f, isMovingTo: false, currentBodyPosition: p.Position); + interpM.Enqueue(target, 0f, isMovingTo: false, currentBodyPosition: m.Position); + } + + var preP = p.Position; + p.Position += combP.ComputeOffset(dt, p.Position, Vector3.Zero, p.Orientation, interpP, maxSpeed); + var rP = engine.ResolveWithTransition(preP, p.Position, cellP, R, H, StepUp, StepDown, + isOnGround: true, body: p, moverFlags: playerMover, movingEntityId: idPlayer); + p.Position = rP.Position; if (rP.CellId != 0) cellP = rP.CellId; + engine.ShadowObjects.UpdatePosition(idPlayer, p.Position, Quaternion.Identity, 0f, 0f, Lb, seedCellId: cellP); + + var preM = m.Position; + m.Position += combM.ComputeOffset(dt, m.Position, Vector3.Zero, m.Orientation, interpM, maxSpeed); + var rM = engine.ResolveWithTransition(preM, m.Position, cellM, R, H, StepUp, StepDown, + isOnGround: true, body: m, moverFlags: ObjectInfoState.EdgeSlide, movingEntityId: idMonster); + m.Position = rM.Position; if (rM.CellId != 0) cellM = rM.CellId; + engine.ShadowObjects.UpdatePosition(idMonster, m.Position, Quaternion.Identity, 0f, 0f, Lb, seedCellId: cellM); + + if (tick > 120) + { + maxSpikeP = MathF.Max(maxSpikeP, Vector2.Distance(new(p.Position.X, p.Position.Y), new(preP.X, preP.Y))); + maxSpikeM = MathF.Max(maxSpikeM, Vector2.Distance(new(m.Position.X, m.Position.Y), new(preM.X, preM.Y))); + } + } + + float sep = Vector2.Distance(new(p.Position.X, p.Position.Y), new(m.Position.X, m.Position.Y)); + _out.WriteLine($"player-vs-monster: sep={sep:F3} m, maxSpike P={maxSpikeP:F3} M={maxSpikeM:F3}"); + Assert.True(sep >= ContactDist - 0.16f, + $"a player converging on a monster must de-overlap to near contact-distance (no PvP exemption vs a creature); got {sep:F3} m"); + Assert.True(maxSpikeP < 0.30f && maxSpikeM < 0.30f, + $"#40 reintroduced for the player mover — a stall-blip escaped the sweep: maxSpike P={maxSpikeP:F3} M={maxSpikeM:F3} m (limit 0.30)"); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/PositionManagerTests.cs b/tests/AcDream.Core.Tests/Physics/RemoteMotionCombinerTests.cs similarity index 97% rename from tests/AcDream.Core.Tests/Physics/PositionManagerTests.cs rename to tests/AcDream.Core.Tests/Physics/RemoteMotionCombinerTests.cs index 2920d65c..e6d4300f 100644 --- a/tests/AcDream.Core.Tests/Physics/PositionManagerTests.cs +++ b/tests/AcDream.Core.Tests/Physics/RemoteMotionCombinerTests.cs @@ -6,18 +6,19 @@ using Xunit; namespace AcDream.Core.Tests.Physics; // ───────────────────────────────────────────────────────────────────────────── -// PositionManagerTests — 6 tests covering ComputeOffset. +// RemoteMotionCombinerTests — 6 tests covering ComputeOffset (class renamed R5 +// from PositionManager; see RemoteMotionCombiner's class doc). // // Mirrors retail CPhysicsObj::UpdateObjectInternal (acclient @ 0x00513730). // Pure-function combiner: animation root motion (seqVel × dt, rotated by // body orientation) + InterpolationManager.AdjustOffset correction. // ───────────────────────────────────────────────────────────────────────────── -public sealed class PositionManagerTests +public sealed class RemoteMotionCombinerTests { // ── helpers ─────────────────────────────────────────────────────────────── - private static PositionManager Make() => new(); + private static RemoteMotionCombiner Make() => new(); private static InterpolationManager EmptyInterp() => new(); diff --git a/tests/AcDream.Core.Tests/Physics/RemoteMoveToDriverTests.cs b/tests/AcDream.Core.Tests/Physics/RemoteMoveToDriverTests.cs deleted file mode 100644 index 659452a6..00000000 --- a/tests/AcDream.Core.Tests/Physics/RemoteMoveToDriverTests.cs +++ /dev/null @@ -1,330 +0,0 @@ -using System; -using System.Numerics; -using AcDream.Core.Physics; -using Xunit; - -namespace AcDream.Core.Tests.Physics; - -/// -/// Phase L.1c (2026-04-28). Covers — the -/// per-tick steering port of retail -/// MoveToManager::HandleMoveToPosition for server-controlled remote -/// creatures. -/// -public class RemoteMoveToDriverTests -{ - private const float Epsilon = 1e-3f; - - private static float Yaw(Quaternion q) - { - var fwd = Vector3.Transform(new Vector3(0, 1, 0), q); - return MathF.Atan2(-fwd.X, fwd.Y); - } - - [Fact] - public void Drive_AlreadyAtTarget_ReportsArrived() - { - var bodyPos = new Vector3(10f, 20f, 0f); - var bodyRot = Quaternion.Identity; - var dest = new Vector3(10f, 20.3f, 0f); - - var result = RemoteMoveToDriver.Drive( - bodyPos, bodyRot, dest, - minDistance: 0.5f, distanceToObject: 0.6f, - dt: 0.016f, moveTowards: true, - out var newOrient); - - Assert.Equal(RemoteMoveToDriver.DriveResult.Arrived, result); - Assert.Equal(bodyRot, newOrient); // orientation untouched - } - - [Fact] - public void Drive_AceMeleePacket_UsesDistanceToObjectAsArrival() - { - // ACE chase packet: MinDistance=0, DistanceToObject=0.6 (melee). - // Body at 0.5m from target should ARRIVE — not keep oscillating - // around the target the way it did pre-fix when only MinDistance - // was the gate. This is the "monster keeps running in different - // directions when it should be attacking" regression fix. - var bodyPos = new Vector3(0f, 0f, 0f); - var bodyRot = Quaternion.Identity; - var dest = new Vector3(0f, 0.5f, 0f); - - var result = RemoteMoveToDriver.Drive( - bodyPos, bodyRot, dest, - minDistance: 0f, distanceToObject: 0.6f, - dt: 0.016f, moveTowards: true, - out _); - - Assert.Equal(RemoteMoveToDriver.DriveResult.Arrived, result); - } - - [Fact] - public void Drive_FleeArrival_UsesMinDistance() - { - // Flee branch (moveTowards=false): arrival when dist >= MinDistance. - // Retail / ACE both use MinDistance for the flee-arrival threshold. - var bodyPos = new Vector3(0f, 0f, 0f); - var bodyRot = Quaternion.Identity; - var dest = new Vector3(0f, 6f, 0f); - - var result = RemoteMoveToDriver.Drive( - bodyPos, bodyRot, dest, - minDistance: 5.0f, distanceToObject: 0.6f, - dt: 0.016f, moveTowards: false, - out _); - - Assert.Equal(RemoteMoveToDriver.DriveResult.Arrived, result); - } - - [Fact] - public void Drive_ChaseDoesNotArriveAtMinDistanceFloor() - { - // Regression: my earlier max(MinDistance, DistanceToObject) port - // would have arrived here because dist (1.5) <= MinDistance (2.0). - // Retail uses DistanceToObject for chase arrival, so a chase at - // dist=1.5 with DistanceToObject=0.6 should still STEER, not arrive. - var bodyPos = new Vector3(0f, 0f, 0f); - var bodyRot = Quaternion.Identity; - var dest = new Vector3(0f, 1.5f, 0f); - - var result = RemoteMoveToDriver.Drive( - bodyPos, bodyRot, dest, - minDistance: 2.0f, distanceToObject: 0.6f, - dt: 0.016f, moveTowards: true, - out _); - - Assert.Equal(RemoteMoveToDriver.DriveResult.Steering, result); - } - - [Fact] - public void Drive_ChasingButNotInRange_ReportsSteering() - { - var bodyPos = new Vector3(0f, 0f, 0f); - var bodyRot = Quaternion.Identity; // facing +Y - var dest = new Vector3(0f, 50f, 0f); // straight ahead - - var result = RemoteMoveToDriver.Drive( - bodyPos, bodyRot, dest, - minDistance: 0f, distanceToObject: 0f, - dt: 0.016f, moveTowards: true, - out var newOrient); - - Assert.Equal(RemoteMoveToDriver.DriveResult.Steering, result); - // Already facing target → snap branch keeps yaw at 0. - Assert.InRange(Yaw(newOrient), -Epsilon, Epsilon); - } - - [Fact] - public void Drive_TargetSlightlyOffAxis_SnapsWithinTolerance() - { - // Body facing +Y; target at (1, 10, 0) — that's a small angle - // (about 5.7°), well within the 20° snap tolerance. - var bodyPos = Vector3.Zero; - var bodyRot = Quaternion.Identity; - var dest = new Vector3(1f, 10f, 0f); - - var result = RemoteMoveToDriver.Drive( - bodyPos, bodyRot, dest, - minDistance: 0f, distanceToObject: 0f, - dt: 0.016f, moveTowards: true, - out var newOrient); - - Assert.Equal(RemoteMoveToDriver.DriveResult.Steering, result); - // Snap should land us pointing at (1, 10): yaw = atan2(-1, 10) ≈ -0.0997 rad. - float expectedYaw = MathF.Atan2(-1f, 10f); - Assert.InRange(Yaw(newOrient), expectedYaw - Epsilon, expectedYaw + Epsilon); - - // Verify orientation actually transforms +Y onto the (1,10) line. - var worldFwd = Vector3.Transform(new Vector3(0, 1, 0), newOrient); - Assert.InRange(worldFwd.X / worldFwd.Y, 0.1f - 1e-3f, 0.1f + 1e-3f); - } - - [Fact] - public void Drive_TargetBeyondTolerance_RotatesByLimitedStep() - { - // Body facing +Y; target at (-10, 0) — that's 90° to the left - // (well beyond the 20° snap tolerance), so we turn by at most - // TurnRateRadPerSec * dt this tick rather than snapping. - var bodyPos = Vector3.Zero; - var bodyRot = Quaternion.Identity; // yaw = 0 - var dest = new Vector3(-10f, 0f, 0f); // yaw = +π/2 (left) - const float dt = 0.1f; - - var result = RemoteMoveToDriver.Drive( - bodyPos, bodyRot, dest, - minDistance: 0f, distanceToObject: 0f, - dt: dt, moveTowards: true, - out var newOrient); - - Assert.Equal(RemoteMoveToDriver.DriveResult.Steering, result); - float expectedStep = RemoteMoveToDriver.TurnRateRadPerSec * dt; - // We should turn LEFT (positive yaw) toward the target. - Assert.InRange(Yaw(newOrient), expectedStep - Epsilon, expectedStep + Epsilon); - } - - [Fact] - public void Drive_TargetBehind_TurnsRightOrLeftViaShortestPath() - { - // Body facing +Y; target directly behind at (0, -10, 0). - // |delta| = π, equally close either way; the implementation - // picks one (sign depends on float wobble) — just assert - // we made progress (yaw changed by exactly TurnRate * dt). - var bodyPos = Vector3.Zero; - var bodyRot = Quaternion.Identity; - var dest = new Vector3(0f, -10f, 0f); - const float dt = 0.1f; - - var result = RemoteMoveToDriver.Drive( - bodyPos, bodyRot, dest, - minDistance: 0f, distanceToObject: 0f, - dt: dt, moveTowards: true, - out var newOrient); - - Assert.Equal(RemoteMoveToDriver.DriveResult.Steering, result); - float expectedStep = RemoteMoveToDriver.TurnRateRadPerSec * dt; - Assert.InRange(MathF.Abs(Yaw(newOrient)), expectedStep - Epsilon, expectedStep + Epsilon); - } - - [Fact] - public void Drive_PreservesOrientationAtArrival() - { - var bodyPos = new Vector3(5f, 5f, 0f); - var bodyRot = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, 1.234f); - var dest = new Vector3(5.01f, 5.01f, 0f); - - var result = RemoteMoveToDriver.Drive( - bodyPos, bodyRot, dest, - minDistance: 0.5f, distanceToObject: 0.6f, - dt: 0.016f, moveTowards: true, - out var newOrient); - - Assert.Equal(RemoteMoveToDriver.DriveResult.Arrived, result); - // Caller would zero velocity; orientation should be untouched - // so the body settles facing whatever direction it was already. - Assert.Equal(bodyRot, newOrient); - } - - [Fact] - public void ClampApproachVelocity_NoOverShoot_LandsExactlyAtThreshold() - { - // Body 1 m from destination, running at 4 m/s, dt = 0.1 s. - // Naive advance = 0.4 m → would end at 0.6 m from dest, exactly - // on the threshold. With threshold=0.6 and remaining=0.4, the - // clamp should let the full velocity through (advance == remaining). - var bodyPos = new Vector3(0f, 0f, 0f); - var dest = new Vector3(0f, 1f, 0f); - var vel = new Vector3(0f, 4f, 0f); - - var clamped = RemoteMoveToDriver.ClampApproachVelocity( - bodyPos, vel, dest, arrivalThreshold: 0.6f, dt: 0.1f, moveTowards: true); - - // Within float-precision: 4 m/s × 0.1 s = 0.4 m, exactly the - // remaining distance. The clamp may apply a 0.99999×-style - // tiny scale due to FP rounding — accept anything ≥ 99.9% of - // the input as "no meaningful overshoot prevention applied." - Assert.InRange(clamped.Y, 4f * 0.999f, 4f); - Assert.Equal(0f, clamped.X); - Assert.Equal(0f, clamped.Z); - } - - [Fact] - public void ClampApproachVelocity_WouldOverShoot_ScalesDownToExactLanding() - { - // Body 1 m from destination, running at 4 m/s, dt = 0.2 s. - // Naive advance = 0.8 m → would overshoot 0.6 m threshold by 0.4 m. - // remaining = 0.4 m, advance = 0.8 m → scale = 0.5. - // Velocity should be halved → 2 m/s. - var bodyPos = new Vector3(0f, 0f, 0f); - var dest = new Vector3(0f, 1f, 0f); - var vel = new Vector3(0f, 4f, 0f); - - var clamped = RemoteMoveToDriver.ClampApproachVelocity( - bodyPos, vel, dest, arrivalThreshold: 0.6f, dt: 0.2f, moveTowards: true); - - Assert.InRange(clamped.Y, 2f - Epsilon, 2f + Epsilon); - Assert.Equal(0f, clamped.X); - } - - [Fact] - public void ClampApproachVelocity_AlreadyAtThreshold_ZeroesHorizontal() - { - // Body exactly 0.6 m from dest with threshold 0.6 → remaining ≈ 0. - // Any horizontal velocity would overshoot; clamp must zero it. - var bodyPos = new Vector3(0f, 0f, 0f); - var dest = new Vector3(0f, 0.6f, 0f); - var vel = new Vector3(0f, 4f, 0.5f); // some Z to confirm Z is preserved - - var clamped = RemoteMoveToDriver.ClampApproachVelocity( - bodyPos, vel, dest, arrivalThreshold: 0.6f, dt: 0.016f, moveTowards: true); - - Assert.Equal(0f, clamped.X); - Assert.Equal(0f, clamped.Y); - Assert.Equal(0.5f, clamped.Z); // gravity / Z handling unaffected - } - - [Fact] - public void ClampApproachVelocity_FleeBranch_NoOp() - { - // moveTowards=false (flee): no overshoot risk, return velocity unchanged. - var bodyPos = Vector3.Zero; - var dest = new Vector3(0f, 1f, 0f); - var vel = new Vector3(0f, -4f, 0f); - - var clamped = RemoteMoveToDriver.ClampApproachVelocity( - bodyPos, vel, dest, arrivalThreshold: 5f, dt: 0.5f, moveTowards: false); - - Assert.Equal(vel, clamped); - } - - [Fact] - public void OriginToWorld_AppliesLandblockGridShift() - { - // Cell ID 0xA8B4000E → landblock x=0xA8, y=0xB4. With live center - // at (0xA9, 0xB4), that's one landblock west and zero north, - // so origin (10, 20, 0) inside that landblock should map to - // (10 - 192, 20 + 0, 0) = (-182, 20, 0) in render-world space. - var w = RemoteMoveToDriver.OriginToWorld( - originCellId: 0xA8B4000Eu, - originX: 10f, originY: 20f, originZ: 0f, - liveCenterLandblockX: 0xA9, liveCenterLandblockY: 0xB4); - - Assert.Equal(-182f, w.X); - Assert.Equal(20f, w.Y); - Assert.Equal(0f, w.Z); - } - - [Fact] - public void TurnRateFor_WalkingReturnsBaseRate() - { - // Retail: omega.z = ±π/2 × turn_speed (1.0) = π/2 rad/s ≈ 90°/s - // Anchor: docs/research/named-retail/acclient_2013_pseudo_c.txt - // CMotionInterp::apply_run_to_command 0x00527be0 only - // multiplies under HoldKey.Run — walking is unscaled. - float rate = RemoteMoveToDriver.TurnRateFor(running: false); - Assert.Equal(MathF.PI / 2.0f, rate, precision: 5); - } - - [Fact] - public void TurnRateFor_RunningAppliesRunTurnFactor() - { - // Retail: omega.z = ±π/2 × turn_speed × run_turn_factor - // run_turn_factor = 1.5f at 0x007c8914 (PDB-named). - // apply_run_to_command (acclient_2013_pseudo_c.txt:305098) - // multiplies turn_speed by 1.5f when input is TurnRight - // under HoldKey.Run. - float rate = RemoteMoveToDriver.TurnRateFor(running: true); - Assert.Equal(MathF.PI / 2.0f * 1.5f, rate, precision: 5); - } - - [Fact] - public void TurnRateRadPerSec_BackCompatStillResolvesToWalkingRate() - { - // Existing call sites that haven't yet migrated to TurnRateFor - // (e.g., RemoteMoveToDriver.Drive's TurnSpeed=1.0 callers) still - // see the walking-rate constant. Same numerical value as - // BaseTurnRateRadPerSec. - Assert.Equal(RemoteMoveToDriver.BaseTurnRateRadPerSec, - RemoteMoveToDriver.TurnRateRadPerSec, precision: 5); - } -} diff --git a/tests/AcDream.Core.Tests/Physics/RemoteWeenieRunRateTests.cs b/tests/AcDream.Core.Tests/Physics/RemoteWeenieRunRateTests.cs new file mode 100644 index 00000000..e54d8aa3 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/RemoteWeenieRunRateTests.cs @@ -0,0 +1,52 @@ +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// R4-V5 #160 fix: retail's apply_run_to_command (0x00527be0) run-rate +/// chain is weenie ? (InqRunRate() ?: my_run_rate) : 1.0. Remote +/// weenies FAIL InqRunRate, landing on my_run_rate — the field the mt-6/7 +/// unpack writes with the wire's MoveToRunRate (M13). These pin that a +/// RemoteWeenie-equipped interp scales the run promotion by MyRunRate +/// (observer-side movetos ran in slow motion when the interp had no +/// weenie and took the degenerate 1.0 branch). +/// +public class RemoteWeenieRunRateTests +{ + [Fact] + public void ApplyRunToCommand_RemoteWeenie_ScalesByWireRunRate() + { + var interp = new MotionInterpreter(new PhysicsBody()) + { + WeenieObj = new RemoteWeenie(), + MyRunRate = 4.5f, // the mt-6 wire write (unpack @300603) + }; + + uint motion = MotionCommand.WalkForward; + float speed = 1.0f; + interp.apply_run_to_command(ref motion, ref speed); + + Assert.Equal(MotionCommand.RunForward, motion); + Assert.Equal(4.5f, speed, 3); + } + + [Fact] + public void ApplyRunToCommand_NoWeenie_KeepsRetailDegenerateBranch() + { + // Verbatim retail: a weenie-LESS (detached-class) object scales by + // 1.0 (raw 305062-305076 `else x87_r7 = 1f`). Production bodies all + // carry a weenie (player: PlayerWeenie; remotes: RemoteWeenie). + var interp = new MotionInterpreter(new PhysicsBody()) + { + MyRunRate = 4.5f, + }; + + uint motion = MotionCommand.WalkForward; + float speed = 1.0f; + interp.apply_run_to_command(ref motion, ref speed); + + Assert.Equal(MotionCommand.RunForward, motion); + Assert.Equal(1.0f, speed, 3); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/RetailObserverTraceConformanceTests.cs b/tests/AcDream.Core.Tests/Physics/RetailObserverTraceConformanceTests.cs new file mode 100644 index 00000000..80200142 --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/RetailObserverTraceConformanceTests.cs @@ -0,0 +1,191 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Text.RegularExpressions; +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// L.2g S2 conformance harness, layer 1: golden fixtures parsed from a LIVE +/// cdb trace of a RETAIL observer client +/// (Fixtures/l2g-observer-trace.log, captured 2026-07-02 with +/// tools/cdb/l2g-observer.cdb while a retail actor ran the structured +/// motion protocol through ACE). +/// +/// Each [MTIS] block is an exact INPUT (the InterpretedMotionState retail +/// received, dumped field-by-field) and the [DIM] lines that follow on the +/// same minterp are retail's exact OUTPUT (every DoInterpretedMotion +/// dispatch, in order). We replay every input through acdream's funnel and +/// assert an identical dispatch sequence — retail's actual runtime is the +/// oracle, not anyone's reading of the decomp. +/// +/// Exclusions (documented, not silent): +/// - Action-class dispatches (0x10000000 bit) come from the UM's action +/// LIST, which the [MTIS] struct dump doesn't include (LList pointer +/// only) — filtered from both sides; covered by the synthetic action +/// tests in MotionInterpreterFunnelTests instead. +/// - motion==0x80000000 entries (the unpack-level DoMotion(command_ids[0]) +/// style call for wire style index 0) — outside +/// move_to_interpreted_state, so it can never appear in a +/// MoveToInterpretedState replay; the filter stays for that trace- +/// mechanics reason. The PRODUCTION gap the old note pointed at ("S3 +/// wires the unpack-level style-on-change") CLOSED in R5-V4: the +/// GameWindow routing heads dispatch DoMotion(style) on change for every +/// movement type (unpack_movement @00524502-0052452c; conformance: +/// RemoteChaseEndToEndHarnessTests.ChaseArm_WithStanceChange_ +/// AppliesStanceBeforeTheChase). +/// +public class RetailObserverTraceConformanceTests +{ + private sealed record TraceCase( + int Line, string Minterp, InboundInterpretedState Ims, List Dims); + + private sealed class RecordingSink : IInterpretedMotionSink + { + public readonly List Applied = new(); + public bool ApplyMotion(uint motion, float speed) + { + Applied.Add(motion); + // R3-W5: style/stance ids (>= 0x80000000) have no dat MotionData + // entry — retail's real motion-table lookup fails for them + // (see MotionInterpreterDoMotionFamilyTests / the interface + // doc on IInterpretedMotionSink.ApplyMotion for the full + // rationale). The fake sink mirrors that so the style dispatch + // doesn't clobber ForwardCommand before the next read. + return motion < 0x80000000u; + } + public bool StopMotion(uint motion) => true; + } + + private static string TracePath() + { + var dir = AppContext.BaseDirectory; + while (dir is not null && !File.Exists(Path.Combine(dir, "AcDream.slnx"))) + dir = Directory.GetParent(dir)?.FullName; + Assert.NotNull(dir); + return Path.Combine(dir!, "tests", "AcDream.Core.Tests", "Fixtures", "l2g-observer-trace.log"); + } + + private static List ParseTrace() + { + var lines = File.ReadAllLines(TracePath()); + var cases = new List(); + var mtisRe = new Regex(@"\[MTIS\] minterp=(\w+)"); + var fieldRe = new Regex(@"\+0x(\w+) (\w+)\s+: (\S+)"); + var dimRe = new Regex(@"\[DIM\] minterp=(\w+) motion=(\w+)"); + + for (int i = 0; i < lines.Length; i++) + { + var m = mtisRe.Match(lines[i]); + if (!m.Success) continue; + string minterp = m.Groups[1].Value; + + var ims = InboundInterpretedState.Default(); + int j = i + 1; + for (; j < lines.Length; j++) + { + var f = fieldRe.Match(lines[j]); + if (!f.Success) break; + string name = f.Groups[2].Value; + string val = f.Groups[3].Value; + uint ParseHex() => Convert.ToUInt32(val, 16); + float ParseF() => float.Parse(val, CultureInfo.InvariantCulture); + switch (name) + { + case "current_style": ims.CurrentStyle = ParseHex(); break; + case "forward_command": ims.ForwardCommand = ParseHex(); break; + case "forward_speed": ims.ForwardSpeed = ParseF(); break; + case "sidestep_command": ims.SideStepCommand = ParseHex(); break; + case "sidestep_speed": ims.SideStepSpeed = ParseF(); break; + case "turn_command": ims.TurnCommand = ParseHex(); break; + case "turn_speed": ims.TurnSpeed = ParseF(); break; + } + } + + // Collect this minterp's DIMs until the next UNPACK/MTIS event. + var dims = new List(); + for (; j < lines.Length; j++) + { + if (lines[j].Contains("[UNPACK]") || lines[j].Contains("[MTIS]")) break; + var d = dimRe.Match(lines[j]); + if (d.Success && d.Groups[1].Value == minterp) + dims.Add(Convert.ToUInt32(d.Groups[2].Value, 16)); + } + + // A SECOND style dispatch marks a second apply_current_movement + // pass fired by the physics tick (HitGround / LeaveGround + // re-apply, CMotionInterp::HitGround 0x00528ac0) — not by this + // UM. Keep only the first pass as this UM's output. (2 cases in + // the capture — the actor's jump/land moments.) + int secondStyle = -1; + for (int k = 1; k < dims.Count; k++) + if (dims[k] == ims.CurrentStyle) { secondStyle = k; break; } + if (secondStyle > 0) dims = dims.Take(secondStyle).ToList(); + + cases.Add(new TraceCase(i + 1, minterp, ims, dims)); + } + return cases; + } + + private static bool IsExcluded(uint motion) + => (motion & 0x10000000u) != 0 // action-list dispatches, not in the dump + || motion == 0x80000000u; // unpack-level style-index-0 call + + [Fact] + public void EveryTracedUm_ProducesRetailsExactDispatchSequence() + { + var cases = ParseTrace(); + Assert.True(cases.Count > 100, $"expected >100 traced UMs, parsed {cases.Count}"); + + int verified = 0; + var failures = new List(); + foreach (var c in cases) + { + // The trace breakpoint sits at DoInterpretedMotion ENTRY + // (pre-gate); the sink records POST-gate (GetObjectSequence) + // calls. For grounded bodies they coincide. A Falling dispatch + // for a non-Falling forward command marks the traced body as + // AIRBORNE at that moment (the actor's jump) — replay those + // with contact cleared, and drop the traced style entry from + // the expectation (called pre-gate, blocked post-gate). + bool airborne = c.Ims.ForwardCommand != 0x40000015u + && c.Dims.Contains(0x40000015u); + + var body = new PhysicsBody(); + body.State |= PhysicsStateFlags.Gravity; + body.TransientState |= TransientStateFlags.Active; + if (!airborne) + body.TransientState |= TransientStateFlags.Contact + | TransientStateFlags.OnWalkable; + var mi = new MotionInterpreter(body); + var sink = new RecordingSink(); + + mi.MoveToInterpretedState(c.Ims, sink); + + var expected = c.Dims.Where(d => !IsExcluded(d) + && (!airborne || d != c.Ims.CurrentStyle)).ToList(); + var actual = sink.Applied.Where(d => !IsExcluded(d)).ToList(); + if (!expected.SequenceEqual(actual)) + { + failures.Add( + $"line {c.Line} minterp {c.Minterp}: " + + $"fwd=0x{c.Ims.ForwardCommand:X8}@{c.Ims.ForwardSpeed:F2} " + + $"side=0x{c.Ims.SideStepCommand:X8} turn=0x{c.Ims.TurnCommand:X8} — " + + $"retail [{string.Join(",", expected.Select(d => d.ToString("X8")))}] " + + $"vs acdream [{string.Join(",", actual.Select(d => d.ToString("X8")))}]"); + } + else + { + verified++; + } + } + + Assert.True(failures.Count == 0, + $"{failures.Count} of {cases.Count} traced UMs diverged " + + $"({verified} conformant):\n" + string.Join("\n", failures.Take(12))); + } +} diff --git a/tests/AcDream.Core.Tests/Physics/ServerControlledLocomotionTests.cs b/tests/AcDream.Core.Tests/Physics/ServerControlledLocomotionTests.cs index 65cc50da..9ea2ca04 100644 --- a/tests/AcDream.Core.Tests/Physics/ServerControlledLocomotionTests.cs +++ b/tests/AcDream.Core.Tests/Physics/ServerControlledLocomotionTests.cs @@ -6,41 +6,8 @@ namespace AcDream.Core.Tests.Physics; public sealed class ServerControlledLocomotionTests { - [Fact] - public void PlanMoveToStart_SeedsImmediateRunCycle() - { - var plan = ServerControlledLocomotion.PlanMoveToStart(); - Assert.True(plan.IsMoving); - Assert.Equal(MotionCommand.RunForward, plan.Motion); - Assert.Equal(1.0f, plan.SpeedMod); - } - [Fact] - public void PlanMoveToStart_AppliesRetailRunRate() - { - var plan = ServerControlledLocomotion.PlanMoveToStart( - moveToSpeed: 1.25f, - runRate: 1.5f, - canRun: true); - - Assert.True(plan.IsMoving); - Assert.Equal(MotionCommand.RunForward, plan.Motion); - Assert.Equal(1.875f, plan.SpeedMod); - } - - [Fact] - public void PlanMoveToStart_UsesWalkWhenRunDisallowed() - { - var plan = ServerControlledLocomotion.PlanMoveToStart( - moveToSpeed: 0.75f, - runRate: 2.0f, - canRun: false); - - Assert.True(plan.IsMoving); - Assert.Equal(MotionCommand.WalkForward, plan.Motion); - Assert.Equal(0.75f, plan.SpeedMod); - } [Fact] public void PlanFromVelocity_StopsBelowRetailNoiseThreshold() diff --git a/tests/AcDream.Core.Tests/Physics/ShadowRegistrationOverflowTests.cs b/tests/AcDream.Core.Tests/Physics/ShadowRegistrationOverflowTests.cs new file mode 100644 index 00000000..5ea131ff --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/ShadowRegistrationOverflowTests.cs @@ -0,0 +1,147 @@ +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using AcDream.Core.Physics; +using AcDream.Core.World; +using DatReaderWriter.Enums; +using DatReaderWriter.Types; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// #185 (2026-07-08) — the outdoor-stairs "invisible wall" root cause: the +/// former per-part landblock shadow registration used a synthetic part-id +/// entity.Id * 256u + partIndex that OVERFLOWED uint32 for class-prefixed +/// landblock ids (0x40/0x80/0xC0…). The << 8 dropped the +/// prefix byte, so different-class entities sharing the low 24 bits collided on +/// one shadow part-id and Register's deregister-then-insert silently +/// overwrote one entity's collision geometry — rendered stair steps with NO +/// collision. The fix registers each multi-part entity via +/// under its UNIQUE 32-bit +/// entity.Id (retail add_shadows_to_cells / CPartArray::AddPartsShadow). +/// +public class ShadowRegistrationOverflowTests +{ + // Two real stair-entity ids from the #185 capture that share the low 24 bits + // (0xF68221) but differ in the class-prefix byte. + private const uint EntityA = 0x40F68221u; + private const uint EntityB = 0xC0F68221u; + + private const uint LbId = 0xF6820000u; + private const float OffX = 0f, OffY = 0f; + + // ── The root cause, as pure arithmetic ──────────────────────────────── + + [Fact] + public void OldPartIdScheme_OverflowsUint32_AndCollides() + { + // entity.Id * 256u == entity.Id << 8, truncated to 32 bits → the prefix + // byte falls off the top and the two distinct entities alias. + uint oldPartA = unchecked(EntityA * 256u); // 0x40F68221 << 8 → 0xF6822100 + uint oldPartB = unchecked(EntityB * 256u); // 0xC0F68221 << 8 → 0xF6822100 + Assert.Equal(0xF6822100u, oldPartA); + Assert.Equal(oldPartA, oldPartB); // COLLISION = the #185 bug + Assert.NotEqual(EntityA, EntityB); // …yet the entities ARE distinct + } + + // ── The bug: old per-part Register loses one registration ───────────── + + private static ShadowShape Cyl(Vector3 local) => new( + GfxObjId: 0u, LocalPosition: local, LocalRotation: Quaternion.Identity, + Scale: 1f, CollisionType: ShadowCollisionType.Cylinder, Radius: 1f, CylHeight: 2f); + + [Fact] + public void OldPerPartRegister_CollidingIds_SecondSilentlyOverwritesFirst() + { + var reg = new ShadowObjectRegistry(); + + // Two DIFFERENT physical objects at DIFFERENT cells, registered the OLD way + // (Register with the synthetic overflowing part-id). EntityA at cell (0,0), + // EntityB at cell (1,0) — 30 m apart in X. + var posA = new Vector3(12f, 12f, 50f); // → cell LbId|1 + var posB = new Vector3(42f, 12f, 50f); // → cell LbId|9 + + reg.Register(unchecked(EntityA * 256u), 0u, posA, Quaternion.Identity, 1f, + OffX, OffY, LbId, ShadowCollisionType.Cylinder, 2f); + reg.Register(unchecked(EntityB * 256u), 0u, posB, Quaternion.Identity, 1f, + OffX, OffY, LbId, ShadowCollisionType.Cylinder, 2f); + + // EntityA's registration is GONE (its part-id was reused by EntityB): its + // cell is empty. This is exactly the missing stair-step collision. + Assert.Empty(reg.GetObjectsInCell(LbId | 1u)); + Assert.NotEmpty(reg.GetObjectsInCell(LbId | 9u)); + Assert.Equal(1, reg.TotalRegistered); // one silently lost + } + + // ── The fix: RegisterMultiPart keys on the unique entity.Id ─────────── + + [Fact] + public void RegisterMultiPart_CollidingLowBitsIds_BothSurvive() + { + var reg = new ShadowObjectRegistry(); + + var posA = new Vector3(12f, 12f, 50f); // → cell LbId|1 + var posB = new Vector3(42f, 12f, 50f); // → cell LbId|9 + + reg.RegisterMultiPart(EntityA, posA, Quaternion.Identity, + new[] { Cyl(Vector3.Zero) }, 0u, EntityCollisionFlags.None, + OffX, OffY, LbId, isStatic: true); + reg.RegisterMultiPart(EntityB, posB, Quaternion.Identity, + new[] { Cyl(Vector3.Zero) }, 0u, EntityCollisionFlags.None, + OffX, OffY, LbId, isStatic: true); + + // Both distinct entities survive at their own cells — no overflow collision. + Assert.Contains(reg.GetObjectsInCell(LbId | 1u), e => e.EntityId == EntityA); + Assert.Contains(reg.GetObjectsInCell(LbId | 9u), e => e.EntityId == EntityB); + Assert.Equal(2, reg.TotalRegistered); + } + + // ── The builder: one BSP shape per BSP part; shells + no-BSP excluded ── + + private static GfxObjPhysics BspGfx(float radius) + { + var leaf = new PhysicsBSPNode { Type = BSPNodeType.Leaf }; + return new GfxObjPhysics + { + BSP = new PhysicsBSPTree { Root = leaf }, + BoundingSphere = new Sphere { Origin = Vector3.Zero, Radius = radius }, + Resolved = new Dictionary(), + PhysicsPolygons = new Dictionary(), + Vertices = new VertexArray(), + }; + } + + [Fact] + public void FromLandblockBspParts_OneShapePerBspPart_LocalTransformPreserved() + { + var meshRefs = new[] + { + new MeshRef(0x01000AC5u, Matrix4x4.CreateTranslation(0f, 0.5f, 0.4f)), + new MeshRef(0x01000AC5u, Matrix4x4.CreateTranslation(0f, 1.0f, 0.8f)), + new MeshRef(0x0BADBADu, Matrix4x4.Identity), // no physics BSP → skipped + }; + + var shapes = ShadowShapeBuilder.FromLandblockBspParts( + meshRefs, isBuildingShell: false, + getGfxObj: id => id == 0x01000AC5u ? BspGfx(1.05f) : null); + + Assert.Equal(2, shapes.Count); // only the two BSP-bearing parts + Assert.All(shapes, s => Assert.Equal(ShadowCollisionType.BSP, s.CollisionType)); + Assert.All(shapes, s => Assert.Equal(0x01000AC5u, s.GfxObjId)); + // Local part offsets survive (decomposed from PartTransform). + Assert.Contains(shapes, s => Vector3.Distance(s.LocalPosition, new Vector3(0f, 0.5f, 0.4f)) < 1e-4f); + Assert.Contains(shapes, s => Vector3.Distance(s.LocalPosition, new Vector3(0f, 1.0f, 0.8f)) < 1e-4f); + // Radius = local BoundingSphere radius × part scale (1.0). + Assert.All(shapes, s => Assert.Equal(1.05f, s.Radius, 3)); + } + + [Fact] + public void FromLandblockBspParts_BuildingShell_ReturnsEmpty() + { + var meshRefs = new[] { new MeshRef(0x01000AC5u, Matrix4x4.Identity) }; + var shapes = ShadowShapeBuilder.FromLandblockBspParts( + meshRefs, isBuildingShell: true, getGfxObj: _ => BspGfx(1f)); + Assert.Empty(shapes); // building shells collide via the building channel + } +} diff --git a/tests/AcDream.Core.Tests/Physics/ShadowShapeBuilderShapeSourceTests.cs b/tests/AcDream.Core.Tests/Physics/ShadowShapeBuilderShapeSourceTests.cs index 7677b548..925ba472 100644 --- a/tests/AcDream.Core.Tests/Physics/ShadowShapeBuilderShapeSourceTests.cs +++ b/tests/AcDream.Core.Tests/Physics/ShadowShapeBuilderShapeSourceTests.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Numerics; using AcDream.Core.Physics; using DatReaderWriter.DBObjs; using DatReaderWriter.Enums; @@ -90,4 +91,32 @@ public class ShadowShapeBuilderShapeSourceTests Assert.Empty(shapes); } + + // 2026-07-07 — the PREMISE of the player-vs-monster crowd-collision fix (the + // CSphere family port): a humanoid Setup carries body Spheres and NO + // CylSpheres, so FromSetup emits Sphere-type shadows → collision runs through + // Transition.SphereCollision (the retail CSphere::intersects_sphere family), + // NOT the cylinder path. Mirrors the human Setup 0x02000001 (two body spheres + // at 0.475 / 1.350, r=0.48 — TS-46 / the physics digest). If this ever flips + // to CylSphere-first, the crowd fix would be aimed at the wrong dispatcher. + [Fact] + public void Setup_WithBodySpheres_NoCylSpheres_EmitsSphereShapes() + { + var setup = new Setup + { + CylSpheres = new List(), + Spheres = new List + { + new Sphere { Origin = new Vector3(0f, 0f, 0.475f), Radius = 0.48f }, + new Sphere { Origin = new Vector3(0f, 0f, 1.350f), Radius = 0.48f }, + }, + Parts = new List>(), + PlacementFrames = new Dictionary(), + }; + + var shapes = ShadowShapeBuilder.FromSetup(setup, entScale: 1f, hasPhysicsBsp: _ => false); + + Assert.Equal(2, shapes.Count); + Assert.All(shapes, s => Assert.Equal(ShadowCollisionType.Sphere, s.CollisionType)); + } } diff --git a/tests/AcDream.Core.Tests/Physics/SphereCollisionFamilyTests.cs b/tests/AcDream.Core.Tests/Physics/SphereCollisionFamilyTests.cs new file mode 100644 index 00000000..b2545c0e --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/SphereCollisionFamilyTests.cs @@ -0,0 +1,251 @@ +using System; +using System.Numerics; +using AcDream.Core.Physics; +using Xunit; +using Xunit.Abstractions; +using Plane = System.Numerics.Plane; + +namespace AcDream.Core.Tests.Physics; + +/// +/// Conformance tests for the retail CSphere::intersects_sphere collision +/// family port (2026-07-07) — dispatcher 0x00537A80 + step_sphere_up +/// 0x00537900 + slide_sphere 0x00537440 + +/// land_on_sphere 0x005379a0 + collide_with_point +/// 0x00537230 + step_sphere_down 0x00536d20. Pseudocode: +/// docs/research/2026-07-07-csphere-collision-family-pseudocode.md. +/// +/// +/// The driving repro: the user's live report that a player packed inside a crowd +/// of monsters gets wedged and can't wiggle free, where retail leaves room to +/// shuffle out. Humanoid creatures/players collide as body Spheres +/// (Setup.Spheres → emits +/// ), so the crowd contact runs through +/// Transition.SphereCollision. Before this port that method was a +/// hand-rolled 3-D wall-slide with a forced fixed de-penetration (register +/// TS-45) — opposing radial pushes from neighbours cancelled and the +/// player wedged. The faithful family routes the slide through the shared crease +/// projection, restoring retail's tangential shuffle. Synthetic spheres only — no +/// dat dependency. +/// +/// +public class SphereCollisionFamilyTests +{ + private readonly ITestOutputHelper _out; + public SphereCollisionFamilyTests(ITestOutputHelper output) => _out = output; + + private const uint TestLandblockId = 0xA9B40000u; + private const uint TestCellId = TestLandblockId | 0x0001u; // landcell (0,0) + + private const float SphereRadius = 0.48f; // retail player capsule radius + private const float SphereHeight = 1.20f; + private const float StepUpHeight = 0.60f; + private const float StepDownHeight = 0.04f; + + private const float CreatureRadius = 0.48f; // a humanoid body sphere + + /// + /// THE headline behavior: the crease slide lets a grounded player SHUFFLE + /// AROUND a body-sphere creature that partly blocks the path, instead of + /// sticking to it. The creature sits slightly EAST of the player's northward + /// line; the player walks N, grazes the creature's south-west, and must slide + /// along it (crease = collisionNormal × ground-up) and continue past. + /// + /// + /// This is the retail-faithful tangential slide the port restores. The + /// pre-2026-07-07 hand-rolled SphereCollision force-pushed the contact + /// RADIALLY to a fixed combinedR + 1 cm shell (shoving the player + /// south-west, back along its approach) — TS-45. In a crowd those radial + /// shoves from several neighbours fight each other and wedge the player; the + /// tangential crease slide is what leaves "room to shuffle out". The player + /// starts CLEAR (not penetrating) — a start deep inside overlapping spheres + /// reverts in retail too (validate_transition restores curr_pos on a + /// non-clean step, 0x0050aa70:272593), so that is not a valid repro. + /// + /// + [Fact] + public void GroundedDiagonalApproach_SlidesPastOffsetCreature() + { + var engine = BuildEngine(out _); + RegisterCreatureSphere(engine, 0xC0C0u, 10.35f, 12f); // slightly EAST of the N path + + var body = MakeGroundedBody(new Vector3(10f, 10f, 0f)); + Vector3 pos = body.Position; + uint cellId = TestCellId; + bool grounded = true; + var perTick = new Vector3(0f, 0.08f, 0f); // push NORTH + + for (int tick = 0; tick < 60; tick++) + { + var result = engine.ResolveWithTransition( + pos, pos + perTick, cellId, + SphereRadius, SphereHeight, StepUpHeight, StepDownHeight, + grounded, body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide, + movingEntityId: 0); + + body.Position = result.Position; + pos = result.Position; + cellId = result.CellId; + grounded = result.IsOnGround; + _out.WriteLine($"tick {tick,2}: ({pos.X:F3},{pos.Y:F3})"); + } + + _out.WriteLine($"final pos=({pos.X:F3},{pos.Y:F3},{pos.Z:F3}) grounded={grounded}"); + + // The creature centre is at Y=12. If the player slid around it, it ends + // NORTH of the creature; if it stuck, it wedges near Y≈11 (surface at + // Y = 12 − sqrt(0.96² − 0.35²) ≈ 11.11). + Assert.True(pos.Y > 12.5f, + $"Player must slide around the offset creature and continue north, not stick at " + + $"its surface; got Y={pos.Y:F3}"); + } + + /// + /// A single body-sphere creature dead ahead: the player pushing straight into + /// it must stop AT the surface (a head-on push has no crease tangent → the + /// slide degenerates → Collided) and must NOT penetrate or pass through. + /// Surface contact is at Y = 11.5 − (0.48+0.48) = 10.54. + /// + [Fact] + public void GroundedSingleCreature_HeadOnPush_BlocksWithoutPenetration() + { + var engine = BuildEngine(out _); + RegisterCreatureSphere(engine, 0xC0B0u, 12f, 11.5f); // due north + + var body = MakeGroundedBody(new Vector3(12f, 10f, 0f)); + Vector3 pos = body.Position; + uint cellId = TestCellId; + bool grounded = true; + var perTick = new Vector3(0f, 0.08f, 0f); // straight in + + for (int tick = 0; tick < 30; tick++) + { + var result = engine.ResolveWithTransition( + pos, pos + perTick, cellId, + SphereRadius, SphereHeight, StepUpHeight, StepDownHeight, + grounded, body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide, + movingEntityId: 0); + + body.Position = result.Position; + pos = result.Position; + cellId = result.CellId; + grounded = result.IsOnGround; + } + + _out.WriteLine($"final pos=({pos.X:F3},{pos.Y:F3},{pos.Z:F3})"); + + Assert.True(pos.Y < 10.7f, + $"Player must be blocked at the sphere surface (Y≈10.54), not penetrate; got Y={pos.Y:F3}"); + Assert.True(pos.Y > 10.3f, + $"Player must actually reach the creature (not stop early); got Y={pos.Y:F3}"); + } + + /// + /// An ETHEREAL sphere (state 0x4, non-static) is fully passable — the branch-1 + /// early-OK consume plus the caller's Layer-2 override. Guards the door/ghost + /// passability against the family rewrite. + /// + [Fact] + public void GroundedEtherealSphere_IsFullyPassable() + { + var engine = BuildEngine(out _); + RegisterCreatureSphere(engine, 0xC0E0u, 12f, 11.5f, + state: 0x4u, isCreatureFlag: false); // ETHEREAL_PS, non-static + + var body = MakeGroundedBody(new Vector3(12f, 10f, 0f)); + Vector3 pos = body.Position; + uint cellId = TestCellId; + bool grounded = true; + var perTick = new Vector3(0f, 0.08f, 0f); + + for (int tick = 0; tick < 45; tick++) + { + var result = engine.ResolveWithTransition( + pos, pos + perTick, cellId, + SphereRadius, SphereHeight, StepUpHeight, StepDownHeight, + grounded, body: body, + moverFlags: ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide, + movingEntityId: 0); + + body.Position = result.Position; + pos = result.Position; + cellId = result.CellId; + grounded = result.IsOnGround; + } + + _out.WriteLine($"final pos=({pos.X:F3},{pos.Y:F3},{pos.Z:F3})"); + + Assert.True(pos.Y > 12.5f, + $"Ethereal sphere must not block (walked from 10 past the axis); got Y={pos.Y:F3}"); + } + + // ─────────────────────────────────────────────────────────────── + // Harness (mirrors CylSphereFamilyTests) + // ─────────────────────────────────────────────────────────────── + + private static PhysicsEngine BuildEngine(out PhysicsDataCache cache) + { + cache = new PhysicsDataCache(); + var engine = new PhysicsEngine { DataCache = cache }; + + var heights = new byte[81]; + var heightTable = new float[256]; // all zero → terrain Z = 0 + engine.AddLandblock( + landblockId: TestLandblockId, + terrain: new TerrainSurface(heights, heightTable), + cells: Array.Empty(), + portals: Array.Empty(), + worldOffsetX: 0f, + worldOffsetY: 0f); + + return engine; + } + + /// + /// Register a humanoid body sphere at foot height (Z = SphereRadius) so the + /// player's foot sphere overlaps it horizontally. Flagged as a creature by + /// default (the crowd case), mimicking a live monster's body-sphere shadow. + /// + private static void RegisterCreatureSphere(PhysicsEngine engine, uint entityId, + float x, float y, float radius = CreatureRadius, uint state = 0u, + bool isCreatureFlag = true) + { + engine.ShadowObjects.Register( + entityId, gfxObjId: 0u, + new Vector3(x, y, SphereRadius), Quaternion.Identity, radius, + worldOffsetX: 0f, worldOffsetY: 0f, landblockId: TestLandblockId, + collisionType: ShadowCollisionType.Sphere, + cylHeight: 0f, scale: 1f, + state: state, + flags: isCreatureFlag ? EntityCollisionFlags.IsCreature : EntityCollisionFlags.None, + isStatic: false); + } + + private static PhysicsBody MakeGroundedBody(Vector3 position) + { + var floorPlane = new Plane(Vector3.UnitZ, 0f); + var floorVerts = new[] + { + new Vector3(-100f, -100f, 0f), + new Vector3( 100f, -100f, 0f), + new Vector3( 100f, 100f, 0f), + new Vector3(-100f, 100f, 0f), + }; + + return new PhysicsBody + { + Position = position, + Orientation = Quaternion.Identity, + ContactPlaneValid = true, + ContactPlane = floorPlane, + ContactPlaneCellId = TestCellId, + WalkablePolygonValid = true, + WalkablePlane = floorPlane, + WalkableVertices = floorVerts, + WalkableUp = Vector3.UnitZ, + TransientState = TransientStateFlags.Contact | TransientStateFlags.OnWalkable, + }; + } +} diff --git a/tests/AcDream.Core.Tests/Physics/WeenieErrorCodeTableTests.cs b/tests/AcDream.Core.Tests/Physics/WeenieErrorCodeTableTests.cs new file mode 100644 index 00000000..e42b23cc --- /dev/null +++ b/tests/AcDream.Core.Tests/Physics/WeenieErrorCodeTableTests.cs @@ -0,0 +1,136 @@ +using AcDream.Core.Physics; +using Xunit; + +namespace AcDream.Core.Tests.Physics; + +/// +/// R3-W1 — pins 's numeric values against the +/// definitive retail table in +/// docs/research/2026-07-02-r3-motioninterp/W0-pins.md §A10 (an exhaustive +/// sweep of every return <code> site across raw 304908-306277 + +/// 300150-300540: 19 return sites + 1 store site, all attributed). These +/// codes are local-only (never on the wire), so the renumber from the +/// pre-R3 shuffled names is a safe rename — this test is the single +/// source of truth that a future edit can't silently un-pin. +/// +public sealed class WeenieErrorCodeTableTests +{ + [Fact] + public void None_Is0x00() + => Assert.Equal(0x00u, (uint)WeenieError.None); + + [Fact] + public void NoPhysicsObject_Is0x08() + => Assert.Equal(0x08u, (uint)WeenieError.NoPhysicsObject); + + /// + /// 0x0B — NoMotionInterpreter. R4-V1 addition (M12), per + /// docs/research/2026-07-03-r4-moveto/r4-moveto-decomp.md §12 constants + /// inventory row (8, 0xb, 0x36, 0x37, 0x38, 0x3d, 0x47). + /// + [Fact] + public void NoMotionInterpreter_Is0x0B() + => Assert.Equal(0x0Bu, (uint)WeenieError.NoMotionInterpreter); + + [Fact] + public void NotGrounded_Is0x24() + => Assert.Equal(0x24u, (uint)WeenieError.NotGrounded); + + [Fact] + public void CrouchInCombatStance_Is0x3f() + => Assert.Equal(0x3fu, (uint)WeenieError.CrouchInCombatStance); + + [Fact] + public void SitInCombatStance_Is0x40() + => Assert.Equal(0x40u, (uint)WeenieError.SitInCombatStance); + + [Fact] + public void SleepInCombatStance_Is0x41() + => Assert.Equal(0x41u, (uint)WeenieError.SleepInCombatStance); + + [Fact] + public void ChatEmoteOutsideNonCombat_Is0x42() + => Assert.Equal(0x42u, (uint)WeenieError.ChatEmoteOutsideNonCombat); + + /// + /// 0x36 — ActionCancelled. R4-V1 addition (M12). Site: + /// MoveToManager::PerformMovement (§3a @0052a901) — every new + /// moveto cancels the previous one with this code before dispatching; + /// also CPhysicsObj::interrupt_current_movement's + /// MovementManager::CancelMoveTo(0x36) call (§9e). Per §7c, the + /// arg is NEVER READ inside MoveToManager::CancelMoveTo's body in + /// this build — kept for parity/logging, not behavior. + /// + [Fact] + public void ActionCancelled_Is0x36() + => Assert.Equal(0x36u, (uint)WeenieError.ActionCancelled); + + /// + /// 0x37 — ObjectGone. R4-V1 addition (M12). Site: + /// MoveToManager::HandleUpdateTarget (§6d @307866-307867) — + /// retarget delivery with a non-OK target status. + /// + [Fact] + public void ObjectGone_Is0x37() + => Assert.Equal(0x37u, (uint)WeenieError.ObjectGone); + + /// + /// 0x38 — NoObject. R4-V1 addition (M12). Site: + /// MoveToManager::HandleUpdateTarget (§6d @307857-307858) — the + /// FIRST target callback arrives with a non-OK status (target never + /// resolved). + /// + [Fact] + public void NoObject_Is0x38() + => Assert.Equal(0x38u, (uint)WeenieError.NoObject); + + [Fact] + public void ActionDepthExceeded_Is0x45() + => Assert.Equal(0x45u, (uint)WeenieError.ActionDepthExceeded); + + [Fact] + public void GeneralMovementFailure_Is0x47() + => Assert.Equal(0x47u, (uint)WeenieError.GeneralMovementFailure); + + [Fact] + public void YouCantJumpFromThisPosition_Is0x48() + => Assert.Equal(0x48u, (uint)WeenieError.YouCantJumpFromThisPosition); + + [Fact] + public void CantJumpLoadedDown_Is0x49() + => Assert.Equal(0x49u, (uint)WeenieError.CantJumpLoadedDown); + + /// + /// 0x3D — YouChargedTooFar. R4-V1 addition (M12). Site: + /// MoveToManager::HandleMoveToPosition Phase 2 arrival check — + /// fail_distance exceeded (r4-moveto-decomp.md §6b). + /// + [Fact] + public void YouChargedTooFar_Is0x3D() + => Assert.Equal(0x3Du, (uint)WeenieError.YouChargedTooFar); + + /// + /// Every code in the A10 table in one pass — guards against a + /// future partial edit desyncing an individual test above from the + /// enum declaration. + /// + [Theory] + [InlineData(WeenieError.None, 0x00u)] + [InlineData(WeenieError.NoPhysicsObject, 0x08u)] + [InlineData(WeenieError.NoMotionInterpreter, 0x0Bu)] + [InlineData(WeenieError.NotGrounded, 0x24u)] + [InlineData(WeenieError.ActionCancelled, 0x36u)] + [InlineData(WeenieError.ObjectGone, 0x37u)] + [InlineData(WeenieError.NoObject, 0x38u)] + [InlineData(WeenieError.CrouchInCombatStance, 0x3fu)] + [InlineData(WeenieError.SitInCombatStance, 0x40u)] + [InlineData(WeenieError.SleepInCombatStance, 0x41u)] + [InlineData(WeenieError.ChatEmoteOutsideNonCombat, 0x42u)] + [InlineData(WeenieError.ActionDepthExceeded, 0x45u)] + [InlineData(WeenieError.GeneralMovementFailure, 0x47u)] + [InlineData(WeenieError.YouCantJumpFromThisPosition, 0x48u)] + [InlineData(WeenieError.CantJumpLoadedDown, 0x49u)] + [InlineData(WeenieError.YouChargedTooFar, 0x3Du)] + public void A10Table_EveryCode_MatchesRetailNumericValue(WeenieError code, uint expected) + => Assert.Equal(expected, (uint)code); +} diff --git a/tests/AcDream.Core.Tests/Rendering/Issue176177DungeonSeamInspectionTests.cs b/tests/AcDream.Core.Tests/Rendering/Issue176177DungeonSeamInspectionTests.cs new file mode 100644 index 00000000..5013fb1d --- /dev/null +++ b/tests/AcDream.Core.Tests/Rendering/Issue176177DungeonSeamInspectionTests.cs @@ -0,0 +1,676 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Numerics; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; +using Xunit; +using Xunit.Abstractions; +using Env = System.Environment; + +namespace AcDream.Core.Tests.Rendering; + +/// +/// #176 (purple flashing on dungeon floors at cell seams) + #177 (stairs pop +/// in/out across levels) — dat-truth inspection for the Facility Hub anchor +/// cells. The load-bearing topology fact from the #137 arc: corridor FLOORS +/// are portal polygons (PortalSide floor-portals to under-rooms, e.g. +/// 0x8A02016E visual polys 1/3/5 → 0x011E). These dumps answer: +/// +/// (a) are the floor-portal VISUAL polys textured (drawn by CellMesh.Build) +/// or NoPos-stippled (skipped)? Same question for the RECIPROCAL portal +/// polys in the other cell — two textured coincident planes would +/// z-fight (#176's angle-dependent flash candidate); +/// (b) which cell owns the actual stair-step geometry at the +/// 0x8A020182 → 0x8A020183 level transit (#177's pop-in subject); +/// (c) do any drawn polys reference surfaces that fail to resolve +/// (the magenta-placeholder class)? +/// +/// ⚠️ id-space trap (cost the #137 saga a wrong mechanism): +/// CellPortal.PolygonId indexes CellStruct.Polygons (VISUAL), never +/// PhysicsPolygons — same ids in both tables are unrelated polygons. +/// +public class Issue176177DungeonSeamInspectionTests +{ + private readonly ITestOutputHelper _out; + public Issue176177DungeonSeamInspectionTests(ITestOutputHelper output) => _out = output; + + private static string? ResolveDatDir() + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + return Directory.Exists(datDir) ? datDir : null; + } + + private static Matrix4x4 WorldTransform(EnvCell cell) + { + var rot = new Quaternion( + cell.Position.Orientation.X, cell.Position.Orientation.Y, + cell.Position.Orientation.Z, cell.Position.Orientation.W); + return Matrix4x4.CreateFromQuaternion(rot) + * Matrix4x4.CreateTranslation( + cell.Position.Origin.X, cell.Position.Origin.Y, cell.Position.Origin.Z); + } + + private static (EnvCell cell, DatReaderWriter.Types.CellStruct cs)? LoadCell(DatCollection dats, uint cellId) + { + var envCell = dats.Get(cellId); + if (envCell is null) return null; + var environment = dats.Get(0x0D000000u | envCell.EnvironmentId); + if (environment is null) return null; + if (!environment.Cells.TryGetValue(envCell.CellStructure, out var cs)) return null; + return (envCell, cs!); + } + + private static List WorldVerts( + DatReaderWriter.Types.CellStruct cs, DatReaderWriter.Types.Polygon poly, Matrix4x4 world) + { + var result = new List(poly.VertexIds.Count); + foreach (var vid in poly.VertexIds) + if (cs.VertexArray.Vertices.TryGetValue((ushort)vid, out var v)) + result.Add(Vector3.Transform(v.Origin, world)); + return result; + } + + /// + /// Mirror of CellMesh.Build's inclusion rules (verts ≥ 3, no NoPos + /// stippling, PosSurface index in range) — the DRAWN verdict per poly. + /// + private static bool WouldDraw(DatReaderWriter.Types.Polygon poly, EnvCell cell) => + poly.VertexIds.Count >= 3 + && !poly.Stippling.HasFlag(DatReaderWriter.Enums.StipplingType.NoPos) + && poly.PosSurface >= 0 + && poly.PosSurface < cell.Surfaces.Count; + + /// + /// (a)+(c): every CellPortal of the cell — the visual portal poly's + /// stippling/sides/surface, world plane, span, DRAWN verdict, and whether + /// the referenced Surface resolves in the dat. + /// + [Theory] + [InlineData(0x8A02016Eu)] // corridor with floor-portals 1/3/5 → 0x011E (#176 anchor) + [InlineData(0x8A02011Eu)] // the under-hall at z=−12 those portals lead to + [InlineData(0x8A02017Au)] // adjacent corridor cell (the #137 seam partner) + [InlineData(0x8A020182u)] // stair transit upper cell, z −6 (#177 anchor) + [InlineData(0x8A020183u)] // stair transit lower cell, z −9 (#177 anchor) + public void PortalPolys_SurfaceAndDrawVerdict_Dump(uint cellId) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var loaded = LoadCell(dats, cellId); + Assert.NotNull(loaded); + var (cell, cs) = loaded!.Value; + var world = WorldTransform(cell); + + _out.WriteLine($"=== 0x{cellId:X8} Env=0x{cell.EnvironmentId:X4} struct={cell.CellStructure} " + + $"pos=({cell.Position.Origin.X:F2},{cell.Position.Origin.Y:F2},{cell.Position.Origin.Z:F2}) ==="); + _out.WriteLine($" Surfaces ({cell.Surfaces.Count}): " + + string.Join(" ", cell.Surfaces.ConvertAll(s => $"0x{0x08000000u | (uint)s:X8}"))); + _out.WriteLine($" visualPolys={cs.Polygons.Count} physicsPolys={cs.PhysicsPolygons.Count} portals={cell.CellPortals.Count}"); + + // #177 pivot check: dungeon staircases are often EnvCell STATICS (the + // #119 tower class) — if one lives here, the vanish subject is the + // static's cull, not the shell flood. + _out.WriteLine($" StaticObjects={cell.StaticObjects.Count}"); + foreach (var so in cell.StaticObjects) + _out.WriteLine($" static id=0x{so.Id:X8} at ({so.Frame.Origin.X:F2},{so.Frame.Origin.Y:F2},{so.Frame.Origin.Z:F2})"); + + foreach (var p in cell.CellPortals) + { + if (!cs.Polygons.TryGetValue((ushort)p.PolygonId, out var poly)) + { + _out.WriteLine($" portal poly={p.PolygonId} -> 0x{p.OtherCellId:X4} [{p.Flags}] NOT IN VISUAL TABLE"); + continue; + } + + var w = WorldVerts(cs, poly, world); + var n = w.Count >= 3 + ? Vector3.Normalize(Vector3.Cross(w[1] - w[0], w[2] - w[0])) + : Vector3.Zero; + var min = new Vector3(float.MaxValue); var max = new Vector3(float.MinValue); + foreach (var v in w) { min = Vector3.Min(min, v); max = Vector3.Max(max, v); } + + bool drawn = WouldDraw(poly, cell); + string surfInfo = "posSurf=OUT-OF-RANGE"; + if (poly.PosSurface >= 0 && poly.PosSurface < cell.Surfaces.Count) + { + uint surfaceId = 0x08000000u | (uint)cell.Surfaces[poly.PosSurface]; + var surface = dats.Get(surfaceId); + surfInfo = surface is null + ? $"posSurf[{poly.PosSurface}]=0x{surfaceId:X8} SURFACE-MISS" + : $"posSurf[{poly.PosSurface}]=0x{surfaceId:X8} type={surface.Type} origTex=0x{(uint)surface.OrigTextureId:X8}"; + } + + _out.WriteLine( + $" portal poly={p.PolygonId} -> 0x{p.OtherCellId:X4} [{p.Flags}] " + + $"stip={poly.Stippling} sides={poly.SidesType} verts={poly.VertexIds.Count} " + + $"n=({n.X:F2},{n.Y:F2},{n.Z:F2}) " + + $"x=[{min.X:F2},{max.X:F2}] y=[{min.Y:F2},{max.Y:F2}] z=[{min.Z:F2},{max.Z:F2}] " + + $"{surfInfo} DRAWN={drawn}"); + } + + // (c) sweep: any DRAWN poly in the whole cell whose surface misses. + int drawnCount = 0, missCount = 0; + foreach (var (id, poly) in cs.Polygons) + { + if (!WouldDraw(poly, cell)) continue; + drawnCount++; + uint surfaceId = 0x08000000u | (uint)cell.Surfaces[poly.PosSurface]; + if (dats.Get(surfaceId) is null) + { + missCount++; + _out.WriteLine($" >>> DRAWN poly {id} has MISSING surface 0x{surfaceId:X8}"); + } + } + _out.WriteLine($" drawn-poly sweep: {drawnCount} drawn, {missCount} with missing surfaces"); + } + + /// + /// (a) reciprocal check: for each anchor pair, world-transform BOTH + /// sides' portal polys and test plane coincidence + both-drawn — the + /// #176 z-fight candidate is a coincident pair with DRAWN=true twice. + /// + [Theory] + [InlineData(0x8A02016Eu, 0x8A02011Eu)] + [InlineData(0x8A02016Eu, 0x8A02017Au)] + [InlineData(0x8A020182u, 0x8A020183u)] + public void ReciprocalPortalPolys_CoincidenceAndDrawVerdict(uint cellA, uint cellB) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var la = LoadCell(dats, cellA); + var lb = LoadCell(dats, cellB); + Assert.NotNull(la); + Assert.NotNull(lb); + var (ca, csa) = la!.Value; + var (cb, csb) = lb!.Value; + var wa = WorldTransform(ca); + var wb = WorldTransform(cb); + + ushort lowA = (ushort)(cellA & 0xFFFFu); + ushort lowB = (ushort)(cellB & 0xFFFFu); + + _out.WriteLine($"=== reciprocal pair 0x{cellA:X8} <-> 0x{cellB:X8} ==="); + foreach (var pa in ca.CellPortals) + { + if (pa.OtherCellId != lowB) continue; + if (!csa.Polygons.TryGetValue((ushort)pa.PolygonId, out var polyA)) continue; + var va = WorldVerts(csa, polyA, wa); + if (va.Count < 3) continue; + var na = Vector3.Normalize(Vector3.Cross(va[1] - va[0], va[2] - va[0])); + float da = Vector3.Dot(na, va[0]); + bool drawnA = WouldDraw(polyA, ca); + + _out.WriteLine($" A poly={pa.PolygonId} [{pa.Flags}] n=({na.X:F2},{na.Y:F2},{na.Z:F2}) planeD={da:F2} " + + $"stip={polyA.Stippling} sides={polyA.SidesType} DRAWN={drawnA}"); + + foreach (var pb in cb.CellPortals) + { + if (pb.OtherCellId != lowA) continue; + if (!csb.Polygons.TryGetValue((ushort)pb.PolygonId, out var polyB)) continue; + var vb = WorldVerts(csb, polyB, wb); + if (vb.Count < 3) continue; + var nb = Vector3.Normalize(Vector3.Cross(vb[1] - vb[0], vb[2] - vb[0])); + float db = Vector3.Dot(nb, vb[0]); + bool drawnB = WouldDraw(polyB, cb); + + float align = Vector3.Dot(na, nb); + // Coincident planes: |align|≈1 and same plane offset (sign per normal direction). + bool coincident = MathF.Abs(align) > 0.99f + && MathF.Abs(MathF.Abs(da) - MathF.Abs(db)) < 0.05f; + + _out.WriteLine($" B poly={pb.PolygonId} [{pb.Flags}] n=({nb.X:F2},{nb.Y:F2},{nb.Z:F2}) planeD={db:F2} " + + $"stip={polyB.Stippling} sides={polyB.SidesType} DRAWN={drawnB} " + + $"align={align:F3} coincident={coincident}" + + (coincident && drawnA && drawnB ? " >>> Z-FIGHT CANDIDATE (both drawn, same plane)" : "")); + } + } + } + + /// + /// #176 THE STRIPES (user screenshot, 2026-07-06 evening): a floor region + /// z-fights in regular bands between a purple-lit copy and an unlit copy — + /// two COINCIDENT DRAWN surfaces with different per-cell light sets. This + /// sweep hunts the pair in the dat: every pair of DRAWN polys across the + /// corridor neighborhood that is coplanar AND overlapping in area. Before + /// the light-cap fix both copies were usually equally unlit (the purple + /// portal light was cap-evicted) so the fight was invisible; the stable + /// light exposed it. + /// + [Fact] + public void CorridorNeighborhood_CoplanarOverlappingDrawnPolyPairs() + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + // Seed cells around the screenshot location (the 016E/017A seam) + + // one portal ring. + var cellIds = new HashSet { 0x8A020164u, 0x8A020165u, 0x8A02016Eu, 0x8A02017Au }; + foreach (var seed in new List(cellIds)) + { + var seedCell = dats.Get(seed); + if (seedCell is null) continue; + foreach (var p in seedCell.CellPortals) + cellIds.Add(0x8A020000u | p.OtherCellId); + } + + // Collect all DRAWN polys world-space per cell. + var drawn = new List<(uint CellId, ushort PolyId, Vector3 N, float D, + Vector3 Min, Vector3 Max, uint SurfaceId)>(); + foreach (var cellId in cellIds) + { + var loaded = LoadCell(dats, cellId); + if (loaded is null) continue; + var (cell, cs) = loaded.Value; + var world = WorldTransform(cell); + + foreach (var (id, poly) in cs.Polygons) + { + if (!WouldDraw(poly, cell)) continue; + var w = WorldVerts(cs, poly, world); + if (w.Count < 3) continue; + var n = Vector3.Normalize(Vector3.Cross(w[1] - w[0], w[2] - w[0])); + float d = Vector3.Dot(n, w[0]); + var min = new Vector3(float.MaxValue); var max = new Vector3(float.MinValue); + foreach (var v in w) { min = Vector3.Min(min, v); max = Vector3.Max(max, v); } + uint surfaceId = 0x08000000u | (uint)cell.Surfaces[poly.PosSurface]; + drawn.Add((cellId, id, n, d, min, max, surfaceId)); + } + } + _out.WriteLine($"cells={cellIds.Count} drawnPolys={drawn.Count}"); + + int pairs = 0; + for (int i = 0; i < drawn.Count; i++) + { + for (int j = i + 1; j < drawn.Count; j++) + { + var a = drawn[i]; var b = drawn[j]; + if (a.CellId == b.CellId && a.PolyId == b.PolyId) continue; + + float align = Vector3.Dot(a.N, b.N); + if (MathF.Abs(align) < 0.999f) continue; + float dB = align > 0 ? b.D : -b.D; + if (MathF.Abs(a.D - dB) > 0.02f) continue; // same plane within 2 cm + + // Overlap in world AABB, with meaningful area in the plane. + float ox = MathF.Min(a.Max.X, b.Max.X) - MathF.Max(a.Min.X, b.Min.X); + float oy = MathF.Min(a.Max.Y, b.Max.Y) - MathF.Max(a.Min.Y, b.Min.Y); + float oz = MathF.Min(a.Max.Z, b.Max.Z) - MathF.Max(a.Min.Z, b.Min.Z); + if (ox < 0.05f || oy < 0.05f) continue; + // For horizontal planes require XY overlap area; for walls allow thin Z. + bool horizontal = MathF.Abs(a.N.Z) > 0.85f; + if (horizontal && ox * oy < 0.05f) continue; + if (!horizontal && oz < 0.05f) continue; + + pairs++; + _out.WriteLine( + $">>> COPLANAR-OVERLAP {(a.CellId == b.CellId ? "SAME-CELL" : "CROSS-CELL")}: " + + $"0x{a.CellId:X8} poly {a.PolyId} (surf 0x{a.SurfaceId:X8}) <-> " + + $"0x{b.CellId:X8} poly {b.PolyId} (surf 0x{b.SurfaceId:X8}) " + + $"n=({a.N.X:F2},{a.N.Y:F2},{a.N.Z:F2}) align={align:F3} " + + $"overlap x={ox:F2} y={oy:F2} z=[{MathF.Max(a.Min.Z, b.Min.Z):F2}..{MathF.Min(a.Max.Z, b.Max.Z):F2}]"); + } + } + _out.WriteLine($"coplanar overlapping drawn pairs: {pairs}"); + } + + /// + /// #176 candidate (A2C): the opaque pass derives GL_SAMPLE_ALPHA_TO_COVERAGE + /// from the sampled texture alpha (mesh_modern.frag uRenderPass==0 keeps + /// alpha as-sampled). If the corridor floor texture decodes with alpha + /// below 1.0, MSAA coverage punches see-through holes in the floor — + /// fog-purple clear color — worst at grazing angles (mip-level dependent + /// → camera-angle dependent, far floor = at seams). Decode the floor + /// surface chain and histogram the alpha channel. + /// + [Theory] + [InlineData(0x08000377u)] // corridor floor (portal strips + plain floors) + [InlineData(0x08000376u)] + [InlineData(0x08000375u)] + [InlineData(0x08000378u)] + [InlineData(0x08000379u)] // under-level walls + [InlineData(0x080000DFu)] // stair-transit cells' 5th surface + public void FloorSurface_DecodedAlphaHistogram(uint surfaceId) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var surface = dats.Get(surfaceId); + Assert.NotNull(surface); + _out.WriteLine($"Surface 0x{surfaceId:X8}: type={surface!.Type} origTex=0x{(uint)surface.OrigTextureId:X8} " + + $"transl={surface.Translucency:F2}"); + if (surface.OrigTextureId == 0) { _out.WriteLine(" (no texture — solid color surface)"); return; } + + var surfTex = dats.Get((uint)surface.OrigTextureId); + Assert.NotNull(surfTex); + _out.WriteLine($" SurfaceTexture 0x{(uint)surface.OrigTextureId:X8}: {surfTex!.Textures.Count} textures " + + $"[{string.Join(" ", surfTex.Textures.ConvertAll(t => $"0x{t:X8}"))}]"); + + foreach (var texId in surfTex.Textures) + { + var rs = dats.Get((uint)texId); + if (rs is null) { _out.WriteLine($" RenderSurface 0x{texId:X8}: MISS"); continue; } + + // Decode with the production Core helpers (same paths the WB atlas uses). + var data = new byte[rs.Width * rs.Height * 4]; + bool decodedOk = true; + switch (rs.Format) + { + case DatReaderWriter.Enums.PixelFormat.PFID_INDEX16: + { + var pal = dats.Get(rs.DefaultPaletteId); + if (pal is null) { _out.WriteLine($" RenderSurface 0x{texId:X8}: INDEX16 with no palette 0x{rs.DefaultPaletteId:X8}"); decodedOk = false; break; } + AcDream.Core.Rendering.Wb.TextureHelpers.FillIndex16(rs.SourceData, pal, data, rs.Width, rs.Height); + break; + } + case DatReaderWriter.Enums.PixelFormat.PFID_P8: + { + var pal = dats.Get(rs.DefaultPaletteId); + if (pal is null) { _out.WriteLine($" RenderSurface 0x{texId:X8}: P8 with no palette"); decodedOk = false; break; } + AcDream.Core.Rendering.Wb.TextureHelpers.FillP8(rs.SourceData, pal, data, rs.Width, rs.Height); + break; + } + case DatReaderWriter.Enums.PixelFormat.PFID_R5G6B5: + AcDream.Core.Rendering.Wb.TextureHelpers.FillR5G6B5(rs.SourceData, data, rs.Width, rs.Height); + break; + case DatReaderWriter.Enums.PixelFormat.PFID_A4R4G4B4: + AcDream.Core.Rendering.Wb.TextureHelpers.FillA4R4G4B4(rs.SourceData, data, rs.Width, rs.Height); + break; + case DatReaderWriter.Enums.PixelFormat.PFID_A8R8G8B8: + AcDream.Core.Rendering.Wb.TextureHelpers.FillA8R8G8B8(rs.SourceData, data, rs.Width, rs.Height); + break; + case DatReaderWriter.Enums.PixelFormat.PFID_R8G8B8: + AcDream.Core.Rendering.Wb.TextureHelpers.FillR8G8B8(rs.SourceData, data, rs.Width, rs.Height); + break; + case DatReaderWriter.Enums.PixelFormat.PFID_DXT1: + { + // DXT1/BC1: 8-byte blocks — c0 (u16 LE), c1 (u16 LE), 16×2-bit + // indices. c0 <= c1 selects 3-COLOR mode where index 3 decodes + // to TRANSPARENT BLACK (alpha=0). Our atlas uploads DXT1 as the + // RGBA variant (TextureFormatExtensions.ToCompressedGL), so any + // such texel reaches the shader with alpha=0 — and the opaque + // pass discards alpha<0.05 fragments. Count them. + int blocks = rs.SourceData.Length / 8; + int threeColorBlocks = 0; + long transparentTexels = 0; + for (int b = 0; b < blocks; b++) + { + int o = b * 8; + ushort c0 = (ushort)(rs.SourceData[o] | (rs.SourceData[o + 1] << 8)); + ushort c1 = (ushort)(rs.SourceData[o + 2] | (rs.SourceData[o + 3] << 8)); + if (c0 > c1) continue; // 4-color opaque mode + threeColorBlocks++; + for (int bi = 0; bi < 4; bi++) + { + byte row = rs.SourceData[o + 4 + bi]; + for (int t = 0; t < 4; t++) + if (((row >> (t * 2)) & 0x3) == 3) + transparentTexels++; + } + } + _out.WriteLine($" RenderSurface 0x{texId:X8} DXT1 {rs.Width}x{rs.Height}: blocks={blocks} " + + $"threeColorBlocks={threeColorBlocks} alpha0Texels={transparentTexels}" + + (transparentTexels > 0 + ? " >>> ALPHA=0 TEXELS PRESENT (opaque-pass discard punches holes)" + : " (no transparent-mode texels)")); + decodedOk = false; // histogram printed above; skip the RGBA path + break; + } + default: + _out.WriteLine($" RenderSurface 0x{texId:X8}: fmt={rs.Format} (not decoded by this test)"); + decodedOk = false; + break; + } + if (!decodedOk) continue; + + // Alpha histogram over the decoded RGBA bytes (stride 4, alpha at +3). + int n = data.Length / 4; + int a255 = 0, aHigh = 0, aMid = 0, aLow = 0, a0 = 0; + byte minA = 255; + for (int i = 0; i < n; i++) + { + byte a = data[i * 4 + 3]; + if (a < minA) minA = a; + if (a == 255) a255++; + else if (a >= 243) aHigh++; // ≥0.95 — safe for A2C + else if (a >= 13) aMid++; // 0.05..0.95 — partial coverage + else if (a > 0) aLow++; + else a0++; + } + _out.WriteLine($" RenderSurface 0x{texId:X8} fmt={rs.Format} {rs.Width}x{rs.Height}: " + + $"alpha histogram n={n} a=255:{a255} 243-254:{aHigh} 13-242:{aMid} 1-12:{aLow} 0:{a0} minA={minA}" + + (aMid + aLow + a0 > 0 ? " >>> SUB-OPAQUE ALPHA PRESENT (A2C hole candidate)" : " (fully opaque)")); + } + } + + /// + /// #176 candidate: the under-hall 0x011E floods in at down-pitches and + /// its surface list carries 0x08000034 (Base1Solid|Translucent — a + /// COLORED translucent solid). If its drawn polys sit at z=−6 (coplanar + /// with the corridor floor), the transparent pass blends that color over + /// the floor whenever the under-hall is admitted — angle-dependent + /// purple at seams. Dump every DRAWN poly (plane, z-span, surface, and + /// the surface's ColorValue) of the under-hall + its under-level + /// neighbors. + /// + [Theory] + [InlineData(0x8A02011Eu)] + [InlineData(0x8A020119u)] + [InlineData(0x8A02011Du)] + [InlineData(0x8A020122u)] + [InlineData(0x8A02011Fu)] + [InlineData(0x8A02016Eu)] // corridor cells — the striped-floor screenshot area + [InlineData(0x8A02017Au)] + [InlineData(0x8A020165u)] + public void UnderHall_DrawnPolys_SurfaceColors(uint cellId) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var loaded = LoadCell(dats, cellId); + if (loaded is null) { _out.WriteLine($"0x{cellId:X8} NOT FOUND"); return; } + var (cell, cs) = loaded.Value; + var world = WorldTransform(cell); + + _out.WriteLine($"=== 0x{cellId:X8} drawn polys ==="); + foreach (var (id, poly) in cs.Polygons) + { + if (!WouldDraw(poly, cell)) continue; + var w = WorldVerts(cs, poly, world); + if (w.Count < 3) continue; + var n = Vector3.Normalize(Vector3.Cross(w[1] - w[0], w[2] - w[0])); + float minZ = float.MaxValue, maxZ = float.MinValue; + foreach (var v in w) { minZ = MathF.Min(minZ, v.Z); maxZ = MathF.Max(maxZ, v.Z); } + + uint surfaceId = 0x08000000u | (uint)cell.Surfaces[poly.PosSurface]; + var surface = dats.Get(surfaceId); + string surfInfo = surface is null + ? $"0x{surfaceId:X8} MISS" + : $"0x{surfaceId:X8} type={surface.Type} color=0x{surface.ColorValue:X8} origTex=0x{(uint)surface.OrigTextureId:X8} lum={surface.Luminosity:F2} transl={surface.Translucency:F2}"; + _out.WriteLine($" poly {id}: n=({n.X:F2},{n.Y:F2},{n.Z:F2}) z=[{minZ:F2},{maxZ:F2}] " + + $"verts={poly.VertexIds.Count} surf={surfInfo}"); + } + } + + /// + /// The transit-lag question (#176/#177 root-cause fork): production + /// [cell-transit] lines fire 0.1–0.6 m PAST the portal plane. Is that + /// (a) dat-real — the cells' CellBSP volumes OVERLAP past the plane, so + /// retail's point_in_cell (same dat, same walk) keeps the old cell too — + /// or (b) our membership's bug? Probe raw CellBSP containment for both + /// cells of each seam across the portal plane. + /// + [Theory] + [InlineData(0x8A02016Eu, 0x8A02017Au, 85.00f, -40f, -5.0f)] + [InlineData(0x8A020182u, 0x8A020183u, 98.333f, -40f, -7.5f)] + public void SeamCells_CellBspContainment_AcrossPortalPlane( + uint cellAId, uint cellBId, float planeX, float y, float z) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var la = LoadCell(dats, cellAId); + var lb = LoadCell(dats, cellBId); + Assert.NotNull(la); + Assert.NotNull(lb); + var (ca, csa) = la!.Value; + var (cb, csb) = lb!.Value; + + Matrix4x4.Invert(WorldTransform(ca), out var invA); + Matrix4x4.Invert(WorldTransform(cb), out var invB); + + _out.WriteLine($"=== CellBSP containment across plane x={planeX:F2} " + + $"(A=0x{cellAId:X8}, B=0x{cellBId:X8}) ==="); + for (float dx = -0.6f; dx <= 0.65f; dx += 0.05f) + { + var world = new Vector3(planeX + dx, y, z); + bool inA = csa.CellBSP?.Root is not null + && Physics.PointInCellBspViaBspQuery(csa.CellBSP.Root, Vector3.Transform(world, invA)); + bool inB = csb.CellBSP?.Root is not null + && Physics.PointInCellBspViaBspQuery(csb.CellBSP.Root, Vector3.Transform(world, invB)); + _out.WriteLine($" x=plane{(dx >= 0 ? "+" : "")}{dx:F2} inA={(inA ? "Y" : "-")} inB={(inB ? "Y" : "-")}" + + (inA && inB ? " <<< OVERLAP" : !inA && !inB ? " <<< NEITHER" : "")); + } + } + + private static class Physics + { + // Thin forwarder so this Rendering-side test reads clearly; the walk + // is the production BSPQuery.PointInsideCellBsp. + public static bool PointInCellBspViaBspQuery( + DatReaderWriter.Types.CellBSPNode node, Vector3 localPoint) + => AcDream.Core.Physics.BSPQuery.PointInsideCellBsp(node, localPoint); + } + + /// + /// (b) #177: which cell owns the stair-step geometry? Histogram of DRAWN + /// visual polys by normal class + the z-ladder of horizontal polys + /// (stair steps show as a ladder of small floor polys at stepped + /// z-levels). Also lists every portal with its plane orientation — + /// is the 0x0182↔0x0183 connection a floor-portal or a wall-portal? + /// + [Theory] + [InlineData(0x8A020182u)] + [InlineData(0x8A020183u)] + public void StairTransit_GeometryOwnerAndPortalOrientation(uint cellId) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var loaded = LoadCell(dats, cellId); + Assert.NotNull(loaded); + var (cell, cs) = loaded!.Value; + var world = WorldTransform(cell); + + int floors = 0, ceilings = 0, walls = 0, inclined = 0; + var floorZLevels = new SortedDictionary(); // z rounded to 0.1 m → count + + foreach (var (id, poly) in cs.Polygons) + { + var w = WorldVerts(cs, poly, world); + if (w.Count < 3) continue; + var n = Vector3.Normalize(Vector3.Cross(w[1] - w[0], w[2] - w[0])); + float az = MathF.Abs(n.Z); + if (az > 0.85f) + { + // Horizontal poly — bucket by mean z. + float meanZ = 0; foreach (var v in w) meanZ += v.Z; meanZ /= w.Count; + int zKey = (int)MathF.Round(meanZ * 10f); + floorZLevels.TryGetValue(zKey, out var c); + floorZLevels[zKey] = c + 1; + if (n.Z > 0) floors++; else ceilings++; + } + else if (az < 0.25f) walls++; + else + { + inclined++; + float minZ = float.MaxValue, maxZ = float.MinValue; + foreach (var v in w) { minZ = MathF.Min(minZ, v.Z); maxZ = MathF.Max(maxZ, v.Z); } + _out.WriteLine($" INCLINED poly {id}: n=({n.X:F2},{n.Y:F2},{n.Z:F2}) z=[{minZ:F2},{maxZ:F2}] " + + $"verts={poly.VertexIds.Count} stip={poly.Stippling} DRAWN={WouldDraw(poly, cell)}"); + } + } + + _out.WriteLine($"=== 0x{cellId:X8} poly histogram: floors={floors} ceilings={ceilings} walls={walls} inclined={inclined} ==="); + _out.WriteLine(" horizontal-poly z-ladder (z → count): " + + string.Join(" ", System.Linq.Enumerable.Select(floorZLevels, kv => $"{kv.Key / 10f:F1}:{kv.Value}"))); + + foreach (var p in cell.CellPortals) + { + if (!cs.Polygons.TryGetValue((ushort)p.PolygonId, out var poly)) continue; + var w = WorldVerts(cs, poly, world); + if (w.Count < 3) continue; + var n = Vector3.Normalize(Vector3.Cross(w[1] - w[0], w[2] - w[0])); + string orient = MathF.Abs(n.Z) > 0.85f ? "HORIZONTAL (floor/ceiling portal)" + : MathF.Abs(n.Z) < 0.25f ? "vertical (wall portal)" + : "INCLINED portal"; + var min = new Vector3(float.MaxValue); var max = new Vector3(float.MinValue); + foreach (var v in w) { min = Vector3.Min(min, v); max = Vector3.Max(max, v); } + _out.WriteLine($" portal poly={p.PolygonId} -> 0x{p.OtherCellId:X4} [{p.Flags}] {orient} " + + $"n=({n.X:F2},{n.Y:F2},{n.Z:F2}) z=[{min.Z:F2},{max.Z:F2}]"); + } + } + + /// + /// #176 THE TRIANGLES (user screenshot, 2026-07-06): floor tiles show hard + /// per-triangle purple facets — smooth Gouraud can't produce a hard diagonal + /// across a flat tile, so the CELL VERTEX NORMALS are the suspect. CellMesh.cs:80 + /// uses sw.Normal (dat vertex normal), falling back to UnitZ when zero. Dump the + /// per-vertex dat normals for every DRAWN poly: are they smooth (vary per vertex), + /// per-FACE (constant per poly = flat shading = facets), or ZERO (fallback → all + /// up → floor unlit)? Compares the dat vertex normal to the poly's geometric + /// face normal to flag flat-shaded polys. + /// + [Theory] + [InlineData(0x8A02015Eu)] // #176 repro corridor + [InlineData(0x8A02016Eu)] // corridor with floor-portals + public void CellVertexNormals_SmoothOrFaceted_Dump(uint cellId) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var loaded = LoadCell(dats, cellId); + if (loaded is null) { _out.WriteLine($"0x{cellId:X8} NOT FOUND"); return; } + var (cell, cs) = loaded.Value; + + int zero = 0, faceMatch = 0, smooth = 0, total = 0; + _out.WriteLine($"=== 0x{cellId:X8} per-vertex dat normals (local space), DRAWN polys ==="); + foreach (var (id, poly) in cs.Polygons) + { + if (!WouldDraw(poly, cell)) continue; + // Geometric face normal from the first 3 LOCAL verts. + var lv = new List(); + var vn = new List(); + foreach (var vid in poly.VertexIds) + if (cs.VertexArray.Vertices.TryGetValue((ushort)vid, out var v)) { lv.Add(v.Origin); vn.Add(v.Normal); } + if (lv.Count < 3) continue; + total++; + var face = Vector3.Normalize(Vector3.Cross(lv[1] - lv[0], lv[2] - lv[0])); + + // Classify: all-zero (fallback), all-equal-to-face (flat), or varying (smooth). + bool allZero = vn.TrueForAll(x => x == Vector3.Zero); + bool allEqualFace = vn.TrueForAll(x => x != Vector3.Zero && Vector3.Dot(Vector3.Normalize(x), face) > 0.999f); + bool varying = false; + for (int i = 1; i < vn.Count; i++) + if (vn[i] != Vector3.Zero && Vector3.Dot(Vector3.Normalize(vn[i]), Vector3.Normalize(vn[0])) < 0.999f) varying = true; + if (allZero) zero++; else if (allEqualFace) faceMatch++; else if (varying) smooth++; + + string tag = allZero ? "ZERO(→UnitZ)" : allEqualFace ? "FLAT(=face)" : varying ? "SMOOTH(varies)" : "uniform(≠face)"; + _out.WriteLine($" poly {id} face=({face.X:F2},{face.Y:F2},{face.Z:F2}) {tag} datN=[" + + string.Join(" ", vn.ConvertAll(x => $"({x.X:F2},{x.Y:F2},{x.Z:F2})")) + "]"); + } + _out.WriteLine($"SUMMARY 0x{cellId:X8}: drawnPolys={total} zero={zero} flatFace={faceMatch} smooth={smooth}"); + } +} diff --git a/tests/AcDream.Core.Tests/Rendering/Issue93TownNetworkFountainRoomLightInspectionTests.cs b/tests/AcDream.Core.Tests/Rendering/Issue93TownNetworkFountainRoomLightInspectionTests.cs new file mode 100644 index 00000000..aa7e1159 --- /dev/null +++ b/tests/AcDream.Core.Tests/Rendering/Issue93TownNetworkFountainRoomLightInspectionTests.cs @@ -0,0 +1,186 @@ +using System; +using System.IO; +using DatReaderWriter; +using DatReaderWriter.DBObjs; +using DatReaderWriter.Options; +using Xunit; +using Xunit.Abstractions; +using Env = System.Environment; + +namespace AcDream.Core.Tests.Rendering; + +/// +/// #79/#93/#176/#177 A7.L1 (2026-07-09) — dat-truth check for the Town Network +/// fountain room (0x00070144). Live probe evidence (launch-a7-lightscope.log) +/// showed 0x00070144 NEVER appears in the [indoor-light] byCell histogram across +/// every visit this session, regardless of the visible-cell scoping fix — every +/// pooled light belongs to NEIGHBORING cells (0x132/0x133/0x143/0x145/0x155/0x157), +/// never to 0x144 itself. Both registration sites (GameWindow.cs:3771 live weenie +/// spawns, GameWindow.cs:7919 dat EnvCell statics) already tag CellId correctly, so +/// this is either (a) the room genuinely has no dat-authored Setup.Lights of its +/// own (a registration/spawn-side non-issue — the darkness is caused by something +/// else entirely), or (b) it DOES have fixtures that never made it into +/// EnvCell.StaticObjects / the live weenie spawn set (a real hydration gap). +/// Dumps StaticObjects + each Setup-sourced static's Setup.Lights.Count for the +/// fountain room and its immediate neighbors observed this session, so the answer +/// is read from the dat directly instead of inferred from aggregate counts. +/// +public class Issue93TownNetworkFountainRoomLightInspectionTests +{ + private readonly ITestOutputHelper _out; + public Issue93TownNetworkFountainRoomLightInspectionTests(ITestOutputHelper output) => _out = output; + + private static string? ResolveDatDir() + { + var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR") + ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile), + "Documents", "Asheron's Call"); + return Directory.Exists(datDir) ? datDir : null; + } + + [Theory] + [InlineData(0x00070144u)] // the fountain room — the user's original repro spot + [InlineData(0x00070156u)] // player's teleport-in cell this session + [InlineData(0x00070164u)] + [InlineData(0x00070132u)] + [InlineData(0x00070133u)] + [InlineData(0x00070143u)] + [InlineData(0x00070145u)] + [InlineData(0x00070146u)] + [InlineData(0x00070155u)] + [InlineData(0x00070157u)] + public void StaticObjects_SetupLightsCount_Dump(uint cellId) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var envCell = dats.Get(cellId); + if (envCell is null) + { + _out.WriteLine($"=== 0x{cellId:X8} NOT FOUND in dat ==="); + return; + } + + _out.WriteLine($"=== 0x{cellId:X8} Env=0x{envCell.EnvironmentId:X4} struct={envCell.CellStructure} " + + $"pos=({envCell.Position.Origin.X:F2},{envCell.Position.Origin.Y:F2},{envCell.Position.Origin.Z:F2}) " + + $"StaticObjects={envCell.StaticObjects.Count} ==="); + + int totalLights = 0; + foreach (var so in envCell.StaticObjects) + { + if ((so.Id & 0xFF000000u) == 0x02000000u) + { + var setup = dats.Get(so.Id); + int lightCount = setup?.Lights.Count ?? -1; + totalLights += Math.Max(lightCount, 0); + _out.WriteLine($" SETUP id=0x{so.Id:X8} at ({so.Frame.Origin.X:F2},{so.Frame.Origin.Y:F2},{so.Frame.Origin.Z:F2}) Lights={lightCount}"); + } + else + { + _out.WriteLine($" id=0x{so.Id:X8} at ({so.Frame.Origin.X:F2},{so.Frame.Origin.Y:F2},{so.Frame.Origin.Z:F2}) (not a Setup — no Lights dict)"); + } + } + _out.WriteLine($" TOTAL dat-authored Lights in cell 0x{cellId:X8} StaticObjects: {totalLights}"); + } + + /// + /// Setup 0x02000365 at (69.88,-69.92,5.01) — 5 m above the fountain, the room's + /// ONLY dat-authored light (Lights=1) — never appeared in the live [indoor-light] + /// byCell histogram. GameWindow.cs:7324 drops the ENTIRE hydrated entity (light + /// included) when its flattened meshRefs.Count == 0 — mirror that exact + /// gate here (IsRuntimeHiddenMarker skip, then GfxObj-resolves check) to see + /// whether this specific fixture is a mesh-less/marker-only "light attach point" + /// that the mesh-gate silently drops before the lights loop (GameWindow.cs:7892) + /// ever sees it. + /// + [Fact] + public void CeilingFixtureSetup_MeshFlattenSurvivorCount_Dump() + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + const uint setupId = 0x02000365u; + var setup = dats.Get(setupId); + Assert.NotNull(setup); + + _out.WriteLine($"=== Setup 0x{setupId:X8}: Parts={setup!.Parts.Count} PlacementFrames={setup.PlacementFrames.Count} Lights={setup.Lights.Count} ==="); + foreach (var kvp in setup.Lights) + _out.WriteLine($" light[{kvp.Key}] Color=({kvp.Value.Color?.Red},{kvp.Value.Color?.Green},{kvp.Value.Color?.Blue}) Intensity={kvp.Value.Intensity} Falloff={kvp.Value.Falloff} ConeAngle={kvp.Value.ConeAngle}"); + + var flat = AcDream.Core.Meshing.SetupMesh.Flatten(setup); + _out.WriteLine($" SetupMesh.Flatten -> {flat.Count} MeshRefs"); + + int survivors = 0, markerSkipped = 0, gfxNull = 0; + foreach (var mr in flat) + { + if (AcDream.Core.Meshing.GfxObjDegradeResolver.IsRuntimeHiddenMarker(dats, mr.GfxObjId)) + { + markerSkipped++; + _out.WriteLine($" part gfx=0x{mr.GfxObjId:X8} -> MARKER (skipped)"); + continue; + } + var gfx = dats.Get(mr.GfxObjId); + if (gfx is null) + { + gfxNull++; + _out.WriteLine($" part gfx=0x{mr.GfxObjId:X8} -> GFXOBJ-NULL (dropped)"); + continue; + } + survivors++; + _out.WriteLine($" part gfx=0x{mr.GfxObjId:X8} -> survives (Polygons={gfx.Polygons.Count})"); + } + _out.WriteLine($" meshRefs survivor count = {survivors} (markerSkipped={markerSkipped} gfxNull={gfxNull}) " + + $"=> GameWindow.cs:7324 would {(survivors == 0 ? "DROP" : "KEEP")} this entity"); + } + + /// + /// Follow-up (same session, 2026-07-09): user confirmed lighting improved but + /// reported missing candle flames + fountain water particles. Hypothesis tested: + /// same mesh-empty hydration-gate class as the light fix, just for + /// Setup.DefaultScript instead of Setup.Lights (GpuWorldState.cs:221 fires + /// ambient particle scripts from DefaultScript.DataId per hydrated entity — the + /// SAME lb.Entities list EntityHydrationRules.ShouldKeepEntity gates). + /// REFUTED — do not re-chase this specific mechanism for #79/#93's particle + /// residual. The fountain (0x02000AA3) has a SURVIVING mesh part (1/1) AND a + /// real DefaultScript (0x33000B21, almost certainly the water spray) — never + /// dropped by the gate, mesh or no. The "16 ring objects" guess (0x02001967) was + /// WRONG: real mesh, DefaultScript==0 — not candles, no script at all. Filed as + /// its own issue (missing ambient particles) — the remaining suspects are + /// downstream of hydration entirely: does EntityScriptActivator/ + /// PhysicsScriptRunner actually fire DefaultScript=0x33000B21 for dat-hydrated + /// (ServerGuid==0) entities at runtime, does that script resolve to a real + /// PhysicsScriptTable entry, and does the resulting emitter reach the particle + /// renderer. NOT investigated further this session — separate root cause, + /// separate fix. + /// + [Theory] + [InlineData(0x02000AA3u)] // the fountain itself (cell 0x00070144 center) + [InlineData(0x02001967u)] // the 16 ring objects around the fountain (candles?) + [InlineData(0x020018C5u)] // the other cell-center static + public void FountainAndCandleSetup_DefaultScriptAndMeshSurvivorCount_Dump(uint setupId) + { + var datDir = ResolveDatDir(); + if (datDir is null) { _out.WriteLine("SKIP: no dat dir"); return; } + using var dats = new DatCollection(datDir, DatAccessType.Read); + + var setup = dats.Get(setupId); + Assert.NotNull(setup); + + _out.WriteLine($"=== Setup 0x{setupId:X8}: Parts={setup!.Parts.Count} DefaultScript.DataId=0x{setup.DefaultScript.DataId:X8} Lights={setup.Lights.Count} ==="); + + var flat = AcDream.Core.Meshing.SetupMesh.Flatten(setup); + int survivors = 0; + foreach (var mr in flat) + { + if (AcDream.Core.Meshing.GfxObjDegradeResolver.IsRuntimeHiddenMarker(dats, mr.GfxObjId)) continue; + if (dats.Get(mr.GfxObjId) is null) continue; + survivors++; + } + bool wouldBeKeptByCurrentFix = AcDream.Core.Meshing.EntityHydrationRules.ShouldKeepEntity(survivors, setup.Lights.Count); + _out.WriteLine($" flattened={flat.Count} meshSurvivors={survivors} " + + $"hasDefaultScript={setup.DefaultScript.DataId != 0} " + + $"=> current ShouldKeepEntity(mesh,lights) = {wouldBeKeptByCurrentFix}"); + } +} diff --git a/tests/AcDream.Core.Tests/Rendering/TranslucencyFadeManagerTests.cs b/tests/AcDream.Core.Tests/Rendering/TranslucencyFadeManagerTests.cs new file mode 100644 index 00000000..41be6390 --- /dev/null +++ b/tests/AcDream.Core.Tests/Rendering/TranslucencyFadeManagerTests.cs @@ -0,0 +1,152 @@ +using AcDream.Core.Rendering; +using Xunit; + +namespace AcDream.Core.Tests.Rendering; + +public sealed class TranslucencyFadeManagerTests +{ + [Fact] + public void StartPartFade_InstantEpsilon_CommitsEndImmediately() + { + var mgr = new TranslucencyFadeManager(); + + mgr.StartPartFade(entityId: 1, partIndex: 0, start: 0f, end: 1f, + time: TranslucencyFadeManager.TranslucencyInstantEpsilon); + + Assert.True(mgr.TryGetCurrentValue(1, 0, out float value)); + Assert.Equal(1f, value); + + // No ramp survives — advancing further changes nothing. + mgr.AdvanceAll(10f); + Assert.True(mgr.TryGetCurrentValue(1, 0, out float after)); + Assert.Equal(1f, after); + } + + [Fact] + public void StartPartFade_ZeroTime_IsTreatedAsInstant() + { + var mgr = new TranslucencyFadeManager(); + mgr.StartPartFade(entityId: 5, partIndex: 2, start: 0f, end: 0.5f, time: 0f); + + Assert.True(mgr.TryGetCurrentValue(5, 2, out float value)); + Assert.Equal(0.5f, value); + } + + [Fact] + public void StartPartFade_RealDuration_ImmediatelyReadableAsStart() + { + var mgr = new TranslucencyFadeManager(); + mgr.StartPartFade(entityId: 1, partIndex: 0, start: 0.2f, end: 0.8f, time: 1f); + + // Before any AdvanceAll — the ramp's t=0 value must already be readable + // (FPHook's first Execute call reports value=start on the same frame). + Assert.True(mgr.TryGetCurrentValue(1, 0, out float value)); + Assert.Equal(0.2f, value); + } + + [Fact] + public void AdvanceAll_LinearInterpolation_MidpointIsExact() + { + var mgr = new TranslucencyFadeManager(); + mgr.StartPartFade(entityId: 1, partIndex: 0, start: 0f, end: 1f, time: 1f); + + mgr.AdvanceAll(0.5f); + + Assert.True(mgr.TryGetCurrentValue(1, 0, out float value)); + Assert.Equal(0.5f, value, 5); + } + + [Fact] + public void AdvanceAll_AsymmetricRange_LinearAtQuarterDuration() + { + var mgr = new TranslucencyFadeManager(); + mgr.StartPartFade(entityId: 1, partIndex: 0, start: 0.2f, end: 1.0f, time: 4f); + + mgr.AdvanceAll(1f); // t = 0.25 + + Assert.True(mgr.TryGetCurrentValue(1, 0, out float value)); + Assert.Equal(0.2f + (1.0f - 0.2f) * 0.25f, value, 5); + } + + [Fact] + public void AdvanceAll_Overshoot_CommitsExactEndValue() + { + var mgr = new TranslucencyFadeManager(); + mgr.StartPartFade(entityId: 1, partIndex: 0, start: 0f, end: 1f, time: 0.267f); + + mgr.AdvanceAll(10f); // massive overshoot past duration + + Assert.True(mgr.TryGetCurrentValue(1, 0, out float value)); + Assert.Equal(1f, value); // bitwise-exact, not approximately-equal + } + + [Fact] + public void AdvanceAll_PastCompletion_IsIdempotent() + { + var mgr = new TranslucencyFadeManager(); + mgr.StartPartFade(entityId: 1, partIndex: 0, start: 0f, end: 1f, time: 0.1f); + + mgr.AdvanceAll(1f); + Assert.True(mgr.TryGetCurrentValue(1, 0, out float first)); + + mgr.AdvanceAll(1f); // ramp already finished — a second advance must not change anything + Assert.True(mgr.TryGetCurrentValue(1, 0, out float second)); + + Assert.Equal(first, second); + Assert.Equal(1f, second); + } + + [Fact] + public void ClearEntity_RemovesActiveAndCommittedState() + { + var mgr = new TranslucencyFadeManager(); + mgr.StartPartFade(entityId: 1, partIndex: 0, start: 0f, end: 1f, time: 1f); + Assert.True(mgr.TryGetCurrentValue(1, 0, out _)); + + mgr.ClearEntity(1); + + Assert.False(mgr.TryGetCurrentValue(1, 0, out _)); + mgr.AdvanceAll(1f); // must not throw even though the entity is gone + Assert.False(mgr.TryGetCurrentValue(1, 0, out _)); + } + + [Fact] + public void StartPartFade_SecondCallReplacesFirst() + { + var mgr = new TranslucencyFadeManager(); + mgr.StartPartFade(entityId: 1, partIndex: 0, start: 0f, end: 1f, time: 10f); + mgr.AdvanceAll(1f); // 10% into the first (abandoned) ramp + + // Restart with a fresh, shorter ramp — the old target must be abandoned. + mgr.StartPartFade(entityId: 1, partIndex: 0, start: 0.9f, end: 0f, time: 1f); + Assert.True(mgr.TryGetCurrentValue(1, 0, out float atRestart)); + Assert.Equal(0.9f, atRestart); + + mgr.AdvanceAll(1f); // finishes the SECOND ramp, not the first + Assert.True(mgr.TryGetCurrentValue(1, 0, out float value)); + Assert.Equal(0f, value); + } + + [Fact] + public void TryGetCurrentValue_UnknownPart_ReturnsFalse() + { + var mgr = new TranslucencyFadeManager(); + Assert.False(mgr.TryGetCurrentValue(entityId: 999, partIndex: 0, out float value)); + Assert.Equal(0f, value); + } + + [Fact] + public void MultiplePartsOnSameEntity_AdvanceIndependently() + { + var mgr = new TranslucencyFadeManager(); + mgr.StartPartFade(entityId: 1, partIndex: 0, start: 0f, end: 1f, time: 1f); + mgr.StartPartFade(entityId: 1, partIndex: 1, start: 0f, end: 1f, time: 2f); + + mgr.AdvanceAll(1f); + + Assert.True(mgr.TryGetCurrentValue(1, 0, out float part0)); + Assert.True(mgr.TryGetCurrentValue(1, 1, out float part1)); + Assert.Equal(1f, part0); // part 0's 1s ramp is done + Assert.Equal(0.5f, part1, 5); // part 1's 2s ramp is halfway + } +} diff --git a/tests/AcDream.Core.Tests/Rendering/TranslucencyHookSinkTests.cs b/tests/AcDream.Core.Tests/Rendering/TranslucencyHookSinkTests.cs new file mode 100644 index 00000000..8917d3f4 --- /dev/null +++ b/tests/AcDream.Core.Tests/Rendering/TranslucencyHookSinkTests.cs @@ -0,0 +1,70 @@ +using System.Numerics; +using AcDream.Core.Rendering; +using DatReaderWriter.Types; +using Xunit; + +namespace AcDream.Core.Tests.Rendering; + +public sealed class TranslucencyHookSinkTests +{ + [Fact] + public void TransparentPartHook_ForwardsFieldsVerbatimToManager() + { + var mgr = new TranslucencyFadeManager(); + var sink = new TranslucencyHookSink(mgr); + + var hook = new TransparentPartHook { PartIndex = 3, Start = 0.1f, End = 0.9f, Time = 0.5f }; + sink.OnHook(entityId: 42, entityWorldPosition: Vector3.Zero, hook: hook); + + Assert.True(mgr.TryGetCurrentValue(42, 3, out float value)); + Assert.Equal(0.1f, value); // t=0 value, readable immediately after the hook fires + } + + [Fact] + public void TransparentPartHook_InstantTime_CommitsEndImmediately() + { + var mgr = new TranslucencyFadeManager(); + var sink = new TranslucencyHookSink(mgr); + + var hook = new TransparentPartHook { PartIndex = 0, Start = 0f, End = 1f, Time = 0f }; + sink.OnHook(entityId: 1, entityWorldPosition: Vector3.Zero, hook: hook); + + Assert.True(mgr.TryGetCurrentValue(1, 0, out float value)); + Assert.Equal(1f, value); + } + + [Fact] + public void EtherealHook_IsIgnored() + { + var mgr = new TranslucencyFadeManager(); + var sink = new TranslucencyHookSink(mgr); + + sink.OnHook(entityId: 1, entityWorldPosition: Vector3.Zero, hook: new EtherealHook { Ethereal = true }); + + Assert.False(mgr.TryGetCurrentValue(1, 0, out _)); + } + + [Fact] + public void WholeObjectTransparentHook_IsIgnored() + { + var mgr = new TranslucencyFadeManager(); + var sink = new TranslucencyHookSink(mgr); + + // #188 scope: the whole-object variant is deliberately NOT ported this pass. + sink.OnHook(entityId: 1, entityWorldPosition: Vector3.Zero, + hook: new TransparentHook { Start = 0f, End = 1f, Time = 1f }); + + Assert.False(mgr.TryGetCurrentValue(1, 0, out _)); + } + + [Fact] + public void UnrelatedHook_IsIgnored() + { + var mgr = new TranslucencyFadeManager(); + var sink = new TranslucencyHookSink(mgr); + + sink.OnHook(entityId: 1, entityWorldPosition: Vector3.Zero, hook: new SoundTableHook()); + + Assert.False(mgr.TryGetCurrentValue(1, 0, out _)); + } +} diff --git a/tests/AcDream.Core.Tests/Streaming/GpuWorldStateTests.cs b/tests/AcDream.Core.Tests/Streaming/GpuWorldStateTests.cs index 0d0db085..dfe186e1 100644 --- a/tests/AcDream.Core.Tests/Streaming/GpuWorldStateTests.cs +++ b/tests/AcDream.Core.Tests/Streaming/GpuWorldStateTests.cs @@ -92,6 +92,47 @@ public class GpuWorldStateTests Assert.Equal(1, state.PendingLiveEntityCount); // 0xAAAAFFFF entry still parked } + [Fact] + public void RelocateEntity_StrandedInPending_MovesToLoadedTarget() + { + // Regression: the cold-spawn / run-out "invisible player" bug + // (2026-07-03). A persistent (server-spawned) entity that spawned into a + // not-yet-loaded landblock is parked in the pending bucket. The per-frame + // RelocateEntity is supposed to keep it homed to its current landblock so + // it draws — but the old implementation scanned ONLY _loaded, so it + // silently no-op'd on a pending entity and the player stayed hidden + // forever. Confirmed live: "[ent] APPEND guid=0x5000000A -> PENDING(hidden)" + // with no later DRAWSET PRESENT, even after the landblock loaded (its + // sibling NPCs re-hydrated into it fine — the player was excluded). + var state = new GpuWorldState(); + + var player = new WorldEntity + { + Id = 1, + ServerGuid = 0x5000000Au, // server-spawned + persistent + SourceGfxObjOrSetupId = 0x01000001u, + Position = System.Numerics.Vector3.Zero, + Rotation = System.Numerics.Quaternion.Identity, + MeshRefs = Array.Empty(), + }; + state.MarkPersistent(0x5000000Au); + + // Spawned before its landblock streamed in → parked in pending, hidden. + state.AppendLiveEntity(0xADAF0011u, player); + Assert.Empty(state.Entities); + Assert.Equal(1, state.PendingLiveEntityCount); + + // The player's current landblock IS loaded now (the live log shows the + // sibling NPCs re-hydrated into it). RelocateEntity — called every frame + // to keep the player homed to its current landblock — must promote the + // stranded pending entity into the loaded bucket so it draws. + state.AddLandblock(MakeStubLandblock(0xBBBBFFFFu)); + state.RelocateEntity(player, 0xBBBB0011u); + + Assert.Single(state.Entities); // now drawn + Assert.Equal(0, state.PendingLiveEntityCount); // no longer stranded + } + [Fact] public void RemoveLandblock_DropsPendingForThatLandblock() { diff --git a/tests/AcDream.Core.Tests/World/InteriorEntityIdAllocatorTests.cs b/tests/AcDream.Core.Tests/World/InteriorEntityIdAllocatorTests.cs new file mode 100644 index 00000000..bdbb32cc --- /dev/null +++ b/tests/AcDream.Core.Tests/World/InteriorEntityIdAllocatorTests.cs @@ -0,0 +1,90 @@ +using AcDream.Core.World; +using Xunit; + +namespace AcDream.Core.Tests.World; + +/// +/// #190 (2026-07-09) — the interior entity id space (0x40XXYY##, +/// GameWindow.cs's interiorIdBase + localCounter) reserved only 8 bits +/// (256 values) for a landblock's WHOLE interior static population. The Town +/// Network hub (205 cells) reached 248 before the #79/#93 A7.L1 light fix, +/// then 277 after it — PAST the 8-bit boundary, silently aliasing into the +/// next landblock's reserved Y-byte (0x40000815 decoded as landblock Y=0x08, +/// not the true Y=0x07). Same collision CLASS as #119 (two landblocks +/// sharing one id space), triggered by entity COUNT instead of a computation +/// bug. Widened the counter to 12 bits (4095) by shrinking the fixed class +/// prefix from a full byte (0x40) to its top nibble (0x4_) — verified safe +/// against every classification check that reads entity.Id +/// (GameWindow.cs's _isOutdoorMesh threshold, _isLandblockStab +/// prefix, scenery bit) since none of them decode X/Y back out. +/// +public class InteriorEntityIdAllocatorTests +{ + [Fact] + public void Base_AlwaysAtOrAboveStabThreshold() + { + // GameWindow.cs: `entity.Id < 0x40000000u` classifies "stab" — + // every interior-static base must sit AT or ABOVE this floor for + // every landblock coordinate, including the corners. + for (uint y = 0; y <= 255; y += 51) + for (uint x = 0; x <= 255; x += 51) + Assert.True(InteriorEntityIdAllocator.Base(x, y) >= 0x40000000u); + } + + [Fact] + public void Base_NeverMatchesLandblockStabPrefix() + { + // GameWindow.cs: `(entity.Id & 0xFF000000u) == 0xC0000000u` identifies + // LandBlockInfo stabs — an interior-static base must never collide. + for (uint y = 0; y <= 255; y += 51) + for (uint x = 0; x <= 255; x += 51) + Assert.NotEqual(0xC0000000u, InteriorEntityIdAllocator.Base(x, y) & 0xFF000000u); + } + + [Fact] + public void Base_NeverSetsSceneryBit() + { + // GameWindow.cs: `(entity.Id & 0x80000000u) != 0` identifies procedural + // scenery — an interior-static base must never set bit 31. + for (uint y = 0; y <= 255; y += 51) + for (uint x = 0; x <= 255; x += 51) + Assert.Equal(0u, InteriorEntityIdAllocator.Base(x, y) & 0x80000000u); + } + + [Fact] + public void MaxCounter_StaysWithinTheSameLandblocksReservedRange() + { + // The literal #190 repro, generalized: adding the full counter budget + // to a landblock's base must never spill into a DIFFERENT landblock's + // base. Checked against every adjacent-Y and adjacent-X neighbor. + for (uint y = 0; y < 255; y++) + { + uint thisBase = InteriorEntityIdAllocator.Base(0, y); + uint nextYBase = InteriorEntityIdAllocator.Base(0, y + 1); + Assert.True(thisBase + InteriorEntityIdAllocator.MaxCounter < nextYBase, + $"y={y}: counter budget overflows into landblock y={y + 1}'s id range"); + } + } + + [Fact] + public void TownNetworkRepro_277EntitiesStaysInTheSameLandblock() + { + // The exact #190 repro values: landblock 0x0007xxxx (X=0, Y=7), 277 + // hydrated entities (the count AFTER the #79/#93 A7.L1 light fix). + // Under the OLD 8-bit-counter scheme this aliased into Y=8's range + // (0x40000815 read back as Y=0x08). Under the new scheme it must not. + uint id = InteriorEntityIdAllocator.Base(0, 7) + 277u; + uint decodedYByte = (id & 0xFF000000u); // old scheme's Y read (byte-aligned) + Assert.NotEqual(0xC0000000u, decodedYByte); // sanity: still not a landblock-stab + Assert.True(id < InteriorEntityIdAllocator.Base(0, 8), + "277 entities must stay inside landblock Y=7's reserved id range"); + } + + [Fact] + public void MaxCounter_Is4095() + { + // Locks the documented capacity (12-bit counter) so a future edit + // that accidentally narrows it again gets caught here first. + Assert.Equal(0xFFFu, InteriorEntityIdAllocator.MaxCounter); + } +} diff --git a/tests/AcDream.Core.Tests/World/StreamingReadinessGateTests.cs b/tests/AcDream.Core.Tests/World/StreamingReadinessGateTests.cs new file mode 100644 index 00000000..e3792da0 --- /dev/null +++ b/tests/AcDream.Core.Tests/World/StreamingReadinessGateTests.cs @@ -0,0 +1,72 @@ +using AcDream.Core.World; +using Xunit; + +namespace AcDream.Core.Tests.World; + +/// +/// #192 (2026-07-09) — login into a non-Holtburg position sometimes showed +/// stabs/scenery floating in the wrong place. Root cause: the streaming/render +/// gate opened as soon as WorldSession reached InWorld +/// (GameWindow.cs's old !IsLiveModeWaitingForLogin || liveInWorld +/// condition) — but InWorld fires immediately after the login handshake +/// (WorldSession.cs:608), BEFORE the player's own spawn CreateObject +/// (which carries their real position) has even arrived over the network. Any +/// landblock streamed in that window baked its world offset from +/// _liveCenterX/Y's STARTUP placeholder (Holtburg, 0xA9B4) — a real +/// position, not a "we don't know yet" sentinel — and that stale-baked geometry +/// still got applied once it finished building, landing wherever the guess put +/// it relative to whatever streamed in afterward with the corrected center. +/// +/// The fix isn't "pick a different placeholder" (any placeholder racing against +/// the real answer reproduces the same bug) — it's gating on whether the real +/// position is actually known yet, independent of session state. +/// +public class StreamingReadinessGateTests +{ + [Fact] + public void ShouldStream_OfflineMode_AlwaysTrue() + { + // Not live mode at all — no race is possible, no real position to wait for. + Assert.True(StreamingReadinessGate.ShouldStream( + liveModeEnabled: false, chaseModeEverEntered: false, liveInWorld: false, liveCenterKnown: false)); + } + + [Fact] + public void ShouldStream_ChaseModeEverEntered_AlwaysTrueRegardlessOfCenterKnown() + { + // Once chase mode has engaged even once, the gate latches open for the + // rest of the session (matches the pre-existing IsLiveModeWaitingForLogin + // latch semantics) — this is well past the login race window. + Assert.True(StreamingReadinessGate.ShouldStream( + liveModeEnabled: true, chaseModeEverEntered: true, liveInWorld: true, liveCenterKnown: false)); + } + + [Fact] + public void ShouldStream_LiveModeNotYetInWorld_False() + { + Assert.False(StreamingReadinessGate.ShouldStream( + liveModeEnabled: true, chaseModeEverEntered: false, liveInWorld: false, liveCenterKnown: false)); + } + + [Fact] + public void ShouldStream_LiveModeInWorldButCenterUnknown_False() + { + // THE REGRESSION TEST. Under the old code, liveInWorld alone opened the + // gate here — this is exactly the window where InWorld has fired but the + // player's own spawn CreateObject (and hence the real center) hasn't + // arrived yet. Must stay closed. + Assert.False(StreamingReadinessGate.ShouldStream( + liveModeEnabled: true, chaseModeEverEntered: false, liveInWorld: true, liveCenterKnown: false)); + } + + [Fact] + public void ShouldStream_LiveModeInWorldAndCenterKnown_True() + { + // Once the real position is confirmed, stream even though chase mode + // hasn't engaged yet — this preserves the #106 gate-3 fix (auto-entry + // waits for terrain under the spawn; terrain streaming must not wait for + // auto-entry in turn, or the two deadlock each other). + Assert.True(StreamingReadinessGate.ShouldStream( + liveModeEnabled: true, chaseModeEverEntered: false, liveInWorld: true, liveCenterKnown: true)); + } +} diff --git a/tools/analyze_resolve_capture.py b/tools/analyze_resolve_capture.py new file mode 100644 index 00000000..c369b290 --- /dev/null +++ b/tools/analyze_resolve_capture.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python3 +"""Classify ACDREAM_CAPTURE_RESOLVE JSONL into OK / partial / stuck / airborne-stuck. + +The A/B measurement instrument for the #182 verbatim player-physics rebuild +(docs/superpowers/plans/2026-07-07-player-physics-update-verbatim-rebuild.md). + +Each JSONL record (PhysicsResolveCapture.ResolveCaptureRecord) has: + input.{currentPos,targetPos,cellId,...}, bodyBefore/bodyAfter (PhysicsBodySnapshot + incl. velocity, slidingNormal, transientState), result.{position,cellId,isOnGround, + collisionNormalValid,collisionNormal}. Vector3 = {x,y,z}. + +Buckets (move-intent records only, i.e. targetPos != currentPos): + OK reached target: dist(result.position, targetPos) <= EPS_REACH + partial advanced short: moved > EPS_MOVE and not OK (retail SLID) + stuck reverted: moved <= EPS_MOVE (retail COLLIDED-revert) + airborne-stuck subset of stuck: bodyBefore airborne w/ jump velocity into a + near-horizontal collision normal (the falling-animation wedge) + +Retail target (tools/cdb/retail-crowd-jump3.cdb): + ~78% OK, 12.7% COLLIDED (~stuck), 8.8% SLID (~partial), 0 airborne-stuck. + +Usage: py tools/analyze_resolve_capture.py [capture.jsonl] +""" +import sys +import json +import math + +EPS_REACH = 0.02 # 2 cm — "reached target" +EPS_MOVE = 0.01 # 1 cm — "advanced at all" + + +def dist(a, b): + return math.sqrt((a["x"] - b["x"]) ** 2 + (a["y"] - b["y"]) ** 2 + (a["z"] - b["z"]) ** 2) + + +def classify(rec): + i = rec["input"] + if dist(i["targetPos"], i["currentPos"]) <= EPS_MOVE: + return None # zero-motion rest tick — not a move-intent record + r = rec["result"] + moved = dist(r["position"], i["currentPos"]) + reached = dist(r["position"], i["targetPos"]) <= EPS_REACH + if reached: + return "ok" + if moved > EPS_MOVE: + return "partial" + # reverted / stuck. airborne-stuck = a stuck frame while AIRBORNE (OnWalkable bit clear): + # the "stuck in the falling animation" wedge. The near-horizontal creature normal is the + # cause and the jump velocity the symptom, but the sliding normal flips frame-to-frame so + # neither is reliable every frame — the airborne (not-grounded) revert is the stable marker. + bb = rec.get("bodyBefore") or {} + on_walkable = bb.get("transientState", 0) & 0x2 # TransientStateFlags.OnWalkable + if not on_walkable: + return "airborne-stuck" + return "stuck" + + +def main(path): + counts = {"ok": 0, "partial": 0, "stuck": 0, "airborne-stuck": 0} + total_move = 0 + total_records = 0 + with open(path, "r", encoding="utf-8") as f: + for line in f: + line = line.strip() + if not line: + continue + try: + rec = json.loads(line) + except json.JSONDecodeError: + continue + total_records += 1 + c = classify(rec) + if c is None: + continue + total_move += 1 + if c == "airborne-stuck": + counts["airborne-stuck"] += 1 + counts["stuck"] += 1 # airborne-stuck is a subset of stuck for the % columns + else: + counts[c] += 1 + + print(f"total records: {total_records}") + if total_move == 0: + print("no move-intent records") + return + print(f"move-intent resolves: {total_move}") + for k in ("ok", "partial", "stuck"): + print(f" {k:16s} {counts[k]:6d} {100.0 * counts[k] / total_move:5.1f}%") + print(f" {'airborne-stuck':16s} {counts['airborne-stuck']:6d} (frames; subset of stuck)") + print("retail target: ok ~78% partial ~9% stuck ~13% airborne-stuck 0") + + +if __name__ == "__main__": + main(sys.argv[1] if len(sys.argv) > 1 else "acdream-crowd-resolve.jsonl") diff --git a/tools/cdb/issue176-floor-light.cdb b/tools/cdb/issue176-floor-light.cdb new file mode 100644 index 00000000..d07b9d1d --- /dev/null +++ b/tools/cdb/issue176-floor-light.cdb @@ -0,0 +1,26 @@ +$$ +$$ #176 floor triangles - retail light-setup trace (2026-07-06) +$$ Q: does retail set up the DYNAMIC magenta portal light (intensity=100, +$$ color 0.784,0,0.784) as a HARDWARE light applied to the corridor CELL? +$$ If yes -> retail's cell floor IS lit by the portal via D3D hardware T&L, +$$ so the per-vertex wedge pattern is retail-FAITHFUL, not an acdream bug. +$$ +$$ config_hardware_light(d3dIndex@[esp+4], _D3DLIGHT9* out@[esp+8], +$$ ulong cellID@[esp+0xc], LIGHTINFO* info@[esp+0x10]) +$$ d3dIdx 1-10 = DYNAMIC (viewer / teleport PORTAL); 11+ = STATIC (wall torch, baked) +$$ Dumping the cellID lets us see WHICH cell the magenta portal is configured for. +$$ + +.logopen C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\retail-floor-light.log +.sympath C:\Users\erikn\source\repos\acdream\refs +.symopt+ 0x40 +.reload /f acclient.exe + +r $t0 = 0 +r $t1 = 0 + +$$ config_hardware_light - every hardware light setup, with its cell id + LIGHTINFO. +bp acclient!PrimD3DRender::config_hardware_light "r $t0=@$t0+1; r $t1=@$t1+1; .printf /D \"[CHL] hit#%d d3dIdx=%d cell=%08x\\n\", @$t1, dwo(@esp+4), dwo(@esp+0xc); dt acclient!LIGHTINFO dwo(@esp+0x10) type intensity falloff color; .if (@$t0 >= 500) { qd } .else { gc }" + +.printf \"issue176-floor-light armed: config_hardware_light with cell id + LIGHTINFO. Stand in the corridor looking at the purple floor+walls. qd (auto-detach) after 500 hits.\\n\" +g diff --git a/tools/cdb/issue186-connector-decider.cdb b/tools/cdb/issue186-connector-decider.cdb new file mode 100644 index 00000000..4cb50a07 --- /dev/null +++ b/tools/cdb/issue186-connector-decider.cdb @@ -0,0 +1,37 @@ +* #186 connector GREY flap - PICK-vs-FLOOD decider (2026-07-08) +* Attach to a LIVE retail acclient.exe HELD in the connecting-room grey pose. +* Binary MUST pair with refs/acclient.pdb (check_exe_pdb.py -> MATCH). +* +* Two breakpoints, both sampled at a low rate to avoid lagging retail -> ACE timeout: +* bp1 SmartBox::update_viewer (0x453ce0) -> viewer.objcell_id = the render ROOT (viewer_cell) +* player m_position = confirms we are at the pose (expect 0116) +* bp2 PView::DrawCells (0x5a4840) -> cell_draw_num + cell_draw_list ids = the DRAWN cell set +* + eye viewpoint +* +* DECISION (handoff 2026-07-08-186 section 3): +* retail viewerCell == 0116 -> PICK fix (acdream over-switches root to connector 0118) +* retail viewerCell == 0118 AND draw list has 0116 -> FLOOD fix (retail keeps the back-portal room drawn) +* +* update_viewer sets viewer_cell at EXIT, so at bp ENTRY viewer.objcell_id is the PRIOR frame value. +* For a HELD (stationary) pose prior==current, so this is exact - HOLD the grey pose. +* +* Auto-detach via .detach after a hit threshold (qd does NOT fire inside a conditional bp action - it +* strands cdb and kills retail). NEVER put a semicolon inside a comment line (it splits into a command). + +.logopen C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\issue186-connector-decider.log +.sympath C:\Users\erikn\source\repos\acdream\refs +.symopt+ 0x40 +.reload /f acclient.exe + +.echo ===SYMBOLS=== +x acclient!SmartBox::update_viewer +x acclient!PView::DrawCells + +r $t0 = 0 +r $t1 = 0 + +bp acclient!SmartBox::update_viewer "r $t0 = @$t0 + 1; .if (@$t0 % 15 == 1) { .printf \"[root] hit=%d viewerCell=%04x playerCell=%04x\\n\", @$t0, @@c++(((acclient!SmartBox*)@ecx)->viewer.objcell_id) & 0xffff, @@c++(((acclient!SmartBox*)@ecx)->player->m_position.objcell_id) & 0xffff }; gc" + +bp acclient!PView::DrawCells "r $t1 = @$t1 + 1; .if (@$t1 % 15 == 1) { r $t2 = @@c++(((acclient!PView*)@ecx)->cell_draw_num); .printf \"[draw] hit=%d num=%d:\", @$t1, @$t2; .for (r $t3 = 0; @$t3 < @$t2; r $t3 = @$t3 + 1) { .printf \" %04x\", @@c++(((acclient!PView*)@ecx)->cell_draw_list.data[@$t3]->m_DID.id) & 0xffff }; .printf \" || eye \"; dx acclient!Render::FrameCurrent->viewer.viewpoint }; .if (@$t1 >= 3000) { .detach } .else { gc }" + +g diff --git a/tools/cdb/l2g-observer.cdb b/tools/cdb/l2g-observer.cdb new file mode 100644 index 00000000..c14ebb00 --- /dev/null +++ b/tools/cdb/l2g-observer.cdb @@ -0,0 +1,42 @@ +* L.2g S2-blocker trace — what does a RETAIL OBSERVER do with ACE's +* flags=0 "empty" UpdateMotion while the actor toggles walk/run? +* +* Attach target: the retail OBSERVER client (standing still, watching). +* Driver: the user Shift-toggles + starts/stops the ACTOR from the other +* retail client. +* +* Expected chain per decomp (to confirm or refute): +* CPhysics::SetObjectMovement (gates, stamps) [SOM] + obj id +* MovementManager::unpack_movement (10-way dispatch) [UNPACK] +* CMotionInterp::move_to_interpreted_state (flat copy) [MTIS] + IMS dump +* CMotionInterp::apply_interpreted_movement [AIM] +* CMotionInterp::apply_raw_movement (local-player alt) [ARM] +* CMotionInterp::DoInterpretedMotion per axis [DIM] + motion id +* +* The [MTIS] InterpretedMotionState dump on an empty UM is THE answer: +* if forward_command=0x41000003 (Ready) is flat-applied and [DIM] shows +* Ready, retail really does stop the remote — and the observer's clean +* rendering must come from somewhere else. If the dump or the DIM stream +* shows something else (e.g. WalkForward), we found the mechanism. +* +* Auto-detach: after 600 SetObjectMovement hits via .detach (NOT qd — +* qd is silently ignored in bp actions, see project_retail_debugger.md). + +.logopen C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\l2g-observer-trace.log +.sympath C:\Users\erikn\source\repos\acdream\refs +.symopt+ 0x40 +.reload /f acclient.exe + +x acclient!CPhysics::SetObjectMovement +x acclient!MovementManager::unpack_movement +x acclient!CMotionInterp::move_to_interpreted_state +x acclient!CMotionInterp::DoInterpretedMotion + +r $t0 = 0 +bp acclient!CPhysics::SetObjectMovement "r $t0 = @$t0 + 1; .printf \"\\n[SOM %d] obj=%p movSeq=%x scSeq=%x auto=%x id: \", @$t0, poi(@esp+4), poi(@esp+10)&0xffff, poi(@esp+14)&0xffff, poi(@esp+18); dt acclient!CPhysicsObj poi(@esp+4) id; .if (@$t0 >= 250) { .detach } .else { gc }" +bp acclient!MovementManager::unpack_movement ".printf \"[UNPACK] mm=%p\\n\", @ecx; gc" +bp acclient!CMotionInterp::move_to_interpreted_state ".printf \"[MTIS] minterp=%p ims:\\n\", @ecx; dt acclient!InterpretedMotionState poi(@esp+4); gc" +bp acclient!CMotionInterp::apply_interpreted_movement ".printf \"[AIM] minterp=%p\\n\", @ecx; gc" +bp acclient!CMotionInterp::apply_raw_movement ".printf \"[ARM] minterp=%p\\n\", @ecx; gc" +bp acclient!CMotionInterp::DoInterpretedMotion ".printf \"[DIM] minterp=%p motion=%08x\\n\", @ecx, poi(@esp+4); gc" +g diff --git a/tools/cdb/pview-spiral2.cdb b/tools/cdb/pview-spiral2.cdb new file mode 100644 index 00000000..5e67d65b --- /dev/null +++ b/tools/cdb/pview-spiral2.cdb @@ -0,0 +1,10 @@ +.logopen C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\retail-spiral2.log +.sympath C:\Users\erikn\source\repos\acdream\refs +.symopt+ 0x40 +.reload /f acclient.exe +r $t0 = 0 +bp acclient!PView::DrawCells "r $t0=@$t0+1; .if (@$t0 < 6000) { .if (@$t0 % 20 == 0) { r $t1 = @@c++(((acclient!PView*)@ecx)->cell_draw_num); .printf \"[DC] h=%d num=%d:\", @$t0, @$t1; .for (r $t3=0; @$t3 < @$t1; r $t3=@$t3+1) { .printf \" %04x\", @@c++(((acclient!PView*)@ecx)->cell_draw_list.data[@$t3]->m_DID.id) & 0xffff }; .printf \" || eye \"; dx acclient!Render::FrameCurrent->viewer.viewpoint }; gc }" +g +.echo ===DETACHING=== +qd +.logclose diff --git a/tools/cdb/pview-verify.cdb b/tools/cdb/pview-verify.cdb new file mode 100644 index 00000000..e6e0d408 --- /dev/null +++ b/tools/cdb/pview-verify.cdb @@ -0,0 +1,14 @@ +.logopen C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\retail-pview-verify.log +.sympath C:\Users\erikn\source\repos\acdream\refs +.symopt+ 0x40 +.reload /f acclient.exe +.echo ===XVIEW=== +x acclient!PView::DrawCells +x acclient!PView::ConstructView +.echo ===DTPVIEW=== +dt acclient!PView cell_draw_num cell_draw_list +.echo ===DTENVCELL=== +dt acclient!CEnvCell m_DID +r $t0 = 0 +bp acclient!PView::DrawCells "r $t0=@$t0+1; .echo ===HIT===; dx ((acclient!PView *)@ecx)->cell_draw_num; dx ((acclient!PView *)@ecx)->cell_draw_list.data[0]->m_DID.id; qd" +g diff --git a/tools/cdb/retail-crowd-jump.cdb b/tools/cdb/retail-crowd-jump.cdb new file mode 100644 index 00000000..991cd362 --- /dev/null +++ b/tools/cdb/retail-crowd-jump.cdb @@ -0,0 +1,38 @@ +.logopen C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\retail-crowd-jump.log +.sympath C:\Users\erikn\source\repos\acdream\refs +.symopt+ 0x40 +.reload /f acclient.exe + +r $t0 = 0 +r $t1 = 0 +r $t2 = 0 +r $t3 = 0 + +.echo === ARMED: land_on_sphere + validate_transition + FindObjCollisions; auto-detach after 25000 SetPositionInternal === + +* CSphere::land_on_sphere (0x005379a0) — an AIRBORNE mover's foot sphere hit another +* sphere (a creature body or a sphere-object). If this fires when you jump onto the +* monster pack, the LOCAL client is attempting a creature landing (branch 4 airborne). +* Rare -> always gc, never strands. +bp acclient!CSphere::land_on_sphere "r $t0 = @$t0 + 1; .printf \"[LAND-ON-SPHERE] #%d\\n\", @$t0; gc" + +* CTransition::validate_transition (0x0050aa70) — the commit/revert. arg2 (at esp+4, +* thiscall) is the transitional_insert RESULT fed in: 1=OK 2=COLLIDED 3=ADJUSTED 4=SLID. +* Rate-limited so the log stays readable. A burst of arg2=2 (COLLIDED) during the +* jump-land = the local transition hit the creature and reverted (server must place you). +bp acclient!CTransition::validate_transition "r $t1 = @$t1 + 1; .if (@$t1 % 60 == 0) { .printf \"[VALIDATE] #%d arg2=%d\\n\", @$t1, poi(@esp+4) }; gc" + +* CPhysicsObj::FindObjCollisions (0x0050f050) — count only. Confirms the local player's +* transition is testing object collisions at all during the repro. +bp acclient!CPhysicsObj::FindObjCollisions "r $t3 = @$t3 + 1; gc" + +* CPhysicsObj::SetPositionInternal — the position commit AND the detach anchor. Fires for +* every object's position set (player + creatures), so it always reaches the threshold in +* a live crowd. On the 25000th hit it prints the summary and does NOT gc -> cdb breaks -> +* g returns -> the top-level qd detaches cleanly. (qd is NEVER inside a bp action.) +bp acclient!CPhysicsObj::SetPositionInternal "r $t2 = @$t2 + 1; .if (@$t2 < 25000) { gc } .else { .printf \"[SUMMARY] land_on_sphere=%d validate=%d findObjColl=%d setPos=%d\\n\", @$t0, @$t1, @$t3, @$t2 }" + +g +.echo === DETACHING === +qd +.logclose diff --git a/tools/cdb/retail-crowd-jump2.cdb b/tools/cdb/retail-crowd-jump2.cdb new file mode 100644 index 00000000..d050d5f3 --- /dev/null +++ b/tools/cdb/retail-crowd-jump2.cdb @@ -0,0 +1,28 @@ +.logopen C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\retail-crowd-jump2.log +.sympath C:\Users\erikn\source\repos\acdream\refs +.symopt+ 0x40 +.reload /f acclient.exe + +r $t0 = 0 +r $t1 = 0 +r $t2 = 0 + +.echo === ARMED v2: land_on_sphere + validate(COLLIDED count); AUTO-DETACH after 6000 validate === + +* CSphere::land_on_sphere (0x005379a0) — an airborne mover's foot sphere hit another +* sphere. RARE -> cheap, no meaningful lag. $t1 (validate count) timestamps each hit so we +* can read the PATTERN: a brief burst per jump = the local client lands on the creature; +* a long steady burst = it's stuck locally (arming every frame) and the SERVER lifts you. +bp acclient!CSphere::land_on_sphere "r $t0 = @$t0 + 1; .printf \"[LAND] #%d vt=%d\\n\", @$t0, @$t1; gc" + +* CTransition::validate_transition (0x0050aa70, UNAMBIGUOUS) — the commit/revert, AND the +* detach anchor. arg2 (poi esp+4) = the transitional_insert result: 1=OK 2=COLLIDED 4=SLID. +* We count COLLIDED and log every 5th so a jump that reverts locally shows a COLLIDED spike. +* On the 6000th hit (~15-20 s) it prints the summary and does NOT gc -> cdb breaks -> g +* returns -> the top-level qd detaches cleanly. qd is NEVER inside a bp action. +bp acclient!CTransition::validate_transition "r $t1 = @$t1 + 1; .if (@$t1 < 6000) { r $t3 = poi(@esp+4); .if (@$t3 == 2) { r $t2 = @$t2 + 1; .if (@$t2 % 5 == 0) { .printf \"[COLLIDED] #%d vt=%d\\n\", @$t2, @$t1 } }; gc } .else { .printf \"[DETACH] validate=%d land_on_sphere=%d collided=%d\\n\", @$t1, @$t0, @$t2 }" + +g +.echo === DETACHING === +qd +.logclose diff --git a/tools/cdb/retail-crowd-jump3.cdb b/tools/cdb/retail-crowd-jump3.cdb new file mode 100644 index 00000000..57281627 --- /dev/null +++ b/tools/cdb/retail-crowd-jump3.cdb @@ -0,0 +1,34 @@ +.logopen C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\retail-crowd-jump3.log +.sympath C:\Users\erikn\source\repos\acdream\refs +.symopt+ 0x40 +.reload /f acclient.exe + +r $t9 = 0 +r $t0 = 0 +r $t1 = 0 +r $t2 = 0 +r $t4 = 0 +r $t5 = 0 + +.echo === ARMED v3 (PLAYER-ATTRIBUTED): capture player ptr from set_local_velocity; filter validate + land_on_sphere to it; auto-detach after 40000 validate === + +* Capture the LOCAL player's CPhysicsObj* from the first input-driven local-velocity set. +* Creatures are dead-reckoned (interpolated), not set via set_local_velocity, so the first +* hit after you start moving is the player. Printed so we can sanity-check it's one pointer. +bp acclient!CPhysicsObj::set_local_velocity "r $t8 = @ecx; .if (@$t9 == 0) { r $t9 = @$t8; .printf \"[PLAYER-PTR] %p\\n\", @$t9 }; gc" + +* land_on_sphere: mover = arg2->object = poi(poi(esp+4)) (OBJECTINFO.object at offset 0). +* Log ONLY when the mover is the player. If this stays 0 while you jump onto monsters, the +* local client is NOT computing your creature landing (server places you). +bp acclient!CSphere::land_on_sphere "r $t7 = poi(poi(@esp+4)); .if (@$t7 == @$t9) { r $t0 = @$t0 + 1; .printf \"[PLAYER-LAND] #%d vt=%d\\n\", @$t0, @$t1 }; gc" + +* validate_transition: mover = poi(ecx) (CTransition.object_info.object at offset 0). For the +* PLAYER only, tally the transition result arg2 (poi esp+4): 2=COLLIDED, 4=SLID, else OK/ADJ. +* pCOL/pSLID near 0 during the crowd jump = the player is NOT locally colliding with creatures. +* $t1 (ALL validates) is the unambiguous detach anchor -> break at 40000 -> qd. +bp acclient!CTransition::validate_transition "r $t1 = @$t1 + 1; .if (@$t1 >= 0n40000) { .printf \"[DETACH] pPtr=%p pValidate=%d pCOLLIDED=%d pSLID=%d pLand=%d\\n\", @$t9, @$t2, @$t4, @$t5, @$t0 } .else { .if (poi(@ecx) == @$t9) { r $t2 = @$t2 + 1; r $t3 = poi(@esp+4); .if (@$t3 == 2) { r $t4 = @$t4 + 1 } .else { .if (@$t3 == 4) { r $t5 = @$t5 + 1 } } }; gc }" + +g +.echo === DETACHING === +qd +.logclose diff --git a/tools/cdb/run-issue186-decider.ps1 b/tools/cdb/run-issue186-decider.ps1 new file mode 100644 index 00000000..6b77bd5e --- /dev/null +++ b/tools/cdb/run-issue186-decider.ps1 @@ -0,0 +1,7 @@ +# Attach cdb to a live retail acclient.exe and run the #186 connector decider script. +# Prereq: retail is already in-world (user walked to the connecting room, holding the grey pose). +# Verify pairing first: py tools/pdb-extract/check_exe_pdb.py "C:/Turbine/Asheron's Call/acclient.exe" +$cdb = "C:\Program Files (x86)\Windows Kits\10\Debuggers\x86\cdb.exe" +$script = "C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\tools\cdb\issue186-connector-decider.cdb" +$tee = "C:\Users\erikn\source\repos\acdream\.claude\worktrees\vigorous-joliot-f0c3ad\issue186-connector-decider.console.log" +& $cdb -pn acclient.exe -cf $script *>&1 | Tee-Object -FilePath $tee