[user1303836]

#293 is merged into main, and this PR now targets main. It carries #293's review fixes and the fixes for every review thread on this PR. Everything a player sees or does beyond the realism overhaul: a computer opponent, fighting styles, Fight Night's corner, count, blind-side, parry and body-shot mechanics, a rebalanced engine whose bouts go rounds, physics knockouts, graphic gore and dismemberment, a broadcast presentation with commentary and a ring announcer, camera choices, records and CompuBox stats.

What players will notice

Fight the computer

• A player alone in an instance can call in a Rookie, Contender or Champion from the waiting screen. The computer boxes through the same server engine, snapshots, renderer, replay and result card as a person.
• Each level is a boxer with a name, a record and a fighting style of his own. He notices punches only after a reaction delay that depends on the level, answers with the evasion that actually works against that punch, keeps his range, jabs to set up, puts together combinations, goes to the body against a high guard, times late guard raises into perfect blocks, counters, circles off the ropes, holds when hurt, protects a shut eye and punches at his opponent's, gives his corner an instruction between rounds and has to beat the count like anyone else. He never fouls.
• Bouts against the computer are unrated; the result card says so, and Rematch calls the same boxer back.
• Difficulty, measured with scripted players over a 50 ms connection with a 6-9 tick reaction, 48 seeds a cell:
  • A skilled player beats the rookie every time, the contender 57% of the time and the champion 31%.
  • A counter-punching script beats them 100%, 23% and 10%.
  • A button-masher beats the rookie 79% of the time and almost never the others.
  • Each punch gets its own reaction (champion 5-8 ticks, contender 7-10, rookie 10-14), and the computer parries only as often as its perfect-block chance says.
• Doctor stoppages are an occasional finish:
  • Jabs no longer open cuts like power punches.
  • The doctor's limits (cut 800, swelling 900) live in the manifest, and the commentary's cut calls derive from them.
  • The exception is a one-sided beating: a scripted counter-puncher stops the rookie on cuts in about 3 bouts in 10.

Fighting styles

• Before every bout each fighter has ten seconds to pick how he boxes: balanced, boxer, slugger, swarmer or counter-puncher. A boxer's jab recovers faster and reaches further; a slugger hits harder and takes poise damage better but tires sooner and moves slower; a swarmer is quicker on his feet and with hooks and uppercuts and digs to the body; a counter-puncher's counters land harder in a wider window. The last pick is remembered; the computer picks at once and fights to its style.
• Hidden picks: each fighter's style stays hidden from the other corner until the bell, so waiting to counter-pick gains nothing.
• Style balance, measured on held-out seeds:
  • Scripted skilled-against-brawler play is 46-54% for every pair at 50 ms.
  • Computer against computer, every pair is 34-66%. The widest is the swarmer against the computer's boxer, 62-64% over 96 bouts: the infighter's edge over an out-boxer.

Fight Night mechanics

• The corner between rounds: close the cut, bring down the swelling, or catch your breath (keys 1/2/3, face buttons, or tap). The cutman works the brow, the eye, or holds a water bottle, and the broadcast says what each corner chose.
• The count: the standing fighter walks to the far neutral corner, the count runs to a mandatory eight even if the fighter is up earlier, the referee checks him, and the fight resumes on "Box!".
• The blind side: an eye swollen shut (700 eye damage) cannot see punches from that side; they cannot be slipped or perfectly blocked and land 20% harder. The plate shows the shut eye and the face closes it.
• Parry: a perfect block of a power punch staggers the puncher and roots him for the counter. Only a guard raised after being down for a moment (6 ticks) can parry, so flicking the guard blocks but never parries.
• Guard break: a block that wears the guard below 60 breaks it. The guard bar marks 60, and a spent guard drops the gloves to the chin.
• Angles: facing turns at most 75° a second, so circling at full speed takes an angle on a man who stands still, and his straight goes past.
• Judging: ring control counts in seconds and only in rounds where a clean punch landed, so it settles a close round but never wins one on its own.
• Body shots: they drain stamina, and a hard one on a fighter whose body is broken down drops him to one knee a moment later.
• Tired punches: a fighter with too little stamina still throws, slowly and weakly, instead of the key press being ignored.
• Bouts that go rounds: every bout used to end in round 1 in under a minute, because any clean shot stunned a fighter with his guard down and each further hit restarted the stun. Now a clean shot only makes a fresh fighter flinch; only a big counter, a power shot or an already hurt fighter is rocked, a stun cannot chain into a knockdown, blocked punches cost far less, and knockdowns come from accumulated damage lowering the poise a fighter can recover. Champion against champion now goes past round 1 in about three bouts in four and to the cards in about a quarter.
• The opening: round 1 opens with an eight-second introduction and glove touch; later rounds start at the bell. Fouls need Shift (Shift+1 low blow, Shift+2 headbutt) so a corner pick at the bell can never become one, and the referee separates the fighters after a foul.

Knockouts and gore

