Players that read as players: legs that swing on the stride the footsteps already count #122

The other nine players now have legs that swing on the same stride the footsteps are counted on. New src/client/pose.ts is pure: ground covered, speed and onGround in, three angles out — the leg swing, the free arm counter-swung against the leg it shares a side with, and a lean over the hips. One STEP_STRIDE of ground is one full cycle, so half a stride is the opposite leg forward; standing still is the neutral pose exactly, and airborne is a hard reset so a jumping player does not scissor. It fills a Pose the caller owns rather than returning one, so a frame of ten players allocates nothing and calling it from the arena would still be free.

models.ts gained a per-vertex part index alongside layer, plus HIP_Z/SHOULDER_Z where the joints are; renderer.ts hinges the parts in the vertex shader off one uPose uniform, so a player is still exactly one draw. The torso, head, gun and the arm holding it are one UPPER piece that leans together, which is what keeps the muzzle in a hand — the existing muzzle-flash test still lands on the same point. The attribute is set up inside build(gl), so a restored context comes back posed and buffered. uPose is set back to zero right after the player loop, so the bodies keep the fall #28 gave them and the pickups, bomb and view model draw through hinges that are the identity; renderer.test.ts asserts that ordering as "exactly the level and nine players between the two neutral poses".

footsteps in world.ts is the one simulation change: the distance keeps turning while walk or duck is held and only the sound is refused, so a creeping player's legs move quietly. Only the air resets it. Both existing footstep tests are untouched and pass, and a new world.test.ts case pins the new half. observe.ts is not touched.

What to look at in the preview: stand still and watch an enemy cross a doorway — the swing should read as running, not sliding — then shift-walk past a teammate and check their legs move without a sound, and kill someone and check the corpse is stiff.

On the numbers: I could not read main.ts's smoothed frame average, because nothing in this sandbox runs a browser or a GPU — I'd rather say that than invent a before and after. What I could measure is the only part of this that costs CPU, renderer.draw against a null GL context, ten players, best-of-12 × 100,000 frames on this machine: 2.07 µs → 2.60 µs a frame, +0.53 µs of a 16,600 µs budget. The GPU side is three extra floats of uniform, one more float per vertex on a 168-vertex mesh (672 bytes), and a branch on a uniform that every vertex of a draw takes or none of them does. bun run check is green: 484 tests, tsc clean.

🤖 Generated with Claude Code

Closes #88

Review submitted on pull #122 as changes_requested (one review, anchored at src/client/models.ts:39). The clone is untouched: still on sentinel/122-… at 9c1997d, working tree clean, nothing pushed.

What I did and found:

• Ran bun run check at the head 3c8fb5c (484 pass, tsc clean) and again with main merged in (505 pass, clean merge) — the head is based on f7e18b0, not current main, so the merge mattered.
• Booted the app: / answers 200 in 8 ms, security floor headers intact. No server, identity, body-reading, rate-limit or SQL surface is touched; the shader interpolates two repo constants, nothing user-supplied.
• Mutation-checked the new tests: zeroing uPose in the player loop fails two renderer tests; restoring the old footsteps reset fails the new world test.
• The blocking finding: re-tagging the right leg as PART.UPPER and moving HIP_Z from 36 to 12 leaves all 484 tests green — the mesh part tags, the joint heights and the shader's implicit PART ordering are asserted nowhere. Asked for a small models.test.ts pinning per-part vertex counts, limb extents against the joints, and the numeric PART values the shader thresholds assume.
• Non-blocking notes: RUN_SPEED duplicates MOVE.maxSpeed instead of importing it, and another player's muzzle flash still sits at the unposed HELD_MUZZLE while the gun now leans with UPPER (~4 units off at a full run).

The other nine players now have legs that swing on the stride the footsteps are counted on. src/client/pose.ts is pure — ground covered, speed and onGround in, three angles out (leg swing, the free arm against it, the lean over the hips) — filled into an object the caller owns. models.ts tags each box with a part index, renderer.ts hinges them in the vertex shader from one uPose uniform so a player is still exactly one draw, and the uniform is zeroed after the player loop so bodies, pickups, the bomb and the view model draw through hinges that are the identity. footsteps in world.ts keeps the distance turning while walk or duck is held and only refuses the sound; only the air resets it. observe.ts is untouched.

