Compare commits

...
31 Commits
Author SHA1 Message Date
UnixNight fafb54730a Record body ownership regression and package validation 2026-11-05 11:12:30 -05:00
UnixNight c9d0c5be59 Preserve contact-owned roots and independent body modes 2026-11-05 11:06:13 -05:00
UnixNight 3845ea7114 Record airborne bridge regression and package verification 2026-11-05 10:28:10 -05:00
UnixNight 27be8ed630 Integrate source airborne tilt and logical-root rendering 2026-11-05 10:19:12 -05:00
UnixNight a61f1b0284 Record Jimmy movement integration and package validation 2026-11-05 09:56:25 -05:00
UnixNight acd1b287cf Accept original canonical angle at first Bubble replay step 2026-11-05 09:52:02 -05:00
UnixNight 0e2f426d42 Match Jimmy controller arithmetic and facing to original probes 2026-11-05 09:47:28 -05:00
UnixNight 42ea2b8cd5 Record Scooter feedback fix and standalone package verification 2026-11-04 22:48:20 -05:00
UnixNight fccc0b9d1b Restore Goddard leveling and Scooter positional pitch processing 2026-11-04 18:27:56 -05:00
UnixNight 74be19eb15 Record Scooter regression and standalone package verification 2026-11-04 18:09:09 -05:00
UnixNight 62c07a3d59 Implement source-backed Scooter vehicle in tutorial and outside 2026-11-04 18:06:09 -05:00
UnixNight 8df5e81070 Record Grappler regression native replay and package validation 2026-11-04 11:33:19 -05:00
UnixNight 43806fe862 Implement verified Grappler body camera and helpers in VR08 2026-11-04 11:27:03 -05:00
UnixNight ffea678e90 Recover Grappler aim gating and implement verified ray constraint components 2026-11-03 22:22:45 -05:00
UnixNight 0c913d15aa Implement Grappler scalar component with original-code references 2026-11-03 21:25:54 -05:00
UnixNight 70cba65c1f Correct orbit camera horizontal input direction 2026-11-03 21:13:34 -05:00
UnixNight 87381049da Record orbit camera runtime and package verification 2026-11-03 17:40:45 -05:00
UnixNight d8f1b51c86 Fix orbit camera mirroring by matching gameplay handedness 2026-11-03 17:38:48 -05:00
UnixNight 1b679c641a Record Rocketship impact correction package verification 2026-11-03 16:55:54 -05:00
UnixNight 62e908e26d Fix Rocketship wall damage flash misinterpreted as model scaling 2026-11-03 16:53:56 -05:00
UnixNight b5ef5b8b64 Record Rocketship standalone package and validation results 2026-11-03 16:44:54 -05:00
UnixNight e77add5fdf Implement evidence-backed VR02 Rocketship flight and ownership 2026-11-03 16:42:09 -05:00
UnixNight 312efccb77 Add Give All Gadgets to the F1 Player menu 2026-11-03 14:30:05 -05:00
UnixNight a274670fe8 Recover Rocketship flight components against original-code probes 2026-11-03 11:09:16 -05:00
UnixNight c6eb1861cd Assess supplied jn-engine research and capture evidence 2026-11-03 10:42:14 -05:00
UnixNight c0acf58d9c Record Baseball package and standalone validation 2026-11-02 22:57:55 -05:00
UnixNight d6ca417e9e Implement Baseball aiming, pooled projectiles and VR07 targets 2026-11-02 22:54:19 -05:00
UnixNight 50fcb87d90 Record Bubble package and standalone validation 2026-11-02 17:01:21 -05:00
UnixNight 1ae5f4251c Implement Bubble controller, sprite and VR01 body behavior 2026-11-02 16:57:54 -05:00
UnixNight 9ea578492d Record Invisible package and standalone verification 2026-11-02 09:24:08 -05:00
UnixNight 1897dd2b90 Implement timed Invisible gadget and shared energy warnings 2026-11-02 09:21:56 -05:00
287 changed files with 49525 additions and 217 deletions

No files matched your search

+72 -4
View File
@@ -35,10 +35,29 @@ other agents' active changes. Keep updates concise, save detailed evidence to di
Use bounded endian-aware parsers, portable paths, clear C#, deterministic tests,
and explicit unmanaged ownership. Build frequently. Update `docs/progress.md`,
`docs/tasks.md`, `docs/decisions.md`, and compatibility evidence before transitions.
Current mode is user-requested gameplay/gadget implementation. On2026-10-27 the
user parked collision recovery and requested gadgets. This overrides the earlier
feature-expansion pause; retain evidence before gameplay assumptions. Preserve
the35a2a66 body milestone/0272f7b release notes and remaining C4/C5 gates for return.
Current priority (2026-11-05): user pauses gadget expansion and returns to Jimmy
movement stabilization. Preserve current movement as baseline; do not substitute
JN-Engine native/Godot movement. Use its original decompiler index only as leads,
verified with REA/authoritative originals. See docs/gameplay/jimmy-movement-stabilization.md.
The prior collision work is resumed where needed for movement; preserve the
35a2a66/0272f7b checkpoints and their source gates before broader body admission.
Controller checkpoint integrates108 native ground/air/facing/jump comparisons;
13 Jimmy source guards,26 movement/20 body groups and all five native SDL jump
aliases pass. Source pressure requires a real support polygon; lab/outside keep
capsule compatibility. The next bounded air-target/root-render bridge is now
implemented (docs/gameplay/jimmy-air-bridge.md):146 saved source observations
compare, including12 air targets and12 degree/14 hierarchical transforms. Target
dirty/Init and retained apply-owned pitch seeds stay separate from current Euler.
Modern local sole correction and final OMT render-decomposition precision remain
explicit; broader special/root-changing/dynamic contacts are next.27 contact
dispatch observations still do not establish live special callbacks.
Body publication/mode foundation now implements fresh previous/live XYZW,
independent source flags, retained context and post-landing payload ownership.
100 new complete original comparisons plus six bounded callback-state cases pass;
see docs/checkpoint/body-contact-implementation.md. Keep admission gated: actual
Jimmy hazards/climbs, multi-frame actor mode/facing/animation and dynamic/shared
scene context are still open. No automatic lab/outside solver replacement.
No Remote/new-gadget implementation until this movement priority is handled.
The initial architecture checkpoint is documented in docs/checkpoint/review.md; use the playable
69d0187 baseline as a comparison tool. Read
docs/checkpoint/README.md, coverage.md and implementation-plan.md before gameplay
@@ -46,6 +65,55 @@ changes. Current gadget controls/resources/primary-fire findings belong in
docs/gameplay/. Distinguish static recovery, implementation, port tests and original
runtime evidence. Main owns integration/runtime; gadget investigators have
exclusive named files, not shared directories.
Scooter feedback fixes: docs/gameplay/scooter-dismount-leveling.md and
scooter-pitch.md. Preserve dismount Euler copy; source4096E0 levels Goddard X/Z
in the bounded follow bridge. ScooterAudio adds47D9D0 positional frequency/history
after the unchanged engine formula; current shared listener includes parked/script
cameras.11 native facing +11 frequency traces,13 Scooter/2 audio/10 Patrol groups
and24 Python guards pass; both native input replays pass with zero validation
errors. Both packages identify cleanfccc0b9; standalone Linux repeats both scenes
with20 matching readbacks. Whole-original/audible Windows comparison remains open.
Latest gadget continuation: docs/gameplay/scooter-live.md. Scooter is live in
VR05 and outsideLEV1 through normal owned tile/F1. Separate C3DJEEP body and four
real wheel supports, source drive/input/impact/default camera, exact source-pivot
art, pitch-controlled engine and summon/contact mount/cleanup/RETURN are integrated.
53 copied-original observations match managed formulas;10-phase headless/native
Linux replays pass in both scenes, zero validation errors. The32-row debug Player
page fits ultrawide. Whole-original/native Windows comparison, modes2..20,
mouse/analog, dynamic pairs and arbitrary retained LOAD/save remain open. Goddard
follow is an opt-in bounded adapter in these scenes. Source/REA artifacts are under
artifacts/scooter-*-live; all ownership is primary. Package evidence is in the live
report. Both packages identify clean62c07a3, resources match, and standalone
Linux from /tmp passes both10-phase native replays with20 identical readbacks.
All303 Python+2 HUD/managed/36 main GPU regressions and539 original hashes pass.
Preserve parked Jimmy collision; Scooter's source callback is independent.
Grappler remains live boundedVR08; see docs/gameplay/grappler-live.md for113
original-component observations,13 managed/40 Python checks and9-phase SDL replay.
The user clarified orbit's remaining issue was inverted Left/Right; Left/A and
Right/D azimuth mappings are corrected, Up/Down unchanged. The historical orbit packages
identified clean70cba65; native input/resize/validation passes. See docs/orbit-camera.md.
Rocketship remains live in boundedVR02: source body/callbacks,
registration-ordered input, maneuvers/camera, original
driver/Goddard/flame resources and F1 grant.96 isolated original component cases
support the source contracts; full pair discovery, other levels, special mission/
hazard/RNG effects and whole-original/native Windows comparison remain open.
Its wall-impact material RGBA correction is docs/gameplay/rocketship-impact-render.md;
13 managed/22 Python checks and final native Linux flight replay pass.
Grappler source is in docs/gameplay/grappler.md. Friend
research assessment is docs/reviews/jn-engine-survey.md; use its decompiler leads
with REA/source checks, not its tuned C gameplay. All ownership has returned.
Preserve baseline69d0187 and parked35a2a66/0272f7b collision checkpoints. Latest
package provenance and validation are recorded in the live report.
Baseball continuation: docs/gameplay/baseball-implementation.md. Its20-slot
pool, hold/release aiming, original TIME art and boundedVR07 moving targets are
implemented; original dynamic pair discovery/other enemy consumers remain open.
Scooter historical recovery is docs/gameplay/scooter.md; live coverage is scooter-live.md.
Bubble's mode2,
original sprite and boundedVR01 source body/floor state are implemented and tested;
Invisible, ray/jetpack and shared energy state remain integrated. Other gadgets
and broader collision/camera/retained-helper behavior remain separate gates.
All current investigator ownership has returned to primary. Keep full enemy AI,
suppression globals, render state and original/native Windows verification distinct.
Use REA for original-binary investigations from now on, including delegated
investigations. Preserve its Evidence and cross-check relevant addresses/bytes;
+55 -5
View File
@@ -5,7 +5,13 @@ using C#/.NET 10, Silk.NET.Vulkan (Vulkan 1.3), and SDL3. Original files remain
untouched in `../Original`. Work is local; no remote operations or runtime online
services are used.
**Current direction: gameplay gadgets; collision recovery is parked.** The
**Current direction: stabilize Jimmy movement before more gadgets.** Keep our
playable movement baseline; JN-Engine's original decompiler index supplies leads,
verified with REA and authoritative component probes. The
[movement checkpoint](docs/gameplay/jimmy-movement-stabilization.md) records
controller/facing/jump corrections. The [air bridge](docs/gameplay/jimmy-air-bridge.md)
adds source airborne tilt, target-state ownership and full Euler rendering, with
explicit remaining render precision/body gates. The
[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
@@ -16,16 +22,26 @@ collision and shared camera state remain incomplete.
The user requested this change after milestone35a2a66/0272f7b. Gadget work uses
original controls, state and assets; the collision checkpoint remains available
to resume after this gameplay work.
VR04 now uses recovered static body response/support/friction with original-code
VR04 and the bounded VR01/VR07 tutorials use recovered static body response/support/friction with original-code
numeric references. Lab/outside retain the capsule until special contacts and
dynamic collision are recovered; see [body implementation](docs/checkpoint/collision-body-implementation.md).
**Current milestone: original gadget screen and playable shrink ray.**
**Current milestone: VR08 Grappler, VR02 Rocketship, Baseball, Bubble, Invisible, shrink ray and their gadget screen.**
Tab/Space selects owned gadgets and their practice levels; the default device
fires on Enter/Ctrl/left mouse and supports actual VR04 soldier shrink/restore
with original morphs and score effects. Other gadget effects remain incomplete.
with original morphs and score effects. Invisible uses the recovered recharge,
activation, blend flash, meter and cleanup rules; full enemy sensing/combat and
other gadget effects remain incomplete.
See [gadget implementation](docs/gameplay/gadgets-implementation.md) for recovered
rules, modern policies and the verification boundary.
The [Invisible continuation](docs/gameplay/invisible-implementation.md) records
the later implementation and shared energy-warning sounds.
The [Bubble continuation](docs/gameplay/bubble-implementation.md) adds its source
controller, original sprite, automatic/high bounces and VR01 floor behavior.
The [Baseball continuation](docs/gameplay/baseball-implementation.md) adds hold/
release aiming, original ball/TIME art and VR07's moving targets and trophy gate.
The [Grappler continuation](docs/gameplay/grappler-live.md) adds VR08 attachment,
shared body/contact state, source camera, rope/SWING/cursor and cleanup.
The runtime includes recovered camera/speech triggers, moving props, Carl/Goddard
patrol logic, pickups, objectives, the practice prompt, VR04 powered jumping and
@@ -66,6 +82,34 @@ jetpack state controls, camera obstruction, audio category mutes, objective/prac
controls and checkpoint save/load. **F3** toggles noclip: WASD moves/strafe, arrows
move/turn, Space/E rises, Ctrl/Q descends and Shift triples flight speed. Noclip
bypasses collision and contact triggers; reset or a new level disables it.
F1→Player also grants/selects Invisible, unequips it, and shows its timers and
targetability state. After selecting Invisible, allow7 seconds to recharge, then
fire without jump to activate for7 seconds at a fixed2-energy cost (tutorials
are exempt). Its last3 seconds flash before normal rendering returns.
F1→Player can also Give/Select Bubble. **Up or primary fire** accelerates, arrows
steer, and holding jump makes higher bounces. Tab/Space first unequips it; the
original sprite fades afterward. VR01 uses source body/floor rules; lab/outside
collision remains provisional.
F1→Player also has **Give/Select Baseball**. Hold **Enter/Ctrl/left mouse** to
aim, use **Up/Down** to change elevation and **Left/Right** to turn, then release
fire to throw. Practice on its owned tile opens VR07. The twenty-ball pool,
target respawn and original aim display are implemented; full enemy combat and
original dynamic contact scheduling remain incomplete.
**F1 → Player → Give All Gadgets** grants all eight gadgets without changing
the equipped gadget. Close F1, then use Tab/Space to select one.
Rocketship flight is available in **VR02**: select its Practice tile, then equip
it there or use **F1 → Player → Give/Select Rocketship**. Up/right mouse accelerates
and climbs; Down brakes and descends; Left/Right banks. **Enter/T** performs a
180-degree turn, **R** barrel rolls, and Tab/Space unequips. R resets normally
when unmounted. Source camera, aircraft body and Jimmy/Goddard/flame visuals are
included. Other levels and special mission/hazard sequences remain unfinished.
Grappler is live in **VR08**. Select its Practice tile, then equip it there or
use **F1 → Player → Give/Select Grappler**. Aim Jimmy toward a surface until the
target appears; **Enter/Ctrl/left mouse** attaches and reels, arrows steer,
and **Shift/Insert/right mouse** detaches when fire is released. Tab/Space
unequips. Original rope, SWING morph, cursor, sounds, camera and contact response
are connected. Other levels and special camera/contact policies remain open.
**F2** toggles a compact live debug overlay without pausing play. It shows frame
timing, position/velocity, movement, control/force state, tasks, camera/clipping
@@ -89,7 +133,7 @@ equipped, the first press unequips it. Use the mouse or arrows to point, then
Enter/Ctrl or a mouse button to select. Escape or Return closes the screen.
Practice Mode followed by an owned gadget enters its original tutorial directly.
The screen scales uniformly on widescreen and pauses port gameplay while music
continues. Other gadget selection art is present; their special behaviors remain
continues. Other gadget selection art is present; the remaining special behaviors stay
future work. F1's jetpack availability control also controls shrink-ray ownership.
The pickup's original objective calls its jump action the **jet pack**. Its
@@ -210,3 +254,9 @@ The collision continuation adds a probed
[source sphere kernel](docs/checkpoint/collision-response.md) and integrates the
[overhead response](docs/checkpoint/ceiling-wrapper.md); full capsule replacement
and [shared camera handoff](docs/checkpoint/camera-handoff.md) remain open.
Scooter is implemented in VR05 and outside LEV1. Select its owned tile with
Tab/Space (or F1 → Player → Give/Select Scooter), then walk into the summoned
vehicle at Goddard. Up/primary fire accelerates, Left/Right steers, Down brakes
then reverses, jump jumps, Tab/Space unequips. F1 Give All Gadgets also grants
its normal tile. Source, verification and remaining limits: [Scooter](docs/gameplay/scooter-live.md).
+8
View File
@@ -250,3 +250,11 @@ The wall response is still the port's swept sphere, not the original47BD80 solve
Visuals use those actor roots without an additional sole-based correction.
The remaining raw-sole/root clearance difference is documented in collision notes.
Primary added a tenth test group for Carl's profile, speed, yaw factor and state9.
2026-11-04 Scooter follow-up: the opt-in VR05/LEV1 Goddard follow bridge now
applies recovered4096E0 pitch/yaw/roll smoothing toward its ordinary supported
follow target, rather than preserving dismount tilt indefinitely. Cleanup keeps
the full source Euler handoff. Nine active copied-original angle cases plus two
gate observations and actual tilted-dismount tests support this correction;
general patrol/Carl and airborne target selection retain their earlier limits.
See [scooter-dismount-leveling](../gameplay/scooter-dismount-leveling.md).
+113
View File
@@ -5,6 +5,44 @@ SDL3 for platform windowing, input and audio. Linux x64 and Windows x64 are
equally required. Source is `src/GamePort/`; root executable csproj allows
`dotnet build` and `dotnet run` from GamePort. No runtime network dependencies.
`Scooter` is a separate registered C3DJEEP in VR05/LEV1, owning body, wheels,
steering/impact/jump clocks and camera state. Selection summons at the companion;
strict contact transfers raw control. PlayerSceneBinding runs body, player/input,
vehicle frame/passenger-copy, then wheel phase. OrdinaryBodyPhysics exposes the
wall callback before floor/friction so contact speed writes affect the same pass.
ScooterVisuals uses exact unit-scale body/wheels/rider morphs; SceneAudio maps
source engine frequency to SDL stream ratio. Goddard follow is opt-in for these
scenes. Scene-local lifetime, provisional moving doors and fixed cadence remain
explicit boundaries. See gameplay/scooter-live.md.
`BaseballGadget` keeps pending/saved/displayed aim, camera adjustments and20 owned
`BaseballProjectile` entries distinct from equipped raw mode. Cleanup hides its
UI/restores the companion but retains the latch and flying balls. `SceneBaseballs`
steps bodies before controller input and target frame state afterward; six duplicate
3TAR tags retain source-instance identities. The source body has an explicit ball
profile for delayed landing impulse, prevent-lowering=false and reflection/friction.
Sphere-pair discovery remains a declared bounded adapter. `BaseballVisuals` and
`BaseballAimOverlay` append source Canv2/253 and TIME16-pixel glyphs using the
existing world/overlay pipelines and uniform viewport. See baseball-implementation.md.
Bubble adds separate `BubbleMotion` input/apply, `BubbleEffect` owned clock and
`BubbleVisuals` original canvas. LabSimulation keeps body factor, current maximum,
movement mode and captured sprite root distinct. The source static factory also
admits VR01; its retained support ID feeds bounded `Vr01FloorState` before the
controller, independently of current support/control. `PlayerAppearance` stores
material writes from Invisible alpha/blend requests and late lava RGBA, preserving
source phase order instead of rebuilding one effect's alpha every render.
See gameplay/bubble-implementation.md for coverage and remaining gates.
The Invisible continuation adds `InvisibleGadget` in Jimmy's post-movement wrapper
phase, separate from input identity. `PlayerSceneBinding` supplies raw-any-control,
handles equip/companion flags and receives a named-Jimmy cleanup event from CAM/
initial MCA, distinct from raw-owner preparation. `PlayerGadgetMaterial` changes
the existing atlas draw; `InvisibleMeterOverlay` loads original Canv21/22 and
uses shared uniform viewport scaling. `PlayerEnergy` is application-session owned
across scene rebuilds, preserving scalar/warning latch separately from TSK.
See gameplay/invisible-implementation.md for exact coverage and remaining gates.
The first gadget slice separates UI display selection from the equipped raw mode.
`GadgetScreen` owns group0 panel state/hit regions; `GadgetMenuOverlay` loads54
original canvases and applies shared uniform640×480 viewport/pointer transforms.
@@ -69,12 +107,32 @@ avoids a Python runtime dependency in native packages. Mesh draw ranges omit nul
materials following the original renderer, while retaining their geometry. Default
normal atlas and morph transforms are supported by binary/duplicate-asset evidence.
`OriginalBodyPhysics` now retains current/previous Vec4, anchor and independent
integration/support/collision/world-response/alternate modes. World callbacks see
live state; fresh full-point equality controls candidate publication. Landing
publishes floor root/anchor/acceleration before37C, then restores cached velocity
and supported=true. Inactive paths preserve the prior per-body collision context.
This is a bounded foundation for special callbacks, not automatic scene admission;
see [body contact implementation](checkpoint/body-contact-implementation.md).
`Game/LabSimulation` supplies the no-gadget walking/jump checkpoint, using recovered
speed/yaw/impulse/airborne/camera formulas. `FixedStepClock` supplies a deliberate
60Hz port policy independent of rendering; original invocation cadence remains
unverified. SDL events feed held keyboard/mouse state; focus/minimize clear input
and pause simulation, while C pauses for inspection and R resets the start area.
The Jimmy movement checkpoint uses `JimmyGroundMotion`/`JimmyAirMotion` for
source input and velocity publication, `JimmyOrientation` in the base phase
before control gating, and `JetpackBurst` for the controller/effect state tables.
Keyboard-turn latch and destination Euler/dirty are retained independently of
current Euler. Init clears the target/dirty while apply-owned air pitch seeds
survive bounded route loads. Ground pressure requires a real source-body support
polygon; the capsule does not manufacture one. JimmyRenderTransform now supplies
the full Euler hierarchical basis, source degree quantization and a modern local
sole correction around the logical root. Final OMT model decomposition remains
a separate precision gate. See
[movement stabilization](gameplay/jimmy-movement-stabilization.md).
`SceneCollision` sweeps/slides a vertical capsule against retained original scene
triangles, including invisible proxies, and clips the chase camera with a sphere
sweep. Solver/masks/radius/pivot are explicit approximations. The physical position
@@ -242,3 +300,58 @@ and queued work are not cleared by a transform setter. The original full wrapper
registry, body response and morph clock are still not reconstructed by this bridge.
See checkpoint/control-phase-implementation.md. REA tooling is separate from
runtime architecture; setup/provenance are in rea.md.
## Owned aircraft
Rocketship composes RocketFlight, RocketMotion, RocketOrientation and the source
static-body/camera adapters in boundedVR02. PlayerSceneBinding schedules ship and
Jimmy bodies before the fresh/retained input/normal boundary, transfers control
to the registered3ROC and synchronizes the still-physical passenger afterward.
Raw control and inventory permission remain distinct from named-Jimmy scripted
cleanup. Release disables ship integration, stops engine/fire, retains rider root
and shared eye, and returns Jimmy to FALL. Four dedicated source-pivot morphs
replace the standing player draw while mounted. Source/probe/port validation and
unresolved lifetime/pair/camera boundaries are in gameplay/rocketship-live.md.
Grappler's distinct source ownership and
geometry/material/swing contract is in gameplay/grappler.md; it is not a simple
player movement mode or nearest-tag interaction.
GrapplerMotion implements the isolated attachment/reel/damping arithmetic and
independent fire/jump detach predicate, compared with30 copied-original cases.
It owns no body/ray/camera/helper lifetime and is not called by live simulation;
integration gates and retained source/REA findings are in gameplay/grappler-component.md.
GrapplerGeometry adds source aim early-return/rope-constraint/post-base contact
rules. GrapplerRay binds the verifiedVR08 static profile and captures selected
polygon/material with the hit via OriginalCameraRay.TraceSelectedGeometry, which
is independent of camera debug disabling. No live simulation calls these yet.
The active-input return must gate later primary dispatch while normal Jimmy frame
publication continues. Shared collision context/base contact and helper/camera
ownership remain integration work; see gameplay/grappler-query.md.
## Live bounded VR08 Grappler (2026-11-04)
The component-only gates described above are now integrated for VR08. Main owns
GrapplerMemory across Run/scene reconstruction; LabSimulation owns the scene's
GrapplerGadget and body/camera state. Normal physics retains its sphere context,
then fresh controlled input runs camera followed by attached movement/aim/fire;
ordinary player apply still runs after an input early return. Retained entry
moves input after ordinary apply, preserving the existing registration boundary.
Attached Move reuses the preceding physics context, including stale last polygon;
support/ray metadata is separate. Both normal and attached wall callbacks reach
the recovered post-base detach rule. No new body integrator or direct-pull path.
Camera locals retain their source writers; GrapplerCamera consumes them through
movement-mode-specific follow branches, obstruction and old shared-eye aim.
GrapplerVisuals appends exact prepared rope/SWING/target resources and draws at
source pivots. It applies the retained first-length scale to base rope geometry,
uses pre-collision desired root and replaces the standing draw only during SWING.
The existing generic sprite-facing bridge remains a documented rendering policy.
PlayerSceneBinding handles selection, companion eligibility and authored cleanup.
RETURN explicitly releases selected Jimmy before staging; ordinary scene teardown
releases scene-local helpers/sound before SceneAudio disposal as a modern safety
boundary. Scalar memory survives; original TSK serialization is not expanded.
F3/R debug cleanup is separate from source ownership semantics. See
[coverage and verification](gameplay/grappler-live.md) for113 component observations,
13 live managed groups, native replay and excluded shared/special-level behavior.
@@ -0,0 +1,110 @@
# Body callback ownership implementation
2026-11-05. Continues Jimmy movement after the air/render checkpoint27be8ed.
Current lab/outside capsule and all special-contact admission gates are preserved.
This implements the body publication/mode prerequisites, not new climb/hazard
mechanics or a complete original body in every level.
## Evidence and implementation
[Root publication](body-root-publication.md) records19 new original component
cases using actual copied479D20/47B4B0/kernel. [Body modes](body-modes.md) records87
new observations using full479D20/support/friction and a synthetic dispatcher.
Both reuse retained REA Evidence and guard original spans/offsets/provenance.
`OriginalBodyState` now retains finite live-root W, source previous Vec4, support
anchor and independent `BodyModes`: integration210, support1C8, collision220,
world response1D0 and alternate228. Nullable modes mean the ordinary constructor
defaults; the explicit point constructor supplies W1. Scooter reset now uses that
point constructor instead of zero-initializing W through default(struct).
`OrdinaryBodyStep.PreviousPosition` deliberately stays the frame-entry XYZ
diagnostic consumed by the existing provisional dynamic adapter. It is not used
as a substitute for the newly retained previous Vec4.
- Support clear precedes the integration gate. Inactive integration preserves
roots, anchor, pending work and the existing collision context, then returns.
- The geometry argument/global getter remains independent of body modes. Global
geometry-off follows the recovered gravity/support policy. A scene getter
optionally models support's fresh global read after callbacks.
- World response-off copies current root to previous and translates, retaining
gravity/impulse, optional support/friction and the previous static context.
- Collision-off translates or holds according to228, preserves previous root,
skips support/friction and still reaches suppression. Neither unclipped branch
acquires the world branch's−25000 candidate clamp.
- World callbacks now receive the live entry root, not the tentative clipped
candidate. They may edit live/previous independently. Fresh XYZW equality
controls publication of the precomputed candidate and its original W. Callback
roots rejected by that barrier receive neither old fallingY nor candidate clamp.
Changing both roots to equal still permits the old candidate to overwrite them.
- Support uses fresh live/previous XYZ after publication/rejection. Landing37C
observes the floor root, anchor and zeroed vertical acceleration but old velocity.
Callback root/anchor/acceleration/impulse/modes survive; source cached VX/Z plus
Y0 and supported=true are published afterward. Friction/suppression read current
speed/motion and retain their own ownership.
- The existing wall hook remains wall-only. Ordinary/profile ceiling/reflection
behavior is kept separate. Static context resets only in the world branch;
other branches retain it, reporting zero new traversal work.
`tests/GamePort.BodyOwnershipTests` compares81 complete native mode/landing outputs
and19 root outputs. The17 native root-isolation cases no-op support; the managed
support gate mirrors those publication outputs, while two cases execute actual
support in both implementations. For six native synthetic-dispatch mutation cases,
a real wall delivers the managed callback: owned state/flags/branch continuation
compare, while intentionally different clipped XYZ is not claimed as numeric
conformance. All100 complete comparisons and six state comparisons pass.
Existing20 body,13 Scooter and13 Grappler groups pass in initial targeted runs.
Artifacts: artifacts/body-contact-integration/{ownership-initial,body-initial,
scooter-initial,grappler-initial,build-initial}.log. The full regression, native and
package results are recorded below as verification finishes.
## Remaining integration boundary
No real Jimmy material120..129/110..119/FENCE/LADDER callback is enabled here.
Animation acceptance/end/fallback, hazard/impulse updater4255C0, successful ray
filters, control/facing/action state, dynamic eligibility and scene-wide shared
collision globals still need separate recovery and runtime proof. No callback is
classified ordinary merely to bypass constructor rejection.
LabSimulation still reconstructs the admitted ordinary body each pass; actual
multi-frame special modes must persist actor state when their callbacks are
integrated. Vehicles/projectiles already retain their body records. The per-body
static context remains a bounded approximation of original scene-global ownership.
Radius/factor/friction/suppression arguments remain fixed during the admitted
pass; reentrant/nested body updates and other mutable getter side effects are not
established by these finite probes. Modern F3 noclip is a separate policy.
The root record adds no TSK/save fields or runtime original-code dependency.
Physics remains independent of raw player control. The existing rendering/air
state and upright local alignment from the previous checkpoint are preserved.
## Final regression and native verification
Full scripts/test.sh exits0:333 Python tests,2 HUD extraction checks,45 managed
projects,36 main Vulkan render completions (zero validation errors), original
asset decoders, lab/underground routes, saves, animation and SDL dummy audio
lifecycle, plus539 unchanged original hashes. The main restore/build emitsNU1900
warnings for unavailable vulnerability metadata; no compilation errors occur.
Packaging uses cached dependencies with NuGetAudit=false. Logs and structured
summary: artifacts/body-contact-integration/full-tests.log and validation-summary.json.
Native Linux GTX1070/private Xvfb1920×1080 passes both10-stage Scooter replays,
right-mouse VR04 jetpack, Shift lab walking and control phases with received SDL
input/resize and zero Vulkan errors. All five Jimmy final/airborne captures match
the preserved air-bridge baseline byte-for-byte; baseline-readbacks.json records
that comparison. Default gameplay/scene collision admission is preserved.
## Packaged checkpoint
Both self-contained platform packages identify clean runtime commit
`c9d0c5be59eedba3a92dcd46d1beb96b2e9e941a`, source_dirty=no.519 original copies
and4271 prepared scene/resource files match in each; package-identity.json records
binary/build identities. Standalone Linux from /tmp with SDK variables unset
passes both Scooter scenes and Jimmy walking/jetpack. All27 stage/final readbacks
match development exactly, with zero enabled Vulkan validation errors. Logs:
package-{scooter-vr05,scooter-outside,walk,jetpack}.log and package-readbacks.json.
Post-package audit verifies all539 originals unchanged. Windows cross-publishing
and resource checks remain separate from pending native Windows and original
whole-game comparison. Documentation commits after the runtime revision record
validation; package BUILD-INFO.txt retains exact source provenance.
+131
View File
@@ -0,0 +1,131 @@
# Body modes and post-callback ownership
2026-11-05. This closes a bounded prerequisite for Jimmy's special contacts; it
does not enable new terrain/climb policies or replace the lab/outside capsule.
The authoritative EXE SHA256 is
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
JN-Engine gameplay is not the oracle. Retained REA instruction Evidence
`ev_0d64cc58fa8f5573fc8e61e0f2c20e36288099212bd2257d3a3121361fd6c904`
is artifacts/jimmy-movement-audit/rea-original-disassembly.json; the original
479D20 procedure Evidence is
`ev_5439072b32ae9f9208795ad2b07bc524e2407b46da487072fb3dfd8c10e7c4b0`.
No unchanged failed Ghidra selector was repeated. This investigation reuses those
instructions and independently guards the complete body/support/friction spans.
## Source branch and state map
Addresses are EXE VAs; raw offsets equal VA−400000 in these PE-mapped spans.
Slot numbers refer to the body/game interface, Jimmy complete object+C0.
The generic data fields and initialization are separately recorded in
[body composition](collision-body-composition-source.md).
| Source VA / raw offset | Recovered phase |
|---|---|
|479D2E/479D34 /79D2E/79D34|Read supported218; cache prior support695D49 even if integration will reject.|
|479D3D..479D4E /79D3D..79D4E|If support handling1C8, clear supported21C(false). Otherwise preserve the previous supported flag.|
|479D58..479D60 /79D58..79D60|Integration210=false returns after those effects: root/previous/anchor, impulse, velocity, acceleration, angular velocity and static context remain unchanged.|
|479DDA..479E54 /79DDA..79E54|Global geometry4F69E5=true publishes anchor(0,−25000,0). False publishes supported=true, anchor(0,currentY,0), acceleration(0,+800,0), velocity(oldX,0,oldZ). Pending impulse still applies later.|
|479E63..479FD2 /79E63..79FD2|Rotate by angular×dt; consume impulse once; add acceleration then gravity separately; compute displacement from final velocity.|
|479FD6 /79FD6|Collision220 gates the post-integration branch.|
|479FE8 /79FE8|When collision=true, world-response1D0 selects clipping versus direct translation. This is not the integration/global-geometry gate.|
|47A038..47A096 /7A038..7A096|World branch alone resets last polygon/nearest face130000/nearest edge radius/auxiliary; captures full live root into previous2FC, then dispatches world traversal.|
|47A123..47A1C4 /7A123..7A1C4|World path compares fresh previous/live Vec4; equality permits candidate clampY≥−25000/publication314. See the independent root-publication investigation.|
|47A1CC..47A220 /7A1CC..7A220|Collision=true/world-response=false copies live Vec4 to previous, then translates31C(displacement). No static-context reset, world dispatch or−25000 clamp.|
|47A22A /7A22A|Fresh support1C8 read after world callback/publication/direct translation; true calls47B890.|
|47B890 /7B890|Support independently rereads global geometry. False skips its query/result publication; it does not retroactively cancel the gravity already consumed earlier in479D20.|
|47A241..47A25A /7A241..7A25A|Fresh published-speed268==0 enters friction47A330. That helper reads current supported218 and only damps when supported and magnitude>0.|
|47A264..47A28E /7A264..7A28E|Collision=false reads alternate228: false translates31C; true holds root. Both skip previous-root copy, support and friction.|
|47A294..47A31D /7A294..7A31D|All integrated branches reach suppression. Angular and linear quick magnitude×scale≤.1 clear the respective velocity; linear additionally requires a fresh published268==0. Rotation already happened, even if angular velocity is then cleared.|
A support-disabled body may retain supported=true, including while moving upward.
If collision is enabled, that stale-but-owned supported state still allows
friction. Disabling support is not permission to clear it unconditionally.
Collision-disabled bodies skip friction even when global geometry-off forced
supported=true. World-response-off retains integration, gravity, impulse,
optional support and friction, plus the prior static context. F3 noclip remains a
separate modern policy.
## Flag mutation timing
The source does not reselect a branch already entered. Synthetic world callbacks
that change integration210, collision220 or world1D0 still finish the selected
world publication/support/friction path in the current call. The changed flags
persist for a later call. Support1C8 is read fresh after world dispatch, so changing
it there suppresses the current support query. Global geometry is also read fresh
inside support; changing it during world work suppresses support while retaining
the already integrated gravity/acceleration and earlier anchor.
For example, the final native fixture's world mutation5 changes global geometry
to false after integrating fallingVy−213.333328. The output still has that Vy,
acceleration0 and anchorY−25000, with no support query; it is not the early
geometry-off result with acceleration+800/support=true/vertical cancellation.
A mutable scene-global getter can represent that read boundary; embedding a new
per-body geometry flag would misstate its ownership. No live original writer or
new gameplay use of that global is inferred from the synthetic callback.
## Landing37C: writes before and after callback
47BB10..47BB4B publishes anchor, supported root through318 and acceleration
(oldAx,0,oldAz). It checks prior supported695D49 and invokes37C at47BB5E only on
an unsupported→supported transition. The callback observes the new root/anchor/
zeroed vertical acceleration but old live velocity and supported=false.
47BB64..47BB80 then overwrites velocity with **cached pre-callback VX/Z and Y0**,
and writes supported=true. Support pointers34C/33C follow at47BB91/47BBA1.
Consequently:
- Callback velocityXYZ and supported edits are overwritten, even though the
callback legitimately owned them during its invocation.
- Callback root (including W), acceleration, anchor and pending impulse survive.
Pending impulse is not consumed a second time; its next owner is a later body pass.
- Modes and published speed survive. Published speed is read fresh by friction;
changing it to100 skips damping in the same call.
- Callback angular velocity survives into friction/suppression; with(7,123,9),
friction.8/dt1/60 yields approximately(6.906667,121.360001,8.88).
- Changing support/collision/integration modes during37C does not rerun preceding
branches or stop the support function's final supported=true publication.
The native payload cases verify each item. They do not execute Jimmy's real37C
(which is an inherited no-op), an animation event or a special Player callback.
They establish generic phase ownership for safe composition.
## Copied-original fixture and verification
`tools/binary/body_modes.py` reuses the existing read-only body/support range and
relocation collector. Generated sources are separated from the Wine work/prefix
under artifacts/body-modes/generated. The probe executes full copied479D20,
47A330 friction and47B890/support queries against the existing synthetic floor.
Its47B4B0 world dispatcher is deliberately substituted: it adds the supplied
movement to the candidate and performs selected synthetic flag mutations.
Angular334 is a simple additive synthetic virtual, not proof of generic angle
normalization. The copied original OMT quick-magnitude export is retained.
No real world traversal, actor, loader/game entrypoint, animation or audio runs.
The final isolated Wine32 run exits0 with BODY_MODES_COMPLETE.87 observations:
64 combinations of integration/support/world/collision/alternate/global geometry;
6 world-mutation cases;11 genuine landing-mutation cases;6 no-clamp/suppression
extras. Source, generator/shared harness/generated EXE/log hashes and all numeric
vectors/counters/event traces are committed in tests/body-modes-reference.json.
The initial landing setup had prior support=true and therefore correctly emitted
no37C; it was corrected to unsupported before using those cases as callback
evidence. A regeneration attempt into the parent directory containing a Wine
prefix was rejected by the symlink guard; separate generated output resolved it.
Only the final87-case run is retained as the committed conformance fixture.
Four Python groups pass: identity/ranges/provenance, all64 branch/counter/context
combinations, callback/suppression observations and generated-output separation.
Run from GamePort:
```
python3 -m unittest discover -s tests -p test_body_modes.py -v
python3 tools/binary/body_modes.py ../Original --generate-probe artifacts/body-modes/new-generated
```
Parent owns managed integration and its conformance claim. Source-world mutation
outputs depend on the synthetic unclipped dispatcher candidate; a real-wall
adapter may compare branch/state invariants without claiming candidateXYZ parity.
All64 flag cases,11 landing payload cases and6 no-clamp/suppression cases permit
full numeric body comparison under the corresponding floor/empty-world fixture.
Contact metadata, root-changing Vec4 publication, special animation/control and
dynamic body eligibility remain independent gates. Whole-original gameplay and
native Windows movement are not established by these component calls.
+135
View File
@@ -0,0 +1,135 @@
# Contact-owned Vec4 root publication
2026-11-05. Follow-up to [body composition](collision-body-composition-source.md)
and [special contacts](jimmy-special-contact.md). This closes one body-state
boundary; it does not enable special contacts or replace the lab/outside capsule.
Original Neutron.exe SHA256:
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
## Source structures and phases
All VAs below are independently PE-mapped; raw offsets equal VA−400000 for these
ranges. REA's retained complete EXE disassembly is
`ev_0d64cc58fa8f5573fc8e61e0f2c20e36288099212bd2257d3a3121361fd6c904`,
artifacts/jimmy-movement-audit/rea-original-disassembly.json. Earlier body Evidence
`ev_5439072b32ae9f9208795ad2b07bc524e2407b46da487072fb3dfd8c10e7c4b0`
and its prototype limitations remain in the composition report. No unchanged
failed Ghidra selector was repeated. Instructions establish the following facts;
original component execution corroborates their numeric consequences below.
Jimmy uses the game interface at complete+C0. **Data** previous-root Vec4 is
interface1F4/1F8/1FC/200 (complete2B4..2C0); current-root Vec4 is
interface214/218/21C/220 (complete2D4..2E0). These are not same-numbered virtual
slots. Vtable4A373C binds previous getter2F8→4721E0, previous setter2FC→472240,
live getter310→472300 and Vec4 setter314→472360. Each getter copies all four
floats into the caller buffer.314 is a plain four-float store; unlike XYZ318's
472330 wrapper, it does not immediately call3DC. Full logical/render publication
ownership therefore remains distinct from the body-state store.
| VA / raw offset | Recovered operation |
|---|---|
|47A084 /7A084|After integration and before world dispatch, copy current full Vec4 into previous2FC. A stale initial previous root does not survive this boundary.|
|47A0D6 /7A0D6|Positive displacementY:47B4B0 receives fullXYZ.|
|47A10F..47A11F /7A10F..7A11F|NonpositiveY:47B4B0 receives XZ/zeroY, then add the original already-computed fallingY to the **candidate**, after dispatcher/contact returns.|
|47B80F /7B80F;47B82E /7B82E|Dispatcher terminal374/370 receives actor/normal/polygon, not the candidate pointer. The bounded dispatcher call closure has no actor310/314/2FC root publication before those callbacks. It modifies the separate candidate.|
|47A12C /7A12C;47A13D /7A13D|After dispatch/contact, read fresh previous2F8 and then fresh current310 into separate stack buffers.|
|47A143..47A181 /7A143..7A181|Compare X,Y,Z,W. Only equality through all four comparisons reaches candidate publication.|
|47A187..47A1C4 /7A187..7A1C4|Only the permitted candidate has Y clamped to−25000, then full Vec4 is stored through314. A rejected callback-owned live root is neither displaced nor clamped here.|
|47A22A..47A235 /7A22A..7A235|Support eligibility is read afterward. Support47B890 can run even when publication was rejected; it reads current/previous afresh.|
For admitted finite values, the useful projection is:
```
previous = live // world branch entry
candidate = dispatch(entry, full or XZ delta)
if falling: candidate.Y += precontactDelta.Y
previousNow = getPrevious(); liveNow = getLive()
if previousNow.XYZW == liveNow.XYZW:
candidate.Y = max(candidate.Y, -25000)
setLive(candidate) // candidate W, not callback W
supportIfEnabled() // uses current/previous now
frictionAndSuppression() // source state remains independently owned
```
This is not `callback changed Position => skip`: changing **both** previous and
live to equal values permits the old candidate to overwrite that change. Changing
only previous can reject publication even when live XYZ stayed at entry. Changing
only W can reject it even when all XYZ match. The initial entry root remains a
useful diagnostic, but must not substitute for the fresh source previous record
when the support phase runs.
## Original execution and observations
The generated probe executes full copied479D20, real47B4B0/grid/kernel and, in two
cases, real47B890/support. It reuses the independently guarded
body_step_probe.c mapper and synthetic virtual/body/grid contracts. A broad
synthetic vertical wall produces one actual terminal374 contact per case.
The custom contact mutates body records; it is not a recovered climb/hazard
mechanic. A wrapper at the support CALL either logs/no-ops to isolate candidate
publication or calls the unchanged original47B890. No game entrypoint, script,
animation, audio or GPU is executed. Original files are not modified/executed in
place; the existing reference_capture sandbox mounts only a separate copied
installation, disables networking and uses a generated Wine32 prefix.
19 final cases exit0 and print BODY_ROOT_PUBLICATION_COMPLETE. Native output,
capture.json, generated source/header and source hashes are under
artifacts/body-root-publication/. The committed fixture is
`tests/body-root-publication-reference.json`; its input/flag schemas and source,
shared harness, probe executable and output hashes are recorded. Build output is
kept in build/ separately from the Wine prefix: output-symlink protection
intentionally rejects generating over a directory containing prefix symlinks.
Representative observations (entry=(0,20,20,1), radius10, factor1.265,
velocity=(0,−120,−900), dt1/60):
| Contact action | Final live / previous effect | Publication |
|---|---|---|
|None|Live(0,17.7777786,10,1)|Allowed; original gravity and old falling delta applied.|
|Change liveX to100|Live(100,20,20,1), previous remains entry|Rejected; no old fallingY is added to live.|
|Change previousX to100|Live remains entry|Rejected even though live itself did not move.|
|Change liveW to2 or previousW to2|XYZ remains entry; changed W is retained|Rejected.|
|Set both XYZ to(101,250,303)|Old candidate overwrites live; previous remains(101,250,303,1)|Allowed because fresh roots are equal.|
|Set both W to2|Old candidateW1 overwrites liveW; previousW2 remains|Allowed; retaining callback liveW would be incorrect.|
|Set liveY to−30000|Callback-owned liveY remains−30000 in isolated-support case|Rejected, so candidate clamp does not clamp live.|
|EntryY−26000, no root mutation|LiveY−25000|Allowed candidate is clamped.|
|Entry previous=(999,999,999,3)|Contact sees entry previous=(0,20,20,1)|World branch resets previous before callback.|
The unchanged upward case endsY23.1111107; upward liveX/W mutations reject just
as downward ones do. `callback_motion` consumes an initial impulse30 before the
contact (seenVy≈−103.3333), then the contact writes velocity(9,8,7),
acceleration(4,5,6), pendingImpulseY77. Those new fields survive. The root still
uses the precontact falling delta and endsY18.2777786; the new positiveVy8 is not
integrated again during this pass.
Event strings corroborate ownership: C=terminal contact, R=fresh previous read,
L=fresh live read, P=candidate Vec4 publication, S=support CALL. Permitted cases
are `CRLPS`; rejected cases `CRLS`. The two original-support cases continue
`CRLSRL`, proving support reads both records after rejection. With contact-owned
live=(101,5,303,1), real support raises rootY12.6499996, zeros Vy, sets support
and emits one landing. Therefore rejection is not a blanket return from physics.
## Verification and implementation boundary
Four Python groups pass: original identity/ranges/12 publication anchors/four
bindings/four root leaves; all19 saved boundaries and call ordering; generator/
shared-harness provenance; original/output/symlink isolation. Commands:
```
python3 -m unittest discover -s tests -p test_body_root_publication.py -v
python3 tools/binary/body_root_publication.py ../Original --generate-probe artifacts/body-root-publication/build
i686-w64-mingw32-gcc -O0 -I tools/binary -I artifacts/body-root-publication/build artifacts/body-root-publication/build/body_root_publication_probe.c -o artifacts/body-root-publication/build/body_root_publication_probe.exe -lm
python3 tools/recon/reference_capture.py --asset-probe --probe-executable artifacts/body-root-publication/build/body_root_publication_probe.exe --probe-success BODY_ROOT_PUBLICATION_COMPLETE --seconds 15 --output artifacts/body-root-publication/probe
```
Parent owns runtime integration and managed conformance. Preserve live Vec4 W and
fresh previous Vec4; call a contact with live root state rather than candidate.
After it returns, compare those records before applying candidate/clamp. Keep
callback velocity/acceleration/queued impulse, and pass fresh previous into
support. A legacy entry-position diagnostic may remain a distinct output.
Confidence is high for these guarded finite component cases. Nonfinite/x87
unordered comparisons, arbitrary callback-driven flag/radius/material mutations,
actual special animation handlers and their root/previous policies, real dynamic
pairs/shared context, whole-original movement and native Windows gameplay remain
separate gates. This report makes no lab/outside source-body admission claim and
changes no runtime/shared documentation or existing fixtures/tests.
+21
View File
@@ -10,6 +10,26 @@ Address details/PE offsets and source-byte extractors are in the linked reports.
**M**=managed port regression, **R**=port runtime. No row has full original-game
runtime comparison. Coverage does not mean implementation completeness.
2026-11-05 movement continuation: [Jimmy stabilization](../gameplay/jimmy-movement-stabilization.md)
supersedes MOVE/JET arithmetic details below. Ground, air and control-independent
full-axis facing now have108 native component comparisons including the jump
suffix. COLL keeps its admission gate: real support polygon pressure is live in
the source body, while lab/outside retain capsule compatibility.27 special
contact dispatch and12 air-target observations expose remaining gates; they do
not certify special callbacks or the ordinary air-pitch visual bridge.
The following [air-target/render continuation](../gameplay/jimmy-air-bridge.md)
implements ordinary pitch/roll targets, dirty/Init and retained seed ownership,
full current Euler publication and source hierarchical model rotation.146 native
observations now compare with managed components. The model-local sole correction
is modern; exact final OMT render decomposition and broad collision remain open.
[Body contact ownership](body-contact-implementation.md) now closes the finite
current/previous XYZW barrier, independent body modes, context lifetime and landing
payload ordering.100 new complete original comparisons and six callback-state
comparisons pass. Special callback mechanics, actor mode persistence and scene-wide
dynamic/shared context remain separate gates; lab/outside capsule is preserved.
| ID / system | Recovered contract / anchors | Port implementation | Evidence / remaining gap | Next bounded action |
|---|---|---|---|---|
| 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. Uncontrolled body/fire now continue while movement/input are gated. Other systems remain grouped; fixed60Hz policy. | S/M/R. Controlled player partial order implemented; bounded raw-owner preparation implemented; full wrapper/registry/cadence open. | C3 continue other callbacks and morph/control phases; C4 support/response remains separate. |
@@ -27,6 +47,7 @@ runtime comparison. Coverage does not mean implementation completeness.
| INVENTORY | PostLoad common prefix enables eight owned gadgets4→1, then VR01..08 disables1→4; full tail re-enables the practice gadget. LV1B disables1/7; other wire values 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 other level tails remain incomplete; bounded route mode/hold/fire carry is implemented. | 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. |
| SCOOTER |4211A0/412A90 owned vehicle/4 children;465220/465830 drive/input;467080 post-normal wheel support;421910 impact;4130A0 camera;4281B3 cleanup. | Now live VR05 and outsideLEV1, normal tile plus F1. Body→input/frame→rider-copy→wheel phases, exact unscaled resources, source camera/audio and RETURN. | S/P/M/R:53 isolated original observations, actual-level managed tests,10-phase native/headless replays. No complete original-game comparison. | Whole-original/native Windows comparison; shared global/pair state, retained LOAD/helper/save lifecycle and other levels remain bounded. See gameplay/scooter-live.md. |
## Interaction and ownership map
+8
View File
@@ -185,3 +185,11 @@ allowed where it resolves a core-system question, without waiting for every leve
Linux from /tmp passes source-body VR04 flight and nondefault tutorial/RETURN.
Source/native validation enabled; release layers unavailable; native Windows
comparison remains open. Logs: artifacts/body-composition/.
C4 body ownership continuation (2026-11-05): implemented finite fresh previous/live
XYZW publication, independent body modes, retained context and landing payload
ordering.100 complete native comparisons plus six state-only mutation cases pass;
full regression/native/package checks are in body-contact-implementation.md.
Lab/outside remain gated behind actual hazard/climb callbacks, actor mode/animation
persistence and dynamic/shared-scene context. Do not infer full C4 completion.
+140
View File
@@ -0,0 +1,140 @@
# Jimmy special contacts: movement-stability audit
2026-11-04. Static recovery plus27 isolated original-dispatch observations; no
runtime solver change. Current playable fccc0b9 remains the baseline. The user
returned priority to Jimmy movement and explicitly allowed JN-Engine as a guide.
JN-Engine's prototype movement is not imported or treated as an oracle.
## Result and immediate implementation boundary
The lab/outside capsule bypasses material callbacks entirely: SceneCollision's
private triangles retain geometric positions/normals but no linked material ID,
and LabSimulation.StepPhysics receives only grounded/wall/ceiling flags. This is
a concrete missing interaction layer, not evidence that changing walk constants
or adding universal wall reflection will fix collision fidelity.
**Do not globally admit lab/outside to OriginalBodyPhysics yet.** Besides dynamic
pairs, three directly evidenced contracts are missing: material-driven hazard/
climb actions, world-response1D0 state during special animation, and contact-owned
root publication. The existing ordinary sphere composition assumes no
root-changing callbacks. Its wallContact hook alone does not establish the
source's fresh previous/live Vec4 equality or special-animation lifecycle.
For example, it currently adds the old falling displacement.Y after the hook
returns a root, whereas the original can skip that entire candidate publication
when the contact changed live/previous root. A root-changing callback cannot be
made faithful simply by returning a different OrdinaryBodyState.Position.
The smallest safe movement implementation chunk is ordinary ground/air arithmetic
and phase stability while preserving the current route solver. For collision:
first preserve/report actual contacted shape/polygon/3DMa identity in a diagnostic
path; next implement the state-owning callbacks and source body modes with
regressions; only then enable a bounded real lab/outside source-body route. Do not
silently classify a special contact as ordinary to make scene admission succeed.
## Original identity and source map
Neutron.exe SHA256:
f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8.
Every code VA below maps to raw offset VA−400000, independently checked by PE.
`tools/binary/jimmy_special_contact.py` records five bounded spans with hashes,
raw offsets and four live virtual bindings. Existing material loader/source
coverage is in collision-contact-callbacks.md and its guarded helper.
| Code VA / raw offset | Observed contract |
|---|---|
|43AA40 /3AA40|Player contact handler takes **game interface** (Jimmy complete+C0), supplied Vec4 normal and polygon. First requires elapsed game774>3; missing polygon/material/chunk yields no special policy. Reads signed archive3DMa ID through polygon+4→material+C→chunk+8.|
|43AA7E..43AAD5 /3AA7E..3AAD5|IDs120..129 call **complete virtual160**, IDs110..119 call **complete164**. These dispatches precede the movement-mode check and therefore still occur in nonzero modes.160/164 are slot offsets, not material IDs.|
|43AAD5..43AAF9 /3AAD5..3AAF9|Fence IDs60..69 and ladder180 require mode game704==0. Other metadata returns without generic reflection/projection. The handler contains no raw controlled-pointer gate.|
|43AB17..43ABBF /3AB17..3ABBF|Ladder first requires game338→472570 retained support polygon pointer (live234), then a47C210 probe. This is not the same predicate as current grounded218. A missing retained polygon prevents even the ray attempt.|
|43ACD4..43AE19 /3ACD4..3AE19|Fence requires first probe to miss and subsequent side probes to hit. Miss-only synthetic probes make exactly two calls then reject. Different ray outcome sequences are not equivalent to a single wall hit.|
|43AC29..43ACC5 /3AC29..3ACC5;43AF54..43AFDB /3AF54..3AFDB|Successful branches derive yaw from negative supplied normal through original angles, set destination/live orientation, transform local offsets, publish root314 and request LADDER/FENCE through complete150. Full successful-ray traces remain unexecuted.|
|42A7E0 /2A7E0|Jimmy complete160 requires splat cooldown1E60<=0 and !1DED latch. Requests SPLAT via150, sets latch, clears impact clock1DE8 and controller scalar complete6C8/game608, stores supplied normal at1DF0..1DFC, requests−5 energy/score through42A920/42ADC0, and SFX37. Those helpers retain their own tutorial/global policies.|
|42A8D0 /2A8D0|Jimmy complete164 requires !1DEC latch and raw gadget4F0588!=0 (Bubble0 immunity). Sets latch, clears1DE8, requests−5 energy/score, calls complete1E0→425120 (mode1 jump/effect cancellation). It does not share160's cooldown gate.|
|437953..43796A /37953..3796A|Increment game774 elapsed **before** base40E050 and later raw ownership gate. Physics contact reads the preceding phase's elapsed. Omitting this timer would permanently suppress source policies; gating it only on Jimmy input is also wrong.|
|43B408..43B4B4 /3B408..3B4B4;43B4BE..43B58A /3B4BE..3B58A|FENCE/LADDER animation entry owns saved destination Vec4 complete838..844/game778..784. Respective local offsets(0,320,150)/(0,800,150), velocity0, gameA8(false), action helper148, global busy4F83E0=true, duration complete888=4/6, fallback timer868=5, elapsed834=0, nonloop animation and SFX146/143.|
|43A900 /3A900|AnimEnded handler returns FENCE/LADDER to STOP, clears busy/duration, calls Jimmy game410→42AFC0, clears action flag complete6E4/game624 and controller speed complete6C8/game608, restores saved full Vec4 root314, then gameA8(true). SPLAT/HIT branches differ.|
|437988..437A15 /37988..37A15|Fallback timer game7A8 is decremented before input ownership gate. Expiry while busy can restore the saved root/response state too. Source duration4/6 and fallback5 are distinct; do not invent one universal fixed climb timer.|
|47A123..47A1C4 /7A123..7A1C4|Body publication rereads previous2F8/live310 and compares all four components. A contact-owned root change skips candidate clamp/publication. Vector3-only stale equality is not this boundary.|
Bindings independently checked: Jimmy complete4A3BDC+160→42A7E0,+164→42A8D0;
Jimmy game4A373C+374→42A660→Player43AA40; Player game4AF6C4+374→43AA40.
Game338→472570 returns retained polygon234, not a boolean grounded query.
GameA8→470FD0 changes **world-response** getter1D0/live13C. It does not disable
integration210, support1C8, raw control118 or global geometry4F69E5. Consequently
`geometryEnabled=false` in the current managed body is not an implementation of
this transition: that parameter follows global geometry-off gravity cancellation.
The pose setter's exact callback acceptance, source morph/event cadence, impact
latch/impulse updater4255C0, successful ladder/fence ray offsets/filters and reset
interactions need component/runtime closure before actual mechanics are enabled.
The stored impact normal is consumed later; immediate arbitrary velocity reflection
would replace that state machine with a different behavior.
## REA and JN-Engine evidence
JN-Engine docs/decomp/C3DPlayer.md, C3DJimmy.md and original decompiler bodies
in docs/decomp/evidence/c3dplayer_movement_target3.md/c3djimmy_target6.md supplied
function/field leads. Shared EXE identity is verified; its prototype movement and
its different declared OMT2.dll build are not numeric/runtime authorities here.
Class reports mix game and complete bases in places; the offsets above follow
authoritative instructions and the independently established+C0 interface.
Configured REA/Ghidra12.1.4 batch at artifacts/jimmy-special-contact/rea used the
existing generated target copy and exported Evidence/closed snapshot:
- 42A7E0: ev_801bbf1e21eb341f126f5e57e3efbfca42bb1c799680b2429c7f05dfdda3d625.
- 42A8D0: ev_889e1c63d50f8e6da7e451ba0b821396f884fb7d7961dcdede3c4f3ca0e54af3.
- 43A900: ev_0c030c12f6beb0790a6be2c53d3c4ac6591c8c2bd6552e8ea888f8de13455c7f.
43AFF0 returned an explicit procedure-recognition error; retained reply03.json
is not successful decompilation and the unchanged selector was not repeated.
Its supporting instruction extract is saved as special-animation.asm; the JN
body is only a lead. Reused43AA40 Evidence:
ev_4f2a6aa666451db831efd46f5c587573e22d8072315626b8bc2f844f9c6f0cae
under artifacts/collision-integration/contacts/rea-callbacks. REA x87/return-address
aliases are imperfect; reviewed call signatures/bytes settle the normal payload.
## Isolated original execution and tests
The new generated probe executes copied43AA40 with synthetic game/complete
vtables, linked polygon/material/chunk records, no-op160/164 callbacks and a
miss-only ray stub. It **does not** execute real damage, successful climb,
animation, body integration, collision traversal or the original game entrypoint.
An initialized local Wine32 prefix runs the copied code in the project's separate
network/filesystem sandbox; Wine exit0 and JIMMY_SPECIAL_CONTACT_COMPLETE are
retained in artifacts/jimmy-special-contact/probe/{wine.log,capture.json}.
27 observations cover signed metadata and all dispatch boundaries, strict elapsed
3/above3, nonzero movement modes, null polygon/material/chunk, missing retained
support polygon, and both hazard dispatch/fence ray attempts with raw controlNULL.
Normal Vec4 reaches160 unchanged. Miss-only fence performs two probes; ladder one
when support pointer exists. These are branch/gate observations, not terrain
success or original end-to-end movement traces.
`tests/test_jimmy_special_contact.py` commits the observations, original source
span/binding identity and generator/harness/executable/log hashes. Four Python
groups pass: source/offset/bindings, all27 native dispatch cases, provenance, and
output/original/symlink isolation. Originals remain untouched. No runtime source
or existing tests/docs were modified by this investigator; no commit was made.
## Proposed continuation gates
1. Keep source-backed controller/air/jump fixes and current playable route solver
independent; preserve fccc0b9 and subsequent tested movement checkpoints.
2. Expose contact metadata/root-ownership diagnostics; recover4255C0 impact latch
and impulse completion, then implement material120..129's bounded hazard flow.
3. Recover/verify successful climb rays, full animation-end/fallback ownership and
independent world-response mode before adopting fence/ladder callbacks.
4. Complete dynamic pair eligibility/shared context and Vec4 publication, then
run input-only lab/tutorial/RETURN/outside cases with known special contacts.
General floor/step/wall fidelity is not established by these27 leaf probes.
## Subsequent prerequisite implementation
[Body contact implementation](body-contact-implementation.md) now supplies the
fresh previous/live XYZW barrier, independent source modes and landing ownership,
with100 complete native comparisons plus six callback-state cases. The missing
barrier/flag paragraphs above describe the audit baseline, superseded by that
bounded foundation. Actual hazard/climb callbacks, animation acceptance/completion,
per-actor multi-frame state and dynamic context still gate broad admission.
+220
View File
@@ -1,8 +1,228 @@
# Compatibility and validation
Body contact foundation (2026-11-05): finite XYZW publication, independent body
modes, static-context retention and landing callback ownership implemented.100
full native numeric outputs and six state/branch comparisons pass; existing
20 body/13 Scooter/13 Grappler groups pass. Native Linux both Scooter scenes,
Jimmy walking/flight and control phases pass with zero Vulkan errors; all five
Jimmy final/airborne readbacks match the preserved air bridge exactly. No special
Jimmy contact or broader scene admission is enabled. Evidence and remaining
limits: [body contact](checkpoint/body-contact-implementation.md).
Body foundation final validation: full scripts/test.sh exits0 (333 Python+2 HUD,
45 managed projects,36 main Vulkan completions, asset/save/audio checks and539
original hashes). Clean c9d0c5b Linux/Windows packages have matching519 original
copies and4271 prepared files each. Standalone Linux from /tmp passes both Scooter
scenes and walking/jetpack, with27 matching development readbacks and zero
validation errors. Original/native Windows comparison and actual special Jimmy
callbacks remain separate; see the body implementation report.
Jimmy airborne bridge (2026-11-05): ordinary forward/back pitch and turn lean,
source target/dirty/Init/retained-seed ownership, full authored Euler and logical
root hierarchical rendering are integrated.146 native component outputs match;
final OMT model decomposition remains an explicit precision gate, and sole
alignment remains a modern local adapter. Native Linux all-five-jump walking/
jetpack replays pass with25 identical cross-binding captures; Carl/control phases
pass, zero validation errors. Collision admission is unchanged. Detailed current
validation and limits: [air bridge](gameplay/jimmy-air-bridge.md).
Air-bridge package validation: clean27be8ed for Linux/Windows;519 original asset
copies and4271 prepared files match per package. Standalone Linux from /tmp passes
walking/jetpack, all five final/airborne captures matching development, zero
validation errors. All script checks pass across recorded runs:325 Python+2 HUD,
44 managed projects,36 main render completions and539 unchanged original hashes.
Native Windows/full original comparison and exact final OMT decomposition remain
open; the current bridge preserves the explicit modern sole alignment.
Jimmy movement (2026-11-05):108 copied-original ground/air/facing/jump observations
match managed components.26 integrated movement/20 body groups pass; lab and
two-way underground routes retain the user's baseline. Native Linux walking and
VR04 powered input replays pass all five jump aliases and resize, with identical
readbacks across aliases and zero Vulkan validation errors. Carl control lock,
control-independent body/fire and Grappler native replays pass. Source pressure
is restricted to real source support; the lab/outside capsule keeps compatibility
behavior. Ordinary air pitch/full root rendering and special/dynamic contacts
remain open, as do complete original and native Windows comparison. Details and
provenance: [Jimmy stabilization](gameplay/jimmy-movement-stabilization.md).
Jimmy final package validation: both self-contained builds identify cleanacd1b28;
519 original copies and4271 prepared resource files match per package. Standalone
Linux from /tmp repeats walking/powered SDL replays with two matching development
readbacks and zero validation errors. All script checks pass across documented
run/resumptions (320 Python+2 HUD,43 managed projects,36 main render completions,
asset/audio/save checks,539 unchanged originals). Native Windows and whole-original
movement comparison remain pending; see the stabilization report for exact gates.
Scooter feedback follow-up (2026-11-04): missing Goddard follow pitch/roll leveling
and source positional engine-frequency correction are implemented.13 Scooter/2
ScooterAudio/10 Patrol groups,24 targeted Python checks, route/audio regressions
and both10-phase native Linux SDL replays pass; zero validation errors.11 new
native facing traces and11 frequency traces distinguish source math from port
composition. The correction lowers engine pitch slightly; audible parity/native
Windows confirmation remains unverified. Reports: gameplay/scooter-pitch.md and
scooter-dismount-leveling.md. Both packages identify cleanfccc0b9 with14 matching Scooter resources. Standalone
Linux from /tmp passes both10-phase SDL replays;20 readbacks match development
byte-for-byte.539 originals remain unchanged. Provenance: scooter-live.md.
Scooter (2026-11-04): live in VR05 and outside LEV1 through normal owned gadget
selection and F1 grant.53 copied-original component observations match managed
math; actual-level tests cover mount, wheel/body phases, drive/jump, head-on
recovery, camera and cleanup/RETURN. Native Linux GTX1070/private Xvfb1920×1080
passes both10-phase SDL input replays with zero enabled Vulkan validation errors.
A2560×1080 Player-page capture shows all32 rows including Scooter; inspected.
Headless replay passes both scenes. Source and final validation/package provenance
are in gameplay/scooter-live.md. Fixed cadence, Jimmy's outside capsule, provisional
NPC/dynamic door body, other levels and original/native Windows comparison remain
explicit limits. Both packages identify clean62c07a3; all14 Scooter resources
match. Standalone Linux from /tmp passes both10-phase native SDL replays, with
all20 stage captures identical to development.303 Python+2 HUD/all managed/36
main GPU regressions and the post-package539-file audit pass. Historical
gadget-only status below is retained chronologically.
Compilation, native runtime, original behavior and full feature completion are
separate evidence categories. **The game is not fully reconstructed/playable yet.**
Current Grappler scope is liveVR08: source ordinary body/shared sphere context,
recovered camera, original rope/SWING/cursor, sounds and selection/RETURN cleanup.
113 original-component observations;13 managed live/40 Python checks pass. Native
Linux GTX1070 and headless replay pass9 phases with zero Vulkan validation errors.
Both packages identify clean43806fe and contain9 exact Grappler resource files.
Standalone Linux from /tmp passes and matches all9 development captures. Full
scripts/test.sh passes297 Python+2 HUD/all managed and route/gadget/audio checks;
all539 original hashes verify unchanged.
Exact art/capture and package evidence: gameplay/grappler-live.md. Whole-original
VR08, native Windows, other levels and general dynamic pairs remain unverified.
Historical component-only status (superseded for boundedVR08):
Grappler query/constraint checkpoint:42 new copied-original observations (72
total),10 managed/18 Python groups,11 camera/13 Rocketship groups and main build
pass. ActualVR08 ray/filter/material integration works in tests. Lab gameplay
readback is byte-identical; lab and VR08 geometry preview render with enabled
Vulkan validation, zero errors.539 original hashes verify. Attached world-body/
base-contact composition, camera and helper presentation/lifetime remain open;
Grappler is not live and playable packages remain70cba65. See gameplay/grappler-query.md.
Grappler scalar checkpoint:30 copied-original Wine32 observations match5 managed
groups,14 Python source/projection checks,25 movement/15 gadget groups and main
build pass. No live Grappler, new Vulkan path or original/native Windows gameplay
comparison is claimed. See gameplay/grappler-component.md. Playable packages
remain70cba65 with the orbit horizontal-input correction, verified by native
Linux SDL input/resize and zero enabled Vulkan validation errors.
Orbit inspector follow-up: corrected right-handed inspection view/perspective
to gameplay's positive-Z left-handed convention.36 camera/aspect cases and all
existing projection checks pass. Enabled-validation llvmpipe captures confirm
the removed horizontal reflection; lab gameplay captures are byte-identical.
Native/package evidence: orbit-camera.md. Native Windows remains unverified.
Native GTX1070/private Xvfb orbit input/resize check passes, enabled validation
and zero errors. Both packages identify clean d8f1b51. Standalone Linux capture
from /tmp matches the corrected source byte for byte;539 original hashes verify.
Rocketship impact follow-up: corrected first-material red-flash RGBA previously
misapplied to ship scale.13 managed groups include actual wall contact plus130
frames of unchanged geometry, correct ship-only tint, recovery and repeated
renders. Source guards independently verify material allocation and DLL diffuse
consumption; old numeric probe labels were insufficient semantic evidence.
See gameplay/rocketship-impact-render.md for REA and package/runtime checks.
Both packages identify clean62e908e. Standalone Linux from /tmp passes all10
ordinary flight/control phases on GTX1070 with real SDL keys and enabled Vulkan
validation, zero errors.22 targeted Python checks and539 original hashes pass;
native Windows runtime for this fix remains pending.
VR02 Rocketship (2026-11-03): live aircraft/static support and callbacks, original
input/facing/maneuvers/camera, owned rider/Goddard/fire and engine lifecycle.
14 flight/12 final integration groups;96 isolated original component observations.
Native Linux GTX1070/private Xvfb1920×1080 ten-phase real SDL replay passes with
zero Vulkan validation errors; headless matches.295 extra ordinary ticks are an
accelerated port fixture, not original cadence or manual tutorial completion.
Full268 Python+2 HUD/managed/33 GPU+17 material regression passes;539 hashes verify.
Both packages identify clean e77add5;18 resource files/four source RGBA hashes
match. Final standalone Linux from /tmp passes all10 SDL phases with validation
enabled. Packaged1920×1080 F1 Player page fits32 lines (headless layer unavailable).
Other levels, special missions/hazards/RNG, full source pair discovery, generic
Jimmy post-vehicle Euler/render bridge and original/native Windows comparison
remain boundaries. See gameplay/rocketship-live.md for package provenance.
Give All Gadgets debug action (2026-11-03): F1→Player grants items0..7 without
changing selection. Debug-menu action/navigation/repeat/layout checks and main
build pass; llvmpipe headless1920×1080 view renders all rows with zero Vulkan
validation errors. Readback inspected; artifacts/debug-give-all/render.log.
Rocketship component/Grappler recovery (2026-11-03): isolated keyboard/vertical
math matches28 copied-original Wine32 observations across13 managed groups.
Rocket source3/resource5/Grappler12 and existing Gadget15/Movement25 groups pass;
main .NET10 build succeeds with the existing NU1900 metadata warning.539 originals
verify unchanged. Exact resource export remains opt-in; no live vehicle/Grappler,
new Vulkan/native Windows or whole-original gameplay verification is claimed.
No package rebuild: playable d6ca417 remains baseline. Next live gates and full
scope are recorded in gameplay/rocketship-component.md.
Supplied jn-engine assessment (2026-11-03): documentation/source/artifact review
only; no new build or runtime validation. Same declared EXE, different declared
OMT2.dll;254 ASE/126 PNG/35 GAM files match byte for byte. All539 original hashes
verify. Class specs, decompiler bodies and derived D3D7 fixtures are useful
evidence candidates; proposed original gameplay traces/raw OMTC/Ghidra project
are not included. No prototype C mechanics were imported or port fidelity
promoted. See reviews/jn-engine-survey.md; existing package claims below stand.
Baseball (2026-11-02): source hold/release/20-slot pool, exact ball/aim/TIME art,
bounded ball body, VR07 moving-target callbacks and F1 grant are implemented.
12 managed/6 visual/16 Baseball Python groups and independent review pass.
Native Linux GTX1070/private Xvfb1920×1080 passes real SDL Ctrl/Left/Up/Tab,
all eight render phases, actual target hit/respawn and zero enabled Vulkan
validation errors. Its1010 extra ordinary player/target ticks are an accelerated
port fixture. Sphere contact discovery, angular wall response, full enemy combat,
retained helper lifetime and original/native Windows comparisons remain open.
Complete regression passes232 Python+2 HUD, all managed suites,32 GPU runs and
17 material checks;539 originals verify. Both packages identify clean d6ca417;
all16 Baseball/aim pixel hashes match. Standalone Linux from /tmp passes all
eight phases and the1920×1080 F1 Player view; release validation layers unavailable.
All539 originals verify after packaging. Native Windows remains unverified.
gameplay/baseball-implementation.md
records the coverage map. Scooter's recovered wheel/control dependencies are
documented but not implemented as invented Jimmy movement.
Bubble (2026-11-02): original mode2 controller, sprite/flags/pulse/fade, controlled
drain, loop/boing ownership, cleanup650 and boundedVR01 source body/floor111 are
integrated. Six isolated copied-original body references match managed output.
Independent review and13 integration/11 motion/8 visual groups pass. Full suite:
202 Python+2 HUD, all managed checks,31 main GPU completions and17 Vulkan material
checks, zero enabled validation errors; SDL dummy lifecycle and539 originals pass.
Native Linux GTX1070/private Xvfb1920×1080 passes real Ctrl/Left/Shift/Tab and all
eight rendered phases. The fixture advances306 extra normal player ticks; this
is not original cadence/manual completion/full hazard or original visual parity.
Lab/outside capsule, fixed render bridge, generic camera/Euler scheduling, other
damage flags, mouse/analog and retained-helper lifetime remain explicit limits.
Both self-contained packages identify clean1ae5f42 (source_dirty=no), preserve exact
Canv1 RGBA hashes and publish successfully despite NU1900 metadata warnings.
Standalone Linux from /tmp passes all eight Bubble phases and a1920×1080 F1 Player
view; release validation layers are unavailable, distinct from enabled checks.
All539 originals verify after packaging. Native Windows remains unverified.
See gameplay/bubble-implementation.md and artifacts/bubble-implementation/.
Invisible continuation (2026-11-02): recovered mode2 timers, fixed energy cost,
alpha/blend flashing, original meter and companion/cutscene cleanup are integrated.
Shared source energy warning latch/audio now serves ray/jetpack/Invisible. Fifteen
managed groups and182 Python source/parser checks pass. Native Linux/private
Xvfb GTX1070 at1920×1080 verifies real SDL Ctrl/Tab and six rendered phases with
zero enabled Vulkan validation errors; headless matches. The fixture accelerates
836 ordinary player ticks between captures and does not prove original cadence,
enemy immunity, original pixel placement/visual parity or tutorial completion.
Full scripts/test.sh passes182 Python+2 HUD, all managed suites,30 main GPU
completions and17 isolated Vulkan material checks, with zero enabled validation
errors. SDL dummy lifecycle and539 original hashes pass. Both self-contained
packages identify clean1897dd2 (source_dirty=no) and preserve exact Canv21/22
meter pixel hashes. Standalone Linux from /tmp passes all six Invisible phases
and a1920×1080 F1 Player-page render. Release validation layers are unavailable,
distinct from enabled source/native checks. Both platform publications succeed
despite NU1900 vulnerability-metadata warnings. Windows native gadget verification
remains open;539 original hashes verify again after packaging.
See gameplay/invisible-implementation.md and artifacts/gadget-followup/.
Gadgets (2026-10-27 UTC): original gadget screen and combined shrink-ray/jetpack
are implemented; actual VR04 soldiers use original shrink morphs, source timer,
authored AI reset and ordinary10-point score/save effect. First complete run:
+26 -1
View File
@@ -26,10 +26,35 @@ by themselves. Debug tools do not imply reconstructed progression or full gamepl
## Player and Systems pages
**Give/Select Scooter** grants item4 and summons the live vehicle at Goddard in
VR05 or outside LEV1. Walk into it to mount; selecting alone leaves Jimmy free.
The normal owned gadget tile works outside too. Header diagnostics report
OFF/PARK/RIDE, speed and front/rear supported wheel counts. Tab/Space unequips;
F3/reset releases vehicle control and sound. The Player page remains32 rows.
Player includes **Give All Gadgets**, which sets all eight gadget tiles to owned
and available in the current scene. It preserves the equipped gadget and other
inventory entries. Normal level-load availability rules still apply afterward.
**Give/Select Rocketship** equips the live vehicle in VR02; elsewhere it grants
the tile for Practice entry. Its speed, vertical velocity and contact count appear
in the Player header. The complete page still fits32 rows and scales uniformly.
While mounted, Enter/T turns180degrees and R barrel rolls; Tab/Space unequips.
Force Control continues to drive the mounted pilot without changing authored
ownership; enabling noclip releases the ship and engine before flying Jimmy.
The General page retains the existing actions. Player adds noclip, staged flight
speeds300/600/1200/2400 (Enter applies), clear motion/queued jump, reopen objective,
return to noclip entry, apply source level gadget availability, toggle input after
player, staged jetpack states0/1/4 with a separate Apply row, and energy refill.
player, staged jetpack states0/1/4 with a separate Apply row, energy refill,
Give/Select Invisible and Unequip Current Gadget. Invisible obeys its source
energy/recharge gates; a grant is not instant activation. The header shows
remaining time, recharge and targetability. Full enemy sensing is not implied.
Give/Select Bubble uses the implemented mode2 controller, while Unequip starts
its original fade. Diagnostics show Bubble phase and source radius/factor.
Give/Select Baseball grants item6 and shows aim/pending/throw diagnostics. Hold
primary fire and use Up/Down to aim; release to throw. Cleanup preserves its
source pending latch and existing flying balls. See gameplay/baseball-implementation.md.
State0 means unowned,1 enabled and4 disabled by the level. The full availability
action re-enables the matching VR practice gadget and applies LV1B restrictions
on gadgets1/7 after the common prefix. Other level-specific tails remain incomplete. These controls expose
+140
View File
@@ -200,3 +200,143 @@
Keep modern full-panel pause, upright effect transform, additive branch and
blended-depth policy explicit. Other gadgets, full AI and warning-audio
lifecycle remain independent evidence gates, not guessed feature completion.
37. **Preserve timed gadget and cleanup ownership.** Invisible's seven-second
recharge/active clocks run after movement with any nonnull controlled pointer;
raw-null pause is distinct from cleanup. CAM/MCA default DeactivateInv to1
and explicitly release named Jimmy before target validation, independently
of raw-owner438. Keep failed display2/raw−1 selection, source blend flashing,
original meter art and companion body flags separate from AI activation.
Energy scalar and warning latch share one session owner; raw saved/refill
assignment is not a helper-driven warning rearm. Full enemy sensing,
suppression globals, graphics options and canvas alignment remain explicit.
38. **Integrate Bubble's controller and body together.** Mode2 is persistent and
has fire throttle, its own turn cap and direct300/900 supported bounce; it
must not enter the ordinary550/jetpack table. Pass radius160/factor.415 to the
tested static body, preserve queued work/root and restore source650 maximum
on cleanup. VR01's floor111 has a retained-material callback even in air, so
implement that bounded policy with original bypass/debounce/material ordering.
Original Canv1 remains an independently updated sprite with full RGBA fade,
not invented sphere geometry. Keep the render bridge, generic camera/Euler,
other damage states and retained helper lifetime explicit. Bubble practice
precedes live equip; menu gating reads raw mode, not display selection.
39. **Keep Baseball ownership beyond selection.** Preserve the original20-slot
ring, pending release after cleanup, prior-capture label and source release
cost/sound order. Landing queues a full impulse before support clears Y;
use a ball-specific profile rather than Jimmy callbacks. VR07 target state
belongs to source instances despite duplicate tags, with strict parent hit
threshold and conditional collision activation. Exact TIME glyph binding
replaces the temporary font policy. Keep current sphere-pair discovery,
angular reflection, mouse/analog aim and helper retention across loads explicit.
40. **Save Scooter recovery before implementing it.** Its separate C3DJEEP actor,
mount/control handoff and wheel-dependent drive/support cannot be represented
by a Jimmy mode or an invented constant wheel count. Preserve the source
report/exporter and close wheel bodies before live Scooter integration.
41. **Use supplied jn-engine as research, not a replacement runtime.** Same EXE
declaration and415 byte-identical shared assets support cross-indexing its
class specs/decompiler bodies and adapting bounded tests. Different declared
OMT2.dll, mixed pointer bases, forced prototypes and explicit native gameplay
tunings require independent checks. Retain C#/.NET10/SDL3/Vulkan and REA byte
evidence. Capture tooling/derived scenes are present; raw OMTC, analysed
Ghidra database and proposed gameplay state traces are not. Record offered
permission before source import. Assessment: reviews/jn-engine-survey.md.
42. **Verify vehicle arithmetic before connecting live ownership.** RocketFlight
preserves per-callback input acceleration, support/brake ordering and retained
vertical-command publication, compared with28 isolated copied-original cases.
Radius50 is collision size, not render scale; rates650/−650 are acceleration,
not assigned velocity. Do not substitute Jimmy's body/camera for aircraft
callbacks or claim the scalar component is a live Rocketship. Resolve owned
versus placed properties, passenger/effect lifetime and control/camera phase
before VR02 integration. Grappler's geometry/material/swing contract likewise
forbids nearest-hook/direct-pull replacement. See gameplay/rocketship-component.md.
43. **Compose the owned Rocketship in boundedVR02.** Preserve source registration
order, rider static-body work, separate raw control/menu permission and
named-Jimmy cleanup.1E4 is a dynamic-pair flag, not an integration gate.
Dedicated source callbacks, Euler seam, maneuvers, LOOK-to-eye camera and
passenger/flame pivots replace provisional movement/render assumptions.
Require source/probe admission for other materials/levels; no nearest-ship,
invented boost or direct vertical-velocity substitute.96 isolated component
observations support contracts; live SDL/Vulkan replay verifies the port,
not whole-original or native Windows fidelity. See gameplay/rocketship-live.md.
44. **Identify field consumers before assigning render semantics.** Rocketship's
four impact writes are first-material diffuse RGBA, not shape scale. The
copied suffix probe validated numeric values but its synthetic buffer and
historical `scale` label did not establish their meaning. Constructor and
actual DLL renderer consumers now guard the contract. Use a ship-only red
material flash with unit geometry; regress vertex positions as well as values.
See gameplay/rocketship-impact-render.md.
45. **Keep inspection in the gameplay coordinate convention.** A right-handed
view/perspective pair can render a valid frame while mirroring a positive-Z
source scene relative to gameplay. OrbitCamera now owns the matching
left-handed view/projection; apply the shared Vulkan Y correction only once.
Regress screen right/up and depth across camera poses, not frame presence
alone. The modern inspector is separate from recovered original camera logic.
46. **Keep Grappler cursor/attachment and input/normal gates distinct.** The leaf
attachment helper lacks cursor filters, but aim's earlier true return ends
active input before that helper. Do not interpret it as a rejection bypass.
Attached input may return early while ordinary Jimmy frame publication still
runs. Compare isolated sqrt/first-scale/reel/damping with original snippets
before composing body/camera/helper ownership; do not invent250 clamps or a
detach impulse. GrapplerMotion remains isolated until those gates close.
47. **Keep Grappler query metadata and component boundaries explicit.** Capture
the actual first selected polygon/material with its hit. Preserve root versus
swing-pivot origins, quick-magnitude constraint order and strict>60 contact
detach. Native aim/constraint/post-base suffix probes do not establish the
full body context, base contact, camera or helper lifecycle; close those
contracts before liveVR08. See gameplay/grappler-query.md.
48. **Bound Grappler's shared collision and persistent helper state.** Reuse the
preceding source-body sphere context in attached47B4B0, including stale last
polygon callbacks; support/ray metadata is separate. Keep scalar memory at
session scope and helper/audio state at scene scope. Explicit RETURN cleanup
is recovered; ordinary reconstructed-scene disposal is a modern safety
boundary. Preserve first geometry scale across reattach/reequip/load. Camera
offsets are locals consumed by separate ground/air branches, not world poses.
Exact SWING uses its own source-pivot draw. See gameplay/grappler-live.md.
46. **Scooter owns a vehicle body and real wheel supports.** Normal item4 selection
summons at Goddard; strict later contact mounts. Keep scalar/live velocity/
pending impulse and body/input/frame/wheel phases distinct. Enable bounded
VR05 and outsideLEV1 from the normal owned tile. Use source body150/.2,
four narrow wheel offsets, explicit prevent-lowering/bounce overrides,
face-only camera clip and exact unscaled art. Preserve parked Jimmy collision.
Native component comparison, managed integration and port rendering establish
separate coverage; no complete original/Windows parity is inferred.
47. **Fix Scooter handoff consumers and sound channel processing.** Preserve
copied dismount Euler, then run source Goddard X/Z leveling with.3 factors
in the supported follow bridge. Preserve the nominal engine pitch command,
then apply recovered47D9D0 positional frequency/history and DX bounds.
Use shared listener state for mounted/parked/script cameras; global audio
cadence and attenuation remain separate. See the focused gameplay reports.
48. **Stabilize Jimmy from authoritative components while preserving the playable baseline.**
Use JN's original decompiler index as leads only. Integrate source ground/air
input, velocity, full-axis base facing and precise jump hold/gravity after
copied-original comparison. Preserve retained targets and keyboard-turn latch;
facing runs without raw input ownership. Require real support polygon338 for
downward ground pressure; do not translate capsule Grounded into that state.
The failed stair route and successful compatibility rerun are retained evidence.
Keep ordinary air pitch/actor-root visual bridge together as the next chunk,
and special/root-changing/dynamic body behavior behind independent gates.
See gameplay/jimmy-movement-stabilization.md.
49. **Keep air input, facing and the logical-root visual bridge together.**
Pitch seeds are retained apply-owned fields, not per-input mode constants.
Init clears destination Euler/dirty independently of current full STRT Euler.
Publish full authored/current XYZ and enable ordinary pitch/turn lean with
source hierarchical rotation/degree caching. Retain upright foot alignment
as an explicit local model correction around the logical root; do not call it
an original pivot offset or mutate source geometry/body support. Defer OMT's
final approximate-angle model decomposition with its measured seam mismatch.
Broader special/dynamic collision retains separate gates. See jimmy-air-bridge.md.
50. **Preserve contact-owned root and body modes instead of treating world-off as noclip.**
Keep current/previous full Vec4, anchor and source integration/support/
collision/world/alternate gates independently. Only fresh XYZW equality permits
publication of the original candidate; callback roots do not inherit stale
falling displacement/clamp. Landing callback root/anchor/acceleration/impulse/
modes persist, while cached velocity/support publication follows afterward.
World-off still integrates and may support; collision-off has its own hold/
translation branch. Preserve inactive-path context. Retain the lab/outside
capsule until real Jimmy callbacks and multi-frame/dynamic ownership are proven.
See checkpoint/body-contact-implementation.md.
+145
View File
@@ -0,0 +1,145 @@
# Baseball original resources and VR07 fixture
2026-11-02. Original serialized resources and decoded pixels were read locally;
originals were not modified or executed. Binary activation/projectile/target
behavior belongs to the separate Baseball contract investigation. This report
records asset identity and a resource interface suitable for integration.
`tools/extractors/baseball_resources.py` exposes `export_baseball(original, output)`
and writes schema1 `baseball.json`. It preserves five exact canvases from
RetainedSprites.omt and the authored VR07 start/target/intro properties, including
every property source offset/raw bytes and duplicate target tags. It rejects
original subtree/ancestor outputs and existing descendant symlinks, checks both
archive and GAM identities before writing, and guards dimensions/pixel hashes.
```bash
python3 tools/extractors/baseball_resources.py ../Original --output artifacts/vehicle-assets/baseball
python3 -m unittest discover -s tests -p test_baseball_resources.py -v
```
Six regression checks pass: exact RGBA/PNG/provenance, original aim/glyph pixels,
six distinct target
records with authored property bytes, protected output paths, changed decoded
pixels and changed archive identity. Local output and test log are
`artifacts/vehicle-assets/baseball/` and `artifacts/vehicle-assets/baseball-tests.log`.
No shared prepare/runtime/build files were changed by this investigator.
## Port visual implementation and tested limits
`Application/BaseballVisuals.cs` appends20 hidden world alpha quads to a supplied
Mesh, preserving its collision metadata and existing draws/textures. `Update`
uses the caller's pool visibility/position, exact Canv2 and25×25 world dimensions.
It does not animate frames2..5 or invent a lifetime. Camera-facing centered
billboard orientation is a declared modern policy pending exact inherited sprite
render recovery. Degenerate straight-up/down cameras use a finite orthonormal
basis. Resource paths are bounded to the prepared Baseball directory, input
size/depth/dimensions and exact original pixel hashes are validated.
`Application/BaseballAimOverlay.cs` uses exact screens.omt Canv253 CrossHairs
15×210 pixels, SHA256
`2e16e11b151c8474ba68fd5017d1a3a6304a594a7f34c3b423f3417c7edfb453`.
The complete strip stays stationary at logical(315,100), without frame cropping.
Visibility follows AimVisible; text reads the separate prior-capture DisplayPitch,
not the newly captured SavedPitch. Source numeric position is
`y=trunc((45-DisplayPitch)*4.3+100)`, source text anchorx286, with positive-space
plus two zero-padded decimal digits from `% .2d`.
The subsequent [TIME font recovery](baseball-font.md) closes that binding:
set5 digits use alpha.omt118,127,120..126,119, all16×16. A null positive-space
glyph has zero advance; visible digits begin286 and302. Exact green pixels are
preserved with white vertex tint. Runtime/exporter/tests now use that source
mapping; the temporary SMAL policy is superseded.
The exporter writes these plus the source strip into `aimTextures`, each with
its source database key, byte range and decoded hash. `aimArchiveSha256` guards
screens.omt and alpha.omt. Source table, formatting and advance Evidence is in
baseball-font.md.
UiViewport retains uniform scale and centered640×480 placement at widescreen
and portrait sizes. Screen/world quads use alpha blending with unmodified source
texture alpha. Six standalone checks pass in
`artifacts/vehicle-assets/baseball-visual-tests.log`:20-slot/pixel/source metadata,
billboard bounds/camera degeneracies, stationary aim/number/selected glyphs,
widescreen and portrait scaling, combined world/overlay isolation and rejection
of altered pixels/dimensions/path traversal. Invocation:
```bash
source scripts/env.sh
dotnet run --project tests/GamePort.BaseballVisualTests
```
These are compiled port-side deterministic mesh/pixel checks. They do not verify
a displayed Vulkan frame, original source execution or native Windows behavior.
## Projectile and retained target artwork
Archive `omt/RetainedSprites.omt` SHA256
`b584ffa4a38f4bc809b3ea8f4321e0c08f2719e22df41a3fb4cd143ed89b3bef`.
This archive contains Canv resources, not 3D shapes.
| Canv / name | Offset / bytes | Dimensions | Decoded RGBA SHA256 |
| --- | --- | --- | --- |
|2 ball0000|72372 /3786|32×32|`68904b758e69139de0b01329b2a9844ecd2a466f31598c24324affaccfa2cab9`|
|3 ball0001|68582 /3790|32×32|`005def070e18111fbdb067e75285dad8ec677c1608020f55c3db7a4b9745205c`|
|4 ball0002|64788 /3794|32×32|`c368a59d5d7a57824c1c6b56b617cf058f5d5d53e18e5e48989710413490c536`|
|5 ball0003|58830 /3794|32×32|`e5da21c359d3215759e5c3c238107f526f7109203c0ff9fa391a3c8bc40c17ed`|
|8 target|48796 /10034|64×64|`8d31014cb9b9661ebed902c864bf740f562460e74da3f6b86ed3d2be4d10f0ec`|
Manifest `textures` records id/name/width/height/path/png/sourceOffset/sourceBytes/
sourceSha256/rgbaSha256. `ballCanvasIds` lists source IDs2..5 in source-number
order, without assigning animation cadence. `retainedTargetCanvasId:8` names
the literal retained artwork only; it is not the six VR07 target actors' artwork.
Pixels are neither recolored nor resized. The source target8 image visibly has
a four-corner frame/cross pattern; inspected original pixels are available as
`artifacts/vehicle-assets/retained_8.png`.
The contract investigator corrected an early interpretation of constructor40FC50:
its complete57C=25 is the inherited sprite dimension, complete580=2 the initial
canvas ID, and complete5F8..604 retain IDs2..5. It is not shape25. Exact REA
Evidence, frame selection, billboarding, size and render-state policy belong in
that investigator's source report; this exporter embeds no unverified cadence.
## Actual VR07 target visuals
All six authored `3TAR` records explicitly serialize `SpriteDatabase=sprites.omt`,
`SpriteIndex=135`, `SpriteSize=150`. The source resource is Canv135 **star**,
128×128 at offset2750568/35394 bytes. It is a pale purple jagged starburst with
8,016 alpha255 and8,368 alpha0 pixels. Exact RGBA SHA256:
`42bbea6c33fc2889cad0cd659af2274f936be10643254af233779c44f1e41e07`.
Archive SHA256:
`c8e016ea73e6104b9b672139b1d0b0ac83afc4feff6cc744a7fa4f6ba919e2a2`.
Inspected pixels: `artifacts/vehicle-assets/sprites_135.png`.
The existing `prepare_entities` exporter already follows this explicit sprite
database/index and can supply the exact texture; no duplicate sprite export is
necessary. Primary independently traced actual factory45CA06 to430220, inheriting
the sprite base441980; it is distinct from the Jimmy-owned retained target actor
and from the other class constructor4453B0 sharing a FourCC. That factory/default
recovery is separate from the serialized values verified here. The integration
must establish that the source loader respects the serialized overrides before
claiming runtime target appearance parity.
## Authored tutorial instances
VR07.gam SHA256
`1260b75d82ec794f9375ada30e186424746bc1dd4e4b0540c9b69bb7ad12d0b1`.
Six target offsets are0x885,0xAD6,0xD27,0xF78,0x11C9,0x141C. Every target uses
the same tag `C3DMOVINGTARGET`; identify instances by source offset/ordinal.
All serialize Speed100, HitsRequired3, NumPoints10, RespawnTime15 and
ActivateObject=`none`. These are data values, not reconstructed hit/motion rules.
| Offsets | Authored start | Authored destination |
| --- | --- | --- |
|885,AD6,D27|(-755,188,277)|(815,188,277)|
|F78,11C9,141C|(815,333,1520)|(-755,333,1520)|
Do not silently replace each instance's serialized Position with StartPos; both
are retained in the manifest. Constructor/postload/frame behavior determines how
these fields interact. PHONEBOOTH is STRT0x48C, authored position
(7.5705023,216.7101440,-1525.1119385), yaw0, StartTrigger=`bb1`.
Intro3MCA0x1892 serializes PlayerControlled=`NULL`, DeactivateInv1,
NextTrigger=`default` and source voicepractice IDs36,19,35,33,34.
This fixture has authored visuals sufficient for projectile and six target
rendering using the current sprite infrastructure. Source targeting, motion,
contacts, inventory/intro state, score, respawn and original/native Windows
execution comparison remain independent implementation/verification gates.
+114
View File
@@ -0,0 +1,114 @@
# Baseball TIME font closure
2026-11-02. Static original-binary and asset recovery. No original executable was
run or original file modified. This closes the font resource/advance/tint
questions, not displayed original pixel alignment or general renderer parity.
Primary owns the exporter and runtime changes; this investigation edits only this
report and generated `artifacts/baseball-font/`.
## Recommended integration
Replace the temporary SMAL digits with TIME set5's original **16×16** alpha.omt
canvases. Decimal0..9 maps to **118,127,120,121,122,123,124,125,126,119**.
The format is `% .2d`, but TIME's leading positive space maps to a null glyph
and has **zero advance**. For the current declared logical overlay rectangles,
draw the visible digits at **x286 and302**, width/height16, and the existing
source y formula. Do not add an8- or16-unit leading-space advance.
Retain the exact source RGBA with white vertex tint. All ten glyphs have opaque
RGB **(17,255,73)** and alpha0/255; preserve these green pixels without recoloring.
The leaf sets material RGB=(1,1,1), alpha from global4F4ED4 (initially1), and blend
enums from4F4ECC/4F4ED0 (initial6/7). The text function resets that alpha global
to1 after ordinary text. The Baseball caller does not supply an additional tint.
Exact shared-alpha scheduling across all possible text callers is outside this
bounded recovery; ordinary opaque glyph material alpha1 is the evidenced default.
## REA Evidence and supporting bytes
REA analyzed the existing generated copy
`artifacts/uncontrolled-phases/rea/Neutron.exe`, SHA256
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
Ghidra12.1.4 returned all four requested routines. Complete replies, exported
Evidence and the closed snapshot are in `artifacts/baseball-font/rea-local/`.
| Routine | REA Evidence |
| --- | --- |
|4683E0 font initialization|`ev_f5dd8e211882ec340474745de486b4d431a981816a512773fd57a51cb6bfa1bc`|
|468660 formatted text/layout|`ev_e20b6c0cc47aa285935609ad63ea77cf92d9d23b3ca18fe52c7dd6fc286f2308`|
|4689F0 glyph emission|`ev_8a5c0ce796b76993a6e86e19a1d2a36fb1945f1a23c6416ad446213e1e0e043c`|
|468B80 font/character selection|`ev_bd91c2e5548e4e627af7f3faf7e8d5f2a70fa830bff9c3a5bbcbeb55c545e5d9`|
The first sandboxed attempt failed when Ghidra's local Unix socket bind returned
Operation not permitted. The task's owned failed batch was interrupted and its
session closed; its complete failure replies remain in `rea/`. The approved
local static run resolved that host IPC restriction without configuration edits.
This was not a source-execution observation. Both owned sessions are closed.
`font-assembly.txt` and `aim-call-assembly.txt` cross-check the same generated
EXE's instructions. `source-spans.json` records original VAs/file offsets/lengths/
SHA256 for the four functions, bounded Baseball call and font table. Ghidra's
468660 prototype loses its variadic arguments, and4689F0 reports a spurious
unaff_retaddr parameter. Argument and x-advance facts below therefore come from
checked instructions, not literal translation of those pseudocode signatures.
The four code entries map to file offsets683E0,68660,689F0,68B80; the font
table maps toF4ED8. `tools/binary/baseball.py` also guards/exports the table hash,
TIME digit IDs and null-space mapping so this binding remains reproducible.
## Table and glyph identity
4683E0 loads alpha.omt via string4F51D8, then at46844A..46849F walks six groups
of64 signed16-bit table entries startingVA4F4ED8. Index−1 stores a null pointer;
all other IDs are looked up through477890. Runtime pointer table is5091E0.
468B80 uppercases the character, admits ASCII32..95, and selects TIME
`54494D45`→set5 at468C23; SMAL `534D414C` instead selects set1 at468C39.
Runtime index is `font*64+uppercase(character)-32`. The set5 table starts4F5158;
digit0's word is4F5178. The768 source table bytes have SHA256
`910bef1d7aca6f1aa328ba9f671831bdbbda19b419fb0c693117cb096d542226`.
alpha.omt SHA256
`53cb9f47a588b1f19eb0adc4d43c8066a8b78aedd764b9e9314c81e287991126`.
Every digit below is16×16. `glyphs.json` records exact source resource byte
ranges, RGBA SHA256, alpha counts and opaque RGB. No regenerated substitute font
or scaling of the existing8×8 SMAL images is needed.
| Character | Canv / name | Source offset / bytes | RGBA SHA256 |
| --- | --- | --- | --- |
|0|118 t1600|74484 /642|`edc60e65dcf7320813a80d4312e3c45951ccfc566ea79dfabf7a22ebc4b96049`|
|1|127 t1601|25406 /466|`1fd058ad5bdc0f8a064ef7d2d52b2b036df3f35515691a366799d7e8aab5297f`|
|2|120 t1602|73236 /450|`62aaeaaf107300a6f4f7ff52e98106c1520a9edbe2137626ee41091cf243e5c5`|
|3|121 t1603|76660 /450|`d78bf1895f5838b9eb8c6a22565a9588dae4fc8f7106697df373f4408aae634c`|
|4|122 t1604|19604 /562|`f6d628639de4e40005f62f63a49308ff9ee0656a36bb6eb7787230b4830a5ed9`|
|5|123 t1605|19154 /450|`9f58cad5621d89b7a7012036daa8532b2397b0d9d267ab7d1aa5a7cd10d7ae87`|
|6|124 t1606|73872 /530|`49cdc9ec812f4ef3826011d542c30afbb10229c4b4ce549e7820233bbaa53dd9`|
|7|125 t1607|17298 /458|`aaef2d59c2636c059b446bed643985ca55d15b2d070b0582b2d8994b3bf74f1e`|
|8|126 t1608|23440 /610|`bade574a4624a3f763ddd9c87fa2f102562b00d8d604e9faf32a43b372de64e0`|
|9|119 t1609|2438 /530|`0a663ddf2df9f1065f5e4ffe27b4d1fa96edd5f19b6323217bad4148f8d2f3d7`|
|space|−1 /null|table word4F5158|no canvas/no advance|
|minus|−1 /null|table word4F5172|no canvas/no advance|
## Formatting, advance and material facts
Baseball426754..42678D truncates the previously captured1D68 pitch to an integer,
pushes format string4EF440 (`25 20 2e 32 64 00`, `% .2d`), fontTIME, computed y
andx286 into468660. Y is `trunc((45-priorPitch)*4.3+100)`, with45 as source
float49D5C8 and4.3/100 as doubles4A3E40/4A3130. This occurs before4268A3..8A9
captures current camera pitch into1D68, supporting the separate DisplayPitch.
468660 formats into its local buffer and iterates characters.46891A gets the
glyph pointer,468931 calls the glyph emitter, and468939 tests that pointer.
For null pointers46893B jumps directly to46894C, skipping the x addition.
For non-null pointers46893D..468948 advances by `canvas.width*screenWidth/640`.
Therefore TIME space and minus are absent and zero-width. Every available digit
advances16 logical units; there is no kerning or extra letter spacing in this
path. A format result ` 09` draws0 and9 consecutively with no leading gap.
Pitch is clamped0..45 in the sustained-hold path, so a negative-number glyph is
not required for this bounded Baseball label.
4689F0 rejects null glyphs immediately at4689F8..4689FA and allocates no slot.
For a real glyph it binds the source canvas, sets custom width/height from its
pixel dimensions scaled byscreenWidth/640 andscreenHeight/480, alignment fields
BC=1/C0=2, source blend globals, white RGB at468AFE/468B08/468B0F and alpha from
4F4ED4 at468B17. 4689BF resets global alpha to1 after ordinary formatted text.
This closes the resource sizes, per-glyph step and material tint. General sprite
alignment caches, original frame scheduling, fixed-function alpha tests and
widescreen policy remain renderer boundaries rather than font-table gaps.
+97
View File
@@ -0,0 +1,97 @@
# Baseball gameplay integration
2026-11-02. User-directed gadget continuation after clean1ae5f42/50fcb87 Bubble.
Broad collision investigation remains parked. Scooter's recovered separate vehicle
and wheel dependencies are saved in scooter.md; no invented drive support was added.
## Coverage map
| Recovered original | Current implementation | Evidence / remaining boundary |
| --- | --- | --- |
| Item6/raw6 equip without energy gate | Source selection, Goddard hide/body flags, F1 grant | baseball.md; availability and display remain separate from raw mode |
| Hold/first-arm/later capture/release | Supported SHOOT, source Up/Down pitch, Left/Right yaw, first-arm saved value, prior label | Keyboard/primary subset; mouse/analog aim and global suppressor lifecycle remain open |
| complete84C camera scalar and7CC height | Default10, equipped height+30, source eye/target scalar terms, cleanup0/height200 then ordinary reset10 | Existing camera ray/smoothing/Euler/viewport boundaries remain |
| Release even after cleanup/at zero energy | Sound10 before launch, then pending clear and fixed−1 shared energy helper | Twenty owned entries persist independently of raw mode; no invented ammo or TTL |
| Launch local point/vector, speed1800 | Local(0,80,50), aim slope saved/45, quick magnitude, full transform bridge | Upright yaw tested; full source trig/Euler equivalence is unverified |
| Ball radius15/factor1/friction.46 | Explicit source body profile, prevent-lowering=false, delayed full-vector landing impulse, horizontal wall response | Angular reflection tail and general dynamic pairs remain open |
| Ball appearance | Exact RetainedSprites Canv2, source25-square billboard | Other preloaded ball canvases are not animated without a proven cadence |
| Aim strip/text | Exact screens253 at315,100; exact TIME set5 green16-square glyphs at286/302 | Full original sprite alignment/render state remains separate; uniform widescreen policy retained |
| VR07 registration/body | False game filter and bounded static Jimmy/ball body, textureless collision retained | Full material/scene flags and dynamic body interactions remain incomplete |
| Six moving3TAR records | Source-instance identity, source speed/destination/reset-to-start, hidden movement and15-second respawn | Body/controller partial order is implemented; full original registry order remains open |
| Target/parent callbacks |10-point hit, missing-parent198, strict>HitsRequired, parent collision/visibility and199 | Current sphere overlap discovers contacts; other enemies/ball consumers remain unported |
| Cutscene/debug/reset/load | Dedicated unconditional Baseball companion restoration, named-Jimmy cleanup, modern reset clears pool | Original retained helper/pool/latch lifetime across ordinary loads remains unresolved |
Source addresses/file offsets, fields, guarded bytes, REA Evidence and provider
limits are in [Baseball](baseball.md), [targets](baseball-targets.md),
[resources](baseball-assets.md), [TIME font](baseball-font.md) and
[review](baseball-review.md). All investigations used local generated copies;
originals were neither modified nor executed. Static projections, managed tests,
port GPU/native checks and original gameplay observations are separate categories.
## Runtime ownership
LabSimulation owns BaseballGadget, its shared camera scalar/height bridge and20
projectiles. Input updates camera adjustment before follow, then primary actions
after ordinary steering. Hold clears controller speed, requires support and the
shared energy gate for a new arm/capture, and selects SHOOT. First hold retains
old saved pitch; later hold captures clamped0..45. DisplayPitch stores the value
used before that capture. Release hides the UI and checks pending alone, so cleanup
does not silently cancel a throw. Audio request precedes launch; energy follows it.
SceneBaseballs owns source moving-target state and the bounded world/pair adapter.
Bodies run before player control; target timers and next velocity run afterward.
Landing sets an impulse from the old live velocity before support zeros Y; the
next body tick consumes it, including X/Z. Pool reuse preserves pending impulse
and support. Unequip retains flying balls. Modern reset/new scene clears the
port-owned pool explicitly; it is not a claim of original retained-loader parity.
Target activation calls the parent's source428 behavior, not the script trigger
interpreter. VR07's initially hidden trophy cannot be collected before activation.
Its HasCollision property controls pair enable independently of visibility and
integration. Baseball cleanup restores Goddard even in Invisible's six blocked
levels; that policy is covered separately in regressions.
Live ball bodies/contacts are bounded to LV1B,VR01,VR04,VR07 andLEV1. Other
levels do not yet run this consumer. The shared body remains the ordinary source
composition for Jimmy. Ball response
is an explicit profile; allowing ball wall materials does not imply recovered
special Jimmy contacts or lab/outside source-body replacement. Its horizontal
reflection uses the source normal/damping; the angular tail is omitted. Current
target/Jimmy recovery detection uses per-tick sphere overlap, with no claim of
source pair membership, discovery order, swept discovery or full enemy combat.
## Verification
Twelve managed groups cover arm/capture/display order, sound/launch/cost ordering,
release after cleanup, twenty-slot reuse, upright launch, queued landing impulse/.46 floor friction, wall reflection,
actual VR07 duplicate identities, target respawn/start reset, cutscene cleanup,
all six companion restoration exceptions, and real target contacts activating
the trophy on the strict fourth hit with HasCollision0/−1. Six visual groups
cover exact pixels, ball dimensions, degenerate camera bases, source aim layout,
widescreen/portrait scaling, combined mesh isolation and bounded resources.
Sixteen Baseball Python groups cover source projections, byte guards and exports.
Scooter source/resource regressions are separate. Independent review findings
were corrected and rerun; see baseball-review.md.
Headless and native Linux GTX1070/private Xvfb1920×1080 pass all eight rendered
phases: equip, first hold, prior-label/capture, release, flight, actual authored
target hit, unequip retaining the ball, and respawn. Real SDL Ctrl/Left/Up/Tab
arrives; enabled Vulkan validation reports zero errors. The fixture advances1010
extra ordinary player/body/target ticks between captures, preserving VR07 energy20.
No actor relocation or direct timer/body-state writes are used. This is an
accelerated port fixture, not original cadence/manual tutorial completion.
Aim/flight/hit readbacks are inspected. Logs: artifacts/baseball-implementation/.
Complete scripts/test.sh passes232 Python+2 HUD, all managed suites,32 main GPU
completions and17 material checks, zero enabled validation errors, SDL dummy
lifecycle and539 unchanged originals. Final focused12-group/16-source-group checks
cover the additional callback numeric assertions and font table guard. Clean package
results: both Linux/Windows packages identify clean d6ca417 (source_dirty=no).
All16 referenced Baseball/aim canvases match their original pixel hashes in both.
Standalone Linux from /tmp passes all eight gameplay phases and the1920×1080
expanded F1 Player view. Release validation layers are unavailable; enabled
source/native results remain separate. Both publishes succeed despite NU1900
metadata warnings;539 original hashes verify after packaging. Logs: package.log,
package-baseball.log, package-debug-player.log, originals-after-package.log.
Native Windows, whole-original runtime/visual comparison, retained
helper lifetime and complete combat remain open.
+81
View File
@@ -0,0 +1,81 @@
# Baseball implementation review
2026-11-02. Independent read-only review of BaseballGadget, SceneBaseballs,
OriginalBodyPhysics, LabSimulation, PlayerSceneBinding and Program wiring.
Source baseline/evidence and provider limitations are in
[baseball.md](baseball.md); no unchanged REA queries were repeated.
## Resolved findings
1. **Companion cleanup policy differs by gadget.** The initial implementation
subscribed Baseball.EquippedChanged to InvisibleEquipped, incorrectly skipping
restoration in LEV6/LEV7/LV1C/LV1D/LV4A/LV6A. Source raw6 cleanup42871D..878D
restores Goddard when its pointer exists without Invisible's9E8 skip test
(compare428144). PlayerSceneBinding now uses a dedicated BaseballEquipped
handler with unconditional restoration. A regression verifies all six levels.
2. **Initially hidden tutorial trophy contact must be disabled.** At review time
SceneBaseballs activated its parent with Active=Visible=true, while
SceneInteractions3TRO contacts used Active regardless of visibility or pair
enable. This permits collecting VR07's initially hidden trophy before earning
it. Primary subsequently added a narrow trophy pair-enable/activation correction
in SceneBaseballs and requires trophy pair enable in SceneInteractions. The
regression exercises real ball/target contacts, strict fourth-hit activation,
and HasCollision0/−1 behavior. It passes.
Do not replace this with a scene Trigger: target430570 calls parent428(1).
The source alias needed for the second correction is proven: pickup property
reader40D41A passes interface+584 and literal4ED26C=`HasCollision` to3FC, type6.
C3DVRTrophy interface table4BE404 has428→40E1F0. For argument1 it calls
3AC→4730E0→224(true) only when HasCollision is nonzero, then unhides through
complete58(0) when needed. Argument0 calls3A4→473030→224(false), then hides.
It does not enable214 integration, award score or invoke the script interpreter.
These are supplemental reviewed instructions; primary owns adding the exact
guards to baseball_targets.py. They are not attributed to new REA pseudocode.
## Checked source contracts
- Equip has no fresh energy gate. Camera height adds30; cleanup restores200
through170→437740 and clears pitch to0. Ordinary non-raw6 input subsequently
restores pitch10. Current Forward/Backward mapping correctly increases pitch
on Up and decreases on Down,20*fixed-dt; this source keyboard field is unrelated
to PageUp/PageDown.
- First supported hold shows the aim strip and arms without refreshing saved
pitch. Later holds clamp0..45. DisplayPitch is copied before capture, matching
the original one-invocation label delay. Release hides the strip and launches
once from the saved pitch, including after unequip and at zero energy.
- Cleanup retains pending throw, saved pitch and20 projectile entries. Source
ring reuse does not clear pending impulse/support; current Launch preserves
both. Modern scene reset clears the pool and is an explicit lifecycle boundary.
- Projectile launch uses local(0,80,50), normalized local aim slope pitch/45,
source quick magnitude and speed1800. Upright yaw cases pass. Continuous
full-Euler transform remains a declared original table-precision boundary.
- Ball floor friction and wall damping both read slot248/live150=.46;
authored24=3.2 belongs to a different field. Floor support uses radius15,
factor1, prevent-lowering=false. Current Projectile.Step explicitly supplies.46.
- Landing queues oldX,−.65*oldY,oldZ into impulse before support zeros velocityY;
next body consumes it. Current implementation preserves this phase order.
- Program runs ball/target bodies before player input, and target frame callbacks
afterward. Input ownership follows LabSimulation's controlled path. Release
from a pending latch is processed even when raw6 is no longer equipped.
## Declared limits, not release claims
SceneBaseballs uses per-tick sphere overlap instead of original pair membership,
registry order and swept discovery. It can re-hit an overlapping ball after a
target respawns, whereas original enter callback timing still needs the pair
scheduler. Whole-scene pair response and other ball consumers remain incomplete.
Ball angular wall response is omitted, and each managed ball tick supplies zero
angular state; its billboard's positional path is the bounded tested subset.
Only Canv2 is used because no four-canvas animation advancement was recovered.
The full original game and native Windows input have not been runtime-compared
by this review.
## Verification
`dotnet run --project tests/GamePort.BaseballTests --no-restore` passed11 groups
with the local .NET environment. Python discovery `test_baseball*.py` passed16
groups covering source guards, resources and target projections. These results
were rerun after the companion/trophy fixes. No remaining concrete blocker was
found within this bounded review; the declared limits above remain. No runtime
or shared source was edited by this reviewer.
+99
View File
@@ -0,0 +1,99 @@
# VR07 moving targets and Baseball contacts
2026-11-02. Static recovery and source projections; original whole-game execution
has not been observed. Original EXE SHA256 is
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
`tools/binary/baseball_targets.py` guards the reviewed spans, virtual bindings,
factory and false registration filter. It reports PE-mapped offsets. All code
addresses below have file offset VA−400000 in this executable.
## Evidence and identity
The generated EXE copy was inspected with local REA/Ghidra12.1.4, profile digest
`e1ad533d4cc0333c2136fe0894217de2d61feea098240326e78633f9e4ddcbf9`.
Complete Evidence and a closed snapshot are retained in
`artifacts/baseball-targets/rea-local-ipc/`:
| Procedure | Evidence |
| --- | --- |
|430220 moving-target construction|ev_3e420d49b2d4d524b6a80f3aebddef7d54863186d417cfc3b48d0f2a20b0fa29|
|430570 Baseball contact|ev_3a2778c478e072e201b1e3baaf87434837fd570a00b5ee84022491175c00c7c4|
|441AC0 sprite PostLoad|ev_236e87925819c8924f5becb9a72da56152655b79d0527a2d81bdef32c912917f|
|4573F0 VR07 construction|ev_11fddbe40ea4b959e27cba000aa4557cb04b2d4d104b11f155feedf88a97f04c|
4306B0 and475CD0 were not recognized procedures and the provider's numeric
fallback interpreted them as unmapped file offsets. Their behavior is supported
by guarded disassembly, not attributed to pseudocode. The initial restricted
attempt failed at the Ghidra local socket; its owned batch was interrupted and
has no close/snapshot artifact. The later successful session explicitly closed
and exported its snapshot. Permitted local IPC resolved that host restriction. No client configuration
or original bytes changed. REA inspection is static, not target execution.
3TAR's actual factory45CA06 constructs430220, complete table4A8E74, game interface
complete+C8/table4A8A10. Do not confuse it with Jimmy's C3DTarget aim helper or the
different4453B0 class also registering3TAR. Actual runtime type is C3DMOVINGTARGET.
VR07 constructor4573F0 binds complete game4CFAE0; slot134→475CD0 returns false
(`32c0c21800`), permitting the previously recovered NC/checkpoint registration
filters. VR07 has134 serialized triangles and no special Jimmy wall materials.
Textureless triangles remain collision candidates even though rendering skips them.
## State and interaction
| Complete field | Meaning / writer |
| --- | --- |
|57C/580/584|Sprite size/index/database; defaults100/98/sprites.omt; GAM overrides150/135/sprites.omt|
|5EC..5F8|Start XYZ/W, W initialized1|
|5FC..608|Destination XYZ/W, W initialized1|
|60C|Speed, default100|
|610|Respawn timer, initialized0|
|614|ActivateObject name|
|678/67C/680|HitsRequired(default5), NumPoints(default10), RespawnTime(default15)|
Source radius75 is set at430485. World response and support are disabled by
430478/430480; integration is enabled430495. Frame game3C4→4306B0 first invokes
463090, then updates orientation, respawn and velocity. Positive respawn subtracts
dt with a float store; <=0 clamps0 and unhides. Hidden targets keep moving.
The vector to Destination is quick-normalized and multiplied by Speed. Ordinary
sqrt distance<100 then teleports to Start through314. Endpoints are not swapped;
the just-published velocity survives the teleport into the next integration phase.
Zero-length normalization is explicitly bounded to zero in the modern port.
Contact game40→430570 first calls470A90, then accepts C3DBASEBALL only while
timer<=0. It hides the target, copies RespawnTime, and awards NumPoints through
42ADC0. It does not hide/destroy the ball. Lookup of ActivateObject returns the
first matching tagged actor. Missing parent requests SFX198. A C3DTROPHY or
C3DPICKUPITEM parent has its respective hit counter incremented; activation
occurs only when count **> HitsRequired**, then resets counter and requests199.
This strict comparison requires four qualifying contacts for VR07's value3.
Trophy interface4BE404 slot428→40E1F0 takes activation1, conditionally enables
collision via3AC when interface584 is nonzero, then unhides. It does not execute
the script trigger interpreter or restart integration. Activation0 disables
collision via3A4 and hides. The port preserves that limited visibility/contact
operation; its existing actor flags remain a narrower adapter than all source flags.
## Actual tutorial and implementation boundary
VR07 GAM SHA256 is
`1260b75d82ec794f9375ada30e186424746bc1dd4e4b0540c9b69bb7ad12d0b1`.
Six3TAR records at file offsets885,AD6,D27,F78,11C9,141C all use the same tag
C3DMOVINGTARGET. They must be stored by source instance/offset, never collapsed
by a tag dictionary. Each has speed100, score10, respawn15 and HitsRequired3.
Only record11C9 names parent `trophy`; the others name `none` and produce198.
The original visible target is the explicitly serialized sprites.omt Canv135
star,150×150.441AC0 proves that binding; RetainedSprites Canv8 `target` is separate.
SceneBaseballs separates body integration before controller from target frame
updates after controller. Pair discovery currently checks current sphere overlap
at radii15+75 and Jimmy recovery15+player radius. This is a declared modern adapter,
not recovered47A580 registry ordering, swept dynamic contacts or full enemy combat.
Static ball response uses the source body/grid/support with ball callbacks; its
angular reflection tail and full logical/render Euler lifecycle remain open.
VR07's hidden trophy has contact disabled until its source activation so the
existing pickup adapter cannot collect it while invisible.
Four Python groups cover identity/spans, duplicate source identities, hit gate,
stored respawn subtraction and strict parent threshold. Modern managed/native
results are recorded separately in baseball-implementation.md. Retained helpers
across level loads, moving target generic flags/rotation, full original cadence,
original runtime and native Windows comparison remain unresolved.
+144
View File
@@ -0,0 +1,144 @@
# Baseball source contract
2026-11-02. Static recovery; original EXE SHA256
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
Text raw offsets equal VA−400000. The helper PE-maps and guards15 reviewed
source ranges,13 virtual targets and8 constants. No original game code was run.
## Practical scope
Baseball is feasible as the next bounded gadget with VR07 targets. It needs a
20-entry projectile pool, original sprite, primary hold/release state and narrow
ball-specific physics callbacks. Broad enemy AI is unnecessary for VR07's six
3TAR objects. Target behavior/registration is independently owned in
[baseball-targets.md](baseball-targets.md); resources in
[baseball-assets.md](baseball-assets.md). Generic full-scene collisions remain
outside a claim of finished gadget fidelity.
## Evidence and provider boundary
Local REA/Ghidra successfully decompiled constructor40FC50, Evidence
`ev_5c45397cd90b6247920a64a8b27d2838d805a8e1eebba69886f7ffd81d62993a`,
and physics scheduler479BC0, Evidence
`ev_56b7e074ec8509d1c5b3576d02361ff051963b777d7ccb8259ed9c65dc2db52f`.
Complete replies, exported bundle and closed snapshot are in
artifacts/baseball-contract/rea-local/. The initial sandbox attempt could not bind
the Ghidra Unix socket; its errors remain in rea/. The local permitted execution
completed. Queries426030,429A30,40FF40,40FF80,427FF0,428D50,472B10 were not
recognized as procedures; provider then interpreted numeric selectors as unmapped
file offsets. Their behavior below uses reviewed guarded disassembly, not claimed
successful pseudocode. Whole-game execution, original runtime comparison and
arbitrary-input x87 equivalence are unverified.
## Owners, equip and cleanup
Jimmy complete table4A3BDC:174→428D50 equip,178→427FF0 cleanup,
180→429A30 throw,148→429A00 stops saved soundA44 only,170→437740 camera defaults.
Item6 dispatch table4298E8+7*4→4296F8; raw6 cleanup428844+6*4→42871D.
Equip4296F8 sets raw4F0588=6 with **no energy gate**, adds30 to camera scalar
complete7CC, hides menu+4E4 if needed, then hides Goddard and disables its body
214 and visibilityD0. Practice item9==2 then selects VR07 through42976C..7D8.
Cleanup42871D clears complete84C (camera/aim scalar), restores Goddard and shadow,
calls170 camera defaults, hides menu4E4, then common tail sets mode−1.
It **does not clear** pending throw complete1E26 or saved pitch1E28, and does not
destroy or hide the20 flying balls. A later release can therefore still throw.
Constructor422609..269C allocates20 C3DBaseball complete objects of61C bytes,
stores pointers at Jimmy+AB4..B00 and initializes signed WORD B04=0. Ball game
interface is complete+C8 (table49141C), unlike Jimmy+C0. Pool capacity is not an
ammo count; current nonnull slot is reused and B04 increments modulo20. Null
slot leaves index unchanged. No ammo decrement is present in this launch path.
## Hold, pitch and release
426030's existing ownership/modal gates and movement438A60 precede primary
actions. Held predicate is helper42A7A0 OR separately polled Enter; release means
both false. Helper includes mouse/Enter/Ctrl/controller and suppressor4F83E0.
42668F..66BD rejects busy1D65, modal4F8182 or raw0, then zeroes controller
speed608. Energy helper4269D0 rejects energy<=0 unless complete9F8 override.
No minimum1-energy threshold is required. Ground support is necessary to enter
the raw6 aiming branch; airborne raw6 follows existing primary behavior.
Ground hold426718 selects SHOOT, calls148 to stop sound, then raw6:
1. Emit angle text for the **previous saved pitch**1E28, before any new capture.
2. Show fixed menu4E4 crosshair strip.
3. First held tick sets pending1E26 and calls148 again; it does not capture pitch.
4. Later held ticks clamp complete84C to[0,45], then copy it to1E28.
The same complete84C is modified by ordinary input438C2C..CC6;4267D3 reads it
as interface+78C. It is **not logical EulerX**. Down(VK_DOWN28/address509860) decreases
it20*dt; Up(VK_UP26/address50985E) increases it20*dt. Otherwise signed mouseY*dt
is added, with analog threshold branches. Raw6 preserves it when not firing;
other modes ordinarily reset10. The camera uses it through439625 (eyeY offset
7CC−2*84C) and4396A9 (targetY7DC+scale*84C). This is independent of throw's
full logical-Euler point/vector transform.
Menu4E4 is screens Canv253,15×210 at logical(315,100), scale1, initialized hidden
at4020DD..2104. Hold shows it, release426585 hides it. The adjacent numeric text
call468660 is variadic formatted text (vsprintf at468694), not sprite animation:
x286,y=trunc((45−savedPitch)*4.3+100), identity54494D45, format`% .2d`,
value=trunc(savedPitch). This yields a positive blank plus two precision digits.
TIME selector468C23 uses font5;46844A loads its64-word map from4F4ED8.
Digits0..9 map to alphaCanv[118,127,120,121,122,123,124,125,126,119].
SPACE maps−1/null; null-glyph advance is separate asset/UI work.
Release42659F..65F9 tests pending alone, plays SFX10 once, stops soundA44,
calls complete180 with(0,80,50,savedPitch), sets interfaceA48=0, clears pending,
then energy42A920(−1). It performs **no fresh mode, support or energy gate**.
Shared energy exemptions/clamps/warnings apply; VR07 is exempt. SHOOT uses the
existing authored shooting clip; no bespoke baseball throw clip was established.
## Launch and body callbacks
429A30 transforms local spawn point(0,80,50) through interface384 (472980),
unhides selected pool entry, enables collision224 and integration214, publishes
root314, transforms local vector(0,float32(savedPitch*float32(1/45)),1) through
38C (472B10), quick-normalizes, then sets velocityXYZ×1800 through2C4.
It does not clear pending impulse or support on reuse. For upright logical
pitch/roll0, yaw theta gives spawn root+(−50sin(theta),80,50cos(theta)) and
velocity1800*normalize(−sin(theta),savedPitch/45,cos(theta)). Source trig-table
quantization and imported quick magnitude differ from continuous host math.
Constructor40FC50 binds retainedsprites.omt Canv2 with sprite size25; preloads
Canv2..5. Complete57C=25 is size, **not a3D shapeID** (435430→464430).
It sets radius15, authored property24=3.2, wall damping28=.46, and leaves the
floor support factor1. Floor friction also reads slot248 and is.46 (47A356); suppression scale.5.
Pool initialization hides it, disables integration214 and collision224; launch
enables both. Generic defaults include support1C8=true, world1D0=true,
reflection1D8=true, prevent-lowering208=false. Constructor sets authored204=false
and224=false. Do not confuse authored field offsets, live fields and slots.
|Ball interface slot / implementation|Effect|
|---|---|
|370→40FF50→472690|Ceiling callback: independently clear positive velocityY and positive accelerationY.|
|374→40FEE0→458890→378472750|Generic wall reflection. Normalize horizontal velocity; reflect using supplied normal; rescale by old horizontal magnitude; preserve oldY; damp resulting XZ by(1−slot248), where slot248 reads wall damping.46. Angular heading response is an additional source tail.|
|37C→40FF80|Read live velocity2BC; store queued impulse288=(oldX,−.65*oldY,oldZ). **This is not a velocity write.**|
|3C4→40FF40→463090→458930→473240|Generic update; no baseball-specific TTL or canvas-frame advancement recovered.|
Support47BB10..BBA7 publishes floor root, zeros accelerationY, invokes37C only
on previous-support=false, then zeros velocityY and sets support true. Next
ordinary body tick consumes queued impulse before acceleration/gravity. Because
37C queued full X/Z, horizontal speed can increase on the next tick; do not
silently discard those components. See existing
[body composition](../checkpoint/collision-body-composition-source.md) for
gravity, displacement, static support/friction and publication order. Ball's
factor1/radius15 and no prevent-lowering must be supplied to a ball adapter;
Jimmy-specific callbacks are unsuitable. No automatic first-hit destruction or
fixed-distance/time expiry is justified by this class.
Jimmy enter423014..307D recognizes C3DBASEBALL, disables ball214/224 and hides
it. Other objects own their contact effects. A target hit cannot be presumed to
consume a ball solely from its name; target and dynamic-contact scheduling need
their own source boundary. Cleanup6 leaves balls active; scene/pool ownership
must survive until its actual loader/reset boundary.
## Verification
tests/test_baseball.py verifies source identity/ranges/virtuals, first-hold versus
later pitch capture, stale displayed pitch, hold gates, release after cleanup,
ring reuse/null behavior, upright launch offsets and delayed full-vector landing
impulse. These are bounded static projections, not original execution or modern
runtime verification. Frame animation of the four preloaded ball canvases,
general dynamic collision response and exact trig precision remain unresolved.
+183
View File
@@ -0,0 +1,183 @@
# Bubble body, VR01 registration and support material
2026-11-02. Independent investigation; no modern runtime files changed. The
ordinary body can accept Bubble's radius/factor and actual VR01 static geometry,
provided the separate retained support-material callback is preserved. VR01 has
no special wall374 polygons; it does have a consequential lava floor111.
This does not reopen dynamic actors or all special-contact policies.
## Evidence and scope
EXE SHA256 `f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
OMT DLL SHA256 `3ec41ead011adf56387a6dbd4580e5b5a9721b5f8020c8a56420f42824354943`.
`tools/binary/bubble_body.py` PE-maps eight bounded body hashes,27 fixed sites,
ten virtual targets and the DLL texture-pointer publication, then independently
decodes VR01/VR04. Text VA minus400000 gives EXE raw offset here; DLL source
100013B5 maps raw13B5. Full facts/hashes are in
`artifacts/bubble/body/source-contract.json`; raw disassemblies sit beside it.
Relevant reused REA Evidence, with complete reports already retained:
| Source | Evidence | Retained location |
| --- | --- | --- |
|479D20 integration|`ev_5439072b32ae9f9208795ad2b07bc524e2407b46da487072fb3dfd8c10e7c4b0`|artifacts/collision-response/rea-response/|
|40E050 animated base|`ev_03a109302788b85597e253293bbcb535c4080732e41cc828bb33d01d2b2da09a`|artifacts/uncontrolled-phases/rea/|
|462520 support/material bridge|`ev_f0a2e1fd465472295b272f2fdbfb6be4651aeb8c35d90dc2ca02a495ed359edd`|same|
|OMT material read10001490|`ev_f592b625a60ec683a17627d671c47d78d722eb39d5eb407744d53a283ee2586d`|artifacts/collision-integration/contacts/rea-material-identity/03.json|
|Bubble equip/cleanup|[Bubble source report](bubble.md)|artifacts/bubble/rea-effect/|
New REA/Ghidra factor-setter4711E0 Evidence
`ev_5d2495e741932d9eb7b5a687d31b4fcc7a398d890797247ddf262677f6cf490f`
is saved/exported/closed under `artifacts/bubble/body/rea-ipc/`.
It confirms authored2C is stored and forwarded through254 to live154; the
setter changes no root.424600/44E030/4252E0 were not recognized as procedures;
their VA queries fell through to unmapped file-offset errors. These are saved
provider gaps, not successful pseudocode. Their contracts use reviewed bounded
instructions and fixed guards. The first `rea/` attempt failed because the host
sandbox denied the Unix socket; the successful local IPC retry is separate.
## Body parameters and root alignment — recovered and probed
Equip429049/429058 sets authored/live radius160 and factorfloat32(.415).
Cleanup42809C/4280AB sets60/float32(1.265). Supported wrapper42469B..4246E9
restores **live** radius160 for raw mode0,60 otherwise; it does not set factor,
reposition root or add a landing callback. It is outside the controller raw-owner
gate. The existing OriginalBodyPhysics.Step already accepts radius and factor;
the live caller must pass the current factor instead of fixed1.265.
Support47B890 uses radius×factor for final root offset. Bubble's66.4 is lower
than ordinary75.9 despite the larger collision sphere. Prevent-lowering208=true
rejects downward root correction. Consequently equip must not immediately move
the root downward, and cleanup must not preserve Bubble66.4 as the ordinary floor
offset. Inherited Jimmy landing37C→472970 is a return. Support publishes shape34C
and polygon33C through plain setters4725C0/472580; these perform no special callback.
Six additional copied-original body fixtures ran atdtfloat32(1/60), gravity−800,
friction.8, suppression.5, ordinary integration/support/world flags, no dynamic
pass and a synthetic flat triangle. Source479D20/support instructions ran inside
a copied generated32bit process; synthetic virtual methods supplied body state,
no-op contacts and a landing observer. The game entry point, real Jimmy, source
input/audio/scripts and actual VR01 geometry did not execute.
| Fixture | Original observed rootY | Original observed Vy/support |
| --- | ---: | --- |
|160/.415 at66.4|66.4000015|0/true|
|160/.415 at26|66.4000015|0/true|
|Equip160/.415 from ordinary75.9|75.6777802|−13.333334/false; no forced lowering|
|Cleanup60/1.265 from66.4|75.9000015|0/true|
|160/.415 at66.4, priorVy300|71.1777802|286.666656/false|
|160/.415 at66.4, priorVy900|81.1777802|886.666687/false|
Data, binary/source/header hashes and scope are in
`artifacts/bubble/body/original-body-results.json`; full output is
`probe/wine.log`. `--probe-source` generates the fixture source from the existing
body harness. Compile with `i686-w64-mingw32-gcc -O0 -Wall -Wextra -Itools/binary
-Iartifacts/bubble/body artifacts/bubble/body/bubble-body-probe.c -o
artifacts/bubble/body/probe.exe -lm`; generate the guarded header through
body_step_evidence.py. Run only through reference_capture.py with its copied game
directory and no-network/no-original-mount namespace. Initial6second Wine prefix
setup did not complete; the next prefix failed kernel32 loading. Both logs remain.
A separate copy of the prior working prefix completed the probe with exit0.
The constant75.9 ActorRoot/feet/render bridge remains a **modern approximation**.
Changing that bridge to radius×factor on every equip would introduce an immediate
root/render movement not justified by either setters or this probe. Preserve the
documented visual boundary and test source physics roots independently.
## Actual VR01 static filter and material coverage — closed for this archive
455EF0 constructor binds complete game table4CD740 at455F5A and registers
FourCCVR01 at455FA8. Its134→475CD0 returnsfalse, so the shared loader imposes
no extra game polygon exclusion. Shared NC44DD64, checkpoint4791C7 and
game4791D9 filters match the existing route adapter. Source shape-ID enumeration
is valid here: the archive has only contiguous shapeID0, VRRoom. All polygons
have three corners. No NC shape or checkpoint material is used.
| Archive | Shapes | Registered/all | Wall grid | Used material IDs |
| --- | --- | ---: | ---: | --- |
|VR01.omt|0 VRRoom,60 vertices|80|60|0,1,2,3,4,111|
|VR04.omt|0 Box01,336 vertices|508|420|0,2,3,4,6|
VR01 polygons48..53 alone use111 (`112lava`), all stored normalY=.991954..1.
They never register in the wall grid (requiresY<.7), so cannot dispatch370/374
through static traversal. The other eligible wall374 IDs0..4 are ordinary.
VR01 source GAM contains16 entities including one3ROC, two3PHO and a3TRO, no3SOL;
absence of soldiers does not prove all actor pairs ineligible. Dynamic actor
collision remains excluded exactly as in the bounded VR04 body implementation.
## Retained support polygon and floor111 — distinct callback
Support's no-op landing does **not** prove the floor harmless. Current support
is cleared at the next body start, but stored polygon338 is not cleared there.
462520 checks gameplay475CA0, integration210 and nonnull stored polygon338.
It reads polygon+4 material and material+80 **texture pointer**, then calls game130
with actor/material/texture/dt.44E030 requires nonnull actor and texture, resolves
material+0C→chunk+8 signed resourceID, and checks actor FourCC3JIM.
There is no218-grounded test in the110..119 branch. Preserve the last successful
support polygon until a later successful support overwrites it, even in flight.
The actual VR01 used materials all link Canv resources;111 links Canv6. This
nonnull texture gate is not the material payload's trailing3. OMT's exported
set_texture100013A0 writes the texture at+80,100013BB.
Order:424C34 calls437940;43796A calls40E050;40E0EB calls462520;46258F invokes
VR01 game130→44E030. This is before controller ownership437A2B, before applying
mode2 bounce and after the wrapper ceiling/downward queries. It remains eligible
when Jimmy is uncontrolled, subject to the common gameplay/integration gates.
For actualVR01 IDs0..4/111, the bounded source policy is:
- Enter110..119 at44E170: if complete1E02 isfalse, invoke198→42AB00 then set1E02.
42AB00 requestsSFX39 unconditionally and190 only if raw mode!=0. Bubble keeps39.
- Invoke164→42A8D0 every eligible base tick. It returns immediately if complete
1DEC isalreadytrue or raw mode==0. Otherwise set1DEC=true, sharedtimer1DE8=0,
call42A920(−5),42ADC0(−5), then complete1E0→425120. Energy retains common VR01
exemption; score still clamps after−5.425120 cancels only movementmode1.
- Leaving110..119 clears1E02 through19C→472970(no-op). Leaving does not clear1DEC.
Cleanup while still over retained111 therefore starts damage on the next base
tick without replaying entrySFX39/190 if the entry latch is stilltrue.
-111 chooses game sound selector35; IDs0..4 choose5. Selector change invokes
complete1E4→42AEC0, which only retargets a pre-existing A44 loop handle, stops it
and starts the new resource repeating. Full movement-footstep ownership is open.
This policy justifies an explicit VR01 floor111 handler, not every special contact
on LV1B/LEV1. The source ordinary wall callback remains unchanged for Bubble;
do not add generic horizontal reflection. Controller bounce/held-jump/SFX106 is
recovered separately in [bubble-motion.md](bubble-motion.md).
## Lava flash phase and rendering boundary
Late wrapper424C88 invokes4255C0. With other damage states1DED/1E03 false,
4257D6 addsdt to shared1DE8 while1DEC=true.4257E8 compares the retained x87 sum
before4257EE stores thefloat timer; the later pulse also consumes the retained
sum. Strict sum>4 (49D5E8) clears1DEC and writeswhite; at exactly4 it still flashes.
A sum just above4 can clear1DEC while the persisted timer rounds to4. Otherwise
`pulse=(sin(timer*20)+1)*.5`. It directly writes complete5C0 material+4C..58 as
RGBA(pulse,1,pulse,1). Raw mode0 does not stop a previously active flash.
42A8D0 does not call114 or another linked-material alpha setter.
1DED has earlier priority/return;1E03 precedes lava and shares the timer, possibly
addingdt before lava addsdt again. Those other damage policies remain outside
this slice. Invisible114 writes all linked materials, while this late source
write targets the one5C0 material. A port must retain explicit material-write
ordering or document the bounded renderer approximation. A fresh per-frame
Invisible RGBA snapshot cannot silently erase a retained lava write.
## Validation and recommendation
Five Python groups pass in `artifacts/bubble/body/tests.log`: original guards,
actual archive registration/texture/material coverage, Bubble entry bypass,
cleanup damage/strict4second flash including compare-before-store, and base callback gates. Six copied original
numeric cases pass as above. No modern build, port gameplay or whole original
gameplay was run by this investigator. Confidence is high for guarded source
order, actual archive counts and the isolated flatfloor body outputs; whole actor
pair eligibility, all damage-state interactions and original visual equivalence
remain open.
Minimum bounded integration: admitVR01 in the source static factory after these
registration checks; pass radius160/factor.415 and restore60/1.265 without direct
root correction; retain support polygon/material independently ofcurrent support;
run the explicit111 phase before controlled movement plus its late flash clock.
Keep dynamic/special walls parked, and preserve the75.9 render bridge explicitly.
If the111 pipeline is omitted, limit claims to raw0 Bubble body and keep ordinary
VR01/postcleanup floor behavior marked incomplete. A mode0 radius alone never
establishes full Bubble support/collision fidelity.
@@ -0,0 +1,55 @@
# Bubble implementation review
2026-11-02. Independent source review of the current integration against
`bubble.md`, `bubble-motion.md`, `bubble-body.md`, `bubble-rendering.md` and
their recorded source contracts. Read-only inspection of runtime/test files;
this report is the reviewer's only edited file. No new binary recovery or
original-game execution was performed. No blocking implementation mismatch was
found within the declared bounded profile.
## Checked contracts
| Contract / source evidence | Current implementation |
| --- | --- |
| Equip429049..429085 and cleanup428037..4280BB | `LabSimulation.GadgetMode` sets raw0/movement2, radius160/factor.415/max1350, preserves root/queued body state, and rejects existing effect flags. Cleanup restores60/1.265/mode0 and source max650, calls Stop and separately clears expansion. |
| Input426084 then drain426264..42629F and placement4262A5..4263DA | `StepInput` updates steering/camera, adjusts shared energy, performs depletion cleanup, then captures BubbleRoot from the resulting camera eye even when that cleanup changed mode. Rendering consumes this stored root. |
| Input/Jimmy/Bubble partial order | Fresh `Step` schedules input before the player and owned effect afterward; retained-order policy places input after the effect. Effect time advances without raw input ownership. Retained helper lifetime is still an explicit inference. |
| Mode2 apply4387E0 and input439900 | Fire supplies throttle while ordinary beam/jetpack dispatch is suppressed. Supported input decay and later scalar halving remain separate. Bounce assigns liveY300/900 after XZ composition, publishes the post-half scalar, retains mode2 and requests106 only for held jump. |
| Supported wrapper42469B..4246E9 | Supported Bubble retains radius160 and STOP; equip/cleanup do not directly recenter the actor root. The fixed75.9 render bridge remains a stated modern boundary. |
| Body479D20/support47B890 | Current radius/factor reach `OriginalBodyPhysics`. Production admission remains VR01/VR04; lab/outside retain their prior capsule adapter. No dynamic actor or generic special wall policy is newly implied. |
| Retained polygon338 →462520→44E030 | Successful source support updates retained material independently of current support. Actual VR01 profile0..4/111 runs before the controller gate, including airborne/uncontrolled ticks; Bubble skips the specific damage callback but preserves entry39 and the latch. Cleanup permits damage on the retained111 without replaying entry sounds. |
| Late lava4257D6..4257EE | Float timer persistence is separated from the unrounded strict>4 comparison and pulse input. `Vr01FloorState.Step` runs after Invisible's material requests; stored `PlayerAppearance` prevents a fresh Invisible snapshot from erasing late RGBA. |
| Source practice428F61..428FCA | Bubble practice selection updates display selection and requests the scene without starting live body/effect setup. `GadgetScreen` and cleanup use raw mode separately from display selection, including rejected Invisible equip. |
| Sprite410AE0/410CA0/410D00 | Independent flags, active/expanding/collapsing priority, strict fade boundaries, full RGBA, retained dimensions and original Canv1 pixels remain intact in effect/visual components. |
## Verification
Reviewer reran from `GamePort/`, with the local SDK environment and
`--no-restore`:
- `dotnet run --project tests/GamePort.BubbleTests`:13 groups passed, including
six copied-original numeric body references and actual VR01 retained111.
- `dotnet run --project tests/GamePort.BubbleMotionTests`:11 groups passed.
- `dotnet run --project tests/GamePort.BubbleVisualTests`:8 groups passed.
These are managed source-projection/integration checks. They do not establish
whole original-game behavior, GPU appearance, sound audibility or native Windows
runtime compatibility. Full-suite, packaging and presentation results belong to
the primary integration report.
## Remaining boundaries and useful follow-up
The declared `TracksBubbleOrientation` profile preserves the prior yaw-only
baseline before first Bubble use. Its destination handoff follows the recovered
conditional ground/ordinary-air contracts; shared generic interpolation enable,
dirty flags and transform scheduling remain open. The source camera adapter,
mouse/analog extensions, complete retained-helper lifetime, other damage flags,
footstep-loop ownership, dynamic pairs and broader special contacts likewise
remain open. No universal hazard immunity or original visual parity follows from
this slice.
Optional future regression strengthening: assert the exact captured-root formula
against the post-input camera eye, and explicitly compare fresh versus retained
input scheduling at an effect start/cleanup boundary. Current code follows those
orders, but existing frozen-root/independent-clock assertions cover only part of
that contract. No extra runtime code or new tests were added during this review.
+115
View File
@@ -0,0 +1,115 @@
# Bubble gameplay integration
2026-11-02. User-directed gadget continuation after1897dd2/9ea5784. The broader
collision checkpoint remains parked. This adds Bubble's original sprite/controller
and a bounded source static-body/floor profile in its actual VR01 tutorial.
## Coverage map
| Original system | Current implementation | Evidence / remaining boundary |
| --- | --- | --- |
| Item0/raw0, movement2 | Separate inventory/display/body/controller state; failed transitions retain raw−1 | bubble.md, bubble-motion.md; full inventory/equip policies for other gadgets remain open |
| Radius160/factor.415, cleanup60/1.265 | Source body parameters; no direct root recenter; cleanup maximum650 | bubble-body.md; six isolated copied-original body references match managed results |
|439900 input/4387E0 apply | Fire/Up throttle, turn±50, supported input decay, XZ before scalar halving, direct300/900 bounce | Keyboard subset; mouse/analog and full scheduler remain open |
| Action/orientation | Supported STOP, retained unsupported pose, recovered tilt targets/math | Bubble orientation bridge; complete generic Euler/dirty/camera ownership remains open |
| Bubble410AE0/410CA0/410D00 | Independent visual clock; exact flag priority/strict fade;240 pulse; full RGBA | bubble-rendering.md; default additive branch, modern world-billboard basis/depth policy |
| RetainedSprites.omt Canv1 | Exact146×146 pixels, bounded exporter/manifest/runtime hash check | No invented sphere or Jimmy scaling; original renderer orientation/UV padding remains open |
| Controlled drain/sound |−.5dt via shared energy owner; loop2; held supported106; cleanup stops loop | Tutorial helper immunity; raw-null input can stop drain without stopping visual clock |
| VR01 floor111 | Retained support identity, entry39/optional190, raw0 damage bypass,−5 score/energy and strict4-second flash | Other damage flags and full footstep-loop ownership remain open |
| Material write order | Stored PlayerAppearance receives Invisible alpha/blend requests and later lava RGBA | Current single-atlas material; complete linked models/material/render states remain open |
| Practice/cutscene/debug | Bubble practice precedes live equip; actual raw-mode menu gate; named Jimmy cleanup; F1 grant and diagnostics | Owned helper lifetime across ordinary loads and native Windows/original whole-game comparison remain open |
Source hashes, VAs/file offsets, structures, byte guards and REA Evidence are in
[bubble.md](bubble.md), [motion](bubble-motion.md), [body](bubble-body.md) and
[rendering](bubble-rendering.md). Complete exports and closed snapshots stay in
artifacts/bubble*/. Copied-original execution is limited to the isolated body
routine with synthetic virtuals, not the game entry point or original gameplay.
## Runtime ownership and boundaries
LabSimulation owns BubbleEffect, its captured world root, radius/factor/current
maximum and mode2 motion. Input uses source steering/camera before drain/placement;
depletion cleans the mode but still captures the final sprite root. Fresh input
precedes Jimmy; the effect clock runs after Jimmy before retained-input policy.
Fresh callback partial order is source-supported. Complete retained helper
survival/initialization remains unresolved, so retained-helper parity is not claimed.
The supported wrapper selects STOP and radius160. Mode2 bypasses normal550 jump/
jetpack state changes and remains2 through landing. Apply preserves incoming liveY
when unsupported. On support, held jump sets liveY900 and requests106; released
jump composes XZ, then halves the published scalar and sets liveY300 without sound.
Acceleration and pending impulse are not cleared on equip/apply. Cleanup restores
radius60/factor1.265/movement0/current maximum650 and begins the independent fade.
SourceA20=.5 cleanup write has no closed consumer; no guessed countdown is added.
Source static response is enabled for VR01 in addition to VR04. Actual VR01's
80 polygons/60 wall entries have only ordinary wall materials; its six111 polygons
are support surfaces, not wall374. All used original materials have linked textures.
The base callback consumes retained support material even while currently airborne
or uncontrolled, before controller movement. Ordinary floors clear entry state;
Bubble raw0 prevents new lava damage but does not erase an existing flash.
Tutorial exemption skips energy loss, not score loss. The late flash writes RGBA
and preserves blend-enable/factors, correctly retaining its interaction with
Invisible's material requests. Other damage flags and dynamic pairs remain out
of this bounded profile. Missing material is skipped; texture-link eligibility
is source-verified for these actual VR01 IDs, not a general textureless-material
implementation for other scenes.
The existing fixed75.9 root-to-feet/render bridge remains explicit: Bubble physical
support is66.4 and equip does not force a downward root correction. Lab/outside
continue using their provisional capsule/dynamic adapter; this is not a claim of
source Bubble collision in those scenes. Shared camera targets/smoothing/clipping
retain existing approximation gates, including known Bubble follow differences.
TracksBubbleOrientation preserves the earlier yaw-only baseline until Bubble first
needs pitch/roll. It then uses recovered target/easing/full-forward math and retains
normal cleanup handoff: accepted ground direction restores target pitch/roll0,
no input does not invent a reset, and normal air targets0/−turn. Exact generic Euler
update enable/phase remains separate. Modern reset clears this bridge. Source
logical root and original visual pivot are not conflated.
Bubble practice selection records the display item but skips live equip before
requesting VR01, matching the source early practice branch. Failed live selection
can leave a display item with raw−1; GadgetScreen now reads the actual raw mode.
Named-Jimmy CAM/MCA cleanup uses the earlier recovered DeactivateInv path. Modern
F3/Stop Motion releases Bubble and lets its owned fade finish; noclip still bypasses
body/contact/energy actions. Reset/new scene clears the port-owned effect; exact
retained original helper fade across loads remains open.
## Verification and continuation
Thirteen focused integration groups cover six copied-body numeric references,
queued work/root preservation,300/900 bounces and mode persistence, independent
clock/drain, depletion/selection/audio, transition rejection, ray suppression,
actual111 retained-floor behavior, strict flash, stored material order, practice
and raw/display gates, cutscene cleanup and modern flight fade. Eleven motion
and eight effect/visual groups are separate. Source projection checks do not
claim original execution. The initial synthetic test floor had visible winding;
corrected to source winding before matching the original references.
The eight-frame smoke uses actual VR01/PHONEBOOTH, source input/body/effect paths
and extra ordinary player ticks between rendered phases. It does not relocate
actors or directly mutate timers/velocities. Ctrl/Left and Shift exercise throttle,
steering and an actual supported900 bounce/SFX106; Tab cleans, then full RGBA fade
and hidden state are captured. Extra ticks and verification results are logged
explicitly in artifacts/bubble-implementation/. This is an accelerated port
fixture, not original cadence, manual tutorial completion or full-game comparison.
Complete scripts/test.sh passes202 Python+2 HUD, all managed suites,31 main GPU
completions and17 isolated Vulkan material checks, with zero enabled validation
errors. SDL dummy lifecycle and539 original hashes pass. Independent review
reruns13 integration/11 motion/8 visual groups and finds no blocker in this scope.
Native GTX1070/private Xvfb1920×1080 passes all eight SDL phases with zero enabled
validation errors,306 accelerated player ticks and tutorial energy20. Active/fade
readbacks were inspected.
Both self-contained packages identify clean1ae5f42 (source_dirty=no). Publication
succeeds for both platforms despite NU1900 metadata warnings. Exact original
Canv1 RGBA hashes match in both. Standalone Linux from /tmp passes all eight Bubble
phases and the expanded F1 Player view at1920×1080; release validation layers are
unavailable. All539 originals verify after packaging. Logs are in
artifacts/bubble-implementation/. Preserved baseline packages remain untouched.
Windows is cross-built; native gadget verification remains open.
Next gadget work must retain the documented body, camera, material, input and
helper-lifetime boundaries rather than assuming universal immunity.
+242
View File
@@ -0,0 +1,242 @@
# Bubble movement mode2
2026-11-02. Completes the static movement/input/bounce contract needed after
[Bubble equip/effect](bubble.md), with a pure C# arithmetic component. This
investigator ran no original gameplay. Source projections and component tests
remain separate from live port integration and original runtime comparison.
EXE SHA-256 `f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
All VAs below PE-map to file offsets VA−400000 in these original ranges.
`tools/binary/bubble_motion.py` verifies identity,11 complete bounded span hashes,
17 decisive instruction sites,8 virtual bindings and11 constants. Generated
`artifacts/bubble-motion/source-contract.json` records bytes, offsets and hashes.
## REA and source coverage
Local REA6.8.0/Ghidra12.1.4 used generated
`artifacts/uncontrolled-phases/rea/Neutron.exe`. Complete replies, Evidence bundle
and closed snapshot are under `artifacts/bubble-motion/rea-native/`:
| Routine | Evidence |
| --- | --- |
|438A60 dispatch|`ev_e645423e5ad809add30e5c0c5893df7ffda0b885988f9cf438d2d2b117502c56`,02.json|
|437940 frame|`ev_de7097867d129a4232318e667e9496c6868cdb1da4b37a1f3304c94b0b101677`,03.json|
|429A00 refresh148|`ev_0028e3f28c5aed508fab954fe8da6170690efa742614dab2044408ddd0062180`,06.json|
4387E0,439900,42A720,4378D0 numeric VA queries did not return pseudocode: the
profile failed to match a procedure and then interpreted the number as an
unmapped file offset. Corrected file-offset selectors387E0,39900,2A720,378D0 and
72B10 are retained separately under `rea-offsets/`: all explicitly report that
no procedure matches the identifier. That session exported its complete empty
Evidence bundle and closed/snapshotted. These are provider coverage gaps.
The first sandboxed batch (`rea-movement/`) encountered the known Unix-socket
`Operation not permitted` host restriction. Its worker was interrupted and its
owned session closed/snapshotted; it contains zero successful Evidence. This was
not a target execution or analysis-completeness success. An explicitly allowed
local static invocation resolved IPC without configuration changes.
Supplementary fixed-range objdump source is saved as frame.asm,input.asm,
callback.asm,pose.asm,transform.asm. Unsupported decompiler routines are recovered
from these guarded instructions/virtual bindings, not invented REA successes.
Profile digest is `e1ad533d4cc0333c2136fe0894217de2d61feea098240326e78633f9e4ddcbf9`.
## Owners, dispatch and phases
Jimmy complete object has game interface+C0; complete vtable4A3BDC and game
vtable4A373C. Input438A60/frame437940 receive interface;439900/4387E0 receive
complete object. Relevant complete fields:
| Offset | Meaning |
| --- | --- |
|6BC/6C0/6C4/6C8|Per-input increment30 / decay35 / current maximum / scalar speed|
|6D4/6D8|Turn rate / copied apply turn rate|
|6E4/6E5/6E6|Forward/backward/keyboard turn flags|
|7C4|Movement mode, not equipped raw gadget|
|7EC/7F0|Forward/backward destination pitch; apply writes−10/+10 every call|
Game2BC→471F10 gets live body velocity,2C4→471F40 sets it; game38C→472B10
rotates a local vector by current Euler. These are separate from pending impulse
2CC and acceleration. Complete128→439900 input;13C→4387E0 Bubble apply;
154→42A720 landing hook;158→4378D0 jump held;15C→42A7A0 fire held.
437940 calls40E050 before control identity/suppression/menu checks. Only afterward
437A49..437A79 dispatches mode2 directly to13C. Mode2 bypasses every ordinary
ground/air mode0/1 landing reset and jetpack jump-state table. After13C returns,
437C22..437C2D publishes controller scalar to game26C body speed. Landing keeps
movementmode2. No new radius, jump state, pending impulse or acceleration write
occurs in4387E0; do not clear those on equip/apply without another source owner.
Prior queued impulse/acceleration may therefore survive equip until another body
phase replaces them. Generic gravity/support behavior belongs to the body report.
426030 input first checks407060 false,475CA0 true, nonnull controlled5099E4,
4F8430 false and interface1D2D false. Its order is:
1.426084 calls438A60; modes1/2 share439900 (438B60 fall-through438B6D).
This changes steering, destination Euler and camera eye before Bubble placement.
2.426098 calls complete188→429D00. Raw Bubble0 fails that handler's raw7 guard
at429DBB, returns false42A652 and does not consume the callback.
3.Unsupported Bubble skips jetpack input at4260D3; supported input passes the
existing grounded path (including any pre-existing fall-impact flag handling).
4.426264 tests movementmode2, drains−.5dt and calls cleanup178 if energy<=0.
5.Even if cleanup switched mode0,4262A5 still positions Bubble from **the current
camera eye after439900**, using the formula already recovered in bubble.md.
Shared later menu/fire phases follow. Beam suppression does not suppress the
steering use of the fire predicate.
## Input439900
Keyboard subset, in source order:
| Rule | Exact source behavior |
| --- | --- |
|Turn|Left precedes Right; ±100dt. Release moves toward0 by100dt, clamped crossing. Mode2 caps±50 at439CB2..439CFB, ordinary air caps±30. Turning adds no speed.|
|Throttle|Up **or held primary fire in mode2** sets6E4; adds30 per call when below max, capped at current6C4=1350. Fire predicate is15C, not jump158.|
|Coast|Without throttle, speed>max×float.909090936 subtracts17.5; otherwise retained.|
|Supported decay|439BA2..439BED: if grounded and speed>0 subtract17.5, with **no clamp crossing0**; if grounded and speed<=0 set0. Applies even with throttle.|
|Brake|Down sets6E5. Positive speed subtracts35 if supported,17.5 otherwise, clamped to0. Negative speed adds35, clamped to0. Does not start reverse.|
|Destination Euler|For mode2 set(−10,currentYaw,−.25×turn) with throttle;(+10,currentYaw,−.25×turn) with brake; otherwise(0,currentYaw,−.25×turn). Forward takes priority over backward.|
Example source composition while supported: speed100+Up→130−17.5=112.5 in input;
later released-jump apply computes XZ from112.5, then publishes56.25. These two
grounded reductions have distinct owners and must not be collapsed into one.
At small positive speed5 the supported input decay yields−12.5; next supported
input zeroes it. This intermediate sign is a source fact, not a clamp omission.
Mouse/analog extensions are also statically bounded:46A460 supplies signed16
mouse axes. Nonzero horizontal mouse overrides keyboard turn and adds mouseX×dt
to turn; absent mouse, analogX<−.5 selects left, analogX>.5 selects right. Vertical
rate is mouseY/dt. Up, analogY>.5, rate>40 or mode2 fire selects throttle; fixed30
is used for keyboard/analog/fire, otherwise the positive rate is added. Down,
analogY<−.5 or rate<−40 selects brake. Strict inequalities are at439A97..439AE6
and439BF5..439C1D. Projections deliberately accept only keyboard flags; no mouse
or analog runtime implementation is claimed here. Zero dt division is not modeled
as safe input; actual frame contract is0<dt<1.
## Apply4387E0 and supported bounces
Every apply writes7EC=−10 and7F0=+10. It reads **incoming live body velocity**.
Only when its magnitude is nonzero does it copy turn6D4→6D8, add yaw+=turn×dt
through game334, and compute the side term:
```
sideSpeed = turn * (1-friction) * speed * float(1/55)
```
Zero incoming velocity skips direct yaw and produces sideSpeed0, but still
constructs forward velocity. Friction getter game248 supplies the existing.8;
factor.415 is a different body property. Unlike ground apply there is no extra
dt in this side speed. Source yaw uses degree-to-index float45.5111122,
truncate47F940 and mask3FFF, then the16384-entry float sine/cosine tables.
472B10 transforms local(0,0,speed), producing
`(-sin(yaw)*cos(pitch)*speed, sin(pitch)*speed, cos(yaw)*cos(pitch)*speed)`.
Roll has no effect for this particular local vector.438950..438976 uses only
transformed X/Z plus the yaw-only side vector and preserves incoming velocityY.
Pitch therefore changes horizontal forward magnitude, **not** vertical velocity.
Full transform source is guarded; host continuous trig in the projection is an
explicit precision approximation. The existing destination Euler interpolator
43A420 uses4.5/sec for pitch/roll and3.7/sec for wrapped yaw; this investigation
does not re-claim all its enable/dirty/base-transform phase ownership.
After composing XZ,43899A calls grounded218. If false, return. If true:
-Call complete154→42A720, which loadsA14 and jumps472970.472970 is a single RET;
it has no landing-effect mutation in this shipped EXE.
-Call complete158→4378D0 current jump-held predicate. It reads the same five
source jump inputs (50993A,509865,509848,509898,509AC5). Its raw6 exception
requires fire+support; raw Bubble0 has no extra denial.
-Held jump: directly set live velocityY900, retaining freshly composed XZ;
play SFX106 (`bubble_boing`) at4389F8. No edge latch: each supported apply can
invoke this sound/velocity write. Scalar speed is retained.
-Released jump: **after XZ composition**, halve scalar6C8 and directly set live
velocityY300. There is no SFX106 in this path. The reduced scalar is then
published by437C22, while current live XZ still represents the pre-half scalar.
These are automatic repeated bounces, not ordinary550 queued jump impulses.
Movementmode2 persists after both branches; ordinary jetpack JumpState/held-clock
logic is not called. Unsupported apply preserves liveY and the mode.
The Jimmy wrapper separately tests support42469B. For raw Bubble0 it restores
live radius160 and directly requests completeE0("STOP",1) at4246CD..4246D4.
The string is4ED040. Unsupported wrapper makes no action request at this site.
4387E0 and439900 contain no JUMP/FLY/RUN selection. Equip's refresh148→429A00
only stops A44 sound; it does not reset Euler or select a flying animation. Retain
these proven boundaries instead of inventing a Bubble flight pose.
## Camera dependency and verification limits
439900 retains shared camera destination calls120/384 and scalar16C→43B820.
Mode2 branch439F4D..43A03A scales horizontal follow by1.8×dt×that scalar.
Vertical follow uses1.5 outside the close-height branch; when
abs(truncate(rootY−eyeY))<=800 and rootY+20<=eyeY, its scale is.8 when
abs(truncate(deltaY−eyeY))>550, else.2. That second expression uses the existing
target-minus-eye delta before subtracting eyeY; do not simplify it into a more
plausible height expression. Shared complete851 overrides all axes with.1dt.
Exact scalar16C, destination geometry and native camera clipping retain their
separate existing camera gates. Sprite placement order after this handler is
closed even when that modern camera adapter remains approximate.
Ten Python groups pass (`artifacts/bubble-motion/tests.log`): original span/
binding/constants guards; fire throttle; turn/pose priorities; supported input
reduction and negative crossing; coast/brake; pitch-forward/liveY preservation;
direct900/300 bounce, sound and scalar/XZ ordering; zero-velocity yaw gate and
bounded inputs. These are static/projection checks, not original runtime probes.
`src/GamePort/Game/BubbleMotion.cs` implements the keyboard input and apply
component using the port's quantized `LabSimulation.Trig` for current pitch/yaw.
Its public results are `BubbleSteering(Speed,TurnRate,TargetPitch,TargetRoll)` and
`BubbleApply(Velocity,Yaw,Speed,Boing)`; methods are `StepInput` and `StepApply`.
Eleven C# numeric/bounds groups pass in `artifacts/bubble-motion/csharp-tests.log`,
including112.5 XZ versus56.25 publication and quantized pitch cosine. Run with
`dotnet run --project tests/GamePort.BubbleMotionTests --no-restore` after local
restore. It changes no normal-air component and performs no body integration,
impulse, acceleration, gadget lifetime, sprite, sound playback or mode writes.
Primary owns live C# integration and its port checks. Remaining broader gates are
original/native Windows gameplay comparison, shared base/rotation/camera state,
full mouse/analog integration and dynamic/special collision coverage; source body
radius/factor/support is coordinated in bubble-body.md. No universal immunity or
entire-game completion is implied.
## Cleanup Euler handoff and A20 search boundary
Follow-up2026-11-02. Cleanup428037..4280CC writes Jimmy completeA20=.5 at428045;
it contains no Euler or destination-Euler setter. Do not interpret.5 as an
upright timer without a recovered consumer. Source constructor4226CF initializes
A20=0; another gadget cleanup42821A writes.5. A complete raw DWORD search of EXE
`.text` VA401000, raw length573440, finds six little-endian `200A0000` occurrences:
4226D1,428047,42821C are the displacements of those three MOV writes;45CFE3,
45D024,45D035 are unrelated PUSH immediates. A direct objdump operand search for
completeA20 and game960 found no read. This is a bounded negative search:
derived pointers, bulk access or other interface aliases have not been ruled out;
the consumer remains **unknown**, not proven absent or dead. The helper's
`handoff` block guards the complete search boundary and six supporting spans.
Normal ground438BC0 does provide a source destination handoff, conditional on
accepted steering. ESI initializes0 at438F66. Right4391BB, Left439239,
Forward4392BA and accepted backward4393D5/4393EE set it nonzero. At43951E, if ESI
remains0, execution skips **all** destination setters to4395CF. Thus no-input
ground behavior preserves the prior Bubble target, including pitch/roll.
For accepted steering, each destination setter43957C,439599,4395C9 passes
**pitch0 and roll0**, retaining its separately computed destination yaw.
Ordinary keyboard Left/Right/Forward/Backward all reach this handoff when their
direction is accepted. Backward specifically has the prior438F9A..438FBB gate:
raw−1 or3 with fire held rejects reverse, so Backward+Fire without another
accepted direction need not produce ESI. Raw6 and other special-gadget gates
must retain their own boundaries.
Normal air mode1 always reaches439D81..439E2B and requests destination
`(pitch0,currentYaw,roll−turn)`; Bubble mode2 instead requests its±10 pitch and
−.25turn roll described above. Normal air release eventually reduces turn to0,
so its requested roll also becomes0. This is an input destination update, not
an immediate Euler reset. Shared43A420's active branch interpolates pitch and
roll error×dt×double4.5, yaw error×dt×double3.7 (with angle wrap and dirty flags).
No cleanup-specific A20 ownership is visible in that routine. This follow-up
does not newly close all scheduling/enable/transform ownership for that shared
interpolator or require an invented blend during cleanup.
REA queries43A420 and438BC0 in `artifacts/bubble-motion/rea-upright/` did not
match recognized procedures; their numeric VA requests then returned the
provider's unmapped-file-offset fallback diagnostics. Complete failures, empty
Evidence export and closed snapshot are retained. Supporting conclusions use
the guarded disassembly `normal-input-tail.asm`, `normal-apply.asm` and
`rotation.asm`. Two added Python groups guard A20's bounded search and the
conditional ground/normal-air destination handoff; C# BubbleMotion was unchanged.
+140
View File
@@ -0,0 +1,140 @@
# Bubble sprite implementation and rendering boundary
2026-11-02. Implements the owned visual component and original resource export.
Equip/body/input integration belongs to the primary runtime change. This report
establishes source recovery, asset identity and managed checks; it does not claim
original Bubble execution, exact original sprite orientation or native Windows
runtime verification. Originals remain read only, with539 unchanged hashes.
## Source and additional REA evidence
[bubble.md](bubble.md) retains the authoritative410840/410AE0/410CA0/410D00
contract, source spans, virtual bindings and REA limitations. EXE SHA256 is
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
Additional local Ghidra12.1.4 queries used the same generated copy, exported
complete Evidence and closed/snapshotted under
`artifacts/bubble/rea-rendering-ipc/`:
| Procedure | Evidence ID | Observation |
| --- | --- | --- |
|4352F0 sprite base |`ev_7ea79d719ffb701f10a497f5790384aa56801d970a34ea7ecd4152052ac8f8df` |Calls463F10; sets complete+C8 game interface; temporarily sets flagC4 bit1. |
|4645F0 InitSpriteProperties |`ev_ab13438ec345f10472d10965048c34d31654e6d9303d729df98b65aa92d37a1e` |Writes AC/B0 supplied size, WORDC4=1, alignmentBC/C0=3, blend6/7. Graphics flag true writes RGBA(.9,.9,.9,1). |
|464210 preparation |`ev_4d39cc1aaad564de60bb801c08dfeb740d52e507227e630de9b0570e3e1bc43d` |Calls458910, forwards root/Euler to virtual setters, calls479A40; does not recover camera-facing drawing. |
The initial sandbox attempt is retained in `rea-rendering/`; Ghidra imported
successfully but could not bind its local Unix socket (`Operation not permitted`).
The allowed local IPC retry above succeeded. That initial batch supplies no
successful decompilation Evidence; no original code was executed in either.
Supplementary objdump output and independently mapped source-span hashes are in
`artifacts/bubble/*-rendering.asm` and `rendering-spans.json`. End VAs are exclusive:
| VA range | File offset / bytes | SHA256 |
| --- | --- | --- |
|4352F0..4353BF |352F0 /207 |`ee18deb9d0492ee3d921e99d56edea9eb11fc4b28bdbc171ee398a6628a41834` |
|4645F0..4646B8 |645F0 /200 |`1e666182de97533be5e917b5763957ce148bceb831b05061df19ccd89d3bae28` |
|464210..46429F |64210 /143 |`a99be3694789b6b6284b7e171eec0f2f26b59eef6a366265646bf6c8cbd92000` |
Constructor410978 supplies200 to4645F0 before overriding blend to6/1. Start
changes destination to1 or7, with no color reset. The optional conventional
graphics branch therefore starts with(.9,.9,.9,1) before its first fade update;
the default additive branch retains white. Active conventional rendering writes
(1,1,1,.5), while default additive rendering retains the previous RGBA.
Assembly410AEC..410AF2 adds dt and stores a float timer without popping the x87
sum. The expansion comparison410B95 and collapse subtraction/comparison410C12..
410C1E use that unrounded sum. `BubbleEffect.Step` retains a double addition for
those boundaries while storing `Timer` as float. The active pulse reloads stored
Timer at410B4C. A managed test covers Timer rounding to1 while the strict source
comparison has already crossed1. `Math.Sin` is a numeric projection; x87 fsin
bit parity and whole-game timing remain unverified.
## Callback ordering
Jimmy42232C constructs Bubble410840; its410892 call enters4352F0, whose435341
call enters463F10. The independently established chain in
[lab-registry.md](../checkpoint/lab-registry.md) continues463F6C complete+C8 →
4586F0 →46FBE0 → tail insertion. Together with the owned effect slot3C4→410AE0,
this supports fresh-game **input → Jimmy → Bubble update** as a partial order,
with other registered helpers allowed between them. The owned fire registers
earlier during Jimmy's base construction. The source registry, not source60Hz,
establishes that relative order.
Retained Bubble survival, teardown flags and update eligibility have not been
independently traced here. Reusing the same owned component across ordinary
Jimmy retention, and scheduling Jimmy → Bubble → newly appended game input,
remains an integration inference until that helper lifecycle is closed. The
modern fixed-step cadence is a separate port policy. Do not gate visual time on
raw input ownership merely because placement/drain happen in controlled input.
## Assets and exported format
`tools/extractors/bubble_resources.py` resolves the archive case-insensitively,
validates its complete hash, unique Canv1 metadata, payload and decoded pixels
before writing. It rejects outputs in/above originals and preexisting output
file symlinks. Export contains no generated sphere or recolored image:
```bash
python3 tools/extractors/bubble_resources.py ../Original \
--output artifacts/extracted/bubble
```
`bubble.json` schema1 contains `source`, archive `sourceSha256` and exactly one
`textures` record with id/name/width/height/path/png/sourceOffset/sourceBytes/
sourceSha256/rgbaSha256. `canvas_1.rgba` and `canvas_1.png` retain the original
146×146 image, including5492 alpha0 and15824 alpha255 texels.
- Archive SHA256: `b584ffa4a38f4bc809b3ea8f4321e0c08f2719e22df41a3fb4cd143ed89b3bef`.
- Payload offset17FCE/66322 bytes, SHA256: `9b6cdce95bd408fa1dc806d30520df65971f25d1663ab8da4ca6bf41380805ec`.
- Decoded RGBA SHA256: `a3a678c47c1ce94946b1136560a84f3ef86c6884b981256a9fbff62fe8a988e4`.
## Implemented renderer and explicit policies
`BubbleEffect` owns independent Active/Expanding/Collapsing/Visible flags, Timer,
full Vector4 Color and dimensions. `Start()` only sets expansion/visibility and
resets Timer. `Stop()` is the original leaf and deliberately preserves expansion;
Jimmy cleanup must additionally call `ClearExpansion()`. Active beats expansion,
which beats collapse. Fade does not change size; the first active invocation
changes200×200 to240×(240+sin(timer*10)*30), retaining the last pulse size during
collapse. Exactly1 remains expanding; exactly zero fade remains collapsing and
visible. A subsequent negative fade hides it. `Reset()` reconstructs initial
owned visual state rather than pretending to be the original Stop leaf.
`BubbleVisuals(Mesh combined, string preparedRoot)` loads `bubble/bubble.json`,
bounds its manifest/pixel sizes, validates the original pixel hash and appends
four vertices/six indices. It preserves existing draws/textures and collision
metadata. `Update(destination,effect,root,eye,target)` receives the already
captured source BubbleRoot; it applies no extra Jimmy scale or root offset.
RGB multiplies all four vertex colors; alpha goes through MeshDraw.Opacity.
Default blend is SRC_ALPHA/ONE; optional graphics mode uses
SRC_ALPHA/ONE_MINUS_SRC_ALPHA. Current Vulkan blended world draws test existing
opaque depth without writing depth.
The quad is centered on root and uses the same camera-facing basis as the
existing scene sprite adapter: direction=normalize(target−eye), right from
worldUp×direction, up=direction×right, with deterministic degenerate-camera
fallbacks. Width/height are complete world-space edge lengths; UVs cover the
complete original image. **This basis, centered interpretation, modern UV0..1,
filtering/alpha-cutout behavior and depth-write policy remain modern rendering
boundaries.** Alignment3/3 is recovered, but complete original engine alignment
scheduling, local-axis orientation, camera roll, render-state ownership and
zero-length original placement normalization are not closed. The result must
not be described as original visual parity without comparison.
## Validation
- Five Python checks pass: exact archive/resource/decoded PNG identity, output
separation, child symlink protection and rejection before writing on bad
archive/dimensions/pixels.
- Eight managed effect/visual groups pass: strict boundaries and full RGBA,
pulse/graphics branches, Stop priority/cleanup, unrounded fade comparison,
independent clocks/reset, original quad/material/metadata, camera degeneracy
and malformed/path-traversing/altered resource rejection.
- Main `dotnet build --no-restore` passes with zero errors; cached NU1900
vulnerability-feed warning is unrelated to this change. All539 original hashes
verify unchanged. Logs: `artifacts/bubble/visual-validation/`.
Commands: `python3 -m unittest discover -s tests -p test_bubble_resources.py -v`
and `source scripts/env.sh; dotnet run --project tests/GamePort.BubbleVisualTests`.
Managed/asset checks and compilation do not establish GPU rendering, original
runtime comparison or Windows execution. Primary integration owns those results.
+171
View File
@@ -0,0 +1,171 @@
# Bubble gadget source contract
2026-11-01. Recovered static contract for the next gadget; **no Bubble runtime
implementation or original-game execution is claimed by this investigation**.
Original EXE SHA-256
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
Preferred VAs below map to file offsets VA−400000 in the supplied text section;
`tools/binary/bubble.py` independently PE-maps and exports every retained site.
Output is `artifacts/bubble/source-contract.json`:12 bounded span hashes,37
instruction sites and6 virtual bindings. Originals were read only.
## REA evidence and scope
Two local REA/Ghidra sessions inspected the generated
`artifacts/uncontrolled-phases/rea/Neutron.exe` copy, exported complete Evidence
and closed/snapshotted under `artifacts/bubble/`.
| Procedure | Evidence / saved reply |
| --- | --- |
| Bubble constructor410840 | `ev_a0c9ee6d5757a741190f3dfcc093bdc7d7b802bcdcd2cbc029422550d34e7cb2`, `rea-effect/00.json` |
| Start410CA0 | `ev_097f43eb24a762785dd495220c26a8995d541c69de3e9a88d4c195e24a04b1ce`, `rea-effect/02.json` |
| Stop410D00 | `ev_d88f2e5a0b0b2ea4f47758084f3c2a6c605f18a1b8c7c4aa3b7cff0e9465b2e7`, `rea-effect/03.json` |
427FF0,4299B0,429A30 (`rea-core/`) and410AE0 (`rea-effect/01.json`) were not
recognized as procedures by the native profile. Numeric VA queries fell back to
unmapped file-offset errors; the complete diagnostics remain on disk. These are
not successful decompilations. Contracts below use reviewed fixed instruction
ranges/virtual bindings, supported by the successful constructor/start/stop
Evidence. No unchanged failed query was repeated. Supplementary objdump output
is retained as `equip.asm`, `cleanup.asm`, `class.asm`, `position.asm` and
`exe.asm`; source hashes and mapping keep this independently reviewable.
## Owners and layout — recovered
The [group0 menu](gadget-controls.md) names item0 **BUBBLE** and maps its practice
to VR01. Global signed WORD4F0588 is equipped raw mode; source movement mode is
a separate WORD at Jimmy complete7C4/interface704. The Bubble is owned at Jimmy
completeA14/interface954. Constructor42232C calls410840, stores the result42233C
and initially hides it at42236E. It is not a free-moving projectile or Jimmy's
physical body.
Bubble complete vtable492970; game interface is complete+C8 with table49250C.
Game slot3C4 binds410AE0 update; generic1C binds464130. Constructor4108F7 registers
FourCC `3BUB`; class name is `C3DBUBBLE`. Constructor4352F0 supplies the sprite
base. Own body integration/triangle collision is disabled through471030(0) and
4710C0(0); Jimmy's body instead changes radius/factor when equipped.
| Bubble complete field | Purpose established here |
| --- | --- |
|90..9C|RGBA sprite color; expanding/collapsing writes all four components|
|AC/B0|Sprite width/height; initially200/200 via4645F0(200)|
|B4/B8|Source/destination blend enums6 /1 or7|
|57C|Integer base pulse size240, initialized410935|
|584|Copied archive name `RetainedSprites.omt`|
|5E8|Loaded original canvas resource; constructor477890(archive,1)|
|600|Float visual timer, incremented each effect update|
|604|Float pulse `sin(timer*10)*30` while active|
|610|Float fade scalar|
|614/615/616|Active / expanding / collapsing flags respectively|
The retained resource is Canv1 of RetainedSprites.omt, not an ASE sphere. Exact
archive/pixels/tutorial inventory is independently documented by the asset
investigator. The sprite's full camera-facing transform remains a rendering
adapter dependency; the ellipse/pulse does not justify inventing sphere geometry.
## Equip and cleanup — recovered
Complete Jimmy174→428D50 dispatches item0 to428F61. The common menu caller closes
and invokes cleanup178 first; arbitrary calls to174 without that caller are not
equivalent. Bubble branch order:
1. Require the owned Bubble pointer. If absent, return without a new effect.
2. If runtime Practice state(0,9)==2, reset that state and load `vr01.gam` at
428FCA using existing return strings. This precedes energy and visual-state tests.
3. At428FDA require energy4F83D4>0 or Jimmy complete9F8 nonzero. The latter is
retained here as an unnamed exemption flag; its complete ownership is open.
Failure writes raw mode−1 at428FFA and returns.
4. Reject Bubble active614, collapsing616 or expanding615 before starting another
transition. These flags are not a generic cooldown invented by the port.
5. At429049/429058 invoke game110/100 for **radius160/factor0.415**; write raw mode0
at429065, movement mode2 at429072 and max controller speed1350 at42907B.
6. Call410CA0 at429085. Start sets expanding615, timer600=0, unhides the sprite
if necessary and chooses blend6/1 (additive) or6/7 (conventional alpha) from
graphics flag509A13. It does not clear other transition flags itself.
7. Start loop SFX2 at429093..4290A1 only if Jimmy completeA40 handle is−1, then
animation refresh148. Source animation selection also depends on movement/body.
Cleanup178→427FF0 dispatches raw mode0 to428037. With the owned Bubble it sets
Jimmy A20=0.5, movement mode0, **max controller speed650**, calls410D00 to begin
collapse, then **separately clears expanding615** at42806B. It stops the A40 loop
and resets handle−1; invokes radius60/factor1.265; writes raw mode−1 at4280BB.
The source's explicit650 cleanup value must not silently be replaced by the
constructor's600 or by generic authored-state restoration. The A20 consumer is
not closed here. Missing-pointer cleanup falls to the shared raw−1 tail without
these body/effect changes. Cleanup also restores selected-device HUD3 via the
common prelude. It does not directly transfer raw controlled-pointer ownership.
## Active input, movement and interactions — recovered boundary
426030's input callback retains its existing global/game/control predicates.
Within it426264 tests **movement mode2**, not raw mode0, then426272..426280 calls
42A920 with `−0.5*dt`. The common energy helper owns VR exemption, clamp and warning
sounds; no duplicate exemption is implied by the Bubble branch. After adjustment,
426285..42629F invokes cleanup178 if energy<=0. Consequently controlled Bubble
input drains0.5 energy/second outside exempt tutorial handling. Loss of input
ownership can stop this branch while the independently registered effect still
updates. This is not permission to pause every clock on raw-control loss.
The same branch positions the sprite using current camera eye509A50+44..4C:
`direction=normalize(JimmyRoot+(0,100,0)−eye)`;
`BubbleRoot=JimmyRoot+(0,50,0)−direction*80` (4262A5..4263DA).
This is camera-relative and differs from simply drawing a sphere centered at
JimmyRoot. Zero-length normalization/imported-vector rounding remains open.
Generic input438B1E..438B98 maps movement modes1 **and2** to shared439900, while
mode0 maps438BC0 and3 maps43A120. The prior air-steering recovery of439900 is useful,
but does not close Bubble's complete jumping/body/mode transition behavior.
Supported Jimmy wrapper4246A9..4246E3 explicitly restores live radius160/raw mode0
or60 otherwise, before the later movement/fire phases. A live Bubble integration
must preserve source authored/live radii and movementmode2, including support.
Ordinary primary fire4266AC rejects raw mode0 before controller-speed-zero,
SHOOT and the ray scan. Jetpack dispatch also skips raw mode0 at4260D3. Bubble
must not keep the ordinary beam or powered-jump path active merely because item3
is owned. Other generic movement/jump paths still need caller-complete recovery.
Source callbacks42A870 and42A8D0 return early for raw mode0 before their energy/
score/flash effects, and42AB0E skips an additional SFX190. Their complete callers/
meaning are not traced here; this establishes specific bypasses, **not** universal
invulnerability against every hazard, actor or script.
## Sprite transitions — recovered, with numeric projection limits
410AE0 first increments float timer600 bydt, then processes flags in priority
order active614, expanding615, collapsing616:
- **Active:** pulse=sin(timer*10)*30; width=(float)integer57C=240 and height=240+pulse.
If509A13 is true, RGBA becomes(1,1,1,0.5); otherwise existing RGBA is retained.
This does not geometrically scale Jimmy or the sprite during fade.
- **Expanding:** scalar610=timer; strictly `timer>double1` clamps scalar1, sets
active614 and clears expanding615. RGBA=(scalar,scalar,scalar,scalar).
At exactly1 it remains expanding until a later update.
- **Collapsing:** scalar610=1−timer; strictly scalar<0 clamps0, clears collapsing616
and hides the sprite. RGBA=(scalar,scalar,scalar,scalar). Exactly0 retains collapse
until a later update. Stop410D00 sets collapsing616, clears active614 and timer0;
Jimmy cleanup must additionally clear expanding615 or expansion retains priority.
The Python projection retains these state/strict-boundary distinctions and
single-precision stored values. It does not claim x87 intermediate/fsin bit parity
or original runtime observations. Blending both RGB and alpha during fade can
change perceived brightness; replacing it with alpha-only is a behavior change.
## Validation, current implementation and next action
Six Python source-contract groups pass in `artifacts/bubble/tests.log`: original
identity/span/site/virtual guards and offsets, equip order/flags, movement2 drain,
strict expand boundary/color without size scaling, active pulse/graphics alpha,
and cleanup priority/strict-negative collapse. This is static/source-projection
validation, not native Bubble gameplay or an original game capture.
The port's group0 selection/practice already exposes Bubble, but **this agent made
no runtime changes**. Raw mode0 radius160 is a named future case; the existing
ordinary static Jimmy body subset must not be advertised as complete Bubble
physics. Recommended next coherent implementation: retain an owned sprite with
original Canv1, source transition flags and camera-relative placement; integrate
source radius/factor/maxspeed/movement2/ordinary-fire cancellation together,
including source cleanup650, controlled−0.5dt and independent visual clock.
First recover the generic mode2 jump/body transitions and actual VR01 support/
collision class coverage, then test equip→expand→move/jump→empty/Tab cleanup→fade
and tutorial/RETURN persistence. Full hazard/AI immunity and renderer orientation
remain explicit gates. Invisible is the primary's selected next playable slice;
this Bubble contract is ready for that later chunk without speculative physics.
+12 -2
View File
@@ -103,8 +103,9 @@ prepared standing mesh, so existing morph preparation can preserve its topology.
|rope01.ASE,rope02.ASE|1 each /30|6 vertices/6 faces and4 vertices/2 faces.|
|laser02.ASE,missile.ASE|1 each /30|8 vertices/8 faces and7 vertices/10 faces; missile's goo.bmp reference is not a verified gadget attachment.|
scooter.omt contains shape0 `goddard01`, shape1 `wheel`, matching material/canvas
resources0 `goddard128` and1 `scooterwheel2`; archive SHA256
scooter.omt contains shape0 `goddard01`, shape1 `wheel`; material0 `goddard128`
links Canv1 `goddard128`, material1 `scooterwheel2` links Canv0 `scooterwheel2`.
This corrects the earlier ambiguous material/canvas association; archive SHA256
`8d4ffdafee5fd819c5220ee4f608c901a5988fe6b8b13316e15618f5eec75e81`.
inventory.omt is an older-looking icon set with BUBBLE/GODJEEP/SCOOTER/jetpack etc;
its names alone do not justify replacing screens.omt menu art or IDs.
@@ -132,3 +133,12 @@ range, timing, energy and interruption policy. The selection3 naming overlap is
an explicit reason to implement the combined shrink/jetpack controls coherently.
Other gadget assets are candidates for later behavior recovery, not evidence that
all eight gadget behaviors are currently implemented.
2026-11-04 Scooter continuation: export_scooter now prepares exact OMT shape0/1,
Canv0/1 pixels and HISCOOT/HISCOOTSTOP rider morphs, with source aliases and PE
spans in its manifest. Runtime body/wheels/rider preserve source pivots/unit scale;
null-material wheel faces remain undrawn. The Goddard HISCOOT alias is separately
recovered and is not substituted for the active Jeep mesh. Eight resource groups
check exact geometry/UVs/normals/materials/radii/pixels, morph samples/topology,
binding instructions, determinism, identity and output isolation. Live status and
remaining render/lifetime limits: [scooter-live.md](scooter-live.md).
+175
View File
@@ -0,0 +1,175 @@
# Bubble / Invisible resource and tutorial follow-up
2026-11-01. Original asset parsing, decoded-pixel inspection and local REA static
analysis. Originals remain untouched. This report does not establish original
gameplay execution, enemy detection, tutorial completion or native Windows runtime.
Primary selected Invisible as the next bounded gameplay implementation; Bubble
resource observations are retained for the later effect.
## Evidence and reusable output
`tools/extractors/gadget_followup_assets.py` inventories exact original resources,
seven current Jimmy clips and both authored tutorials. It retains archive/payload
hashes, resource byte offsets, GAM property offsets/raw bytes and duplicate tags.
It also guards the source image identities and eight bounded meter code spans.
No game code is executed by this utility. Generated report and inspected images:
`artifacts/gadget-followup-assets/resources.json`, `orangebubble.png`,
`controls_109.png`, `controls_111.png`, `canvas_21.png`, `canvas_22.png`.
```bash
python3 tools/extractors/gadget_followup_assets.py ../Original \
--output artifacts/gadget-followup-assets/resources.json \
--meter-output artifacts/extracted/invisible-meter
python3 -m unittest discover -s tests -p test_gadget_followup_assets.py -v
```
`export_meter(original, output)` writes `meter.json` schema1, reference640×480,
exactly two texture records and original decoded RGBA/PNG files. Records contain
id/name/width/height/path/png/sourceOffset/sourceBytes/sourceSha256/rgbaSha256.
Both names/dimensions are checked before any files are written. Original root,
its subtrees and ancestor outputs are rejected. Pixel files are neither recolored
nor resized; state/tint/geometry belong to the caller. Six checks pass in
`artifacts/gadget-followup-assets/tests.log`: exact assets, tutorial source offsets,
duplicate identity, output protection, pixel export and guarded meter spans.
## Invisible uses the existing Jimmy family — asset facts
`png/jimycarl.png` is256×256; all65,536 texels have alpha255. The existing
prepared Jimmy atlas therefore has no translucent source pixels to replace for
this effect. Source `jimstop.ASE` has426 vertices/814 faces, two samples at10fps,
480 ticks/frame, and supplies3,551 UV entries/814 UV faces. `jimrun`,
`jimbackpedal`, `jimjump`, `jimfall`, `jimfly` and `jimshoot` have the same
vertex/face counts and no UV tables; existing preparation uses the standing UV
topology. This report verifies counts and resource identity, not every morph's
original interpolation phase.
No additional ASE or PNG is required for the recovered Invisible material path.
[Invisible source](invisible.md) owns the activation/timer/state interpretation;
[material report](gadget-blending.md) already traces complete slot114→40E4A0
positive RGBA/material alpha and source blend enums. Existing port fragment
cutout occurs before multiplying material opacity, so alpha0.7 does not discard
this fully opaque source atlas. Original fixed-function alpha-test interaction
and full material-state parity remain separate renderer questions.
The original control strip Canv111 `BmenuLInvisible` visibly labels primary mouse
and Ctrl as INVISIBLE. Bubble strip109 separately labels mouse movement/forward,
jump and Ctrl/Insert keyboard equivalents. These inspected pixels corroborate
the input descriptions; they do not establish a held/edge policy, timers or
power consumption. Menu/HUD resources already exported for both items are in
[gadget assets](gadget-assets.md); no invented icons are needed.
## Recharge-meter resources and source chain
Original `screens.omt` SHA256:
`e8e95231f5d302b41f4fbf33df1c5a08ce4645370f9f519527ff1727b73b7a5e`.
| Canvas | Source offset / bytes | Exact decoded dimensions |
| --- | --- | --- |
|21 `meter` |0x88E18 /8118 |30×110, border/backplate |
|22 `metercolor` |0x8C5D8 /9138 |30×110, original multicolor fill |
REA inspected private hashed copies. EXE identity is
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`;
DLL identity is `3ec41ead011adf56387a6dbd4580e5b5a9721b5f8020c8a56420f42824354943`.
Complete replies, exports and closed snapshots are in
`artifacts/gadget-followup-assets/rea-meter/` and `rea-meter-dll/`.
The renderer/alignment follow-up is exported/closed in `rea-meter-surface/`.
| Source function | REA Evidence |
| --- | --- |
|401430 menu construction |`ev_e7355ffccf1c4066e58d93e229e4a89662e01045e555d178cb2c11b1ddb5b42b` |
|402D70 canvas placement |`ev_37b8296fe0ea52d6b1d36ba096c60700a7dca3986cb7966b8d6d2884253bf4f0` |
|4037F0 meter percent |`ev_525ca303ce70c16f524063053ebdd9fecd82054cf480d8f2f30f1ec0d7e08333` |
|DLL10029430 canvas render |`ev_f133d0c29cd7b2969814c4b89df37e369776d954543980c93dc69bc3ccb7e579` |
|DLL10029180 canvas construction |`ev_856445a19d924cf5ec157575da27686731caca9a1a611895a98d269fe31c4b03` |
|DLL10037AC0 draw_surface |`ev_143b978a715b32486294f27aa987c926c0cf8f52e09a2116b81ec34803d9962b` |
|DLL10029870 update_logic |`ev_5021f9ff80b9087cafdf449976e363921d6159833f003efe15870f24932d8343` |
|DLL10029890 compute_auto_align |`ev_b963c3e443054b1425af94a27efd37cc157f6dd2070d2d87cbb2a78f72dc083e` |
|DLL10029930 get_canv_wordsize |`ev_d766e30f3466351eaea497f58546f564563849cf9fdc269c42b131c01ac542a5` |
Constructor401430 opens `omt/screens.omt` and binds global4F7CB0 to canvas21 at
4017CB, global4F8028 to canvas22 at401865 through402D70→menu454/402E30. Literal
coordinate arguments are(320,7) and(322,4). Constructor sets sprite source blend6,
destination1 or7 according to graphics509A13; RGBA initiallywhite. Runtime
menu484/488 show/hide both;48C/490 change fill tint to red(1,.2,.2,1)/white.
Those latter caller/state branches are guarded by [Invisible](invisible.md).
4037F0 (raw0x37F0) clamps only negative percent to0, writes fill width
`screenWidth/640*27`, and height `screenHeight/480*percent*1.04`. Global4F6560 is
screen width,4F655E height. The multiplier at48D908/raw8D908 is a stored double
**1.04**, not0.01. At100 percent the logical height is104. Width/height are fields
AC/B0; source sprite placement44/48 stays separate. No forced100 clamp is proven
in this leaf. Caller supplies the actual timer/recharge conversion.
Texture resize is **full-image stretch**, not percentage UV cropping. Canvas
render10029430 obtains custom AC/B0 dimensions when flagC4 bit0 is set, then
forwards the original canvas, cached offsets, dimensions and RGBA90 to renderer
slotB0.402D70 sets flagC4 to1. DX draw_surface10037AC0 builds a rectangle using
the supplied width/height, with source UV0..0.9999 for the single-texture path;
the tiled path distributes the complete source canvas across those dimensions.
Percentage does not enter UV selection. The modern texture uses0..1 over the
exact decoded image; legacy edge epsilon/texture padding remain renderer details.
The tint multiplies this original gradient once; no replacement solid fill or
partial-source gradient crop is evidenced. Source48C/490 tint leaves are already
in the guarded192-byte meter_tint span0x3730..37F0.
Modern layout policy: interpret the source coordinates using a640×480 logical
viewport with uniform widescreen scale, background rectangle(320,7,30,110),
fill width27 and bottom114/top `114−1.04*percent`. This preserves source initial
bottom placement while changing height. It is explicitly not a fully closed
original pixel-position recovery:402D70 writes alignment modesBC/C0=3;
constructor initializes cached offsetsA0/A4=0, while engine update_logic10029870
can recompute−half-size offsets through10029890. Canvas render forwards cached
offsets and dimensions. Whether these menu sprites enter that engine logic pass,
and the exact frame of recomputation, remain unresolved. Pseudocode for402D70
has incorrectly recovered parameters; its arguments/formulas above are checked
against the guarded instructions, not copied from its prototype.
## Original tutorial fixtures
| Data | VR01 Bubble | VR03 Invisible |
| --- | --- | --- |
|GAM SHA256 |`7938214fb62784fcb34245491342a5f33e3615bdc178e4883a9e285e6869904f` |`8acc4d3b8c416c41c1900ac0b1f895ab5819781e5dd87d19a1f177414660d5b2` |
|Entity count |16 |67 |
|Scene shape |`VRRoom`,60 vertices/80 triangles |`Box01`,280 vertices/424 triangles |
|PHONEBOOTH STRT offset |0x45C |0x406 |
|Authored root |(−2678.0381,87.3322,−2783.4011) |(−292.9982,160.3451,−2467.5544) |
|Yaw |290 |290 |
|Intro |`bu`,3MCA0xA61 |`inv`,3MCA0x8EEE |
|Voicepractice IDs |24/23/22 |21/20/37 |
|Return LOAD offsets |0x83C radius400;0x1631 radius300 |0x94DE radius300 |
Both intros serialize PlayerControlled=NULL and NextTrigger=default. VR01 has
DeactivateInv=1; VR03 omits that property. Absence is not evidence forfalse;
the constructor/default binding is documented separately by the Invisible
investigator. VR03 source SoundIndex0/1/2 properties occur at0x90F7/0x9176/0x91F5.
The voice bank also contains invisibility4/ID38, but this intro does not use it.
VR03 contains eight actual3SOL at source offsets0x7BA,14B0,1EB7,342B,4828,4D2F,
5736,633B. All share ObjectTag `C3DYOKIANSOLDIER`; keep actor identity by instance/
source offset, never collapse them into one dictionary/tag lookup. Each serializes
AIState2, VisibleRange2500,FOV359,TargetNameJIM1. These data values do not recover
the target-detection algorithm or prove combat/AI is implemented.
Literal patrol links contain two missing names: yok3→`tok4`, and soldier0x5736
starts at `fyoy1`; supplied patrols contain `yok4`/`fyok1`. Preserve these original
strings rather than silently repairing them. VR01 contains no3SOL.
A meaningful bounded Invisible fixture can load actualVR03/PHONEBOOTH, skip or
complete its source intro, and exercise equipped/ready/activation/expiry/recharge/
cleanup against the current player, atlas and meter. It must establish item2
availability through the existing inventory/PostLoad contract. No fake enemy or
invented vision/combat response is needed to verify this first effect. Tutorial
navigation, stealth detection and trophy/RETURN completion remain separate tests.
## Bubble assets retained for later
`RetainedSprites.omt` Canv1 `orangebubble` at0x17FCE/66322 bytes decodes146×146,
with15,824 opaque and5,492 transparent pixels. RGBA SHA256:
`a3a678c47c1ce94946b1136560a84f3ef86c6884b981256a9fbff62fe8a988e4`.
This is confirmed by the Bubble constructor's explicit archive/ID binding, not
just its name: [Bubble report](bubble.md), constructor410840 REA
`ev_a0c9ee6d5757a741190f3dfcc093bdc7d7b802bcdcd2cbc029422550d34e7cb2`,
saved/exported/closed in `artifacts/bubble/rea-effect/`. No new ASE is indicated.
SoundEffects Wave2/3/106 are gravitybubble/gravitybubbleoff/bubble boing; serialized
resource identities alone do not establish repeat/stop ownership. Bubble pulse,
growth/fade/collision and billboard orientation belong to that system report.
+4
View File
@@ -1,5 +1,9 @@
# First playable gadget implementation
Historical first slice. [Invisible continuation](invisible-implementation.md)
supersedes its unimplemented Invisible/shared energy-warning items; other limits
below remain scoped to the recorded2026-10-27 implementation.
2026-10-27. User-directed gameplay continuation; collision checkpoint35a2a66/
0272f7b remains parked. This implements the original gadget screen and the combined
shrink-ray/jetpack device, with a bounded3SOL target consumer. It does not complete
+58
View File
@@ -0,0 +1,58 @@
# Grappler shared body/contact composition
2026-11-04. Original EXE SHA256 f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8.
Static VAs in this report map to file offset VA−400000. Source ranges/hashes,
relocation allowlist and generator: `tools/binary/grappler_body.py`;
`artifacts/grappler-body-live/source.json`. Reuses REA47B4B0
`ev_d45e078c585d3773494c0e0dfb1696178dd0b8ce8b696caf133892ff070e552e`
and43AA40 `ev_4f2a6aa666451db831efd46f5c587573e22d8072315626b8bc2f844f9c6f0cae`.
This checkpoint adds execution of copied components, not new whole-original play.
## Recovered ownership and order
479BC0..479D1B traverses enabled body integration before ordinary object callbacks.
479D20 initializes shared sphere state once: last polygon695D4C=NULL,
nearest face695D5C=130000, nearest edge5CFBE0=radius. Sphere hit point is5CFBE8.
Body motion invokes47B4B0; callback370 handles normalY<=−.7 and374 handles
normalY>−.7. Support47B890→47C6E0 and ray47C210 use selected polygon695D54 /
hit5CFC60 instead. They preserve all four sphere state fields.
429D00's attached branch invokes47B4B0 at42A016 without resetting that sphere
context. Therefore movement *away* from a previously accepted wall can replay
374 even when the new movement accepts no polygon. Zero delta skips dispatch.
A fresh context on each attached move would silently lose this callback.
Jimmy374→42A660 first invokes full Player43AA40. For the bounded VR08 material
IDs0/2/3/4, all probed grounded/mature combinations leave the body unchanged.
The derived suffix clears horizontal swing globals4F82BC/C0, then detaches
strictly when their incoming magnitude exceeds60; equality60 stays attached.
The action latch is set by this same fast-contact branch. Detach429C10 zeros
velocity, selects FALL, damps swing .96 and stops loop34; it adds no impulse.
Ordinary ceiling370→472690 clears positive Y velocity and acceleration separately.
Attached input later clears Vy unconditionally. After an attached callback the
429D00 tail still executes, including swing publication and pre-collision rope root.
Normal frame/player update still runs after input returns.
## Copied-original observations
`artifacts/grappler-body-live/probe/wine.log` ends
GRAPPLER_BODY_COMPONENT_COMPLETE; private Wine32 probe exit0. Generated code
uses copied original body/support/ray/static dispatcher, synthetic grid and
callback counters. Its8 chained observations cover body wall+floor, support/ray
preservation, stale replay, zero delta and the −.7 boundary.32 cases execute full
43AA40 then42A660 across four materials ×grounded ×mature ×fast/slow swing.
A final case checks ceiling's independent positive-Y rules.41 observations and
input/log hashes are retained in `tests/GamePort.GrapplerLiveTests/original-body-reference.json`.
These are original-component execution with synthetic inputs, not whole-game,
original scheduler, historical hardware or original render evidence.
## Implemented bridge and limits
OriginalBodyPhysics retains its mutable StaticCollisionContext. MoveAttached
requires the preceding body phase and reuses that object. LabSimulation invokes
370/374 after publication, feeds attached contact back to GrapplerGadget and
continues ordinary player update. Normal physics wall callbacks also reach it.
Bounded live admission adds only VR08, whose materials are independently guarded.
Other actors/global sphere-context interleavings, dynamic pairs, special-material
callbacks and other levels remain outside this integration. The per-player
context is a bounded adapter, not a recovered general scene-global scheduler.
+125
View File
@@ -0,0 +1,125 @@
# Grappler follow camera: local fields, consumers and live adapter
2026-11-03. Static recovery against Neutron.exe SHA256
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
Originals remain untouched. All VAs below have PE file offset VA−400000 at
the guarded sites. `tools/binary/grappler_camera.py` emits actual mapped offsets,
span hashes, virtual targets and constants to
`artifacts/grappler-camera-live/source.json`. Its twelve tests exercise a bounded
Python projection, not original game execution or a live camera comparison.
## State writers are not camera poses
Jimmy complete+7C8/7CC/7D0 stores local eye XYZ; +7D8/7DC/7E0 local look XYZ;
+854/858/85C stores follow gains. These fields feed shared viewport eye
+44/48/4C and pitch/yaw +50/52 through the active follow callback. They are not
ready-to-use world coordinates or camera height/distance parameters.
| State / original writer | Eye local | Look local | Stored gains XYZ |
|---|---|---|---|
|Normal defaults437740..43778D, complete170|0,200,−350|0,80,0|1.6,1,1.6|
|Equip42981A..429844|0,50,−350|0,150,80|**Unchanged**|
|Attach426D59..426D7F|X unchanged,400,−650|**Unchanged**|.8,1,.8|
|Attached detach429C34..429C74|0,50,−350|0,130,100|1.6,1,1.6|
|Cleanup4287FC..42880A|Detach then normal defaults|Detach then normal defaults|Normal defaults|
Detach429C10 is a strict no-op when attached4F8210 is already false. Cleanup
still calls437740 in that case. Equip does not clear attachment or first rope
length in its selected branch. Higher-level selection/cleanup order owns those
transitions. Attaching again after detach retains look(0,130,100); equipping
again restores look(0,150,80). Always rebuilding a generic "attached camera"
would erase this observable difference.
## Ordinary walking follow
Complete124→438BC0 uses the normal subpath439625..4398EF when special camera
flag828 is false. The source adjustment complete84C defaults to10 and normal
walking resets it to10 at438CC6 when its enclosing camera/gadget conditions
permit; Grappler raw7 is not the special raw6 exception.
The effective points are:
```
eye = root + fullEulerRotate(eyeX, eyeY − 2*adjustment, eyeZ)
look = root + fullEulerRotate(lookX, lookY + 1.9*adjustment, lookZ)
gain = (storedX, storedY + .2, storedZ)
```
439652 and4396DA invoke game384→472980, the full logical Euler point
transform, using the source negative Z/X/Y table rotation. Thus equipped normal
eyeY is30 and lookY169 at zero rotation; attached eyeY380. Neither is a direct
substitution into the port's existing ordinary hardcoded follow offsets.
439658..439686 caches desired eye at complete804..810. Normal4397B1..4397F8
multiplies each delta by its effective gain, obstacle gain and dt; there is no
final interpolation-factor clamp in this path.
Flag828 can instead choose a different transformed/cached eye and uniform
gains; flag851 selects fixed .2 smoothing independent of the normal branch.
These are explicit excluded branches, not proven absent from every level.
## Ordinary airborne follow
Complete128→439900 captures OLD viewport eye at439E33.439E38..439E6B
passes raw eye locals to complete120→43A5D0. This helper does **not** add120
to Y:120 is a virtual-slot coordinate. At43A5EA it reads logical Euler, then
43A5F0..43A67B uses pitch0, yaw=`AddAxis(logicalYaw, complete6D4)`, and logical
roll. The helper applies the table rotation, reads root310 at43A6FB, and adds
root XYZ. Complete6D4 is the source turning accumulator, not a camera-local Y
offset. Negative yaw addition follows the previously recovered truncation/360
seam from `RocketOrientation.AddAxis`.
439E81..439EAA transforms unadjusted look locals using game384 full Euler.
For ordinary movement mode other than2,43A03C..43A06C uses **fixed**
gains(1.2,2,1.2), multiplied by obstacle gain and dt. It never reads stored
854..85C there. Attached air therefore uses eyeY400, with look150/80 on first
attach or130/100 after detach/reattach. Body pitch affects the look but not air
eye pitch; body roll affects both. Turn accumulator affects only air eye yaw.
Movement mode2 has separate Bubble gains and flag851 still selects its special
.2 branch. Do not claim these ordinary Grappler formulas cover those branches.
## Shared obstruction and old-eye orientation
Both paths call complete16C→43B820 after computing points. Its caller supplies
look by value and desired eye by pointer; the two preliminary actor310 reads
are not additional point offsets.47C210(false) traces look→eye with original
static grid/order/filter semantics. On hit43B884..43B8F4 writes:
```
desiredEye = look − .75*(look − hit) = .25*look + .75*hit
obstacleGain = 1.5 # miss returns1
newEye = oldEye + (desiredEye − oldEye) * gain * obstacleGain * dt
aim = look − oldEye # deliberately NOT look − newEye
```
Walking captures old eye in complete714/718/71C before this path and uses it
at439830..439865. Air captures old eye in locals and uses it at43A09F..43A0CE.
OMT vector `angles` IAT48D108 yields signed14-bit orientation; subsequent
viewport delta arithmetic gives the new quantized pitch/yaw. Reusing the Rocket
orientation helper is justified; using its gain2 obstacle callback instead of
the Jimmy gain1.5 is not. See [camera-ray-predicate.md](../checkpoint/camera-ray-predicate.md)
for the independently recovered obstruction query.
## Adapter recommendation and verification boundary
Keep a small mutable source-local camera state with the exact writers above.
For bounded VR08, dispatch ground versus air with the stored movement-mode
decision recovered in438A60, then use full source transforms and one source
camera ray. Preserve shared viewport history and compute aim from old eye.
Do not use support alone to pick a camera branch, reset look on each attach,
apply stored gains to air, or post-correct with a second collision query.
Resetting camera state at a reconstructed scene boundary must follow the actual
PostLoad/default/control event; the persistent-state report is separate.
REA was used through the existing local launcher on a generated EXE copy.
The first new helper request mistakenly supplied VA as a numeric file offset;
the corrected file offset3A5D0 mapped to43A5D0 but Ghidra12.1.4 had no recognized
procedure there. Both complete failures are retained in
`artifacts/grappler-camera-live/rea-eye*/`. No pseudocode success is claimed and
no unchanged failed request was repeated. Existing successful REA evidence for
437740 is ev_d2502f41c45731b86d4365634fbc6f0d1b3b70d880fd5741275fd36f1d585aa4;
47C210 is ev_ff5aab3bdc275e6626753743a3567a556f698209ad9f65689cf49a4b5f56107d.
Guarded disassembly supplies the missing follow/eye entries.
Unresolved: runtime original-versus-port VR08 camera comparison; flag828/851
transitions outside the bounded normal case; complete scene-entry shared-camera
cache continuity. No new copied-original camera probe was run in this chunk.
+107
View File
@@ -0,0 +1,107 @@
# Grappler scalar checkpoint
Historical component checkpoint; liveVR08 integration now supersedes its pending
gates. See [Grappler live status](grappler-live.md) for current scope and tests.
Continuation: [aim/constraint/contact checkpoint](grappler-query.md) adds42
original component observations and corrects the enclosing aim→primary gate.
The attachment leaf's broad acceptance does not bypass aim's earlier return.
2026-11-03. Continues user-requested gadgets after the Rocketship/orbit fixes.
The latest playable packages include the orbit Left/Right correction70cba65.
GrapplerMotion is an isolated component; no live equip/ray/swing/camera path is
enabled. Originals and supplied friend files remain untouched. All investigator
ownership returned after their usage limits; primary integrated retained results.
## Implemented coverage
| Original span, exclusive end | File offset | Managed coverage / verification |
| --- | --- | --- |
|426BE8..426C70|26BE8|Explicit x87 sqrt distance minus100, first-length sentinel and initial rope Z scale.8 native cases, including reattach, fractions and short/negative lengths.|
|426DAC..426DD5|26DAC|Held reel: old length strictly>250, subtract250*dt without final clamp.6 native cases; loop-audio branches are outside the snippet.|
|429DC9..429DF5|29DC9|Fast reel: target<old length, subtract950*dt without target clamp.6 native cases.|
|42A077..42A1A2|2A077|Swing scalar offset acceleration, stored elapsed>=double.2, clamp50 and350 damping boundary, subtract float.2 once.10 native cases; no body constraint/position execution.|
`tools/binary/grappler.py` guards the authoritative EXE identity and enclosing
source spans; `grappler_motion.py` records the four exact span hashes/offsets and
imports completed probe results. The numeric fixture in
`tests/GamePort.GrapplerTests/original-scalar-reference.json` includes source,
generator, executable and log hashes. Eight attachment observations measure only
length/initial-length/scale callback; managed velocityY100 and reel target are
supported by the separate guarded426CDE..426D4D source, not those observations.
Independent jump/fire detach is retained from the prior source contract.
42A0C2 stores Z while retaining its unrounded x87 value until damping; the new
managed helper preserves a double intermediate there. X is reloaded after its
float store. Both are bounded projections; general x87 bit identity is unclaimed.
Neither negative lengths nor250/target overshoot are silently repaired.
## Probe boundary and verification
`grappler_scalar_probe.c` copies the hashed EXE into private memory, relocates
only whitelisted absolute scalar operands in the four slices, seeds synthetic
frame/root/state, stubs the rope shape's scale callback and exits at bounded
slice boundaries. It never invokes the original entrypoint, ray/body dispatch,
audio or renderer. Separate copied Wine32 installation/prefix runs with no
network or Original mount. Thirty cases finish with GRAPPLER_SCALARS_COMPLETE.
The initial fresh Wine prefix exceeded an8-second allowance and could not load
kernel32 on retry; those failures are retained. A copied previously working
prefix resolved startup. A fixed original-image allocation was unavailable;
the final successful probe uses private image relocation instead. Earlier map
failure logs are retained, and no results from failed runs enter the fixture.
The initial C build collided with Windows' byte typedef; emitter naming was
corrected before successful compilation.
Five managed groups compare all30 native observations within.0002 and cover
first-length retention, source-only velocity/target, overshoot, one-step damping,
simultaneous fire/jump and bounded inputs.14 Python source/projection checks,
existing25 movement/15 gadget groups and the main .NET10 build pass. This is
component execution/port compilation, not original or modern Grappler gameplay.
Evidence is under artifacts/grappler-scalars/{source.json,probe-ready/wine.log,
probe-ready/capture.json,managed.log,python.log,movement.log,gadgets.log,build.log}.
## Retained source investigation and remaining integration gates
The following source evidence narrows the next work; it is not a live adapter:
- Aim cursor and attachment have different gates.426A70 attaches on a successful
ray hit without repeating429D00's450-distance/material rejection. Both query
root→full-Euler local(0,2400,2400) using47C210(false). The aim path refreshes
root at42A384, discarding the earlier swing pivot+116. VR08 game vtable4D00D0
slot134 at4D0204→475CD0(false) supports static filter admission, but selected
material/global context and attached callback composition remain to implement.
- 429D00 returning true only ends the remaining active input426030. Ordinary
Jimmy437940 still dispatches437C40/437F90, publishing velocity independently
after swing root work; do not skip normal movement wholesale. Swing constraint
normalization uses OMT quick_magnitude, unlike attachment's explicit sqrt.
- Constructor/helper bindings point to HIROPE→rope01.ASE/jimycarl.png and the
owned cursor's retainedsprites.omt8. Cursor constructor4453B0 includes misleading
shadow debug strings; full draw/size/material consumers and helper retention
remain gates before an exact resource exporter/live visuals.
Retained REA replies, export bundles and closed snapshots:
| Artifact / procedure | REA Evidence |
| --- | --- |
|grappler-ray/rea/01.json47C210|ev_ff5aab3bdc275e6626753743a3567a556f698209ad9f65689cf49a4b5f56107d|
|grappler-ray/rea/02.json469A10|ev_03ea52bd4de36f296429073b5478032e7e55f7dc64c8545de8151bb893dd3542|
|grappler-motion/rea-base/00.json43AA40|ev_4f2a6aa666451db831efd46f5c587573e22d8072315626b8bc2f844f9c6f0cae|
|grappler-motion/rea-base/01.json47B4B0|ev_d45e078c585d3773494c0e0dfb1696178dd0b8ce8b696caf133892ff070e552e|
|grappler-resources/rea-constructors/00.json41EEB0|ev_307511ff899b91988b77796923fdfc31fa0f1bda5549f13b34c775fdc4917591|
|grappler-resources/rea-constructors/01.json4453B0|ev_423e61df2143a9dd441abffb09540b8c4ce401a0a05774d59221db623c2a7007|
|grappler-resources/rea-constructors/02.json445540|ev_76d17159215638e5e200985b3b83fa917c484805543a80a6b0ec2b86d466a488|
|grappler-resources/rea-constructors/03.json41F030|ev_2c7479a578411c7248c48387125c005db3241e79a3cb91254f1c81bff267957f|
All artifact paths are under artifacts/. The unrecognized475CD0 pseudocode
request has a retained provider error; raw vtable/code supplies that leaf's
evidence. Prior unrecognized429D00/426A70 calls were not repeated. No provider
configuration changed. Source disassembly supplements successful recognized
helpers; no whole-function pseudocode success is attributed to missing entries.
Next: selected polygon/material context and exact original attached constraint /
collision callback42A660; helper model/cursor draw+reset/cleanup and shared follow
camera ownership. Then boundedVR08 integration with simultaneous jump/fire,
reattach, control loss, menu, noclip and RETURN tests. No nearest-hook/direct-pull
substitute, invented launch impulse, generic helper persistence or original/native
Windows gameplay claim is enabled by this checkpoint.
+132
View File
@@ -0,0 +1,132 @@
# Grappler lifecycle and retained state
2026-11-03. Static source contract, EXE SHA256
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
Preferred-base VAs map to raw file offset VA−400000 at the guarded code sites.
Source guards/projection tests are recorded in grappler-camera-live/source.json
and python.log. No original gameplay was executed for this investigation.
## State ownership and reset boundaries
Jimmy complete owns rope+B0C, cursor+B14, companion+A1C and sound handle+1E04.
Raw selected gadget4F0588 and Grappler globals are process storage, not fields
serialized into the TSK inventory. Retained Jimmy is reused by ordinary loads;
its constructor must not be simulated on every scene entry.
| Storage | Fresh Jimmy constructor | Attach | Detach / selected cleanup |
|---|---|---|---|
|attached4F8210|422761→false|426C7F→true|429C28/428810→false|
|anchor index4F82CC, first anchor XYZ4F8214..1C|422767..422782→zero|Current ray hit copied to indexed anchor|No clear|
|first length4F82B4|422796→0|426C24 tests0;426C6B writes current length only on zero sentinel|**Preserved**|
|current length4F82B8|42278C→0|426C1E stores distance−100|Preserved; reel/swing own later updates|
|swingX/Z4F82BC/C0|4227A0/AA→0|426CE2/EC→0|429C7E..CA5 multiply each by float.96|
|elapsed4F82C4|4227B4→0|426D2E→0|Preserved|
|fast target4F82C8|No explicit constructor write; process zero-fill initially|426D4D→anchorY−rootY−200|Preserved|
|complete864 action byte|Not renamed as generic control state|426C85→true|429C2E/428816→false|
|loop34 handle complete1E04|4227CD→−1|Stop old, play new34, save handle|Stop if valid; store−1|
The complete EXE disassembly scan has only two direct writes to first lengthB4:
constructor zero422796 and first-attach assignment426C6B. The inspected retained
Init437890 and full PostLoad423610 route do not repeat that constructor reset;
the global writes in equip/detach/cleanup are bounded above. This supports
retaining B4 across ordinary retained-player loads and re-equips. It does not
establish a disk save/load serialization contract or arbitrary indirect memory
write absence. First attachment's length/600 scales owned rope Z only whenB4=0;
recreating the port visual requires preserving/reconstructing that first scale
as an implementation bridge, not rescaling it from each current length.
Constructor reset is tied to a newly constructed Jimmy, not just a new game
screen. Current length and swing state also survive the listed cleanup paths,
but attach always assigns/reset them. Session storage is appropriate for these
globals; a scene-local active attachment/query reference still needs an explicit
safe boundary in a modern adapter. Such teardown is not evidence that the
original ordinary stage reset attachment.
## Equip, attach, detach and helper visibility
4297DD equip hides the companion via complete58(1), gameD0(0), game214(0)
when present, writes camera locals and raw7. No attach/reset is implicit. The
optional inventory/tutorial menu command9B is a separate branch.
426A70 attachment is reached only after429D00's enclosing aim/blocking gates.
It stops prior +A3C audio, repeats its ray, stores length/anchor/first scale,
sets attached/action, clears jump+7E8 and linked jump effect+6C0, plays one-shot
31 and restarts loop34. It zeros swing scalars/time, preserves velocityXZ,
writes velocityY100, sets fast target, and changes camera fields. The rope's
non-null/resource-visible guard426D85..426D9D calls complete58(0) and records
the visibility-related70 state. The exact owned-resource rendering is separate
from the camera/lifecycle contract.
Held primary while attached reduces length by250*dt only while old length>250,
ensuring loop34; the alternate branch stops that loop. Before raw7 dispatch,
429D5D..429DBB maintains loop34 according to42A7A0 held-primary and attached.
This prelude is not an unconditional loop: it stops a valid handle when the
appropriate predicate fails. Fast reel950*dt and its target test are separate.
Do not combine all sources into a forever-running equipped sound.
429C10 returns immediately if already unattached. Otherwise it clears attached
and action, resets detached camera locals, damps residual swing.96, **sets body
velocity XYZ0**, directly selects FALL, stops loop34 and marks−1, and hides rope
via complete58(1). It does not supply launch velocity, reset first length, clear
movement speed, rewrite jump/movement mode or erase pending impulse. Caller
preparation may do some of those things independently.
Selected cleanup4287AC conditionally restores the companion if its+9E8 gate is
zero: show58(0) only when visibility-related70 is nonzero, then gameD0(1) and
game214(1). It calls detach204, ordinary camera170, clears attached/action again,
hides cursor58(1), and sets raw−1 in common tail428832. The +9E8 guard prevents
unconditional companion visibility restoration. Inactive detach is not an
independent catch-all loop stop; valid source state keeps loop ownership aligned.
The prior independent resource investigation owns exact helper retention/draw.
## SWING is protected from ordinary action requests
The controlled frame calls438A60 then429D00 before later primary426A70. A true
429D00 return ends remaining426030 input only; normal Jimmy437940 still runs.
An attached swing sets logical Euler pitch/roll0 while preserving yaw at429E4A..
429E7C, then requests complete150(`SWING`) at429E84..429E8B before rope/body
constraint work. Ordinary437940's movement/body publication must continue.
Complete150→43AFF0 first compares current action with the requested action and
protected actions. Literal SWING4EF6D8 is checked at43B096..43B0B0; matching
current SWING returns43B597 before RUN/STOP/LEFT/RIGHT conditional changes.
Thus normal437940 requests do not overwrite SWING. Detach uses direct complete
E0(`FALL`,1) and bypasses that conditional action guard. The air jump/FALL path
in437F90 can directly request FALL only for jump modes3/4; attachment already
clears jump mode0. A retained SWING render pose is justified while this contract
holds; it must yield to direct scripted/hit/death action ownership rather than
being a universal per-render override of every action.
## Control and transition events are different boundaries
Source [cutscene-preparation.md](../checkpoint/cutscene-preparation.md) recovers:
| Event | Proven operation affecting Grappler |
|---|---|
|CAM with NULL control|Jimmy438→42AE00→selected cleanup178, then410 speed/velocity preparation, orientation flatten, raw control clear|
|Initial non-none MCA activation|410 first, orientation flatten, then438 selected cleanup and raw clear|
|Later MCA shot|No repeated410/438/raw-clear preparation|
|AI with NULL control|410 and raw clear; **no438 selected cleanup**|
|Raw control owner changes alone|Controlled426030/437940 tail stops; no generic detach follows from that fact|
|RETURN457FF7|Selected cleanup178 before return flags and staging|
|Ordinary LOAD/practice stage43B5A0|No selected cleanup;148→429A00 only stops+A44, distinct from loop34|
|Retained Init/PostLoad|No blanket first-length reset; specific scene/gadget/camera rules remain separate|
410→42AFC0 clears speed/velocity through43A750 and requests conditional STOP.
When SWING is current,43AFF0 can preserve it; do not infer detach from STOP
preparation alone. Menus pause or gate input under their existing phase rules.
Debug noclip is a modern policy, with no source semantics. A chosen noclip/scene
safety detach should be labeled as that adapter boundary and retain proven B4
persistence. Debug force control likewise changes modern effective ownership;
it must not erase already delivered authored selected-cleanup events.
## Remaining questions and claim boundary
The ordinary VR08 lifecycle is sufficiently specified for a bounded live
adapter plus tests for first attach, held reel, jump release, high-contact
detach, reattach, re-equip, CAM/MCA cleanup and RETURN. Save-file serialization
of global first length is not recovered. Whole-original menu/control/render
comparisons, malformed selected/attached/loop combinations and all other
levels' special follow/action policies remain open. These are static facts and
projection checks; managed compilation or VR08 smoke must be reported separately
by the integrating primary, and Windows user testing remains runtime evidence.
+108
View File
@@ -0,0 +1,108 @@
# Live Grappler: bounded VR08
2026-11-04. Supersedes component-only status in grappler-query.md. Original
EXE/DLL/assets remain authoritative and untouched. The playable orbit70cba65,
lab69d0187 and parked collision35a2a66/0272f7b checkpoints remain preserved.
All prior investigators returned ownership; primary integrated and verified.
## Coverage and implementation
| Contract | Original evidence | Current adapter / verification |
|---|---|---|
|Root/full-Euler first-hit ray, material/close gate|429D00 and enclosing426030;23 native aim cases|GrapplerRay/Geometry; actualVR08 and close-surface regression. Early input return still permits ordinary player update.|
|Attach/reel/swing/detach scalars|426A70/429D00/429C10;30 native scalar +10 constraint cases|GrapplerGadget composes recovered components; no direct-pull replacement, reel clamp or launch impulse. Normal body and frame phases continue.|
|Shared sphere/body/base contact|479D20→47B4B0,42A016,43AA40→42A660;41 new native cases|OriginalBodyPhysics retains mutable context; attached Move reuses it. Normal and attached wall callbacks both reach Grappler. Live actual-wall scalar/root fixture verifies high-contact detachment.|
|Camera|438BC0/439900,437740, attach/equip/detach writers; guarded static/Python projection|GrapplerCamera dispatches by movement mode, uses distinct ground/air transforms/gains, obstruction gain and old-eye quantized aim. Managed checks and rendered replay; no original-camera runtime comparison.|
|Rope/SWING/cursor|HIROPE/HISWING bindings, OMT shape-scale consumer,445580 final110 dimensions|Exact exported art, dedicated source-pivot morph; fixed first-length scale, pre-collision rope root, alpha cursor. Generic billboard remains modern renderer bridge.|
|Selection/companion/control|427FF0→4287AC, CAM/MCA vs AI_NULL, RETURN457FF7|Normal selection and F1 grant; cleanup hides helpers/stops34/restores camera and eligible companion. Raw control loss alone does not detach. Actual intro and RETURN tests pass.|
|Persistence|Ctor/first-attach-only B4 writes; source lifecycle in grappler-lifecycle.md|GrapplerMemory lives in Main across reconstructed scenes; helpers are scene-local. Retained scalars tested; not serialized into TSK.|
|Debug policy|Modern tool boundary, not original recovery|F3 releases attachment/selection. R resets memory. GiveGrappler outsideVR08 retains practice selection but enables no unsupported live mechanics.|
State belongs to three scopes: process/session scalar memory (anchor, first/current
length, reel target, swing), scene-local helper/controller state (equipped/attached,
loop/cursor/pose), and LabSimulation body/shared viewport history. Cleanup releases
attached motion, default camera, visuals and sound without erasing first scale.
RETURN raises selected cleanup before the transition event. An ordinary modern
scene teardown also releases scene-local resources before SceneAudio disposal;
this is a modern safety boundary, **not** a claim that every original LOAD detaches.
Retained scalar memory survives that boundary; scene-entry shared-eye continuity
and arbitrary non-RETURN attached transitions remain unresolved.
On attach, clear jump word/effect only, set Vy100, preserve movement mode, hold,
acceleration and pending impulse. Input runs before ordinary player apply on fresh
entry and after it on retained entry. StepCamera precedes gadget input. SWING uses
a separate source-pivot draw and preserves ordinary body publication. Collision
may detach during attached movement; the source tail still updates swing/helper
state using the unclipped constraint root. Surface aim is then recomputed; fire
performs a fresh trace when unattached. No cached cursor-to-anchor substitution.
## Checks and captured evidence
- 113 original-component observations total: prior72 scalar/aim/constraint/contact
plus41 body/support/ray/full-contact cases. Native probe generation/log/reference
hashes are retained; source execution uses copies under artifacts, never Original.
- 13 managed live groups (`tests/GamePort.GrapplerLiveTests`) cover fresh/retained
input order, attachment/normal body, held reel/simultaneous fire+jump, detach/
reattach/first-scale, strict60 impact, actual wall constraint collision, shared
stale-contact replay/zero delta, camera consumers/transitions, ownership/intro,
actual RETURN, noclip/reset/retained memory, helper art and close-surface gate.
The actual-wall test explicitly positions Jimmy and sets rope/swing state;
this is distinct from the unseeded input replay below.
- 40 Grappler Python checks: guarded original spans, camera projections, assets and
saved native-body observations. The final full Python suite passes297 tests plus2 separate HUD checks.
- The final scripts/test.sh run exits0:297 Python+2 HUD checks, all managed
suites, route/gadget GPU replays, checkpoint/transition and audio checks pass;
all539 original hashes verify. Log `artifacts/grappler-live-final-tests.log`. Selected-source Patrol/Interaction projects needed
explicit Grappler/heading dependencies; initial compile failures were fixed.
- Headless llvmpipe1280×720 and native Linux GTX1070/private Xvfb1920×1080 replay
pass all9 phases with enabled Vulkan validation, zero errors. SDL Left/Ctrl/Up/
Shift/F3 events are received.120 extra ordinary ticks reuse received input;
no root/velocity/rope scalar/timer is seeded. Capture stages include attach,
original SWING/rope, detach, reattach, cutscene, noclip and reset. Images inspected.
Logs `artifacts/grappler-live-{smoke,window}.log`; captures share those prefixes.
- 1920×1080 Player-page capture (`artifacts/grappler-debug-wide.ppm`) fits all32
rows including Give/Select Grappler. Managed navigation/repeat/bounds checks pass.
Reproduce from GamePort with `source scripts/env.sh`, then:
```
dotnet run --project tests/GamePort.GrapplerLiveTests
dotnet run -- --scene artifacts/extracted/VR08/scene.json --level gam/VR08.gam \
--smoke-grappler --headless --screenshot artifacts/grappler-check.ppm
```
Native-window replay uses `--width 1920 --height 1080` without `--headless`,
private Xvfb and SDL_AUDIODRIVER=dummy
where no hardware output is available. Dummy audio verifies stream/lifecycle,
not audible quality. Original whole-game VR08 and native Windows play remain
unverified; cross-publishing is recorded separately below.
## Remaining work
Full scene-global body interleavings/dynamic pairs, other levels/material policies,
special camera828/851/mode2, complete source renderer flags/lighting, arbitrary
attached ordinary LOAD continuity and save serialization of globals remain open.
These do not block the boundedVR08 implementation. Next gadget candidate is
Scooter, whose support/wheel/contact contracts are explicitly unresolved in
scooter.md; recover them before implementing its vehicle behavior. Preserve the
parked general collision work and avoid expanding Grappler to other levels until
those shared contracts and actual original comparisons support it.
## Package validation
Both self-contained packages identify clean source43806fe86224c685f56e897b88b4656305d16bdd
in BUILD-INFO.txt. Linux executable is native ELF x86-64, Windows is PE32+ x86-64.
All9 Grappler resource files compare byte-for-byte with extraction in both
packages, including both exact RGBA canvases, original morph samples and manifest.
`artifacts/grappler-live-package.log` records successful publishes/preparation;
NU1900 vulnerability-metadata lookup warnings are the existing restricted-network
condition, not compilation failures. No runtime online dependency was introduced.
Final standalone Linux test ran from /tmp with DOTNET_ROOT/DOTNET_ROOT_X64 unset,
bundled assets, native GTX1070/SDL3 and private Xvfb1920×1080. All9 phases and
five injected SDL key bindings pass with zero enabled Vulkan validation errors;
all9 stage GPU readbacks are byte-identical to the development native run. Log:
`artifacts/grappler-live-standalone.log`; resource/readback hashes are retained in
`artifacts/grappler-live-package-check.json`. Packages are `dist/linux-x64` and
`dist/win-x64`. Native Windows gameplay and whole-original comparisons remain
pending; Windows publication is not represented as runtime validation.
+123
View File
@@ -0,0 +1,123 @@
# Grappler aim, constraint and contact checkpoint
Historical component checkpoint; liveVR08 integration now supersedes its pending
gates. See [Grappler live status](grappler-live.md) for current scope and tests.
2026-11-03. Continues [scalar checkpoint](grappler-component.md). Adds a bounded
VR08 ray/material adapter and isolated aim/rope-constraint/post-base contact
implementation. **Grappler is not enabled in live gameplay yet.** The next gates
are shared body collision state, camera and helper presentation/lifetime.
## Corrected active-input ownership
The attachment leaf426A70 accepts a ray hit without repeating the cursor filter.
That does not mean ordinary input can attach to every hidden-cursor surface:
- 426084 calls438A60 input, then426098 calls complete188→429D00.
- 42609E tests AL;4260A0 branches to4269C3 on true.4269C3..4269CD is a direct
epilogue/return, before later primary1C0→426A70 at4266C8.
- Aim distance<450 hides the cursor and returns true; rejected material does
the same. Both therefore end the remaining active-input pass. Ordinary Jimmy
normal/frame publication still runs separately, as previously recovered.
- The rejected-material branch42A4F8..42A535 may subtract250*dt when held fire
or consuming Enter46A3E0(13) accepts and old rope length>250. The close-distance
branch does not execute that reeling. Neither adds a final length clamp.
- 42A7A0 already polls Enter among primary inputs; the extra consuming Enter path
is separate and short-circuited when the primary predicate is true. The managed
component receives those predicates; keyboard state consumption belongs to its
future caller, not this pure geometry API.
This corrects the earlier interpretation that cursor rejection could simply be
bypassed by held primary. No live behavior had been connected to that assumption.
GrapplerAim.EndsActiveInput records the enclosing return, rather than only whether
a fire button happened to be held.
## Source evidence and implemented scope
Authoritative EXE f5281076…1aea8 and OMT2.dll3ec41ead…54943 are required by
`tools/binary/grappler_query.py`. Full hashes, each span hash/file offset and the
native generator/executable/log identities are in the committed numeric fixture.
Text file offsets below are VA−400000. Runtime globals are not file offsets.
| Source span, exclusive end | File offset | Contract |
| --- | --- | --- |
|42A406..42A652|2A406|Aim hit/miss, strict450 threshold, selected polygon/material/definition distinction, blocked ranges, cursor point and early return.|
|429EA0..429FA4|29EA0|Anchor minus root+116, X/Z perturbation by swing*dt*30, original DLL quick-magnitude normalization, rope-length constraint and desired root before body clipping.|
|42A69B..42A6F1|2A69B|After base contact, zero swing X/Z; only sqrt(X²+Z²)>60 dispatches detach and sets Jimmy action latch1E25.|
|426030..4260A6,4269C3..4269CD|26030,269C3|Input→aim→true-return gate, separate from later primary helper.|
|42A7A0..42A7D6,46A3E0..46A3FB|2A7A0,6A3E0|Primary held predicate and consuming key-array read.|
Selected polygon global695D54 points to material+4, definition+0C, ID+8; global
5CFC60 holds the hit point. Missing polygon or definition passes the material
gate; present polygon without a material blocks. IDs60..69,80..89,210..219,−1,170
block. Visible cursor position uses hit−100*normalized(full ray), not normalized
hit offset. Normalization uses the original quantized quick_magnitude.
VR08 constructor's game table4D00D0 has slot134 at4D0204→475CD0, whose exact
bytes32C0C21800 return false while popping its24-byte arguments. Therefore the
existing NC/checkpoint admission and wall-first/grid/FIFO query are valid there.
Actual VR08 has240 polygons and only collision material IDs0/2/3/4, all ordinary.
GrapplerRay rejects other levels/profiles instead of inventing material context.
It queries the actual root and full-Euler local(0,2400,2400), not root+116.
OriginalCameraRay.TraceSelectedGeometry captures hit plus original polygon
metadata together. It uses the existing traversal and is independent of the
modern camera query toggle. Camera-only disabling must not disable gadget rays.
Tests retain a farther first-hit blocked material instead of silently selecting a
nearer allowed material. No global source state is manufactured from cursor art.
The source constraint stores normalized X/Y before scaling, while Z retains its
unrounded intermediate. Managed code preserves that order with double arithmetic;
general x87 identity remains unclaimed. Zero-vector normalization is explicitly
outside the finite modern component boundary (the source produces nonfinite
geometry); it is not silently repaired with a new position.
## Original-code and port verification
`grappler_query_probe.c` copies three bounded EXE slices into private memory,
relocates whitelisted operands, calls our copied original DLL quick_magnitude,
and supplies synthetic ray/material/cursor/primary/detach accessors. It never
runs the game entrypoint, actual world ray traversal, body dispatcher, base
contact43AA40, camera, rope renderer or full detach lifecycle. The constraint
exits before47B4B0; impact starts after43AA40. These bounds matter.
42 observations complete in the isolated copied Wine32 environment with no
network or Original mount:23 aim,10 constraint and9 post-base impact cases.
Combined with the previous30 scalar observations,72 copied-original observations are
checked by10 managed groups. New vector tolerance is.004 units (including large
coordinates); scalar checkpoint retains.0002. Flags and owner/gate states compare
exactly. The actual VR08 authored start yields two cardinal aiming hits with
retained material identities. No original gameplay/render comparison is claimed.
18 Python Grappler source/projection/evidence groups,11 existing camera groups,
13 Rocketship groups and main .NET10 build pass. Final two-frame lab gameplay
readback is byte-identical to the prior corrected-camera baseline. Actual VR08
geometry preview also renders two frames; both runs enable Vulkan validation and
report zero errors.539 original files verify unchanged. No new gameplay package
was needed; playable packages remain70cba65.
Logs: artifacts/grappler-query/{probe/wine.log,probe/capture.json,managed-final.log,
python.log,camera.log,rocketship.log,build-final.log,gameplay.log,vr08.log,
originals.log}. One synthetic first-hit test initially used the opposite of the
source winding; its failed log is retained and the fixture winding was corrected.
The first leaf guard expected a plain return, then was corrected to the actual
stdcall24-byte return before importing references.
REA's existing47C210 evidence
ev_ff5aab3bdc275e6626753743a3567a556f698209ad9f65689cf49a4b5f56107d
and43AA40/47B4B0 evidence in grappler-component.md remain supporting static
records. A new local REA/Ghidra426030 pseudocode query was not recognized; the
complete error/export/closed snapshot are retained in
artifacts/grappler-live/rea-input/. No repeated selector/config repair or
successful pseudocode is claimed. Exact guarded caller bytes plus the copied
aim execution establish the early-return correction.
## Next integration
Carry the original shared sphere/selected-contact context across ordinary
physics and the attached47B4B0 call, including42A660→43AA40. Do not treat the
post-base contact suffix alone as full collision integration. Then finish helper
rope/cursor material/transforms, follow-camera fields and equip/detach/control
loss/RETURN persistence. The cursor's retainedsprites Canv8 is already exported
for Baseball; rope HIROPE→rope01.ASE still needs a verified runtime binding.
Only then enable boundedVR08 with input-driven attach/reel/swing/detach checks.
+50
View File
@@ -0,0 +1,50 @@
# Grappler source resources and helper presentation
2026-11-04. Exporter: `tools/extractors/grappler_resources.py`; generated manifest
`artifacts/extracted/grappler/grappler.json`. Six source-file SHA256 values are
checked before export; originals remain untouched. Export includes rope01.ASE,
jimswing.ASE, jimstop topology, jimycarl pixels and RetainedSprites canvas8.
## Recovered bindings and consumers
EXE VAs map to file offset VA−400000 at these sites. HIROPE points to rope01.ASE;
HISWING→jimswing.ASE and SWING are bound422BCC..422BDA. Source rope has6 indexed
vertices/6 triangles, longitudinal Z0..600.9758 after the established ASE axis
conversion. Init41F0FA..41F12E applies roll180; attached429D00 sets pitch/yaw
from the quantized constraint offset and resets roll0. Render position is the
unclipped constraint desired root+Y116, even when collision clips Jimmy elsewhere.
First attachment426C63 mutates shape geometry through virtual34 using
(firstLength/600) longitudinal scale. Original OMT2.dll10005970 (file5970) is
OMedia3DShape::scale, not an actor transform or radius setter. Reeling does not
repeat that geometry mutation. The modern renderer equivalently applies the
retained first scale to fresh base vertices each render; it never accumulates it.
SWING has426 indexed vertices,814 faces, source samples0/480. Its absent UVs use
jimstop's source topology and exact jimycarl atlas.43AFF0 protects SWING from
ordinary conditional RUN/STOP requests; body integration is still active. The
port draws a dedicated source-pivot morph and hides the ordinary standing draw.
Cursor4453B0 inherits SpriteSize150, but its init445580 (file45580), invoked by
virtual40C, converts final signed words complete5E8/5EA=110 to world dimensions
completeAC/B0. Thus the visible cursor is110×110.4645F0 sets alpha blend6/7 and
center alignment3/3; canvas8 is64×64, decoded SHA256
8d31014cb9b9661ebed902c864bf740f562460e74da3f6b86ed3d2be4d10f0ec.
Flags248 and source constructor metadata remain in the manifest.
## REA and verification boundary
REA on generated copies retained complete replies/snapshots in
`artifacts/grappler-assets-live/rea-{shape,sprite,bind}/`. Shape consumer Evidence
`ev_e337ad879cea5877eb463324d48d15f860ceacf80c8225e66e9f35bc4b8ed660`;
sprite replies include `ev_9af340590afc1e0c64a249af250a520b2f09eba484e95d097f134b3254b67a8d`,
`ev_ab13438ec345f10472d10965048c34d31654e6d9303d729df98b65aa92d37a1e`,
`ev_69c4b496b5da7846245164028f0cb994222b0f136d24bb5fa3da7fdf236b228d`.
464430 was not recognized; failure retained, no decompilation success claimed.
Disassembly and guarded byte spans supplement those results.
Six Python checks verify exact source samples/pixels, source binding/consumer
spans, final cursor sizing and bounded output. Managed live tests verify constant
first-scale rendering, helper cleanup and110-unit cursor dimensions. Native
Linux VR08 captures show rope/SWING/cursor. Generic sprite billboarding uses the
existing modern camera-facing bridge; full original flags/renderer behavior,
lighting and original-versus-port visual comparison remain unresolved.
+131
View File
@@ -0,0 +1,131 @@
# Grappler source contract and integration gate
Continuation: [scalar implementation and30 copied-original cases](grappler-component.md).
The component remains isolated; live ray/body/camera/helper gates below still apply.
Later [aim/constraint checkpoint](grappler-query.md) proves the enclosing input
gate:429D00 returning true prevents later primary attachment dispatch. The leaf
helper's lack of duplicate material checks must not be read as a bypass.
2026-11-03. Item7/raw7, using the supplied target6 decompiler bodies as leads,
then independently reading the hashed EXE instructions. No friend gameplay code
imported. Static recovery and twelve Python source/projection tests only: no live
Grappler, original gameplay execution or Windows validation is claimed.
## Identity, REA and guarded evidence
Neutron.exe SHA256 is `f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
All addresses below are preferred-base EXE virtual addresses; for these text spans
the file offset is VA−400000. `tools/binary/grappler.py` guards twelve spans,
three virtuals, two dispatch entries, sixteen constants and four strings;
`artifacts/grappler-contract/source.json` records each exact offset/hash.
REA6.8.0/Ghidra12.1.4 with project launcher/profile
`e1ad533d4cc0333c2136fe0894217de2d61feea098240326e78633f9e4ddcbf9`
decompiled jump predicate42A730, Evidence
`ev_4c43cfa8fa5d66c31111d49510aba391f069b446160a448c5544ea042dd452c4`.
Complete replies/export/snapshot are in
`artifacts/grappler-contract/rea-trajectory-20261103/`.
426A70's VA selector failed fallback file mapping; corrected offsets26A70,
29D00 and29C10 mapped correctly but have no recognized procedures in this
default Ghidra analysis. Those explicit errors are retained separately under
`rea-trajectory-offset-20261103/`; no identical retry followed. The older
`rea-controller/` attempt had an IPC denial. This run used the permitted local
Unix socket access and closed both owned sessions. No REA/config repair occurred.
Supporting decompilation is `../../../jn-engine-master/docs/decomp/evidence/
c3djimmy_target6.md`, helpers426A70/429D00/429C10. Its forced `__thiscall`,
`unaff_retaddr` and uninitialized aliases are not ABI proof. Byte-guarded objdump
and known game-interface helpers establish the contracts below; full-Euler/x87
and body execution still need separate references.
## Owners and fields
Jimmy complete pointer owns game interface+C0. Complete vtable4A3BDC has
188→429D00 (swing/aim),1C0→426A70 (held primary),204→429C10 (detach).
These offsets are distinct from movement mode complete+7C4.
| Owner | State and evidence |
|---|---|
| Jimmy complete+B0C | Owned C3DGraplingHook: ctor41EEB0 called422800, pointer stored422810, named at422821..82C; not a nearest serialized hook actor |
| Jimmy complete+B14 | Owned C3DTargetCursor: ctor4453B0 called42255B, stored42256B, named/hidden42257C..59D |
| Jimmy complete+A1C | Companion hidden and movement/collision disabled on equip/attach; cleanup restores only under its own9E8/visibility gates |
| Jimmy complete+1E04 | Loop34 audio handle;−1 sentinel; also touched by pre-mode-check swing helper |
| Globals4F8210/4F82CC | Attached byte / signed16 anchor index; constructor422761/767 initializes zero |
| Global4F8214+index*16 | Float4 anchor, copied from ray hit5CFC60 at426BA7..BD6; no tagged target search |
| Globals4F82B4/B8 | First rope length/current rope length; constructor zeroes both; first-length/scaling write only when B4==0 |
| Globals4F82BC/C0/C4/C8 | Horizontal swing scalars, elapsed damping time, fast-reel target |
| Jimmy complete+864 | Set on attach, cleared detach/cleanup; retain as an action flag until inherited consumers are fully recovered |
| Jimmy complete+7C8..7E0,854..85C | Follow eye/target and smoothing fields changed during equip/attach/detach |
Constructor zeroes the first anchor XYZ and scalars at42276E..7BE. Neither
guarded detach nor raw7 cleanup clears first lengthB4. Full helper persistence
through retained level loads remains a separate lifetime question. The indexed
region permits multiple slots by address arithmetic; do not invent a wrapping
rope/anchor stack: the bounded EXE references inspected show initialization and
reads of index, with no proven advancing writer.
## Input/update and state transitions
426030 receives Jimmy's game interface. After modal/game/control gates it runs
438A60 input then complete188→429D00 at426098; a true result ends Jimmy's active
controller pass. Held primary later reaches1C0→426A70 at4266C8 before the common
energy helper1C4 at4266DB. Thus Grappler attachment has no local energy charge and
precedes that shared zero-energy reject. Do not add an energy cost from menu index.
- **Equip:** jump-table4298E8 slot8 selects4297DD; hide/disable companion,
follow eye(0,50,−350), target(0,150,80), raw mode7. Optional inventory/menu
tutorial command9B remains its own branch.
- **Aim:** 429D00 samples root+Y116. After mode7's fast reel and optional jump
detach, its end portion performs a geometry ray from current root to full-Euler
local point(0,2400,2400), helper47C210. Distance<450 hides cursor and returns
true. Selected-polygon material IDs60..69,80..89,210..219,−1,170 also hide/block.
Polygon without material blocks; material without definition passes this test;
absent selected polygon passes it. A valid cursor is placed100 back from the
hit along ray direction. This is not a query for the nearest3GRA entity.
Its true return at close/rejected surfaces ends426030 before primary dispatch;
rejected-material held fire/consuming Enter may still reel the existing length.
- **Attach / held primary:**426A70 returns false outside raw7; otherwise consumes
primary even on a miss. While unattached it stops+A3C, repeats the root/local
point ray, stores hit anchor, sets current length=distance(root,hit)−100.
If B4==0, scale rope Z by length/600 and preserve first length. Set attached
byte and+864, reset jump word+7E8 and linked jump effect+6C0, emitSFX31, restart
loop34, clear horizontal swing/time, preserve velocityX/Z but setY100.
Fast-reel target=anchorY−rootY−200; eyeY400/Z−650, smoothing(.8,1,.8).
- **Reel:** when already attached and old length>250, subtract250*dt and ensure
loop34. Otherwise stop loop34. There is **no final250 clamp**. Swing helper
independently subtracts950*dt when target<current length, also without clamp.
- **Swing:** root+Y116 is constrained to length from anchor, perturbed by horizontal
scalars*dt*30. Proposed displacement passes through source body47B4B0 before
writing root314; velocityY is then cleared. SetSWING. Update scalars by
−constrained rope offsetX/Z*dt*.17 (stack0C/14, not body displacement64/6C).
At elapsed>=double.2, clamp each±50, multiply .95 when
length<350 else .98, then subtract float.2 **once**, not in a while loop.
Rope model orientation/placement and a separate shadow down-ray are also owned
here. This depends on full Euler/table math and body/camera shared context.
- **Detach:** independent jump predicate42A730 with attached and no held fire
calls204→429C10. Clear attachment/+864, restore eye(0,50,−350), target(0,130,100)
and smoothing(1.6,1,1.6). Multiply swing globals by.96 but **set body velocity
to(0,0,0)**, selectFALL, stop loop34 and hide rope. No invented launch impulse.
- **Collision:** game-interface override42A660 calls base43AA40, clears horizontal
swing and releases if their prior magnitude>60; pointer adjustment−C0 reaches
complete204. Shared collision dispatch/callback ownership remains a live gate.
- **Unequip:** raw7 cleanup4287AC restores eligible companion, detaches, restores
ordinary camera170, clears attached/+864, hides cursor; common tail sets raw−1.
## Implementation boundary and verification
The twelve Python tests verify byte identities, selected-material range edges and
missing-material branches, accepted-hit scalar initialization/reattach retention,
250/950 overshoot behavior, damping threshold/clamp/one-step timing and independent
jump/fire release. Host arithmetic projections explicitly omit x87 intermediate
precision, actual ray traversal, body/camera/actor execution. They do not establish
original runtime parity.
Safe now: use these isolated scalar rules and ownership map as implementation
contracts/tests. **Do not enable live Grappler as nearest-hook/direct pull.** Close
full-Euler ray/filter and selected-material context in VR08; body47B4B0 under
attached state including callback42A660; model/pose placement and shared camera
ownership; fresh/retained helper lifetime and control-loss cleanup. B4's first
length retention and simultaneous jump/fire are necessary regressions. REA's
missing function boundaries could be addressed on a copied analysis project using
the supplied explicit-boundary approach, without blindly trusting forced ABI.
+117
View File
@@ -0,0 +1,117 @@
# Invisible gameplay continuation
2026-11-02. Implements original item2/raw mode2 and shared energy warnings.
Collision recovery remains parked at35a2a66/0272f7b; the preceding gadget
source/packages7b5230c remain a separate verified milestone.
## Coverage and evidence
| System | Original contract | Port / remaining boundary |
| --- | --- | --- |
| Selection428E51 | Display2 precedes actual equip;9F8 tutorial override | Failed equip can retain display2/raw−1; successful equip starts both clocks0 |
| Wrapper424E80 | After base movement; any controlled pointer | Separate from Jimmy input identity; raw NULL freezes/hides meter |
| Activation | Recharge exactly7, energy>2/override, fixed−2 | Initial7-second recharge;7-second active timer; held reactivation; jump blocks activation only |
| Material114/FC/target55D | Alpha.7, indexed blend flash; target eligibility | Existing Jimmy draw; targetability retained, full enemy AI consumers absent |
| Meter4037F0 | Canv21/22, full gradient stretch, size/tint | Exact original pixels; logical placement/uniform scale is declared modern policy |
| Companion/cleanup427FF0 | Immediate hide, D0/214 flags,9E8 restore guard | Separate movement/body flags; body integration gated without blanket AI pause |
| CAM4165B7/MCA43129A | Default DeactivateInv1, named Jimmy lookup | Prelude separate from raw438 preparation; AI-null retains effect |
| Energy42A920 | Scalar4F83D4 and warning latch4F83DC | Shared owner and80/182 callback order/hysteresis across ordinary loads |
| Bubble follow-up | Equip/visual/drain/cleanup recovered | Runtime pending full movementmode2/jump/body contract |
Static reports retain hashes, VAs/file offsets, guarded bodies/sites, complete
REA Evidence, exports/snapshots and provider errors: [Invisible](invisible.md),
[assets/meter](gadget-followup-assets.md), [shared energy](player-energy.md),
[independent review](invisible-review.md) and [Bubble](bubble.md). No new whole
original-game execution was performed. The retained complete42A920 REA record
was reused rather than repeating that investigation.
## Implementation and ownership
LabSimulation owns InvisibleGadget and invokes it after controlled movement,
before its existing owned jetpack-effect phase. PlayerSceneBinding supplies both
Jimmy input permission and raw-any-control. Another controlled actor permits
this wrapper without granting Jimmy movement. Raw NULL freezes both timers and
hides the meter without ending the material effect. The pure recovered suppressor
branch is tested, but source globals4F8182/4F83E0 have no complete lifecycle
provider yet. Existing modal/focus/debug capture remains a broader port policy.
Successful equip hides Goddard immediately, starts both timers0 and colors/shows
the meter red. Initial recharge must reach exactly7 before a later tick can
activate. Held primary without jump requires energy strictly>2 or the tutorial
override, spends fixed2, sets remaining7/targetablefalse/alpha.7, then decrements
remaining in the same invocation. No continuous Invisible drain, invented sound
or edge latch is added. Ordinary jumping remains possible.
At remaining<=3, trunc(remaining×5)%2 selects conventional versus additive blend
on material0. Expiry<=0 restores opaque/targetable/red; recharge begins next tick.
The additive initial branch follows the existing chosen source graphics-option
path; its original option predicate remains open. Blended world depth writes
remain disabled as an explicit renderer policy. Captures verify port output,
not original visual parity or self-occlusion equivalence.
PlayerGadgetMaterial changes the existing atlas draw without changing pose,
geometry or authored visibility. InvisibleMeterOverlay uses exact Canv21/22 RGBA,
source width27/height percent×1.04, white/red vertex tint and full texture stretch.
Percentage is published before recharge clamps7, preserving its small ready
overshoot. Source local positions become centered640×480 logical rectangles
with uniform widescreen scale. Cached engine autoalignment scheduling is still
open; original pixel-placement fidelity is not claimed.
SceneDirector emits named-Jimmy GadgetReleaseRequested at initial CAM/MCA
activation when DeactivateInv is absent/true, before first MCA target/skip checks.
This differs from ordered raw-owner438/410/flatten callbacks. Explicit0 can bypass
the named prelude; raw-owner preparation can still clean. AI-null stops motion
and clears control without invented cleanup. Release stores remaining7/recharge0
and restores local state. Modern reset clears timers/diagnostics explicitly.
Companion movement/body-enable fields are distinct from AI Active. Equip disables
both and hides Goddard; cleanup restores them outside the six proven PostLoad9E8
blocked levels. ActorPatrol skips disabled body integration while retaining its
bounded AI subset. Independent future writes to movement/body flags, full
companion lifecycle and other AI modes remain separate work.
PlayerEnergy retains scalar and warning latch across ordinary scene rebuilds.
Ray, active jetpack and Invisible share tutorial bypass, empty-crossing80 before
write, low182 after scalar/before latch, strict<19 warning and>20 rearm. Raw saved
scalar/debug refill does not invent a latch reset. TSK retains its original
scalar only; complete damage/energy/pickup consumers remain unported.
## Controls and verification
Select owned Invisible in Tab/Space, wait for recharge, then hold Enter/Ctrl/left
mouse without jump. F1→Player adds Give/Select Invisible, Unequip and timer/
targetability diagnostics. F1 retains the existing gameplay/audio pause policy;
Tab while a special gadget is equipped unequips first.
Fifteen managed groups cover numeric/sound order, retained energy ownership,
strict gates, same-tick decrement, held activation, flash/expiry, raw-null/other
owner distinctions, named cleanup, companion restoration, failed display/raw
equip separation and original meter/widescreen geometry. Source coverage grows
to182 Python checks plus separate HUD tests. Independent review ran the earlier
12 groups before the final three binding/meter groups were added.
The eight-frame --smoke-invisible fixture explicitly advances836 additional
normal player ticks between rendered phases. It grants owned item2 and skips the
intro without relocating actors or directly mutating timers/materials. Headless
and native1920×1080 GTX1070/private Xvfb pass charged, activated, alpha flash,
additive flash, expired and unequipped checks; native uses real SDL Ctrl/Tab.
Tutorial energy stays20. Both report zero enabled Vulkan validation errors.
Six-phase captures were inspected. Logs/captures: artifacts/gadget-followup/.
These accelerated observations do not establish real-time original cadence,
manual navigation, enemy immunity, tutorial completion or native Windows runtime.
Complete scripts/test.sh passes182 Python+2 HUD checks, all managed suites,
30 main GPU completions and17 isolated Vulkan material checks, with zero enabled
validation errors. SDL dummy lifecycle and539 unchanged originals pass. Package
results follow the clean source milestone in progress.md. Full enemy sensing/
combat, graphics-option selection, cached canvas
alignment, exact scheduler/x87 boundaries and the other gadgets remain open.
Release: both self-contained packages identify clean1897dd2 (source_dirty=no).
Linux/Windows publish succeeds despite NU1900 metadata warnings. Exact Canv21/22
RGBA hashes match in both packages. Standalone Linux from /tmp passes all six
Invisible phases and the expanded F1 Player view at1920×1080; release validation
layers are unavailable. All539 original hashes verify after packaging. Logs:
package.log, package-invisible.log, package-debug-player.log and
originals-after-package.log. Windows is cross-built; native gadget testing remains
unverified. Preserved baseline packages remain untouched.
+100
View File
@@ -0,0 +1,100 @@
# Invisible implementation review
2026-11-01. Independent read-only review of the primary's current Invisible/energy
runtime against [invisible.md](invisible.md), retained companion/preparation
evidence and the original42A920 instructions. Reviewed files:
InvisibleGadget, PlayerEnergy, LabSimulation, PlayerSceneBinding,
PlayerGadgetMaterial, SceneDirector, ActorPatrol, Program and InvisibleTests.
The reviewer edits only this report; primary owns fixes and integration.
## Directly evidenced correction found and resolved
The initial SceneDirector only released gadgets through current raw-owner438
preparation. Original CAM4165B7..4165DC and MCA43129A..4312CC separately inspect
DeactivateInv and look up **JIM1**, even when the controlled pointer is already
NULL or another actor owns it. Both constructors default the property1; absent
GAM data does not mean false. MCA's prelude runs before its first target-none
branch. The initial implementation could therefore retain active Invisible
through a CAM/MCA where original code cleans it.
Primary added GadgetReleaseRequested with an explicit JIM1 lookup and
Integer("DeactivateInv",1) at single-CAM/initial-MCA activation, before target/
skip checks. PlayerSceneBinding subscribes and uses existing selected-gadget
cleanup. Re-reading confirms that correction is present. Existing ordered raw
438/410/flatten preparation remains separate. Later MCA shot changes do not
repeat the initial prelude. AI-null still dispatches410 without invented438/
gadget cleanup; its raw-null pause can retain Invisible state as source does.
## Confirmed source alignment
- Invisible runs immediately after the player movement phase and before the
existing owned effect phase. AnyControlled is passed separately from Jimmy
input ownership. Null raw control freezes timers/hides the meter; a different
nonnull owner can permit the wrapper without permitting Jimmy movement.
- Equip accepts energy>0 or VR override. Display selection2 is retained even
when the actual raw-mode equip rejects; caller cleanup removes the old special
mode first. Successful equip resets both clocks0. Unequip stores remaining7,
recharge0 and restores opaque/targetable presentation; modern full reset
starts0 and clears diagnostic counts explicitly.
- Activation uses remaining0 and recharge exactly7, primary without jump,
energy strictly>2 or override, one fixed−2 adjustment and same-call remaining
decrement. Initial recharge must complete first; reaching7 cannot activate
until the next invocation. Held primary can reactivate after another recharge.
- Recharge runs only with remaining0 and positive energy/override, clamps7 and
turns the meter white. Expiry<=0 restores opaque/targetable/red; recharge
starts next call. Active duration continues at zero energy or during jumps.
- Opacity0.7, additive initial branch and last3s alternating conventional/
additive blend match the guarded material path. Expiry argument0 means reset
material alpha1/blend-disabled, not alpha0. The one-atlas Jimmy draw keeps
authored visibility and geometry; no invented whole-model hide/fade is used.
- PlayerEnergy implements strict19/20 warning hysteresis, empty-crossing sound80
before the scalar write, low182 after the write/before latch and VR01..08
helper bypass. The scalar and warning latch share a session owner across
ordinary loads; raw saved/debug scalar assignment does not rearm the helper.
The upper clamp compares the pre-store sum, and callback-driven scalar changes
are respected by reloading after the crossing callback, as source42A975 does.
- Companion hide/disable occurs on equip, including recharge, not on activation.
The binding preserves distinct AI activation, body-enable and movement-enable
fields. Its six-level restore exclusion matches the bounded PostLoad9E8
mapping; it does not restore a saved previous visibility or blanket-pause AI.
## Explicit remaining boundaries
1. The pure Invisible suppressor branch is implemented/tested, but LabSimulation
currently supplies no provider for source global4F8182, nor the primary helper's
independent4F83E0 veto. Modern modal/focus/debug capture clears input/pauses
simulation. Those policies do not establish the complete original global
suppression lifecycle; document this as partial input coverage.
2. Source55D/49D target eligibility is stored/observable, but full enemy sensing,
lost-target, existing attack and class-specific consumers are absent. Generic
409CC0 also permits positive enemy934 when the flag is false. Do not describe
the slice as universal enemy avoidance or invulnerability.
3. Companion9E8 is represented by known initial level policy. Later source
setters/dynamic modes remain outside this bridge. MovementEnabled is stored
but has no independent modern consumer yet; the bounded equip/cleanup path
writes it together with BodyEnabled, which gates body integration. Independent
changes to only one flag require their original consumers before expansion.
4. Additive is the declared graphics509A13=false branch. The original setting
predicate, general multi-material/LOD behavior, transparent depth state,
original registry cadence and exhaustive x87 meter boundaries remain open.
Existing full-panel/noclip pauses and full scene rebuild are modern policies.
5. Meter resources/layout are being integrated by primary from the independent
asset report. This review does not certify that unfinished overlay or final
native/packaged renders. Full game and native Windows comparison remain open.
## Verification
The reviewer independently ran the current twelve managed Invisible/energy groups
successfully using the existing project SDK, logged in
`artifacts/invisible/runtime-review-tests.log`. That run covers energy callback
ordering/hysteresis/retention/tutorial bypass, first recharge, activation strict
threshold/jump, raw-null/suppressor pause, flash/expiry, repeated held activation,
cleanup and material mapping. It predates the primary's additional binding/
companion fixtures. Nine source/static-projection groups independently pass in
`artifacts/invisible/tests.log`; these do not execute original code.
Final integration should retain explicit fixtures for raw-other-owner activation
without Jimmy movement, AI-null freeze, named-Jimmy CAM/MCA cleanup while already
raw-null, DeactivateInv default/explicit0, failed equip/display separation and
companion restore restrictions. Primary owns those runtime additions and the
complete suite, actual SDL/GPU input/readback, builds and release evidence.
+172
View File
@@ -0,0 +1,172 @@
# Invisible gadget source contract
2026-11-01. Original item2/raw mode2. This report records static recovery and
bounded source projections; it does not claim original gameplay execution, port
integration or native platform verification. Original files were read only.
## Evidence and addresses
EXE SHA256 is `f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
`tools/binary/invisible.py ../Original` guards seven complete bounded spans,
50 decisive instruction slices, eight virtual bindings and six constants. Its
`artifacts/invisible/source-contract.json` records preferred VAs, PE-mapped file
offsets, bytes and hashes. All code addresses below map to file offset VA−400000;
the helper computes rather than assumes that mapping. Main source callers and
state fields are distinct from the display item index documented in
[gadget-controls.md](gadget-controls.md).
REA/Ghidra12.1.4 inspected a generated hashed EXE copy. Complete replies,
Evidence export and closed-session snapshot are retained in
`artifacts/invisible/rea-invisible-ipc/`:
| Procedure | REA Evidence |
| --- | --- |
|40E4A0 linked-model alpha/material setter|`ev_615030aa60b2346083853c40aa719ebc466e9f393fd870ea9722536a4f64cfac`|
|409CC0 generic enemy target predicate|`ev_1c4fe58878638158ea6f33db1474848910256873c00f266968debbf2ea35bf3f`|
|4037F0 meter size setter|`ev_525ca303ce70c16f524063053ebdd9fecd82054cf480d8f2f30f1ec0d7e08333`|
424E80 and427FF0 entry queries were unrecognized and returned input/mapping
errors; no pseudocode is attributed to them. Their bounded instructions, vtable
targets, branches and exact source identity supply the contracts below. The
earlier default-sandbox batch (`rea-update/`) failed Ghidra's Unix-socket bind;
its diagnostics and closed snapshot are retained, and `doctor.json` records the
diagnostic follow-up. Local IPC permission fixed that host restriction without
changing REA/client configuration or executing the target. Both sessions closed.
## State owners and update order — recovered
Jimmy complete-object vtable4A3BDC has1C8→424E80,178→427FF0,
FC→40DD40(indexed material blend) and114→40E4A0(all linked materials alpha).
Global signed WORD4F0588 is equipped mode. Menu display2 is separate.
| Jimmy complete field | Meaning established by this path |
| --- | --- |
|1E1C float|Remaining Invisible duration; constructor/equip zero, activation7|
|1E20 float|Recharge; constructor/equip/activation zero, ready exactly7|
|55D byte (=game-interface49D)|AI target visibility/eligibility flag; false while effect active|
|9F8 byte (=game-interface938)|Energy override; constructor false, PostLoad true for VR01..08|
|A18 pointer|Menu/UI owner|
|A1C pointer|Goddard/companion owner|
Jimmy game-interface frame424600 calls base movement437940 at424C34, then
complete slot1C8 at424C3F, then later complete1B4/1B0. Thus Invisible is a Jimmy
wrapper phase after movement, distinct from the controlled-input callback and
the ordinary ray's input phase. Existing full registry/fixed-step approximation
remains separate.
At424E80 a null controlled pointer5099E4 hides both meter sprites and returns,
freezing Invisible timers. Any nonnull controlled pointer passes; the leaf does
not compare it with Jimmy's identity. Mode!=2 then returns. Mode2 shows both
meter sprites before the remaining activation/timer branches. Menu modal/frame
eligibility can stop the enclosing frame before this leaf; do not treat this
as proof all menu/audio clocks follow this routine.
## Equip and activation — recovered
Selecting item2 reaches428E51 after the menu caller's close/old-gadget cleanup.
The display-selection callback already ran at428D97. With energy<=0 and9F8 false,
the branch writes raw mode−1 and skips companion/timer/target-flag/meter setup.
It still reaches Practice-state handling and may load VR03. Do not restore the
old special mode or normalize display2 into raw2 after a rejected equip.
With energy>0 or9F8 true, equip hides Goddard immediately through complete58(1),
sets Goddard gameD0(0) and214(false), writes raw mode2, zeroes both timers, sets
Jimmy55D=true and colors/shows the meter red. Goddard stays hidden for the entire
equipped mode, including recharge; this is not a shared fade with Jimmy.
Activation in424EBA..424F68 requires primary helper42A7A0 true and jump helper
42A730 false. If global4F8182 is true on that branch, the function returns before
either timer advances. Suppression does not freeze a call with primary false or
jump true. Otherwise activation requires remaining exactly0, recharge bits
exactly float7, and energy **strictly>2** or9F8 true. Failed energy at this ready
branch returns. Held primary has no separate edge latch here and can activate
again after another completed recharge.
Success calls42A920 with fixed delta−2, sets remaining7, writes indexed material0
blend6/1, applies alpha0.7 to all linked Jimmy materials, clears target flag55D
and resets recharge0. The same invocation then decrements remaining bydt. There
is no continuous Invisible energy drain, invented fire cooldown or activation
sound in this leaf. Shared42A920 may emit its own energy warnings; primary owns
that lifecycle. Ordinary jumps are allowed: mode2 is accepted in42A759; no
Invisible-specific pose, new model or forced grounded requirement appears here.
## Timers, meter and material — recovered
After activation attempt, only remaining==0 and(energy>0 or9F8) grows recharge
bydt. The meter receives recharge×stored-float(1/7)×100. At recharge>=7 the fill
is colored white, then recharge is clamped to exactly7. Reaching ready during
this call permits activation on the **next** invocation.
Independently, remaining>0 subtractsdt, writes meter percentage
max(remaining×stored-float(1/7)×100,0), then expires at remaining<=0. Expiry sets
remaining0, indexed blend6/7, alpha-reset argument0, target flagtrue and red meter.
It does not grow recharge in that call; recharge resumes on the next invocation.
If remaining is still positive and<=3, trunc(remaining×5)%2 selects indexed
material0 dest7 when odd, dest1 when even; source factor remains6. This is a
blend flash, not alpha on/off, uniform transparency ramp or mesh hiding.
40DD40(index,source,destination) writes the indexed material30/34 fields.
40E4A0(alpha>0) walks the linked model57C material array88..8C, writes diffuse
RGBA(1,1,1,alpha), enables blend flag38 bit0 and selects source6/dest1 when graphics
flag509A13 is false, dest7 when true. For alpha<=0 it clears the blend bit, restores
RGBA1 and6/7. Therefore expiry/cleanup mean opaque alpha1, not invisible alpha0.
6/1 is SrcAlpha/One additive,6/7 SrcAlpha/InvSrcAlpha conventional alpha per
[gadget-blending.md](gadget-blending.md). The graphics-option predicate remains
unclosed. An upright current-Jimmy renderer can use the existing material variants;
do not claim complete original material/LOD/depth-state equivalence.
Menu48D414 binds484→4036C0(show both),488→403700(hide both),
48C→403730(red fill(1,.2,.2,1), show),490→4037A0(white fill).
4037F0 sets fill width27×(windowWidth/640), height
max(percent,0)×1.04×(windowHeight/480). Source meter sprite pointers are
4F7CB0/4F8028. [Follow-up asset report](gadget-followup-assets.md) owns exact
Canv21/22 bindings/layout and modern uniform-widescreen adaptation. Arithmetic
uses x87 intermediates and float stores; exhaustive boundary equivalence is not
claimed by the Python projection.
## Cleanup, control and AI consumers — recovered boundaries
427FF0 dispatches the mode table428844; entry2 reaches42810C. It writes material0
blend6/7, remaining7 (not0), target flagtrue, recharge0 and hides both meter sprites.
If Goddard exists and its complete9E8 flag is false, it shows Goddard and re-enables
gameD0/214. It resets Jimmy alpha through114(0) and raw mode−1. Selecting Invisible
again resets both timers0. Source constructor4227BE/C7 also starts both0.
CAM and initial MCA can explicitly clean inventions. CAM constructor415C09/D5
defaults DeactivateInv to1 at complete9C0; property415F74 binds game-interface8F8
(interface offsetC8 proven415A60). Activation4165B7 checks the field before JIM1
lookup/cleanup178. MCA constructor430AA0 defaults completeEB8=1; property430D82
binds interfaceDF0 (offsetC8 at430930), activation43129A/CC checks then cleans.
Both use exact string `DeactivateInv` at4EDF10. Omitted GAM property therefore
keeps defaulttrue; an explicit0 can suppress that prelude. Ordered raw-owner438
preparation also calls cleanup178 at42AE14. AI-null40C4AD..527 calls410, STOP/
sound148 and clears raw control, but that inspected block does **not** call438/
178. Do not blanket-cancel Invisible on every control loss: timers can freeze
with the effect retained while raw control is null. Reset/ordinary-load behavior
must respect proven Init/PostLoad and callback boundaries, not one broad reset.
Generic enemy reads target game-interface49D at40847C,408788,4087FC to gate
chase/acquisition/lost-target branches. REA409CC0 confirms a target pointer is
required and the eligibility test permits49D=true **or** positive enemy934;
Invisible is not proof universal enemy immunity. Later enemy modes/reaction
consumers, attacks already underway and class-specific overrides remain open.
The port can retain the flag and report its state without claiming enemies avoid
Jimmy until the corresponding AI consumers are implemented.
## Verification and recommended bounded implementation
Nine deterministic Python groups pass in `artifacts/invisible/tests.log`:
source identity/spans/sites/vtables/constants, equip/activation threshold split,
first recharge/next-call activation, fixed cost/same-call decrement, jump and
suppressor/control gates, zero-energy clocks, blend flash/exact-zero expiry,
cleanup and source graphics branch. These are independently transcribed static
projections, not original execution or modern runtime verification.
Implement mode2 in the existing post-movement Jimmy wrapper phase with separate
raw-any-control and Jimmy-input ownership. Preserve exact timers/strict gates,
original material/meter resources, Goddard hide/restore and evidence-backed
cleanup points. Verify initial recharge, held activation, ordinary jump, last3s
blend flash, expiry/recharge, low-energy rejection, VR exemption, modal pause,
explicit/implicit cutscene cleanup and AI-null freeze. Keep full enemy AI,
original graphics-option choice, exact scheduler/x87 boundaries and native
Windows/original whole-game comparison explicitly unresolved.
+119
View File
@@ -0,0 +1,119 @@
# Jimmy airborne targets and rendering bridge
2026-11-05. Continuation of [movement stabilization](jimmy-movement-stabilization.md).
Preserve the playable controller baseline and original550 impulse/−800 gravity;
JN-Engine is used only for original-code navigation, verified with REA/source.
## Recovered contracts and integration
[Target state](jimmy-air-target-state.md) records source addresses/offsets, Init,
accepted input, pitch seeds, destination/dirty ownership and route retention.
[Render transform](jimmy-render-transform.md) records source-degree/OMT matrix
recovery and copied-original observations. These distinguish instruction/data
recovery, native component execution, implementation and port verification.
- `JimmyAirMotion.Destination` matches all12 previously recovered ordinary-air
writes: Up reads retained forward pitch, Down reads backward pitch, Up wins,
neutral pitch0, yaw=current and roll=−turn. These are now live.
- `LabSimulation` retains forward/back pitch seeds. Constructor/debug reset seeds
−40/+10; ordinary air apply reasserts−40/+10, Bubble apply−10/+10. Input reads
whatever the preceding apply left. Bubble equip/cleanup does not reseed.
- `PlayerLevelState` carries these two process scalars only through its already
bounded lab/VR04/outside ordinary/jetpack route. Init resets targetEuler0 and
dirty=false independently. Original TSK files gain no fields. Debug reset R
remains a modern constructor-style reset.
- Current Euler, destination Euler and dirty state are separate. Accepted active
ground input writes upright destination; neutral leaves it. Air writes each
pass. Facing runs before raw control gating, only when dirty, then retains dirty
according to the before-step equality check. Authored fullXYZ writes current
Euler without replacing destination. Default route STRTs are upright; arbitrary
selected STRT Euler is now passed in full instead of dropping X/Z.
- `PlayerSceneBinding` and application sync publish full current Euler. The old
Bubble-only orientation switch/seeding bridge is removed. Vehicle passengers
continue to copy their full authored Euler; Scooter's existing copied-destination
adapter is retained as its separate compatibility boundary.
- The character model now uses `JimmyRenderTransform`: source-degree quantization,
proven local rotation order and the unrotated logical root. The former sole
correction becomes a fixed model-local translation before rotation. Upright
placement is preserved; tilt pivots around the logical root. This correction
remains modern, not an original recovered offset or complete pivot parity.
Debug noclip/Stop Motion explicitly freezes the pending facing request along
with body motion, so enabling/debug-stopping flight cannot retain an unseen tilt
request. This is modern tool policy, separate from original script preparation.
Script STOP still preserves destination and queued body/effect work.
## Component and integration verification
12 destination observations compare against the managed target helper. New
integrated cases cover Init/dirty/current writes, control locks, ordinary tilt,
scalar versus horizontal velocity, fresh/retained first Bubble input, cleanup,
route carry/reseed and noclip.28 movement groups,20 body groups and13 Grappler
integration groups pass in targeted runs. Lab and underground input-only routes
pass. Renderer component/whole-regression/native/package results follow below.
The old powered-path regression required50 units of lateral displacement under
flat air. Source pitch attenuation produces about38 units on both paths in its
same60-step fixture; the test now requires30 measurable lateral units and retained
lift. No gameplay tuning was changed to recover the old flat-air distance.
Artifacts: artifacts/jimmy-air-bridge/{movement-diagnostic,movement-targets,
movement-bridge,body-targets,grappler-targets,lab-route,underground-route}.log.
## Remaining gates
The source hierarchical transform is recovered; OMT's later final render-matrix
decomposition/re-quantization is still approximated, with measured seam deviation
recorded in the transform report. The model-local sole alignment and original
animation-root/completion behavior remain distinct. No radius, support, dynamic
or special-contact admission changes are made here. Root-changing callback Vec4
publication, world-response versus integration, hazards/climbs and dynamic pair
eligibility remain the next Jimmy body checkpoint. Whole-original trajectories,
original cadence and native Windows gameplay still require comparison.
### Native movement integration
Native Linux GTX1070/private Xvfb1920×1080 passes300-step VR04 powered steering
and240-step lab walking for shift/right-shift/insert/keypad0/right-mouse, including
actual SDL event receipt and resize. New smoke captures at powered step75/110 and
ordinary jump step90 record current/target Euler and the rendered frame. All25
final/airborne readbacks match across bindings, with zero Vulkan validation errors.
The first forward/brake/ordinary airborne captures were visually inspected.
Powered step75 has currentEuler≈(323.858,293.333,349.214), target(−40,292.917,−25);
step110 has≈(5.430,307.417,342.110), target(10,307.333,−5). Current Euler continues
through its own interpolation/turn phase rather than snapping to the target.
The300-step fixture travels359.19 versus the prior flat-air403.88; maximum rise
418.93, one burst/two landings and VR energy20 are preserved. This is port replay
measurement, not original whole-game trajectory evidence. Native Carl input lock
and control-independent body/fire/resumption also pass. Logs, images and all25
hashes: artifacts/jimmy-air-bridge/window/.
### Whole regression verification
All checks in scripts/test.sh complete across the main invocation and recorded
resumption:325 Python tests,2 HUD extraction tests,44 managed projects,36 main
Vulkan render completions, asset decoder checks, save/load, animation and SDL
dummy audio/lifecycle, plus539 unchanged originals. The initial invocation stopped
at a Director fixture that expected a tilt to survive five active ground-input
steps without full-Euler sync. Its corrected fixture seeds current tilt immediately
before the command, preserving the test's intended camera-vs-AI preparation
boundary; the Director suite passes. The resumed tail is retained separately.
This records the resumed checks, not a successful exit of the initial invocation.
Logs: artifacts/jimmy-air-bridge/full-tests.log, director-corrected.log and
test-tail.log. No gameplay math was tuned to restore obsolete fixture assumptions.
### Packaged checkpoint
Both self-contained packages identify clean runtime commit
`27be8ed63079ae2e3bf7e965ee205c4a57a96559`, source_dirty=no. Each contains519
unchanged original asset copies and4271 scene/resource files matching preparation.
Artifacts: package.log and package-identity.json. Standalone Linux from /tmp with
DOTNET_ROOT/DOTNET_CLI_HOME/NUGET_PACKAGES unset passes right-mouse powered flight
and Shift walking with actual SDL input/resize, zero Vulkan validation errors.
All five final/forward/braking/ordinary-air readbacks match development byte-for-byte;
package-{walk,jetpack}.log and package-readbacks.json retain evidence. Post-package
original audit verifies all539 hashes unchanged. Windows cross-build/resource
checks remain distinct from native Windows and whole-original gameplay verification.
Subsequent documentation commits record validation; package BUILD-INFO preserves
its exact runtime source provenance.
+130
View File
@@ -0,0 +1,130 @@
# Jimmy ordinary airborne movement audit
2026-11-04. User prioritizes stable Jimmy movement and explicitly preserves the
current GamePort feel over JN-Engine's replacement movement. JN-Engine's saved
original decompiler output was used only to locate/interpret original routines;
its C/Godot movement was not used as a behavioral reference. Authoritative source
is the immutable project EXE SHA256
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
## Recovered contracts and concrete mismatches
Addresses below are original EXE VAs; independently mapped file offsets equal
VA−400000. `tools/binary/jimmy_air_motion.py` guards source identity, five complete
bounded ranges and decoded absolute relocation operands. Source instruction
extracts are retained in artifacts/jimmy-air-audit/{input,apply}.asm.
| Original VA / offset | Original behavior | Prior port mismatch / bounded correction |
|---|---|---|
|439900..439A69 /39900..39A69|Mode1 keyboard Left precedes Right, changes stored turn by100dt; no-key return toward0 occurs only when complete6E6 keyboard-turn latch is set. Key turning sets latch; mouse turning clears it.|AirSteering always applied return, without storing the latch. JimmyAirMotion.Input owns explicit latch state; caller must retain it and share it with other input modes.|
|439AE6..439B69 /39AE6..39B69|Up adds30 only when scalar<maximum, then clamps. Existing overspeed is preserved.|RecoveredMotion.AddSpeed clamped overspeed down to maximum. New helper preserves it. Ground correction is investigated separately.|
|439B69..439BA2 /39B69..39BA2|Without throttle, coast only above maximum*float.909090936; compare uses the unrounded x87 product. Coast subtracts17.5 per callback.|Float-rounded C# comparison misses a representable threshold case. At max600, speed545.45459 must coast to527.95459. New helper uses double intermediate for the comparison.|
|439BA2..439BED /39BA2..39BED|Independently test body218 support, even with stored air mode1. Supported positive scalar subtracts17.5 with no crossing clamp; nonpositive scalar resets0.|Old AirSteering had no support argument. Supported speed300+Up ends312.5; speed5 with no keys ends−12.5. These affect landing/rejump and retained input phases.|
|439C1D..439CB2 /39C1D..39CB2|Down after throttle/coast/support subtracts35 supported or17.5 airborne, clamps positive scalar to0; negative scalar adds35 toward0.|Old helper used17.5 for positive scalar regardless support. No reverse-flight initiation is added.|
|439D81..439DB7 /39D81..39DB7|Ordinary mode1 turn caps±30, distinct from Bubble's±50.|Existing cap is correct and retained.|
|437FD0..438011 /37FD0..38011|Read incoming live velocity. Exact zero magnitude skips independent yaw AND lateral computation. It still publishes forward scalar afterward.|LabSimulation gated yaw but computed side unconditionally. Zero incoming velocity/scalar300/turn30 produces(0,0,300), not a lateral launch.|
|438011..438062 /38011..38062|For nonzero velocity, call334 AddEuler(0,turn*dt,0), then side=turn*float(1/55)*(1−friction)*scalar, without dt on side.|Existing side formula is generally right but ungated. Plain yaw modulo omitted full-axis AddEuler normalization. New helper reuses original-leaf-compatible RocketOrientation.Add.|
|438062..4380E6 /38062..380E6|Rotate the lateral contribution around current yaw using original OMT table values.|Retain yaw-only lateral contribution. No invented normalization or clamp.|
|4380E6..438124 /380E6..38124|game38C rotates local(0,0,scalar) by full Euler. Sum its X/Z with lateral contribution and preserve incoming Vy, discarding rotated forwardY.|Old port used flat yaw only. Nonzero pitch must scale horizontal forward; roll does not alter this local-forward vector. Use original-compatible rotate/lookup helper.|
The probe complete-object fields are6C8 scalar,6D4 turn,6D8 applied turn,
6BC acceleration step30,6C0 decay35,6C4 maximum600,6E4/6E5 throttle/backward,
6E6 keyboard-turn latch,7C4 movement mode1. Its game interface is complete+C0.
Game Euler is224/228/22C; getVelocity2BC/setVelocity2C4, friction248, support218,
getEuler328, AddEuler334, local-vector transform38C are separate calls. Synthetic
probe binds the last three to original4723F0/472480/472B10. Real class wrapper
334 may add gameplay gates; source publication/controller ownership remain caller
responsibilities and are not reconstructed by this isolated component.
Keyboard steering and scalar increments retain current signs, precedence, source
per-callback30/17.5/35 values and mode1 turn cap. Existing ordinary flat-air
movement with nonzero incoming velocity is preserved. None of these corrections
adopts JN-Engine's tuned jump650/gravity1600 or instant tank movement.
## Native observations and REA
`tests/GamePort.JimmyAirTests/original-air-reference.json` commits35 copied-original
observations and source/generator/shared-map-helper/probe-EXE/output-log hashes:
22 mode1 keyboard input cases and13 velocity-prefix cases. Coverage includes
Up/Down combinations, overspeed, exact coast boundary, supported positive/negative
crossings, turn cap/precedence/latch/return crossing,60Hz, zero/rising/falling live
velocity, slope pitch, roll, Euler seam/negative angle normalization, friction0,
reverse scalar, zero scalar and ordinary60Hz output.
Probe executes copied439900 through439DB7 (before orientation/camera work) and
complete-entry437F90 through438124 (before jump suffix). It supplies synthetic
actor/body/friction/mouse callbacks and uses the copied project's original OMT
trig global plus original Euler helpers. Zero mouse/controller input is explicit.
439900's continuation is replaced by a stack-correct return, and437F90's suffix
is replaced by its original4387A1 epilogue. No original game entrypoint, physics,
collision, camera, animation or audio is executed. Source jump suffix438148 and
effect421FB0 are independent parent investigations.
The isolated Wine32 run exits0 and prints JIMMY_AIR_MOTION_COMPLETE; capture.json
and wine.log are retained in artifacts/jimmy-air-audit/probe. Thirty-five saved
outputs match two managed conformance groups. Two Python groups guard source,
relocations, PE offsets, complete fixture counts and generator provenance. This
is original component execution, not whole-original or native Windows gameplay.
REA/Ghidra12.1.4 was invoked through the configured local scripts/rea.sh on the
generated target copy. The default profile did not recognize439900 as a procedure;
the complete explicit mapped-selector failure, export and closed snapshot are
retained under artifacts/jimmy-air-audit/rea-input. No pseudocode success or
Evidence ID is attributed to that failure, and the unchanged selector was not
repeated. Earlier Bubble movement attempts had provider startup failures and do
not establish successful decompilation either. Supporting source instructions,
whole-source identity and new native observations establish the bounded arithmetic.
JN's docs/decomp/evidence/c3dplayer_movement_target3.md supplied an original-code
reading lead, independently checked against these project originals.
## Integration API and remaining limits
New `JimmyAirMotion` is an isolated source-backed implementation. Parent owns live
integration and existing AirSteering/LabSimulation files:
1. Pass Input(new(Speed,TurnRate,keyboardTurnLatch),input,Grounded,dt,MaximumSpeed).
Retain returned scalar, rate and latch. Complete6E6 is shared with ground and
Bubble input: update it when those source paths set it; do not reset each frame.
2. Call Apply(Speed,TurnRate,new(Pitch,Yaw,Roll),Velocity,dt,friction) in the ordinary
air branch, after existing facing/mode selection and before438148 jump suffix.
Publish returned full Euler and velocity. The incoming velocity gate must use
prior live velocity, not a newly fabricated forward vector.
3. Keep body-first/fresh-vs-retained order, ordinary landing/reset, jump/jetpack
state/effect, raw/effective control and special modes in their existing owners.
This does not implement mouse/controller axes, general camera/pose targets,
reverse-run helper states, complete full-Euler/render root behavior, original
cadence, dynamic/special contacts or the jump state suffix. Fixed60Hz and source
body vs capsule admission remain existing port policies. Ordinary input requires
0<dt<1 because the original divides mouse deltas by dt. Native Windows and
whole-original movement/trajectory comparison remain unverified.
## Destination-Euler follow-up (2026-11-05)
REA's complete retained objdump Evidence
`ev_0d64cc58fa8f5573fc8e61e0f2c20e36288099212bd2257d3a3121361fd6c904`
adds the next target write. 439DB7..439E33 (offset39DB7;
range end39E33) reads accepted forward6E4 before backward6E5, writes pitch7EC
or7F0, yaw=currentEulerY and roll=−turn. Neutral pitch is0. Constructor437445/
43744F (offset37445/3744F) initializes7EC=−40,7F0=10; ordinary437FBC/437FC6
reasserts those values. Bubble43880A/438814 substitutes−10/10. These are
retained controller fields, separate from current Euler and destination Euler.
`tools/binary/jimmy_air_targets.py` extends the previous input probe through
439E33, supplying a synthetic36C destination writer. Twelve native observations
are retained in `tests/GamePort.JimmyAirTests/original-air-targets-reference.json`,
including both arrows (Up wins), turn signs, supported zero/overspeed, zero and
custom pitch seeds. Isolated capture exits0 with JIMMY_AIR_TARGETS_COMPLETE;
source range, generator, executable and output hashes are recorded. No camera,
facing interpolation, body or original whole-game entrypoint ran. A Python guard
checks source/provenance and saved writes; this is recovery evidence, not a
managed/runtime implementation claim.
At the initial controller checkpoint these targets stayed behind the paired
render/state gate. They are now live with retained apply-owned seeds, destination
Init/dirty and the logical-root hierarchical render bridge. See
[air bridge](jimmy-air-bridge.md) for implementation,146 component comparisons,
route/native/package verification and remaining visual precision/body limits.
Live integration/route/native/package status (2026-11-05): [movement stabilization](jimmy-movement-stabilization.md). The audit API notes above describe the isolated component boundary; parent integration is now recorded in that continuation.
+155
View File
@@ -0,0 +1,155 @@
# Jimmy air targets: owners, initialization and mode transitions
2026-11-05. Original EXE SHA256
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
This closes the state boundary needed to integrate the
[twelve original air destination writes](jimmy-air-motion.md). It adds static
source/data verification, not another original runtime capture. JN-Engine's
saved original index was a navigation aid; its tuned movement is not used.
REA's retained complete instruction Evidence is
`ev_0d64cc58fa8f5573fc8e61e0f2c20e36288099212bd2257d3a3121361fd6c904`,
artifacts/jimmy-movement-audit/rea-original-disassembly.json. No unchanged failed
Ghidra selector was repeated. Focused extracts and the source report are under
artifacts/jimmy-air-target-state/. Preferred EXE VA maps to file offset VA−400000;
the helper independently uses PE sections and guards every listed anchor.
## Distinct state owners
Jimmy's game interface is complete object+C0. These are **data offsets**, not
same-numbered virtual slots:
| State | Game-interface data / complete data | Owner |
|---|---|---|
|Current Euler|224/228/22C /2E4/2E8/2EC|330→472420 sets XYZ;334→458F90→472480 adds Euler.|
|Destination Euler|274/278/27C /334/338/33C|36C→472660 writes all three axes and sets dirty byte+A.|
|Facing enabled/dirty|5/A /C5/CA|Init enables5, clearsA; source facing reads both; input destination writes setA.|
|Air forward/back pitch seeds|72C/730 /7EC/7F0|Constructor and movement apply callbacks, not input or current support.|
|Other yaw scalar|61C /6DC|Constructor0; Jimmy Init captures current yaw. No other direct access appears in the bounded437290..43B820 controller search.|
The last scalar is **not** the destination yaw captured by the ground probe.
`jimmy_ground_motion_probe.c` explicitly captures game+278 after its synthetic36C
writer. `JimmyGroundState.TargetYaw` therefore models retained destinationEuler.Y;
ordinary air input replacing that destination Y is expected. There is no evidence
for adding an independently consumed ground-yaw accumulator merely because Init
writes61C. The bounded direct-access search is not a whole-program proof that
61C is globally unused.
### Input publication
- Ground43915D..4395CF calls36C only when an accepted active heading path reaches
43957C,439599 or4395C9 (offset3957C/39599/395C9). It writes `(0,heading,0)`;
accepted Up/Down without a turn uses current yaw. Neutral leaves destination
Euler and dirty state alone. Backward acceptance is resolved before this suffix.
- Ground apply437C40..437F7F has no36C call or direct61C/6DC read. It does not
copy a saved ground yaw into the destination each pass. Its independent334
yaw addition does not become a destination write.
- Air input439A7A/439A80 clears accepted throttle6E4 and brake6E5, then sets them
in the accepted branches439AF2/439C29. In the bounded zero-mouse/analog case,
Up accepts throttle; Down accepts brake; mode2 additionally accepts primary fire
as throttle. Target publication reads these accepted flags, not speed>0.
- Ordinary target branch439DB7..439E33 (offset39DB7..39E33) chooses forward pitch
seed first, backward seed second, otherwise0; yaw=currentEuler.Y;
roll=−storedTurn. Both arrows select forward pitch even though both affect the
speed arithmetic. Mode2's preceding439CFx..439D7C branch uses roll=−.25*turn
(constant4AFD2C, fileAFD2C), with the same seed selection.
- Shared36C dispatch439E2D→472660 writes targets even when neutral or equal to
current Euler. Its setter stores274/278/27C at472668/472672/472678 and sets
dirty+A=1 at47267E. The existing12 native observations cover ordinary targets;
mode2 roll/first-tick sequencing here is statically recovered.
## Lifecycle and phase order
| Event / original VA (file offset) | Result |
|---|---|
|Constructor437445/43744F (37445/3744F)|Complete7EC=−40,7F0=+10.|
|Ordinary apply437FBC/437FC6 (37FBC/37FC6)|Reassert complete7EC=−40,7F0=+10 before composing ordinary air velocity.|
|Bubble apply43880A/438814 (3880A/38814)|Reassert complete7EC=−10,7F0=+10 before Bubble velocity/bounce.|
|Bubble cleanup428037..4280CC (28037..280CC)|If owned effect exists, mode7C4=0, maximum650, radius60/factor1.265 and effect/sound cleanup. No pitch-seed or destination-Euler reset appears in this resolved branch.|
|Generic Init4709CA/9D0/9D6 (709CA/709D0/709D6)|Clear destination XYZ.4709E2 enables facing5;4709E6 clears dirtyA. This is not a current-Euler zeroing policy.|
|Jimmy Init437890..4378CC (37890..378CC)|Calls4587F0→470540, clears speed/turn/published scalar, copies current yaw to61C. It does not re-seed7EC/7F0.|
|PostLoad4239E6 (239E6)|Copy the selected STRT's full authored rotation through174→4716D0. That setter copies authoredFC/100/104 and calls330→472420 to publish currentXYZ. Target Euler/dirty are not modified by this leaf chain.|
|Control preparation42AFC0→43A750|Clears speed/body XYZ velocity and stops sound, then requests STOP. It is not a destination/facing reset or evidence that all current Euler axes become0.|
Route property extraction does not reconstruct the object or re-run its
constructor: see [retained property stream](../checkpoint/retained-streamer.md).
Its verified20 descriptors do not point at game72C/730. The closed generic Init,
PostLoad and no-selected-gadget/jetpack cleanup route therefore retain these
pitch seeds while resetting destination Euler/dirty independently. This is the
bounded LV1B→VR04→LV1B→LEV1 contract, not arbitrary selected gadget/level cleanup.
Original save files do not gain these process fields; current R reset remains
an explicit modern debug policy and can restore constructor seeds.
The existing original registry/partial-order findings imply these concrete
transition cases; the joint sequence has not been newly executed here:
1. First Bubble activation on a fresh input-before-player tick may read the prior
−40 seed. Its later Bubble apply publishes−10, so subsequent Bubble input reads
−10. Retained player-before-input order seeds−10 before that first input.
2. Bubble cleanup leaves−10. Ground mode itself does not re-seed it. A subsequent
input already dispatched in ordinary air mode may read−10 until ordinary air
apply reasserts−40. Do not choose pitch solely from the current mode at input.
3. During a retained ordinary scene load, preserve the seed fields but initialize
targetEuler=(0,0,0), enabled=true, dirty=false. Reapply authored/current Euler
and subsequent destination writes through their own owners.
## Facing and control
43796A calls40E050→462520→473240 before the raw controlled-pointer check at
437A1B.47328D dispatches3D8→43A420. Facing itself checks global475CA0, game byte5
enabled and byteA dirty at43A426/43A433/43A43E; it does not query raw control.
475CA0's global pause/gameplay policy is not the controlled-player identity.
After accepting the gates,43A44F clearsA, then each unequal **before-step**
current/target component setsA again. Its comparisons are direct float equality,
before shortest-arc conversion/interpolation. It then calls334 even if all axes
were equal. A caller reproducing state needs to set `dirty = oldEuler != target`
when the facing callback actually runs; testing equality only after interpolation
can change that final pass. If a gate rejects the callback, dirty survives.
Canonical360 vs0 may remain unequal even when their angular delta is0. Direct
330 current-Euler writes do not synthesize dirty state or replace destinations.
## Initial current Euler is data, not target defaults
The source PostLoad copies full STRT XYZ. Default route GAM data nevertheless
supports keeping the present upright baseline:
| Original GAM / selected default STRT | Authored/current rotation after the resolved setter |
|---|---|
|level1b.gam /STARTEXP|(0,155,0)|
|VR04.gam /PHONEBOOTH|(0,290,0)|
|level1.gam /PHONEBOOTH|(0,220,0)|
The read-only helper records each GAM SHA256 and JIM1/STRT record offsets.
Arbitrary `--start` selections or authored script rotation with nonzero X/Z need
fullXYZ current publication; no source flattening is inferred from targetInit0.
RETURN restores a separate saved root, not a saved rotation; the selected STRT
rotation and its callback chain still apply. Other body/model animation offsets
belong to the render-transform investigation, not this Euler state report.
## Implementation contract and verification
Parent owns live implementation. Retain forward/back pitch seeds as fields,
seed them in apply callbacks, and read them at input time. Store current Euler,
destination Euler and facing enabled/dirty independently. Ground helpers' existing
destinationY state can remain a view of destinationEuler.Y; no extra6DC owner is
needed by proven ground math. Preserve source phase order, support/input gates,
and the explicit modern reset boundary. Full actor-root/model placement must be
handled by the sibling render bridge before enabling ordinary pitch visually.
`tools/binary/jimmy_air_target_state.py` guards32 source anchors,9 virtual targets,
11 bounded instruction ranges, the registered route descriptor boundary and
selected STRT data. Optional `--rea-disassembly` validates retained REA identity
and emits the bounded61C/6DC access and ground-apply call lists. Three Python
groups pass with exact source/offset/binding, separate target/current/default
route data and apply-owned seed checks. Run:
```
python3 -m unittest discover -s tests -p test_jimmy_air_target_state.py -v
python3 tools/binary/jimmy_air_target_state.py ../Original --rea-disassembly artifacts/jimmy-movement-audit/rea-original-disassembly.json
```
Confidence is high for the guarded local contracts and route data. Full original
frame execution, unsupported modes/gadgets, other selected starts/levels, original
cadence, complete animation-root rendering and native Windows comparison remain
separate. No shared runtime or existing evidence fixture was changed here.
+101
View File
@@ -0,0 +1,101 @@
# Jimmy ordinary ground movement audit
2026-11-04. User paused gadget expansion to stabilize Jimmy. Preserve the current
playable fccc0b9 baseline. This report isolates original keyboard ground input
and ground velocity apply; it does not replace collision, timing or animation.
The supplied JN-Engine C3DPlayer report/target3 decompiler dump supplied function
names/field leads only. Its tuned/native gameplay is not used as an oracle.
## Original evidence and ownership
EXE SHA256 `f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`;
OMT2.dll `3ec41ead011adf56387a6dbd4580e5b5a9721b5f8020c8a56420f42824354943`.
`jimmy_ground_motion.py` validates both identities and six bounded ranges, with
PE-mapped offsets and hashes. The listed EXE text offsets are VA−400000.
REA/GNU objdump produced source observation
`ev_0d64cc58fa8f5573fc8e61e0f2c20e36288099212bd2257d3a3121361fd6c904`.
Complete Evidence is under artifacts/jimmy-ground-audit/rea-disassembly.json;
summary projection `ev_eeefcf5542ee0c3151932829c0e898696754a264ac7fccb208fa26cceb36f0c0`
is in rea-summary.json. The command completed, output was not truncated, and
pre/post source digests match. The provider's executable-version/format metadata
is unknown; the independent PE reader establishes the image mapping. This is
static instruction evidence, not successful Ghidra pseudocode or target execution.
Previously failed unchanged procedure selectors were not repeated.
| Source VA / offset | Owner and contract |
|---|---|
|438BC0 /38BC0;438CE3 /38CE3|Ground input clears complete6E4 accepted forward/back flag. Mouse/side-camera/idle prefix is outside the pure keyboard suffix.|
|43915D..43928D /3915D..3928D|Clear870 keyboard lateral bias. Left precedes Right. Left adds20 yaw delta and−1000 lateral, Right−20/+1000. Set6E6 keyboard-turn latch. Add30 to6C8 only when below6C4 cap, then clamp an actual crossing.|
|43928D..439318 /3928D..39318|Up halves nonzero keyboard yaw delta and applies a second below-cap30 increment. Sets6E4. Up+turn can therefore increment twice. Existing overspeed is preserved, not clamped down.|
|438F66..438FE3 /38F66..38FE3|Earlier backward-acceptance gate uses Down/analog/side qualifications. In raw−1/3, true primary predicate15C suppresses accepted backward. Flags864/828 also qualify acceptance. This prefix is caller-owned, not part of the suffix probe.|
|439318..439416 /39318..39416|Accepted backward850 sets6E4; ordinary subtract35*1.5 and clamp−cap*.5. If seeded830 is strictly>double1.5, set latch828, speed=cap, stored target710=currentYaw+180, keyboard yaw delta0. Already latched backward keeps cap. Releasing acceptance clears830 and latch. The830 clock's increment owner remains unresolved.|
|439416..439490 /39416..39490|Without Up or accepted backward, release positive/negative scalar toward0 by35. Left-only still receives this decay after its acceleration. Keyboard side bias can move while scalar remains0.|
|43951E..4395CF /3951E..395CF|Accepted active input publishes destination yaw even with zero turn: ordinary currentYaw+delta; latched with delta uses currentYaw−delta*.5, otherwise stored710. No active input retains the previous destination.|
|437C40..437DF6 /37C40..37DF6|Read current live velocity; special global4F83E0 returns unchanged. Only nonzero incoming velocity OR nonzero keyboard lateral admits yaw addition and side computation. That gate does not suppress the later base forward rewrite. Side=(turn*(1−friction)*speed*float(1/45)+bias)*dt. Read full Euler via328, add yaw via334 and use full-Euler38C(0,0,speed). Publish its X/Z plus side, preserving incoming Y.|
|437E10..437F4B /37E10..37F4B|Only supported218 and nonnull support polygon338 reaches the support suffix. It subtracts float250 at4A3E58 from current live Vy. The rest of the normal/angle calculation does not project X/Z onto a slope or publish a new actor Euler here.|
|437C22..437C2D /37C22..37C2D|Controlled wrapper publishes complete6C8 controller scalar into body160 afterward. This is separate from live velocity and body friction state.|
Complete/game interface displacement isC0. Complete6BC acceleration30,6C0 decay35,
6C4 current cap600,6C8 controller scalar,6D4 turn rate,6D8 applied turn,6E4 accepted
forward/back,6E6 keyboard-turn latch,710 stored backward heading,828 auto-turn latch,
830 clock,850 accepted-backward and870 lateral bias. Live Euler is game224/228/22C;
destination is game274/278/27C. Ground only sets6E6 on turns; neutral/up/back do
not clear it. The source's air handler owns later keyboard-turn return behavior.
## Confirmed differences from the pre-audit port
1. RecoveredMotion.AddSpeed's unconditional Min(speed+30,cap) reduces existing
overspeed; the original only adds while below cap. This affects ground/air use
of that helper; changing the shared helper requires checking its other callers.
2. Active forward/backward input without turn must publish current yaw as the new
destination. LabSimulation only changed targetYaw for a nonzero turn delta,
allowing residual destination-yaw drift after releasing turn while keeping Up.
3. Ground direction uses full Euler X/Z, not yaw alone. A pitch30/yaw45/roll20
native case projects speed300 to X/Z≈−183.725/+183.725, not±212.132. This matters
during tilt restoration after gadgets/script placement; no new slope tilt is
invented by the helper.
4. Live support with a real polygon supplies downward Vy−250 pressure. The port
preserved Y unchanged. Supported/no-polygon and unsupported cases retain Y.
5. Side computation shares the incoming-motion/bias gate. The existing simplified
apply computes side outside it. Most ordinary landings reset turn0, but the
mathematical distinction is explicit and tested.
6. Primary/backward acceptance and the latent auto-turn state are not modeled by
the old simplified input. Do not enable a fabricated1.5-second timer: its live
clock owner must be recovered first. The pure helper permits explicit source
state inputs so the seeded branches can be compared without claiming live use.
## Implementation, tests and integration
`JimmyGroundMotion.Input` returns state, keyboard lateral and heading-update flag.
Callers resolve backward acceptance (ordinary raw−1/3 primary blocks it), retain
shared6E6 on neutral ground input and set it on Left/Right. BackSeconds defaults0;
leave auto-turn live admission gated until its clock owner is established.
`Apply` accepts full live Euler, source turn/bias, actual support and actual support
polygon presence. It returns velocity and Euler. Body integration, input/apply
order, ordinary/gadget mode dispatch, collision and published-speed copy stay
with the caller. In particular, do not derive a support polygon merely from a
provisional capsule's Grounded flag or apply this ground suffix during air mode.
Twenty-five copied-original observations execute successfully in isolated Wine32:
17 keyboard suffix cases (combinations, release/crossing, cap/overspeed, backward
cap and seeded exact/over1.5/latch branches), eight complete437C40 cases (rest,
stationary turn, lateral-only, turn, full tilt, supported polygon, missing polygon,
unsupported). Synthetic actor/root/support/animation methods surround the copied
routines; original OMT vector/trig methods execute from a copied DLL. No original
game entrypoint, camera prefix, general dynamic body or complete Jimmy executes.
The initial missing OMT export qualifier was corrected before the final run;
only the final exit0/JIMMY_GROUND_COMPLETE output establishes observations.
The committed original-ground-reference.json records both source identities,
bounded spans, generator/shared harness/executable/log hashes and all25 cases.
Two managed groups compare every case and check active-versus-idle heading and
caller-owned primary/backward suppression. Two Python groups validate identity,
provenance, ranges/offsets and complete observed counts. Logs and final capture
metadata are under artifacts/jimmy-ground-audit/. Parent owns live integration,
route/render/platform checks and root status documents; this agent made no shared
runtime edits or commits. Whole-original/native Windows movement parity remains
unverified. Mouse/analog, camera side timers, generic clock registration, full
standing/pose/climb branches and engine cadence remain separate evidence gates.
Live integration/route/native/package status (2026-11-05): [movement stabilization](jimmy-movement-stabilization.md). The audit API notes above describe the isolated component boundary; parent integration is now recorded in that continuation.
+58
View File
@@ -0,0 +1,58 @@
# Jimmy jump and powered hold conformance
2026-11-05. Authoritative EXE SHA256
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
This extends the existing [jetpack recovery](../analysis/jetpack.md); the playable
550 impulse, −800 gravity and existing state0..5 behavior remain the baseline.
JN-Engine's tuned movement is not used.
## Evidence and corrections
REA inspect-with-objdump Evidence
`ev_0d64cc58fa8f5573fc8e61e0f2c20e36288099212bd2257d3a3121361fd6c904`
retains the complete original disassembly in
artifacts/jimmy-movement-audit/rea-original-disassembly.json. This is static
instruction evidence. The complete437F90..4387D8 range, including both jump
tables, maps to file37F90..387D8. Euler helpers4723F0/472480/472B10 map to
723F0/72480/72B10. The generator guards identity, offsets and each range's hash.
`tools/binary/jimmy_jump_motion.py` extends the air harness without its early
suffix return. It executes full copied437F90 with synthetic actor/body, support,
energy/inventory, level, animation and effect callbacks, plus original OMT trig
and original Euler leaves. The game entrypoint, collision/body integration,
effect countdown421FB0 and real animation/audio are not executed. Absolute
strings and jump-table entries are separately relocated; operands outside the
mapped image are rejected so disassembled table bytes cannot corrupt relocation.
Initial harness attempts required correcting those relocations and the synthetic
509948 owner pointer. Only the final successful32-case run is used as evidence.
The isolated Wine32 run exits0 and prints JIMMY_JUMP_MOTION_COMPLETE. Fixture
`tests/GamePort.JimmyJumpTests/original-jump-reference.json` records32 observations,
source ranges, relocations, generator/shared setup/probe executable/output hashes.
Generated source, capture.json and wine.log remain in artifacts/jimmy-jump-audit.
The managed suite compares jump state, hold/effect timers, pending impulse,
vertical/extra acceleration, pose requests, effect calls and radius writes.
Two directly evidenced precision mismatches are corrected in `JetpackBurst`:
- Before powered state3, gravity correction retains the wide intermediate:
`(float)((double)gravityY * 1.33f - gravityY)`. With−800 this is−264.000031,
rather than the old staged float−264.
- 438407 stores hold as float but43840D compares the unrounded x87 sum against
float.4. Stored `.3f + .1f` and `23f/60 + 1f/60` both become.400000006,
but only the first starts the burst. The port now compares the wide sum before
returning. Testing the stored float cannot distinguish those observations.
Coverage includes states0..5, held/released branches, takeoff/landing, null effect,
expiry, exact/adjacent hold thresholds, inventory/energy/gadget/level gates,
VR04 immunity and both sides of the500-height acceleration threshold. The outer
437940 grounded/released bypass remains a caller phase and is not certified by
invoking437F90 alone. Physics consumes pending impulse on the following pass;
source effect421FB0, input registration and raw control retain their own owners.
## Remaining limits
This proves bounded original component outputs and managed conformance, not a
whole-original trajectory. Fixed60Hz, the capsule in lab/outside, render root,
complete animation completion, sound and native Windows feel remain separate.
Live route and SDL tests are recorded in [movement stabilization](jimmy-movement-stabilization.md).
@@ -0,0 +1,147 @@
# Jimmy movement stabilization
2026-11-04. User pauses gadget expansion and prioritizes solid Jimmy movement.
Current C# movement is the playable baseline; runtime packages fccc0b9 and source
42ea2b8 remain preserved. JN-Engine's native/Godot movement is explicitly not the
behavior oracle. Its saved original decompiler/class index is a navigation aid;
REA, authoritative bytes and copied-original observations verify corrections.
## Working checkpoints
1. Compare ordinary ground/air input, velocity and facing with copied-original
cases; preserve current acceleration/jump/gravity values unless contradicted.
2. Verify jump/hold/release/landing, jetpack acceleration/expiry, queued impulse
and physics-before-input ownership, including fresh/retained scene order.
3. Recover lab/outside contact metadata, root publication and animation-owned
response sufficiently to replace the provisional capsule safely. Preserve
scene/actor state ownership; do not enable unsupported special contacts.
4. Verify the combined input/physics/control/animation behavior on lab → VR04 →
lab → outside, including all jump aliases, stairs/slopes/walls/ceilings,
cutscenes, reset, RETURN and stable presentation-rate behavior.
## Evidence boundary on entry
Current ordinary body is source-backed in bounded tutorials; lab/outside still
use the modern capsule. Controller input and apply are simplified in LabSimulation,
with source-based Jump550/gravity800 plus jump acceleration correction, fixed60Hz
as a modern policy, and a sole/root render bridge. Previous numeric/route/native
verification remains valuable; it does not certify complete movement fidelity.
Ground/air/math corrections are separate from admitting special/dynamic physics.
New independent reports: jimmy-ground-motion.md, jimmy-air-motion.md,
jimmy-orientation.md and ../checkpoint/jimmy-special-contact.md. Parent owns
integration/jump/route verification; investigators own their named new files only.
Findings/tests and implementation status are updated here as chunks finish.
## Controller checkpoint, 2026-11-05
Integrated `JimmyGroundMotion`, `JimmyAirMotion` and `JimmyOrientation` into
LabSimulation. Ground Up/accepted Down publishes current heading even without
turn input, clearing the old turn destination; neutral retains it. Acceleration
preserves existing overspeed. Ground backward acceptance honors raw−1/3 primary
fire. Air input retains the shared keyboard-turn latch, performs its independent
supported subtraction/brake and compares coast with the wide product. Full-Euler
apply preserves incoming Vy and correctly gates lateral/yaw on incoming velocity.
Facing uses original shortest arcs/full-axis angle normalization and runs in the
base phase even without raw control. Published speed, pending impulse, effect
clock and fresh/retained ordering remain separate. [Jump conformance](jimmy-jump-motion.md)
adds the exact wide hold comparison and gravity intermediate.
108 saved native observations compare against managed components:25 ground,
35 air,16 facing and32 jump.27 additional native special-contact dispatch cases
establish callback eligibility only.12 air destination writes establish missing
pitch/roll target behavior, which remains a deliberate implementation gate; see
[jimmy-air-motion.md](jimmy-air-motion.md). These are copied-original component
observations, not observed original whole-game play.
### Collision compatibility boundary
The original supported ground apply subtracts250 from live Vy only when actual
support polygon338 is non-null. This is live with the source body and its real
SupportHit. A capsule Grounded flag or floor-height query does not stand in for338.
An attempted mapping from capsule support introduced a repeatable lab stair block
(artifacts/jimmy-movement-audit/lab-route.log, leg1 root4307.62/15.13/351.25).
Removing that mapping restores the entire input-only route
(lab-route-compatible.log), and the two-way underground route also passes. The
capsule retains baseline landing Vy0. This is an explicit compatibility gate,
not an original-body result or a replacement friction/step tuning fix.
### Next coherent implementation chunks
1. **Implemented bounded bridge:** source destination-Euler pitch/roll, retained
apply-owned7EC/7F0, Init/dirty, full authored XYZ and logical-root render basis.
[Air bridge](jimmy-air-bridge.md) records integration and subsequent validation.
The modern local sole correction and final OMT decomposition precision remain
explicit limitations; this does not close full original visual parity.
2. Finish Vec4 previous/live-root publication after callbacks; separate body
integration210 from world-response1D0. Verify successful fence/ladder entry,
animation-end/fallback completion and4255C0 hazard/impulse ownership before
broader Jimmy body admission. The incomplete success-probe experiment is
preserved under ignored artifacts/jimmy-special-contact/success; it is not
conformance evidence or part of the committed dispatcher tool.
3. Recover dynamic pair eligibility/shared context and original support metadata;
replace the lab/outside capsule in an independently verified route chunk.
4. Complete animation/camera/retained helper/cadence comparison on a working
original installation and native Windows. The user's preserved movement
baseline remains authoritative among unverified port alternatives.
### Cross-system regression interpretation
Original AddEuler stores small negative pitch near360; Bubble's test/smoke checks
now compare signed angular direction rather than requiring a negative stored
number. Its fire/throttle and source target sign stay unchanged. Source-supported
Grappler attachment also exposes phase composition: fresh input writes Vy100,
then the ordinary ground controller subtracts250, producing−150; retained late
input writes100 after that publication. The existing ground native positive-Vy
case proves this subtraction. Managed attachment checks now distinguish those
orders. Control loss still runs the body, but a supported root need not move;
its regression checks the physics count/support/ownership instead of inventing
an airborne displacement. Grappler completion/other callbacks are not inferred
from these tests.
The eight-stage Bubble GPU replay exposed the first-step boundary too: a negative
subdegree facing increment can publish canonical360, whose signed remainder is0.
The immediate throttle assertion admits that source result; the sustained managed
case still requires negative lean. Both headless and native1920×1080 SDL Bubble
replays pass all eight phases with zero validation errors. This correction changes
only the smoke predicate, not movement or gadget behavior.
## Verification and package checkpoint
The checks in scripts/test.sh pass across the main run and recorded resumed runs:
320 Python tests,2 HUD extraction checks,43 managed projects, main Vulkan replays,
asset decoder checks, dummy SDL audio/lifecycle and539 original hashes. The main
run first stopped at the obsolete Grappler attachment expectation. Its corrected
13-group suite passes; the remaining script tail then found the first-step Bubble
canonical360 smoke assumption. Corrected headless/native Bubble replays pass, and
the final GPU/save/load/animation/audio tail exits0. The initial failure logs are
preserved. This is a resumed verification record, not a claim that the initial
single script invocation exited successfully.
Artifacts under artifacts/jimmy-movement-audit: full-tests-final.log,
grappler-integrated.log, remaining-tests.log, bubble-final.log, gpu-tail.log and
validation-summary.json. These include36 main Vulkan render completion lines,
all zero validation errors, plus the corrected Bubble replay. Managed component
fixtures compare108 original observations. Both lab/underground navigation and
all source-body gates pass.
Native Linux GTX1070/private Xvfb1920×1080 runs pass walking and powered steering
with shift/right-shift/insert/keypad0/right-mouse, received SDL input and resize.
Each set of five final readbacks is byte-identical. Native Carl/control-phase,
9-stage Grappler and8-stage Bubble pass, with zero Vulkan validation errors.
Logs and captures are in window/. This is port runtime verification; actual
whole-original/native Windows gameplay remains unverified for this checkpoint.
Both self-contained packages identify clean runtime commit
`acd1b287cfdc19e6b5d16c5c10a1d9e9b90c6d41`, source_dirty=no.
Final packaging log: artifacts/jimmy-movement-audit/package-final.log. Each has519
unchanged original asset copies and4271 scene/resource files matching preparation;
package-identity.json records executable/DLL digests and build information.
Standalone Linux from /tmp with DOTNET_ROOT/DOTNET_CLI_HOME/NUGET_PACKAGES unset
passes300-step right-mouse powered flight and240-step Shift walking, received SDL
input and resize, zero validation errors. Both final readbacks match development
byte-for-byte; package-{walk,jetpack}.log and package-readbacks.json retain results.
Post-package audit verifies all539 originals unchanged. Windows cross-publishing
and resource checks do not establish native Windows gameplay. Documentation after
this runtime commit records validation; BUILD-INFO.txt preserves package provenance.
+74
View File
@@ -0,0 +1,74 @@
# Jimmy facing interpolation and full Euler seams
2026-11-04. This source-backed helper closes an integration dependency of the
ordinary movement audit. The current playable port remains the baseline. No
JN-Engine native movement/controller constants were adopted.
## Recovered original contract
Authoritative EXE SHA256
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
Code VAs below have independently mapped file offset VA−400000. New extractor
jimmy_orientation.py records three bounded ranges, hashes and two double factors.
| VA / file offset | Contract |
|---|---|
|43A420..43A5CF /3A420..3A5CF|Jimmy game-interface3D8 facing.475CA0 gameplay gate, +5 enabled, +A dirty control execution. Clear dirty, read current224/228/22C and retained target274/278/27C. Unequal axes reassert dirty; current/target remain distinct state.|
|43A4A4..43A58C /3A4A4..3A58C|For each target−current difference, wrap strictly>180 by−360 and strictly<−180 by+360 once. ±180 retain sign. Pitch/yaw deltas have explicit float stack stores; roll's difference remains on x87 until final argument publication.|
|43A58C..43A5C2 /3A58C..3A5C2|Multiply differences by supplied float dt, then double4.5 for pitch/roll (4AFD38), double3.7 for yaw (4AFCF0), store each resulting delta as float parameter and invoke334. There is no small-step snap or gain clamp.|
|458F90..458FB6 /58F90..58FB6|Jimmy334 wrapper repeats gameplay gate, then forwards XYZ float parameters to472480.|
|472480..472570 /72480..72570|Add angles and preserve original asymmetric negative truncation and strict>360 single wrap. Existing RocketOrientation.Add models this leaf; zero steps can normalize negative angles.|
|473240→47328D /73240→7328D|Shared base updater invokes game3D8→43A420.43796A calls40E050 before437A1B raw-owner identity check. Facing is thus a base phase independent of movement input acceptance. Body/registry/callback ordering still belongs to caller.|
Jimmy vtable4A373C+334 binds458F90 and+3D8 binds43A420. The probe uses these
original wrapper/leaf bodies with a synthetic game-interface object and active
475CA0. No global game entrypoint or actor/controller/body path executes.
## Why this matters for live integration
LabSimulation previously interpolated raw targetPitch−Pitch and targetRoll−Roll
with float4.5, while yaw used IEEERemainder and float3.7. Source AddEuler used by
movement canonicalizes all axes, so a recovered pitch/roll338 must approach0
through360. A raw difference would instead rotate338 toward0 the long way.
This can create an artificial spin after a slope/vehicle/Bubble tilt. Source
native338→0 at60Hz produces339.65 on both pitch/roll, preserving the short arc.
New JimmyOrientation.Step(current,target,dt,enabled=true,dirty=true) returns the
new full Euler and leaves destination state untouched. It supports ordinary
movement and existing Bubble facing; no targets are invented/reset by the helper.
X/Y delta rounding, factor widths and AddEuler parameter publication are preserved
with double intermediates and explicit float argument casts. Disabled/clean gates
return current unchanged. Caller owns actual enabled/dirty fields and scheduling;
this pure API does not infer either from input ownership.
Parent owns LabSimulation integration: apply this once in the recovered base
phase, after fresh input and before ordinary controlled apply, while retained
input remains after player/fire. Remove duplicate naive interpolation. Exact
base-wrapper/dirty flag state and unsupported class modes remain separate gates.
## Evidence and verification
Parent's retained REA inspect_with_objdump Evidence
`ev_0d64cc58fa8f5573fc8e61e0f2c20e36288099212bd2257d3a3121361fd6c904`
contains the complete original disassembly. Bundle:
artifacts/jimmy-movement-audit/rea-original-disassembly.json. The focused source
instructions/caller are retained under artifacts/jimmy-orientation-audit. The
same routine may not be recognized as a Ghidra procedure under the default profile;
no unchanged failed pseudocode selector was repeated. This evidence establishes
bytes/instructions, not original gameplay runtime.
The isolated copied-original probe executes43A420/458F90/472480 and records16
cases: ordinary axes,338→0 leveling, both359/1 seams, negative angles, exact±180,
>180, canonical360, fractional input/double arithmetic, small-angle/no-snap,
120-tick settling, upright and enabled/dirty/zero-dt gates. Wine32 exits0 with
JIMMY_ORIENTATION_COMPLETE. Source/generator/shared-map-helper/generated EXE/log
hashes are committed in original-orientation-reference.json. Native outputs and
capture metadata are under artifacts/jimmy-orientation-audit/probe.
Two managed groups compare all16 observations and verify retained target state.
Two Python groups guard identity, ranges/offsets, double factors, complete fixture
and provenance/gates. This is component execution plus managed conformance, not
whole-original/native Windows gameplay, full animation/visual-root parity or a
complete scene registry/cadence implementation. Parent records live verification.
Live integration/route/native/package status (2026-11-05): [movement stabilization](jimmy-movement-stabilization.md). The audit API notes above describe the isolated component boundary; parent integration is now recorded in that continuation.
+114
View File
@@ -0,0 +1,114 @@
# Jimmy logical/render Euler and compatible pivot bridge
2026-11-05. This investigates the original transform before enabling ordinary
up/down airborne tilt. The existing playable movement and upright placement are
the baseline. JN-Engine original class/decompiler notes supplied navigation leads;
its tuned movement and renderer are not copied as behavior references.
## Original facts and state ownership
Authoritative identities are EXE
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`
and OMT2.dll
`3ec41ead011adf56387a6dbd4580e5b5a9721b5f8020c8a56420f42824354943`.
`tools/binary/jimmy_model_bridge.py` guards their ranges, five Jimmy bindings and
both double angle constants. File offsets below are independently PE-mapped.
| VA / file offset | Recovered contract |
|---|---|
|EXE4624B0 /624B0|Jimmy game-interface3DC asks310→472300 for the current logical/body Vec4; copies XYZ to complete44/48/4C without scale or floor/sole subtraction.|
|EXE4624F0 /624F0|Angle publication hook3E0 jumps to473540.|
|EXE473540 /73540|Reads current degree Euler through328→4723F0; each axis is remainder360, multiplied by **double**45.51111111111111 at4D6408 and truncated through47F940, then masked16383. Double360 is4D6410.|
|EXE462500 /62500|Game3E4 stores the three resulting shorts at interface−70/−6E/−6C = complete50/52/54. Position and cached render angles are distinct records.|
|DLL1003FA60 /3FA60|OMediaElement::compute_hxform copies the parent hierarchy; obtains current animation dynamic offset from virtual7C and adds complete44/48/4C. With identity parent, resulting translation is exactly root+dynamic offset. Rotation does not rotate that root.|
|DLL1003FB26..1003FBE3 /3FB26..3FBE3|Reads cached angle shorts52/50/54 with negative signs and rotates the hierarchical basis. Row-vector form is Rz(−roll)·Rx(−pitch)·Ry(−yaw), with unit scale in the probed path.|
|DLL1003FC00 /3FC00|compute_model_matrix consumes the hierarchy and decomposes/re-quantizes its rotation through original angle lookup before publishing the final4×4. This additional precision behavior is distinct from the hierarchical basis.|
473540 does **not** duplicate Y into X: the0C stack load at473586 reads Y, then
pushZ at473595 shifts the stack. The0C load at4735A6 consequently reads original
X. Native asymmetric(-40,45,-15)→(14564,2048,15702) confirms independent axes.
The double render conversion is kept separate from physics472B10's float
45.5111122 factor. Render caching is not permission to mutate current degree
Euler or its destination state. Their phase/state owners remain in LabSimulation.
The position bridge has no hardcoded radius75.9, standing-minimum offset or scale.
Prior mode2 DLL import probes establish original jimstop geometry and zero dynamic
frame offsets for the tested clips; see [original collision](../analysis/original-collision.md).
That does not certify every clip, shape mutation, hierarchy or transform flag.
There is no newly recovered original correction for the port's sole alignment.
## REA and native evidence
The retained EXE instruction Evidence is
`ev_0d64cc58fa8f5573fc8e61e0f2c20e36288099212bd2257d3a3121361fd6c904`
in artifacts/jimmy-movement-audit/rea-original-disassembly.json. The DLL REA
inspect-with-objdump Evidence is
`ev_af082632c98b34ccfcedef01466cafa03365e7fbf482496d01a4cda6d2f8f787`,
retained in artifacts/jimmy-model-bridge/rea-dll-disassembly.json. Its16MiB output
cap was reached, so it is a **bounded prefix**, completion unknown, not complete
DLL analysis. All transform ranges used here are present and separately guarded
against original bytes. An initial REA target-path error was corrected by making
a separate generated DLL copy; no missing-target result is cited as analysis.
The OMT probe calls exported compute_hxform and compute_model_matrix against a
synthetic element, identity parent and zero dynamic-offset callback. Fourteen
cases include upright, individual90° axes, full combined axes, ordinary forward/
backward air tilts, negative units,16383/16384 seams, halfturn, tiny angles and
two roots with the same rotation. No game/renderer entrypoint, GPU, body,
animation or audio runs. The original DLL is loaded only from an isolated copy.
The angle probe executes copied473540, original4723F0 getter and462500 setter
with synthetic actor fields. It bypasses CRT exception dispatch at4802CA into
its original finite x87 remainder primitive4802D4;47F940 truncation is original.
Twelve finite cases cover independent axes, negative/fractional degrees, multiple
revolutions, exact angle units, canonical360 and tiny seams. This does not verify
CRT exceptions, nonfinite inputs or the whole object scheduler.
Both isolated Wine32 runs exit0 with their success markers. First-time Wine prefix
creation exceeded the initial capture window; reuse of an already completed local
analysis prefix resolved setup. Successful model and angle logs/capture metadata
are retained separately under artifacts/jimmy-model-bridge. Fixture
`tests/GamePort.JimmyRenderTests/original-render-reference.json` commits all40
observations (14 hierarchy +14 final render matrices +12 angle writes), source
ranges/constants/bindings and generator/probe-EXE/output hashes.
## Implemented helper and explicit modern policy
`JimmyRenderTransform.AngleUnits` follows the recovered finite degree conversion.
`Source(root,euler)` uses those units and the original hierarchical axis order;
its translation is the unrotated root. `Aligned(root,euler,localYCorrection)`
pre-translates local vertices before that source rotation/root transform.
The helpers are pure and reject nonfinite inputs; no broader renderer or asset
rewriting is introduced.
For baseline upright placement, the caller may retain the fixed modern correction
`c = -modelMinimumY - rootHeight`, then use
`Translate(0,c,0) * Source(ActorRoot,Euler)`. For the standing mesh, minimumY is
approximately−64.6165 and the existing logical clearance is75.9, givingc≈−11.2835.
This preserves the upright sole location while combined pitch/roll rotate around
the logical root. The local point(0,−c,0) stays at ActorRoot under every rotation.
It is a **modern compatibility adapter**, not a recovered original pivot offset,
scale or new body clearance. It must not change collision/body support geometry.
The old world-space sole correction is not evidence for the source transform.
## Tests and remaining gates
The managed suite compares all12 original degree writes and14 hierarchical
transforms (basis tolerance1e−6), unit-scale determinant, unrotated translation,
modern upright/combined-tilt pivot invariants and nonfinite rejection. Two Python
groups verify source ranges/constants/bindings and complete native fixture/
provenance. Commands from GamePort:
```
dotnet run --project tests/GamePort.JimmyRenderTests
python3 -m unittest discover -s tests -p test_jimmy_model_bridge.py
```
Both pass. Final OMT model-matrix parity is deliberately **not** claimed. Its
approximate angle decomposition produces up to0.007286333 matrix-coefficient
deviation in the14 saved cases, largest at the16383-unit near-zero seam; ordinary
combined air tilt differs by roughly0.0002..0.0003. The test records that mismatch
instead of treating the final matrices as conforming. Exact decomposition/lookup,
all render flags/parents/dynamic offsets, complete source pivot/clip ownership and
whole-original/native Windows visual comparison remain separate gates. Runtime
integration/route/native checks are owned by the parent movement continuation.
+65
View File
@@ -0,0 +1,65 @@
# Shared player energy and warning sounds
2026-11-01. Static recovery reuses the complete local REA/Ghidra12.1.4 record
`artifacts/shrink-ray/rea-primary-followup/04.json`, Evidence
`ev_71897af12f4bfa1de946c6f17f3bbed34764fdc84258ce64516c8f1f904b465d`.
Its exported bundle and closed snapshot remain beside it. No duplicate analysis
session or original execution was needed. Supplementary instruction cross-checks
are in `artifacts/gadget-followup/energy.instructions.txt`.
`tools/binary/player_energy.py ../Original` checks the full original EXE hash,
the complete42A920..42AA13 body, ten decisive sites and four constants. Output
`artifacts/gadget-followup/energy-source.json` records PE-mapped file offsets
for all preferred VAs below. Original EXE SHA256:
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
For these .text locations, mapped file offset is VA−400000.
## Recovered state and order
Global float4F83D4 is the player energy scalar; byte4F83DC is a separate low-warning
latch. Jimmy constructor42217E clearsEBX,422980 writesBL to the latch. Existing
retained-loader evidence shows ordinary loads reuse Jimmy without repeating his
constructor. TSK stores PlayerValue, not this latch; direct scalar load is distinct
from calling the adjustment helper. Full new-game/load UI ownership remains open.
42A92B..42A93D compares the current game's FourCC against numericVR01..VR08 and
returns for those tutorials without changing scalar, latch or playing sounds.
Otherwise:
1. When old energy>0 and the requested sum<=0,42A967..42A972 requests SFX80 before
the scalar changes. Staying at zero is not another crossing.
2.42A975 reloads the live scalar, adds the delta and stores float32. The upper100
comparison uses the still-live x87 sum. Above100 clamps100, clears the latch
and returns (42A985..42A9A3).
3. Negative stored energy clamps0. Stored energy<19 emits SFX182 once if the latch
is false, then sets it true (42A9C3..42A9F7). The scalar is already published
when that sound is requested; the latch is written afterward.
4. Values19..20 inclusive preserve the latch; strictly>20 clears it
(42A9F8..42AA12). A direct assignment/refill is not itself this helper call.
The shared consumers include ordinary ray426F5A (−dt), powered-fire421FB0's active
phase (−dt×.5), Invisible424F26 (fixed−2 on activation), and Bubble42627C
(−dt×.5; Bubble runtime remains pending). Tutorial immunity does not bypass the
individual caller's activation gate; Jimmy PostLoad independently sets its9F8
energy-override field for VR01..08.
## Current implementation and verification boundaries
`PlayerEnergy` owns scalar and warning latch. Main retains one instance across
ordinary scene rebuilds; LabSimulation delegates scalar access and adjustments to
it. Warning callbacks run in source write order and feed SceneAudio's existing
SFX bank/gate. The ray and positive jetpack-effect phase now call this owner;
Invisible spends2 through the same path. The independent JetpackBurst pure helper
continues to expose its numeric projection for algorithm tests.
Modern doubles preserve the relevant two-float sum before stores; exhaustive x87
rounding/control-word equivalence is not claimed. Nonfinite input is rejected.
Saved scalar assignment and modern debug refill do not infer a warning reset.
The modern debug checkpoint/load interface is not an original full save UI.
Managed tests cover strict19/20 boundaries, one-shot warning episodes, crossing
sound before scalar/low sound after scalar, clamp, tutorial bypass and shared
ordinary-load ownership. Source tests guard constructor, both new callsites,
body/constants and offsets. They are port/static checks, separate from listening
to the original whole game or native Windows verification. Whole energy/damage/
pickup consumers, soundbank timing and exact original scheduler remain open.
+97
View File
@@ -0,0 +1,97 @@
# Rocketship resources and VR02 authored data
2026-11-03. Read-only original asset inspection plus exact resource export.
No original binary executed; no original/friend-tree changes. Binary ownership,
physics, transforms, animation timing and material flags belong to
[Rocketship recovery](rocketship.md), not to geometric compatibility.
`tools/extractors/rocketship_resources.py` exposes
`export_rocketship(original, output)`. It validates all12 source hashes, ASE
sample/topology and decoded RGBA identities before writing a separate directory.
It rejects original subtrees/ancestors and existing descendant symlinks. Four
source-named animation manifests reference exact original PNG pixels; no family
action names, transforms, invented UVs, interpolation or material flags are set.
Generated data: `artifacts/rocket-assets/resources/rocketship.json`.
```bash
python3 tools/extractors/rocketship_resources.py ../Original --output artifacts/rocket-assets/resources
python3 -m unittest discover -s tests -p test_rocketship_resources.py -v
```
## Meshes and textures
Coordinates use the existing independently matched ASE conversion `(x,z,y)`,
texture `(u,-v)`; exporter preserves sample positions. Original smoothing remains
unrecovered; existing ASE exporter reconstructs flat normals.
| Source | Indexed vertices / faces | Exact source sample times | fps / ticks per frame | Texture topology |
|---|---|---|---|---|
|strato.ASE / strato01|159 /262|0|30 /160|Own497 UVs,262 texture faces|
|firestrato.ASE / Cylinder01|7 /6|0,480,960|10 /480|Own10 UVs,6 texture faces|
|jimdrive.ASE / 01jimmy|426 /814|0,480|10 /480|No UVs; original jimstop426 base|
|godrocket.ASE / point|222 /411|0,960,1920|5 /960|No UVs; original godpoint222 base|
The two morphs retain the base's faces/UVs by vertex index, matching existing
original-morph exporter semantics. This establishes renderable resource
compatibility; runtime DRIVE/ROCK selection/attachment still needs binary proof.
The three godrocket samples share bounds but contain different indexed positions;
retain all samples rather than treating identical bounds as a static clip.
| Exact PNG | Size | Decoded RGBA SHA256 |
|---|---|---|
|strato.png|256×256|`b1b18454fe0413e3ce885a61e4407c808060da0fe29ef2aec26ccd4e39437f31`|
|fire.png|100×100|`07dbbc4c6b99b6fa5fe424f2f917e03352a9c635fdc1593fc12f354be83a9a7f`|
|jimycarl.png|256×256|`5e54ccb99e9e060843cd7f80fd93ff8bf47f8779666e41d4240398354a278a3f`|
|goddard02.png|256×256|`9eb24c8fa41ddf08d2f33dd7b7513b632d4262cfc26cab3383c54258b9647a62`|
Retained REA body-init43DD10 Evidence
`ev_d7bf671456c93939ac04ab612e10181e729e078de4bfc06b22f4b5302d71da00`
(`artifacts/rocket-contract/rea-core/00.json`) verifies HIDEFAULT→Strato.ase,
strato.png, DEFAULT and game110(50.0). EXE VAs in this range map to file offset
VA−400000. The source setter110→471240 establishes50 as body radius; it is not
a visual scale. Constructor4192E0 also binds DEFAULT→firestrato.ASE/fire.png;
see the accompanying Rocketship source report for guards/Evidence. Driver/dog
resource candidates are exported without
asserting their runtime state/visibility/material bindings. Do not substitute
rocket.ASE, rocketfire.ASE or objects.omt shape26 merely because their names
sound appropriate; their topology differs from this recovered Strato binding.
## VR02 and campaign corpus
All35 supplied GAMs were parsed.32 contain one3ROC; Level3B/3E and VR08 do not.
Two independent3FLA records occur in Level2 (offset7267) and Level2b (4C20),
not VR02; this does not count constructor-owned fire children. Complete observed
placement values are retained in `artifacts/rocket-assets/placements.json`.
VR02.gam SHA256
`3be92e270bd14e6fc41db702e68c894562128d23d46704b89f7abb1914bebc5c`.
All18 entity records/ordinals/property bytes/offsets are retained in the manifest.
Its sole3ROC is ordinal1, file offset1CD; position
`(445.8588257,74.9721756,598.4440918)`, yaw9.9755859375, TaskNameLIBBY.
Authored fields: MaxHeight3900, MaxSpeed1400, AccelRate400, DecelRate1, Up650,
Down−650, MaxVertVelocity650, NewGravity0, AccelLean20, DecelLean−20. These
values do not define the flying algorithm or active Jimmy-owned rocket spawn.
PHONEBOOTH/STRT points at intro3MCA `rs`; the source intro target list is
rs1/rs2/rs3/Jim1. There are **two rs1 patrol entities**, ordinals13/15,
offsets23DE/2C09. Preserve distinct records and original lookup behavior; do not
deduplicate tags or assume which position the original resolver chooses. Seven
3PIC records use indices3101..3107; LOAD offset21B9 targets RETURN with radius400.
VR02.omt SHA256
`ab041f663cd5e68d58e590feeb7661f308a70ccc682a32c49ccd82b74bec61c0`.
One shape0 `Box01`, offset74464,93802 bytes,424 indexed vertices/880 triangle
polygons; no NC-named shape. Material counts:0→160,2→96,3→192,5→400,null→32.
Retain the32 textureless polygons in collision data; absence of special Jimmy
materials alone does not prove game-class registration or flying-body admission.
The current route camera/static-body factory also excludes VR02 pending those
source gates. Resource export does not change that factory.
## Verification and remaining boundaries
Five resource checks pass: exact pixels/source sampling and mesh indices,
base-topology UV/sample-position binding, VR02 offsets/duplicate tags/null
polygons, protected output paths and changed-source/pixel rejection before output.
Standalone CLI export succeeds. No port gameplay, Vulkan, native Windows or
full original-runtime comparison is claimed by these checks. Main owns shared
prepare/package wiring; resources are currently opt-in via the new exporter.
+58
View File
@@ -0,0 +1,58 @@
# Rocketship body and VR02 contacts
2026-11-03. `tools/binary/rocketship_body.py` guards callbacks/flags/physics and
vtable4B25AC; file offsets accompany generated reports. EXE text VAs map to
VA−400000. Source/complete REA replies and closed sessions are retained under
`artifacts/rocket-body/rea-{callbacks,vr02-contacts}/`.
43E8D0 Evidence `ev_8f8b2ab2823b93372092e5e555faff811da178c40935fac0a9bb33142ff43bc1`;
435CE0 `ev_0134513dc749fa400dba28ed28630e6c567b382aec6c7e93684e19464a165924`;
435800 `ev_16509f386735a8186417564f0d6b8c8454a6a10bb3d3d3933946589ab8710c9a`.
Unrecognized raw procedures use guarded source and isolated probes, not a claim
of successful decompilation.
## Body composition
Rocket radius50, factorfloat32(.6), frictionfloat32(.8), prevent-lowering TRUE
(43D90D→470F70(1)). Support clearance is float32(30.0000019), not Jimmy75.9.
Normal479D20/support composition applies. Landing37C→472970 is no-op.
Terminal geometry callback370→43EB70 when normalY<=−.7 unconditionally assigns
velocityY−120; X/Z, root and acceleration survive. Ordinary Jimmy's positive-Y
cancellation is incorrect here. Callback374→43E8D0 otherwise has rider effects;
it does not call generic reflection378→472750 and does not change ship velocity/root.
374 requires rider, selected polygon and material pointer. Missing definition
uses ordinary effects; defined170/−1 ignores. OrdinaryVR02 material IDs0/2/3/5
produce rider1A0(−1,−1,1), sound197, duration1 and impact latch/timer reset only
when no impact is active.130..139 uses−10/5seconds;185..189 uses rider latch
and an additional rider198 callback. Those special cases are not admitted by
the bounded live VR02 material profile. Null-material polygons still clip the
body, but do not emit damage/impact effects.
23 copied-original370/374 cases preserve synthetic root/acceleration and verify
these branches. `artifacts/rocket-body/source-and-callbacks.json` records their
inputs/results and generator/executable/log hashes. Six copied479D20/support
cases in `body-support-probe/wine.log` establish floor30.0000019, no forced
lowering from75.9, rise with priorVy300 and independent published-speed friction.
All use synthetic body/rider/audio accessors and separate Wine32 execution;
no original gameplay runs. OriginalBodyPhysics's Rocketship profile composes
the ceiling rule and prevent-lowering; caller owns ordinary rider effects.
## Pair flag and actual actor classes
**1E4 writes interface137; it does not disable integration.** It inhibits
dynamic push/recording, while479D20 integration uses210/live13E. Mounted Jimmy
can still run static physics before ship update overwrites his transform.
Earlier broad statements that mounting disables his physical body were wrong.
VR02 contains Jimmy, ship, phone booth, trophy, seven3PIC, LOAD, four patrols,
STRT and MCA. No authored mine/rock/missile exists. Phone/trophy constructors
use sphere mode1, pairs=true, world/support/integration=false,137=true,
radius40/20. They are not missing box geometry for the static resolver. This
does not prove all source pair callbacks absent.
Pickup435D08 requires caller==raw controlled5099E4: mounted ship qualifies,
passenger does not. LOAD457EE6 and Phone435800 require C3DJIMMY: actual passenger
can qualify while Rocketship cannot. Keep distinct actor identity/radii: controlled
ship50 for pickups and Jimmy60 for LOAD. Current discovery remains the port's
bounded sphere-overlap adapter; original full pair ordering is not reconstructed.
+80
View File
@@ -0,0 +1,80 @@
# Rocketship arithmetic and resource checkpoint
Historical a274670 checkpoint; superseded for live VR02 status by
[rocketship-live.md](rocketship-live.md). Later source/probes corrected the
unconditional input-after-apply wording: game and ship callbacks are separate,
ordered by fresh/retained registration. Mounted Jimmy still runs static physics.
2026-11-03. Continued gadgets after the supplied jn-engine assessment c6eb186.
Kept the playable d6ca417 source/packages and parked collision baseline intact.
Independent investigators owned Rocketship source, resources and Grappler source;
primary reviewed/integrated their files. All ownership has returned.
## Implemented and tested
`src/GamePort/Game/RocketFlight.cs` implements ordinary keyboard scalar/bank input
from41A6C0 and vertical publication from41A470..41A6A8. It is an isolated component,
not a connected live vehicle. Input updates retained state after application in
the ordinary source update; no input-before-integration reorder was introduced.
Caller owns body integration, X/Z vectors, facing and camera state.
Important source behavior preserved:
- Acceleration400 is per callback; support loss500*dt follows it. Down brakes
even with Up held, then Up wins the published vertical flags.
- Bank changes160*dt, clamps±45, and prior keyboard bank returns at130*dt.
- Up/Down650/−650 are acceleration commands, not direct velocities. Publication
subtracts global gravity; current velocity independently clamps±650.
- Below speed100, prior vertical command survives and the height clamp is skipped.
At the ceiling, root Y clamps but positive Vy survives; neutral snapping uses
a strict(−60,60) band.
Two isolated copied-original probes establish14 input-prefix and14 vertical-suffix
references. Generated Win32 harnesses used synthetic mouse/support/transform/audio
or body accessors, skipped camera/horizontal/integration paths and ran in separate
Wine32 namespaces. Original entrypoint/gameplay did not execute. Source bounds,
REA Evidence, file offsets and complete provenance are in
[rocketship.md](rocketship.md) and `artifacts/rocket-contract/`.
Numeric fixtures in `tests/GamePort.RocketFlightTests/` retain source, body,
generator, executable and log hashes. Thirteen managed groups compare all claimed
scalar/flag outputs with absolute tolerance.0002, reject nonfinite comparisons,
and cover phase/threshold/priority/invalid-input cases. Destination Euler and
source-preserved X/Z values are outside this scalar API's comparison. The test
is registered in `scripts/test.sh`; no live simulation path uses the component
yet. No bit-identical general x87 or original cadence claim is made.
`rocketship_resources.py` exports exact Strato/firestrato geometry, compatible
Jimmy/Goddard morph samples, PNG pixels and VR02 records after12 source hashes and
topology/pixel checks. Five tests cover output protection and resource identity.
It remains opt-in; shared preparation/package resources were not changed.
## Research integrated
[Rocketship source](rocketship.md) establishes Jimmy's owned ship, rider/control
handoff and cleanup, radius50/factor.6/friction.8, FireStrato binding and VR02's
false game polygon filter. The friend's label “visual scalar50” was corrected
through the original setter. Live body/factory admission remains unchanged.
[Grappler source](grappler.md) establishes owned rope/cursor, full-Euler ray and
material gates, attach/reel/swing/detach ordering and retained first rope length.
Twelve Python source/projection checks pass. No nearest-hook/direct-pull mechanic
or friend gameplay code was imported. Guarded tools also preserve provider gaps;
the existing local REA launcher was used without configuration changes.
Validation:13 Rocket managed groups,3 Rocket source groups,5 resource groups,
12 Grappler groups,15 existing Gadget and25 Movement groups pass. Main .NET10 build
passes with the existing NU1900 unavailable metadata warning;539 original hashes
verify unchanged. Independent read-only review agrees with the declared component
scope. No new Vulkan/live gameplay/native Windows checks or package rebuild was
needed or claimed; prior playable releases remain the user testing baseline.
## Next coherent chunk
Close the aircraft-specific370/374/378 collision callbacks, normal Euler/slip/
roll/facing and shared camera record update. Establish owned-versus-placed3ROC
property/reset behavior and retained helper lifetime. Then integrate explicit
vehicle ownership, passenger/Goddard/fire transforms and audio, mount/cleanup,
VR02 live body and F1 controls, with input/unequip/control-loss/RETURN regressions.
The source radius/support alone cannot justify using Jimmy's body/camera as a
vehicle replacement. Grappler's body/camera/material-context gates remain separate.
+113
View File
@@ -0,0 +1,113 @@
# Rocketship wall-impact render correction
2026-11-03, user-reported wall-hit distortion. **Recovered fact: the four
impact values are material diffuse RGBA, not geometry scale.** The earlier
Rocketship lifecycle report, source-projection naming and supplied friend's
`C3DRocketShip.md` called these values scale; that semantic interpretation was
wrong. The copied-original numeric observations remain valid.
## Ownership and source chain
Authoritative EXE SHA256:
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
Authoritative OMT2.dll SHA256:
`3ec41ead011adf56387a6dbd4580e5b5a9721b5f8020c8a56420f42824354943`.
The friend's different DLL is not used. Analysis reads generated copies only.
1. EXE40DCA0 allocates0x8C bytes;40DCC0 calls IAT48D18C, whose imported name
is `OMedia3DMaterial::OMedia3DMaterial()`.40DCCA stores this pointer in
`complete+5C0+textureIndex*4`.40DCD1/40DCD4 initialize its blend fields30/34.
This is the inherited indexed material array, not an object transform.
2. Rocket43E76E loads `game-interface+500`, equal to `complete+5C0`, material0.
43E780 adds4C. Stores43E78B,43E795,43E7A4,43E7A7 write offsets4C,50,54,58
respectively as `(1,pulse,pulse,1)`. No passenger, Goddard or flame pointer
is traversed by these writes.
3. DLL exported `OMedia3DMaterial::set_color` at10001320 writes the three RGB
components into offsets4C/50/54 (among its other material colors), proving
the fields belong to a color. Its name comes from our DLL export table.
4. DLL exported `OMediaDXRenderPort::draw_shape` at100374B0 consumes the same
material fields.100376A6 passes material+4C to render-port set_material
as its diffuse color. The unlit branch1003787C..100378F6 reads+58 first,
then+4C,+50,+54, multiplies components by255 and packs ARGB diffuse.
Thus offsets4C/50/54 are RGB and58 is alpha. Geometric vertices are not
scaled by this code.
5. Existing REA40E4A0 independently writes `(1,1,1,alpha)` at these same
material offsets while changing blend state. Existing Shrink Ray and
Invisible evidence already identified this as opacity rather than scale.
EXE text raw offsets above are VA−400000; the cited DLL code ranges have raw
offsets VA−10000000. Full bytes/hash guards are retained in
`artifacts/rocket-impact-render/material-byte-guards.json`:
| Source range, exclusive end | Raw start | SHA256 |
| --- | --- | --- |
| EXE43E76E..43E7AA |3E76E|52fb46c6a2271fd06691be976a277a53350aaf6dd2b7083a623ffa797eb8819f|
| EXE40DCA0..40DCF6 |DCA0|fd3810ec3db075e35a81025c0ebec5bd0c2504072306dafac78e5a818c817aff|
| DLL10001320..1000139B |1320|071ee5efa77f876b08994ddc3750a4b8e6f2581b741f1e4c8202285b12ff6a65|
| DLL10037694..100376B3 |37694|d9784e68b81bf68a5ef9df686fc4535675915f21643898bcda0dc1ade43562d5|
| DLL10037874..100378FA |37874|32a2fea66ca6438d44061ba85730509d8c7509ac045001688273c65042619ae4|
## REA evidence and probe interpretation
New local REA/Ghidra queries of the generated authoritative DLL copy succeeded;
complete replies, export bundle and closed snapshot are under
`artifacts/rocket-impact-render/rea-material/`:
- 10001320 set_color: `ev_71e12ebb8e6f6994553fe33606a358b7cd5a0277e50f8190b022e28216ced8ef`.
- 10036F70 DX set_material: `ev_991aa57164839ac125a6cfd9ea309896ef8e525037debed8aeb7f413da71c72c`.
- 100619C0 pipeline set_material: `ev_50a751ce5c2dae8b884f31c0f4da52b6f792054c9d30b74fa64739c84ffa1a76`.
Prior40E4A0 evidence:
`ev_615030aa60b2346083853c40aa719ebc466e9f393fd870ea9722536a4f64cfac`,
`artifacts/invisible/rea-invisible-ipc/01.json`. The DX set_material decompiler
loses stack-copy detail; exact draw_shape disassembly supplies the downstream
packed-color ordering. This is static shipped-artifact evidence, not observed
original gameplay.
The eight earlier impact-tail probes stubbed the material object and printed
the four writes under the misleading output label `scale`. They measured
values, timing, strict expiry and impulses; they did not execute a renderer
and therefore never established scaling. Preserve the old raw fixture field
for provenance, but interpret the observations as color.
## Implementation implication and verification boundary
Apply `(1,pulse,pulse,1)` only to the ship's diffuse tint, retain unit geometric
scale, and restore white when the source impact interval expires. Keep the
existing source pulse and strict timer comparison. The result is a red/white
damage flash with opaque alpha, not a squash/stretch animation. Passenger,
Goddard and fire transforms/tints remain independent.
The binary investigation performs no target execution. Primary integrated
ImpactColor(Vector4), ship-only vertex RGB/opaque alpha and unit model geometry.
Python projections now name the field color; future probes print rgba while
retained raw observations keep their old label. Three independent byte spans
guard the writer, material constructor and DLL diffuse consumer in regression.
The13-group managed suite passes. Its new regression drives the live static-wall
callback twice against a synthetic triangle, samples all four original resource layers over130 frames, checks
every vertex against unit geometry, checks ship-only red tint and verifies
re-rendering does not accumulate color. It also verifies expiry and reset restore
white.12 lifecycle Python groups pass, including all eight numeric references.
Main .NET build passes. The existing1920×1080 ten-phase headless flight replay
passes with validation enabled and zero Vulkan errors; that replay has no wall
impact and is not a GPU wall-hit comparison. All539 original hashes verify.
Logs: artifacts/rocket-impact-render/{managed.log,python-material.log,build.log,
replay.log,originals.log}.
Full original wall-hit rendering and native Windows comparison remain separate
evidence categories.
## Release verification
Linux/Windows self-contained packages rebuilt from clean source
62e908e26d6452e18a2d0d5aab6627b0e8275dda; both BUILD-INFO.txt files record
source_dirty=no. All18 Rocketship resource files match the prepared originals.
Standalone Linux from /tmp on GTX1070/private Xvfb1920×1080 passes all10
flight/control phases with actual injected SDL keys and zero Vulkan errors,
validation enabled. This is the ordinary flight replay; wall-hit geometry/tint
is checked in the managed regression above.22 Rocketship Python source/projection
tests pass. All539 original hashes verify after packaging. Native Windows runtime
for this correction remains pending. Logs: artifacts/rocket-impact-render/
{package.log,package-resources.log,package-runtime.log,python-all-final.log,
originals-final.log}. Subsequent documentation-only changes retain this binary
source provenance.
+62
View File
@@ -0,0 +1,62 @@
# Owned Rocketship lifetime, passengers and audio
2026-11-03. `tools/binary/rocketship_lifecycle.py` guards15 spans/six virtuals,
animation strings and impact constants. Text offsets are VA−400000.
REA43EA60 Evidence `ev_b28a6f3c3709bd2dc15ad82b84d77485761790d09f103f1796320c254ea7f3c3`;
471000 `ev_2f4144c8b1d3d2cb8f0055eb0b45bd66fba6241074364da7f86339f9ed58152d`;
471090 `ev_87e9605c4180524d37fe82ff4a0070b18863a43e7f19e2b398ea393752e31fdc`.
Complete replies/failures/snapshots remain in artifacts/rocket-lifecycle/rea-20261103.
43DF70's default provider boundary remains missing; source instructions, guarded
vtable/callers and isolated component execution supplement it.
## Identity and reset
Jimmycomplete+AB0 owns the ship.43D950 sets retention470F40(0),43D9F9 sets reusable
game+9,43D916 registers FourCC3ROC through462220 (game+404). Loader46E6A0 finds
an eligible reusable ID;46E6E0 returns first matching ID in registry order.
The authored GAM3ROC reapplies properties to that owned object. It is not a
nearest ship or tag search. VR02 has exactly one serialized3ROC.
Mount copies root/Euler, enables geometryD0 and integration214, transfers game118
to ship+C0, stores complete Jimmy at shipcomplete+740/interface+680 and selects
DRIVE. It does not reset ship velocity, scalar or maneuver state. Raw1 cleanup
428541..428582 disables214, sets137 inhibit, explicitly calls complete128(0)
→43EA80 to stop engine and hides fire. It restores Jimmy ownership, clears link,
clears Jimmy velocity/acceleration and enters movementmode1/FALL, retaining his
last copied root. Level initialization43EA60→41A0B0 and43DB10 is a separate reset;
do not confuse remount with a new level. Normal unmounted update's base flight
math still precedes its speed0 tail.
## Update and presentation
43DF70 inherits flight apply, then copies ship root/Euler exactly into rider and
his proxy root, reasserts control at43E23E and updates owned visuals. Goddard local
offset(0,10,−25) uses full Euler; fire shares ship root/Euler. JimmyHIDRIVE→jimdrive
is registered422B04..18; GoddardHIROCK→godrocket at41CE2C..40. Fire41939E..3E8 binds
firestrato/fire.png and40DD40(0,6,1): source-alpha/one additive. Fire hides for Down
or speed<=0, shows otherwise. Scripted burst/RNG and twenty linked effects remain
separate from ordinary VR02, whose constructor EC1 prevents ordinary drive burst.
43E7E0 is the separately dispatched game-controlled input callback. Its rider
complete1AC target is427370, the gadget menu; Tab/Space must work while the ship
owns control. Fresh/retained registry order governs input-before/after apply.
Engine43EA80 switches0 stop,1 loop195,2 loop196, stopping old handle first;
unchanged1/2 does not restart. InputUp chooses2, Down/stopped0, positive coast1.
Sound197 is ordinary wall hit. All three are PCM in the existing sound bank.
Ordinary wall impact starts duration1 and E84, ED0=false.43E6E8 adds dt and tests
the unrounded sum **strictly greater** than duration. Equality still pulses;
expiry restores DRIVE and white material. The first material RGBA is(1,s,s,1),
s=(sin(time*20)+1)/2: a red damage flash. The initial port/report misidentified
this as shape scaling; corrected after the user's wall-impact bug report.
EXE43E76E selects material interface+500;43E78B..43E7A7 writes+4C..58.
OurDLL1003787C..100378F6 consumes those fields as ARGB diffuse. See
[impact-render proof and regression](rocketship-impact-render.md). Original
probe fixture/log retains its historical `scale` field label for provenance;
the numeric values are valid but do not establish geometry deformation.
Strong ED0 queuesY−700; EC0 burst separately queues−750, excluded from ordinary
VR02. Eight copied-original suffix cases in impact-probe/wine.log verify strict
expiry/pulse/queued impulses, including a float-store equality whose unrounded
sum has expired. Synthetic rider/render/impulse accessors run in isolated Wine32;
this is not original lifecycle or whole-game verification.
+107
View File
@@ -0,0 +1,107 @@
# Live VR02 Rocketship checkpoint
2026-11-03. Continues312efcc with a bounded playable aircraft in the authored
VR02 scene. Original files and supplied friend research remain unchanged. No
friend gameplay code was imported. Baseline69d0187 and parked collision
35a2a66/0272f7b remain available for comparison.
## Controls
F1 → Player → Give/Select Rocketship grants its tile. Outside VR02 this retains
the selection for Practice without enabling an invented player-flight mode.
Open Tab/Space, choose the Rocketship tile and Practice to enter VR02. Equip
there using the tile or F1 action. Up/right mouse accelerates and climbs, Down
brakes/descends, Left/Right banks. Enter/T turns180 degrees; R barrel rolls.
Tab/Space unequips before opening the gadget panel. R resets while unmounted.
## Source and implementation coverage
Source addresses, structures, caller chains, file offsets, REA Evidence IDs and
component-probe provenance are in [body](rocketship-body.md),
[motion/camera](rocketship-motion-camera.md), [lifecycle](rocketship-lifecycle.md)
and the earlier [component report](rocketship-component.md). EXE text file offsets
are VA−400000. Original executable/DLL hashes are guarded by the analysis tools.
Follow-up: [wall-impact material correction](rocketship-impact-render.md) fixes
an initial port bug that treated a red damage flash as ship geometry scaling.
Impact now changes only first-material RGB; ship/passengers/fire retain unit
model scale. The13-group regression includes two actual wall callbacks and
per-vertex geometry/color checks over130 frames, including expiry/re-rendering.
| Original contract | Current implementation and evidence | Remaining boundary |
| --- | --- | --- |
| Jimmy-owned reusable3ROC, ID reuse and mount/cleanup | Rocketship binds the sole authoredVR02 actor; PlayerSceneBinding transfers ownership, seeds root/Euler/shared eye, preserves remount motion and stops engine/fire on release | General retained helper registry across levels |
| Body before input/normal, fresh/retained registration order | Explicit StepBody, LabSimulation afterPhysics hook, input-before/after normal according to InputAfterPlayerUpdate | Full original traversal and original frame cadence |
| Radius50/factor.6/friction.8/prevent-lowering; ceiling370 and wall374 | Rocketship body profile with native support references and ordinary material effects | Other-level materials, special damage, complete pair scheduling |
| Jimmy1E4 dynamic inhibit, independent static body | Jimmy static physics continues before ship root/Euler synchronization | General dynamic push/recording implementation |
| Scalar/bank, vertical command, Euler/facing/slip, turn/barrel | RocketFlight/RocketOrientation/RocketMotion compare against copied-original numeric fixtures | General x87 bit identity and all modal globals |
| LOOK→eye clip, shared OLD eye, detail gain and quantized angles | OriginalCameraRay plus source camera math; both detail branches checked in components | Whole-game shared camera ownership, detail initialization and renderer parity |
| Strato/HIDRIVE/HIROCK/FireStrato and engine195/196, hit197 | Exact extracted morphs/textures; source pivots/full Euler, Goddard offset, additive flame; unchanged engine mode does not restart | Scripted effects, EC0/ED0, RNG and20 linked effects |
| Controlled-owner pickup vs named-Jimmy LOAD | Ship radius50 used for3PIC; real passenger radius60 used for LOAD | Port sphere discovery remains an adapter; no full pair-order claim |
| Control loss and menu/reset/noclip | Named-Jimmy MCA release, FALL cleanup, shared eye handoff, Tab/Space, F1 force-control, reset and F3 cleanup | Generic post-vehicle Jimmy Euler/render bridge and complete transition persistence |
Corrections replace earlier symptom-level assumptions:1E4 does not disable
integration, input is not unconditionally after normal, camera trace starts at
LOOK rather than ROOT, and turn/barrel controls are not boosts. No nearest-ship
search, direct vertical-velocity substitute or standing-foot art correction is
used for this vehicle.
## Verification
96 isolated copied-original observations:14 keyboard,14 vertical,31
motion/facing/camera,23 callbacks,6 support and8 impact suffix cases. These run
copied EXE/DLL components with synthetic accessors in separate Wine32 prefixes;
they do not run original gameplay. Committed fixtures and source guards allow
repeatable projection checks.14 managed flight groups and12 final Rocketship
integration groups pass. The latter cover actualVR02, fresh/retained input,
mount/remount/audio, source support, ceiling/wall, pickup/LOAD identity, RETURN,
resources, force-control and named-Jimmy cleanup.
Full scripts/test.sh passed268 Python regressions+2 HUD checks, all managed
suites,33 main GPU completions and17 material checks, with zero Vulkan validation
errors and539 original files unchanged. Its Rocketship integration run had10
groups; the final two force-control/MCA groups and tiny related fixes were checked
afterward by the12-group focused run. The initial selected-project compilation
failure was corrected by accepting a DirectorActor contact descriptor instead of
depending on Rocketship; its failed log is preserved separately.
Headless and native Linux GTX1070/private Xvfb1920×1080 replays pass all10 phases:
mount, flight, bank, turn, roll start/barrel, release, remount and noclip cleanup.
Native replay receives real injected SDL Up/Left/Enter/R/Tab/F3 events (mask63),
stops engine audio and reports zero enabled Vulkan validation errors.295 extra
ordinary ticks reuse received input through binding/interactions/director without
teleporting or seeding motion/timers; this is accelerated port verification.
Energy stays20. Captures show Jimmy/Goddard/fire attached during maneuvers.
Logs and readbacks: artifacts/rocketship-live/{integration.log,headless.log,
native-ipc.log,phases.png}; initial failures are retained separately. The initial
native sandbox could not access local X11 sockets; a locally approved IPC run
succeeded. No network display, uploads or original entrypoint execution occurred.
## Release and next work
Both self-contained packages were rebuilt from clean source
e77add5fdf158ada46e5de3f5eca9cb7af16af92. Their BUILD-INFO.txt files record
source_dirty=no. All18 Rocketship resource files match the prepared output on
both platforms, including the four exact original RGBA hashes and all morph
frames. Package resources were explicitly added to scripts/package.sh; this
resource directory has no scene.json and was not covered by the scene-copy loop.
The final Linux package runs directly from /tmp without the SDK or Original
paths in its arguments. Native GTX1070/private Xvfb1920×1080 again passes all10
phases, real SDL keys, energy20/20, engine cleanup and zero Vulkan validation
errors with validation enabled. The packaged F1 Player page also renders all32
lines at1920×1080; its headless release invocation has no available validation
layer. Both sets of readbacks were inspected. Original539-file verification
passes after packaging. Evidence: artifacts/rocketship-live/{package.log,
package-resources.log,package-native.log,package-menu.log,package-phases.png,
package-menu.png,final-managed.log,final-build.log,final-originals.log}.
Later release-note changes do not alter the compiled source. Native Windows
execution remains unverified; cross-publishing does not establish it.
Next evidence gates are non-VR02 reuse/level lifetime, special hazard/mission
consumers, shared-camera and general Jimmy Euler presentation after cleanup,
and full original actor-pair scheduling. Grappler and Scooter retain their
separate recovered contracts and are not enabled through approximate mechanics.
Manual original-versus-port tutorial completion and native Windows testing are
still required for broader fidelity claims.
+60
View File
@@ -0,0 +1,60 @@
# Rocketship motion, facing and camera continuation
2026-11-03. Source guards in `tools/binary/rocketship_motion_camera.py` cover
ten EXE spans/seven virtuals, imports/constants and both authoritative image
hashes. Text file offsets are VA−400000. Complete REA replies/provider failures
are retained under `artifacts/rocket-motion-camera/rea-{helpers,camera}/`.
472480 Evidence `ev_24161f6af107c0a3282a5600306feca8c43be2a6448e12a3df408dfea38a70ce`;
458F90 `ev_80bdb649020f090d63625bbe8d731786d2097f32b00625615bfe5384197cd040`.
Use prior41A140/41A6C0 Evidence from rocketship.md. Several queried raw entries
remain unrecognized; bounded disassembly and copied-original probes supplement
them. Static evidence is distinct from original runtime execution.
## Corrections and recovered behavior
43DF70/41A140 normal update does not call controlled-input43E7E0. Game44DF80→
475A70 dispatches raw owner3CC separately. Fresh game registration can put input
before ship update; retained helpers precede the appended destination game.
Use the recovered `InputAfterPlayerUpdate` phase boundary, with all body work
before either callback. Earlier unconditional input-after-apply prose is stale.
- Full local rotation472B10/point472980 uses negative Z, negative X, negative Y,
with original lookup trig. This differs from some earlier provisional combined
Euler adapters. RocketOrientation is independently scoped and tested.
- 472480 addition: negative sum becomes360−abs(trunc(sum)); sum>360 subtracts360
once; equality360 survives. Negative fractional seams therefore lose fractions.
- Facing41ADF0 runs through the inherited animated update before horizontal
application. It skips while prior barrel timer670>0. Pitch/roll use shortest
±180 deltas; yaw only corrects positive>180. Rates are2/4/3 times dt. All-zero
differences clear the source facing flag.
- Incoming full velocity!=0 permits yaw+=bank*dt and stores previous bank618.
Side scalar is previousBank*.0181818176060915*(1−friction)*speed; rotated local
forward supplies X/Z, with cos(yaw)*side addedX and sin(yaw)*side addedZ. PreserveY.
- Enter/T starts latched674=1 while moving; it adds180*dt yaw and decrements/clamps
its timer. Horizontal publication skips while the POST-decrement timer>0.
R starts latched670=1 and adds270*dt roll, including its finishing frame.
These are turn/roll maneuvers, not speed boosts. Modal globals suppress new
latch changes; timer updates themselves remain separate.
- Input destination is(Up?20:Down?−20:0,currentYaw,−bank), with stopped neutral
roll0. Source engine mode2 Up,0 Down/stopped,1 positive coast.
## Camera and original observations
Eye local(0,200,−500), look local(0,50,200), both full-Euler transformed.
Native probe corrects an early static interpretation:419DE0 traces **look→eye**,
not root→eye. Hit response is look−.75*(look−hit), gain2; miss gain1.
Follow uses OLD shared eye with gain*dt*(detail<=1?.6:1.2). Aim vector is look−OLD
eye, independent of updated eye. Original DLL vector::angles uses squared-ratio
half-acos lookup, quantized inverse heading and signed14-bit pitch/yaw; no atan2.
`artifacts/rocket-motion-camera/original-results.json` records31 copied-original
transform, horizontal, auxiliary, facing and camera cases. The Win32 harness
executes copied EXE instructions plus our copied OMT2.dll trig/angles (hash
3ec41ead…54943), with synthetic body/input/ray accessors. Original entrypoint,
world integration and gameplay do not run. Source/generator/executable/log hashes
are retained. The committed numeric fixture is
`tests/GamePort.RocketFlightTests/original-motion-reference.json`.
RocketOrientation, RocketMotion and OriginalHeading.Angles compare against these
31 cases; scalar/vector tolerance.002 and exact integer angle outputs. Existing
14 input/14 vertical references remain independent. General x87 bit identity,
whole-game camera cadence and full renderer parity are not established.
+171
View File
@@ -0,0 +1,171 @@
# Rocketship ownership and bounded flight components
2026-11-03. Original static recovery, guarded bytes and two isolated original
component probes. Friend research supplied useful class/function names; its
prototype vehicle mechanics were not imported. No live vehicle implementation
or original whole-game/native Windows verification is claimed by this report.
Primary owns any modern integration and its separate validation.
## Evidence and identity
EXE SHA256 `f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
`tools/binary/rocketship.py` guards ten source spans, six virtual targets and eight
constants, with PE-mapped file offsets in
`artifacts/rocket-contract/source-contract.json`. These .text VAs map to raw
offset VA−400000. Full disassembly windows are retained beside the report.
No friend OMT2.dll address is assumed applicable to our different DLL build.
| Source | REA Evidence | Retained path |
|---|---|---|
|43D840 constructor|`ev_0f31a079ff84847fd27d3e41de320d6bedddcbf3917b5f3e2b345773809a0b86`|rocket-contract/rea-core/01.json|
|43DD10 visual/body init|`ev_d7bf671456c93939ac04ab612e10181e729e078de4bfc06b22f4b5302d71da00`|rocket-contract/rea-core/00.json|
|41A140 apply|`ev_ba8607f59d6ebc468cd956e6b1c8d295eecb21889055130da4706e6cbc8e6ba2`|rocket-contract/rea-flight-ipc/00.json|
|41A6C0 input/camera|`ev_ef4490ca220408f61e74f4d122b472f9055475ec4b51e2446620a54ffd1c7b2c`|rocket-contract/rea-flight-ipc/01.json|
|43E7E0 controlled callback|`ev_20502f86a5c3c7bee2ea47608f89d578286785d1ba540b5fa7f7e56ed90505a0`|rocket-contract/rea-flight-ipc/04.json|
|4192E0 fire constructor|`ev_4f74f2325cf84e07d75696f1903bfff3800a02f9b6b706431a5b90b66a83c914`|rocket-contract/rea-flight-ipc/05.json|
Paths in that table are below `artifacts/`. Complete replies, bundles and closed
snapshots are retained. Initial `rea-flight/` failed at the known local Unix
socket sandbox boundary; one IPC-authorized retry succeeded.43DB10/43DF70 still
are not recognized as procedures in that profile; their saved errors are not
pseudocode evidence. Their bounded source instructions are guarded/reviewed.
419550 was queried as a possible effect initializer but is Flag construction;
it is not used to establish Rocketship behavior. No configuration was changed.
## State ownership, selection and cleanup
Jimmy's complete object owns a separate Rocketship allocation at+AB0, initialized
through constructor43D840; complete vtable4B2A4C, game-interface
vtable4B25AC at complete+C0. The ship's complete+740/interface+680 is a pointer to
the **complete Jimmy rider**, resolving the friend's unnamed linked-actor field.
Twenty other linked slots retain a separate unresolved effect/child role.
Item1 branch42944D..429686 uses this owned pointer; there is no nearest placed
3ROC search. It activates the ship, copies Jimmy root/Euler via game310/328 into
ship318/330, transfers game118 control to ship+C0 at4295A5, stores rider+740 at
4295B4, inhibits Jimmy dynamic push/recording through1E4 (his static physics still
runs), hides/disables relevant
companion flags, selects Jimmy DRIVE and writes raw gadget1 at42967F. Null owned
pointer skips this equip body. Availability/HUD commands remain separate.
Raw1 cleanup428512..42871D disables/hides ship flags, restores Jimmy game118
ownership at4285BA, restores companion policy, clears ship+740 at4286AE, clears
Jimmy acceleration/velocity, selects the normal animation/movement state, closes
HUD mode and writes raw−1. The original raw cleanup belongs to ownership change,
not just a rendered model toggle. Retained helper life and unmount-root timing
need the ordinary update/loader context before live integration.
43DD10 game110→471240 initializes authored34 and live15C **radius50**, not a visual
scale50.43D840 sets factor float32(.6); inherited419B70 sets friction float32(.8).
Thus ordinary radius×factor support clearance is30, distinct from Jimmy75.9.
Shape transforms/render scale are separate. This corrects the friend report's
"visual scalar" label. No wheel child construction was observed.
## Input/apply ordering and exact bounded arithmetic
Rocket registry update43DF70 calls inherited41A140 before its passenger/effect
tail. Controlled callback43E7E0 gates on407060 false and475CA0 true, then invokes
41A6C0, optionally updates a fire-held timer and calls rider complete1AC with dt.
**Apply consumes retained input state; input does not integrate the body.**
Game475A70 dispatches controlled-input3CC separately; fresh/retained registry
order determines whether it precedes ship update. The live continuation and
corrected flag/order contracts are in [rocketship-live.md](rocketship-live.md).
Offsets below are relative to the game interface (game pointer=complete+C0;
addC0 to these offsets for complete-object fields): speed608, bank614,
previous bank618, cap604, max height620,
up/down638/639, prior keyboard-bank flag63A, vertical command65C, mouse pitch66C.
The shared flying properties include acceleration5FC400, deceleration6001,
cap6041400, height620, rates624650/628−650 and velocity cap62C650. Inherited
constructor defaults are distinct from GAM reapplication and level-specific259
overrides;43DCE1 writes VR02 max height3900.
Keyboard/zero-mouse41A6C0 order:
1. Left bank +=160dt; else Right -=160dt. After keyboard release a retained
keyboard-origin bank approaches0 at130dt. Mouse-origin bank has no such return.
2. Up adds AccelRate **per callback** if below cap, then clamps cap. Without Up,
speed>cap×float32(.90909094) loses DecelRate×.5 per callback.
3. Supported state independently subtracts500dt, clamped0, even with Up held.
4. Down subtracts DecelRate×dt if supported or DecelRate×.1 in air from positive
speed; negative speed adds DecelRate toward0. Up+Down still performs this
braking, then Up clears the published Down flag. Bank clamps to±45.
Source Up/Down keys are50985E/509860, Left/Right50985D/50985F. Analog thresholds
are strictly>.5/<−.5. Right mouse509834 and accumulated mouse pitch>15 also give
Up;50993A or pitch<−15 give Down. Mouse Y accumulates×dt and moves toward the
±10 band by20dt outside it. Nonzero mouse X supplies bank delta×dt instead of
keyboard steering. Boost/barrel-roll globals and complete camera tail remain
outside the primary keyboard component; do not expose ordinary keyboard scope
as complete input support.
41A470..41A6A8 vertical publication is independently recoverable:
- speed<100 preserves prior65C and skips the height decision.
- At speed>=100, rootY>=MaxHeight clamps root only and sets command0, or DownRate
if prior Down. Below ceiling, prior Up/Down selects their respective command.
- Neutral uses−160 for Vy>0,+160 otherwise; strict−60<Vy<60 snaps Vy and command0.
- Body accelerationY becomes command−global gravity, preserving X/Z acceleration.
Existing Vy is then independently clamped±MaxVertVelocity, preserving X/Z.
UpRate/DownRate here are **acceleration commands**, despite the friend's velocity
target naming. Above-ceiling positive Vy is not immediately zeroed. No source
position integration occurs in this component beyond the direct ceiling clamp.
## Actual VR02 static scene gate
456270 constructor binds complete game table4CDD30 at4562DA and registers VR02
at456328.4563D0 is Init, not construction. Table4CDD30+134→475CD0 returnsfalse,
so shared4791C7/4791D9/NC registration has no additional VR02 game exclusion.
Resource-side material/shape inventory is in rocketship-assets.md; it does not
by itself establish flying body callbacks or dynamic actor eligibility.
## Isolated original numeric verification
Two generated32bit probes map copied EXE sections and rebase explicit guarded
global operands. The input probe executes original41A6C0 through41AC0E, replacing
mouse polling with fixed inputs, supplying synthetic support/Euler/audio virtuals,
and skipping the camera tail. The vertical probe uses a small frame thunk into
unchanged41A470..41A6A8 and synthetic body getters/setters; horizontal/animated
prefixes and integration do not execute. Neither calls the game entrypoint.
Both ran through `tools/recon/reference_capture.py` in separate generated Wine32
prefixes, with no network or original-directory mount, exiting0.
| Selected case | Original observation |
|---|---|
|Up airborne dt1/60 and dt.1|speed400 for both|
|Up supported dt1/60|391.666656|
|Up+Down airborne / supported|399.899994 /391.649994; Up true, Down false|
|Coast1400 /1200|1399.5 /1200|
|Down1000 airborne /supported|999.900024 /991.650024|
|Left+Right dt.1|bank16, Left wins|
|Prior keyboard10 /mouse10 neutral|bank0 /10|
|speed99,root5000,Vy900,command123|root5000,Vy650,command123,body acceleration923|
|Ceiling Up,root5000,Vy300|root3900,Vy300,command0,body acceleration800|
|Neutral Vy±60|retained velocity, command∓160|
|Neutral Vy±59.99|velocity0,command0,body acceleration800|
|Up /Down with gravity−800|body acceleration1450 /150|
All14 input and14 vertical cases, exact float32 inputs, tuning, observed outputs,
EXE/body/generator/probe/log hashes are in `original-input-results.json` and
`original-vertical-results.json` below `artifacts/rocket-contract/`. All vertical
cases preserve synthetic XZ velocity11/22 and acceleration33/44. Logs, compiled
probes and generated C remain there. Exporter flags `--probe-source`,
`--vertical-probe-source`, `--probe-log/--probe-executable` and vertical equivalents
reproduce the source and ingest complete logs; incomplete/duplicate cases reject.
These are isolated original arithmetic references, not original gameplay traces.
Three Python source/identity/incomplete-capture regression groups pass; both
generated probes compile with i686-w64-mingw32-gcc `-O0 -Wall -Wextra`.
## Safe implementation boundary and next gates
The primary implementation and its28 numeric comparisons are recorded in
[the component checkpoint](rocketship-component.md). Do not enable a live
Rocketship controller until:
normal horizontal Euler/slip/roll/facing and actual camera record updates are
closed; aircraft-specific body370/374/378 callbacks are composed; registry/control
handoff and retained-helper life are integrated; owned-versus-placed3ROC property
and reset timing are proven; passenger/Goddard/fire attachment and effect/audio
ownership are implemented. Collision/impact/mission sequences remain separate
gates. Do not turn this recovery into tuned nearest-rocket boarding or assume
ordinary Jimmy collision/camera matches the vehicle.
@@ -0,0 +1,59 @@
# Goddard leveling after Scooter dismount
2026-11-04. User reports that Goddard retains the dismount angle. Reproduced in
managed integration with actual VR05 steering/lean and normal selection cleanup.
The cleanup copy itself is recovered behavior; the missing later AI phase caused
pitch and roll to remain unchanged indefinitely.
## Original contract and implementation
- 4281B3..4284FB (file offsets281B3..284FB) copies vehicle root and full Euler to
the restored companion. Preserve that handoff; do not flatten at unequip.
- 4096E0..40988D (86E0..888D) is the AI game-interface facing update. It checks
gameplay gate475CA0, interface+5 enabled and+A dirty, reads current Euler224/228/
22C and destination274/278/27C, wraps each delta strictly>180 or<−180, multiplies
axis factors810/814/818 by dt, and calls334→458F90→472480. The wrapper repeats the gameplay gate. All three axes participate.
- 41C8DB..41C90C (1C8DB..1C90C) overrides Goddard's complete8D0/8D4/8D8 factors to
(.3,3.2,.3). These are interface810/814/818; the complete/game displacement isC0.
- Ordinary supported moving AI4093BD..4093D0 (93BD..93D0) calls36C with pitch0,
target yaw and roll0. Airborne and other AI branches differ; they are not added
by this fix. The prior base/facing phase consumes the preceding destination.
- 472480..472570 (72480..72570) adds Euler with the source asymmetric negative
truncation and strict>360 wrap. The existing RocketOrientation.Add reproduces
that shared leaf, including canonical360 and unusual negative-input rounding.
ActorPatrol previously changed Y alone. Its opt-in Goddard follow bridge (VR05/
LEV1) now applies the full original axis step toward its ordinary upright X/Z
follow target. Heading selection/order and non-follow lab/Carl patrol stay in
their existing bounded adapters. Disabled companions remain frozen. Cleanup
still copies the actual lean; enabled subsequent updates gradually level it.
At60Hz the.3 factor gives about22% of the original tilt after five seconds.
## Evidence and validation
Original EXE SHA256
f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8.
`tools/binary/goddard_leveling.py` guards the complete identity and records four
bounded spans/hashes/PE offsets. Committed fixture
`tests/GamePort.ScooterTests/original-leveling-reference.json` records source,
probe generator/shared harness/executable/log hashes and11 copied-original
observations. Nine active cases compare against the managed facing step: tilt,
opposite signs, seams, negative angles, exact/over180, one60Hz tick, five seconds,
and upright. Two additional native enabled/dirty gate observations remain separate
from the pure step. The synthetic probe executes copied4096E0 and472480 only,
with source Goddard factors; no original body/AI target selection/game entrypoint.
The initialized-prefix run exits0 and prints GODDARD_LEVELING_COMPLETE. An earlier
fresh-prefix15-second run did not finish startup and establishes no observations.
REA/Ghidra requests4096E0/409140 returned explicit procedure lookup failures.
Complete replies, exported bundle and closed snapshot are retained under
artifacts/scooter-dismount-followup/rea. No successful pseudocode or Evidence ID is
attributed to these failed selectors and they were not repeated. Supporting
instruction extracts and successful native numeric traces are retained alongside
that directory. This does not claim whole-original gameplay comparison.
Scooter integration adds actual tilted dismount, exact cleanup copy, gradual
next-phase decay, five-second recovery and disabled freeze, plus nine native
numeric comparisons (13 groups total). Existing10 Patrol groups still pass.
Native rendering/build/package follow-up is recorded in scooter-live.md. Native
Windows/user-visible confirmation of this correction remains separate.
+214
View File
@@ -0,0 +1,214 @@
# Live Scooter: VR05 and outside LEV1
2026-11-04. Supersedes the deferred status in [scooter.md](scooter.md).
The user requested normal outside use after the vehicle implementation. Item4
now summons an independent C3DJEEP at Goddard; walking into it mounts Jimmy.
An owned tile in the normal Tab/Space gadget panel works in both scenes. F1 →
Player → Give/Select Scooter supplies the same selection path. Up/primary fire
accelerates, Left/Right steers, Down brakes then reverses, jump queues a supported
jump, and Tab/Space unequips. There is no invented equip-energy requirement.
Other scenes retain the tile/Practice flow without enabling an unsupported body.
## Source and evidence
Authoritative EXE SHA256:
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
Original files remain untouched. The friend's source supplied leads; binary and
resource checks against this project's originals determine the contracts.
`scooter.py` retains17 spans/13 virtual bindings/10 constants; `scooter_motion.py`
adds20 bounded ranges, PE offsets, hashes and relocation operands. The committed
`tests/GamePort.ScooterTests/original-motion-reference.json` identifies source,
probe generator, generated executable and Wine log, with53 observations. Code
addresses below have file offset VA−400000, independently checked by PE mapping.
| Original VA / file offset | Caller, owner and recovered contract |
|---|---|
|4211A0 /211A0;464B90 /64B90|Jimmy Init423CE8 lazily constructs6AC-byte Jeep, stored Jimmy+A30. Complete vtable4A2F8C, game+C0 vtable4A2AEC. Radius150, support factor.2, friction.9, suppression1. Explicit464C75 sets prevent-lowering true;464C7D disables bounce.|
|4290B7 /290B7|Selection requires enabled Goddard, copies his root/Euler into vehicle, enables/shows vehicle, disables/hides companion. Selecting alone does not mount.|
|47B3E0 /7B3E0;47A430 /7A430;422F13 /22F13|Strict quick-magnitude sphere contact invokes Jimmy's interaction dispatcher422D30, identifies C3DJEEP, calls complete1E0→425120, transfers raw owner5099E4, sets rider69C, selects SCOOT.425120 only cancels mode1 jump/effect when eligible.|
|412A90 /12A90;468020 /68020|Construct four wheel children, first4 of6 pointer slots578..58C. Local positions (−3,1,73),(3,1,73),(−3,1,−30),(3,1,−30). Mutual wheel/vehicle/passenger exclusions. Wheels have no independent integration/gravity; support queries are manual.|
|465830 /65830;421C10 /21C10|Keyboard steering±200dt, cap45, Left precedence; return-to-zero latch. Rear support required for throttle/reverse. Accel700, brake1200, maximum1485, reverse−594. Down's first edge brakes; held reverse additionally waits through the source one-second timer branch. No sprint predicate.|
|465220 /65220|Counts prior child supports, applies yaw only with front contacts/horizontal motion, coasting/steer/slope terms, then full-velocity/forward mixing only with parent support and≥2 child supports. Direction sum is intentionally not renormalized. Scalar, velocity and pending impulse are distinct state.|
|421910 /21910;467000 /67000;4669F0 /669F0|Head-on contact with horizontal quick speed>20 and abs(forward·normal)≥.9 starts impact: speed/acceleration0. No bounce reflection. Four-second enabled-body state damps horizontal velocity/angular velocity, then clears them. Glancing positive-speed throttle applies source minimum230, even if it raises a slow scalar.|
|473770 /73770;412F90 /12F90;467080 /67080|Post-normal registry phase sets roll=−steering/2, manually queries each wheel's real support, clamps local suspension±15, spins from horizontal travel/radius, then synchronizes visuals. Radius23.769514 from OMT shape1 header. Wheels do not fabricate support from the parent.|
|476FF0 /76FF0;466AF0 /66AF0;473320 /73320|Stored support normal→signed14-bit angle components→yaw-rotated pitch/roll. The target yaw is overwritten with live yaw. Source full AddEuler normalizes all axes during drive. Facing uses shortest delta, rate*dt and strict small-step snap. No contacts selects pitch340/rate2; unmounted sets rate10.|
|421580 /21580|Mounted jump latch queues Y700; float pose clock strictly exceeds double.3 before selecting SCOOTSTOP for signed speed<10, otherwise SCOOT. Jimmy copies root/Euler before the later wheel/lean phase.|
|4130A0 /130A0|Default mode1 eye uses rotated(−30,0,−200)+worldY50, quick-distance gains1/1.7/2.8, smoothing before clipping, new-eye quantized aim toward rotated(0,50,100). Impact retains eyeY, approaches rootXZ at.3dt and aims at root.413870 explicitly passes edges=false.|
|413852 /13852;47B4B0 /7B4B0|Camera resets nearest face distance130000 only, inherits edge/contact state, clips from vehicle root with cube75's sphere radius64.9519043. Ordinary body initializes its own sphere context; no invented camera sweep.|
|412ED0 /12ED0|Enabled/visible vehicle starts loop SFX46 and retains base sample frequency. Pitch=max(7000,trunc(base+signedSpeed*(1/1.9)*51)). Parked vehicle also sounds; cleanup stops it.|
|4281B3 /281B3;457FF7 /57FF7|Selected cleanup restores eligible Goddard at vehicle root/Euler, disables/hides vehicle, stops engine. Mounted branch restores Jimmy raw control, raises root40, clears acceleration/live velocity, preserves movement mode/pending impulse. RETURN explicitly invokes cleanup before requesting transition.|
Vehicle complete offsets:600/602/604 front/rear/total support WORDs;610/618/620/
628 acceleration/brake/base/current maximum;61C prior scalar;63C angle;640 yaw
rate;648 brake timer;64C impact timer;650/654 camera modes;658/659 throttle/brake;
65C impact;65D/65F keyboard/reverse latch;690/694 engine channel/base frequency;
698 jump latch;69C rider;6A0 pose clock. Full source structures remain partial.
REA/Ghidra12.1.4 evidence is retained under artifacts/scooter-{wheels,assets,
lifecycle,motion}-live, including complete replies, exports and closed snapshots.
Important Evidence IDs:
-465220 `ev_09ecf350c8705d5f9c1da5b444eb8cd027f64f4859713b29c9d04bc4c55c2bc8`;
465830 `ev_dbb6ac283387e14f08d527a750c14af44c52ed80c612c40393a5434a16589916`.
-467080 `ev_3e6bc2c29886888f3d70087b38b7a8b933d70394908f0328e1a3032a39cd9077`;
468020 `ev_2bbed17bcf63926b0ed8202ebf6d7320bf49ddb5bc4427a541c2bff4e448e84b`;
4682A0 `ev_f083ee63317f9d4d999b16da31c770e0f5c0517caebf73ba53e8769bc4ee7699`.
-4213F0 `ev_4ef0cec31d2f339f8e10213acabaa71f0fee3f7c6c96f278f691947616dbaa22`;
422AC0 `ev_a689f8970de2072f0e2b18babfa9f20c9aa9824a37acdb76c158218d4b85d992`;
477550 `ev_d44b004b6fe8045d4f9592712cda51bcb3cfb331d58980493bd7ced707d68150`.
-476FF0 `ev_9d38be2acca1063e7d91783adc0e928f9f9128cfb9031e258eaa51e94f0adfa1`;
467990 `ev_c4db605fd549572edcee03e01e5c0026ba856ad5ad0016678fd1ca2902e5610b`.
Some selectors, including4130A0/422D30/466AF0, were not recognized as complete
procedures. Saved instructions and callers fill those bounded gaps; no successful
decompilation is attributed to them. x87 aliases in465220/476FF0 are unreliable;
assembly plus copied-original numeric execution resolves arithmetic. No unchanged
failed selector was retried. Profile identity and exact metadata remain in the
saved REA bundles.
## Implementation and ownership
`Scooter` owns vehicle body, previous wheel contacts, input latches, impact/pose
clocks and shared-camera history. `ScooterMotion`, `ScooterWheels` and
`ScooterCamera` isolate the recovered formulas. `PlayerSceneBinding` steps body
before input, tests contact after Jimmy's independent physics, transfers ownership,
steps vehicle frame, copies passenger transform, then steps wheel phase. Fresh/
retained input order follows the existing player registration-order switch.
Raw control loss alone does not teardown; named-Jimmy CAM/MCA/RETURN cleanup does.
`SceneInteractions` accepts vehicle-owned pickups and coincident Jimmy LOAD, with
separate radii150/60. Excluded wheel/passenger pair callbacks are not dispatched.
General dynamic pair discovery remains unimplemented. Provisional moving-door
response is an explicitly inherited modern adapter.
Source PostLoad41E0F9 places active-follow Goddard250 behind Jimmy when a ray is
clear; retained STRT placement4239EC and RETURN423AE3 remain separate source paths.
The port creates the owned companion in VR05/LEV1 before runtime bindings and uses
behind250 or STRT fallback. Its opt-in state4 follow subset uses408E40/408BC0
velocity/arrival hysteresis and41E303 speed450/600 plus far warp1500→behind800.
It retains the existing provisional NPC body and heading/animation bridge; this
is not full Goddard AI. Lab patrol behavior is unchanged. Modern R reset releases
selection, clears vehicle state and restores the companion near the start. F3
releases it before noclip. Modern scene teardown disposes the engine before audio.
Vehicle/wheel allocation is scene-local; arbitrary non-RETURN persistence and
full retained-source reconstruction are unresolved, not silently claimed exact.
`ScooterVisuals` uses source-pivot, unit-scale scooter.omt shape0 and four shape1
wheels. Null-material faces remain undrawn (DLL1003756C), rather than invented
white caps. Exact original canvases are exported. HISCOOT and HISCOOTSTOP bind
jimscooter/Jimscooterstop morphs, with jimstop topology and original opaque Jimmy
atlas; the rider uses the Euler copied before wheel lean. godscooter.ASE is a
separate Goddard transformation resource, not the active vehicle shape.421535→
477550 makes the source shape unlit; there is no impact scale change.
## Verification and unresolved questions
-53 copied-original Wine32 component observations match managed formulas:22 drive,
9 input,8 normal→Euler (unused output yaw excluded),3 facing,7 wall and4 impact.
Harness supplies synthetic base actor/camera/audio/wheel support and original
OMT vector/trig. It never runs the original game entrypoint. Source quarter-turn
table sin=1/cos=0 is observed, explaining exact cardinal terrain endpoints.
-11 managed integration groups use real VR05/LEV1 data: ordinary outside tile,
summon/contact mount, body/wheels, drive/steer/brake/jump/no energy debit,
actual front-door wall and four-second recovery, default/impact camera math,
dismount40/companion/audio, named cleanup/noclip/reset, actual RETURN and visual
repeat/hide, plus follow/freeze/warp/reset of the companion. Front-door +Z driving hits the house steps, correctly entering impact.
-The original OMT cube probe observed75→bounds±37.5/radius64.9519043 with false
flag before a later unrelated true-flag call faulted. That diagnostic run was
not a clean complete camera probe; full camera execution is not claimed.
-Source guards and exact-resource exporter checks run through scripts/test.sh.
Runtime replay/build/package results are recorded below after verification.
Remaining: original whole-game comparison and native Windows play; mouse/analog
input and camera modes2..20; special cutscene camera helpers; scene-wide shared
collision globals including Jimmy/vehicle/other body ordering; general dynamic
pairs, mission/hazard callbacks and other levels; exact Goddard body/animation;
full retained vehicle/wheel/helper lifetime and save/load; render/cadence/pivot
parity. Jimmy's lab/outside capsule remains parked; Scooter uses its independent
source static body and does not bypass special Jimmy policies. Fixed60Hz and
modern wide UI are explicit port policies. Dummy audio verifies transport and
lifecycle, not speakers or audible pitch quality.
## Port replay evidence
Headless llvmpipe1280×720 and native Linux GTX1070/private Xvfb1920×1080
pass10 render phases in both VR05 and LEV1: summon, contact mount, drive, steer,
brake/jump, dismount, remount, named cleanup, noclip and reset. All seven injected
SDL keys are received; Vulkan validation is enabled with zero errors. The outside
replay explicitly uses authored school1 and turns away from obstacles; front-door
head-on behavior is covered separately by the actual-geometry managed test.
248 extra player/vehicle/interactions/director ticks reuse received input, without
root/speed/timer seeding. Companion/patrol and HUD clocks are not included in those
extra fixture ticks; this is not a source cadence or manual tutorial-completion
claim. Final native R exercises the real reset command; the headless fixture calls
the bounded reset helpers directly. Logs: artifacts/scooter-{vr05,outside}{,-window}.log;
stage captures share those prefixes. Images were inspected, including source
rider/body/wheels and the full32-row2560×1080 Player page.
From GamePort, `source scripts/env.sh`, then:
```
dotnet run --project tests/GamePort.ScooterTests
dotnet run -- --scene artifacts/extracted/VR05/scene.json --level gam/VR05.gam \
--smoke-scooter --headless --screenshot artifacts/scooter-check.ppm
dotnet run --no-build -- --scene artifacts/extracted/level1/scene.json \
--level gam/level1.gam --start school1 --smoke-scooter --headless
```
For native SDL replay omit --headless and add `--width 1920 --height 1080`. Set SDL_AUDIODRIVER=dummy only when hardware output is
unavailable. The audio replay executes SDL frequency-ratio calls and cleanup;
audible behavior and native Windows playback remain unverified.
Final regression: scripts/test.sh exits0 (artifacts/scooter-final-tests.log):303
Python tests plus2 separate HUD checks, all managed suites,36 main GPU completions
with zero enabled Vulkan validation errors,17 material readback checks, route/
checkpoint/transition/animation and SDL dummy audio checks. All539 originals
verify unchanged. The later companion-active guard and first-engine-frame frequency
ordering were verified by the final11-group Scooter and10-group Patrol runs;
source guards and final .NET10 build pass. The build retains the existing NU1900
unavailable vulnerability-metadata warning; there are no compilation errors.
Native Windows runtime and original whole-game comparison are still pending.
## Packaged checkpoint
Both self-contained platform packages identify clean runtime commit
`62c07a3d59ca6d71a7456957d8586c268d27c439` with source_dirty=no. Packaging log:
artifacts/scooter-package.log. The local cached-dependency publish used
NuGetAudit=false. All14 Scooter resource files match the prepared originals in
both packages; binary identities are retained in artifacts/scooter-package-identity.json.
The packaged Linux apphost runs from /tmp with DOTNET_ROOT, DOTNET_CLI_HOME and
NUGET_PACKAGES unset and uses only its packaged asset paths. Both native1920×1080
SDL replays pass10 phases and all keys, with enabled Vulkan validation/zero errors.
Logs: artifacts/scooter-package-{vr05,outside}.log. All20 stage readbacks match the
development/native captures byte-for-byte; artifacts/scooter-package-readbacks.json.
The final post-package audit verifies all539 originals unchanged. The Windows
package was cross-published and its resources checked; native Windows execution,
audible quality and whole-original comparison remain pending. Validation notes
are copied into each package; BUILD-INFO.txt separately identifies their commit.
## User feedback: pitch and angled dismount
The follow-up fixes the missing consumers rather than changing the original
handoff: Goddard keeps the source copied Euler at release, then his enabled
follow update gradually levels X/Z with source.3 axis factors. ScooterAudio
applies recovered positional frequency/history after the nominal engine command,
using the shared listener (including script and parked Jimmy camera). The nominal
pitch ramp already matches the original.11 new original facing traces and11
frequency traces are retained separately from the earlier53 drive observations.
13 Scooter,2 audio,10 Patrol and24 targeted Python groups pass, as do lab/
underground navigation and SDL dummy audio regressions. Native Linux GTX1070
1920×1080 replays pass both10-phase scenes with zero enabled validation errors.
The sound correction is slight; audible/native Windows comparison is still open.
See [leveling](scooter-dismount-leveling.md) and [pitch](scooter-pitch.md) for the
source/evidence, phase boundaries and limits.
Follow-up packages identify clean runtime commit
`fccc0b9d1b6ae962d32147e4ae1433fce6a1a23e`; both self-contained publishes pass.
Log: artifacts/scooter-fixes-package.log. All14 Scooter resource files match in
both platform packages; binary identities are in scooter-fixes-package-identity.json.
Standalone Linux from /tmp with SDK variables unset passes both10-phase native
SDL replays, with zero enabled Vulkan validation errors. All20 native readbacks
match development byte-for-byte (scooter-fixes-package-readbacks.json). Logs:
artifacts/scooter-fixes-package-{vr05,outside}.log. All539 originals verify
unchanged after packaging. Windows cross-build/resource validation is distinct
from the pending native Windows and audible comparison.
+86
View File
@@ -0,0 +1,86 @@
# Scooter pitch: engine command and positional channel update
2026-11-04. User reported that engine sound rises too high. The existing engine
formula is supported by the original instructions; the directly evidenced missing
step is the separate positional channel update. No invented Scooter pitch ceiling
or reduced acceleration/speed is introduced.
## Recovered source
EXE SHA256 `f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`;
OMT2.dll SHA256 `3ec41ead011adf56387a6dbd4580e5b5a9721b5f8020c8a56420f42824354943`.
`tools/binary/scooter_pitch.py` checks both identities, four bounded code ranges
and three constants, with independently mapped PE offsets. For the listed EXE
code, file offset=VA−400000; DLL code offset=VA−10000000.
| Original location / offset | Contract |
|---|---|
|412ED0 /12ED0;412F2D..412F60 /12F2D..12F60|Jeep's engine update calls game268→471B50 to read scalar speed, multiplies double495310=0.5263157894736842 then double495308=51, adds captured complete694 base frequency, truncates toward zero, floors at7000, writes channel command695E3C. Engine channel is complete690. First frame starts SFX46 and captures base without the later-frame pitch update.|
|47D5DB /7D5DB;47D6E0 /7D6E0|Positional channel creation initializes frequency command695E3C to11025 and enables frequency adjustment byte695E1C. This matches Scooter's original Wave46 sample rate11025; WAV extraction is not resampling it.|
|47D5CB /7D5CB;47D5EE /7D5EE|Store initial emitter/listener distance into history695F84, then invoke positional update47D9D0. At nonzero initial distance this first update writes nominal frequency and replaces history with integer0.|
|47D9D0 /7D9D0;47DA0C..47DA7E /7DA0C..7DA7E|Read emitter root through310 and listener viewport509A50 eye+44/+48/+4C; compute original quick magnitude. Zero distance returns before frequency/history update.|
|47DBB1..47DC1D /7DBB1..7DC1D|When adjustment enabled, correction=trunc((distance−history)*float.75). If distance>history, apply nominal−correction; otherwise nominal+correction. Thus the ordinary finite correction lowers pitch in both directions. The final FILD/FSTP stores the signed integer correction into history, **not distance**. This unusual source behavior is independently executed below.|
|47D8F0 /7D8F0|Global sound update enumerates active channels and calls47D9D0. Source callers include44DF9A and47E57A. Its cadence relative to vehicle and render registry is a separate global scheduling contract.|
|DLL1003BBA0..1003BBF9 /3BBA0..3BBF9|OMediaDXSoundChannel::set_frequency stores requested unsigned Hz, clamps nonzero values to100..100000 with a native buffer, and forwards to DirectSound slot44. Zero means source frequency. There is no lower hidden Scooter-specific maximum.|
Existing REA/Ghidra12.1.4 engine evidence:
`ev_0001ffbd4f35880bb9fe9c53985f1953f475984404b5be77753031e07a77bfca`
under artifacts/scooter-lifecycle-live/rea-camera. Its pseudocode loses x87
frequency producers; the saved sound.asm and constant bytes establish the formula.
New REA evidence, exported with closed snapshots under artifacts/scooter-pitch:
- 47D9D0: `ev_1b042ef49ef4615de500303bde18eb9da879d00a2e8ae9dfde76cfdfb31a2ec6`
in rea-position/evidence.json. The decompiler aliases x87/local values incorrectly;
instruction47DBFC and47DC11 establish which integer is published to history.
- DLL1003BBA0: `ev_7439bef8e2bb303a2acba66af75a3513ab2ea007ebdb187732b9c7d4ab6cfe6c`
in rea-dll/evidence.json.
- DLL100EFF20: `ev_6cdab21683335bcecdc6e96aa42b96b63456cfa1ab02b64a283b07f91dc46a15`;
shared inherited no-op export, not the active DX setter.
The MCP session reported GHIDRA_INSTALL_DIR unset. The established local
scripts/rea.sh launcher has the configured Ghidra/JDK, so new analysis used that
CLI with copied targets. No MCP registration/configuration was changed. No target
entrypoint was executed during static analysis.
## Implementation and verification
`ScooterAudio` owns per-channel history and last applied device frequency. Its
EngineFrequency preserves the original scalar slope/floor. Frequency applies the
positional correction using emitter root and current rendered listener eye, then
DX's unsigned/nonzero bounds; zero-distance calls retain applied Hz/history.
Reset runs when a new engine stream starts. SDL maps resulting Hz to the original
WAV input rate through SDL_SetAudioStreamFrequencyRatio; local SDL_audio.h confirms
higher ratio raises pitch. No cumulative multiplication or input-rate inversion
was found in SdlAudio/SceneAudio.
A copied-original47D9D0 harness uses synthetic actor/engine/channel/camera and
original OMT quick-magnitude/trig exports; no game entrypoint, sound playback or
DirectSound hardware is invoked. Eleven cases execute successfully in isolated
Wine32, including zero-distance early return, positive and negative signed history,
constant-distance recurrence, fractional truncation, reverse floor ordering and
maximum-speed command. Native Wine exit0/capture success are saved under
artifacts/scooter-pitch/probe. The committed reference fixture identifies source,
generator, shared map helper, generated EXE and original-output log by hash.
Examples: nominal50885 at distance800/history0 applies50285 and stores600; next
same-distance update applies50735 and stores150. Reverse nominal7000 at distance500
applies6625: the7000 floor precedes positional adjustment and must not be repeated.
Source positional update does not modify nominal command695E3C.
Two Python groups guard source/provenance and eleven native cases. Two managed
ScooterAudio groups match those eleven observations and verify engine arithmetic,
stream-reset history, zero-distance device retention and reverse ordering.
Integration API: create a scene-local ScooterAudio; on EngineStarted call Reset
before starting SFX46. On EngineSpeedChanged pass Frequency(baseHz,speed,vehicle.Root,
listenerEye) to SceneAudio.TuneLoop. Use the actual shared listener, including
scripted eye and Jimmy eye when parked; summon-time Scooter.CameraEye alone is
stale for parked engine sound.
Boundaries: this is the recovered engine+frequency path, not complete positional
volume/pan, channel allocation/bank failure handling or exact scene-wide47D8F0
scheduling. Applying once per engine-frame update is a bounded port composition.
Native original audible comparison, speaker quality and native Windows playback
remain unverified. The correction lowers pitch slightly; static/source-component
evidence does not establish that every perceived pitch difference is resolved.
+207
View File
@@ -0,0 +1,207 @@
# Scooter: original static checkpoint (historical)
Current implementation and corrected contracts: [scooter-live.md](scooter-live.md).
The following records the earlier evidence boundary.
2026-11-02. Static source recovery only; **no live Scooter implementation or
original gameplay verification**. User parked broad collision. Scooter cannot
faithfully reuse only Jimmy's current body: original drive/steering depends on
separately constructed wheel children. Primary was advised before runtime work
and selected another gadget for the next implementation slice.
Original EXE SHA-256
`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`.
`tools/binary/scooter.py` guards17 complete bounded spans,13 virtual bindings,
10 constants,4 strings and the always-false sprint predicate. Generated ledger
`artifacts/scooter-contract/source-contract.json` contains exact VAs, PE offsets,
lengths and hashes. For every code VA in this report, file offset is VA−400000.
Data/table addresses must use the ledger's PE reader; do not assume this identity
for an arbitrary PE. Supplementary instructions are in the same artifact directory.
## REA evidence and coverage
Local `scripts/rea.sh`/Ghidra12.1.4 analyzed the generated copy
`artifacts/uncontrolled-phases/rea/Neutron.exe`; originals were not executed.
`rea-vehicle/01.json` recovered465220 with Evidence
`ev_09ecf350c8705d5f9c1da5b444eb8cd027f64f4859713b29c9d04bc4c55c2bc8`;
`02.json` recovered465830 with Evidence
`ev_dbb6ac283387e14f08d527a750c14af44c52ed80c612c40393a5434a16589916`.
Profile digest is
`e1ad533d4cc0333c2136fe0894217de2d61feea098240326e78633f9e4ddcbf9`.
Complete bundle and closed snapshot are retained.465220 pseudocode contains
incorrect float/pointer/local aliases and loses some x87 scalar producers;
the guarded instructions resolve the gates and arithmetic cited below.
421580 and412A90 returned explicit procedure-lookup/unmapped-file-offset
provider errors. Initial exploratory437F90/43A120 (Jimmy routines, subsequently
excluded from Scooter) also failed; `rea-native/` retains failures, empty export
and closed snapshot. No unchanged failed request was repeated. The first
sandboxed `rea-equip/` attempt saved only successful target-open metadata and no
pseudocode/Evidence or closed snapshot before its worker ended; no success is
attributed to it. Local static IPC allowance resolved the host restriction for
the later complete batches without changing client configuration.
## Actor, construction and selection
Inventory item4/raw mode4 is Scooter. Movement mode is a **separate vehicle
state**, not Jimmy movementmode3. C3DJEEP constructor4211A0 calls412870→464B90;
complete vtable4A2F8C, game interface+C0/vtable4A2AEC.4213F0 loads
`omt\\scooter.omt` (string4EEF2C). Radius is150 at42128E via game110→471240;
inherited factor is float.2 at412942 via4711E0. These are distinct from body
friction; do not replace friction with.2.
Jimmy game initialization423CE8..423DC1 lazily allocates6AC bytes, constructs
4211A0, and stores complete actor at Jimmy+A30 (game+970). Complete168→412A90
receives `(73,-30,3,3,1,true,true)` at423D58..75.412A90 constructs **four**
C3D wheel actors through type33574845/459CB0 into the first4 of6 pointer slots
complete578..58C and stores relative offsets in complete5A0+16*i. It also adds
mutual collision exclusions3A8. The slots are initialized null in464C9A..BC.
Thus the last2 generally remain absent in this constructor path; support code
still scans6. Wheel collision/body scheduling and wheel-type implementation are
not closed by this investigation.
Panel4278D7 already closes and invokes Jimmy cleanup178 before174(4), as in
[gadget-controls](gadget-controls.md). Item4 leaf4290B7 requires Jimmy+A1C
companion. It hides companion+994 via58(true), requires companion gameCC true,
sets raw4, copies companion root310/Euler328 into vehicle via16C/174, hides
vehicle and children through complete174→421800, enables vehicle gameD0/214,
then hides/disables companion gameD0/214. **This does not mount Jimmy or change
controlled pointer directly.** Failed companion gates still continue to practice
handling429297. Armed practice switches item9 to1 and loads VR05. Do not add an
energy requirement: the reviewed equip leaf has none.
Mount is a later Jimmy interaction callback:422F13..422FB9 recognizes target
`C3DJEEP`, invokes Jimmy complete1E0, calls game118(vehicle game interface),
stores Jimmy complete pointer into vehicle69C, hides Jimmy+A2C, adds Jimmy's
vehicle collision exclusion3A8, selects `SCOOT` with E0(...,true), then refresh148.
The callback's full interaction eligibility/caller and complete1E0 effect remain
separate gates. Merely selecting the tile must not fabricate a mount event.
## Fields, input and apply
Offsets here are **vehicle complete object** unless explicitly marked game.
| Offset | Source owner |
| --- | --- |
|578..58C|6 child pointer slots;4 populated by this setup|
|600/602/604|signed WORD front2/rear4/total child support counts|
|610/618/620/628|acceleration700/deceleration1200/base maximum2250/current maximum1485|
|61C|previous source scalar speed|
|63C/640|steering wheel angle/applied yaw rate|
|658/659|throttle/braking flags|
|65D/65F|keyboard-turn/reverse-held latch|
|650/654|camera mode/previous camera mode|
|690/694|engine channel/base sample frequency|
|698/69C/6A0|jump edge latch/mounted Jimmy pointer/animation clock|
464F60(100), called by base constructor, sets acceleration=100+600,
deceleration1200, base maximum=100*4.5+1800=2250 and default maximum=base*.66.
Vehicle game268/26C get/set scalar speed. Complete130→413A60 always returns false
in C3DJEEP, so the inherited sprint branch is inactive and normal maximum is
float1485. Mouse, controller and inherited AI/camera paths are not included in
the pure keyboard projection.
Input421880 rejects407060 true,475CA0 false or open gadget panel. Primary fire
509834 sets global4F8182; input then delegates465830. That input first copies
current scalar speed into61C, clears analog throttle/brake flags and fetches
mouse axes through completeF8. With mouseX0, keyboard Left precedes Right,
adds/subtracts200dt to angle63C and sets keyboard-turn latch. With no turn key,
that latch permits return toward0 by200dt, clamped at crossing. Angle caps±45.
Nonzero mouseX uses2*dt*mouseX and clears keyboard-turn latch; inherited return
does not necessarily continue after mouse release. Left/Right also accept
analogX<−.5/>.5 through421C10/40.
Forward predicate421C70 requires rear support count602>0 plus Up, primary fire,
controller button509AC4 or analogY>.5. It adds acceleration700dt while below
maximum and clamps there; at/above maximum normal no-sprint branch preserves
speed. Backward421CB0 also requires602>0 and supports Down/analogY<−.5, with
the source primary-fire/controller qualifications retained in instructions.
First accepted backward call sets reverse latch: positive speed subtracts1200dt
and clamps0; negative speed adds1200dt and clamps0. Subsequent held calls
subtract1200dt, allowing reverse down to−currentMaximum*.4 (about−594).
Braking flag659 persists through the continued-held path; release clears both
braking and reverse latch. Forward executes before backward. These are dt-based
vehicle increments, unlike Jimmy's fixed-per-callback Bubble throttle.
Apply421580 calls412ED0→465220, which calls462520 first, then requires475CA0
and game210. It scans actual nonnull children and their game218, recomputing
600/602/604. Steering requires nonzero incoming horizontal live velocity and
front count600>0. Scalar speed gives scale=min(horizontalMagnitude*.005,1);
ordinary yaw rate640=frontCount*angle63C*scale (inherited AI uses2 instead).
The dot between normalized horizontal velocity and rotated local forward
chooses forward/reverse yaw sign; yaw increment is rate*dt.
The drive-velocity rewrite at465594 requires **vehicle game218 AND total child
support604>=2**. Missing/unsupported children do not imply support. Unsupported
vehicle still publishes scalar speed but does not execute that rewrite.
Supported scalar decay/turn drag/slope terms, normalized live/forward direction
mixing and friction can change speed and velocity; the whole465220 span and
Evidence are retained but no full numerical drive projection is claimed. The
`drive_eligible` helper tests only its recovered eligibility gate. Jimmy's
ordinary application formula is not equivalent to this routine.
## Mounted update, animation, sound and cleanup
After vehicle apply,421580 with mounted69C calls Jimmy complete1AC(dt), handles
the five standard jump inputs and copies vehicle root/Euler into Jimmy. Jump
uses its own edge latch698: release clears it; held with latchfalse and vehicle
support queues `(0,700,0)` through game28C, then sets latch. Airborne hold does
not latch, so support can accept it later. This is pending velocity/impulse state,
not an immediate Y700 live-velocity assignment. No mounted pointer takes a
different stop/reset path421794; it does not run mounted jump/pose updates.
Animation timer6A0 stores float(timer+dt), compares to **double.3**, and when
greater selects Jimmy `SCOOTSTOP` for signed scalar speed<10, otherwise `SCOOT`,
both E0(...,true), then clears timer. Reverse speed therefore chooses stop at
this site. float32(.3) is already greater than double.3. Do not replace the
threshold with.3f equality. No Goddard195-vertex morph binding was proven;
[asset inspection](gadget-assets.md) and vehicle asset export retain that gap.
412ED0 starts positional looping SFX46 (`Scooter`) through4589C0 when vehicle
gameCC and audio global696008 are true and engine channel690 is−1. It captures
channel base frequency in694; later frames write a speed-dependent frequency,
minimum7000. No direct energy debit42A920 was found in the reviewed equip,
vehicle input/apply/update spans. This bounded result does not prove global
energy policy for every interaction/caller.
Cleanup178 raw4 jumps4281B3. If companion absent or companion gameCC already
true it proceeds to common raw−1 return42882F without the full vehicle teardown.
Otherwise it clears menu4B4, writes JimmyA20=.5 (consumer remains unknown),
copies vehicle root/Euler back to companion, shows/enables companion D0/214,
resets42AE90 clocks, removes Jimmy vehicle exclusion3B0, exposes vehicle children
through completeD8→464F00, disables vehicle D0/214, destroys retained helper via
complete164, stops engine690 and clears it−1. If mounted69C nonnull it additionally
clears Jimmy action latch1E25 and4F8182, restores game118(Jimmy interface), raises
Jimmy rootY by constant49FAD4, clears acceleration278/live velocity2C4, requests
`RUN`4ECA64, exposes Jimmy+A2C (unless509A13), and finally clears vehicle69C.
Every completed return sets raw−1. The exact elevation constant is intentionally
left in guarded source pending the full dismount/body policy; no new cleanup
Euler blend or Jimmy movement-mode reset was inferred.
## Camera and implementation boundary
Vehicle camera completeEC→4130A0 runs at the end of465830; it uses camera
mode650, previous654, global eye509A50, vehicle rotations/speed and native
collision clipping. Default mode1 is set in464D1F and its source branch begins
413234; Down/reverse and camera-mode inputs remain separate concepts. Full
camera branch arithmetic/obstruction ownership is unresolved, and using Jimmy
camera439900 for Scooter would be a declared approximation. There is no proven
complete camera contract here merely because source is retained.
Practical next slice, in order:
1. Close C3D wheel child transforms, support/contact scheduling, source body
properties and static VR05 eligibility; preserve actual4-child constructor.
2. Add distinct registered Scooter actor, spawned/mounted/control-owner state,
child exclusions, mount eligibility and atomic cleanup handoff.
3. Port465830 keyboard and465220 full arithmetic with regression projections,
then jump/pose/SFX46/camera. Preserve scalar/live/pending state separation.
4. Compare original mount/drive/jump/reverse/dismount runtime before claiming
faithful playability. Native Windows comparison remains unverified.
These dependencies make a movement-only Jimmy flag insufficient. Broad collision
remains parked; no runtime source was edited by this investigator. Nine Python
groups pass: identity/span/binding guards, spawn-vs-mount, real support gating,
steering caps/release, rear-support throttle, brake/reverse ordering, jump edge,
animation float/double boundary and bounded inputs. They validate source
projections, not original execution or port vehicle behavior.
+97
View File
@@ -0,0 +1,97 @@
# Scooter / Rocketship resource contract
2026-11-02. Read-only original asset inspection. No original executable was run
and no original file was modified. Source binding recovery belongs to
`scooter_contract`; geometry/sample/pixel observations here do not establish
attachment, steering, visibility, sound ownership or interpolation policy.
`tools/extractors/scooter_resources.py` exposes `export_scooter(original, output)`.
Its schema1 `scooter.json` references two independent original OMT shape scenes,
Jimmy's two renderable Scooter animation manifests, and the two unbound Goddard
Scooter source morphs. It checks original hashes before output, rejects original
subtrees/ancestors and existing descendant symlinks, and uses portable
case-insensitive asset lookup. Original PNG pixels and OMT canvas alpha are kept.
```bash
python3 tools/extractors/scooter_resources.py ../Original --output artifacts/vehicle-assets/scooter
python3 -m unittest discover -s tests -p test_scooter_resources.py -v
```
Five checks pass: shape/material/pixel identity, exact Jimmy base topology and
sample positions, preserved unbound source times/absent UVs, source/output
protection and changed-source rejection before output. Generated inspection data
is `artifacts/vehicle-assets/inventory.json`; generated resources are under
`artifacts/vehicle-assets/scooter/`. No shared prepare/runtime files were edited.
## Usable Scooter geometry
Archive `omt/scooter.omt` SHA256
`8d4ffdafee5fd819c5220ee4f608c901a5988fe6b8b13316e15618f5eec75e81`.
| Original resource | Offset / bytes | Geometry / exact texture link |
| --- | --- | --- |
|3DSh0 `goddard01`|104 /19342|98 indexed vertices,176 triangles; material0|
|3DSh1 `wheel`|92304 /5814|32 indexed vertices,56 triangles; material1 plus null-material polygons|
|3DMa0 `goddard128`|19446 /52|Canv1|
|3DMa1 `scooterwheel2`|19498 /52|Canv0|
|Canv0 `scooterwheel2`|22568 /3966|32×32, RGBA SHA256 `92dfef71def8079db70ba4eaa47e973d45a0b3987418e87dbf65cc3cf0bf823b`|
|Canv1 `goddard128`|26534 /65770|128×128, RGBA SHA256 `b22651171a7b9f2c99831a1ff4fd8d01d11ccabfc276d71dd91bacd710cd1cba`|
This corrects the ambiguous material/canvas ordering in gadget-assets.md:
body material0 points to **canvas1**, wheel material1 to **canvas0**.
Each shape gets a separate `shape_ID/scene.json` compatible with the existing
OMT scene loader, expanded source positions, source normals/materials/UVs,
transitively referenced decoded canvas and provenance. Null wheel materials stay
null (`material:-1`), rather than receiving an invented visible material.
Neither shape is translated, scaled or instanced by this exporter. Runtime must
use the separately recovered original body/wheel attachment contract.
## Morph compatibility
| Original ASE | Indexed vertices / faces | Sample times | fps / ticks per frame | Available base |
| --- | --- | --- | --- | --- |
|jimscooter|426 /814|0,480|10 /480|jimstop426; base supplies original UV/topology|
|jimscooterstop|426 /814|0,480|10 /480|jimstop426; base supplies original UV/topology|
|godscooter|195 /370|0,161|30 /160|none recovered|
|godscooter2|195 /370|0,161|30 /160|none recovered|
|godrocket|222 /411|0,960,1920|5 /960|count-compatible godpoint222, binding separate|
|jimdrive|426 /814|0,480|10 /480|count-compatible jimstop426, binding separate|
Jimmy exports use the existing `export_ase` family format and exact original
`png/jimycarl.png` (SHA256
`55ed165aaffe177cb62558a08d13fc3b2210da6e353065b108849d46df9dacb6`).
Each animation is source-named, with relative `../jimycarl.rgba` texture and
two expanded geometry frames. No family action names or playback times are
assigned. Existing `prepare_actor` can express these Jimmy clips directly.
Flat reconstructed ASE normals remain the existing exporter limitation.
Both Scooter dog morphs have **no UV tables**. Their195 positions differ from
both OMT body98 and the existing Goddard godpoint222 base. Existing morph export
correctly rejects these combinations. `godscooter-unbound.json` and
`godscooter2-unbound.json` preserve all parsed positions/faces and exact sample
times, without fabricated UVs or rendering them as a valid actor. The second
sample's161 ticks is intentionally retained, not rounded to160. Material-list
filenames include many unrelated scene leftovers; these do not prove binding.
## Rocketship and Baseball boundary
`godrocket.ASE` lacks UVs but has222 vertices/411 faces, the same count as
`godpoint.ASE` (textured high-detail Goddard base). This permits existing actor
export mechanics *if* binary binding establishes that base. It does not justify
claiming the gadget renders that clip. `jimdrive.ASE` similarly has426 positions
and no UVs. `rocket.ASE` is a separate textured16-vertex/22-face mesh (one sample,
5fps/960 ticks), and `rocketfire.ASE` has4 vertices/3 faces at0/960/1920 with UVs.
The material texts mention rocket.bmp/fire.png; no Rocketship gadget attachment
is inferred. `objects.omt` contains3DSh26 `rocketship`135 vertices/236 polygons;
that name also does not close the gadget's resource binding.
No baseball-named ASE or PNG was found by bounded filename search. This does not
establish that the source lacks a ball asset. The separate Baseball investigation
has recovered constructor40FC50 using RetainedSprites.omt Canv2 at sprite size25;
25 is not a shape ID. Exact resources and TIME font are in `baseball-assets.md`
and `baseball-font.md`. Original HUD/control/sound identity
is already inventoried in `gadget-assets.md` and should not be duplicated.
Static asset extraction and the five Python checks are verified. Gadget rendering,
wheel motion, source animation timing, original execution comparison and native
Windows behavior remain unverified.
+59
View File
@@ -0,0 +1,59 @@
# Orbit camera handedness correction
Follow-up: the user clarified that the remaining issue was inverted Left/Right
input; Up/Down was correct. Orbit Left/A now increases azimuth, Right/D decreases
it, matching the corrected view. Elevation, projection and gameplay controls
are unchanged. This is a two-line modern input mapping correction.
Both executables republished from clean70cba65 using the unchanged verified
packaged assets. Standalone native Linux GTX1070/private Xvfb input/resize smoke
passes with enabled Vulkan validation and zero errors; evidence is
artifacts/orbit-camera/horizontal-{build-linux.log,build-windows.log,native.log}.
Native Windows runtime testing remains pending.
2026-11-03. User reports the world flips when using orbit inspection.
This is a modern camera bug; no new original-binary interpretation is needed.
## Cause and correction
Program used System.Numerics CreateLookAt/CreatePerspectiveFieldOfView for
inspection, both right-handed. Gameplay and source geometry use positive-Z
left-handed camera space. At the same eye/target/up, swapping the paired view
and perspective conventions reverses screen X. The old orbit view therefore
mirrored the world relative to gameplay. Vulkan's shared M22 viewport flip is
still required for screen Y; removing that would introduce another inversion.
OrbitCamera now owns the inspector eye/view/projection calculation and uses
CreateLookAtLeftHanded/CreatePerspectiveFieldOfViewLeftHanded. The caller applies
the same single Vulkan Y correction as gameplay. Existing orbit positions,
elevation limits, zoom, field of view and depth range are retained. Gameplay,
scripted and Rocketship cameras keep their existing math.
## Verification
ProjectionTests covers36 combinations of four azimuths, three elevations and
three aspect ratios (4:3,16:9,21:9). Tests independently construct forward/right/up
vectors and verify centered target, screen directions, positive-Z forward and
Vulkan0..1 near/far depth. Existing all35 level clip mappings and actual outside
geometry regression also pass. Main .NET build passes.
Before/after960×720 llvmpipe model captures show the horizontal reflection;
mirroring the old image matches the corrected view to under.0012 mean intensity
per RGB channel, versus2.68–4.77 without reflection. Both runs enable Vulkan
validation and report zero errors. Captures were inspected. The two-frame lab
gameplay readbacks before/after are byte-identical with the same copied assets.
Generated evidence: artifacts/orbit-camera/{projection.log,build.log,before.log,
after.log,comparison.log,comparison.png,gameplay-before.log,gameplay-after.log}.
The first test compile had an ambiguous target-typed Vector4 overload; specifying
Vector4 fixed it before validation.
Native Linux GTX1070/private Xvfb starts the actual orbit path at1920×1080,
receives SDL Right, resizes the swapchain800×600 and renders six frames with
validation enabled and zero errors. Both self-contained packages rebuilt from
clean d8f1b51c8610aeaadc5e1792548c24c74e3a4881 (source_dirty=no). Standalone Linux
from /tmp renders an orbit capture byte-identical to the corrected source
capture using only packaged assets. Its release headless invocation has no
available validation layer. All539 original file hashes verify after packaging.
Additional evidence: artifacts/orbit-camera/{native.log,package.log,
package-provenance.log,package-runtime.log,originals-final.log}. Later
documentation-only changes retain this compiled-source provenance. Native
Windows execution of this correction remains pending.
+484 -2
View File
@@ -1,4 +1,486 @@
# Progress — 2026-10-27
# Progress — 2026-11-05
## Body root/mode ownership checkpoint
Implemented the next Jimmy body prerequisites while keeping lab/outside capsule
and special-contact gates. OriginalBodyPhysics separates integration/support/
collision/world response/alternate/global geometry, retains previous/current
Vec4 and anchor, gives callbacks the live root and uses fresh XYZW equality for
candidate publication. Support/landing callback state ownership is explicit;
only world publication applies its candidate clamp/falling displacement.
New conformance compares100 complete native outputs (19 root+81 mode/landing)
and six callback-state cases with an explicit synthetic-vs-real wall boundary.
All pass, as do existing20 body/13 Scooter/13 Grappler targeted groups. Source/
provenance: [implementation](checkpoint/body-contact-implementation.md),
[root](checkpoint/body-root-publication.md), [modes](checkpoint/body-modes.md).
Both investigators returned ownership. Real Jimmy hazard/climb state and dynamic eligibility remain
next; no broad admission, new gadget or whole-original parity is claimed.
Full scripts/test.sh exits0:333 Python+2 HUD,45 managed projects,36 main render
completions, zero validation errors, save/animation/audio and539 original hashes.
Both packages identify cleanc9d0c5b with519 original copies/4271 prepared files
matching per platform. Standalone Linux from /tmp repeats both Scooter scenes
and Jimmy walking/jetpack;27 captures match development exactly, zero validation
errors. Native Windows and whole-original comparison remain pending. Final
provenance, the nonfatal NU1900 metadata warning and source gates are in the body
contact implementation report.
## Jimmy airborne target and render bridge
Ordinary jump/jetpack now reads source forward/backward pitch and turn lean, with
apply-owned seeds preserved through Bubble transitions and bounded route loads.
Destination Euler/dirty, current full STRT/authored Euler and Init are separate.
Full Euler is published to the director and character model; the old Bubble-only
orientation path is removed. Source degree caching/hierarchical rotation now
pivots around the logical root. The upright sole alignment is retained as an
explicit modern local correction; final OMT decomposition precision remains open.
146 original observations compare with managed components: prior108,12 ordinary
air targets,12 render angle writes and14 hierarchical matrices.14 additional final
render matrices document a precision mismatch rather than conformance.28 movement,
20 body and13 Grappler groups pass; lab/two-way underground routes pass. Native
Linux1920×1080 walking/jetpack replays pass all five jump bindings;25 final/airborne
readbacks match across bindings. Carl/control phases pass, zero validation errors.
The existing powered replay now travels359.19 instead of403.88 with source pitch
attenuation; rise418.93 and source impulse/gravity remain unchanged. First forward,
brake and ordinary jump captures were visually inspected.
Evidence/integration: [air bridge](gameplay/jimmy-air-bridge.md),
[target state](gameplay/jimmy-air-target-state.md),
[render transform](gameplay/jimmy-render-transform.md). Both investigators returned
ownership. Remaining priority is root-changing/special/dynamic contact state
before replacing the lab/outside capsule; no gadget expansion.
All scripts/test.sh checks pass across the recorded initial/corrected Director/
resumed runs:325 Python+2 HUD,44 managed projects and36 main Vulkan completions,
zero validation errors, save/load/animation/audio and539 unchanged originals.
Both self-contained packages identify clean27be8ed;519 original copies and4271
prepared resource files match per package. Standalone Linux from /tmp with SDK
variables unset passes walking/powered replays; all five final/airborne readbacks
match development exactly. Windows native and whole-original comparison remain
pending. Final provenance and limits are in the air-bridge report.
## Jimmy controller conformance checkpoint
User pauses gadget expansion and prioritizes Jimmy movement, preserving our
playable baseline over JN-Engine's tuned movement. Integrated recovered ground/
air input and velocity, shared keyboard-turn latch, full-axis base facing before
control gating, exact jetpack hold comparison and gravity intermediate.108 saved
original component outputs match managed checks:25 ground,35 air,16 facing,
32 jump. REA retained complete original instructions; native component runs are
separate from whole-original gameplay.27 special-contact dispatch and12 missing
air-target observations are documented, with explicit implementation gates.
26 integrated movement groups,20 body groups and13 Jimmy evidence guards pass.
Input-only lab and two-way underground routes pass. A pressure/capsule stair
regression was caught and its evidence retained: source−250 Vy requires an actual
support polygon and remains disabled in the lab/outside capsule. Native Linux
1920×1080 SDL walking and powered flight pass all five jump aliases, with resize,
received-key checks, identical final readbacks per replay and zero validation
errors. Native Carl/control-phase and9-stage Grappler replays also pass. Source
angle normalization required signed-direction Bubble assertions; supported
Grappler tests now distinguish fresh−150 versus late100 velocity publication.
Continuation/coverage: [Jimmy movement](gameplay/jimmy-movement-stabilization.md).
Next: ordinary-air destination Euler plus actor-root render bridge, followed by
root-changing/special/dynamic contacts before broader source-body admission.
The incomplete successful-climb probe is preserved in ignored artifacts, not
claimed as verified. All investigator file ownership has returned to primary.
No new gadget work, broad body replacement or complete movement parity is claimed.
All scripts/test.sh checks now pass across the recorded run/resumptions after
correcting obsolete Grappler and first-step Bubble assertions:320 Python+2 HUD,
43 managed projects and36 main Vulkan render completions with zero validation
errors, asset decoders, saves/animation/audio and539 original hashes. Both packages
identify cleanacd1b28 with519 matching original asset copies and4271 prepared
resource files each. Standalone Linux from /tmp with SDK variables unset repeats
Shift walking and right-mouse powered flight with two byte-identical development
readbacks and zero validation errors. Windows native gameplay remains unverified.
Logs/provenance: artifacts/jimmy-movement-audit/ and the stabilization report.
## Scooter pitch and dismount follow-up
User confirmed Scooter works, then reported high pitch and Goddard retaining an
angled dismount. Keep the recovered Euler handoff; add missing4096E0 full-axis
leveling in the bounded Goddard follow bridge. The engine's nominal formula is
correct; add original47D9D0 positional frequency correction, per-channel history
and zero-distance device retention, using the shared listener eye. Source audio
global scheduling/attenuation and audible Windows comparison remain open.
11 native leveling traces (9 active/2 gates) and11 native positional-frequency
observations are recorded.13 Scooter/2 ScooterAudio/10 Patrol groups,24 targeted
Python checks, lab/underground routes and SDL dummy pause/lifecycle pass. Both
1920×1080 native SDL Scooter replays pass10 phases with validation enabled and
zero errors. Findings: [leveling](gameplay/scooter-dismount-leveling.md) and
[pitch](gameplay/scooter-pitch.md). Both packages identify cleanfccc0b9; all14 Scooter resources match. Standalone
Linux from /tmp passes both10-phase SDL replays;20 readbacks match development
byte-for-byte, zero validation errors.539 originals remain unchanged. Native
Windows/audible comparison remains pending. See scooter-live.md for provenance.
## Live Scooter in VR05 and outside LEV1
Implemented independent vehicle/wheel bodies, summon-at-Goddard and strict contact
mount, normal owned-tile outside selection, drive/steer/brake/reverse/jump,
impact/recovery, rider poses, default/impact camera, engine pitch and atomic
cleanup/RETURN. Exact body/wheels/rider resources use source pivots and unit scale.
F1 grants/selects Scooter and shows mount/speed/wheel state; the32-row Player page
fits native2560×1080. Goddard has an opt-in bounded follow subset in these scenes.
53 copied-original component observations match managed formulas. Both headless
and native Linux1920×1080 replays pass10 phases with real SDL input and zero
Vulkan validation errors. Actual front-door head-on contact/recovery is a separate
managed test: it correctly blocks throttle for four seconds. Camera source413870
passes edges=false, correcting an initial mismatch. Source/REA ledger, coverage,
port boundaries and remaining work: [scooter-live.md](gameplay/scooter-live.md).
Full scripts/test.sh passes303 Python+2 HUD/all managed suites and36 main GPU
completions, with zero validation errors. Final11 Scooter/10 Patrol groups and
539 original hashes pass. Both packages identify clean62c07a3; all14 Scooter
resource files match. Standalone Linux from /tmp with SDK variables unset passes
both10-phase native SDL replays; all20 readbacks match development byte-for-byte.
Post-package originals verify unchanged. Final provenance is in the live report.
Original whole-game and native Windows comparison remain pending; Jimmy's
lab/outside capsule and parked broad collision work are preserved.
## Live VR08 Grappler
Integrated shared body/sphere contact state, full bounded base callbacks, recovered
follow camera, exact rope/SWING/cursor art, selection/audio/companion lifecycle
and RETURN cleanup. Process scalar memory survives scene reconstruction; noclip/
reset teardown is explicitly modern debug policy.113 copied-original component
observations support the composition;13 managed live groups and40 Python checks
pass. Native Linux GTX1070/private Xvfb1920×1080 input replay passes9 phases with
zero enabled Vulkan validation errors; headless replay also passes.32-row Player
debug page includes Grappler and fits widescreen. Details/limits and final build
evidence: [grappler-live.md](gameplay/grappler-live.md). Whole-original comparison
and native Windows gameplay remain pending. Both packages identify clean43806fe;
all9 exact resource files match. Standalone Linux from /tmp passes the9 SDL
phases with validation enabled, and all9 stage readbacks match development
byte-for-byte. Full scripts/test.sh passes297 Python+2 HUD/all managed and
headless route/gadget/audio checks; all539 originals verify unchanged. Final
suite log: artifacts/grappler-live-final-tests.log. Package log:
artifacts/grappler-live-package.log.
Earlier component-only status follows chronologically.
# Progress — 2026-11-03
## Grappler ray, constraint and contact checkpoint
Added boundedVR08 GrapplerRay and first-hit polygon/material capture, plus aim
gating, quick-magnitude rope constraint and post-base contact response.42 new
copied-original cases (23 aim/10 constraint/9 impact) match; with earlier30,
10 managed groups cover72 observations.18 Python,11 camera/13 Rocketship groups
and .NET10 build pass. ActualVR08 authored-start rays hit with correct metadata;
lab gameplay readback remains byte-identical and actualVR08 preview renders with
enabled Vulkan validation, zero errors.539 originals unchanged.
Important correction: the attach leaf's lack of duplicate material filters does
not bypass aim rejection.426098..4260A0 ends active input on429D00's true return;
close/rejected surfaces therefore prevent later primary dispatch. Rejected
material may reel before returning; close distance does not. Strict>60 post-base
contact detach and normalized source rope offsets are independently probed.
Source/evidence/limits: [grappler-query.md](gameplay/grappler-query.md).
No live Grappler or package update is claimed. Next: shared47B4B0 collision state
and43AA40 composition, follow camera, rope/cursor render+reset/lifetime, then
boundedVR08 live attach/reel/swing/detach/control-loss/RETURN. Pure constraint and
post-base suffixes do not establish those integrations. Playable70cba65 retained.
## Grappler scalar checkpoint
Implemented isolated GrapplerMotion attachment length/first-scale, held/fast reel,
damping and jump/fire detach predicates. Thirty copied-original Wine32 scalar
observations match5 managed groups;14 Python guards/projections, existing25
movement/15 gadget groups and main .NET10 build pass. Source/log/generator/binary
hashes and source offsets are committed with the fixture. No live mode7, ray,
attached body, rope/cursor rendering or camera is enabled. Scope and retained
REA findings: [grappler-component.md](gameplay/grappler-component.md).
Current playable Linux/Windows packages identify clean70cba65, including the
user-clarified orbit Left/Right correction; native Linux input/resize validation
passes. Grappler component source is a later local checkpoint, not a new gameplay
package claim. All investigator ownership returned. Next: selected material ray
context, original attached collision composition, helper rendering/lifetime and
shared camera, then explicit boundedVR08/control-loss/RETURN integration.
## Orbit horizontal input follow-up and Grappler continuation
User clarified the remaining orbit issue is Left/Right control inversion, with
Up/Down already correct. Reversed only orbit Left/A and Right/D azimuth input.
The corrected coordinate convention and vertical/gameplay input remain unchanged.
Build/package validation follows in orbit-camera.md.
Grappler is the next gadget. Independent investigations retained REA/source
artifacts before reaching usage limits; primary owns all files again. Preserve
artifacts/grappler-{ray,motion,resources}/. Important recovered leads: the attach
leaf uses any ray hit, but earlier aim rejection can prevent its dispatch; VR08 slot134
returns false through475CD0; root-local ray discards the swing pivot+116. Attach
uses x87 sqrt, swing normalization uses OMTquick magnitude; ordinary437940 frame
still runs after the swing input short-circuit. Rope is HIROPE→rope01.ASE with
jimycarl.png; cursor is retainedsprites.omt8. No live code/exporter was added.
Next primary work is review/guard retained results, complete component probes,
then implement boundedVR08 only when body/camera/helper contracts support it.
## Orbit camera reflection correction
The modern inspector paired a right-handed view/perspective with source scenes
whose gameplay cameras use positive-Z left-handed space. This mirrored the world
on switching camera modes. OrbitCamera now supplies the matching left-handed
view/projection and retains the shared single Vulkan Y correction.36 camera/
aspect matrix cases pass plus existing35-level projection checks. Before/after
GPU captures confirm the removed reflection; lab gameplay captures remain
byte-identical. Main build passes. Native/package evidence is recorded in
[orbit-camera.md](orbit-camera.md). This is a port camera fix, not new original
runtime evidence.
Native Linux GTX1070/private Xvfb1920×1080 orbit input/resize check passes with
validation enabled and zero errors. Both packages identify clean d8f1b51; final
standalone Linux capture matches corrected source byte for byte.539 original
hashes verify after packaging. Native Windows runtime remains pending.
## Rocketship wall-impact correction
User Windows testing exposed wild ship scaling on wall hits. The initial port
misread first-material RGBA writes as geometry scale. EXE43E76E selects material
interface+500;43E78B..43E7A7 writes(1,pulse,pulse,1), and ourDLL10037874..100378FA
consumes+4C/+50/+54/+58 as diffuse RGB/alpha. Rocketship now stores ImpactColor;
visuals keep unit geometry and tint only the ship material. Driver/Goddard/fire
positions, scale and color are independent. Expiry/reset restore white.
13 managed groups pass, including two actual static-wall callbacks and per-vertex
geometry/color checks over130 frames with repeated renders/expiry. Copied-original
numeric fixtures retain their historical raw `scale` label with corrected meaning;
Python projections use color and guard the EXE writer/material constructor/DLL
consumer. Main build and targeted source/render checks pass. Details, REA evidence
and final package verification: [impact report](gameplay/rocketship-impact-render.md).
Both packages identify clean62e908e and retain18 exact resource files. Final
standalone Linux GTX1070/private Xvfb1920×1080 flight replay passes all10 SDL
phases with validation enabled and zero errors;22 Python Rocketship checks and
539 original hashes pass. No current native Windows runtime claim is added.
## Live VR02 Rocketship
Implemented owned/reused3ROC flight in VR02: source ceiling/wall/support profile,
registration-ordered body/input/normal phases, original Euler seam/facing, Enter/T
turn and R barrel roll, old-eye camera, driver/Goddard/flame art and engine loops.
Mounted Jimmy retains static physics before ship-root synchronization. Pickups
use controlled ship radius50; LOAD uses actual Jimmy radius60. Tab/Space, F1,
cutscene cleanup, force-control, reset and noclip ownership are integrated.
Source/probe details and boundaries: [rocketship-live.md](gameplay/rocketship-live.md).
96 copied-original observations cover input/vertical, motion/camera, callbacks,
support and impact components.14 managed flight groups,12 final integration groups
and source/projection checks pass. Native GTX1070/private Xvfb1920×1080 passes
all10 render/control phases and real SDL Up/Left/Enter/R/Tab/F3, engine cleanup
and zero Vulkan validation errors. Headless matches;295 accelerated ordinary
ticks reuse received input without relocation or timer mutation. Captures inspected.
Full scripts/test.sh passes268 Python+2 HUD/all managed/33 GPU+17 material checks;
539 original hashes verify. Initial selected-project compile dependency was fixed
by passing a DirectorActor contact descriptor; failed log remains separate.
Both self-contained packages identify clean e77add5; all18 Rocketship resource
files/four exact RGBA hashes match. Final standalone Linux from /tmp passes all10
SDL phases with validation enabled;1920×1080 Player-page capture fits32 lines.
Package logs/provenance are in the live report. Other levels,
special hazards/missions/RNG, original pair ordering and native Windows comparison
remain open; preserved collision/reference baselines remain untouched.
## Give All Gadgets debug action
Added user-requested F1→Player→Give All Gadgets. It sets items0..7 to available
ownership1 without changing selection or other inventory entries. The Player
page remains within32 overlay lines. Debug-menu navigation/repeat/layout checks
and main .NET10 build pass; existing NU1900 metadata warning remains unrelated.
Headless llvmpipe1920×1080 Player-page render passes with zero Vulkan validation
errors; readback inspected and all rows fit. Log: artifacts/debug-give-all/render.log.
Normal level-load availability policy still applies; no gadget behavior changes.
## Earlier Rocketship component and Grappler recovery
Historical component-only status below is superseded for VR02 by the live
checkpoint above. Grappler gates remain open.
Continued user-requested gadgets using supplied decompiler leads, independently
checked with local REA and guarded original bytes. Integrated source/resource
reports and exporters for Rocketship and Grappler; no friend gameplay code was
imported. All investigators returned ownership. Details:
[rocketship-component.md](gameplay/rocketship-component.md).
Implemented isolated RocketFlight ordinary keyboard scalar/bank and vertical
publication. Two copied-original Wine32 probes establish14 input and14 vertical
references;13 managed groups compare the committed numeric fixtures and threshold/
ordering/admission cases. This is not connected live flight. Original radius50
is a collider setter, correcting the friend's visual-scale interpretation;
Up/Down650 are acceleration commands, not direct velocity assignments.
Exact Strato/firestrato/Jimmy/Goddard resources and VR02 authored provenance export
separately with5 checks. Rocket source3/Grappler12 groups pass, along with existing
Gadget15/Movement25 groups and main .NET10 build (existing NU1900 metadata warning).
All539 originals verify unchanged. Native component probes are distinct from
whole-game, new Vulkan/live gameplay or native Windows validation. Packages remain
the prior playable d6ca417; preserved collision baselines remain untouched.
Next: close aircraft body callbacks, Euler/slip/roll/camera, owned-versus-placed
property/reset and passenger/effect/helper lifetime, then integrate explicit
vehicle ownership and boundedVR02/F1 with live input/control-loss/RETURN tests.
Grappler ray/material context, attached body/camera and helper lifetime remain
separate integration gates; no nearest-hook/direct-pull substitute was enabled.
## Supplied jn-engine research assessment
User requested review of the friend's SURVEY-for-Rockman.md and jn-engine-master.
Survey read in full; independent source/gameplay and capture/tooling reviews are
integrated in [reviews/jn-engine-survey.md](reviews/jn-engine-survey.md). Useful
class/address index, saved Jimmy helper bodies (including429D00), animation and
campaign leads, capture tooling and derived Level1 fixtures. All208 ledger rows
are specs, not implemented/fidelity-verified classes. C gameplay uses explicit
approximations and conflicting gadget modes; retain our existing C# port.
EXE SHA matches the friend's declaration; OMT2.dll differs. All254 ASE/126 PNG/
35 GAM shared files are byte-identical by case-insensitive name and SHA-256.
Complete539-file original manifest verifies unchanged. Mixed Jimmy pointer bases,
stale timer naming and capture-specific renderer claims require validation.
No raw OMTC, analysed Ghidra database or proposed gameplay state tap is included.
Prepared a local evidence-request document; no external message was sent.
Documentation-only assessment: no gameplay changes, friend-tree edits/execution,
network, build or new runtime claim. Both investigators returned ownership.
Use the saved bodies to guide the next bounded REA gadget recovery; original
state captures would strengthen future cadence/control/transition comparisons.
Direct source import awaits recording the author's offered permission/licence.
Existing d6ca417 playable/packages and collision gates are preserved.
## Baseball continuation
Continued gadgets after clean1ae5f42/50fcb87. Local REA investigations recovered
Baseball's20-slot pool, hold/release and delayed landing impulse, VR07 moving
targets/strict parent activation and exact TIME font. Original addresses/offsets,
fields, hashes, provider limitations and closed Evidence are in gameplay/baseball*,
with separate source guards and tests. Scooter recovery is saved in scooter.md
and vehicle-assets.md; its separate C3DJEEP/wheel body gates prohibit pretending
that a Jimmy mode implements it. All investigator file ownership has returned.
Implemented BaseballGadget/Projectile, explicit ball body response, SceneBaseballs,
original ball/aim/TIME rendering, VR07 source static registration and F1 grant/
diagnostics. Pending throws/flying balls survive unequip; source scalar/label and
sound/launch/cost order are separate. Six identical target tags preserve distinct
instances. Review corrected gadget-specific companion restoration and hidden
trophy contact/conditional activation;12 managed/6 visual and16 Baseball Python
groups pass. Bounded pair discovery and angular/world/Euler/helper retention
limits remain explicit; full enemy AI/combat is not claimed.
Headless and native GTX1070/private Xvfb1920×1080 pass all eight rendered phases,
including real SDL Ctrl/Left/Up/Tab, actual target hit, retained projectile and
respawn; enabled Vulkan validation reports zero errors. Fixture advances1010
extra ordinary player/target ticks, preserves tutorial energy20 and does not
relocate actors or directly modify timers. Captures were inspected. Complete
scripts/test.sh passes232 Python+2 HUD, all managed suites,32 main GPU completions
and17 isolated material checks with zero enabled validation errors. SDL dummy
lifecycle and539 original hashes pass. A final focused12-group Baseball run adds
source wall-reflection and.46 floor-friction numeric checks;16 Baseball Python
groups pass after adding the font-table guard. Logs:
artifacts/baseball-implementation/. No new native Windows/original whole-game
runtime claim is made.
Source milestone d6ca417 is committed locally. Linux-x64 and win-x64 packages
identify that clean source (source_dirty=no); both publish successfully despite
NU1900 unavailable vulnerability metadata. All16 referenced Baseball/aim canvases,
including exact TIME glyph pixels, verify in both. Standalone Linux from /tmp
passes all eight Baseball phases and a1920×1080 F1 Player view with the new grant
and diagnostics; release validation layers are unavailable, separate from enabled
source/native checks. All539 originals verify after packaging. Logs: package.log,
package-baseball.log, package-debug-player.log and originals-after-package.log.
Live ball bodies/contacts are bounded to LV1B/VR01/VR04/VR07/LEV1; other levels,
full enemy combat and native Windows gadget verification remain open. Preserved
baseline packages and parked collision checkpoints remain untouched.
## Bubble continuation
User continued gadgets after clean1897dd2/9ea5784. Bubble mode2 motion, body,
sprite and VR01 floor dependencies are recovered in gameplay/bubble-motion.md,
bubble-body.md and bubble-rendering.md. Six isolated copied-original body cases
establish160/.415 support66.4, no forced lowering on equip, cleanup60/1.265 and
300/900 bounce motion. REA Evidence, guarded source reports and probe fixtures
are retained locally. Full original gameplay/native Windows remain separate.
Primary integrated BubbleEffect/Motion/Visuals, controlled−.5dt, fire-as-throttle,
persistent movementmode2, direct300/900 bounces, source cleanup650, original Canv1
full RGBA fade and F1 grant/select. VR01 now uses the recovered static body subset
with retained-material111 lava/score/audio/debounce policy. A stored material
owner preserves Invisible114/FC versus late lava RGBA write order. The original
fixed75.9 root/render bridge remains; lab/outside still use provisional collision.
GadgetScreen reads actual raw mode and Bubble practice loads before live equip.
Thirteen Bubble integration groups pass, alongside11 pure motion and8 effect/
visual groups. Independent review reruns those suites and finds no blocker within
the declared profile. Complete scripts/test.sh passes202 Python+2 HUD checks,
all managed suites,31 main GPU completions,17 isolated material checks and SDL
dummy lifecycle, with zero enabled Vulkan validation errors. All539 originals
verify. Native GTX1070/private Xvfb at1920×1080 passes all eight Bubble SDL phases,
including real supported900/SFX106, cleanup650 and visible full RGBA fade. Its
accelerated fixture advances306 extra ordinary player ticks and retains tutorial
energy20; it does not prove original cadence or manual tutorial completion.
Readbacks were inspected. Logs: artifacts/bubble-implementation/.
All investigator ownership has returned to primary. A20's consumer remains open;
normal accepted-input target handoff is recovered without guessing a countdown.
Source milestone1ae5f42 is committed locally. Both self-contained packages identify
that clean source (source_dirty=no) and contain exact Canv1 pixels verified against
their recorded RGBA hash. Linux/Windows publish succeeds despite NU1900 unavailable
vulnerability metadata. Standalone Linux from /tmp passes all eight Bubble phases
and a1920×1080 expanded F1 Player view. Release validation layers are unavailable;
enabled source/native checks remain separate. Windows is cross-built, not natively
gadget-tested by the agent. All539 originals verify after packaging. Logs:
package.log, package-bubble.log, package-debug.log, originals-after-package.log in
artifacts/bubble-implementation/. Preserved baseline packages remain untouched.
No broad C4/C5 resume:
dynamic/special lab/outside collision, shared camera/Euler ownership, all damage
flags and retained owned-helper lifetime remain explicit boundaries.
## Invisible and shared energy continuation
Implemented original item2/raw mode2: initial7-second recharge, fixed2-energy
activation,7-second active timer, original alpha.7/last3-second blend flash,
original Canv21/22 meter, companion hide/body flags and source cleanup. Enter/
Ctrl/left mouse activates after recharge without jump. F1→Player grants/selects
Invisible, unequips it and shows remaining/recharge/targetability diagnostics.
Raw-null control freezes its timers; named-Jimmy CAM/MCA DeactivateInv cleanup
is independent from raw-owner preparation. Full enemy sensing remains unported.
PlayerEnergy now retains the shared scalar/warning latch across ordinary loads;
ray, active jetpack and Invisible adjustments use original empty80/low182 sounds
with strict19/20 hysteresis and source callback order. The existing complete
42A920 REA record is reused; new independent REA reports cover Invisible,
material/AI dependencies, meter art/UV/rendering and Bubble's next-step contract.
All investigators have returned file ownership; original files remain read only.
Fifteen managed Invisible/energy groups pass, including binding/control/companion
and widescreen meter checks.182 Python checks and independent review pass. Native
GTX1070/private Xvfb at1920×1080 passes real SDL Ctrl/Tab through all six rendered
phases, zero enabled Vulkan validation errors; headless matches. This explicit
fixture advances836 extra normal player ticks, not an original-cadence capture.
Six-phase readbacks were inspected. Complete scripts/test.sh passes182 Python+2
HUD checks, all managed suites,30 main GPU completions and17 isolated Vulkan
material checks with zero enabled validation errors. SDL dummy lifecycle and all
539 original hashes pass. Log: integration.log. Clean package/standalone release
results will be recorded after the verified source milestone.
Logs: artifacts/gadget-followup/; reports: gameplay/invisible-implementation.md,
invisible.md, player-energy.md, gadget-followup-assets.md and invisible-review.md.
Bubble evidence now records original Canv1 effect, equip/cleanup, controlled
energy drain and movementmode2/radius/factor changes. Runtime waits for that
mode's full movement/jump/body contract. Other gadgets/full enemy AI, global
suppression lifecycle, graphics-option/depth state, cached canvas alignment,
original runtime and native Windows verification remain open.
Source milestone1897dd2 is committed locally. Linux-x64 and win-x64 packages
identify that clean source (source_dirty=no). Both publish successfully despite
NU1900 unavailable vulnerability metadata. Both contain exact Canv21/22 meter
pixels verified against their recorded RGBA hashes. Standalone Linux launched
from /tmp passes all six Invisible phases and a1920×1080 expanded F1 Player-page
render. Release validation layers are unavailable; enabled source/native results
above remain separate. Windows is cross-built, not natively gadget-tested by the
agent. All539 original hashes verify again after packaging. Logs: package.log,
package-invisible.log, package-debug-player.log, originals-after-package.log in
artifacts/gadget-followup/. Preserved baseline package copies remain untouched.
## Gameplay gadgets — user-directed continuation
@@ -675,5 +1157,5 @@ Do not claim complete gameplay based on direct-contact route or GPU smoke tests.
All previous agent file ownership has returned to primary; investigators that
reached usage limits are not dependencies. Generated output stays separate from
Original and the nested local repository has no remotes. Read tasks.md and Git
Original. Existing remote configuration remains untouched and unused. Read tasks.md and Git
status before continuing; preserve source evidence and update these notes.
+4
View File
@@ -3,6 +3,10 @@
Original API and state maps: `analysis/graphics.md`. Mesh/material/texture formats:
`file-formats.md`. Vulkan code: `src/GamePort/Rendering/Vulkan/VulkanRenderer.cs`.
Modern orbit inspection uses gameplay's positive-Z left-handed view/perspective
and the same single Vulkan viewport Y correction. The former right-handed pair
mirrored the scene when changing modes; regression and GPU proof: orbit-camera.md.
Default prepared LV1B view uses the GAM STARTEXP camera; positive-Z projection
uses recovered FOV `0xAAA/16384*360` degrees, near 20, far 10000. Generic engine
far default is 3200; other scene-specific overrides remain to be mapped. Camera
+70
View File
@@ -5,6 +5,63 @@ offsets, virtual addresses, API symbols or observed behavior. Decompiled output
evidence, not original source. Original gameplay has not yet been observed successfully; isolated original DLL
probes and modern runtime checks are recorded separately.
- [Body root publication](checkpoint/body-root-publication.md) and
[body modes](checkpoint/body-modes.md):19 actual dispatcher/kernel contact-root
observations plus87 body/support/friction flag/payload observations. Parent
[integration](checkpoint/body-contact-implementation.md) compares100 complete
outputs and six state-only mutation cases; independent flags, XYZW and landing
ownership are implemented without enabling special Jimmy terrain or dynamic pairs.
- [Jimmy air target state](gameplay/jimmy-air-target-state.md) and
[render transform](gameplay/jimmy-render-transform.md): apply-owned pitch seeds,
full STRT/current Euler, destination/dirty Init, degree-to-short caching and
original hierarchical basis.26 additional native comparisons plus14 final render
matrices (documented precision mismatch). [Integration](gameplay/jimmy-air-bridge.md)
keeps the local sole correction modern and broader body admission separate.
- [Jimmy movement stabilization](gameplay/jimmy-movement-stabilization.md):
current priority, preserving our playable controller over JN's tuned replacement.
Ground/air/facing/jump reports record108 native component observations matched
by managed implementations,27 special-contact eligibility observations and12
recovered air destination writes. The last two are investigation evidence;
special-body and ordinary air-pitch/render integration remain open. REA's
complete original instruction Evidence and offsets are linked in those reports.
- `gameplay/grappler-live.md`: boundedVR08 integration/coverage and runtime
evidence. `grappler-body.md` records shared sphere context and41 native cases;
`grappler-camera.md`, `grappler-resources.md`, `grappler-lifecycle.md` record
consumer state, exact art/shape-scale source and cleanup/persistence. Original
component execution and modern/native Windows evidence remain distinct.
- `gameplay/grappler-query.md`: enclosing426030 early-return correction,
VR08 static filter/selected-material metadata,42 copied-original aim/constraint/
post-base contact cases and corresponding managed components. The attachment
leaf's broad acceptance does not bypass earlier aim rejection. Full attached
body/base-contact, camera and helper presentation/lifetime remain separate.
- `gameplay/grappler-component.md`:30 copied-original attachment/reel/damping
observations, isolated managed component and retained ray/body/resource REA
evidence. Cursor rejection differs from attach acceptance, and input swing
short-circuit does not suppress ordinary Jimmy frame publication. Live gates
remain explicit.
- `gameplay/rocketship-live.md`, `rocketship-body.md`, `rocketship-motion-camera.md`
and `rocketship-lifecycle.md`: owned/reused3ROC, body flags/callbacks, registry
input order, source Euler/maneuvers/shared-eye camera, rider/Goddard/fire/audio
lifecycle,96 copied-original component observations and boundedVR02 integration.
REA IDs/source offsets and unresolved special materials/pairs/retained lifetime
remain explicit; port replay is distinct from original gameplay verification.
- `gameplay/bubble-motion.md`, `bubble-body.md`, `bubble-rendering.md`,
`bubble-implementation.md`, `bubble-implementation-review.md`: mode2 controller,
copied-original radius/factor/support references, actualVR01 floor111/texture
linkage, original owned sprite and bounded implementation/review. Source and
runtime evidence remain distinct; retained helper/camera/Euler gates persist.
- `gameplay/invisible.md`, `invisible-implementation.md`, `invisible-review.md`:
timed mode2/targetability/material state, named-Jimmy versus raw-owner cleanup,
bounded implementation and independent review. `gadget-followup-assets.md`
records original meter/tutorial resources, UV stretch and alignment uncertainty;
`player-energy.md` reuses42A920 REA for warning-latch/callback order.
`bubble.md` records the next gadget's physics/visual/drain contracts and gates.
- `gameplay/gadgets-implementation.md`: first playable gadget scope and evidence
map. `gadget-controls.md`/`gadget-assets.md` retain original group0 state, menu
rectangles and54 canvases. `shrink-ray.md` traces input/ownership/energy/target
@@ -80,6 +137,19 @@ and activation gating remain unresolved. The no-gadget controller checkpoint now
integrates the corrected formulas; see analysis/movement-checkpoint.md rather than
the older preliminary movement interpretations.
## Gadget component continuation — 2026-11-03
Supplied jn-engine class names/saved decompiler bodies guided independent local
REA and guarded-byte recovery. Rocketship owner/control, radius50/factor.6,
flight input/apply and VR02 game filter are documented in gameplay/rocketship.md.
Two synthetic Wine32 harnesses executed copied input/vertical instruction ranges,
yielding28 numeric references for13 managed RocketFlight groups. This does not
observe whole-game flight or recover the remaining body/camera/attachment phase.
Provenance and next gates: gameplay/rocketship-component.md. Grappler's source
ray/material, attach/reel/swing/detach and retained helper state are recorded in
gameplay/grappler.md with12 source/projection checks; live integration is gated.
Original/friend files remain untouched; no tuned friend C gameplay was imported.
## Unresolved
Follow-up evidence: `analysis/runtime-checkpoint.md` identifies TSK StoredVector,
+73
View File
@@ -0,0 +1,73 @@
# Proposed evidence request for jn-engine author
2026-11-03. Prepared locally from the supplied survey; **not sent**. This is an
investigation contract, not an implemented recorder/replay feature or schedule.
Our [assessment](jn-engine-survey.md) explains the evidence and version limits.
## Existing material first
- Analysed Neutron.exe Ghidra project/export, Ghidra version, analysis options
and applied script list. Saved target6 bodies are already useful; preserve
prototype warnings and explicit function boundaries in the handoff.
- Raw Level1 OMTC for anchor8881 and constituent world-fixture keyframes, with
matching original screenshots and fixture-generation commands/settings.
Derived scenes/draws/textures exist locally; raw capture/reference image do not.
- Hashes of the actual captured EXE, OMT2.dll and proxy, executable variant,
display/renderer settings, starting level/save/task state and capture build.
EXE manifest matches ours; OMT2.dll manifest currently differs.
- The offered written code/script permission or permissive licence, if direct
source import is intended. Keep original game assets/binaries distinct.
## Minimal original-state recording
First record a short VR04 standing/walk/release/turn/jump/held-jetpack sequence.
Then lab→VR04→lab→outside, including intro, Carl control handoff and RETURN.
Gadget activation, death/restart and save/load can follow a validated basic trace.
Please record a versioned little-endian schema and an address/base map. Every
state field should name its width/type, pointer base, sampling phase and source
instruction/helper; mark unresolved fields rather than guessing. Include:
- Update sequence, render sequence, phase, game dt and wall timestamp separately.
Renderer EndScene timestamps alone cannot establish simulation cadence/order.
Identify skipped/invalid-dt and paused updates; report dropped frames/records.
- Initial save/TSK/checkpoint/level/start identity, RNG and relevant settings;
input down/edge state, focus, mouse/controller axes and polling phase.
- Raw controlled pointer and class identity, independently tracked Jimmy identity,
pose/velocity, movement mode, jump phase, support/shadow distance, pending
impulse, control/cutscene owner, gadget display/raw mode and energy/timers.
- Camera mode/owner/transform/clips, task/SCENE changes, objective/UI transitions,
audio start/stop identifiers and level-load/RETURN/reset boundaries as feasible.
Start with samples immediately around the game-update body, then add subphases
where a discrepancy demands it. Our current static map has dt write47E502 to
696030, physics47E554, registry47E582→473740, transform sync47E587→473770,
base draw47E6DF and render counter increment47E6EF. These are **EXE virtual
addresses**, with their current evidence in `../checkpoint/loop-motion.md`;
validate safe hook boundaries/ABI before instrumenting a copied installation.
Registry order and changes within the update can matter, so a lone end-of-frame
snapshot cannot establish which owner wrote a field first.
## Pointer-base correction needed before capture
Jimmy's game interface is complete object+C0. These established pairs are:
| Value | Complete Jimmy | Jimmy game interface |
|---|---|---|
| Movement mode | +7C4 | +704 |
| Jump state | +7E8 | +728 |
| Shadow ground distance | +86C | +7AC |
The survey's proposed list mixes the two columns. The raw controlled global
5099E4 can be null or owned by another class during cutscenes/vehicles; do not
apply Jimmy offsets without class validation. Root/velocity access slots are
virtual getters, not established raw memory field offsets. Resolve actual
storage or use a reviewed getter strategy without changing simulation state.
Similarly verify widths/layouts for proposed SCENE/objective/gadget/RNG taps;
the survey alone does not define a serialization contract.
Acceptance: one short recording with reproducible startup, explicit schema,
complete input/dt/state phase alignment and no unexplained record drops. Compare
that recording manually before expanding recorder coverage or implementing a
GamePort replay consumer. Keep capture/replay work local with separate generated
outputs and untouched originals.
+19
View File
@@ -0,0 +1,19 @@
# jn-engine capture, tooling and oracle review
2026-11-03. Read-only source/artifact inspection; no friend code, scripts, legacy binaries, network services or Ghidra jobs executed. Paths below beginning `J/` mean `../../../jn-engine-master/` relative to this document. Confidence is high for source/artifact inventory; reported historical measurements remain provenance claims until independently replayed.
**Useful now:** capture-derived Level 1 fixtures, bounded algorithm reference tests, and address/naming tools. Preserve GamePort's C#/.NET 10, SDL3 and Vulkan architecture; translate selected evidence rather than importing the C/SDL2/OpenGL runtime.
**Binary scope.** Local SHA-256 recomputation confirms `Original/Neutron.exe` matches `J/docs/binaries.sha256:12` (`f5281076…1aea8`). However our `Original/OMT2.dll` is `3ec41ead…54943`; friend declares `a94f13e1…b0fea` (`:14`). Executable addresses can be cross-indexed; DLL addresses, helper semantics and captured renderer behavior need version reconciliation. No friend original DLL is included for byte comparison. This difference is not evidence that its captures are wrong.
**Instrumentation exists, state tracing does not.** `J/instrument/proxy/ddraw_proxy.c:4` implements a replacement `ddraw.dll` forwarding through `ddraw_orig.dll`; COM wrappers hook scene boundaries, draws and state changes (`com_wrappers.c:202–234,389`). `protocol.h:12–83` specifies packed little-endian OMTC v4, accepting v1–4: transforms, viewport, textures, render/texture-stage states, light/material, draws; v3 adds pixels, v4 masks/color keys. Commands include capture controls, frame marks and camera changes (`:62–71`). Capture uses a 32 MiB producer/consumer buffer; overflow drops whole frames (`capture.c:43,596–616`). Frame time is `GetTickCount`, **not the simulation dt** (`:581–584`). No proposed state-tap addresses or gameplay-state record exist in this instrumentation.
**Included evidence has limits.** `assets/capture/` contains 390 files, 13,512,573 bytes. `level1_hudfix/frame_meta.json:4–31` attributes anchor frame 8881 to a 2026-05-25 capture, 640×480, 3,523 draws and 342 textures. Local `draws.json` actually contains 3,523 entries; textures, HUD reconstruction, `scene.bin`, `scene_reproject.bin` and `scene_world.bin` are present. The world fixture combines seven accepted keyframes; three rejected registrations are recorded (`scene_world_summary.json:5–32`). These are useful rendering fixtures, not continuous movement/physics evidence. No `.omtc`, original screenshot named by the manifest, original executable tree, `.gpr` or `.gzf` project is supplied. `validate_replay_fixture.py:34–39` requires absent raw artifacts, so its accepted-frame replay cannot currently be reproduced directly.
**Renderer claims deserve targeted calibration.** `PROJECT_HISTORY.md:1242–1259` records unusual projection `[3][3]=1`, zero vertex-alpha caveats, no fog in that capture, billboard tags, HUD FVF `0x152`/orthographic projection and `canvas_id=Canv+1`. Treat these as scoped capture/source findings. Do not infer universal no-fog or force every Vulkan material opaque. Verify matrix storage/transposition explicitly: wire schema says row-major (`protocol.h:92`) while architectural math uses column vectors. Historical histogram improvements are not image parity (`history/native_vs_capture_8881_phase5_report.md:94–117`). Particularly, `tools/check_oracle_diff.py:41–74` checks fixture counts/magic, player presence and FOV/clip values; it does **not** compare images or trajectories.
**Oracles: 16 substantive Python scripts plus one template**, rather than the survey's 15. All substantive scripts build/run repository-specific C dumpers. Reuse expected-value functions, corpus enumeration and protocol formats with a C# adapter; no existing generic external-runtime CLI makes them drop-in tests. Strong cases include 3CAM clamp-order/branch precedence with real authored counterexamples (`C3DCutSceneCamera.py:8–35`) and animation mutation tests (`C3DAnimated_dispatch.py:460–498`). Scope remains narrow: 3MCA excludes six out-of-range entries (`C3DMultiCutSceneCamera.py:20–26`); walk-camera uses synthetic inputs/tolerances and documents omitted paths (`C3DPlayer_walkcam.py:29–43`); AI-trigger bypasses activation gates (`C3DAITrigger.py:21–25`). These prove translations against recovered models, not independent original runtime fidelity.
**Adoption route.** First compare shared corpus/hashes, then adapt one camera/parser oracle and selected Level 1 render-state fixtures. Ghidra markup/dump scripts exist, but markup creates/replaces structures (`ApplyRttiClassMarkup.java:154–170`); apply only to a copied project with explicit paths. The analysed project remains an offer. State tapping is feasible future instrumentation: require pre/post-update phase, dt, input snapshot, stable actor identity, initial save/state/RNG, collision/camera state and dropped-frame reporting before replay comparisons. Begin with VR04 walking/jumping/jetpack traces.
Keep execution local: receiver defaults to all interfaces (`receive.py:392`) with control enabled (`:501`); deployment uploads remotely (`deploy_xp.py:144–145`). Do not run those defaults or remote workflows. Use reviewed offline readers/local fixtures and separate generated directories. No new implementation or runtime validation is claimed here.
+86
View File
@@ -0,0 +1,86 @@
# jn-engine gameplay review
2026-11-03. Read-only source/document comparison. `J:` denotes
`../../../jn-engine-master/`; `N:` denotes this GamePort repository. No original
execution, network, builds or friend-repository changes. Confidence is high for
what these source files implement; original-behavior claims below remain
candidates until checked against our guarded binary evidence.
## Verdict
Useful chiefly as an address/naming index, decompilation supplement and campaign
research map. Do not replace our movement or recovered gadgets with its C runtime.
The ledger really contains 208 rows, all `spec`, with 181 Medium and 27 Low
confidence, and every named report exists (`J:docs/decomp_ledger.csv`). That is
specification coverage, not 208 faithfully implemented classes. Three resolver
rows are deliberately inert, including the unported rock-placement controller
(`J:src/game/behaviors/behavior_resolver_inert.c:1-19`).
## Concrete comparisons
- **Locomotion is intentionally different.** Its live player defers parsed
acceleration/deceleration and uses instant tank movement, jump650 and
turn2.8 radians/s (`J:src/game/behaviors/behavior_player.c:14-27,113-155`).
World gravity is1600, versus our recovered800 magnitude
(`J:src/engine/physics.h:6-8`). These are explicit native tunings, not evidence
against our controller. Collision is axis-separated AABB resolution plus a
mesh adapter (`J:src/engine/physics.c:24-50,87-134`).
- **Gadget names/modes cannot be transplanted.** Its eight-gadget list includes
Jetpack and excludes Baseball (`J:src/game/behaviors/behavior_gadgets.c:71-80`);
our recovered eight tiles include Baseball, with Jetpack outside that tile set
(`N:docs/gameplay/gadget-controls.md:67-79`). Native Shrink Ray writes mode6
(`J:src/game/behaviors/behavior_gadgets.c:180-182`), whereas our item6/raw6 is
Baseball (`N:docs/gameplay/baseball-implementation.md:11-15`). Its own AMI table
sends mode6 toVR07, and its header admits gadget-to-AMI mapping was unrecovered
(`J:src/game/gadget_menu.c:52-61`; `gadget_menu.h:25-30`).
- **Our recent slices are substantially deeper.** Friend Invisible hides Jimmy
immediately on equip and calls the mechanic native design
(`J:src/game/behaviors/behavior_gadgets.c:31-37,175-178`); our recovered activation
has recharge7, duration7, cost2, alpha.7 and a separate AI eligibility flag
(`N:docs/gameplay/invisible.md:64-91`). Friend Bubble recovers visual phases but
explicitly invents follow placement; it has no corresponding mode2 body/input
implementation (`J:src/game/behaviors/behavior_gadgets.c:286-325,467-479`;
compare `N:docs/gameplay/bubble-implementation.md:11-18,37-43`). Its Baseball is
a forward projectile at800 with2.5s lifetime
(`J:src/game/behaviors/behavior_player.c:139-155`); ours implements source
aim/release, twenty retained slots and speed1800 without inventedTTL
(`N:docs/gameplay/baseball-implementation.md:11-21`).
- **Rocket/Grappler/Scooter are prototypes, not shortcuts through recovery.**
Rocket selection force-boards the nearest3ROC within6000
(`J:src/game/behaviors/behavior_gadgets.c:154-160`). Grappler chooses the nearest
hook and directly translates Jimmy with tuned reach2200/pull1500/arrival120
(`same:348-350,387-399,481-490`). Scooter has tuned movement, no wheel children,
and mounts directly on selection (`J:src/game/behaviors/behavior_scooter.c:25-30,
48-55,75-77,155-161`). Our recovered Scooter instead separates equip from later
interaction mount and requires four constructed wheel actors
(`N:docs/gameplay/scooter.md:50-75`). Reuse their asset/class leads and investigate
Jimmy429D00/426A70; do not adopt these replacement mechanics.
## Highest-value next reuse
**Animation:** `J:docs/decomp/C3DAnimated.md:221-232` identifies repeated last-frame
completion, including paused one-shots, no completion latch, and selection timing
reset rules. Runtime implements these at `J:src/game/animated_dispatch.c:210-258`;
player HIT/SPLAT/FENCE/LADDER hooks switch toSTOP
(`player_anim.c:137-142`). This is useful beyond our currently limited pose enum
(`N:src/GamePort/Game/LabSimulation.cs:8`). Preserve its own `linked-blocked`
boundary: nativeASE metadata does not prove originalA3dm import/timing or faithful
FENCE entry (`J:docs/decomp/C3DAnimated.md:183-193,334-358`). Mutation-sensitive
native oracles establish implementation wiring, not execution of the original.
**Campaign/state:** use `J:src/game/behaviors/behavior_ai_trigger.c:140-193` as a
compact SCENE/KITTY transition checklist. Its explicit deferrals include AIState,
AISpeed, animation selection and state-gated object dispatch (`same:37-40`), plus
reward/menu/Goddard/energy effects (`same:140-145,192-193`). Its arm-on-exit
trigger policy (`same:13-17`) requires independent validation.
**Trust corrections:** survey says `+86C` timer naming was corrected, but
`J:docs/decomp/C3DPlayer.md:70` still says `jump_gate_timer`. Jimmy's field-map
pointer bases are mixed (`C3DJimmy.md:18,24-26,35`); normalize complete versus
game-interface+C0 before reusing offsets. Target6 also forces generic thiscall
signatures and warns about `unaff_retaddr`/dt artifacts
(`J:docs/decomp/evidence/c3djimmy_target6.md:19-32`). Treat its function definitions
as useful recovery leads, not ABI proof.
+118
View File
@@ -0,0 +1,118 @@
# Supplied jn-engine assessment
2026-11-03. User requested review of `../../../SURVEY-for-Rockman.md` and
`../../../jn-engine-master/`. The survey was read in full; its generated claims
were checked against supplied source/artifacts and our existing evidence.
Read-only review of that tree; no friend code, legacy executables, deployment,
network services or Ghidra scripts executed. GamePort source baseline: d6ca417;
documentation HEAD on entry: c0acf58. No gameplay changes or new runtime claim.
## Conclusion
**Useful research and validation material, especially the saved decompiler bodies
and original capture tooling. It is not a more complete faithful gameplay
implementation to substitute for this port.** Keep C#/.NET10, SDL3 and Vulkan.
Use their class/address index to accelerate REA investigations; independently
check each imported interpretation. Their C/SDL2/OpenGL gameplay intentionally
contains approximations which our recent recovered gadget slices already exceed.
Detailed independent reviews:
[gameplay](jn-engine-gameplay.md), [capture/tooling](jn-engine-capture.md).
A ready-to-share [evidence request](jn-engine-capture-request.md) records the
most valuable additional material; nothing has been sent externally.
## Identity and corpus checks
Local SHA-256 recomputation versus `J:docs/binaries.sha256`:
| Binary | Our original | Friend's declared original | Consequence |
|---|---|---|---|
| Neutron.exe | 1,019,904 bytes; `f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8` | Identical declared size/hash | EXE addresses can be cross-indexed |
| OMT2.dll | 1,343,488 bytes; `3ec41ead011adf56387a6dbd4580e5b5a9721b5f8020c8a56420f42824354943` | 1,339,392 bytes; `a94f13e148bff790aab556d0381055df57f2ff4f9abc5947c25847c7370b0fea` | Reconcile DLL build before reusing DLL addresses or treating captures as our exact engine version |
Friend originals are not included, so the second column is a direct measurement
and the third a supplied manifest declaration. A DLL difference does not make
their measurements invalid; it limits their automatic applicability.
Case-insensitive filename pairing and SHA-256 comparison establish **all 254
Original/ASE, 126 Original/png and 35 Original/gam files are byte-identical to
their supplied counterparts**. Friend directories contain two additional ASEs
(`bigbotstop.ase`, `sporkystop.ase`) and thirty additional PNGs. Do not merge these
extras into our authoritative asset set. The survey's asset-count explanation is
stale; our earlier 128 PNG count includes two root font PNGs outside Original/png.
Our full original manifest verifies all539 files unchanged after this review.
## Evidence value and reuse order
Here `J:` means `../../../jn-engine-master/`, relative to this report.
| Material | Verified scope | Recommended use |
|---|---|---|
| Class ledger and reports | 208 ledger rows, all `spec`: 181 Medium/27 Low; reports present | Naming/address/dependency index, not a completion percentage |
| Jimmy target6 decompiler output | Saved helper bodies including 428D50, 427FF0, 429D00, 426A70; generic signatures have artifacts | First gameplay reuse: compare Grappler/Rocketship recovery with REA and guarded EXE bytes |
| C3DAnimated report/dispatch | Completion and selection timing rules, including repeated end callbacks | Candidate for replacing limited animation ownership after independent verification |
| GAM schema, class IDs, SCENE/KITTY transition table | Source/data research over shared level corpus; several effects deferred | Expand campaign coverage checklist and identify missing owners/callers |
| Linkage oracles | 16 substantive Python scripts plus template, building their C dumpers | Adapt selected expected-value functions/corpus cases to a GamePort adapter; not drop-in original-runtime tests |
| DDraw proxy and OMTC protocol | Real draw/state/texture capture implementation; derived Level1 fixtures supplied | Calibrate selected Vulkan states after matching binary/version and matrix conventions |
| Ghidra scripts and offered database | Scripts included; analysed project absent | Apply reviewed naming/function-boundary ideas to a copied project through our REA workflow |
| Gameplay state tap / deterministic original replay | Proposed in survey; not implemented/included | Request a minimal phase-aware trace before building a replay consumer |
**Immediate recovery lead:** `J:docs/decomp/evidence/c3djimmy_target6.md:2556`
contains Jimmy429D00, previously unidentified by our default analysis. Its
header and `J:tools/ghidra/CreateFunctions.java` explain how explicit boundaries
were created. This can unblock investigation, but forced `__thiscall`,
`unaff_retaddr` and uninitialized aliases prevent treating the output as a
finished algorithm or ABI. Maintain REA Evidence and byte checks when continuing.
## Corrections before adoption
- Movement is explicitly tuned: instant tank movement, jump650 and gravity1600.
This is not evidence to replace our recovered550/800 behavior.
- Their native gadget list includes Jetpack and omits Baseball; Shrink Ray uses
raw6, conflicting with our recovered item6/raw6 Baseball. Invisible activation,
Bubble placement, Grappler pull, Scooter mounting and Baseball lifetime also
contain native design/tunings. Use class evidence, not these replacement rules.
- Jimmy field maps mix complete-object and game-interface bases. Our established
interface is complete+C0. Movement mode is complete+7C4/interface+704; jump state
complete+7E8/interface+728; shadow distance complete+86C/interface+7AC.
The survey mixes these bases in its proposed tap list. Its corrected shadow
interpretation is also not propagated to `J:docs/decomp/C3DPlayer.md`.
- Capture fixtures are derived evidence, not an included raw stream: 390 files,
13,512,573 bytes; anchor8881 has3523 draws/342 textures at640x480. No `.omtc`
or named original reference screenshot is present. The “oracle diff” checks
fixture structure/counts/configuration, not pixels or gameplay trajectories.
- No-fog/vertex-alpha/projection observations are capture-specific. Verify state
and matrix storage before changing global rendering policies.
- The survey compared older builds; its “other seven gadgets” and “no vehicles”
coverage statements do not describe current GamePort recovery/integration.
- No licence file was found in the supplied tree. Record the offered written
permission or permissive licence before directly importing friend code/scripts.
Field/loop cross-checks: [movement checkpoint](../analysis/movement-checkpoint.md),
[Bubble pointer/slot contracts](../gameplay/bubble-motion.md),
[loop ownership](../checkpoint/loop-motion.md). Detailed citations for the C
runtime differences and capture limits are in the two independent reviews.
## Concrete next steps and remaining questions
1. For the next gadget slice, use the saved429D00/426A70 bodies and Rocketship
class report to guide a bounded REA recovery. Resolve pointer bases, callers,
ownership and body dependencies before implementation; do not port prototype
gadget movement.
2. Request the analysed Ghidra database, raw OMTC with matching screenshots and
exact capture DLL hashes. Their existing Level1 fixtures are useful now, but
raw data is needed to reproduce the claimed renderer observations independently.
3. Start the proposed original-state instrumentation with VR04 movement/jetpack,
then lab→tutorial→lab→outside including Carl/RETURN. Require game-update
phases, initial state and stable actor identity before planning replay tooling.
4. Later adapt one camera oracle and animation-completion cases, explicitly
separating recovered-model consistency from original-runtime comparison.
Open: capture DLL version/availability; raw evidence and analysed project;
corrected/typed field maps and function signatures; original simulation cadence;
renderer parity; actual state-tap feasibility; final-level/credits behavior;
code reuse permission. None is silently resolved by this source intake.
Validation this turn: source/artifact review, exact binary/corpus hashes, ledger
counts and original-manifest verification. No new build, port regression run,
original execution or native Windows validation was needed or claimed.
+147 -3
View File
@@ -46,6 +46,122 @@ compile, runtime and original-fidelity verification are separate.
## Immediate continuation
- [ ] Current priority: stabilize Jimmy's ground/air input, facing, jump/landing,
body/contact response and route/control transitions before more gadgets. Keep
our movement baseline; JN-Engine is an original-code index, not a movement model.
See gameplay/jimmy-movement-stabilization.md for bounded evidence/verification gates.
- [x] Jimmy controller arithmetic/facing checkpoint: source ground/air components,
shared keyboard latch, control-independent full-axis facing, exact jump hold and
gravity intermediates.108 saved original component observations match managed
checks. Capsule compatibility remains explicit; broad collision is not complete.
- [x] Jimmy ordinary-air destination pitch/roll, retained apply-owned pitch seeds,
destination/dirty Init, full authored Euler and logical-root rendering bridge.
12 target writes plus12 degree/14 hierarchical transforms compare against
managed components. Sole alignment remains modern; final OMT decomposition
precision is separate. See gameplay/jimmy-air-bridge.md.
- [x] Body callback publication/mode prerequisite: finite XYZW fresh equality,
independent integration/support/collision/world/alternate modes, context lifetime
and landing payload ownership.100 full native comparisons plus six callback
state cases pass. Special callback/body admission remains gated; see
checkpoint/body-contact-implementation.md.
- [ ] Next verify successful fence/ladder completion, hazard/impulse, actor mode
persistence/control/facing and dynamic eligibility
before replacing the lab/outside capsule.27 dispatch cases establish eligibility
only; the unfinished successful-climb harness remains ignored investigation work.
- [x] Scooter feedback: Goddard gradually levels pitch/roll after tilted dismount;
engine uses missing source positional frequency/history correction.13 Scooter,
2 audio,10 Patrol and24 Python groups plus native input replays pass. See
gameplay/scooter-dismount-leveling.md and scooter-pitch.md. Audible/native
Windows comparison remains open; the recovered nominal engine formula stands.
- [x] Bounded liveVR08 Grappler: shared body context/full base callback, follow
camera, original rope/SWING/cursor/audio, ownership/RETURN/retained scalars,
normal/debug selection.13 managed groups/40 Python checks and9-phase native
Linux SDL replay pass. See gameplay/grappler-live.md for evidence and limits.
- [ ] Native Windows and whole-originalVR08 comparison; shared dynamic pairs,
special policies/other levels and non-RETURN attachment continuity remain open.
- [x] Scooter source wheel/support/contact recovery and bounded live VR05/LEV1:
separate vehicle, real4-wheel supports, normal owned-tile outside use, source
drive/impact/camera/pose/audio, summon/contact mount/cleanup and RETURN.53 native
component observations, managed integration and10-phase Linux SDL replays pass.
See gameplay/scooter-live.md; preserve parked general collision continuation.
- [ ] Scooter whole-original/native Windows comparison; mouse/analog/camera
modes2..20, special mission helpers, general dynamic pairs and retained LOAD/
save lifecycle remain open. Other levels require evidence before enabling.
Historical Grappler gates below were closed for boundedVR08 by this checkpoint;
component reports remain evidence, not current live status.
- [x] Grappler aim/root-Euler ray/first-hit material, normalized constraint and
post-base contact:42 additional original cases,72 total/10 managed/18 Python;
actualVR08 query and existing camera/Rocketship/GPU regressions pass.
- [x] Grappler live gates: carry shared sphere/contact context through attached
47B4B0 and43AA40; complete follow camera and rope/cursor presentation/lifetime,
then actualVR08 attach/reel/swing/detach/control-loss/RETURN. See grappler-query.md.
- [x] User-clarified orbit Left/Right inversion: reverse horizontal azimuth
mapping while preserving correct Up/Down and gameplay controls.
- [x] Grappler isolated attachment/reel/damping component:30 copied-original
observations,5 managed/14 Python checks plus25 movement/15 gadget groups pass.
- [x] Grappler next: complete retained REA/source findings from
artifacts/grappler-{ray,motion,resources}/, close body/camera/helper contracts
and compare original components before enabling boundedVR08. Investigators
reached usage limits; all file ownership returned to primary.
- [x] Correct orbit inspection's mirrored world: share gameplay handedness,
verify36 angle/elevation/aspect cases, GPU reflection and unchanged gameplay.
- [x] Correct user-reported Rocketship wall scaling: recover material RGBA
consumer, replace geometry deformation with red damage flash, regress actual
wall contact/per-vertex geometry/color through repeated impacts and expiry.
- [x] Live boundedVR02 Rocketship: source aircraft callbacks/support, owned actor
control, fresh/retained input order, maneuvers/camera, exact passenger/fire art,
engine audio, F1, cutscene/force-control/reset/noclip and distinct pickup/LOAD callers.
- [x]96 isolated original observations;14 flight/12 final integration groups;
native GTX1070/private Xvfb1920×1080 ten-phase SDL replay; full268 Python+2 HUD/
managed/33 GPU+17 material suite and539 unchanged original hashes.
- [x] Clean e77add5 Linux/Windows packages,18 resource files/four exact RGBA hashes;
standalone Linux ten-phase native replay and1920×1080 F1 Player-page readback.
- [ ] Rocketship outside VR02, special hazard/mission/RNG effects, general original
pair scheduling and full original/native Windows comparison. See live report.
- [x] User-requested F1→Player Give All Gadgets: grant all eight without selecting,
preserve other inventory, keep the32-line layout; debug-menu checks/build pass.
**Gadget component checkpoint2026-11-03:**
[Rocketship arithmetic/resources](gameplay/rocketship-component.md).
- [x] Use supplied decompiler leads with independent REA/source guards for
Rocketship owner/control/body dimensions, flight input/apply and VR02 filter.
- [x] Implement isolated keyboard/vertical components;13 managed groups compare
14 input+14 vertical copied-original observations and explicit boundaries.
- [x] Export exact Rocketship resources/VR02 records with5 checks; recover
Grappler attachment/material/swing/lifetime source with12 checks. Rocket source
3 checks, existing Gadget15/Movement25 and .NET10 build pass;539 hashes verify.
- [x] Close ordinary VR02 Rocketship callbacks, Euler/maneuver/camera and
owned/GAM reset/attachment gates; integrate actual art/audio, F1 and live control
with source RETURN/cutscene ownership regressions. General pair/lifetime remains bounded.
- [x] Close boundedVR08 Grappler ray/material context, attached dispatcher/camera/Euler and
helper lifetime before live mode7. No substitute hook/pull behavior.
Historical component-only claims are superseded for liveVR02 Rocketship and
liveVR08 Grappler. Scalar/query reports remain component evidence, not current
feature status; see gameplay/grappler-live.md.
**Supplied friend's decomp assessment completed2026-11-03.**
See [assessment](reviews/jn-engine-survey.md), independent gameplay/capture
reviews and the prepared local evidence request. No source import or gameplay
change. Same EXE/shared corpus, different declared OMT2.dll;208 class specs and
saved helper bodies are useful leads, prototype C gameplay is not authoritative.
For subsequent gadget work, cross-check target6's429D00/426A70 and Rocketship
report with local REA. Raw original traces, analysed Ghidra project, capture DLL
identity and offered code permission remain open; do not treat proposals as
delivered runtime evidence. Preserved port/release validation is unchanged.
**Current direction: user-requested gameplay gadgets; collision work parked.**
Preserve35a2a66 body implementation,0272f7b release notes and baseline69d0187.
Recover/implement original gadget selection/use with local REA and original art;
@@ -65,10 +181,38 @@ the resume backlog, not prerequisites imposed on this user-directed gadget work.
- [x] Managed/source/GPU checks and native Linux menu/ray input fixtures.
- [x] Rebuild clean7b5230c Linux/Windows gadget packages, verify54 canvases/new
manifests in both, and run standalone Linux menu/ray fixtures from /tmp.
- [ ] Other special gadget effects and equip cleanup, energy-warning audio,
enemy AI/reaction consumers and original/native Windows comparison.
- [x] Invisible source, timed activation/recharge/flash, original meter, companion
body/visibility and named-Jimmy cutscene cleanup; shared energy warning lifecycle.
- [x] Independent review,182 Python/15 Invisible managed groups, native Linux SDL
six-phase render at1920×1080; complete integration30 GPU+17 material checks pass.
- [x] Build clean1897dd2 Invisible Linux/Windows packages, check exact meter pixels
in both and standalone Linux six-phase/F1 widescreen renders from /tmp.
- [x] Recover Bubble visual/equip/drain/cleanup source contracts with REA/guards.
- [x] Recover Bubble movementmode2 input/apply, direct300/900 bounce, actualVR01
static/floor111 coverage and six copied-original body numeric references.
- [x] Implement original Canv1/effect/motion and boundedVR01 body/floor state;
13 integration/11 motion/8 visual groups and independent review pass.
- [x] Complete202 Python+2 HUD, managed,31 GPU+17 material and native1920×1080
SDL Bubble checks;539 original hashes unchanged.
- [x] Commit clean1ae5f42 Bubble milestone, rebuild Linux/Windows packages, verify
exact Canv1 pixels in both and standalone Linux gameplay/debug view from /tmp.
- [x] Recover Baseball equip/hold/release, owned20-slot pool, queued landing
impulse, exact original TIME font and VR07 moving-target/parent contracts.
- [x] Implement Baseball, original ball/aim rendering, F1 grant, bounded VR07
source body/targets, eleven integration/six visual groups; independent review.
- [x] Headless and native1920×1080 actual SDL aim/release/target-hit/respawn pass;
1010 extra complete player/target ticks are an explicit accelerated port fixture.
- [x] Complete232 Python+2 HUD/all managed/32 GPU+17 material regression; final
12-group Baseball callbacks and16 source groups pass;539 original hashes verify.
- [x] Clean d6ca417 Linux/Windows packages, all16 source canvas hashes in both,
standalone Linux eight-phase gameplay and widescreen F1 Player view from /tmp;
539 originals verify after packaging. Native Windows comparison remains open.
- [x] Save Scooter separate actor/mount/vehicle and original asset contracts;
wheel body/support lifecycle remains a gate before faithful live integration.
- [ ] Rocketship other-level/special consumers, Scooter, Remote and live Grappler; full enemy AI and
original/native Windows comparison. Retain collision/camera/retained-helper gates.
Details: [first gadget slice](gameplay/gadgets-implementation.md). Investigators
Details: [Baseball continuation](gameplay/baseball-implementation.md). Investigators
have returned all file ownership to primary. Complete final regression, native
Linux input and release checks pass; the remaining gadget effects are the next
gameplay backlog. Native Windows gadget verification remains open.
+43 -1
View File
@@ -15,6 +15,18 @@ for rid in linux-x64 win-x64; do
cp -a artifacts/extracted/ui/. "$out/scenes/ui/"
mkdir -p "$out/scenes/gadgets"
cp -a artifacts/extracted/gadgets/. "$out/scenes/gadgets/"
mkdir -p "$out/scenes/invisible-meter"
cp -a artifacts/extracted/invisible-meter/. "$out/scenes/invisible-meter/"
mkdir -p "$out/scenes/bubble"
cp -a artifacts/extracted/bubble/. "$out/scenes/bubble/"
mkdir -p "$out/scenes/baseball"
cp -a artifacts/extracted/baseball/. "$out/scenes/baseball/"
mkdir -p "$out/scenes/rocketship"
cp -a artifacts/extracted/rocketship/. "$out/scenes/rocketship/"
mkdir -p "$out/scenes/grappler"
cp -a artifacts/extracted/grappler/. "$out/scenes/grappler/"
mkdir -p "$out/scenes/scooter"
cp -a artifacts/extracted/scooter/. "$out/scenes/scooter/"
mkdir -p "$out/scenes/effects"
cp -a artifacts/extracted/effects/. "$out/scenes/effects/"
cp artifacts/extracted/scene-catalog.json "$out/scenes/scene-catalog.json"
@@ -39,7 +51,7 @@ for rid in linux-x64 win-x64; do
printf 'packaged_utc=%s\n' "$(date -u +%FT%TZ)"
} > "$out/BUILD-INFO.txt"
cat > "$out/README.md" <<'NOTES'
# Neutron lab story, gadgets and jet pack checkpoint
# Neutron lab story and gadgets checkpoint
Linux: run ./launch-scene.sh. Windows: run launch-scene.cmd.
Append --headless --frames 2 to render without a window, or --screenshot lab.ppm
@@ -52,6 +64,15 @@ F1 opens debug tools: arrows navigate/change, Enter applies, Tab switches pages,
F1/Escape closes. General/Player/Systems pages cover implemented runtime controls.
The menu pauses gameplay/audio and provides diagnostics, camera/cutscene controls,
energy/jetpack/task changes, level/start selection, reset and Force Control toggle.
F1 -> Player -> Give/Select Grappler equips it in VR08. Its Practice tile opens
that tutorial. Aim at a surface until the target appears; hold Enter/Ctrl/left
mouse to attach/reel, arrows steer, release fire and jump to detach. Tab/Space
unequips. Grappler is currently limited to VR08.
Scooter works normally in VR05 and outside: select its owned gadget tile or
F1/Player Give/Select Scooter, then walk into it at Goddard to mount. Up/primary
fire accelerates, Left/Right steers, Down brakes then reverses, jump jumps.
Tab/Space unequips, restores Goddard and stops the engine. Give All Gadgets grants
the normal tile too. See docs/gameplay/scooter-live.md for source and limits.
Player/Systems add input ordering, jetpack availability, objective/practice, camera
obstruction, audio category mutes and debug checkpoint save/load. Checkpoints save
level/start/progression, not live position; see docs/debug-menu.md.
@@ -70,6 +91,27 @@ Practice Mode plus an owned gadget opens its tutorial. The combined shrink-ray/
jetpack pickup fires on Enter/Ctrl/left mouse and bursts on jump. Original Yokian
soldiers support the shrink morph,30-second restoration and10-point reward.
Other gadget effects and full enemy AI/combat remain incomplete.
Invisible is now implemented: select its owned tile, wait7 seconds to recharge,
then fire without jump for a7-second effect costing2 energy (tutorials exempt).
F1/Player can Give/Select Invisible, Unequip, and show its timers/targetability.
The original meter and final3-second flashing are included; enemy sensing remains
incomplete. Source warning sounds for low/empty energy are shared by gadgets.
Bubble is implemented too: F1/Player can Give/Select Bubble, Up or primary fire
accelerates, arrows steer, and jump holds produce higher bounces. Tab/Space first
unequips it, then the original sprite fades. VR01 uses recovered static body and
floor111 behavior; lab/outside still have provisional collision.
Baseball is implemented: F1/Player can Give/Select Baseball. Hold Enter/Ctrl/left
mouse, Up/Down changes elevation and Left/Right turns; release fire to throw.
Its owned tile's Practice Mode opens VR07 with original moving targets,15-second
respawn and source trophy activation. Original ball/crosshair/TIME glyphs scale
uniformly on widescreen. Full enemy combat and original pair scheduling remain
incomplete; flying balls and a pending throw can survive unequipping.
Rocketship flight is implemented in VR02. Select its Practice tile, then equip
it there with Tab/Space or F1/Player Give/Select Rocketship. Up/right mouse
accelerates and climbs, Down brakes and descends, Left/Right banks. Enter/T
performs a180-degree turn and R barrel rolls; Tab/Space unequips. R remains
reset when unmounted. Aircraft body/camera and source driver/Goddard/flame art
are included; other levels and special mission/hazard sequences remain open.
Append --inspect to start directly in the old scene inspector.
The default runs the recovered lab camera/speech sequence; Escape/Space skips
its actions and restores control. --skip-intro starts with control; --mute disables
+32
View File
@@ -6,13 +6,31 @@ python3 tools/extractors/prepare.py --all-scenes --audio sounds musicsecretlab
dotnet run --project tests/GamePort.DataTests -- ../Original
dotnet run --project tests/GamePort.CollisionTests -- ../Original
dotnet run --project tests/GamePort.MovementTests -- ../Original
dotnet run --project tests/GamePort.JimmyGroundTests
dotnet run --project tests/GamePort.JimmyAirTests
dotnet run --project tests/GamePort.JimmyOrientationTests
dotnet run --project tests/GamePort.JimmyRenderTests
dotnet run --project tests/GamePort.JimmyJumpTests
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.SphereResponseTests
dotnet run --project tests/GamePort.StaticCollisionTests
dotnet run --project tests/GamePort.BodyPhysicsTests
dotnet run --project tests/GamePort.BodyOwnershipTests
dotnet run --project tests/GamePort.GadgetTests
dotnet run --project tests/GamePort.InvisibleTests
dotnet run --project tests/GamePort.BubbleMotionTests
dotnet run --project tests/GamePort.BubbleVisualTests
dotnet run --project tests/GamePort.BubbleTests
dotnet run --project tests/GamePort.BaseballTests
dotnet run --project tests/GamePort.BaseballVisualTests
dotnet run --project tests/GamePort.RocketFlightTests
dotnet run --project tests/GamePort.RocketshipTests
dotnet run --project tests/GamePort.GrapplerLiveTests
dotnet run --project tests/GamePort.ScooterTests
dotnet run --project tests/GamePort.ScooterAudioTests
dotnet run --project tests/GamePort.GrapplerTests
dotnet run --project tests/GamePort.HeadingTests
dotnet run --project tests/GamePort.BlendTests
dotnet run --project tests/GamePort.CameraRayTests
@@ -53,6 +71,13 @@ dotnet run --no-build -- --headless --smoke-objective-panel --story-time 1 --scr
dotnet run --no-build -- --headless --smoke-objective-panel --story-time 9 --screenshot artifacts/test-objective-hidden.ppm
dotnet run --no-build -- --headless --scene artifacts/extracted/VR04/scene.json --level gam/VR04.gam --smoke-jetpack --screenshot artifacts/test-jetpack.ppm
dotnet run --no-build -- --headless --scene artifacts/extracted/VR04/scene.json --level gam/VR04.gam --smoke-shrink-ray --screenshot artifacts/test-shrink-ray.ppm
dotnet run --no-build -- --headless --scene artifacts/extracted/VR03/scene.json --level gam/VR03.gam --smoke-invisible --screenshot artifacts/test-invisible.ppm
dotnet run --no-build -- --headless --scene artifacts/extracted/VR01/scene.json --level gam/VR01.gam --smoke-bubble --screenshot artifacts/test-bubble.ppm
dotnet run --no-build -- --headless --scene artifacts/extracted/VR07/scene.json --level gam/VR07.gam --smoke-baseball --screenshot artifacts/test-baseball.ppm
dotnet run --no-build -- --headless --scene artifacts/extracted/VR08/scene.json --level gam/VR08.gam --smoke-grappler --screenshot artifacts/test-grappler.ppm
dotnet run --no-build -- --headless --scene artifacts/extracted/VR02/scene.json --level gam/VR02.gam --smoke-rocketship --screenshot artifacts/test-rocketship.ppm
dotnet run --no-build -- --headless --scene artifacts/extracted/VR05/scene.json --level gam/VR05.gam --smoke-scooter --screenshot artifacts/test-scooter-vr05.ppm
dotnet run --no-build -- --headless --scene artifacts/extracted/level1/scene.json --level gam/level1.gam --start school1 --smoke-scooter --screenshot artifacts/test-scooter-outside.ppm
dotnet run --no-build -- --headless --skip-intro --write-save artifacts/test-checkpoint.tsk
dotnet run --no-build -- --headless --load-save artifacts/test-checkpoint.tsk --skip-intro
dotnet run --no-build -- --headless --story --scene artifacts/extracted/VR01/scene.json --level gam/VR01.gam --smoke-transition --skip-intro
@@ -69,6 +94,13 @@ SDL_AUDIODRIVER=dummy dotnet run --no-build -- --scene-audio-smoke artifacts/ext
SDL_AUDIODRIVER=dummy dotnet run --no-build -- --cutscene-audio-smoke artifacts/extracted/level1b/entities/entities.json
python3 tools/recon/inventory.py ../Original --verify docs/original-manifest.json
if [[ "${NEUTRON_WINDOW_TEST:-0}" == 1 ]]; then
dotnet run --no-build -- --scene artifacts/extracted/VR05/scene.json --level gam/VR05.gam --smoke-scooter --width 1920 --height 1080 --screenshot artifacts/test-scooter-vr05-window.ppm
dotnet run --no-build -- --scene artifacts/extracted/level1/scene.json --level gam/level1.gam --start school1 --smoke-scooter --width 1920 --height 1080 --screenshot artifacts/test-scooter-outside-window.ppm
dotnet run --no-build -- --scene artifacts/extracted/VR08/scene.json --level gam/VR08.gam --smoke-grappler --width 1920 --height 1080 --screenshot artifacts/test-grappler-window.ppm
dotnet run --no-build -- --scene artifacts/extracted/VR02/scene.json --level gam/VR02.gam --smoke-rocketship --width 1920 --height 1080 --screenshot artifacts/test-rocketship-window.ppm
dotnet run --no-build -- --scene artifacts/extracted/VR07/scene.json --level gam/VR07.gam --smoke-baseball --width 1920 --height 1080 --screenshot artifacts/test-baseball-window.ppm
dotnet run --no-build -- --scene artifacts/extracted/VR01/scene.json --level gam/VR01.gam --smoke-bubble --width 1920 --height 1080 --screenshot artifacts/test-bubble-window.ppm
dotnet run --no-build -- --scene artifacts/extracted/VR03/scene.json --level gam/VR03.gam --smoke-invisible --width 1920 --height 1080 --screenshot artifacts/test-invisible-window.ppm
dotnet run --no-build -- --smoke-gadget-menu --width 1920 --height 1080 --screenshot artifacts/test-gadget-menu-window.ppm
dotnet run --no-build -- --scene artifacts/extracted/VR04/scene.json --level gam/VR04.gam --smoke-shrink-ray --screenshot artifacts/test-shrink-ray-window.ppm
dotnet run --no-build -- --smoke-debug-tools
@@ -0,0 +1,76 @@
using System.Numerics;
using GamePort.Assets;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Source stationary crosshair strip and prior-capture pitch label.
/// Original TIME set5 glyphs preserve their green pixels and null-space advance. UiViewport supplies the port's uniform centered widescreen policy.</summary>
public sealed class BaseballAimOverlay
{
private static readonly Dictionary<int,(int Width,int Height,string Hash)> Expected = new()
{
[253]=(15,210,"2e16e11b151c8474ba68fd5017d1a3a6304a594a7f34c3b423f3417c7edfb453"),
[118]=(16,16,"edc60e65dcf7320813a80d4312e3c45951ccfc566ea79dfabf7a22ebc4b96049"),
[127]=(16,16,"1fd058ad5bdc0f8a064ef7d2d52b2b036df3f35515691a366799d7e8aab5297f"),
[120]=(16,16,"62aaeaaf107300a6f4f7ff52e98106c1520a9edbe2137626ee41091cf243e5c5"),
[121]=(16,16,"d78bf1895f5838b9eb8c6a22565a9588dae4fc8f7106697df373f4408aae634c"),
[122]=(16,16,"f6d628639de4e40005f62f63a49308ff9ee0656a36bb6eb7787230b4830a5ed9"),
[123]=(16,16,"9f58cad5621d89b7a7012036daa8532b2397b0d9d267ab7d1aa5a7cd10d7ae87"),
[124]=(16,16,"49cdc9ec812f4ef3826011d542c30afbb10229c4b4ce549e7820233bbaa53dd9"),
[125]=(16,16,"aaef2d59c2636c059b446bed643985ca55d15b2d070b0582b2d8994b3bf74f1e"),
[126]=(16,16,"bade574a4624a3f763ddd9c87fa2f102562b00d8d604e9faf32a43b372de64e0"),
[119]=(16,16,"0a663ddf2df9f1065f5e4ffe27b4d1fa96edd5f19b6323217bad4148f8d2f3d7")
};
private static readonly int[] DigitIds = [118,127,120,121,122,123,124,125,126,119];
private readonly int[] offsets = new int[21];
private readonly uint[] firstIndices = new uint[21];
public Mesh Mesh { get; }
public BaseballAimOverlay(Mesh combined, string preparedRoot)
{
var images = BaseballResourcePixels.Load(preparedRoot,"aimTextures",Expected);
var builder = new BaseballQuadBuilder(combined);
(offsets[0],firstIndices[0]) = builder.AddQuad(builder.AddTexture(images[253]),true);
//TextureId is immutable. Two banks of ten digit quads select exact glyphs
//without modifying shared draws or allocating per-frame geometry.
for(var digit=0;digit<10;digit++)
{
var texture=builder.AddTexture(images[DigitIds[digit]]);
for(var place=0;place<2;place++)
{
var index=1+place*10+digit;
(offsets[index],firstIndices[index])=builder.AddQuad(texture,true);
}
}
Mesh=builder.Build();
}
public void Update(Mesh destination, BaseballGadget device, uint width, uint height)
{
if(destination.Vertices.Length<offsets.Max()+4)throw new ArgumentException("Destination omits Baseball aim vertices",nameof(destination));
var viewport=new UiViewport(width,height);
var pitch=device.DisplayPitch;
if(!float.IsFinite(pitch)||pitch<0||pitch>45)throw new ArgumentOutOfRangeException(nameof(device),"Source pitch label must remain0..45");
var number=(int)pitch;
var y=(int)((45-(double)pitch)*4.3+100);
Quad(0,new(315,100),new(15,210),device.AimVisible);
for(var digit=0;digit<10;digit++)
{
//TIME set5 has a null space pointer; source468939 skips both
//drawing and advance for the positive sign blank.
Quad(1+digit,new(286,y),new(16,16),device.AimVisible&&digit==number/10);
Quad(11+digit,new(302,y),new(16,16),device.AimVisible&&digit==number%10);
}
void Quad(int index,Vector2 position,Vector2 size,bool visible)
{
var draw=destination.Draws.First(d=>d.ScreenSpace&&d.FirstIndex==firstIndices[index]&&d.IndexCount==6);
draw.Visible=visible;
if(!visible)return;
var p=position+viewport.CenterOffset;
var corners=new[]{p,p+new Vector2(size.X,0),p+size,p+new Vector2(0,size.Y)};
for(var corner=0;corner<4;corner++)
destination.Vertices[offsets[index]+corner].Position=viewport.ToNdc(corners[corner]);
}
}
}
+72
View File
@@ -0,0 +1,72 @@
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Actual VR07 input fixture. Extra ticks run ordinary body, input,
/// target-frame and director paths; no actor relocation or timer mutation.</summary>
public sealed class BaseballSmoke
{
private readonly LabSimulation player;
private readonly PlayerSceneBinding binding;
private readonly SceneInventory inventory;
private readonly SceneBaseballs scene;
private readonly SceneDirector director;
private readonly bool[] checks=new bool[8];
private readonly float initialEnergy;
private int extraTicks;
private bool hitObserved;
public BaseballSmoke(LabSimulation player,PlayerSceneBinding binding,SceneInventory inventory,
SceneBaseballs scene,SceneDirector director)
{
this.player=player;this.binding=binding;this.inventory=inventory;this.scene=scene;this.director=director;
initialEnergy=player.Energy;
inventory.SetState(0,6,1);inventory.SelectGadget(6);
}
public void BeforeFrame(int count,Action<uint,bool> key,bool headless)
{
if(count==1&&!headless){key(224,true);key(80,true);}
if(count==2&&!headless){key(80,false);key(82,true);}
if(count==3&&!headless){key(224,false);key(82,false);}
if(count is 4 or 5)Advance(40);
if(count==6){if(headless)inventory.SelectGadget(-1);else key(43,true);}
if(count==7)
{
if(!headless)key(43,false);
Advance(930);
}
}
private void Advance(int ticks)
{
for(var i=0;i<ticks;i++)
{
scene.StepBodies(FixedStepClock.Step);
binding.Step(default);
scene.StepTargets(FixedStepClock.Step);
director.Step(FixedStepClock.Step);
hitObserved|=scene.Hits>0;
extraTicks++;
}
}
public void AfterFrame(int count)
{
var gadget=player.Baseball;
if(count==0)checks[0]=gadget.Equipped&&player.GadgetMode==6&&!gadget.PendingThrow;
if(count==1)checks[1]=gadget.PendingThrow&&gadget.AimVisible&&gadget.SavedPitch==0;
if(count==2)checks[2]=gadget.PendingThrow&&gadget.AimVisible&&gadget.SavedPitch>10&&gadget.DisplayPitch==0;
if(count==3)checks[3]=gadget.Throws==1&&!gadget.PendingThrow&&!gadget.AimVisible&&gadget.Projectiles[0].Visible;
if(count==4)checks[4]=gadget.Projectiles[0].Visible&&gadget.Projectiles[0].Position!=gadget.Projectiles[0].PreviousPosition;
if(count==5)checks[5]=scene.Hits>0&&scene.Targets.Any(t=>t.Remaining>0&&!t.Actor.Visible);
if(count==6)checks[6]=player.GadgetMode==-1&&!gadget.Equipped&&gadget.Projectiles.Any(b=>b.Visible);
if(count==7)checks[7]=hitObserved&&scene.Targets.All(t=>t.Remaining==0&&t.Actor.Visible);
}
public bool Passed=>checks.All(v=>v)&&player.Energy==initialEnergy;
public string Report=>$"Baseball fixture: equipped={checks[0]}, arm={checks[1]}, prior-label/capture={checks[2]}, release={checks[3]}, flight={checks[4]}, actual target hit={checks[5]}, unequip retains ball={checks[6]}, respawn={checks[7]}, hits={scene.Hits}, recovered={scene.Recovered}, extra full player/target ticks={extraTicks}, energy={player.Energy:F3}/{initialEnergy:F3}.";
public static PlayerInput Input(int count)=>new(count==2,false,count==1,false,false,Fire:count is 1 or 2);
public static string? StageName(int count)=>count switch
{0=>"equipped",1=>"arm",2=>"aim",3=>"throw",4=>"flight",5=>"hit",6=>"unequip",7=>"respawn",_=>null};
}
+125
View File
@@ -0,0 +1,125 @@
using System.Numerics;
using System.Security.Cryptography;
using System.Text.Json;
using GamePort.Assets;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Source25-unit ball sprites. Camera-facing centered quads are a
/// declared port policy; frame selection belongs to source gameplay state.</summary>
public sealed class BaseballVisuals
{
private readonly int[] offsets = new int[20];
private readonly uint[] firstIndices = new uint[20];
private readonly Dictionary<int, int> textures = [];
public Mesh Mesh { get; }
public BaseballVisuals(Mesh combined, string preparedRoot)
{
var resources = BaseballResourcePixels.Load(preparedRoot, "textures", BaseballResourcePixels.Balls);
var builder = new BaseballQuadBuilder(combined);
foreach (var (id, image) in resources.Where(p => p.Key is >= 2 and <= 5))
textures.Add(id, builder.AddTexture(image));
for (var i = 0; i < 20; i++)
(offsets[i], firstIndices[i]) = builder.AddQuad(textures[2], false);
Mesh = builder.Build();
}
public void Update(Mesh destination, IReadOnlyList<BaseballProjectile> balls, Vector3 eye, Vector3 target)
{
if (balls.Count > 20) throw new ArgumentException("Baseball source pool contains20 slots", nameof(balls));
if (destination.Vertices.Length < offsets[^1] + 4) throw new ArgumentException("Destination omits Baseball vertices", nameof(destination));
if (!Finite(eye) || !Finite(target)) throw new ArgumentException("Baseball camera must be finite");
var direction = target - eye;
direction = direction.LengthSquared() < .000001f ? Vector3.UnitZ : Vector3.Normalize(direction);
var right = Vector3.Cross(Vector3.UnitY, direction);
right = right.LengthSquared() < .000001f ? Vector3.UnitX : Vector3.Normalize(right);
var up = Vector3.Normalize(Vector3.Cross(direction, right));
var x = right * 12.5f; var y = up * 12.5f;
for (var i = 0; i < 20; i++)
{
var draw = destination.Draws.First(d => !d.ScreenSpace && d.FirstIndex == firstIndices[i] && d.IndexCount == 6);
draw.Visible = i < balls.Count && balls[i].Visible;
if (!draw.Visible) continue;
var ball = balls[i];
if (!Finite(ball.Position)) throw new ArgumentException("Baseball position must be finite", nameof(balls));
if (!textures.TryGetValue(ball.CanvasId, out var texture) || texture != draw.TextureId)
throw new InvalidDataException("Baseball frame differs from its fixed source canvas2");
var p = ball.Position; var offset = offsets[i];
destination.Vertices[offset] = new(p-x-y, new(0,1), Vector3.One);
destination.Vertices[offset+1] = new(p+x-y, new(1,1), Vector3.One);
destination.Vertices[offset+2] = new(p+x+y, new(1,0), Vector3.One);
destination.Vertices[offset+3] = new(p-x+y, new(0,0), Vector3.One);
}
}
private static bool Finite(Vector3 value) => float.IsFinite(value.X) && float.IsFinite(value.Y) && float.IsFinite(value.Z);
}
internal static class BaseballResourcePixels
{
internal static readonly Dictionary<int,(int Width,int Height,string Hash)> Balls = new()
{
[2]=(32,32,"68904b758e69139de0b01329b2a9844ecd2a466f31598c24324affaccfa2cab9"),
[3]=(32,32,"005def070e18111fbdb067e75285dad8ec677c1608020f55c3db7a4b9745205c"),
[4]=(32,32,"c368a59d5d7a57824c1c6b56b617cf058f5d5d53e18e5e48989710413490c536"),
[5]=(32,32,"e5da21c359d3215759e5c3c238107f526f7109203c0ff9fa391a3c8bc40c17ed"),
[8]=(64,64,"8d31014cb9b9661ebed902c864bf740f562460e74da3f6b86ed3d2be4d10f0ec")
};
internal static Dictionary<int,PngImage> Load(string preparedRoot, string array,
IReadOnlyDictionary<int,(int Width,int Height,string Hash)> expected)
{
var manifest = Path.GetFullPath(Path.Combine(preparedRoot,"baseball/baseball.json"));
if (new FileInfo(manifest).Length > 256*1024) throw new InvalidDataException("Baseball manifest exceeds limit");
using var document = JsonDocument.Parse(File.ReadAllBytes(manifest), new JsonDocumentOptions { MaxDepth=12 });
var root = document.RootElement;
if (root.GetProperty("schema").GetInt32()!=1 || root.GetProperty(array).GetArrayLength()!=expected.Count)
throw new InvalidDataException("Unsupported Baseball resources");
var directory = Path.GetDirectoryName(manifest)!;
var result = new Dictionary<int,PngImage>();
foreach (var entry in root.GetProperty(array).EnumerateArray())
{
var id = entry.GetProperty("id").GetInt32();
if (!expected.TryGetValue(id,out var source) || result.ContainsKey(id)
|| entry.GetProperty("width").GetInt32()!=source.Width || entry.GetProperty("height").GetInt32()!=source.Height
|| entry.GetProperty("rgbaSha256").GetString()!=source.Hash)
throw new InvalidDataException("Invalid original Baseball canvas");
var path = Path.GetFullPath(Path.Combine(directory,entry.GetProperty("path").GetString()!));
if (!path.StartsWith(directory+Path.DirectorySeparatorChar,StringComparison.Ordinal)
|| new FileInfo(path).Length != source.Width*source.Height*4)
throw new InvalidDataException("Invalid Baseball pixel path/length");
var pixels = File.ReadAllBytes(path);
if (Convert.ToHexStringLower(SHA256.HashData(pixels))!=source.Hash)
throw new InvalidDataException("Baseball pixels differ from original canvas");
result.Add(id,new((uint)source.Width,(uint)source.Height,pixels));
}
return result;
}
}
internal sealed class BaseballQuadBuilder(Mesh source)
{
private readonly List<MeshVertex> vertices = source.Vertices.ToList();
private readonly List<uint> indices = source.Indices.ToList();
private readonly List<MeshDraw> draws = source.HasExplicitDraws ? source.Draws.ToList()
: source.Indices.Length == 0 ? [] : [new(0,(uint)source.Indices.Length,-1)];
private readonly Dictionary<int,PngImage> textures = new(source.Textures);
internal int AddTexture(PngImage image)
{
var id=int.MinValue+17000; while(textures.ContainsKey(id))id++;
textures.Add(id,image); return id;
}
internal (int Offset,uint FirstIndex) AddQuad(int texture, bool screen)
{
var offset=vertices.Count; var first=(uint)indices.Count; var vertex=(uint)offset;
vertices.AddRange([new(Vector3.Zero,new(0,0),Vector3.One),new(Vector3.Zero,new(1,0),Vector3.One),
new(Vector3.Zero,new(1,1),Vector3.One),new(Vector3.Zero,new(0,1),Vector3.One)]);
indices.AddRange([vertex,vertex+1,vertex+2,vertex,vertex+2,vertex+3]);
draws.Add(new(first,6,texture){Visible=false,ScreenSpace=screen,Blend=MeshBlend.Alpha});
return(offset,first);
}
internal Mesh Build() => new(vertices.ToArray(),indices.ToArray()) { HasExplicitDraws=true, Draws=draws.ToArray(),
Textures=textures, CollisionPolygons=source.CollisionPolygons, HasCollisionMaterialIds=source.HasCollisionMaterialIds };
}
+133
View File
@@ -0,0 +1,133 @@
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Eight rendered port-verification phases, with accelerated full
/// player ticks between them. This is an input fixture, not original cadence.</summary>
public sealed class BubbleSmoke
{
private readonly LabSimulation player;
private readonly SceneInventory inventory;
private readonly bool[] checks = new bool[8];
private readonly float initialEnergy;
private float? supportedRootY;
private int acceleratedTicks, boingSounds, bouncesBeforeHeld, soundsBeforeHeld;
public BubbleSmoke(LabSimulation player, SceneInventory inventory)
{
this.player = player;
this.inventory = inventory;
initialEnergy = player.Energy;
player.GadgetSound += (id, _) => { if (id == 106) boingSounds++; };
inventory.SetState(0, 0, 1);
inventory.SelectGadget(0);
if (player.GadgetMode != 0 || player.MovementMode != 2 || player.InteractionRadius != 160
|| MathF.Abs(player.BodyFactor - .415f) > .00001f || player.MaximumSpeed != 1350
|| !player.Bubble.Expanding)
throw new InvalidOperationException("Bubble fixture requires a connected, eligible mode0/movement2 player binding with radius160/factor.415/max1350");
}
public void BeforeFrame(int count, Action<uint, bool> injectKey, bool headless)
{
if (count == 1) Advance(80);
if (count == 2 && !headless)
{
injectKey(224, true); //Left Ctrl: shared primary-fire throttle.
injectKey(80, true); //Left arrow: airborne steering.
}
if (count == 3)
{
PrepareLanding();
bouncesBeforeHeld = player.BubbleBounces;
soundsBeforeHeld = boingSounds;
//The next ordinary application tick consumes this SDL event.
//Never advance the jump helper before actual input processing.
if (!headless) injectKey(225, true);
}
if (count == 4 && !headless)
{
injectKey(224, false);
injectKey(80, false);
injectKey(225, false);
}
if (count == 5)
{
//Release near the next support contact so the fixed captured
//sprite remains in view while its source-owned fade runs.
PrepareLanding();
if (headless) inventory.SelectGadget(-1);
else injectKey(43, true);
}
if (count == 6)
{
if (!headless) injectKey(43, false);
Advance(40);
}
if (count == 7) Advance(40);
}
private void Advance(int count)
{
for (var i = 0; i < count; i++) Tick();
}
private void Tick()
{
player.Step(default);
acceleratedTicks++;
ObserveSupport();
}
private void ObserveSupport()
{
//Read the actual supported root; initial placement's Grounded flag is
//not an observed floor height until at least one real player tick.
if (player.Grounded) supportedRootY = player.ActorRoot.Y;
}
private void PrepareLanding()
{
for (var i = 0; i < 600; i++)
{
var predictedY = player.ActorRoot.Y
+ (player.Velocity.Y - 800 * FixedStepClock.Step) * FixedStepClock.Step;
if (supportedRootY is { } floor && player.Velocity.Y < 0 && predictedY <= floor) return;
Tick();
}
throw new InvalidOperationException($"Bubble fixture could not find an imminent supported landing within600 full player ticks: rootY={player.ActorRoot.Y:F4}, velocityY={player.Velocity.Y:F4}, last supported rootY={supportedRootY?.ToString("F4") ?? "unobserved"}");
}
public void AfterFrame(int count)
{
ObserveSupport();
var effect = player.Bubble;
if (count == 0) checks[0] = effect.Expanding && effect.Visible && !effect.Active
&& effect.Color.X > 0 && effect.Color.X < 1;
if (count == 1) checks[1] = effect.Active && !effect.Expanding && effect.Visible
&& effect.Width == 240 && effect.Height >= 210 && effect.Height <= 270;
if (count == 2) checks[2] = player.GadgetMode == 0 && player.MovementMode == 2
//The first subdegree negative AddEuler can normalize to360;
//sustained negative lean is covered by the managed integration test.
&& player.Speed > 0 && player.TurnRate > 0 && MathF.IEEERemainder(player.Pitch,360) <= 0 && !player.Shooting;
if (count == 3) checks[3] = player.BubbleBounces > bouncesBeforeHeld
&& MathF.Abs(player.Velocity.Y - 900) < .001f && boingSounds > soundsBeforeHeld;
if (count == 4) checks[4] = player.GadgetMode == 0 && effect.Active && !player.Shooting;
if (count == 5) checks[5] = player.GadgetMode == -1 && player.MaximumSpeed == 650
&& player.InteractionRadius == 60 && MathF.Abs(player.BodyFactor - 1.265f) < .00001f
&& effect.Collapsing && !effect.Active && !effect.Expanding;
if (count == 6) checks[6] = effect.Visible && effect.Collapsing && effect.Color.X > 0
&& effect.Color.X < 1 && effect.Color.X == effect.Color.Y && effect.Color.X == effect.Color.Z
&& effect.Color.X == effect.Color.W;
if (count == 7) checks[7] = !effect.Visible && !effect.Collapsing && effect.Color == System.Numerics.Vector4.Zero;
}
private bool EnergyPreserved => !player.IgnoresGadgetEnergy || player.Energy == initialEnergy;
public bool Passed => checks.All(value => value) && EnergyPreserved;
public string Report => $"Bubble fixture: expanding={checks[0]}, active={checks[1]}, fire/left throttle={checks[2]}, held support900/SFX106={checks[3]}, input release={checks[4]}, cleanup650={checks[5]}, fullRGBA fade={checks[6]}, hidden={checks[7]}, accelerated player ticks={acceleratedTicks}, boing sounds={boingSounds}, level={player.LevelCode}, energy={player.Energy:F3}/{initialEnergy:F3}, tutorial energy preserved={EnergyPreserved}.";
public static string? StageName(int count) => count switch
{ 0 => "expand", 1 => "active", 2 => "steer", 3 => "high-bounce", 5 => "release", 6 => "fade", 7 => "hidden", _ => null };
public static PlayerInput Input(int count) => new(false, false, count is 2 or 3, false,
count == 3, Fire: count is 2 or 3);
}
+86
View File
@@ -0,0 +1,86 @@
using System.Numerics;
using System.Security.Cryptography;
using System.Text.Json;
using GamePort.Assets;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Original Canv1 world quad with full RGBA fade. Camera-facing basis
/// and center alignment are declared port policies pending original render recovery.</summary>
public sealed class BubbleVisuals
{
private const string PixelHash = "a3a678c47c1ce94946b1136560a84f3ef86c6884b981256a9fbff62fe8a988e4";
private readonly int offset;
private readonly uint firstIndex;
public Mesh Mesh { get; }
public BubbleVisuals(Mesh combined, string preparedRoot)
{
var manifest = Path.GetFullPath(Path.Combine(preparedRoot, "bubble/bubble.json"));
if (new FileInfo(manifest).Length > 16 * 1024) throw new InvalidDataException("Bubble manifest exceeds limit");
using var document = JsonDocument.Parse(File.ReadAllBytes(manifest), new JsonDocumentOptions { MaxDepth = 10 });
var root = document.RootElement;
if (root.GetProperty("schema").GetInt32() != 1 || root.GetProperty("textures").GetArrayLength() != 1)
throw new InvalidDataException("Unsupported Bubble resource format");
var entry = root.GetProperty("textures")[0];
if (entry.GetProperty("id").GetInt32() != 1 || entry.GetProperty("name").GetString() != "orangebubble"
|| entry.GetProperty("width").GetInt32() != 146 || entry.GetProperty("height").GetInt32() != 146
|| entry.GetProperty("rgbaSha256").GetString() != PixelHash)
throw new InvalidDataException("Invalid source Bubble canvas");
var directory = Path.GetDirectoryName(manifest)!;
var path = Path.GetFullPath(Path.Combine(directory, entry.GetProperty("path").GetString()!));
if (!path.StartsWith(directory + Path.DirectorySeparatorChar, StringComparison.Ordinal)
|| new FileInfo(path).Length != 146 * 146 * 4)
throw new InvalidDataException("Invalid Bubble pixel path/length");
var rgba = File.ReadAllBytes(path);
if (!Convert.ToHexStringLower(SHA256.HashData(rgba)).Equals(PixelHash, StringComparison.Ordinal))
throw new InvalidDataException("Bubble decoded pixels differ from the original canvas");
offset = combined.Vertices.Length;
firstIndex = (uint)combined.Indices.Length;
var textures = new Dictionary<int, PngImage>(combined.Textures);
var textureId = int.MinValue + 16000;
while (textures.ContainsKey(textureId)) textureId++;
textures.Add(textureId, new(146, 146, rgba));
var vertices = combined.Vertices.ToList();
vertices.AddRange([new(Vector3.Zero, new(0, 1), Vector3.One), new(Vector3.Zero, new(1, 1), Vector3.One),
new(Vector3.Zero, new(1, 0), Vector3.One), new(Vector3.Zero, new(0, 0), Vector3.One)]);
var first = (uint)offset;
var indices = combined.Indices.ToList();
indices.AddRange([first, first + 1, first + 2, first, first + 2, first + 3]);
var draws = combined.Draws.ToList();
if (!combined.HasExplicitDraws && firstIndex != 0) draws.Add(new(0, firstIndex, -1));
draws.Add(new(firstIndex, 6, textureId) { Visible = false, Blend = MeshBlend.Additive });
Mesh = new(vertices.ToArray(), indices.ToArray()) { HasExplicitDraws = true, Draws = draws.ToArray(),
Textures = textures, CollisionPolygons = combined.CollisionPolygons,
HasCollisionMaterialIds = combined.HasCollisionMaterialIds };
}
public void Update(Mesh destination, BubbleEffect effect, Vector3 root, Vector3 eye, Vector3 target)
{
if (destination.Vertices.Length < offset + 4)
throw new ArgumentException("Destination omits Bubble vertices", nameof(destination));
var draw = destination.Draws.First(d => !d.ScreenSpace && d.FirstIndex == firstIndex && d.IndexCount == 6);
draw.Visible = effect.Visible;
draw.Blend = effect.ConventionalBlend ? MeshBlend.Alpha : MeshBlend.Additive;
draw.Opacity = effect.Color.W;
if (!draw.Visible) return;
if (!Finite(root) || !Finite(eye) || !Finite(target))
throw new ArgumentException("Bubble root and camera must be finite");
var direction = target - eye;
if (direction.LengthSquared() < .000001f) direction = Vector3.UnitZ;
direction = Vector3.Normalize(direction);
var right = Vector3.Cross(Vector3.UnitY, direction);
right = right.LengthSquared() < .000001f ? Vector3.UnitX : Vector3.Normalize(right);
var up = Vector3.Normalize(Vector3.Cross(direction, right));
var x = right * (effect.Width * .5f);
var y = up * (effect.Height * .5f);
var color = new Vector3(effect.Color.X, effect.Color.Y, effect.Color.Z);
destination.Vertices[offset] = new(root - x - y, new(0, 1), color);
destination.Vertices[offset + 1] = new(root + x - y, new(1, 1), color);
destination.Vertices[offset + 2] = new(root + x + y, new(1, 0), color);
destination.Vertices[offset + 3] = new(root - x + y, new(0, 0), color);
}
private static bool Finite(Vector3 value) => float.IsFinite(value.X) && float.IsFinite(value.Y) && float.IsFinite(value.Z);
}
+25 -7
View File
@@ -7,7 +7,8 @@ namespace GamePort.Application;
public sealed record DebugScene(string LevelFile, string Code, string[] Starts);
public enum DebugAction { None, Resume, Camera, SkipCutscene, RefillEnergy, GiveJetpack, ApplySceneTask, LoadScene, Reset, ForceControl, ToggleOverlay,
Noclip, NoclipSpeed, StopMotion, ShowObjective, ReturnNoclipEntry, LevelAvailability, InputOrder, ApplyJetpackState,
CameraObstruction, MuteMusic, MuteSpeech, MuteEffects, RestartMusic, StopEffects, SaveCheckpoint, LoadCheckpoint, Practice }
CameraObstruction, MuteMusic, MuteSpeech, MuteEffects, RestartMusic, StopEffects, SaveCheckpoint, LoadCheckpoint, Practice,
GiveInvisible, UnequipGadget, GiveBubble, GiveBaseball, GiveAllGadgets, GiveRocketship, GiveGrappler, GiveScooter }
public sealed record DebugMenuView(string[] Lines, int SelectedLine);
public sealed record DebugStatus(string Level, string Start, Vector3 Root, float Yaw, float Speed,
bool Grounded, float Energy, int Score, int SceneTask, string Cutscene, bool Controlled,
@@ -25,6 +26,16 @@ public sealed record DebugSystems
public float JumpHold { get; init; }
public float BurnRemaining { get; init; }
public int JetpackAvailability { get; init; }
public float InvisibleRemaining { get; init; }
public float InvisibleRecharge { get; init; }
public bool Targetable { get; init; } = true;
public string BubblePhase { get; init; } = "OFF";
public string BaseballState { get; init; } = "OFF";
public string? ScooterState { get; init; }
public string? GrapplerState { get; init; }
public string? RocketshipState { get; init; }
public float BodyRadius { get; init; } = 60;
public float BodyFactor { get; init; } = 1.265f;
public int Objective { get; init; }
public float ObjectiveTime { get; init; }
public bool? CameraObstruction { get; init; }
@@ -48,7 +59,7 @@ public sealed class DebugMenu
public const int ItemCount = 12;
public const int PageCount = 3;
public int Page { get; private set; }
public int PageItems => Page switch { 1 => 10, 2 => 9, _ => ItemCount };
public int PageItems => Page switch { 1 => 18, 2 => 9, _ => ItemCount };
private static readonly float[] FlySpeeds = [300, 600, 1200, 2400];
private int flySpeedIndex = 1, jetpackStateIndex = 1;
private static readonly int[] JetpackStates = [0, 1, 4];
@@ -110,7 +121,9 @@ public sealed class DebugMenu
0 => DebugAction.Noclip, 1 => DebugAction.NoclipSpeed, 2 => DebugAction.StopMotion,
3 => DebugAction.ShowObjective, 4 => DebugAction.ReturnNoclipEntry,
5 => DebugAction.LevelAvailability, 6 => DebugAction.InputOrder,
8 => DebugAction.ApplyJetpackState, 9 => DebugAction.RefillEnergy, _ => DebugAction.None
8 => DebugAction.ApplyJetpackState, 9 => DebugAction.RefillEnergy,
10 => DebugAction.GiveInvisible, 11 => DebugAction.UnequipGadget, 12 => DebugAction.GiveBubble,
13 => DebugAction.GiveBaseball, 14 => DebugAction.GiveAllGadgets,15=>DebugAction.GiveRocketship,16=>DebugAction.GiveGrappler,17=>DebugAction.GiveScooter, _ => DebugAction.None
};
if (Page == 2) return Selected switch
{
@@ -147,19 +160,24 @@ public sealed class DebugMenu
Page == 1 ? $"PENDING {V(system.PendingImpulse)}" : $"AUDIO BYTES MUSIC {system.MusicBytes} VOICE {system.SpeechBytes}",
Page == 1 ? $"JUMP {system.JumpState} HOLD {F(system.JumpHold)} BURN {F(system.BurnRemaining)}"
: $"EFFECT BYTES {system.EffectBytes} AUDIO AVAILABLE {system.AudioAvailable}",
$"OBJECTIVE {system.Objective} TIME {F(system.ObjectiveTime)} GADGET STATE {system.JetpackAvailability}", ""];
$"OBJECTIVE {system.Objective} TIME {F(system.ObjectiveTime)} GADGET STATE {system.JetpackAvailability}",
$"INVISIBLE {F(system.InvisibleRemaining)} RECHARGE {F(system.InvisibleRecharge)}/7 TARGETABLE {system.Targetable}",
$"BUBBLE {system.BubblePhase} BODY R {F(system.BodyRadius)} FACTOR {system.BodyFactor.ToString("0.000",c)}",
system.ScooterState is{} scooter?$"SCOOTER {scooter}":system.GrapplerState is{} grapple?$"GRAPPLER {grapple}":system.RocketshipState is{} rocket?$"ROCKET {rocket}":$"BASEBALL {system.BaseballState}"];
string[] items = Page == 1 ? [
$"NOCLIP (F3): {system.Noclip} (ENTER TOGGLE)",
$"FLY SPEED: {F(FlySpeed)} LIVE {F(system.NoclipSpeed)} (ENTER APPLIES)", "STOP MOTION / CLEAR QUEUED JUMP", "SHOW CURRENT OBJECTIVE",
"RETURN TO NOCLIP ENTRY POSITION", "APPLY THIS LEVEL'S GADGET AVAILABILITY",
$"INPUT AFTER PLAYER: {system.InputAfterPlayer} (TOGGLE)",
$"JET PACK STATE: {JetpackState} (0 NONE / 1 OWNED / 4 DISABLED)", "APPLY JET PACK STATE", "REFILL ENERGY TO 100"] : [
$"JET PACK STATE: {JetpackState} (0 NONE / 1 OWNED / 4 DISABLED)", "APPLY JET PACK STATE", "REFILL ENERGY TO 100",
"GIVE / SELECT INVISIBLE", "UNEQUIP CURRENT GADGET", "GIVE / SELECT BUBBLE", "GIVE / SELECT BASEBALL",
"GIVE ALL GADGETS", "GIVE / SELECT ROCKETSHIP (VR02)", "GIVE / SELECT GRAPPLER (VR08)", "GIVE / SELECT SCOOTER (VR05 / OUTSIDE)"] : [
$"STATIC CAMERA OBSTRUCTION: {(system.CameraObstruction?.ToString() ?? "UNAVAILABLE")}",
$"MUTE MUSIC: {system.MusicMuted}", $"MUTE SPEECH: {system.SpeechMuted}", $"MUTE EFFECTS: {system.EffectsMuted}",
"RESTART SELECTED MUSIC", "STOP ALL EFFECTS / LOOPS", "SAVE DEBUG CHECKPOINT", "LOAD DEBUG CHECKPOINT", "SHOW JET PACK PRACTICE PROMPT"];
return new([.. header, .. items, "", "TAB NEXT PAGE UP/DOWN SELECT ENTER APPLY",
return new([.. header, .. items, "TAB NEXT PAGE UP/DOWN SELECT ENTER APPLY",
Page == 1 ? "FLY: WASD/ARROWS SPACE/E UP CTRL/Q DOWN SHIFT FAST" : "CHECKPOINT: DEBUG-CHECKPOINT.TSK BESIDE EXECUTABLE",
"F1 / ESC CLOSE - ACTIONS USE EXISTING SYSTEMS", Message], header.Length + Selected);
Message], header.Length + Selected);
}
return new([
"NEUTRON DEBUG MENU - F1",
+75
View File
@@ -0,0 +1,75 @@
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Input replay on the authored VR08 start. Extra ordinary ticks reuse
/// received input; no root, velocity, rope scalar or timer is seeded.</summary>
public sealed class GrapplerSmoke
{
private readonly LabSimulation player;
private readonly PlayerSceneBinding binding;
private readonly SceneDirector director;
private readonly SceneInteractions interactions;
private GrapplerGadget G=>player.Grappler!;
private PlayerInput last;
private int extra;
private float attachedLength,first;
private readonly bool[] checks=new bool[9];
public GrapplerSmoke(LabSimulation player,PlayerSceneBinding binding,SceneDirector director,SceneInteractions interactions)
{
this.player=player;this.binding=binding;this.director=director;this.interactions=interactions;
interactions.Inventory.SetState(0,7,1);interactions.Inventory.SelectGadget(7);
}
public void BeforeFrame(int frame,Action<uint,bool> key,bool headless)
{
if(frame==0&&!headless)key(80,true);
if(frame==1)
{
for(int i=0;i<360&&!G.CursorVisible;i++)Advance(1);
if(!headless){key(80,false);key(224,true);}
}
if(frame==2)Advance(6);
if(frame==3&&!headless){key(224,false);key(82,true);}
if(frame==4){Advance(15);if(!headless){key(82,false);key(225,true);}}
if(frame==5)
{
if(!headless){key(225,false);key(224,true);}
interactions.Inventory.SelectGadget(7);
}
if(frame==6)
{
if(!headless)key(224,false);
director.Trigger("gr");
}
if(frame==7)
{
director.Skip();interactions.Inventory.SelectGadget(7);
if(headless)player.SetNoclip(true);else key(60,true);
}
if(frame==8)player.Reset();
}
public void Received(PlayerInput input)=>last=input;
private void Advance(int count)
{
for(int i=0;i<count;i++)
{
binding.Step(last);interactions.UpdateEnergy(player.Energy);director.Step(FixedStepClock.Step);extra++;
}
}
public void AfterFrame(int frame)
{
if(frame==0)checks[0]=G.Equipped&&player.GadgetMode==7;
if(frame==1){checks[1]=G.Attached&&G.Attachments==1&&G.LoopPlaying;attachedLength=G.Memory.Length;first=G.Memory.FirstLength;}
if(frame==2)checks[2]=G.Attached&&G.SwingPose&&G.Memory.Length<attachedLength&&player.PhysicsSteps>6;
if(frame==3)checks[3]=G.Attached&&G.SwingPose&&!G.LoopPlaying;
if(frame==4)checks[4]=!G.Attached&&!G.SwingPose&&!G.LoopPlaying&&G.Memory.FirstLength==first;
if(frame==5)checks[5]=G.Attached&&G.Attachments==2&&G.Memory.FirstLength==first;
if(frame==6)checks[6]=!G.Equipped&&!G.Attached&&!G.LoopPlaying&&player.GadgetMode==-1;
if(frame==7)checks[7]=player.Noclip&&!G.Equipped&&interactions.Inventory.SelectedGadget==-1;
if(frame==8)checks[8]=!player.Noclip&&!G.Attached&&G.Memory.FirstLength==0;
}
public bool Passed=>checks.All(v=>v);
public string Report=>$"Grappler fixture: equip={checks[0]}, attach={checks[1]}, reel/swing={checks[2]}, release loop={checks[3]}, jump detach={checks[4]}, reattach/first={checks[5]}, cutscene={checks[6]}, noclip={checks[7]}, reset={checks[8]}, extra ordinary ticks={extra}.";
public static PlayerInput Input(int frame)=>new(frame==3,false,frame==0,false,frame==4,Fire:frame is 1 or 2 or 5);
public static string? StageName(int frame)=>frame switch{0=>"equip",1=>"attach",2=>"swing",3=>"release-loop",4=>"detach",5=>"reattach",6=>"cutscene",7=>"noclip",8=>"reset",_=>null};
}
@@ -0,0 +1,79 @@
using System.Numerics;
using System.Security.Cryptography;
using System.Text.Json;
using GamePort.Assets;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>HIROPE/HISWING use source pivots; target canvas8 is a centered
/// 110x110 alpha quad. Billboarding uses the existing port sprite bridge.</summary>
public sealed class GrapplerVisuals
{
private sealed record Clip(MorphAnimation Animation,int Offset,MeshDraw Draw);
private readonly Clip rope,swing;
private readonly int cursorOffset;
private readonly MeshDraw cursor;
public Mesh Mesh {get;}
public GrapplerVisuals(Mesh combined,string preparedRoot)
{
var root=Path.GetFullPath(Path.Combine(preparedRoot,"grappler"));
using var doc=JsonDocument.Parse(File.ReadAllBytes(Path.Combine(root,"grappler.json")));
if(doc.RootElement.GetProperty("schema").GetInt32()!=1)throw new InvalidDataException("Unknown Grappler resources");
string Resource(string path)
{
var full=Path.GetFullPath(Path.Combine(root,path));
if(!full.StartsWith(root+Path.DirectorySeparatorChar,StringComparison.Ordinal))throw new InvalidDataException("Grappler resource escapes root");
return full;
}
Clip Load(string key)
{
var animation=new MorphAnimation(Resource(doc.RootElement.GetProperty(key).GetString()!));
var offset=combined.Vertices.Length;var id=int.MinValue;
while(combined.Textures.ContainsKey(id))id++;
combined=animation.AppendTo(combined,id);var draw=combined.Draws[^1];draw.Visible=false;
return new(animation,offset,draw);
}
rope=Load("ropeAnimation");swing=Load("swingAnimation");
var entry=doc.RootElement.GetProperty("cursor");
var rgba=File.ReadAllBytes(Resource(entry.GetProperty("path").GetString()!));
if(entry.GetProperty("width").GetInt32()!=64||entry.GetProperty("height").GetInt32()!=64
||rgba.Length!=64*64*4||Convert.ToHexStringLower(SHA256.HashData(rgba))!="8d31014cb9b9661ebed902c864bf740f562460e74da3f6b86ed3d2be4d10f0ec")
throw new InvalidDataException("Grappler cursor differs from source canvas8");
cursorOffset=combined.Vertices.Length;var firstIndex=(uint)combined.Indices.Length;var textures=new Dictionary<int,PngImage>(combined.Textures);
var cursorId=int.MinValue;while(textures.ContainsKey(cursorId))cursorId++;
textures.Add(cursorId,new(64,64,rgba));
var vertices=combined.Vertices.ToList();
vertices.AddRange([new(Vector3.Zero,new(0,1),Vector3.One),new(Vector3.Zero,new(1,1),Vector3.One),
new(Vector3.Zero,new(1,0),Vector3.One),new(Vector3.Zero,new(0,0),Vector3.One)]);
var first=(uint)cursorOffset;var indices=combined.Indices.ToList();
indices.AddRange([first,first+1,first+2,first,first+2,first+3]);
cursor=new(firstIndex,6,cursorId){Visible=false,Blend=MeshBlend.Alpha};
Mesh=new(vertices.ToArray(),indices.ToArray()){Textures=textures,HasExplicitDraws=true,Draws=[..combined.Draws,cursor],
CollisionPolygons=combined.CollisionPolygons,HasCollisionMaterialIds=combined.HasCollisionMaterialIds};
}
public void Update(Mesh destination,GrapplerGadget gadget,Vector3 actorRoot,Vector3 rotation,double time,
PlayerAppearance appearance,Vector3 eye,Vector3 target)
{
rope.Draw.Visible=gadget.Attached;swing.Draw.Visible=gadget.SwingPose;cursor.Visible=gadget.Equipped&&gadget.CursorVisible;
if(rope.Draw.Visible)rope.Animation.Sample(0,destination.Vertices.AsSpan(rope.Offset,rope.Animation.Base.Vertices.Length),
RocketOrientation.Model(gadget.RopeRotation,gadget.RopeRoot,new(1,1,gadget.Memory.RopeScaleZ)));
if(swing.Draw.Visible)
{
swing.Animation.Sample(time,destination.Vertices.AsSpan(swing.Offset,swing.Animation.Base.Vertices.Length),
RocketOrientation.Model(rotation,actorRoot,Vector3.One));
PlayerGadgetMaterial.Apply(swing.Draw,appearance);var c=appearance.Color;
for(var i=0;i<swing.Animation.Base.Vertices.Length;i++)destination.Vertices[swing.Offset+i].Color*=new Vector3(c.X,c.Y,c.Z);
}
if(!cursor.Visible)return;
var direction=target-eye;direction=direction.LengthSquared()<.000001f?Vector3.UnitZ:Vector3.Normalize(direction);
var right=Vector3.Cross(Vector3.UnitY,direction);right=right.LengthSquared()<.000001f?Vector3.UnitX:Vector3.Normalize(right);
var up=Vector3.Normalize(Vector3.Cross(direction,right));var x=right*55;var y=up*55;var center=gadget.CursorPosition;
destination.Vertices[cursorOffset]=new(center-x-y,new(0,1),Vector3.One);
destination.Vertices[cursorOffset+1]=new(center+x-y,new(1,1),Vector3.One);
destination.Vertices[cursorOffset+2]=new(center+x+y,new(1,0),Vector3.One);
destination.Vertices[cursorOffset+3]=new(center-x+y,new(0,0),Vector3.One);
}
}
@@ -0,0 +1,71 @@
using System.Numerics;
using System.Text.Json;
using GamePort.Assets;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Original Canv21/22 meter. Source size/tint/full-image stretch with
/// a declared logical rectangle conversion and uniform centered widescreen UI.</summary>
public sealed class InvisibleMeterOverlay
{
private readonly int offset;
private readonly uint firstIndex;
public Mesh Mesh { get; }
public InvisibleMeterOverlay(Mesh combined, string manifest)
{
var full = Path.GetFullPath(manifest);
var directory = Path.GetDirectoryName(full)!;
if (new FileInfo(full).Length > 16 * 1024) throw new InvalidDataException("Meter manifest exceeds limit");
using var document = JsonDocument.Parse(File.ReadAllBytes(full), new JsonDocumentOptions {MaxDepth=10});
var root = document.RootElement;
if (root.GetProperty("schema").GetInt32() != 1 || root.GetProperty("referenceWidth").GetInt32() != 640
|| root.GetProperty("referenceHeight").GetInt32() != 480 || root.GetProperty("textures").GetArrayLength() != 2)
throw new InvalidDataException("Unsupported Invisible meter format");
offset = combined.Vertices.Length; firstIndex = (uint)combined.Indices.Length;
var vertices = combined.Vertices.ToList(); var indices = combined.Indices.ToList();
var draws = combined.Draws.ToList(); var textures = new Dictionary<int,PngImage>(combined.Textures);
if (!combined.HasExplicitDraws && indices.Count != 0) draws.Add(new(0,(uint)indices.Count,-1));
var seen = new HashSet<int>();
foreach (var entry in root.GetProperty("textures").EnumerateArray().OrderBy(e=>e.GetProperty("id").GetInt32()))
{
var id = entry.GetProperty("id").GetInt32();
if (id is not (21 or 22) || !seen.Add(id) || entry.GetProperty("width").GetInt32()!=30
|| entry.GetProperty("height").GetInt32()!=110) throw new InvalidDataException("Invalid source meter canvas");
var path = Path.GetFullPath(Path.Combine(directory,entry.GetProperty("path").GetString()!));
if (!path.StartsWith(directory+Path.DirectorySeparatorChar,StringComparison.Ordinal)
|| new FileInfo(path).Length != 30*110*4) throw new InvalidDataException("Invalid meter pixel path/length");
var textureId = int.MinValue+15000; while(textures.ContainsKey(textureId))textureId++;
textures.Add(textureId,new(30,110,File.ReadAllBytes(path)));
var first = (uint)vertices.Count;
vertices.AddRange([new(Vector3.Zero,new(0,0),Vector3.One),new(Vector3.Zero,new(.9999f,0),Vector3.One),
new(Vector3.Zero,new(.9999f,.9999f),Vector3.One),new(Vector3.Zero,new(0,.9999f),Vector3.One)]);
indices.AddRange([first,first+1,first+2,first,first+2,first+3]);
draws.Add(new((uint)indices.Count-6,6,textureId){ScreenSpace=true,Visible=false});
}
Mesh = new(vertices.ToArray(),indices.ToArray()) {HasExplicitDraws=true,Draws=draws.ToArray(),Textures=textures,
CollisionPolygons=combined.CollisionPolygons,HasCollisionMaterialIds=combined.HasCollisionMaterialIds};
}
public void Update(Mesh destination, InvisibleGadget device, uint width, uint height)
{
var viewport = new UiViewport(width,height);
var visible = device.Equipped && device.MeterVisible;
var color = device.MeterReady ? Vector3.One : new Vector3(1,.2f,.2f);
var fillHeight = (float)(Math.Max(device.MeterPercent,0)*1.04);
Quad(0,new(320,7),new(30,110),Vector3.One);
Quad(1,new(322,114-fillHeight),new(27,fillHeight),color);
void Quad(int index, Vector2 position, Vector2 size, Vector3 tint)
{
destination.Draws.First(d=>d.ScreenSpace&&d.FirstIndex==firstIndex+(uint)index*6).Visible=visible;
var p = position+viewport.CenterOffset;
var corners = new[] {p,p+new Vector2(size.X,0),p+size,p+new Vector2(0,size.Y)};
for(var i=0;i<4;i++)
{
destination.Vertices[offset+index*4+i].Position=viewport.ToNdc(corners[i]);
destination.Vertices[offset+index*4+i].Color=tint;
}
}
}
}
@@ -0,0 +1,67 @@
using GamePort.Assets;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Accelerated port verification: full player ticks between six rendered
/// phases. No actor relocation or direct timer/material writes; not original cadence.</summary>
public sealed class InvisibleSmoke
{
private readonly LabSimulation player;
private readonly SceneInventory inventory;
private readonly bool[] checks = new bool[6];
private readonly float initialEnergy;
private int acceleratedTicks;
public InvisibleSmoke(LabSimulation player, SceneInventory inventory)
{
this.player = player; this.inventory = inventory; initialEnergy = player.Energy;
inventory.SetState(0,2,1); inventory.SelectGadget(2);
if (player.GadgetMode != 2 || !player.Invisible.Equipped)
throw new InvalidOperationException("Invisible fixture requires a connected, eligible player binding");
Advance(() => player.Invisible.Recharge == 7);
}
public void BeforeFrame(int count, Action<uint,bool> injectKey, bool headless)
{
if (count == 1 && !headless) injectKey(224,true);
if (count == 2 && !headless) injectKey(224,false);
if (count == 3) Advance(() => player.Invisible.Active && player.Invisible.Remaining <= 2.9f && player.Invisible.ConventionalBlend);
if (count == 4) Advance(() => player.Invisible.Active && !player.Invisible.ConventionalBlend);
if (count == 5) Advance(() => !player.Invisible.Active);
if (count == 6)
{
if (headless) inventory.SelectGadget(-1);
else injectKey(43,true);
}
if (count == 7 && !headless) injectKey(43,false);
}
private void Advance(Func<bool> done)
{
for(var i=0;i<1000;i++)
{
if(done())return;
player.Step(default); acceleratedTicks++;
}
throw new InvalidOperationException("Invisible fixture did not reach the requested source phase");
}
public void AfterFrame(int count, MeshDraw material)
{
var device = player.Invisible;
if(count==0)checks[0]=device.Recharge==7 && device.Targetable && material.Opacity==1 && device.MeterReady;
if(count==1)checks[1]=device.Active && device.Activations==1 && device.Remaining>3
&& material.Opacity==.7f && material.Blend==MeshBlend.Additive
&& player.Energy==(player.IgnoresGadgetEnergy ? initialEnergy : initialEnergy-2);
if(count==3)checks[2]=device.Active && material.Opacity==.7f && material.Blend==MeshBlend.Alpha;
if(count==4)checks[3]=device.Active && material.Blend==MeshBlend.Additive && device.Remaining<=3;
if(count==5)checks[4]=!device.Active && device.Targetable && material.Opacity==1 && material.Blend==MeshBlend.Opaque;
if(count==7)checks[5]=player.GadgetMode==-1 && !device.Equipped && !device.MeterVisible && device.Targetable;
}
public bool Passed => checks.All(value=>value);
public string Report => $"Invisible fixture: charged={checks[0]}, activation={checks[1]}, alpha flash={checks[2]}, additive flash={checks[3]}, expiry={checks[4]}, unequip={checks[5]}, accelerated player ticks={acceleratedTicks}, energy={player.Energy:F3}.";
public static string? StageName(int count) => count switch
{0=>"charged",1=>"active",3=>"alpha",4=>"additive",5=>"expired",7=>"unequipped",_=>null};
}
+22
View File
@@ -0,0 +1,22 @@
using System.Numerics;
namespace GamePort.Application;
/// <summary>Inspection camera in the same positive-Z view space as gameplay.
/// Caller applies the Vulkan viewport Y flip to Projection exactly once.</summary>
public readonly record struct OrbitCamera(Vector3 Eye, Matrix4x4 View, Matrix4x4 Projection)
{
public static OrbitCamera Create(Vector3 target, float radius, float angle, float elevation, float aspect)
{
if (!float.IsFinite(target.X) || !float.IsFinite(target.Y) || !float.IsFinite(target.Z)
|| !float.IsFinite(radius) || radius < .01f || !float.IsFinite(angle)
|| !float.IsFinite(elevation) || MathF.Abs(elevation) >= MathF.PI / 2
|| !float.IsFinite(aspect) || aspect <= 0)
throw new ArgumentOutOfRangeException(nameof(radius), "A finite orbit outside the poles and positive viewport are required");
var eye = target + radius * new Vector3(MathF.Cos(elevation) * MathF.Sin(angle),
MathF.Sin(elevation), MathF.Cos(elevation) * MathF.Cos(angle));
return new(eye, Matrix4x4.CreateLookAtLeftHanded(eye, target, Vector3.UnitY),
Matrix4x4.CreatePerspectiveFieldOfViewLeftHanded(MathF.PI / 3, aspect,
Math.Max(radius / 10000, .01f), radius * 20));
}
}
@@ -0,0 +1,18 @@
using GamePort.Assets;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Current Jimmy atlas is one linked material. Source114 alpha and
/// indexed0 FC blend changes affect that draw without changing pose/visibility.</summary>
public static class PlayerGadgetMaterial
{
public static void Apply(MeshDraw draw, PlayerAppearance appearance)
{ draw.Opacity=appearance.Color.W; draw.Blend=appearance.Blend; }
public static void Apply(MeshDraw draw, InvisibleGadget invisible)
{
draw.Opacity = invisible.Opacity;
draw.Blend = !invisible.Active ? MeshBlend.Opaque
: invisible.ConventionalBlend ? MeshBlend.Alpha : MeshBlend.Additive;
}
}
@@ -0,0 +1,86 @@
using System.Numerics;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>VR02 ordinary-phase replay; extra ticks reuse the last received
/// input. No actor relocation, velocity seeding or timer modification.</summary>
public sealed class RocketshipSmoke
{
private readonly LabSimulation player;
private readonly PlayerSceneBinding binding;
private readonly SceneInventory inventory;
private readonly SceneDirector director;
private readonly SceneInteractions interactions;
private readonly Rocketship ship;
private readonly bool[] checks=new bool[10];
private readonly Vector3 initial;
private readonly float energy;
private PlayerInput last;
private int extra;
private float turnYaw;
public RocketshipSmoke(LabSimulation player,PlayerSceneBinding binding,SceneDirector director,SceneInteractions interactions)
{
this.player=player;this.binding=binding;this.director=director;this.interactions=interactions;
inventory=interactions.Inventory;ship=binding.Rocketship!;
energy=player.Energy;initial=player.ActorRoot;
inventory.SetState(0,1,1);inventory.SelectGadget(1);
}
public void BeforeFrame(int count,Action<uint,bool> key,bool headless)
{
if(count==0&&!headless)key(82,true);
if(count==1)Advance(90);
if(count==2&&!headless)key(80,true);
if(count==3)
{
Advance(45);
if(!headless){key(80,false);key(82,false);}
}
if(count==4)
{
Advance(30);turnYaw=ship.Rotation.Y;
if(!headless)key(40,true);
}
if(count==5)
{
Advance(65);
if(!headless){key(40,false);key(21,true);}
}
if(count==6){Advance(35);if(!headless)key(21,false);}
if(count==7)
{
Advance(30);
if(headless)inventory.SelectGadget(-1);else key(43,true);
}
if(count==8){if(!headless)key(43,false);inventory.SelectGadget(1);}
if(count==9){if(headless)player.SetNoclip(true);else key(60,true);}
}
public void Received(PlayerInput input)=>last=input;
private void Advance(int count)
{
for(var i=0;i<count;i++)
{
if(binding.Step(last))interactions.Update(player.ActorRoot,player.InteractionRadius,ship.Mounted?ship.Actor:null);
interactions.UpdateEnergy(player.Energy);director.Step(FixedStepClock.Step);extra++;
}
}
public void AfterFrame(int count)
{
if(count==0)checks[0]=ship.Mounted&&player.GadgetMode==1&&!director.Controlled&&binding.InventoryControlled;
if(count==1)checks[1]=Vector3.Distance(ship.Root,initial)>100&&ship.Root.Y>initial.Y+30&&ship.FireVisible&&ship.BodySteps>80;
if(count==2)checks[2]=ship.Steering.Bank>0;
if(count==3)checks[3]=ship.Rotation.Y!=0&&ship.Steering.Bank>10;
if(count==4)checks[4]=ship.Maneuver.TurnRemaining>.9f;
if(count==5)checks[5]=ship.Maneuver.TurnRemaining==0&&MathF.Abs(MathF.IEEERemainder(ship.Rotation.Y-turnYaw,360))>90&&ship.Maneuver.RollRemaining>.9f;
if(count==6)checks[6]=ship.Maneuver.RollRemaining>0&&ship.Rotation.Z>60;
if(count==7)checks[7]=!ship.Mounted&&player.GadgetMode==-1&&director.Controlled&&ship.EngineMode==0&&!ship.FireVisible;
if(count==8)checks[8]=ship.Mounted&&player.GadgetMode==1;
if(count==9)checks[9]=!ship.Mounted&&player.Noclip&&director.Controlled&&ship.EngineMode==0;
}
public bool Passed=>checks.All(x=>x)&&player.Energy==energy;
public string Report=>$"Rocketship fixture: mount={checks[0]}, fly={checks[1]}, bank={checks[2]}, turn={checks[3]}, maneuver={checks[4]}, finish/roll={checks[5]}, barrel={checks[6]}, release={checks[7]}, remount={checks[8]}, noclip cleanup={checks[9]}, extra ordinary ticks={extra}, energy={player.Energy}/{energy}.";
public static PlayerInput Input(int count)=>new(count<=2,false,count==2,false,false,RocketTurn:count==4,RocketRoll:count==5);
public static string? StageName(int count)=>count switch
{0=>"mounted",1=>"flying",2=>"bank",3=>"turn",4=>"maneuver",5=>"roll-start",6=>"barrel",7=>"released",8=>"remounted",9=>"noclip",_=>null};
}
@@ -0,0 +1,58 @@
using System.Numerics;
using System.Text.Json;
using GamePort.Assets;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Original Strato, HIDRIVE, HIROCK and additive FireStrato resources.
/// Uses source local pivots/transforms without standing-sole correction.</summary>
public sealed class RocketshipVisuals
{
private sealed record Clip(MorphAnimation Animation,int Offset,MeshDraw Draw);
private readonly Clip ship,rider,dog,fire;
public Mesh Mesh { get; }
public RocketshipVisuals(Mesh combined,string preparedRoot)
{
var root=Path.Combine(preparedRoot,"rocketship");
using var doc=JsonDocument.Parse(File.ReadAllText(Path.Combine(root,"rocketship.json")));
if(doc.RootElement.GetProperty("schema").GetInt32()!=1)throw new InvalidDataException("Unknown Rocketship resource schema");
Clip Load(string name)
{
var animation=new MorphAnimation(Path.Combine(root,name,"animation.json"));
var offset=combined.Vertices.Length;
var id=int.MinValue;while(combined.Textures.ContainsKey(id))id++;
combined=animation.AppendTo(combined,id);
var draw=combined.Draws[^1];draw.Visible=false;
return new(animation,offset,draw);
}
ship=Load("strato");rider=Load("jimdrive");dog=Load("godrocket");fire=Load("firestrato");
fire.Draw.Blend=MeshBlend.Additive;fire.Draw.Opacity=1;
Mesh=combined;
}
public void Update(Mesh mesh,Rocketship vehicle,double time,PlayerAppearance appearance)
{
var ordinary=RocketOrientation.Model(vehicle.Rotation,vehicle.Root,Vector3.One);
Draw(ship,ordinary,vehicle.Mounted);
//Original material RGBA pulses red on impact; geometry keeps unit scale.
var impact=vehicle.ImpactColor;
ship.Draw.Opacity=impact.W;
for(var i=0;i<ship.Animation.Base.Vertices.Length;i++)
mesh.Vertices[ship.Offset+i].Color*=new Vector3(impact.X,impact.Y,impact.Z);
Draw(rider,ordinary,vehicle.Mounted);
Draw(dog,RocketOrientation.Model(vehicle.Rotation,vehicle.CompanionRoot,Vector3.One),vehicle.Mounted);
Draw(fire,ordinary,vehicle.Mounted&&vehicle.FireVisible);
PlayerGadgetMaterial.Apply(rider.Draw,appearance);
var color=appearance.Color;
for(var i=0;i<rider.Animation.Base.Vertices.Length;i++)
mesh.Vertices[rider.Offset+i].Color*=new Vector3(color.X,color.Y,color.Z);
void Draw(Clip clip,Matrix4x4 model,bool visible)
{
clip.Draw.Visible=visible;
if(visible)clip.Animation.Sample(time,mesh.Vertices.AsSpan(clip.Offset,clip.Animation.Base.Vertices.Length),model);
}
}
}
@@ -25,7 +25,7 @@ public sealed class SceneSpriteVisuals
var textures = new Dictionary<int, PngImage>(combined.Textures);
foreach (var actor in director.Actors)
{
if (actor.Kind is not ("3PIC" or "3ANI") || actor.SourceGam is not { } source) continue;
if (actor.Kind is not ("3PIC" or "3ANI" or "3TAR") || actor.SourceGam is not { } source) continue;
var database = source.Text("SpriteDatabase") ?? "none";
var identities = actor.Kind == "3ANI" ? Enumerable.Range(1, 9)
.Select(i => source.Integer("Sprite" + i, -1)).TakeWhile(i => i >= 0).ToArray()
+75
View File
@@ -0,0 +1,75 @@
using System.Numerics;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Ordinary input replay at the authored tutorial/outside start. Extra
/// body/input/frame ticks reuse received input; no root, speed or timer seeding.</summary>
public sealed class ScooterSmoke
{
private readonly LabSimulation player;
private readonly PlayerSceneBinding binding;
private readonly SceneDirector director;
private readonly SceneInteractions interactions;
private readonly Scooter scooter;
private readonly string level;
private readonly bool[] checks=new bool[10];
private PlayerInput last;private Vector3 mountedRoot;private float yaw,speed;private int extra;
public ScooterSmoke(LabSimulation p,PlayerSceneBinding b,SceneDirector d,SceneInteractions i,string level)
{player=p;binding=b;director=d;interactions=i;scooter=b.Scooter!;this.level=level;i.Inventory.SetState(0,4,1);i.Inventory.SelectGadget(4);}
public void BeforeFrame(int frame,Action<uint,bool> key,bool headless)
{
if(frame==0&&!headless)key(81,true);
if(frame==1)
{
for(int i=0;i<120&&!scooter.Mounted;i++)Advance(1);
if(!headless){key(81,false);key(82,true);if(level=="LEV1")key(80,true);}mountedRoot=scooter.Root;
}
if(frame==2){Advance(90);yaw=scooter.Rotation.Y;if(!headless)key(80,true);}
if(frame==3){Advance(15);speed=scooter.Steering.Speed;if(!headless){key(82,false);key(80,false);key(81,true);}}
if(frame==4)
{
Advance(12);for(int i=0;i<120&&!scooter.Supported;i++)Advance(1);
if(!headless){key(81,false);key(225,true);}
}
if(frame==5){Advance(120);if(headless)interactions.Inventory.SelectGadget(-1);else{key(225,false);key(43,true);}}
if(frame==6){if(!headless)key(43,false);interactions.Inventory.SelectGadget(4);}
if(frame==7){if(level=="VR05")director.Trigger("scooter");else director.ReleasePlayerGadget();}
if(frame==8)
{
director.Skip();interactions.Inventory.SelectGadget(4);
if(headless)player.SetNoclip(true);else key(60,true);
}
if(frame==9)
{
if(headless){binding.ResetVehicle();player.Reset();}
else {key(60,false);key(21,true);}
}
}
public void Received(PlayerInput input)=>last=input;
private void Advance(int ticks)
{
for(int i=0;i<ticks;i++)
{
binding.Step(last);
interactions.Update(player.ActorRoot,player.InteractionRadius,scooter.Mounted?scooter.Actor:null);
interactions.UpdateEnergy(player.Energy);director.Step(FixedStepClock.Step);extra++;
}
}
public void AfterFrame(int frame)
{
Console.WriteLine($"Scooter {StageName(frame)}: root={scooter.Root}, rotation={scooter.Rotation}, velocity={scooter.Velocity}, scalar={scooter.Steering.Speed}, supported={scooter.Supported}, wheels={scooter.FrontSupports}/{scooter.RearSupports}, impact={scooter.ImpactActive}, contacts={scooter.Contacts}, jumps={scooter.Jumps}.");
if(frame==0)checks[0]=scooter.Spawned&&!scooter.Mounted&&player.GadgetMode==4;
if(frame==1)checks[1]=scooter.Mounted&&binding.InventoryControlled&&director.AuthoredControlledTag==scooter.Actor.Tag;
if(frame==2)checks[2]=scooter.Mounted&&Vector3.Distance(scooter.Root,mountedRoot)>100&&scooter.Steering.Speed>100;
if(frame==3)checks[3]=scooter.Rotation.Y!=yaw&&scooter.Steering.Angle>0;
if(frame==4)checks[4]=scooter.Steering.Speed<speed&&scooter.Jumps>0;
if(frame==5)checks[5]=!scooter.Spawned&&!scooter.Mounted&&!scooter.EnginePlaying&&director.Controlled;
if(frame==6)checks[6]=scooter.Mounted&&player.GadgetMode==4;
if(frame==7)checks[7]=!scooter.Spawned&&!scooter.EnginePlaying&&player.GadgetMode==-1;
if(frame==8)checks[8]=player.Noclip&&!scooter.Spawned&&interactions.Inventory.SelectedGadget==-1;
if(frame==9)checks[9]=!player.Noclip&&!scooter.Spawned&&scooter.BodySteps==0;
}
public bool Passed=>checks.All(v=>v);
public string Report=>$"Scooter {level}: summon={checks[0]}, contact mount={checks[1]}, drive={checks[2]}, steer={checks[3]}, brake/jump={checks[4]}, dismount={checks[5]}, remount={checks[6]}, authored cleanup={checks[7]}, noclip={checks[8]}, reset={checks[9]}, extra ordinary ticks={extra}.";
public static PlayerInput Input(int frame,string level)=>new(frame is 1 or 2,frame is 0 or 3,frame==2||frame==1&&level=="LEV1",false,frame==4);
public static string? StageName(int frame)=>frame switch{0=>"summoned",1=>"mounted",2=>"driving",3=>"steer",4=>"jump",5=>"dismounted",6=>"remounted",7=>"cleanup",8=>"noclip",9=>"reset",_=>null};
}
@@ -0,0 +1,73 @@
using System.Numerics;
using System.Text.Json;
using GamePort.Assets;
using GamePort.Game;
namespace GamePort.Application;
/// <summary>Original scooter.omt shape0 and four shape1 wheels, plus exact
/// HISCOOT/HISCOOTSTOP source-pivot morphs. Null-material faces stay undrawn.</summary>
public sealed class ScooterVisuals
{
private sealed record Static(Mesh Source,int Offset,MeshDraw[] Draws);
private sealed record Clip(MorphAnimation Source,int Offset,MeshDraw Draw);
private readonly Static body;
private readonly Static[] wheels;
private readonly Clip scoot,stop;
public Mesh Mesh{get;}
public ScooterVisuals(Mesh combined,string preparedRoot)
{
var root=Path.GetFullPath(Path.Combine(preparedRoot,"scooter"));
using var document=JsonDocument.Parse(File.ReadAllBytes(Path.Combine(root,"scooter.json")));
var data=document.RootElement;
if(data.GetProperty("schema").GetInt32()!=1)throw new InvalidDataException("Unknown Scooter schema");
string Resource(string key)
{
var path=Path.GetFullPath(Path.Combine(root,data.GetProperty(key).GetString()!));
if(!path.StartsWith(root+Path.DirectorySeparatorChar,StringComparison.Ordinal))throw new InvalidDataException("Scooter path escapes resources");
return path;
}
Static Append(Mesh source)
{
var textures=new Dictionary<int,PngImage>(combined.Textures);var ids=new Dictionary<int,int>();
int next=int.MinValue;foreach(var pair in source.Textures)
{while(textures.ContainsKey(next))next++;ids[pair.Key]=next;textures.Add(next++,pair.Value);}
int offset=combined.Vertices.Length;uint indexOffset=(uint)combined.Indices.Length;
var draws=source.Draws.Select(d=>new MeshDraw(d.FirstIndex+indexOffset,d.IndexCount,d.TextureId==-1?-1:ids[d.TextureId])
{Visible=false,Blend=d.Blend,Opacity=d.Opacity}).ToArray();
combined=new([..combined.Vertices,..source.Vertices],[..combined.Indices,..source.Indices.Select(i=>i+(uint)offset)])
{HasExplicitDraws=true,Textures=textures,Draws=[..combined.Draws,..draws],CollisionPolygons=combined.CollisionPolygons,
HasCollisionMaterialIds=combined.HasCollisionMaterialIds};
return new(source,offset,draws);
}
Clip Load(string key)
{
var source=new MorphAnimation(Resource(key));int offset=combined.Vertices.Length,id=int.MinValue;
while(combined.Textures.ContainsKey(id))id++;combined=source.AppendTo(combined,id);
var draw=combined.Draws[^1];draw.Visible=false;return new(source,offset,draw);
}
body=Append(Mesh.LoadSceneJson(Resource("bodyMesh")));
var wheel=Mesh.LoadSceneJson(Resource("wheelMesh"));wheels=Enumerable.Range(0,4).Select(_=>Append(wheel)).ToArray();
scoot=Load("scootAnimation");stop=Load("stopAnimation");Mesh=combined;
}
public void Update(Mesh destination,Scooter vehicle,double time,PlayerAppearance appearance)
{
Draw(body,vehicle.Root,vehicle.Rotation,vehicle.Spawned);
for(int i=0;i<4;i++)Draw(wheels[i],vehicle.WheelRoots[i],vehicle.WheelRotations[i],vehicle.Spawned);
Pose(scoot,vehicle.Mounted&&!vehicle.RiderStopped);Pose(stop,vehicle.Mounted&&vehicle.RiderStopped);
void Draw(Static visual,Vector3 root,Vector3 angles,bool visible)
{
foreach(var draw in visual.Draws)draw.Visible=visible;
if(!visible)return;var model=RocketOrientation.Model(angles,root,Vector3.One);
for(int i=0;i<visual.Source.Vertices.Length;i++)
{var v=visual.Source.Vertices[i];v.Position=Vector3.Transform(v.Position,model);destination.Vertices[visual.Offset+i]=v;}
}
void Pose(Clip clip,bool visible)
{
clip.Draw.Visible=visible;if(!visible)return;
clip.Source.Sample(time,destination.Vertices.AsSpan(clip.Offset,clip.Source.Base.Vertices.Length),
RocketOrientation.Model(vehicle.RiderRotation,vehicle.Root,Vector3.One));
PlayerGadgetMaterial.Apply(clip.Draw,appearance);var color=appearance.Color;
for(int i=0;i<clip.Source.Base.Vertices.Length;i++)destination.Vertices[clip.Offset+i].Color*=new Vector3(color.X,color.Y,color.Z);
}
}
}
+2
View File
@@ -54,6 +54,8 @@ public sealed class SceneAudio : IDisposable
loops.Add(loopOwner, new(wave.Path, true, Paused, EffectsMuted));
}
}
public void TuneLoop(string owner,Func<int,int> frequency)
{if(loops.TryGetValue(owner,out var stream))stream.SetFrequency(frequency(stream.SourceFrequency));}
public void StopLoop(string owner)
{
if (loops.Remove(owner, out var stream)) stream.Dispose();
+7
View File
@@ -10,6 +10,7 @@ public sealed class SdlAudio : IDisposable
private int length;
private readonly bool loop;
private bool audioInitialized;
public int SourceFrequency {get;private set;}
public bool Paused { get; private set; }
public bool Muted { get; private set; }
public int QueuedBytes
@@ -28,6 +29,7 @@ public sealed class SdlAudio : IDisposable
try
{
if(!Sdl.SDL_LoadWAV(Path.GetFullPath(path),out var spec,out data,out var size))throw new InvalidOperationException(Sdl.Error);
SourceFrequency=spec.Frequency;
length=checked((int)size);
stream=Sdl.SDL_OpenAudioDeviceStream(uint.MaxValue,ref spec,0,0);
if(stream==0)throw new InvalidOperationException(Sdl.Error);
@@ -55,6 +57,11 @@ public sealed class SdlAudio : IDisposable
if (!Sdl.SDL_SetAudioStreamGain(stream, muted ? 0 : 1)) throw new InvalidOperationException(Sdl.Error);
Muted = muted;
}
public void SetFrequency(int frequency)
{
ObjectDisposedException.ThrowIf(stream==0,this);
if(frequency<=0||!Sdl.SDL_SetAudioStreamFrequencyRatio(stream,(float)frequency/SourceFrequency))throw new InvalidOperationException(Sdl.Error);
}
private void Queue(){if(!Sdl.SDL_PutAudioStreamData(stream,data,length))throw new InvalidOperationException(Sdl.Error);}
public void Pump(){if(!Paused && loop && QueuedBytes<length)Queue();}
public void Dispose()
+39 -4
View File
@@ -37,7 +37,8 @@ public sealed class ActorPatrol
public float WaitRemaining { get; private set; }
public string? CurrentWaypoint => waypoint?.Tag;
public string? PreviousWaypoint => previousWaypoint?.Tag;
public bool SupportedState => actor.AIstate is 1 or 3 or 7 or 9 || actor.Kind == "3CAR" && actor.AIstate == 6;
public bool FollowPlayer {get;set;}
public bool SupportedState => actor.AIstate is 1 or 3 or 7 or 9 || actor.Kind == "3CAR" && actor.AIstate == 6 || FollowPlayer&&actor.Kind=="3DOG"&&actor.AIstate==4;
public ActorPatrol(DirectorActor actor, Func<string, DirectorActor?> findActor,
Func<PatrolBodyState, float, PatrolBodyState> integrateBody,
@@ -86,24 +87,30 @@ public sealed class ActorPatrol
if (!float.IsFinite(dt) || dt < 0 || dt > 1) throw new ArgumentOutOfRangeException(nameof(dt));
SynchronizeAuthoredState();
if (!SupportedState) return false;
if (!actor.Active) return true;
if (!actor.Active||!actor.MovementEnabled) return true;
if (!float.IsFinite(actor.Speed)) throw new InvalidOperationException("Nonfinite Goddard speed");
// EXE408023->40E050: the body consumes the *previous* velocity first.
var body = integrateBody(new(actor.Position, Velocity), dt);
var body = actor.BodyEnabled ? integrateBody(new(actor.Position, Velocity), dt) : new PatrolBodyState(actor.Position, Velocity);
if (!Finite(body.Position) || !Finite(body.Velocity))
throw new InvalidOperationException("Goddard body solver produced nonfinite state");
actor.Position = body.Position;
Velocity = body.Velocity;
if(FollowPlayer&&actor.Kind=="3DOG")
actor.Rotation=GoddardFacing(actor.Rotation,desiredYaw,dt);
else
{
var yawError = (desiredYaw - actor.Rotation.Y) % 360;
if (yawError > 180) yawError -= 360;
if (yawError < -180) yawError += 360;
actor.Rotation = actor.Rotation with { Y = actor.Rotation.Y + yawError * yawFactor * dt };
}
switch (actor.AIstate)
{
case 1: Velocity = Vector3.Zero; break; // EXE40835D, after body integration.
case 3: StepPatrol(); break;
case 4: StepFollow(); break;
case 7: StepWait(dt); break;
// State9 jumps directly to the common finisher408911. State6 calls
// sensing409CC0 first; source player-contact dispatch is implemented
@@ -112,12 +119,40 @@ public sealed class ActorPatrol
}
// States1/6/7 return before selecting a destination angle (409186..19B).
// Retain the old destination on a waypoint change, as the source does.
if (actor.AIstate == 3 && DestinationDelta.X * DestinationDelta.X + DestinationDelta.Z * DestinationDelta.Z > 0)
if (actor.AIstate is 3 or 4 && DestinationDelta.X * DestinationDelta.X + DestinationDelta.Z * DestinationDelta.Z > 0)
desiredYaw = MathF.Atan2(-DestinationDelta.X, DestinationDelta.Z) * (180 / MathF.PI);
Publish();
return true;
}
/// <summary>4096E0 with41C8DB Goddard factors and the ordinary supported
/// follow target (pitch/roll0). Dismount copies tilt; this later AI phase
/// gradually levels it. Full airborne AI target selection remains separate.</summary>
public static Vector3 GoddardFacing(Vector3 rotation,float yaw,float dt)
{
static float Arc(float delta)=>delta>180?delta-360:delta< -180?delta+360:delta;
var delta=new Vector3(Arc(-rotation.X)*.3f*dt,Arc(yaw-rotation.Y)*3.2f*dt,Arc(-rotation.Z)*.3f*dt);
return RocketOrientation.Add(rotation,delta);
}
private void StepFollow()
{
var target=findActor("JIM1");if(target==null||!target.Active)return;
DestinationDelta=target.Position-actor.Position;DestinationDistance=DestinationDelta.Length();
var length=magnitude(DestinationDelta);
float multiplier=DestinationDistance>=2000?3:DestinationDistance>=1000?1.7f:1;
Velocity=Arrived||length==0?Vector3.Zero:DestinationDelta/length*(actor.Speed*multiplier);
if(DestinationDistance<ArrivalDistance)Arrived=true;
else if(DestinationDistance>ArrivalDistance*1.5f)Arrived=false;
actor.Speed=DestinationDistance>440?600:450;
if(DestinationDistance>1500)
{
actor.Position=target.Position+RocketOrientation.Rotate(new(0,0,-800),target.Rotation);
Velocity=Vector3.Zero;
}
actor.Animation=magnitude(Velocity)>20?"RUN":"WAG";
}
private void StepPatrol()
{
waypoint ??= findActor(actor.Patrol ?? "none");
+9 -6
View File
@@ -2,8 +2,9 @@ namespace GamePort.Game;
public readonly record struct AirSteeringResult(float Speed, float TurnRate);
/// <summary>Keyboard subset of normal airborne input439900 (mode1).
/// Modes1/2 share the handler; special flight mode2 and mouse/analog are separate.
/// <summary>Legacy stateless compatibility helper and shared steering constants.
/// Live ordinary input uses JimmyAirMotion, which retains the keyboard latch,
/// supported mode1 braking and original coast comparison precision.
/// </summary>
public static class AirSteering
{
@@ -11,9 +12,11 @@ public static class AirSteering
public const float TurnLimit = 30; //439D81..439DB7, ordinary mode1.
public const float CoastThreshold = 0.9090909361839294f; //49D5DC.
public static AirSteeringResult Step(float speed, float turnRate, PlayerInput input, float seconds)
public static AirSteeringResult Step(float speed, float turnRate, PlayerInput input, float seconds,
float maximumSpeed = RecoveredMotion.MaximumSpeed)
{
if (!float.IsFinite(speed) || !float.IsFinite(turnRate) || !float.IsFinite(seconds) || seconds < 0 || seconds >= 1)
if (!float.IsFinite(speed) || !float.IsFinite(turnRate) || !float.IsFinite(seconds)
|| !float.IsFinite(maximumSpeed) || maximumSpeed<=0 || seconds < 0 || seconds >= 1)
throw new ArgumentOutOfRangeException(nameof(seconds));
var turnStep = TurnAcceleration * seconds;
if (input.Left) turnRate += turnStep;
@@ -22,8 +25,8 @@ public static class AirSteering
else if (turnRate > 0) turnRate = MathF.Max(0, turnRate - turnStep);
turnRate = Math.Clamp(turnRate, -TurnLimit, TurnLimit);
if (input.Forward) speed = RecoveredMotion.AddSpeed(speed);
else if (speed > RecoveredMotion.MaximumSpeed * CoastThreshold)
if (input.Forward) speed = RecoveredMotion.AddSpeed(speed,maximumSpeed);
else if (speed > maximumSpeed * CoastThreshold)
speed -= RecoveredMotion.SpeedDecay * .5f;
//439C1D..439CB2 brakes to0, without starting reverse flight.
if (input.Backward)
+138
View File
@@ -0,0 +1,138 @@
using System.Numerics;
namespace GamePort.Game;
/// <summary>Jimmy's raw6 aim/release state (42659F/426744). The twenty owned
/// projectiles survive unequip; this object is reset only with the modern scene.
/// Source evidence and precision boundaries: gameplay/baseball.md.</summary>
public sealed class BaseballGadget
{
public const int PoolSize = 20;
private readonly BaseballProjectile[] projectiles = Enumerable.Range(0, PoolSize).Select(_ => new BaseballProjectile()).ToArray();
public IReadOnlyList<BaseballProjectile> Projectiles => projectiles;
public bool Equipped { get; private set; }
public bool PendingThrow { get; private set; }
public bool AimVisible { get; private set; }
public float CameraPitch { get; private set; } = 10;
public float CameraHeight { get; private set; } = 200;
public float SavedPitch { get; private set; }
public float DisplayPitch { get; private set; }
public int NextSlot { get; private set; }
public int Throws { get; private set; }
public event Action<bool>? EquippedChanged;
public event Action? Thrown;
public void Equip()
{
Equipped = true;
CameraHeight += 30; //429707..429713 complete7CC; cleanup resets its defaults.
EquippedChanged?.Invoke(true);
}
public void Release()
{
Equipped = AimVisible = false;
CameraPitch = 0;
CameraHeight = 200;
//42871D does not write Jimmy1E26/1E28 or destroy its AB4 pool.
EquippedChanged?.Invoke(false);
}
public void StepInput(PlayerInput input, Vector3 root, Vector3 euler, bool supported,
float energy, bool exempt, Action stop, Action<bool> shooting, Action<float> adjustEnergy)
{
if (!input.Fire)
{
AimVisible = false;
shooting(false);
if (!PendingThrow) return;
Thrown?.Invoke(); //4265A9 requests10 before the launch virtual.
projectiles[NextSlot].Launch(root, euler, SavedPitch);
NextSlot = (NextSlot + 1) % PoolSize;
PendingThrow = false;
Throws++;
adjustEnergy(-1);
return;
}
if (!Equipped) return;
stop();
if (energy <= 0 && !exempt || !supported) return;
shooting(true);
AimVisible = true;
DisplayPitch = SavedPitch;
if (!PendingThrow)
{
PendingThrow = true;
return; //First hold arms without refreshing the saved pitch.
}
CameraPitch = Math.Clamp(CameraPitch, 0, 45);
SavedPitch = CameraPitch;
}
public void StepCameraInput(PlayerInput input)
{
if (!Equipped) { CameraPitch=10; return; }
if (!input.Fire) return;
if (input.Backward) CameraPitch -= 20 * FixedStepClock.Step;
else if (input.Forward) CameraPitch += 20 * FixedStepClock.Step;
}
public void Reset()
{
if (Equipped) Release();
PendingThrow = AimVisible = false;
CameraPitch = 10; SavedPitch = DisplayPitch = 0;
CameraHeight = 200;
NextSlot = Throws = 0;
foreach (var projectile in projectiles) projectile.Reset();
}
}
/// <summary>C3DBaseball owned pool entry. No invented ammo count or lifetime.</summary>
public sealed class BaseballProjectile
{
public Vector3 Position { get; private set; }
public Vector3 PreviousPosition { get; private set; }
public Vector3 Velocity { get; private set; }
public Vector3 PendingImpulse { get; private set; }
public bool Supported { get; private set; }
public bool Visible { get; private set; }
public int CanvasId => 2; //40FB50 initializes2; a sequence caller is not recovered.
public int Landings { get; private set; }
public void Launch(Vector3 root, Vector3 euler, float pitch)
{
if (!float.IsFinite(root.X + root.Y + root.Z + euler.X + euler.Y + euler.Z + pitch)
|| pitch < 0 || pitch > 45) throw new ArgumentOutOfRangeException(nameof(pitch));
//384/38C use the player's full local transform. This bridge matches the
//port's recovered Bubble Euler convention; generic original Euler remains
//a declared precision/ownership boundary. Upright yaw is the tested path.
var rotation = Matrix4x4.CreateRotationZ(-euler.Z * MathF.PI / 180)
* Matrix4x4.CreateRotationX(-euler.X * MathF.PI / 180)
* Matrix4x4.CreateRotationY(-euler.Y * MathF.PI / 180);
Position = root + Vector3.Transform(new Vector3(0, 80, 50), rotation);
var direction = Vector3.Transform(new Vector3(0, pitch * .02222222276031971f, 1), rotation);
Velocity = direction / OriginalBodySupport.QuickMagnitude(direction) * 1800;
//429A30 does not clear a reused entry's impulse/support state.
PreviousPosition = Position;
Visible = true;
}
public void Step(OriginalBodyPhysics physics, float seconds)
{
if (!Visible) return;
PreviousPosition = Position;
var result = physics.Step(new(Position, Velocity, Vector3.Zero, PendingImpulse, Supported), seconds,
radius: 15, factor: 1, friction: .46f, profile: BodyResponseProfile.Baseball);
Position = result.Body.Position; Velocity = result.Body.Velocity;
PendingImpulse = result.Body.Impulse; Supported = result.Body.Supported;
if (result.Landing != null) Landings++;
}
public void Hide() => Visible = false; //Source disables integration/pairs and hides, retaining body state.
public void Reset()
{
Visible=Supported=false; Position=PreviousPosition=Velocity=PendingImpulse=Vector3.Zero;
Landings=0;
}
}
+73
View File
@@ -0,0 +1,73 @@
using System.Numerics;
namespace GamePort.Game;
/// <summary>Owned C3DBubble sprite transitions (410AE0/410CA0/410D00).
/// The caller owns equip, cleanup, placement and callback scheduling.</summary>
public sealed class BubbleEffect(bool conventionalBlend = false)
{
public bool Visible { get; private set; }
public bool Active { get; private set; }
public bool Expanding { get; private set; }
public bool Collapsing { get; private set; }
public float Timer { get; private set; }
public Vector4 Color { get; private set; } = conventionalBlend ? new(.9f, .9f, .9f, 1) : Vector4.One;
public float Width { get; private set; } = 200;
public float Height { get; private set; } = 200;
public bool ConventionalBlend { get; } = conventionalBlend;
public void Start()
{
// Source equip rejects all three flags before calling this leaf.
Expanding = true;
Timer = 0;
Visible = true;
}
public void Stop()
{
// Source410D00 leaves expansion alone. Jimmy cleanup clears it separately.
Collapsing = true;
Active = false;
Timer = 0;
}
public void ClearExpansion() => Expanding = false;
public void Step(float seconds)
{
if (!float.IsFinite(seconds) || seconds < 0 || seconds >= 1)
throw new ArgumentOutOfRangeException(nameof(seconds));
//410AF2 stores float timer but retains the addition on the x87 stack
//for the fade comparisons. Preserve that distinction at strict boundaries.
var sum = (double)Timer + seconds;
Timer = (float)sum;
if (Active)
{
Width = 240;
Height = (float)(240 + Math.Sin((double)Timer * 10) * 30);
if (ConventionalBlend) Color = new(1, 1, 1, .5f);
}
else if (Expanding)
{
var scalar = (float)sum;
if (sum > 1) { scalar = 1; Active = true; Expanding = false; }
Color = new(scalar);
}
else if (Collapsing)
{
var fade = 1 - sum;
var scalar = (float)fade;
if (fade < 0) { scalar = 0; Collapsing = false; Visible = false; }
Color = new(scalar);
}
}
public void Reset()
{
Visible = Active = Expanding = Collapsing = false;
Timer = 0;
Color = ConventionalBlend ? new(.9f, .9f, .9f, 1) : Vector4.One;
Width = Height = 200;
}
}
+92
View File
@@ -0,0 +1,92 @@
using System.Numerics;
namespace GamePort.Game;
public readonly record struct BubbleSteering(float Speed, float TurnRate, float TargetPitch, float TargetRoll);
public readonly record struct BubbleApply(Vector3 Velocity, float Yaw, float Speed, bool Boing);
/// <summary>
/// Keyboard subset of mode2 input439900 and apply4387E0. Body integration,
/// impulses, acceleration and gadget lifetime belong to their existing phases.
/// Source ownership and precision limits: docs/gameplay/bubble-motion.md.
/// </summary>
public static class BubbleMotion
{
public const float MaximumSpeed = 1350;
public const float TurnLimit = 50;
public const float ReleasedBounceSpeed = 300;
public const float HeldBounceSpeed = 900;
public static BubbleSteering StepInput(float speed, float turn, PlayerInput input,
bool supported, float seconds, float maximumSpeed = MaximumSpeed,
float forwardPitch=-10,float backwardPitch=10)
{
Validate(speed, turn, seconds);
if (!float.IsFinite(maximumSpeed) || maximumSpeed <= 0||!float.IsFinite(forwardPitch)||!float.IsFinite(backwardPitch))
throw new ArgumentOutOfRangeException(nameof(maximumSpeed));
var turnStep = AirSteering.TurnAcceleration * seconds;
if (input.Left) turn += turnStep;
else if (input.Right) turn -= turnStep;
else if (turn < 0) turn = MathF.Min(0, turn + turnStep);
else if (turn > 0) turn = MathF.Max(0, turn - turnStep);
//439ABB..439AE6: mode2 also uses the shared fire predicate as throttle.
var forward = input.Forward || input.Fire;
if (forward && speed < maximumSpeed)
speed = MathF.Min(maximumSpeed, speed + RecoveredMotion.SpeedIncrement);
if (!forward && speed > maximumSpeed * AirSteering.CoastThreshold)
speed -= RecoveredMotion.SpeedDecay * .5f;
//439BA2..439BED: this subtraction deliberately has no crossing clamp.
if (supported) speed = speed > 0 ? speed - RecoveredMotion.SpeedDecay * .5f : 0;
if (input.Backward)
{
if (speed > 0)
speed = MathF.Max(0, speed - RecoveredMotion.SpeedDecay * (supported ? 1 : .5f));
else if (speed < 0)
speed = MathF.Min(0, speed + RecoveredMotion.SpeedDecay);
}
turn = Math.Clamp(turn, -TurnLimit, TurnLimit);
return new(speed, turn, forward ? forwardPitch : input.Backward ? backwardPitch : 0, -.25f * turn);
}
public static BubbleApply StepApply(float speed, float turn, float yaw, float pitch,
Vector3 velocity, bool supported, bool jump, float seconds)
{
Validate(speed, turn, seconds);
if (!float.IsFinite(yaw) || !float.IsFinite(pitch)
|| !float.IsFinite(velocity.X) || !float.IsFinite(velocity.Y) || !float.IsFinite(velocity.Z))
throw new ArgumentOutOfRangeException(nameof(velocity));
float sideSpeed = 0;
//43884E..4388AE: test incoming velocity before replacing its X/Z.
if (velocity != Vector3.Zero)
{
yaw += turn * seconds;
const float friction = .8f;
sideSpeed = turn * .0181818176060915f * (1 - friction) * speed;
}
var (sin, cos) = LabSimulation.Trig(yaw);
var forwardSpeed = LabSimulation.Trig(pitch).Cos * speed;
velocity = new(-sin * forwardSpeed + cos * sideSpeed, velocity.Y,
cos * forwardSpeed + sin * sideSpeed);
//43899A..438A50: direct liveY assignment, after composing current X/Z.
//Only the published scalar halves; current velocity keeps pre-half X/Z.
if (supported)
{
velocity.Y = jump ? HeldBounceSpeed : ReleasedBounceSpeed;
if (!jump) speed *= .5f;
}
return new(velocity, yaw, speed, supported && jump);
}
private static void Validate(float speed, float turn, float seconds)
{
if (!float.IsFinite(speed) || !float.IsFinite(turn) || !float.IsFinite(seconds)
|| seconds < 0 || seconds >= 1)
throw new ArgumentOutOfRangeException(nameof(seconds));
}
}
+4 -3
View File
@@ -5,7 +5,7 @@ namespace GamePort.Game;
public readonly record struct GadgetCanvas(int Id, Vector2 Position);
/// <summary>Bounded group0 gadget panel; source425870/425EF0/425B20/427370.</summary>
public sealed class GadgetScreen(SceneInventory inventory)
public sealed class GadgetScreen(SceneInventory inventory, Func<int>? rawMode = null)
{
public static IReadOnlyList<Vector2> Positions { get; } = Array.AsReadOnly<Vector2>([new(12,182), new(158,182), new(12,327), new(157,327),
new(342,182), new(487,182), new(342,327), new(487,327)]);
@@ -24,7 +24,7 @@ public sealed class GadgetScreen(SceneInventory inventory)
{
if (Open) { Close(); return true; }
if (!permitted) return false;
if (EquippedMode(inventory.SelectedGadget) != -1)
if ((rawMode?.Invoke() ?? EquippedMode(inventory.SelectedGadget)) != -1)
{
inventory.SelectGadget(-1); Changed?.Invoke(); return true;
}
@@ -72,7 +72,8 @@ public sealed class GadgetScreen(SceneInventory inventory)
var item = Hovered;
var practice = PracticeArmed;
Close();
inventory.SelectGadget(item);
//428F61 loads Bubble practice BEFORE live radius/mode/effect setup.
inventory.SelectGadget(item,equip:!(practice && item==0));
if (practice) PracticeRequested?.Invoke(item);
return true;
}
+35
View File
@@ -0,0 +1,35 @@
using System.Numerics;
namespace GamePort.Game;
public readonly record struct GrapplerCameraLocals(Vector3 Eye,Vector3 Look,Vector3 Gains)
{
public static GrapplerCameraLocals Default=>new(new(0,200,-350),new(0,80,0),new(1.6f,1,1.6f));
public GrapplerCameraLocals Equip()=>this with{Eye=new(0,50,-350),Look=new(0,150,80)};
public GrapplerCameraLocals Attach()=>this with{Eye=new(Eye.X,400,-650),Gains=new(.8f,1,.8f)};
public GrapplerCameraLocals Detach()=>new(new(0,50,-350),new(0,130,100),new(1.6f,1,1.6f));
}
public readonly record struct GrapplerCameraResult(Vector3 Eye,Vector3 Target,Vector3 Look,Vector3 DesiredEye,float RayGain);
/// <summary>Ordinary438BC0/439900 follow branches. Excludes flags828/851 and
/// Bubble mode2; aim is quantized from look minus OLD shared eye.</summary>
public static class GrapplerCamera
{
public static GrapplerCameraResult Follow(GrapplerCameraLocals locals,Vector3 root,Vector3 rotation,
float turnRate,int movementMode,Vector3 oldEye,float seconds,Func<Vector3,Vector3,SupportHit?>? ray)
{
GrapplerMotion.Time(seconds);GrapplerMotion.Finite(root);GrapplerMotion.Finite(rotation);GrapplerMotion.Finite(oldEye);
if(movementMode==2)throw new NotSupportedException("Grappler camera excludes Bubble mode2");
var eyeLocal=locals.Eye;var lookLocal=locals.Look;var eyeRotation=rotation;Vector3 gains;
if(movementMode==0)
{eyeLocal.Y-=20;lookLocal.Y=(float)(lookLocal.Y+1.9*10);gains=locals.Gains+new Vector3(0,.2f,0);}
else {eyeRotation=new(0,RocketOrientation.AddAxis(rotation.Y,turnRate),rotation.Z);gains=new(1.2f,2,1.2f);}
var desired=root+RocketOrientation.Rotate(eyeLocal,eyeRotation);
var look=root+RocketOrientation.Rotate(lookLocal,rotation);float gain=1;
if(ray?.Invoke(look,desired) is{} hit){desired=look-(look-hit.Position)*.75f;gain=1.5f;}
var eye=oldEye+(desired-oldEye)*gains*(gain*seconds);
var(pitch,yaw)=OriginalHeading.Angles(look-oldEye);
var direction=RocketOrientation.Rotate(Vector3.UnitZ,new(pitch*.02197265625f,yaw*.02197265625f,0));
return new(eye,eye+direction*200,look,desired,gain);
}
}
+115
View File
@@ -0,0 +1,115 @@
using System.Numerics;
using GamePort.Assets;
namespace GamePort.Game;
/// <summary>Process globals owned by retained Jimmy; not TSK fields.</summary>
public sealed class GrapplerMemory
{
public Vector3 Anchor;
public float FirstLength,Length,ReelTarget;
public float RopeScaleZ=1;
public GrapplerSwing Swing;
public void Clear(){Anchor=default;FirstLength=Length=ReelTarget=0;RopeScaleZ=1;Swing=default;}
}
public readonly record struct GrapplerMove(Vector3 Root,Vector3 Velocity);
public readonly record struct GrapplerInputResult(Vector3 Root,Vector3 Rotation,Vector3 Velocity,bool NewAttachment,bool EndsActiveInput=false);
/// <summary>Owned raw7 controller, bounded to VR08. Body and input phases are
/// placed by LabSimulation; shared globals survive reconstructed scene loads.</summary>
public sealed class GrapplerGadget : IDisposable
{
private readonly GrapplerRay ray;
public GrapplerMemory Memory {get;}
public GrapplerCameraLocals Camera {get;private set;}=GrapplerCameraLocals.Default;
public bool Equipped {get;private set;}
public bool Attached {get;private set;}
public bool SwingPose {get;private set;}
public bool CursorVisible {get;private set;}
public bool LoopPlaying {get;private set;}
public Vector3 CursorPosition {get;private set;}
public Vector3 RopeRoot {get;private set;}
public Vector3 RopeRotation {get;private set;}=new(0,0,180);
public int Attachments {get;private set;}
public int Detachments {get;private set;}
public int Contacts {get;private set;}
public event Action<bool>? EquippedChanged;
public event Action? Detached;
public event Action<int,bool>? Sound;
public event Action? LoopStopped;
public GrapplerGadget(Mesh world,string level,GrapplerMemory? memory=null)
{ray=new(world,level);Memory=memory??new();}
public void Equip()
{
if(Equipped)Release();
Equipped=true;Camera=Camera.Equip();EquippedChanged?.Invoke(true);
}
public void Release()
{
Detach();CursorVisible=false;Camera=GrapplerCameraLocals.Default;
if(Equipped){Equipped=false;EquippedChanged?.Invoke(false);}
SetLoop(false);
}
public void Reset()
{Release();Memory.Clear();Attachments=Detachments=Contacts=0;RopeRoot=default;RopeRotation=new(0,0,180);}
public void Detach()
{
if(!Attached)return;
Attached=SwingPose=false;Detachments++;
Memory.Swing=Memory.Swing with{X=Memory.Swing.X*.96f,Z=Memory.Swing.Z*.96f};
Camera=Camera.Detach();SetLoop(false);Detached?.Invoke();
}
public void Contact()
{
if(!Attached)return;
Contacts++;var response=GrapplerGeometry.Contact(Memory.Swing);Memory.Swing=response.Swing;
if(response.Detach)Detach();
}
public GrapplerInputResult StepInput(Vector3 root,Vector3 rotation,Vector3 velocity,PlayerInput input,
float seconds,Func<Vector3,GrapplerMove> move)
{
if(!Equipped)return new(root,rotation,velocity,false);
SetLoop(Attached&&input.Fire);
Memory.Length=GrapplerMotion.FastReel(Memory.Length,Memory.ReelTarget,seconds);
if(GrapplerMotion.JumpDetaches(input.Jump,input.Fire,Attached))
{Detach();return new(root,rotation,Vector3.Zero,false);}
if(Attached)
{
rotation=new(0,rotation.Y,0);SwingPose=true;
var constraint=GrapplerGeometry.Constrain(root,Memory.Anchor,Memory.Swing,Memory.Length,seconds);
var body=move(constraint.DesiredRoot);root=body.Root;velocity=body.Velocity with{Y=0};
//The callback can detach/clear scalars, but this source tail still runs.
Memory.Swing=GrapplerMotion.Swing(Memory.Swing,seconds,constraint.Offset.X,constraint.Offset.Z,Memory.Length);
var(pitch,yaw)=OriginalHeading.Angles(constraint.Offset);
RopeRotation=new(pitch*.02197265625f,yaw*.02197265625f,0);
RopeRoot=constraint.DesiredRoot+Vector3.UnitY*116;
}
var aim=ray.Aim(root,rotation,input.Fire,input.GrapplerEnter,Memory.Length,seconds);
Memory.Length=aim.Length;CursorVisible=aim.CursorVisible;CursorPosition=aim.CursorPosition;
if(aim.EndsActiveInput||!input.Fire)return new(root,rotation,velocity,false,aim.EndsActiveInput);
if(Attached)
{
bool reeling=Memory.Length>250;
Memory.Length=GrapplerMotion.HeldReel(Memory.Length,seconds);SetLoop(reeling);
return new(root,rotation,velocity,false,true);
}
//426A70 performs a fresh query; a cursor position is not an anchor cache.
if(ray.Trace(root,rotation) is not{} hit)return new(root,rotation,velocity,false,true);
var attached=GrapplerMotion.Attach(root,hit.Hit.Position,velocity,Memory.FirstLength);
Memory.Anchor=hit.Hit.Position;Memory.Length=attached.Length;Memory.FirstLength=attached.InitialLength;
if(attached.RopeScaleZ is{} scale)Memory.RopeScaleZ=scale;
Memory.ReelTarget=attached.FastReelTarget;Memory.Swing=default;
Attached=true;Attachments++;Camera=Camera.Attach();
Sound?.Invoke(31,false);SetLoop(false);SetLoop(true);
return new(root,rotation,attached.Velocity,true,true);
}
public void Dispose()=>Release();
private void SetLoop(bool play)
{
if(LoopPlaying==play)return;LoopPlaying=play;
if(play)Sound?.Invoke(34,true);else LoopStopped?.Invoke();
}
}
+69
View File
@@ -0,0 +1,69 @@
using System.Numerics;
namespace GamePort.Game;
public readonly record struct GrapplerSurface(bool PolygonPresent,bool MaterialPresent,bool DefinitionPresent,int MaterialId)
{
public bool BlocksCursor=>PolygonPresent&&(!MaterialPresent||DefinitionPresent&&
(MaterialId is >=60 and <=69 or >=80 and <=89 or >=210 and <=219 or -1 or 170));
}
public readonly record struct GrapplerAim(bool CursorVisible,bool EndsActiveInput,Vector3 CursorPosition,float Length);
public readonly record struct GrapplerConstraint(Vector3 Offset,Vector3 DesiredRoot);
public readonly record struct GrapplerContact(GrapplerSwing Swing,bool Detach);
/// <summary>429D00 aim/constraint and42A69B post-base contact contracts.
/// Caller still owns registry phases, actual body callbacks, camera and helpers.</summary>
public static class GrapplerGeometry
{
public static GrapplerAim Aim(Vector3 root,Vector3 endpoint,Vector3? hit,GrapplerSurface surface,
bool fire,bool enter,float length,float seconds)
{
Finite(root);Finite(endpoint);
GrapplerMotion.Finite(length);GrapplerMotion.Time(seconds);
if(hit is not{} point)return new(false,false,default,length);
Finite(point);
double x=(double)point.X-root.X,y=(double)point.Y-root.Y,z=(double)point.Z-root.Z;
if(Math.Sqrt(x*x+y*y+z*z)<450)return new(false,true,default,length);
if(surface.BlocksCursor)
return new(false,true,default,fire||enter?GrapplerMotion.HeldReel(length,seconds):length);
var delta=endpoint-root;
double inverse=InverseMagnitude(delta);
var offset=new Vector3((float)((double)(float)(delta.X*inverse)*100),
(float)((double)(float)(delta.Y*inverse)*100),(float)(delta.Z*inverse*100));
return new(true,false,point-offset,length);
}
public static GrapplerConstraint Constrain(Vector3 root,Vector3 anchor,GrapplerSwing swing,float length,float seconds)
{
Finite(root);Finite(anchor);
Validate(swing);GrapplerMotion.Finite(length);GrapplerMotion.Time(seconds);
var pivot=root+Vector3.UnitY*116;
var delta=new Vector3((float)((float)(anchor.X-pivot.X)+(double)swing.X*seconds*30),
anchor.Y-pivot.Y,(float)(((double)anchor.Z-pivot.Z)+(double)swing.Z*seconds*30));
double inverse=InverseMagnitude(delta);
var offset=new Vector3((float)((double)(float)(delta.X*inverse)*length),
(float)((double)(float)(delta.Y*inverse)*length),(float)(delta.Z*inverse*length));
return new(offset,new(anchor.X-offset.X,(float)(anchor.Y-((double)offset.Y+116)),anchor.Z-offset.Z));
}
public static GrapplerContact Contact(GrapplerSwing swing)
{
Validate(swing);
double x=swing.X,z=swing.Z;
return new(new(0,0,swing.Elapsed),Math.Sqrt(x*x+z*z)>60);
}
private static double InverseMagnitude(Vector3 vector)
{
var magnitude=OriginalBodySupport.QuickMagnitude(vector);
if(magnitude<=0)throw new NotSupportedException("Source zero-vector normalization produces nonfinite geometry");
return 1d/magnitude;
}
private static void Finite(Vector3 vector)
{
if(!float.IsFinite(vector.X)||!float.IsFinite(vector.Y)||!float.IsFinite(vector.Z))
throw new ArgumentOutOfRangeException(nameof(vector));
}
private static void Validate(GrapplerSwing swing)
{GrapplerMotion.Finite(swing.X);GrapplerMotion.Finite(swing.Z);GrapplerMotion.Finite(swing.Elapsed);}
}
Loaded 100 of 287 files, more files were not shown because too many files have changed in this diff. Show more