SBR: Shoot, Block, Reload

At a glance

• Outcome: A phone duel you can learn in one sentence and lose to for months. Shoot punishes reload, block reflects shoot, reload banks your next shot. Everything else is moving into the opening and committing before they do.
• Status: Playable. Solo Drill runs against a three-tier AI rival with the full games-and-sets structure, verified by headless checks and screenshotted from the real build. No playtest session has been written up. Targeting iOS.
• Role: Solo.
• Stack & libraries: Godot 4.6, GDScript, ENet for LAN.
• Validation: 43 headless check scripts driving the real duel controller frame by frame, with more check code than game code. That’s possible because combat resolution lives in a pure module with no scene tree.
• Limitations: Nothing in the release evidence chain has a recorded result. The signoff report is 60 blank fields, the release checklist has none of its 36 boxes ticked, the playtest report is an empty template, and the known-issues log has never held an entry, which makes it an unused form instead of a clean bill of health. LAN parity is unproven: the protocol regression matrix was deferred by decision, not passed.

The loop

Three actions, one triangle. Shoot punishes reload. Block reflects shoot. Reload banks your next shot.

That’s the entire ruleset, and it’s printed on the lobby screen because hiding it would add nothing.

The triangle is temporal, not turn-based. Shoot commits you for a third of a second. Reload commits you longer and pays out at the end, so damage inside that window costs you the stack and damage a frame after it doesn’t. Block raises a shield immediately, and it only converts a shot that physically reaches it while the shield is up. A shot that arrives late passes through a shield that already expired.

So “block beats shoot” isn’t a cell in a matrix. It’s a question about where the projectile is in the final millisecond.

What got torn out to make that true

The first version resolved combat in pairs. Both duelists picked, the exchange resolved, repeat. That’s gone.

Each duelist now commits on their own timer, and the commitments overlap. A shot can leave the barrel while your opponent is still winding up, and one attack can resolve while the other player is still locked into an answer. Resolution is deliberately allowed to finish out of order, so a later commitment can land first without confusing anything.

That single change is what makes movement worth anything. Under paired resolution, moving between the pick and the resolve changed nothing. Now, where you are when the other person’s shot arrives is the whole read.

What isn’t in the game

Four constraints were written down before the mechanics were: symmetry, full readability, committal actions, and no parallel resource systems. They mostly show up as things that aren’t there.

The depth config has eight feature flags and six of them are off. A perfect block is deferred pending a real parry rewrite, the reload feint is cut outright, and clash cancellation and post-hit momentum were never switched on. Reload stacks are the only resource in the duel, which is why there’s no meter, no cooldown and no ultimate. A second currency would give you something to think about that isn’t the read.

Overload is depth inside shoot, not a fourth action. It costs your whole magazine. Against an open target it deals double damage, and against a block it deals single damage, which is the one case where block doesn’t reflect and the blocker banks nothing. That exception got argued for in writing. The rule the whole game teaches is that block answers shoot, and overload is the one attack allowed to break it, priced at everything you have and still cut in half, so it teaches respect for block rather than immunity from it.

Cover makes the read positional, so peeking an edge changes which answers are even available. Sudden death shrinks the arena so stalling stops working. And matches run as games and sets instead of single rounds, which is the part that turned it from a toy into a game. A read that works once has to survive being run back, and the tagline is exactly that: commit the read, then run it back.

The rival is not cheating

This is the part I’d point at, and it’s the obvious question about any single-player-versus-AI game.

The rival telegraphs every action before committing to it, and the time it spends telegraphing comes out of its own initiative rather than being added on top. Difficulty is an information budget, not a stat advantage. The easiest tier gives you nearly half a second of warning and the hardest gives you a fifth of that.

It has no hidden information either. It aims through the same assist the player uses, and it has no ability to plan a bank shot you can’t see coming.

The tiers change what it can do, not how fast it does it. The lowest tier can’t juke, can’t overload, and never lies. The middle tier gains a committed sidestep into cover, chosen once instead of re-evaluated every frame, so it reads as a decision rather than as tracking. The top tier gains overload and lies about roughly a quarter of its tells, advertising one legal action and committing another.

Each tier draws from its own seeded randomness, reset per round only in its counters, so the rival doesn’t replay the same opening every time.

Built for a phone first

The touch layer got more attention than the rules did, because a duel decided in commitment windows is unplayable if the input is ambiguous. That meant symmetric aim with editable touch layouts, twin-stick routing that survives a modal opening over it, and a HUD that tells you what a lane color means (yellow reaches the rival, red hits cover, gray means empty) instead of making you learn it by losing.

The honest part: LAN and the evidence chain

Host Duel and Join Duel are in the lobby and the networking layer exists. The rig was genuinely built, and there’s a deployed test device with an artifact digest and a deploy log on file. Then the matrix rows were left blank.

The protocol regression matrix runs two full sets with forced timeouts on each peer, checking for state divergence, and it was deferred rather than executed. I cleared a solo-feel pass and let the next wave proceed before it ran, and that decision is written down in the repo with the risk named. Set and match replication is unproven over real LAN.

The wider version: release-candidate signoff hasn’t started. The repo’s own rule is the harsh reading, and I’d rather print it than soften it. An empty known-issues log does not clear an evidence gate, and device feel, thermal behavior, LAN parity and player understanding may never be inferred from commits or passing headless checks.

So the status says playable, not multiplayer. Solo Drill is the part that’s been exercised. The matrix is still mandatory and re-attached to the next release barrier, which is the right place for it, but until it runs, LAN is a claim rather than a result.