Add controllable lab walking checkpoint with collision and chase camera

This commit is contained in:
UnixNight committed 2026-10-23 23:29:40 -04:00
1 parent 37fa18094f
commit 58424120bb
26 files changed
+1848 -110

No files matched your search

+140
View File
@@ -0,0 +1,140 @@
# Controllable lab: provisional collision reconstruction
This checkpoint implements deterministic static geometric collision against the
extracted original scene. It is **not the recovered original collision solver**.
The original collision masks, class activation rules, shape selection, tolerances,
step handling and controller state integration are still unresolved. No original
runtime comparison establishes collision fidelity.
## Source geometry and inclusion policy
`level1b.omt` SHA-256:
`5a33d11311fc222631eb8f7384d1863192cb1f55f7e67035caa0ae12fd9892ab`.
The existing read-only extractor produces
`artifacts/extracted/level1b/scene.json` in unchanged original Y-up world units:
8,607 expanded vertices and 2,869 triangles. Collision uses **all nondegenerate
source triangles**, independent of `Mesh.Draws`, texture or material resolution.
The actual lab has no degenerate triangles removed by this rule. Mesh vertex/index
arrays and original files are not modified.
The lab includes 45 draw ranges / 325 triangles referencing unresolved material18.
The renderer correctly skips those ranges under recovered null-material behavior
(see graphics.md). Names include `blockfan`, `blockfan01`, `blockfan02`,
`blockscreen`, `blockwaterthing`, `blockwindow`, `blockcrate*`, `phoneblock*`,
`doorblock*`, plus Box/Plane/Cylinder/Mesh objects. These names and simplified
surfaces support a proxy interpretation; they do not prove a complete original
collision mask. Rendering visibility alone is therefore not used to discard them.
The regression creates a mesh with no visible draws and proves its original
triangles still block movement.
No decorative surface is excluded at this checkpoint: there is insufficient
specific evidence for a general exclusion rule. This conservative policy can block
on decorative surfaces or invisible proxies that original state/activation logic
would disable. Animated/dynamic scene entities are not added to this static mesh.
There is no invented room-sized collision box or coordinate clamp.
## Capsule coordinates and API
`src/GamePort/Game/SceneCollision.cs` accepts an extracted `Mesh` and provides:
- `Move(feetPosition, displacement, radius, height)` returns final feet `Position`,
final-support `Grounded`, and `HitCeiling`/`HitWall` impacts during the move.
- `GroundHeight(point, maxDrop, maxRise=0)` returns the highest triangle surface
inside the requested vertical interval at point.XZ. The default upper bound is
point.Y, so an overhead ceiling cannot replace the floor below a GAM root.
- `ClipCamera(target, desiredEye, radius=8)` sweeps a sphere from the camera target
toward the desired eye and stops at the first source surface.
The collision volume is a vertical capsule: its lower sphere center is feet.Y plus
radius, its upper center is feet.Y plus height minus radius. Height includes both
caps; all units retain original asset scale. Ground surfaces and ceiling undersides
are treated as two-sided geometry. The provisional walkable threshold is contact
normal.Y >=0.65 (about49.46 degrees); steeper contacts classify as walls. Skin is
0.05 world units; numerical tolerance is0.005. These constants are implementation
choices, not recovered original values.
The recovered standing Jimmy base bounds are Y=-64.6165..144.8196, height209.4361,
X width76.6604 (X=-34.1281..42.5323), and Z=-20.4173..49.0276. The collision code
does not assume a radius or a model-root offset. Callers supply dimensions and
render the base model with origin.Y=feet.Y-minBaseY. Regression radii24 and34.7
exercise both a narrower provisional torso volume and a larger standing volume;
neither is claimed as recovered. A base-mesh bounding radius can overestimate limbs
or underestimate a different animated pose, so it does not establish original
physics geometry.
At GAM root (5071.933105,26.661896,824.103943), the highest floor below root is
Y=0.5486332. Either tested radius stands at feet Y=0.59863245 after collision skin,
with no lateral spawn correction. GAM root data remains unchanged. The model's
negative base Y and the original actor-root offset remain separate from capsule
feet; the integrating controller is responsible for that transform.
## Algorithm and bounded behavior
Triangles are validated once; invalid indices/nonfinite positions are rejected,
and zero-area triangles are ignored. Per-triangle axis-aligned bounds only prune
queries; they are not solid collision volumes. Narrow-phase distance uses the
closest pair between the vertical capsule axis segment and a triangle: face
intersection, endpoint-to-triangle regions, and segment-to-each-edge distances.
This covers triangle edges and vertices that an axis-center ray would miss.
Movement first resolves initial overlaps, choosing the deepest contact for at most
12 passes. It then uses conservative advancement of capsule/triangle closest
features to find the earliest contact, with at most40 iterations per triangle.
The separating closest-pair plane supplies a safe advance; the finite-limit
fallback stops conservatively. Remaining motion is projected along the contact
plane and swept again, for at most8 slide passes. Support is queried at the final
position, so crossing a floor earlier does not keep the actor grounded after a
ledge. Falling/jumping actors are never snapped down by a ground-height query.
Face-region closest points use direct plane projection. When a closest contact
cannot be distinguished from that plane within0.005 units, its exact plane normal
is used. This avoids false horizontal normals from floating-point cancellation on
large coplanar triangle seams. Tests include far-apart vertices and original-scale
translated geometry. Float32 arithmetic is deterministic for the same input stream
on the tested .NET runtime; cross-architecture bit identity is not established.
Impossible spawn gaps, initially deeply intersecting solid volumes, more than8
successive slide constraints in one move, and extreme grazing feature sequences
can exhaust bounds and stop short. This is a bounded static checkpoint solver,
not a general rigid-body engine. There is no recovered stair step-up, moving
platform, entity collision, friction, original slope state, trigger or damage
behavior. Camera sweep does not depenetrate an initially embedded target.
## Verification
From GamePort, after normal asset preparation:
```bash
source scripts/env.sh
dotnet run --project tests/GamePort.CollisionTests/GamePort.CollisionTests.csproj
```
Eleven deterministic checks pass on local Linux .NET10. They compile linked
collision/Mesh/PNG sources without an additional NuGet test framework. Coverage:
flat support and bounded ground queries;10,000-unit floor/wall falls/sweeps;
wall sliding/departure; corner persistence; ceiling/underside; slope climbing and
landing; ledge departure; isolated triangle edges/vertices; camera sphere sweeps;
100,000-unit sweeps in a translated original-scale room;2,000 repeated floor-seam
moves; invisible proxy retention; malformed input; and actual lab data.
Actual lab tests use both radius24 and34.7, height209.4361. Two identical240-tick
traces at3 horizontal units/tick replay identically, stay finite/above the floor,
and travel720 units in the initial155-degree direction to approximately
(4767.5977,0.598948,171.56355). Six hundred eastward movement ticks encounter
original geometry and stop near these positions:
| Radius | X | Y | Z |
| --- | --- | --- | --- |
| 24 | 5405.448 | 0.601050 | 730.06195 |
| 34.7 | 5394.750 | 0.601352 | 724.18370 |
The small Z slide follows original source surfaces; no room boundary is supplied.
A synthetic jump trajectory using550 units/s initial speed and1064 units/s²
acceleration rises and lands back at (5071.933,0.598633,824.1037) for both radii.
Those trajectory inputs exercise the collision API and are not claimed as the
recovered complete jump state machine. Original-lab replay/wall/jump checks took
about0.5s combined locally, excluding scene loading/compilation.
These are algorithm and source-data tests. Controller/input/render integration,
GPU output and native Windows behavior require the primary checkpoint validation;
this report does not claim those tests ran as part of the isolated collision suite.
+266
View File
@@ -0,0 +1,266 @@
# Walking and jump checkpoint evidence
Static investigation, 2026-10-23. Sources: read-only `Original/Neutron.exe`,
`artifacts/binary/neutron.asm`, and the existing RTTI/PE analysis. No original
program was executed for these findings. Recovered instructions are not runtime
verification. Addresses below are executable VAs; for these `.text` ranges the
on-disk file offset is VA minus `0x400000`.
## Pointer and update conventions
`C3DJimmy` has its game interface at complete-object offset `0xC0`. The interface
vtable is `0x4A373C`, complete-object OMT vtable `0x4A3BDC`. Confusing these
pointers changes every field interpretation. Input dispatcher `0x438A60` and
update `0x437940` receive interface pointers; walking `0x438BC0`, ground apply
`0x437C40`, and air apply `0x437F90` receive complete-object pointers.
Relevant interface methods:
| Slot | Target | Meaning recovered here |
|---|---|---|
| `0x218` | `0x458960` | Grounded predicate |
| `0x248` | `0x471AD0` | Friction getter, interface `+0x150` |
| `0x24C` | `0x471AE0` | Friction setter |
| `0x310` | `0x472300` | Current position vector |
| `0x318` | `0x472330` | Set position vector |
| `0x328` | `0x4723F0` | Current Euler rotation |
| `0x334` | `0x458F90` | Add current Euler rotation |
| `0x36C` | `0x472660` | Set destination rotation |
World integration at `0x479EBB–0x479F8D` adds queued impulse to velocity and
clears the queue, adds object acceleration times `dt`, adds global gravity
times `dt`, then obtains the updated velocity for displacement times `dt`.
This is semiimplicit Euler. Game gravity is `(0,-800,0)`, set at `0x44D414`;
the engine initialization value `-5000` is superseded. Exact ordering of input,
rotation interpolation, physics and rendering across the entire frame remains
unverified. A fixed 60 Hz simulation is a port compatibility choice: original
speed increments are per invocation, while displacement and interpolation use
seconds. Original gameplay cadence has not been observed.
The physics support-hit branch `0x479DF7–0x479E54` sets grounded, zeroes
vertical velocity and sets object acceleration to cancel gravity. Because
queued impulses are applied afterward, a takeoff step which still finds
support can receive the full 550 impulse with no net gravity that step,
before airborne acceleration begins. A port's immediate grounded-to-airborne
transition can differ by one tick; do not claim an exact original jump apex.
Movement dispatcher mode 1 (`0x438B60`) logs and returns without running
walking input. Ordinary arrow acceleration/turn input is therefore absent
while that air mode is active. Air apply reuses takeoff speed and rotation,
preserving vertical velocity; with the default extra turn rate zero, it has
no new keyboard steering. Its nonzero extra-turn lateral calculation uses
`turnRate*(1-friction)*speed/55`, without the ground branch's additional `dt`
on lateral magnitude, and omits the keyboard side contribution. A port that
allows normal walking input in the air should identify that as an approximation.
## Normal keyboard walking
Constructor `0x437280` initializes complete-object fields `+0x6BC=30` speed
increment, `+0x6C0=35` speed decay, `+0x6C4=600` maximum speed,
`+0x6C8=0` current speed, `+0x6D4=0` extra turn rate. Constructor `0x4373B0`
sets friction to float `0.8` through `0x4711B0`, which forwards via slot
`0x24C`. The subsequent `0.7` at `0x4373C2` is a different property and must
not replace this friction value.
Arrow booleans are `0x50985D` left, `0x50985E` up, `0x50985F` right,
`0x509860` down. Key array starts at `0x509838`, indexed by Windows virtual
key; event setters `0x46A360`/`0x46A380` confirm these arrow indices.
Ignoring mouse/analog input and special gadgets, walking input proceeds in
this order:
1. Down enables the reverse flag at `0x438F9A–0x438FDD`.
2. Left has precedence over Right. Left at `0x43921C` sets yaw delta `+20`
degrees and side contribution `-1000`; Right at `0x4391A7` sets `-20`
and `+1000`. Either adds 30 to speed, capped at 600.
3. Up at `0x4392A9` separately adds 30, capped at 600. Thus Up+Left/Right
increments speed twice per invocation. Up halves any nonzero accumulated
yaw delta at `0x4392CC`; keyboard Up+Left/Right therefore produces
`+10`/`-10` rather than `+20`/`-20` degrees of target offset.
4. If reverse is enabled and the reverse-run flag is clear, subtract
`35*1.5=52.5` from speed, clamped below at `-600*0.5=-300`
(`0x439344–0x43937D`). Up+Down is processed in this order too.
5. If neither Up nor reverse marked the moving flag, decay speed by 35
toward zero (`0x439416–0x43948A`). Turning by itself adds 30 above but
still encounters this decay, because the turn branch sets `+0x6E6`,
not the forward moving flag `+0x6E4`.
6. If a yaw input was supplied, set destination yaw to **current yaw plus
this invocation's delta**, at `0x4395A1–0x4395C9`. It does not repeatedly
accumulate into the previous destination. A pending pushed setter argument
shifts the apparent local stack offset by four bytes here.
Rotation interpolation `0x43A420–0x43A5C2` wraps the yaw error to
`[-180,180]` and adds `error * dt * 3.7` to current yaw. The `3.7` is a
double at `0x4AFCF0`; pitch and roll use `4.5` at `0x4AFD38`. Consequently
held Left/Right alone requests about 74 degrees/s, and Up+Left/Right about
37 degrees/s, before any other turn source. The full interpolator also has
enable/dirty flags, so these formulas describe its active branch.
At zero pitch/roll, forward is `(-sin(yaw), 0, cos(yaw))` and right is
`(cos(yaw),0,sin(yaw))`. Ground apply `0x437CC9–0x437DF0` preserves vertical
velocity and computes:
```text
currentYaw += extraTurnRate * dt
sideSpeed = (extraTurnRate * (1-friction) * speed / 45 + sideContribution) * dt
velocityXZ = forward(currentYaw) * speed + right(currentYaw) * sideSpeed
```
The ordinary keyboard walking path does not assign `extraTurnRate`;
constructor zero is therefore the relevant baseline. Its lateral key term is
still present, e.g. Left at `dt=1/60` contributes about `-16.667` units/s to
local right. Original angle lookup converts float degrees by multiplying
float `45.5111122`, truncating through `0x47F940`, then masking with `0x3FFF`.
It uses 16384-entry float sine/cosine arrays. Continuous host trigonometry
is an approximation to that lookup.
### Reverse-run branch uncertainty
There is a branch when complete `+0x830 > 1.5` at `0x439383` which sets
speed 600, remembers current yaw plus 180 degrees, and sets reverse-run flag
`+0x828`. While that flag remains set, reverse keeps speed 600. Input release
clears the flag. However, the cached full executable disassembly only shows
initialization/reset and reads of this timer in the player code; no increment
was found. The timed transition's reachability is unresolved. Persistent
backpedal capped at -300 is the directly usable baseline. Do not silently add
a hold timer or claim the turnaround runs in the original.
## Basic jump and held-input behavior
Complete field `+0x7C4` is the movement mode (walking 0, air 1, flying 2,
seated 3), while `+0x7E8` is a separate jump state. The outer update
`0x437A7E–0x437C1C` calls air apply while jump is held or while an existing
air mode has not yet landed. A released, grounded player is returned to
walking, and **jump state is reset to 0** at `0x437B9E`
(`interface +0x728 = complete +0x7E8`).
Jump-held predicate `0x4378D0` accepts global right mouse, Insert, Shift,
numpad 0, or controller flag, subject to gadget-6/ground gating. The
previously cited Jimmy helper `0x42A730` is separate; the complete-object
vtable slot `0x158` used by base player here targets `0x4378D0`.
For jump states less than 3, `0x438148–0x43818D` sets additional object
acceleration Y to `gravityY*1.33 - gravityY`. Combined with global gravity,
net acceleration is approximately `-1064` units/s². The factor is float
`1.33000004` at `0x4AFCE4`. Input release from state 1 does not shorten the
impulse or alter this acceleration immediately.
Held dispatch table at `0x4387AC` is:
| State | Target | Effect |
|---|---|---|
| 0 | `0x438379` | If grounded, select `JUMP`, queue `(0,550,0)`, enter 1, clear hold timer `+0x874` |
| 1 | `0x4383FD` | Add `dt` to hold timer; after `>0.4`, run gadget/level checks and enter 3 |
| 2 | `0x438559` | On renewed hold, run gadget/level checks and enter 3 |
| 3 | `0x438693` | On ground contact, stop effect and enter 4 |
| 4 | `0x4387A1` | No action while held |
| 5 | `0x4386FB` | Reset to 0 if grounded |
Released table at `0x4387C4`, indexed by state minus 1, maps 1 to
`0x438732` (enter 2), 2 to no action, 3 to `0x438745` (stop effect, enter
4), 4 to `0x43879A` (grounded resets 0), and 5 to `0x43878C` (same).
The outer grounded-release reset usually handles landing before this table.
State 4 blocks automatic repetition while held. The zero-burn gadget-disabled
path below resets state 3 to 0 sooner and can repeat on landing while held.
### Long hold without an available gadget
Absence of a gadget does **not** leave the jump in state 1. At
`0x43848E–0x4384C8`, profile 0/item 3 state 0 or 4 branches to a path that
sets jump state 3 on every level except `VR04`. This skips the effect/animation
and velocity-Y=10 branch used when the gadget is allowed. `0x403950` retrieves
that profile item state. Initial current gadget is -1 at `0x42225F`.
Crucially, there is an earlier guard at `0x438192–0x43820D`. Complete
`+0x7F8` points to `C3DJetpackFire`, allocated in the player constructor
(`0x4374DF`, stored `0x4374EF`, debug name at `0x4F058C`). Its constructor
`0x421D80` initializes burn time `+0x6C0=0` at `0x421E68`; takeoff also
clears it at `0x438387–0x438391`. If this object exists and burn time is
<=0, states 3 or 4 reset to jump state 0, retain air mode 1, select `FALL`,
and return **before** changing object acceleration. Thus a normal disabled
gadget keeps the prior extra acceleration `-264` and remains ballistic at
net `-1064`, even after a long hold. No powered hover needs to be invented
for that case. If jump is still held when grounded after this state reset,
state 0 can queue another jump. This repeat-on-landing is a static call-path
consequence, awaiting original runtime comparison.
Only a null effect pointer or positive burn time reaches the following
distance-controlled acceleration branch for state >=3
(`0x438210–0x43830D`). For `g=-800`:
| Condition | Additional Y acceleration | Net including gravity |
|---|---:|---:|
| complete `+0x86C <500`, vertical velocity >=-1 | `-g -0.1*g = 880` | 80 |
| complete `+0x86C <500`, vertical velocity <-1 | `-g -0.3*g = 1040` | 240 |
| complete `+0x86C >=500` | `0.1*g-g = 720` | -80 |
`+0x86C` is **not a timer**: `0x425450–0x42547C` writes the distance between
Jimmy and his `C3DShadow` (`complete +0xA2C`). Jimmy constructor `0x42250C`
creates it via `0x43F640`, stores it at `0x42251C`, and names it with the
debug string `C3DShadow` at `0x4EE75C`. Shadow constructor `0x43F775` sets
its height field `+0x5EA` to 30. Update `0x4252E0` queries a vertical segment
from Jimmy root `P` to `P-(0,2500,0)` through `0x47C6E0`; the returned hit at
global `0x5CFC60` supplies the shadow's Y. `0x4253BE–0x42541C` sets shadow
position to `(playerX, hitY+height/2-2, playerZ)`. With default height30 the
distance is therefore `abs(playerRootY-hitY-13)`. Global `0x4F8210 !=0`, a
failed query, or absent shadow leaves the previous distance unchanged.
Ground-distance semantics are directly supported, but the exact original
query filter/surface selection remains unverified.
## Walking follow camera
Default fields at `0x437740` are local eye `(0,200,-350)`, target `(0,80,0)`,
and interpolation coefficients `(1.6,1,1.6)`. Normal nongadget walking sets
complete `+0x84C=10` at `0x438CC6`; camera construction adjusts those to:
```text
desiredEye = transformLocal(0, 200-2*10, -350) = transformLocal(0,180,-350)
lookTarget = transformLocal(0, 80+1.9*10, 0) = transformLocal(0,99,0)
```
Eye construction is `0x439625–0x439652`; target construction
`0x4396A9–0x4396DA`. The factor at `0x4AFCE8` is **double 1.9**.
`0x472980` transforms the local point by actor Euler rotation and position.
Normal interpolation at `0x4397B1–0x4397F1` is:
```text
camera += (desiredEye - previousCamera) * (1.6, 1.2, 1.6) * obstructionFactor * dt
```
The extra 0.2 in Y comes from double `0x4A2AD0`. Unobstructed factor is 1;
`0x43B820` performs a scene ray query, modifies the desired eye if hit, and
returns factor 1.5. The precise obstruction geometry and reverse-run camera
remain unported details. A special flag `+0x851` instead uses 0.2 on every
axis. The ordinary code looks toward the target using the camera position
saved at the start of the handler (`+0x714,+0x718,+0x71C`), then writes the
viewport angles; copying a conventional look-at using the new eye is a small
but real approximation.
## Actor pivot, scale and collider
No reliable original capsule/cylinder dimensions or actor-specific model
translation/scale were recovered in this investigation. Jimmy InitObject's
call with `(0,600,100)` is a **position setter**, slot `0x318`, and supplies
no collider dimensions. Shape-change hook `0x462270` reads the shape bounding
radius and six min/max values, forwarding them to object properties; this
does not establish a capsule radius or the player-specific collision proxy.
Raw standing model bounds, the GAM root placement and the preview sole
correction remain separately documented in existing scene/gameplay findings.
A capsule based on raw mesh width/height and a separate simulation-feet
origin is a port approximation. Neither the observed floor contact nor the
raw bounding box proves an original scale factor or root-to-feet offset.
## Checks and remaining work
Instruction ranges were re-read with bounded `objdump -d -M intel` commands;
float/double constants and jump tables were independently decoded from file
bytes with `tools/binary/pe_inspect.py` and Python `struct`. This caught three
material preliminary errors: key strafe signs, assuming the target yaw
accumulates, and interpreting the look-target multiplier as a float.
Outstanding: original frame phase order/cadence; reverse timer writer;
long-hold jump/repeat comparison; shadow query surface selection; original
collision proxy and shape converter mode-2/pivot behavior. No runtime fidelity
claim follows from the static formulas or a successful port build.
+15 -7
View File
@@ -30,17 +30,25 @@ 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.
Physics arithmetic fragments are independent of a full controller; no invented
collision/task system has been silently inserted. The main program remains a
scene investigation runtime; future simulation must be a separate stateful module
with recovered timing, input, collision, triggers and progression.
`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.
`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
is feet; a separate original-root height feeds camera math and standing mesh minimum
Y feeds visual placement. GAM/ASE data is preserved. There is no task/trigger engine.
Application/PreviewCharacterPlacement and PreviewAnimationLibrary keep inspection
policies separate from gameplay fragments. Ground contact is a model-only offset
policies available alongside the walking checkpoint. Inspector ground contact is a model-only offset
derived once from visible surfaces and the standing bind pose, with raw source
placement preserved. Clip selection displays actual still/moving state and does
not simulate walking/jumping actions. These policies need replacement/integration
as original controller, actor transforms and state behavior are recovered.
not simulate walking/jumping actions. In walking mode, original idle/run/backpedal/
jump/fall clips follow simulation state. Looping, timing, transitions and the visual
floor-derived pivot still require original comparison and further recovery.
Subsystem implementation and validated ownership are documented in
`infrastructure.md`, `analysis/graphics.md` and `rendering.md` as they become
+11 -3
View File
@@ -13,6 +13,7 @@ separate evidence categories. **The game is not fully reconstructed/playable yet
| Windows x64 publish | Pass | Correct PE32+ app and SDL3.dll; initial native rendering user-reported |
| Windows package under Wine64 | Preliminary headless pass | Two frames, exit0; fixed-time readback identical to Linux on lavapipe; validation disabled |
| Corrected Windows preview under Wine64 | Preliminary window pass | Six frames, key2 animation switch, resize800x600, exit0; validation disabled |
| Windows walking package under Wine64 | Preliminary240-step window pass | SDL arrows/Shift, walking/jump/landing and800x600 resize; matches Linux movement statistics; validation disabled |
| Linux self-contained package | Native run verified | Two headless frames without SDK/source/originals mounted |
| Vulkan1.3 lab | llvmpipe + GTX1070 | Real indexed/textured/depth frame/readback; validation enabled, zero errors |
| Original camera/projection | Data/math integrated | GAM camera, recovered FOV/clips; startup/follow behavior not compared |
@@ -26,10 +27,15 @@ separate evidence categories. **The game is not fully reconstructed/playable yet
| Mouse/relative input/controller | Incomplete | SDL entry point declaration alone is not behavior |
| Audio stream | Linux dummy device | Original11025Hz mono WAV consumed10752bytes/500ms; speakers untested |
| Physics fragments/RNG | Standalone C# tests | Recovered arithmetic; controller/jump/collision state incomplete |
| No-gadget walking/jump controller | Linux tests and GPU replay pass | Recovered speed/yaw/ballistic formulas; transient jump state/order approximated |
| Static source collision | 11 deterministic groups pass | Capsule sweep/slide, walls/ceilings/slopes/ledges; all2869 lab triangles retained; masks/dimensions provisional |
| Simulation cadence | 13 movement groups pass | Fixed60Hz independent of60/120/144Hz rendering, ten-minute finite run; original cadence unresolved |
| Walking camera and animation | Linux headless/window pass | Original five motion clips, recovered eye180/target99; pivot, timing and obstruction solver provisional |
| Walk SDL input/resize | GTX1070/Xvfb240-step pass | Arrows/Shift injected through SDL; travel1250.12,jump/landing; resize800x600; zero validation errors |
| Intro/task/entity/gameplay loop | Incomplete | GAM data recovery is not task execution or gameplay |
| Menus/AI/combat/progression/saves | Incomplete | Required future work |
| Original execution | Attempted under isolated Wine11 | Window created, GL/Vulkan rendering unusable; no reference comparison |
| Native Windows functionality | Partially user-reported | Initial window/3D frame displayed; corrected build/input/audio/resize still unverified natively |
| Native Windows functionality | Loading/rendering user-confirmed | This movement checkpoint/input/audio/resize still unverified natively |
Generated evidence: artifacts/final-tests.log, test-level1b.ppm, test-player.ppm,
resize-input.ppm, package-linux.ppm, extracted/audit.json and reference*/ logs.
@@ -38,5 +44,7 @@ visual equivalence. Windows cross-publishing must not be represented as Windows
runtime validation. Package scope and prerequisites are in infrastructure.md.
Known visual/behavior limits include incomplete lighting/fog/blend/culling/material
mapping, inferred initial look-at, preview animation loop/speed, no reconstructed
intro/controller/collision/trigger execution and no original comparison captures.
mapping, inferred model/root pivot, provisional collision/cadence/animation timing,
close-wall camera clipping near Jimmy, absent intro/trigger/interaction execution,
and no original comparison captures. Walk evidence: artifacts/walk-tests.log,
test-walk.ppm, walk-start.png and walk-window.ppm. Original fidelity is unverified.
+9
View File
@@ -24,3 +24,12 @@
model-only floor correction derived from standing soles and visible geometry,
with explicit preview labeling and regression tests. Preserve GAM/ASE data and
per-frame morph displacement; this is not the original collision algorithm.
9. **Controllable lab before complete scene.** Integrate evidence-backed no-gadget
walking/jumping/camera now, with separate stateful simulation and explicit
provisional source-triangle capsule collision. Rendering does not set the number
of movement calls: use60Hz until original cadence is recovered. Preserve source
GAM/ASE positions; keep physical feet, inferred actor-root height and visual
pivot separate. Include invisible geometry rather than inventing visibility
masks. Document the skipped intro, missing interactions, transient jump-state
simplification, animation timing and close-wall camera limitation. Test against
source geometry and build both packages without calling this a faithful full scene.
+15 -8
View File
@@ -22,6 +22,8 @@ downloads are permitted by the specification; no project material is uploaded.
- Original OMT-derived world geometry/materials/textures; original ASE model and
retained-base vertex morph animation samples; original GAM entities/camera.
- Self-contained Linux/Windows publishing with matching native SDL3 libraries.
- Controllable lab with separate60Hz simulation, source-triangle capsule collision,
original no-gadget walking/jump formulas, chase camera and original motion clips.
The renderer completes submissions synchronously. This deliberately simple early
implementation is maintainable but does not target final performance. It currently
@@ -52,20 +54,25 @@ animation state/render sorting are incomplete. See rendering.md for evidence.
Windows drivers remain untested. See reference-testing.md for exact scope.
- Corrected Windows preview also passes a six-frame Wine64 window/input/animation
selection/resize smoke (validation disabled). Native Windows retest is pending.
- Movement checkpoint packages rebuilt: Linux GTX1070 window and Windows Wine64
window each pass240 steps, SDL arrows/Shift, jump/landing and resize800x600.
Movement statistics match (travel1250.12, maxrise137.62, grounded final).
Linux Khronos validation is enabled with zero errors; Wine validation is disabled.
## Scope limits
This is an investigation/runtime foundation, not complete reconstructed gameplay.
Original collisions, task/trigger execution, introductory cutscene, inventory,
combat, enemies, progression, save/load, original mouse/control behavior and
remaining scenes are incomplete. Player rendering at the original startpoint is
an animation inspection preview; default idle samples are identical. Keys1/2/3/4
select original clips. Preview floor correction is separate from original physics;
its transform and interpolation loop/speed are not a recovered state machine.
This is a controllable lab checkpoint, not complete reconstructed gameplay.
Collision solver/masks/dimensions, pivot,60Hz cadence, camera obstruction and
animation state timing remain provisional. Original task/trigger execution,
introductory cutscene, inventory, combat, enemies, progression, save/load, mouse
steering and remaining scenes are incomplete. The default now walks/jumps from
the original start area; `--inspect` retains clip selection with keys1/2/3/4.
Default idle samples remain identical. The floor-derived visual transform is
separate from original physics; details are in the movement/collision reports.
Packages include local copies of asset directories (ASE/png/gam/omt), original
font PNGs/NewGame/readme, lab/Jimmy scene resources, recovered music, .NET runtime,
SDL3, SPIR-V and these limitations. Legacy EXEs/DLLs, old user save slots, tool
caches and analysis databases are not runtime dependencies. Vulkan drivers remain
platform prerequisites. Initial native Windows rendering is user-reported; the
corrected preview and broader native Windows functionality remain unverified.
movement checkpoint and broader native Windows functionality remain unverified.
+49 -14
View File
@@ -1,15 +1,52 @@
# Progress — current checkpoint
**Full reconstruction is incomplete.** The current milestone is an evidence-backed
asset recovery toolchain and a native original-scene/animation investigation
runtime with local Linux/Windows packages. No completed playable-scene claim.
asset recovery toolchain and a controllable original lab with local Linux/Windows
packages. This is a movement checkpoint, not a completely reconstructed scene.
## Controllable lab checkpoint
The user confirmed that the previous Windows build loads and renders and asked
to advance. The default now runs walking/backpedaling/turning, ballistic no-gadget
jumping, source-triangle collision, a chase camera, and original idle/run/backpedal/
jump/fall clips. Arrows move, Shift/Insert/numpad0/right mouse jump, R resets, C
pauses for inspection/resumes, F11 fullscreen, Escape quits. The intro is skipped.
Recovered arithmetic and addresses are in `analysis/movement-checkpoint.md`.
Notable corrections: Left precedence; current-yaw target offsets rather than
accumulating destination yaw; Up halves keyboard turn; turning alone decays speed;
no ordinary midair arrow steering; disabled-gadget long hold can repeat on landing;
normal camera eye `(0,180,-350)` and target `(0,99,0)`. Exact original frame order
is unresolved; the transient disabled-gadget state3 transition is collapsed.
Explicit port approximations: fixed60Hz cadence, capsule radius24 and standing
height209.4361, floor-derived model/root separation, static sweep/slide solver and
all-source-triangle mask, camera sphere obstruction, animation state/loop timing.
Collision retains all2869 lab triangles including325 invisible proxy triangles.
Original solver/masks, actor pivot/scale, stairs/dynamic objects and state activation
remain unresolved. At walls the clipped camera can move close to Jimmy.
Verification: 11 collision and13 movement groups pass, including real lab source
geometry, long/high-speed sweeps, held/re-pressed jumping, ten-minute stability,
deterministic replay and60/120/144Hz presentation yielding the same simulation.
A240-step GPU walk/jump replay travels1250.12 units, jumps once, lands, and ends
grounded; maximum rise137.62. This is port behavior, not original fidelity proof.
The Linux SDL window run receives injected movement/jump keys, resizes800x600,
and reports zero Vulkan validation errors on GTX1070. Headless llvmpipe also
reports zero errors. User-confirmed native Windows loading/rendering applies to
the previous build; native Windows movement validation remains outstanding.
Both self-contained packages were rebuilt. The Linux package passes the same
GTX1070 window replay; the Windows package passes240 windowed frames under isolated
Wine64 with SDL keys/jump/resize and identical movement statistics (validation
disabled there). Wine is preliminary compatibility evidence, not native Windows.
One additional inspector-window regression was not executed because automatic
approval review was unavailable; the full headless inspector regressions passed.
## Latest user-reported preview fix
The user ran the Windows build and observed a static Jimmy partially inside the
lab floor. This verifies initial Windows startup/rendering by user report, with
OS/GPU/version/input/audio details unspecified. Updated native Windows testing
remains pending.
OS/GPU/version/input/audio details unspecified. The user subsequently confirmed that the corrected build loads and renders.
Both issues were reproduced from actual assets: jimstop has two byte-identical
vertex poses, and its minimum local Y=-64.6165 plus GAM Y=26.6619 places the soles
@@ -77,17 +114,15 @@ swapchain image count mismatch. Native Windows/VM access has been requested for
reference/fidelity and native port validation. These failures do not establish
original behavior. Static reverse engineering can continue independently.
Original controller, collision resolution, introductory LABEXP cutscene, entity
activation/task/trigger execution, interactions, combat, AI, progression, menus,
mouse behavior and saves remain incomplete. Gravity/impulse integration fragments
are tested, but the player jump state machine adds extra acceleration and is not
implemented as a complete controller. Animation looping/speed are explicit preview
policies. Rendering material/lighting/fog/blend state mapping also remains incomplete.
Original collision resolution, introductory LABEXP cutscene, entity activation/
task/trigger execution, interactions, combat, AI, progression, menus, mouse aiming
and saves remain incomplete. The no-gadget controller checkpoint requires original
runtime comparison. Animation looping/speed and collider/pivot remain approximations.
Rendering material/lighting/fog/blend state mapping also remains incomplete.
Three subagents contributed independent investigation/infrastructure work and then
hit a usage limit. Primary reviewed/integrated their work, corrected texture and
visibility assumptions, finished scripts/tests/packages, and owns the current files.
Do not assume their final reports imply completed gameplay.
Two investigators contributed movement evidence/tests and collision implementation/
tests for this checkpoint. Primary integrated the runtime, input, animation, packages
and verification. Reports distinguish static recovery from runtime checks.
## Continuation
+12
View File
@@ -67,3 +67,15 @@ frames, preview correction+38.503Y, injected key2 switched to Run cycle, and
tests separately enabled Khronos validation and reported zero errors. The latest
artifacts/windows-smoke contains that updated window test, superseding the earlier
headless capture. Native Windows retesting is still pending.
The controllable lab checkpoint supersedes that capture with
`python3 tools/recon/reference_capture.py --port-walk --seconds 60`.
The rebuilt self-contained Windows package rendered240 windowed frames under
isolated Wine64, received SDL arrow/Shift events, jumped/landed, resized800x600,
and exited0. Travel1250.12, maxrise137.62, one jump, two landing transitions and
final grounded feet `(4524.3555,0.62445164,-280.2899)` match Linux replay statistics.
The extra landing transition is stepping off/recontacting source geometry; it is
not a second jump. Validation was disabled in Wine. Logs/readback now live in
`artifacts/windows-smoke/`, with harness summary `artifacts/walk-wine-test.log`.
This validates preliminary port compatibility only; native Windows movement and
original-game movement/collision/camera comparison remain outstanding.
+7 -1
View File
@@ -11,6 +11,10 @@ evidence, not original source. Runtime behavior has not yet been observed.
- `analysis/assets.md`, `file-formats.md`: recovered OMT/ASE/texture/audio evidence.
- `gam-format.md`: fully accounted GAM wire format and exact round-trip validation.
- `analysis/gameplay.md`: original controls, startpoint/camera, entities and limits.
- `analysis/movement-checkpoint.md`: corrected walking/yaw/airborne/jump-held and
chase-camera evidence; original frame order, pivot and collider remain unresolved.
- `analysis/collision-checkpoint.md`: explicit provisional source-triangle solver,
geometry/mask choices, tests and limitations; not an original algorithm recovery.
## Function map under investigation
@@ -23,7 +27,9 @@ these coefficients timestep-independent. Gravity and jump have since been
resolved: game setup 0x44D414 sets gravity Y=-800; jump branch 0x4383B3 queues
Y=550 impulse, consumed/cleared at 0x479EBB..0x479EF2. Semi-implicit free-motion
fragment implemented in Game/RecoveredMotion.cs and regression tested; collision
and activation gating remain unresolved. See analysis/gameplay.md.
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.
## Unresolved
+21 -11
View File
@@ -18,23 +18,32 @@
- [x] Preliminary Wine64 Windows-package render; exact fixed-time readback matches Linux.
- [x] Isolated copied-original Wine attempts; actual failures documented.
- [x] Correct preview floor overlap, identify still idle, add explicit animation inspection controls/tests.
- [ ] Retest corrected Windows build natively; initial rendering is user-reported.
- [x] User confirmed corrected Windows build loads and renders.
- [x] Controllable lab: recovered walking/backpedal/turn/no-gadget jump formulas,
original animation clips, fixed60Hz simulation, collision and chase camera.
- [x] 11 collision and13 movement test groups; source lab and synthetic edge cases,
render-rate independence, held/re-pressed jumping and ten-minute stability.
- [x] Linux240-step SDL key/jump/resize replay and GPU readback, zero validation errors.
- [x] Rebuilt both packages; packaged Linux window and preliminary Windows Wine64
window240-step walking/key/jump/resize pass, matching movement statistics.
- [ ] Test this movement checkpoint natively on Windows (previous rendering confirmed).
## Next implementation priorities
1. Recover full player physics/collision and controller before calling any preview
playable. Trace `0x479D20` past displacement integration, shared collision call
1. Replace provisional capsule collision/pivot with recovered original behavior.
Trace `0x479D20` past displacement integration, shared collision call
via interface slot0x130 in `0x462520`, and object collision caches. Retain
invisible/null-material geometry; its exact collision masks remain unresolved.
Recover original actor/model pivot, scale and spawn settling: the preview now
uses a floor-derived model offset, which must be replaced with proven behavior.
2. Finish airborne state table at `0x437F90` (jump at `0x4383B3`, extra acceleration
`0x438148`, held predicate `0x42A730`, mode dispatch `0x437A8C`). Gravity is -800,
queued impulse550, but normal jump states add gravity*1.33-gravity; avoid the
incomplete '-800 only' jump model. Map landing, retrigger and jetpack gates.
3. Finish walking friction/input/cadence: `0x438BC0`, `0x437C40`, destination yaw
`0x472660`, yaw interpolation `0x43A430`. Resolve mixed per-call acceleration
with timed integration; rendering refresh rate must not accelerate movement.
Recover stair/step handling, dynamic collider activation, and camera obstruction.
2. Compare reconstructed no-gadget airborne behavior with the original. Walking,
jump state table and zero-fuel held/re-press repeat path are now recovered in
`analysis/movement-checkpoint.md`; transient state3 and takeoff phase remain
approximations. Recover powered gadget states and original animation routing.
3. Recover original frame cadence and phase order; current fixed60Hz preserves
per-call speed increments independent of rendering. Find reverse timer+0x830
writer before implementing its >1.5 turnaround branch. Recover mouse steering.
4. Execute LV1B STARTEXP/LABEXP intro. GAM parsing supplies records; implement task
prerequisites, object activation/visibility, camera triggers and progression
from code/observations. Then build a complete small scene (VR01 if useful).
@@ -46,7 +55,8 @@
## Required validation and expansion
- [ ] Usable original reference captures under local Windows/VM or working Wine.
- [ ] Original walking/jump/collision/camera/input comparisons and first complete scene.
- [ ] Original walking/jump/collision/camera/input comparisons and first complete scene
including intro/triggers/interactions (movement checkpoint implemented).
- [ ] Physical audio output and original SFX/music timing, mixing/panning/positional audio.
- [ ] Fullscreen, minimized-window, mouse/relative capture, display scaling and controller behavior.
- [ ] Pickups, score/health, gadgets/inventory, combat/AI, all levels and transitions.