openbrawl 0.2.2

package/LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2026 Bad Cat Brewing LLC. All rights reserved.
+
+This software and associated documentation files (the "Software") may not be
+copied, modified, merged, published, distributed, sublicensed, or sold, in
+whole or in part, without the prior written permission of the copyright holder.
+
+The Software is provided "as is", without warranty of any kind, express or
+implied. In no event shall the copyright holder be liable for any claim,
+damages, or other liability arising from the use of the Software.
+
+Use of the Software via its published npm package (openbrawl) is permitted for
+personal, non-commercial purposes only.

package/README.md

@@ -0,0 +1,21 @@
+# OpenBrawl
+
+AI-powered auto-battler in your terminal. Type a prompt. Forge a creature. Watch it fight.
+
+Requires [Claude Code](https://claude.ai/claude-code) to be installed.
+
+## Play
+
+```bash
+npx openbrawl
+```
+
+## Modes
+
+**Forge Mode** - 10 rounds of prompt-driven creature evolution. Describe weapons, defenses, abilities, allies, and transformations. Claude interprets your prompts and generates stats, abilities, and mutations. Battle AI rivals after each round.
+
+**Buddy Battle** - Pit two Anthropic buddy cards against each other in a best-of-3 narrative showdown. Copy a buddy card to your clipboard, press V to load it, and watch Claude narrate the fight beat by beat.
+
+## License
+
+Proprietary. See [LICENSE](./LICENSE).

package/dist/buddy/battle.js

@@ -0,0 +1,41 @@
+// src/buddy/battle.ts
+function extractJSON(raw) {
+    try {
+        JSON.parse(raw.trim());
+        return raw.trim();
+    }
+    catch { }
+    const fenceMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fenceMatch)
+        return fenceMatch[1].trim();
+    const objMatch = raw.match(/\{[\s\S]*\}/);
+    if (objMatch)
+        return objMatch[0];
+    return raw.trim();
+}
+export function parseBattleRound(raw, roundNumber, validNames) {
+    const json = JSON.parse(extractJSON(raw));
+    const beats = (json.beats ?? []).map((b) => String(b));
+    if (beats.length === 0) {
+        throw new Error("No beats in battle response");
+    }
+    let winner = String(json.winner ?? "");
+    // Validate winner is one of the two buddy names
+    if (!validNames.includes(winner)) {
+        // Try case-insensitive match
+        const match = validNames.find((n) => n.toLowerCase() === winner.toLowerCase());
+        if (match) {
+            winner = match;
+        }
+        else {
+            // Fallback: pick randomly
+            winner = validNames[Math.random() < 0.5 ? 0 : 1];
+        }
+    }
+    return {
+        roundNumber,
+        beats,
+        winner,
+        victoryQuip: json.victoryQuip ?? json.victory_quip ?? undefined,
+    };
+}

package/dist/buddy/parse.js

