diff --git a/README.md b/README.md index 6a2e237..272f8c1 100644 --- a/README.md +++ b/README.md @@ -9,8 +9,10 @@ services are used. [checkpoint review](docs/checkpoint/review.md), [coverage map](docs/checkpoint/coverage.md) and [implementation plan](docs/checkpoint/implementation-plan.md) compare source owners, update order and lifecycles with the port. Clean69d0187 and its packages -are preserved locally as the playable baseline. Task/objective and Carl callback -ordering are the first verified corrections from this investigation. +are preserved locally as the playable baseline. Corrections now include task/Carl +callbacks, controlled player phase ordering, source static camera queries for the +first route and gadget availability through tutorial/return. Full scene scheduling, +collision and shared camera state remain incomplete. **Current milestone: original lab story, interactions and jet pack practice flow.** The runtime includes recovered camera/speech triggers, moving props, Carl/Goddard diff --git a/docs/checkpoint/README.md b/docs/checkpoint/README.md index 05180ab..02af81f 100644 --- a/docs/checkpoint/README.md +++ b/docs/checkpoint/README.md @@ -14,6 +14,10 @@ primary ownership. Follow-ups cover [lab registry](lab-registry.md), [scene loader](scene-loader.md). All investigators have returned file ownership. Primary owns integration/runtime corrections. [Exit review](review.md) records checkpoint completion, verified changes and the next evidence gates. +Implementation continuation: [level-game lifetime](level-game-lifetime.md), +[retained character resets](retained-character-reset.md), and +[player phase implementation](player-phase-implementation.md). These supersede +the old-game-removal question and record the first C3/C5/C7 implementation chunks. Evidence labels used throughout: diff --git a/docs/checkpoint/camera-ray-predicate.md b/docs/checkpoint/camera-ray-predicate.md index d480acc..6740630 100644 --- a/docs/checkpoint/camera-ray-predicate.md +++ b/docs/checkpoint/camera-ray-predicate.md @@ -15,6 +15,17 @@ nearest-hit support query or swept camera sphere would produce a different algorithm. Full follow-camera integration still requires camera state continuity, source angle/previous-eye handling and the remaining input-mode branches. +**Implementation continuation:** `OriginalCameraRay` now implements these source +grids and shares the individual segment kernel with `OriginalBodySupport` while +preserving support's nearest-hit reducer. Program uses this query for LV1B/VR04/ +LEV1. Player follow consumes one query per input callback, source hit adjustment +and1.5 gain; the post-interpolation sphere sweep is removed for these scenes. +Other scene filters and synthetic fixtures keep the explicit provisional adapter. +Eleven managed groups verify route registration counts and synthetic order/kernel/ +filter cases; a separate movement consumer check asserts origin, gain and absence +of a second query. Shared viewport/DEFAULT handoff and full follow state remain +open, so this is static-obstruction recovery rather than whole-camera fidelity. + ## Actual caller arguments and unused actor getter Jimmy complete vtable4A3BDC, slot16C at4A3D48 (fileA3D48), resolves43B820. diff --git a/docs/checkpoint/coverage.md b/docs/checkpoint/coverage.md index 2ab1618..6b4f909 100644 --- a/docs/checkpoint/coverage.md +++ b/docs/checkpoint/coverage.md @@ -2,15 +2,17 @@ Checkpoint scope: lab → tutorial VR04 → lab → outside, including intro, explanation, pickup/practice, RETURN, Carl conversation and exit. This compares -source contracts with playable baseline69d0187, not all gameplay in all levels. +source contracts with the current port and preserved playable baseline69d0187, +not all gameplay in all levels. Rows marked “now” include the implementation +continuation; the original baseline remains a separate comparison point. Address details/PE offsets and source-byte extractors are in the linked reports. **S**=static/data recovery, **P**=isolated original component probe, **M**=managed port regression, **R**=port runtime. No row has full original-game runtime comparison. Coverage does not mean implementation completeness. -| ID / system | Recovered contract / anchors | Baseline implementation | Evidence / remaining gap | Next bounded action | +| ID / system | Recovered contract / anchors | Port implementation | Evidence / remaining gap | Next bounded action | |---|---|---|---|---| -| LOOP | Viewport47E4F0: physics479BC0 before registry473740, including game input44DF80; second sync473770; list50999C construction order. Separate millisecond engine logic/morph clock100F9B10. | Fixed60Hz grouped controller→physics→NPC→director→UI→morph. | S/M/R. Source pass/input bridge recovered; actual cadence and retained/spawned-object order still open. | C3: construction/reuse registry trace before changing scheduler. | +| LOOP | Viewport47E4F0 physics before registry473740, including input44DF80; second sync473770; construction order and selective retained-character/new-game ordering. Separate engine morph clock. | Player now integrates prior body state, then fresh input/player/fire or retained player/fire/input. Other systems remain grouped; fixed60Hz policy. | S/M/R. Controlled player partial order implemented; full registry/cadence and uncontrolled-body preparation open. | C3 continue other callbacks and morph/control phases; C4 support/response remains separate. | | INPUT | Game interface+8C slot3C4→44DF80→475A70 reads controlled5099E4 and calls3CC; Jimmy interface+C0→426030. | SDL arrows/jump aliases; control gate, modern debug override; mouse/controller incomplete. | S/M/R, user Windows route. Input occurs in object traversal after physics; device sampling/focus and latency open. | Trace event pump, key/mouse and focus gates alongside retained registry order. | | MOVE |437940/439900 ground/air arithmetic; physics479D20 consumes queued impulse once before acceleration/gravity. | Recovered arithmetic placed in same-tick controller→physics; fixed dt, custom yaw/model conventions. | S/P/M/R. Local arithmetic evidence does not validate enclosing phase. | Split pending velocity/impulse only after C3 oracle. | | JET |437F90 controller;421FB0 effect; fresh constructor order places fire after Jimmy, both after global physics. States0..5, hold>.4,8s, energy. | Explicit state table with post-collision effect ticking and VR immunity. | S/M/R. Fresh same-pass countdown recovered; retained child lifecycle, sound and expiry→animation open. | Trace retained Jimmy/fire resets and phase end events before scheduler integration. | @@ -18,10 +20,11 @@ runtime comparison. Coverage does not mean implementation completeness. | ANIM | Engine morph10002DB0; linear interpolation10002F9A; game logical→OMT sync4624B0. | ASE sample timing, unconditional loop closure, pose/action aliases,1/60 advance. | S/P/M/R. Playback flags, rate, completion callbacks, transition order open. | Recover one-shot/loop/end notifications before more aliases. | | SCRIPT | Source AI/CAM/MCA dispatch and chains; task45F990 objective406F50 BEFORE records BEFORE per-entity424. | Bounded synchronous director; baseline objective after records/actor batch. | S/M/R. Script callbacks recovered for route; generic class coverage and reentrancy incomplete. | C1: ordered objective notification; C2: per-actor Carl override. | | CONTROL | Global5099E4 null during valid CAM/MCA; PlayerControlled completion target; DEFAULT447D..447F restores camera/UI/music. | Director raw ownership plus explicit debug effective override; player physics stops when uncontrolled. | S/M/R. Null control is not proof all objects/physics stop; scheduler gap remains. | Map raw ownership transitions against phase gates and deferred LOAD. | -| CAMERA | Shared viewport; strict>1000 DEFAULT snap;43B820 ray correction;47C210 first wall-grid hit then first general-grid hit, FIFO cells; source per-level far planes. | Shot-time interpolation, separate chase eye stale during cutscenes, fixed follow gains and nearest sphere obstruction; merged max far plane. | S/M/R. Static grid predicate/filters now recovered; x87 boundaries, source angle/previous-eye and input branches open. | C5: static source adapter then shared camera handoff/follow; no nearest-hit substitution. | +| CAMERA | Shared viewport; strict>1000 DEFAULT snap; source eye correction/gain; first wall-grid hit then general-grid FIFO; per-level far planes. | Static source query now integrated for the three route scenes; other scenes use provisional sweep. Separate chase/script eyes and merged clip maximum remain. | S/M/R. Query/kernel/counts tested; x87 boundaries, shared handoff/previous-eye and input branches open. | C5 next shared viewport/DEFAULT and complete follow state. | | AUDIO | CAM416776..E1 stops music; DEFAULT447F12..45 restarts; bank696008 / gate4F8434; handle47D890 polls inherited software duration and repeat+30. | Separate SDL streams, floating-file-duration cutscene completion, independent per-file SFX. | S/M/R (dummy streams). Source duration/allocation/play-failure/bank/attenuation lifecycle incomplete; speakers/native Windows timing not verified. | C6: explicit bank owner and software channel-clock tests; SDL queue-empty is not the source oracle. | | UI |406F50 selector/timer;4043D9 controlled clock;407070/O edge;404D97 practice resume.44 objective flags distinct from selector. | Timed objective subset, modal practice, modern UiViewport/debug. | S/M/R. Other flags/gadgets/highlights/cursor/energy/layout transitions open; source widescreen not recovered. | Keep modern scale policy separate; recover UI dispatcher/mode gates before expanding. | -| LOAD | CEditor+74C/+74D deferred scene request; selective teardown/reuse;Jimmy/Goddard retention; per-object28→40C. RETURN root+9A8/flags954/9A5, restore423A90, STRT suppress4427F2. | RuntimeCheckpoint carried root/return bool, reconstructed actors/audio, app-owned presentation. | S/M/R. Core loader chain recovered; per-field resets, retained helper/current-game lifetime and fades open.50988A is editor R input, not load reset. | C7: retained-field/route lifecycle trace, then state-container integration; keep modern presentation. | +| LOAD | CEditor deferred scene request; selective teardown/reuse; Init stored+11→live+139 resolves old-game deletion; Jimmy/Goddard retained. RETURN root/flags and per-object28→40C. | Snapshot/reconstructed scene state with retained input-order identity; app-owned presentation. | S/M/R. Old-game removal closed. Per-field/helper resets and fades remain;50988A is editor R input. | C7: retained-field/route lifecycle fixtures, then state-container integration. | +| INVENTORY | PostLoad423DEF..423EC1 enables eight owned gadgets4→1, then VR01..08 disables1→4; other values/items preserved. | Availability pass now applied at level entry and verified across TSK tutorial/return; snapshots preserve raw values. | S/M/R. Full selected-gadget/UI and retained scalar state remain incomplete. | Keep availability separate from ownership, task changes and arbitrary state carry. | | SAVE | TSK45FEE0 writer /4603F0 reader; records, arrays, return strings, stored departure root; queued460E70→460EA0. | Original-format round-trip and CLI save, scene snapshots; no full source save UI/load lifecycle. | S/M. Source reader duplicates matching task callback then all-entity420 post-task hook; this is distinct from Jimmy placement PostLoad423A90. Current fresh-director path differs. | C7 after C1/C2; test repeated callbacks before adopting loader behavior. | | CHECKPOINT | Pickup42AF00 stores+1E38 root/+1E48 level separately from+9A8 RETURN root. | Capture exposed, not used for return; source capture consumers unknown. | S/M. Do not interpret as death/respawn until read consumer found. | Track unresolved consumer; no speculative gameplay. | @@ -42,18 +45,20 @@ runtime comparison. Coverage does not mean implementation completeness. ## Assumptions and symptom-level adapters to replace -1. Fixed60Hz and controller-before-physics currently make tests deterministic; - they are not recovered original scheduling. Preserve arithmetic tests but do - not treat existing travel measurements as the source oracle. +1. Fixed60Hz remains a deterministic port policy. Baseline controller-before- + physics has now been replaced for the controlled player; other grouped scene + callbacks and morph timing remain incomplete. Preserve arithmetic tests but + do not treat existing travel measurements as the source oracle. 2. Floor snap/visual sole correction and24-unit swept capsule solve visible penetration/navigation symptoms. They do not recover Jimmy's body/root geometry or47BD80 response. Keep rendering pivot and physics support investigations separate. 3. Carl activation is applied after a generic actor batch in the baseline; source virtual callbacks execute per actor in registry order. C2 replaces this adapter without inventing full NPC sensing. -4. Chase interpolation/sphere clipping and DEFAULT's simple camera reset mask - camera ownership gaps. Per-level far limits are recovered; merged-layer maximum - is a rendering policy pending masks/fog, not complete clipping recovery. +4. Route static sphere clipping is now replaced by source grids/kernel. Chase + state and DEFAULT's simple camera reset still mask ownership gaps. Per-level + far limits are recovered; merged-layer maximum is a rendering policy pending + masks/fog, not complete clipping recovery. 5. File duration is a cutscene completion estimate. The source also uses software duration, but integer elapsed boundaries, repeat, invalid/stopped channels, clock pause and effects-bank ownership remain lifecycle inputs. SDL queue-empty diff --git a/docs/checkpoint/implementation-plan.md b/docs/checkpoint/implementation-plan.md index e5eb94a..84c5539 100644 --- a/docs/checkpoint/implementation-plan.md +++ b/docs/checkpoint/implementation-plan.md @@ -53,3 +53,26 @@ allowed where it resolves a core-system question, without waiting for every leve - Exit review: core architecture checkpoint documented in `review.md`; feature expansion remains paused. C1/C2 full integration passes; final follow-up Python discovery and original hashes recorded under artifacts/re-checkpoint/. +- C3/C7 gate closed: normal Init copies stored+11 to live+139, restoring the + level game's deletion predicate. Destructor explicitly unlinks its registry + node. `level-game-lifetime.md` and three byte regressions retain that proof. +- C3 first implementation: controlled player physics consumes prior motion/queued + impulse before input/player/fire callbacks. Fresh versus retained input order + follows proven registration; stored mode and same-frame landing reset are + explicit. Twenty movement groups, input-only routes and GPU RETURN pass targeted + checks. Full-scene scheduling, uncontrolled-body and collision response remain open. +- C5 static adapter implemented/integrated for LV1B/VR04/LEV1: source cell/FIFO/ + wall-first predicate and single-triangle kernel, source eye adjustment/gain, + one query per input callback. Eleven camera groups and existing support groups + pass; full camera handoff/input state remains open. +- C7 availability correction: level entry enables state4→1 for the recovered eight + gadgets, then VR01..08 disables owned1→4. Unknown states/other groups preserved; + tutorial bypass unchanged. Source anchors and boundary/round-trip tests cover it. + Arbitrary retained scalar/mode/fire state is still gated by the streamer/lifecycle + fixture; no blanket carry was introduced. +- Full integration passes: artifacts/implementation/integration-final.log. + Seventy Python checks, all managed groups including20 movement/11 camera/ + 13 support, GPU story/route/practice/RETURN/jetpack/animation with zero validation + errors, SDL dummy lifecycle and539 unchanged hashes. RETURN also verifies + retained input order and tutorial availability normalization. Packages rebuilt + after the implementation milestone; platform runtime claims remain separate. diff --git a/docs/checkpoint/level-game-lifetime.md b/docs/checkpoint/level-game-lifetime.md new file mode 100644 index 0000000..198e5ec --- /dev/null +++ b/docs/checkpoint/level-game-lifetime.md @@ -0,0 +1,99 @@ +# C3/C7: old level-game deletion is restored by ordinary initialization + +Static source recovery,2026-10-25. Original Neutron.exe SHA256 +`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`. +Preferred VAs below are EXE addresses. Their physical offsets are VA−400000; +the read-only helper independently uses PE section mapping and emits both. +No original was modified or executed. No modern runtime code was edited here. + +## Resolved distinction: stored defaults versus live state + +The prior loader report correctly found the lab class-default initializer's +virtual204(0) at44D472, but that writes **live interface+139 only**. The +constructor-reachable class-default stage is not the final lifetime state. +The normal initialization pass subsequently restores live state from a separate +stored field, **interface+11**. This resolves the apparent preserved-old-game +contradiction without inferring destruction from overwriting509948. + +| Stage | Original instruction / function | Effect | +|---|---|---| +| Generic constructor |46FDB3 pushes1;46FDB7 →470F40 | Setter writes stored+11 and dispatches204 to set live+139 | +| Class defaults |44D456 pushes0;44D472 invokes204 | Live+139 becomes0, stored+11 remains1 | +| Normal per-object initialization |46E5C3 invokes slot28 | Lab/tutorial/outside game slot28 is44D4E0 | +| Game base initialization |44D4E0 jumps4587F0;4587F3 calls470540 | Enters the common initialization bridge | +| Restore effective lifecycle state |4705B3 invokes8C getter470F30, pushes result4705B9,4705BC invokes204 setter4719C0 | Reads stored+11 and writes live+139 | +| PostLoad |46E61A invokes40C after28 for each object | Game has already restored its ordinary live teardown predicate1 | +| Ordinary departure |46E032/46E06F/46E0AC call200 getter4719B0 | Getter reads live+139; game qualifies for all three teardown passes | + +This common initializer also copies other stored/editor configuration fields to +live fields. Do not generalize every corresponding field as persisted gameplay +state: the +11→+139 bridge is specifically proven here. + +Route game interface tables: + +- Lab4C386C, tutorial VR04 4CE4AC, outside4C561C all resolve28→44D4E0, + 8C→470F30 and204→4719C0. +- 470F30 reads byte[interface+11].4719C0 writes byte[interface+139] from its + argument.4719B0 reads that live field for the teardown predicate. +- The usual game interface is complete+8C for level-game objects, unlike Jimmy's + complete+C0. Pointer bases must remain explicit. + +## Actual deletion and registry removal + +For initialized old level games with live+139=1, ordinary transition46DFF0: + +1. Calls slot20 in the first filtered traversal at46E054. +2. Calls slot34 in the second filtered traversal at46E091. +3. Sets interface+6=1 in the third traversal at46E0CA. +4. Calls473710 at46E0D9. That sweep finds marked objects, invokes interface + slot0 with argument1 at473733..737, then restarts the global list scan. + +Lab slot0 at4C386C points44F610: subtract5C converts game interface+8C to the +destructor's complete+30 subobject, then jumps44F3F0. That scalar deleting +wrapper calls44F420; its base call44F499→44D390 jumps44D3C2→4746E0. +The game destructor calls4587E0 at47476A with its game interface, and4587E0 +jumps470060, the common interface destructor. + +The common destructor explicitly scans registry50999C at4700E5, matches the +dying interface against node+8 at4700F2, and erases matching nodes using +469490 at470106 with list object509998. This is the actual old-game registry +removal edge. It precedes allocation/registration of the destination game in +46E170. Existing current-game pointer509948 can temporarily refer to the old +object during teardown; destination construction overwrites it later, but that +overwrite is not the operation responsible for deletion. + +There is no need to model accumulating old level-game input callbacks for the +normal route: the initialized live flag selects ordinary deletion. Abnormal +paths that bypass normal Init or mutate the stored/live flags require separate +evidence and are outside this successful-load case. + +## Why Jimmy and Goddard differ + +Jimmy4226B5..BF and Goddard41C99B..9E invoke470F40 with0. Unlike the game's +class-default virtual204(0), this updates **both** stored+11 and live+139. +Common Init therefore restores0 for these retained characters, and their +positive reusable+9 fields allow GAM/object lookup reuse without re-appending +their nodes. Those constructor values, their reuse flag and any later field +resets are separate concepts. + +Fresh lab order game→Jimmy→fire remains proven by lab-registry.md. On a +successful later ordinary load the old game is deleted, retained nodes keep +their order, and the new game is appended afterward. Thus relative input versus +Jimmy order can differ from fresh construction. Complete retained helper-node +and per-field reset coverage is still needed before claiming all callback +ordering or all transition state is recovered. + +## Verification and implementation consequence + +`checkpoint_level_game_lifetime.py ../Original` checks the binary identity, +decisive stored/live flag, initialization, teardown and destructor/unlink bytes, +plus route vtable targets. Its tests guard the actual source contract rather +than a speculative lifecycle simulation. This is static evidence, not observed +original gameplay. + +The normal old-level-game removal gate is now closed. C3 can preserve retained +object insertion order while deleting/replacing the level-game callback owner, +instead of freezing fresh game-before-Jimmy order for every transition. Keep +the port's application-owned window/Vulkan session as the authorized modern +presentation policy. Remaining source gates are per-field character/helper +reset rules, exact timer/event-pump behavior and original runtime comparison. diff --git a/docs/checkpoint/player-phase-implementation.md b/docs/checkpoint/player-phase-implementation.md new file mode 100644 index 0000000..bb2189c --- /dev/null +++ b/docs/checkpoint/player-phase-implementation.md @@ -0,0 +1,79 @@ +# C3 implementation: player phase boundaries + +The first implementation chunk separates the controlled player's prior-body +physics, game input, player controller, owned fire effect and camera-input update. +It does not replace the entire scene scheduler, collision response or animation +clock. Evidence is in `input-frame-bridge.md`, `lab-registry.md`, the new +`player_phase_evidence.py`, and the follow-up `level-game-lifetime.md`. + +## Source contract and implementation + +EXE47E554 calls479BC0 physics before473740 game-object callbacks47E582;473770 +sync follows47E587. A fresh game registers before Jimmy, and Jimmy before his +owned fire. Retained Jimmy/fire precede the newly appended destination game. +The level-game deletion predicate is restored by normal initialization; a +constructor-default zero is not the final gameplay lifetime flag. The focused +lifetime report records the complete vtable/field provenance. + +`LabSimulation.Step` now integrates **existing** velocity, acceleration and queued +impulse first. Fresh input then produces speed/destination yaw, the player update +produces velocity/impulse for the next physics pass, and fire ticks afterward. +On scene continuation, the player/fire update precedes the destination input +callback. `InputAfterPlayerUpdate` records this specific retained registry relation; +it does not claim all source objects are retained by the current port. + +Input uses the stored movement mode, as438B1E..438B2A does, rather than deriving +it from current physical support. Held jump selects air mode at437A96. Grounded +released-jump reset437B9E..437BAC clears jump state, mode and turn in the **player** +callback. Landing can therefore clear turn on the same frame physics finds support. +Jump queues impulse after physics and requests its pose; it does not retroactively +move the body or falsely clear its physical supported state that frame. + +Source addresses above have EXE raw offsets VA−400000. The helper verifies the +hashed supplied EXE, maps PE offsets and checks9 decisive instruction sequences. +No original code was executed for these source assertions. + +## Verification and remaining limits + +Movement regressions assert old velocity before current input, one-time delayed +impulse consumption, fresh versus retained ordering, independent movement mode, +landing reset and unchanged fixed-step presentation independence. Input-only lab +navigation still reaches SCENE35→50→60 and the outside LOAD. This is port evidence, +not original timing/latency fidelity. Source nominal frame rate remains unproven; +the port keeps its explicit60Hz policy. + +The existing capsule/gravity adapter remains. Source479DF7..479E54 can cancel +gravity on a support hit before a queued jump, giving a different first takeoff +velocity. Applying that cancellation to the provisional capsule's prior support +flag caused false support transitions in the port; it must be integrated with +the recovered pre-integration support/response in C4, not bolted onto that flag. +No source-fidelity claim is made for jump apex, stairs, wall response or visual +pivot. The underground replay checks clearance of the recovered radius60 body, +not raw209-unit standing-mesh bounds, which are a separate provisional render +scale/pivot policy. Closed-gate collision and both directional crossings remain +required. This clarifies the physical assertion rather than inferring a collider +from the render mesh. + +Other scene callbacks still run in subsystem groups. Uncontrolled player physics +and control-release body preparation need their own source trace before changing +cutscene behavior. Engine morph logic remains on the port animation clock. These +are explicit next scheduler boundaries, not claimed solved by this player chunk. + +Bounded follow-up anchors for that next boundary (static reads, not implemented +here): Jimmy game vtable4A373C+410→42AFC0 calls43A750 at42AFC3.43A758 clears +speed interface608;43A76C calls2C4 with three zero arguments. That target471F40 +writes interface1A4/1A8/1AC. Map this preparation to the body consumer before +changing uncontrolled physics or resumption. Slot438→42AE00 additionally calls +complete178→427FF0 and sets interface1D65/global4F8182. These callbacks belong +to CAM/MCA ownership transfer, rather than interpreting null control as a whole +world pause. Lateral input complete870 is written by walking input43915D/4391B1/ +439226; its cross-mode lifetime is another scalar coupling to verify when filling +out the phase state model. The present chunk does not claim all controller fields. + +Final verification: full scripts/test.sh passes, log +`artifacts/implementation/integration-final.log`;20 movement groups and the new +11 camera groups, existing support/interaction/route suites, all GPU replays with +zero enabled-validation errors, SDL dummy tests and539 original hashes unchanged. +The70 Python checks include the new mode/phase and lifecycle source anchors. +Baseline69d0187 and current240-step completed walks have essentially identical +travel/final position; within-frame producer/consumer timing is tested separately. diff --git a/docs/checkpoint/retained-character-reset.md b/docs/checkpoint/retained-character-reset.md new file mode 100644 index 0000000..af7ba59 --- /dev/null +++ b/docs/checkpoint/retained-character-reset.md @@ -0,0 +1,151 @@ +# Retained character resets: bounded C3/C7 contract + +Static investigation,2026-10-25. Originals remain read-only and were not executed. +Neutron.exe SHA256 is +`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`. +All code/vtable anchors below are preferred-base EXE VAs; PE-mapped raw file +offset is VA−400000 for these sites. The new helper prints both coordinates and +checks individual bytes, virtual targets and source route GAM properties. +This report distinguishes proven local resets from fields whose enclosing +retention/property/callback semantics remain unresolved. No runtime code changed. + +## Enclosing ordinary-load phases + +The common loader evidence remains `scene-loader.md`: selective teardown, GAM +factory/reuse/property stream, then registry per-object28 followed immediately +by40C. Jimmy/Goddard can survive and be reused; that alone does not imply every +field survives. Jimmy uses game-interface complete+C0; shadow uses complete+C8. +Keep constructor/default-class initialization separate from callbacks28/40C. + +The object property read at46E3FD uses IAT48D190, imported +`OMediaStreamOperators::operator>>(OMediaClassStreamer*)`. Route JIM1 property +records contain authored position/rotation/flags/StartPoint and no serialized +jump/movement-mode/burn timer field. This is a statement about decoded records, +not proof the read implementation cannot indirectly invoke another callback. +Full streamer virtual call provenance is still a separate gate. + +## Jimmy initialization: exact resets and a coordinate correction + +Jimmy interface vtable4A373C+28→437890. It first calls4587F0 at437896; +4587F0→470540 applies generic authored/live-property setters, then calls +interface68(1). Jimmy-specific43789B..4378C1 then: + +| Instruction / raw offset | Field and recovered effect | +|---|---| +|4378A1 /378A1|Clear interface608 = complete6C8 (movement speed in existing recovery)| +|4378A7 /378A7|Clear interface614 = complete6D4 (air turning accumulator)| +|4378AD /378AD|Clear interface618 = complete6D8; full semantic name unresolved here| +|4378B8 /378B8|Invoke interface328 =4723F0, the logical Euler-vector getter| +|4378BE..4378C1 /378BE..378C1|Copy that vector's Y into interface61C = complete6DC| + +**Correction:** interface328 is not velocity.4723F0 copies interface224/228/ +22C/230, the logical Euler vector (position is214/218/21C/220). Therefore the +earlier scene-loader wording “captures another velocity component” is stale. +The clear618/capture61C pair should remain unnamed or associated with yaw +tracking until its consumers are traced; do not carry it as vertical velocity. + +Generic470540 additionally clears interface274/278/27C and298 at4709CA..9DC, +then sets byte5=1 and bytesA/6=0. This report does not name that vector as impulse +without tracing the actual body consumer. It also re-applies authored defaults +through virtual getters/setters, so absence of a direct scalar write in437890 +alone is not proof of scalar preservation. + +## Jimmy PostLoad40C + +Vtable4A373C+40C→423610. Selected proven effects relevant to transition state: + +| Site | State transition / ownership | +|---|---| +|42363B|Clear interface1D91; semantic name not assigned| +|423642..423656|Load default SoundEffects.omt, set current bank696008; gate4F8434 initially clear| +|4236A3/4236AA|Set current interaction/body radius60 through interface110| +|4236B3/4236BA|Set support factor1.265f through interface100| +|4236C0|Clear interface938 (tutorial flag later set for VR01..08)| +|4236FF|Current game virtual168(0), a gameplay/modal state callback; do not equate every control state with world pause| +|42370A and423729|Complete11C(0) for Jimmy and existing companion; both resolve40D350 and disable morph animation pause flag complete654, not jump/movement mode| +|42375E/423778|Stop associated saved effect handles through458A00, mark handles974/988 as−1| +|42378B /2378B|Clear WORD interface728 = complete7E8, the jump state, to0| +|423792|Clear interface970 temporary object pointer before later allocation| +|42399D/4239E6|Apply matching STRT root and Euler rotation| +|423A90..423B1E|Consume pending RETURN flag, override Jimmy with saved departure root, apply identical companion root| +|423B3D|Grant control through current game virtual118| +|423B43..423C67|Write shared viewport: authored STRT camera occurs inside match loop, later unconditional actor-local(0,200,−300) overwrites viewport eye| +|423CD4..423CE2|When companion already exists, call its interface174(0,0,0); constructor is not repeated| + +The final viewport assignment explains why merely carrying the old chase-eye +cache would not reproduce source scene entry. Full orientation/follow cache +setup remains in the camera investigation. The unconditional final eye uses +local(0,200,−300), distinct from DEFAULT's local(0,500,−500) conditional snap. + +### Movement mode, fire and transition staging limits + +Player constructor43748A initializes complete7C4 movement mode0, but the inspected +JimmyInit28 and JimmyPostLoad40C do not establish an unconditional reset of this +field. PostLoad does explicitly reset jump state7E8 as above. Stage43B5A0 is +called with the complete player pointer; its complete148 call43B7FB resolves +429A00, which stops sound handle completeA44 and assigns−1. That callback does +not reset movement mode or fire time. Stage also clears complete7FC at43B5EE. + +Do not promote absence of writes in these bounded local functions to a complete +preservation proof: game/streamer/control callbacks and class-specific gadget +cleanup can change player state elsewhere. In particular RETURN457FF7 performs +gadget cleanup before flags/staging, distinct from ordinary stage. Carrying raw +movement mode, held input, physics vectors or arbitrary jump timers across scenes +is not yet justified by this report. The current port's blanket constructor +zeroing is likewise an implementation policy, not a recovered reset contract. + +## Retained fire/shadow/companion callbacks + +| Object | Constructor-only state | Ordinary per-object28 /40C | +|---|---|---| +|Jetpack fire complete+C0 interface4A3160|421E51 calls470F40(0), selecting retention;421E62 zeros complete6BC owner and421E68 zeros complete6C0 timer; player437525 later assigns owner interface to6BC|28=4587F0 generic Init;40C=40E7B0 generic visibility/animation policy. Neither local path assigns owner6BC or timer6C0. No repeated constructor assumed.| +|Shadow complete+C8 interface4B37B8|43F767 calls470F40(0); authored size/owner are separate from runtime position|28=4587F0;40C=43F810→4354C0, then copies authored size words to completeAC/B0, resets completeB4=2/B8=0 and optional visibility flag. More base4354C0 effects remain open.| +|Goddard complete+C0 interface49F480|Ctor sets retention/reuse and owns shadow; aliases/defaults are constructor state|28=41E6A0→407EB0→4587F0; then byteA=1, AIstate608=authored87C, current waypoint800=null.40C=41E590→409480, then level-specific visibility/collision/radius policy.| + +Fire421FB0 later queries its owner and, when grounded, clears timer interface600 +(complete6C0) at421FE9, then subtracts dt. That is an **effect tick**, not an +initialization reset. It can observe the controller's same-pass changes according +to the recovered registry ordering. Timer preservation through local28/40C does +not prove it survives the entire transition unchanged without an intervening +owner/gadget/frame callback; exact first destination tick remains a lifecycle test. + +Goddard's ordinary PostLoad sets radius130 and enables normal body behavior for +LV1B/VR04/LEV1; source-level hide branches cover other levels. Its existing-instance +callback174 is4716D0, not a constructor. Full rotation/AI resource resets in +409480 are not recovered here; retain the earlier patrol approximations explicitly. + +## Directly evidenced implementation candidate: gadget availability + +JimmyPostLoad **always first enables** group0 gadgets in source order +`7,3,0,5,1,6,2,4` via403870(false), calls423DEF..423E3F. For numeric +VR01..VR08 it then calls403870(true) for those same indices at423E71..423EC1. +At40389E, disabling changes only owned state1→4; at4038AA enabling changes only +4→1. All other values are preserved, including unowned0 and unknown wire values. +This is availability state, not ownership acquisition or inventory reset. + +For the route: lab entry converts disabled-owned4→1; practice VR04 converts +owned1→4; return lab converts4→1. The VR04 powered-jump path bypasses the normal +inventory state guard, so source state4 here does not imply the tutorial jetpack +should fail. Lab→outside similarly normalizes these group0 entries; tasks, score +and acquired-table state remain independent. The audited baseline lacked this +availability pass. Continuation now calls `SceneInventory.ApplyLevelAvailability` +once on level entry, before starting the authored sequence, and preserves raw +values in constructors/snapshots and arbitrary task assignments. Managed tests +cover every VR01..08 code, all relevant/unknown state boundaries, both untouched +inventory regions and TSK round-trip back to lab. GPU practice/RETURN smoke also +asserts state4 in VR04 and state1 on lab return. This correction does not invent +persistence for arbitrary physics/mode/fire fields. + +## Verification and remaining gates + +Run `python3 -m unittest discover -s tests -p test_checkpoint_character_reset.py -v` +and `python3 tools/binary/checkpoint_character_reset.py ../Original`. Tests verify +31 immutable instruction anchors,11 callback/vtable targets,16 exact gadget-call +arguments, source route player property names, and conditional1/4 conversion +boundaries. The state oracle tests interpretation, not execution of source code. + +Remaining gates: complete property-streamer callback chain; RETURN gadget cleanup +versus ordinary departure; movement-mode/fire/hold/extra-acceleration writer +provenance through all destination callbacks; physical body re-registration/reset; +full shadow base reset and Goddard409480 policy; source camera orientation/cache +reset. Do not carry these fields merely because object identity persists. diff --git a/docs/checkpoint/review.md b/docs/checkpoint/review.md index a4e9fdf..94a50ce 100644 --- a/docs/checkpoint/review.md +++ b/docs/checkpoint/review.md @@ -1,5 +1,11 @@ # Checkpoint exit and implementation continuation +Implementation has since continued: the old-game Init/deletion gate is resolved, +controlled player phases are split, the route static camera query is integrated, +and PostLoad gadget availability is applied. See `player-phase-implementation.md`, +`level-game-lifetime.md` and the current ledger. The exit review below preserves +the evidence/verification boundary at the original checkpoint milestone. + The initial architecture checkpoint is complete: all requested core systems have source anchors, state owners/lifetimes, route interactions, baseline comparison, explicit unknowns and bounded implementation actions. Feature expansion remains diff --git a/docs/checkpoint/scene-loader.md b/docs/checkpoint/scene-loader.md index fb51b9d..a06048d 100644 --- a/docs/checkpoint/scene-loader.md +++ b/docs/checkpoint/scene-loader.md @@ -79,7 +79,7 @@ retention and the current-level global509948 are distinct: GAM loading assigns Further class-specific lifecycle flags or later predicate changes require their own evidence; do not generalize the constructor default into a full object map. -**Critical integration consistency gate: old level-game ownership.** The lab game +**Resolved follow-up: old level-game ownership.** The lab game is initialized for preservation (interface4C386C slots200/204 resolve 4719B0/C0; defaults bridge above reaches44D456's push0/44D472's dispatch204). Later changes to that predicate remain part of the lifetime audit. GAM loading then @@ -95,12 +95,16 @@ The lab constructor chain44F300→44F358/44D2B0→44D306/4745A0 was also inspect destructor/removal was established in this inspected chain. **Overwriting the current-game pointer does not remove an old game from registry50999C.** -Consequently the remaining contract must include the old level-game registry -membership and callback eligibility: locate its explicit removal/deactivation -or account for its retained28/40C/update callbacks. Do not infer a clean sequence -containing only Jimmy/Goddard plus the new game from selective deletion alone. -Possible later class/OMT ownership effects remain open; this negative bounded -audit does not prove that old games accumulate or remain active at runtime. +The subsequent audit in `level-game-lifetime.md` closes this gap: normal Init28 +calls470540, whose4705B3 getter8C reads stored interface+11 through470F30; +4705BC setter204 copies it to live+139. Generic game construction stored+11=1; +the direct defaults204(0) never changed that stored value. Thus initialized level +games qualify for selective teardown. Their destructor reaches470060 and +explicitly removes their registry node at470106→469490. Jimmy/Goddard instead +use470F40(0), setting both stored/live fields, so initialization preserves their +retention. The earlier bounded prefix/constructor search was incomplete; pointer +overwrite is still not deletion, but Init and destructor now establish actual +old-game removal and retained-character/new-game ordering. ## GAM construction/reuse and initialization @@ -127,7 +131,7 @@ registry in order. It invokes object28, handles attached render-object state, then object40C, handles attached render state again, then advances registry. These are per-object boundaries, not “initialize all, then PostLoad all.” Jimmy's 28 is437890; it calls4587F0→470540 and resets movement fieldsinterface+608/+614/ -+618 and captures another velocity component+61C. Jimmy40C423610 applies: ++618 and captures logical Euler.Y (yaw) into+61C, not body velocity. Jimmy40C423610 applies: 1. Matching source STRT root42399D and rotation4239E6. 2. Existing companion source root423A36. @@ -176,8 +180,8 @@ force original editor R semantics into the game's current R reset control. ## Bounded continuation gate -1. Resolve old level-game removal/deactivation and callback eligibility across - destination construction. Then trace a retained Jimmy through one departure, +1. Old level-game removal is now resolved by the Init stored/live flag bridge and + destructor unlink. Trace a retained Jimmy through one departure, identifying every mutation from property load, initialization and PostLoad. Constructor evidence closes byte+9 ownership; it does not substitute for this per-field reset trace. diff --git a/docs/compatibility.md b/docs/compatibility.md index a3a7ef4..8234fe1 100644 --- a/docs/compatibility.md +++ b/docs/compatibility.md @@ -3,6 +3,16 @@ Compilation, native runtime, original behavior and full feature completion are separate evidence categories. **The game is not fully reconstructed/playable yet.** +Latest implementation continuation: controlled player phase ordering, route static +camera query and PostLoad gadget availability pass the full `scripts/test.sh`. +Evidence: artifacts/implementation/integration-final.log;70 Python regressions, +20 movement groups,11 new camera groups,13 existing support groups, remaining +managed groups, GPU story/practice/RETURN/Carl/objective/jetpack/animation checks, +SDL dummy lifecycle and539 unchanged original hashes. GPU validation is enabled +and every run reports zero errors. Native Windows runtime and original-game +comparison are not added by these tests. Known limits remain explicit in the +current checkpoint coverage/implementation reports. + Architecture checkpoint: see `checkpoint/review.md` for coverage and remaining gates. C1 objective/task order and C2 per-actor Carl callback corrections pass the full `scripts/test.sh` integration, all GPU runs with zero Vulkan validation diff --git a/docs/decisions.md b/docs/decisions.md index 9730fb6..e7a7c51 100644 --- a/docs/decisions.md +++ b/docs/decisions.md @@ -112,3 +112,19 @@ pre-assignment notification rather than relying on subscriber registration order. Preserve repeated/missing assignment dispatch. Source loader's additional task callbacks/PostLoad are a distinct lifecycle question, not implied by this fix. +25. **Consume prior player motion before callbacks.** Split controlled player + physics, input, controller and fire effect phases. Fresh input precedes Jimmy; + retained Jimmy/fire precede the appended destination game/input. Track this + relation explicitly across scene continuations. Mode-based input and the + player's grounded-release reset are separate boundaries. Keep fixed60Hz, + capsule/support and other grouped scene callbacks explicit approximations. +26. **Use the source static camera predicate on proven route scenes.** Build + sparse grids in source shape/polygon order, prefer the first wall-grid hit, + then the first all-grid hit. Use the individual source segment kernel without + nearest reduction; apply source desired-eye weighting and gain before follow + interpolation. Only LV1B/VR04/LEV1 filters are proven. Shared camera handoff, + special follow/input state and exact x87 boundaries remain separate work. +27. **Apply gadget availability at level entry.** Source PostLoad enables eight + group0 gadgets4→1, then disables owned1→4 in VR01..08. Preserve unknown states, + item8 and group1. This is availability, not acquisition or save normalization; + snapshots/constructors retain raw wire data. VR04's source jetpack bypass remains. diff --git a/docs/progress.md b/docs/progress.md index 2e76c28..50623f8 100644 --- a/docs/progress.md +++ b/docs/progress.md @@ -1,5 +1,38 @@ # Progress — 2026-10-25 +## Evidence-led implementation continuation + +Old level-game removal is resolved by `checkpoint/level-game-lifetime.md`: class +defaults briefly clear live+139, but normal Init restores it from stored+11=1; +the destructor explicitly removes the registry node. Jimmy/Goddard instead store +0 and remain retained/reusable. Three new immutable-source regressions guard it. + +Implemented controlled player prior-body physics → fresh input/player/fire, or +retained player/fire/input after scene continuation. Jump impulses wait for the +next body pass; input uses stored mode, and grounded release clears turn inside +the player callback. Current fixed60Hz, capsule/grounding, uncontrolled-body and +other grouped scene phases remain provisional. Twenty targeted movement groups +and lab/underground routes pass; GPU lab→VR04→lab verifies retained input order. + +Implemented `OriginalCameraRay` for LV1B/VR04/LEV1: source static grids, FIFO +wall-first hit, individual segment kernel, source eye weighting/gain and one query +per input callback. Eleven camera groups and existing13 support groups pass. +Camera shared-state handoff and full follow/input modes remain open. + +Implemented PostLoad gadget availability1↔4 for the recovered eight group0 items; +tutorial entry/normal return, unknown values, untouched regions and TSK round-trip +are tested. VR04 bypass remains. Arbitrary retained mode/fire state is not carried +without the remaining property/control callback proof. Details and exact limits: +`checkpoint/player-phase-implementation.md`, `retained-character-reset.md`. +Full `scripts/test.sh` passes (artifacts/implementation/integration-final.log): +70 Python checks, all managed groups including20 movement/11 camera/13 support, +GPU route/story/practice/RETURN/jetpack/animation with zero validation errors, +SDL dummy lifecycle and539 unchanged original hashes. RETURN smoke confirms +retained input ordering and enabled gadget state1 after tutorial state4. The +preserved baseline's240-step walk and new phase implementation have essentially +identical completed travel/final position, with the intended within-frame delay +verified separately. No native Windows/original runtime comparison is claimed. + ## Architecture reverse-engineering checkpoint User direction supersedes feature-expansion priorities below. Full `prompt.MD` diff --git a/docs/tasks.md b/docs/tasks.md index 6e57552..44c473b 100644 --- a/docs/tasks.md +++ b/docs/tasks.md @@ -58,9 +58,16 @@ plan in verified chunks. Earlier priorities below are a backlog. - [x] C2 per-actor Carl override; full integration and route checks pass. - [x] C3 input/frame/fresh construction, C5 grid predicate, C6 software voice clock and C7 ordinary selective-loader evidence follow-ups. -- [ ] Next: current-game registry removal/eligibility and retained Jimmy/helper - resets; then split scheduler phases against a source route lifecycle trace. - Static camera adapter can proceed independently with source first-hit rules. +- [x] Old level-game lifetime resolved: normal Init restores stored+11→live+139; + ordinary destructor explicitly unlinks its registry node. +- [x] Controlled player phase split and retained input order; delayed impulses, + stored movement mode and same-frame landing reset. Full-scene scheduler open. +- [x] Static first-hit camera adapter integrated for LV1B/VR04/LEV1 with shared + segment kernel and source hit weighting/gain. Full camera handoff/state open. +- [x] Source PostLoad gadget availability through tutorial/normal level entry. +- [ ] Next: retained mode/fire/body reset fixture through the full property/control + callback chain, remaining scene callback/morph phases, shared viewport/DEFAULT + handoff and C4 collision. C6 source channel allocation/clock/banks remains separate. 1. Lab regressions are corrected and republished, with user verification of their own Windows build. Keep comprehensive native Windows driver/audio/input diff --git a/scripts/test.sh b/scripts/test.sh index ebc27a1..330cfac 100755 --- a/scripts/test.sh +++ b/scripts/test.sh @@ -9,6 +9,7 @@ dotnet run --project tests/GamePort.MovementTests -- ../Original dotnet run --project tests/GamePort.DirectorTests -- ../Original dotnet run --project tests/GamePort.PatrolTests -- ../Original dotnet run --project tests/GamePort.SupportTests -- ../Original +dotnet run --project tests/GamePort.CameraRayTests dotnet run --project tests/GamePort.InteractionTests -- ../Original dotnet run --project tests/GamePort.CheckpointTests -- ../Original dotnet run --project tests/GamePort.DebugMenuTests -- ../Original diff --git a/src/GamePort/Game/JetpackBurst.cs b/src/GamePort/Game/JetpackBurst.cs index c37643f..7286c99 100644 --- a/src/GamePort/Game/JetpackBurst.cs +++ b/src/GamePort/Game/JetpackBurst.cs @@ -21,8 +21,8 @@ public readonly record struct JetpackEffectResult( /// /// The jump/jetpack branches of EXE437F90 and effect timer of EXE421FB0. -/// Controller and effect phases are separate: their full-scene order has not -/// been recovered. The caller must explicitly choose an order. Horizontal +/// Controller and effect phases are separate. The normal route registry places +/// Jimmy before his retained fire; other full-scene phases remain incomplete. Horizontal /// movement, shadow queries, visuals and sound callbacks belong to the caller. /// public static class JetpackBurst diff --git a/src/GamePort/Game/LabSimulation.cs b/src/GamePort/Game/LabSimulation.cs index db7126a..9fa2f31 100644 --- a/src/GamePort/Game/LabSimulation.cs +++ b/src/GamePort/Game/LabSimulation.cs @@ -15,9 +15,12 @@ public sealed class LabSimulation { public const float BodyRadius = 24; // Provisional, not a recovered collider dimension. private readonly SceneCollision collision; + private readonly Func? cameraRay; private readonly Vector3 sourceStart; private readonly float startYaw, modelMinimumY, rootHeight, startFloor; - private float targetYaw, extraAirAcceleration, shadowDistance; + private float targetYaw, extraAirAcceleration, shadowDistance, lateralContribution; + private Vector3 pendingImpulse; + private int movementMode; private JetpackBurstState jumpState; private bool forceFall; public Func? JetpackInventoryState { get; set; } @@ -31,11 +34,17 @@ public sealed class LabSimulation public float BodyHeight { get; } public Vector3 Position { get; private set; } // Feet, not original actor root. public Vector3 Velocity { get; private set; } + public Vector3 PendingImpulse => pendingImpulse; + public int MovementMode => movementMode; + // Fresh game registers before Jimmy. A retained Jimmy precedes the newly + // appended destination game, whose input callback therefore runs later. + public bool InputAfterPlayerUpdate { get; set; } public float Yaw { get; private set; } public float Speed { get; private set; } public float TurnRate { get; private set; } public bool Grounded { get; private set; } - public PlayerPose Pose => Grounded ? Speed < -1 ? PlayerPose.Backpedal : Speed > 1 ? PlayerPose.Run : PlayerPose.Idle + public PlayerPose Pose => pendingImpulse.Y > 0 ? PlayerPose.Jump + : Grounded ? Speed < -1 ? PlayerPose.Backpedal : Speed > 1 ? PlayerPose.Run : PlayerPose.Idle : jumpState.JumpState == 3 && jumpState.EffectRemaining > 0 ? PlayerPose.Fly : !forceFall && Velocity.Y > 0 ? PlayerPose.Jump : PlayerPose.Fall; public int Steps { get; private set; } @@ -51,9 +60,11 @@ public sealed class LabSimulation public Matrix4x4 Model => Matrix4x4.CreateRotationY(-Yaw * MathF.PI / 180) * Matrix4x4.CreateTranslation(Position - new Vector3(0, modelMinimumY, 0)); - public LabSimulation(SceneCollision collision, Mesh standingPose, Vector3 start, float yaw) + public LabSimulation(SceneCollision collision, Mesh standingPose, Vector3 start, float yaw, + Func? cameraRay = null) { this.collision = collision; + this.cameraRay = cameraRay; sourceStart = start; startYaw = yaw; var bounds = standingPose.Bounds(); @@ -76,13 +87,14 @@ public sealed class LabSimulation Velocity = Vector3.Zero; Yaw = targetYaw = startYaw; Speed = TurnRate = extraAirAcceleration = shadowDistance = 0; + lateralContribution = 0; pendingImpulse = Vector3.Zero; movementMode = 0; jumpState = default; forceFall = JetpackEffectVisible = false; InteractionRadius = 60; Bursts = 0; Grounded = true; Steps = Jumps = Landings = WallHits = 0; Travel = MaximumRise = 0; - CameraEye = DesiredEye(); + CameraEye = DesiredEye().Eye; } /// Jimmy PostLoad423A90..423ABF restores the saved RETURN root. @@ -92,7 +104,7 @@ public sealed class LabSimulation if (!float.IsFinite(root.X) || !float.IsFinite(root.Y) || !float.IsFinite(root.Z)) throw new ArgumentOutOfRangeException(nameof(root)); Position = root - Vector3.UnitY * rootHeight; - CameraEye = DesiredEye(); + CameraEye = DesiredEye().Eye; } // EXE 0x47F940 truncates, then degree lookup masks to the 16384-entry table. @@ -105,19 +117,29 @@ public sealed class LabSimulation } public void Step(PlayerInput input) + { + //47E554 global body integration precedes473740 registry callbacks. + // This reconstructs the player/input/fire partial order, not the full + // scene registry, original cadence or original collision response. + StepPhysics(); + if (!InputAfterPlayerUpdate) StepInput(input); + StepPlayer(input); + var effect = JetpackBurst.StepEffect(jumpState, Grounded, FixedStepClock.Step, Energy, LevelCode); + jumpState = effect.State; Energy = effect.Energy; JetpackEffectVisible = effect.Visible; + if (InputAfterPlayerUpdate) StepInput(input); + Steps++; + } + + private void StepInput(PlayerInput input) { const float dt = FixedStepClock.Step; - var wasGrounded = Grounded; - float lateral = 0; - if (Grounded) + lateralContribution = 0; + //438A60 dispatches by stored movement mode, not current support. + if (movementMode == 0) { - //437B9E..437BAC uses an interface pointer: interface+614 is - //complete+6D4. Normal grounded/released input clears air turn. - if (!input.Jump) TurnRate = 0; - InteractionRadius = 60; // Jimmy's ordinary grounded update42469B. float yawDelta = 0; - if (input.Left) { yawDelta += 20; lateral = -1000; Speed = RecoveredMotion.AddSpeed(Speed); } - else if (input.Right) { yawDelta -= 20; lateral = 1000; Speed = RecoveredMotion.AddSpeed(Speed); } + if (input.Left) { yawDelta += 20; lateralContribution = -1000; Speed = RecoveredMotion.AddSpeed(Speed); } + else if (input.Right) { yawDelta -= 20; lateralContribution = 1000; Speed = RecoveredMotion.AddSpeed(Speed); } if (input.Forward) { yawDelta *= 0.5f; Speed = RecoveredMotion.AddSpeed(Speed); } if (yawDelta != 0) targetYaw = Yaw + yawDelta; if (input.Backward) Speed = MathF.Max(Speed - 52.5f, -300); @@ -131,15 +153,29 @@ public sealed class LabSimulation //438011..43802B adds the independent turn rate directly to yaw. targetYaw = Yaw; } + StepCamera(); //438BC0/439900 input path owns follow; still provisional geometry/state. + } + + private void StepPlayer(PlayerInput input) + { + const float dt = FixedStepClock.Step; var yawError = MathF.IEEERemainder(targetYaw - Yaw, 360); Yaw = (Yaw + yawError * dt * 3.7f) % 360; - if (Velocity.LengthSquared() != 0 || Grounded && lateral != 0) + //437A96 selects air mode on held jump;437B9E..BAC resets jump/mode/turn + //only in the player's grounded/released update, after input when fresh. + if (input.Jump) movementMode = 1; + else if (Grounded) + { + movementMode = 0; TurnRate = 0; + } + if (Grounded) InteractionRadius = 60; + if (Velocity.LengthSquared() != 0 || movementMode == 0 && lateralContribution != 0) Yaw = (Yaw + TurnRate * dt) % 360; var (sin, cos) = Trig(Yaw); var velocity = new Vector3(-sin * Speed, Velocity.Y, cos * Speed); //437CDx ground uses /45 then dt;43803B air uses /55 without dt. const float friction = .8f; - var sideSpeed = Grounded ? (TurnRate * (1 - friction) * Speed / 45 + lateral) * dt + var sideSpeed = movementMode == 0 ? (TurnRate * (1 - friction) * Speed / 45 + lateralContribution) * dt : TurnRate * (1 - friction) * Speed * .0181818176060915f; velocity += new Vector3(cos, 0, sin) * sideSpeed; if (collision.GroundHeight(ActorRoot, 2500) is { } shadowFloor) @@ -147,14 +183,26 @@ public sealed class LabSimulation var air = JetpackBurst.Step(jumpState, new(Grounded, input.Jump, velocity.Y, shadowDistance, JetpackInventoryState?.Invoke() ?? 0, Energy, LevelCode, GadgetMode, dt, extraAirAcceleration)); jumpState = air.State; extraAirAcceleration = air.ExtraAccelerationY; - var impulse = new Vector3(0, air.ImpulseY, 0); - if (air.ImpulseY != 0) { Grounded = false; Jumps++; } + pendingImpulse += new Vector3(0, air.ImpulseY, 0); + if (air.ImpulseY != 0) Jumps++; + if (air.MovementModeOverride is { } mode) movementMode = mode; if (air.VelocityYOverride is { } vertical) velocity.Y = vertical; if (air.RadiusOverride is { } radius) InteractionRadius = radius; if (air.Pose == JetpackPose.Fall) forceFall = true; else if (air.Pose is JetpackPose.Jump or JetpackPose.Fly) forceFall = false; if (air.StartGadget) Bursts++; - var displacement = RecoveredMotion.Integrate(ref velocity, ref impulse, + Velocity = velocity; // Produced body state is consumed by the next physics pass. + } + + private void StepPhysics() + { + const float dt = FixedStepClock.Step; + var wasGrounded = Grounded; + var velocity = Velocity; + // Keep the existing capsule/gravity adapter until C4 recovers Jimmy's + // pre-integration support/response. Source479DF7..479E54 can cancel + // gravity before a supported impulse; this adapter does not model that. + var displacement = RecoveredMotion.Integrate(ref velocity, ref pendingImpulse, Vector3.UnitY * extraAirAcceleration, RecoveredMotion.Gravity, dt); var before = Position; var result = collision.Move(Position, displacement, BodyRadius, BodyHeight); @@ -175,24 +223,30 @@ public sealed class LabSimulation if (Grounded && velocity.Y < 0 || result.HitCeiling && velocity.Y > 0) velocity.Y = 0; if (Grounded) { extraAirAcceleration = 0; forceFall = false; } Velocity = velocity; - // Explicit port phase policy: controller, collision, then effect update. - // Original global object iteration order has not yet been matched. - var effect = JetpackBurst.StepEffect(jumpState, Grounded, dt, Energy, LevelCode); - jumpState = effect.State; Energy = effect.Energy; JetpackEffectVisible = effect.Visible; if (!wasGrounded && Grounded) Landings++; if (result.HitWall) WallHits++; Travel += Vector2.Distance(new(before.X, before.Z), new(Position.X, Position.Z)); MaximumRise = Math.Max(MaximumRise, Position.Y - startFloor); - Steps++; - var desired = DesiredEye(); - var delta = (desired - CameraEye) * new Vector3(1.6f, 1.2f, 1.6f) * dt; - CameraEye = collision.ClipCamera(CameraTarget, CameraEye + delta); } - private Vector3 DesiredEye() + private void StepCamera() + { + const float dt = FixedStepClock.Step; + var desired = DesiredEye(); + var delta = (desired.Eye - CameraEye) * new Vector3(1.6f, 1.2f, 1.6f) * desired.Gain * dt; + CameraEye = cameraRay == null ? collision.ClipCamera(CameraTarget, CameraEye + delta) : CameraEye + delta; + } + + private (Vector3 Eye, float Gain) DesiredEye() { var (sin, cos) = Trig(Yaw); - return collision.ClipCamera(CameraTarget, ActorRoot + new Vector3(sin * 350, 180, -cos * 350)); + var eye = ActorRoot + new Vector3(sin * 350, 180, -cos * 350); + if (cameraRay == null) return (collision.ClipCamera(CameraTarget, eye), 1); + //43B820: query from the computed look target; first accepted static hit + //moves desired eye25% toward look and returns follow gain1.5. No radius + //or second sweep after interpolation occurs in that source callback. + return cameraRay(CameraTarget, eye) is { } hit + ? (CameraTarget - (CameraTarget - hit.Position) * .75f, 1.5f) : (eye, 1); } public static PlayerInput SmokeInput(int step) => new(step < 120, false, false, diff --git a/src/GamePort/Game/OriginalBodySupport.cs b/src/GamePort/Game/OriginalBodySupport.cs index 3310965..9c16ad5 100644 --- a/src/GamePort/Game/OriginalBodySupport.cs +++ b/src/GamePort/Game/OriginalBodySupport.cs @@ -107,35 +107,53 @@ public static class OriginalBodySupport var nearestDistance = length; foreach (var triangle in triangles) { - RequireFinite(triangle.A); RequireFinite(triangle.B); RequireFinite(triangle.C); - var edge1 = triangle.B - triangle.A; - var edge2 = triangle.C - triangle.A; - var p = Cross(direction, edge2); - var determinant = Dot(edge1, p); - // Source indices use the opposite sign from a conventional right- - // handed visible-front-face test. Preserve the actual serialized order. - if (twoSided ? MathF.Abs(determinant) < TriangleEpsilon : determinant > -TriangleEpsilon) - continue; - var inverse = 1 / determinant; - var relative = start - triangle.A; - var u = Dot(relative, p) * inverse; - if (u < 0 || u > 1) continue; - var q = Cross(relative, edge1); - var v = Dot(q, direction) * inverse; - if (v < 0 || u + v > 1) continue; - var distance = Dot(q, edge2) * inverse; - // Source accepts the beginning, but rejects its endpoint and equal - // distance candidates. No invented extra ray distance or skin is used. - if (distance < 0 || distance >= length) continue; - var position = start + direction * distance; - var fromStart = QuickMagnitude(position - start); - if (fromStart >= nearestDistance) continue; - nearestDistance = fromStart; - nearest = new SupportHit(position, triangle.ShapeId, triangle.PolygonId, fromStart); + var hit = IntersectSegment(triangle, start, direction, length, twoSided); + if (hit is not { } candidate || candidate.Distance >= nearestDistance) continue; + nearestDistance = candidate.Distance; + nearest = candidate; } return nearest; } + /// + /// EXE469B70's individual source-winding triangle test, without47C6E0's + /// nearest-hit reduction. Camera47C210 instead accepts the first grid hit. + /// + public static SupportHit? IntersectSegment(SupportTriangle triangle, + Vector3 start, Vector3 end, bool twoSided = false) + { + RequireFinite(start); RequireFinite(end); + var direction = end - start; + var length = QuickMagnitude(direction); + if (length == 0) return null; + return IntersectSegment(triangle, start, direction / length, length, twoSided); + } + + private static SupportHit? IntersectSegment(SupportTriangle triangle, + Vector3 start, Vector3 direction, float length, bool twoSided) + { + RequireFinite(triangle.A); RequireFinite(triangle.B); RequireFinite(triangle.C); + var edge1 = triangle.B - triangle.A; + var edge2 = triangle.C - triangle.A; + var p = Cross(direction, edge2); + var determinant = Dot(edge1, p); + // Preserve serialized winding, opposite to the conventional visible front. + if (twoSided ? MathF.Abs(determinant) < TriangleEpsilon : determinant > -TriangleEpsilon) + return null; + var inverse = 1 / determinant; + var relative = start - triangle.A; + var u = Dot(relative, p) * inverse; + if (u < 0 || u > 1) return null; + var q = Cross(relative, edge1); + var v = Dot(q, direction) * inverse; + if (v < 0 || u + v > 1) return null; + var distance = Dot(q, edge2) * inverse; + // Beginning accepted, endpoint rejected; no invented camera radius/skin. + if (distance < 0 || distance >= length) return null; + var position = start + direction * distance; + return new SupportHit(position, triangle.ShapeId, triangle.PolygonId, QuickMagnitude(position - start)); + } + private static float Dot(Vector3 a, Vector3 b) => (float)((double)a.X * b.X + (double)a.Y * b.Y + (double)a.Z * b.Z); private static Vector3 Cross(Vector3 a, Vector3 b) => new( diff --git a/src/GamePort/Game/OriginalCameraRay.cs b/src/GamePort/Game/OriginalCameraRay.cs new file mode 100644 index 0000000..834193d --- /dev/null +++ b/src/GamePort/Game/OriginalCameraRay.cs @@ -0,0 +1,151 @@ +using System.Numerics; +using GamePort.Assets; + +namespace GamePort.Game; + +public readonly record struct CameraRayPolygon(SupportTriangle Triangle, Vector3 StoredNormal, + string? ShapeName = null, string? MaterialName = null); +public readonly record struct CameraRayResult(Vector3 Eye, float Gain, SupportHit? Hit); + +/// +/// Source47C210 static camera predicate: first accepted wall-grid polygon, then +/// first general-grid polygon. Cell rectangle order and FIFO registration matter; +/// this is not the support query's nearest-hit reducer or a camera sphere sweep. +/// See checkpoint/camera-ray-predicate.md for addresses and approximation limits. +/// +public sealed class OriginalCameraRay +{ + public const int GridSize = 260; + public const float CellScale = 0.0020000000949949026f; //4D6A04. + public const float CellOrigin = 130; //49B1FC. + private readonly Dictionary> walls = []; + private readonly Dictionary> all = []; + public bool Enabled { get; set; } = true; //4F69E5. + public int PolygonCount { get; } + public int WallPolygonCount { get; } + /// Modern query diagnostic; repeated cells are intentionally counted. + public int LastTriangleTests { get; private set; } + + /// + /// Caller supplies raw, untranslated static source triangles. Registration + /// follows shape resource ID then polygon array index, not render-draw order. + /// Game-specific polygon exclusion must be resolved by the caller. + /// + public OriginalCameraRay(IEnumerable polygons) + { + ArgumentNullException.ThrowIfNull(polygons); + var identities = new HashSet<(int Shape, int Polygon)>(); + foreach (var polygon in polygons.OrderBy(p => p.Triangle.ShapeId).ThenBy(p => p.Triangle.PolygonId)) + { + if (polygon.ShapeName?.StartsWith("nc", StringComparison.OrdinalIgnoreCase) == true + || IsCheckpoint(polygon.MaterialName)) continue; + var triangle = polygon.Triangle; + RequireFinite(triangle.A); RequireFinite(triangle.B); RequireFinite(triangle.C); + RequireFinite(polygon.StoredNormal); + if (!identities.Add((triangle.ShapeId, triangle.PolygonId))) + throw new InvalidDataException("Camera query needs one source triangle per polygon; fan-triangulated polygons are unsupported"); + var wall = polygon.StoredNormal.Y < .7f; //4798B3; equality excluded. + var min = Vector3.Min(triangle.A, Vector3.Min(triangle.B, triangle.C)); + var max = Vector3.Max(triangle.A, Vector3.Max(triangle.B, triangle.C)); + foreach (var cell in CellsBetween(min, max)) + { + Append(all, cell, triangle); + if (wall) Append(walls, cell, triangle); + } + PolygonCount++; + if (wall) WallPolygonCount++; + } + } + + /// + /// LV1B/VR04/LEV1 complete game slot134 is475CD0 (false), so only the proven + /// NC/checkpoint gates apply. Reject other levels rather than inventing masks. + /// Prepared source metadata is required; raw render visibility is irrelevant. + /// + public static OriginalCameraRay FromRouteScene(Mesh mesh, string levelCode) + { + ArgumentNullException.ThrowIfNull(mesh); + if (levelCode is not ("LV1B" or "VR04" or "LEV1")) + throw new NotSupportedException("Static camera game-filter recovery currently covers LV1B, VR04 and LEV1"); + if (mesh.Indices.Length % 3 != 0 || mesh.CollisionPolygons.Length != mesh.Indices.Length / 3) + throw new InvalidDataException("Original camera query requires source polygon metadata"); + var polygons = new CameraRayPolygon[mesh.CollisionPolygons.Length]; + for (var i = 0; i < polygons.Length; i++) + { + var source = mesh.CollisionPolygons[i]; + var a = mesh.Indices[i * 3]; var b = mesh.Indices[i * 3 + 1]; var c = mesh.Indices[i * 3 + 2]; + if (a >= mesh.Vertices.Length || b >= mesh.Vertices.Length || c >= mesh.Vertices.Length) + throw new InvalidDataException("Camera triangle index outside vertex table"); + polygons[i] = new(new(mesh.Vertices[a].Position, mesh.Vertices[b].Position, mesh.Vertices[c].Position, + source.ShapeId, source.PolygonIndex), source.Normal, source.ShapeName, source.MaterialName); + } + return new(polygons); + } + + /// 47C210/47C280/47C4B0: increasing X, increasing Z, FIFO first hit. + public SupportHit? Trace(Vector3 start, Vector3 end, bool twoSided = false) + { + RequireFinite(start); RequireFinite(end); + LastTriangleTests = 0; + if (!Enabled) return null; + foreach (var grid in new[] { walls, all }) + foreach (var cell in CellsBetween(start, end)) + if (grid.TryGetValue(cell, out var triangles)) + foreach (var triangle in triangles) + { + LastTriangleTests++; + if (OriginalBodySupport.IntersectSegment(triangle, start, end, twoSided) is { } hit) + return hit; + } + return null; + } + + /// 43B820: ray originates at computed look target, never actor root. + public CameraRayResult Constrain(Vector3 lookPoint, Vector3 desiredEye) + { + var hit = Trace(lookPoint, desiredEye); + return hit is { } accepted + ? new(lookPoint - (lookPoint - accepted.Position) * .75f, 1.5f, accepted) + : new(desiredEye, 1, null); + } + + /// + ///47F940 truncation then signed16. Double intermediates approximate source + /// x87, not bit-exact boundary emulation. Conversion overflow is unsupported. + /// + public static short CellCoordinate(float value) + { + if (!float.IsFinite(value)) throw new ArgumentOutOfRangeException(nameof(value)); + var scaled = (double)value * CellScale + CellOrigin; + if (scaled <= long.MinValue || scaled >= long.MaxValue) + throw new ArgumentOutOfRangeException(nameof(value), "Original x87 integer-overflow behavior is not recovered"); + return unchecked((short)(long)Math.Truncate(scaled)); + } + + private static IEnumerable CellsBetween(Vector3 a, Vector3 b) + { + var ax = (int)CellCoordinate(a.X); var bx = (int)CellCoordinate(b.X); + var az = (int)CellCoordinate(a.Z); var bz = (int)CellCoordinate(b.Z); + var minX = Math.Max(0, Math.Min(ax, bx)); var maxX = Math.Min(GridSize - 1, Math.Max(ax, bx)); + var minZ = Math.Max(0, Math.Min(az, bz)); var maxZ = Math.Min(GridSize - 1, Math.Max(az, bz)); + for (var x = minX; x <= maxX; x++) + for (var z = minZ; z <= maxZ; z++) yield return GridSize * x + z; + } + + private static void Append(Dictionary> grid, int cell, SupportTriangle triangle) + { + if (!grid.TryGetValue(cell, out var list)) grid.Add(cell, list = []); + list.Add(triangle); + } + + private static bool IsCheckpoint(string? material) => material is not null + && (material.Equals("cstart", StringComparison.OrdinalIgnoreCase) + || material.Length == 7 && material.StartsWith("ccheck", StringComparison.OrdinalIgnoreCase) + && material[6] is >= '1' and <= '9'); + + private static void RequireFinite(Vector3 vector) + { + if (!float.IsFinite(vector.X) || !float.IsFinite(vector.Y) || !float.IsFinite(vector.Z)) + throw new ArgumentOutOfRangeException(nameof(vector), "Finite source coordinates required"); + } +} diff --git a/src/GamePort/Game/SceneInventory.cs b/src/GamePort/Game/SceneInventory.cs index 7b48d9c..ec64316 100644 --- a/src/GamePort/Game/SceneInventory.cs +++ b/src/GamePort/Game/SceneInventory.cs @@ -24,6 +24,24 @@ public sealed class SceneInventory public void SetState(int group, int item, int state) => states[Offset(group, item)] = state; + /// + /// Jimmy PostLoad423DEF..423EC1: enable these eight owned gadgets, then + /// disable them in numeric VR01..VR08. State4 is unavailable ownership, + /// distinct from unowned0. Other wire values and item8 remain unchanged. + /// + public void ApplyLevelAvailability(string levelCode) + { + ArgumentNullException.ThrowIfNull(levelCode); + ReadOnlySpan items = [7, 3, 0, 5, 1, 6, 2, 4]; + foreach (var item in items) + if (states[item] == 4) states[item] = 1; + // Exactly the eight original FourCC values in the source numeric range. + if (levelCode.Length == 4 && levelCode.StartsWith("VR0", StringComparison.Ordinal) + && levelCode[3] is >= '1' and <= '8') + foreach (var item in items) + if (states[item] == 1) states[item] = 4; + } + public void SelectGadget(int item) { if (item != -1 && (item is < 0 or >= 9 || State(0, item) == 0)) diff --git a/src/GamePort/Program.cs b/src/GamePort/Program.cs index 37ff645..7c1accd 100644 --- a/src/GamePort/Program.cs +++ b/src/GamePort/Program.cs @@ -300,8 +300,14 @@ internal static class Program throw new ArgumentException("A scene and matching GAM are required to place an animated player."); animations = new PreviewAnimationLibrary(animationPath); var standingPose = AseMesh.Load(AssetPath.Resolve(root, "ASE/jimstop.ase")); - if (walking) simulation = new LabSimulation(new SceneCollision(mesh), standingPose, originalStart.Position, originalStart.Rotation.Y) - { LevelCode = level!.Code }; + if (walking) + { + var cameraRay = level!.Code is "LV1B" or "VR04" or "LEV1" + ? OriginalCameraRay.FromRouteScene(world, level.Code) : null; + simulation = new LabSimulation(new SceneCollision(world), standingPose, originalStart.Position, originalStart.Rotation.Y, + cameraRay == null ? null : (look, eye) => cameraRay.Trace(look, eye)) + { LevelCode = level.Code, InputAfterPlayerUpdate = carriedSave != null }; + } if (walking && returning) simulation!.RestoreReturnRoot(returnRoot); var placement = PreviewCharacterPlacement.Create(mesh, standingPose, originalStart.Position, originalStart.Rotation.Y); characterModel = placement.Model; @@ -321,6 +327,7 @@ internal static class Program storyTasks = tasks; director = new SceneDirector(level!, tasks, resources.Duration); interactions = new SceneInteractions(director, tasks, save); + interactions.Inventory.ApplyLevelAvailability(level!.Code); objectivePanel = new ObjectivePanel(interactions.CurrentObjective); interactions.ObjectiveChanged += objectivePanel.Select; simulation!.Energy = interactions.Energy; @@ -442,13 +449,15 @@ internal static class Program && Vector3.Distance(simulation.ActorRoot, returnRoot) < .001f && Vector2.Distance(new(returnRoot.X, returnRoot.Z), new(originalStart!.Position.X, originalStart.Position.Z)) > 100; var companionRestored = director.FindActor("C3DGODDARD")?.Position == returnRoot; - restored &= companionRestored; - Console.WriteLine($"Practice RETURN: exact saved root={restored}, root={simulation.ActorRoot}, STRT yaw={simulation.Yaw}, intro suppressed={!director.Playing}, companion restored={companionRestored}."); + restored &= companionRestored && simulation.InputAfterPlayerUpdate && interactions.Inventory.State(0, 3) == 1; + Console.WriteLine($"Practice RETURN: exact saved root={restored}, root={simulation.ActorRoot}, STRT yaw={simulation.Yaw}, intro suppressed={!director.Playing}, companion restored={companionRestored}, retained player input order={simulation.InputAfterPlayerUpdate}, gadget availability={interactions.Inventory.State(0, 3)}."); if (!restored) throw new InvalidOperationException("RETURN did not restore the live departure root without replaying STRT actions"); } if (args.Contains("--skip-intro") || jetpackSmoke || debugSmoke || diagnosticsSmoke) { sceneAudio?.StopSpeech(); director.Skip(); } if (practiceReturnSmoke && level.Code == "VR04") { + if (interactions!.Inventory.State(0, 3) != 4) + throw new InvalidOperationException("Tutorial PostLoad did not disable the owned gadget before VR04's bypass"); director.Skip(); interactions!.Update(level.Entities.First(e => e.Kind == "LOAD").Position); if (transitionRequest is not { Returning: true }) throw new InvalidOperationException("VR04 exit did not preserve RETURN identity"); diff --git a/tests/GamePort.CameraRayTests/GamePort.CameraRayTests.csproj b/tests/GamePort.CameraRayTests/GamePort.CameraRayTests.csproj new file mode 100644 index 0000000..969865e --- /dev/null +++ b/tests/GamePort.CameraRayTests/GamePort.CameraRayTests.csproj @@ -0,0 +1,15 @@ + + + Exenet10.0 + enableenable + false + + + + + + + + + + diff --git a/tests/GamePort.CameraRayTests/Program.cs b/tests/GamePort.CameraRayTests/Program.cs new file mode 100644 index 0000000..99f200f --- /dev/null +++ b/tests/GamePort.CameraRayTests/Program.cs @@ -0,0 +1,151 @@ +using System.Numerics; +using GamePort.Assets; +using GamePort.Game; + +var count = 0; +void Check(bool value, string message) { if (!value) throw new Exception(message); } +void Near(float actual, float expected, float tolerance, string message) => + Check(MathF.Abs(actual - expected) <= tolerance, $"{message}: {actual} != {expected}"); +void Test(string name, Action action) { action(); count++; Console.WriteLine($"PASS {name}"); } +void Reject(Action action, string message) where T : Exception +{ + try { action(); } catch (T) { return; } + throw new Exception(message); +} +SupportTriangle Horizontal(float y, int shape = 1, int polygon = 0) => + new(new(-10, y, -10), new(10, y, -10), new(0, y, 10), shape, polygon); +CameraRayPolygon Wall(float y, int shape = 1, int polygon = 0) => new(Horizontal(y, shape, polygon), Vector3.Zero); +CameraRayPolygon Floor(float y, int shape = 1, int polygon = 0) => new(Horizontal(y, shape, polygon), Vector3.UnitY); +var high = new Vector3(0, 100, 0); +var low = Vector3.Zero; + +Test("farther FIFO wall hit wins over nearer wall and general-grid floor", () => +{ + var ray = new OriginalCameraRay([Wall(20, 1), Wall(80, 2), Floor(90, 0)]); + var hit = ray.Trace(high, low); + Check(hit?.ShapeId == 1 && hit?.PolygonId == 0, "camera used nearest rather than first source wall"); + Near(hit!.Value.Position.Y, 20, .00001f, "first wall point"); + Near(hit.Value.Distance, 80, .00001f, "first wall distance"); + var nearest = OriginalBodySupport.Trace([Horizontal(20, 1), Horizontal(80, 2), Horizontal(90, 0)], high, low); + Check(nearest?.ShapeId == 0, "support nearest reduction changed while extracting the shared kernel"); + var result = ray.Constrain(high, low); + Near(result.Eye.Y, 40, .00001f, "source .25look+.75hit point"); + Check(result.Gain == 1.5f && result.Hit == hit, "obstructed gain/identity"); +}); + +Test("registration uses shape and polygon identities rather than render order", () => +{ + var ray = new OriginalCameraRay([Wall(80, 7, 2), Wall(20, 7, 1), Wall(90, 8, 0)]); + Check(ray.Trace(high, low)?.PolygonId == 1, "source polygon registration FIFO changed"); + ray = new([Wall(80, 7), Wall(20, 3)]); + Check(ray.Trace(high, low)?.ShapeId == 3, "source shape registration order changed"); +}); + +Test("inclusive cell rectangle scans increasing X and Z even against ray direction", () => +{ + SupportTriangle PlaneX(float x, int id) => new(new(x, -10, -10), new(x, -10, 10), new(x, 10, 0), id); + var rayX = new OriginalCameraRay([new(PlaneX(900, 1), Vector3.Zero), new(PlaneX(100, 2), Vector3.Zero)]); + Check(rayX.Trace(new(1000, 0, 0), Vector3.Zero)?.ShapeId == 2, + "grid rectangle should test farther lower-X cell first"); + SupportTriangle PlaneZ(float z, int id) => new(new(-10, -10, z), new(0, 10, z), new(10, -10, z), id); + var rayZ = new OriginalCameraRay([new(PlaneZ(900, 1), Vector3.Zero), new(PlaneZ(100, 2), Vector3.Zero)]); + Check(rayZ.Trace(new(0, 0, 1000), Vector3.Zero)?.ShapeId == 2, + "inner grid rectangle should test farther lower-Z cell first"); +}); + +Test("missed polygons are tested again in each cell and in fallback grid", () => +{ + var triangle = new SupportTriangle(new(-10, 0, 0), new(10, 0, 0), new(0, 0, 600)); + var ray = new OriginalCameraRay([new(triangle, Vector3.Zero)]); + Check(ray.Trace(new(0, 10, 1), new(0, 10, 501)) == null, "parallel segment fabricated hit"); + Check(ray.LastTriangleTests == 4, "query silently deduplicated source repeated-cell candidates"); +}); + +Test("general grid fallback, stored-normal threshold and source winding", () => +{ + var ray = new OriginalCameraRay([new(Horizontal(50), new(0, .7f, 0))]); + Check(ray.PolygonCount == 1 && ray.WallPolygonCount == 0, "normal.Y equality must be excluded from wall grid"); + Check(ray.Trace(high, low).HasValue && ray.LastTriangleTests == 1, "general grid fallback missing"); + Check(ray.Trace(low, high) == null, "source backface accepted"); + Check(ray.Trace(low, high, true).HasValue, "two-sided source override rejected"); + var reverse = Horizontal(50) with { B = Horizontal(50).C, C = Horizontal(50).B }; + Check(new OriginalCameraRay([new(reverse, Vector3.UnitY)]).Trace(high, low) == null, "serialized winding was reversed"); +}); + +Test("beginning accepted, endpoint rejected, zero-length and degenerate triangles miss", () => +{ + var ray = new OriginalCameraRay([Floor(0)]); + Check(ray.Trace(new(0, 20, 0), low) == null, "strict segment endpoint accepted"); + Check(ray.Trace(low, new(0, -20, 0)).HasValue, "beginning was rejected by an invented skin"); + Check(ray.Trace(low, low) == null, "zero segment fabricated hit"); + var degenerate = new OriginalCameraRay([new(new(Vector3.Zero, Vector3.Zero, Vector3.Zero), Vector3.Zero)]); + Check(degenerate.Trace(high, low) == null, "degenerate triangle fabricated hit"); + Check(ray.Trace(new(0, 20, 0), new(0, .001f, 0)) == null, "triangle beyond segment accepted"); +}); + +Test("NC shapes and checkpoint materials filter registration, null material remains", () => +{ + var ray = new OriginalCameraRay([ + new(Horizontal(90, 1), Vector3.Zero, "NCwater"), + new(Horizontal(80, 2), Vector3.Zero, null, "CSTART"), + new(Horizontal(70, 3), Vector3.Zero, null, "cCHECK9"), + new(Horizontal(60, 4), Vector3.Zero, "ordinary", null), + new(Horizontal(50, 5), Vector3.Zero, null, "ccheck0"), + new(Horizontal(40, 6), Vector3.Zero, null, "ccheck10")]); + Check(ray.PolygonCount == 3 && ray.WallPolygonCount == 3, "source registration filters differ"); + Check(ray.Trace(high, low)?.ShapeId == 4, "invisible null-material proxy was excluded"); +}); + +Test("source enable flag and unobstructed gain leave desired eye unchanged", () => +{ + var ray = new OriginalCameraRay([Wall(50)]) { Enabled = false }; + var result = ray.Constrain(high, low); + Check(result.Eye == low && result.Gain == 1 && result.Hit == null && ray.LastTriangleTests == 0, + "disabled predicate queried geometry or moved eye"); + ray.Enabled = true; + result = ray.Constrain(new(100, 100, 100), new(100, 0, 100)); + Check(result.Eye == new Vector3(100, 0, 100) && result.Gain == 1 && result.Hit == null, "miss changed eye or gain"); +}); + +Test("stored float cell scale, negative truncation, signed16 domain and out-of-grid misses", () => +{ + Check(BitConverter.SingleToInt32Bits(OriginalCameraRay.CellScale) == 0x3b03126f, "source cell scale changed"); + Check(OriginalCameraRay.CellCoordinate(-1) == 129 && OriginalCameraRay.CellCoordinate(0) == 130, + "negative coordinate cell conversion changed"); + Check(OriginalCameraRay.CellCoordinate(-65000) == 0 && OriginalCameraRay.CellCoordinate(-65500) == -1, + "source truncation near negative grid edge differs"); + Check(OriginalCameraRay.CellCoordinate(1_000_000) == 2130, "out-of-grid conversion incorrectly clamps cells"); + var ray = new OriginalCameraRay([Floor(50)]); + Check(ray.Trace(new(1_000_000, 100, 1_000_000), new(1_000_000, 0, 1_000_000)) == null, + "out-of-grid source query fabricated hit"); +}); + +Test("malformed, nonfinite and unsupported scene contracts reject explicitly", () => +{ + Reject(() => new OriginalCameraRay([Wall(20), Wall(80)]), "ambiguous source polygon identity accepted"); + Reject(() => new OriginalCameraRay([new(Horizontal(20), new(float.NaN, 0, 0))]), "nonfinite normal accepted"); + var ray = new OriginalCameraRay([Wall(50)]); + Reject(() => ray.Trace(new(float.NaN, 0, 0), low), "nonfinite segment accepted"); + Reject(() => OriginalCameraRay.CellCoordinate(float.MaxValue), "unknown x87 overflow silently emulated"); + var empty = new Mesh([], []); + Reject(() => OriginalCameraRay.FromRouteScene(empty, "LV2A"), "unrecovered game filter silently assumed false"); + Reject(() => OriginalCameraRay.FromRouteScene(new Mesh(new MeshVertex[3], [0, 1, 2]), "LV1B"), + "missing polygon source metadata accepted"); +}); + +Test("original route geometry registration counts and retained invisible polygons", () => +{ + var prepared = Path.GetFullPath(args.Length > 0 ? args[0] : "artifacts/extracted"); + foreach (var (scene, code, polygons, walls) in new[] { + ("level1b", "LV1B", 2851, 2483), ("VR04", "VR04", 508, 420), ("level1", "LEV1", 5231, 3860) }) + { + var mesh = Mesh.LoadSceneJson(AssetPath.Resolve(prepared, scene + "/scene.json")); + var ray = OriginalCameraRay.FromRouteScene(mesh, code); + Check(ray.PolygonCount == polygons && ray.WallPolygonCount == walls, + $"{scene} original polygon/wall registration differs: {ray.PolygonCount}/{ray.WallPolygonCount}"); + if (scene == "level1b") + Check(mesh.Draws.Sum(d => (long)d.IndexCount) < mesh.Indices.Length, "lab proxy visibility fixture changed"); + } +}); + +Console.WriteLine($"Camera ray checks: {count} groups passed. Source ordering/kernel translation verified; original runtime and x87 boundary equivalence remain unverified."); diff --git a/tests/GamePort.CameraRayTests/README.md b/tests/GamePort.CameraRayTests/README.md new file mode 100644 index 0000000..585584b --- /dev/null +++ b/tests/GamePort.CameraRayTests/README.md @@ -0,0 +1,50 @@ +# Static source camera query checks + +Run from GamePort: + +```sh +source scripts/env.sh +dotnet run --project tests/GamePort.CameraRayTests +dotnet run --project tests/GamePort.SupportTests +``` + +Optional first argument selects the prepared-scene root (default +`artifacts/extracted`). Original geometry is prepared separately; these tests +do not modify or execute original files. + +`OriginalCameraRay.FromRouteScene(mesh, levelCode)` accepts only LV1B, VR04 and +LEV1, whose original game polygon-filter slot134 is475CD0 (false). It retains +source shape/polygon identity and stored normals, excludes NC/checkpoint records, +and rejects included fan-triangulated polygon identities rather than changing the +original first-three-corner rule. All included polygons in these three original +scenes are triangles. Original registration counts are2851/2483 wall (lab), +508/420 (VR04),5231/3860 (outside). + +Source anchors and exact file offsets are recorded in +`docs/checkpoint/camera-ray-predicate.md` and checked by +`tests/test_checkpoint_camera_ray.py`. Critical contracts are47C210 wall-first +then general-grid fallback;47C280/47C4B0 inclusive ascending X/Z rectangle and +FIFO first accepted polygon;479800 tail insertion and4798B3 normal.Y<.7; +469A10/469B70 one-sided segment/triangle kernel and strict endpoint rejection. +43B820 applies `.25*look+.75*hit` and returns gain1.5; a miss leaves eye/gain1. + +API: `Trace(start,end,twoSided=false)` returns optional SupportHit; +`Constrain(look,desired)` returns CameraRayResult(Eye,Gain,Hit). Enabled is the +per-adapter representation of source global4F69E5. PolygonCount/WallPolygonCount +and LastTriangleTests are modern diagnostics; repeated cells count repeated +triangle tests. OriginalBodySupport.IntersectSegment shares the recovered +individual kernel while its existing Trace retains nearest reduction. + +The checks exercise source route counts and deliberately non-nearest results, +cell direction, FIFO identity, repeated candidates, fallback, normal threshold, +winding/sidedness, beginning/end, degenerate segments, filters, proxy retention, +enable flag, look-point weighting, negative/signed16 cells and malformed inputs. +They verify this port implementation and source data, not original running-game +behavior or whole-camera integration. + +Limits: grid conversion uses double intermediates in place of x87 extended +precision; exact boundary equivalence and integer overflow remain unrecovered. +Finite values outside supported signed64 conversion throw. Lookup tables retain +the existing support module's modern-trig limitation. Other level-specific +polygon filters, missing shape IDs, nonidentity terrain transforms, camera input +modes and shared viewport/follow update state remain outside this adapter. diff --git a/tests/GamePort.InteractionTests/Program.cs b/tests/GamePort.InteractionTests/Program.cs index 14eb8c7..6d3f43e 100644 --- a/tests/GamePort.InteractionTests/Program.cs +++ b/tests/GamePort.InteractionTests/Program.cs @@ -155,6 +155,34 @@ inventory.SetState(0, 3, 0); Throws(() => inventory.SelectGadget(3)); inventory.SetState(0, 3, 1); inventory.SelectGadget(3); Check(inventory.SelectedGadget == 3, "Owned gadget selection"); Console.WriteLine("PASS inventory bounds, ownership, unknown-state preservation and gadget availability"); +foreach (var state in new[] { int.MinValue, -1, 0, 1, 2, 3, 4, 5, int.MaxValue }) +{ + foreach (var tutorial in Enumerable.Range(1, 8).Select(i => "VR0" + i)) + { + var availability = new SceneInventory(Enumerable.Repeat(state, 19)); + availability.ApplyLevelAvailability(tutorial); + var disabled = state is 1 or 4 ? 4 : state; + Check(Enumerable.Range(0, 8).All(i => availability.State(0, i) == disabled), + "Tutorial PostLoad only disables owned states1/4"); + Check(availability.State(0, 8) == state && Enumerable.Range(0, 10).All(i => availability.State(1, i) == state), + "PostLoad availability preserves gadget8 and the independent inventory group"); + var carried = OriginalSave.Parse((original with { InventoryStates = availability.Snapshot() }).Encode()); + var returned = new SceneInventory(carried.InventoryStates); + returned.ApplyLevelAvailability("LV1B"); + Check(Enumerable.Range(0, 8).All(i => returned.State(0, i) == (state is 1 or 4 ? 1 : state)), + "Serialized tutorial state returns to enabled owned gadgets in lab"); + } +} +foreach (var normal in new[] { "LV1B", "LEV1", "VR00", "VR09", "vr04" }) +{ + var availability = new SceneInventory(Enumerable.Repeat(4, 19)); + availability.ApplyLevelAvailability(normal); + Check(availability.State(0, 3) == 1 && availability.State(0, 8) == 4, + "Normal/fourcc-boundary PostLoad enables selected owned gadgets only"); +} +Check(JetpackBurst.CanStart("VR04", -1, 4, 20), "Tutorial jetpack bypass still works with disabled inventory state4"); +Console.WriteLine("PASS source PostLoad gadget availability, tutorial boundaries and lab RETURN round-trip"); + // Independently recover the original SCENE setter's two dispatch tables rather // than testing the port's switch against another manually copied switch. var exe = File.ReadAllBytes(AssetPath.Resolve(root, "Neutron.exe")); diff --git a/tests/GamePort.MovementTests/Program.cs b/tests/GamePort.MovementTests/Program.cs index 257c9ba..651a17b 100644 --- a/tests/GamePort.MovementTests/Program.cs +++ b/tests/GamePort.MovementTests/Program.cs @@ -8,6 +8,8 @@ var tests = new (string Name, Action Check)[] { ("60 simulation calls across 60/120/144 Hz presentation", ClockRates), ("clock remainder, stall bound, reset and invalid intervals", ClockBoundaries), + ("physics consumes prior motion; fresh versus retained input order", FrameOrdering), + ("source camera query origin, hit adjustment, gain and one query per input", CameraQueryConsumer), ("turn-only speed, forward acceleration/cap and release", SpeedLimits), ("backpedal cap and release", Backpedal), ("yaw sign, forward half-turn and left precedence", Turning), @@ -59,6 +61,69 @@ static void ClockBoundaries() Throws(() => clock.Advance(elapsed)); } +static void FrameOrdering() +{ + var fresh = FlatSimulation(); + var origin = fresh.Position; + var forward = new PlayerInput(true, false, false, false, false); + fresh.Step(forward); + NearVector(fresh.Position, origin, .0001f, "input cannot move an already integrated body"); + Near(fresh.Speed, 30, 0, "fresh input runs before player callback"); + Near(fresh.Velocity.Z, 30, 0, "player produces velocity for the next physics pass"); + fresh.Step(forward); + Near(fresh.Position.Z - origin.Z, 30 * FixedStepClock.Step, .0001f, "next physics consumes previous30, not current60"); + + var retained = FlatSimulation(); + retained.InputAfterPlayerUpdate = true; + retained.Step(forward); + Near(retained.Speed, 30, 0, "new level game updates retained player's input later"); + Near(retained.Velocity.Z, 0, 0, "retained player callback preceded first destination input"); + retained.Step(forward); + NearVector(retained.Position, origin, .0001f, "second retained physics still sees old zero velocity"); + Near(retained.Velocity.Z, 30, 0, "retained player now produces prior input speed"); + retained.Step(forward); + Near(retained.Position.Z - origin.Z, 30 * FixedStepClock.Step, .0001f, "retained third physics consumes first input"); + + var jump = FlatSimulation(); + jump.Step(new(false, false, false, false, true)); + NearVector(jump.Position, origin, .0001f, "queued jump cannot retroactively change physics"); + Near(jump.PendingImpulse.Y, 550, 0, "jump impulse remains pending until next body pass"); + Check(jump.Grounded && jump.Pose == PlayerPose.Jump, "jump animation request does not change physical support"); + jump.Step(default); + Near(jump.PendingImpulse.Y, 0, 0, "next body pass consumes queued impulse exactly once"); + Near(jump.Velocity.Y, 550 - 800 * 1.33f * FixedStepClock.Step, .0001f, + "next body pass applies one impulse plus the retained provisional gravity adapter"); + Check(!jump.Grounded && jump.Position.Y > origin.Y, "queued jump takes off on following body pass"); + jump.Step(default); + Check(jump.Velocity.Y < 550 && jump.Velocity.Y > 500, "later body pass adds acceleration without repeating impulse"); + jump.Reset(); + NearVector(jump.PendingImpulse, Vector3.Zero, 0, "reset clears pending physical work"); + Check(jump.MovementMode == 0, "reset restores stored walking input mode"); +} + +static void CameraQueryConsumer() +{ + var enabled = false; + var queries = 0; + var lastLook = Vector3.Zero; + var lastDesired = Vector3.Zero; + SupportHit? Query(Vector3 look, Vector3 desired) + { + queries++; lastLook = look; lastDesired = desired; + return enabled ? new SupportHit((look + desired) / 2, 7, 9, 0) : null; + } + var simulation = FlatSimulation(cameraRay: Query); + var before = simulation.CameraEye; + var beforeQueries = queries; + enabled = true; + simulation.Step(default); + NearVector(lastLook, simulation.CameraTarget, .0001f, "ray origin is look target rather than actor root"); + var adjusted = lastLook + (lastDesired - lastLook) * .375f; + var expected = before + (adjusted - before) * new Vector3(1.6f, 1.2f, 1.6f) * 1.5f * FixedStepClock.Step; + NearVector(simulation.CameraEye, expected, .0001f, "source hit weighting and follow gain feed interpolation"); + Check(queries == beforeQueries + 1, "no additional camera obstruction query after interpolation"); +} + static void SpeedLimits() { var turn = FlatSimulation(); @@ -102,7 +167,8 @@ static void Turning() Near(left.Yaw, -right.Yaw, .00001f, "opposed keyboard yaw symmetry"); Near(forwardLeft.Yaw, left.Yaw / 2, .00001f, "Up halves target turn offset"); Near(forwardLeft.Speed, 60, 0, "Up plus turn performs both speed increments"); - Check(left.Position.X < 0 && right.Position.X > 0, "keyboard side-velocity signs"); + Check(left.Velocity.X < 0 && right.Velocity.X > 0, "keyboard side-velocity signs for next physics pass"); + Near(left.Position.X, 0, .0001f, "turn input waits for subsequent physics"); var both = FlatSimulation(); var leftOnly = FlatSimulation(); @@ -138,8 +204,8 @@ static void JumpLanding() var simulation = FlatSimulation(); var floor = simulation.Position.Y; simulation.Step(new(false, false, false, false, true)); - Check(!simulation.Grounded && simulation.Velocity.Y > 500 && simulation.Jumps == 1 && simulation.Pose == PlayerPose.Jump, - "jump takes off with one queued impulse"); + Check(simulation.Grounded && simulation.PendingImpulse.Y == 550 && simulation.Jumps == 1 && simulation.Pose == PlayerPose.Jump, + "jump queues once after physics and requests its animation"); var sawFall = false; var largestHeight = simulation.Position.Y; for (var i = 0; i < 120; i++) @@ -164,7 +230,7 @@ static void HeldJump() for (var i = 0; i < 150; i++) simulation.Step(default); Check(simulation.Jumps == jumpCount && simulation.Grounded, "release stops held repetition and lands"); simulation.Step(new(false, false, false, false, true)); - Check(simulation.Jumps == jumpCount + 1 && !simulation.Grounded, "new grounded press starts another jump"); + Check(simulation.Jumps == jumpCount + 1 && simulation.PendingImpulse.Y == 550, "new grounded press queues another jump"); } static void AirArithmetic() @@ -196,6 +262,7 @@ static void AirControl() { var simulation = FlatSimulation(); simulation.Step(new(false, false, false, false, true)); + simulation.Step(default); // Consume the queued takeoff before airborne input. var origin = simulation.Position; for (var i = 0; i < 20; i++) { @@ -262,10 +329,14 @@ static void LandingTurn() { var simulation = FlatSimulation(); simulation.Step(new(true, false, false, false, true)); - for (var i = 0; i < 120 && !simulation.Grounded; i++) + var largestAirTurn = 0f; + for (var i = 0; i < 120 && (i == 0 || !simulation.Grounded); i++) + { simulation.Step(new(true, false, initialLeft, !initialLeft, false)); - Check(simulation.Grounded && MathF.Abs(simulation.TurnRate) > 20, - "Landing fixture retains an opposing air turn before outer grounded reset"); + largestAirTurn = MathF.Max(largestAirTurn, MathF.Abs(simulation.TurnRate)); + } + Check(simulation.Grounded && largestAirTurn > 20 && simulation.TurnRate == 0, + "Physics landing precedes the same-frame player update clearing air turn"); var before = simulation.Yaw; simulation.Step(new(true, false, !initialLeft, initialLeft, false)); Near(simulation.TurnRate, 0, 0, "grounded released-jump reset clears shared air-turn field"); @@ -376,7 +447,7 @@ static void OriginalLab(string project, string originals) Near(simulation.Position.Y, .5486332f + SceneCollision.Skin, .03f, "original lab jump returns to floor"); } -static LabSimulation FlatSimulation(float yaw = 0) +static LabSimulation FlatSimulation(float yaw = 0, Func? cameraRay = null) { var positions = new[] { @@ -386,7 +457,7 @@ static LabSimulation FlatSimulation(float yaw = 0) var floor = new Mesh(positions.Select(p => new MeshVertex(p, Vector2.Zero, Vector3.One)).ToArray(), [0, 1, 2, 3, 4, 5]); var standing = new Mesh([new(new(-20, -20, -20), Vector2.Zero, Vector3.One), new(new(20, 80, 20), Vector2.Zero, Vector3.One)], []); - return new LabSimulation(new SceneCollision(floor), standing, new Vector3(0, 25, 0), yaw); + return new LabSimulation(new SceneCollision(floor), standing, new Vector3(0, 25, 0), yaw, cameraRay); } static void SameState(LabSimulation actual, LabSimulation expected, string message) diff --git a/tests/GamePort.UndergroundRouteTests/Program.cs b/tests/GamePort.UndergroundRouteTests/Program.cs index e3631e7..6804ae7 100644 --- a/tests/GamePort.UndergroundRouteTests/Program.cs +++ b/tests/GamePort.UndergroundRouteTests/Program.cs @@ -136,14 +136,15 @@ void Tick(PlayerInput input) director.Touch(level.Player.Tag!, simulation.ActorRoot); interactions.Update(simulation.ActorRoot, simulation.InteractionRadius); mechanisms.Update(simulation.ActorRoot, simulation.InteractionRadius); - // Test actual aperture clearance when crossing the gate plane, before this - // frame's mechanism movement. The resolver uses this same current transform. + // Test the recovered radius60 root body when crossing the gate plane, + // before mechanism movement. Raw standing mesh height is a provisional + // visual/pivot policy, not the dynamic collider used by the source adapter. if ((previous.Z - bars.Position.Z) * (simulation.ActorRoot.Z - bars.Position.Z) < 0) { var box = visuals.DoorColliders().Single(); var minimumY = DynamicSceneCollision.Corners(box).Min(p => p.Y); - Require(minimumY > simulation.Position.Y + simulation.BodyHeight, - "Replay crossed the bars before the moving doorway cleared the player"); + Require(minimumY > simulation.ActorRoot.Y + simulation.InteractionRadius, + "Replay crossed the bars before the moving doorway cleared the recovered body"); crossings++; } mechanisms.Step(FixedStepClock.Step); diff --git a/tests/test_checkpoint_character_reset.py b/tests/test_checkpoint_character_reset.py new file mode 100644 index 0000000..6f02600 --- /dev/null +++ b/tests/test_checkpoint_character_reset.py @@ -0,0 +1,49 @@ +"""Retained-character source evidence and state-conversion boundaries.""" +from pathlib import Path +import sys +import unittest + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tools/binary')) +from checkpoint_character_reset import collect, gadget_postload + + +class CharacterResetEvidenceTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.report = collect(ROOT.parent / 'Original') + + def test_source_identity_reset_and_callback_provenance(self): + self.assertTrue(self.report['known_binary']) + for key in ('sites', 'vtables', 'gadget_calls'): + for item in self.report[key]: + with self.subTest(key=key, item=item): + self.assertTrue(item['matches']) + + def test_euler_capture_is_not_body_velocity(self): + sites = {s['name']: s for s in self.report['sites']} + self.assertEqual(sites['euler_getter_y']['actual'], '8b9128020000') + self.assertEqual(sites['player_init_yaw_capture']['actual'], '8b500489961c060000') + tables = {s['name']: s['target'] for s in self.report['vtables']} + self.assertEqual(tables['Jimmy Euler getter'], '0x4723f0') + + def test_gadget_postload_disables_owned_only_and_restores_on_return(self): + original = [0, 1, 4, 2, 3, -1, 99, 1, 123] + disabled = gadget_postload(original, True) + self.assertEqual(disabled, [0, 4, 4, 2, 3, -1, 99, 4, 123]) + self.assertEqual(gadget_postload(disabled, False), [0, 1, 1, 2, 3, -1, 99, 1, 123]) + self.assertEqual(original, [0, 1, 4, 2, 3, -1, 99, 1, 123]) + self.assertEqual(gadget_postload(disabled, True), disabled) + with self.assertRaises(ValueError): + gadget_postload([0] * 7, False) + + def test_route_properties_do_not_serialize_mode_or_burn_timer(self): + self.assertEqual([x['code'] for x in self.report['route']], ['LV1B', 'VR04', 'LEV1']) + for item in self.report['route']: + self.assertIn('StartPoint', item['player_properties']) + self.assertFalse(any('jump' in p.casefold() or 'mode' in p.casefold() + or 'burn' in p.casefold() for p in item['player_properties'])) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_checkpoint_level_game_lifetime.py b/tests/test_checkpoint_level_game_lifetime.py new file mode 100644 index 0000000..ebb9c26 --- /dev/null +++ b/tests/test_checkpoint_level_game_lifetime.py @@ -0,0 +1,39 @@ +"""Guard source stored/live lifecycle fields and the old-game deletion path.""" +from pathlib import Path +import sys +import unittest + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tools/binary')) +from checkpoint_level_game_lifetime import collect + + +class LevelGameLifetimeTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.report = collect(ROOT.parent / 'Original') + + def test_original_instruction_and_vtable_identity(self): + self.assertTrue(self.report['known_binary']) + for item in self.report['sites'] + self.report['vtables']: + with self.subTest(item=item): + self.assertTrue(item['matches']) + + def test_route_level_games_share_initialization_contract(self): + slots = {(x['owner'], x['slot']): x['target'] for x in self.report['vtables']} + for owner in ('lab', 'tutorial', 'outside'): + self.assertEqual(slots[owner, '0x28'], '0x44d4e0') + self.assertEqual(slots[owner, '0x8c'], '0x470f30') + self.assertEqual(slots[owner, '0x204'], '0x4719c0') + + def test_actual_initializer_precedes_postload_and_teardown_calls_sweep(self): + sites = {x['label']: x for x in self.report['sites']} + self.assertLess(int(sites['loader_init_slot']['va'], 16), int(sites['loader_postload_slot']['va'], 16)) + self.assertEqual(sites['base_init_to_common']['target'], '0x470540') + self.assertEqual(sites['teardown_delete_sweep']['target'], '0x473710') + self.assertEqual(sites['lab_destructor_base']['target'], '0x44d390') + self.assertEqual(sites['game_destructor_interface']['target'], '0x4587e0') + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_player_phase_evidence.py b/tests/test_player_phase_evidence.py new file mode 100644 index 0000000..ec6b6cc --- /dev/null +++ b/tests/test_player_phase_evidence.py @@ -0,0 +1,19 @@ +from pathlib import Path +import sys +import unittest + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tools/binary')) +from player_phase_evidence import collect + + +class PlayerPhaseEvidenceTests(unittest.TestCase): + def test_original_mode_and_frame_boundaries(self): + evidence = collect(ROOT.parent / 'Original') + self.assertEqual(len(evidence['sites']), 9) + self.assertEqual([s['va'] for s in evidence['sites'][-3:]], + ['0x47e554', '0x47e582', '0x47e587']) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/binary/checkpoint_character_reset.py b/tools/binary/checkpoint_character_reset.py new file mode 100644 index 0000000..f9c5f2b --- /dev/null +++ b/tools/binary/checkpoint_character_reset.py @@ -0,0 +1,136 @@ +#!/usr/bin/env python3 +"""Read-only retained-character initialization and PostLoad evidence.""" +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path +import struct +import sys + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from checkpoint_script_state import EXE_SHA256, find_case, read_va, rel_call_target +from pe_inspect import PE +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'levels')) +import gam + +SITES = ( + ('player_init_base', 0x437896, 'e8550f0200'), + ('player_init_speed_zero', 0x4378A1, '898608060000'), + ('player_init_turn_zero', 0x4378A7, '898614060000'), + ('player_init_618_zero', 0x4378AD, '898618060000'), + ('player_init_euler_getter', 0x4378B8, 'ff9028030000'), + ('player_init_yaw_capture', 0x4378BE, '8b500489961c060000'), + ('euler_getter_y', 0x4723FC, '8b9128020000'), + ('postload_jump_zero', 0x42378B, '6689bd28070000'), + ('postload_normal_radius60', 0x4236A3, '6800007042'), + ('postload_normal_support_factor', 0x4236B3, '6885eba13f'), + ('postload_animation_pause_disable', 0x42370A, 'ff901c010000'), + ('stage_sound_stop', 0x43B7FB, 'ff9248010000'), + ('sound_stop_only_handle', 0x429A19, 'c786440a0000ffffffff'), + ('fire_constructor_preservation', 0x421E51, 'e8eaf00400'), + ('fire_constructor_owner_zero', 0x421E62, '899ebc060000'), + ('fire_constructor_timer_zero', 0x421E68, '899ec0060000'), + ('fire_owner_assignment', 0x437525, '8981bc060000'), + ('fire_grounded_owner_clear', 0x421FE9, 'c7860006000000000000'), + ('fire_timer_tick', 0x421FF3, 'd98600060000d8642418'), + ('player_constructor_mode_zero', 0x43748A, '66899dc4070000'), + ('goddard_init_base_jump', 0x41E6A0, 'e90b98feff'), + ('goddard_init_authored_state', 0x407EBC, '8b867c080000898608060000'), + ('goddard_init_waypoint_clear', 0x407EC8, 'c7860008000000000000'), + ('goddard_postload_base', 0x41E593, 'e8e8aefeff'), + ('goddard_reuse_callback', 0x423CE2, 'ff9074010000'), + ('inventory_disable_compare_one', 0x40389E, '66833801751166c7000400'), + ('inventory_enable_compare_four', 0x4038AA, '66833804750566c7000100'), + ('tutorial_level_lower_bound', 0x423E52, '3d31305256'), + ('tutorial_level_upper_bound', 0x423E5D, '3d38305256'), + ('tutorial_mode_flag', 0x423E6A, 'c6853809000001'), + ('tutorial_objective_hidden', 0x423EC6, 'c70588814f000000a041'), +) + +VTABLES = ( + ('Jimmy Init', 0x4A373C, 0x28, 0x437890), + ('Jimmy PostLoad', 0x4A373C, 0x40C, 0x423610), + ('Jimmy Euler getter', 0x4A373C, 0x328, 0x4723F0), + ('Jimmy transition stop sound', 0x4A3BDC, 0x148, 0x429A00), + ('Jimmy animation pause', 0x4A3BDC, 0x11C, 0x40D350), + ('Fire Init', 0x4A3160, 0x28, 0x4587F0), + ('Fire PostLoad', 0x4A3160, 0x40C, 0x40E7B0), + ('Goddard Init', 0x49F480, 0x28, 0x41E6A0), + ('Goddard PostLoad', 0x49F480, 0x40C, 0x41E590), + ('Shadow Init', 0x4B37B8, 0x28, 0x4587F0), + ('Shadow PostLoad', 0x4B37B8, 0x40C, 0x43F810), +) + +GADGET_INDICES = (7, 3, 0, 5, 1, 6, 2, 4) +ENABLE_CALLS = (0x423DEF, 0x423DFA, 0x423E05, 0x423E10, + 0x423E1B, 0x423E26, 0x423E34, 0x423E3F) +DISABLE_CALLS = (0x423E71, 0x423E7C, 0x423E87, 0x423E92, + 0x423E9D, 0x423EA8, 0x423EB6, 0x423EC1) + + +def gadget_postload(states, tutorial): + """Bounded state oracle: source403870 preserves values other than1/4.""" + values = list(states) + if len(values) < 8: + raise ValueError('Need all eight group0 gadget entries') + for index in GADGET_INDICES: + if values[index] == 4: + values[index] = 1 + if tutorial: + for index in GADGET_INDICES: + if values[index] == 1: + values[index] = 4 + return values + + +def collect(root: Path): + pe = PE(find_case(root, 'Neutron.exe')) + digest = hashlib.sha256(pe.data).hexdigest() + sites = [] + for name, va, expected in SITES: + actual = read_va(pe, va, len(bytes.fromhex(expected))).hex() + item = dict(name=name, va=hex(va), file_offset=hex(pe.offset(va-pe.base)), + expected=expected, actual=actual, matches=actual == expected) + if actual.startswith('e8'): + item['direct_call_target'] = hex(rel_call_target(pe, va)) + sites.append(item) + tables = [] + for name, table, slot, expected in VTABLES: + actual = struct.unpack(' dict: + pe = PE(find_case(original, "Neutron.exe")) + digest = hashlib.sha256(pe.data).hexdigest() + sites = [] + for label, va, expected in SITES: + actual = read_va(pe, va, len(expected) // 2).hex() + item = dict(label=label, va=hex(va), file_offset=hex(pe.offset(va-pe.base)), + expected=expected, actual=actual, matches=actual == expected) + if actual.startswith("e8"): + item["target"] = hex(rel_call_target(pe, va)) + sites.append(item) + tables = [] + for name, table, slot, expected in TABLES: + va = table + slot + actual, = struct.unpack("