Implement Baseball aiming, pooled projectiles and VR07 targets

This commit is contained in:
UnixNight committed 2026-11-02 22:54:19 -05:00
1 parent 50fcb87d90
commit d6ca417e9e
50 files changed
+3149 -32

No files matched your search

+5 -1
View File
@@ -46,7 +46,11 @@ changes. Current gadget controls/resources/primary-fire findings belong in
docs/gameplay/. Distinguish static recovery, implementation, port tests and original docs/gameplay/. Distinguish static recovery, implementation, port tests and original
runtime evidence. Main owns integration/runtime; gadget investigators have runtime evidence. Main owns integration/runtime; gadget investigators have
exclusive named files, not shared directories. exclusive named files, not shared directories.
Latest continuation: docs/gameplay/bubble-implementation.md. Bubble's mode2, Latest continuation: docs/gameplay/baseball-implementation.md. Baseball's20-slot
pool, hold/release aiming, original TIME art and boundedVR07 moving targets are
implemented; original dynamic pair discovery/other enemy consumers remain open.
Scooter recovery is saved in docs/gameplay/scooter.md; do not invent wheel supports.
Bubble's mode2,
original sprite and boundedVR01 source body/floor state are implemented and tested; original sprite and boundedVR01 source body/floor state are implemented and tested;
Invisible, ray/jetpack and shared energy state remain integrated. Other gadgets Invisible, ray/jetpack and shared energy state remain integrated. Other gadgets
and broader collision/camera/retained-helper behavior remain separate gates. and broader collision/camera/retained-helper behavior remain separate gates.
+9 -2
View File
@@ -16,11 +16,11 @@ collision and shared camera state remain incomplete.
The user requested this change after milestone35a2a66/0272f7b. Gadget work uses The user requested this change after milestone35a2a66/0272f7b. Gadget work uses
original controls, state and assets; the collision checkpoint remains available original controls, state and assets; the collision checkpoint remains available
to resume after this gameplay work. to resume after this gameplay work.
VR04 and the bounded VR01 Bubble tutorial now use 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 numeric references. Lab/outside retain the capsule until special contacts and
dynamic collision are recovered; see [body implementation](docs/checkpoint/collision-body-implementation.md). dynamic collision are recovered; see [body implementation](docs/checkpoint/collision-body-implementation.md).
**Current milestone: Bubble, Invisible, shrink ray and their gadget screen.** **Current milestone: Baseball, Bubble, Invisible, shrink ray and their gadget screen.**
Tab/Space selects owned gadgets and their practice levels; the default device 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 fires on Enter/Ctrl/left mouse and supports actual VR04 soldier shrink/restore
with original morphs and score effects. Invisible uses the recovered recharge, with original morphs and score effects. Invisible uses the recovered recharge,
@@ -32,6 +32,8 @@ The [Invisible continuation](docs/gameplay/invisible-implementation.md) records
the later implementation and shared energy-warning sounds. the later implementation and shared energy-warning sounds.
The [Bubble continuation](docs/gameplay/bubble-implementation.md) adds its source The [Bubble continuation](docs/gameplay/bubble-implementation.md) adds its source
controller, original sprite, automatic/high bounces and VR01 floor behavior. 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 runtime includes recovered camera/speech triggers, moving props, Carl/Goddard The runtime includes recovered camera/speech triggers, moving props, Carl/Goddard
patrol logic, pickups, objectives, the practice prompt, VR04 powered jumping and patrol logic, pickups, objectives, the practice prompt, VR04 powered jumping and
@@ -80,6 +82,11 @@ F1→Player can also Give/Select Bubble. **Up or primary fire** accelerates, arr
steer, and holding jump makes higher bounces. Tab/Space first unequips it; the 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 original sprite fades afterward. VR01 uses source body/floor rules; lab/outside
collision remains provisional. 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.
**F2** toggles a compact live debug overlay without pausing play. It shows frame **F2** toggles a compact live debug overlay without pausing play. It shows frame
timing, position/velocity, movement, control/force state, tasks, camera/clipping timing, position/velocity, movement, control/force state, tasks, camera/clipping
+10
View File
@@ -5,6 +5,16 @@ SDL3 for platform windowing, input and audio. Linux x64 and Windows x64 are
equally required. Source is `src/GamePort/`; root executable csproj allows equally required. Source is `src/GamePort/`; root executable csproj allows
`dotnet build` and `dotnet run` from GamePort. No runtime network dependencies. `dotnet build` and `dotnet run` from GamePort. No runtime network dependencies.
`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 Bubble adds separate `BubbleMotion` input/apply, `BubbleEffect` owned clock and
`BubbleVisuals` original canvas. LabSimulation keeps body factor, current maximum, `BubbleVisuals` original canvas. LabSimulation keeps body factor, current maximum,
movement mode and captured sprite root distinct. The source static factory also movement mode and captured sprite root distinct. The source static factory also
+13
View File
@@ -3,6 +3,19 @@
Compilation, native runtime, original behavior and full feature completion are Compilation, native runtime, original behavior and full feature completion are
separate evidence categories. **The game is not fully reconstructed/playable yet.** separate evidence categories. **The game is not fully reconstructed/playable yet.**
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. Package status is in progress.md; 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 Bubble (2026-11-02): original mode2 controller, sprite/flags/pulse/fade, controlled
drain, loop/boing ownership, cleanup650 and boundedVR01 source body/floor111 are drain, loop/boing ownership, cleanup650 and boundedVR01 source body/floor111 are
integrated. Six isolated copied-original body references match managed output. integrated. Six isolated copied-original body references match managed output.
+3
View File
@@ -35,6 +35,9 @@ energy/recharge gates; a grant is not instant activation. The header shows
remaining time, recharge and targetability. Full enemy sensing is not implied. remaining time, recharge and targetability. Full enemy sensing is not implied.
Give/Select Bubble uses the implemented mode2 controller, while Unequip starts Give/Select Bubble uses the implemented mode2 controller, while Unequip starts
its original fade. Diagnostics show Bubble phase and source radius/factor. 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 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 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 on gadgets1/7 after the common prefix. Other level-specific tails remain incomplete. These controls expose
+12
View File
@@ -219,3 +219,15 @@
not invented sphere geometry. Keep the render bridge, generic camera/Euler, not invented sphere geometry. Keep the render bridge, generic camera/Euler,
other damage states and retained helper lifetime explicit. Bubble practice other damage states and retained helper lifetime explicit. Bubble practice
precedes live equip; menu gating reads raw mode, not display selection. 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.
+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.
+88
View File
@@ -0,0 +1,88 @@
# 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.
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 are recorded in progress.md when available. 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.
+98
View File
@@ -0,0 +1,98 @@
# 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
closed. 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.
+3 -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.| |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.| |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 scooter.omt contains shape0 `goddard01`, shape1 `wheel`; material0 `goddard128`
resources0 `goddard128` and1 `scooterwheel2`; archive SHA256 links Canv1 `goddard128`, material1 `scooterwheel2` links Canv0 `scooterwheel2`.
This corrects the earlier ambiguous material/canvas association; archive SHA256
`8d4ffdafee5fd819c5220ee4f608c901a5988fe6b8b13316e15618f5eec75e81`. `8d4ffdafee5fd819c5220ee4f608c901a5988fe6b8b13316e15618f5eec75e81`.
inventory.omt is an older-looking icon set with BUBBLE/GODJEEP/SCOOTER/jetpack etc; 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. its names alone do not justify replacing screens.omt menu art or IDs.
+204
View File
@@ -0,0 +1,204 @@
# Scooter: separate vehicle and deferred implementation
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.
+32
View File
@@ -1,5 +1,37 @@
# Progress — 2026-11-02 # Progress — 2026-11-02
## 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. Clean package validation follows. Logs:
artifacts/baseball-implementation/. No new native Windows/original whole-game
runtime claim is made.
## Bubble continuation ## Bubble continuation
User continued gadgets after clean1897dd2/9ea5784. Bubble mode2 motion, body, User continued gadgets after clean1897dd2/9ea5784. Bubble mode2 motion, body,
+13 -2
View File
@@ -80,10 +80,21 @@ the resume backlog, not prerequisites imposed on this user-directed gadget work.
SDL Bubble checks;539 original hashes unchanged. SDL Bubble checks;539 original hashes unchanged.
- [x] Commit clean1ae5f42 Bubble milestone, rebuild Linux/Windows packages, verify - [x] Commit clean1ae5f42 Bubble milestone, rebuild Linux/Windows packages, verify
exact Canv1 pixels in both and standalone Linux gameplay/debug view from /tmp. exact Canv1 pixels in both and standalone Linux gameplay/debug view from /tmp.
- [ ] Rocketship, Scooter, Remote, Baseball and Grappler; full enemy AI and - [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.
- [ ] Clean Baseball Linux/Windows package validation.
- [x] Save Scooter separate actor/mount/vehicle and original asset contracts;
wheel body/support lifecycle remains a gate before faithful live integration.
- [ ] Rocketship, Scooter, Remote and Grappler; full enemy AI and
original/native Windows comparison. Retain collision/camera/retained-helper gates. 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 have returned all file ownership to primary. Complete final regression, native
Linux input and release checks pass; the remaining gadget effects are the next Linux input and release checks pass; the remaining gadget effects are the next
gameplay backlog. Native Windows gadget verification remains open. gameplay backlog. Native Windows gadget verification remains open.
+8
View File
@@ -19,6 +19,8 @@ for rid in linux-x64 win-x64; do
cp -a artifacts/extracted/invisible-meter/. "$out/scenes/invisible-meter/" cp -a artifacts/extracted/invisible-meter/. "$out/scenes/invisible-meter/"
mkdir -p "$out/scenes/bubble" mkdir -p "$out/scenes/bubble"
cp -a artifacts/extracted/bubble/. "$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/effects" mkdir -p "$out/scenes/effects"
cp -a artifacts/extracted/effects/. "$out/scenes/effects/" cp -a artifacts/extracted/effects/. "$out/scenes/effects/"
cp artifacts/extracted/scene-catalog.json "$out/scenes/scene-catalog.json" cp artifacts/extracted/scene-catalog.json "$out/scenes/scene-catalog.json"
@@ -83,6 +85,12 @@ 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 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 unequips it, then the original sprite fades. VR01 uses recovered static body and
floor111 behavior; lab/outside still have provisional collision. 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.
Append --inspect to start directly in the old scene inspector. Append --inspect to start directly in the old scene inspector.
The default runs the recovered lab camera/speech sequence; Escape/Space skips The default runs the recovered lab camera/speech sequence; Escape/Space skips
its actions and restores control. --skip-intro starts with control; --mute disables its actions and restores control. --skip-intro starts with control; --mute disables
+4
View File
@@ -17,6 +17,8 @@ dotnet run --project tests/GamePort.InvisibleTests
dotnet run --project tests/GamePort.BubbleMotionTests dotnet run --project tests/GamePort.BubbleMotionTests
dotnet run --project tests/GamePort.BubbleVisualTests dotnet run --project tests/GamePort.BubbleVisualTests
dotnet run --project tests/GamePort.BubbleTests dotnet run --project tests/GamePort.BubbleTests
dotnet run --project tests/GamePort.BaseballTests
dotnet run --project tests/GamePort.BaseballVisualTests
dotnet run --project tests/GamePort.HeadingTests dotnet run --project tests/GamePort.HeadingTests
dotnet run --project tests/GamePort.BlendTests dotnet run --project tests/GamePort.BlendTests
dotnet run --project tests/GamePort.CameraRayTests dotnet run --project tests/GamePort.CameraRayTests
@@ -59,6 +61,7 @@ dotnet run --no-build -- --headless --scene artifacts/extracted/VR04/scene.json
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/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/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/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 --skip-intro --write-save artifacts/test-checkpoint.tsk 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 --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 dotnet run --no-build -- --headless --story --scene artifacts/extracted/VR01/scene.json --level gam/VR01.gam --smoke-transition --skip-intro
@@ -75,6 +78,7 @@ 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 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 python3 tools/recon/inventory.py ../Original --verify docs/original-manifest.json
if [[ "${NEUTRON_WINDOW_TEST:-0}" == 1 ]]; then if [[ "${NEUTRON_WINDOW_TEST:-0}" == 1 ]]; then
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/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 -- --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 -- --smoke-gadget-menu --width 1920 --height 1080 --screenshot artifacts/test-gadget-menu-window.ppm
@@ -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 };
}
+8 -5
View File
@@ -8,7 +8,7 @@ public sealed record DebugScene(string LevelFile, string Code, string[] Starts);
public enum DebugAction { None, Resume, Camera, SkipCutscene, RefillEnergy, GiveJetpack, ApplySceneTask, LoadScene, Reset, ForceControl, ToggleOverlay, public enum DebugAction { None, Resume, Camera, SkipCutscene, RefillEnergy, GiveJetpack, ApplySceneTask, LoadScene, Reset, ForceControl, ToggleOverlay,
Noclip, NoclipSpeed, StopMotion, ShowObjective, ReturnNoclipEntry, LevelAvailability, InputOrder, ApplyJetpackState, 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 } GiveInvisible, UnequipGadget, GiveBubble, GiveBaseball }
public sealed record DebugMenuView(string[] Lines, int SelectedLine); public sealed record DebugMenuView(string[] Lines, int SelectedLine);
public sealed record DebugStatus(string Level, string Start, Vector3 Root, float Yaw, float Speed, 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, bool Grounded, float Energy, int Score, int SceneTask, string Cutscene, bool Controlled,
@@ -30,6 +30,7 @@ public sealed record DebugSystems
public float InvisibleRecharge { get; init; } public float InvisibleRecharge { get; init; }
public bool Targetable { get; init; } = true; public bool Targetable { get; init; } = true;
public string BubblePhase { get; init; } = "OFF"; public string BubblePhase { get; init; } = "OFF";
public string BaseballState { get; init; } = "OFF";
public float BodyRadius { get; init; } = 60; public float BodyRadius { get; init; } = 60;
public float BodyFactor { get; init; } = 1.265f; public float BodyFactor { get; init; } = 1.265f;
public int Objective { get; init; } public int Objective { get; init; }
@@ -55,7 +56,7 @@ public sealed class DebugMenu
public const int ItemCount = 12; public const int ItemCount = 12;
public const int PageCount = 3; public const int PageCount = 3;
public int Page { get; private set; } public int Page { get; private set; }
public int PageItems => Page switch { 1 => 13, 2 => 9, _ => ItemCount }; public int PageItems => Page switch { 1 => 14, 2 => 9, _ => ItemCount };
private static readonly float[] FlySpeeds = [300, 600, 1200, 2400]; private static readonly float[] FlySpeeds = [300, 600, 1200, 2400];
private int flySpeedIndex = 1, jetpackStateIndex = 1; private int flySpeedIndex = 1, jetpackStateIndex = 1;
private static readonly int[] JetpackStates = [0, 1, 4]; private static readonly int[] JetpackStates = [0, 1, 4];
@@ -118,7 +119,8 @@ public sealed class DebugMenu
3 => DebugAction.ShowObjective, 4 => DebugAction.ReturnNoclipEntry, 3 => DebugAction.ShowObjective, 4 => DebugAction.ReturnNoclipEntry,
5 => DebugAction.LevelAvailability, 6 => DebugAction.InputOrder, 5 => DebugAction.LevelAvailability, 6 => DebugAction.InputOrder,
8 => DebugAction.ApplyJetpackState, 9 => DebugAction.RefillEnergy, 8 => DebugAction.ApplyJetpackState, 9 => DebugAction.RefillEnergy,
10 => DebugAction.GiveInvisible, 11 => DebugAction.UnequipGadget, 12 => DebugAction.GiveBubble, _ => DebugAction.None 10 => DebugAction.GiveInvisible, 11 => DebugAction.UnequipGadget, 12 => DebugAction.GiveBubble,
13 => DebugAction.GiveBaseball, _ => DebugAction.None
}; };
if (Page == 2) return Selected switch if (Page == 2) return Selected switch
{ {
@@ -157,14 +159,15 @@ public sealed class DebugMenu
: $"EFFECT BYTES {system.EffectBytes} AUDIO AVAILABLE {system.AudioAvailable}", : $"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}", $"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)}", ""]; $"BUBBLE {system.BubblePhase} BODY R {F(system.BodyRadius)} FACTOR {system.BodyFactor.ToString("0.000",c)}",
$"BASEBALL {system.BaseballState}", ""];
string[] items = Page == 1 ? [ string[] items = Page == 1 ? [
$"NOCLIP (F3): {system.Noclip} (ENTER TOGGLE)", $"NOCLIP (F3): {system.Noclip} (ENTER TOGGLE)",
$"FLY SPEED: {F(FlySpeed)} LIVE {F(system.NoclipSpeed)} (ENTER APPLIES)", "STOP MOTION / CLEAR QUEUED JUMP", "SHOW CURRENT OBJECTIVE", $"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", "RETURN TO NOCLIP ENTRY POSITION", "APPLY THIS LEVEL'S GADGET AVAILABILITY",
$"INPUT AFTER PLAYER: {system.InputAfterPlayer} (TOGGLE)", $"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 INVISIBLE", "UNEQUIP CURRENT GADGET", "GIVE / SELECT BUBBLE", "GIVE / SELECT BASEBALL"] : [
$"STATIC CAMERA OBSTRUCTION: {(system.CameraObstruction?.ToString() ?? "UNAVAILABLE")}", $"STATIC CAMERA OBSTRUCTION: {(system.CameraObstruction?.ToString() ?? "UNAVAILABLE")}",
$"MUTE MUSIC: {system.MusicMuted}", $"MUTE SPEECH: {system.SpeechMuted}", $"MUTE EFFECTS: {system.EffectsMuted}", $"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"]; "RESTART SELECTED MUSIC", "STOP ALL EFFECTS / LOOPS", "SAVE DEBUG CHECKPOINT", "LOAD DEBUG CHECKPOINT", "SHOW JET PACK PRACTICE PROMPT"];
@@ -25,7 +25,7 @@ public sealed class SceneSpriteVisuals
var textures = new Dictionary<int, PngImage>(combined.Textures); var textures = new Dictionary<int, PngImage>(combined.Textures);
foreach (var actor in director.Actors) 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 database = source.Text("SpriteDatabase") ?? "none";
var identities = actor.Kind == "3ANI" ? Enumerable.Range(1, 9) var identities = actor.Kind == "3ANI" ? Enumerable.Range(1, 9)
.Select(i => source.Integer("Sprite" + i, -1)).TakeWhile(i => i >= 0).ToArray() .Select(i => source.Integer("Sprite" + i, -1)).TakeWhile(i => i >= 0).ToArray()
+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;
}
}
+11 -2
View File
@@ -41,6 +41,7 @@ public sealed class LabSimulation
public string LevelCode { get; set; } = "LV1B"; public string LevelCode { get; set; } = "LV1B";
public InvisibleGadget Invisible { get; } = new(); public InvisibleGadget Invisible { get; } = new();
public BubbleEffect Bubble { get; } = new(); public BubbleEffect Bubble { get; } = new();
public BaseballGadget Baseball { get; } = new();
public PlayerAppearance Appearance { get; } = new(); public PlayerAppearance Appearance { get; } = new();
public Vr01FloorState FloorState { get; } = new(); public Vr01FloorState FloorState { get; } = new();
public Vector3 BubbleRoot { get; private set; } public Vector3 BubbleRoot { get; private set; }
@@ -58,6 +59,7 @@ public sealed class LabSimulation
var previousPose=Pose; var previousPose=Pose;
if (gadgetMode == 0) ReleaseBubble(); if (gadgetMode == 0) ReleaseBubble();
if (gadgetMode == 2) Invisible.Release(); if (gadgetMode == 2) Invisible.Release();
if (gadgetMode == 6) Baseball.Release();
gadgetMode = -1; gadgetMode = -1;
if (value == 0) if (value == 0)
{ {
@@ -70,6 +72,7 @@ public sealed class LabSimulation
return; return;
} }
if (value == 2 && !Invisible.Equip(Energy, IgnoresGadgetEnergy)) return; if (value == 2 && !Invisible.Equip(Energy, IgnoresGadgetEnergy)) return;
if (value == 6) Baseball.Equip();
gadgetMode = value; gadgetMode = value;
} }
} }
@@ -124,7 +127,7 @@ public sealed class LabSimulation
public Func<Vector3, Vector3, float, Vector3>? DynamicRootResolver { get; set; } public Func<Vector3, Vector3, float, Vector3>? DynamicRootResolver { get; set; }
public Vector3 ActorRoot => Position + Vector3.UnitY * rootHeight; public Vector3 ActorRoot => Position + Vector3.UnitY * rootHeight;
public Vector3 CameraEye { get; private set; } public Vector3 CameraEye { get; private set; }
public Vector3 CameraTarget => ActorRoot + new Vector3(0, 99, 0); public Vector3 CameraTarget => ActorRoot + new Vector3(0, 80 + 1.9f * Baseball.CameraPitch, 0);
public Matrix4x4 Model => Matrix4x4.CreateRotationZ(-(TracksBubbleOrientation?Roll:0) * MathF.PI / 180) public Matrix4x4 Model => Matrix4x4.CreateRotationZ(-(TracksBubbleOrientation?Roll:0) * MathF.PI / 180)
* Matrix4x4.CreateRotationX(-(TracksBubbleOrientation?Pitch:0) * MathF.PI / 180) * Matrix4x4.CreateRotationY(-Yaw * MathF.PI / 180) * Matrix4x4.CreateRotationX(-(TracksBubbleOrientation?Pitch:0) * MathF.PI / 180) * Matrix4x4.CreateRotationY(-Yaw * MathF.PI / 180)
* Matrix4x4.CreateTranslation(Position - new Vector3(0, modelMinimumY, 0)); * Matrix4x4.CreateTranslation(Position - new Vector3(0, modelMinimumY, 0));
@@ -141,6 +144,7 @@ public sealed class LabSimulation
this.energy = energy ?? new PlayerEnergy(); this.energy = energy ?? new PlayerEnergy();
Invisible.AlphaRequested += Appearance.SetAlpha; Invisible.AlphaRequested += Appearance.SetAlpha;
Invisible.BlendRequested += Appearance.SetBlend; Invisible.BlendRequested += Appearance.SetBlend;
Baseball.Thrown += () => GadgetSound?.Invoke(10,false);
sourceStart = start; sourceStart = start;
startYaw = yaw; startYaw = yaw;
var bounds = standingPose.Bounds(); var bounds = standingPose.Bounds();
@@ -161,6 +165,8 @@ public sealed class LabSimulation
if (gadgetMode == 0) { GadgetMode=-1; DefaultGadgetRequested?.Invoke(); } if (gadgetMode == 0) { GadgetMode=-1; DefaultGadgetRequested?.Invoke(); }
if (gadgetMode == 2) gadgetMode = -1; if (gadgetMode == 2) gadgetMode = -1;
Invisible.Reset(); Invisible.Reset();
Baseball.Reset();
if (gadgetMode == 6) gadgetMode = -1;
Bubble.Reset(); FloorState.Reset(); Appearance.Reset(); retainedSupportMaterial=null; Bubble.Reset(); FloorState.Reset(); Appearance.Reset(); retainedSupportMaterial=null;
Pitch=Roll=targetPitch=targetRoll=0; BubbleBounces=0; Pitch=Roll=targetPitch=targetRoll=0; BubbleBounces=0;
TracksBubbleOrientation=false; TracksBubbleOrientation=false;
@@ -404,6 +410,7 @@ public sealed class LabSimulation
//438011..43802B adds the independent turn rate directly to yaw. //438011..43802B adds the independent turn rate directly to yaw.
targetYaw = Yaw; targetYaw = Yaw;
} }
Baseball.StepCameraInput(input);
StepCamera(); //438BC0/439900 input path owns follow; still provisional geometry/state. StepCamera(); //438BC0/439900 input path owns follow; still provisional geometry/state.
if (movementMode==2) if (movementMode==2)
{ {
@@ -415,6 +422,8 @@ public sealed class LabSimulation
BubbleRoot=ActorRoot+Vector3.UnitY*50-direction*80; BubbleRoot=ActorRoot+Vector3.UnitY*50-direction*80;
} }
InputActions?.Invoke(input); InputActions?.Invoke(input);
Baseball.StepInput(input,ActorRoot,new(Pitch,Yaw,Roll),Grounded,Energy,IgnoresGadgetEnergy,
StopForPrimaryFire,SetShooting,AdjustEnergy);
} }
private void StepPlayer(PlayerInput input) private void StepPlayer(PlayerInput input)
@@ -541,7 +550,7 @@ public sealed class LabSimulation
private (Vector3 Eye, float Gain) DesiredEye() private (Vector3 Eye, float Gain) DesiredEye()
{ {
var (sin, cos) = Trig(Yaw); var (sin, cos) = Trig(Yaw);
var eye = ActorRoot + new Vector3(sin * 350, 180, -cos * 350); var eye = ActorRoot + new Vector3(sin * 350, Baseball.CameraHeight - 2 * Baseball.CameraPitch, -cos * 350);
if (Noclip) return (eye, 1); // Debug exploration also bypasses camera obstruction. if (Noclip) return (eye, 1); // Debug exploration also bypasses camera obstruction.
if (cameraRay == null) return (collision.ClipCamera(CameraTarget, eye), 1); if (cameraRay == null) return (collision.ClipCamera(CameraTarget, eye), 1);
//43B820: query from the computed look target; first accepted static hit //43B820: query from the computed look target; first accepted static hit
+31 -5
View File
@@ -13,6 +13,8 @@ public readonly record struct OrdinaryBodyStep(OrdinaryBodyState Body, Vector3 P
Vector3 SupportAnchor, SupportHit? SupportHit, BodyLandingObservation? Landing, Vector3 SupportAnchor, SupportHit? SupportHit, BodyLandingObservation? Landing,
CameraRayPolygon? Contact, int CollisionPasses, int TriangleTests); CameraRayPolygon? Contact, int CollisionPasses, int TriangleTests);
public enum BodyResponseProfile { Jimmy, Baseball }
/// <summary> /// <summary>
/// Bounded479D20 composition: enabled integration/support/pairs/static flags, /// Bounded479D20 composition: enabled integration/support/pairs/static flags,
/// prevent-lowering true, ordinary Jimmy370/374/37C and no dynamic body pass. /// prevent-lowering true, ordinary Jimmy370/374/37C and no dynamic body pass.
@@ -26,10 +28,10 @@ public sealed class OriginalBodyPhysics
{ {
private readonly OriginalStaticCollision collision; private readonly OriginalStaticCollision collision;
public OriginalBodyPhysics(OriginalStaticCollision collision) public OriginalBodyPhysics(OriginalStaticCollision collision, bool allowSpecialMaterials = false)
{ {
ArgumentNullException.ThrowIfNull(collision); ArgumentNullException.ThrowIfNull(collision);
if (collision.HasSpecialPlayerContacts) if (collision.HasSpecialPlayerContacts && !allowSpecialMaterials)
throw new NotSupportedException("Ordinary body composition requires recovered special-contact policies for this scene"); throw new NotSupportedException("Ordinary body composition requires recovered special-contact policies for this scene");
this.collision = collision; this.collision = collision;
} }
@@ -38,7 +40,8 @@ public sealed class OriginalBodyPhysics
public OrdinaryBodyStep Step(OrdinaryBodyState body, float seconds, public OrdinaryBodyStep Step(OrdinaryBodyState body, float seconds,
float radius = OriginalBodySupport.JimmyRadius, float factor = OriginalBodySupport.JimmyFactor, float radius = OriginalBodySupport.JimmyRadius, float factor = OriginalBodySupport.JimmyFactor,
float friction = .8f, float suppressionScale = .5f, bool geometryEnabled = true) float friction = .8f, float suppressionScale = .5f, bool geometryEnabled = true,
BodyResponseProfile profile = BodyResponseProfile.Jimmy)
{ {
Finite(body.Position); Finite(body.Velocity); Finite(body.Acceleration); Finite(body.Impulse); Finite(body.Position); Finite(body.Velocity); Finite(body.Acceleration); Finite(body.Impulse);
Finite(body.AngularVelocity); Finite(body.Rotation); Finite(body.AngularVelocity); Finite(body.Rotation);
@@ -77,6 +80,21 @@ public sealed class OriginalBodyPhysics
if (velocity.Y > 0) velocity.Y = 0; if (velocity.Y > 0) velocity.Y = 0;
if (acceleration.Y > 0) acceleration.Y = 0; if (acceleration.Y > 0) acceleration.Y = 0;
} }
else if (profile == BodyResponseProfile.Baseball && move.CallbackPolygon is { } wall)
{
//40FEE0 ->458890 ->472750: reflect horizontal direction, keep Y,
//then damp horizontal components by1-.46. Its angular tail does not
//change position/velocity; sprite/Euler side effects remain separate.
var horizontal = velocity with {Y=0};
var magnitude = OriginalBodySupport.QuickMagnitude(horizontal);
if (magnitude > 0)
{
var direction = horizontal / magnitude;
var reflected = direction - 2 * Vector3.Dot(direction, wall.StoredNormal) * wall.StoredNormal;
velocity = new(reflected.X * magnitude * (1-.46f), velocity.Y,
reflected.Z * magnitude * (1-.46f));
}
}
var position = move.Position; var position = move.Position;
if (horizontalFirst) position.Y += delta.Y; if (horizontalFirst) position.Y += delta.Y;
position.Y = MathF.Max(position.Y, -25000); position.Y = MathF.Max(position.Y, -25000);
@@ -86,13 +104,21 @@ public sealed class OriginalBodyPhysics
BodyLandingObservation? landing = null; BodyLandingObservation? landing = null;
if (geometryEnabled) if (geometryEnabled)
{ {
var support = OriginalBodySupport.Resolve(new(position, previous, velocity, acceleration, radius, factor), var support = OriginalBodySupport.Resolve(new(position, previous, velocity, acceleration, radius, factor,
PreventLowering: profile == BodyResponseProfile.Jimmy),
wasSupported, (start, end, sides) => collision.TraceSupport(start, end, sides)); wasSupported, (start, end, sides) => collision.TraceSupport(start, end, sides));
if (support.Supported) if (support.Supported)
{ {
//37C observes new root/zero acceleration but old velocity/support. //37C observes new root/zero acceleration but old velocity/support.
//Jimmy's inherited37C is a no-op; the observation is diagnostic. //Jimmy's inherited37C is a no-op; the observation is diagnostic.
if (support.Landed) landing = new(support.Body.Position, velocity, support.Body.Acceleration, false); if (support.Landed)
{
landing = new(support.Body.Position, velocity, support.Body.Acceleration, false);
//40FF80 receives old live velocity after root/acceleration
//publication and writes impulse288, before support zeros Y.
if (profile == BodyResponseProfile.Baseball)
body = body with {Impulse = new(velocity.X, velocity.Y * -.65f, velocity.Z)};
}
body = body with { Position = support.Body.Position, Velocity = support.Body.Velocity, body = body with { Position = support.Body.Position, Velocity = support.Body.Velocity,
Acceleration = support.Body.Acceleration, Supported = true }; Acceleration = support.Body.Acceleration, Supported = true };
anchor = support.SupportAnchor; anchor = support.SupportAnchor;
+1 -1
View File
@@ -65,7 +65,7 @@ public sealed class OriginalCameraRay
public static OriginalCameraRay FromRouteScene(Mesh mesh, string levelCode) public static OriginalCameraRay FromRouteScene(Mesh mesh, string levelCode)
{ {
ArgumentNullException.ThrowIfNull(mesh); ArgumentNullException.ThrowIfNull(mesh);
if (levelCode is not ("LV1B" or "VR01" or "VR04" or "LEV1")) if (levelCode is not ("LV1B" or "VR01" or "VR04" or "VR07" or "LEV1"))
throw new NotSupportedException("Static camera game-filter recovery covers the route and VR01"); throw new NotSupportedException("Static camera game-filter recovery covers the route and VR01");
if (mesh.Indices.Length % 3 != 0 || mesh.CollisionPolygons.Length != mesh.Indices.Length / 3) if (mesh.Indices.Length % 3 != 0 || mesh.CollisionPolygons.Length != mesh.Indices.Length / 3)
throw new InvalidDataException("Original camera query requires source polygon metadata"); throw new InvalidDataException("Original camera query requires source polygon metadata");
+1 -1
View File
@@ -61,7 +61,7 @@ public sealed class OriginalStaticCollision
public static OriginalStaticCollision FromRouteScene(Mesh mesh, string level) public static OriginalStaticCollision FromRouteScene(Mesh mesh, string level)
{ {
ArgumentNullException.ThrowIfNull(mesh); ArgumentNullException.ThrowIfNull(mesh);
if (level is not ("LV1B" or "VR01" or "VR04" or "LEV1")) if (level is not ("LV1B" or "VR01" or "VR04" or "VR07" or "LEV1"))
throw new NotSupportedException("Original static game-filter recovery covers the route and VR01"); throw new NotSupportedException("Original static game-filter recovery covers the route and VR01");
if (mesh.Indices.Length % 3 != 0 || mesh.CollisionPolygons.Length != mesh.Indices.Length / 3) if (mesh.Indices.Length % 3 != 0 || mesh.CollisionPolygons.Length != mesh.Indices.Length / 3)
throw new InvalidDataException("Source static collision requires original polygon metadata"); throw new InvalidDataException("Source static collision requires original polygon metadata");
+10 -1
View File
@@ -20,6 +20,7 @@ public sealed class PlayerSceneBinding : IDisposable
director.GadgetReleaseRequested += Release; director.GadgetReleaseRequested += Release;
inventory.GadgetSelected += Selected; inventory.GadgetSelected += Selected;
player.Invisible.EquippedChanged += InvisibleEquipped; player.Invisible.EquippedChanged += InvisibleEquipped;
player.Baseball.EquippedChanged += BaseballEquipped;
player.DefaultGadgetRequested += DefaultGadget; player.DefaultGadgetRequested += DefaultGadget;
Selected(inventory.SelectedGadget); Selected(inventory.SelectedGadget);
} }
@@ -49,7 +50,7 @@ public sealed class PlayerSceneBinding : IDisposable
if (!string.Equals(actor.Tag, tag, StringComparison.OrdinalIgnoreCase)) return; if (!string.Equals(actor.Tag, tag, StringComparison.OrdinalIgnoreCase)) return;
//427FF0 switches raw mode, not display selection. A rejected Invisible //427FF0 switches raw mode, not display selection. A rejected Invisible
//equip can leave display2 with raw mode-1; cleanup does not equip it. //equip can leave display2 with raw mode-1; cleanup does not equip it.
if (player.GadgetMode is 0 or 2 || inventory.SelectedGadget is -1 or 3) if (player.GadgetMode is 0 or 2 or 6 || inventory.SelectedGadget is -1 or 3)
{ inventory.SelectGadget(-1); player.GadgetMode = -1; } { inventory.SelectGadget(-1); player.GadgetMode = -1; }
else if (player.GadgetMode != -1) UnsupportedGadgetCleanups++; else if (player.GadgetMode != -1) UnsupportedGadgetCleanups++;
} }
@@ -70,6 +71,13 @@ public sealed class PlayerSceneBinding : IDisposable
companion.Visible = companion.MovementEnabled = companion.BodyEnabled = !equipped; companion.Visible = companion.MovementEnabled = companion.BodyEnabled = !equipped;
} }
private void BaseballEquipped(bool equipped)
{
//Raw6 cleanup42871D has no Invisible's complete9E8 restoration veto.
if(director.FindActor("C3DGODDARD") is {} companion)
companion.Visible=companion.MovementEnabled=companion.BodyEnabled=!equipped;
}
private void Transform(DirectorActor actor) private void Transform(DirectorActor actor)
{ {
if (string.Equals(actor.Tag, tag, StringComparison.OrdinalIgnoreCase)) if (string.Equals(actor.Tag, tag, StringComparison.OrdinalIgnoreCase))
@@ -83,6 +91,7 @@ public sealed class PlayerSceneBinding : IDisposable
director.GadgetReleaseRequested -= Release; director.GadgetReleaseRequested -= Release;
inventory.GadgetSelected -= Selected; inventory.GadgetSelected -= Selected;
player.Invisible.EquippedChanged -= InvisibleEquipped; player.Invisible.EquippedChanged -= InvisibleEquipped;
player.Baseball.EquippedChanged -= BaseballEquipped;
player.DefaultGadgetRequested -= DefaultGadget; player.DefaultGadgetRequested -= DefaultGadget;
} }
} }
+149
View File
@@ -0,0 +1,149 @@
using System.Numerics;
using GamePort.Assets;
namespace GamePort.Game;
/// <summary>Owned Baseball bodies and source3TAR callbacks. Pair discovery uses
/// a bounded sphere-overlap adapter; original pair scheduling remains unported.</summary>
public sealed class SceneBaseballs
{
private readonly LabSimulation player;
private readonly OriginalBodyPhysics physics;
private readonly SceneDirector director;
private readonly Dictionary<DirectorActor,int> parentHits = [];
public IReadOnlyList<MovingBaseballTarget> Targets { get; }
public int Hits { get; private set; }
public int Recovered { get; private set; }
public event Action<int>? Sound;
public event Action<int>? ScoreAwarded;
public SceneBaseballs(SceneDirector director, LabSimulation player, Mesh world)
{
this.director=director; this.player=player;
physics=new(OriginalStaticCollision.FromRouteScene(world,player.LevelCode),allowSpecialMaterials:true);
Targets=director.Actors.Where(a=>a.Kind=="3TAR").Select(a=>new MovingBaseballTarget(a)).ToArray();
InitializeTrophyContacts();
}
public void StepBodies(float seconds)
{
foreach(var target in Targets) target.StepBody(seconds);
foreach(var ball in player.Baseball.Projectiles)
{
ball.Step(physics,seconds);
if(!ball.Visible) continue;
//This modern discovery adapter supplies real source callback rules.
//It does not claim original47A580 pair ordering or swept contacts.
foreach(var target in Targets)
if(target.Actor.BodyEnabled && Vector3.DistanceSquared(ball.Position,target.Actor.Position)<90*90
&& target.Hit())
{
Hits++; ScoreAwarded?.Invoke(target.Points);
ActivateParent(target);
}
if(Vector3.DistanceSquared(ball.Position,player.ActorRoot)<(15+player.InteractionRadius)*(15+player.InteractionRadius))
{ ball.Hide(); Recovered++; }
}
}
public void StepTargets(float seconds)
{
foreach(var target in Targets) target.StepFrame(seconds);
}
private void ActivateParent(MovingBaseballTarget target)
{
var parent=director.FindActor(target.ActivateObject);
if(parent==null) { Sound?.Invoke(198); return; }
if(parent.Kind is not ("3TRO" or "3PIC")) return;
var count=parentHits.GetValueOrDefault(parent)+1;
if(count>target.HitsRequired)
{
parentHits[parent]=0;
//The source invokes parent428(1), not the trigger interpreter.
parent.Visible=true;
if(parent.SourceGam?.Integer("HasCollision",-1)!=0)parent.BodyEnabled=true;
Sound?.Invoke(199);
}
else parentHits[parent]=count;
}
public void Reset()
{
Hits=Recovered=0; parentHits.Clear();
foreach(var target in Targets) target.Reset();
InitializeTrophyContacts();
}
private void InitializeTrophyContacts()
{
if(player.LevelCode!="VR07")return;
foreach(var trophy in director.Actors.Where(a=>a.Kind=="3TRO"))
trophy.BodyEnabled=trophy.Visible && trophy.SourceGam?.Integer("HasCollision",-1)!=0;
}
}
/// <summary>Factory45CA06's C3DMOVINGTARGET, not Jimmy's C3DTarget helper.</summary>
public sealed class MovingBaseballTarget
{
public DirectorActor Actor { get; }
private readonly Vector3 initial;
private readonly bool initialVisible;
public Vector3 Start { get; }
public Vector3 Destination { get; }
public Vector3 Velocity { get; private set; }
public float Speed { get; }
public float Remaining { get; private set; }
public float RespawnTime { get; }
public int Points { get; }
public int HitsRequired { get; }
public string ActivateObject { get; }
public MovingBaseballTarget(DirectorActor actor)
{
Actor=actor;
if(actor.Kind!="3TAR" || actor.SourceGam is not {} source)
throw new ArgumentException("Moving target needs its actual source entity",nameof(actor));
initial=actor.Position;
initialVisible=actor.Visible;
Start=new(source.Number("StartPosX"),source.Number("StartPosY"),source.Number("StartPosZ"));
Destination=new(source.Number("DestPosX"),source.Number("DestPosY"),source.Number("DestPosZ"));
Speed=source.Number("Speed",100); RespawnTime=source.Number("RespawnTime",15);
Points=source.Integer("NumPoints",10); HitsRequired=source.Integer("HitsRequired",5);
ActivateObject=source.Text("ActivateObject")??"none";
}
public void StepBody(float seconds)
{
if(!Actor.BodyEnabled) return;
//Source target disables world response and support. Preserve the common
//integrate-before-frame partial order. Full registry/global-flag timing
//remains a separate boundary; this is not a new general actor scheduler.
Velocity+=RecoveredMotion.Gravity*seconds;
Actor.Position+=Velocity*seconds;
}
public void StepFrame(float seconds)
{
if(!float.IsFinite(seconds)||seconds<0||seconds>=1)throw new ArgumentOutOfRangeException(nameof(seconds));
if(Remaining>0)
{
Remaining-=seconds;
if(Remaining<=0) { Remaining=0; Actor.Visible=true; }
}
var delta=Destination-Actor.Position;
var distance=delta.Length(); //Source tests ordinary sqrt distance, normalizes with quick magnitude.
var magnitude=OriginalBodySupport.QuickMagnitude(delta);
Velocity=magnitude>0?delta/magnitude*Speed:Vector3.Zero;
if(distance<100) Actor.Position=Start; //430826 teleports to Start, it does not exchange endpoints.
}
public bool Hit()
{
if(Remaining>0) return false;
Actor.Visible=false; Remaining=RespawnTime;
return true;
}
public void Reset() { Actor.Position=initial; Actor.Visible=initialVisible; Velocity=Vector3.Zero; Remaining=0; }
}
+2 -1
View File
@@ -96,7 +96,8 @@ public sealed class SceneInteractions
} }
// Carl InitObject413E2F..45 sets radius100 and support factor0.75. // Carl InitObject413E2F..45 sets radius100 and support factor0.75.
var radius = playerRadius + (source.Kind == "3TRO" ? 20 : source.Kind == "3CAR" ? 100 : source.Number("Radius")); var radius = playerRadius + (source.Kind == "3TRO" ? 20 : source.Kind == "3CAR" ? 100 : source.Number("Radius"));
var overlaps = actor.Active && OriginalBodySupport.QuickMagnitude(activePlayerRoot - actor.Position) < radius; var overlaps = actor.Active && (source.Kind!="3TRO" || actor.BodyEnabled)
&& OriginalBodySupport.QuickMagnitude(activePlayerRoot - actor.Position) < radius;
if (!overlaps) { contacts.Remove(source.Offset); continue; } if (!overlaps) { contacts.Remove(source.Offset); continue; }
if (!contacts.Add(source.Offset)) continue; if (!contacts.Add(source.Offset)) continue;
switch (source.Kind) switch (source.Kind)
+58 -8
View File
@@ -88,6 +88,7 @@ internal static class Program
--smoke-jetpack 300-step powered steering/jump check in VR04 --smoke-jetpack 300-step powered steering/jump check in VR04
--smoke-shrink-ray Fire at an actual VR04 soldier; explicit player-placement fixture --smoke-shrink-ray Fire at an actual VR04 soldier; explicit player-placement fixture
--smoke-invisible Accelerated recharge/activation/flash/expiry/unequip fixture in VR03 --smoke-invisible Accelerated recharge/activation/flash/expiry/unequip fixture in VR03
--smoke-baseball VR07 aim/release/flight/target/respawn fixture
--smoke-bubble VR01 expand/throttle/bounce/cleanup/fade input fixture --smoke-bubble VR01 expand/throttle/bounce/cleanup/fade input fixture
--gadget-menu Render original gadget panel (--skip-intro); fixture owns item3 --gadget-menu Render original gadget panel (--skip-intro); fixture owns item3
--smoke-gadget-menu SDL menu input/pause/selection/practice/Return check (24 frames) --smoke-gadget-menu SDL menu input/pause/selection/practice/Return check (24 frames)
@@ -260,6 +261,7 @@ internal static class Program
var shrinkSmoke = args.Contains("--smoke-shrink-ray"); var shrinkSmoke = args.Contains("--smoke-shrink-ray");
var invisibleSmoke = args.Contains("--smoke-invisible"); var invisibleSmoke = args.Contains("--smoke-invisible");
var bubbleSmoke = args.Contains("--smoke-bubble"); var bubbleSmoke = args.Contains("--smoke-bubble");
var baseballSmoke = args.Contains("--smoke-baseball");
var carlSmoke = args.Contains("--smoke-carl-cutscene"); var carlSmoke = args.Contains("--smoke-carl-cutscene");
var controlPhaseSmoke = args.Contains("--smoke-control-phases"); var controlPhaseSmoke = args.Contains("--smoke-control-phases");
var objectiveWindowSmoke = args.Contains("--smoke-objective-window"); var objectiveWindowSmoke = args.Contains("--smoke-objective-window");
@@ -280,7 +282,7 @@ internal static class Program
var defaultStory = (defaultScene || args.Contains("--walk")) && !args.Contains("--inspect") && !walkSmoke && !args.Contains("--smoke-window") var defaultStory = (defaultScene || args.Contains("--walk")) && !args.Contains("--inspect") && !walkSmoke && !args.Contains("--smoke-window")
&& animationPath == null && !args.Contains("--time"); && animationPath == null && !args.Contains("--time");
var story = defaultStory || loadedSave != null || saveOutput != null || args.Contains("--story") || args.Contains("--story-time") var story = defaultStory || loadedSave != null || saveOutput != null || args.Contains("--story") || args.Contains("--story-time")
|| args.Contains("--skip-intro") || jetpackSmoke || shrinkSmoke || invisibleSmoke || bubbleSmoke || gadgetWindowSmoke || practiceWindowSmoke || practiceReturnSmoke || carlSmoke || controlPhaseSmoke || objectiveSmoke; || args.Contains("--skip-intro") || jetpackSmoke || shrinkSmoke || invisibleSmoke || bubbleSmoke || baseballSmoke || gadgetWindowSmoke || practiceWindowSmoke || practiceReturnSmoke || carlSmoke || controlPhaseSmoke || objectiveSmoke;
if (story && (args.Contains("--inspect") || walkSmoke || args.Contains("--smoke-window"))) if (story && (args.Contains("--inspect") || walkSmoke || args.Contains("--smoke-window")))
throw new ArgumentException("Story playback requires its own simulation mode."); throw new ArgumentException("Story playback requires its own simulation mode.");
if (walkSmoke && args.Contains("--inspect")) throw new ArgumentException("Walk smoke cannot run in inspection mode."); if (walkSmoke && args.Contains("--inspect")) throw new ArgumentException("Walk smoke cannot run in inspection mode.");
@@ -310,6 +312,9 @@ internal static class Program
ShrinkSoldierVisuals? soldierVisuals = null; ShrinkSoldierVisuals? soldierVisuals = null;
JetpackVisuals? jetpackVisuals = null; JetpackVisuals? jetpackVisuals = null;
BubbleVisuals? bubbleVisuals = null; BubbleVisuals? bubbleVisuals = null;
SceneBaseballs? baseballs = null;
BaseballVisuals? baseballVisuals = null;
BaseballAimOverlay? baseballAim = null;
var practice = new PracticePrompt(); var practice = new PracticePrompt();
ObjectivePanel? objectivePanel = null; ObjectivePanel? objectivePanel = null;
var patrols = new Dictionary<string, ActorPatrol>(StringComparer.OrdinalIgnoreCase); var patrols = new Dictionary<string, ActorPatrol>(StringComparer.OrdinalIgnoreCase);
@@ -338,13 +343,13 @@ internal static class Program
var standingPose = AseMesh.Load(AssetPath.Resolve(root, "ASE/jimstop.ase")); var standingPose = AseMesh.Load(AssetPath.Resolve(root, "ASE/jimstop.ase"));
if (walking) if (walking)
{ {
var cameraRay = level!.Code is "LV1B" or "VR01" or "VR04" or "LEV1" var cameraRay = level!.Code is "LV1B" or "VR01" or "VR04" or "VR07" or "LEV1"
? OriginalCameraRay.FromRouteScene(world, level.Code) : null; ? OriginalCameraRay.FromRouteScene(world, level.Code) : null;
debugCameraRay = cameraRay; debugCameraRay = cameraRay;
simulation = new LabSimulation(new SceneCollision(world), standingPose, originalStart.Position, originalStart.Rotation.Y, simulation = new LabSimulation(new SceneCollision(world), standingPose, originalStart.Position, originalStart.Rotation.Y,
cameraRay == null ? null : (look, eye) => cameraRay.Trace(look, eye), cameraRay == null ? null : (look, eye) => cameraRay.Trace(look, eye),
cameraRay == null ? null : (start, end) => cameraRay.TraceGeometry(start, end), cameraRay == null ? null : (start, end) => cameraRay.TraceGeometry(start, end),
level.Code is "VR01" or "VR04" ? OriginalStaticCollision.FromRouteScene(world,level.Code) : null, energy) level.Code is "VR01" or "VR04" or "VR07" ? OriginalStaticCollision.FromRouteScene(world,level.Code) : null, energy)
{ LevelCode = level.Code, InputAfterPlayerUpdate = carriedSave != null }; { LevelCode = level.Code, InputAfterPlayerUpdate = carriedSave != null };
if (carriedPlayer != null) if (carriedPlayer != null)
{ {
@@ -389,6 +394,11 @@ internal static class Program
gadgets = new SceneGadgets(director,interactions.Inventory,simulation,world); gadgets = new SceneGadgets(director,interactions.Inventory,simulation,world);
gadgets.ScoreAwarded += interactions.ChangeScore; gadgets.ScoreAwarded += interactions.ChangeScore;
} }
if(level.Code is "LV1B" or "VR01" or "VR04" or "VR07" or "LEV1")
{
baseballs=new(director,simulation,world);
baseballs.ScoreAwarded+=interactions.ChangeScore;
}
mechanisms = new SceneMechanisms(director); mechanisms = new SceneMechanisms(director);
interactions.Transition += RequestTransition; interactions.Transition += RequestTransition;
interactions.PracticeRequested += practice.Show; interactions.PracticeRequested += practice.Show;
@@ -445,6 +455,8 @@ internal static class Program
mesh = jetpackVisuals.Mesh; mesh = jetpackVisuals.Mesh;
bubbleVisuals = new(mesh,Path.GetFullPath(Path.Combine(Path.GetDirectoryName(scene!)!,".."))); bubbleVisuals = new(mesh,Path.GetFullPath(Path.Combine(Path.GetDirectoryName(scene!)!,"..")));
mesh = bubbleVisuals.Mesh; mesh = bubbleVisuals.Mesh;
baseballVisuals = new(mesh,Path.GetFullPath(Path.Combine(Path.GetDirectoryName(scene!)!,"..")));
mesh = baseballVisuals.Mesh;
if (gadgets != null) if (gadgets != null)
{ {
rayVisuals = new ShrinkRayVisuals(mesh,Path.GetFullPath(Path.Combine(Path.GetDirectoryName(scene!)!, "..")),root); rayVisuals = new ShrinkRayVisuals(mesh,Path.GetFullPath(Path.Combine(Path.GetDirectoryName(scene!)!, "..")),root);
@@ -454,6 +466,8 @@ internal static class Program
mesh = hud.Mesh; mesh = hud.Mesh;
invisibleMeter = new InvisibleMeterOverlay(mesh,Path.Combine(Path.GetDirectoryName(scene!)!,"../invisible-meter/meter.json")); invisibleMeter = new InvisibleMeterOverlay(mesh,Path.Combine(Path.GetDirectoryName(scene!)!,"../invisible-meter/meter.json"));
mesh = invisibleMeter.Mesh; mesh = invisibleMeter.Mesh;
baseballAim = new(mesh,Path.GetFullPath(Path.Combine(Path.GetDirectoryName(scene!)!,"..")));
mesh = baseballAim.Mesh;
gadgetOverlay = new GadgetMenuOverlay(mesh, Path.Combine(Path.GetDirectoryName(scene!)!, "../gadgets/gadgets.json")); gadgetOverlay = new GadgetMenuOverlay(mesh, Path.Combine(Path.GetDirectoryName(scene!)!, "../gadgets/gadgets.json"));
mesh = gadgetOverlay.Mesh; mesh = gadgetOverlay.Mesh;
Console.WriteLine($"Prepared source model actors: {staticVisuals.ActorCount}."); Console.WriteLine($"Prepared source model actors: {staticVisuals.ActorCount}.");
@@ -486,7 +500,7 @@ internal static class Program
var storyTime = double.Parse(Option(args, "--story-time") ?? "0", System.Globalization.CultureInfo.InvariantCulture); var storyTime = double.Parse(Option(args, "--story-time") ?? "0", System.Globalization.CultureInfo.InvariantCulture);
if (!double.IsFinite(storyTime) || storyTime < 0 || storyTime > 3600 || storyTime > 0 && !headless) if (!double.IsFinite(storyTime) || storyTime < 0 || storyTime > 3600 || storyTime > 0 && !headless)
throw new ArgumentException("Story time must be0..3600 seconds in headless mode."); throw new ArgumentException("Story time must be0..3600 seconds in headless mode.");
var frames = int.Parse(Option(args, "--frames") ?? (walkSmoke ? "240" : jetpackSmoke ? "300" : shrinkSmoke ? "90" : invisibleSmoke || bubbleSmoke ? "8" : gadgetWindowSmoke ? "24" : objectiveWindowSmoke ? "180" : carlSmoke ? "60" : controlPhaseSmoke ? "32" : toolsSmoke ? "20" : debugSmoke ? "16" : diagnosticsSmoke ? "24" : headless ? "1" : "0")); var frames = int.Parse(Option(args, "--frames") ?? (walkSmoke ? "240" : jetpackSmoke ? "300" : shrinkSmoke ? "90" : invisibleSmoke || bubbleSmoke || baseballSmoke ? "8" : gadgetWindowSmoke ? "24" : objectiveWindowSmoke ? "180" : carlSmoke ? "60" : controlPhaseSmoke ? "32" : toolsSmoke ? "20" : debugSmoke ? "16" : diagnosticsSmoke ? "24" : headless ? "1" : "0"));
if (gadgetWindowSmoke && (headless || level?.Code != "LV1B" || loadedSave != null || frames < 24)) if (gadgetWindowSmoke && (headless || level?.Code != "LV1B" || loadedSave != null || frames < 24))
throw new ArgumentException("Gadget menu SDL fixture requires a fresh windowed lab and24 frames"); throw new ArgumentException("Gadget menu SDL fixture requires a fresh windowed lab and24 frames");
if (shrinkSmoke && (level?.Code != "VR04" || gadgets == null || frames < 60)) if (shrinkSmoke && (level?.Code != "VR04" || gadgets == null || frames < 60))
@@ -495,6 +509,8 @@ internal static class Program
throw new ArgumentException("Invisible smoke requires a fresh VR03 and at least8 frames"); throw new ArgumentException("Invisible smoke requires a fresh VR03 and at least8 frames");
if (bubbleSmoke && (level?.Code!="VR01" || frames<8 || loadedSave!=null)) if (bubbleSmoke && (level?.Code!="VR01" || frames<8 || loadedSave!=null))
throw new ArgumentException("Bubble smoke requires a fresh VR01 and at least8 frames"); throw new ArgumentException("Bubble smoke requires a fresh VR01 and at least8 frames");
if(baseballSmoke && (level?.Code!="VR07" || frames<8 || loadedSave!=null))
throw new ArgumentException("Baseball fixture requires a fresh VR07 and at least8 frames");
if (controlPhaseSmoke && (level?.Code != "LV1B" || loadedSave != null || frames < 32 || director == null)) if (controlPhaseSmoke && (level?.Code != "LV1B" || loadedSave != null || frames < 32 || director == null))
throw new ArgumentException("Control-phase fixture needs a fresh lab and at least32 frames"); throw new ArgumentException("Control-phase fixture needs a fresh lab and at least32 frames");
if (toolsSmoke && (headless || frames < 16 || director == null || level?.Code != "LV1B" || loadedSave != null || debugMenu.Open)) if (toolsSmoke && (headless || frames < 16 || director == null || level?.Code != "LV1B" || loadedSave != null || debugMenu.Open))
@@ -529,6 +545,8 @@ internal static class Program
var sawShrinkKey = false; var sawShrinkKey = false;
InvisibleSmoke? invisibleFixture = null; InvisibleSmoke? invisibleFixture = null;
BubbleSmoke? bubbleFixture = null; BubbleSmoke? bubbleFixture = null;
BaseballSmoke? baseballFixture = null;
var sawBaseballKeys=0;
var sawBubbleKeys=0; var sawBubbleKeys=0;
Console.WriteLine($"Scene presentation: revision={renderer.SceneRevision}, windows={presentation.WindowCreationCount}, renderers={presentation.RendererCreationCount}, window ID={(window == 0 ? 0 : Sdl.SDL_GetWindowID(window))}, size={renderer.Width}x{renderer.Height}."); Console.WriteLine($"Scene presentation: revision={renderer.SceneRevision}, windows={presentation.WindowCreationCount}, renderers={presentation.RendererCreationCount}, window ID={(window == 0 ? 0 : Sdl.SDL_GetWindowID(window))}, size={renderer.Width}x{renderer.Height}.");
{ {
@@ -541,6 +559,7 @@ internal static class Program
simulation.GadgetSound += (id,loop) => sceneAudio?.Effect(id,loop?"bubble":null); simulation.GadgetSound += (id,loop) => sceneAudio?.Effect(id,loop?"bubble":null);
simulation.BubbleSoundStopped += () => sceneAudio?.StopLoop("bubble"); simulation.BubbleSoundStopped += () => sceneAudio?.StopLoop("bubble");
} }
if(baseballs!=null)baseballs.Sound+=id=>sceneAudio?.Effect(id);
if (gadgets != null) if (gadgets != null)
{ {
gadgets.Sound += (id,loop) => sceneAudio?.Effect(id,loop ? "shrink-ray" : null); gadgets.Sound += (id,loop) => sceneAudio?.Effect(id,loop ? "shrink-ray" : null);
@@ -568,6 +587,7 @@ internal static class Program
} }
director.Begin(originalStart!, activateStartTrigger: !returning); director.Begin(originalStart!, activateStartTrigger: !returning);
gadgets?.Reset(); gadgets?.Reset();
baseballs?.Reset();
interactions!.Reset(); interactions!.Reset();
mechanisms!.Reset(); mechanisms!.Reset();
director.SyncActor(level!.Player!.Tag!, simulation!.ActorRoot, new Vector3(0, simulation.Yaw, 0)); director.SyncActor(level!.Player!.Tag!, simulation!.ActorRoot, new Vector3(0, simulation.Yaw, 0));
@@ -583,7 +603,7 @@ internal static class Program
Console.WriteLine($"Practice RETURN: exact saved root={restored}, root={simulation.ActorRoot}, STRT yaw={simulation.Yaw}, intro suppressed={!director.Playing}, companion restored={companionRestored}, retained player input order={simulation.InputAfterPlayerUpdate}, gadget availability={interactions.Inventory.State(0, 3)}."); Console.WriteLine($"Practice RETURN: exact saved root={restored}, root={simulation.ActorRoot}, STRT yaw={simulation.Yaw}, intro suppressed={!director.Playing}, companion restored={companionRestored}, retained player input order={simulation.InputAfterPlayerUpdate}, gadget availability={interactions.Inventory.State(0, 3)}.");
if (!restored) throw new InvalidOperationException("RETURN did not restore the live departure root without replaying STRT actions"); if (!restored) throw new InvalidOperationException("RETURN did not restore the live departure root without replaying STRT actions");
} }
if (args.Contains("--skip-intro") || jetpackSmoke || shrinkSmoke || invisibleSmoke || bubbleSmoke || gadgetWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke || controlPhaseSmoke) { sceneAudio?.StopSpeech(); director.Skip(); } if (args.Contains("--skip-intro") || jetpackSmoke || shrinkSmoke || invisibleSmoke || bubbleSmoke || baseballSmoke || gadgetWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke || controlPhaseSmoke) { sceneAudio?.StopSpeech(); director.Skip(); }
if (gadgetWindowSmoke) { interactions!.Inventory.SetState(0,3,1); interactions.Inventory.SelectGadget(3); } if (gadgetWindowSmoke) { interactions!.Inventory.SetState(0,3,1); interactions.Inventory.SelectGadget(3); }
if (controlPhaseSmoke) if (controlPhaseSmoke)
{ {
@@ -664,6 +684,7 @@ internal static class Program
gadgetScreen.Point(new(200,380), level!.Code, storyTasks!.Get("SCENE")); gadgetScreen.Point(new(200,380), level!.Code, storyTasks!.Get("SCENE"));
} }
if (invisibleSmoke) invisibleFixture = new(simulation!,interactions!.Inventory); if (invisibleSmoke) invisibleFixture = new(simulation!,interactions!.Inventory);
if(baseballSmoke)baseballFixture=new(simulation!,playerBinding!,interactions!.Inventory,baseballs!,director);
if (bubbleSmoke) bubbleFixture = new(simulation!,interactions!.Inventory); if (bubbleSmoke) bubbleFixture = new(simulation!,interactions!.Inventory);
if (shrinkSmoke) if (shrinkSmoke)
{ {
@@ -756,7 +777,7 @@ internal static class Program
if (simulation == null) { debugMenu.Message = "RESET REQUIRES PLAY MODE"; return; } if (simulation == null) { debugMenu.Message = "RESET REQUIRES PLAY MODE"; return; }
if (practice.Active) practice.Key(17, Vector2.Zero); if (practice.Active) practice.Key(17, Vector2.Zero);
simulation.Reset(); poseTime = 0; sceneAudio?.StopSpeech(); director?.Begin(originalStart!); simulation.Reset(); poseTime = 0; sceneAudio?.StopSpeech(); director?.Begin(originalStart!);
interactions?.Reset(); mechanisms?.Reset(); gadgets?.Reset(); mouseFire = false; interactions?.Reset(); mechanisms?.Reset(); gadgets?.Reset(); baseballs?.Reset(); mouseFire = false;
director?.SyncActor(level!.Player!.Tag!, simulation.ActorRoot, new Vector3(0, simulation.Yaw, 0)); director?.SyncActor(level!.Player!.Tag!, simulation.ActorRoot, new Vector3(0, simulation.Yaw, 0));
} }
void ToggleCamera() void ToggleCamera()
@@ -843,6 +864,10 @@ internal static class Program
debugMenu.Message = simulation?.GadgetMode==0 ? "BUBBLE EQUIPPED - FIRE/UP ACCELERATES, JUMP BOUNCES HIGH" debugMenu.Message = simulation?.GadgetMode==0 ? "BUBBLE EQUIPPED - FIRE/UP ACCELERATES, JUMP BOUNCES HIGH"
: simulation?.Bubble.Collapsing==true ? "WAIT FOR THE BUBBLE TO FADE BEFORE REEQUIPPING" : "ENERGY REQUIRED TO EQUIP"; : simulation?.Bubble.Collapsing==true ? "WAIT FOR THE BUBBLE TO FADE BEFORE REEQUIPPING" : "ENERGY REQUIRED TO EQUIP";
break; break;
case DebugAction.GiveBaseball when interactions != null:
interactions.Inventory.SetState(0,6,1); interactions.Inventory.SelectGadget(6);
debugMenu.Message="BASEBALL EQUIPPED - HOLD FIRE, UP/DOWN AIM, RELEASE TO THROW";
break;
case DebugAction.CameraObstruction when debugCameraRay != null: case DebugAction.CameraObstruction when debugCameraRay != null:
debugCameraRay.Enabled = !debugCameraRay.Enabled; debugMenu.Message = "STATIC CAMERA QUERY TOGGLED"; break; debugCameraRay.Enabled = !debugCameraRay.Enabled; debugMenu.Message = "STATIC CAMERA QUERY TOGGLED"; break;
case DebugAction.MuteMusic or DebugAction.MuteSpeech or DebugAction.MuteEffects when sceneAudio != null: case DebugAction.MuteMusic or DebugAction.MuteSpeech or DebugAction.MuteEffects when sceneAudio != null:
@@ -908,6 +933,11 @@ internal static class Program
} }
while (running) while (running)
{ {
baseballFixture?.BeforeFrame(count,(key,down)=>
{
var e=new Sdl.Event{Type=down?Sdl.KeyDown:Sdl.KeyUp,Scancode=key,Down=down?(byte)1:(byte)0};
if(!Sdl.SDL_PushEvent(ref e))throw new InvalidOperationException(Sdl.Error);
},headless);
bubbleFixture?.BeforeFrame(count,(key,down)=> bubbleFixture?.BeforeFrame(count,(key,down)=>
{ {
var e=new Sdl.Event{Type=down?Sdl.KeyDown:Sdl.KeyUp,Scancode=key,Down=down?(byte)1:(byte)0}; var e=new Sdl.Event{Type=down?Sdl.KeyDown:Sdl.KeyUp,Scancode=key,Down=down?(byte)1:(byte)0};
@@ -964,6 +994,8 @@ internal static class Program
} }
while (!headless && Sdl.SDL_PollEvent(out var e)) while (!headless && Sdl.SDL_PollEvent(out var e))
{ {
if(baseballSmoke && e.Type==Sdl.KeyDown)
sawBaseballKeys|=e.Scancode switch{224=>1,80=>2,82=>4,43=>8,_=>0};
if (bubbleSmoke && e.Type==Sdl.KeyDown) if (bubbleSmoke && e.Type==Sdl.KeyDown)
sawBubbleKeys |= e.Scancode switch {224=>1,80=>2,225=>4,43=>8,_=>0}; sawBubbleKeys |= e.Scancode switch {224=>1,80=>2,225=>4,43=>8,_=>0};
if (e.Type is Sdl.Quit or 0x210) running = false; if (e.Type is Sdl.Quit or 0x210) running = false;
@@ -1090,12 +1122,13 @@ internal static class Program
} }
} }
if (debugMenu.Open) animationStarted += elapsed; if (debugMenu.Open) animationStarted += elapsed;
if (simulation != null && !debugMenu.Open && !inspecting && !practice.Active && gadgetScreen?.Open != true && (active || headless || walkSmoke || jetpackSmoke || shrinkSmoke || invisibleSmoke || bubbleSmoke || gadgetWindowSmoke || objectiveWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke)) if (simulation != null && !debugMenu.Open && !inspecting && !practice.Active && gadgetScreen?.Open != true && (active || headless || walkSmoke || jetpackSmoke || shrinkSmoke || invisibleSmoke || bubbleSmoke || baseballSmoke || gadgetWindowSmoke || objectiveWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke))
{ {
var steps = headless || walkSmoke || jetpackSmoke || shrinkSmoke || invisibleSmoke || bubbleSmoke || gadgetWindowSmoke || practiceWindowSmoke || carlSmoke || controlPhaseSmoke || objectiveWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke ? 1 : stepClock.Advance(elapsed); var steps = headless || walkSmoke || jetpackSmoke || shrinkSmoke || invisibleSmoke || bubbleSmoke || baseballSmoke || gadgetWindowSmoke || practiceWindowSmoke || carlSmoke || controlPhaseSmoke || objectiveWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke ? 1 : stepClock.Advance(elapsed);
for (var step = 0; step < steps; step++) for (var step = 0; step < steps; step++)
{ {
var input = carlSmoke || controlPhaseSmoke ? new PlayerInput(true, false, true, false, true) var input = carlSmoke || controlPhaseSmoke ? new PlayerInput(true, false, true, false, true)
: baseballSmoke && headless ? BaseballSmoke.Input(count)
: bubbleSmoke && headless ? BubbleSmoke.Input(count) : bubbleSmoke && headless ? BubbleSmoke.Input(count)
: invisibleSmoke && headless ? new PlayerInput(false,false,false,false,false,Fire:count==1) : invisibleSmoke && headless ? new PlayerInput(false,false,false,false,false,Fire:count==1)
: shrinkSmoke && headless ? new PlayerInput(false,false,false,false,false,Fire:true) : shrinkSmoke && headless ? new PlayerInput(false,false,false,false,false,Fire:true)
@@ -1107,12 +1140,14 @@ internal static class Program
keys.Contains(4), keys.Contains(7), keys.Contains(225) || keys.Contains(229), keys.Contains(4), keys.Contains(7), keys.Contains(225) || keys.Contains(229),
mouseFire || keys.Contains(40) || keys.Contains(88) || keys.Contains(224) || keys.Contains(228)); mouseFire || keys.Contains(40) || keys.Contains(88) || keys.Contains(224) || keys.Contains(228));
gadgets?.StepBodies(FixedStepClock.Step); gadgets?.StepBodies(FixedStepClock.Step);
baseballs?.StepBodies(FixedStepClock.Step);
var before = simulation.Position; var before = simulation.Position;
var powered = simulation.JetpackEffectVisible && !simulation.Grounded; var powered = simulation.JetpackEffectVisible && !simulation.Grounded;
bool acceptsInput; bool acceptsInput;
if (playerBinding != null) acceptsInput = playerBinding.Step(input); if (playerBinding != null) acceptsInput = playerBinding.Step(input);
else { simulation.Step(input); acceptsInput = true; } else { simulation.Step(input); acceptsInput = true; }
gadgets?.StepTimers(FixedStepClock.Step); gadgets?.StepTimers(FixedStepClock.Step);
baseballs?.StepTargets(FixedStepClock.Step);
if (jetpackSmoke && powered) if (jetpackSmoke && powered)
{ {
poweredAirTravel += Vector2.Distance(new(before.X, before.Z), new(simulation.Position.X, simulation.Position.Z)); poweredAirTravel += Vector2.Distance(new(before.X, before.Z), new(simulation.Position.X, simulation.Position.Z));
@@ -1179,6 +1214,8 @@ internal static class Program
if (shrinkSmoke && gadgets!.Ray.Visible) shrinkPhaseMask |= 1 << gadgets.Ray.TexturePhase; if (shrinkSmoke && gadgets!.Ray.Visible) shrinkPhaseMask |= 1 << gadgets.Ray.TexturePhase;
jetpackVisuals?.Update(mesh, simulation!); jetpackVisuals?.Update(mesh, simulation!);
bubbleVisuals?.Update(mesh,simulation!.Bubble,simulation.BubbleRoot,renderEye,renderTarget); bubbleVisuals?.Update(mesh,simulation!.Bubble,simulation.BubbleRoot,renderEye,renderTarget);
baseballVisuals?.Update(mesh,simulation!.Baseball.Projectiles,renderEye,renderTarget);
baseballAim?.Update(mesh,simulation!.Baseball,renderer.Width,renderer.Height);
spriteVisuals?.FaceCamera(renderEye, renderTarget, mesh); spriteVisuals?.FaceCamera(renderEye, renderTarget, mesh);
objectivePanel?.Key(keys.Contains(18) && !debugMenu.Open && !inspecting && !practice.Active && gadgetScreen?.Open != true objectivePanel?.Key(keys.Contains(18) && !debugMenu.Open && !inspecting && !practice.Active && gadgetScreen?.Open != true
&& director is { Controlled: true, InventoryEnabled: true }); && director is { Controlled: true, InventoryEnabled: true });
@@ -1211,6 +1248,7 @@ internal static class Program
Targetable = simulation?.Invisible.Targetable ?? true, Targetable = simulation?.Invisible.Targetable ?? true,
BubblePhase = simulation?.Bubble.Active==true ? "ACTIVE" : simulation?.Bubble.Expanding==true ? "EXPAND" BubblePhase = simulation?.Bubble.Active==true ? "ACTIVE" : simulation?.Bubble.Expanding==true ? "EXPAND"
: simulation?.Bubble.Collapsing==true ? "FADE" : "OFF", : simulation?.Bubble.Collapsing==true ? "FADE" : "OFF",
BaseballState=simulation==null?"OFF":$"{(simulation.Baseball.Equipped?"ON":"OFF")} AIM {simulation.Baseball.SavedPitch:F1} PENDING {simulation.Baseball.PendingThrow} THROWS {simulation.Baseball.Throws}",
BodyRadius = simulation?.InteractionRadius ?? 60, BodyFactor=simulation?.BodyFactor ?? 1.265f, BodyRadius = simulation?.InteractionRadius ?? 60, BodyFactor=simulation?.BodyFactor ?? 1.265f,
Objective = interactions?.CurrentObjective ?? 0, ObjectiveTime = objectivePanel?.Elapsed ?? 0, Objective = interactions?.CurrentObjective ?? 0, ObjectiveTime = objectivePanel?.Elapsed ?? 0,
CameraObstruction = debugCameraRay?.Enabled, CameraPolygons = debugCameraRay?.PolygonCount ?? 0, CameraObstruction = debugCameraRay?.Enabled, CameraPolygons = debugCameraRay?.PolygonCount ?? 0,
@@ -1249,6 +1287,12 @@ internal static class Program
} }
renderer.UpdateVertices(mesh.Vertices); renderer.UpdateVertices(mesh.Vertices);
renderer.Render(view * projection); renderer.Render(view * projection);
if(baseballFixture!=null)
{
baseballFixture.AfterFrame(count);
if(BaseballSmoke.StageName(count) is{} stage && Option(args,"--screenshot") is{} capture)
renderer.SavePpm(Path.ChangeExtension(capture,$".{stage}.ppm"));
}
if (bubbleFixture!=null) if (bubbleFixture!=null)
{ {
bubbleFixture.AfterFrame(count); bubbleFixture.AfterFrame(count);
@@ -1529,6 +1573,12 @@ internal static class Program
if (!headless) Console.WriteLine($"Invisible SDL primary received: {sawShrinkKey}."); if (!headless) Console.WriteLine($"Invisible SDL primary received: {sawShrinkKey}.");
if (!invisibleFixture.Passed || !headless && !sawShrinkKey) return 2; if (!invisibleFixture.Passed || !headless && !sawShrinkKey) return 2;
} }
if(baseballFixture!=null)
{
Console.WriteLine(baseballFixture.Report);
if(!headless)Console.WriteLine($"Baseball SDL keys received: {sawBaseballKeys==15}.");
if(!baseballFixture.Passed || !headless && sawBaseballKeys!=15)return 2;
}
if (bubbleFixture!=null) if (bubbleFixture!=null)
{ {
Console.WriteLine(bubbleFixture.Report); Console.WriteLine(bubbleFixture.Report);
@@ -0,0 +1,6 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable><EnableDefaultCompileItems>false</EnableDefaultCompileItems></PropertyGroup>
<ItemGroup><Compile Include="Program.cs"/><Compile Include="../../src/GamePort/Assets/*.cs"/>
<Compile Include="../../src/GamePort/Game/*.cs"/></ItemGroup>
</Project>
+141
View File
@@ -0,0 +1,141 @@
using System.Numerics;
using System.Text;
using System.Buffers.Binary;
using GamePort.Game;
using GamePort.Assets;
var count=0;
void Check(bool value,string message){if(!value)throw new Exception(message);}
void Near(float a,float b,string message)=>Check(MathF.Abs(a-b)<.02f,$"{message}: {a} != {b}");
void Test(string name,Action action){action();count++;Console.WriteLine($"PASS {name}");}
void Hold(BaseballGadget device,bool down=false,bool up=false,float energy=20,bool supported=true)
{
var input=new PlayerInput(down,up,false,false,false,Fire:true);
device.StepCameraInput(input);
device.StepInput(input,Vector3.Zero,Vector3.Zero,supported,energy,false,()=>{},_=>{},_=>{});
}
void Release(BaseballGadget device,Action<float>? cost=null)=>device.StepInput(default,Vector3.Zero,Vector3.Zero,false,0,false,()=>{},_=>{},cost??(_=>{}));
Mesh Floor()=>new([new(new(-4000,0,-4000),Vector2.Zero,Vector3.One),new(new(4000,0,-4000),Vector2.Zero,Vector3.One),
new(new(4000,0,4000),Vector2.Zero,Vector3.One),new(new(-4000,0,4000),Vector2.Zero,Vector3.One)], [0,1,2,0,2,3])
{HasCollisionMaterialIds=true,CollisionPolygons=[new(0,0,Vector3.UnitY,"floor","floor",0),new(0,1,Vector3.UnitY,"floor","floor",0)]};
Test("first hold arms, next captures pitch, label retains prior capture",()=>{
var g=new BaseballGadget();g.Equip();Hold(g,true);
Check(g.PendingThrow&&g.AimVisible&&g.SavedPitch==0,"first hold arms only");
Hold(g,true);Near(g.SavedPitch,10+2f/3,"camera pitch");Check(g.DisplayPitch==0,"first numeric label precedes capture");
var old=g.SavedPitch;Hold(g,true);Check(g.DisplayPitch==old&&g.SavedPitch>old,"stored label order");
for(var i=0;i<200;i++)Hold(g,true);Check(g.SavedPitch==45,"upper clamp");
for(var i=0;i<200;i++)Hold(g,up:true);Check(g.SavedPitch==0,"lower clamp");
});
Test("release launches once with sound before fixed energy debit",()=>{
var g=new BaseballGadget();g.Equip();Hold(g);Hold(g);var order=new List<string>();g.Thrown+=()=>{
Check(g.PendingThrow&&!g.Projectiles[0].Visible,"sound callback precedes launch and pending clear");order.Add("sound");};
Release(g,cost=>{Check(cost==-1,"fixed cost");order.Add("cost");});Release(g);
Check(order.SequenceEqual(new[]{"sound","cost"})&&g.Throws==1&&!g.PendingThrow,"one release transaction");
Check(g.Projectiles[0].Visible&&g.NextSlot==1,"first owned pool slot");
});
Test("pending throw survives cleanup and can release at zero energy",()=>{
var g=new BaseballGadget();g.Equip();Hold(g);Hold(g,true);var saved=g.SavedPitch;g.Release();
Check(g.PendingThrow&&!g.AimVisible&&g.CameraPitch==0&&g.SavedPitch==saved,"source cleanup scalar ownership");
Release(g);Check(g.Throws==1&&g.Projectiles[0].Visible,"release predicate has no fresh energy or raw-mode gate");
});
Test("twenty reused slots, no invented ammo or lifetime",()=>{
var g=new BaseballGadget();g.Equip();
for(var i=0;i<23;i++){Hold(g);Release(g);}
Check(g.Throws==23&&g.NextSlot==3&&g.Projectiles.Count==20&&g.Projectiles.All(b=>b.Visible),"fixed wraparound pool");
g.Release();Check(g.Projectiles.All(b=>b.Visible),"unequip retains helper bodies");
g.Reset();Check(g.Throws==0&&g.Projectiles.All(b=>!b.Visible),"modern new scene clears port-owned pool");
});
Test("upright launch offset, quick-normalized speed and45-degree slope",()=>{
var ball=new BaseballProjectile();ball.Launch(new(100,200,300),Vector3.Zero,45);
Check(ball.Position==new Vector3(100,280,350),"local80/50 offset");Near(ball.Velocity.Y/ball.Velocity.Z,1,"slope45/45");
Near(OriginalBodySupport.QuickMagnitude(ball.Velocity),1800,"published speed");
ball.Launch(Vector3.Zero,new(0,90,0),0);Near(ball.Position.X,-50,"rotated offset");Near(ball.Velocity.X,-1800,"yaw90 velocity");
});
Test("landing queues old horizontal velocity and-.65Y before support clearsY",()=>{
var physics=new OriginalBodyPhysics(OriginalStaticCollision.FromRouteScene(Floor(),"VR07"));
var result=physics.Step(new(new(0,16,0),new(60,-120,0),Vector3.Zero,Vector3.Zero),1f/60,
radius:15,factor:1,friction:.46f,profile:BodyResponseProfile.Baseball);
Check(result.Landing!=null&&result.Body.Supported&&result.Body.Velocity.Y==0,"landing and liveY reset");
Near(result.Body.Impulse.X,60,"queued oldX");Near(result.Body.Impulse.Y,(120+800f/60)*.65f,"queued bounce");
Near(result.Body.Velocity.X,59.54f,"source .46 floor friction follows landing callback");
var next=physics.Step(result.Body,1f/60,radius:15,factor:1,friction:.46f,profile:BodyResponseProfile.Baseball);
Check(next.Body.Impulse==Vector3.Zero,"one consumption");Check(next.Body.Velocity.X>result.Body.Velocity.X,"horizontal impulse is added, not replaced");
});
Test("ball wall callback reflects and damps horizontal velocity while preserving falling Y",()=>{
var wall=new CameraRayPolygon(new(new(-1000,-1000,0),new(-1000,1000,0),new(1000,1000,0)),Vector3.UnitZ);
var physics=new OriginalBodyPhysics(new([wall]));
var result=physics.Step(new(new(0,100,30),new(0,-10,-1800),Vector3.Zero,Vector3.Zero),1f/60,
radius:15,factor:1,friction:.46f,profile:BodyResponseProfile.Baseball);
Check(result.Contact==wall,"source static dispatcher finds the actual wall");
Near(result.Body.Velocity.Z,972,"horizontal reflection and1-.46 damping");
Near(result.Body.Velocity.Y,-10-800f/60,"wall callback keeps liveY");
Check(result.Body.Impulse==Vector3.Zero&&!result.Body.Supported,"wall is not a landing callback");
});
Test("target cooldown runs while hidden and end arrival teleports to Start",()=>{
var actor=new SceneDirector(new("VR07",[Entity("3TAR","target",("StartPosX",-500f),("DestPosX",500f),("RespawnTime",1f))]),new TaskStates([]),(_,_)=>1).Actors[0];
var t=new MovingBaseballTarget(actor);Check(t.Hit()&&!t.Hit()&&!actor.Visible,"one callback per respawn");
t.StepFrame(.5f);Check(!actor.Visible,"still hidden");t.StepFrame(.5f);Check(actor.Visible&&t.Remaining==0,"exact zero expires");
actor.Position=new(450,0,0);t.StepFrame(0);Check(actor.Position==t.Start&&t.Velocity.X>0,"source teleports without swapping endpoints");
});
Test("VR07 keeps six duplicate-tag targets by source instance",()=>{
var level=GamLevel.Load("../Original/gam/VR07.gam");var d=new SceneDirector(level,new TaskStates([]),(_,_)=>1);
var mesh=Mesh.LoadSceneJson("artifacts/extracted/VR07/scene.json");var collision=OriginalStaticCollision.FromRouteScene(mesh,"VR07");
Check(!collision.HasSpecialPlayerContacts&&collision.PolygonCount>0,"ordinary source wall profile");
var p=new LabSimulation(new SceneCollision(mesh),AseMesh.Load("../Original/ASE/jimstop.ase"),level.Entities.First(e=>e.Kind=="STRT").Position,0){LevelCode="VR07"};
var scene=new SceneBaseballs(d,p,mesh);Check(scene.Targets.Count==6,"all source records");
Check(scene.Targets.Select(t=>t.Actor.SourceGam!.Offset).Distinct().Count()==6,"instances are never resolved by duplicate tag");
var first=scene.Targets[0];var second=scene.Targets[1];first.Hit();Check(!first.Actor.Visible&&second.Actor.Visible,"per-instance state");
});
Test("named-Jimmy cutscene restores companion while retaining pending throw",()=>{
var mesh=Floor();var p=new LabSimulation(new SceneCollision(mesh),AseMesh.Load("../Original/ASE/jimstop.ase"),new(0,80,0),0){LevelCode="LV1B"};
var d=new SceneDirector(new("LV1B",[Entity("3JIM","JIM1"),Entity("3DOG","C3DGODDARD"),Entity("3MCA","cleanup",("CameraTarget0","none"))]),new TaskStates([]),(_,_)=>1);
var bag=new SceneInventory(new int[19]);bag.SetState(0,6,1);using var binding=new PlayerSceneBinding(d,p,bag,"JIM1");
bag.SelectGadget(6);binding.Step(new(false,false,false,false,false,Fire:true));
Check(!d.FindActor("C3DGODDARD")!.Visible&&p.Baseball.PendingThrow,"equip hides companion and arms");
d.Trigger("cleanup");Check(p.GadgetMode==-1&&p.Baseball.PendingThrow&&d.FindActor("C3DGODDARD")!.Visible,"named cleanup preserves source latch");
});
Test("Baseball cleanup restores companion even in Invisible's blocked levels",()=>{
foreach(var code in new[]{"LEV6","LEV7","LV1C","LV1D","LV4A","LV6A"})
{
var p=new LabSimulation(new SceneCollision(Floor()),AseMesh.Load("../Original/ASE/jimstop.ase"),new(0,80,0),0){LevelCode=code};
var d=new SceneDirector(new(code,[Entity("3JIM","JIM1"),Entity("3DOG","C3DGODDARD")]),new TaskStates([]),(_,_)=>1);
var bag=new SceneInventory(new int[19]);bag.SetState(0,6,1);using var binding=new PlayerSceneBinding(d,p,bag,"JIM1");
bag.SelectGadget(6);bag.SelectGadget(-1);var companion=d.FindActor("C3DGODDARD")!;
Check(companion.Visible&&companion.BodyEnabled&&companion.MovementEnabled,"raw6 unconditional restoration "+code);
}
});
Test("actual contact activates trophy only after strict fourth hit and honors HasCollision",()=>{
foreach(var hasCollision in new[]{0,-1})
{
var mesh=Floor();var p=new LabSimulation(new SceneCollision(mesh),AseMesh.Load("../Original/ASE/jimstop.ase"),new(1000,80,0),0){LevelCode="VR07"};
var d=new SceneDirector(new("VR07",[Entity("3TAR","target",("PositionY",100f),("PositionZ",100f),
("StartPosY",100f),("StartPosZ",100f),("DestPosX",1000f),("RespawnTime",.25f),("ActivateObject","trophy"),("HitsRequired",3)),
Entity("3TRO","trophy",("InitiallyVisible",0),("HasCollision",hasCollision))]),new TaskStates([]),(_,_)=>1);
var scene=new SceneBaseballs(d,p,mesh);var trophy=d.FindActor("trophy")!;
Check(!trophy.Visible&&!trophy.BodyEnabled,"initial hidden trophy contact disabled");
var score=0;var sounds=new List<int>();scene.ScoreAwarded+=x=>score+=x;scene.Sound+=sounds.Add;
for(var i=0;i<4;i++)
{
p.Baseball.Projectiles[i].Launch(new(0,20,0),Vector3.Zero,0);
scene.StepBodies(1f/60);
foreach(var ball in p.Baseball.Projectiles)ball.Hide();
if(i<3)Check(!trophy.Visible,"strict threshold must not activate at "+(i+1));
scene.StepTargets(.5f);
}
Check(scene.Hits==4&&score==40&&trophy.Visible&&trophy.BodyEnabled==(hasCollision!=0),"source contact and conditional enable");
Check(sounds.SequenceEqual(new[]{199})&&!d.Blocked,"parent428 does not invoke trigger interpreter");
}
});
Console.WriteLine($"Baseball:{count} groups passed; pair scheduling/full enemy combat remain separate.");
GamEntity Entity(string kind,string tag,params(string Name,object Value)[] values)
{
var props=new Dictionary<string,GamProperty>(StringComparer.Ordinal);
foreach(var(name,value) in new[]{("ObjectTag",(object)tag)}.Concat(values))
{
if(value is string text)props[name]=new(name,1,Encoding.Latin1.GetBytes(text));
else{var raw=new byte[4];if(value is float f)BinaryPrimitives.WriteInt32BigEndian(raw,BitConverter.SingleToInt32Bits(f));
else BinaryPrimitives.WriteInt32BigEndian(raw,(int)value);props[name]=new(name,value is float?3u:6u,raw);}
}
return new(kind,props.Count,props,[]);
}
@@ -0,0 +1,11 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable><EnableDefaultCompileItems>false</EnableDefaultCompileItems></PropertyGroup>
<ItemGroup><Compile Include="Program.cs" />
<Compile Include="../../src/GamePort/Assets/*.cs" />
<Compile Include="../../src/GamePort/Game/*.cs" />
<Compile Include="../../src/GamePort/Application/UiViewport.cs" />
<Compile Include="../../src/GamePort/Application/BaseballVisuals.cs" />
<Compile Include="../../src/GamePort/Application/BaseballAimOverlay.cs" />
</ItemGroup>
</Project>
@@ -0,0 +1,153 @@
using System.Numerics;
using System.Security.Cryptography;
using System.Text.Json.Nodes;
using GamePort.Application;
using GamePort.Assets;
using GamePort.Game;
var prepared=args.Length==0?"artifacts/extracted":args[0];
var count=0;
void Check(bool condition,string message){if(!condition)throw new Exception(message);}
void Near(float actual,float expected,string message)=>Check(MathF.Abs(actual-expected)<.001f,$"{message}: {actual} != {expected}");
void Test(string name,Action action){action();count++;Console.WriteLine($"PASS {name}");}
void Invalid(Action action)
{
try{action();}catch(Exception e)when(e is ArgumentException or InvalidDataException){return;}
throw new Exception("Invalid visual input accepted");
}
BaseballGadget Aim(float pitch,bool visible=true)
{
var device=new BaseballGadget();
//Visual contract fixtures set published state directly, independently of
//input/timing tests owned by BaseballGadget's separate test project.
typeof(BaseballGadget).GetProperty("DisplayPitch")!.SetValue(device,pitch);
typeof(BaseballGadget).GetProperty("AimVisible")!.SetValue(device,visible);
return device;
}
Vector2 Pixels(MeshVertex vertex,uint width,uint height)=>new((vertex.Position.X+1)*width/2,(vertex.Position.Y+1)*height/2);
Test("twenty exact source balls append hidden alpha quads and preserve scene metadata",()=>
{
var source=new Mesh([new(new(1,2,3),Vector2.Zero,Vector3.One)],[0,0,0])
{
CollisionPolygons=[new(1,2,Vector3.UnitY,"floor")],HasCollisionMaterialIds=true,
Textures=new(){[int.MinValue+17000]=PngImage.White}
};
var visual=new BaseballVisuals(source,prepared);
Check(visual.Mesh.Vertices.Length==81&&visual.Mesh.Indices.Length==123,"append20 quads");
Check(visual.Mesh.Draws.Length==21&&!visual.Mesh.Draws[0].ScreenSpace,"preserve implicit scene draw");
Check(visual.Mesh.Vertices[0].Position==new Vector3(1,2,3),"original vertex retained");
Check(ReferenceEquals(visual.Mesh.CollisionPolygons,source.CollisionPolygons)&&visual.Mesh.HasCollisionMaterialIds,"collision metadata retained");
Check(visual.Mesh.Draws.Skip(1).All(d=>!d.Visible&&!d.ScreenSpace&&d.Blend==MeshBlend.Alpha),"hidden alpha world sprites");
var image=visual.Mesh.Textures[visual.Mesh.Draws[^1].TextureId];
Check(image.Width==32&&image.Height==32,"source32x32 canvas");
Check(Convert.ToHexStringLower(SHA256.HashData(image.Rgba))=="68904b758e69139de0b01329b2a9844ecd2a466f31598c24324affaccfa2cab9","exact ball0000 pixels");
Check(visual.Mesh.Draws[^1].TextureId!=int.MinValue+17000,"texture collision avoided");
});
Test("source25-unit ball corners face camera with finite degenerate bases and full UVs",()=>
{
var visual=new BaseballVisuals(new([],[]),prepared);
var ball=new BaseballProjectile();ball.Launch(new(5,10,15),Vector3.Zero,0);
foreach(var target in new[]{Vector3.Zero,Vector3.UnitY,-Vector3.UnitY,new Vector3(2,3,4)})
{
visual.Update(visual.Mesh,[ball],Vector3.Zero,target);
var v=visual.Mesh.Vertices.Take(4).ToArray();
Check(v.All(c=>float.IsFinite(c.Position.X+c.Position.Y+c.Position.Z)),"finite basis");
Near(Vector3.Distance(v[0].Position,v[1].Position),25,"source width");
Near(Vector3.Distance(v[1].Position,v[2].Position),25,"source height");
Check(Vector3.Distance(v.Aggregate(Vector3.Zero,(a,b)=>a+b.Position)/4,ball.Position)<.0001f,"source published position is center");
Check(v.Select(c=>c.Uv).SequenceEqual(new Vector2[]{new(0,1),new(1,1),new(1,0),new(0,0)}),"full source UV");
Check(visual.Mesh.Draws.Count(d=>d.Visible)==1,"unused19 slots remain hidden");
}
ball.Hide();visual.Update(visual.Mesh,[ball],Vector3.Zero,Vector3.UnitZ);
Check(visual.Mesh.Draws.All(d=>!d.Visible),"hide removes stale draw");
Invalid(()=>visual.Update(new([],[]),[ball],Vector3.Zero,Vector3.UnitZ));
Invalid(()=>visual.Update(visual.Mesh,[ball],new(float.NaN),Vector3.UnitZ));
Invalid(()=>visual.Update(visual.Mesh,Enumerable.Range(0,21).Select(_=>ball).ToArray(),Vector3.Zero,Vector3.UnitZ));
});
Test("aim uses stationary original strip, prior-capture pitch and source integer truncation",()=>
{
var overlay=new BaseballAimOverlay(new([],[]),prepared);
foreach(var pitch in new[]{0f,9.9f,17.5f,44.99f,45f})
{
overlay.Update(overlay.Mesh,Aim(pitch),640,480);
Check(overlay.Mesh.Draws.Count(d=>d.Visible)==3,"one strip and two digits");
var visible=overlay.Mesh.Draws.Where(d=>d.Visible).ToArray();
var strip=visible.Single(d=>overlay.Mesh.Textures[d.TextureId].Height==210);
var start=overlay.Mesh.Indices[strip.FirstIndex];
Near(Pixels(overlay.Mesh.Vertices[start],640,480).X,315,"strip x stationary");
Near(Pixels(overlay.Mesh.Vertices[start],640,480).Y,100,"strip y stationary");
var digits=visible.Where(d=>d!=strip).OrderBy(d=>Pixels(overlay.Mesh.Vertices[overlay.Mesh.Indices[d.FirstIndex]],640,480).X).ToArray();
for(var place=0;place<2;place++)
{
var point=Pixels(overlay.Mesh.Vertices[overlay.Mesh.Indices[digits[place].FirstIndex]],640,480);
Near(point.X,286+place*16,"null TIME space has zero advance");
Near(point.Y,(int)((45-(double)pitch)*4.3+100),"label integer y");
var digit=place==0?(int)pitch/10:(int)pitch%10;
Check(overlay.Mesh.Textures[digits[place].TextureId].Rgba.SequenceEqual(
File.ReadAllBytes(Path.Combine(prepared,$"baseball/aim_{new[]{118,127,120,121,122,123,124,125,126,119}[digit]}.rgba"))),"exact selected source digit pixels");
}
Check(strip.Blend==MeshBlend.Alpha&&strip.ScreenSpace,"screen alpha path");
}
overlay.Update(overlay.Mesh,Aim(0,false),640,480);
Check(overlay.Mesh.Draws.All(d=>!d.Visible),"unequip hides all owned aim draws");
Invalid(()=>overlay.Update(overlay.Mesh,Aim(float.NaN),640,480));
Invalid(()=>overlay.Update(overlay.Mesh,Aim(46),640,480));
Invalid(()=>overlay.Update(overlay.Mesh,Aim(0),0,480));
Invalid(()=>overlay.Update(new([],[]),Aim(0),640,480));
});
Test("widescreen preserves aim pixel proportions and centered640x480 placement",()=>
{
var overlay=new BaseballAimOverlay(new([],[]),prepared);
foreach(var size in new[]{(640u,480u),(1920u,1080u),(3440u,1440u),(480u,800u)})
{
var(w,h)=size;var scale=MathF.Min(w/640f,h/480f);
overlay.Update(overlay.Mesh,Aim(45),w,h);
var strip=overlay.Mesh.Draws.Single(d=>d.Visible&&overlay.Mesh.Textures[d.TextureId].Height==210);
var start=overlay.Mesh.Indices[strip.FirstIndex];
var a=Pixels(overlay.Mesh.Vertices[start],w,h);var b=Pixels(overlay.Mesh.Vertices[start+2],w,h);
Near(a.X,w/2f-5*scale,"centered strip x");
Near(a.Y,(h-480*scale)/2+100*scale,"centered strip y");
Near(b.X-a.X,15*scale,"uniform source width");Near(b.Y-a.Y,210*scale,"uniform source height");
}
});
Test("world plus overlay updates retain each other's vertices and draws",()=>
{
var balls=new BaseballVisuals(new([],[]),prepared);var overlay=new BaseballAimOverlay(balls.Mesh,prepared);
var ball=new BaseballProjectile();ball.Launch(Vector3.Zero,Vector3.Zero,0);
balls.Update(overlay.Mesh,[ball],Vector3.Zero,Vector3.UnitZ);
var position=overlay.Mesh.Vertices[0].Position;
overlay.Update(overlay.Mesh,Aim(12),1920,1080);
Check(overlay.Mesh.Vertices[0].Position==position&&overlay.Mesh.Draws[0].Visible,"overlay retains world state");
Check(overlay.Mesh.Draws.Count(d=>d.Visible)==4,"one world and three overlay draws");
});
Test("altered pixels, dimensions and manifest traversal are rejected",()=>
{
var directory=Path.Combine(Path.GetTempPath(),"neutron-baseball-visual-"+Guid.NewGuid());
var output=Path.Combine(directory,"baseball");Directory.CreateDirectory(output);
try
{
var source=Path.Combine(prepared,"baseball");
foreach(var path in Directory.EnumerateFiles(source,"*.rgba"))File.Copy(path,Path.Combine(output,Path.GetFileName(path)));
var original=File.ReadAllText(Path.Combine(source,"baseball.json"));
var root=JsonNode.Parse(original)!;
void Save()=>File.WriteAllText(Path.Combine(output,"baseball.json"),root.ToJsonString());
root["textures"]![0]!["path"]="../outside.rgba";Save();
File.Copy(Path.Combine(source,"canvas_2.rgba"),Path.Combine(directory,"outside.rgba"));
Invalid(()=>new BaseballVisuals(new([],[]),directory));
root=JsonNode.Parse(original)!;root["aimTextures"]![0]!["width"]=16;Save();
Invalid(()=>new BaseballAimOverlay(new([],[]),directory));
root=JsonNode.Parse(original)!;Save();
File.WriteAllBytes(Path.Combine(output,"canvas_2.rgba"),new byte[4096]);
Invalid(()=>new BaseballVisuals(new([],[]),directory));
File.WriteAllBytes(Path.Combine(output,"aim_253.rgba"),new byte[15*210*4]);
Invalid(()=>new BaseballAimOverlay(new([],[]),directory));
}
finally{Directory.Delete(directory,true);}
});
Console.WriteLine($"Baseball visual checks passed: {count}");
@@ -19,6 +19,7 @@
<Compile Include="../../src/GamePort/Game/PlayerEnergy.cs"/> <Compile Include="../../src/GamePort/Game/PlayerEnergy.cs"/>
<Compile Include="../../src/GamePort/Game/InvisibleGadget.cs"/> <Compile Include="../../src/GamePort/Game/InvisibleGadget.cs"/>
<Compile Include="../../src/GamePort/Game/BubbleEffect.cs"/> <Compile Include="../../src/GamePort/Game/BubbleEffect.cs"/>
<Compile Include="../../src/GamePort/Game/BaseballGadget.cs"/>
<Compile Include="../../src/GamePort/Game/BubbleMotion.cs"/> <Compile Include="../../src/GamePort/Game/BubbleMotion.cs"/>
<Compile Include="../../src/GamePort/Game/PlayerAppearance.cs"/> <Compile Include="../../src/GamePort/Game/PlayerAppearance.cs"/>
<Compile Include="../../src/GamePort/Game/Vr01FloorState.cs"/> <Compile Include="../../src/GamePort/Game/Vr01FloorState.cs"/>
@@ -23,6 +23,7 @@
<Compile Include="../../src/GamePort/Game/PlayerEnergy.cs"/> <Compile Include="../../src/GamePort/Game/PlayerEnergy.cs"/>
<Compile Include="../../src/GamePort/Game/InvisibleGadget.cs"/> <Compile Include="../../src/GamePort/Game/InvisibleGadget.cs"/>
<Compile Include="../../src/GamePort/Game/BubbleEffect.cs"/> <Compile Include="../../src/GamePort/Game/BubbleEffect.cs"/>
<Compile Include="../../src/GamePort/Game/BaseballGadget.cs"/>
<Compile Include="../../src/GamePort/Game/BubbleMotion.cs"/> <Compile Include="../../src/GamePort/Game/BubbleMotion.cs"/>
<Compile Include="../../src/GamePort/Game/PlayerAppearance.cs"/> <Compile Include="../../src/GamePort/Game/PlayerAppearance.cs"/>
<Compile Include="../../src/GamePort/Game/Vr01FloorState.cs"/> <Compile Include="../../src/GamePort/Game/Vr01FloorState.cs"/>
+61
View File
@@ -0,0 +1,61 @@
"""Source guard/projection checks; these do not execute original gameplay."""
from pathlib import Path
import sys
import unittest
ROOT=Path(__file__).resolve().parents[1]
sys.path.insert(0,str(ROOT/'tools/binary'))
from baseball import Aim, aim_hold, aim_label, cleanup, collect, landing_impulse, launch_yaw_only, next_slot, release, f32
class BaseballSourceTests(unittest.TestCase):
def test_identity_ranges_and_virtuals(self):
report=collect(ROOT.parent/'Original')
self.assertEqual(len(report['bodies']),15)
self.assertEqual(len(report['vtables']),13)
self.assertEqual(report['wall_damping'],f32(.46))
self.assertEqual(report['pool_size'],20)
self.assertTrue(all(int(b['va'],16)-int(b['file_offset'],16)==0x400000 for b in report['bodies']))
def test_first_hold_does_not_capture_then_clamps_and_displays_previous(self):
state=aim_hold(Aim(saved_pitch=12),30)
self.assertEqual(state,Aim(True,12))
self.assertEqual(aim_label(state.saved_pitch),(286,241,12))
self.assertEqual(aim_hold(state,80),Aim(True,45))
self.assertEqual(aim_hold(state,-3),Aim(True,0))
for flags in ({'mode':0},{'mode':2},{'supported':False},{'energy':0},{'modal':True},{'busy':True}):
self.assertEqual(aim_hold(state,42,**flags),state)
self.assertEqual(aim_hold(Aim(),20,energy=0,exempt=True),Aim(True,0))
def test_release_survives_cleanup_without_fresh_energy_or_mode_gate(self):
state=Aim(True,30)
self.assertEqual(cleanup(state),state)
self.assertEqual(release(state,primary=True),(state,None))
after,event=release(cleanup(state))
self.assertEqual(after,Aim(False,30))
self.assertEqual(event,dict(pitch=30,sound=10,energy=-1.))
self.assertEqual(release(after),(after,None))
def test_ring_is_capacity_not_ammo_and_null_slot_does_not_advance(self):
self.assertEqual(next_slot(19),0)
self.assertEqual(next_slot(19,exists=False),19)
for index in (-1,20):
with self.assertRaises(ValueError): next_slot(index)
def test_launch_origin_and_aim_slope(self):
root,velocity=launch_yaw_only((1,2,3),0,0)
self.assertEqual(root,(1.,82.,53.))
self.assertEqual(velocity,(-0.,0.,1800.))
root,v=launch_yaw_only((0,0,0),90,45)
self.assertAlmostEqual(root[0],-50)
self.assertAlmostEqual(v[0],-v[1],places=4)
self.assertAlmostEqual(sum(x*x for x in v),1800**2,places=5)
def test_landing_queues_full_vector_before_velocity_y_is_zeroed(self):
impulse=landing_impulse((100,-200,50))
self.assertEqual(impulse,(100.,130.,50.))
# Source support then stores velocity(100,0,50); next body adds impulse.
self.assertEqual(tuple(a+b for a,b in zip((100.,0.,50.),impulse)),(200.,130.,100.))
if __name__=='__main__': unittest.main()
+94
View File
@@ -0,0 +1,94 @@
from pathlib import Path
import hashlib
import json
import sys
import tempfile
import unittest
from unittest.mock import patch
ROOT = Path(__file__).resolve().parents[1]
ORIGINAL = ROOT.parent/'Original'
sys.path.insert(0, str(ROOT/'tools/extractors'))
from baseball_resources import ARCHIVE_SHA256, VR07_SHA256, CANVASES, AIM_CANVASES, AIM_ARCHIVES, export_baseball
from omt import FormatError
from png import read_png
@unittest.skipUnless(ORIGINAL.exists(), 'Original assets are local integration fixtures')
class BaseballResourceTests(unittest.TestCase):
def test_exact_original_pixels_and_provenance(self):
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)/'baseball'
manifest = export_baseball(ORIGINAL, output)
self.assertEqual(manifest, json.loads((output/'baseball.json').read_text()))
self.assertEqual((manifest['schema'], manifest['sourceSha256']), (1, ARCHIVE_SHA256))
self.assertEqual([e['id'] for e in manifest['textures']], [2, 3, 4, 5, 8])
for entry, expected in zip(manifest['textures'], CANVASES):
self.assertEqual((entry['id'], entry['name'], entry['sourceOffset'], entry['sourceBytes'],
entry['width'], entry['height'], entry['rgbaSha256']), expected)
rgba = (output/entry['path']).read_bytes()
self.assertEqual(hashlib.sha256(rgba).hexdigest(), entry['rgbaSha256'])
self.assertEqual(read_png(output/entry['png'])['rgba'], rgba)
def test_aim_strip_and_original_gameplay_glyphs_are_not_substituted(self):
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)/'baseball'
manifest = export_baseball(ORIGINAL, output)
self.assertEqual(manifest['aimArchiveSha256'], AIM_ARCHIVES)
for entry, expected in zip(manifest['aimTextures'], AIM_CANVASES):
self.assertEqual((entry['database'], entry['id'], entry['width'], entry['height'], entry['rgbaSha256']), expected)
rgba = (output/entry['path']).read_bytes()
self.assertEqual(hashlib.sha256(rgba).hexdigest(), entry['rgbaSha256'])
self.assertEqual(read_png(output/entry['png'])['rgba'], rgba)
def test_tutorial_retains_six_duplicate_tags_and_exact_properties(self):
with tempfile.TemporaryDirectory() as directory:
manifest = export_baseball(ORIGINAL, Path(directory)/'baseball')
tutorial = manifest['tutorial']
self.assertEqual(tutorial['sha256'], VR07_SHA256)
targets = [e for e in tutorial['entities'] if e['kind'] == '3TAR']
self.assertEqual([e['offset'] for e in targets], [0x885, 0xAD6, 0xD27, 0xF78, 0x11C9, 0x141C])
for target in targets:
values = {p['name']: p['value'] for p in target['properties']}
self.assertEqual((values['ObjectTag'], values['SpriteDatabase'], values['SpriteIndex']),
('C3DMOVINGTARGET', 'sprites.omt', 135))
self.assertEqual((values['HitsRequired'], values['Speed'], values['NumPoints'], values['RespawnTime']),
(3, 100.0, 10, 15.0))
source = next(p for p in target['properties'] if p['name'] == 'SpriteIndex')
self.assertEqual(source['raw'], '00000087')
self.assertGreater(source['offset'], target['offset'])
def test_source_outputs_and_descendant_symlinks_rejected(self):
for output in (ORIGINAL, ORIGINAL/'omt/baseball-generated', ORIGINAL.parent):
with self.subTest(output=output), self.assertRaises(ValueError):
export_baseball(ORIGINAL, output)
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)/'baseball'
output.mkdir()
target = Path(directory)/'unchanged'
target.write_bytes(b'unchanged')
(output/'canvas_2.rgba').symlink_to(target)
with self.assertRaises(ValueError):
export_baseball(ORIGINAL, output)
self.assertEqual(target.read_bytes(), b'unchanged')
def test_bad_pixels_rejected_before_output(self):
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)/'baseball'
with patch('baseball_resources.read_canvas', return_value=dict(width=32, height=32, rgba=b'\0'*4096)), \
self.assertRaises(FormatError):
export_baseball(ORIGINAL, output)
self.assertFalse(output.exists())
def test_bad_source_identity_rejected_before_decode(self):
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)/'baseball'
with patch('baseball_resources.digest', return_value='0'*64), \
patch('baseball_resources.read_canvas') as decoder, self.assertRaises(FormatError):
export_baseball(ORIGINAL, output)
decoder.assert_not_called()
self.assertFalse(output.exists())
if __name__ == '__main__':
unittest.main()
+33
View File
@@ -0,0 +1,33 @@
import sys
from pathlib import Path
import unittest
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tools/binary'))
import baseball_targets as source
class BaseballTargetTests(unittest.TestCase):
def test_original_guards_and_six_distinct_records(self):
report = source.collect(Path(__file__).resolve().parents[2] / 'Original')
self.assertEqual(len(report['targets']), 6)
self.assertEqual(len({e['offset'] for e in report['targets']}), 6)
self.assertEqual({e['properties']['ObjectTag'] for e in report['targets']}, {'C3DMOVINGTARGET'})
self.assertTrue(all(e['properties']['SpriteIndex'] == 135 for e in report['targets']))
def test_hit_respawn_gate_and_score(self):
self.assertEqual(source.hit_target(0, 10, 15), dict(accepted=True, hidden=True, timer=15, points=10))
self.assertFalse(source.hit_target(.0001, 10, 15)['accepted'])
self.assertTrue(source.hit_target(-1, 10, 15)['accepted'])
def test_expiry_uses_stored_subtraction(self):
self.assertEqual(source.step_respawn(1, 1), (0, True))
self.assertEqual(source.step_respawn(0, .5), (0, False))
self.assertEqual(source.step_respawn(.75, .5), (.25, False))
def test_parent_threshold_is_strict(self):
self.assertEqual(source.parent_hits(2, 3), (3, False))
self.assertEqual(source.parent_hits(3, 3), (0, True))
if __name__ == '__main__':
unittest.main()
+90
View File
@@ -0,0 +1,90 @@
"""Static source guards/projections, not original runtime Scooter tests."""
from pathlib import Path
import sys
import unittest
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT/'tools/binary'))
import scooter as s
class ScooterTests(unittest.TestCase):
def test_identity_and_source_guards(self):
source = ROOT.parent/'Original'
if not source.exists():
self.skipTest('Original source directory unavailable')
result = s.collect(source)
self.assertEqual(17, len(result['bodies']))
self.assertEqual(150, result['radius'])
self.assertEqual(4, result['wheel_construction_count'])
self.assertFalse(result['runtime_implemented'])
def test_spawn_does_not_mount(self):
self.assertEqual('raw4_vehicle_visible_unmounted', s.equip_result())
self.assertEqual('unchanged', s.equip_result(companion_enabled=False))
self.assertEqual('unchanged', s.equip_result(companion_exists=False))
self.assertEqual('practice_VR05', s.equip_result(practice=True))
def test_actual_child_support_required(self):
self.assertFalse(s.drive_eligible(True, (None,)*6)['drive'])
state = s.drive_eligible(True, (True, False, True, False, None, None))
self.assertEqual(dict(front=1, rear=1, total=2, drive=True), state)
self.assertFalse(s.drive_eligible(False, (True,)*6)['drive'])
self.assertFalse(s.drive_eligible(True, (True, False, None, None, None, None))['drive'])
with self.assertRaises(ValueError):
s.drive_eligible(True, (True, True))
def test_steering_keyboard_priority_cap_and_release(self):
state = s.keyboard_input(s.Steering(), .1, left=True, right=True)
self.assertAlmostEqual(20, state.turn, places=5)
state = s.keyboard_input(state, .2, left=True)
self.assertEqual(45, state.turn)
self.assertEqual(0, s.keyboard_input(state, .3).turn)
self.assertEqual(-45, s.keyboard_input(state, .5, right=True).turn)
def test_forward_requires_rear_support_and_uses_dt(self):
self.assertEqual(0, s.keyboard_input(s.Steering(), .1, forward=True).speed)
state = s.keyboard_input(s.Steering(), .1, forward=True, rear_supports=1)
self.assertAlmostEqual(70, state.speed, places=4)
for _ in range(30):
state = s.keyboard_input(state, .1, forward=True, rear_supports=2)
self.assertEqual(s.f32(2250*s.f32(.66)), state.speed)
self.assertEqual(state.speed, s.keyboard_input(state, .1).speed)
def test_reverse_first_call_brakes_then_reverses(self):
state = s.keyboard_input(s.Steering(speed=100), .1, backward=True, rear_supports=2)
self.assertEqual(0, state.speed)
self.assertTrue(state.braking)
state = s.keyboard_input(state, .1, backward=True, rear_supports=2)
self.assertAlmostEqual(-120, state.speed, places=4)
for _ in range(10):
state = s.keyboard_input(state, .1, backward=True, rear_supports=2)
self.assertEqual(s.f32(-s.f32(2250*s.f32(.66))*s.f32(.4)), state.speed)
state = s.keyboard_input(state, .1)
self.assertFalse(state.reverse_latch)
self.assertFalse(state.braking)
def test_jump_edge_and_support_gates(self):
self.assertEqual((False, None), s.jump_pending(mounted=True, grounded=False, held=True, latched=False))
self.assertEqual((True, (0.,700.,0.)), s.jump_pending(mounted=True, grounded=True, held=True, latched=False))
self.assertEqual((True, None), s.jump_pending(mounted=True, grounded=True, held=True, latched=True))
self.assertEqual((False, None), s.jump_pending(mounted=True, grounded=True, held=False, latched=True))
self.assertEqual((True, None), s.jump_pending(mounted=False, grounded=True, held=False, latched=True))
def test_animation_strict_timer_and_signed_speed(self):
self.assertEqual((0., 'SCOOTSTOP'), s.animation_step(0., .31, -100))
self.assertEqual((0., 'SCOOT'), s.animation_step(0., .31, 10))
self.assertIsNone(s.animation_step(0., .29, 100)[1])
# float32(.3) is greater than the source double.3 comparison operand.
self.assertEqual((0., 'SCOOT'), s.animation_step(0., .3, 10))
def test_bounded_projection(self):
for value in [-1, 1, float('nan'), float('inf')]:
with self.assertRaises(ValueError):
s.keyboard_input(s.Steering(), value)
with self.assertRaises(ValueError):
s.keyboard_input(s.Steering(), .1, rear_supports=5)
if __name__ == '__main__':
unittest.main()
+98
View File
@@ -0,0 +1,98 @@
from pathlib import Path
import hashlib
import json
import sys
import tempfile
import unittest
from unittest.mock import patch
ROOT = Path(__file__).resolve().parents[1]
ORIGINAL = ROOT.parent/'Original'
sys.path.insert(0, str(ROOT/'tools/extractors'))
from ase import expand_mesh, read_ase
from entities import resolve_asset
from omt import FormatError
from png import read_png
from scooter_resources import SOURCES, export_scooter
@unittest.skipUnless(ORIGINAL.exists(), 'Original assets are local integration fixtures')
class ScooterResourceTests(unittest.TestCase):
def test_original_shape_material_links_and_pixels(self):
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)/'scooter'
manifest = export_scooter(ORIGINAL, output)
self.assertEqual(manifest, json.loads((output/'scooter.json').read_text()))
self.assertEqual(manifest['sources'], SOURCES)
self.assertEqual([s['triangles'] for s in manifest['shapes']], [176, 56])
for identity, expected_canvas in ((0, 1), (1, 0)):
scene = json.loads((output/f'shape_{identity}/scene.json').read_text())
self.assertEqual(len(scene['materials']), 1)
self.assertEqual(scene['materials'][0]['texture'], dict(type='Canv', id=expected_canvas))
texture = scene['textures'][0]
self.assertEqual(texture['id'], expected_canvas)
image = read_png(output/f'shape_{identity}'/texture['png'])
self.assertEqual(image['rgba'], (output/f'shape_{identity}'/texture['path']).read_bytes())
wheel = json.loads((output/'shape_1/scene.json').read_text())
self.assertIn(-1, [m['material'] for m in wheel['meshes']])
self.assertEqual((output/'jimycarl.rgba').read_bytes(),
read_png(resolve_asset(ORIGINAL, 'png/jimycarl.png'))['rgba'])
def test_jimmy_exact_base_topology_and_morph_positions(self):
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)/'scooter'
export_scooter(ORIGINAL, output)
base = read_ase(resolve_asset(ORIGINAL, 'ASE/jimstop.ASE'))['objects'][0]['samples'][0]
for stem in ('jimscooter', 'jimscooterstop'):
source = read_ase(resolve_asset(ORIGINAL, f'ASE/{stem}.ASE'))
animation = json.loads((output/stem/'animation.json').read_text())
self.assertEqual((animation['framesPerSecond'], animation['ticksPerFrame']), (10, 480))
self.assertEqual([f['time'] for f in animation['frames']], [0, 480])
self.assertEqual(animation['sha256'], source['sha256'])
for index, sample in enumerate(source['objects'][0]['samples']):
expected = expand_mesh(dict(sample, faces=base['faces'], uvs=base['uvs'],
textureFaces=base['textureFaces']))
actual = json.loads((output/stem/animation['frames'][index]['path']).read_text())
self.assertEqual(actual['vertices'], [list(v) for v in expected['vertices']])
self.assertEqual(actual['uvs'], [list(v) for v in expected['uvs']])
def test_unbound_morphs_retain_source_161_ticks_and_no_guessed_uvs(self):
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)/'scooter'
manifest = export_scooter(ORIGINAL, output)
for entry in manifest['unboundMorphs']:
morph = json.loads((output/entry['path']).read_text())
self.assertEqual((morph['framesPerSecond'], morph['ticksPerFrame']), (30, 160))
samples = morph['objects'][0]['samples']
self.assertEqual([s['time'] for s in samples], [0, 161])
self.assertEqual([len(s['vertices']) for s in samples], [195, 195])
self.assertTrue(all(not s['uvs'] and not s['textureFaces'] for s in samples))
self.assertEqual(morph['sha256'], hashlib.sha256(
resolve_asset(ORIGINAL, 'ASE/'+entry['source']).read_bytes()).hexdigest())
def test_original_subtrees_ancestors_and_symlinks_rejected(self):
for output in (ORIGINAL, ORIGINAL/'png/generated-scooter', ORIGINAL.parent):
with self.subTest(output=output), self.assertRaises(ValueError):
export_scooter(ORIGINAL, output)
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)/'scooter'
output.mkdir()
outside = Path(directory)/'unchanged'
outside.write_text('unchanged')
for relative in ('scooter.json', 'shape_0', 'jimscooter', 'jimycarl.rgba'):
(output/relative).symlink_to(outside)
with self.subTest(relative=relative), self.assertRaises(ValueError):
export_scooter(ORIGINAL, output)
self.assertEqual(outside.read_text(), 'unchanged')
(output/relative).unlink()
def test_changed_source_identity_rejected_before_writes(self):
with tempfile.TemporaryDirectory() as directory:
output = Path(directory)/'scooter'
with patch.dict(SOURCES, {'omt/scooter.omt': '0'*64}), self.assertRaises(FormatError):
export_scooter(ORIGINAL, output)
self.assertFalse(output.exists())
if __name__ == '__main__':
unittest.main()
+187
View File
@@ -0,0 +1,187 @@
#!/usr/bin/env python3
"""Identity-guarded Baseball evidence and bounded arithmetic projections.
No original code executes. The yaw-only launch projection uses continuous host
trig; source full-Euler table quantization remains a separate precision boundary.
"""
from __future__ import annotations
import argparse
from dataclasses import dataclass, replace
import hashlib
import json
import math
from pathlib import Path
import struct
from checkpoint_script_state import EXE_SHA256, find_case, read_va
from pe_inspect import PE
BODIES = (
('constructor', 0x40fc50, 0x40fe67, 'f539ae6099b61f9f1f7007cd185f211b3165dc484cf502c80eb4b5dfc1c2ef0b'),
('pool', 0x422609, 0x4226a3, '8324ec8b6bd8d9ce6c65782611781d2a5e990e8f73359fd0403e6795ba1a9771'),
('primary', 0x426566, 0x4268b4, 'be39a4022aaaf35b9e629597bd04a50e957dcdbe8c8e64fd6ca91e7060b66565'),
('equip', 0x4296f8, 0x4297dd, '2c530179e91a377e31e9bc169c25332bf3821cec614e927d3d5bc51871d69d10'),
('cleanup', 0x42871d, 0x4287ac, '7fdcf6718f6a53a5136240894dbd8c9f840968afbf7c5e10f2d2f766da48a3dd'),
('launch', 0x429a30, 0x429c03, 'fb35366b25c4a6b1503a8028aeb354d8bbfc8d32f60a850a2fde109913e34a53'),
('ball_callbacks', 0x40fee0, 0x410020, '0b0a8ca521c8f92583a57586af945860bb21042240b72b8bc57ff13e061ac45c'),
('jimmy_contact', 0x423014, 0x423080, '997533ba4cd830f11af35b19aa926ebc52a5fce2ee394a7da2c0b82410d9b4d3'),
('aim_input', 0x438bc0, 0x438cd0, '329acdc727d4d68fcc7d2cc85dcfe408f6e18700574af891d889673a780ec7d5'),
('support_order', 0x47bb10, 0x47bba7, '7f34edef3fad0a511d8af4ff8add816d9169b8407b05f1093683969ee4a21669'),
('wall_reflection', 0x472750, 0x472970, 'cae4ae6987680cb97264a918efc33e5bdd25f3b419096d201fc948130bc52315'),
('defaults', 0x46fd90, 0x46fe49, 'c04ff2c68b8b2ce5cbee48675a54e73f85dcf3014c9b9efd93a42213c75792ab'),
('aim_art', 0x402084, 0x402107, '4a839c828fe971f0629796f8dfe5523e695a448bd5812768a74f3976071b561e'),
('stop_sound', 0x429a00, 0x429a25, '09501f7e7ec80126459cd211ad9520f65c66d1ca4c6e644781a05137d620c3fd'),
('energy_gate', 0x4269d0, 0x426a69, '0a97a24b016fa6743b518cd6ebadce5966a717b84e4ca0bdfa583bcdc65d16b5'),
)
VTABLES = (
(0x4a3bdc, 0x174, 0x428d50), (0x4a3bdc, 0x178, 0x427ff0),
(0x4a3bdc, 0x180, 0x429a30), (0x4a3bdc, 0x148, 0x429a00),
(0x4a3bdc, 0x170, 0x437740), (0x49141c, 0x370, 0x40ff50),
(0x49141c, 0x374, 0x40fee0), (0x49141c, 0x378, 0x472750),
(0x49141c, 0x37c, 0x40ff80), (0x49141c, 0x3c4, 0x40ff40),
(0x49141c, 0x40c, 0x410000), (0x49141c, 0x288, 0x471cc0),
(0x49141c, 0x2c4, 0x471f40),
)
CONSTANTS = ((0x49195c, 'f', -0.6499999761581421),
(0x49fabc, 'f', 0.02222222276031971),
(0x4a311c, 'f', 1800.), (0x49d5c8, 'f', 45.),
(0x48d404, 'f', 30.), (0x4a3e40, 'd', 4.3),
(0x4a3130, 'd', 100.), (0x495324, 'f', 20.))
def collect(original: Path | str):
pe = PE(find_case(Path(original), 'Neutron.exe'))
digest = hashlib.sha256(pe.data).hexdigest()
if digest != EXE_SHA256:
raise ValueError('Unexpected original EXE identity')
bodies = []
for name, start, end, expected in BODIES:
actual = hashlib.sha256(read_va(pe, start, end-start)).hexdigest()
if actual != expected:
raise ValueError(f'Changed source span {name}')
bodies.append(dict(name=name, va=hex(start), file_offset=hex(pe.offset(start-pe.base)),
length=end-start, sha256=actual))
for table, slot, target in VTABLES:
if struct.unpack('<I', read_va(pe, table+slot, 4))[0] != target:
raise ValueError(f'Changed virtual {table:x}+{slot:x}')
for va, fmt, value in CONSTANTS:
if struct.unpack('<'+fmt, read_va(pe, va, struct.calcsize(fmt)))[0] != value:
raise ValueError(f'Changed constant {va:x}')
# These are dispatcher table entries, not guessed gadget enumeration labels.
if struct.unpack('<I', read_va(pe, 0x4298e8+7*4, 4))[0] != 0x4296f8:
raise ValueError('Changed item6 equip target')
if struct.unpack('<I', read_va(pe, 0x428844+6*4, 4))[0] != 0x42871d:
raise ValueError('Changed raw6 cleanup target')
font_table = read_va(pe, 0x4f4ed8, 768)
if hashlib.sha256(font_table).hexdigest() != '910bef1d7aca6f1aa328ba9f671831bdbbda19b419fb0c693117cb096d542226':
raise ValueError('Changed source gameplay font table')
digits = [struct.unpack_from('<h', font_table, 5*128+(ord(c)-32)*2)[0] for c in '0123456789']
if digits != [118,127,120,121,122,123,124,125,126,119] or struct.unpack_from('<h', font_table, 5*128)[0] != -1:
raise ValueError('Changed TIME digit/null-space binding')
return dict(sha256=digest, bodies=bodies,
vtables=[dict(table=hex(t), slot=hex(s), target=hex(v)) for t,s,v in VTABLES],
constants=[dict(va=hex(a), value=v) for a,_,v in CONSTANTS],
pool_size=20, ball_canvas=2, ball_size=25, radius=15,
factor=1, wall_damping=f32(.46), floor_friction=f32(.46),
authored_property24=f32(3.2),
landing_impulse_scale=f32(-.65), throw_energy=-1, throw_sound=10,
aim_font=dict(table_va='0x4f4ed8', table_file_offset=hex(pe.offset(0x4f4ed8-pe.base)),
set=5, digits=digits, null_space=True, digit_dimensions=[16,16]),
aim_canvas=253, aim_position=[315,100], practice='vr07.gam')
def f32(value):
return struct.unpack('<f', struct.pack('<f', value))[0]
def finite(*values):
if not all(math.isfinite(v) for v in values):
raise ValueError('Finite inputs required')
@dataclass(frozen=True)
class Aim:
pending: bool = False
saved_pitch: float = 0.
def aim_hold(state: Aim, current_pitch: float, *, mode=6, supported=True,
energy=1., exempt=False, busy=False, modal=False):
"""42668F..4268AF after outer input/primary gates; no timing integration.
First hold arms without capturing a new pitch. Existing pending state is
preserved by rejects. Airborne raw6 follows other primary behavior.
"""
finite(current_pitch, energy, state.saved_pitch)
if busy or modal or mode == 0 or (energy <= 0 and not exempt):
return state
if mode != 6 or not supported:
return state
if not state.pending:
return replace(state, pending=True)
return replace(state, saved_pitch=f32(max(0., min(45., current_pitch))))
def release(state: Aim, *, primary=False):
"""426585..4265F9; intentionally no mode/energy test after pending check."""
if primary or not state.pending:
return state, None
return replace(state, pending=False), dict(pitch=state.saved_pitch, sound=10, energy=-1.)
def cleanup(state: Aim):
"""Raw6 cleanup does not write pending1E26 or savedPitch1E28."""
return state
def aim_label(saved_pitch):
"""426754..426792 screen text arguments, computed BEFORE new pitch capture."""
finite(saved_pitch)
return 286, int((45.-saved_pitch)*4.3+100.), int(saved_pitch)
def next_slot(index: int, *, exists=True):
if not 0 <= index < 20:
raise ValueError('Pool index must be0..19')
return (index+1) % 20 if exists else index
def launch_yaw_only(root, yaw, saved_pitch):
"""429A30 upright actor subset, no original trig-table precision claim.
Full source uses local-point384(0,80,50), then local-vector38C(0,
float32(pitch*float32(1/45)),1), quick-normalize, multiply1800.
"""
finite(*root, yaw, saved_pitch)
if len(root) != 3 or not 0 <= saved_pitch <= 45:
raise ValueError('Three-vector root and bounded pitch required')
angle = math.radians(yaw)
s, c = math.sin(angle), math.cos(angle)
slope = f32(saved_pitch*f32(1/45))
scale = 1800/math.sqrt(1+slope*slope)
return ((root[0]-50*s, root[1]+80, root[2]+50*c),
(-s*scale, slope*scale, c*scale))
def landing_impulse(velocity):
"""40FF80 writes impulse288, BEFORE support47BB74 clears velocityY."""
finite(*velocity)
x,y,z = velocity
return f32(x), f32(y*f32(-.65)), f32(z)
if __name__ == '__main__':
cli=argparse.ArgumentParser(description=__doc__)
cli.add_argument('original', type=Path)
cli.add_argument('--output', type=Path)
args=cli.parse_args()
result=json.dumps(collect(args.original), indent=2)+'\n'
if args.output:
original=args.original.resolve()
if args.output.resolve().is_relative_to(original):
cli.error('Write generated evidence outside the original directory')
args.output.parent.mkdir(parents=True, exist_ok=True)
args.output.write_text(result)
else:
print(result, end='')
+79
View File
@@ -0,0 +1,79 @@
#!/usr/bin/env python3
"""Read-only source guards for VR07 moving targets; projections are not execution."""
from __future__ import annotations
import argparse
import hashlib
import json
from pathlib import Path
import struct
import sys
from checkpoint_script_state import EXE_SHA256, find_case, read_va
from pe_inspect import PE
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'levels'))
from gam import parse
BODIES = (
('target_constructor', 0x430220, 0x4304F6, '17b53c1d4a2196a52bfc43bb7a96216874d7d8923474a2062513312bbe783ae2'),
('target_contact', 0x430570, 0x4306A2, 'c5aeee5d71caba224d24159edbfc9a9d835cb4524ae13eee063e69e3187a76c4'),
('target_frame', 0x4306B0, 0x430860, '85fd36a64db4876ffabe0f66d3897ef0ee95ed1401646591afcff2ebdb55093f'),
('sprite_postload', 0x441AC0, 0x441B20, '10dcae6c03a8cf9f54aade2062a315179a4de9546f1c36380083edfb3d344062'),
('vr07_constructor', 0x4573F0, 0x4574D8, '5a4772c281584d37184d99a7b995fa806ff653bc8ed680c75227560663110523'),
('parent_activation', 0x40E1F0, 0x40E270, '515567cf4a702fa8864c3b714759585e83f34bddb047e8eb762dede3ef480951'),
)
TABLES = ((0x4A8A10, 0x40, 0x430570), (0x4A8A10, 0x3C4, 0x4306B0),
(0x4A8A10, 0x40C, 0x441AC0), (0x4CFAE0, 0x134, 0x475CD0),
(0x4BE404, 0x428, 0x40E1F0))
def collect(original: Path):
pe = PE(find_case(original, 'Neutron.exe'))
if hashlib.sha256(pe.data).hexdigest() != EXE_SHA256:
raise ValueError('Unexpected original executable identity')
bodies = []
for name, start, end, expected in BODIES:
if hashlib.sha256(read_va(pe, start, end-start)).hexdigest() != expected:
raise ValueError(f'Changed original span {name}')
bodies.append(dict(name=name, va=hex(start), fileOffset=hex(pe.offset(start-pe.base)),
length=end-start, sha256=expected))
for table, slot, target in TABLES:
if struct.unpack('<I', read_va(pe, table+slot, 4))[0] != target:
raise ValueError('Changed original virtual target')
if read_va(pe, 0x45CA06, 5) != bytes.fromhex('e81538fdff'):
raise ValueError('Changed 3TAR factory constructor')
if read_va(pe, 0x475CD0, 5) != bytes.fromhex('32c0c21800'):
raise ValueError('Changed false game registration filter')
level = parse(find_case(original, 'gam/VR07.gam').read_bytes())
targets = [dict(offset=hex(e.offset), properties=e.values()) for e in level.entities if e.kind == '3TAR']
return dict(sha256=EXE_SHA256, bodies=bodies, targets=targets,
vtables=[dict(table=hex(t), slot=hex(s), target=hex(f)) for t,s,f in TABLES],
evidenceType='Static source guards and serialized data, not original runtime')
def hit_target(timer: float, points: int, respawn: float):
"""430592..4305D1: caller already proved a C3DBASEBALL contact."""
if timer > 0:
return dict(accepted=False, hidden=False, timer=timer, points=0)
return dict(accepted=True, hidden=True, timer=respawn, points=points)
def step_respawn(timer: float, seconds: float):
"""4306FA..43074F: expiry is <=0 after the stored float subtraction."""
if timer <= 0:
return timer, False
value = struct.unpack('<f', struct.pack('<f', timer-seconds))[0]
return (0, True) if value <= 0 else (value, False)
def parent_hits(count: int, required: int):
"""4305FB..430631: strict >, not >=; only after a matching parent lookup."""
count += 1
return (0, True) if count > required else (count, False)
if __name__ == '__main__':
cli = argparse.ArgumentParser(description=__doc__)
cli.add_argument('original', type=Path)
print(json.dumps(collect(cli.parse_args().original), indent=2))
+199
View File
@@ -0,0 +1,199 @@
#!/usr/bin/env python3
"""Read-only Scooter identity guards and bounded static projections.
No target execution. Input projection is keyboard-only; drive gate deliberately
requires child support observations instead of fabricating wheel contacts.
"""
from __future__ import annotations
import argparse
from dataclasses import dataclass, replace
import hashlib
import json
import math
from pathlib import Path
import struct
from checkpoint_script_state import EXE_SHA256, find_case, read_va
from pe_inspect import PE
BODIES = (
('equip', 0x4290b7, 0x429375, '4e65ee2007a20cd3a78a4529c8177fb6245c539041b82417095a267c193d9ec1'),
('cleanup', 0x4281b3, 0x4284fb, '8ac21a2f27a6703058d18965e86759a878e7d31da86fa827015394164e1a06ec'),
('spawn', 0x423ce8, 0x423dc1, 'dbfa1a7b5609eef20a3ef3d9bd86320d79ee616b06220bedce71bb014d04c5a6'),
('mount', 0x422f13, 0x422fb9, '4d51aa5e2324e3af45632eeae417e976d4cbee9e421a10b1b47ca0a5758811d5'),
('constructor', 0x4211a0, 0x4212f7, 'dd15bf6a55325da3247fe6fe9d9986b2a718ee5945dc10f5dfcbd1ed23a7c741'),
('frame', 0x421580, 0x4217ca, '0d05dda2520f9063d66b256098ad4e63f42eeb1139620d458c86d9a9b6d4b458'),
('input', 0x421880, 0x4218be, 'e46056df24b730111fbaa9a02878ad954762e4b23ac2cec602bbf875677ce14c'),
('predicates', 0x421c10, 0x421cf7, '7461aaff87634a270874304ad4a4618fdc020c3643cc21d605d5cf3b4581820e'),
('vehicle_frame', 0x465220, 0x46582d, '22a766ca5ccd38bcb524d75b1620dfd4718b2ddef2997dedae3f6f84d0984ec8'),
('vehicle_input', 0x465830, 0x465dfe, '62cb4e87ab784d45a13fc763cb79b00d23942a95776568209cbd2b0b625f191f'),
('vehicle_constructor', 0x464b90, 0x464de2, 'af460774f65ffa90dde8407145ffee72643f3e81586a033162b5b22985067017'),
('parameters', 0x464f60, 0x464fcb, 'd32e32495b39a261b6f778d5a24da9a70309c4766dc0994cc2a4973253f57aa9'),
('wheel_setup', 0x412a90, 0x412c77, '2f44692c4545b8088711168dff16269461a862c400b591e091a20ce89c9576ff'),
('sound', 0x412ed0, 0x412f8b, '93ae7fb944aaeff732fa99bcc89db5546bdf8a379a3922575d79b693c03f4408'),
('camera', 0x4130a0, 0x413a60, '9614e6e4ae80f576c060706bd6da453e8f29d8568330c60293570f57c3f4dcc2'),
('collision_callback', 0x421910, 0x421ba4, 'a5a0cd543bf833aa87a896c33144c4d374bb55aae7d7726619011ce6b3611ebc'),
('base_factor', 0x412940, 0x41294c, '5bd12b37bcf408ee68ea761709182ba1781a4b7debbf0bae4a236ac1aa0ae238'),
)
VTABLES = (
(0x4a2f8c, 0x168, 0x412a90), (0x4a2f8c, 0x174, 0x421800),
(0x4a2f8c, 0xec, 0x4130a0), (0x4a2f8c, 0x120, 0x421c10),
(0x4a2f8c, 0x124, 0x421c40), (0x4a2f8c, 0x128, 0x421c70),
(0x4a2f8c, 0x12c, 0x421cb0), (0x4a2f8c, 0x130, 0x413a60),
(0x4a2aec, 0x110, 0x471240), (0x4a2aec, 0x100, 0x4711e0),
(0x4a2aec, 0x214, 0x471a00), (0x4a2aec, 0x28c, 0x471c90),
(0x4a2aec, 0x438, 0x4218c0),
)
CONSTANTS = ((0x4a3110, 'd', .3), (0x48e5dc, 'f', 200.),
(0x49d5cc, 'f', -45.), (0x49d5c8, 'f', 45.),
(0x4a3118, 'f', 0.6600000262260437),
(0x4afce0, 'f', 0.4000000059604645),
(0x4a311c, 'f', 1800.), (0x4a3120, 'f', 4.5),
(0x4a3124, 'f', 600.), (0x48e5ec, 'f', 10.))
def collect(original: Path | str):
pe = PE(find_case(Path(original), 'Neutron.exe'))
digest = hashlib.sha256(pe.data).hexdigest()
if digest != EXE_SHA256:
raise ValueError('Unexpected original EXE identity')
bodies = []
for name, start, end, expected in BODIES:
actual = hashlib.sha256(read_va(pe, start, end-start)).hexdigest()
if actual != expected:
raise ValueError(f'Changed source span {name}')
bodies.append(dict(name=name, va=hex(start), file_offset=hex(pe.offset(start-pe.base)),
length=end-start, sha256=actual))
for base, slot, expected in VTABLES:
if struct.unpack('<I', read_va(pe, base+slot, 4))[0] != expected:
raise ValueError(f'Changed virtual {base:x}+{slot:x}')
for va, kind, expected in CONSTANTS:
if struct.unpack('<'+kind, read_va(pe, va, struct.calcsize(kind)))[0] != expected:
raise ValueError(f'Changed constant {va:x}')
for va, value in [(0x4eef2c, b'omt\\scooter.omt\0'), (0x4eef4c, b'SCOOT\0'),
(0x4eef54, b'SCOOTSTOP\0'), (0x4ecc80, b'C3DJEEP\0')]:
if read_va(pe, va, len(value)) != value:
raise ValueError(f'Changed source string {va:x}')
if read_va(pe, 0x413a60, 3) != b'\x32\xc0\xc3':
raise ValueError('Changed always-false sprint predicate')
return dict(sha256=digest, bodies=bodies,
vtables=[dict(table=hex(b), slot=hex(s), target=hex(t)) for b,s,t in VTABLES],
constants=[dict(va=hex(a), value=v) for a,k,v in CONSTANTS],
raw_mode=4, actor_class='C3DJEEP', radius=150, factor=f32(.2),
wheel_slots=6, wheel_construction_count=4, drive_support_minimum=2,
normal_maximum=f32(2250*f32(.66)), jump_pending_y=700,
original_runtime_verified=False, runtime_implemented=False)
def f32(value):
return struct.unpack('<f', struct.pack('<f', value))[0]
def finite(*values):
if not all(math.isfinite(v) for v in values):
raise ValueError('Finite source inputs required')
def timestep(seconds):
finite(seconds)
if not 0 <= seconds < 1:
raise ValueError('Bounded timestep required')
def equip_result(*, companion_exists=True, companion_enabled=True, practice=False):
"""4290B7 leaf. Spawning/showing does not itself mount or change control."""
if practice:
return 'practice_VR05'
return 'raw4_vehicle_visible_unmounted' if companion_exists and companion_enabled else 'unchanged'
def drive_eligible(grounded: bool, wheel_supports: tuple[bool | None, ...]):
"""465594..4655AE. None is a missing child, not an invented supported child."""
if len(wheel_supports) != 6 or any(v is not None and type(v) is not bool for v in wheel_supports):
raise ValueError('Six source wheel slots required')
front = sum(v is True for v in wheel_supports[:2])
rear = sum(v is True for v in wheel_supports[2:])
return dict(front=front, rear=rear, total=front+rear,
drive=bool(grounded and front+rear >= 2))
@dataclass(frozen=True)
class Steering:
speed: float = 0.
turn: float = 0.
keyboard_turn: bool = False
reverse_latch: bool = False
braking: bool = False
def keyboard_input(state: Steering, seconds: float, *, left=False, right=False,
forward=False, backward=False, rear_supports=0):
"""465830 keyboard subset, no AI/sprint/mouse/analog/camera/contact phase.
413A60 sprint predicate always returns false for this vehicle. Values round
at source storage boundaries, without claiming x87 bit parity.
"""
timestep(seconds)
finite(state.speed, state.turn)
if type(rear_supports) is not int or not 0 <= rear_supports <= 4:
raise ValueError('Rear source support count0..4 required')
dt = f32(seconds)
turn = state.turn
key_turn = state.keyboard_turn
if left:
turn += dt*200
key_turn = True
elif right:
turn -= dt*200
key_turn = True
elif key_turn:
turn = max(0., turn-dt*200) if turn > 0 else min(0., turn+dt*200)
turn = f32(min(45., max(-45., turn)))
speed = state.speed
reverse_latch, braking = state.reverse_latch, state.braking
maximum = f32(2250*f32(.66))
throttle = forward and rear_supports > 0
if throttle:
if speed < maximum:
speed = f32(min(maximum, speed+dt*700))
reverse_latch = False
if backward and rear_supports > 0:
if not reverse_latch:
reverse_latch = True
if speed > 0:
speed = f32(max(0., speed-dt*1200))
braking = True
elif speed < 0:
speed = f32(min(0., speed+dt*1200))
braking = True
else:
speed = f32(max(-maximum*f32(.4), speed-dt*1200))
else:
braking = False
reverse_latch = False
return Steering(speed, turn, key_turn, reverse_latch, braking)
def jump_pending(*, mounted: bool, grounded: bool, held: bool, latched: bool):
"""4215BA..421618: source pending vector write, not direct live velocity."""
if not mounted:
return latched, None
if not held:
return False, None
if not latched and grounded:
return True, (0., 700., 0.)
return latched, None
def animation_step(timer: float, seconds: float, speed: float):
"""42171A: strict double.3 comparison after float timer store."""
finite(timer, speed)
timestep(seconds)
timer = f32(timer+f32(seconds))
return (0., 'SCOOTSTOP' if speed < 10 else 'SCOOT') if timer > .3 else (timer, None)
if __name__ == '__main__':
cli = argparse.ArgumentParser(description=__doc__)
cli.add_argument('original', type=Path)
print(json.dumps(collect(cli.parse_args().original), indent=2))
+127
View File
@@ -0,0 +1,127 @@
#!/usr/bin/env python3
"""Export exact Baseball canvases and authored VR07 data without timing guesses."""
from __future__ import annotations
import argparse
from dataclasses import asdict
import hashlib
import json
from pathlib import Path
from entities import resolve_asset
from gam import parse
from omt import Database, FormatError, read_canvas, write_png
ARCHIVE_SHA256 = 'b584ffa4a38f4bc809b3ea8f4321e0c08f2719e22df41a3fb4cd143ed89b3bef'
VR07_SHA256 = '1260b75d82ec794f9375ada30e186424746bc1dd4e4b0540c9b69bb7ad12d0b1'
# Identity, source name, offset, bytes, width, height, decoded RGBA SHA256.
CANVASES = (
(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'),
)
AIM_ARCHIVES = {
'omt/screens.omt': 'e8e95231f5d302b41f4fbf33df1c5a08ce4645370f9f519527ff1727b73b7a5e',
'alpha.omt': '53cb9f47a588b1f19eb0adc4d43c8066a8b78aedd764b9e9314c81e287991126',
}
AIM_CANVASES = (
('omt/screens.omt', 253, 15, 210, '2e16e11b151c8474ba68fd5017d1a3a6304a594a7f34c3b423f3417c7edfb453'),
('alpha.omt', 118, 16, 16, 'edc60e65dcf7320813a80d4312e3c45951ccfc566ea79dfabf7a22ebc4b96049'),
('alpha.omt', 127, 16, 16, '1fd058ad5bdc0f8a064ef7d2d52b2b036df3f35515691a366799d7e8aab5297f'),
('alpha.omt', 120, 16, 16, '62aaeaaf107300a6f4f7ff52e98106c1520a9edbe2137626ee41091cf243e5c5'),
('alpha.omt', 121, 16, 16, 'd78bf1895f5838b9eb8c6a22565a9588dae4fc8f7106697df373f4408aae634c'),
('alpha.omt', 122, 16, 16, 'f6d628639de4e40005f62f63a49308ff9ee0656a36bb6eb7787230b4830a5ed9'),
('alpha.omt', 123, 16, 16, '9f58cad5621d89b7a7012036daa8532b2397b0d9d267ab7d1aa5a7cd10d7ae87'),
('alpha.omt', 124, 16, 16, '49cdc9ec812f4ef3826011d542c30afbb10229c4b4ce549e7820233bbaa53dd9'),
('alpha.omt', 125, 16, 16, 'aaef2d59c2636c059b446bed643985ca55d15b2d070b0582b2d8994b3bf74f1e'),
('alpha.omt', 126, 16, 16, 'bade574a4624a3f763ddd9c87fa2f102562b00d8d604e9faf32a43b372de64e0'),
('alpha.omt', 119, 16, 16, '0a663ddf2df9f1065f5e4ffe27b4d1fa96edd5f19b6323217bad4148f8d2f3d7'),
)
TIME_DIGITS = (118, 127, 120, 121, 122, 123, 124, 125, 126, 119)
def digest(data: bytes) -> str:
return hashlib.sha256(data).hexdigest()
def export_baseball(original: Path, output: Path) -> dict:
original, output = original.resolve(), output.resolve()
if output.is_relative_to(original) or original.is_relative_to(output):
raise ValueError('Output must be separate from the original installation')
if output.exists() and any(p.is_symlink() for p in output.rglob('*')):
raise ValueError('Generated Baseball paths must not contain symlinks')
database = Database(resolve_asset(original, 'omt/RetainedSprites.omt'))
if digest(database.data) != ARCHIVE_SHA256:
raise FormatError('Unexpected original Baseball archive identity')
textures, pixels = [], []
for identity, name, offset, size, width, height, rgba_sha in CANVASES:
matches = [e for e in database.entries if e.type == 'Canv' and e.id == identity]
if len(matches) != 1:
raise FormatError('Missing original Baseball canvas')
entry = matches[0]
if (entry.name, entry.offset, entry.size) != (name, offset, size):
raise FormatError('Unexpected original Baseball canvas metadata')
payload = database.payload(entry)
canvas = read_canvas(payload)
rgba = canvas['rgba']
if (canvas['width'], canvas['height'], len(rgba), digest(rgba)) != (width, height, width*height*4, rgba_sha):
raise FormatError('Unexpected original Baseball decoded pixels')
textures.append(dict(id=identity, name=name, width=width, height=height,
path=f'canvas_{identity}.rgba', png=f'canvas_{identity}.png',
sourceOffset=offset, sourceBytes=size, sourceSha256=digest(payload), rgbaSha256=rgba_sha))
pixels.append(rgba)
aim_databases = {name: Database(resolve_asset(original, name)) for name in AIM_ARCHIVES}
for name, expected in AIM_ARCHIVES.items():
if digest(aim_databases[name].data) != expected:
raise FormatError('Unexpected Baseball aim archive identity')
aim_textures, aim_pixels = [], []
for archive, identity, width, height, rgba_sha in AIM_CANVASES:
aim_database = aim_databases[archive]
entry = next(e for e in aim_database.entries if e.type == 'Canv' and e.id == identity)
payload = aim_database.payload(entry)
canvas = read_canvas(payload)
rgba = canvas['rgba']
if (canvas['width'], canvas['height'], len(rgba), digest(rgba)) != (width, height, width*height*4, rgba_sha):
raise FormatError('Unexpected Baseball aim decoded pixels')
aim_textures.append(dict(id=identity, name=entry.name, database=archive,
width=width, height=height, path=f'aim_{identity}.rgba', png=f'aim_{identity}.png',
sourceOffset=entry.offset, sourceBytes=entry.size, sourceSha256=digest(payload), rgbaSha256=rgba_sha))
aim_pixels.append(rgba)
source = resolve_asset(original, 'gam/VR07.gam')
source_data = source.read_bytes()
if digest(source_data) != VR07_SHA256:
raise FormatError('Unexpected original Baseball tutorial identity')
level = parse(source_data)
records = [dict(ordinal=index, **asdict(entity)) for index, entity in enumerate(level.entities)
if entity.kind in ('STRT', '3TAR', '3MCA')]
targets = [r for r in records if r['kind'] == '3TAR']
if len(targets) != 6:
raise FormatError('Unexpected original Baseball tutorial target count')
manifest = dict(schema=1, source=database.path.name, sourceSha256=ARCHIVE_SHA256,
textures=textures, ballCanvasIds=[2, 3, 4, 5], retainedTargetCanvasId=8,
aimTextures=aim_textures, aimArchiveSha256=AIM_ARCHIVES.copy(),
aimFontPolicy='Original TIME set5; null space has zero advance;16-unit digits',
aimDigitIds=list(TIME_DIGITS),
tutorial=dict(source=source.name, sha256=VR07_SHA256, entities=records),
bindingPolicy='Exact resource identities; caller owns source timing, dimensions, billboarding and attachments')
output.mkdir(parents=True, exist_ok=True)
for entry, rgba in zip(textures+aim_textures, pixels+aim_pixels):
(output/entry['path']).write_bytes(rgba)
write_png(output/entry['png'], entry['width'], entry['height'], rgba)
(output/'baseball.json').write_text(json.dumps(manifest, indent=2)+'\n', encoding='utf-8')
return manifest
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('original', type=Path)
parser.add_argument('--output', type=Path, required=True)
args = parser.parse_args()
export_baseball(args.original, args.output)
print(f'Original Baseball resources exported: {args.output}/baseball.json')
if __name__ == '__main__':
main()
+2
View File
@@ -13,6 +13,7 @@ from ui import export_ui
from gadget_resources import export_gadget_resources from gadget_resources import export_gadget_resources
from gadget_followup_assets import export_meter from gadget_followup_assets import export_meter
from bubble_resources import export_bubble from bubble_resources import export_bubble
from baseball_resources import export_baseball
from sound_bank import export_sound_bank from sound_bank import export_sound_bank
@@ -84,6 +85,7 @@ def main():
export_gadget_resources(Database(find_archive(args.original, 'screens')), args.output / 'gadgets') export_gadget_resources(Database(find_archive(args.original, 'screens')), args.output / 'gadgets')
export_meter(args.original, args.output / 'invisible-meter') export_meter(args.original, args.output / 'invisible-meter')
export_bubble(args.original,args.output/'bubble') export_bubble(args.original,args.output/'bubble')
export_baseball(args.original,args.output/'baseball')
effects = export_sound_bank(args.original, args.output / 'effects') effects = export_sound_bank(args.original, args.output / 'effects')
print(f"SoundEffects.omt: {len(effects['resources'])} original sound identities") print(f"SoundEffects.omt: {len(effects['resources'])} original sound identities")
for name in args.audio: for name in args.audio:
+100
View File
@@ -0,0 +1,100 @@
#!/usr/bin/env python3
"""Export original Scooter resource data; do not assign attachments or playback.
The two Scooter ASE morphs have 195 indexed positions, whereas scooter.omt's
body has 98. Keep these samples unbound rather than inventing UVs or a base.
"""
from __future__ import annotations
import argparse
import hashlib
import json
from pathlib import Path
from ase import export_ase, read_ase
from entities import resolve_asset
from models import export_omt_model
from omt import Database, FormatError, read_shape
from png import read_png
SOURCES = {
'omt/scooter.omt': '8d4ffdafee5fd819c5220ee4f608c901a5988fe6b8b13316e15618f5eec75e81',
'ASE/jimstop.ASE': 'b294d090ac5c4ec449d845db6d837f2cbedf5f7b812f5b6ed2bb70f85246f1d0',
'ASE/jimscooter.ASE': 'b27c8cb80811eb70e391fc061dab99c7d5f0b4d884c109b34c673a1815508299',
'ASE/jimscooterstop.ASE': 'edcdcc879a28757994525f815c88cd6dd46dc788b69ba2f902323d6de48cb873',
'ASE/godscooter.ASE': 'c18f1414ec2b397e0c8f8320f63830ab88630ea05a354bb99af34ce7fea79bd1',
'ASE/godscooter2.ASE': 'fcf9ca5e8298efa7b4d551d9d09878c04f1f2647b6a30edfa2297617a7d63189',
'png/jimycarl.png': '55ed165aaffe177cb62558a08d13fc3b2210da6e353065b108849d46df9dacb6',
}
def _json(path: Path, value):
path.write_text(json.dumps(value, separators=(',', ':'), allow_nan=False)+'\n', encoding='utf-8')
def export_scooter(original: Path, output: Path) -> dict:
original, output = original.resolve(), output.resolve()
if output.is_relative_to(original) or original.is_relative_to(output):
raise ValueError('Output must be separate from the original installation')
# Existing descendants are checked before any helper writes into them.
if output.exists() and any(p.is_symlink() for p in output.rglob('*')):
raise ValueError('Generated Scooter paths must not contain symlinks')
paths = {name: resolve_asset(original, name) for name in SOURCES}
for name, path in paths.items():
if hashlib.sha256(path.read_bytes()).hexdigest() != SOURCES[name]:
raise FormatError(f'Unexpected original Scooter source identity: {name}')
database = Database(paths['omt/scooter.omt'])
shapes = {}
for identity, expected in ((0, ('goddard01', 98, 176)), (1, ('wheel', 32, 56))):
entry = next(e for e in database.entries if e.type == '3DSh' and e.id == identity)
shape = read_shape(database.payload(entry))
if (entry.name, len(shape['vertices']), len(shape['polygons'])) != expected:
raise FormatError('Unexpected original Scooter shape metadata')
shapes[identity] = shape
animations = {name: read_ase(path) for name, path in paths.items() if name.startswith('ASE/')}
for name, animation in animations.items():
expected_count = 195 if 'godscooter' in name else 426
if len(animation['objects']) != 1 or len(animation['objects'][0]['samples']) != 2:
raise FormatError('Unexpected original Scooter animation objects/samples')
if any(len(s['vertices']) != expected_count for s in animation['objects'][0]['samples']):
raise FormatError('Unexpected original Scooter morph vertex count')
texture_path = resolve_asset(original, 'png/jimycarl.png')
texture = read_png(texture_path)
rgba = texture.pop('rgba')
texture.update(source=texture_path.name, sourceSha256=hashlib.sha256(texture_path.read_bytes()).hexdigest(),
rgbaSha256=hashlib.sha256(rgba).hexdigest(), path='../jimycarl.rgba')
manifest = dict(schema=1, sources=SOURCES.copy(), shapes=[], animations=[], unboundMorphs=[],
bindingPolicy='Resource-only export; caller owns original attachment, transforms and timing')
output.mkdir(parents=True, exist_ok=True)
for identity in shapes:
folder = f'shape_{identity}'
details = export_omt_model(database, identity, output/folder)
manifest['shapes'].append(dict(id=identity, path=folder+'/scene.json', **details))
(output/'jimycarl.rgba').write_bytes(rgba)
for stem in ('jimscooter', 'jimscooterstop'):
animation = export_ase(paths[f'ASE/{stem}.ASE'], output/stem, paths['ASE/jimstop.ASE'])
animation['texture'] = texture
_json(output/stem/'animation.json', animation)
manifest['animations'].append(dict(source=stem+'.ASE', path=stem+'/animation.json'))
for stem in ('godscooter', 'godscooter2'):
animation = animations[f'ASE/{stem}.ASE']
filename = stem+'-unbound.json'
_json(output/filename, animation)
manifest['unboundMorphs'].append(dict(source=stem+'.ASE', path=filename,
vertices=195, sourceTimes=[s['time'] for s in animation['objects'][0]['samples']],
reason='No matching textured base recovered; OMT body 98 and existing Goddard base 222 differ'))
_json(output/'scooter.json', manifest)
return manifest
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('original', type=Path)
parser.add_argument('--output', type=Path, required=True)
args = parser.parse_args()
export_scooter(args.original, args.output)
print(f'Original Scooter resources exported: {args.output}/scooter.json')
if __name__ == '__main__':
main()