Implement Grappler scalar component with original-code references

This commit is contained in:
UnixNight committed 2026-11-03 21:25:54 -05:00
1 parent 70cba65c1f
commit 0c913d15aa
18 files changed
+1014 -14

No files matched your search

+14 -11
View File
@@ -46,20 +46,23 @@ changes. Current gadget controls/resources/primary-fire findings belong in
docs/gameplay/. Distinguish static recovery, implementation, port tests and original docs/gameplay/. Distinguish static recovery, implementation, port tests and original
runtime evidence. Main owns integration/runtime; gadget investigators have runtime evidence. Main owns integration/runtime; gadget investigators have
exclusive named files, not shared directories. exclusive named files, not shared directories.
Latest continuation: docs/gameplay/rocketship-live.md. Rocketship is live in bounded Latest gadget continuation: docs/gameplay/grappler-component.md. GrapplerMotion
VR02. The modern inspector's world-mirroring correction is docs/orbit-camera.md: is isolated:30 copied-original scalar observations,5 managed/14 Python groups,
same handedness as gameplay,36 matrix cases/GPU/native input+resize checks pass, existing25 movement/15 gadget groups and main build pass. Ray/body/camera/helper
packages identify clean d8f1b51. The gadget continuation remains bounded gates remain before liveVR08. Source and REA artifacts are retained under
VR02; follow-up docs/gameplay/rocketship-impact-render.md corrects wall-hit artifacts/grappler-{ray,motion,resources,scalars}/; all ownership returned after
material RGBA previously misread as scale. Packages identify clean62e908e; investigator usage limits. No approximate hook/pull mechanic is enabled.
13 managed/22 Python checks and final native Linux flight replay pass. The user clarified orbit's remaining issue was inverted Left/Right; Left/A and
The live scope remains bounded Right/D azimuth mappings are corrected, Up/Down unchanged. Playable packages
VR02: source body/callbacks, registration-ordered input, maneuvers/camera, original identify clean70cba65; native input/resize/validation passes. See docs/orbit-camera.md.
Rocketship remains live in boundedVR02: source body/callbacks,
registration-ordered input, maneuvers/camera, original
driver/Goddard/flame resources and F1 grant.96 isolated original component cases driver/Goddard/flame resources and F1 grant.96 isolated original component cases
support the source contracts; full pair discovery, other levels, special mission/ support the source contracts; full pair discovery, other levels, special mission/
hazard/RNG effects and whole-original/native Windows comparison remain open. hazard/RNG effects and whole-original/native Windows comparison remain open.
Grappler source is in Its wall-impact material RGBA correction is docs/gameplay/rocketship-impact-render.md;
docs/gameplay/grappler.md; no approximate hook/pull mechanic is enabled. Friend 13 managed/22 Python checks and final native Linux flight replay pass.
Grappler source is in docs/gameplay/grappler.md. Friend
research assessment is docs/reviews/jn-engine-survey.md; use its decompiler leads research assessment is docs/reviews/jn-engine-survey.md; use its decompiler leads
with REA/source checks, not its tuned C gameplay. All ownership has returned. with REA/source checks, not its tuned C gameplay. All ownership has returned.
Preserve baseline69d0187 and parked35a2a66/0272f7b collision checkpoints. Latest Preserve baseline69d0187 and parked35a2a66/0272f7b collision checkpoints. Latest
+5
View File
@@ -285,3 +285,8 @@ unresolved lifetime/pair/camera boundaries are in gameplay/rocketship-live.md.
Grappler's distinct source ownership and Grappler's distinct source ownership and
geometry/material/swing contract is in gameplay/grappler.md; it is not a simple geometry/material/swing contract is in gameplay/grappler.md; it is not a simple
player movement mode or nearest-tag interaction. player movement mode or nearest-tag interaction.
GrapplerMotion implements the isolated attachment/reel/damping arithmetic and
independent fire/jump detach predicate, compared with30 copied-original cases.
It owns no body/ray/camera/helper lifetime and is not called by live simulation;
integration gates and retained source/REA findings are in gameplay/grappler-component.md.
+7
View File
@@ -3,6 +3,13 @@
Compilation, native runtime, original behavior and full feature completion are Compilation, native runtime, original behavior and full feature completion are
separate evidence categories. **The game is not fully reconstructed/playable yet.** separate evidence categories. **The game is not fully reconstructed/playable yet.**
Grappler scalar checkpoint:30 copied-original Wine32 observations match5 managed
groups,14 Python source/projection checks,25 movement/15 gadget groups and main
build pass. No live Grappler, new Vulkan path or original/native Windows gameplay
comparison is claimed. See gameplay/grappler-component.md. Playable packages
remain70cba65 with the orbit horizontal-input correction, verified by native
Linux SDL input/resize and zero enabled Vulkan validation errors.
Orbit inspector follow-up: corrected right-handed inspection view/perspective Orbit inspector follow-up: corrected right-handed inspection view/perspective
to gameplay's positive-Z left-handed convention.36 camera/aspect cases and all to gameplay's positive-Z left-handed convention.36 camera/aspect cases and all
existing projection checks pass. Enabled-validation llvmpipe captures confirm existing projection checks pass. Enabled-validation llvmpipe captures confirm
+6
View File
@@ -270,3 +270,9 @@
left-handed view/projection; apply the shared Vulkan Y correction only once. left-handed view/projection; apply the shared Vulkan Y correction only once.
Regress screen right/up and depth across camera poses, not frame presence Regress screen right/up and depth across camera poses, not frame presence
alone. The modern inspector is separate from recovered original camera logic. alone. The modern inspector is separate from recovered original camera logic.
46. **Keep Grappler cursor/attachment and input/normal gates distinct.** Cursor
distance/material rejection does not prevent attachment on a ray hit.
Attached input may return early while ordinary Jimmy frame publication still
runs. Compare isolated sqrt/first-scale/reel/damping with original snippets
before composing body/camera/helper ownership; do not invent250 clamps or a
detach impulse. GrapplerMotion remains isolated until those gates close.
+100
View File
@@ -0,0 +1,100 @@
# Grappler scalar checkpoint
2026-11-03. Continues user-requested gadgets after the Rocketship/orbit fixes.
The latest playable packages include the orbit Left/Right correction70cba65.
GrapplerMotion is an isolated component; no live equip/ray/swing/camera path is
enabled. Originals and supplied friend files remain untouched. All investigator
ownership returned after their usage limits; primary integrated retained results.
## Implemented coverage
| Original span, exclusive end | File offset | Managed coverage / verification |
| --- | --- | --- |
|426BE8..426C70|26BE8|Explicit x87 sqrt distance minus100, first-length sentinel and initial rope Z scale.8 native cases, including reattach, fractions and short/negative lengths.|
|426DAC..426DD5|26DAC|Held reel: old length strictly>250, subtract250*dt without final clamp.6 native cases; loop-audio branches are outside the snippet.|
|429DC9..429DF5|29DC9|Fast reel: target<old length, subtract950*dt without target clamp.6 native cases.|
|42A077..42A1A2|2A077|Swing scalar offset acceleration, stored elapsed>=double.2, clamp50 and350 damping boundary, subtract float.2 once.10 native cases; no body constraint/position execution.|
`tools/binary/grappler.py` guards the authoritative EXE identity and enclosing
source spans; `grappler_motion.py` records the four exact span hashes/offsets and
imports completed probe results. The numeric fixture in
`tests/GamePort.GrapplerTests/original-scalar-reference.json` includes source,
generator, executable and log hashes. Eight attachment observations measure only
length/initial-length/scale callback; managed velocityY100 and reel target are
supported by the separate guarded426CDE..426D4D source, not those observations.
Independent jump/fire detach is retained from the prior source contract.
42A0C2 stores Z while retaining its unrounded x87 value until damping; the new
managed helper preserves a double intermediate there. X is reloaded after its
float store. Both are bounded projections; general x87 bit identity is unclaimed.
Neither negative lengths nor250/target overshoot are silently repaired.
## Probe boundary and verification
`grappler_scalar_probe.c` copies the hashed EXE into private memory, relocates
only whitelisted absolute scalar operands in the four slices, seeds synthetic
frame/root/state, stubs the rope shape's scale callback and exits at bounded
slice boundaries. It never invokes the original entrypoint, ray/body dispatch,
audio or renderer. Separate copied Wine32 installation/prefix runs with no
network or Original mount. Thirty cases finish with GRAPPLER_SCALARS_COMPLETE.
The initial fresh Wine prefix exceeded an8-second allowance and could not load
kernel32 on retry; those failures are retained. A copied previously working
prefix resolved startup. A fixed original-image allocation was unavailable;
the final successful probe uses private image relocation instead. Earlier map
failure logs are retained, and no results from failed runs enter the fixture.
The initial C build collided with Windows' byte typedef; emitter naming was
corrected before successful compilation.
Five managed groups compare all30 native observations within.0002 and cover
first-length retention, source-only velocity/target, overshoot, one-step damping,
simultaneous fire/jump and bounded inputs.14 Python source/projection checks,
existing25 movement/15 gadget groups and the main .NET10 build pass. This is
component execution/port compilation, not original or modern Grappler gameplay.
Evidence is under artifacts/grappler-scalars/{source.json,probe-ready/wine.log,
probe-ready/capture.json,managed.log,python.log,movement.log,gadgets.log,build.log}.
## Retained source investigation and remaining integration gates
The following source evidence narrows the next work; it is not a live adapter:
- Aim cursor and attachment have different gates.426A70 attaches on a successful
ray hit without repeating429D00's450-distance/material rejection. Both query
root→full-Euler local(0,2400,2400) using47C210(false). The aim path refreshes
root at42A384, discarding the earlier swing pivot+116. VR08 game vtable4D00D0
slot134 at4D0204→475CD0(false) supports static filter admission, but selected
material/global context and attached callback composition remain to implement.
- 429D00 returning true only ends the remaining active input426030. Ordinary
Jimmy437940 still dispatches437C40/437F90, publishing velocity independently
after swing root work; do not skip normal movement wholesale. Swing constraint
normalization uses OMT quick_magnitude, unlike attachment's explicit sqrt.
- Constructor/helper bindings point to HIROPE→rope01.ASE/jimycarl.png and the
owned cursor's retainedsprites.omt8. Cursor constructor4453B0 includes misleading
shadow debug strings; full draw/size/material consumers and helper retention
remain gates before an exact resource exporter/live visuals.
Retained REA replies, export bundles and closed snapshots:
| Artifact / procedure | REA Evidence |
| --- | --- |
|grappler-ray/rea/01.json47C210|ev_ff5aab3bdc275e6626753743a3567a556f698209ad9f65689cf49a4b5f56107d|
|grappler-ray/rea/02.json469A10|ev_03ea52bd4de36f296429073b5478032e7e55f7dc64c8545de8151bb893dd3542|
|grappler-motion/rea-base/00.json43AA40|ev_4f2a6aa666451db831efd46f5c587573e22d8072315626b8bc2f844f9c6f0cae|
|grappler-motion/rea-base/01.json47B4B0|ev_d45e078c585d3773494c0e0dfb1696178dd0b8ce8b696caf133892ff070e552e|
|grappler-resources/rea-constructors/00.json41EEB0|ev_307511ff899b91988b77796923fdfc31fa0f1bda5549f13b34c775fdc4917591|
|grappler-resources/rea-constructors/01.json4453B0|ev_423e61df2143a9dd441abffb09540b8c4ce401a0a05774d59221db623c2a7007|
|grappler-resources/rea-constructors/02.json445540|ev_76d17159215638e5e200985b3b83fa917c484805543a80a6b0ec2b86d466a488|
|grappler-resources/rea-constructors/03.json41F030|ev_2c7479a578411c7248c48387125c005db3241e79a3cb91254f1c81bff267957f|
All artifact paths are under artifacts/. The unrecognized475CD0 pseudocode
request has a retained provider error; raw vtable/code supplies that leaf's
evidence. Prior unrecognized429D00/426A70 calls were not repeated. No provider
configuration changed. Source disassembly supplements successful recognized
helpers; no whole-function pseudocode success is attributed to missing entries.
Next: selected polygon/material context and exact original attached constraint /
collision callback42A660; helper model/cursor draw+reset/cleanup and shared follow
camera ownership. Then boundedVR08 integration with simultaneous jump/fire,
reattach, control loss, menu, noclip and RETURN tests. No nearest-hook/direct-pull
substitute, invented launch impulse, generic helper persistence or original/native
Windows gameplay claim is enabled by this checkpoint.
+3
View File
@@ -1,5 +1,8 @@
# Grappler source contract and integration gate # Grappler source contract and integration gate
Continuation: [scalar implementation and30 copied-original cases](grappler-component.md).
The component remains isolated; live ray/body/camera/helper gates below still apply.
2026-11-03. Item7/raw7, using the supplied target6 decompiler bodies as leads, 2026-11-03. Item7/raw7, using the supplied target6 decompiler bodies as leads,
then independently reading the hashed EXE instructions. No friend gameplay code then independently reading the hashed EXE instructions. No friend gameplay code
imported. Static recovery and twelve Python source/projection tests only: no live imported. Static recovery and twelve Python source/projection tests only: no live
+5
View File
@@ -4,6 +4,11 @@ Follow-up: the user clarified that the remaining issue was inverted Left/Right
input; Up/Down was correct. Orbit Left/A now increases azimuth, Right/D decreases input; Up/Down was correct. Orbit Left/A now increases azimuth, Right/D decreases
it, matching the corrected view. Elevation, projection and gameplay controls it, matching the corrected view. Elevation, projection and gameplay controls
are unchanged. This is a two-line modern input mapping correction. are unchanged. This is a two-line modern input mapping correction.
Both executables republished from clean70cba65 using the unchanged verified
packaged assets. Standalone native Linux GTX1070/private Xvfb input/resize smoke
passes with enabled Vulkan validation and zero errors; evidence is
artifacts/orbit-camera/horizontal-{build-linux.log,build-windows.log,native.log}.
Native Windows runtime testing remains pending.
2026-11-03. User reports the world flips when using orbit inspection. 2026-11-03. User reports the world flips when using orbit inspection.
This is a modern camera bug; no new original-binary interpretation is needed. This is a modern camera bug; no new original-binary interpretation is needed.
+17
View File
@@ -1,5 +1,22 @@
# Progress — 2026-11-03 # Progress — 2026-11-03
## Grappler scalar checkpoint
Implemented isolated GrapplerMotion attachment length/first-scale, held/fast reel,
damping and jump/fire detach predicates. Thirty copied-original Wine32 scalar
observations match5 managed groups;14 Python guards/projections, existing25
movement/15 gadget groups and main .NET10 build pass. Source/log/generator/binary
hashes and source offsets are committed with the fixture. No live mode7, ray,
attached body, rope/cursor rendering or camera is enabled. Scope and retained
REA findings: [grappler-component.md](gameplay/grappler-component.md).
Current playable Linux/Windows packages identify clean70cba65, including the
user-clarified orbit Left/Right correction; native Linux input/resize validation
passes. Grappler component source is a later local checkpoint, not a new gameplay
package claim. All investigator ownership returned. Next: selected material ray
context, original attached collision composition, helper rendering/lifetime and
shared camera, then explicit boundedVR08/control-loss/RETURN integration.
## Orbit horizontal input follow-up and Grappler continuation ## Orbit horizontal input follow-up and Grappler continuation
User clarified the remaining orbit issue is Left/Right control inversion, with User clarified the remaining orbit issue is Left/Right control inversion, with
+6
View File
@@ -5,6 +5,12 @@ 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 evidence, not original source. Original gameplay has not yet been observed successfully; isolated original DLL
probes and modern runtime checks are recorded separately. probes and modern runtime checks are recorded separately.
- `gameplay/grappler-component.md`:30 copied-original attachment/reel/damping
observations, isolated managed component and retained ray/body/resource REA
evidence. Cursor rejection differs from attach acceptance, and input swing
short-circuit does not suppress ordinary Jimmy frame publication. Live gates
remain explicit.
- `gameplay/rocketship-live.md`, `rocketship-body.md`, `rocketship-motion-camera.md` - `gameplay/rocketship-live.md`, `rocketship-body.md`, `rocketship-motion-camera.md`
and `rocketship-lifecycle.md`: owned/reused3ROC, body flags/callbacks, registry and `rocketship-lifecycle.md`: owned/reused3ROC, body flags/callbacks, registry
input order, source Euler/maneuvers/shared-eye camera, rider/Goddard/fire/audio input order, source Euler/maneuvers/shared-eye camera, rider/Goddard/fire/audio
+6 -3
View File
@@ -48,7 +48,9 @@ compile, runtime and original-fidelity verification are separate.
- [x] User-clarified orbit Left/Right inversion: reverse horizontal azimuth - [x] User-clarified orbit Left/Right inversion: reverse horizontal azimuth
mapping while preserving correct Up/Down and gameplay controls. mapping while preserving correct Up/Down and gameplay controls.
- [ ] Grappler next: integrate retained REA/source findings from - [x] Grappler isolated attachment/reel/damping component:30 copied-original
observations,5 managed/14 Python checks plus25 movement/15 gadget groups pass.
- [ ] Grappler next: complete retained REA/source findings from
artifacts/grappler-{ray,motion,resources}/, close body/camera/helper contracts artifacts/grappler-{ray,motion,resources}/, close body/camera/helper contracts
and compare original components before enabling boundedVR08. Investigators and compare original components before enabling boundedVR08. Investigators
reached usage limits; all file ownership returned to primary. reached usage limits; all file ownership returned to primary.
@@ -90,7 +92,8 @@ compile, runtime and original-fidelity verification are separate.
- [ ] Close Grappler ray/material context, attached dispatcher/camera/Euler and - [ ] Close Grappler ray/material context, attached dispatcher/camera/Euler and
helper lifetime before live mode7. No substitute hook/pull behavior. helper lifetime before live mode7. No substitute hook/pull behavior.
No live Rocketship/Grappler or new package claim; d6ca417 remains playable baseline. Historical component-only claims are superseded for liveVR02 Rocketship.
Grappler scalar checkpoint is gameplay/grappler-component.md; it remains isolated.
**Supplied friend's decomp assessment completed2026-11-03.** **Supplied friend's decomp assessment completed2026-11-03.**
See [assessment](reviews/jn-engine-survey.md), independent gameplay/capture See [assessment](reviews/jn-engine-survey.md), independent gameplay/capture
@@ -149,7 +152,7 @@ the resume backlog, not prerequisites imposed on this user-directed gadget work.
539 originals verify after packaging. Native Windows comparison remains open. 539 originals verify after packaging. Native Windows comparison remains open.
- [x] Save Scooter separate actor/mount/vehicle and original asset contracts; - [x] Save Scooter separate actor/mount/vehicle and original asset contracts;
wheel body/support lifecycle remains a gate before faithful live integration. wheel body/support lifecycle remains a gate before faithful live integration.
- [ ] Rocketship, Scooter, Remote and Grappler; full enemy AI and - [ ] Rocketship other-level/special consumers, Scooter, Remote and live Grappler; full enemy AI and
original/native Windows comparison. Retain collision/camera/retained-helper gates. original/native Windows comparison. Retain collision/camera/retained-helper gates.
Details: [Baseball continuation](gameplay/baseball-implementation.md). Investigators Details: [Baseball continuation](gameplay/baseball-implementation.md). Investigators
+1
View File
@@ -21,6 +21,7 @@ dotnet run --project tests/GamePort.BaseballTests
dotnet run --project tests/GamePort.BaseballVisualTests dotnet run --project tests/GamePort.BaseballVisualTests
dotnet run --project tests/GamePort.RocketFlightTests dotnet run --project tests/GamePort.RocketFlightTests
dotnet run --project tests/GamePort.RocketshipTests dotnet run --project tests/GamePort.RocketshipTests
dotnet run --project tests/GamePort.GrapplerTests
dotnet run --project tests/GamePort.HeadingTests dotnet run --project tests/GamePort.HeadingTests
dotnet run --project tests/GamePort.BlendTests dotnet run --project tests/GamePort.BlendTests
dotnet run --project tests/GamePort.CameraRayTests dotnet run --project tests/GamePort.CameraRayTests
+64
View File
@@ -0,0 +1,64 @@
using System.Numerics;
namespace GamePort.Game;
public readonly record struct GrapplerAttachment(float Length,float InitialLength,float? RopeScaleZ,
float FastReelTarget,Vector3 Velocity);
public readonly record struct GrapplerSwing(float X,float Z,float Elapsed);
/// <summary>Isolated426BE8/426DAC/429DC9/42A077 scalar contracts. Does not
/// perform ray queries, body constraint, camera/visual ownership or live equip.</summary>
public static class GrapplerMotion
{
public static GrapplerAttachment Attach(Vector3 root,Vector3 anchor,Vector3 velocity,float initialLength=0)
{
Finite(root);Finite(anchor);Finite(velocity);Finite(initialLength);
double x=(double)anchor.X-root.X,y=(double)anchor.Y-root.Y,z=(double)anchor.Z-root.Z;
float length=(float)(Math.Sqrt(x*x+y*y+z*z)-100);
return new(length,initialLength==0?length:initialLength,
initialLength==0?(float)((double)length*.0016666667070239782f):null,
(float)((double)anchor.Y-root.Y-200),velocity with{Y=100});
}
public static float HeldReel(float length,float seconds)
{
Finite(length);Time(seconds);
return length>250?(float)(length-(double)seconds*250):length;
}
public static float FastReel(float length,float target,float seconds)
{
Finite(length);Finite(target);Time(seconds);
return target<length?(float)(length-(double)seconds*950):length;
}
public static GrapplerSwing Swing(GrapplerSwing state,float seconds,float offsetX,float offsetZ,float length)
{
Finite(state.X);Finite(state.Z);Finite(state.Elapsed);Time(seconds);
Finite(offsetX);Finite(offsetZ);Finite(length);
float time=state.Elapsed+seconds;
float x=(float)(state.X-(double)offsetX*seconds*.17);
//42A0C2 stores Z but retains its unrounded x87 value through damping.
double z=state.Z-(double)offsetZ*seconds*.17;
if(time>=.2)
{
float gain=length<350?.95f:.98f;
x=(float)(Math.Clamp(x,-50,50)*(double)gain);
z=Math.Clamp(z,-50,50)*gain;
time-=.2f;
}
return new(x,(float)z,time);
}
public static bool JumpDetaches(bool jumpHeld,bool fireHeld,bool attached)=>jumpHeld&&!fireHeld&&attached;
private static void Time(float value)
{
if(!float.IsFinite(value)||value<0||value>=1)throw new ArgumentOutOfRangeException(nameof(value));
}
private static void Finite(float value)
{
if(!float.IsFinite(value))throw new ArgumentOutOfRangeException(nameof(value));
}
private static void Finite(Vector3 value){Finite(value.X);Finite(value.Y);Finite(value.Z);}
}
@@ -0,0 +1,9 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable><EnableDefaultCompileItems>false</EnableDefaultCompileItems></PropertyGroup>
<ItemGroup>
<Compile Include="Program.cs"/>
<Compile Include="../../src/GamePort/Game/GrapplerMotion.cs"/>
<None Include="original-scalar-reference.json" CopyToOutputDirectory="PreserveNewest"/>
</ItemGroup>
</Project>
+59
View File
@@ -0,0 +1,59 @@
using System.Numerics;
using System.Text.Json;
using GamePort.Game;
using var document=JsonDocument.Parse(File.ReadAllText(Path.Combine(AppContext.BaseDirectory,"original-scalar-reference.json")));
var cases=document.RootElement.GetProperty("cases").EnumerateArray().ToArray();
Check(cases.Length==30,"thirty copied-original observations");
foreach(var c in cases)
{
var p=c.GetProperty("input").EnumerateArray().Select(x=>x.GetSingle()).ToArray();
var observed=c.GetProperty("observed").EnumerateArray().Select(x=>x.GetSingle()).ToArray();
var name=c.GetProperty("kind").GetString()+"/"+c.GetProperty("name").GetString();
switch(c.GetProperty("kind").GetString())
{
case "attach":
var a=GrapplerMotion.Attach(new(p[0],p[1],p[2]),new(p[3],p[4],p[5]),new(11,-222,33),p[6]);
Near(a.Length,observed[0],name+" length");Near(a.InitialLength,observed[1],name+" first length");
Check(a.RopeScaleZ.HasValue==(observed[3]==1),name+" scale write ownership");
if(a.RopeScaleZ is{} scale)Near(scale,observed[2],name+" scale");
break;
case "held":Near(GrapplerMotion.HeldReel(p[0],p[2]),observed[0],name);break;
case "fast":Near(GrapplerMotion.FastReel(p[0],p[1],p[2]),observed[0],name);break;
case "swing":
var s=GrapplerMotion.Swing(new(p[0],p[1],p[2]),p[3],p[4],p[5],p[6]);
Near(s.X,observed[0],name+" X");Near(s.Z,observed[1],name+" Z");Near(s.Elapsed,observed[2],name+" elapsed");break;
default:throw new Exception("Unknown native reference kind");
}
}
Console.WriteLine("PASS all30 copied-original attachment/reel/damping scalar observations");
var first=GrapplerMotion.Attach(Vector3.Zero,new(0,300,400),new(10,-200,20));
Check(first.Velocity==new Vector3(10,100,20)&&first.FastReelTarget==100,"source attachment velocity/reel target");
var second=GrapplerMotion.Attach(Vector3.Zero,new(0,600,800),Vector3.Zero,first.InitialLength);
Check(second.InitialLength==400&&second.Length==900&&second.RopeScaleZ==null,"reattach retains first rope length/scale");
Console.WriteLine("PASS first-length retention and independent velocity/scalar publication");
Check(GrapplerMotion.HeldReel(251,.1f)==226&&GrapplerMotion.HeldReel(250,.1f)==250,"strict held-reel gate without final250 clamp");
Check(GrapplerMotion.FastReel(251,250,.1f)==156&&GrapplerMotion.FastReel(250,250,.1f)==250,"strict fast-reel target without final clamp");
var shortRope=GrapplerMotion.Swing(new(100,-100,.2f),0,0,0,349);
var longRope=GrapplerMotion.Swing(new(100,-100,.2f),0,0,0,350);
Check(shortRope.X==47.5f&&longRope.X==49,"350 damping boundary after50 clamp");
var tick=GrapplerMotion.Swing(new(50,50,0),.6f,0,0,400);
Near(tick.X,49,"one damping per callback");Near(tick.Elapsed,.4f,"remainder retained");
Console.WriteLine("PASS strict overshoot, clamp/damping threshold and one-step timing");
Check(GrapplerMotion.JumpDetaches(true,false,true),"jump detaches");
Check(!GrapplerMotion.JumpDetaches(true,true,true)&&!GrapplerMotion.JumpDetaches(false,false,true)
&&!GrapplerMotion.JumpDetaches(true,false,false),"independent fire/jump/attached predicates");
Console.WriteLine("PASS simultaneous fire prevents jump detach");
Reject(()=>GrapplerMotion.HeldReel(300,-.1f));Reject(()=>GrapplerMotion.FastReel(300,0,float.NaN));
Reject(()=>GrapplerMotion.Attach(new(float.PositiveInfinity,0,0),Vector3.Zero,Vector3.Zero));
Reject(()=>GrapplerMotion.Swing(new(0,0,float.NaN),.1f,0,0,400));
Console.WriteLine("PASS nonfinite and unsupported timestep boundaries");
Console.WriteLine("Grappler:5 scalar groups; ray/body/camera/lifetime and live VR08 integration remain separate gates.");
static void Check(bool ok,string message){if(!ok)throw new Exception(message);}
static void Near(float actual,float expected,string message)=>Check(float.IsFinite(actual)&&MathF.Abs(actual-expected)<.0002f,$"{message}: {actual} != {expected}");
static void Reject(Action action){try{action();throw new Exception("Invalid scalar state accepted");}catch(ArgumentOutOfRangeException){}}
@@ -0,0 +1,515 @@
{
"source_sha256": "f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8",
"ranges": [
{
"kind": "attach",
"va": "0x426be8",
"end_va": "0x426c70",
"file_offset": "0x26be8",
"sha256": "afefa8d85ac6fb17d71ad2841570e88819b4159e911f037cd5e1f5edab127a7b"
},
{
"kind": "held",
"va": "0x426dac",
"end_va": "0x426dd5",
"file_offset": "0x26dac",
"sha256": "b59ca8ba618e4ae7b5486e850ef97b353bc12254c03274bf41159fa70e5df4c5"
},
{
"kind": "fast",
"va": "0x429dc9",
"end_va": "0x429df5",
"file_offset": "0x29dc9",
"sha256": "51e8557c6f1183ba5bb7d125ad48aba9cdcae3698ef93308e47e0cf4e83ac3aa"
},
{
"kind": "swing",
"va": "0x42a077",
"end_va": "0x42a1a2",
"file_offset": "0x2a077",
"sha256": "5599448797384fa4c5be142d41e1592d0e71db9ecafe7a235d18636033699415"
}
],
"scope": "Isolated scalar prefixes/suffixes; no ray, body, camera, renderer or original gameplay execution",
"generator_sha256": "c51cc1ecefaf7a90e69a40624fd0e8cd7e01500359c4e67aee6213bb36f4a810",
"executable_sha256": "6168b4ed3e65c094a9d28a79a9a5e2f13b499e487d631081b57c708569ad2b88",
"log_sha256": "83814ffeb801e329126a00677f680d159dc2ab44e540843571233004f8565db5",
"cases": [
{
"kind": "attach",
"name": "first",
"input": [
0.0,
0.0,
0.0,
0.0,
300.0,
400.0,
0.0
],
"observed": [
400.0,
400.0,
0.666666687,
1.0
]
},
{
"kind": "attach",
"name": "retained",
"input": [
0.0,
0.0,
0.0,
0.0,
600.0,
800.0,
400.0
],
"observed": [
900.0,
400.0,
12345.0,
0.0
]
},
{
"kind": "attach",
"name": "fraction",
"input": [
1.25,
-30.75,
48.125,
634.625,
413.75,
-95.125,
0.0
],
"observed": [
686.933716,
686.933716,
1.14488959,
1.0
]
},
{
"kind": "attach",
"name": "short",
"input": [
0.0,
0.0,
0.0,
0.0,
50.0,
0.0,
0.0
],
"observed": [
-50.0,
-50.0,
-0.0833333358,
1.0
]
},
{
"kind": "attach",
"name": "zero",
"input": [
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0
],
"observed": [
-100.0,
-100.0,
-0.166666672,
1.0
]
},
{
"kind": "attach",
"name": "negative",
"input": [
-130.0,
315.0,
-490.0,
-530.0,
-285.0,
310.0,
0.0
],
"observed": [
977.032959,
977.032959,
1.62838829,
1.0
]
},
{
"kind": "attach",
"name": "same_first",
"input": [
0.0,
0.0,
0.0,
0.0,
300.0,
400.0,
400.0
],
"observed": [
400.0,
400.0,
12345.0,
0.0
]
},
{
"kind": "attach",
"name": "negative_first",
"input": [
0.0,
0.0,
0.0,
0.0,
300.0,
400.0,
-100.0
],
"observed": [
400.0,
-100.0,
12345.0,
0.0
]
},
{
"kind": "held",
"name": "above",
"input": [
251.0,
0.0,
0.100000001
],
"observed": [
226.0
]
},
{
"kind": "held",
"name": "equal",
"input": [
250.0,
0.0,
0.100000001
],
"observed": [
250.0
]
},
{
"kind": "held",
"name": "below",
"input": [
249.0,
0.0,
0.100000001
],
"observed": [
249.0
]
},
{
"kind": "held",
"name": "negative",
"input": [
-100.0,
0.0,
0.100000001
],
"observed": [
-100.0
]
},
{
"kind": "held",
"name": "long",
"input": [
300.0,
0.0,
0.600000024
],
"observed": [
150.0
]
},
{
"kind": "held",
"name": "tick",
"input": [
950.0,
0.0,
0.0166666675
],
"observed": [
945.833313
]
},
{
"kind": "fast",
"name": "above",
"input": [
251.0,
250.0,
0.100000001
],
"observed": [
156.0
]
},
{
"kind": "fast",
"name": "equal",
"input": [
250.0,
250.0,
0.100000001
],
"observed": [
250.0
]
},
{
"kind": "fast",
"name": "below",
"input": [
249.0,
250.0,
0.100000001
],
"observed": [
249.0
]
},
{
"kind": "fast",
"name": "negative_target",
"input": [
50.0,
-200.0,
0.100000001
],
"observed": [
-45.0
]
},
{
"kind": "fast",
"name": "long",
"input": [
300.0,
0.0,
0.600000024
],
"observed": [
-270.000031
]
},
{
"kind": "fast",
"name": "tick",
"input": [
950.0,
0.0,
0.0166666675
],
"observed": [
934.166687
]
},
{
"kind": "swing",
"name": "free",
"input": [
10.0,
20.0,
0.0,
0.100000001,
100.0,
-200.0,
400.0
],
"observed": [
8.30000019,
23.3999996,
0.100000001
]
},
{
"kind": "swing",
"name": "equal",
"input": [
50.0,
-50.0,
0.0,
0.200000003,
0.0,
0.0,
400.0
],
"observed": [
49.0,
-49.0,
0.0
]
},
{
"kind": "swing",
"name": "short",
"input": [
100.0,
-100.0,
0.200000003,
0.0,
0.0,
0.0,
349.0
],
"observed": [
47.5,
-47.5,
0.0
]
},
{
"kind": "swing",
"name": "long",
"input": [
100.0,
-100.0,
0.200000003,
0.0,
0.0,
0.0,
350.0
],
"observed": [
49.0,
-49.0,
0.0
]
},
{
"kind": "swing",
"name": "one_damping",
"input": [
50.0,
50.0,
0.0,
0.600000024,
0.0,
0.0,
400.0
],
"observed": [
49.0,
49.0,
0.400000036
]
},
{
"kind": "swing",
"name": "offset",
"input": [
60.0,
-55.0,
0.189999998,
0.0199999996,
102.0,
-73.0,
349.899994
],
"observed": [
47.5,
-47.5,
0.00999999046
]
},
{
"kind": "swing",
"name": "near_clamp",
"input": [
49.9999886,
-49.9999886,
0.189999998,
0.0199999996,
-9.99999975e-05,
9.99999975e-05,
400.0
],
"observed": [
48.9999886,
-48.9999886,
0.00999999046
]
},
{
"kind": "swing",
"name": "tick",
"input": [
4.125,
-2.75,
0.189999998,
0.0166666675,
170.125,
-333.75,
350.0
],
"observed": [
3.57011962,
-1.76828754,
0.00666666031
]
},
{
"kind": "swing",
"name": "below_time",
"input": [
8.0,
9.0,
0.189999998,
0.00899999961,
90.0,
-65.0,
800.0
],
"observed": [
7.86229992,
9.09945011,
0.199000001
]
},
{
"kind": "swing",
"name": "negative_length",
"input": [
5.0,
-6.0,
0.100000001,
0.200000003,
-200.0,
90.0,
-5.0
],
"observed": [
11.21,
-8.60700035,
0.100000009
]
}
]
}
+38
View File
@@ -0,0 +1,38 @@
"""Copied-original scalar observations, separate from body/visual/gameplay parity."""
import json
from pathlib import Path
import sys
import unittest
ROOT=Path(__file__).resolve().parents[1]
sys.path.insert(0,str(ROOT/'tools/binary'))
from grappler import attach_scalars,held_reel,fast_reel,swing_scalars
from grappler_motion import collect
class GrapplerScalarReferences(unittest.TestCase):
def test_hashed_scalar_ranges_and_reference_identity(self):
source=collect(ROOT.parent/'Original')
fixture=json.loads((ROOT/'tests/GamePort.GrapplerTests/original-scalar-reference.json').read_text())
self.assertEqual(fixture['source_sha256'],source['source_sha256'])
self.assertEqual(fixture['ranges'],source['ranges'])
self.assertEqual(len(fixture['cases']),30)
self.assertEqual([r['kind'] for r in source['ranges']],['attach','held','fast','swing'])
def test_all_thirty_native_scalar_observations(self):
fixture=json.loads((ROOT/'tests/GamePort.GrapplerTests/original-scalar-reference.json').read_text())
for case in fixture['cases']:
with self.subTest(case['kind']+'/'+case['name']):
p=case['input'];observed=case['observed']
if case['kind']=='attach':
a=attach_scalars(p[:3],p[3:6],initial_length=p[6])
actual=[a.length,a.initial_length]
self.assertEqual(a.scale_z is not None,observed[3]==1)
if a.scale_z is not None:actual.append(a.scale_z)
elif case['kind']=='held':actual=[held_reel(p[0],p[2])]
elif case['kind']=='fast':actual=[fast_reel(*p)]
else:actual=swing_scalars(*p)
for a,b in zip(actual,observed):self.assertAlmostEqual(a,b,delta=.0002)
if __name__=='__main__':unittest.main()
+63
View File
@@ -0,0 +1,63 @@
#!/usr/bin/env python3
"""Guarded Grappler scalar spans and copied-original reference import.
No target execution here. Probe execution uses reference_capture.py with a
generated Win32 harness and copied installation in a separate namespace.
"""
import argparse
from collections import Counter
import hashlib
import json
from pathlib import Path
import re
from grappler import collect as source_contract
from checkpoint_script_state import find_case, read_va
from pe_inspect import PE
RANGES=(('attach',0x426be8,0x426c70),('held',0x426dac,0x426dd5),
('fast',0x429dc9,0x429df5),('swing',0x42a077,0x42a1a2))
def collect(original):
contract=source_contract(original)
pe=PE(find_case(Path(original),'Neutron.exe'))
return dict(source_sha256=contract['sha256'],ranges=[dict(kind=kind,va=hex(start),
end_va=hex(end),file_offset=hex(pe.offset(start-pe.base)),
sha256=hashlib.sha256(read_va(pe,start,end-start)).hexdigest()) for kind,start,end in RANGES],
scope='Isolated scalar prefixes/suffixes; no ray, body, camera, renderer or original gameplay execution')
def reference(original,log,executable):
result=collect(original)
log=Path(log);text=log.read_text()
if 'GRAPPLER_SCALARS_COMPLETE' not in text:raise ValueError('Probe did not finish')
cases=[]
for line in text.splitlines():
m=re.fullmatch(r'CASE (attach|held|fast|swing) (\w+) in=([^ ]+) out=([^ ]+)',line)
if not m:continue
kind,name,inputs,outputs=m.groups()
cases.append(dict(kind=kind,name=name,input=[float(x) for x in inputs.split(',')],
observed=[float(x) for x in outputs.split(',')]))
if Counter(c['kind'] for c in cases)!=dict(attach=8,held=6,fast=6,swing=10):
raise ValueError('Incomplete or duplicate scalar cases')
result.update(generator_sha256=hashlib.sha256(Path(__file__).with_name('grappler_scalar_probe.c').read_bytes()).hexdigest(),
executable_sha256=hashlib.sha256(Path(executable).read_bytes()).hexdigest(),
log_sha256=hashlib.sha256(log.read_bytes()).hexdigest(),cases=cases)
return result
if __name__=='__main__':
cli=argparse.ArgumentParser(description=__doc__)
cli.add_argument('original',type=Path);cli.add_argument('--log',type=Path)
cli.add_argument('--executable',type=Path);cli.add_argument('--output',type=Path)
args=cli.parse_args()
if bool(args.log)!=bool(args.executable):cli.error('--log and --executable are required together')
if args.output:
source=args.original.resolve();target=args.output.resolve()
if target.is_relative_to(source) or source.is_relative_to(target):
cli.error('Output must be separate from originals')
result=reference(args.original,args.log,args.executable) if args.log else collect(args.original)
text=json.dumps(result,indent=2)+'\n'
if args.output:args.output.parent.mkdir(parents=True,exist_ok=True);args.output.write_text(text)
else:print(text,end='')
+96
View File
@@ -0,0 +1,96 @@
/* Isolated copied EXE scalar slices. No game entrypoint, ray, body or renderer.
Absolute scalar operands are relocated into the private copied image. */
#include <windows.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TC __attribute__((thiscall))
static unsigned char*mapped;
#define AT(a) (mapped+(a)-0x400000)
#define F(a) (*(float*)AT(a))
static unsigned char object[0x1f00],hook[0x600],shape[16];
static uintptr_t shape_table[0x40/4];
static float scale_z;static int scale_calls;
static void require(int ok,const char*why){if(!ok){fprintf(stderr,"FAIL %s\n",why);exit(2);}}
static void TC scale(void*self,float x,float y,float z){require(self==shape&&x==1&&y==1,"shape scale arguments");scale_z=z;scale_calls++;}
static void map_source(void){
FILE*f=fopen("Neutron.exe","rb");require(f!=NULL,"generated EXE copy");fseek(f,0,SEEK_END);long size=ftell(f);rewind(f);
require(size==1019904,"EXE size");unsigned char*d=malloc(size);require(d!=NULL,"buffer");require(fread(d,1,size,f)==(size_t)size,"read");fclose(f);
require(*(uint16_t*)d==IMAGE_DOS_SIGNATURE,"DOS");uint32_t off=*(uint32_t*)(d+0x3c);
require(off<(uint32_t)size-sizeof(IMAGE_NT_HEADERS32),"NT bounds");IMAGE_NT_HEADERS32*nt=(void*)(d+off);
require(nt->Signature==IMAGE_NT_SIGNATURE&&nt->FileHeader.Machine==IMAGE_FILE_MACHINE_I386&&nt->OptionalHeader.ImageBase==0x400000&&nt->OptionalHeader.SizeOfImage==0x299000,"PE identity");
unsigned char*m=VirtualAlloc(NULL,0x299000,MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE);require(m!=NULL,"private source map");mapped=m;
IMAGE_SECTION_HEADER*s=IMAGE_FIRST_SECTION(nt);require((unsigned char*)(s+nt->FileHeader.NumberOfSections)<=d+size,"sections");
for(unsigned i=0;i<nt->FileHeader.NumberOfSections;i++){
require((uint64_t)s[i].PointerToRawData+s[i].SizeOfRawData<=(uint64_t)size&&(uint64_t)s[i].VirtualAddress+s[i].SizeOfRawData<=0x299000,"section bounds");
memcpy(m+s[i].VirtualAddress,d+s[i].PointerToRawData,s[i].SizeOfRawData);
}free(d);
shape_table[0x34/4]=(uintptr_t)scale;*(void**)shape=shape_table;*(void**)(hook+0x57c)=shape;*(void**)(object+0xb0c)=hook;
}
static void relocate(uint32_t start,uint32_t end){
const uint32_t operands[]={0x48d96c,0x48d914,0x4a3e5c,0x4f82b8,0x4f82b4,0x4a3e58,0x4f82c8,0x4a3e88,
0x4f82bc,0x4f82c0,0x4f82c4,0x4a3e80,0x4a2ad0,0x48d400,0x4a3e78,0x49fae4,0x4a3e74,0x4a3e70,0x4a3e6c};
for(uint32_t a=start;a+4<=end;a++){
uint32_t value;memcpy(&value,AT(a),4);
for(unsigned i=0;i<sizeof(operands)/sizeof(operands[0]);i++)if(value==operands[i]){
uint32_t relocated=(uintptr_t)AT(value);memcpy(AT(a),&relocated,4);a+=3;break;
}
}
}
static void emit_byte(unsigned char**p,unsigned char x){*(*p)++=x;}
static void word(unsigned char**p,uint32_t x){memcpy(*p,&x,4);*p+=4;}
static void jump(unsigned char*p,void*target){*p=0xe9;int32_t delta=(unsigned char*)target-p-5;memcpy(p+1,&delta,4);}
static void stack_copy(unsigned char**p,int src,int dest){
emit_byte(p,0x8b);emit_byte(p,0x48);emit_byte(p,src); /* ecx=[eax+src] */
emit_byte(p,0x89);emit_byte(p,0x8c);emit_byte(p,0x24);word(p,dest);
}
static void*wrapper(uint32_t entry,uint32_t exit1,uint32_t exit2,int kind){
unsigned char*code=VirtualAlloc(NULL,256,MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE);require(code!=NULL,"thunk");unsigned char*p=code;
emit_byte(&p,0x53);emit_byte(&p,0x55);emit_byte(&p,0x56);emit_byte(&p,0x57); /* save all nonvolatile registers */
emit_byte(&p,0x81);emit_byte(&p,0xec);word(&p,0xa0);
emit_byte(&p,0x8b);emit_byte(&p,0x84);emit_byte(&p,0x24);word(&p,0xb4); /* eax=args */
if(kind==0){stack_copy(&p,0,0x10);stack_copy(&p,4,0x14);stack_copy(&p,8,0x18);}
else if(kind==1)stack_copy(&p,0,0x54);
else {stack_copy(&p,0,0x98);if(kind==3){stack_copy(&p,4,0x0c);stack_copy(&p,8,0x14);}}
emit_byte(&p,0xbe);word(&p,(uintptr_t)object);emit_byte(&p,0xb8);word(&p,(uintptr_t)AT(0x4f8214));
jump(p,AT(entry));p+=5;unsigned char*epilogue=p;
emit_byte(&p,0x81);emit_byte(&p,0xc4);word(&p,0xa0);emit_byte(&p,0x5f);emit_byte(&p,0x5e);emit_byte(&p,0x5d);emit_byte(&p,0x5b);emit_byte(&p,0xc3);
jump(AT(exit1),epilogue);if(exit2)jump(AT(exit2),epilogue);return code;
}
typedef void(*run_fn)(float*);
static run_fn attachment,held,fast,damping;
static void attach_case(const char*name,float x,float y,float z,float ax,float ay,float az,float first){
float args[]={x,y,z};F(0x4f8214)=ax;F(0x4f8218)=ay;F(0x4f821c)=az;F(0x4f82b4)=first;F(0x4f82b8)=123;
scale_z=12345;scale_calls=0;attachment(args);
printf("CASE attach %s in=%.9g,%.9g,%.9g,%.9g,%.9g,%.9g,%.9g out=%.9g,%.9g,%.9g,%d\n",name,x,y,z,ax,ay,az,first,F(0x4f82b8),F(0x4f82b4),scale_z,scale_calls);
}
static void reel_case(const char*name,int is_fast,float length,float target,float dt){
float args[]={dt};F(0x4f82b8)=length;F(0x4f82c8)=target;(is_fast?fast:held)(args);
printf("CASE %s %s in=%.9g,%.9g,%.9g out=%.9g\n",is_fast?"fast":"held",name,length,target,dt,F(0x4f82b8));
}
static void swing_case(const char*name,float x,float z,float timer,float dt,float ox,float oz,float length){
float args[]={dt,ox,oz};F(0x4f82bc)=x;F(0x4f82c0)=z;F(0x4f82c4)=timer;F(0x4f82b8)=length;damping(args);
printf("CASE swing %s in=%.9g,%.9g,%.9g,%.9g,%.9g,%.9g,%.9g out=%.9g,%.9g,%.9g\n",name,x,z,timer,dt,ox,oz,length,F(0x4f82bc),F(0x4f82c0),F(0x4f82c4));
}
int main(void){
map_source();relocate(0x426be8,0x426c70);relocate(0x426dac,0x426dd5);relocate(0x429dc9,0x429df5);relocate(0x42a077,0x42a1a2);
attachment=wrapper(0x426be8,0x426c70,0,0);held=wrapper(0x426dac,0x426dd5,0x426dfd,1);
fast=wrapper(0x429dc9,0x429df5,0,2);damping=wrapper(0x42a077,0x42a1a2,0,3);
attach_case("first",0,0,0,0,300,400,0);attach_case("retained",0,0,0,0,600,800,400);
attach_case("fraction",1.25f,-30.75f,48.125f,634.625f,413.75f,-95.125f,0);
attach_case("short",0,0,0,0,50,0,0);attach_case("zero",0,0,0,0,0,0,0);
attach_case("negative",-130,315,-490,-530,-285,310,0);
attach_case("same_first",0,0,0,0,300,400,400);attach_case("negative_first",0,0,0,0,300,400,-100);
reel_case("above",0,251,0,.1f);reel_case("equal",0,250,0,.1f);reel_case("below",0,249,0,.1f);
reel_case("negative",0,-100,0,.1f);reel_case("long",0,300,0,.6f);reel_case("tick",0,950,0,1.f/60);
reel_case("above",1,251,250,.1f);reel_case("equal",1,250,250,.1f);reel_case("below",1,249,250,.1f);
reel_case("negative_target",1,50,-200,.1f);reel_case("long",1,300,0,.6f);reel_case("tick",1,950,0,1.f/60);
swing_case("free",10,20,0,.1f,100,-200,400);swing_case("equal",50,-50,0,.2f,0,0,400);
swing_case("short",100,-100,.2f,0,0,0,349);swing_case("long",100,-100,.2f,0,0,0,350);
swing_case("one_damping",50,50,0,.6f,0,0,400);swing_case("offset",60,-55,.19f,.02f,102,-73,349.9f);
swing_case("near_clamp",49.99999f,-49.99999f,.19f,.02f,-.0001f,.0001f,400);
swing_case("tick",4.125f,-2.75f,.19f,1.f/60,170.125f,-333.75f,350);
swing_case("below_time",8,9,.19f,.009f,90,-65,800);swing_case("negative_length",5,-6,.1f,.2f,-200,90,-5);
puts("GRAPPLER_SCALARS_COMPLETE");return 0;
}