# Fencer One combatant in the fence duel. Attaches to a bare entity — it asks `fencer_body` for its rig in `awake`, so it needs no Model or mesh of its own. Owns footwork along the piste (world X, depth and height held) and the windup → active → recover state machine behind the four commitments: `thrust`, `sweep`, `lunge` and `parry`. Every commitment carries the body over its own `advance`, so distance and commitment can be made in one action; the step stops at the fencer's own `minReach` rather than carrying it inside its own measure. Footwork is bounded by the other fencer, not by the property line: a man who has drawn back into his own garden is still reachable, which is the whole reason to hold the measure. Breaking ground is slower than taking it. A commitment that reached nobody — short of its reach, or crowded inside it, or a guard that turned nothing aside — enters recovery from a debt. So does one that was parried. The debt is the commitment's own (`duel.whiffOf` / `duel.parriedOf`), so it scales with what the commitment bought: a thrust turned aside costs half a second and a lunge turned aside costs the better part of two. That debt is the opening the other fencer is meant to punish, and `phaseTime < 0` in `recover` is how a reader tells a real opening from an ordinary recovery. **The lunge is recovered to the line it was thrown from.** It is the one commitment marked `recoil`: whatever of its 1.30 m of `advance` it managed to cover, it gives back over its own recovery, travelling backwards at the pace it went out and unable to answer anything while it does. `recoilLeft` is the ground still owed. So the lunge buys half a metre of reach nothing else has, and buys no position at all — which is what stops it being a free way to close the measure. A commitment made while `riposte` is open comes out at `RIPOSTE_QUICK` of its wind-up, reaches `RIPOSTE_REACH` further, cannot be turned aside, and plants `RIPOSTE_POSTS` posts instead of one. The component is input-agnostic except for one case: a `role = "player"` fencer on a local entity reads the `move` axis and the `thrust` / `sweep` / `lunge` / `parry` actions itself. A `role = "rival"` fencer is driven by `FencerAI` through the same public methods a human's input reaches. Fields worth reading from outside: `role`, `action`, `phase`, `phaseTime`, `riposte`, `ripostePending`, `whiffed`, `frozen`, `touches`, `facing`. `action` is `""` while idle, not `"guard"`; the idle `phase` is `"guard"`. Methods: `commit(name)`, `walk(dir, dt, line)`, `resetTo(line)`, `receiveTouch()`, `beParried()`, `clash()`, `openRiposte()`, `markContact()`, `freeze(on)`, `isStriking()`, `currentReach()`, `currentMinReach()`. Requires the `duel` and `fencer_body` modules and `@builtin::modules.zinput`. `DuelMatch` umpires between two of these; it is what calls `receiveTouch` / `beParried` / `clash` / `openRiposte` / `markContact`.

