Hard West (and Hard West 2) damage math — what the engine actually models

What Hard West actually does (per the manual + verified play)

Hard West's combat is deterministic with a per-target Luck pool acting as a dodge absorber. Per the official gameplay manual:

• Each shot reduces the TARGET's Luck by the shooter's chance-to-hit. If you have 75% to hit a target with 80 Luck, the shot misses (because Luck > 0) but the target's Luck drops to 5; the next 75% shot from anyone in your posse hits deterministically.
• Luck refills when the target IS hit (not when missed). Refill amount varies by character; capped at max Luck.
• The "Luck powers" are a separate pool — your posse spends Luck on special abilities (fan, ricochet, panic). That's distinct from the dodge absorber.

So Hard West Luck is fundamentally per-target absorption, not per-shooter hit-chance boost. There's no random hit roll — the dodge pool either absorbs the shot or doesn't.

What the engine's luck keyword models

The current luck preset implements a generic per-shooter hit-chance variance reduction: pool of 5 capacity, +5% to the shooter's next-attempt hit chance per pool unit (full pool = +25% boost), each hit consumes 1 pool, each miss refunds 1.

This is structurally a streak-protection mechanism — variance shrinks, mean stays put. It's a useful abstraction for "stochastic hit chance with cross-attempt memory," but it doesn't match Hard West's actual deterministic dodge-pool. Players coming from Hard West expecting per-target dodge math will get the wrong answer.

The engine and the Luck and streak protection pillar have been updated to call this out: the luck preset is a generic streak-protection variant, not a faithful Hard West model.

Engine grammar (as currently shipped)

Postfix luck keyword on a percentage attack chain:

<attack> @ hit P% attacks N luck

Per-shooter pool of 5 capacity, +5% to next attempt per unit, each hit consumes 1 luck, each miss refunds 1. Useful for modelling generic streak-protection mechanics; not a Hard West fidelity model.

The luck keyword composes with the standard attacks N chain primitive, the cascade [HP1, HP2, …] onkill kill-cascade chain, and multi-round rounds_to_kill simulations (Luck pool persists across round boundaries). The streak / Luck concept pillar covers the joint-state Markov walk that powers cascade and rounds_to_kill composition.

Worked examples

Each strike URL renders the full damage distribution. Compare the no-luck and with-luck rows: the Luck-pool variant has a higher mean (the pool starts full, so the first attempt sees max boost) and a much smaller "all-miss" tail.

About the parameter values

Hard West's exact Luck consumption and refund formulas aren't published in any official source. The preset here (pool of 5, +5% per unit, 1-for-1 hit / miss exchange) captures the structural shape of the mechanic from community datamining. The math substrate (state-carrying Markov walk over a bounded state space) is exact; per-game preset values can be substituted via the standard modulator parameters when a verified source is available.

Bravado — kill-chain refresh (narrowed model)

In Hard West 2, Bravado means: any kill fully refreshes the killer's AP, with no cap. The refreshed AP can be spent on movement, abilities, or attacks against any target. The engine models the specific subgame "spend the refreshed AP on another instance of the same attack against the next enemy in the queue" — that's the question damage math typically asks. The general "refresh AP, then move + use an ability + shoot a different target" case is out of scope for a pure damage engine.

Surface form: <attack> attacks N bravado [HP1, HP2, ...] chain M. chain M is a recursion bound on the math (default 10), not a game rule — the actual game has no cap.

Distinct from cascade [HPs] onkill <bonus> (which fires a separate bonus expression on the first kill only — caps at one pending follow-up regardless of multi-kill). Bravado tracks an integer pool of pending follow-up shots, so 3+ kills in a turn correctly accumulate 3+ extra shots.

Composes with

The Luck pool threads through the engine's other state machines via a shared joint-state Markov walk:

• Kill-cascade chain: cascade [HPs] onkill with Luck active — per-attack hit chance is looked up on the Luck-pool axis; each outcome transitions both the cascade and Luck axes together. Useful for "what if Hard West had GWM-on-kill."
• Multi-round encounters: rounds_to_kill threads Luck-pool state across round boundaries within an encounter, instead of refilling the pool each round. The joint (state, cum_damage) chain is the honest model of Hard West's per-encounter pacing.

Cross-encounter persistence composes on top by chaining encounters with the end-state distribution as the start state for the next encounter — same pattern as multi-arc gambler's- ruin in the CoC sanity pillar.

The faithful dodge primitive

Postfix grammar: <dmg> @ hit P% dodge L refill R shots N where L is the target's max Luck (0–100), R is the per-hit refill (0–100), and N is the shot count.

The walk is deterministic per shot:

• If current target Luck ≥ P: shot misses; target Luck -= P.
• Otherwise: shot hits; target Luck = min(current + R, L).

The hit count is then folded as an N-fold convolution of the conditional-on-hit damage distribution. With refill 0 the pool depletes monotonically (worst case for the defender); with refill = L the pool resets after every hit (best case for the defender).

Worked example: 100 @ hit 75% dodge 100 refill 50 shots 4 — first shot misses (Luck 100→25), second shot hits (Luck 25→75), third shot misses (Luck 75→0), fourth shot hits (Luck 0→50). Two hits × 100 = 200 mean damage, /strike/100~hit75dodge100refill50shots4.

Bullet ricochet (the in-game special ability bought with Luck power) is still abstracted: the engine's ricochet N falloff X% grammar models the "diminishing-damage chain that breaks on miss" math without modelling the encounter-geometry that determines which targets a real Hard West ricochet path actually hits.