Action Sandbox: one game character, rebuilt byte by byte

Missing evidence stays missing, rather than being filled in with a number that merely looks right.

The goal

The goal is a controllable Zenless Zone Zero character in an empty black room, covering movement, sprinting, turning, combos, hit reactions, flight, cloth, face, lighting and camera, with nothing else on screen so that each mechanism can be watched on its own.

It's a study rather than a game, so there are no enemies, no damage numbers and no menus, and nothing gets released. If a feature doesn't help me observe a mechanism, it's out of scope.

An evidence pipeline, not a game project

Every behaviour in the sandbox has to trace back to a source, which is why the work runs as a pipeline that moves through read-only copies of the game, static extraction, normalised tables, the Unity rebuild, isolated observation, then captures, numerical gates and independent review.

Sources are ranked, so the game's own data is read first, byte by byte, with disassembly coming next and frame captures after that. When none of the three can answer a question, the answer is written down as unverified, rather than putting a plausible default in its place.

6 bytes

between two controller files, which set three transition gates

483,822

field definitions recovered without running the game

3,299.98 mm

per run cycle, across sixteen measured cycles

0 ULP

between six cloth rest lengths and the game’s runtime values

96.7%

of pixel-shader lines aligned across two builds

0 px

difference between decoded lightmaps and the reference

Reading the game without running it

The game's scripts are compiled to native code with IL2CPP, so their types aren't just lying around. Instead, a Python decoder and a C# writer rebuild the type metadata from copied files, without ever executing the game, which recovers 483,822 field definitions, emitted in their original declaration order.

The tool checks the exact SHA-256 of every input and refuses any other build, because a wrong build can still produce numbers that look fine. On top of that, asset reads are only accepted when the reader consumes exactly the expected number of bytes.

Six bytes, three transitions

Two copies of the character's animation controller, both 62,088 bytes, differed in exactly six bytes, and once those are mapped field by field, they turn three run-to-stop transitions from immediate into gated at frames 69, 89 and 108 of a 114-frame clip.

The rebuilt controller keeps all 53 states, real blend trees with their thresholds and time scales, frame-count gates and the game's own 44 transition-offset edges, because rebuilding only the shape of the graph would look right while still turning at the wrong moment.

Motion, measured in millimetres

Root motion is a contract between baked clip data and runtime flags, so both of them have to move together. Under the audited setup, sixteen complete run cycles measured 3,299.984 to 3,299.991 mm each, compared with the clip's 3.3 m.

Timing follows the game's own frame phases rather than Unity's usual callbacks, which means animation is evaluated on the fixed 60 Hz step, input is written in Update, and the turning logic reads its values on the same side of evaluation as the game does. That matters because even the right value is still wrong if it arrives one frame late.

The cloth solver, rebuilt from the engine binary

Hair and skirt physics run in a solver that's compiled into the game's modified engine rather than its scripts, so its behaviour was recovered from the binary itself, which comes down to one integration and one pass per constraint each frame, in the order Elastic, Rigid, Angle, Collide, Stretch, using the game's own time-step and stiffness conversions.

The 3.2 additions, from capsule collision to horizontal springs, are rebuilt as separate switches, and the six front-skirt spring rest lengths match the game's runtime values at 0 ULP, which means right down to the last bit of a 32-bit float. Wherever a residual still remains, such as on the chest tassel, it's recorded as unsolved.

Shaders, light and post-processing

The shaders are ported against their register layout, so to work out which constant sits where, two builds of the same shader were aligned line by line (96.7% of pixel-shader lines matched). The character light, the nine-tap per-object shadows and the face's stencil-only hair pass all follow the captured frames.

Post-processing follows the game's chain in draw order, going through bloom, light shafts, temporal anti-aliasing, motion blur and then the final grading pass. The training room is also rebuilt from the game's scene files, and its HDR lightmaps decode with zero pixel difference from the reference.

The camera, in its own units

The camera's follow point is the model origin, which two independent sources confirmed bit for bit. Horizontal input is measured in degrees per second, while vertical input is measured in normalised elevation rather than degrees. The slight slide after the mouse stops actually comes from a 0.1-second deceleration ramp, rather than from smoothing.

How every claim is checked

Captures run on locked logical time, so two runs can be compared frame by frame. Spike detection uses thresholds computed per segment, because standing and running differ by two orders of magnitude, and on test data that brought false alarms down from 90 to 6.

A known-good baseline pins code, scenes, importer settings and the hashes of all 42 animation clips together. The work itself is split between AI agent lanes, with independent auditors who check each pinned revision, and even so, a passing baseline is never presented as proof that the sandbox equals the game.

An illustrative state graph rather than the game's data

      

Debug HUD

Idle

frame 0 / 60

Parameters

Open right now

    Kept private

    The character assets are extracted for offline study only, so nothing from the game is published here, and the state graph above is just an illustration rather than the game's actual data.

    C

    Calyndrae

    Designer and developer

    Next case studyPioneering