# FencerAI The neighbour across the line. Sits beside a `Fencer` (`role = "rival"`) and drives it through the same public methods a human's input reaches, so it plays by exactly the rules the player does. ## What it does - **Keeps the measure.** Between decisions it sits inside its own thrust measure rather than at the far edge of it, and breaks ground when crowded. - **Reads the tell.** Seeing a wind-up costs `0.34 - 0.20 * skill` seconds, so a thrust's 0.22 s tell is under an ordinary neighbour's eye and a sweep's or a lunge's is not. A read thrust or lunge is answered with a guard; a read sweep is answered by not being there, because a broadside crashes through a guard. - **Keeps a book.** Every commitment the opponent makes is counted into a decaying tally. A man who has thrust four times running meets a guard that went up *before* the wind-up it answers — which is the only reply to a tell too short to see. A man who keeps holding a guard meets a broadside. A man who keeps swinging broadsides takes the parry's weight back out of the book. - **Punishes an opening.** A blade that whiffed or was turned aside recovers from a debt; that is an opening, and an ordinary recovery is not. - **Takes its riposte** without thinking, at the extended measure a riposte reaches. - **Observes the forms.** A neighbour does not run a man through who has not raised his panel. When the opponent has offered nothing for a while, the invitation is waited for — for `patience` seconds' worth of good form — and the measure is held rather than closed. The riposte, the punish and the read all run above this, so the courtesy costs nothing against a man who is actually fencing; it is felt only by one who is not. ## Style `style` names which neighbour's fencing this is, and it is what makes the roster three opponents rather than one opponent at three settings. It is set from `DuelMatch.neighbourKey`, and the table it selects lives in `duel.STYLES`. - **Mrs Pettifer** keeps bees and keeps her distance. She stands at the far edge of the measure, takes a long time over a decision, will not be hurried into a lunge, and will wait all afternoon for a man who has not yet offered anything. - **Major Wickham** fenced for the regiment and remembers everything. He fences the man rather than the measure: a stroke thrown twice is a stroke he has already answered, and the third one meets the answer waiting for it — a guard already rising against a repeated thrust, a thrust inside a repeated broadside's wind-up, a broadside through a panel that keeps being hidden behind. - **The Dowager Lady Ashcombe** has not surrendered a boundary in forty years. She fights close, gives no ground, favours the broadside and the lunge, and fences hardest of all with her own hedge behind her: `ardour` reports the quality she is actually fencing at, which rises with the line as it comes back toward her. ## Skill `skill` (0..1) moves six things at once: how quickly the eye settles on a wind-up, how reliably that read turns into the right answer, how often an opening is punished, how briskly it decides, how strongly the book steers it, and — the one that shows most — how truly it judges the measure. A low neighbour believes his panel is longer than it is and throws from too far out, whiffing and handing over the openings a good one never gives. ## Fields `skill`, `style`, `opponent` (left unset, it finds the `role = "player"` fencer), and the live read-outs `decision`, `reading` (`attacker` | `turtle` | `sweeper` | `mixed`), `thinkIn`, `sawExposed`, `idleFor`, `indulge`, `ardour`, and the `habit*` counters. Requires the `duel` module.

# garden The grounds the Hedgerow Assizes are fought in, and the boundary fence that is the health bar. ```luau local Garden = require("garden") Garden.build(style) -- rebuild the static arena under "duel_arena" Garden.fence(line) -- rebuild the boundary under "duel_fence" Garden.style() -- the style standing in the world right now Garden.styleLabel(name) -- what a style's grounds are called Garden.STYLES -- { "assize", "pettifer", "wickham", "ashcombe" } ``` ## Styles One rite, four grounds. `assize` is the neutral ground the game opens on; the other three are the neighbours'. Every style is the same ground plan wearing a different palette, skyline and furniture — the lawn, the piste, the gateways and the dark band a fencer's shoulders are read against never move. | style | grounds | reads as | |---|---|---| | `assize` | the neutral ground | clipped topiary, urns, brick perimeter | | `pettifer` | Lower Marsh Cottage | blossom hedge, orchard, bee skeps, cottages beyond the gates | | `wickham` | The Limes | cool clipped yew, pennants, bollards and chain, poplars | | `ashcombe` | Ashcombe Hall | dark ancient topiary and a peacock, stone terrace, the Hall at both ends | `style` is **sticky**. `DuelMatch` and `GardenDressing` both rebuild the arena with no argument, and a garden that reverted every restart would be no garden at all — so a name sets it and a later `build()` keeps it. An unknown name falls back to the standing style rather than erroring. To go back to the neutral ground, name it: `Garden.build("assize")`. ## The lawn is the score `Garden.fence(line)` draws the ground the fence has taken as the history of the bout rather than as one pale rectangle: - everything more than four posts back is settled turf, mown and grown in; - the four most recent bays are laid one to a post and brighten toward the line; - every one of those posts still shows its spoil ring — earth turned when it went in, greening over with each bay it falls behind; - the leading edge is cut in three steps, because a lawn does not change hands along a ruler; - the paling stops 0.42 m short of the line so the boundary post stands clear of it, with the two fencers straddling it. ## Rules this module keeps - **Nothing it makes reaches `scene.json`.** Every entity is `setTemporary(true)` on the line after it spawns; both builders despawn what they find first. - **Flat things are shelved.** Every horizontal surface has its own height in `M.Y`, 10 mm apart, and each is a 20 mm slab whose TOP sits on its shelf. Two flat slabs that overlap in depth z-fight, and a z-fight across a lawn reads as a diagonal seam drawn on the grass. - **Nothing stands at fencer height inside the reading zone.** Every prop a style adds is behind the mid hedge or beyond a gateway. The eye must find the gap between the two fencers before it finds anything else. - **The garden has edges.** A perimeter wall on the three open sides and a treeline beyond them, because without them the turf runs to the horizon in every direction and the walled garden is not walled. ## Adding a style Add an entry to `STYLE` and its name to `M.STYLES`. A style is a palette plus three functions — `skyline`, `furniture` and `beyond` — and nothing else in the module needs to know about it.