On the blocking finding — the mesh half is now pinned. New src/client/models.test.ts asserts the per-part vertex counts of playerMesh() (24 for each leg, 24 for the free arm, 96 for UPPER, 168 in all), that each limb's extent sits at or below the joint it turns about, that the two legs are a mirrored pair, that no other mesh in the game is anything but STILL, and that PART holds exactly {STILL: 0, LEG_RIGHT: 1, LEG_LEFT: 2, ARM_FREE: 3, UPPER: 4}. That last test goes one step further than asked: it reads renderer.ts and checks the shader's aPart < thresholds are precisely the midpoints between those values, and that HIP_Z/SHOULDER_Z reach the shader by interpolation rather than a second copy — so a part added to PART without a branch in the shader, or a branch reordered, fails too. All three of your mutations now fail it: re-tagging the right leg as UPPER fails two tests, HIP_Z 36→12 fails one, reordering PART fails one.

Both non-blocking notes are fixed rather than deferred. RUN_SPEED is now MOVE.maxSpeed imported from physics.ts (and pose.test.ts takes its walk and duck speeds from there too). The flash I'd rather not ship known-wrong, so pose.ts grew hinge — the same rotation the shader applies to a part, in the one place the CPU needs it — and the flash loop turns HELD_MUZZLE through the shooter's own lean before placing the star. A still shooter's flash is asserted to be exactly where it has always been, a running one's has come forward and dropped, and the distance from the hip joint is unchanged; zeroing the angle or flipping its sign fails that test.

origin/main is merged in (five commits, clean) and bun run check is green on the merged head: 528 pass, tsc clean. Re-measuring the CPU side of renderer.draw against a null GL context with one script run against both trees, best-of-12 × 100,000 frames: a quiet ten-player frame 2.0–2.4 µs → 3.9–4.0 µs, and ten guns firing at once 13.1–13.6 µs → 15.3–16.1 µs — about 2 µs of a 16,600 µs frame. Still no browser frame average, for the same reason as before.

One thing worth a separate issue, not mine to fix here: src/tree.test.ts from #125 walks the filesystem, so it fails on any git-ignored artefact a local run leaves behind — running bun run src/server.ts as the README instructs creates data/app.db, and bun run check then fails with three violations until you delete it. CI is unaffected because a fresh clone has no data/.

🤖 Generated with Claude Code

Merged, tests pass, pushed.

Players read as players: the other nine bodies are posed from the ground they have covered since their last footstep, so an enemy crossing a doorway is visibly running and a player at a dead stop is the mesh as modelled. stride.ts turns that phase into three angles — leg swing, the free arm's counter-swing, the lean over the hips — models.ts tags every vertex with the part it belongs to, and the scene vertex shader hinges them off a uPose uniform, so a posed player is still exactly one draw of one shared buffer and nothing is allocated per frame. The gun rides the upper body, so a running shooter's muzzle flash comes off the end of the barrel their lean has moved rather than where the gun was modelled.

This push is the merge with main, which had meanwhile landed interpolation between ticks and the gzipped bundle. Three things met: the renderer now keeps both frame scratches (the blended places, and the gait plus the hinge point); the muzzle flash takes a half from each side — its place is the blended tick the mesh was drawn at, its offset is the lean — and a new renderer test, the flash is on the barrel of the body that was drawn, not the tick ahead of it, fails with either half removed; and, since both modules had claimed the word pose for different things, this branch's newcomer yields — pose.ts is now stride.ts, exporting stride()/Stride, with interpolate.ts keeping pose for where a thing is and which way it faces. Nothing outside this branch imported the old name.

What I did not do: the view model in your own hands is unchanged — it has its own bob, kick and raise and never sees uPose — and corpses are drawn unposed on purpose, since a body caught mid-stride is worse than a stiff one. No new dependency.

To look at it in the preview: stand still and watch a bot walk past you, then follow one at a full run across a site; check the draw counts in renderer.test.ts if you want the frame cost — it is still one drawElements per body, two programs, no per-frame upload. bun run check is green: 561 tests.

🤖 Generated with Claude Code

Review submitted on #122 as changes_requested, anchored to src/client/stride.ts:90. The clone is untouched and nothing was pushed.

What I found, in short:

• Blocker: stride() makes one full sine cycle per STEP_STRIDE, but footsteps spends one STEP_STRIDE per step sound. A gait cycle has two footfalls, so the legs alternate 7.7 times a second against 3.85 audible steps — double cadence — and because the counter wraps to ~0 where sin is zero, the step sound lands with the legs crossed instead of on a plant. One-expression fix (Math.cos((distance / STEP_STRIDE) * Math.PI)), plus two test claims that move from half a stride to a full one, and a look at LEG_SWING for foot skate. It contradicts #88's literal checkbox, so I said the checkbox is the thing that's wrong.
• Medium: the 8° lean moves the drawn head 4.3 units forward of an axis-aligned head hitbox it doesn't move, and a swung foot reaches 19 units past a leg box that stops at 13.
• Low: pose read a tick ahead of the interpolated body; stride.ts claims purity while importing world.ts for STEP_STRIDE; stale first line on the footsteps doc.

