@provable-games/dm-engine 0.1.0 → 0.3.0

package/dist/replay.js

@@ -1,49 +1,122 @@
-import { BEAST_NAMES, STARTER_BEAST_ATTACK_DAMAGE } from "./constants/beast.js";
+import { actionSeed as deriveActionSeed } from "./protocol.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;
+import { getMaxHealth } from "./rules/health.js";
+import { getLevelSeed } from "./rules/market.js";
+import { felt_to_two_u64, generateStartingStatsFromSeed, get_simple_entropy, getBattleRandomness, getBeastEntropy, getBeastFromEntropy, getBeastFromSeed, getRandomness, } from "./rules/processFutures.js";
 const EMPTY_ITEM = { id: 0, xp: 0 };
 /**
- * Resolve which randomness mode this action runs in.
+ * The three randomness modes, mirroring `utils/randomness.cairo::RandomnessMode`.
  *
- * 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
+ * A mode chooses where the NON-combat stream comes from. Combat is never on this dial: `attack`,
+ * `flee` and `equip` always roll from the block hash, in every mode.
+ */
+export const RandomnessMode = {
+    /** Every action rolls from the hash of the block that resolves it. */
+    FULL: 0,
+    /** Non-combat rolls expand `game_seed`; the encounter table is fixed before the run starts. */
+    SEEDED: 1,
+    /** Non-combat rolls expand the current `level_salt`, itself re-rolled live on every level-up. */
+    PER_LEVEL: 2,
+};
+/** `ImplAdventurer::nonzero_salt` -- mask, keeping zero (the never-rolled sentinel) out. */
+export function nonzeroSalt(value, mask) {
+    const masked = value & mask;
+    return Number(masked === 0n ? 1n : masked);
+}
+/**
+ * The `SEEDED` stream: an expansion of `game_seed`, blind to the chain.
+ *
+ * `adventurerId` is deliberately absent -- every adventurer on the settings entry walks the
+ * identical dungeon, which is what makes the mode useful for fixtures and tournaments.
+ */
+function seededRolls(adventurer, gameSeed) {
+    if (gameSeed === 0)
+        return null;
+    const { u64_1, u64_2 } = felt_to_two_u64(get_simple_entropy(adventurer.xp, gameSeed));
+    return { actionSeed: u64_1, marketSeed: u64_2 };
+}
+/**
+ * The `PER_LEVEL` stream: an expansion of the current level's salt.
+ *
+ * `getLevelSeed` folds `adventurerId` in, so two adventurers holding the same 14-bit salt still
+ * run different levels.
+ */
+function perLevelRolls(adventurerId, adventurer) {
+    const levelSeed = getLevelSeed(adventurer.level_salt, BigInt(adventurerId ?? "0"));
+    const { u64_1, u64_2 } = felt_to_two_u64(get_simple_entropy(adventurer.xp, levelSeed));
+    return { actionSeed: u64_1, marketSeed: u64_2 };
+}
+/**
+ * The always-live stream: the block hash mixed with the adventurer's own state.
  *
- * 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.
+ * The only one of the three that mixes `health`. Neither seeded stream does, deliberately --
+ * health is a product of live combat, so folding it in would make a seeded or per-level encounter
+ * table follow the fight.
  */
-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 };
+function liveRolls(blockHash, gameId, adventurer) {
+    if (blockHash === null)
+        return null;
+    const seed = deriveActionSeed(blockHash, BigInt(gameId ?? "0"), adventurer.xp, adventurer.health, adventurer.beast_health > 0);
+    const { u64_1, u64_2 } = felt_to_two_u64(seed);
+    return { actionSeed: u64_1, marketSeed: u64_2 };
+}
+/**
+ * `randomness::get_action_seeds` -- one block per mode, matching the Cairo split.
+ *
+ *   FULL       combat: live  / live          explore: live       / live
+ *   SEEDED     combat: live  / game_seed     explore: game_seed  / game_seed
+ *   PER_LEVEL  combat: live  / live          explore: level_salt / live
+ *
+ * (`actionSeed` / `marketSeed` -- the second is what `level_salt` is re-rolled from on a level-up.)
+ *
+ * `inCombat` is the combat carve-out: `attack`, `flee` and `equip` pass true and take `actionSeed`
+ * from the block hash whatever the mode says. It is also what keeps repeated fights apart -- a
+ * bundle shares one block hash, so the state term is the only thing separating its actions, and
+ * only `liveRolls` mixes `health`. Combat is the one thing that can act twice at the same xp.
+ *
+ * Returning `null` means neither stream was available (no block hash, no usable seed), and every
+ * caller keeps its pre-existing unseeded branch for that case.
+ */
+function resolveActionRolls(blockHash, gameId, adventurer, gameSeed, mode, inCombat) {
+    if (mode === RandomnessMode.SEEDED) {
+        // The reseed stays on the seeded stream even for combat, or a mid-fight level-up would make
+        // the market after it unreproducible from `game_seed`.
+        const seeded = seededRolls(adventurer, gameSeed);
+        if (!seeded)
+            return null;
+        if (!inCombat)
+            return seeded;
+        const live = liveRolls(blockHash, gameId, adventurer);
+        if (!live)
+            return null;
+        return { actionSeed: live.actionSeed, marketSeed: seeded.marketSeed };
     }
-    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 };
+    if (mode === RandomnessMode.PER_LEVEL) {
+        // The reseed is live on BOTH paths, and that live draw IS the mode: the level-up is the one
+        // unpredictable moment in a per-level run.
+        const live = liveRolls(blockHash, gameId, adventurer);
+        if (!live)
+            return null;
+        if (inCombat)
+            return live;
+        const level = perLevelRolls(gameId, adventurer);
+        return { actionSeed: level.actionSeed, marketSeed: live.marketSeed };
     }
