diff --git a/AGENTS.md b/AGENTS.md index e0c493c..d7ae096 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -46,6 +46,11 @@ changes. Current gadget controls/resources/primary-fire findings belong in docs/gameplay/. Distinguish static recovery, implementation, port tests and original runtime evidence. Main owns integration/runtime; gadget investigators have exclusive named files, not shared directories. +Latest continuation: docs/gameplay/invisible-implementation.md. Invisible's timed +effect, original meter, companion/cutscene cleanup and shared energy warnings are +implemented; Bubble source is recorded in bubble.md pending movementmode2/body. +All current investigator ownership has returned to primary. Keep full enemy AI, +suppression globals, render state and original/native Windows verification distinct. Use REA for original-binary investigations from now on, including delegated investigations. Preserve its Evidence and cross-check relevant addresses/bytes; diff --git a/README.md b/README.md index 6f1dbf6..87bb40d 100644 --- a/README.md +++ b/README.md @@ -20,12 +20,16 @@ VR04 now uses recovered static body response/support/friction with original-code numeric references. Lab/outside retain the capsule until special contacts and dynamic collision are recovered; see [body implementation](docs/checkpoint/collision-body-implementation.md). -**Current milestone: original gadget screen and playable shrink ray.** +**Current milestone: gadget screen, shrink ray and timed Invisible 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 -with original morphs and score effects. Other gadget effects remain incomplete. +with original morphs and score effects. Invisible uses the recovered recharge, +activation, blend flash, meter and cleanup rules; full enemy sensing/combat and +other gadget effects remain incomplete. See [gadget implementation](docs/gameplay/gadgets-implementation.md) for recovered rules, modern policies and the verification boundary. +The [Invisible continuation](docs/gameplay/invisible-implementation.md) records +the later implementation and shared energy-warning sounds. The runtime includes recovered camera/speech triggers, moving props, Carl/Goddard patrol logic, pickups, objectives, the practice prompt, VR04 powered jumping and @@ -66,6 +70,10 @@ jetpack state controls, camera obstruction, audio category mutes, objective/prac controls and checkpoint save/load. **F3** toggles noclip: WASD moves/strafe, arrows move/turn, Space/E rises, Ctrl/Q descends and Shift triples flight speed. Noclip bypasses collision and contact triggers; reset or a new level disables it. +F1→Player also grants/selects Invisible, unequips it, and shows its timers and +targetability state. After selecting Invisible, allow7 seconds to recharge, then +fire without jump to activate for7 seconds at a fixed2-energy cost (tutorials +are exempt). Its last3 seconds flash before normal rendering returns. **F2** toggles a compact live debug overlay without pausing play. It shows frame timing, position/velocity, movement, control/force state, tasks, camera/clipping @@ -89,7 +97,7 @@ equipped, the first press unequips it. Use the mouse or arrows to point, then Enter/Ctrl or a mouse button to select. Escape or Return closes the screen. Practice Mode followed by an owned gadget enters its original tutorial directly. The screen scales uniformly on widescreen and pauses port gameplay while music -continues. Other gadget selection art is present; their special behaviors remain +continues. Other gadget selection art is present; the remaining special behaviors stay future work. F1's jetpack availability control also controls shrink-ray ownership. The pickup's original objective calls its jump action the **jet pack**. Its diff --git a/docs/architecture.md b/docs/architecture.md index 4239cdd..48eeaaa 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -5,6 +5,15 @@ SDL3 for platform windowing, input and audio. Linux x64 and Windows x64 are equally required. Source is `src/GamePort/`; root executable csproj allows `dotnet build` and `dotnet run` from GamePort. No runtime network dependencies. +The Invisible continuation adds `InvisibleGadget` in Jimmy's post-movement wrapper +phase, separate from input identity. `PlayerSceneBinding` supplies raw-any-control, +handles equip/companion flags and receives a named-Jimmy cleanup event from CAM/ +initial MCA, distinct from raw-owner preparation. `PlayerGadgetMaterial` changes +the existing atlas draw; `InvisibleMeterOverlay` loads original Canv21/22 and +uses shared uniform viewport scaling. `PlayerEnergy` is application-session owned +across scene rebuilds, preserving scalar/warning latch separately from TSK. +See gameplay/invisible-implementation.md for exact coverage and remaining gates. + The first gadget slice separates UI display selection from the equipped raw mode. `GadgetScreen` owns group0 panel state/hit regions; `GadgetMenuOverlay` loads54 original canvases and applies shared uniform640×480 viewport/pointer transforms. diff --git a/docs/compatibility.md b/docs/compatibility.md index d01e21a..c9c03a0 100644 --- a/docs/compatibility.md +++ b/docs/compatibility.md @@ -3,6 +3,20 @@ Compilation, native runtime, original behavior and full feature completion are separate evidence categories. **The game is not fully reconstructed/playable yet.** +Invisible continuation (2026-11-02): recovered mode2 timers, fixed energy cost, +alpha/blend flashing, original meter and companion/cutscene cleanup are integrated. +Shared source energy warning latch/audio now serves ray/jetpack/Invisible. Fifteen +managed groups and182 Python source/parser checks pass. Native Linux/private +Xvfb GTX1070 at1920×1080 verifies real SDL Ctrl/Tab and six rendered phases with +zero enabled Vulkan validation errors; headless matches. The fixture accelerates +836 ordinary player ticks between captures and does not prove original cadence, +enemy immunity, original pixel placement/visual parity or tutorial completion. +Full scripts/test.sh passes182 Python+2 HUD, all managed suites,30 main GPU +completions and17 isolated Vulkan material checks, with zero enabled validation +errors. SDL dummy lifecycle and539 original hashes pass. New packages await the +clean source milestone; Windows native gadget verification remains open. +See gameplay/invisible-implementation.md and artifacts/gadget-followup/. + Gadgets (2026-10-27 UTC): original gadget screen and combined shrink-ray/jetpack are implemented; actual VR04 soldiers use original shrink morphs, source timer, authored AI reset and ordinary10-point score/save effect. First complete run: diff --git a/docs/debug-menu.md b/docs/debug-menu.md index 60f3b11..7480469 100644 --- a/docs/debug-menu.md +++ b/docs/debug-menu.md @@ -29,7 +29,10 @@ by themselves. Debug tools do not imply reconstructed progression or full gamepl The General page retains the existing actions. Player adds noclip, staged flight speeds300/600/1200/2400 (Enter applies), clear motion/queued jump, reopen objective, return to noclip entry, apply source level gadget availability, toggle input after -player, staged jetpack states0/1/4 with a separate Apply row, and energy refill. +player, staged jetpack states0/1/4 with a separate Apply row, energy refill, +Give/Select Invisible and Unequip Current Gadget. Invisible obeys its source +energy/recharge gates; a grant is not instant activation. The header shows +remaining time, recharge and targetability. Full enemy sensing is not implied. State0 means unowned,1 enabled and4 disabled by the level. The full availability action re-enables the matching VR practice gadget and applies LV1B restrictions on gadgets1/7 after the common prefix. Other level-specific tails remain incomplete. These controls expose diff --git a/docs/decisions.md b/docs/decisions.md index a1c7af0..39bb8e6 100644 --- a/docs/decisions.md +++ b/docs/decisions.md @@ -200,3 +200,12 @@ Keep modern full-panel pause, upright effect transform, additive branch and blended-depth policy explicit. Other gadgets, full AI and warning-audio lifecycle remain independent evidence gates, not guessed feature completion. +37. **Preserve timed gadget and cleanup ownership.** Invisible's seven-second + recharge/active clocks run after movement with any nonnull controlled pointer; + raw-null pause is distinct from cleanup. CAM/MCA default DeactivateInv to1 + and explicitly release named Jimmy before target validation, independently + of raw-owner438. Keep failed display2/raw−1 selection, source blend flashing, + original meter art and companion body flags separate from AI activation. + Energy scalar and warning latch share one session owner; raw saved/refill + assignment is not a helper-driven warning rearm. Full enemy sensing, + suppression globals, graphics options and canvas alignment remain explicit. diff --git a/docs/gameplay/bubble.md b/docs/gameplay/bubble.md new file mode 100644 index 0000000..aebef1c --- /dev/null +++ b/docs/gameplay/bubble.md @@ -0,0 +1,171 @@ +# Bubble gadget source contract + +2026-11-01. Recovered static contract for the next gadget; **no Bubble runtime +implementation or original-game execution is claimed by this investigation**. +Original EXE SHA-256 +`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`. +Preferred VAs below map to file offsets VA−400000 in the supplied text section; +`tools/binary/bubble.py` independently PE-maps and exports every retained site. +Output is `artifacts/bubble/source-contract.json`:12 bounded span hashes,37 +instruction sites and6 virtual bindings. Originals were read only. + +## REA evidence and scope + +Two local REA/Ghidra sessions inspected the generated +`artifacts/uncontrolled-phases/rea/Neutron.exe` copy, exported complete Evidence +and closed/snapshotted under `artifacts/bubble/`. + +| Procedure | Evidence / saved reply | +| --- | --- | +| Bubble constructor410840 | `ev_a0c9ee6d5757a741190f3dfcc093bdc7d7b802bcdcd2cbc029422550d34e7cb2`, `rea-effect/00.json` | +| Start410CA0 | `ev_097f43eb24a762785dd495220c26a8995d541c69de3e9a88d4c195e24a04b1ce`, `rea-effect/02.json` | +| Stop410D00 | `ev_d88f2e5a0b0b2ea4f47758084f3c2a6c605f18a1b8c7c4aa3b7cff0e9465b2e7`, `rea-effect/03.json` | + +427FF0,4299B0,429A30 (`rea-core/`) and410AE0 (`rea-effect/01.json`) were not +recognized as procedures by the native profile. Numeric VA queries fell back to +unmapped file-offset errors; the complete diagnostics remain on disk. These are +not successful decompilations. Contracts below use reviewed fixed instruction +ranges/virtual bindings, supported by the successful constructor/start/stop +Evidence. No unchanged failed query was repeated. Supplementary objdump output +is retained as `equip.asm`, `cleanup.asm`, `class.asm`, `position.asm` and +`exe.asm`; source hashes and mapping keep this independently reviewable. + +## Owners and layout — recovered + +The [group0 menu](gadget-controls.md) names item0 **BUBBLE** and maps its practice +to VR01. Global signed WORD4F0588 is equipped raw mode; source movement mode is +a separate WORD at Jimmy complete7C4/interface704. The Bubble is owned at Jimmy +completeA14/interface954. Constructor42232C calls410840, stores the result42233C +and initially hides it at42236E. It is not a free-moving projectile or Jimmy's +physical body. + +Bubble complete vtable492970; game interface is complete+C8 with table49250C. +Game slot3C4 binds410AE0 update; generic1C binds464130. Constructor4108F7 registers +FourCC `3BUB`; class name is `C3DBUBBLE`. Constructor4352F0 supplies the sprite +base. Own body integration/triangle collision is disabled through471030(0) and +4710C0(0); Jimmy's body instead changes radius/factor when equipped. + +| Bubble complete field | Purpose established here | +| --- | --- | +|90..9C|RGBA sprite color; expanding/collapsing writes all four components| +|AC/B0|Sprite width/height; initially200/200 via4645F0(200)| +|B4/B8|Source/destination blend enums6 /1 or7| +|57C|Integer base pulse size240, initialized410935| +|584|Copied archive name `RetainedSprites.omt`| +|5E8|Loaded original canvas resource; constructor477890(archive,1)| +|600|Float visual timer, incremented each effect update| +|604|Float pulse `sin(timer*10)*30` while active| +|610|Float fade scalar| +|614/615/616|Active / expanding / collapsing flags respectively| + +The retained resource is Canv1 of RetainedSprites.omt, not an ASE sphere. Exact +archive/pixels/tutorial inventory is independently documented by the asset +investigator. The sprite's full camera-facing transform remains a rendering +adapter dependency; the ellipse/pulse does not justify inventing sphere geometry. + +## Equip and cleanup — recovered + +Complete Jimmy174→428D50 dispatches item0 to428F61. The common menu caller closes +and invokes cleanup178 first; arbitrary calls to174 without that caller are not +equivalent. Bubble branch order: + +1. Require the owned Bubble pointer. If absent, return without a new effect. +2. If runtime Practice state(0,9)==2, reset that state and load `vr01.gam` at + 428FCA using existing return strings. This precedes energy and visual-state tests. +3. At428FDA require energy4F83D4>0 or Jimmy complete9F8 nonzero. The latter is + retained here as an unnamed exemption flag; its complete ownership is open. + Failure writes raw mode−1 at428FFA and returns. +4. Reject Bubble active614, collapsing616 or expanding615 before starting another + transition. These flags are not a generic cooldown invented by the port. +5. At429049/429058 invoke game110/100 for **radius160/factor0.415**; write raw mode0 + at429065, movement mode2 at429072 and max controller speed1350 at42907B. +6. Call410CA0 at429085. Start sets expanding615, timer600=0, unhides the sprite + if necessary and chooses blend6/1 (additive) or6/7 (conventional alpha) from + graphics flag509A13. It does not clear other transition flags itself. +7. Start loop SFX2 at429093..4290A1 only if Jimmy completeA40 handle is−1, then + animation refresh148. Source animation selection also depends on movement/body. + +Cleanup178→427FF0 dispatches raw mode0 to428037. With the owned Bubble it sets +Jimmy A20=0.5, movement mode0, **max controller speed650**, calls410D00 to begin +collapse, then **separately clears expanding615** at42806B. It stops the A40 loop +and resets handle−1; invokes radius60/factor1.265; writes raw mode−1 at4280BB. +The source's explicit650 cleanup value must not silently be replaced by the +constructor's600 or by generic authored-state restoration. The A20 consumer is +not closed here. Missing-pointer cleanup falls to the shared raw−1 tail without +these body/effect changes. Cleanup also restores selected-device HUD3 via the +common prelude. It does not directly transfer raw controlled-pointer ownership. + +## Active input, movement and interactions — recovered boundary + +426030's input callback retains its existing global/game/control predicates. +Within it426264 tests **movement mode2**, not raw mode0, then426272..426280 calls +42A920 with `−0.5*dt`. The common energy helper owns VR exemption, clamp and warning +sounds; no duplicate exemption is implied by the Bubble branch. After adjustment, +426285..42629F invokes cleanup178 if energy<=0. Consequently controlled Bubble +input drains0.5 energy/second outside exempt tutorial handling. Loss of input +ownership can stop this branch while the independently registered effect still +updates. This is not permission to pause every clock on raw-control loss. + +The same branch positions the sprite using current camera eye509A50+44..4C: +`direction=normalize(JimmyRoot+(0,100,0)−eye)`; +`BubbleRoot=JimmyRoot+(0,50,0)−direction*80` (4262A5..4263DA). +This is camera-relative and differs from simply drawing a sphere centered at +JimmyRoot. Zero-length normalization/imported-vector rounding remains open. + +Generic input438B1E..438B98 maps movement modes1 **and2** to shared439900, while +mode0 maps438BC0 and3 maps43A120. The prior air-steering recovery of439900 is useful, +but does not close Bubble's complete jumping/body/mode transition behavior. +Supported Jimmy wrapper4246A9..4246E3 explicitly restores live radius160/raw mode0 +or60 otherwise, before the later movement/fire phases. A live Bubble integration +must preserve source authored/live radii and movementmode2, including support. + +Ordinary primary fire4266AC rejects raw mode0 before controller-speed-zero, +SHOOT and the ray scan. Jetpack dispatch also skips raw mode0 at4260D3. Bubble +must not keep the ordinary beam or powered-jump path active merely because item3 +is owned. Other generic movement/jump paths still need caller-complete recovery. +Source callbacks42A870 and42A8D0 return early for raw mode0 before their energy/ +score/flash effects, and42AB0E skips an additional SFX190. Their complete callers/ +meaning are not traced here; this establishes specific bypasses, **not** universal +invulnerability against every hazard, actor or script. + +## Sprite transitions — recovered, with numeric projection limits + +410AE0 first increments float timer600 bydt, then processes flags in priority +order active614, expanding615, collapsing616: + +- **Active:** pulse=sin(timer*10)*30; width=(float)integer57C=240 and height=240+pulse. + If509A13 is true, RGBA becomes(1,1,1,0.5); otherwise existing RGBA is retained. + This does not geometrically scale Jimmy or the sprite during fade. +- **Expanding:** scalar610=timer; strictly `timer>double1` clamps scalar1, sets + active614 and clears expanding615. RGBA=(scalar,scalar,scalar,scalar). + At exactly1 it remains expanding until a later update. +- **Collapsing:** scalar610=1−timer; strictly scalar<0 clamps0, clears collapsing616 + and hides the sprite. RGBA=(scalar,scalar,scalar,scalar). Exactly0 retains collapse + until a later update. Stop410D00 sets collapsing616, clears active614 and timer0; + Jimmy cleanup must additionally clear expanding615 or expansion retains priority. + +The Python projection retains these state/strict-boundary distinctions and +single-precision stored values. It does not claim x87 intermediate/fsin bit parity +or original runtime observations. Blending both RGB and alpha during fade can +change perceived brightness; replacing it with alpha-only is a behavior change. + +## Validation, current implementation and next action + +Six Python source-contract groups pass in `artifacts/bubble/tests.log`: original +identity/span/site/virtual guards and offsets, equip order/flags, movement2 drain, +strict expand boundary/color without size scaling, active pulse/graphics alpha, +and cleanup priority/strict-negative collapse. This is static/source-projection +validation, not native Bubble gameplay or an original game capture. + +The port's group0 selection/practice already exposes Bubble, but **this agent made +no runtime changes**. Raw mode0 radius160 is a named future case; the existing +ordinary static Jimmy body subset must not be advertised as complete Bubble +physics. Recommended next coherent implementation: retain an owned sprite with +original Canv1, source transition flags and camera-relative placement; integrate +source radius/factor/maxspeed/movement2/ordinary-fire cancellation together, +including source cleanup650, controlled−0.5dt and independent visual clock. +First recover the generic mode2 jump/body transitions and actual VR01 support/ +collision class coverage, then test equip→expand→move/jump→empty/Tab cleanup→fade +and tutorial/RETURN persistence. Full hazard/AI immunity and renderer orientation +remain explicit gates. Invisible is the primary's selected next playable slice; +this Bubble contract is ready for that later chunk without speculative physics. diff --git a/docs/gameplay/gadget-followup-assets.md b/docs/gameplay/gadget-followup-assets.md new file mode 100644 index 0000000..c02d08c --- /dev/null +++ b/docs/gameplay/gadget-followup-assets.md @@ -0,0 +1,175 @@ +# Bubble / Invisible resource and tutorial follow-up + +2026-11-01. Original asset parsing, decoded-pixel inspection and local REA static +analysis. Originals remain untouched. This report does not establish original +gameplay execution, enemy detection, tutorial completion or native Windows runtime. +Primary selected Invisible as the next bounded gameplay implementation; Bubble +resource observations are retained for the later effect. + +## Evidence and reusable output + +`tools/extractors/gadget_followup_assets.py` inventories exact original resources, +seven current Jimmy clips and both authored tutorials. It retains archive/payload +hashes, resource byte offsets, GAM property offsets/raw bytes and duplicate tags. +It also guards the source image identities and eight bounded meter code spans. +No game code is executed by this utility. Generated report and inspected images: +`artifacts/gadget-followup-assets/resources.json`, `orangebubble.png`, +`controls_109.png`, `controls_111.png`, `canvas_21.png`, `canvas_22.png`. + +```bash +python3 tools/extractors/gadget_followup_assets.py ../Original \ + --output artifacts/gadget-followup-assets/resources.json \ + --meter-output artifacts/extracted/invisible-meter +python3 -m unittest discover -s tests -p test_gadget_followup_assets.py -v +``` + +`export_meter(original, output)` writes `meter.json` schema1, reference640×480, +exactly two texture records and original decoded RGBA/PNG files. Records contain +id/name/width/height/path/png/sourceOffset/sourceBytes/sourceSha256/rgbaSha256. +Both names/dimensions are checked before any files are written. Original root, +its subtrees and ancestor outputs are rejected. Pixel files are neither recolored +nor resized; state/tint/geometry belong to the caller. Six checks pass in +`artifacts/gadget-followup-assets/tests.log`: exact assets, tutorial source offsets, +duplicate identity, output protection, pixel export and guarded meter spans. + +## Invisible uses the existing Jimmy family — asset facts + +`png/jimycarl.png` is256×256; all65,536 texels have alpha255. The existing +prepared Jimmy atlas therefore has no translucent source pixels to replace for +this effect. Source `jimstop.ASE` has426 vertices/814 faces, two samples at10fps, +480 ticks/frame, and supplies3,551 UV entries/814 UV faces. `jimrun`, +`jimbackpedal`, `jimjump`, `jimfall`, `jimfly` and `jimshoot` have the same +vertex/face counts and no UV tables; existing preparation uses the standing UV +topology. This report verifies counts and resource identity, not every morph's +original interpolation phase. + +No additional ASE or PNG is required for the recovered Invisible material path. +[Invisible source](invisible.md) owns the activation/timer/state interpretation; +[material report](gadget-blending.md) already traces complete slot114→40E4A0 +positive RGBA/material alpha and source blend enums. Existing port fragment +cutout occurs before multiplying material opacity, so alpha0.7 does not discard +this fully opaque source atlas. Original fixed-function alpha-test interaction +and full material-state parity remain separate renderer questions. + +The original control strip Canv111 `BmenuLInvisible` visibly labels primary mouse +and Ctrl as INVISIBLE. Bubble strip109 separately labels mouse movement/forward, +jump and Ctrl/Insert keyboard equivalents. These inspected pixels corroborate +the input descriptions; they do not establish a held/edge policy, timers or +power consumption. Menu/HUD resources already exported for both items are in +[gadget assets](gadget-assets.md); no invented icons are needed. + +## Recharge-meter resources and source chain + +Original `screens.omt` SHA256: +`e8e95231f5d302b41f4fbf33df1c5a08ce4645370f9f519527ff1727b73b7a5e`. + +| Canvas | Source offset / bytes | Exact decoded dimensions | +| --- | --- | --- | +|21 `meter` |0x88E18 /8118 |30×110, border/backplate | +|22 `metercolor` |0x8C5D8 /9138 |30×110, original multicolor fill | + +REA inspected private hashed copies. EXE identity is +`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`; +DLL identity is `3ec41ead011adf56387a6dbd4580e5b5a9721b5f8020c8a56420f42824354943`. +Complete replies, exports and closed snapshots are in +`artifacts/gadget-followup-assets/rea-meter/` and `rea-meter-dll/`. +The renderer/alignment follow-up is exported/closed in `rea-meter-surface/`. + +| Source function | REA Evidence | +| --- | --- | +|401430 menu construction |`ev_e7355ffccf1c4066e58d93e229e4a89662e01045e555d178cb2c11b1ddb5b42b` | +|402D70 canvas placement |`ev_37b8296fe0ea52d6b1d36ba096c60700a7dca3986cb7966b8d6d2884253bf4f0` | +|4037F0 meter percent |`ev_525ca303ce70c16f524063053ebdd9fecd82054cf480d8f2f30f1ec0d7e08333` | +|DLL10029430 canvas render |`ev_f133d0c29cd7b2969814c4b89df37e369776d954543980c93dc69bc3ccb7e579` | +|DLL10029180 canvas construction |`ev_856445a19d924cf5ec157575da27686731caca9a1a611895a98d269fe31c4b03` | +|DLL10037AC0 draw_surface |`ev_143b978a715b32486294f27aa987c926c0cf8f52e09a2116b81ec34803d9962b` | +|DLL10029870 update_logic |`ev_5021f9ff80b9087cafdf449976e363921d6159833f003efe15870f24932d8343` | +|DLL10029890 compute_auto_align |`ev_b963c3e443054b1425af94a27efd37cc157f6dd2070d2d87cbb2a78f72dc083e` | +|DLL10029930 get_canv_wordsize |`ev_d766e30f3466351eaea497f58546f564563849cf9fdc269c42b131c01ac542a5` | + +Constructor401430 opens `omt/screens.omt` and binds global4F7CB0 to canvas21 at +4017CB, global4F8028 to canvas22 at401865 through402D70→menu454/402E30. Literal +coordinate arguments are(320,7) and(322,4). Constructor sets sprite source blend6, +destination1 or7 according to graphics509A13; RGBA initiallywhite. Runtime +menu484/488 show/hide both;48C/490 change fill tint to red(1,.2,.2,1)/white. +Those latter caller/state branches are guarded by [Invisible](invisible.md). + +4037F0 (raw0x37F0) clamps only negative percent to0, writes fill width +`screenWidth/640*27`, and height `screenHeight/480*percent*1.04`. Global4F6560 is +screen width,4F655E height. The multiplier at48D908/raw8D908 is a stored double +**1.04**, not0.01. At100 percent the logical height is104. Width/height are fields +AC/B0; source sprite placement44/48 stays separate. No forced100 clamp is proven +in this leaf. Caller supplies the actual timer/recharge conversion. + +Texture resize is **full-image stretch**, not percentage UV cropping. Canvas +render10029430 obtains custom AC/B0 dimensions when flagC4 bit0 is set, then +forwards the original canvas, cached offsets, dimensions and RGBA90 to renderer +slotB0.402D70 sets flagC4 to1. DX draw_surface10037AC0 builds a rectangle using +the supplied width/height, with source UV0..0.9999 for the single-texture path; +the tiled path distributes the complete source canvas across those dimensions. +Percentage does not enter UV selection. The modern texture uses0..1 over the +exact decoded image; legacy edge epsilon/texture padding remain renderer details. +The tint multiplies this original gradient once; no replacement solid fill or +partial-source gradient crop is evidenced. Source48C/490 tint leaves are already +in the guarded192-byte meter_tint span0x3730..37F0. + +Modern layout policy: interpret the source coordinates using a640×480 logical +viewport with uniform widescreen scale, background rectangle(320,7,30,110), +fill width27 and bottom114/top `114−1.04*percent`. This preserves source initial +bottom placement while changing height. It is explicitly not a fully closed +original pixel-position recovery:402D70 writes alignment modesBC/C0=3; +constructor initializes cached offsetsA0/A4=0, while engine update_logic10029870 +can recompute−half-size offsets through10029890. Canvas render forwards cached +offsets and dimensions. Whether these menu sprites enter that engine logic pass, +and the exact frame of recomputation, remain unresolved. Pseudocode for402D70 +has incorrectly recovered parameters; its arguments/formulas above are checked +against the guarded instructions, not copied from its prototype. + +## Original tutorial fixtures + +| Data | VR01 Bubble | VR03 Invisible | +| --- | --- | --- | +|GAM SHA256 |`7938214fb62784fcb34245491342a5f33e3615bdc178e4883a9e285e6869904f` |`8acc4d3b8c416c41c1900ac0b1f895ab5819781e5dd87d19a1f177414660d5b2` | +|Entity count |16 |67 | +|Scene shape |`VRRoom`,60 vertices/80 triangles |`Box01`,280 vertices/424 triangles | +|PHONEBOOTH STRT offset |0x45C |0x406 | +|Authored root |(−2678.0381,87.3322,−2783.4011) |(−292.9982,160.3451,−2467.5544) | +|Yaw |290 |290 | +|Intro |`bu`,3MCA0xA61 |`inv`,3MCA0x8EEE | +|Voicepractice IDs |24/23/22 |21/20/37 | +|Return LOAD offsets |0x83C radius400;0x1631 radius300 |0x94DE radius300 | + +Both intros serialize PlayerControlled=NULL and NextTrigger=default. VR01 has +DeactivateInv=1; VR03 omits that property. Absence is not evidence forfalse; +the constructor/default binding is documented separately by the Invisible +investigator. VR03 source SoundIndex0/1/2 properties occur at0x90F7/0x9176/0x91F5. +The voice bank also contains invisibility4/ID38, but this intro does not use it. + +VR03 contains eight actual3SOL at source offsets0x7BA,14B0,1EB7,342B,4828,4D2F, +5736,633B. All share ObjectTag `C3DYOKIANSOLDIER`; keep actor identity by instance/ +source offset, never collapse them into one dictionary/tag lookup. Each serializes +AIState2, VisibleRange2500,FOV359,TargetNameJIM1. These data values do not recover +the target-detection algorithm or prove combat/AI is implemented. +Literal patrol links contain two missing names: yok3→`tok4`, and soldier0x5736 +starts at `fyoy1`; supplied patrols contain `yok4`/`fyok1`. Preserve these original +strings rather than silently repairing them. VR01 contains no3SOL. + +A meaningful bounded Invisible fixture can load actualVR03/PHONEBOOTH, skip or +complete its source intro, and exercise equipped/ready/activation/expiry/recharge/ +cleanup against the current player, atlas and meter. It must establish item2 +availability through the existing inventory/PostLoad contract. No fake enemy or +invented vision/combat response is needed to verify this first effect. Tutorial +navigation, stealth detection and trophy/RETURN completion remain separate tests. + +## Bubble assets retained for later + +`RetainedSprites.omt` Canv1 `orangebubble` at0x17FCE/66322 bytes decodes146×146, +with15,824 opaque and5,492 transparent pixels. RGBA SHA256: +`a3a678c47c1ce94946b1136560a84f3ef86c6884b981256a9fbff62fe8a988e4`. +This is confirmed by the Bubble constructor's explicit archive/ID binding, not +just its name: [Bubble report](bubble.md), constructor410840 REA +`ev_a0c9ee6d5757a741190f3dfcc093bdc7d7b802bcdcd2cbc029422550d34e7cb2`, +saved/exported/closed in `artifacts/bubble/rea-effect/`. No new ASE is indicated. +SoundEffects Wave2/3/106 are gravitybubble/gravitybubbleoff/bubble boing; serialized +resource identities alone do not establish repeat/stop ownership. Bubble pulse, +growth/fade/collision and billboard orientation belong to that system report. diff --git a/docs/gameplay/gadgets-implementation.md b/docs/gameplay/gadgets-implementation.md index a0ca206..bf54bb1 100644 --- a/docs/gameplay/gadgets-implementation.md +++ b/docs/gameplay/gadgets-implementation.md @@ -1,5 +1,9 @@ # First playable gadget implementation +Historical first slice. [Invisible continuation](invisible-implementation.md) +supersedes its unimplemented Invisible/shared energy-warning items; other limits +below remain scoped to the recorded2026-10-27 implementation. + 2026-10-27. User-directed gameplay continuation; collision checkpoint35a2a66/ 0272f7b remains parked. This implements the original gadget screen and the combined shrink-ray/jetpack device, with a bounded3SOL target consumer. It does not complete diff --git a/docs/gameplay/invisible-implementation.md b/docs/gameplay/invisible-implementation.md new file mode 100644 index 0000000..0d8e399 --- /dev/null +++ b/docs/gameplay/invisible-implementation.md @@ -0,0 +1,108 @@ +# Invisible gameplay continuation + +2026-11-02. Implements original item2/raw mode2 and shared energy warnings. +Collision recovery remains parked at35a2a66/0272f7b; the preceding gadget +source/packages7b5230c remain a separate verified milestone. + +## Coverage and evidence + +| System | Original contract | Port / remaining boundary | +| --- | --- | --- | +| Selection428E51 | Display2 precedes actual equip;9F8 tutorial override | Failed equip can retain display2/raw−1; successful equip starts both clocks0 | +| Wrapper424E80 | After base movement; any controlled pointer | Separate from Jimmy input identity; raw NULL freezes/hides meter | +| Activation | Recharge exactly7, energy>2/override, fixed−2 | Initial7-second recharge;7-second active timer; held reactivation; jump blocks activation only | +| Material114/FC/target55D | Alpha.7, indexed blend flash; target eligibility | Existing Jimmy draw; targetability retained, full enemy AI consumers absent | +| Meter4037F0 | Canv21/22, full gradient stretch, size/tint | Exact original pixels; logical placement/uniform scale is declared modern policy | +| Companion/cleanup427FF0 | Immediate hide, D0/214 flags,9E8 restore guard | Separate movement/body flags; body integration gated without blanket AI pause | +| CAM4165B7/MCA43129A | Default DeactivateInv1, named Jimmy lookup | Prelude separate from raw438 preparation; AI-null retains effect | +| Energy42A920 | Scalar4F83D4 and warning latch4F83DC | Shared owner and80/182 callback order/hysteresis across ordinary loads | +| Bubble follow-up | Equip/visual/drain/cleanup recovered | Runtime pending full movementmode2/jump/body contract | + +Static reports retain hashes, VAs/file offsets, guarded bodies/sites, complete +REA Evidence, exports/snapshots and provider errors: [Invisible](invisible.md), +[assets/meter](gadget-followup-assets.md), [shared energy](player-energy.md), +[independent review](invisible-review.md) and [Bubble](bubble.md). No new whole +original-game execution was performed. The retained complete42A920 REA record +was reused rather than repeating that investigation. + +## Implementation and ownership + +LabSimulation owns InvisibleGadget and invokes it after controlled movement, +before its existing owned jetpack-effect phase. PlayerSceneBinding supplies both +Jimmy input permission and raw-any-control. Another controlled actor permits +this wrapper without granting Jimmy movement. Raw NULL freezes both timers and +hides the meter without ending the material effect. The pure recovered suppressor +branch is tested, but source globals4F8182/4F83E0 have no complete lifecycle +provider yet. Existing modal/focus/debug capture remains a broader port policy. + +Successful equip hides Goddard immediately, starts both timers0 and colors/shows +the meter red. Initial recharge must reach exactly7 before a later tick can +activate. Held primary without jump requires energy strictly>2 or the tutorial +override, spends fixed2, sets remaining7/targetablefalse/alpha.7, then decrements +remaining in the same invocation. No continuous Invisible drain, invented sound +or edge latch is added. Ordinary jumping remains possible. + +At remaining<=3, trunc(remaining×5)%2 selects conventional versus additive blend +on material0. Expiry<=0 restores opaque/targetable/red; recharge begins next tick. +The additive initial branch follows the existing chosen source graphics-option +path; its original option predicate remains open. Blended world depth writes +remain disabled as an explicit renderer policy. Captures verify port output, +not original visual parity or self-occlusion equivalence. + +PlayerGadgetMaterial changes the existing atlas draw without changing pose, +geometry or authored visibility. InvisibleMeterOverlay uses exact Canv21/22 RGBA, +source width27/height percent×1.04, white/red vertex tint and full texture stretch. +Percentage is published before recharge clamps7, preserving its small ready +overshoot. Source local positions become centered640×480 logical rectangles +with uniform widescreen scale. Cached engine autoalignment scheduling is still +open; original pixel-placement fidelity is not claimed. + +SceneDirector emits named-Jimmy GadgetReleaseRequested at initial CAM/MCA +activation when DeactivateInv is absent/true, before first MCA target/skip checks. +This differs from ordered raw-owner438/410/flatten callbacks. Explicit0 can bypass +the named prelude; raw-owner preparation can still clean. AI-null stops motion +and clears control without invented cleanup. Release stores remaining7/recharge0 +and restores local state. Modern reset clears timers/diagnostics explicitly. + +Companion movement/body-enable fields are distinct from AI Active. Equip disables +both and hides Goddard; cleanup restores them outside the six proven PostLoad9E8 +blocked levels. ActorPatrol skips disabled body integration while retaining its +bounded AI subset. Independent future writes to movement/body flags, full +companion lifecycle and other AI modes remain separate work. + +PlayerEnergy retains scalar and warning latch across ordinary scene rebuilds. +Ray, active jetpack and Invisible share tutorial bypass, empty-crossing80 before +write, low182 after scalar/before latch, strict<19 warning and>20 rearm. Raw saved +scalar/debug refill does not invent a latch reset. TSK retains its original +scalar only; complete damage/energy/pickup consumers remain unported. + +## Controls and verification + +Select owned Invisible in Tab/Space, wait for recharge, then hold Enter/Ctrl/left +mouse without jump. F1→Player adds Give/Select Invisible, Unequip and timer/ +targetability diagnostics. F1 retains the existing gameplay/audio pause policy; +Tab while a special gadget is equipped unequips first. + +Fifteen managed groups cover numeric/sound order, retained energy ownership, +strict gates, same-tick decrement, held activation, flash/expiry, raw-null/other +owner distinctions, named cleanup, companion restoration, failed display/raw +equip separation and original meter/widescreen geometry. Source coverage grows +to182 Python checks plus separate HUD tests. Independent review ran the earlier +12 groups before the final three binding/meter groups were added. + +The eight-frame --smoke-invisible fixture explicitly advances836 additional +normal player ticks between rendered phases. It grants owned item2 and skips the +intro without relocating actors or directly mutating timers/materials. Headless +and native1920×1080 GTX1070/private Xvfb pass charged, activated, alpha flash, +additive flash, expired and unequipped checks; native uses real SDL Ctrl/Tab. +Tutorial energy stays20. Both report zero enabled Vulkan validation errors. +Six-phase captures were inspected. Logs/captures: artifacts/gadget-followup/. + +These accelerated observations do not establish real-time original cadence, +manual navigation, enemy immunity, tutorial completion or native Windows runtime. +Complete scripts/test.sh passes182 Python+2 HUD checks, all managed suites, +30 main GPU completions and17 isolated Vulkan material checks, with zero enabled +validation errors. SDL dummy lifecycle and539 unchanged originals pass. Package +results follow the clean source milestone in progress.md. Full enemy sensing/ +combat, graphics-option selection, cached canvas +alignment, exact scheduler/x87 boundaries and the other gadgets remain open. diff --git a/docs/gameplay/invisible-review.md b/docs/gameplay/invisible-review.md new file mode 100644 index 0000000..68dc475 --- /dev/null +++ b/docs/gameplay/invisible-review.md @@ -0,0 +1,100 @@ +# Invisible implementation review + +2026-11-01. Independent read-only review of the primary's current Invisible/energy +runtime against [invisible.md](invisible.md), retained companion/preparation +evidence and the original42A920 instructions. Reviewed files: +InvisibleGadget, PlayerEnergy, LabSimulation, PlayerSceneBinding, +PlayerGadgetMaterial, SceneDirector, ActorPatrol, Program and InvisibleTests. +The reviewer edits only this report; primary owns fixes and integration. + +## Directly evidenced correction found and resolved + +The initial SceneDirector only released gadgets through current raw-owner438 +preparation. Original CAM4165B7..4165DC and MCA43129A..4312CC separately inspect +DeactivateInv and look up **JIM1**, even when the controlled pointer is already +NULL or another actor owns it. Both constructors default the property1; absent +GAM data does not mean false. MCA's prelude runs before its first target-none +branch. The initial implementation could therefore retain active Invisible +through a CAM/MCA where original code cleans it. + +Primary added GadgetReleaseRequested with an explicit JIM1 lookup and +Integer("DeactivateInv",1) at single-CAM/initial-MCA activation, before target/ +skip checks. PlayerSceneBinding subscribes and uses existing selected-gadget +cleanup. Re-reading confirms that correction is present. Existing ordered raw +438/410/flatten preparation remains separate. Later MCA shot changes do not +repeat the initial prelude. AI-null still dispatches410 without invented438/ +gadget cleanup; its raw-null pause can retain Invisible state as source does. + +## Confirmed source alignment + +- Invisible runs immediately after the player movement phase and before the + existing owned effect phase. AnyControlled is passed separately from Jimmy + input ownership. Null raw control freezes timers/hides the meter; a different + nonnull owner can permit the wrapper without permitting Jimmy movement. +- Equip accepts energy>0 or VR override. Display selection2 is retained even + when the actual raw-mode equip rejects; caller cleanup removes the old special + mode first. Successful equip resets both clocks0. Unequip stores remaining7, + recharge0 and restores opaque/targetable presentation; modern full reset + starts0 and clears diagnostic counts explicitly. +- Activation uses remaining0 and recharge exactly7, primary without jump, + energy strictly>2 or override, one fixed−2 adjustment and same-call remaining + decrement. Initial recharge must complete first; reaching7 cannot activate + until the next invocation. Held primary can reactivate after another recharge. +- Recharge runs only with remaining0 and positive energy/override, clamps7 and + turns the meter white. Expiry<=0 restores opaque/targetable/red; recharge + starts next call. Active duration continues at zero energy or during jumps. +- Opacity0.7, additive initial branch and last3s alternating conventional/ + additive blend match the guarded material path. Expiry argument0 means reset + material alpha1/blend-disabled, not alpha0. The one-atlas Jimmy draw keeps + authored visibility and geometry; no invented whole-model hide/fade is used. +- PlayerEnergy implements strict19/20 warning hysteresis, empty-crossing sound80 + before the scalar write, low182 after the write/before latch and VR01..08 + helper bypass. The scalar and warning latch share a session owner across + ordinary loads; raw saved/debug scalar assignment does not rearm the helper. + The upper clamp compares the pre-store sum, and callback-driven scalar changes + are respected by reloading after the crossing callback, as source42A975 does. +- Companion hide/disable occurs on equip, including recharge, not on activation. + The binding preserves distinct AI activation, body-enable and movement-enable + fields. Its six-level restore exclusion matches the bounded PostLoad9E8 + mapping; it does not restore a saved previous visibility or blanket-pause AI. + +## Explicit remaining boundaries + +1. The pure Invisible suppressor branch is implemented/tested, but LabSimulation + currently supplies no provider for source global4F8182, nor the primary helper's + independent4F83E0 veto. Modern modal/focus/debug capture clears input/pauses + simulation. Those policies do not establish the complete original global + suppression lifecycle; document this as partial input coverage. +2. Source55D/49D target eligibility is stored/observable, but full enemy sensing, + lost-target, existing attack and class-specific consumers are absent. Generic + 409CC0 also permits positive enemy934 when the flag is false. Do not describe + the slice as universal enemy avoidance or invulnerability. +3. Companion9E8 is represented by known initial level policy. Later source + setters/dynamic modes remain outside this bridge. MovementEnabled is stored + but has no independent modern consumer yet; the bounded equip/cleanup path + writes it together with BodyEnabled, which gates body integration. Independent + changes to only one flag require their original consumers before expansion. +4. Additive is the declared graphics509A13=false branch. The original setting + predicate, general multi-material/LOD behavior, transparent depth state, + original registry cadence and exhaustive x87 meter boundaries remain open. + Existing full-panel/noclip pauses and full scene rebuild are modern policies. +5. Meter resources/layout are being integrated by primary from the independent + asset report. This review does not certify that unfinished overlay or final + native/packaged renders. Full game and native Windows comparison remain open. + +## Verification + +The reviewer independently ran the current twelve managed Invisible/energy groups +successfully using the existing project SDK, logged in +`artifacts/invisible/runtime-review-tests.log`. That run covers energy callback +ordering/hysteresis/retention/tutorial bypass, first recharge, activation strict +threshold/jump, raw-null/suppressor pause, flash/expiry, repeated held activation, +cleanup and material mapping. It predates the primary's additional binding/ +companion fixtures. Nine source/static-projection groups independently pass in +`artifacts/invisible/tests.log`; these do not execute original code. + +Final integration should retain explicit fixtures for raw-other-owner activation +without Jimmy movement, AI-null freeze, named-Jimmy CAM/MCA cleanup while already +raw-null, DeactivateInv default/explicit0, failed equip/display separation and +companion restore restrictions. Primary owns those runtime additions and the +complete suite, actual SDL/GPU input/readback, builds and release evidence. diff --git a/docs/gameplay/invisible.md b/docs/gameplay/invisible.md new file mode 100644 index 0000000..522ea5a --- /dev/null +++ b/docs/gameplay/invisible.md @@ -0,0 +1,172 @@ +# Invisible gadget source contract + +2026-11-01. Original item2/raw mode2. This report records static recovery and +bounded source projections; it does not claim original gameplay execution, port +integration or native platform verification. Original files were read only. + +## Evidence and addresses + +EXE SHA256 is `f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`. +`tools/binary/invisible.py ../Original` guards seven complete bounded spans, +50 decisive instruction slices, eight virtual bindings and six constants. Its +`artifacts/invisible/source-contract.json` records preferred VAs, PE-mapped file +offsets, bytes and hashes. All code addresses below map to file offset VA−400000; +the helper computes rather than assumes that mapping. Main source callers and +state fields are distinct from the display item index documented in +[gadget-controls.md](gadget-controls.md). + +REA/Ghidra12.1.4 inspected a generated hashed EXE copy. Complete replies, +Evidence export and closed-session snapshot are retained in +`artifacts/invisible/rea-invisible-ipc/`: + +| Procedure | REA Evidence | +| --- | --- | +|40E4A0 linked-model alpha/material setter|`ev_615030aa60b2346083853c40aa719ebc466e9f393fd870ea9722536a4f64cfac`| +|409CC0 generic enemy target predicate|`ev_1c4fe58878638158ea6f33db1474848910256873c00f266968debbf2ea35bf3f`| +|4037F0 meter size setter|`ev_525ca303ce70c16f524063053ebdd9fecd82054cf480d8f2f30f1ec0d7e08333`| + +424E80 and427FF0 entry queries were unrecognized and returned input/mapping +errors; no pseudocode is attributed to them. Their bounded instructions, vtable +targets, branches and exact source identity supply the contracts below. The +earlier default-sandbox batch (`rea-update/`) failed Ghidra's Unix-socket bind; +its diagnostics and closed snapshot are retained, and `doctor.json` records the +diagnostic follow-up. Local IPC permission fixed that host restriction without +changing REA/client configuration or executing the target. Both sessions closed. + +## State owners and update order — recovered + +Jimmy complete-object vtable4A3BDC has1C8→424E80,178→427FF0, +FC→40DD40(indexed material blend) and114→40E4A0(all linked materials alpha). +Global signed WORD4F0588 is equipped mode. Menu display2 is separate. + +| Jimmy complete field | Meaning established by this path | +| --- | --- | +|1E1C float|Remaining Invisible duration; constructor/equip zero, activation7| +|1E20 float|Recharge; constructor/equip/activation zero, ready exactly7| +|55D byte (=game-interface49D)|AI target visibility/eligibility flag; false while effect active| +|9F8 byte (=game-interface938)|Energy override; constructor false, PostLoad true for VR01..08| +|A18 pointer|Menu/UI owner| +|A1C pointer|Goddard/companion owner| + +Jimmy game-interface frame424600 calls base movement437940 at424C34, then +complete slot1C8 at424C3F, then later complete1B4/1B0. Thus Invisible is a Jimmy +wrapper phase after movement, distinct from the controlled-input callback and +the ordinary ray's input phase. Existing full registry/fixed-step approximation +remains separate. + +At424E80 a null controlled pointer5099E4 hides both meter sprites and returns, +freezing Invisible timers. Any nonnull controlled pointer passes; the leaf does +not compare it with Jimmy's identity. Mode!=2 then returns. Mode2 shows both +meter sprites before the remaining activation/timer branches. Menu modal/frame +eligibility can stop the enclosing frame before this leaf; do not treat this +as proof all menu/audio clocks follow this routine. + +## Equip and activation — recovered + +Selecting item2 reaches428E51 after the menu caller's close/old-gadget cleanup. +The display-selection callback already ran at428D97. With energy<=0 and9F8 false, +the branch writes raw mode−1 and skips companion/timer/target-flag/meter setup. +It still reaches Practice-state handling and may load VR03. Do not restore the +old special mode or normalize display2 into raw2 after a rejected equip. + +With energy>0 or9F8 true, equip hides Goddard immediately through complete58(1), +sets Goddard gameD0(0) and214(false), writes raw mode2, zeroes both timers, sets +Jimmy55D=true and colors/shows the meter red. Goddard stays hidden for the entire +equipped mode, including recharge; this is not a shared fade with Jimmy. + +Activation in424EBA..424F68 requires primary helper42A7A0 true and jump helper +42A730 false. If global4F8182 is true on that branch, the function returns before +either timer advances. Suppression does not freeze a call with primary false or +jump true. Otherwise activation requires remaining exactly0, recharge bits +exactly float7, and energy **strictly>2** or9F8 true. Failed energy at this ready +branch returns. Held primary has no separate edge latch here and can activate +again after another completed recharge. + +Success calls42A920 with fixed delta−2, sets remaining7, writes indexed material0 +blend6/1, applies alpha0.7 to all linked Jimmy materials, clears target flag55D +and resets recharge0. The same invocation then decrements remaining bydt. There +is no continuous Invisible energy drain, invented fire cooldown or activation +sound in this leaf. Shared42A920 may emit its own energy warnings; primary owns +that lifecycle. Ordinary jumps are allowed: mode2 is accepted in42A759; no +Invisible-specific pose, new model or forced grounded requirement appears here. + +## Timers, meter and material — recovered + +After activation attempt, only remaining==0 and(energy>0 or9F8) grows recharge +bydt. The meter receives recharge×stored-float(1/7)×100. At recharge>=7 the fill +is colored white, then recharge is clamped to exactly7. Reaching ready during +this call permits activation on the **next** invocation. + +Independently, remaining>0 subtractsdt, writes meter percentage +max(remaining×stored-float(1/7)×100,0), then expires at remaining<=0. Expiry sets +remaining0, indexed blend6/7, alpha-reset argument0, target flagtrue and red meter. +It does not grow recharge in that call; recharge resumes on the next invocation. +If remaining is still positive and<=3, trunc(remaining×5)%2 selects indexed +material0 dest7 when odd, dest1 when even; source factor remains6. This is a +blend flash, not alpha on/off, uniform transparency ramp or mesh hiding. + +40DD40(index,source,destination) writes the indexed material30/34 fields. +40E4A0(alpha>0) walks the linked model57C material array88..8C, writes diffuse +RGBA(1,1,1,alpha), enables blend flag38 bit0 and selects source6/dest1 when graphics +flag509A13 is false, dest7 when true. For alpha<=0 it clears the blend bit, restores +RGBA1 and6/7. Therefore expiry/cleanup mean opaque alpha1, not invisible alpha0. +6/1 is SrcAlpha/One additive,6/7 SrcAlpha/InvSrcAlpha conventional alpha per +[gadget-blending.md](gadget-blending.md). The graphics-option predicate remains +unclosed. An upright current-Jimmy renderer can use the existing material variants; +do not claim complete original material/LOD/depth-state equivalence. + +Menu48D414 binds484→4036C0(show both),488→403700(hide both), +48C→403730(red fill(1,.2,.2,1), show),490→4037A0(white fill). +4037F0 sets fill width27×(windowWidth/640), height +max(percent,0)×1.04×(windowHeight/480). Source meter sprite pointers are +4F7CB0/4F8028. [Follow-up asset report](gadget-followup-assets.md) owns exact +Canv21/22 bindings/layout and modern uniform-widescreen adaptation. Arithmetic +uses x87 intermediates and float stores; exhaustive boundary equivalence is not +claimed by the Python projection. + +## Cleanup, control and AI consumers — recovered boundaries + +427FF0 dispatches the mode table428844; entry2 reaches42810C. It writes material0 +blend6/7, remaining7 (not0), target flagtrue, recharge0 and hides both meter sprites. +If Goddard exists and its complete9E8 flag is false, it shows Goddard and re-enables +gameD0/214. It resets Jimmy alpha through114(0) and raw mode−1. Selecting Invisible +again resets both timers0. Source constructor4227BE/C7 also starts both0. + +CAM and initial MCA can explicitly clean inventions. CAM constructor415C09/D5 +defaults DeactivateInv to1 at complete9C0; property415F74 binds game-interface8F8 +(interface offsetC8 proven415A60). Activation4165B7 checks the field before JIM1 +lookup/cleanup178. MCA constructor430AA0 defaults completeEB8=1; property430D82 +binds interfaceDF0 (offsetC8 at430930), activation43129A/CC checks then cleans. +Both use exact string `DeactivateInv` at4EDF10. Omitted GAM property therefore +keeps defaulttrue; an explicit0 can suppress that prelude. Ordered raw-owner438 +preparation also calls cleanup178 at42AE14. AI-null40C4AD..527 calls410, STOP/ +sound148 and clears raw control, but that inspected block does **not** call438/ +178. Do not blanket-cancel Invisible on every control loss: timers can freeze +with the effect retained while raw control is null. Reset/ordinary-load behavior +must respect proven Init/PostLoad and callback boundaries, not one broad reset. + +Generic enemy reads target game-interface49D at40847C,408788,4087FC to gate +chase/acquisition/lost-target branches. REA409CC0 confirms a target pointer is +required and the eligibility test permits49D=true **or** positive enemy934; +Invisible is not proof universal enemy immunity. Later enemy modes/reaction +consumers, attacks already underway and class-specific overrides remain open. +The port can retain the flag and report its state without claiming enemies avoid +Jimmy until the corresponding AI consumers are implemented. + +## Verification and recommended bounded implementation + +Nine deterministic Python groups pass in `artifacts/invisible/tests.log`: +source identity/spans/sites/vtables/constants, equip/activation threshold split, +first recharge/next-call activation, fixed cost/same-call decrement, jump and +suppressor/control gates, zero-energy clocks, blend flash/exact-zero expiry, +cleanup and source graphics branch. These are independently transcribed static +projections, not original execution or modern runtime verification. + +Implement mode2 in the existing post-movement Jimmy wrapper phase with separate +raw-any-control and Jimmy-input ownership. Preserve exact timers/strict gates, +original material/meter resources, Goddard hide/restore and evidence-backed +cleanup points. Verify initial recharge, held activation, ordinary jump, last3s +blend flash, expiry/recharge, low-energy rejection, VR exemption, modal pause, +explicit/implicit cutscene cleanup and AI-null freeze. Keep full enemy AI, +original graphics-option choice, exact scheduler/x87 boundaries and native +Windows/original whole-game comparison explicitly unresolved. diff --git a/docs/gameplay/player-energy.md b/docs/gameplay/player-energy.md new file mode 100644 index 0000000..4cf8c3c --- /dev/null +++ b/docs/gameplay/player-energy.md @@ -0,0 +1,65 @@ +# Shared player energy and warning sounds + +2026-11-01. Static recovery reuses the complete local REA/Ghidra12.1.4 record +`artifacts/shrink-ray/rea-primary-followup/04.json`, Evidence +`ev_71897af12f4bfa1de946c6f17f3bbed34764fdc84258ce64516c8f1f904b465d`. +Its exported bundle and closed snapshot remain beside it. No duplicate analysis +session or original execution was needed. Supplementary instruction cross-checks +are in `artifacts/gadget-followup/energy.instructions.txt`. + +`tools/binary/player_energy.py ../Original` checks the full original EXE hash, +the complete42A920..42AA13 body, ten decisive sites and four constants. Output +`artifacts/gadget-followup/energy-source.json` records PE-mapped file offsets +for all preferred VAs below. Original EXE SHA256: +`f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8`. +For these .text locations, mapped file offset is VA−400000. + +## Recovered state and order + +Global float4F83D4 is the player energy scalar; byte4F83DC is a separate low-warning +latch. Jimmy constructor42217E clearsEBX,422980 writesBL to the latch. Existing +retained-loader evidence shows ordinary loads reuse Jimmy without repeating his +constructor. TSK stores PlayerValue, not this latch; direct scalar load is distinct +from calling the adjustment helper. Full new-game/load UI ownership remains open. + +42A92B..42A93D compares the current game's FourCC against numericVR01..VR08 and +returns for those tutorials without changing scalar, latch or playing sounds. +Otherwise: + +1. When old energy>0 and the requested sum<=0,42A967..42A972 requests SFX80 before + the scalar changes. Staying at zero is not another crossing. +2.42A975 reloads the live scalar, adds the delta and stores float32. The upper100 + comparison uses the still-live x87 sum. Above100 clamps100, clears the latch + and returns (42A985..42A9A3). +3. Negative stored energy clamps0. Stored energy<19 emits SFX182 once if the latch + is false, then sets it true (42A9C3..42A9F7). The scalar is already published + when that sound is requested; the latch is written afterward. +4. Values19..20 inclusive preserve the latch; strictly>20 clears it + (42A9F8..42AA12). A direct assignment/refill is not itself this helper call. + +The shared consumers include ordinary ray426F5A (−dt), powered-fire421FB0's active +phase (−dt×.5), Invisible424F26 (fixed−2 on activation), and Bubble42627C +(−dt×.5; Bubble runtime remains pending). Tutorial immunity does not bypass the +individual caller's activation gate; Jimmy PostLoad independently sets its9F8 +energy-override field for VR01..08. + +## Current implementation and verification boundaries + +`PlayerEnergy` owns scalar and warning latch. Main retains one instance across +ordinary scene rebuilds; LabSimulation delegates scalar access and adjustments to +it. Warning callbacks run in source write order and feed SceneAudio's existing +SFX bank/gate. The ray and positive jetpack-effect phase now call this owner; +Invisible spends2 through the same path. The independent JetpackBurst pure helper +continues to expose its numeric projection for algorithm tests. + +Modern doubles preserve the relevant two-float sum before stores; exhaustive x87 +rounding/control-word equivalence is not claimed. Nonfinite input is rejected. +Saved scalar assignment and modern debug refill do not infer a warning reset. +The modern debug checkpoint/load interface is not an original full save UI. + +Managed tests cover strict19/20 boundaries, one-shot warning episodes, crossing +sound before scalar/low sound after scalar, clamp, tutorial bypass and shared +ordinary-load ownership. Source tests guard constructor, both new callsites, +body/constants and offsets. They are port/static checks, separate from listening +to the original whole game or native Windows verification. Whole energy/damage/ +pickup consumers, soundbank timing and exact original scheduler remain open. diff --git a/docs/progress.md b/docs/progress.md index dd6dc8b..0065bb4 100644 --- a/docs/progress.md +++ b/docs/progress.md @@ -1,4 +1,40 @@ -# Progress — 2026-10-27 +# Progress — 2026-11-02 + +## Invisible and shared energy continuation + +Implemented original item2/raw mode2: initial7-second recharge, fixed2-energy +activation,7-second active timer, original alpha.7/last3-second blend flash, +original Canv21/22 meter, companion hide/body flags and source cleanup. Enter/ +Ctrl/left mouse activates after recharge without jump. F1→Player grants/selects +Invisible, unequips it and shows remaining/recharge/targetability diagnostics. +Raw-null control freezes its timers; named-Jimmy CAM/MCA DeactivateInv cleanup +is independent from raw-owner preparation. Full enemy sensing remains unported. + +PlayerEnergy now retains the shared scalar/warning latch across ordinary loads; +ray, active jetpack and Invisible adjustments use original empty80/low182 sounds +with strict19/20 hysteresis and source callback order. The existing complete +42A920 REA record is reused; new independent REA reports cover Invisible, +material/AI dependencies, meter art/UV/rendering and Bubble's next-step contract. +All investigators have returned file ownership; original files remain read only. + +Fifteen managed Invisible/energy groups pass, including binding/control/companion +and widescreen meter checks.182 Python checks and independent review pass. Native +GTX1070/private Xvfb at1920×1080 passes real SDL Ctrl/Tab through all six rendered +phases, zero enabled Vulkan validation errors; headless matches. This explicit +fixture advances836 extra normal player ticks, not an original-cadence capture. +Six-phase readbacks were inspected. Complete scripts/test.sh passes182 Python+2 +HUD checks, all managed suites,30 main GPU completions and17 isolated Vulkan +material checks with zero enabled validation errors. SDL dummy lifecycle and all +539 original hashes pass. Log: integration.log. Clean package/standalone release +results will be recorded after the verified source milestone. +Logs: artifacts/gadget-followup/; reports: gameplay/invisible-implementation.md, +invisible.md, player-energy.md, gadget-followup-assets.md and invisible-review.md. + +Bubble evidence now records original Canv1 effect, equip/cleanup, controlled +energy drain and movementmode2/radius/factor changes. Runtime waits for that +mode's full movement/jump/body contract. Other gadgets/full enemy AI, global +suppression lifecycle, graphics-option/depth state, cached canvas alignment, +original runtime and native Windows verification remain open. ## Gameplay gadgets — user-directed continuation diff --git a/docs/reverse-engineering.md b/docs/reverse-engineering.md index 4a0e368..ff23973 100644 --- a/docs/reverse-engineering.md +++ b/docs/reverse-engineering.md @@ -5,6 +5,13 @@ offsets, virtual addresses, API symbols or observed behavior. Decompiled output evidence, not original source. Original gameplay has not yet been observed successfully; isolated original DLL probes and modern runtime checks are recorded separately. +- `gameplay/invisible.md`, `invisible-implementation.md`, `invisible-review.md`: + timed mode2/targetability/material state, named-Jimmy versus raw-owner cleanup, + bounded implementation and independent review. `gadget-followup-assets.md` + records original meter/tutorial resources, UV stretch and alignment uncertainty; + `player-energy.md` reuses42A920 REA for warning-latch/callback order. + `bubble.md` records the next gadget's physics/visual/drain contracts and gates. + - `gameplay/gadgets-implementation.md`: first playable gadget scope and evidence map. `gadget-controls.md`/`gadget-assets.md` retain original group0 state, menu rectangles and54 canvases. `shrink-ray.md` traces input/ownership/energy/target diff --git a/docs/tasks.md b/docs/tasks.md index 42a12cd..4458fad 100644 --- a/docs/tasks.md +++ b/docs/tasks.md @@ -65,8 +65,15 @@ the resume backlog, not prerequisites imposed on this user-directed gadget work. - [x] Managed/source/GPU checks and native Linux menu/ray input fixtures. - [x] Rebuild clean7b5230c Linux/Windows gadget packages, verify54 canvases/new manifests in both, and run standalone Linux menu/ray fixtures from /tmp. -- [ ] Other special gadget effects and equip cleanup, energy-warning audio, - enemy AI/reaction consumers and original/native Windows comparison. +- [x] Invisible source, timed activation/recharge/flash, original meter, companion + body/visibility and named-Jimmy cutscene cleanup; shared energy warning lifecycle. +- [x] Independent review,182 Python/15 Invisible managed groups, native Linux SDL + six-phase render at1920×1080; complete integration30 GPU+17 material checks pass. +- [ ] Build clean Invisible Linux/Windows packages and verify standalone resources. +- [x] Recover Bubble visual/equip/drain/cleanup source contracts with REA/guards. +- [ ] Close Bubble movementmode2/jump/body contract, then implement original sprite + effect and physics in a bounded tutorial. Other effects/full enemy AI and + original/native Windows comparison remain independent backlog. Details: [first gadget slice](gameplay/gadgets-implementation.md). Investigators have returned all file ownership to primary. Complete final regression, native diff --git a/scripts/package.sh b/scripts/package.sh index 3fc45e8..a906a66 100755 --- a/scripts/package.sh +++ b/scripts/package.sh @@ -15,6 +15,8 @@ for rid in linux-x64 win-x64; do cp -a artifacts/extracted/ui/. "$out/scenes/ui/" mkdir -p "$out/scenes/gadgets" cp -a artifacts/extracted/gadgets/. "$out/scenes/gadgets/" + mkdir -p "$out/scenes/invisible-meter" + cp -a artifacts/extracted/invisible-meter/. "$out/scenes/invisible-meter/" mkdir -p "$out/scenes/effects" cp -a artifacts/extracted/effects/. "$out/scenes/effects/" cp artifacts/extracted/scene-catalog.json "$out/scenes/scene-catalog.json" @@ -70,6 +72,11 @@ Practice Mode plus an owned gadget opens its tutorial. The combined shrink-ray/ jetpack pickup fires on Enter/Ctrl/left mouse and bursts on jump. Original Yokian soldiers support the shrink morph,30-second restoration and10-point reward. Other gadget effects and full enemy AI/combat remain incomplete. +Invisible is now implemented: select its owned tile, wait7 seconds to recharge, +then fire without jump for a7-second effect costing2 energy (tutorials exempt). +F1/Player can Give/Select Invisible, Unequip, and show its timers/targetability. +The original meter and final3-second flashing are included; enemy sensing remains +incomplete. Source warning sounds for low/empty energy are shared by gadgets. Append --inspect to start directly in the old scene inspector. The default runs the recovered lab camera/speech sequence; Escape/Space skips its actions and restores control. --skip-intro starts with control; --mute disables diff --git a/scripts/test.sh b/scripts/test.sh index 184cf0a..aab4442 100755 --- a/scripts/test.sh +++ b/scripts/test.sh @@ -13,6 +13,7 @@ dotnet run --project tests/GamePort.SphereResponseTests dotnet run --project tests/GamePort.StaticCollisionTests dotnet run --project tests/GamePort.BodyPhysicsTests dotnet run --project tests/GamePort.GadgetTests +dotnet run --project tests/GamePort.InvisibleTests dotnet run --project tests/GamePort.HeadingTests dotnet run --project tests/GamePort.BlendTests dotnet run --project tests/GamePort.CameraRayTests @@ -53,6 +54,7 @@ dotnet run --no-build -- --headless --smoke-objective-panel --story-time 1 --scr dotnet run --no-build -- --headless --smoke-objective-panel --story-time 9 --screenshot artifacts/test-objective-hidden.ppm dotnet run --no-build -- --headless --scene artifacts/extracted/VR04/scene.json --level gam/VR04.gam --smoke-jetpack --screenshot artifacts/test-jetpack.ppm dotnet run --no-build -- --headless --scene artifacts/extracted/VR04/scene.json --level gam/VR04.gam --smoke-shrink-ray --screenshot artifacts/test-shrink-ray.ppm +dotnet run --no-build -- --headless --scene artifacts/extracted/VR03/scene.json --level gam/VR03.gam --smoke-invisible --screenshot artifacts/test-invisible.ppm dotnet run --no-build -- --headless --skip-intro --write-save artifacts/test-checkpoint.tsk dotnet run --no-build -- --headless --load-save artifacts/test-checkpoint.tsk --skip-intro dotnet run --no-build -- --headless --story --scene artifacts/extracted/VR01/scene.json --level gam/VR01.gam --smoke-transition --skip-intro @@ -69,6 +71,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 python3 tools/recon/inventory.py ../Original --verify docs/original-manifest.json if [[ "${NEUTRON_WINDOW_TEST:-0}" == 1 ]]; then + dotnet run --no-build -- --scene artifacts/extracted/VR03/scene.json --level gam/VR03.gam --smoke-invisible --width 1920 --height 1080 --screenshot artifacts/test-invisible-window.ppm dotnet run --no-build -- --smoke-gadget-menu --width 1920 --height 1080 --screenshot artifacts/test-gadget-menu-window.ppm dotnet run --no-build -- --scene artifacts/extracted/VR04/scene.json --level gam/VR04.gam --smoke-shrink-ray --screenshot artifacts/test-shrink-ray-window.ppm dotnet run --no-build -- --smoke-debug-tools diff --git a/src/GamePort/Application/DebugMenu.cs b/src/GamePort/Application/DebugMenu.cs index 9c95dfa..42f500d 100644 --- a/src/GamePort/Application/DebugMenu.cs +++ b/src/GamePort/Application/DebugMenu.cs @@ -7,7 +7,8 @@ namespace GamePort.Application; public sealed record DebugScene(string LevelFile, string Code, string[] Starts); public enum DebugAction { None, Resume, Camera, SkipCutscene, RefillEnergy, GiveJetpack, ApplySceneTask, LoadScene, Reset, ForceControl, ToggleOverlay, Noclip, NoclipSpeed, StopMotion, ShowObjective, ReturnNoclipEntry, LevelAvailability, InputOrder, ApplyJetpackState, - CameraObstruction, MuteMusic, MuteSpeech, MuteEffects, RestartMusic, StopEffects, SaveCheckpoint, LoadCheckpoint, Practice } + CameraObstruction, MuteMusic, MuteSpeech, MuteEffects, RestartMusic, StopEffects, SaveCheckpoint, LoadCheckpoint, Practice, + GiveInvisible, UnequipGadget } public sealed record DebugMenuView(string[] Lines, int SelectedLine); public sealed record DebugStatus(string Level, string Start, Vector3 Root, float Yaw, float Speed, bool Grounded, float Energy, int Score, int SceneTask, string Cutscene, bool Controlled, @@ -25,6 +26,9 @@ public sealed record DebugSystems public float JumpHold { get; init; } public float BurnRemaining { get; init; } public int JetpackAvailability { get; init; } + public float InvisibleRemaining { get; init; } + public float InvisibleRecharge { get; init; } + public bool Targetable { get; init; } = true; public int Objective { get; init; } public float ObjectiveTime { get; init; } public bool? CameraObstruction { get; init; } @@ -48,7 +52,7 @@ public sealed class DebugMenu public const int ItemCount = 12; public const int PageCount = 3; public int Page { get; private set; } - public int PageItems => Page switch { 1 => 10, 2 => 9, _ => ItemCount }; + public int PageItems => Page switch { 1 => 12, 2 => 9, _ => ItemCount }; private static readonly float[] FlySpeeds = [300, 600, 1200, 2400]; private int flySpeedIndex = 1, jetpackStateIndex = 1; private static readonly int[] JetpackStates = [0, 1, 4]; @@ -110,7 +114,8 @@ public sealed class DebugMenu 0 => DebugAction.Noclip, 1 => DebugAction.NoclipSpeed, 2 => DebugAction.StopMotion, 3 => DebugAction.ShowObjective, 4 => DebugAction.ReturnNoclipEntry, 5 => DebugAction.LevelAvailability, 6 => DebugAction.InputOrder, - 8 => DebugAction.ApplyJetpackState, 9 => DebugAction.RefillEnergy, _ => DebugAction.None + 8 => DebugAction.ApplyJetpackState, 9 => DebugAction.RefillEnergy, + 10 => DebugAction.GiveInvisible, 11 => DebugAction.UnequipGadget, _ => DebugAction.None }; if (Page == 2) return Selected switch { @@ -147,13 +152,15 @@ public sealed class DebugMenu Page == 1 ? $"PENDING {V(system.PendingImpulse)}" : $"AUDIO BYTES MUSIC {system.MusicBytes} VOICE {system.SpeechBytes}", Page == 1 ? $"JUMP {system.JumpState} HOLD {F(system.JumpHold)} BURN {F(system.BurnRemaining)}" : $"EFFECT BYTES {system.EffectBytes} AUDIO AVAILABLE {system.AudioAvailable}", - $"OBJECTIVE {system.Objective} TIME {F(system.ObjectiveTime)} GADGET STATE {system.JetpackAvailability}", ""]; + $"OBJECTIVE {system.Objective} TIME {F(system.ObjectiveTime)} GADGET STATE {system.JetpackAvailability}", + $"INVISIBLE {F(system.InvisibleRemaining)} RECHARGE {F(system.InvisibleRecharge)}/7 TARGETABLE {system.Targetable}", ""]; string[] items = Page == 1 ? [ $"NOCLIP (F3): {system.Noclip} (ENTER TOGGLE)", $"FLY SPEED: {F(FlySpeed)} LIVE {F(system.NoclipSpeed)} (ENTER APPLIES)", "STOP MOTION / CLEAR QUEUED JUMP", "SHOW CURRENT OBJECTIVE", "RETURN TO NOCLIP ENTRY POSITION", "APPLY THIS LEVEL'S GADGET AVAILABILITY", $"INPUT AFTER PLAYER: {system.InputAfterPlayer} (TOGGLE)", - $"JET PACK STATE: {JetpackState} (0 NONE / 1 OWNED / 4 DISABLED)", "APPLY JET PACK STATE", "REFILL ENERGY TO 100"] : [ + $"JET PACK STATE: {JetpackState} (0 NONE / 1 OWNED / 4 DISABLED)", "APPLY JET PACK STATE", "REFILL ENERGY TO 100", + "GIVE / SELECT INVISIBLE", "UNEQUIP CURRENT GADGET"] : [ $"STATIC CAMERA OBSTRUCTION: {(system.CameraObstruction?.ToString() ?? "UNAVAILABLE")}", $"MUTE MUSIC: {system.MusicMuted}", $"MUTE SPEECH: {system.SpeechMuted}", $"MUTE EFFECTS: {system.EffectsMuted}", "RESTART SELECTED MUSIC", "STOP ALL EFFECTS / LOOPS", "SAVE DEBUG CHECKPOINT", "LOAD DEBUG CHECKPOINT", "SHOW JET PACK PRACTICE PROMPT"]; diff --git a/src/GamePort/Application/InvisibleMeterOverlay.cs b/src/GamePort/Application/InvisibleMeterOverlay.cs new file mode 100644 index 0000000..9fad5bc --- /dev/null +++ b/src/GamePort/Application/InvisibleMeterOverlay.cs @@ -0,0 +1,71 @@ +using System.Numerics; +using System.Text.Json; +using GamePort.Assets; +using GamePort.Game; + +namespace GamePort.Application; + +/// Original Canv21/22 meter. Source size/tint/full-image stretch with +/// a declared logical rectangle conversion and uniform centered widescreen UI. +public sealed class InvisibleMeterOverlay +{ + private readonly int offset; + private readonly uint firstIndex; + public Mesh Mesh { get; } + + public InvisibleMeterOverlay(Mesh combined, string manifest) + { + var full = Path.GetFullPath(manifest); + var directory = Path.GetDirectoryName(full)!; + if (new FileInfo(full).Length > 16 * 1024) throw new InvalidDataException("Meter manifest exceeds limit"); + using var document = JsonDocument.Parse(File.ReadAllBytes(full), new JsonDocumentOptions {MaxDepth=10}); + var root = document.RootElement; + if (root.GetProperty("schema").GetInt32() != 1 || root.GetProperty("referenceWidth").GetInt32() != 640 + || root.GetProperty("referenceHeight").GetInt32() != 480 || root.GetProperty("textures").GetArrayLength() != 2) + throw new InvalidDataException("Unsupported Invisible meter format"); + offset = combined.Vertices.Length; firstIndex = (uint)combined.Indices.Length; + var vertices = combined.Vertices.ToList(); var indices = combined.Indices.ToList(); + var draws = combined.Draws.ToList(); var textures = new Dictionary(combined.Textures); + if (!combined.HasExplicitDraws && indices.Count != 0) draws.Add(new(0,(uint)indices.Count,-1)); + var seen = new HashSet(); + foreach (var entry in root.GetProperty("textures").EnumerateArray().OrderBy(e=>e.GetProperty("id").GetInt32())) + { + var id = entry.GetProperty("id").GetInt32(); + if (id is not (21 or 22) || !seen.Add(id) || entry.GetProperty("width").GetInt32()!=30 + || entry.GetProperty("height").GetInt32()!=110) throw new InvalidDataException("Invalid source meter canvas"); + var path = Path.GetFullPath(Path.Combine(directory,entry.GetProperty("path").GetString()!)); + if (!path.StartsWith(directory+Path.DirectorySeparatorChar,StringComparison.Ordinal) + || new FileInfo(path).Length != 30*110*4) throw new InvalidDataException("Invalid meter pixel path/length"); + var textureId = int.MinValue+15000; while(textures.ContainsKey(textureId))textureId++; + textures.Add(textureId,new(30,110,File.ReadAllBytes(path))); + var first = (uint)vertices.Count; + vertices.AddRange([new(Vector3.Zero,new(0,0),Vector3.One),new(Vector3.Zero,new(.9999f,0),Vector3.One), + new(Vector3.Zero,new(.9999f,.9999f),Vector3.One),new(Vector3.Zero,new(0,.9999f),Vector3.One)]); + indices.AddRange([first,first+1,first+2,first,first+2,first+3]); + draws.Add(new((uint)indices.Count-6,6,textureId){ScreenSpace=true,Visible=false}); + } + Mesh = new(vertices.ToArray(),indices.ToArray()) {HasExplicitDraws=true,Draws=draws.ToArray(),Textures=textures, + CollisionPolygons=combined.CollisionPolygons,HasCollisionMaterialIds=combined.HasCollisionMaterialIds}; + } + + public void Update(Mesh destination, InvisibleGadget device, uint width, uint height) + { + var viewport = new UiViewport(width,height); + var visible = device.Equipped && device.MeterVisible; + var color = device.MeterReady ? Vector3.One : new Vector3(1,.2f,.2f); + var fillHeight = (float)(Math.Max(device.MeterPercent,0)*1.04); + Quad(0,new(320,7),new(30,110),Vector3.One); + Quad(1,new(322,114-fillHeight),new(27,fillHeight),color); + void Quad(int index, Vector2 position, Vector2 size, Vector3 tint) + { + destination.Draws.First(d=>d.ScreenSpace&&d.FirstIndex==firstIndex+(uint)index*6).Visible=visible; + var p = position+viewport.CenterOffset; + var corners = new[] {p,p+new Vector2(size.X,0),p+size,p+new Vector2(0,size.Y)}; + for(var i=0;i<4;i++) + { + destination.Vertices[offset+index*4+i].Position=viewport.ToNdc(corners[i]); + destination.Vertices[offset+index*4+i].Color=tint; + } + } + } +} diff --git a/src/GamePort/Application/InvisibleSmoke.cs b/src/GamePort/Application/InvisibleSmoke.cs new file mode 100644 index 0000000..1372085 --- /dev/null +++ b/src/GamePort/Application/InvisibleSmoke.cs @@ -0,0 +1,67 @@ +using GamePort.Assets; +using GamePort.Game; + +namespace GamePort.Application; + +/// Accelerated port verification: full player ticks between six rendered +/// phases. No actor relocation or direct timer/material writes; not original cadence. +public sealed class InvisibleSmoke +{ + private readonly LabSimulation player; + private readonly SceneInventory inventory; + private readonly bool[] checks = new bool[6]; + private readonly float initialEnergy; + private int acceleratedTicks; + + public InvisibleSmoke(LabSimulation player, SceneInventory inventory) + { + this.player = player; this.inventory = inventory; initialEnergy = player.Energy; + inventory.SetState(0,2,1); inventory.SelectGadget(2); + if (player.GadgetMode != 2 || !player.Invisible.Equipped) + throw new InvalidOperationException("Invisible fixture requires a connected, eligible player binding"); + Advance(() => player.Invisible.Recharge == 7); + } + + public void BeforeFrame(int count, Action injectKey, bool headless) + { + if (count == 1 && !headless) injectKey(224,true); + if (count == 2 && !headless) injectKey(224,false); + if (count == 3) Advance(() => player.Invisible.Active && player.Invisible.Remaining <= 2.9f && player.Invisible.ConventionalBlend); + if (count == 4) Advance(() => player.Invisible.Active && !player.Invisible.ConventionalBlend); + if (count == 5) Advance(() => !player.Invisible.Active); + if (count == 6) + { + if (headless) inventory.SelectGadget(-1); + else injectKey(43,true); + } + if (count == 7 && !headless) injectKey(43,false); + } + + private void Advance(Func done) + { + for(var i=0;i<1000;i++) + { + if(done())return; + player.Step(default); acceleratedTicks++; + } + throw new InvalidOperationException("Invisible fixture did not reach the requested source phase"); + } + + public void AfterFrame(int count, MeshDraw material) + { + var device = player.Invisible; + if(count==0)checks[0]=device.Recharge==7 && device.Targetable && material.Opacity==1 && device.MeterReady; + if(count==1)checks[1]=device.Active && device.Activations==1 && device.Remaining>3 + && material.Opacity==.7f && material.Blend==MeshBlend.Additive + && player.Energy==(player.IgnoresGadgetEnergy ? initialEnergy : initialEnergy-2); + if(count==3)checks[2]=device.Active && material.Opacity==.7f && material.Blend==MeshBlend.Alpha; + if(count==4)checks[3]=device.Active && material.Blend==MeshBlend.Additive && device.Remaining<=3; + if(count==5)checks[4]=!device.Active && device.Targetable && material.Opacity==1 && material.Blend==MeshBlend.Opaque; + if(count==7)checks[5]=player.GadgetMode==-1 && !device.Equipped && !device.MeterVisible && device.Targetable; + } + + public bool Passed => checks.All(value=>value); + public string Report => $"Invisible fixture: charged={checks[0]}, activation={checks[1]}, alpha flash={checks[2]}, additive flash={checks[3]}, expiry={checks[4]}, unequip={checks[5]}, accelerated player ticks={acceleratedTicks}, energy={player.Energy:F3}."; + public static string? StageName(int count) => count switch + {0=>"charged",1=>"active",3=>"alpha",4=>"additive",5=>"expired",7=>"unequipped",_=>null}; +} diff --git a/src/GamePort/Application/PlayerGadgetMaterial.cs b/src/GamePort/Application/PlayerGadgetMaterial.cs new file mode 100644 index 0000000..0cbeaac --- /dev/null +++ b/src/GamePort/Application/PlayerGadgetMaterial.cs @@ -0,0 +1,16 @@ +using GamePort.Assets; +using GamePort.Game; + +namespace GamePort.Application; + +/// Current Jimmy atlas is one linked material. Source114 alpha and +/// indexed0 FC blend changes affect that draw without changing pose/visibility. +public static class PlayerGadgetMaterial +{ + public static void Apply(MeshDraw draw, InvisibleGadget invisible) + { + draw.Opacity = invisible.Opacity; + draw.Blend = !invisible.Active ? MeshBlend.Opaque + : invisible.ConventionalBlend ? MeshBlend.Alpha : MeshBlend.Additive; + } +} diff --git a/src/GamePort/Game/ActorPatrol.cs b/src/GamePort/Game/ActorPatrol.cs index 8fb4d3f..cb24ff5 100644 --- a/src/GamePort/Game/ActorPatrol.cs +++ b/src/GamePort/Game/ActorPatrol.cs @@ -90,7 +90,7 @@ public sealed class ActorPatrol if (!float.IsFinite(actor.Speed)) throw new InvalidOperationException("Nonfinite Goddard speed"); // EXE408023->40E050: the body consumes the *previous* velocity first. - var body = integrateBody(new(actor.Position, Velocity), dt); + var body = actor.BodyEnabled ? integrateBody(new(actor.Position, Velocity), dt) : new PatrolBodyState(actor.Position, Velocity); if (!Finite(body.Position) || !Finite(body.Velocity)) throw new InvalidOperationException("Goddard body solver produced nonfinite state"); actor.Position = body.Position; diff --git a/src/GamePort/Game/InvisibleGadget.cs b/src/GamePort/Game/InvisibleGadget.cs new file mode 100644 index 0000000..33bd0ed --- /dev/null +++ b/src/GamePort/Game/InvisibleGadget.cs @@ -0,0 +1,87 @@ +namespace GamePort.Game; + +/// Jimmy424E80 timed Invisible device; material state and source +/// targetable55D are distinct from raw control and authored visibility. +public sealed class InvisibleGadget +{ + public const float Duration = 7; + public bool Equipped { get; private set; } + public float Remaining { get; private set; } + public float Recharge { get; private set; } + public bool Targetable { get; private set; } = true; + public float Opacity { get; private set; } = 1; + public bool ConventionalBlend { get; private set; } + public bool MeterVisible { get; private set; } + public bool MeterReady { get; private set; } + public float MeterPercent { get; private set; } + public int Activations { get; private set; } + public bool Active => Equipped && !Targetable; + public event Action? EquippedChanged; + + public bool Equip(float energy, bool energyOverride) + { + if (!float.IsFinite(energy)) throw new ArgumentOutOfRangeException(nameof(energy)); + if (energy <= 0 && !energyOverride) return false; + Equipped = true; Remaining = Recharge = 0; Targetable = true; + Opacity = 1; ConventionalBlend = false; MeterReady = false; MeterVisible = true; + EquippedChanged?.Invoke(true); + return true; + } + + public void Release() + { + Equipped = false; Remaining = Duration; Recharge = 0; + Targetable = true; Opacity = 1; ConventionalBlend = false; + MeterVisible = false; MeterReady = false; + EquippedChanged?.Invoke(false); + } + + public void Reset() + { + Release(); Remaining = MeterPercent = 0; Activations = 0; + } + + public void Step(float seconds, bool anyControlled, bool primary, bool jump, + float energy, bool energyOverride, Action adjustEnergy, bool suppressed = false) + { + if (!float.IsFinite(seconds) || seconds < 0 || seconds >= 1) + throw new ArgumentOutOfRangeException(nameof(seconds)); + if (!float.IsFinite(energy)) throw new ArgumentOutOfRangeException(nameof(energy)); + ArgumentNullException.ThrowIfNull(adjustEnergy); + //Any controlled pointer, not necessarily Jimmy's identity. A NULL + //owner freezes timers and hides both meter sprites without cleanup. + if (!anyControlled) { MeterVisible = false; return; } + if (!Equipped) return; + MeterVisible = true; + if (primary && !jump) + { + if (suppressed) return; + if (Remaining == 0 && Recharge == Duration) + { + if (energy <= 2 && !energyOverride) return; + adjustEnergy(-2); + Remaining = Duration; Recharge = 0; Activations++; + ConventionalBlend = false; Opacity = .7f; Targetable = false; + } + } + if (Remaining == 0 && (energy > 0 || energyOverride)) + { + var sum = (double)Recharge + seconds; + Recharge = (float)sum; + MeterPercent = (float)(sum * (1f / 7) * 100); + if (Recharge >= Duration) { Recharge = Duration; MeterReady = true; } + } + if (Remaining <= 0) return; + var remaining = (double)Remaining - seconds; + Remaining = (float)remaining; + MeterPercent = (float)Math.Max(remaining * (1f / 7) * 100, 0); + if (Remaining <= 0) + { + Remaining = 0; Opacity = 1; Targetable = true; + ConventionalBlend = false; MeterReady = false; + return; + } + if (Remaining <= 3) + ConventionalBlend = ((int)((double)Remaining * 5) & 1) != 0; + } +} diff --git a/src/GamePort/Game/LabSimulation.cs b/src/GamePort/Game/LabSimulation.cs index 292e742..9acf9e9 100644 --- a/src/GamePort/Game/LabSimulation.cs +++ b/src/GamePort/Game/LabSimulation.cs @@ -19,6 +19,7 @@ public sealed class LabSimulation private readonly Func? cameraRay; private readonly Func? ceilingRay; private readonly OriginalBodyPhysics? originalBody; + private readonly PlayerEnergy energy; private readonly Vector3 sourceStart; private readonly float startYaw, modelMinimumY, rootHeight, startFloor; private float targetYaw, extraAirAcceleration, shadowDistance, lateralContribution; @@ -28,13 +29,28 @@ public sealed class LabSimulation private bool forceFall; private Vector3 noclipEntry; private float noclipEntryYaw; + private int gadgetMode = -1; public bool Noclip { get; private set; } public bool HasNoclipEntry { get; private set; } public float NoclipSpeed { get; set; } = 600; public Func? JetpackInventoryState { get; set; } public string LevelCode { get; set; } = "LV1B"; - public int GadgetMode { get; set; } = -1; - public float Energy { get; set; } = 20; + public InvisibleGadget Invisible { get; } = new(); + public int GadgetMode + { + get => gadgetMode; + set + { + if (gadgetMode == 2) Invisible.Release(); + gadgetMode = -1; + if (value == 2 && !Invisible.Equip(Energy, IgnoresGadgetEnergy)) return; + gadgetMode = value; + } + } + public bool IgnoresGadgetEnergy => PlayerEnergy.IsTutorial(LevelCode); + public float Energy { get => energy.Value; set => energy.Value = value; } + public bool LowEnergyWarning => energy.LowWarning; + public event Action? EnergySound; //Source260/live15C serves both body collision and contact tests. The name //predates source-body integration; burst100 is not an interaction-only size. public float InteractionRadius { get; private set; } = 60; @@ -84,12 +100,13 @@ public sealed class LabSimulation public LabSimulation(SceneCollision collision, Mesh standingPose, Vector3 start, float yaw, Func? cameraRay = null, Func? ceilingRay = null, - OriginalStaticCollision? originalCollision = null) + OriginalStaticCollision? originalCollision = null, PlayerEnergy? energy = null) { this.collision = collision; this.cameraRay = cameraRay; this.ceilingRay = ceilingRay; originalBody = originalCollision == null ? null : new OriginalBodyPhysics(originalCollision); + this.energy = energy ?? new PlayerEnergy(); sourceStart = start; startYaw = yaw; var bounds = standingPose.Bounds(); @@ -107,6 +124,8 @@ public sealed class LabSimulation public void Reset() { + if (gadgetMode == 2) gadgetMode = -1; + Invisible.Reset(); var floor = collision.GroundHeight(sourceStart, 2500)!.Value; Position = new(sourceStart.X, floor + (UsesOriginalBody ? 0 : SceneCollision.Skin), sourceStart.Z); Velocity = Vector3.Zero; @@ -162,7 +181,7 @@ public sealed class LabSimulation return ((float)Math.Sin(radians), (float)Math.Cos(radians)); } - public void Step(PlayerInput input, bool controlled = true) + public void Step(PlayerInput input, bool controlled = true, bool? anyControlled = null) { if (Noclip) { StepNoclip(input); return; } //47E554 global body integration precedes473740 registry callbacks. @@ -176,8 +195,11 @@ public sealed class LabSimulation //424BE0..424C34 runs this wrapper before437940's ownership gate. StepCeiling(); if (controlled) StepPlayer(input); + Invisible.Step(FixedStepClock.Step, anyControlled ?? controlled, input.Fire, input.Jump, + Energy, IgnoresGadgetEnergy, AdjustEnergy); var effect = JetpackBurst.StepEffect(jumpState, Grounded, FixedStepClock.Step, Energy, LevelCode); - jumpState = effect.State; Energy = effect.Energy; JetpackEffectVisible = effect.Visible; + jumpState = effect.State; JetpackEffectVisible = effect.Visible; + if (effect.Visible) AdjustEnergy(-FixedStepClock.Step * JetpackBurst.EnergyPerSecond); EffectSteps++; if (controlled && InputAfterPlayerUpdate) StepInput(input); Steps++; @@ -192,6 +214,7 @@ public sealed class LabSimulation public void StopForPrimaryFire() => Speed = 0; public void SetShooting(bool shooting) => Shooting = shooting; + public void AdjustEnergy(float delta) => energy.Adjust(delta, LevelCode, id => EnergySound?.Invoke(id)); private void StepCeiling() { diff --git a/src/GamePort/Game/PlayerEnergy.cs b/src/GamePort/Game/PlayerEnergy.cs new file mode 100644 index 0000000..6a9fe48 --- /dev/null +++ b/src/GamePort/Game/PlayerEnergy.cs @@ -0,0 +1,50 @@ +namespace GamePort.Game; + +/// 42A920 global energy and low-warning latch. Retained across ordinary +/// level loads; the original TSK stores the scalar, not this warning latch. +public sealed class PlayerEnergy +{ + private float value = 20; + public float Value + { + get => value; + set + { + if (!float.IsFinite(value)) throw new ArgumentOutOfRangeException(nameof(value)); + this.value = value; + } + } + public bool LowWarning { get; private set; } + + public void Adjust(float delta, string level, Action? sound = null) + { + if (!float.IsFinite(delta)) throw new ArgumentOutOfRangeException(nameof(delta)); + ArgumentNullException.ThrowIfNull(level); + if (IsTutorial(level)) return; + //The first x87 sum is compared before a float store. Sound80 precedes + //the write; the helper then reloads the live global for the actual add. + if (value > 0 && (double)value + delta <= 0) sound?.Invoke(80); + var sum = (double)value + delta; + value = (float)sum; + if (sum > 100) { value = 100; LowWarning = false; return; } + if (value < 0) value = 0; + if (value < 19) + { + if (!LowWarning) + { + sound?.Invoke(182); + LowWarning = true; + } + } + else if (value > 20) LowWarning = false; + } + + public static bool IsTutorial(string level) + { + ArgumentNullException.ThrowIfNull(level); + if (level.Length != 4) return false; + var code = ((uint)level[0] << 24) | ((uint)level[1] << 16) + | ((uint)level[2] << 8) | level[3]; + return code is >= 0x56523031 and <= 0x56523038; + } +} diff --git a/src/GamePort/Game/PlayerSceneBinding.cs b/src/GamePort/Game/PlayerSceneBinding.cs index 10fe990..ea20d17 100644 --- a/src/GamePort/Game/PlayerSceneBinding.cs +++ b/src/GamePort/Game/PlayerSceneBinding.cs @@ -17,14 +17,16 @@ public sealed class PlayerSceneBinding : IDisposable this.director = director; this.player = player; this.inventory = inventory; this.tag = tag; director.ActorPreparing += Prepare; director.AuthoredTransformChanged += Transform; + director.GadgetReleaseRequested += Release; inventory.GadgetSelected += Selected; + player.Invisible.EquippedChanged += InvisibleEquipped; Selected(inventory.SelectedGadget); } public bool Step(PlayerInput input) { var acceptsInput = director.Controlled || player.Noclip; - player.Step(input, acceptsInput); + player.Step(input, acceptsInput, director.ControlledTag != null); var rotation = director.FindActor(tag)?.Rotation ?? Vector3.Zero; director.SyncActor(tag, player.ActorRoot, rotation with { Y = player.Yaw }); return acceptsInput; @@ -35,17 +37,30 @@ public sealed class PlayerSceneBinding : IDisposable if (!string.Equals(actor.Tag, tag, StringComparison.OrdinalIgnoreCase)) return; if (action == ScriptPreparation.StopMotion) player.PrepareForScript(); else if (action == ScriptPreparation.ReleaseGadget) - { - //427FF0 has distinct cases. Only no-selection/jetpack cleanup is - //implemented; do not turn the other gadget cases into blanket resets. - if (inventory.SelectedGadget is -1 or 3) - { inventory.SelectGadget(-1); player.GadgetMode = -1; } - else UnsupportedGadgetCleanups++; - } + Release(actor); + } + + private void Release(DirectorActor actor) + { + if (!string.Equals(actor.Tag, tag, StringComparison.OrdinalIgnoreCase)) return; + //427FF0 switches raw mode, not display selection. A rejected Invisible + //equip can leave display2 with raw mode-1; cleanup does not equip it. + if (player.GadgetMode == 2 || inventory.SelectedGadget is -1 or 3) + { inventory.SelectGadget(-1); player.GadgetMode = -1; } + else if (player.GadgetMode != -1) UnsupportedGadgetCleanups++; } private void Selected(int item) => player.GadgetMode = GadgetScreen.EquippedMode(item); + private void InvisibleEquipped(bool equipped) + { + if (director.FindActor("C3DGODDARD") is not { } companion) return; + //427FF0 requires Goddard complete9E8==false before showing/enabling. + //These six PostLoad levels set that flag (retained-companion.md). + if (!equipped && player.LevelCode is "LEV6" or "LEV7" or "LV1C" or "LV1D" or "LV4A" or "LV6A") return; + companion.Visible = companion.MovementEnabled = companion.BodyEnabled = !equipped; + } + private void Transform(DirectorActor actor) { if (string.Equals(actor.Tag, tag, StringComparison.OrdinalIgnoreCase)) @@ -56,6 +71,8 @@ public sealed class PlayerSceneBinding : IDisposable { director.ActorPreparing -= Prepare; director.AuthoredTransformChanged -= Transform; + director.GadgetReleaseRequested -= Release; inventory.GadgetSelected -= Selected; + player.Invisible.EquippedChanged -= InvisibleEquipped; } } diff --git a/src/GamePort/Game/SceneDirector.cs b/src/GamePort/Game/SceneDirector.cs index 718fe35..2b090f0 100644 --- a/src/GamePort/Game/SceneDirector.cs +++ b/src/GamePort/Game/SceneDirector.cs @@ -14,6 +14,10 @@ public sealed class DirectorActor public Vector3 Rotation { get; internal set; } public bool Visible { get; internal set; } public bool Active { get; internal set; } + //Source body integration and movement-enable flags are separate from AI + //activation. Only the bounded companion gadget consumer writes them here. + public bool BodyEnabled { get; internal set; } = true; + public bool MovementEnabled { get; internal set; } = true; public string Animation { get; internal set; } = "STOP"; public int AIstate { get; internal set; } public float Speed { get; internal set; } @@ -93,6 +97,7 @@ public sealed class SceneDirector public event Action? MusicRestarted; public event Action? ActorChanged; public event Action? ActorPreparing; + public event Action? GadgetReleaseRequested; public event Action? AuthoredTransformChanged; public event Action? Unsupported; @@ -138,6 +143,7 @@ public sealed class SceneDirector var initial = new DirectorActor(source, actor.Tag, actor.Kind, source.Position); actor.Position = initial.Position; actor.Rotation = initial.Rotation; actor.Visible = initial.Visible; actor.Active = initial.Active; + actor.BodyEnabled = initial.BodyEnabled; actor.MovementEnabled = initial.MovementEnabled; actor.Animation = initial.Animation; actor.AIstate = initial.AIstate; actor.Speed = initial.Speed; actor.Patrol = initial.Patrol; actor.SpritePlaying = initial.SpritePlaying; actor.SpriteRevision++; @@ -336,6 +342,7 @@ public sealed class SceneDirector private void StartMulti(GamEntity entity) { + DeactivateInvention(entity); //43129A: explicit Jimmy lookup, before first target check. // MCA's PlayerControlled is its completion target (4311F0), not an // activation grant. Only initial activation clears control; later shots //use431750 without repeating431502..4315A7 preparation. @@ -353,11 +360,12 @@ public sealed class SceneDirector { if (applyCommon) { + DeactivateInvention(entity); //4165B7, distinct from raw-owner preparation. if (Equal(entity.Text("PlayerControlled"), "NULL")) PrepareOwner(ScriptPreparation.ReleaseGadget, ScriptPreparation.StopMotion, ScriptPreparation.FlattenOrientation); SetControl(entity); Toggle(entity); } - if (entity.Integer("DeactivateInv") != 0) InventoryEnabled = false; + if (entity.Integer("DeactivateInv", 1) != 0) InventoryEnabled = false; if (skipping) { if (index >= 0) FinishMulti(entity); @@ -512,6 +520,14 @@ public sealed class SceneDirector } } + private void DeactivateInvention(GamEntity source) + { + //Both CAM/MCA constructors default this property to true. The source + //explicitly looks up Jimmy even when a different actor owns control. + if (source.Integer("DeactivateInv", 1) != 0 && actors.TryGetValue("JIM1", out var jimmy)) + GadgetReleaseRequested?.Invoke(jimmy); + } + private void SetControl(GamEntity entity, bool prepareOwner = false) { var control = entity.Text("PlayerControlled"); diff --git a/src/GamePort/Game/SceneGadgets.cs b/src/GamePort/Game/SceneGadgets.cs index 85b872d..c3c538f 100644 --- a/src/GamePort/Game/SceneGadgets.cs +++ b/src/GamePort/Game/SceneGadgets.cs @@ -52,12 +52,11 @@ public sealed class SceneGadgets : IDisposable player.SetShooting(player.Grounded); if (!loop) { Sound?.Invoke(0,true); loop = true; } const float dt = FixedStepClock.Step; - if (!(player.LevelCode.Length == 4 && player.LevelCode.StartsWith("VR0",StringComparison.Ordinal) - && player.LevelCode[3] is >= '1' and <= '8')) player.Energy = Math.Clamp(player.Energy - dt,0,100); + player.AdjustEnergy(-dt); //Bridge modern signed float yaw to the source's nonnegative Euler domain. var yaw = (player.Yaw % 360 + 360) % 360; var hits = Ray.Fire(player.ActorRoot,yaw,dt, - Soldiers.Select(s => new ShrinkCandidate(s.Actor.Tag,s.Actor.Position,Shrunk:s.Shrunk)), + Soldiers.Select(s => new ShrinkCandidate(s.Actor.Tag,s.Actor.Position,BodyEnabled:s.Actor.BodyEnabled,Shrunk:s.Shrunk)), (start,end) => geometry.TraceGeometry(start,end)); foreach (var tag in hits) { diff --git a/src/GamePort/Program.cs b/src/GamePort/Program.cs index 592e141..2499124 100644 --- a/src/GamePort/Program.cs +++ b/src/GamePort/Program.cs @@ -20,9 +20,10 @@ internal static class Program PlayerLevelState? carriedPlayer = null; var returning = false; var diagnostics = new DebugDiagnostics { Enabled = args.Contains("--debug-overlay") }; + var energy = new PlayerEnergy(); while (true) { - var result = Run(args, carriedSave, carriedPlayer, returning, diagnostics, presentation, out var continuation); + var result = Run(args, carriedSave, carriedPlayer, returning, diagnostics, presentation, energy, out var continuation); if (result != 0 || continuation == null) return result; args = continuation.Args; carriedSave = continuation.Save; returning = continuation.Returning; carriedPlayer = continuation.Player; @@ -43,7 +44,7 @@ internal static class Program private sealed record SceneContinuation(string[] Args, OriginalSave Save, bool Returning, PlayerLevelState? Player); private static int Run(string[] args, OriginalSave? carriedSave, PlayerLevelState? carriedPlayer, bool returning, DebugDiagnostics diagnostics, - RenderSession presentation, out SceneContinuation? continuation) + RenderSession presentation, PlayerEnergy energy, out SceneContinuation? continuation) { continuation = null; if (args.Contains("--help")) @@ -86,6 +87,7 @@ internal static class Program --smoke-practice-window SDL practice pause/dismiss/resize check (12 frames) --smoke-jetpack 300-step powered steering/jump check in VR04 --smoke-shrink-ray Fire at an actual VR04 soldier; explicit player-placement fixture + --smoke-invisible Accelerated recharge/activation/flash/expiry/unequip fixture in VR03 --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-jump-key NAME Replay using shift/right-shift/insert/keypad0/right-mouse @@ -255,6 +257,7 @@ internal static class Program var walkSmoke = args.Contains("--smoke-walk"); var jetpackSmoke = args.Contains("--smoke-jetpack"); var shrinkSmoke = args.Contains("--smoke-shrink-ray"); + var invisibleSmoke = args.Contains("--smoke-invisible"); var carlSmoke = args.Contains("--smoke-carl-cutscene"); var controlPhaseSmoke = args.Contains("--smoke-control-phases"); var objectiveWindowSmoke = args.Contains("--smoke-objective-window"); @@ -275,7 +278,7 @@ internal static class Program var defaultStory = (defaultScene || args.Contains("--walk")) && !args.Contains("--inspect") && !walkSmoke && !args.Contains("--smoke-window") && animationPath == null && !args.Contains("--time"); var story = defaultStory || loadedSave != null || saveOutput != null || args.Contains("--story") || args.Contains("--story-time") - || args.Contains("--skip-intro") || jetpackSmoke || shrinkSmoke || gadgetWindowSmoke || practiceWindowSmoke || practiceReturnSmoke || carlSmoke || controlPhaseSmoke || objectiveSmoke; + || args.Contains("--skip-intro") || jetpackSmoke || shrinkSmoke || invisibleSmoke || gadgetWindowSmoke || practiceWindowSmoke || practiceReturnSmoke || carlSmoke || controlPhaseSmoke || objectiveSmoke; if (story && (args.Contains("--inspect") || walkSmoke || args.Contains("--smoke-window"))) 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."); @@ -299,6 +302,7 @@ internal static class Program SceneHud? hud = null; GadgetScreen? gadgetScreen = null; GadgetMenuOverlay? gadgetOverlay = null; + InvisibleMeterOverlay? invisibleMeter = null; SceneGadgets? gadgets = null; ShrinkRayVisuals? rayVisuals = null; ShrinkSoldierVisuals? soldierVisuals = null; @@ -322,6 +326,7 @@ internal static class Program } var characterOffset = mesh.Vertices.Length; var characterModel = Matrix4x4.Identity; + MeshDraw? characterDraw = null; if (animationPath != null) { if (scene == null || originalStart == null) @@ -336,7 +341,7 @@ internal static class Program simulation = new LabSimulation(new SceneCollision(world), standingPose, originalStart.Position, originalStart.Rotation.Y, cameraRay == null ? null : (look, eye) => cameraRay.Trace(look, eye), cameraRay == null ? null : (start, end) => cameraRay.TraceGeometry(start, end), - level.Code == "VR04" ? OriginalStaticCollision.FromRouteScene(world,level.Code) : null) + level.Code == "VR04" ? OriginalStaticCollision.FromRouteScene(world,level.Code) : null, energy) { LevelCode = level.Code, InputAfterPlayerUpdate = carriedSave != null }; if (carriedPlayer != null) { @@ -353,6 +358,7 @@ internal static class Program var placement = PreviewCharacterPlacement.Create(mesh, standingPose, originalStart.Position, originalStart.Rotation.Y); characterModel = placement.Model; mesh = animations.Current.AppendTo(mesh); + characterDraw = mesh.Draws[^1]; if (walking) Console.WriteLine("Controllable lab: arrows move/turn; Shift/Insert/right mouse jump; Enter/Ctrl/left mouse fire; Tab/Space gadgets; R reset; C inspect; F11 fullscreen; Escape quit. Collision, pivot and timing remain provisional."); else @@ -440,6 +446,8 @@ internal static class Program } hud = new SceneHud(mesh, Path.Combine(Path.GetDirectoryName(scene!)!, "../ui/ui.json")); mesh = hud.Mesh; + invisibleMeter = new InvisibleMeterOverlay(mesh,Path.Combine(Path.GetDirectoryName(scene!)!,"../invisible-meter/meter.json")); + mesh = invisibleMeter.Mesh; gadgetOverlay = new GadgetMenuOverlay(mesh, Path.Combine(Path.GetDirectoryName(scene!)!, "../gadgets/gadgets.json")); mesh = gadgetOverlay.Mesh; Console.WriteLine($"Prepared source model actors: {staticVisuals.ActorCount}."); @@ -472,11 +480,13 @@ internal static class Program var storyTime = double.Parse(Option(args, "--story-time") ?? "0", System.Globalization.CultureInfo.InvariantCulture); if (!double.IsFinite(storyTime) || storyTime < 0 || storyTime > 3600 || storyTime > 0 && !headless) 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" : 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 ? "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)) throw new ArgumentException("Gadget menu SDL fixture requires a fresh windowed lab and24 frames"); if (shrinkSmoke && (level?.Code != "VR04" || gadgets == null || frames < 60)) throw new ArgumentException("Shrink-ray smoke requires actual VR04 and at least60 frames"); + if (invisibleSmoke && (level?.Code != "VR03" || frames < 8 || loadedSave != null)) + throw new ArgumentException("Invisible smoke requires a fresh VR03 and at least8 frames"); 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"); if (toolsSmoke && (headless || frames < 16 || director == null || level?.Code != "LV1B" || loadedSave != null || debugMenu.Open)) @@ -509,6 +519,7 @@ internal static class Program ShrinkSoldier? shrinkVictim = null; var shrinkPhaseMask = 0; var sawShrinkKey = false; + InvisibleSmoke? invisibleFixture = null; 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}."); { using var audio = Option(args, "--audio") is { } audioFile @@ -535,6 +546,7 @@ internal static class Program director.MusicRestarted += sceneAudio.RestartMusic; objectivePanel!.SoundEffect += id => { if (level!.Code == "LV1B") sceneAudio.Effect(id); }; interactions!.SoundEffect += id => sceneAudio.Effect(id); + simulation!.EnergySound += id => sceneAudio.Effect(id); mechanisms!.Sound += (actor, id, loop) => sceneAudio.Effect(id, loop ? actor.Tag : null); mechanisms.StopSound += actor => sceneAudio.StopLoop(actor.Tag); sceneAudio.Music(originalStart!.Text("MusicDatabase") ?? "none", originalStart.Integer("MusicIndex", -1)); @@ -556,7 +568,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)}."); if (!restored) throw new InvalidOperationException("RETURN did not restore the live departure root without replaying STRT actions"); } - if (args.Contains("--skip-intro") || jetpackSmoke || shrinkSmoke || gadgetWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke || controlPhaseSmoke) { sceneAudio?.StopSpeech(); director.Skip(); } + if (args.Contains("--skip-intro") || jetpackSmoke || shrinkSmoke || invisibleSmoke || gadgetWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke || controlPhaseSmoke) { sceneAudio?.StopSpeech(); director.Skip(); } if (gadgetWindowSmoke) { interactions!.Inventory.SetState(0,3,1); interactions.Inventory.SelectGadget(3); } if (controlPhaseSmoke) { @@ -636,6 +648,7 @@ internal static class Program throw new InvalidOperationException("Gadget screen requires player control (--skip-intro)"); gadgetScreen.Point(new(200,380), level!.Code, storyTasks!.Get("SCENE")); } + if (invisibleSmoke) invisibleFixture = new(simulation!,interactions!.Inventory); if (shrinkSmoke) { //Explicit test placement near an ACTUAL authored soldier. @@ -803,6 +816,12 @@ internal static class Program debugMenu.Message = "DEBUG INPUT ORDER TOGGLED; NEW LEVEL RESTORES SOURCE POLICY"; break; case DebugAction.ApplyJetpackState when interactions != null: interactions.Inventory.SetState(0, 3, debugMenu.JetpackState); debugMenu.Message = "JET PACK AVAILABILITY APPLIED"; break; + case DebugAction.GiveInvisible when interactions != null: + interactions.Inventory.SetState(0,2,1); interactions.Inventory.SelectGadget(2); + debugMenu.Message = simulation?.GadgetMode == 2 ? "INVISIBLE EQUIPPED - RECHARGE 7 SECONDS, THEN FIRE" + : "INVISIBLE OWNED - ENERGY REQUIRED TO EQUIP"; break; + case DebugAction.UnequipGadget when interactions != null: + interactions.Inventory.SelectGadget(-1); debugMenu.Message = "GADGET UNEQUIPPED"; break; case DebugAction.CameraObstruction when debugCameraRay != null: debugCameraRay.Enabled = !debugCameraRay.Enabled; debugMenu.Message = "STATIC CAMERA QUERY TOGGLED"; break; case DebugAction.MuteMusic or DebugAction.MuteSpeech or DebugAction.MuteEffects when sceneAudio != null: @@ -868,6 +887,11 @@ internal static class Program } while (running) { + invisibleFixture?.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); if (gadgetWindowSmoke) { void Key(uint key,bool down) { var e=new Sdl.Event {Type=down?Sdl.KeyDown:Sdl.KeyUp,Scancode=key,Down=down?(byte)1:(byte)0}; @@ -990,7 +1014,7 @@ internal static class Program if (e.Type == Sdl.MouseButtonUp && e.MouseButton == 3) mouseJump = false; if (e.Type == Sdl.KeyDown) { - if (shrinkSmoke && e.Scancode == 224) sawShrinkKey = true; + if ((shrinkSmoke || invisibleSmoke) && e.Scancode == 224) sawShrinkKey = true; keys.Add(e.Scancode); if (walkSmoke) sawWalkKeys |= e.Scancode == 82 ? 1 : e.Scancode == 79 ? 2 : e.Scancode == jumpScancode ? 4 : 0; if (jetpackSmoke) sawJetpackKeys |= e.Scancode == 82 ? 1 : e.Scancode == 81 ? 2 : e.Scancode == 80 ? 4 : e.Scancode == jumpScancode ? 8 : 0; @@ -1038,12 +1062,13 @@ internal static class Program } } if (debugMenu.Open) animationStarted += elapsed; - if (simulation != null && !debugMenu.Open && !inspecting && !practice.Active && gadgetScreen?.Open != true && (active || headless || walkSmoke || jetpackSmoke || shrinkSmoke || gadgetWindowSmoke || objectiveWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke)) + if (simulation != null && !debugMenu.Open && !inspecting && !practice.Active && gadgetScreen?.Open != true && (active || headless || walkSmoke || jetpackSmoke || shrinkSmoke || invisibleSmoke || gadgetWindowSmoke || objectiveWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke)) { - var steps = headless || walkSmoke || jetpackSmoke || shrinkSmoke || gadgetWindowSmoke || practiceWindowSmoke || carlSmoke || controlPhaseSmoke || objectiveWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke ? 1 : stepClock.Advance(elapsed); + var steps = headless || walkSmoke || jetpackSmoke || shrinkSmoke || invisibleSmoke || gadgetWindowSmoke || practiceWindowSmoke || carlSmoke || controlPhaseSmoke || objectiveWindowSmoke || debugSmoke || diagnosticsSmoke || toolsSmoke ? 1 : stepClock.Advance(elapsed); for (var step = 0; step < steps; step++) { var input = carlSmoke || controlPhaseSmoke ? new PlayerInput(true, false, true, false, true) + : invisibleSmoke && headless ? new PlayerInput(false,false,false,false,false,Fire:count==1) : shrinkSmoke && headless ? new PlayerInput(false,false,false,false,false,Fire:true) : jetpackSmoke && headless ? LabSimulation.JetpackSmokeInput(simulation.Steps) : walkSmoke && headless ? LabSimulation.SmokeInput(simulation.Steps) : new PlayerInput( @@ -1130,6 +1155,7 @@ internal static class Program objectivePanel?.Step(0, director?.ControlledTag != null, practice.Active); hud?.Update(mesh, interactions!.CurrentObjective, level!.Code == "LV1B" && objectivePanel!.PadVisible && gadgetScreen?.Open != true, practice.Active, objectivePanel!.YOffset, objectivePanel.ContentVisible, renderer.Width, renderer.Height); + invisibleMeter?.Update(mesh,simulation!.Invisible,renderer.Width,renderer.Height); if (gadgetScreen != null) { if (!headless) gadgetScreen.Point(Pointer(),level!.Code,storyTasks!.Get("SCENE")); @@ -1151,6 +1177,8 @@ internal static class Program MovementMode = simulation?.MovementMode ?? 0, InputAfterPlayer = simulation?.InputAfterPlayerUpdate ?? false, JumpState = simulation?.JumpState ?? 0, JumpHold = simulation?.JumpHoldSeconds ?? 0, BurnRemaining = simulation?.JetpackRemaining ?? 0, JetpackAvailability = interactions?.Inventory.State(0, 3) ?? 0, + InvisibleRemaining = simulation?.Invisible.Remaining ?? 0, InvisibleRecharge = simulation?.Invisible.Recharge ?? 0, + Targetable = simulation?.Invisible.Targetable ?? true, Objective = interactions?.CurrentObjective ?? 0, ObjectiveTime = objectivePanel?.Elapsed ?? 0, CameraObstruction = debugCameraRay?.Enabled, CameraPolygons = debugCameraRay?.PolygonCount ?? 0, CameraWallPolygons = debugCameraRay?.WallPolygonCount ?? 0, CameraTests = debugCameraRay?.LastTriangleTests ?? 0, @@ -1179,8 +1207,16 @@ internal static class Program : fixedTime ?? (headless ? count / 60.0 : now - animationStarted), mesh.Vertices.AsSpan(characterOffset, animations.Current.Base.Vertices.Length), characterModel); } + if (simulation != null && characterDraw != null) + PlayerGadgetMaterial.Apply(characterDraw, simulation.Invisible); renderer.UpdateVertices(mesh.Vertices); renderer.Render(view * projection); + if (invisibleFixture != null) + { + invisibleFixture.AfterFrame(count,characterDraw!); + if (InvisibleSmoke.StageName(count) is { } stage && Option(args,"--screenshot") is { } capture) + renderer.SavePpm(Path.ChangeExtension(capture,$".{stage}.ppm")); + } var presentedAt = clock.Elapsed.TotalSeconds; diagnostics.ObserveFrame(presentedAt - lastPresentedAt); lastPresentedAt = presentedAt; @@ -1443,6 +1479,12 @@ internal static class Program if (simulation.Bursts == 0 || simulation.MaximumRise <= 137.62f || !simulation.Grounded || poweredAirTravel <= 20 || !poweredAirTurn || !headless && (sawJetpackKeys != 15 || !didResize)) return 2; } + if (invisibleFixture != null) + { + Console.WriteLine(invisibleFixture.Report); + if (!headless) Console.WriteLine($"Invisible SDL primary received: {sawShrinkKey}."); + if (!invisibleFixture.Passed || !headless && !sawShrinkKey) return 2; + } if (shrinkSmoke) { var renderedHeight = soldierVisuals!.RenderedHeight(shrinkVictim!.Actor.Tag,mesh); diff --git a/tests/GamePort.DebugMenuTests/Program.cs b/tests/GamePort.DebugMenuTests/Program.cs index 95040c5..5ce4686 100644 --- a/tests/GamePort.DebugMenuTests/Program.cs +++ b/tests/GamePort.DebugMenuTests/Program.cs @@ -66,6 +66,15 @@ Require(menu.Page == 0, "Tab cycles all three pages"); Require(menu.FindScene("VR04")?.LevelFile == "VR04.gam" && menu.FindScene("MISSING") == null, "Checkpoint resolution only uses prepared catalog"); Console.WriteLine("PASS paged player/systems tools, noclip, staged settings and bounded overlay views"); +menu.Key(43); +for(var i=0;i<10;i++)menu.Key(81); +Require(menu.Key(40)==DebugAction.GiveInvisible,"Player tools can grant/select implemented Invisible device"); +menu.Key(81);Require(menu.Key(40)==DebugAction.UnequipGadget,"Explicit gadget unequip"); +var invisibleView=menu.View(new("LV1B","STARTEXP",Vector3.Zero,0,0,true,20,0,30,"NONE",true,0,10000,false, + Systems:new(){InvisibleRemaining=4.5f,InvisibleRecharge=0,Targetable=false})); +Require(invisibleView.Lines.Length<=32 && invisibleView.Lines.Any(s=>s.Contains("INVISIBLE 4.5")),"Bounded Invisible timer/target diagnostics"); +Console.WriteLine("PASS Invisible debug commands and live phase diagnostics"); + var original = Path.GetFullPath(args.Length == 1 ? args[0] : "../Original"); var catalog = DebugMenu.AvailableScenes(original, Path.GetFullPath("artifacts/extracted")); Require(catalog.Length == 33 && catalog.All(s => s.Starts.Length > 0), "Only33 supplied scenes with prepared geometry are offered"); diff --git a/tests/GamePort.InteractionTests/GamePort.InteractionTests.csproj b/tests/GamePort.InteractionTests/GamePort.InteractionTests.csproj index c506e64..72aaff3 100644 --- a/tests/GamePort.InteractionTests/GamePort.InteractionTests.csproj +++ b/tests/GamePort.InteractionTests/GamePort.InteractionTests.csproj @@ -16,6 +16,8 @@ + + diff --git a/tests/GamePort.InvisibleTests/GamePort.InvisibleTests.csproj b/tests/GamePort.InvisibleTests/GamePort.InvisibleTests.csproj new file mode 100644 index 0000000..fd34cc8 --- /dev/null +++ b/tests/GamePort.InvisibleTests/GamePort.InvisibleTests.csproj @@ -0,0 +1,12 @@ + + Exenet10.0 + enableenablefalse + + + + + + + + + diff --git a/tests/GamePort.InvisibleTests/Program.cs b/tests/GamePort.InvisibleTests/Program.cs new file mode 100644 index 0000000..bd28f44 --- /dev/null +++ b/tests/GamePort.InvisibleTests/Program.cs @@ -0,0 +1,179 @@ +using System.Numerics; +using System.Buffers.Binary; +using System.Text; +using GamePort.Assets; +using GamePort.Game; +using GamePort.Application; + +void Check(bool value, string message) { if (!value) throw new Exception(message); } +var count = 0; +void Test(string name, Action action) { action(); count++; Console.WriteLine($"PASS {name}"); } +void Charge(InvisibleGadget gadget, float energy = 20, bool exemption = false) +{ + for (var i = 0; i < 450 && gadget.Recharge != 7; i++) + gadget.Step(1f / 60, true, false, false, energy, exemption, _ => throw new Exception("Recharge spends no energy")); + Check(gadget.Recharge == 7, "ready clamp must reach exact7"); +} +InvisibleGadget Ready(float energy = 20, bool exemption = false) +{ + var gadget = new InvisibleGadget(); Check(gadget.Equip(energy, exemption), "equip"); Charge(gadget, energy, exemption); return gadget; +} +Test("energy low warning uses19/20 hysteresis and preserves callback order", () => { + var energy = new PlayerEnergy(); var sounds = new List(); + energy.Adjust(-1, "LV1B", sounds.Add); Check(energy.Value == 19 && sounds.Count == 0, "exact19 is not low"); + energy.Adjust(-.5f, "LV1B", id => { Check(energy.Value == 18.5f && !energy.LowWarning, "low callback after scalar/before latch"); sounds.Add(id); }); + energy.Adjust(-1, "LV1B", sounds.Add); Check(sounds.SequenceEqual(new[] {182}), "warn once per low episode"); + energy.Value = 20; energy.Adjust(0, "LV1B"); Check(energy.LowWarning, "exact20 keeps latch"); + energy.Value = MathF.BitIncrement(20); energy.Adjust(0, "LV1B"); Check(!energy.LowWarning, "above20 clears"); + energy.Adjust(-2, "LV1B", sounds.Add); Check(sounds.SequenceEqual(new[] {182,182}), "renewed episode warns"); +}); +Test("empty crossing sounds before write, then low warning; continuing empty does not repeat", () => { + var energy = new PlayerEnergy { Value = 1 }; var seen = new List(); + energy.Adjust(-2, "LEV1", id => { seen.Add(id); Check(id == 80 ? energy.Value == 1 : energy.Value == 0, "source write order"); }); + Check(seen.SequenceEqual(new[] {80,182}) && energy.Value == 0, "crossing then low sound"); + energy.Adjust(-2, "LEV1", seen.Add); Check(seen.Count == 2, "empty is not another crossing"); + energy.Value = 200; energy.Adjust(0, "LEV1"); Check(energy.Value == 100 && !energy.LowWarning, "upper clamp clears latch"); +}); +Test("tutorial energy helper bypasses scalar, sounds and warning latch", () => { + var energy = new PlayerEnergy { Value = 1 }; energy.Adjust(0, "LV1B"); + for (var i = 1; i <= 8; i++) { + energy.Adjust(-100, $"VR0{i}", _ => throw new Exception("tutorial sound")); + Check(energy.Value == 1 && energy.LowWarning, "tutorial must not clear retained low latch"); + } + Check(!PlayerEnergy.IsTutorial("VR09") && !PlayerEnergy.IsTutorial("vr03"), "exact numeric FourCC range"); +}); +Test("energy latch is retained separately from original saved scalar", () => { + var state = new PlayerEnergy { Value = 1 }; state.Adjust(0, "LV1B"); + var world = new Mesh([new(new(-1000,0,-1000),Vector2.Zero,Vector3.One),new(new(1000,0,-1000),Vector2.Zero,Vector3.One), + new(new(1000,0,1000),Vector2.Zero,Vector3.One),new(new(-1000,0,1000),Vector2.Zero,Vector3.One)],[0,2,1,0,3,2]); + var standing = AseMesh.Load("../Original/ASE/jimstop.ase"); + var first = new LabSimulation(new SceneCollision(world),standing,new(0,80,0),0,energy:state); + var second = new LabSimulation(new SceneCollision(world),standing,new(0,80,0),0,energy:state) {LevelCode="LEV1"}; + var sounds = 0; second.EnergySound += _ => sounds++; + second.Energy = 2; second.AdjustEnergy(-.5f); + Check(first.Energy == 1.5f && second.LowEnergyWarning && sounds == 0, "ordinary load shares scalar/latch owner"); + second.Energy = 100; Check(second.LowEnergyWarning, "raw save/debug scalar assignment is not helper rearm"); +}); +Test("Invisible equip gates zero energy but tutorial override permits it", () => { + var device = new InvisibleGadget(); + Check(!device.Equip(0,false) && !device.Equipped, "ordinary empty equip fails"); + Check(device.Equip(0,true) && device.Recharge == 0 && device.Remaining == 0 && device.Targetable, "VR override equips with fresh clocks"); +}); +Test("held fire cannot activate on same invocation that recharge clamps7", () => { + var device = new InvisibleGadget(); device.Equip(20,false); var spends=0; + while (device.Recharge != 7) device.Step(.5f,true,true,false,20,false,_=>spends++); + Check(spends == 0 && device.Targetable && device.MeterReady, "first charge before first activation"); + device.Step(.5f,true,true,false,20,false,delta=>{Check(delta==-2,"fixed cost");spends++;}); + Check(spends==1 && device.Remaining==6.5f && device.Recharge==0 && !device.Targetable && device.Opacity==.7f, + "activation decrements remaining in same invocation, not a new-frame7"); +}); +Test("activation needs strictly more than2; primary with jump does not activate", () => { + var device=Ready(2); var spends=0; + device.Step(.1f,true,true,false,2,false,_=>spends++); + Check(!device.Active && device.Recharge==7 && spends==0,"exact2 rejected"); + device.Step(.1f,true,true,true,3,false,_=>spends++); Check(!device.Active,"jump blocks activation only"); + device.Step(.1f,true,true,false,MathF.BitIncrement(2),false,_=>spends++); Check(device.Active && spends==1,"strict threshold"); + device.Step(.1f,true,false,true,0,false,_=>spends++); Check(device.Remaining<6.9f,"active continues during jump/empty energy"); +}); +Test("raw NULL ownership and primary suppressor freeze timers independently", () => { + var device=Ready(); device.Step(.1f,true,true,false,20,false,_=>{}); var before=device.Remaining; + device.Step(.25f,false,false,false,20,false,_=>{}); Check(device.Remaining==before && !device.MeterVisible && device.Active,"null freezes, no cleanup"); + device.Step(.25f,true,true,false,20,false,_=>{},suppressed:true); Check(device.Remaining==before && device.MeterVisible,"suppressed primary returns"); + device.Step(.25f,true,true,true,20,false,_=>{},suppressed:true); Check(device.Remaining { + var device=Ready(); device.Step(0,true,true,false,20,false,_=>{}); + for(var i=0;i<8;i++) device.Step(.5f,true,false,false,18,false,_=>{}); + Check(device.Remaining==3 && device.ConventionalBlend,"trunc(3*5) odd conventionalalpha"); + device.Step(.25f,true,false,false,18,false,_=>{}); Check(device.Remaining==2.75f && device.ConventionalBlend,"odd13"); + device.Step(.25f,true,false,false,18,false,_=>{}); Check(device.Remaining==2.5f && !device.ConventionalBlend,"even12 additive"); + for(var i=0;i<5;i++) device.Step(.5f,true,false,false,18,false,_=>{}); + Check(!device.Active && device.Targetable && device.Opacity==1 && device.Recharge==0 && !device.MeterReady,"expiry invocation does not recharge"); + device.Step(.1f,true,false,false,18,false,_=>{}); Check(device.Recharge==.1f,"next invocation starts recharge"); +}); +Test("held primary reactivates after recharge without adding edge latch", () => { + var device=Ready(); var spends=0; + for(var i=0;i<35;i++) device.Step(.5f,true,true,false,20,false,_=>spends++); + Check(spends==2 && device.Activations==2,"repeat held activation after active+recharge"); +}); +Test("release and reset own material/target/meter cleanup", () => { + var device=Ready(); device.Step(.1f,true,true,false,20,false,_=>{}); device.Release(); + Check(!device.Equipped && !device.Active && device.Remaining==7 && device.Recharge==0 && device.Targetable && !device.MeterVisible && device.Opacity==1, + "source release stores7, not active restart"); + device.Reset(); Check(device.Remaining==0 && device.Activations==0,"modern reset starts clean"); +}); +Test("original atlas material changes leave geometry and authored visibility intact", () => { + var device=Ready(); var draw=new MeshDraw(0,3,1) {Visible=false}; + device.Step(0,true,true,false,20,false,_=>{}); PlayerGadgetMaterial.Apply(draw,device); + Check(draw.Opacity==.7f && draw.Blend==MeshBlend.Additive && !draw.Visible,"source alpha.7, additive branch, no show/hide invention"); + for(var i=0;i<8;i++)device.Step(.5f,true,false,false,18,false,_=>{}); + PlayerGadgetMaterial.Apply(draw,device); Check(draw.Blend==MeshBlend.Alpha,"flash routes indexed material alpha"); + device.Release(); PlayerGadgetMaterial.Apply(draw,device); Check(draw.Opacity==1 && draw.Blend==MeshBlend.Opaque,"cleanup restores opaque"); +}); +Test("binding distinguishes another control owner, AI NULL freeze and named camera cleanup", () => { + var jim=Entity("3JIM","JIM1"); var dog=Entity("3DOG","C3DGODDARD",("AIState",1)); + var other=Entity("3AIT","other",("PlayerControlled","C3DGODDARD")); + var freeze=Entity("3AIT","freeze",("PlayerControlled","NULL")); + var keep=Entity("3CAM","keep",("DeactivateInv",0),("CameraTarget","JIM1"),("SoundIndex",1)); + var cleanup=Entity("3MCA","cleanup",("CameraTarget0","none")); + var director=new SceneDirector(new("LV1B",[jim,dog,other,freeze,keep,cleanup]),new TaskStates([]),(_,_)=>1); + var body=Body(); var bag=new SceneInventory(new int[19]); bag.SetState(0,2,1); + using var binding=new PlayerSceneBinding(director,body,bag,"JIM1"); + bag.SelectGadget(2); var companion=director.FindActor("C3DGODDARD")!; + Check(!companion.Visible&&!companion.BodyEnabled&&!companion.MovementEnabled&&companion.Active,"equip hides/disables body, not AI activation"); + var integrations=0; + var patrol=new ActorPatrol(companion,director.FindActor,(state,_)=>{integrations++;return state with{Position=state.Position+Vector3.UnitX};}); + patrol.Step(.1f); Check(integrations==0,"disabled body does not consume provisional integration"); + Charge(body.Invisible); director.Trigger("other"); + var controllers=body.ControllerSteps; + binding.Step(new(false,false,false,false,false,Fire:true)); + Check(body.Invisible.Active && body.ControllerSteps==controllers && body.Energy==18,"nonnull other owner permits wrapper activation without Jimmy input"); + director.Trigger("freeze"); var remaining=body.Invisible.Remaining; + binding.Step(new(false,false,false,false,false)); + Check(body.Invisible.Active && body.Invisible.Remaining==remaining && !body.Invisible.MeterVisible,"AI NULL freezes without cleanup"); + director.Trigger("keep"); Check(body.Invisible.Active,"explicit DeactivateInv0 and absent raw owner preserve effect"); + director.Skip(); director.Trigger("cleanup"); + Check(!body.Invisible.Active && body.GadgetMode==-1 && bag.SelectedGadget==-1 && companion.Visible + && companion.BodyEnabled && companion.MovementEnabled,"default named-Jimmy cleanup even when raw owner NULL/first MCA target none"); + patrol.Step(.1f); Check(integrations==1,"companion body resumes"); +}); +Test("failed ordinary equip retains display2 with raw mode-1", () => { + var director=new SceneDirector(new("LV1B",[Entity("3JIM","JIM1")]),new TaskStates([]),(_,_)=>1); + var body=Body(); body.Energy=0; var bag=new SceneInventory(new int[19]); bag.SetState(0,2,1); + using var binding=new PlayerSceneBinding(director,body,bag,"JIM1"); bag.SelectGadget(2); + Check(bag.SelectedGadget==2 && body.GadgetMode==-1 && !body.Invisible.Equipped,"display callback precedes failed equip"); +}); +Test("original meter resources stretch and tint with uniform widescreen placement", () => { + var world=new Mesh([new(new(1,2,3),Vector2.Zero,Vector3.One)],[0,0,0]){HasCollisionMaterialIds=true}; + var overlay=new InvisibleMeterOverlay(world,"artifacts/extracted/invisible-meter/meter.json"); + var device=Ready(); + foreach(var (width,height) in new[]{(640u,480u),(1920u,1080u),(3440u,1440u)}) { + overlay.Update(overlay.Mesh,device,width,height); + var a=overlay.Mesh.Vertices[5];var b=overlay.Mesh.Vertices[7]; + var view=new UiViewport(width,height); + Check(MathF.Abs((b.Position.X-a.Position.X)*width/2/view.Scale-27)<.0002f,"source fill width27"); + Check(device.MeterPercent>=100 && device.MeterPercent<101,"source percentage precedes recharge clamp"); + Check(Math.Abs((b.Position.Y-a.Position.Y)*height/2/view.Scale-device.MeterPercent*1.04)<.0005,"source fill percent times1.04"); + Check(a.Color==Vector3.One && a.Uv==Vector2.Zero && b.Uv==new Vector2(.9999f,.9999f),"white ready tint and full image stretch"); + Check(overlay.Mesh.Vertices[0].Position==new Vector3(1,2,3)&&overlay.Mesh.HasCollisionMaterialIds,"preserve world and collision identities"); + } + device.Release();overlay.Update(overlay.Mesh,device,1920,1080); + Check(overlay.Mesh.Draws.Skip(1).All(d=>!d.Visible),"unequip hides both original sprites"); +}); +Console.WriteLine($"Invisible/energy:{count} groups passed; full enemy AI, original runtime and native Windows comparison remain separate."); + +LabSimulation Body() +{ + var world=new Mesh([new(new(-1000,0,-1000),Vector2.Zero,Vector3.One),new(new(1000,0,-1000),Vector2.Zero,Vector3.One), + new(new(1000,0,1000),Vector2.Zero,Vector3.One),new(new(-1000,0,1000),Vector2.Zero,Vector3.One)],[0,2,1,0,3,2]); + return new(new SceneCollision(world),AseMesh.Load("../Original/ASE/jimstop.ase"),new(0,80,0),0); +} +GamEntity Entity(string kind,string tag,params (string Name,object Value)[] values) +{ + var properties=new Dictionary(StringComparer.Ordinal); + foreach(var (name,value) in new[]{("ObjectTag",(object)tag)}.Concat(values)) { + if(value is string text)properties[name]=new(name,1,Encoding.Latin1.GetBytes(text)); + else {var raw=new byte[4];BinaryPrimitives.WriteInt32BigEndian(raw,(int)value);properties[name]=new(name,6,raw);} + } + return new(kind,properties.Count,properties,[]); +} diff --git a/tests/GamePort.PatrolTests/GamePort.PatrolTests.csproj b/tests/GamePort.PatrolTests/GamePort.PatrolTests.csproj index c5b17df..b712922 100644 --- a/tests/GamePort.PatrolTests/GamePort.PatrolTests.csproj +++ b/tests/GamePort.PatrolTests/GamePort.PatrolTests.csproj @@ -20,6 +20,8 @@ + + diff --git a/tests/test_bubble.py b/tests/test_bubble.py new file mode 100644 index 0000000..7f9c73e --- /dev/null +++ b/tests/test_bubble.py @@ -0,0 +1,85 @@ +"""Guarded original Bubble branches; projections are not gameplay verification.""" +from dataclasses import replace +from pathlib import Path +import math +import sys +import unittest + +ROOT=Path(__file__).resolve().parents[1] +sys.path.insert(0,str(ROOT/'tools/binary')) +from bubble import BubbleVisual, collect, energy_delta, equip_result, f32, start, stop, visual_step + + +class BubbleSourceTests(unittest.TestCase): + def test_original_identity_spans_sites_and_virtuals(self): + report=collect(ROOT.parent/'Original') + self.assertEqual(len(report['bodies']),12) + self.assertGreaterEqual(len(report['sites']),35) + self.assertEqual(len(report['vtables']),6) + self.assertTrue(all(int(b['va'],16)-int(b['file_offset'],16)==0x400000 for b in report['bodies'])) + self.assertEqual((report['archive'],report['canvas']),('RetainedSprites.omt',1)) + self.assertEqual(report['equip']['radius'],160) + self.assertEqual(report['equip']['factor'],f32(.415)) + self.assertEqual(report['cleanup']['max_speed'],650) + self.assertEqual(report['cleanup']['factor'],f32(1.265)) + + def test_equip_order_and_transition_flags(self): + self.assertEqual(equip_result(0,exists=False,practice=True),'no_effect') + self.assertEqual(equip_result(0,practice=True),'practice_VR01') + self.assertEqual(equip_result(0),'mode_minus1') + self.assertEqual(equip_result(-1),'mode_minus1') + self.assertEqual(equip_result(0,exempt=True),'equip_mode0_movement2') + self.assertEqual(equip_result(.001),'equip_mode0_movement2') + for flags in ({'active':True},{'expanding':True},{'collapsing':True}): + self.assertEqual(equip_result(1,**flags),'unchanged') + with self.assertRaises(ValueError):equip_result(math.nan) + + def test_controlled_movement2_drain_is_half_dt(self): + self.assertEqual(energy_delta(2,.25),-.125) + self.assertEqual(energy_delta(0,.25),0) + self.assertEqual(energy_delta(1,.25),0) + self.assertEqual(energy_delta(3,.25),0) + for seconds in (-1,1,math.inf,math.nan): + with self.assertRaises(ValueError):energy_delta(2,seconds) + + def test_expand_changes_color_not_dimensions_and_crosses_strict_one(self): + state=start(BubbleVisual()) + self.assertFalse(state.hidden) + state=visual_step(state,.5) + self.assertEqual(state.rgba,(.5,)*4) + self.assertEqual((state.width,state.height),(200,200)) + state=visual_step(state,.5) + self.assertEqual(state.rgba,(1.,)*4) + self.assertTrue(state.expanding) + self.assertFalse(state.active) + state=visual_step(state,.125) + self.assertFalse(state.expanding) + self.assertTrue(state.active) + + def test_active_width_pulse_and_graphics_alpha_branch(self): + state=BubbleVisual(active=True,hidden=False,rgba=(.9,)*4) + default=visual_step(state,.125) + alpha=visual_step(state,.125,graphics_alpha=True) + self.assertEqual(default.width,240) + self.assertAlmostEqual(default.height,240+math.sin(1.25)*30,places=4) + self.assertEqual(default.rgba,(.9,)*4) + self.assertEqual(alpha.rgba,(1.,1.,1.,.5)) + self.assertEqual(alpha.height,default.height) + + def test_cleanup_separately_clears_expand_and_fades_until_strict_negative(self): + initial=start(BubbleVisual()) + direct=stop(initial,through_jimmy_cleanup=False) + self.assertTrue(direct.expanding and direct.collapsing) + state=stop(initial) + self.assertFalse(state.expanding or state.active) + self.assertTrue(state.collapsing) + state=visual_step(visual_step(state,.5),.5) + self.assertEqual(state.rgba,(0.,)*4) + self.assertTrue(state.collapsing) + self.assertFalse(state.hidden) + state=visual_step(state,.125) + self.assertTrue(state.hidden) + self.assertFalse(state.collapsing) + + +if __name__=='__main__':unittest.main() diff --git a/tests/test_gadget_followup_assets.py b/tests/test_gadget_followup_assets.py new file mode 100644 index 0000000..6a97ff0 --- /dev/null +++ b/tests/test_gadget_followup_assets.py @@ -0,0 +1,105 @@ +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 gadget_followup_assets import export_meter, inspect, write_report +from omt import FormatError + + +@unittest.skipUnless(ORIGINAL.exists(), 'Original assets are local integration fixtures') +class GadgetFollowupAssetTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.report = inspect(ORIGINAL) + + def test_existing_jimmy_family_has_opaque_atlas_and_compatible_morph_counts(self): + atlas = self.report['jimmyTexture'] + self.assertEqual((atlas['width'], atlas['height']), (256, 256)) + self.assertEqual(atlas['alphaCounts'], {255: 65536}) + for clip in self.report['jimmyClips']: + self.assertEqual(len(clip['nodes']), 1) + node = clip['nodes'][0] + self.assertEqual((node['vertices'], node['faces']), (426, 814)) + if clip['source'].casefold() == 'jimstop.ase': + self.assertEqual((node['uvs'], node['textureFaces']), (3551, 814)) + self.assertEqual(clip['sha256'], 'b294d090ac5c4ec449d845db6d837f2cbedf5f7b812f5b6ed2bb70f85246f1d0') + else: + self.assertEqual((node['uvs'], node['textureFaces']), (0, 0)) + + def test_vr03_preserves_intro_wire_offsets_and_distinct_duplicate_tag_actors(self): + level = next(l for l in self.report['levels'] if l['level'] == 'VR03') + self.assertEqual(level['sha256'], '8acc4d3b8c416c41c1900ac0b1f895ab5819781e5dd87d19a1f177414660d5b2') + self.assertEqual(level['counts']['3SOL'], 8) + soldiers = [e for e in level['entities'] if e['kind'] == '3SOL'] + self.assertEqual(len({e['offset'] for e in soldiers}), 8) + self.assertEqual({e['tag'] for e in soldiers}, {'C3DYOKIANSOLDIER'}) + intro = next(e for e in level['entities'] if e['offset'] == 0x8EEE) + sounds = [p for p in intro['properties'] if p['name'] in ('SoundIndex0', 'SoundIndex1', 'SoundIndex2')] + self.assertEqual([(p['offset'], p['value']) for p in sounds], [(0x90F7, 21), (0x9176, 20), (0x91F5, 37)]) + self.assertEqual((level['meshes'][0]['vertices'], level['meshes'][0]['triangles']), (280, 424)) + + def test_bubble_billboard_and_vr01_are_exact_serialized_resources(self): + sprite = next(r for r in self.report['resources'] if r['archive'] == 'RetainedSprites.omt') + self.assertEqual((sprite['id'], sprite['name'], sprite['offset'], sprite['size']), (1, 'orangebubble', 0x17FCE, 66322)) + self.assertEqual((sprite['canvas']['width'], sprite['canvas']['height']), (146, 146)) + self.assertEqual(sprite['rgbaSha256'], 'a3a678c47c1ce94946b1136560a84f3ef86c6884b981256a9fbff62fe8a988e4') + self.assertEqual(sprite['alphaCounts'], {0: 5492, 255: 15824}) + level = next(l for l in self.report['levels'] if l['level'] == 'VR01') + self.assertEqual(level['sha256'], '7938214fb62784fcb34245491342a5f33e3615bdc178e4883a9e285e6869904f') + self.assertEqual(level['counts'].get('3SOL', 0), 0) + self.assertEqual(sum(level['counts'].values()), 16) + self.assertEqual((level['meshes'][0]['vertices'], level['meshes'][0]['triangles']), (60, 80)) + + def test_report_rejects_original_tree_before_writing(self): + for output in (ORIGINAL/'followup.json', ORIGINAL/'ASE/followup.json', ORIGINAL/'omt/followup.json'): + with self.subTest(output=output), self.assertRaises(ValueError): + write_report(ORIGINAL, output) + with tempfile.TemporaryDirectory() as directory: + output = Path(directory)/'report.json' + report = write_report(ORIGINAL, output) + self.assertTrue(output.is_file()) + self.assertEqual(report['schema'], 1) + + def test_meter_export_preserves_exact_source_pixels_and_bounded_resources(self): + with tempfile.TemporaryDirectory() as directory: + output = Path(directory)/'meter' + manifest = export_meter(ORIGINAL, output) + self.assertEqual(manifest, json.loads((output/'meter.json').read_text())) + self.assertEqual([t['id'] for t in manifest['textures']], [21, 22]) + self.assertEqual([(t['sourceOffset'], t['sourceBytes']) for t in manifest['textures']], + [(0x88E18, 8118), (0x8C5D8, 9138)]) + for texture in manifest['textures']: + expected = next(r for r in self.report['resources'] if r['archive'] == 'screens.omt' and r['id'] == texture['id']) + rgba = (output/texture['path']).read_bytes() + self.assertEqual(len(rgba), 30*110*4) + self.assertEqual(hashlib.sha256(rgba).hexdigest(), expected['rgbaSha256']) + self.assertTrue((output/texture['png']).is_file()) + for output in (ORIGINAL/'generated-meter', ORIGINAL/'ASE/generated-meter', ORIGINAL/'omt/generated-meter'): + with self.subTest(output=output), self.assertRaises(ValueError): + export_meter(ORIGINAL, output) + with tempfile.TemporaryDirectory() as directory: + output = Path(directory)/'meter' + with patch('gadget_followup_assets.read_canvas', return_value=dict(width=1, height=1, rgba=b'\0'*4)): + with self.assertRaises(FormatError): + export_meter(ORIGINAL, output) + self.assertFalse(output.exists()) + + def test_rea_meter_code_spans_and_double_height_multiplier_remain_guarded(self): + contract = self.report['meterCode'] + self.assertEqual(len(contract['guardedSpans']), 8) + self.assertEqual(contract['heightMultiplier'], 1.04) + self.assertEqual((contract['backgroundCanvas'], contract['fillCanvas']), (21, 22)) + self.assertEqual([s['fileOffset'] for s in contract['guardedSpans'][:4]], [0x174D, 0x2D70, 0x3730, 0x37F0]) + self.assertEqual(contract['rawBackgroundPosition'], [320, 7]) + self.assertEqual(contract['rawFillPosition'], [322, 4]) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_invisible.py b/tests/test_invisible.py new file mode 100644 index 0000000..2982b17 --- /dev/null +++ b/tests/test_invisible.py @@ -0,0 +1,87 @@ +import math +from pathlib import Path +import sys +import unittest +from dataclasses import replace + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tools/binary')) +from invisible import State, cleanup, collect, equip, f32, step + +ORIGINAL = Path(__file__).resolve().parents[2] / 'Original' + + +class InvisibleSourceTests(unittest.TestCase): + def test_original_identity_spans_sites_virtuals_and_constants(self): + source = collect(ORIGINAL) + self.assertEqual(len(source['bodies']), 7) + self.assertEqual(len(source['sites']), 50) + self.assertEqual(len(source['vtables']), 8) + for body in source['bodies']: + self.assertEqual(int(body['va'], 16)-0x400000, int(body['file_offset'], 16)) + + def test_equip_energy_gate_is_distinct_from_activation_and_display(self): + self.assertEqual(equip(State(mode=-1), 0).mode, -1) + self.assertEqual(equip(State(mode=-1), .25).mode, 2) + self.assertEqual(equip(State(mode=-1), 0, True).mode, 2) + self.assertEqual((equip(State(), 20).remaining, equip(State(), 20).recharge), (0, 0)) + + def test_first_recharge_clamp_activates_only_on_next_call(self): + state = State() + for _ in range(14): + state, delta = step(state, .5, 20, primary=True) + self.assertEqual(delta, 0) + self.assertEqual((state.recharge, state.remaining, state.meter_red), (7, 0, False)) + state, delta = step(state, .5, 20, primary=True) + self.assertEqual((delta, state.remaining, state.recharge), (-2, 6.5, 0)) + self.assertEqual((state.alpha, state.blend, state.targetable), (f32(.7), 'additive', False)) + + def test_activation_strict_two_and_jump_exclusion(self): + ready = State(recharge=7, meter_red=False) + for energy in (0, 1.5, 2): + state, delta = step(ready, .25, energy, primary=True) + self.assertEqual((state.remaining, delta), (0, 0)) + state, delta = step(ready, .25, 2.01, primary=True) + self.assertEqual((state.remaining, delta), (6.75, -2)) + state, delta = step(ready, .25, 0, primary=True, override=True) + self.assertEqual((state.remaining, delta), (6.75, -2)) + self.assertEqual(step(ready, .25, 20, primary=True, jump=True)[1], 0) + + def test_control_and_suppressor_freeze_only_the_proven_branches(self): + active = State(remaining=5, recharge=0, alpha=f32(.7), blend='additive', targetable=False) + state, _ = step(active, .25, 20, control_present=False) + self.assertEqual((state.remaining, state.meter_visible), (5, False)) + state, _ = step(active, .25, 20, primary=True, suppressed=True) + self.assertEqual(state.remaining, 5) + for primary, jump in [(False, False), (True, True)]: + self.assertEqual(step(active, .25, 20, primary=primary, jump=jump, suppressed=True)[0].remaining, 4.75) + + def test_zero_energy_stops_recharge_but_not_active_duration(self): + self.assertEqual(step(State(recharge=1), .5, 0)[0].recharge, 1) + self.assertEqual(step(State(recharge=1), .5, 0, override=True)[0].recharge, 1.5) + self.assertEqual(step(State(remaining=4), .5, 0)[0].remaining, 3.5) + + def test_last_three_flash_and_exact_zero_expiry(self): + active = State(remaining=3, alpha=f32(.7), blend='additive', targetable=False) + self.assertEqual(step(active, .25, 20)[0].blend, 'alpha') # trunc(2.75*5)=13 + self.assertEqual(step(active, .5, 20)[0].blend, 'additive') # trunc(2.5*5)=12 + ended, delta = step(replace(active, remaining=.5), .5, 20, primary=True) + self.assertEqual((ended.remaining, ended.recharge, delta), (0, 0, 0)) + self.assertEqual((ended.alpha, ended.blend, ended.targetable, ended.meter_red), (1, 'opaque', True, True)) + self.assertEqual(step(ended, .5, 20)[0].recharge, .5) + + def test_cleanup_preserves_source_inactive_timer_value_and_resets_presentation(self): + ended = cleanup(State(remaining=4, alpha=f32(.7), blend='additive', targetable=False)) + self.assertEqual((ended.mode, ended.remaining, ended.recharge), (-1, 7, 0)) + self.assertEqual((ended.alpha, ended.blend, ended.targetable, ended.meter_visible), (1, 'opaque', True, False)) + self.assertEqual(step(ended, .5, 20)[0], ended) + self.assertEqual((equip(ended, 20).remaining, equip(ended, 20).recharge), (0, 0)) + + def test_source_graphics_branch_and_invalid_modern_projection_time(self): + self.assertEqual(step(State(recharge=7), .25, 20, primary=True, graphics_alpha=True)[0].blend, 'alpha') + for seconds in (-1, 1, math.inf, math.nan): + with self.assertRaises(ValueError): + step(State(), seconds, 20) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_player_energy.py b/tests/test_player_energy.py new file mode 100644 index 0000000..443131d --- /dev/null +++ b/tests/test_player_energy.py @@ -0,0 +1,36 @@ +from pathlib import Path +import sys +import unittest + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT/'tools/binary')) +from player_energy import collect + + +class PlayerEnergySourceTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.report = collect(ROOT.parent/'Original') + + def test_exact_shared_body_and_warning_constants(self): + self.assertEqual(self.report['body']['size'], 0xF3) + self.assertEqual(self.report['constants'], dict(zero=0, maximum=100, low=19, rearm=20)) + + def test_sound_and_scalar_order_have_guarded_sites(self): + sites = {site['name']: int(site['va'], 16) for site in self.report['sites']} + self.assertLess(sites['empty_sound_before_scalar'], sites['scalar_store_before_extended_upper_test']) + self.assertLess(sites['low_sound_before_latch'], sites['strict_rearm']) + self.assertEqual(self.report['globals']['warning'], '0x4f83dc') + + def test_constructor_and_both_new_consumers_are_bound(self): + sites = {site['name'] for site in self.report['sites']} + self.assertTrue({'ctor_zero_register', 'ctor_clear_warning', 'ray_adjust_caller', + 'invisible_adjust_caller'}.issubset(sites)) + + def test_every_site_has_pe_mapped_offset(self): + for site in self.report['sites']: + self.assertEqual(int(site['file_offset'], 16), int(site['va'], 16)-0x400000) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/binary/bubble.py b/tools/binary/bubble.py new file mode 100644 index 0000000..f71f648 --- /dev/null +++ b/tools/binary/bubble.py @@ -0,0 +1,156 @@ +#!/usr/bin/env python3 +"""Read-only Bubble gadget contract and bounded source-state projections. + +REA inspected generated EXE copies; these projections are not original execution. +""" +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', 0x410840, 0x410a0f, '60f84d3037031e7bdb4eff676c99b8f14337114086812d90f9cdf6cc512e3c52'), + ('bind', 0x410a80, 0x410ad1, '568468bd5cbd82fe5f4c3d54919b27c3cf6f4c472467102bcd0aae4f97f33f92'), + ('animate', 0x410ae0, 0x410c9e, '2d2fce6259a34254dec6b9e6a6302150f58c79d19771861fcadb26e8eda38c60'), + ('start', 0x410ca0, 0x410cf3, '238c7652a9d6237c6897a74e1c9757b15a063abf017f6e5225d25a75798b0fa3'), + ('stop', 0x410d00, 0x410d16, 'a551ba8c995dfd11db00c5d25f8502101a7bd05928a22781b0fd9f45e0d799c8'), + ('equip', 0x428f61, 0x4290b7, '0d56551646c616094d7550de24600475b2593160234111bb76fe2a434893862c'), + ('cleanup', 0x427ff0, 0x4280cc, 'd81b941f45247d8fc3c7652bc64d06e9c503d699d1a1820c5fab4ffad4e56bf9'), + ('active_input', 0x426264, 0x4263ef, '77de32b45f3808ccd7ec76304d74c82b09cc7ee831a6b7553e3fe68c72296715'), + ('ordinary_fire_gate', 0x42668f, 0x4266b9, 'd88cb837b49acc11f3a779f71b3f361ed27c634532aa3808081cf4a2438ee6b3'), + ('effect_callbacks', 0x42a870, 0x42a91a, 'eb20ec6524bf2a54bf45ea781f0cb0d6bc03f3c729f5dbd4097810d5c9b21fa2'), + ('supported_radius', 0x42469b, 0x4246e9, '40e025e4bdc8bcdbcb24651e3d81908a5b7a9e2cc8de81d733da7490ea76c1d4'), + ('movement_dispatch', 0x438b1e, 0x438ba4, 'a18e41a473e0975ae79c2d328ec323d7c87d77722a6a43a785bbc3fe92a58743'), +) +SITES = ( + ('owned_bubble_ctor', 0x42232c, 5), ('owned_bubble_field', 0x42233c, 6), + ('sprite_archive', 0x410919, 5), ('sprite_canvas1', 0x41094a, 7), + ('radius160', 0x429049, 13), ('factor0415', 0x429058, 13), + ('mode0', 0x429065, 7), ('movement2', 0x429072, 9), ('max1350', 0x42907b, 10), + ('start_effect', 0x429085, 5), ('loop_sound2', 0x429093, 11), + ('practice_vr01', 0x428fca, 5), ('energy_gate', 0x428fda, 25), + ('exempt_flag', 0x428fed, 8), ('active_guard', 0x429013, 14), + ('collapse_guard', 0x429021, 14), ('expand_guard', 0x42902f, 14), + ('cleanup_mode0', 0x428030, 7), ('cleanup_timer05', 0x428045, 10), + ('cleanup_movement0', 0x42804f, 7), ('cleanup_max650', 0x428056, 10), + ('cleanup_stop', 0x428060, 5), ('cleanup_clear_expand', 0x42806b, 6), + ('cleanup_stop_loop', 0x42807c, 7), ('cleanup_radius60', 0x42809c, 13), + ('cleanup_factor1265', 0x4280ab, 13), ('cleanup_mode_minus1', 0x4280bb, 9), + ('input_mode2', 0x426264, 14), ('input_drain', 0x426272, 19), + ('input_empty_cleanup', 0x426285, 32), ('position_y100', 0x4262f2, 6), + ('position_distance80', 0x42637a, 6), ('position_y50', 0x426399, 6), + ('fire_mode0_reject', 0x4266ac, 13), ('effect_pulse30', 0x410b5a, 6), + ('expand_strict1', 0x410b95, 29), ('collapse_strict0', 0x410c1e, 13), +) +VTABLES = ((0x4a3bdc, 0x174, 0x428d50), (0x4a3bdc, 0x178, 0x427ff0), + (0x49250c, 0x3c4, 0x410ae0), (0x49250c, 0x110, 0x471240), + (0x49250c, 0x100, 0x4711e0), (0x4a3bdc, 0x128, 0x439900)) + + +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)) + sites = [dict(name=name, va=hex(va), file_offset=hex(pe.offset(va-pe.base)), + bytes=read_va(pe, va, length).hex()) for name, va, length in SITES] + for base, slot, expected in VTABLES: + if struct.unpack('1. else timer + return replace(state,scalar=scalar,active=timer>1.,expanding=timer<=1.,rgba=(scalar,)*4) + if state.collapsing: + scalar=f32(1.-timer) + return replace(state,scalar=max(0.,scalar),collapsing=scalar>=0., + hidden=state.hidden or scalar<0.,rgba=(max(0.,scalar),)*4) + return state + + +if __name__ == '__main__': + cli=argparse.ArgumentParser(description=__doc__) + cli.add_argument('original',type=Path) + print(json.dumps(collect(cli.parse_args().original),indent=2)) diff --git a/tools/binary/invisible.py b/tools/binary/invisible.py new file mode 100644 index 0000000..7db944a --- /dev/null +++ b/tools/binary/invisible.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +"""Read-only Invisible gadget source guards and bounded branch projections. + +These projections are independently transcribed static contracts, not execution +of original code or a replacement for the port's runtime checks. +""" +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 = ( + ('invisible_tick', 0x424E80, 0x425114, 'b52f6f643c786206fa5a4089d58b311417439a203e0914a8a0243e319c52ebb3'), + ('invisible_equip', 0x428E51, 0x428F61, '9abaa12fb4625248564818695c6a7e6d27fccf15216c670e5321a3742aa99bc2'), + ('invisible_cleanup', 0x42810C, 0x4281B3, '92e9ffe9516cca33159b05d3509dc0e34d839e6c8d3deb7e1cd08adbfbfc2851'), + ('material_alpha', 0x40E4A0, 0x40E5D9, '741d94d5cf14efd99e5380239d7a1b4be7e7fb5f478590604e8bd76b8e5d1ead'), + ('indexed_blend', 0x40DD40, 0x40DD5D, 'b14a27765254aba1bb2e420019648ee0f05573567c1d1f79c6d8ab09cc59fdc5'), + ('meter', 0x4036C0, 0x40385B, '46f35e6db8030b96cd6a0bddaf59cf37d36b41f6b568143856db2184b360ca8b'), + ('enemy_target_flag', 0x409CC0, 0x409CF7, 'cf6e1c52f5801412ab7012465fd41d0278ddb9aef62002535c829f6e03af9252'), +) +SITES = ( + ('tick_after_movement', 0x424C31, 20), + ('tick_control_pointer_not_identity', 0x424E80, 30), + ('tick_mode_two', 0x424E9E, 12), + ('tick_show_meter', 0x424EB4, 6), + ('primary_then_not_jump', 0x424EBA, 26), + ('primary_suppressor_returns', 0x424ED4, 13), + ('activation_remaining_exact_zero', 0x424EE1, 19), + ('activation_recharge_exact_seven_bits', 0x424EF4, 12), + ('activation_energy_strict_two_or_override', 0x424F00, 33), + ('activation_fixed_cost_minus_two', 0x424F21, 10), + ('activation_duration_seven', 0x424F32, 10), + ('activation_blend_source6_dest1', 0x424F3C, 12), + ('activation_material_alpha_point7', 0x424F48, 15), + ('activation_target_flag_false', 0x424F57, 7), + ('activation_recharge_zero', 0x424F5E, 10), + ('recharge_only_remaining_zero', 0x424F68, 23), + ('recharge_energy_positive_or_override', 0x424F7F, 29), + ('recharge_store_before_meter', 0x424F9C, 54), + ('recharge_seven_clamp_white', 0x424FD2, 47), + ('active_strict_positive_before_decrement', 0x425001, 23), + ('active_decrement_before_meter', 0x425018, 28), + ('active_expiry_less_or_equal_zero', 0x425064, 19), + ('expiry_material_reset', 0x425077, 38), + ('expiry_target_true_red_meter', 0x42509D, 25), + ('flash_last_three', 0x4250BA, 19), + ('flash_trunc_remaining_times_five', 0x4250CD, 19), + ('flash_odd_dest7_even_dest1', 0x4250EA, 38), + ('equip_energy_positive_or_override', 0x428E51, 40), + ('equip_mode_two_timers_target_flag', 0x428EB4, 36), + ('equip_display_before_branch', 0x428D95, 9), + ('cleanup_target_flag_true_recharge_zero', 0x428125, 21), + ('cleanup_companion_skip_flag', 0x428144, 20), + ('cleanup_material_opaque_mode_minus_one', 0x428194, 31), + ('constructor_timer_zero', 0x4227BE, 15), + ('constructor_override_false', 0x437650, 6), + ('postload_override_false', 0x4236C0, 7), + ('postload_vr_range_override_true', 0x423E44, 45), + ('enemy_chase_target_flag', 0x40847C, 34), + ('enemy_acquire_target_flag', 0x40877A, 28), + ('enemy_lost_target_flag', 0x4087F6, 51), + ('cam_optional_cleanup_flag', 0x4165B7, 43), + ('mca_optional_cleanup_flag', 0x43129A, 56), + ('jimmy438_cleanup', 0x42AE08, 18), + ('cam_interface_complete_plus_c8', 0x415A60, 6), + ('cam_property_default_one_register', 0x415C09, 5), + ('cam_property_default_one_store', 0x415CD5, 6), + ('cam_deactivateinv_property', 0x415F70, 26), + ('mca_interface_complete_plus_c8', 0x430930, 6), + ('mca_property_default_one', 0x430AA0, 10), + ('mca_deactivateinv_property', 0x430D7E, 26), +) +VTABLES = ( + (0x4A3BDC, 0x1C8, 0x424E80), (0x4A3BDC, 0x178, 0x427FF0), + (0x4A3BDC, 0xFC, 0x40DD40), (0x4A3BDC, 0x114, 0x40E4A0), + (0x48D414, 0x484, 0x4036C0), (0x48D414, 0x488, 0x403700), + (0x48D414, 0x48C, 0x403730), (0x48D414, 0x490, 0x4037A0), +) +CONSTANTS = ((0x48D914, 0.0), (0x48D954, 2.0), (0x48D950, 5.0), + (0x48E5A0, 3.0), (0x48E5B8, 7.0), (0x4A3E30, 1/7)) + + +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 original span {name}') + bodies.append(dict(name=name, va=hex(start), file_offset=hex(pe.offset(start-pe.base)), + length=end-start, sha256=actual)) + sites = [dict(name=name, va=hex(va), file_offset=hex(pe.offset(va-pe.base)), + bytes=read_va(pe, va, length).hex()) for name, va, length in SITES] + tables = [] + for base, slot, expected in VTABLES: + actual = struct.unpack(' 1e-7: + raise ValueError('Changed original float constant') + constants.append(dict(va=hex(va), file_offset=hex(pe.offset(va-pe.base)), value=actual)) + if read_va(pe, 0x4EDF10, 14) != b'DeactivateInv\0': + raise ValueError('Changed cleanup property identity') + return dict(sha256=digest, bodies=bodies, sites=sites, vtables=tables, constants=constants) + + +def f32(value): + return struct.unpack(' 0 or override): + recharge = f32(state.recharge+seconds) + state = replace(state, recharge=min(recharge, 7), + meter_red=False if recharge >= 7 else state.meter_red) + if state.remaining > 0: + remaining = f32(state.remaining-seconds) + if remaining <= 0: + return replace(state, remaining=0, alpha=1, blend='opaque', + targetable=True, meter_red=True), delta + blend = state.blend + if remaining <= 3: + blend = 'alpha' if int(remaining*5) % 2 else 'additive' + state = replace(state, remaining=remaining, blend=blend) + return state, delta + + +if __name__ == '__main__': + cli = argparse.ArgumentParser(description=__doc__) + cli.add_argument('original', type=Path) + print(json.dumps(collect(cli.parse_args().original), indent=2)) diff --git a/tools/binary/player_energy.py b/tools/binary/player_energy.py new file mode 100644 index 0000000..254d2c5 --- /dev/null +++ b/tools/binary/player_energy.py @@ -0,0 +1,52 @@ +#!/usr/bin/env python3 +"""Read-only guards for shared42A920 energy/warning state; REA evidence is reused.""" +import argparse +import hashlib +import json +from pathlib import Path +import struct + +from checkpoint_script_state import find_case, read_va +from pe_inspect import PE + +EXE_SHA256 = 'f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8' +SITES = ( + ('ctor_zero_register', 0x42217E, '33db'), + ('ctor_clear_warning', 0x422980, '881ddc834f00'), + ('tutorial_numeric_range', 0x42A92B, '3d313052567c0b3d383052560f8ed5000000'), + ('empty_sound_before_scalar', 0x42A967, '6a006a506affe80ee00200'), + ('scalar_store_before_extended_upper_test', 0x42A975, 'd905d4834f00d8442404d915d4834f00d81d6cd94800'), + ('upper_clamp_clears_warning', 0x42A992, 'c705d4834f000000c842c605dc834f0000'), + ('low_sound_before_latch', 0x42A9DF, '6a0068b60000006affe893df020083c40cc605dc834f0001'), + ('strict_rearm', 0x42A9F8, 'd905d4834f00d81d24534900dfe0f6c4417507c605dc834f0000'), + ('ray_adjust_caller', 0x426F5A, 'e8c1390000'), + ('invisible_adjust_caller', 0x424F26, 'e8f5590000'), +) + + +def collect(original): + pe = PE(find_case(Path(original), 'Neutron.exe')) + if hashlib.sha256(pe.data).hexdigest() != EXE_SHA256: + raise ValueError('Original EXE identity changed') + body = read_va(pe, 0x42A920, 0xF3) + digest = hashlib.sha256(body).hexdigest() + if digest != '6d6a880fb1b4e39addc588201b7d5bb86c768dbfa3778b35045fc10380c9c5e4': + raise ValueError('Changed energy body') + sites = [] + for name, va, expected in SITES: + if read_va(pe, va, len(bytes.fromhex(expected))) != bytes.fromhex(expected): + raise ValueError('Changed source site: ' + name) + sites.append(dict(name=name, va=hex(va), file_offset=hex(pe.offset(va-pe.base)), bytes=expected)) + constants = {name: struct.unpack(' dict: + """Guard REA-backed original code; no target code is executed.""" + expected = {'Neutron.exe': 'f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8', + 'OMT2.dll': '3ec41ead011adf56387a6dbd4580e5b5a9721b5f8020c8a56420f42824354943'} + images = {name: PE(resolve_asset(original, name)) for name in expected} + for name, image in images.items(): + if digest(image.data) != expected[name]: + raise FormatError(f'Unexpected meter source image: {name}') + spans = [] + for name, label, start, end, sha256 in METER_SPANS: + image = images[name] + if digest(read_va(image, start, end-start)) != sha256: + raise FormatError(f'Unexpected source meter span: {label}') + spans.append(dict(image=name, label=label, start=hex(start), end=hex(end), + fileOffset=image.offset(start-image.base), bytes=end-start, sha256=sha256)) + exe = images['Neutron.exe'] + multiplier = struct.unpack(' str: + return hashlib.sha256(data).hexdigest() + + +def resource(database: Database, kind: str, identity: int) -> dict: + matches = [e for e in database.entries if e.type == kind and e.id == identity] + if len(matches) != 1: + raise FormatError(f'Expected one {database.path.name}:{kind}:{identity}') + entry = matches[0] + payload = database.payload(entry) + result = dict(archive=database.path.name, archiveSha256=digest(database.data), + **asdict(entry), payloadSha256=digest(payload)) + if kind == 'Canv': + canvas = read_canvas(payload) + rgba = canvas.pop('rgba') + result.update(canvas=canvas, rgbaSha256=digest(rgba), + alphaCounts=dict(sorted(Counter(rgba[3::4]).items()))) + return result + + +def tutorial(original: Path, name: str) -> dict: + source = resolve_asset(original, f'gam/{name}.gam') + data = source.read_bytes() + level = parse(data) + database = Database(resolve_asset(original, f'omt/{name}.omt')) + meshes = [] + for entry in database.entries: + if entry.type != '3DSh': + continue + shape = read_shape(database.payload(entry)) + vertices = shape['vertices'] + meshes.append(dict(**asdict(entry), vertices=len(vertices), + polygons=len(shape['polygons']), + triangles=sum(max(0, len(p['corners'])-2) for p in shape['polygons']), + bounds=dict(min=[min(v[i] for v in vertices) for i in range(3)], + max=[max(v[i] for v in vertices) for i in range(3)]))) + # Preserve duplicate tags and literal patrol links; do not silently repair + # malformed/missing references or identify distinct actors by tag alone. + records = [dict(ordinal=index, kind=e.kind, offset=e.offset, + tag=e.values().get('ObjectTag', ''), + properties=[asdict(p) for p in e.properties]) + for index, e in enumerate(level.entities)] + tags = Counter(str(r['tag']).casefold() for r in records) + return dict(level=level.code, source=f'gam/{source.name}', bytes=len(data), + sha256=digest(data), counts=dict(sorted(Counter(e.kind for e in level.entities).items())), + duplicateTags={tag: count for tag, count in sorted(tags.items()) if count > 1}, + archive=database.path.name, archiveSha256=digest(database.data), meshes=meshes, + entities=records) + + +def inspect(original: Path) -> dict: + original = original.resolve() + screens = Database(resolve_asset(original, 'omt/screens.omt')) + retained = Database(resolve_asset(original, 'omt/RetainedSprites.omt')) + voice = Database(resolve_asset(original, 'omt/voicepractice.omt')) + sounds = Database(resolve_asset(original, 'omt/soundeffects.omt')) + texture_source = resolve_asset(original, 'png/jimycarl.png') + texture = read_png(texture_source) + rgba = texture.pop('rgba') + clips = [] + for stem in ('jimstop', 'jimrun', 'jimbackpedal', 'jimjump', 'jimfall', 'jimfly', 'jimshoot'): + source = resolve_asset(original, f'ASE/{stem}.ASE') + clip = read_ase(source) + clips.append({key: value for key, value in clip.items() if key != 'objects'} | dict( + nodes=[dict(name=o['name'], samples=len(o['samples']), + times=[s['time'] for s in o['samples']], + vertices=len(o['samples'][0]['vertices']), + faces=len(o['samples'][0]['faces']), + uvs=len(o['samples'][0]['uvs']), + textureFaces=len(o['samples'][0]['textureFaces'])) for o in clip['objects']])) + return dict(schema=1, + policy='Serialized source data and decoded pixels/topology only; no gameplay or AI inference.', + resources=[resource(screens, 'Canv', i) for i in (11, 13, 21, 22, 47, 52, 88, 94, 109, 111)] + + [resource(retained, 'Canv', 1)] + + [resource(voice, 'Wave', i) for i in (20, 21, 22, 23, 24, 37, 38)] + + [resource(sounds, 'Wave', i) for i in (2, 3, 106)], + jimmyTexture=dict(source=f'png/{texture_source.name}', sha256=digest(texture_source.read_bytes()), + **texture, rgbaSha256=digest(rgba), alphaCounts=dict(sorted(Counter(rgba[3::4]).items()))), + jimmyClips=clips, meterCode=meter_code_contract(original), + levels=[tutorial(original, name) for name in ('VR01', 'VR03')]) + + +def write_report(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') + report = inspect(original) + output.parent.mkdir(parents=True, exist_ok=True) + output.write_text(json.dumps(report, indent=2, allow_nan=False)+'\n', encoding='utf-8') + return report + + +def export_meter(original: Path, output: Path) -> dict: + """Export only the two source-bound recharge meter canvases, without tinting. + + Source 401430 binds 4F7CB0/4F8028 to screens.omt21/22. Gameplay controls + visibility/percent/tint; output does not bake those changes into the pixels. + """ + 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') + database = Database(resolve_asset(original, 'omt/screens.omt')) + recovered = [] + for identity, expected in ((21, 'meter'), (22, 'metercolor')): + record = resource(database, 'Canv', identity) + if record['name'] != expected or (record['canvas']['width'], record['canvas']['height']) != (30, 110): + raise FormatError(f'Unexpected source meter canvas {identity}') + entry = next(e for e in database.entries if e.type == 'Canv' and e.id == identity) + canvas = read_canvas(database.payload(entry)) + recovered.append((record, canvas['rgba'])) + # Validate both identities before producing any generated files. + output.mkdir(parents=True, exist_ok=True) + textures = [] + for record, rgba in recovered: + name = f"canvas_{record['id']}" + (output/(name+'.rgba')).write_bytes(rgba) + write_png(output/(name+'.png'), 30, 110, rgba) + textures.append(dict(id=record['id'], name=record['name'], width=30, height=110, + path=name+'.rgba', png=name+'.png', sourceOffset=record['offset'], + sourceBytes=record['size'], sourceSha256=record['payloadSha256'], rgbaSha256=record['rgbaSha256'])) + manifest = dict(schema=1, referenceWidth=640, referenceHeight=480, + source=database.path.name, sourceSha256=digest(database.data), textures=textures) + (output/'meter.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) + parser.add_argument('--meter-output', type=Path, help='Optional separate generated meter texture directory') + args = parser.parse_args() + report = write_report(args.original, args.output) + if args.meter_output: + export_meter(args.original, args.meter_output) + print(f"{len(report['resources'])} resource identities, {len(report['jimmyClips'])} Jimmy clips, two tutorials: {args.output}") + + +if __name__ == '__main__': + main() diff --git a/tools/extractors/prepare.py b/tools/extractors/prepare.py index 3dd04fd..9a0ba62 100644 --- a/tools/extractors/prepare.py +++ b/tools/extractors/prepare.py @@ -11,6 +11,7 @@ from entities import prepare_entities from models import prepare_models from ui import export_ui from gadget_resources import export_gadget_resources +from gadget_followup_assets import export_meter from sound_bank import export_sound_bank @@ -80,6 +81,7 @@ def main(): (args.output/'scene-catalog.json').write_text(json.dumps(catalog, indent=2)+'\n') export_ui(Database(find_archive(args.original, 'screens')), args.output / 'ui', Database(args.original / 'alpha.omt')) export_gadget_resources(Database(find_archive(args.original, 'screens')), args.output / 'gadgets') + export_meter(args.original, args.output / 'invisible-meter') effects = export_sound_bank(args.original, args.output / 'effects') print(f"SoundEffects.omt: {len(effects['resources'])} original sound identities") for name in args.audio: