Game crouch block and high/low guard stance systems explained

What guard stance is (and why it matters)

Guard stance is the defender's body posture while blocking: standing guard or crouching guard. It is distinct from simply “holding back” — back input enables block, but crouch input (or auto-rules) selects which attack heights the guard can answer.

Three attack height layers drive the stance puzzle:

• Mid — blockable in either standing or crouch guard (most normals and specials).
• Low — must crouch-block; standing guard whiffs or eats the hit.
• Overhead / high — must stand-block or jump; crouch guard leaves the head hurtbox open.

Without explicit stance rules, mixups collapse: either every attack is mid (turtle meta) or height tags exist but players cannot tell which stance they are in. Guard stance FSM is the foundation under high/low mixups, universal overheads, and low/high crush evasion.

Guard stance FSM architecture

A production guard stance machine typically has four states relevant to blocking:

• Neutral — not guarding; full movement.
• Standing guard — back held, not crouching; blocks mid and overhead.
• Crouch guard — back + down held (or auto-triggered by low block rule); blocks mid and low.
• Blockstun — frozen after a blocked hit; stance may be locked or changeable per game rules.

Transitions

Common transition rules:

• Neutral → standing guard: hold back within guard range.
• Standing guard → crouch guard: hold down while blocking.
• Crouch guard → standing guard: release down (back still held).
• Any guard → neutral: release back or leave guard range.

Blockstun stance lock is a major design lever. If blockstun freezes stance, the attacker's last hit in a string dictates the defender's posture for the mixup window — a low ender forces crouch blockstun, setting up an overhead. If stance can change freely during blockstun, defenders fuzzy guard between high and low, raising skill ceiling but shrinking mixup value.

Hurtbox profile coupling

Crouch guard should shrink vertical hurtbox extent — head box drops, low box may tuck. Overheads aim at the standing head volume; if crouch hurtbox still exposes head at standing height, overheads land “through” visually wrong blocks. Serialize hurtbox anchors per stance in frame data and test overlap against hitbox volumes.

Block resolution against attack height tags

When a strike connects during guard, the engine checks attack height tag against defender stance:

Auto-low-block variants (some anime fighters) automatically enter crouch guard when a low is incoming, removing the manual down input. This speeds casual play but flattens mixups unless overheads are fast or unreactable by design — usually a deliberate accessibility trade.

Proximity guard games without explicit crouch block may use high/low hurtbox overlap only (no stance FSM). That works for 2D fighters with clear visual silhouettes but fails in 3D or cinematic angles where stance is ambiguous.

Blockstun, fuzzy guard, and stance buffering

Advanced defenders use fuzzy guard: tap up briefly during blockstun to stand before an overhead, or tap down before a low. This requires stance-change permission during blockstun and tight input buffering so down-tap queues before the mixup frame.

Design parameters:

• Stance lock frames — first N frames of blockstun freeze stance; after N, fuzzy inputs apply.
• Buffer window — how early down/up can be held before the mixup frame.
• Stand-up delay — frames to leave crouch guard; prevents instant fuzzy if too slow.

If fuzzy guard is too strong, overheads and lows never threaten; if too weak, defenders feel locked into wrong stance with no counterplay. Telemetry on fuzzy success rate per mixup slot guides tuning.

Cross-up block direction and stance

Cross-up attacks flip which direction counts as “back” for block input. Guard stance FSM must re-evaluate block direction on the same frame hurtbox overlap is tested — not one frame later — or rollback desyncs appear at cross-up range.

Crouch block during cross-up lows is especially sensitive: down-back must resolve to both correct facing and crouch guard. Document whether down-forward counts as crouch block when crossed up (most games: yes, if it maps to down relative to character facing).

Harbor Brawl overhead mixup refactor

Pre-1.9.0 Harbor Brawl used implicit crouch-on-block: holding back while crouching applied a generic guard flag without height resolution. Overheads tagged “high” still checked against a unified block box that crouch defenders accidentally kept raised. Gold-tier players learned to crouch-block entire strings, eating mids safely while overheads remained nearly unreactable at 18f startup.

The refactor shipped four changes:

1. Explicit stance enum on the defender: GUARD_STAND vs GUARD_CROUCH with per-frame hurtbox tables.
2. Height-aware block test on every active frame of every move — no fallback to “blocked if guarding.”
3. Blockstun stance lock for 4f after each blocked hit, then fuzzy window opens (8f buffer).
4. Training overlay showing red/green stance indicator and incoming attack height 6f before active frames.

Results after two weeks ranked: overhead hit rate 41% → 19%; sweep low success 14% → 27%; average combo damage unchanged; “mixups feel fair” survey 31% → 68%. The meta shifted from “always crouch” to alternating stance reads within blockstrings.

Technique decision table

Common pitfalls

• Crouch guard blocks overheads — eliminates half the mixup layer; overheads become cosmetic.
• Standing guard blocks lows — sweeps never threaten; turtle stand-block dominates.
• Hurtbox mismatch — visual crouch block but head box still standing height; players distrust feedback.
• Hidden stance during blockstun — defenders cannot tell if they are crouching; fuzzy guard impossible to learn.
• Inconsistent height tags — same animation mid in one string, low in another without telegraph; reads feel random.
• Cross-up direction lag — one frame late block facing flip causes rollback desync and “wrong way block” reports.
• Chip damage ignores stance — blocked overheads chip through crouch guard anyway; stance rules feel fake.
• No tutorial stance drill — 60% of new players never discover crouch block; overheads dominate low ranks forever.

Production checklist

• Define guard stance enum and transitions (stand, crouch, blockstun lock rules).
• Tag every move active frame with height: mid, low, overhead (or high).
• Publish block matrix in frame data docs and in-game move list.
• Couple crouch guard to low-profile hurtbox tables per character.
• Set blockstun stance lock frames and fuzzy guard buffer windows.
• Test overheads vs crouch block and lows vs stand block on every character.
• Verify cross-up block direction and crouch input on same simulation frame.
• Serialize stance enum in rollback snapshots; never infer from animation only.
• Training mode: stance indicator, incoming height preview, fuzzy success counter.
• Telemetry: overhead hit rate, low hit rate, stance distribution during block.
• Tutorial: block three lows (crouch), then block three overheads (stand).
• Balance: no single stance safe against entire character movelist.

Key takeaways

• Guard stance is a separate FSM from “holding back” — it determines which attack heights can be blocked.
• Standing guard answers mids and overheads; crouch guard answers mids and lows; violating the matrix is how mixups work.
• Blockstun stance lock and fuzzy guard windows control how much defenders can adapt mid-string.
• Hurtbox profiles must match stance visually and logically or players reject the system.
• Harbor Brawl cut overhead hit rate by more than half after explicit height-aware block tests and stance hurtbox tables.

Related reading

• Mixup and high/low combat systems explained — conditioning and strike-throw layers above stance
• Parry and block systems explained — guard input, chip, and riposte foundations
• Sweep and low-profile attack systems explained — lows that force crouch guard
• Universal overhead attack systems explained — overheads that punish crouch block