• Physics knockouts: the beaten fighter falls from the actual punch (head snapping along the blow; onto his back, his side or his knees; against the ropes and posts) and comes to rest; the slow-motion replay plays back the exact same fall, including for a flash knockout or a TKO that ends on the punch. Body-shot knockdowns stay on the one-knee animation. The winner celebrates with his arms up and the referee lifts his glove.
• Bout-ending finishers with full blood: the head bursts on a flash knockout or a huge counter, an eye is forced out by a finishing hook, the head or a hand comes off. Every wound shows skin, fat, muscle and bone; a severed head keeps its owner's face and hair and comes to rest face to the side for the close-up.
• Injuries that build up: eyes swell shut, brows split, blood runs from cuts in rivulets, soaks the chest, trunks and the opponent's gloves, drips onto the canvas, stays there all bout as matte irregular stains and pools under a fallen fighter; spray flies as drops. The gum shield flies out on a heavy head shot and lies on the canvas until the bell.

The broadcast

• Commentary: a play-by-play caller and an analyst react to the fight in captions (knockdowns, hurt fighters, counters, cuts, combinations, body work, parries, the blind side, fouls, corner picks, "Box!", round summaries), one line at a time, kept clear of the panels and dropped when the moment has passed.
• Ring announcer: introduces both fighters with their style and record ("12-3-1 (8 KO)", or a pro debut) on a card and, where the browser can speak, out loud; reads the decision as the referee raises the winner's arm.
• Records: each fighter's wins, losses, draws and knockouts, kept by the server, lead his name plate (desktop) and his introduction.
• Crowd: oohs at big counters, boos at fouls, a murmur when a fighter is hurt, rhythmic clapping when one takes over, a hush through a count and a roar at the end.
• Hurt vision: when your own fighter is rocked the picture blurs and darkens, the sound goes muffled and you hear a heartbeat.
• Cameras: Broadcast, Close, or Over the shoulder behind your own fighter (K cycles them); behind your fighter the controls turn with the camera.
• CompuBox stats on the result card: total punches, jabs and power punches, landed of thrown with percentages (a punch the guard took is not counted as landed).
• The HUD fits phones in both orientations and scales up on big screens; the clock holds at the stoppage time; the count starts at one; a slow connection is flagged only when it is slow.
• Earlier in this PR: each player's own look, corner colours, dressed officials, a crowd in stands, ropes that give, the decision ceremony, the broadcast result card, Discord avatars on the plates.

Server, protocol and security surface

• Protocol 4 (was 3). An open window from an older build gets client_outdated in its own version and a Reload button. New in this release: the cpu and style client frames; select, ready.players[].style, players[].record and players[].cpu, and snapshot style/corner_choice; final.punches; waiting.open_seats of 1 or 2; a spectator welcome that may list 0–2 fighters; and a second fighter welcome when a spectator is seated.
• Rooms:
  • Styles stay hidden until the bell, and a drop or return during the pick resends select.
  • A person who arrives before the bell takes the computer's seat; a seat that opens before the bell goes to the longest-waiting spectator.
  • The next room in an instance holds the last bout's fighters' seats for 60 s. A computer rematch waits 5 s for a friend before calling the computer.
  • Caps of 64 rooms and 16 computer bouts, refused as service_busy.
  • Input after the result counts toward the flood limit.
• Server:
  • CSP img-src is limited to https://cdn.discordapp.com/avatars/.
  • The websocket heartbeat is 5 s, so a fighter who vanishes without a close pauses the bout after 7.5 s.
  • Sign-in limits are keyed on the address plus the Activity instance, because Discord's proxy hides player IPs.
• Persistence: result_json stores both styles; doctor stoppages count as knockouts, and knockouts are recounted from stored bouts at startup.
• Golden replay: it now plays a boxer against a slugger through every rule (1,145 ticks), at protocol 4, and the script fails if any rule stops happening.

Measured

Apple M4 GPU through ANGLE Metal, headless Chrome, the dev fixture with a finisher in the bout:

Scene	Frame rate	Frame times
1280x720 at 2x	60	p99 16.8 ms, worst 16.8 ms
same, CPU throttled 4x	59.9	p99 16.8 ms, worst 33 ms
Phone 390x844 at 3x, CPU throttled 4x	59.6	p99 16.8 ms, one 133 ms frame as the eye finisher starts

• Bundle: 2.62 MB, 1.36 MB gzipped (was 2.41 / 1.29 at the start of this PR).
• GPU memory across rematches: flat (about 0.1 MB per rebuild left inside three.js; it was about 15 MB).
• Canvas blood: only the newly painted region is uploaded, about 3 MiB/s while a fighter bleeds (it was about 112 MiB/s).

Reviews

Every batch of work was reviewed by agents that did not write it, and every finding is fixed with a test that fails on the old code.

• First review (first five commits): 8 findings, fixed in 89b895a.

• Second review (whole branch): the decision walk crossing, rope straps, reduced-motion drift, severed parts losing their look and blood, weak-device costs (officials' hands 3,540 to 684 triangles, crowd uploads halved and shed at the low tier, per-frame allocations), a shader pre-compile that never matched the composer, and a test gap (11 of 13 deliberate breakages passed the suite because nothing tested the draw loop's wiring; a harness now runs the real draw()).