-    return null;
+    // FULL, and the fallback for any value the contract's validation would have rejected. There is
+    // no second stream, so `inCombat` cannot change the answer.
+    return liveRolls(blockHash, gameId, adventurer);
 }
 /**
  * `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.
+ * `rolls.marketSeed` already carries the mode's reseed decision (see `resolveActionRolls`), so
+ * this only has to truncate it. The `Math.random` tail is the pre-existing unseeded fallback.
  */
-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);
-    }
+function levelSaltAfterLevelUp(rolls) {
+    if (rolls)
+        return nonzeroSalt(rolls.marketSeed, 0x3fffn);
     return Math.floor(Math.random() * 0x3fff) | 1;
 }
 /** The four `get_battle_randomness` bytes for one round, as `beast_attack` consumes them. */
@@ -56,15 +129,6 @@ function battleRolls(xp, battleCount, seed) {
         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,
@@ -96,12 +160,14 @@ function applyTheme(beast, _dungeonId) {
  * 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
+ * VRF 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()`.
+ * `entropy` is the RAW block hash that resolves this action for a commit-reveal game, or `null`
+ * for a legacy dungeon, where the handlers fall back to a settings `game_seed` or `Math.random()`.
+ * It is not the seed: `resolveActionRolls` mixes it with the adventurer's own state, which is what
+ * separates two actions that were committed in the same block and therefore share a hash.
  */
 export function applyAction(state, action, entropy) {
     const clientGameAction = (action) => {
@@ -131,101 +197,108 @@ export function applyAction(state, action, entropy) {
                 return [];
         }
     };
+    /**
+     * `Settlement::start` -- an adventurer initializer, and nothing else.
+     *
+     * The settings entry IS the starting state. There is no starter beast and no
+     * default-versus-custom branch: whatever `settings.adventurer` holds is what the run begins
+     * with, `settings.in_battle` decides whether a beast is already waiting, and
+     * `settings.random_starting_stats` deals points on top of the baseline.
+     *
+     * The one thing the player still chooses is the weapon, and only when the settings entry
+     * leaves the slot open.
+     */
     const startGame = (action) => {
-        const settings = action.settings;
+        // The contract reads the settings entry from storage, not from the action. `action.settings`
+        // is a client-side convenience for previews; the replay path carries them on the state.
+        const settings = action.settings ?? state.gameSettings;
         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,
+        const base = settings?.adventurer;
+        const adventurer = base
+            ? cloneAdventurer(base)
+            : {
+                health: STARTING_HEALTH,
+                xp: 0,
+                gold: STARTING_GOLD,
+                beast_health: 0,
+                stat_upgrades_available: 0,
+                stats: {
+                    strength: 0,
+                    dexterity: 0,
+                    vitality: 0,
+                    intelligence: 0,
+                    wisdom: 0,
+                    charisma: 0,
+                    luck: 0,
                 },
-            });
+                equipment: {
+                    weapon: EMPTY_ITEM,
+                    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,
+            };
+        // An empty weapon slot is the settings entry deferring to the player.
+        if (!adventurer.equipment.weapon.id) {
+            const weapon = action.weapon ?? STARTER_WEAPONS[Math.floor(Math.random() * STARTER_WEAPONS.length)];
+            adventurer.equipment.weapon = { id: weapon, xp: 0 };
+        }
+        // The contract splits the raw START block hash: the low half deals the random stats and the
+        // beast salt, the high half becomes `level_salt`. Without an injected hash this is a client
+        // preview, so it falls back to Math.random and gets corrected by the chain events later.
+        const seeded = entropy !== null;
+        const { u64_1: beastSeed, u64_2: marketSeed } = seeded
+            ? felt_to_two_u64(entropy)
+            : { u64_1: 0n, u64_2: 0n };
+        const randomStats = settings?.random_starting_stats ?? 0;
+        if (randomStats > 0) {
+            const healthBefore = getMaxHealth(adventurer.stats.vitality);
+            const dealt = seeded
+                ? generateStartingStatsFromSeed(beastSeed, randomStats)
+                : generateStartingStats(undefined, randomStats);
+            adventurer.stats.strength += dealt.strength;
+            adventurer.stats.dexterity += dealt.dexterity;
+            adventurer.stats.vitality += dealt.vitality;
+            adventurer.stats.intelligence += dealt.intelligence;
+            adventurer.stats.wisdom += dealt.wisdom;
+            adventurer.stats.charisma += dealt.charisma;
+            // Vitality among the points raises max health, and the adventurer is handed it rather than
+            // starting the run already wounded.
+            const gained = getMaxHealth(adventurer.stats.vitality) - healthBefore;
+            adventurer.health = Math.min(adventurer.health + gained, getMaxHealth(adventurer.stats.vitality));
         }
-        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);
+        // A zero `level_salt` makes `getLevelSeed` return 0, which under PER_LEVEL would give every
+        // adventurer an identical level 1.
+        adventurer.level_salt = seeded
+            ? nonzeroSalt(marketSeed, 0x3fffn)
+            : Math.floor(Math.random() * 0x3fff) | 1;
+        events.push({ type: "level_up", level: calculateLevel(adventurer.xp) });
+        if (settings?.in_battle) {
+            if (seeded) {
+                adventurer.beast_salt = nonzeroSalt(beastSeed, 0x1ffffn);
+                const beastEntropy = getBeastEntropy(adventurer.beast_salt, BigInt(state.gameId ?? "0"), adventurer.xp);
+                const beast = applyTheme(getBeastFromEntropy(adventurer.xp, beastEntropy), null);
+                adventurer.beast_health = beast.health;
+                events.push({ type: "beast", beast });
             }
             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 });
+                const generated = generateBeast(calculateLevel(adventurer.xp));
+                adventurer.beast_health = generated.health;
+                events.push({ type: "beast", beast: applyTheme(beastToBeastEvent(generated), null) });
             }
         }
+        events.push({ type: "adventurer", adventurer });
+        if (settings?.bag && settings.bag.length > 0) {
+            events.push({ type: "bag", bag: settings.bag });
+        }
         return events;
     };
     const explore = (action) => {
@@ -236,13 +309,16 @@ export function applyAction(state, action, entropy) {
         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;
+        const randomnessMode = storeState.gameSettings?.randomness_mode ?? RandomnessMode.FULL;
         // Validate
         if (!canExplore(adventurer))
             return [];
-        // Derive explore seed like the contract: felt_to_two_u64(entropy) → (explore_seed, market_seed)
+        // Derive the explore seed like the contract: mix the block hash with the adventurer's own
+        // state, then felt_to_two_u64 → (explore_seed, market_seed).
         const injectedEntropy = entropy;
-        const rolls = resolveActionRolls(injectedEntropy, gameSeed, gameSeedUntilXp, adventurer.xp);
+        // Explore follows the mode: the encounter at each xp is what a seeded or per-level run makes
+        // predictable.
+        const rolls = resolveActionRolls(injectedEntropy, storeState.gameId, adventurer, gameSeed, randomnessMode, false);
         const useSeeded = rolls !== null;
         const exploreSeed = rolls?.actionSeed ?? 0n;
         const events = [];
@@ -257,7 +333,7 @@ export function applyAction(state, action, entropy) {
             // Determine encounter type: seeded or random
             let exploreResult;
             let rnd = null;
-            if (useSeeded && (gameSeedUntilXp === 0 || gameSeedUntilXp > adventurer.xp)) {
+            if (useSeeded) {
                 rnd = getRandomness(adventurer.xp, exploreSeed);
                 exploreResult = Number(rnd.rnd8 % 3n);
             }
@@ -273,7 +349,7 @@ export function applyAction(state, action, entropy) {
                     // 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);
+                    adventurer.beast_salt = nonzeroSalt(exploreSeed, 0x1ffffn);
                     const beastEntropy = getBeastEntropy(adventurer.beast_salt, storeState.gameId ?? "0", adventurer.xp);
                     const beast = getBeastFromEntropy(adventurer.xp, beastEntropy);
                     adventurer.beast_health = beast.health;
@@ -452,7 +528,7 @@ export function applyAction(state, action, entropy) {
         // Level up check
         const newLevel = calculateLevel(adventurer.xp);
         if (newLevel > previousLevel) {
-            adventurer.level_salt = levelSaltAfterLevelUp(injectedEntropy, rolls, gameSeed, gameSeedUntilXp, adventurer.xp);
+            adventurer.level_salt = levelSaltAfterLevelUp(rolls);
             events.push({ type: "level_up", level: newLevel });
         }
         // Bag event if mutated
@@ -471,14 +547,15 @@ export function applyAction(state, action, entropy) {
         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;
+        const randomnessMode = storeState.gameSettings?.randomness_mode ?? RandomnessMode.FULL;
         // Validate
         if (adventurer.health === 0)
             return [];
         if (adventurer.beast_health <= 0)
             return [];
         const injectedEntropy = entropy;
-        const rolls = resolveActionRolls(injectedEntropy, gameSeed, gameSeedUntilXp, adventurer.xp);
+        // Combat always rolls live, whatever the mode says.
+        const rolls = resolveActionRolls(injectedEntropy, storeState.gameId, adventurer, gameSeed, randomnessMode, true);
         // 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.
@@ -517,30 +594,12 @@ export function applyAction(state, action, entropy) {
                 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.
+                // Item XP. A first-time specials unlock draws from the action's OWN seed. This used to
+                // pass `getItemSpecialsSeed(item_specials_salt, ..)`, which is 0 for exactly as long as
+                // the salt is unset -- so the unlock always wrote the constant 1 and collapsed every item
+                // special in the run. Mirrors the same fix in `combat.cairo`.
                 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);
-                }
+                grantXpToEquippedItems(adventurer, itemXp, storeState.gameId ?? "0", rolls ? Number(rolls.actionSeed & 0xffffn) : undefined);
                 events.push({
                     type: "defeated_beast",
                     beast_id: beast.id,
@@ -578,7 +637,7 @@ export function applyAction(state, action, entropy) {
         // Level up check
         const newLevel = calculateLevel(adventurer.xp);
         if (newLevel > previousLevel) {
-            adventurer.level_salt = levelSaltAfterLevelUp(injectedEntropy, rolls, gameSeed, gameSeedUntilXp, adventurer.xp);
+            adventurer.level_salt = levelSaltAfterLevelUp(rolls);
             events.push({ type: "level_up", level: newLevel });
         }
         // Always emit final adventurer state
@@ -593,22 +652,21 @@ export function applyAction(state, action, entropy) {
         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;
+        const randomnessMode = storeState.gameSettings?.randomness_mode ?? RandomnessMode.FULL;
         // 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);
+        // Combat always rolls live, whatever the mode says.
+        const rolls = resolveActionRolls(injectedEntropy, storeState.gameId, adventurer, gameSeed, randomnessMode, true);
         const fleeSeed = injectedEntropy !== null ? (rolls?.actionSeed ?? null) : null;
         const updateLevelSalt = () => {
-            adventurer.level_salt = levelSaltAfterLevelUp(injectedEntropy, rolls, gameSeed, gameSeedUntilXp, adventurer.xp);
+            adventurer.level_salt = levelSaltAfterLevelUp(rolls);
         };
         const events = [];
         const previousLevel = adventurerLevel;
@@ -802,7 +860,11 @@ export function applyAction(state, action, entropy) {
             // 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;
+            // The contract calls get_random_seed here too, so the block hash gets the same state mix.
+            // `adventurer` is post-equip and still in battle, which is the state the contract holds.
+            const equipSeed = injectedEntropy !== null
+                ? felt_to_two_u64(deriveActionSeed(injectedEntropy, BigInt(storeState.gameId ?? "0"), adventurer.xp, adventurer.health, adventurer.beast_health > 0)).u64_1
+                : null;
             const round = equipSeed !== null ? battleRolls(adventurer.xp, 0, equipSeed) : null;
             const counterAttack = calculateBeastCounterAttack(beast, adventurer, baseDamageReduction, false, round
                 ? {
@@ -837,8 +899,6 @@ export function applyAction(state, action, entropy) {
             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 = [];