@@ -0,0 +1,93 @@
+// src/buddy/parse.ts
+export function parseBuddyCard(raw) {
+    // Strip box-drawing characters from each line
+    const lines = raw.split("\n").map((line) => line.replace(/[│╭╮╰╯─┌┐└┘┬┴├┤┼║═╔╗╚╝╠╣╦╩╬]/g, "").trim()).filter((line) => line.length > 0);
+    // Parse rarity + species from line with star characters
+    let rarity = "";
+    let species = "";
+    const rarityLineIdx = lines.findIndex((l) => /[★☆✦✧⭐]/.test(l) || /^(COMMON|UNCOMMON|RARE|LEGENDARY)/i.test(l));
+    if (rarityLineIdx !== -1) {
+        const rarityLine = lines[rarityLineIdx];
+        const starMatch = rarityLine.match(/[★☆✦✧⭐]+/);
+        const words = rarityLine.replace(/[★☆✦✧⭐]+/, "").trim().split(/\s+/);
+        // Rarity label is typically the first ALL-CAPS word, species is the last
+        const capsWords = words.filter((w) => w === w.toUpperCase() && /^[A-Z]{2,}$/.test(w));
+        if (capsWords.length >= 2) {
+            rarity = `${starMatch?.[0] ?? ""} ${capsWords[0]}`.trim();
+            species = capsWords[capsWords.length - 1];
+        }
+        else if (capsWords.length === 1) {
+            rarity = `${starMatch?.[0] ?? ""} ${capsWords[0]}`.trim();
+        }
+    }
+    // Parse stats — lines matching: ALL_CAPS_NAME  bar_chars  number
+    const stats = [];
+    const statLineIndices = [];
+    lines.forEach((line, idx) => {
+        const statMatch = line.match(/^([A-Z][A-Z\s]+?)\s+[█░▓▒]+\s+(\d+)$/);
+        if (statMatch) {
+            stats.push({ name: statMatch[1].trim(), value: parseInt(statMatch[2], 10) });
+            statLineIndices.push(idx);
+        }
+    });
+    // Parse description — text between quotes (may span multiple lines)
+    const fullText = lines.join("\n");
+    const descMatch = fullText.match(/"([^"]+)"/s);
+    const description = descMatch ? descMatch[1].replace(/\s+/g, " ").trim() : "";
+    // Find the description line indices for exclusion
+    const descLineIndices = [];
+    if (description) {
+        let inDesc = false;
+        lines.forEach((line, idx) => {
+            if (line.includes('"') && !inDesc) {
+                inDesc = true;
+                descLineIndices.push(idx);
+            }
+            else if (inDesc) {
+                descLineIndices.push(idx);
+                if (line.includes('"'))
+                    inDesc = false;
+            }
+        });
+    }
+    // Find name — standalone text line that isn't rarity, stats, or description
+    const excludedIndices = new Set([rarityLineIdx, ...statLineIndices, ...descLineIndices]);
+    let name = "";
+    let nameIdx = -1;
+    // Name comes after the art section, before description/stats
+    // Look for a short standalone text line (1-3 words, not ASCII art)
+    const firstStatIdx = statLineIndices.length > 0 ? Math.min(...statLineIndices) : lines.length;
+    const firstDescIdx = descLineIndices.length > 0 ? Math.min(...descLineIndices) : lines.length;
+    const nameSearchEnd = Math.min(firstStatIdx, firstDescIdx);
+    for (let i = 0; i < nameSearchEnd; i++) {
+        if (excludedIndices.has(i))
+            continue;
+        const line = lines[i];
+        // Name: short text, no special chars (not ASCII art)
+        if (line.length > 0 && line.length <= 30 && /^[A-Za-z][\w\s'-]*$/.test(line) && line.split(/\s+/).length <= 4) {
+            name = line;
+            nameIdx = i;
+            break;
+        }
+    }
+    // ASCII art — everything between rarity line and name line that isn't parsed as something else
+    const artStart = rarityLineIdx !== -1 ? rarityLineIdx + 1 : 0;
+    const artEnd = nameIdx !== -1 ? nameIdx : firstDescIdx;
+    const artLines = [];
+    for (let i = artStart; i < artEnd; i++) {
+        if (!excludedIndices.has(i)) {
+            artLines.push(lines[i]);
+        }
+    }
+    const asciiArt = artLines.join("\n");
+    if (!name && stats.length === 0) {
+        throw new Error("Could not parse buddy card — no name or stats found.");
+    }
+    if (stats.length === 0) {
+        throw new Error("Could not parse buddy card — no stats found.");
+    }
+    if (!name) {
+        name = "Unknown Buddy";
+    }
+    return { name, rarity, species, asciiArt, description, stats };
+}

package/dist/buddy/prompts.js