• Core review (engine, server, computer): a fatal decode for the fighter stopped on a TKO (a field above the client's bound), the computer going passive once battered, unthrottled computer requests, the computer parking outside its reach with swollen eyes, clean hits through a worn guard marked as not landed, checksum gaps, a collapse that was not frozen, negative poise on a flash knockout.

• Client review (rendering): the over-the-shoulder camera lurching on every contact, no knockout replay for a flash knockout or TKO against the real server and its finisher arriving before the punch, bodies that never came to rest and replays that fell differently, a silent heartbeat after a rematch, captions under the corner panel, a held button picking a corner instruction, the gum shield lying on the canvas during the replay, full-texture blood uploads, double-sided heads, muting not stopping the announcer, hurt vision surviving a forfeit.

• Visual QA (a playtest of the whole build on desktop and phones): 27 findings, from colliding plates, banners behind the top bar and a dead-end rematch screen to a count with no recovery time, fighters resting in the neutral corners, heads passing through each other, broken ragdoll poses, hollow severed heads and close-ups of the back of the head. All but two cosmetic items are fixed (see below).

• Final review round (113 inline threads in 12 batches, plus the summaries): every thread is answered with a fix and resolved; for device profiling, the answer is what was measured instead. Ten fix branches covered:

  • the engine rules;
  • the computer and balance;
  • rooms and protocol;
  • the pick screen and announcer;
  • the HUD and phone layout;
  • the camera and finish;
  • the stands, ropes and finisher wounds;
  • the ragdoll;
  • gore and injury shading.

  Each fix has a regression test that fails on the old code.

• GPU memory: every rematch leaked about 15 MB in the shared WebGL context (also on Hands: realism overhaul (simulation feel, netcode, animation, injuries, presentation) #293); fixed, and the rematch-loop check counts live GL objects instead of renderer.info.

Verification

• Checks: uv run ruff check ., uv run ruff format --check ., uv run mypy src/, uv run bandit -r src/, uv run pytest tests/test_hands tests/test_database.py (729 passed; CI runs the whole suite), uv run python scripts/hands_replay.py --check (1,145 ticks through every rule), uv run python scripts/hands_parity_fixtures.py --check (client timing tables and movement traces match the engine), npm run typecheck, npm run test:run (961 passed) and npm run build (static scan passed). The committed bundle matches the build.
• End to end on the real GPU against the real server, with no client or server errors: styles (both fighters pick, the bout starts with both styles), cpu (offer, pick, bout, the computer's corner instruction, knockout, unrated result, rematch against the computer), ko (knockout replay 405 frames, no jumps), tko (three knockdowns, the bout ends on the punch and the replay still plays), reconnect (the opponent sees the pause; smooth rendering resumes at once), a beaten count (standing eight, the winner in the neutral corner, "Box!"), plus the earlier rest, rematch, rematchloop, latency and response.
• The production bundle served by the production server under its real Content Security Policy: pose lab and replay lab render with no violations.

Not verified / known gaps

• No live Discord match has been played on this branch (the bot has been down since the host rebooted on 2026-09-29; see below).
• Browsers only allow speech after a tap or key press, so the first introduction may be silent.
• Physics knockouts: a foot pinned under a falling leg can tilt past 60° for a few frames. Feet otherwise roll only as far as an ankle does, and the skull stays on the canvas.
• Phone name plates show the style and the counts (knockdowns, warnings, points); the record is on the introduction card.
• Balance:
  • The contender figures sit 2 points outside their targets: skilled 57% against 40-55, counter-punching 23% against 25-40.
  • The swarmer beats the computer's boxer 62-64%.
  • Scripted players can't stand in for people, so the next tuning should come from live bouts.
• One 133 ms frame on a throttled phone as the eye finisher is built (measured before the warm-up now compiles every finisher shader at load; not re-measured).
• Profiling on a real iPhone and a mid-range Android inside Discord is still needed; desktop and harness numbers are in the review threads.
• The ring announcer speaks only with a voice that runs on the device, so a browser with only online English voices stays silent.
• Whether a decision should end with a post-bout gore moment is left to the owner.
• An arm torn off at the elbow was cut; the live knockout moment before the replay has no extra payoff; favicon requests return 404 (the static bundle is deliberately exactly three files).
• Setting Discord rich presence ("Round 2 vs ...") would need the rpc.activities.write OAuth scope, which changes the consent prompt; left for a decision.

Running it live

The live bot and its quick tunnel have been down since the host rebooted on 2026-09-29. To play this branch in Discord: stop any running bot (one token, one process), run env -u ANTHROPIC_API_KEY uv run intelstream from a worktree on this branch, start cloudflared tunnel --url http://127.0.0.1:8080, and point the Activity's URL mapping / in the Developer Portal at the new tunnel host.

[user1303836]

Claude review, batch 1 of several: client app, network, audio, commentary, HUD (reviewed at 46d6ffd, re-anchored to 3ee9662)

This is an automated review that the repo owner asked for. The server/CPU opponent, ragdoll, gore/effects, scene/crowd/camera and newest-commit reviews are still running and will post as follow-up batches. Each inline comment was checked against 3ee9662, and anything already fixed there was dropped.

Checks run on 3ee9662 (CI doesn't run on this PR)

• tsc --noEmit passes.
• vitest run passes: 46 files, 622 tests.
• ruff check, ruff format --check and mypy src/ are clean.
• hands_replay.py --check is deterministic (sha256 d236b12f…). It no longer matches the hash the description says is unchanged.
• The committed hands.js/hands.css are byte-identical to a fresh vite build.

Verified OK

• Discord avatars: ids and hashes are format-checked, no referrer is sent, the canvas is never read back, the letter fallback works, and the build scanners allow only the avatar URL prefix.
• Starting the opponent's punch on arrival lines up with the server's contact tick better than before: about 17 ms off instead of 50 ms with jitter up to 200 ms. Only freezes of 400 ms or more make it visibly early more often.
• Settings storage can't throw in Discord's iframe, haptics are guarded, corner instructions are fighter-only during the rest, and a human joining during a pending CPU request is handled. Player names never reach innerHTML.
• The merge of feature/hands-realism at 253b245 kept the CPU rematch working (const rematching = … is captured before the reset). An auto-merge would have broken it silently, and 253b245 resolves it correctly.

Biggest issue in this batch: the engine emits a hit right after every block/perfect_block for the same punch. Only the renderer pairs the two, so CompuBox, the commentary and the audio all count blocked punches as landed. Ten fully blocked jabs show as 10/10 (100%).

[user1303836]

Claude review, batch 2: ragdoll, gore/effects/injury, scene/camera/crowd (reviewed at 46d6ffd, re-anchored to 3ee9662)

Each finding was re-checked against 3ee9662 before posting. 20c019c already fixes the face shape of the severed head, so that comment now covers only the injuries and the material.

Top priorities

1. KnockoutRagdoll.blend() never blends. bone.quaternion.slerpQuaternions(from[i], bone.quaternion, w) copies from into the bone before slerping toward itself (three Quaternion.js:771-773), so the result is always from. Every physics knockdown freezes for 0.1 s and then snaps the head about 26 cm in one frame, right at the knockout punch. Every get-up levitates the body flat and then snaps the chest about 140°. It's a one-line fix (slerp through a scratch quaternion), but it needs a test that checks rotation continuity; the current tests only check positions.

2. Finishers vs. the real server. The room stops ticking on the result tick, so:

   • a third-knockdown TKO decapitates or bursts before the punch is drawn;
   • flash-KO and TKO finishers never get the slow-motion replay (planKnockoutReplay needs 12 ticks after the impact);
   • the finish close-up picks its side before the body falls.

   The dev fixture keeps generating snapshots after the result, which hides all three. Either send a short tail of presentation snapshots after a stoppage, or have the client extend the plan itself.

3. Gore pacing vs. the MK/SoF/Dead Space bar.

   • Ordinary hits over-trigger permanent canvas stains: about 58% of the centre is solid red by the end of round 1 with nobody cut.
   • Finisher wounds stop bleeding after about 1.5 s and only pool if the engine says the fighter was cut.
   • The finisher type ignores punch weight and target (a jab can decapitate, and a body shot severs a hand).
   • Landed gore vanishes.
   • The severed head loses its injuries.

4. The ragdoll is robust to bad dt but not at hand-offs. A fall after a rendering gap starts from a stale pose up to about 2 m from the engine spot. The replay diverges from the live fall when a decapitation changes the masses. Feet and skull limits fight the canvas, so toes jump 20-47 cm and heads flip 40-70° in one frame.

Verified OK

• The ragdoll stays finite and inside the ring with frame times of 0.5 s and 2 s, and allocates nothing per step (about 78 µs per step on desktop).
• Without decapitation or a moving opponent, the replay reproduces the live fall exactly.
• Look hashing over 100k snowflakes is uniform: every skin tint lands at 14.1-14.4%, hair is evenly spread, and neighbouring ids get independent looks.
• The decision-ceremony marks and the referee's raised wrist are correct for all stances.
• Disposal is clean for the crowd, ropes, officials' hands and the shadow material.
• The corner cut waits for the cutman.
• Blood Off/Reduced and reduced motion are honoured for finishers, drops, drips and mist (exceptions are commented inline).
• f510a2b already addresses the crowd and officials triangle counts and the per-frame instance uploads that the reviewer measured at 46d6ffd.

Not commented inline

• The ragdoll's fold style has the same stiffness values as crumple.
• The get-up slides the hands and feet 0.1-0.75 m back to the engine spot.
• Some falls creep for 7 s or more before sleeping.
• The swelling cap after d11a142 (about 1 cm) reads puffy rather than grotesque. Now that the push no longer folds the mesh, the eyes and cheeks could go back toward 2 cm.
• The PR's 60 fps table was measured with a desktop GPU and a throttled CPU. A run on a real mid-range phone inside Discord is still needed, especially with the canvas-blood uploads and the discard in the skin shader.

[user1303836]

Claude review, batch 3: commits 46d6ffd..3ee9662 (realism merge, polishfix, fighter records; re-anchored to f9b85f9)

Verified OK

• The merge of feature/hands-realism at 253b245 lost nothing from f7a989f:

  • the render clock restarts on welcome/resumed;
  • a rematch retries on room_closed behind a single guarded timer;
  • instant sends have their own budget, and the corner choice goes through transmit;
  • constrainPrediction, compileForComposer, disposeComposer/releaseFighterGpu and disposeSkeletons are all present.

  The one hand edit, capturing rematching before the reset, keeps the CPU rematch working.

• The fighter record is built on the server at join from stored results, so a client can't spoof it. Bouts against the computer aren't counted, draws count for both, and a rematch re-reads it after the result is saved.

• The committed bundle at 3ee9662 is byte-identical to a fresh build.

• f9b85f9 addresses the CompuBox and commentary blocked-punch comments from batch 1. The follow-up review of the newest commits is checking it now.

Not tied to one line

• KO count: the stored KO count leaves out doctor stoppages, which a boxing record counts as TKOs. That rule predates this PR, but the count is now shown and read aloud.
• Old clients: an old client crashes on the new record field. The PR already breaks old clients through the required corner_choice, so this is no worse. Making a protocol mismatch reload the page would fix both (see the errors.ts comment on #293).
• Severed head: it still drops every injury. It's covered by the existing comment on effects.ts, now confirmed with a test after 20c019c: the baked geometry is identical to an unhurt boxer's.

[user1303836]

Claude review, batch 4: server, CPU opponent, engine additions (reviewed at 46d6ffd, re-checked against f9b85f9)

The blind-side finding was dropped because df51956 fixes it: the computer now checks _blind_to before slipping and works its corner. Each comment below was re-checked on f9b85f9. The review of the balance commits (75afb48, df51956, f9b85f9) is still running and will be the next batch.

Verified OK

• Cost: the computer brain runs inside the room tick at about 11 µs per tick on average (p99 45 µs), against about 610 µs for the engine step. 24 full bouts against a random human raised no exceptions; that human also sent fouls, clinches, corner actions and get-ups.
• No hidden state: it reads nothing a client can't already see in its own snapshot.
• Unrated: bouts against the computer are never persisted and show ratings unchanged, so rating farming isn't possible.
• One room per account: each account can hold one room and Discord verifies the instance. There's no global room cap, though, so each account can now run a full-speed bout alone.
• Cleanup and access: if the player disconnects, the computer pauses and the room is abandoned after the grace period. Spectators can't call the computer.
• New engine state: corner instructions, blind side, parry stagger and body knockdowns are deterministic and integer-only, their state is in the checksum, and they arrive through the existing rate-limited input pipeline, so only the fighter can send their own. Protocol changes are additive.
• Merge with #293: git merge-tree 37a3df6 46d6ffd merges engine.py, rooms.py and rules.py cleanly with nothing lost. The test files conflict only because both sides appended tests at the end. With those resolved, 280 cpu/engine/rooms/protocol tests, 38 server/scoring tests and the golden check pass.

Windows-only test issues (not regressions from this PR)

• test_a_rematch_reaches_a_new_room_while_the_old_one_is_still_closing fails, as commented on #293.
• test_server.py::test_authenticated_room_admission_is_not_part_of_first_frame_timeout hangs, at both 37a3df6 and 46d6ffd, so a full pytest tests/test_hands never finishes on Windows.

[user1303836]

Claude review, batch 5: balance and CPU commits 3ee9662..f9b85f9 (75afb48, df51956, f9b85f9)

These were measured with a harness driving the real engine and the new hands_balance.py players over about 70 seeded full-length bouts. Throwaway scripts are noted per comment.

Verified OK

• CompuBox fix: f9b85f9 fixes the miscount on CompuBox, the result card, round summaries, combos, the takeover chant, unanswered counts and damage tallies. wasBlocked pairs by action_id, tick and the reversed actor/target, and the committed bundle includes it. Audio and rumble still miss it (inline).
• Engine and tests: the engine stays deterministic (hands_replay.py --check). 231 engine, balance and CPU pytest pass, and 112 vitest pass (render, commentary, prediction, rocked).
• Stun fields: the new fields reset at round end, at rest and on get-up. Neither the 45-tick cap nor the 24-tick clear window is off by one, apart from the rocked bypass in the inline comment.
• Punch timing: the timing table is unaffected, since punch timings and the fatigue formula didn't change.
• CPU visibility and cost: the CPU reads only what the HUD shows, and its per-tick work is bounded.
• Knockdowns: equal computer bouts still produce about 1.6-1.75 knockdowns per bout, but rookie v rookie produced none in 8.
• Turtling isn't dominant: the skilled player, jab spam and hook spam all beat the turtle.

The bigger picture for the AAA/gore goal: the balance pass fixes the round-one stun-lock, but it overcorrects on blood. With marking at 33-70% of the old rates and nothing from blocked punches:

• faces stay nearly clean through three rounds;
• doctor stoppages vanish;
• most client gore thresholds become unreachable: injury.ts cuts and eye closure, the commentary's cut and doctor lines, glove blood, and the CPU's corner and shut-eye play.

Combined with the passive-CPU trap, a dominant human gets a long, bloodless decision. That is the opposite of the Fight Night + MK brief. See the combat-manifest.json and cpu.py comments.

[user1303836]

Claude review, batch 6: HUD, overlay and flow fixes 8cf2611..ae716e6 (re-anchored to 23f886f)

Layout findings were measured by rendering the real drawHud, caption code and stylesheet in headless Edge at 320-412 px portrait, landscape phones and 1920-3440 px.

Verified fixed

• The compact name plates' detail lines overlapping on 360-390 px phones: no overlap from 320 to 412 px. Truncation now cuts the knockdowns, though (inline).
• The ring announcer card showing "RATED 1400" for the computer: it now says COMPUTER.
• The commentary calling blocked punches landed (f9b85f9): still fixed.

Fixed in a way that causes a new problem: the spoken records running into round 1. The voice is now cut at the opening bell, so neither name is ever spoken (inline on app.ts).

Still open, not touched here

• The hurt vision and audio muffle start before the punch lands (renderer.ts).
• On #293, the compact scoreboard mini-bars still overlap by 36 px at 320 px.
• On #293, touch still has no slip, weave, pull or clinch. The new Controls panel has Keyboard, Between rounds and Controller sections but no Touch section.

Looks fine

• Corner panel: the server accepts any instruction once per rest, so hiding an empty option only prevents a wasted pick; it never blocks something the server would accept.
• Commentary expiry: only the "can he beat the count?" lines and the introduction cards can be dropped. Knockdowns, results and the verdict never are.
• Rematch flow: the waiting picker, CPU rematches and retries behave correctly.
• Smaller changes: the caption ghost fix, Shift-gated fouls and the extra measuring (one per plate per frame) are fine.
• Big screens: nothing overflows, and the smallest text is 15 px.

[user1303836]

Claude review, batch 7: client review fixes f9b85f9..8cf2611 (re-anchored to 23f886f)

tsc is clean and all 646 vitest tests pass at 8cf2611. Fixes were checked against throwaway reproductions of the original comments.

Verified fixed

• Over-the-shoulder camera lurch: the contact, teeth and gum-shield code now use their own vectors (contactPoint, mouthPoint).
• Flash-KO and TKO replays are now planned when the recording ends on the punch, and the TKO head no longer comes off before the punch lands.
• Finish close-up: it now picks its side after the replayed fall.
• Ragdoll: the opponent obstacle is recorded per step and replayed. Bodies come to rest, all asleep by 2.3 s in 96 instrumented knockouts.
• Canvas blood uploads: checked in real WebGL2 (headless Edge on a GTX 1080 Ti, and SwiftShader). All 10 mip levels and the rendered frames match the old full-upload path, the stains land the right way round, and there are no GL errors. Dirty-rect union, edge clamping, the 2048 limit and r186's copyTextureToTexture path are correct.
• Rematch audio: the heartbeat, breathing and clapper start over. A forfeit clears the muffle and the hurt vision.
• Smaller fixes: muting stops the announcer mid-line; the corner pads are coloured where the fighters rest; a held controller button is no longer a corner pick; captions keep clear of the panel.

Partly fixed

• settle() is capped at about 280 steps instead of 720, but still in one frame.
• Officials' heads are one-sided again and closed fighter heads drop back faces early, but the sever discard is still compiled into every skin shader, body included.

Still open (not claimed by these commits)

• The ragdoll blend() slerp blocker (ragdoll.ts blend, unchanged). Every physics knockdown still freezes then snaps, and every get-up still snaps about 140°. It's a one-line fix: slerp through a scratch quaternion.
• The ragdoll replay diverging after a decapitation, the stale fall start after a rendering gap, and the solveFeet/skull-cone/ankle pops.
• The blood plane's shader compiling mid-fight.
• The announcer speaking while the Activity is hidden.
• With no replay (mainly reduced motion), the wave-off and celebration still start before the punch lands.

Worth a device check: the region-only canvas upload was measured on desktop Chrome. Whether iOS WebKit copies only the region for a canvas source is unverified, so it's worth profiling on an iPhone.

[user1303836]

Claude review, batch 8: core review fixes ae716e6..23f886f (d91d4d0, e262d77, 7962bf1; re-anchored to the current head)

Checked with throwaway engine and server scripts, hands_balance.py runs on the same seeds, and real engine snapshots fed through the client decoder and predictor. The requested Python tests pass (the 2 known Windows tests deselected), along with vitest, tsc, ruff, mypy and the golden replay check.

Verified fixed

• CPU request flood: cpu frames now count against the frame limit, and the 4,000-frame test ends in rate_limited.
• Single decode per frame: malformed and unknown frames, ticket acks, spectator frames, oversize frames and error codes behave as before.
• CPU "hurt" check: judged against the poise ceiling now. The contender throws 18-61 punches a round in rounds 2-3, where it used to throw 0-2.
• CPU reach: stepping in, follow-ups and approach use the reach its swollen eyes allow.
• Worn-guard parries: perfect and the flash-KO check now follow from blocked. A guard of 0, 50 or 59 lands, counts as landed and lets the queued straight cut in; 60 still parries. That also covers the #293 comment about a guard-broken fighter counting as parried.
• Body-collapse freeze: a fighter walking into the shot drifts at most about 2 units, and his own screen holds him still.
• Stun movement parity: server and client agree to within 1 unit for stuns that don't interrupt a punch (see the inline comment for the ones that do).
• Smaller fixes: the bleeding stamina cap, the poise clamp at bout end, alternating simultaneous body collapses, and checksum coverage of the stun fields. The client only checks the checksum's format.
• Get-up limit: the client's maximum of 171 matches the engine's worst case.

Partly fixed

• The CPU's "stops fighting" trap: the head half is fixed, but the _reserve() half remains (inline).
• Stun movement parity: it holds for plain stuns but not for stuns that cut a punch or land mid-slip (inline).

Still open (not claimed by these commits)

• the CPU's follow-up stamina check using the discounted cost;
• a rocked stun restarting on the tick the last one ends;
• the champion's fixed 133 ms reaction;
• perfect_percent barely affecting perfect blocks;
• a late friend locked into spectating;
• slow cut, eye and bleeding build-up (the faces-stay-clean comment);
• no cue when a worn guard stops blocking.

[user1303836]

Claude review, batch 9: core fixes part 2 0da7263..73eb05a (standing eight, neutral corners, opening introductions, foul separation, tired punches, rebalance, "Box!")

Checked with throwaway engine scripts, hands_balance.py over 24 seeds per matchup, real-time commentary replays and HUD renders. 252 engine/cpu/balance tests and prediction.test.ts pass. 73eb05a ("Box!") has no problems of its own.

Verified fixed

• Stun stumble knockdowns: the half-speed stumble was doubling knockdowns of stunned fighters. After ccca89c, champion v champion has 22 such knockdowns over 24 seeds, with 10 bouts going the distance; contender v contender has 10 and 7. At 50% those were 37 and 39.
• Faces staying clean: largely fixed. Competitive CPU bouts now reach cuts of 437-440, with 4-5 shut eyes per 24 bouts, and one-sided bouts reach doctor stoppages. CPU v CPU bouts still never do.

New rules that check out

• Count and walk: the count, hold, round clock, three-knockdown TKO and checksum are correct, and the 592ca8e display fix works. Across 12,416 walk positions, every walk reaches the far neutral corner within 7.4 s and none leaves the ropes.
• Opening countdown: it applies to round 1 only; the CPU stays idle and the glove touch still lines up.
• Tired punch: it can't flash-KO (it can still cut). Client timing matches the engine on 5,376 tired rows and 192 regenerated timing-table rows.
• Mashing: not a dominant strategy. It beats the rookie 9-2-1 but loses 0-16 to the contender and 1-15 to the champion.

Still open from earlier batches (not changed by these commits)

• a rocked stun restarting with no free tick (reproduced at the 45-tick cap);
• a mid-slip stun freezing the fighter;
• no cue for a worn guard (guard_break fired once in 480 bouts);
• the CPU body reserve (400 vs a maximum stamina of 330);
• the CPU follow-up cost: in that band it now throws a tired arm punch instead of being refused;
• the champion's fixed reaction and perfect_percent;
• stun prediction parity when a stun cuts a punch;
• the result-hold input flood.

[user1303836]

Claude review, batch 10: 3D scene fixes 23f886f..0da7263 (severed heads, winner off the body, knockout ceremony, ragdoll spine limit, head lean, phone camera framing, blood stamps)

These were measured with two-graph and renderer-stub harnesses, a 128-fall ragdoll sweep, a 19.8k-case fuzz of the winner push, camera projection at 16:9 and 390x844, and raycasts against buildRing().

Holds up

• Spine limit (c19bb47): 0 of 128 falls go past 45°, against 124 without it. Start poses stay at or under 17°, so the first step doesn't snap. It adds no new pops, and a warm step costs 79 µs against 76.
• Canvas blood: still uploads by region (no full uploads came back), and the stamps are built once. Droplet counts and the Off/Reduced settings are unchanged.
• Severed head: comes to rest on an ear, within 5 mm of the canvas.
• Winner off the body: never left inside a body circle in 19.8k random cases.
• Arm raise: picks the winner's nearer glove, so it's right for both stances.

Still open: none of the earlier ragdoll and gore comments are fixed by these commits

• The blend() slerp blocker is still there (ragdoll.ts, the slerpQuaternions line). c85c122 added a position lerp beside it, which works because lerpVectors is alias-safe, so during the blend-in the positions now slide while the rotations stay frozen, then snap at 0.1 s. It's a one-line fix: scratch.copy(bone.quaternion); bone.quaternion.copy(from[i]).slerp(scratch, w).
• Ragdoll: the replay masses after a decapitation, the stale fall start after a rendering gap, the toe and skull pops (the 128-fall sweep shows the same spikes with and without the new solvers), and settle() in one frame.
• Severed head look: the material is still plain, computeVertexNormals still creases the UV seams, and closeCut still gets no across. The rigid bake only removes the skin spikes.
• Gore and presentation:
  • canvas stain triggers (unchanged);
  • blocked-punch blood;
  • the flash-KO drip;
  • finisher wounds stopping too soon;
  • landed gore vanishing;
  • finisher choice ignoring the punch;
  • close-up timing without a replay;
  • chest-to-chest pops;
  • the over-the-shoulder camera on portrait;
  • the replay reusing the previous fall;
  • the missing TKO knockdown feedback.

[user1303836]

Claude review, batch 11: fighting styles, client side (73eb05a..3db8394)

Checked with the real engine, the real room harness, drawHud with measured font metrics, and the app DOM rendered with style.css in headless Edge at 11 phone sizes. The four client test files pass (135 tests). The server-side review of the styles is still running and will be the next batch.

Verified fixed

• Name plates at 360-390 px (7fe871f): the phone plate's second line now holds only the style and the knockdowns (at most 77 px), and the plates stay at least 36 px apart from 320 to 412 px.
• Plates cutting the knockdowns: fixed in portrait only; landscape is inline on hud.ts.

Checks out

• Prediction parity is exact. The regenerated 1,280-row style timing table is identical to the committed one, and 4,800 more cases match predictedPunchTiming exactly. That covers all five styles, tired arm punches, and conditioning loss after the punch.
• Footwork: predicted movement stays within about 2 units of the engine over 8 ticks for the swarmer.
• Reach, slips, counter and parry windows follow the snapshot, so nothing needs to match.
• Decoder headroom: the longest styled recovery is 39 ticks (a tired slugger's power uppercut) against the decoder's limit of 40.
• Pick input: input is off during the pick, so nothing leaks into the bout. Held keys don't repeat, so style frames can't flood. The picker's timer and listeners are cleaned up and it's reused across rematches without leaking. Spectators can't pick, and your own reconnect mid-pick restores your settled choice.

Still open from earlier batches

• the announcer cut at the bell (made worse by the style title, inline);
• stun prediction when a stun cuts a punch (prediction.ts);
• the mandatory-eight HUD telling the standing fighter he's down (hud.ts);
• struggle commentary after a fighter has risen.

[user1303836]

Review follow-up: the items not tied to a line

Every inline review thread on this PR has been answered on its thread and resolved. These are the review-summary items that weren't tied to a line, plus four layout problems found while fixing the others. This branch also now carries #293's review fixes (merged in 6333068), and #293 is merged into main.

Ragdoll and gore (batch 2)

• Fold stiffness (7c1f78a): a body-shot knockdown no longer falls like a crumple. The spine gives at once while the knees hold for half a second, so he doubles over into a kneel before he pitches onto his face.
• Get-up sliding (34e3ca9, 40a9b8d): the physics carries the body into the get-up until he is on all fours. Over 16 knockdowns and get-ups no bone moves more than 9 cm a frame in the hand-over or 12 cm in the rise (it was 47-85 cm), toes skate at most 8.4 cm a frame (they slid 0.58-1.16 m), and he rises onto his place instead of walking back to it.
• Eye swelling cap (fe994b2): the cap goes from 1.25 to 2.0 cm, and cheeks swell to 1.8 cm. In real skilled-v-contender bouts the worse eye now swells 1.94 cm at the median (1.25 before). The radial push folds no face triangle at the worst trauma.
• Gore pacing against the MK / Soldier of Fortune / Dead Space bar:
  • Canvas blood builds up over a bout instead of flooding round 1. On a recorded real bout: 948 stains by the end of round 1 (4,176 before), 4,070 by the last bell, with knockdown pools still solid.
  • Landed gore stays on the canvas for the bout.
  • The severed head keeps its bruises and cuts.
  • A punch that rocks a man (70 damage, or a counter of 50) tears flesh from an open cut: in six skilled-v-contender bouts, 46 of 53 such shots did.
  • Finishers are chosen by punch, target and damage, with a new caved-ribs finisher for body shots and arterial fountains that pump for 5-8 s and pool up to 0.8 m.
  • Whether a decision should get a post-bout gore moment is left to the owner.
• Profiling on a real phone inside Discord: not done here, because it needs a person with an iPhone and a mid-range Android. Measured instead:
  • With the fake WebGL harness, a fight frame at 390x844 issues 156 draw calls, 480k triangles and 50 programs (162 calls with a decapitation, its fountain and pool), and the low tier drops to 107 calls.
  • No finisher compiles a shader after load, and every variant compiles in real WebGL2.
  • Canvas blood uploads 3.8-6.5 small regions a second while anyone bleeds.
  • Still needed: a frame-time trace in Discord on both phones at first blood, in round 2 of a cut bout and at a finisher.

Injury thresholds (batch 5) (fe994b2): a cheek cut now opens fully at 750, short of the doctor's 800, and the forehead splits from swelling 380 instead of 520.

HUD, audio and finish timing (batches 6 and 7)

• Audio muffle (492181a): the muffle now starts with the punch that rocks the player, driven by the renderer's onRocked, not when the snapshot arrives.
• Compact mini-bars: fixed by Hands: realism overhaul (simulation feel, netcode, animation, injuries, presentation) #293's c611da8, carried over in the merge. At 320 px the bars and labels sit inside their plates.
• Touch layout after Hands: realism overhaul (simulation feel, netcode, animation, injuries, presentation) #293's moves (e0a70e6, 1f9fbb7):
  • The Controls panel has a Touch section.
  • Captions use the merged pad block.
  • On landscape screens 350 px tall or less the pad block no longer swallows the top bar's Controls and Settings taps.
• No-replay finish (merge, f776085): with no replay, the wave-off and the celebration wait for the frame that shows the finishing punch.

Records, protocol and capacity (batches 3 and 4)

• Doctor stoppages (1ca0c3b) count as knockouts in the record, and stored records are recounted at start.
• Old clients: protocol 4 (5d1d786) means a window from before this PR gets "Hands was updated. Reload to continue." instead of a protocol error.
• Room caps (d7c858b): 64 rooms and 16 computer bouts, refused as service_busy.

Found while fixing (phone layout)

• Countdown, rest and introduction panel (a75b8f6): no longer runs under the touch pads. It used to sit 14 px under SLIP/WEAVE at 320x568 and up to 42 px under BODY/GUARD on landscape phones.
• Short touch hint (37341ab): 5 lines at 320x568 instead of 11.
• Get-up prompt (6fbad42): while the player is down only the four get-up pads show, and the prompt sits clear of them. It used to have BODY/POWER over "NOW!" at 320x568. Real touch events confirm every get-up pad still registers.
• Reconnect panel (50c2c3d): no longer covers the dimmed pads.