From 23ae7a2572cc9cf63a0c55c645bd433b2b010ac0 Mon Sep 17 00:00:00 2001 From: Federico Pasqua Date: Sun, 27 Sep 2026 17:27:37 +0200 Subject: [PATCH] Add Kiai-decided metrics; keep Kiai at +2 (6.6, D47) Report how often a Tecnica is played and how often Kiai decides a Kumite or an Exam fight. The tie rule moves to RulesConfig.attacker_wins, shared by the engine and the metric; games are unchanged. RULES.md drops the Kiai +1 and catch-up variants from the rules under test. Co-Authored-By: Claude Opus 5.5 (1M context) --- RULES.md | 10 ++-- agents/plans/2026-09-25-dojo-board-and-sim.md | 20 ++++++-- src/dojo/engine.py | 5 +- src/dojo/metrics.py | 46 +++++++++++++++++-- src/dojo/report.py | 3 ++ src/dojo/rules.py | 6 +++ tests/test_metrics.py | 32 ++++++++++++- 7 files changed, 106 insertions(+), 16 deletions(-) diff --git a/RULES.md b/RULES.md index d80c0e6..bca7b9e 100644 --- a/RULES.md +++ b/RULES.md @@ -139,7 +139,7 @@ All other cards are shown and resolved immediately. | Type | Card | Effect | Qty | |---|---|---|---| -| Tecnica | Kiai | +2 to your Kumite total. *(+1 to be tested)* | 3 | +| Tecnica | Kiai | +2 to your Kumite total. | 3 | | Tecnica | Uke (Parata) | If you lose, you are not sent to Start (the track change still applies). A losing defender stays on its square; a losing attacker returns to the square it came from, and its turn ends with no square effect. | 2 | | Tecnica | Kaeshi (Contrattacco) | Reroll your die. | 2 | | Movement | Tsugi-ashi | Roll 2d6 and make another full move. That move has its own starting square (for Passo Falso). | 2 | @@ -174,11 +174,11 @@ All other cards are shown and resolved immediately. ## Rule variants under test -Parameters to validate by simulation: Kiai +2 vs +1; starting on 3 with 6+ players; -square mix; game length at 3/4/6/8 players; a catch-up rule (Allenamento gives +2 instead -of +1 to a player two or more belts behind the leader). +Parameters to validate by simulation: starting on 3 with 6+ players; square mix; game +length at 3/4/6/8 players. -Tested and set aside (simulator switches only): Exam ties to the defender; best-of-3 Exam. +Tested and set aside (simulator switches only): Exam ties to the defender; best-of-3 Exam; +Kiai +1. Earlier rules kept as simulator switches: Fatica costing only when you stop on it; Kumite allowed in the first round. diff --git a/agents/plans/2026-09-25-dojo-board-and-sim.md b/agents/plans/2026-09-25-dojo-board-and-sim.md index caca654..a11bcba 100644 --- a/agents/plans/2026-09-25-dojo-board-and-sim.md +++ b/agents/plans/2026-09-25-dojo-board-and-sim.md @@ -60,9 +60,10 @@ Deliverables: | D41 | Phase 6 order: board and Fatica (6.4 with 6.5) → seat order (6.2) → catch-up (6.9) → style dynamics (6.3) → Kiai (6.6), player counts (6.7), length → consolidation (6.8). Structural fixes before tuning | 6.1 review. | | D42 | **Board draft 2 adopted** as `board/quadrant.txt` (`board/board.txt` regenerated; draft 1 is in git history, commit 4998931) | 6.4.0 results. | | D43 | **6.2 seat order suspended**: measuring it needs 4,000+ games per scenario for an effect of a few points; D35 (no Kumite in round 1) stays in the rules. Seat rates are still reported by every run and watched in 6.8 | Developer, after the 4,000-game runs were started. | -| D44 | **6.9 catch-up skipped**: the v0.8 baseline already has 3–4% of player-turns out of contention (worst player 10–13%), so candidate A has little to fix | Developer, after the v0.8 baseline metrics. | +| D44 | **6.9 catch-up skipped**: the v0.8 baseline already has 3–4% of player-turns out of contention (worst player 10–13%), so candidate A has little to fix; dropped from RULES.md "variants under test" (never implemented) | Developer, after the v0.8 baseline metrics. | | D45 | The **`random` lineup is no longer run** in experiments: it never finishes a game and cost ~80% of a run's time. The bot stays in the code and the tests | Developer, 6.10. | | D46 | Performance work must leave **every game identical** (same events for the same seed), so every result recorded in this file stays valid | Developer, 6.10. | +| D47 | **Kiai stays +2**: +2 and +1 are indistinguishable on every target (6.6); +2 decides more fights (5% vs 3% of Kumite in casual play). `kiai_bonus = 1` stays a simulator switch; RULES.md drops the "+1 to be tested" note | Developer, 6.6 results. | ## Phases @@ -173,7 +174,7 @@ Deliverables: - One change at a time. When a change is adopted, re-run the 6.1 baseline so later steps start from the current rules, and log the decision (D-number) here and in `RULES.md`. - Results go in this file as a table per step (command line, scenario, key measures). -**Next action:** developer review of the 6.3 results; then 6.6 Kiai, when the developer says to continue. 6.2 is suspended (D43), 6.9 skipped (D44); 6.4.1 (chance square) stays optional. Order of the steps: D41. Everything up to 6.10 and D46 is committed (0ca905e); the 6.3 results are not; commit only when the developer asks. +**Next action:** 6.7 player counts. 6.2 is suspended (D43), 6.9 skipped (D44); 6.4.1 (chance square) stays optional. Order of the steps: D41. Everything up to 6.6 is committed; commit only when the developer asks. **Targets** (confirmed by the developer as a starting point, D32): @@ -281,7 +282,20 @@ Deliverables: - [x] 6.4.2 Option 1, Fatica on crossing: `RulesConfig.fatica_on_crossing` — each Fatica square entered during a move costs 1 stripe, **1 in total per square whether or not the move stops there** (developer, D33); stopping on it adds nothing more. Engine: apply in `_walk` per square entered (not on teleports / relocations, which never walk). Bot: count Fatica crossed in `_path_score`. Likely needs fewer Fatica squares; test on the current board and on a draft with fewer F. Done as the baseline rule (D36): engine `_step` / `_path_choices`, bot `_path_score`, tests; measured on the current board in the 6.1 re-baseline. - [ ] 6.4.3 If 6.4.1 is run: compare it with the v0.8 baseline on draft 2 (Fatica on crossing, D36) and bring the table to the developer for a decision (then `RULES.md` and D-number). - [x] 6.5 Home farming: covered by board draft 2 (6.4.0): Allenamento moved from the south training room onto the Dojo ring; own-quadrant share of square income 74% → 62–67%, short of the 60% aim (players cross their own quadrant for most of the game); draft 2 adopted as is (D42). Original step: after 6.4, if the own-quadrant share of square income is still above 60% (baseline: 71%), move Allenamento squares away from the Safe Rooms in a board draft (`dojo sim --quadrant board/drafts/...`) and compare. The board must still pass `dojo board validate`. -- [ ] 6.6 Kiai +2 vs +1: 1,000 games each on two lineups. Watch the Exam pass rate, upset rate and how often a Tecnica turns a fight. +- [x] 6.6 Kiai +2 vs +1: 1,000 games each on two lineups. Watch the Exam pass rate, upset rate and how often a Tecnica turns a fight. **Kiai stays +2 (D47).** + - [x] 6.6.1 Metric: `GameMetrics.tecnica_kumite`, `kiai_decided`, `exam_fights`, `exam_kiai_decided`; report line "Tecnica". A fight is decided by Kiai when the result flips with the Kiai bonus removed, dice and other cards unchanged. The tie rule moved to `RulesConfig.attacker_wins`, shared by the engine and the metric (fingerprinted games identical). + - [x] 6.6.2 Run: `uv run dojo sim --games 1000 --seed 0 --kiai 2 1 --lineup balanced,farmer,aggressive balanced casual`. + + | Lineup | Kiai | Minutes mean / p90 | Exam passed | Upsets | Tecnica played in; Kiai decided (Kumite / Exam) | Halfway leader wins | Rivals within 1 belt | + |---|---|---|---|---|---|---|---| + | mixed | +2 | 72 / 95 | 40% | 31% | 2%; 1% / 1% | 40% | 0.84 | + | mixed | +1 | 72 / 95 | 41% | 31% | 2%; 1% / 1% | 41% | 0.85 | + | balanced | +2 | 68 / 92 | 42% | 30% | 2%; 1% / 1% | 39% | 0.81 | + | balanced | +1 | 69 / 93 | 41% | 30% | 2%; 1% / 1% | 39% | 0.82 | + | casual | +2 | 91 / 122 | 43% | 27% | 12%; 5% / 5% | 39% | 1.42 | + | casual | +1 | 91 / 121 | 44% | 27% | 10%; 3% / 4% | 39% | 1.38 | + + - Reading: Kiai +2 and +1 are indistinguishable on every target measure (≤ 1 pp, inside the noise). Tecnica are rare: heuristic bots draw a Nebbia card on 2.3% of turns (0.5 Tecnica per game; Nebbia is worth 0.2 to them, below an Allenamento), casual bots on 9.7% (3.3 Tecnica per game). Even for casual play Kiai decides 5% (+2) vs 3% (+1) of Kumite. Scratch script `tecnica.py` (200 games per lineup). - [ ] 6.7 Player counts: 3 / 4 / 6 / 8 players, start 0; plus start 3 at 6 and 8 players. Minutes per count; decide whether 6+ players start on Yellow. - [x] 6.10 Simulation speed (before 6.3; D46: games unchanged). Profile: ~95% of the time was listing moves (`movement._extend`, `Board.neighbours`, the outcome keys in `Engine._path_choices`). - [x] 6.10.1 Guard: `agents/scripts/fingerprint_games.py` hashes every event of 210 games (mixed / casual at 4 players, 6 players, Fatica on stop with Kumite in round 1, random bots, 60-round cap); `write` before an engine change, `check` after. A tool for refactoring and speed work, not a test (rule changes are expected to differ). Timings came from a scratch benchmark. diff --git a/src/dojo/engine.py b/src/dojo/engine.py index f4de4d8..1f32779 100644 --- a/src/dojo/engine.py +++ b/src/dojo/engine.py @@ -368,10 +368,7 @@ class Game: uke[side] = True totals = (dice[0] + extra[0], dice[1] + extra[1]) - if exam and config.exam_ties_to_defender: - attacker_won = totals[0] > totals[1] - else: - attacker_won = totals[0] >= totals[1] # Senshu: ties go to the attacker. + attacker_won = config.attacker_wins(*totals, exam=exam) winner_belt, loser_belt = belts if attacker_won else belts[::-1] if winner_belt == loser_belt: kind = FightKind.EQUAL diff --git a/src/dojo/metrics.py b/src/dojo/metrics.py index a76985d..6e4fe02 100644 --- a/src/dojo/metrics.py +++ b/src/dojo/metrics.py @@ -26,7 +26,7 @@ from dojo.events import ( TurnSkipped, TurnStarted, ) -from dojo.rules import RulesConfig +from dojo.rules import Card, RulesConfig # Table-time estimate (plan, resolved questions). TURN_SECONDS = 45 @@ -59,6 +59,12 @@ class GameMetrics: exam_attempts: int exam_passes: int exam_challengers: int + exam_fights: int + # Fights with a Tecnica played, and fights whose result flips without the Kiai played + # (dice and other cards unchanged). + tecnica_kumite: int + kiai_decided: int + exam_kiai_decided: int square_gain: int square_loss: int card_gain: int @@ -110,6 +116,7 @@ def measure( losses = Counter[Source]() home = away = 0 kumite = upsets = expected = exam_fights = 0 + tecnica_kumite = kiai_decided = exam_kiai_decided = 0 chain = max_chain = 0 exam_attempts = exam_passes = 0 attempts_by_seat = [0] * players @@ -144,10 +151,17 @@ def measure( position[player] = destination case SentToStart(player=player, square=square): position[player] = square - case KumiteFought(exam=True): + case KumiteFought(exam=True) as fight: exam_fights += 1 - case KumiteFought(attacker=attacker, defender=defender, attacker_won=won, kind=kind): + exam_kiai_decided += _decided_by_kiai(fight, config) + case ( + KumiteFought( + attacker=attacker, defender=defender, attacker_won=won, kind=kind + ) as fight + ): kumite += 1 + tecnica_kumite += bool(fight.cards) + kiai_decided += _decided_by_kiai(fight, config) upsets += kind is FightKind.UPSET expected += kind is FightKind.EXPECTED if attacker == active: @@ -201,6 +215,10 @@ def measure( exam_attempts=exam_attempts, exam_passes=exam_passes, exam_challengers=len(challengers), + exam_fights=exam_fights, + tecnica_kumite=tecnica_kumite, + kiai_decided=kiai_decided, + exam_kiai_decided=exam_kiai_decided, square_gain=gains[Source.SQUARE], square_loss=losses[Source.SQUARE], card_gain=gains[Source.CARD], @@ -233,6 +251,19 @@ def measure( ) +def _decided_by_kiai(fight: KumiteFought, config: RulesConfig) -> bool: + kiai = [0, 0] + for player, card in fight.cards: + if card is Card.KIAI: + kiai[0 if player == fight.attacker else 1] += config.kiai_bonus + if not any(kiai): + return False + without = config.attacker_wins( + fight.attacker_total - kiai[0], fight.defender_total - kiai[1], exam=fight.exam + ) + return without != fight.attacker_won + + def _leader(standings: Standings) -> int | None: top = max(standings) leaders = [p for p, t in enumerate(standings) if t == top] @@ -354,6 +385,11 @@ class Summary: exam_attempts_per_game: float exam_success: float exam_challengers: float + # Shares of Kumite (Exam excluded) with a Tecnica played / decided by Kiai; share of + # Exam fights decided by Kiai. + tecnica_rate: float + kiai_decided_rate: float + exam_kiai_decided_rate: float income_per_turn: dict[Source, tuple[float, float]] square_income_home_per_turn: float square_income_away_per_turn: float @@ -390,6 +426,7 @@ def summarize(scenario: str, games: Iterable[GameMetrics]) -> Summary: turns = sum(r.turns for r in rows) or 1 rounds = sum(r.rounds for r in rows) or 1 kumite = sum(r.kumite for r in rows) + exam_fights = sum(r.exam_fights for r in rows) attempts = sum(r.exam_attempts for r in rows) choices = sum(r.move_choices for r in rows) or 1 seats = len(rows[0].lineup.split(",")) @@ -420,6 +457,9 @@ def summarize(scenario: str, games: Iterable[GameMetrics]) -> Summary: exam_attempts_per_game=attempts / count, exam_success=sum(r.exam_passes for r in rows) / (attempts or 1), exam_challengers=sum(r.exam_challengers for r in rows) / count, + tecnica_rate=sum(r.tecnica_kumite for r in rows) / (kumite or 1), + kiai_decided_rate=sum(r.kiai_decided for r in rows) / (kumite or 1), + exam_kiai_decided_rate=sum(r.exam_kiai_decided for r in rows) / (exam_fights or 1), income_per_turn={ Source.SQUARE: ( per_turn(r.square_gain for r in rows), diff --git a/src/dojo/report.py b/src/dojo/report.py index 7841f7b..4cb787f 100644 --- a/src/dojo/report.py +++ b/src/dojo/report.py @@ -24,6 +24,9 @@ def format_summary(summary: Summary) -> str: f"Longest chain {_spread(summary.max_chain)} (Kumite in one turn, per game)", f"Exam {summary.exam_attempts_per_game:.2f} attempts/game, " f"{summary.exam_success:.0%} passed, {summary.exam_challengers:.2f} challengers/game", + f"Tecnica played in {summary.tecnica_rate:.0%} of Kumite; Kiai decided " + f"{summary.kiai_decided_rate:.0%} of Kumite, {summary.exam_kiai_decided_rate:.0%} of " + "Exam fights", f"Income/turn {income}", f"Square income home {summary.square_income_home_per_turn:+.2f}/turn, " f"away {summary.square_income_away_per_turn:+.2f}/turn (net)", diff --git a/src/dojo/rules.py b/src/dojo/rules.py index d4d3c44..fb0c8d0 100644 --- a/src/dojo/rules.py +++ b/src/dojo/rules.py @@ -89,6 +89,12 @@ class RulesConfig: def shifted(self, position: int, delta: int) -> int: return max(0, min(position + delta, self.max_position)) + def attacker_wins(self, attacker_total: int, defender_total: int, *, exam: bool) -> bool: + """Senshu: ties go to the attacker, unless the Exam option gives them to the defender.""" + if exam and self.exam_ties_to_defender: + return attacker_total > defender_total + return attacker_total >= defender_total + @property def exam_wins_needed(self) -> int: """Rounds the challenger must win: the Exam is a best-of-``exam_rounds`` series.""" diff --git a/tests/test_metrics.py b/tests/test_metrics.py index 114a2da..5f045f3 100644 --- a/tests/test_metrics.py +++ b/tests/test_metrics.py @@ -17,7 +17,7 @@ from dojo.events import ( TurnStarted, ) from dojo.metrics import KUMITE_SECONDS, TURN_SECONDS, GameMetrics, measure, summarize -from dojo.rules import DEFAULT_RULES +from dojo.rules import DEFAULT_RULES, Card HOME_0 = Pos(0, 1) # quadrant 0 @@ -76,6 +76,36 @@ def test_measure_counts_fights_income_and_exams() -> None: assert metrics.minutes == pytest.approx(round((3 * TURN_SECONDS + 5 * KUMITE_SECONDS) / 60, 1)) +@pytest.mark.parametrize( + ("totals", "attacker_won", "cards", "decided"), + [ + ((5, 4), True, ((0, Card.KIAI),), True), + ((5, 3), True, ((0, Card.KIAI),), False), # 3 vs 3 without it: Senshu, still won. + ((8, 4), True, ((0, Card.KIAI),), False), + ((4, 5), False, ((1, Card.KIAI),), True), + ((6, 5), True, ((0, Card.KIAI), (1, Card.KIAI)), False), + ((5, 4), True, ((0, Card.KAESHI),), False), + ], +) +def test_kiai_decides_a_fight_only_when_the_result_flips_without_it( + totals: tuple[int, int], + attacker_won: bool, + cards: tuple[tuple[int, Card], ...], + decided: bool, +) -> None: + fight = KumiteFought(0, 1, 0, 0, *totals, attacker_won, FightKind.EQUAL, False, cards) + exam = replace(fight, exam=True) + + metrics = run([TurnStarted(2, 0, 7), fight, fought(1, 0, FightKind.EQUAL), exam]) + summary = summarize("test", [metrics]) + + assert (metrics.tecnica_kumite, metrics.kiai_decided) == (1, decided) + assert (metrics.exam_fights, metrics.exam_kiai_decided) == (1, decided) + assert summary.tecnica_rate == 0.5 + assert summary.kiai_decided_rate == decided / 2 + assert summary.exam_kiai_decided_rate == decided + + def test_standings_are_sampled_at_turn_ends() -> None: metrics = run( [