@@ -0,0 +1,43 @@
+// src/buddy/prompts.ts
+function serializeBuddy(buddy) {
+    const statsStr = buddy.stats.map((s) => `  ${s.name}: ${s.value}/100`).join("\n");
+    return `Name: ${buddy.name}
+Rarity: ${buddy.rarity}
+Species: ${buddy.species}
+Description: "${buddy.description}"
+Stats:
+${statsStr}`;
+}
+export function buildBuddyBattlePrompt(playerBuddy, opponentBuddy, roundNumber, priorRounds, isMatchPoint) {
+    const priorContext = priorRounds.length > 0
+        ? `\n\nPRIOR ROUNDS:\n${priorRounds.map((r) => `Round ${r.roundNumber}: ${r.winner} won.\n${r.beats.join("\n")}`).join("\n\n")}`
+        : "";
+    const system = `You are the narrator for an epic buddy battle — two collectible creatures with unique personalities and stats face off.
+
+BUDDY 1 (Player):
+${serializeBuddy(playerBuddy)}
+
+BUDDY 2 (Opponent):
+${serializeBuddy(opponentBuddy)}
+
+RULES:
+- These buddies do NOT use traditional ATK/DEF/SPD/HP stats. They have their own unique stats (like DEBUGGING, SNARK, CHAOS, MISCHIEF, etc.).
+- You decide how each buddy's stats translate into combat actions. A buddy with high SNARK might win by demoralizing the opponent. High DEBUGGING might mean spotting weaknesses. High CHAOS means unpredictable attacks. Be creative.
+- Always channel each buddy's personality and attitude throughout. Trash talk, passive-aggressive observations, and in-character quips are MANDATORY in every beat, not just at the end. The buddies' SNARK (or equivalent sass/attitude stat) should drip from the narration.
+- Write the round as exactly 4-6 beats (short dramatic moments, 1-3 sentences each).
+- The final beat MUST declare a winner for the round.
+- Reference specific stats BY NAME and VALUE to justify what happens. Don't just narrate — explain WHY a stat matters in this moment.
+- If this is round 2 or 3, account for prior rounds. Maybe the loser adapts, the winner gets cocky, or a new stat comes into play that wasn't relevant before.
+- Keep it fun, dramatic, and varied — don't repeat narrative patterns across rounds.
+- Battles should feel fair. Don't always give it to the buddy with higher total stats — creativity, personality, and stat matchups matter.
+${isMatchPoint ? "\n- This is the MATCH-DECIDING round. Include a \"victoryQuip\" field — the winner's in-character taunt for the victory screen. Make it memorable." : ""}
+${priorContext}
+
+Respond with ONLY valid JSON:
+{
+  "beats": ["beat 1 text", "beat 2 text", "...", "final beat declaring winner"],
+  "winner": "<exact buddy name>"${isMatchPoint ? ',\n  "victoryQuip": "<winner\'s in-character victory taunt>"' : ""}
+}`;
+    const user = `Narrate Round ${roundNumber} of 3. Fight!`;
+    return { system, user };
+}

package/dist/buddy/types.js

@@ -0,0 +1,2 @@
+// src/buddy/types.ts
+export {};

package/dist/cli.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { App } from "./ui/App.js";
+// Enter alternate screen buffer (like vim) — no scrollback, clean slate
+process.stdout.write("\x1B[?1049h");
+// Hide cursor
+process.stdout.write("\x1B[?25l");
+const { unmount, waitUntilExit } = render(_jsx(App, {}), { exitOnCtrlC: true });
+waitUntilExit().then(() => {
+    // Show cursor
+    process.stdout.write("\x1B[?25h");
+    // Leave alternate screen buffer — restores original terminal content
+    process.stdout.write("\x1B[?1049l");
+});

package/dist/game/combat.js