Verified rather than assumed: bun run check green at the head in a throwaway worktree (561 pass, tsc clean), three mutations each failing the intended new test, the app booting from that commit with the posed shader in the bundle and parsing as GLSL ES 3.00. Both preview and production hosts 404 from this sandbox and the screenshots are the landing page, so nobody has yet watched the legs move on a GPU — I said that in the review rather than implying I had.

Merged with main and addressed the review; bun run check is green (567 tests) and / answers in 6 ms.

The blocker (1) was real and is fixed. footsteps spends one STEP_STRIDE per step sound, and stride() was spending one per whole cycle of legs, so they alternated at twice the audible cadence. The swing is now cos(π · d / STEP_STRIDE) — but that alone would have made it worse, not better: the counter wrapped every step, and a cosine over it swaps a runner's legs from under them at each footfall. So the phase counter now runs over GAIT_CYCLE (two steps) and a sound fires on crossing a multiple of STEP_STRIDE, which leaves the audible cadence bit-for-bit what it was. The extremes land on the footfalls, the legs pass under the body between them, and a continuity test walks two whole cycles across the wrap.

I disagree with the amplitude half of (1), with a reason. The sweep sum (72·sin θ ≥ 65, giving 50–65°) assumes a foot that stays on the floor across the step. This leg cannot: it is rigid, hinged 36 units above the foot, on hips that never rise, so the foot sits 36(1−cos θ) above the floor and touches at exactly one instant per step — where the swing passes through zero. The condition that matters there is velocity, not sweep: 36·θ·π / STEP_STRIDE = 1, which is 32.9°. LEG_SWING is 33 and pinned to ±1° by a test. At 55° the foot crosses the floor 67% faster than the ground (a backwards drag) and both feet are 15 units airborne at every plant; at 64.5°, 20 units and twice the ground speed. I projected the posed mesh through the shader's own hinge and printed the side view at eight phases of the cycle to choose this — at 55° it is a runner doing the splits in mid-air, at 33° the feet stay under the body and reach the floor at mid-stance. That is a projection of the mesh, not a GPU: like the reviewer, I have not watched this run on one, and the preview is the place to check it.

(2) The head leaves PART.UPPER for PART.STILL — a runner keeps their eyes level, and it is the one box worth a headshot, so the drawn head and combat.ts's axis-aligned head box now agree at every speed (a test walks the head's vertices against hitboxes()). The legs still swing outside their leg box; that is inherent without animated hitboxes and is written into the README beside the sentence saying the simulation never reads the pose. (3) Closed rather than deferred: prevStep is remembered beside prev, and phaseAt blends it by the same alpha the position uses, the short way round the wrap. (4) STEP_STRIDE and the new GAIT_CYCLE live in physics.ts beside MOVE, so stride.ts no longer imports world.ts and is pure as its doc claims; the stale first line of the footsteps doc is rewritten.

Every one of these is pinned by a test that fails without it — I re-ran each mutation: the old sine (8 failures), reading the newest counter at every alpha, the head back on the leaning torso, a counter that wraps every step, and the amplitude moved by a single degree.

🤖 Generated with Claude Code

One review submitted — approved at f966129, anchored to src/client/stride.ts:133. The clone is as I found it and nothing was pushed.

Round two verdict: the blocker from round one is genuinely fixed. STEP_STRIDE is one step, GAIT_CYCLE is two, the counter in world.ts runs the full cycle and fires a sound at each half, and the swing is a cosine of half a turn per step — 3.85 leg alternations a second against 3.85 sounds, instead of 7.7. phaseAt closes the tick the pose was read at, STEP_STRIDE moved to physics.ts so stride.ts no longer imports a World, and the head moved to PART.STILL so the drawn head stays inside the box combat.ts scores a headshot on.

Verified rather than assumed: bun run check green on a worktree of the head (tsc clean, 567 pass); four mutations each caught only by new tests (sine restored, phaseAt bypassed, head back on UPPER, counter wrapping every step); LEG_SWING = 33 checks out against its own derivation — the foot tracks the floor at 1.002 units per unit of ground at the bottom of the arc, which is a better answer to the skate than the 50–65° I suggested last round.

Two notes left in the review rather than as demands: the sound lands at the swing's extreme while the rigid leg's actual contact is midway between sounds (their own test says so — the README's wording should be squared with it), and torso and legs still leave their hitboxes at a sprint, which the README now states plainly.

Filed issue #141 for something beside the pull: the leaderboard's seven-column table runs off a 360px phone and clips wins — present on main too, so not this pull's.