# duel The rules of the Hedgerow Assizes, in one place: the ground plan of the walled garden, the frame data of the four commitments, the measure each one works at, the triangle that decides what a contact means, how far a post drives the property line, and the roster of neighbours with the fencing each one keeps. Every duel component reads its numbers from here, so the whole match is tuned in one file. Consumed by `Fencer`, `FencerAI`, `DuelMatch`, `DuelHud`, `DuelFx`, `garden` and the main scene's entrypoint. ## The measure Each action carries a band, not a range: `reach` is the furthest the blade crosses and `minReach` the nearest — inside that, the panel is smothered and the attack is *crowded out*. `advance` is the ground the commitment itself takes, so every attack steps in and a defender cannot simply walk backwards out of the sport. A commitment that reached nobody runs its recovery from a debt, and that debt is the whole punishment for committing at the wrong distance. | Action | windup | active | recover | reach | minReach | advance | whiff | parried | |---|---|---|---|---|---|---|---|---| | `thrust` | 0.22 | 0.10 | 0.42 | 2.55 | 1.55 | 0.35 | 0.35 | 0.45 | | `sweep` | 0.34 | 0.20 | 0.58 | 2.15 | 0.00 | 0.25 | 0.55 | 0.65 | | `lunge` | 0.30 | 0.16 | 0.95 | 3.05 | 1.75 | 1.30 † | 1.00 | 1.20 | | `parry` | 0.05 | 0.34 | 0.40 | — | — | — | 0.30 | — | † The lunge is marked `recoil`: whatever of its `advance` it managed to cover it gives back over its own recovery, travelling backwards and unable to answer anything while it does. It buys reach; it never buys position. ## The triangle `parry` turns a `thrust` and a `lunge` aside and earns a riposte; a `sweep` crashes through a held guard; a `thrust` arrives inside a `sweep`'s long wind-up. A riposte cannot be turned at all. **The guard answers from its first frame.** `resolveTouch` treats a `parry` in `windup` exactly as it treats one in `active`, because a guard that only worked once it had finished rising could be beaten by an attack thrown from further out than the wind-up is long — which made a correct read lose to a committed attack, the one outcome the triangle exists to prevent. ## What a post is worth A post is not a fixed step. Three properties of the ground decide how far the line moves, and between them they are what gives a bout its length: | | | | |---|---|---| | `POST_STEP` | 1.15 | fresh mown lawn in the middle of a garden | | `POST_ROOTED` | 0.60 | the last feet before a hedge are old rooted ground, and give up to this much of the step | | `POST_RECLAIM` | 0.35 | lawn you already conceded holds somebody else's posts; they come out before the line passes back | | `POST_CHURN` | 0.05 | each post already driven breaks the ground a little further, to `POST_CHURN_MAX` | `postDrive(line, dir, posts, driven)` is the whole rule. Rooted ground stops a garden being annexed by a short run of luck; conceded ground stops two even fencers walking the line back and forth all afternoon. Chosen against a simulation of the rule over 600 bouts a configuration, with the riposte rate and touch cadence taken from played logs: a median bout of about 20 touches, 80 % of bouts between 45 s and 120 s. ## The roster, and how each one fences `NEIGHBOURS` is the roster — index, `key`, `skill` and `style`. `STYLES` is the fencing attached to each key, and it is what makes three opponents rather than one opponent at three settings: | | `hold` | `think` | `patience` | `adapt` | `boundary` | |---|---|---|---|---|---| | `pettifer` | +0.55 | 1.45 | 2.4 | 0.6 | 0.0 | | `wickham` | 0.00 | 0.90 | 1.0 | 2.2 | 0.15 | | `ashcombe` | −0.35 | 0.75 | 0.6 | 1.1 | 1.0 | `hold` moves the measure held at rest; `think` the pause between commitments; `patience` how long an opponent who has offered nothing is indulged before the touch is simply fetched; `adapt` how heavily a repeated stroke steers the answer and how much faster the eye settles on one it has seen; `boundary` how far the defence of one's own ground stiffens the fencing as the line comes back toward one's own hedge. `w*` are the standing appetites for each commitment. `style(key)` falls back to `wickham`'s for an unknown name rather than erroring. ## Surface - `ACTIONS` — the table above. - `isAttack(name)`, `reachOf(name, isRiposte)`, `windupOf(name, isRiposte)`, `advanceSpeed(name)`, `whiffOf(name)`, `parriedOf(name)`. - `resolveTouch(attack, defAction, defPhase, isRiposte)` — `"touch"` | `"parried"` | `"nothing"`. - `measureFault(name, gap, isRiposte)` — `"short"` | `"crowded"` | `nil`. - `postDrive(line, dir, posts, driven)` — metres one touch moves the boundary. - `resetX(line, side)` / `clampX(x, line, side, foeX)` — where a fencer stands, and how far it may travel: bounded by the opponent, not by the line. - `winner(line)` — `"player"` | `"rival"` | `nil` for the boundary's position. - `NEIGHBOURS`, `neighbour(index)`, `neighbourIndexOf(key)`, `neighbourNearestSkill(skill)`, `STYLES`, `style(key)`. - `LAWN_HALF`, `LINE_LIMIT`, `POST_STEP`, `POST_ROOTED`, `POST_RECLAIM`, `POST_CHURN`, `POST_CHURN_MAX`, `RIPOSTE_POSTS`, `STANCE`, `WALK_SPEED`, `RETREAT_FACTOR`, `MIN_GAP`, `LEASH`, `RIPOSTE_WINDOW`, `RIPOSTE_QUICK`, `RIPOSTE_REACH`, `CLASH_PUSHBACK`, `HIT_STUN`, `SALUTE_TIME`, `TOUCH_PAUSE`, `SIDE`, `COLOR`.

