Guide

Game rekka attack systems explained

Harbor Brawl shipped Anchor with a three-stage rekka special: press punch once for a short dash punch, again for a follow-up elbow, and a third time for a launching knee. Telemetry showed 34% of ranked rounds ended with the opponent blocking all three stages and still eating chip plus frame-trap pressure because stage two was only −2 on block and stage three could be buffered during blockstun. Players called it unpunishable. The combat team reframed rekka as a commitment ladder — each stage got explicit gating, recovery, and cancel rules. After the patch, full three-stage blockstrings dropped to 9% of rounds, confirm damage from stage-one hits rose 28%, and Anchor pick rate stabilized instead of being banned in casual queues.

A rekka attack (from rekka shinken, the multi-hit special family in The King of Fighters) is a special move that advances through scripted stages when the player presses the same button or motion again within a window. Unlike target combos built from normals, rekka lives inside one special slot and often carries unique neutral utility per stage. This guide covers stage machines, hit and block gating, branching routes, recovery tiers, interaction with special cancels and hit confirms, the Harbor Brawl refactor, a technique decision table, pitfalls, and a production checklist.

What a rekka system is

At runtime a rekka is a small state machine attached to one special move ID:

Stage 0 (initial) — first button press fires the opening animation (often a low-commit poke or approach tool).
Stage 1..N — each subsequent press within the rekka window spawns the next animation if gating rules pass.
Terminal stage — final hit returns the character to neutral (or a defined recovery state); no further rekka input accepted.
Timeout — if the player does not advance within N frames, the rekka chain ends and recovery begins.

Classic examples: Iori's fireball rekka in KOF (three punches, each a different speed and angle), Cammy's spiral arrow variants in some entries, Fei Long's rekka punches in Street Fighter. The pattern gives one special input multiple neutral roles — stage one for spacing, stage two for confirm, stage three for damage or knockdown.

Rekka differs from mashable multi-hit supers: each stage is a discrete animation with its own hitboxes, not a single long active window. It also differs from charge-then-release moves: rekka advances on repeated tap, not hold duration.

Stage gating: hit, block, whiff, and whiff-cancel

Gating rules define when the next stage is legal. This is where most rekka balance problems originate.

Hit-only advancement

Stage two spawns only if stage one connected on hit. Blocked stage one ends the rekka and enters recovery. This is the safest default for offensive rekka: blockstrings cannot silently advance into frame traps. Pair with clear whiff recovery on stage one so neutral pokes stay punishable.

Block-valid advancement

Stage two can spawn on block — intentional for blockstring rekka. Each stage on block must be minus enough that the string ends or the opponent can mash reversal at a defined point. Never stack three block-valid stages that are collectively unpunishable unless the rekka costs meter or carries long total recovery.

Whiff-valid advancement

Some rekka allow stage two on whiff (approach rekka that whiffs stage one but stage two closes distance). Whiff-valid chains need long total recovery or airborne hurtboxes on later stages so whiff fishing loses neutral. Document whiff behavior in training mode — players assume rekka stops on whiff.

Per-stage cancel exits

Stage one may cancel to super on hit only; stage two may not cancel at all. Cancel exits turn rekka into a confirm tool instead of a fixed string. Wire cancel tables per stage, not per move family.

Input windows, buffering, and priority

Rekka feel depends on when the engine accepts the next press:

Hitstop buffer — accept stage N+1 from hitstop frame 1 through a defined end frame. Matches input buffer expectations from links and feels responsive on confirms.
Animation-only window — accept input only during active and recovery of stage N. Stricter; reduces accidental triple-rekka on block when players mash.
Strict sequential — ignore held buttons; require release-then-press per stage. Prevents one physical press from registering multiple stages on keyboard or pad with sticky switches.
Buffer vs special priority — if rekka stage two and a fireball special share the same button, define whether rekka consumes the input first. Ambiguity here produces “wrong move came out” tickets.

For online play, rekka stage counters must advance on confirmed simulation frames in rollback — do not gate stage two on predicted hit that later rolls back, or desynced rekka lengths appear under packet loss.

Branching rekka and route economy

Linear three-hit rekka is the default, but branching adds expression:

Directional branches — stage two forward vs down for overhead vs low. Branch choice usually hit-only; blocked stage one should not offer mixup branches.
Resource branches — stage three costs meter for armor or knockdown; free stage three is safe but weaker. Prevents rekka from being both low-cost neutral and high-damage confirm.
Per-stage scaling — apply combo scaling so rekka stage three in a long string does not exceed single-hit heavy damage. Rekka stage one often uses higher scaling when used as a combo starter from neutral.
Hitstun decay — later rekka stages in one string may apply reduced hitstun so juggle extensions cannot loop rekka into itself without juggle limits.

