@provable-games/dm-engine 0.1.0

package/dist/replay.js

@@ -0,0 +1,856 @@
+import { BEAST_NAMES, STARTER_BEAST_ATTACK_DAMAGE } from "./constants/beast.js";
+import { HEALTH_INCREASE_PER_VITALITY, ITEM_XP_MULTIPLIER_BEASTS, ITEM_XP_MULTIPLIER_OBSTACLES, POTION_HEALTH_AMOUNT, STARTER_WEAPONS, STARTING_GOLD, STARTING_HEALTH, XP_FOR_DISCOVERIES, } from "./constants/game.js";
+import { getBeastName, getBeastTier, getBeastType } from "./rules/beast.js";
+import { calculateGoldReward, calculateLevel, getNewItemsEquipped } from "./rules/game.js";
+import { abilityBasedAvoidThreatWithRoll, beastToBeastEvent, calculateAdventurerAttackDamage, calculateBeastCounterAttack, calculateObstacleDamage, canExplore, decreaseHealth, dropItem, equipItem, generateBeast, generateObstacle, generateStartingStats, getArmorAtSlot, getAttackLocation, getBaseXpReward, getDiscovery, getSlotDisplayName, grantXpToEquippedItems, increaseGold, increaseHealth, increaseXp, isCriticalHit, processLootDiscovery, } from "./rules/gameSimulation.js";
+import { ItemUtils } from "./rules/loot.js";
+import { felt_to_two_u64, get_simple_entropy, getBattleRandomness, getBeastEntropy, getBeastFromEntropy, getBeastFromSeed, getRandomness, } from "./rules/processFutures.js";
+const STARTER_BEAST_HEALTH = 3;
+const EMPTY_ITEM = { id: 0, xp: 0 };
+/**
+ * Resolve which randomness mode this action runs in.
+ *
+ * Three modes, in priority order:
+ *   1. injected entropy (block-hash commit/reveal) -- deterministic against a revealed block hash
+ *   2. settings `game_seed`                        -- deterministic against a fixed seed
+ *   3. neither                                     -- Math.random, corrected later by chain events
+ *
+ * Returning `null` means mode 3, and every caller keeps its pre-existing unseeded branch for that
+ * case, so nothing about VRF dungeons or trials changes.
+ */
+function resolveActionRolls(injectedEntropy, gameSeed, gameSeedUntilXp, xp) {
+    if (injectedEntropy !== null) {
+        const { u64_1, u64_2 } = felt_to_two_u64(injectedEntropy);
+        return { actionSeed: u64_1, marketSeed: u64_2 };
+    }
+    if (gameSeed !== 0 && (gameSeedUntilXp === 0 || gameSeedUntilXp > xp)) {
+        const { u64_1, u64_2 } = felt_to_two_u64(get_simple_entropy(xp, gameSeed));
+        return { actionSeed: u64_1, marketSeed: u64_2 };
+    }
+    return null;
+}
+/**
+ * `level_salt` after a level-up.
+ *
+ * Injected mode uses the action's own market seed, matching `replay.cairo`. Settings-seed mode
+ * deliberately keeps re-deriving from the adventurer's NEW xp -- that is what shipped, and changing
+ * it would silently reroll every existing `game_seed` dungeon's market.
+ */
+function levelSaltAfterLevelUp(injectedEntropy, rolls, gameSeed, gameSeedUntilXp, newXp) {
+    if (injectedEntropy !== null && rolls) {
+        return Number((rolls.marketSeed & 0x3fffn) | 1n);
+    }
+    if (gameSeed !== 0 && (gameSeedUntilXp === 0 || gameSeedUntilXp > newXp)) {
+        const felt = get_simple_entropy(newXp, gameSeed);
+        return Number((felt_to_two_u64(felt).u64_2 & 0x3fffn) | 1n);
+    }
+    return Math.floor(Math.random() * 0x3fff) | 1;
+}
+/** The four `get_battle_randomness` bytes for one round, as `beast_attack` consumes them. */
+function battleRolls(xp, battleCount, seed) {
+    const rnd = getBattleRandomness(xp, battleCount, seed);
+    return {
+        fleeRnd: Number(rnd.rnd1),
+        adventurerCritRnd: Number(rnd.rnd2),
+        beastCritRnd: Number(rnd.rnd3),
+        attackLocationRnd: Number(rnd.rnd4),
+    };
+}
+function getStarterBeastId(weaponId) {
+    if (ItemUtils.isMagicOrCloth(weaponId))
+        return 71; // Troll
+    if (ItemUtils.isBladeOrHide(weaponId))
+        return 21; // Fairy
+    if (ItemUtils.isBludgeonOrMetal(weaponId))
+        return 46; // Bear
+    return 71; // fallback
+}
+function cloneAdventurer(adv) {
+    return {
+        ...adv,
+        stats: { ...adv.stats },
+        equipment: {
+            weapon: { ...adv.equipment.weapon },
+            chest: { ...adv.equipment.chest },
+            head: { ...adv.equipment.head },
+            waist: { ...adv.equipment.waist },
+            foot: { ...adv.equipment.foot },
+            hand: { ...adv.equipment.hand },
+            neck: { ...adv.equipment.neck },
+            ring: { ...adv.equipment.ring },
+        },
+    };
+}
+/**
+ * Identity, deliberately.
+ *
+ * The client re-presents a generated beast under the dungeon's theme here. The engine must
+ * NOT: it emits the same raw ids the contract did, because the indexer stores raw ids and the
+ * client themes on read (`transformApiEvent`). Keeping the call sites lets this file stay a
+ * byte-for-byte port of `useGameCore`'s handlers.
+ */
+function applyTheme(beast, _dungeonId) {
+    return beast;
+}
+/**
+ * Apply one action to `state` and return the events it produced.
+ *
+ * This is `useGameCore`'s body verbatim, with the store reads replaced by `state` and the
+ * `actionEntropy` reads replaced by `entropy`. It is pure: no store, no RPC, no `Date`, and
+ * -- when `entropy` is non-null -- no `Math.random()`. That last property is what lets the
+ * client and the off-chain replayer agree, and it is asserted by the entropy test suite.
+ *
+ * `entropy` is `action_entropy(rolling_i, blockhash)` for a commit-reveal game, or `null` for
+ * a legacy dungeon, where the handlers fall back to a settings `game_seed` or `Math.random()`.
+ */
+export function applyAction(state, action, entropy) {
+    const clientGameAction = (action) => {
+        switch (action.type) {
+            case "start_game":
+                return startGame(action);
+            case "explore":
+                return explore(action);
+            case "attack":
+                return attack(action);
+            case "flee":
+                return flee(action);
+            case "buy_items":
+                return buyItemsAction(action);
+            case "select_stat_upgrades":
+                return selectStatUpgrades(action);
+            case "equip":
+                return equip(action);
+            case "drop":
+                return drop(action);
+            case "surrender":
+                return surrender();
+            case "surrender_and_claim":
+            case "surrender_and_claim_tickets":
+                return surrender();
+            default:
+                return [];
+        }
+    };
+    const startGame = (action) => {
+        const settings = action.settings;
+        const events = [];
+        if (!settings || settings.adventurer.xp === 0) {
+            // `action.weapon` is set by block-hash mode, where the same value is encoded into the
+            // committed START. START consumes no entropy on chain -- it is fully determined by the
+            // weapon -- so pinning that one number is all this branch needs to be exact.
+            const weapon = action.weapon ?? STARTER_WEAPONS[Math.floor(Math.random() * STARTER_WEAPONS.length)];
+            const beastId = getStarterBeastId(weapon);
+            events.push({
+                type: "beast",
+                // Themed too: the starter beast is the first thing a player sees, so it
+                // has to look like the dungeon it opened.
+                beast: applyTheme({
+                    id: beastId,
+                    baseName: BEAST_NAMES[beastId],
+                    name: getBeastName(beastId, 1, 0, 0),
+                    health: STARTER_BEAST_HEALTH,
+                    level: 1,
+                    type: getBeastType(beastId),
+                    tier: getBeastTier(beastId),
+                    specialPrefix: null,
+                    specialSuffix: null,
+                    isCollectable: false,
+                    traitSeed: BigInt(0),
+                }, null),
+            });
+            events.push({
+                type: "adventurer",
+                adventurer: {
+                    health: STARTING_HEALTH - STARTER_BEAST_ATTACK_DAMAGE,
+                    xp: 0,
+                    gold: STARTING_GOLD,
+                    beast_health: STARTER_BEAST_HEALTH,
+                    stat_upgrades_available: 0,
+                    stats: {
+                        strength: 0,
+                        dexterity: 0,
+                        vitality: 0,
+                        intelligence: 0,
+                        wisdom: 0,
+                        charisma: 0,
+                        luck: 0,
+                    },
+                    equipment: {
+                        weapon: { id: weapon, xp: 0 },
+                        chest: EMPTY_ITEM,
+                        head: EMPTY_ITEM,
+                        waist: EMPTY_ITEM,
+                        foot: EMPTY_ITEM,
+                        hand: EMPTY_ITEM,
+                        neck: EMPTY_ITEM,
+                        ring: EMPTY_ITEM,
+                    },
+                    item_specials_salt: 0,
+                    beast_salt: 0,
+                    level_salt: 0,
+                },
+            });
+        }
+        else {
+            // Initialize from editor/trial settings with existing adventurer state
+            const adventurer = { ...settings.adventurer, stats: { ...settings.adventurer.stats } };
+            const adventurerLevel = calculateLevel(adventurer.xp);
+            // Derive seeds like the contract: poseidon(xp, game_seed) → felt_to_two_u64 → (beast_seed, market_seed)
+            if (settings.game_seed !== 0) {
+                const felt = get_simple_entropy(adventurer.xp, settings.game_seed);
+                const { u64_1, u64_2 } = felt_to_two_u64(felt);
+                adventurer.beast_salt = Number((u64_1 & 0x1ffffn) | 1n);
+                adventurer.level_salt = Number((u64_2 & 0x3fffn) | 1n);
+            }
+            else {
+                adventurer.beast_salt = Math.floor(Math.random() * 0x1ffff) | 1;
+                adventurer.level_salt = Math.floor(Math.random() * 0x3fff) | 1;
+            }
+            events.push({ type: "level_up", level: adventurerLevel });
+            if (settings.in_battle) {
+                const dungeonId = null;
+                if (settings.game_seed !== 0) {
+                    const beast = applyTheme(getBeastFromSeed(adventurer.xp, settings.game_seed), dungeonId);
+                    adventurer.beast_health = beast.health;
+                    events.push({ type: "beast", beast });
+                }
+                else {
+                    const generatedBeast = generateBeast(adventurerLevel);
+                    const beastEvent = applyTheme(beastToBeastEvent(generatedBeast), dungeonId);
+                    adventurer.beast_health = generatedBeast.health;
+                    events.push({ type: "beast", beast: beastEvent });
+                }
+            }
+            events.push({ type: "adventurer", adventurer });
+            if (settings.bag && settings.bag.length > 0) {
+                events.push({ type: "bag", bag: settings.bag });
+            }
+        }
+        return events;
+    };
+    const explore = (action) => {
+        const storeState = state;
+        if (!storeState.adventurer)
+            return [];
+        const adventurer = cloneAdventurer(storeState.adventurer);
+        const bag = storeState.bag.map((item) => ({ ...item }));
+        const baseDamageReduction = storeState.gameSettings?.base_damage_reduction ?? 0;
+        const gameSeed = storeState.gameSettings?.game_seed ?? 0;
+        const gameSeedUntilXp = storeState.gameSettings?.game_seed_until_xp ?? 0;
+        // Validate
+        if (!canExplore(adventurer))
+            return [];
+        // Derive explore seed like the contract: felt_to_two_u64(entropy) → (explore_seed, market_seed)
+        const injectedEntropy = entropy;
+        const rolls = resolveActionRolls(injectedEntropy, gameSeed, gameSeedUntilXp, adventurer.xp);
+        const useSeeded = rolls !== null;
+        const exploreSeed = rolls?.actionSeed ?? 0n;
+        const events = [];
+        const previousLevel = calculateLevel(adventurer.xp);
+        const tillDamage = action.tillDamage ?? 0;
+        const tillGold = action.tillGold ?? false;
+        let damageTaken = 0;
+        let goldFound = false;
+        let bagMutated = false;
+        // Exploration loop
+        while (true) {
+            // Determine encounter type: seeded or random
+            let exploreResult;
+            let rnd = null;
+            if (useSeeded && (gameSeedUntilXp === 0 || gameSeedUntilXp > adventurer.xp)) {
+                rnd = getRandomness(adventurer.xp, exploreSeed);
+                exploreResult = Number(rnd.rnd8 % 3n);
+            }
+            else {
+                exploreResult = Math.floor(Math.random() * 3);
+            }
+            if (exploreResult === 0) {
+                // ── Beast encounter ──
+                const adventurerLevel = calculateLevel(adventurer.xp);
+                let beastEvent;
+                if (rnd && injectedEntropy !== null) {
+                    // replay.cairo: write beast_salt from the explore seed FIRST, then hash it with the
+                    // adventurer id and xp to get the beast entropy. The salt is stored state, so getting
+                    // this order wrong desyncs every later action that re-derives the beast from it (attack,
+                    // flee, in-battle equip all do).
+                    adventurer.beast_salt = Number((exploreSeed & 0x1ffffn) | 1n);
+                    const beastEntropy = getBeastEntropy(adventurer.beast_salt, storeState.gameId ?? "0", adventurer.xp);
+                    const beast = getBeastFromEntropy(adventurer.xp, beastEntropy);
+                    adventurer.beast_health = beast.health;
+                    beastEvent = applyTheme(beast, null);
+                }
+                else if (rnd) {
+                    // Seeded beast from explore randomness
+                    const beast = getBeastFromSeed(adventurer.xp, gameSeed);
+                    adventurer.beast_health = beast.health;
+                    beastEvent = applyTheme(beast, null);
+                }
+                else {
+                    const generatedBeast = generateBeast(adventurerLevel);
+                    beastEvent = applyTheme(beastToBeastEvent(generatedBeast), null);
+                    adventurer.beast_health = generatedBeast.health;
+                }
+                // Ambush check (wisdom avoids) — capture roll for visualization
+                let isAmbushed;
+                let ambushRnd;
+                if (rnd) {
+                    ambushRnd = Number(rnd.rnd7);
+                    const scaledChance = Math.floor((adventurerLevel * ambushRnd) / 255);
+                    isAmbushed = !(adventurer.stats.wisdom >= adventurerLevel || adventurer.stats.wisdom > scaledChance);
+                }
+                else {
+                    const rollResult = abilityBasedAvoidThreatWithRoll(adventurerLevel, adventurer.stats.wisdom);
+                    isAmbushed = !rollResult.avoided;
+                    ambushRnd = rollResult.rnd;
+                }
+                const ambushRollData = {
+                    roll: ambushRnd,
+                    threshold: adventurer.stats.wisdom,
+                    max: adventurerLevel,
+                    type: "ambush",
+                };
+                events.push({
+                    type: "beast",
+                    beast: beastEvent,
+                    rollData: ambushRollData,
+                });
+                if (isAmbushed) {
+                    // replay.cairo's beast_encounter passes the outer explore rnd5/rnd6 as the ambush's
+                    // damage location and crit rolls (the beast IDENTITY rnds come from the beast entropy;
+                    // these two do not).
+                    const ambushResult = calculateBeastCounterAttack(beastEvent, adventurer, baseDamageReduction, true, rnd && injectedEntropy !== null
+                        ? { attackLocationRnd: Number(rnd.rnd5), criticalHitRnd: Number(rnd.rnd6) }
+                        : undefined);
+                    if (ambushResult.damage > 0) {
+                        decreaseHealth(adventurer, ambushResult.damage);
+                        events.push({
+                            type: "ambush",
+                            attack: {
+                                damage: ambushResult.damage,
+                                location: ambushResult.location,
+                                critical_hit: ambushResult.critical_hit,
+                            },
+                            rollData: ambushRollData,
+                        });
+                    }
+                }
+                // Beast encounter ends the explore loop (adventurer is now in battle)
+            }
+            else if (exploreResult === 1) {
+                // ── Obstacle encounter ──
+                const adventurerLevel = calculateLevel(adventurer.xp);
+                // replay.cairo: obstacle_encounter(seed = rnd1, level_rnd = rnd4, damage_location = rnd5,
+                // crit = rnd6, dodge = rnd7, item_specials = rnd3).
+                const seededObstacle = rnd !== null && injectedEntropy !== null;
+                const obstacle = generateObstacle(adventurerLevel, seededObstacle
+                    ? { idRnd: Number(rnd.rnd1), levelRnd: Number(rnd.rnd4) }
+                    : undefined);
+                // Dodge check (intelligence avoids) — capture roll for visualization
+                let dodged;
+                let dodgeRnd;
+                if (rnd) {
+                    dodgeRnd = Number(rnd.rnd7);
+                    const scaledChance = Math.floor((adventurerLevel * dodgeRnd) / 255);
+                    dodged =
+                        adventurer.stats.intelligence >= adventurerLevel ||
+                            adventurer.stats.intelligence > scaledChance;
+                }
+                else {
+                    const rollResult = abilityBasedAvoidThreatWithRoll(adventurerLevel, adventurer.stats.intelligence);
+                    dodged = rollResult.avoided;
+                    dodgeRnd = rollResult.rnd;
+                }
+                const obstacleRolls = seededObstacle
+                    ? { attackLocationRnd: Number(rnd.rnd5), criticalHitRnd: Number(rnd.rnd6) }
+                    : undefined;
+                const slot = getAttackLocation(obstacleRolls?.attackLocationRnd);
+                const armor = getArmorAtSlot(adventurer, slot);
+                const obstacleResult = calculateObstacleDamage(obstacle, armor, adventurerLevel, baseDamageReduction, obstacleRolls);
+                const damage = dodged ? 0 : obstacleResult.damage;
+                if (!dodged && damage > 0) {
+                    decreaseHealth(adventurer, damage);
+                    damageTaken += damage;
+                }
+                const xpReward = getBaseXpReward(obstacle.tier, obstacle.level, adventurerLevel);
+                events.push({
+                    type: "obstacle",
+                    xp_reward: xpReward,
+                    obstacle: {
+                        id: obstacle.id,
+                        dodged,
+                        damage: dodged ? 0 : obstacleResult.damage,
+                        location: getSlotDisplayName(slot),
+                        critical_hit: obstacleResult.critical_hit,
+                    },
+                    rollData: {
+                        roll: dodgeRnd,
+                        threshold: adventurer.stats.intelligence,
+                        max: adventurerLevel,
+                        type: "dodge",
+                    },
+                });
+                // Grant XP if alive
+                if (adventurer.health > 0) {
+                    increaseXp(adventurer, xpReward);
+                    // Grant item XP to equipped items. replay.cairo's obstacle_encounter passes the explore
+                    // rnd3 as the item-specials roll.
+                    const itemXp = xpReward * ITEM_XP_MULTIPLIER_OBSTACLES;
+                    grantXpToEquippedItems(adventurer, itemXp, storeState.gameId ?? "0", seededObstacle ? Number(rnd.rnd3) : undefined);
+                }
+            }
+            else {
+                // ── Discovery ──
+                const adventurerLevel = calculateLevel(adventurer.xp);
+                // replay.cairo: get_discovery(level, rnd5, rnd6, rnd7).
+                const discovery = getDiscovery(adventurerLevel, rnd && injectedEntropy !== null
+                    ? {
+                        typeRnd: Number(rnd.rnd5),
+                        amountRnd1: Number(rnd.rnd6),
+                        amountRnd2: Number(rnd.rnd7),
+                    }
+                    : undefined);
+                let lootConversion = null;
+                if (discovery.type === "Gold") {
+                    increaseGold(adventurer, discovery.amount);
+                    goldFound = true;
+                }
+                else if (discovery.type === "Health") {
+                    increaseHealth(adventurer, discovery.amount);
+                }
+                else if (discovery.type === "Loot") {
+                    lootConversion = processLootDiscovery(adventurer, bag, discovery.itemId);
+                    if (lootConversion) {
+                        increaseGold(adventurer, lootConversion.gold);
+                        goldFound = true;
+                    }
+                    else {
+                        bagMutated = true;
+                    }
+                }
+                // Discoveries grant 1 XP
+                increaseXp(adventurer, XP_FOR_DISCOVERIES);
+                events.push({
+                    type: "discovery",
+                    discovery: {
+                        type: discovery.type,
+                        amount: discovery.type === "Loot" ? discovery.itemId : discovery.amount,
+                        ...(lootConversion ? { goldConversion: lootConversion } : {}),
+                    },
+                    xp_reward: XP_FOR_DISCOVERIES,
+                });
+            }
+            // Check loop exit conditions
+            if (!canExplore(adventurer))
+                break;
+            if (tillDamage === 0 && !tillGold)
+                break; // single explore
+            if (tillDamage > 0 && damageTaken >= tillDamage)
+                break;
+            if (tillGold && goldFound)
+                break;
+        }
+        // Level up check
+        const newLevel = calculateLevel(adventurer.xp);
+        if (newLevel > previousLevel) {
+            adventurer.level_salt = levelSaltAfterLevelUp(injectedEntropy, rolls, gameSeed, gameSeedUntilXp, adventurer.xp);
+            events.push({ type: "level_up", level: newLevel });
+        }
+        // Bag event if mutated
+        if (bagMutated) {
+            events.push({ type: "bag", bag });
+        }
+        // Always emit final adventurer state
+        events.push({ type: "adventurer", adventurer });
+        return events;
+    };
+    const attack = (action) => {
+        const storeState = state;
+        if (!storeState.adventurer || !storeState.beast)
+            return [];
+        const adventurer = cloneAdventurer(storeState.adventurer);
+        const beast = storeState.beast;
+        const baseDamageReduction = storeState.gameSettings?.base_damage_reduction ?? 0;
+        const gameSeed = storeState.gameSettings?.game_seed ?? 0;
+        const gameSeedUntilXp = storeState.gameSettings?.game_seed_until_xp ?? 0;
+        // Validate
+        if (adventurer.health === 0)
+            return [];
+        if (adventurer.beast_health <= 0)
+            return [];
+        const injectedEntropy = entropy;
+        const rolls = resolveActionRolls(injectedEntropy, gameSeed, gameSeedUntilXp, adventurer.xp);
+        // Battle rolls are only ever seeded from injected entropy. A settings `game_seed` game leaves
+        // combat random exactly as it does today -- its outcomes get corrected by the chain events the
+        // action returns, so there is nothing here to fix and plenty to break.
+        const battleSeed = injectedEntropy !== null ? (rolls?.actionSeed ?? null) : null;
+        const events = [];
+        const previousLevel = calculateLevel(adventurer.xp);
+        const tillHealth = action.tillHealth ?? 0;
+        const tillBeastHealth = action.tillBeastHealth ?? 0;
+        // Precompute adventurer damage
+        const { normal: normalDamage, crit: critDamage } = calculateAdventurerAttackDamage(adventurer, beast);
+        // Battle loop
+        let battleCount = 0;
+        while (true) {
+            battleCount += 1;
+            // replay.cairo: one get_battle_randomness draw per round, keyed on the CURRENT xp and the
+            // round number. xp only moves when the beast dies (which ends the loop), so in practice the
+            // round number is what advances it -- but it is re-derived every round regardless, because
+            // that is what the contract does.
+            const round = battleSeed !== null ? battleRolls(adventurer.xp, battleCount, battleSeed) : null;
+            const isCrit = isCriticalHit(adventurer.stats.luck, round?.adventurerCritRnd);
+            const adventurerDamage = isCrit ? critDamage : normalDamage;
+            events.push({
+                type: "attack",
+                attack: {
+                    damage: adventurerDamage,
+                    location: "None",
+                    critical_hit: isCrit,
+                },
+            });
+            if (adventurerDamage >= adventurer.beast_health) {
+                // Beast dies
+                adventurer.beast_health = 0;
+                const goldReward = calculateGoldReward(beast, adventurer.equipment.ring);
+                increaseGold(adventurer, goldReward);
+                const adventurerLevel = calculateLevel(adventurer.xp);
+                const xpReward = getBaseXpReward(beast.tier, beast.level, adventurerLevel);
+                const prevLevel = calculateLevel(adventurer.xp);
+                increaseXp(adventurer, xpReward);
+                // Item XP. process_beast_death seeds any first-time specials unlock from the adventurer's
+                // OWN item_specials_seed, not from a fresh roll.
+                const itemXp = xpReward * ITEM_XP_MULTIPLIER_BEASTS;
+                grantXpToEquippedItems(adventurer, itemXp, storeState.gameId ?? "0", injectedEntropy !== null
+                    ? ItemUtils.getItemSpecialsSeed(adventurer.item_specials_salt, storeState.gameId ?? "0")
+                    : undefined);
+                // Level 1→2 transition: generate starting stats — only for games that
+                // genuinely started at xp 0 (fresh starter-beast run). Settings that seed
+                // the adventurer at xp >= 1 already have their starting stats applied.
+                const startedFresh = (storeState.gameSettings?.adventurer?.xp ?? 0) === 0;
+                const newLevel = calculateLevel(adventurer.xp);
+                if (startedFresh && prevLevel === 1 && newLevel >= 2) {
+                    // process_beast_death seeds this from the BATTLE seed (not the market seed).
+                    const startingStats = generateStartingStats(battleSeed ?? undefined);
+                    adventurer.stats.strength += startingStats.strength;
+                    adventurer.stats.dexterity += startingStats.dexterity;
+                    adventurer.stats.vitality += startingStats.vitality;
+                    adventurer.stats.intelligence += startingStats.intelligence;
+                    adventurer.stats.wisdom += startingStats.wisdom;
+                    adventurer.stats.charisma += startingStats.charisma;
+                    adventurer.stats.luck = Math.max(2, Math.min(100, adventurer.stats.luck));
+                    // Health boost from new vitality
+                    increaseHealth(adventurer, HEALTH_INCREASE_PER_VITALITY * startingStats.vitality);
+                }
+                events.push({
+                    type: "defeated_beast",
+                    beast_id: beast.id,
+                    gold_reward: goldReward,
+                    xp_reward: xpReward,
+                });
+                break;
+            }
+            else {
+                // Beast survives, deduct damage
+                adventurer.beast_health -= adventurerDamage;
+                // Beast counter-attack
+                const counterAttack = calculateBeastCounterAttack(beast, adventurer, baseDamageReduction, false, round
+                    ? {
+                        attackLocationRnd: round.attackLocationRnd,
+                        criticalHitRnd: round.beastCritRnd,
+                    }
+                    : undefined);
+                decreaseHealth(adventurer, counterAttack.damage);
+                events.push({
+                    type: "beast_attack",
+                    attack: {
+                        damage: counterAttack.damage,
+                        location: counterAttack.location,
+                        critical_hit: counterAttack.critical_hit,
+                    },
+                });
+                // Check break conditions
+                if (adventurer.health === 0)
+                    break;
+                if (adventurer.health <= tillHealth || adventurer.beast_health <= tillBeastHealth)
+                    break;
+            }
+        }
+        // Level up check
+        const newLevel = calculateLevel(adventurer.xp);
+        if (newLevel > previousLevel) {
+            adventurer.level_salt = levelSaltAfterLevelUp(injectedEntropy, rolls, gameSeed, gameSeedUntilXp, adventurer.xp);
+            events.push({ type: "level_up", level: newLevel });
+        }
+        // Always emit final adventurer state
+        events.push({ type: "adventurer", adventurer });
+        return events;
+    };
+    const flee = (action) => {
+        const storeState = state;
+        if (!storeState.adventurer || !storeState.beast)
+            return [];
+        const adventurer = cloneAdventurer(storeState.adventurer);
+        const beast = storeState.beast;
+        const baseDamageReduction = storeState.gameSettings?.base_damage_reduction ?? 0;
+        const gameSeed = storeState.gameSettings?.game_seed ?? 0;
+        const gameSeedUntilXp = storeState.gameSettings?.game_seed_until_xp ?? 0;
+        // Validate
+        if (adventurer.health === 0)
+            return [];
+        if (adventurer.beast_health <= 0)
+            return [];
+        const adventurerLevel = calculateLevel(adventurer.xp);
+        if (adventurerLevel <= 1)
+            return []; // Can't flee starter beast
+        if (adventurer.stats.dexterity === 0)
+            return [];
+        const injectedEntropy = entropy;
+        const rolls = resolveActionRolls(injectedEntropy, gameSeed, gameSeedUntilXp, adventurer.xp);
+        const fleeSeed = injectedEntropy !== null ? (rolls?.actionSeed ?? null) : null;
+        const updateLevelSalt = () => {
+            adventurer.level_salt = levelSaltAfterLevelUp(injectedEntropy, rolls, gameSeed, gameSeedUntilXp, adventurer.xp);
+        };
+        const events = [];
+        const previousLevel = adventurerLevel;
+        const tillHealth = action.tillHealth ?? 0;
+        // Guaranteed flee if dexterity >= level
+        if (adventurer.stats.dexterity >= adventurerLevel) {
+            adventurer.beast_health = 0;
+            increaseXp(adventurer, 1);
+            events.push({ type: "flee", success: true });
+            events.push({ type: "fled_beast", beast_id: beast.id, xp_reward: 1 });
+            const newLevel = calculateLevel(adventurer.xp);
+            if (newLevel > previousLevel) {
+                updateLevelSalt();
+                events.push({ type: "level_up", level: newLevel });
+            }
+            events.push({ type: "adventurer", adventurer });
+            return events;
+        }
+        // Flee loop
+        let battleCount = 0;
+        while (true) {
+            battleCount += 1;
+            // replay.cairo's flee loop reads the same get_battle_randomness draw as attack, but takes
+            // rnd1 as the flee roll instead of rnd2 as the adventurer crit roll.
+            const round = fleeSeed !== null ? battleRolls(adventurer.xp, battleCount, fleeSeed) : null;
+            const fleeResult = abilityBasedAvoidThreatWithRoll(adventurerLevel, adventurer.stats.dexterity, round?.fleeRnd);
+            const fleeRollData = {
+                roll: fleeResult.rnd,
+                threshold: adventurer.stats.dexterity,
+                max: adventurerLevel,
+                type: "flee",
+            };
+            if (fleeResult.avoided) {
+                adventurer.beast_health = 0;
+                increaseXp(adventurer, 1);
+                events.push({ type: "flee", success: true, rollData: fleeRollData });
+                events.push({ type: "fled_beast", beast_id: beast.id, xp_reward: 1 });
+                break;
+            }
+            else {
+                // Failed flee — beast counter-attacks
+                const counterAttack = calculateBeastCounterAttack(beast, adventurer, baseDamageReduction, false, round
+                    ? {
+                        attackLocationRnd: round.attackLocationRnd,
+                        criticalHitRnd: round.beastCritRnd,
+                    }
+                    : undefined);
+                decreaseHealth(adventurer, counterAttack.damage);
+                events.push({ type: "flee", success: false, rollData: fleeRollData });
+                events.push({
+                    type: "beast_attack",
+                    attack: {
+                        damage: counterAttack.damage,
+                        location: counterAttack.location,
+                        critical_hit: counterAttack.critical_hit,
+                    },
+                });
+                if (adventurer.health === 0)
+                    break;
+                if (adventurer.health <= tillHealth)
+                    break;
+            }
+        }
+        // Level up check
+        const newLevel = calculateLevel(adventurer.xp);
+        if (newLevel > previousLevel) {
+            updateLevelSalt();
+            events.push({ type: "level_up", level: newLevel });
+        }
+        // Always emit final adventurer state
+        events.push({ type: "adventurer", adventurer });
+        return events;
+    };
+    const buyItemsAction = (action) => {
+        const storeState = state;
+        if (!storeState.adventurer)
+            return [];
+        const adventurer = cloneAdventurer(storeState.adventurer);
+        const bag = storeState.bag.map((item) => ({ ...item }));
+        const itemPurchases = action.itemPurchases ?? [];
+        const potions = action.potions ?? 0;
+        // Validate
+        if (adventurer.health === 0)
+            return [];
+        if (adventurer.beast_health > 0)
+            return [];
+        if (adventurer.stat_upgrades_available > 0)
+            return [];
+        const events = [];
+        // Gold is pre-calculated by the caller
+        if (action.remainingGold !== undefined) {
+            adventurer.gold = action.remainingGold;
+        }
+        // Add non-equipped items to bag
+        for (const purchase of itemPurchases) {
+            if (!purchase.equip) {
+                bag.push({ id: purchase.item_id, xp: 0 });
+            }
+        }
+        // Equip purchased items (handles displaced items → bag + stat boosts)
+        for (const purchase of itemPurchases) {
+            if (purchase.equip) {
+                equipItem(adventurer, bag, purchase.item_id);
+            }
+        }
+        // Buy potions
+        if (potions > 0) {
+            increaseHealth(adventurer, POTION_HEALTH_AMOUNT * potions);
+        }
+        events.push({ type: "buy_items", potions, items_purchased: itemPurchases });
+        events.push({ type: "bag", bag });
+        events.push({ type: "adventurer", adventurer });
+        return events;
+    };
+    const selectStatUpgrades = (action) => {
+        const storeState = state;
+        if (!storeState.adventurer)
+            return [];
+        const adventurer = cloneAdventurer(storeState.adventurer);
+        const stats = action.statUpgrades;
+        // Validate
+        if (adventurer.health === 0)
+            return [];
+        if (adventurer.stat_upgrades_available === 0)
+            return [];
+        const events = [];
+        // Apply stats
+        adventurer.stats.strength += stats.strength;
+        adventurer.stats.dexterity += stats.dexterity;
+        adventurer.stats.vitality += stats.vitality;
+        adventurer.stats.intelligence += stats.intelligence;
+        adventurer.stats.wisdom += stats.wisdom;
+        adventurer.stats.charisma += stats.charisma;
+        // Vitality health boost (contract: apply_vitality_health_boost)
+        if (stats.vitality > 0) {
+            increaseHealth(adventurer, HEALTH_INCREASE_PER_VITALITY * stats.vitality);
+        }
+        adventurer.stat_upgrades_available = 0;
+        events.push({ type: "stat_upgrade", stats });
+        events.push({ type: "adventurer", adventurer });
+        return events;
+    };
+    const surrender = () => {
+        const storeState = state;
+        if (!storeState.adventurer)
+            return [];
+        const adventurer = cloneAdventurer(storeState.adventurer);
+        // Validate
+        if (adventurer.health === 0)
+            return [];
+        if (adventurer.beast_health > 0)
+            return [];
+        if (adventurer.xp === 0)
+            return [];
+        adventurer.health = 0;
+        adventurer.beast_salt = 0;
+        adventurer.level_salt = 0;
+        return [{ type: "adventurer", adventurer }];
+    };
+    const equip = (action) => {
+        const storeState = state;
+        if (!storeState.adventurer || !storeState.adventurerState)
+            return [];
+        // Derive items from store state if not explicitly passed (matches GameDirector on-chain path)
+        const items = action.items ??
+            getNewItemsEquipped(storeState.adventurer.equipment, storeState.adventurerState.equipment).map((item) => item.id);
+        // The client's store applies the equip optimistically before this runs, so its
+        // `adventurer.equipment` and `bag` are already correct. The off-chain replayer holds the
+        // pre-action state instead and must do the move itself -- see `equipmentApplied`.
+        const adventurer = cloneAdventurer(storeState.adventurer);
+        const bag = storeState.bag.map((item) => ({ ...item }));
+        const beast = storeState.beast;
+        const baseDamageReduction = storeState.gameSettings?.base_damage_reduction ?? 0;
+        // Validate
+        if (adventurer.health === 0)
+            return [];
+        if (items.length === 0 || items.length > 8)
+            return [];
+        const events = [];
+        // Equip BEFORE the counter-attack: `Inventory::equip` calls `equip_items` first and only
+        // then lets the beast swing, so the beast hits the NEW armour. The client gets this for
+        // free because its store already moved the items; the replayer has to move them here, and
+        // moving them after the counter-attack would quietly under-armour every in-battle equip.
+        if (storeState.equipmentApplied === false) {
+            for (const itemId of items) {
+                equipItem(adventurer, bag, itemId);
+            }
+        }
+        // If in battle, beast counter-attacks (mimics contract: randomness → beast_attack → equip)
+        if (adventurer.beast_health > 0 && beast) {
+            // replay_equip draws get_battle_randomness(xp, 0, equip_seed) -- battle count ZERO, unlike
+            // attack and flee which start at 1 -- and takes rnd3/rnd4 as the beast crit and location.
+            const injectedEntropy = entropy;
+            const equipSeed = injectedEntropy !== null ? felt_to_two_u64(injectedEntropy).u64_1 : null;
+            const round = equipSeed !== null ? battleRolls(adventurer.xp, 0, equipSeed) : null;
+            const counterAttack = calculateBeastCounterAttack(beast, adventurer, baseDamageReduction, false, round
+                ? {
+                    attackLocationRnd: round.attackLocationRnd,
+                    criticalHitRnd: round.beastCritRnd,
+                }
+                : undefined);
+            decreaseHealth(adventurer, counterAttack.damage);
+            events.push({
+                type: "beast_attack",
+                attack: {
+                    damage: counterAttack.damage,
+                    location: counterAttack.location,
+                    critical_hit: counterAttack.critical_hit,
+                },
+            });
+        }
+        events.push({ type: "equip", items });
+        events.push({ type: "bag", bag });
+        events.push({ type: "adventurer", adventurer });
+        return events;
+    };
+    const drop = (action) => {
+        const storeState = state;
+        if (!storeState.adventurer)
+            return [];
+        const adventurer = cloneAdventurer(storeState.adventurer);
+        const bag = storeState.bag.map((item) => ({ ...item }));
+        const items = action.items ?? [];
+        // Validate
+        if (adventurer.health === 0)
+            return [];
+        if (adventurer.beast_health > 0)
+            return []; // Can't drop in battle
+        if (calculateLevel(adventurer.xp) <= 1)
+            return []; // Can't drop during starter beast
+        if (items.length === 0)
+            return [];
+        const events = [];
+        // Drop each item
+        for (const itemId of items) {
+            dropItem(adventurer, bag, itemId);
+        }
+        events.push({ type: "drop", items });
+        events.push({ type: "bag", bag });
+        events.push({ type: "adventurer", adventurer });
+        return events;
+    };
+    return clientGameAction(action);
+}
+//# sourceMappingURL=replay.js.map