# fencer_body What a combatant in the Hedgerow Assizes looks like. ```luau local Body = require("fencer_body") Body.build(owner, role, kit) -- rebuild this fencer's rig Body.pose(owner, action, phase, facing) -- pose it; safe every frame Body.isBuilt(owner) -- was this rig built by this module? Body.forget(owner) -- drop the memoised pose Body.kitOf(role) -- the kit standing on a role Body.kitLabel(name) -- what a turnout is called Body.KITS -- { "assize", "pettifer", "wickham", "ashcombe" } ``` ## Turnouts **The kit dresses the rival only.** The player is the player in every assize and wears the same whites against all three neighbours. | kit | turnout | the read | |---|---|---| | `assize` | claret | a dark block over pale legs | | `pettifer` | the bee veil | a horizontal brim where a head should be | | `wickham` | regimentals | the outline goes UP: shako, plume, cross-belt | | `ashcombe` | mourning | one unbroken dark column to the ground, no legs | Every turnout changes the **silhouette**, not only the palette, because at the size the broadcast camera draws them the outline is the whole of the information. `extra` in each kit is where that happens; it runs after the shared skeleton, and everything it spawns hangs off the rig so it despawns with it. `kit` is **sticky per role**. `Fencer` and `GardenDressing` both rebuild a body with no kit argument, and a rival who reverted to the house colours every rebuild would not be a neighbour. An unknown name falls back to the standing kit rather than erroring. ## Pose Every commitment is a pose of the panel plus the arm that carries it, and the panel's **angle is the tell**: broadside is a sweep gathering, edge-on is a thrust on its way, flat across the body is a guard. A new commitment is a new row in `POSE`, keyed by the same name `Duel.ACTIONS` uses. `pose` memoises the last action/phase/facing and returns immediately when nothing changed — a fencer holds one pose for whole tenths of a second, and re-writing eight transforms every frame for a body that has not moved is the most expensive thing this module could do. ## Rules this module keeps - Nothing it makes reaches `scene.json`: every entity is `setTemporary(true)` on the line after it spawns, and `build` despawns the old rig first. - `panel`, `arm` and `glove` are fixed names — every driver of this body poses those entities. - A rig carries a `_body_mark` child, so a driver can tell a rig this module built from one an older inline builder put up.