Author rekka routes in a table: stage ID, input, gate (hit/block/whiff), branch key, startup, on-block advantage, cancel list, scaling factor. One CSV exported to movelist and balance simulators beats scattered per-animation flags.

Recovery tiers and neutral risk

Each rekka stage should have a defined on-block and on-whiff outcome:

Stage one — fast, low damage, often safe or slightly minus (−2 to −6). Primary neutral tool.
Stage two — more damage, longer recovery, typically minus on block unless hit-only. Confirm reward.
Stage three — knockdown or launch, clearly punishable on block (−12 or worse) if block-valid at all.

A common mistake is making stage one too plus on block, which turns rekka into a self-advancing frame trap without requiring hit confirmation. Audit total frame advantage across all block-valid stages cumulatively — chip plus pushback can still jail even when individual stages look fair.

Whiff recovery on stage two and three must exceed punish range of common normals in your roster. If stage two whiff is only −8 and the fastest punish is 6 frames, neutral becomes rekka fishing.

Harbor Brawl refactor: rekka as commitment ladder

Anchor's rekka patch shipped four changes together:

Hit-only stage two and three — blocked stage one enters −8 recovery with no follow-up. Blockstring rekka loops disappeared.
Per-stage recovery markers — animation pipeline tags rekka_gate_open and rekka_gate_close synced to active frames; buffer accepts next stage only inside the gate.
Branch on hit only — forward stage two launches, down stage two knocks down; choice appears in training overlay after confirmed hit.
Stage-one super cancel — on hit only, stage one cancels to super before stage two window opens; rewards early confirms without forcing full rekka commitment.

Unsafe block rekka rate fell 34% to 9%. Average rekka damage on hit rose because players stopped mashing stage three on block and instead confirmed stage one into super or chose launch vs knockdown branch intentionally.

Technique decision table

Goal	Prefer rekka system	Prefer alternative
One special slot, multiple neutral tools	3-stage rekka with different spacing per stage	Separate special per function (poke, dash, anti-air)
Hit confirm into big damage	Hit-only stage two/three with super cancel off stage one	Normal into special cancel route
Blockstring pressure with clear escape	Block-valid stage one only; hit-only extensions	Stagger normals and frame traps without rekka
Beginner-friendly special	Lenient buffer, two stages max, target-combo-style prompts	Single-button target combo string
Approach and mixup from one input	Branching rekka with directional stage two	Command dash plus separate overhead/low special

Common pitfalls

Block-valid full string. Three minus-two stages still jail if pushback is short. Cumulative block advantage and pushback must be simulated, not eyeballed per stage.
Mash-through on block. If buffer accepts stage three during blockstun without hit gate, players mash out of pressure into accidental damage or unsafe recovery.
Shared animation cancel lists. Rekka stage two inheriting stage-zero cancel flags enables unintended super routes. Gate cancels per stage ID.
Rollback stage drift. Predicted hits that advance rekka before rollback correction desync online matches. Commit stage advance on confirmed hit flags only.
Infinite rekka loops. Stage three knocks down into oki that re-enters rekka with no scaling or juggle limit. Cap rekka repeats per combo or apply escalating scaling.
Opaque movelist. If the move list shows one icon for three stages, players discover gating by trial and error. Show stage tree in UI.

Production checklist

Author rekka stage table: ID, input, gate, branch, startup, advantage, cancels, scaling.
Default stage two and three to hit-only unless block pressure is an explicit design goal.
Mark rekka_gate_open and rekka_gate_close on every stage in the animation pipeline.
Define buffer depth and strict vs lenient input per stage in the combat spec.
Simulate cumulative block advantage and pushback across full block-valid paths.
Apply per-stage combo scaling and juggle limits in the route damage simulator.
Wire super and special cancel exits per stage, not per character-wide defaults.
Expose stage tree, gating failures, and branch options in training mode overlays.
Validate rollback reproduces rekka stage counters identically on both clients.
Publish rekka stage data alongside frame data for community lab tools.
Re-run blockstring safety suite after any gate, recovery, or buffer change.
User-test whiff and block paths with intermediate skill cohort before ranked ship.

Key takeaways

Rekka attacks are staged state machines inside one special — each press advances a scripted animation when gating rules pass.
Hit-only advancement for later stages prevents unpunishable block rekka loops.
Harbor Brawl cut unsafe block rekka from 34% to 9% of rounds with hit-only gates and per-stage recovery.
Branching, scaling, and cancel exits per stage turn rekka into a confirm tool rather than a mash string.
Compare rekka against target combos and special cancels when choosing route expression for a character.