@@ -0,0 +1,325 @@
+function cloneForCombat(creatures, team) {
+    return creatures.map((c) => ({
+        ...c,
+        stats: { ...c.stats },
+        abilities: c.abilities.map((a) => ({ ...a })),
+        currentHP: c.currentHP,
+        team,
+        activeBuffs: [],
+    }));
+}
+function pickTarget(attacker, allCombatants) {
+    const enemies = allCombatants.filter((c) => c.team !== attacker.team && c.currentHP > 0);
+    if (enemies.length === 0)
+        return null;
+    // Allies (non-first creatures) are the front line — target them first.
+    // Only attack the main creature (index 0 in their team) when all allies are down.
+    if (enemies.length > 1) {
+        return enemies[enemies.length - 1]; // last = most recently added ally
+    }
+    return enemies[0];
+}
+function snapshot(combatants) {
+    return combatants
+        .filter((c) => c.currentHP > 0 || c.stats.HP > 0)
+        .map((c) => ({
+        name: c.name,
+        currentHP: Math.max(0, c.currentHP),
+        maxHP: c.stats.HP,
+        team: c.team,
+    }));
+}
+function resolveAbility(ability, owner, allCombatants, events, turn) {
+    // All abilities use value as % proc chance (except heal which always fires but is capped)
+    const roll = Math.random() * 100;
+    if (ability.effect === "stun") {
+        if (roll < ability.value) {
+            const target = pickTarget(owner, allCombatants);
+            if (target) {
+                events.push({
+                    turn,
+                    attacker: owner.name,
+                    attackerSPD: owner.stats.SPD,
+                    defender: target.name,
+                    damage: 0,
+                    abilityTriggered: ability.name,
+                    abilityEffect: `Stunned ${target.name} (${ability.value}% chance — rolled ${Math.floor(roll)})`,
+                    hpAfter: snapshot(allCombatants),
+                });
+            }
+        }
+        return;
+    }
+    if (ability.effect === "heal") {
+        // Heal uses value as flat amount, always fires but capped at missing HP
+        const healAmount = Math.min(ability.value, owner.stats.HP - owner.currentHP);
+        if (healAmount > 0) {
+            owner.currentHP += healAmount;
+            events.push({
+                turn,
+                attacker: owner.name,
+                attackerSPD: owner.stats.SPD,
+                defender: owner.name,
+                damage: -healAmount,
+                abilityTriggered: ability.name,
+                abilityEffect: `Healed ${healAmount} HP`,
+                hpAfter: snapshot(allCombatants),
+            });
+        }
+        return;
+    }
+    if (ability.effect === "damage") {
+        // Proc chance: value as %, capped at 75%
+        const procChance = Math.min(ability.value, 75);
+        if (roll >= procChance)
+            return;
+        const targets = ability.target === "all_enemies"
+            ? allCombatants.filter((c) => c.team !== owner.team && c.currentHP > 0)
+            : [pickTarget(owner, allCombatants)].filter(Boolean);
+        // Damage: scales with owner's ATK. Ability damage = 50-100% of ATK (based on value)
+        // value 15 = 50% ATK, value 50+ = 100% ATK. Minimum 2 damage.
+        const atkMultiplier = Math.min(1.0, 0.5 + (ability.value / 100));
+        const dmg = Math.max(2, Math.round(owner.stats.ATK * atkMultiplier));
+        for (const target of targets) {
+            target.currentHP = Math.max(0, target.currentHP - dmg);
+            events.push({
+                turn,
+                attacker: owner.name,
+                attackerSPD: owner.stats.SPD,
+                defender: target.name,
+                damage: dmg,
+                damageFormula: `${ability.name}: ${dmg} ability dmg (${procChance}% chance — rolled ${Math.floor(roll)})`,
+                abilityTriggered: ability.name,
+                abilityEffect: `Dealt ${dmg} ability damage`,
+                knockedOut: target.currentHP <= 0 ? target.name : undefined,
+                hpAfter: snapshot(allCombatants),
+            });
+        }
+        return;
+    }
+    if (ability.effect === "reflect") {
+        if (roll >= ability.value)
+            return;
+        const reflectTarget = pickTarget(owner, allCombatants);
+        if (reflectTarget) {
+            const reflectDmg = Math.max(1, Math.round(owner.stats.DEF * 0.4));
+            reflectTarget.currentHP = Math.max(0, reflectTarget.currentHP - reflectDmg);
+            events.push({
+                turn,
+                attacker: owner.name,
+                attackerSPD: owner.stats.SPD,
+                defender: reflectTarget.name,
+                damage: reflectDmg,
+                damageFormula: `${ability.name}: ${reflectDmg} reflect dmg (40% of ${owner.stats.DEF} DEF, ${ability.value}% chance — rolled ${Math.floor(roll)})`,
+                abilityTriggered: ability.name,
+                abilityEffect: `Reflected ${reflectDmg} damage`,
+                knockedOut: reflectTarget.currentHP <= 0 ? reflectTarget.name : undefined,
+                hpAfter: snapshot(allCombatants),
+            });
+        }
+        return;
+    }
+    if (ability.effect === "buff") {
+        if (roll >= ability.value)
+            return;
+        const buffAmount = Math.max(1, Math.round(owner.stats.ATK * 0.3));
+        owner.stats.ATK += buffAmount;
+        owner.activeBuffs.push({ stat: "ATK", amount: buffAmount, turnsRemaining: 3, source: ability.name });
+        events.push({
+            turn,
+            attacker: owner.name,
+            attackerSPD: owner.stats.SPD,
+            defender: owner.name,
+            damage: 0,
+            abilityTriggered: ability.name,
+            abilityEffect: `ATK buffed by +${buffAmount} for 3 turns`,
+            hpAfter: snapshot(allCombatants),
+        });
+        return;
+    }
+    if (ability.effect === "debuff") {
+        if (roll >= ability.value)
+            return;
+        const target = pickTarget(owner, allCombatants);
+        if (target) {
+            const debuffAmount = Math.max(1, Math.round(target.stats.DEF * 0.3));
+            target.stats.DEF -= debuffAmount;
+            target.activeBuffs.push({ stat: "DEF", amount: -debuffAmount, turnsRemaining: 3, source: ability.name });
+            events.push({
+                turn,
+                attacker: owner.name,
+                attackerSPD: owner.stats.SPD,
+                defender: target.name,
+                damage: 0,
+                abilityTriggered: ability.name,
+                abilityEffect: `DEF reduced by ${debuffAmount} for 3 turns`,
+                hpAfter: snapshot(allCombatants),
+            });
+        }
+        return;
+    }
+    // Fallback: treat any unknown effect as a damage proc
+    const procChance = Math.min(ability.value, 75);
+    if (roll >= procChance)
+        return;
+    const target = pickTarget(owner, allCombatants);
+    if (target) {
+        const atkMult = Math.min(1.0, 0.5 + (ability.value / 100));
+        const dmg = Math.max(2, Math.round(owner.stats.ATK * atkMult));
+        target.currentHP = Math.max(0, target.currentHP - dmg);
+        events.push({
+            turn,
+            attacker: owner.name,
+            attackerSPD: owner.stats.SPD,
+            defender: target.name,
+            damage: dmg,
+            damageFormula: `${ability.name}: ${dmg} dmg (unknown effect "${ability.effect}" — treated as damage)`,
+            abilityTriggered: ability.name,
+            abilityEffect: `Dealt ${dmg} damage`,
+            knockedOut: target.currentHP <= 0 ? target.name : undefined,
+            hpAfter: snapshot(allCombatants),
+        });
+    }
+}
+function triggerAbilities(trigger, owner, allCombatants, events, turn) {
+    for (const ability of owner.abilities) {
+        if (ability.trigger === trigger) {
+            resolveAbility(ability, owner, allCombatants, events, turn);
+        }
+    }
+}
+const MAX_TICKS = 500;
+const ATB_THRESHOLD = 100;
+/**
+ * ATB (Active Time Battle) combat engine.
+ *
+ * Each tick, every creature accumulates their SPD into a gauge.
+ * When the gauge hits the threshold (100), they act and the gauge resets.
+ * This naturally interleaves attacks: SPD 3 vs SPD 1 produces
+ * A, A, B, A, A, B, A, ... (3:1 ratio, interleaved).
+ */
+export function resolveCombat(playerTeam, rivalTeam) {
+    const combatants = [
+        ...cloneForCombat(playerTeam, "player"),
+        ...cloneForCombat(rivalTeam, "rival"),
+    ];
+    const events = [];
+    // ATB gauges — start at threshold so everyone acts on turn 1
+    const gauges = new Map();
+    for (const c of combatants) {
+        gauges.set(c, ATB_THRESHOLD);
+    }
+    let turnCounter = 0;
+    for (let tick = 0; tick < MAX_TICKS; tick++) {
+        const alive = combatants.filter((c) => c.currentHP > 0);
+        const playersAlive = alive.filter((c) => c.team === "player");
+        const rivalsAlive = alive.filter((c) => c.team === "rival");
+        if (playersAlive.length === 0 || rivalsAlive.length === 0)
+            break;
+        // Sudden death: after tick 300, all creatures take escalating damage
+        if (tick > 300) {
+            const suddenDeathDmg = tick - 300;
+            for (const c of alive) {
+                c.currentHP = Math.max(0, c.currentHP - suddenDeathDmg);
+                if (c.currentHP <= 0) {
+                    turnCounter++;
+                    events.push({
+                        turn: turnCounter,
+                        attacker: "Arena",
+                        attackerSPD: 0,
+                        defender: c.name,
+                        damage: suddenDeathDmg,
+                        damageFormula: `Sudden Death: ${suddenDeathDmg} arena damage (tick ${tick})`,
+                        knockedOut: c.name,
+                        hpAfter: snapshot(combatants),
+                    });
+                }
+            }
+            const pStillAlive = combatants.filter((c) => c.team === "player" && c.currentHP > 0);
+            const rStillAlive = combatants.filter((c) => c.team === "rival" && c.currentHP > 0);
+            if (pStillAlive.length === 0 || rStillAlive.length === 0)
+                break;
+        }
+        // Accumulate SPD into gauges
+        for (const c of alive) {
+            gauges.set(c, (gauges.get(c) ?? 0) + Math.max(1, c.stats.SPD));
+        }
+        // Find all creatures whose gauge hit the threshold
+        const acting = [];
+        for (const c of alive) {
+            if ((gauges.get(c) ?? 0) >= ATB_THRESHOLD) {
+                acting.push(c);
+                // Carry over excess gauge (not a full reset — preserves fractional advantage)
+                gauges.set(c, (gauges.get(c) ?? 0) - ATB_THRESHOLD);
+            }
+        }
+        if (acting.length === 0)
+            continue;
+        // If multiple creatures act on the same tick, faster goes first
+        acting.sort((a, b) => b.stats.SPD - a.stats.SPD);
+        turnCounter++;
+        for (const creature of acting) {
+            if (creature.currentHP <= 0)
+                continue;
+            // Tick down active buffs/debuffs
+            creature.activeBuffs = creature.activeBuffs.filter((b) => {
+                b.turnsRemaining--;
+                if (b.turnsRemaining <= 0) {
+                    creature.stats[b.stat] -= b.amount;
+                    return false;
+                }
+                return true;
+            });
+            triggerAbilities("start_of_turn", creature, combatants, events, turnCounter);
+            const target = pickTarget(creature, combatants);
+            if (!target)
+                break;
+            const rawDamage = creature.stats.ATK - target.stats.DEF;
+            // Chip damage: even fully blocked attacks deal 1 to prevent stalemates
+            const damage = rawDamage > 0 ? rawDamage : 1;
+            const blocked = rawDamage <= 0;
+            target.currentHP = Math.max(0, target.currentHP - damage);
+            events.push({
+                turn: turnCounter,
+                attacker: creature.name,
+                attackerSPD: creature.stats.SPD,
+                defender: target.name,
+                damage,
+                damageFormula: blocked
+                    ? `${creature.stats.ATK} ATK - ${target.stats.DEF} DEF = ${rawDamage} — mostly blocked! (1 chip dmg)`
+                    : `${creature.stats.ATK} ATK - ${target.stats.DEF} DEF = ${damage}`,
+                knockedOut: target.currentHP <= 0 ? target.name : undefined,
+                hpAfter: snapshot(combatants),
+            });
+            // Attacker's on_attack abilities
+            triggerAbilities("on_attack", creature, combatants, events, turnCounter);
+            // Defender's on_hit and on_defend abilities (defensive reactions)
+            if (target.currentHP > 0) {
+                triggerAbilities("on_hit", target, combatants, events, turnCounter);
+                triggerAbilities("on_defend", target, combatants, events, turnCounter);
+            }
+            if (target.currentHP <= 0) {
+                triggerAbilities("on_death", target, combatants, events, turnCounter);
+                const allies = combatants.filter((c) => c.team === target.team && c.currentHP > 0 && c.name !== target.name);
+                for (const ally of allies) {
+                    triggerAbilities("on_ally_death", ally, combatants, events, turnCounter);
+                }
+            }
+            const pAlive = combatants.filter((c) => c.team === "player" && c.currentHP > 0);
+            const rAlive = combatants.filter((c) => c.team === "rival" && c.currentHP > 0);
+            if (pAlive.length === 0 || rAlive.length === 0)
+                break;
+        }
+    }
+    const playerSurvivors = combatants.filter((c) => c.team === "player" && c.currentHP > 0);
+    const rivalSurvivors = combatants.filter((c) => c.team === "rival" && c.currentHP > 0);
+    const playerAlive = playerSurvivors.length > 0;
+    const rivalAlive = rivalSurvivors.length > 0;
+    return {
+        events,
+        playerWon: playerAlive && !rivalAlive,
+        draw: (!playerAlive && !rivalAlive) || (playerAlive && rivalAlive),
+        playerTeamSurvivors: playerSurvivors.map((c) => c.name),
+        rivalTeamSurvivors: rivalSurvivors.map((c) => c.name),
+    };
+}

package/dist/game/rounds.js

@@ -0,0 +1,70 @@
+const CATEGORY_CYCLE = [
+    "weapon",
+    "defense",
+    "special_ability",
+    "recruit_ally",
+    "reshape_evolve",
+];
+const BASE_WORD_BUDGET = 10;
+const WORD_BUDGET_GROWTH = 3;
+const BASE_STAT_BUDGET = 10;
+const STAT_BUDGET_GROWTH = 4;
+export function getCategoryForRound(round) {
+    return CATEGORY_CYCLE[(round - 1) % CATEGORY_CYCLE.length];
+}
+export function getWordBudget(round) {
+    return BASE_WORD_BUDGET + (round - 1) * WORD_BUDGET_GROWTH;
+}
+export function getStatBudget(round) {
+    return BASE_STAT_BUDGET + (round - 1) * STAT_BUDGET_GROWTH;
+}
+const RIVAL_NAMES = [
+    "Vex", "Kron", "Nyx", "Zeph", "Raze", "Glim", "Thane", "Dusk", "Blight", "Shard",
+    "Echo", "Flux", "Grimm", "Hex", "Jolt", "Lurk", "Maw", "Null", "Prism", "Rust",
+];
+const RIVAL_TITLES = [
+    "the Relentless", "the Cunning", "the Unyielding", "the Shadow", "the Devourer",
+    "the Architect", "the Storm", "the Patient", "the Hollow", "the Burning",
+    "the Mirror", "the Thorn", "the Void Walker", "the Iron Will", "the Silent",
+];
+const RIVAL_PERSONALITIES = [
+    "methodical and calculating — always builds counters",
+    "aggressive and reckless — all offense, no defense",
+    "defensive and patient — waits for you to overcommit",
+    "chaotic and unpredictable — wild ability combinations",
+    "balanced and adaptive — mirrors your strategy",
+];
+export function generateRivalIdentity() {
+    const name = RIVAL_NAMES[Math.floor(Math.random() * RIVAL_NAMES.length)];
+    const title = RIVAL_TITLES[Math.floor(Math.random() * RIVAL_TITLES.length)];
+    const personality = RIVAL_PERSONALITIES[Math.floor(Math.random() * RIVAL_PERSONALITIES.length)];
+    return { name, title, personality };
+}
+function createStarterBox(name) {
+    return {
+        name,
+        stats: { ATK: 3, DEF: 2, SPD: 3, HP: 20 },
+        currentHP: 20,
+        abilities: [],
+        mutations: [],
+        flavorText: "A featureless box. It can do nothing... yet.",
+    };
+}
+export function createInitialGameState(mode, withRival = true) {
+    const rivalIdentity = withRival ? generateRivalIdentity() : { name: "Rival Box", title: "the Unknown", personality: "balanced and adaptive" };
+    return {
+        mode,
+        round: 1,
+        lives: 5,
+        maxLives: 5,
+        reforges: 2,
+        maxReforges: 2,
+        playerTeam: [createStarterBox("Box")],
+        rivalTeam: [createStarterBox(rivalIdentity.name)],
+        currentCategory: getCategoryForRound(1),
+        wordBudget: getWordBudget(1),
+        statBudget: getStatBudget(1),
+        phase: "prompting",
+        rivalIdentity,
+    };
+}