@pkmn/engine 0.1.0-dev.9a0c07c3 → 0.1.0-dev.a5a9f4b2

package/src/lib/gen1/mechanics.zig

@@ -56,6 +56,8 @@ const BOOSTS = &[_][2]u8{
 
 const MAX_STAT_VALUE = 999;
 
+const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
+
 pub fn update(battle: anytype, c1: Choice, c2: Choice, log: anytype) !Result {
     assert(c1.type != .Pass or c2.type != .Pass or battle.turn == 0);
     if (battle.turn == 0) return start(battle, log);
@@ -185,6 +187,7 @@ fn selectMove(
     }
 
     // move select
+    volatiles.state = 0;
     if (choice.data == 0) {
         const struggle = ok: {
             for (side.active.moves, 0..) |move, i| {
@@ -301,11 +304,7 @@ fn turnOrder(battle: anytype, c1: Choice, c2: Choice) Player {
         // Pokémon Showdown's beforeTurnCallback shenanigans
         if (showdown and m1 == .Counter and m2 == .Counter) battle.rng.advance(1);
 
-        const p1 = if (showdown)
-            battle.rng.range(u8, 0, 2) == 0
-        else
-            battle.rng.next() < Gen12.percent(50) + 1;
-
+        const p1 = Rolls.speedTie(battle);
         if (!showdown) return if (p1) .P1 else .P2;
 
         // Pokémon Showdown's "lockedmove" volatile's onBeforeTurn uses BattleQueue#changeAction,
@@ -315,7 +314,7 @@ fn turnOrder(battle: anytype, c1: Choice, c2: Choice) Player {
         const t1 = battle.side(.P1).active.volatiles.Thrashing;
         const t2 = battle.side(.P2).active.volatiles.Thrashing;
         // If *both* sides are thrashing it really should be another speed tie, but we've patched
-        // that out and enforce host ordering of events, so P1 just goes first reqgardless of who
+        // that out and enforce host ordering of events, so P1 just goes first regardless of who
         // won the original coin flip
         if (t1 and t2) return .P1;
         return if (p1) if (t1 and !t2) .P2 else .P1 else if (t2 and !t1) .P1 else .P2;
@@ -450,7 +449,7 @@ fn executeMove(
     return doMove(battle, player, mslot, auto, residual, log);
 }
 
-const BeforeMove = union(enum) { done, skip_can, skip_pp, ok, err };
+const BeforeMove = enum { done, skip_can, skip_pp, ok, err };
 
 fn beforeMove(
     battle: anytype,
@@ -513,9 +512,10 @@ fn beforeMove(
     // Pokémon Showdown's disable condition has a single onBeforeMove handler
     if (showdown and try disabled(side, ident, log)) return .done;
 
-    // Pokémon Showdown checks for Flinch *after* instead of before
+    // Pokémon Showdown checks for Flinch *after* instead of before... and doesn't clear Flinch
+    // until its imaginary "residual" phase, meaning Pokémon can sometimes flinch multiple times
+    // from the same original hit
     if (showdown and volatiles.Flinch) {
-        volatiles.Flinch = false;
         try log.cant(ident, .Flinch);
         return .done;
     }
@@ -537,12 +537,7 @@ fn beforeMove(
         } else {
             try log.activate(ident, .Confusion);
 
-            const confused = if (showdown)
-                !battle.rng.chance(u8, 128, 256)
-            else
-                battle.rng.next() >= Gen12.percent(50) + 1;
-
-            if (confused) {
+            if (Rolls.confused(battle)) {
                 assert(!volatiles.MultiHit);
                 if (!volatiles.Rage) volatiles.state = 0;
                 volatiles.Bide = false;
@@ -568,8 +563,12 @@ fn beforeMove(
                     player
                 else
                     player.foe();
+
+                const uncapped = battle.last_damage;
                 // Skipping adjustDamage / randomizeDamage / checkHit
                 _ = try applyDamage(battle, player, target, .Confusion, log);
+                // Pokémon Showdown thinks that confusion damage is uncapped ¯\_(ツ)_/¯
+                if (showdown) battle.last_damage = uncapped;
 
                 return .done;
             }
@@ -578,22 +577,15 @@ fn beforeMove(
 
     if (!showdown and try disabled(side, ident, log)) return .done;
 
-    if (Status.is(stored.status, .PAR)) {
-        const paralyzed = if (showdown)
-            battle.rng.chance(u8, 63, 256)
-        else
-            battle.rng.next() < Gen12.percent(25);
-
-        if (paralyzed) {
-            if (!volatiles.Rage) volatiles.state = 0;
-            volatiles.Bide = false;
-            volatiles.Thrashing = false;
-            volatiles.Charging = false;
-            volatiles.Binding = false;
-            // GLITCH: Invulnerable is not cleared, resulting in permanent Fly/Dig invulnerability
-            try log.cant(ident, .Paralysis);
-            return .done;
-        }
+    if (Status.is(stored.status, .PAR) and Rolls.paralyzed(battle)) {
+        if (!volatiles.Rage) volatiles.state = 0;
+        volatiles.Bide = false;
+        volatiles.Thrashing = false;
+        volatiles.Charging = false;
+        volatiles.Binding = false;
+        // GLITCH: Invulnerable is not cleared, resulting in permanent Fly/Dig invulnerability
+        try log.cant(ident, .Paralysis);
+        return .done;
     }
 
     if (volatiles.Bide) {
@@ -796,7 +788,7 @@ fn doMove(
     };
     assert(!immune or miss or (showdown and move.effect == .Binding));
 
-    var late = showdown;
+    var late = showdown and move.effect != .Explode;
     const skip = status or immune;
     if ((!showdown or (!skip or counter)) and !miss) blk: {
         if (showdown and move.effect.isMulti()) {
@@ -916,7 +908,7 @@ fn doMove(
         if (hit == 0 and ohko) try log.ohko();
         hit += 1;
         if (foe.stored().hp == 0) break;
-        if (!late and !sub) try buildRage(battle, player.foe(), log);
+        if (!late and (!sub or move.effect == .Explode)) try buildRage(battle, player.foe(), log);
         // If the substitute breaks during a multi-hit attack, the attack ends
         if (nullified) break;
     }
@@ -987,8 +979,7 @@ fn checkCriticalHit(battle: anytype, player: Player, move: Move.Data) bool {
     chance = if (side.active.volatiles.FocusEnergy) chance / 2 else @min(chance * 2, 255);
     chance = if (move.effect == .HighCritical) @min(chance * 4, 255) else chance / 2;
 
-    if (showdown) return battle.rng.chance(u8, @intCast(u8, chance), 256);
-    return std.math.rotl(u8, battle.rng.next(), 3) < chance;
+    return Rolls.criticalHit(battle, chance);
 }
 
 fn calcDamage(
@@ -1092,16 +1083,7 @@ fn adjustDamage(battle: anytype, player: Player) u16 {
 
 fn randomizeDamage(battle: anytype) void {
     if (battle.last_damage <= 1) return;
-
-    const random = if (showdown)
-        battle.rng.range(u8, 217, 256)
-    else loop: {
-        while (true) {
-            const r = std.math.rotr(u8, battle.rng.next(), 1);
-            if (r >= 217) break :loop r;
-        }
-    };
-
+    const random = Rolls.damage(battle);
     battle.last_damage = @intCast(u16, @as(u32, battle.last_damage) *% random / 255);
 }
 
@@ -1119,16 +1101,9 @@ fn specialDamage(battle: anytype, player: Player, move: Move.Data, log: anytype)
         // GLITCH: if power = 0 then a desync occurs (or a miss on Pokémon Showdown)
         .Psywave => power: {
             const max = @intCast(u8, @as(u16, side.stored().level) * 3 / 2);
-            if (showdown) {
-                break :power battle.rng.range(u8, 0, max);
-            } else {
-                // GLITCH: Psywave infinite glitch loop
-                if (max <= 1) return Result.Error;
-                while (true) {
-                    const r = battle.rng.next();
-                    if (r < max) break :power r;
-                }
-            }
+            // GLITCH: Psywave infinite glitch loop
+            if (!showdown and max <= 1) return Result.Error;
+            break :power Rolls.psywave(battle, max);
         },
         else => unreachable,
     };
@@ -1260,19 +1235,7 @@ fn metronome(
 ) !?Result {
     var side = battle.side(player);
 
-    side.last_selected_move = if (showdown) blk: {
-        const r = battle.rng.range(u8, 0, @enumToInt(Move.Struggle) - 2);
-        const mod = @as(u2, (if (r < @enumToInt(Move.Metronome) - 1) 1 else 2));
-        break :blk @intToEnum(Move, r + mod);
-    } else loop: {
-        while (true) {
-            const r = battle.rng.next();
-            if (r == 0 or r == @enumToInt(Move.Metronome)) continue;
-            if (r >= @enumToInt(Move.Struggle)) continue;
-            break :loop @intToEnum(Move, r);
-        }
-    };
-
+    side.last_selected_move = Rolls.metronome(battle);
     incrementPP(side, mslot);
 
     if (!try canMove(battle, player, mslot, auto, false, .Metronome, residual, log)) return null;
@@ -1330,23 +1293,24 @@ fn moveHit(battle: anytype, player: Player, move: Move.Data, immune: *bool, mist
         }
 
         // GLITCH: Thrash / Petal Dance / Rage get their accuracy overwritten on subsequent hits
-        var state = &side.active.volatiles.state;
-        const overwritten = (move.effect == .Thrashing or move.effect == .Rage) and state.* > 0;
-        assert(!overwritten or (0 < state.* and state.* <= 255 and !side.active.volatiles.Bide));
-        var accuracy = if (overwritten) state.* else @as(u16, Gen12.percent(move.accuracy));
+        const state = side.active.volatiles.state;
+        var overwrite = move.effect == .Rage or move.effect == .Thrashing;
+        const overwritten = overwrite and state > 0;
+        assert(!overwritten or (0 < state and state <= 255 and !side.active.volatiles.Bide));
+
+        var accuracy = if (overwritten) state else @as(u16, Gen12.percent(move.accuracy));
         var boost = BOOSTS[@intCast(u4, @as(i8, side.active.boosts.accuracy) + 6)];
         accuracy = accuracy * boost[0] / boost[1];
         boost = BOOSTS[@intCast(u4, @as(i8, -foe.active.boosts.evasion) + 6)];
         accuracy = accuracy * boost[0] / boost[1];
         accuracy = @min(255, @max(1, accuracy));
 
-        if (move.effect == .Thrashing or move.effect == .Rage) state.* = accuracy;
+        // Pokémon Showdown only overwrites if the volatile is present
+        if (showdown) overwrite = side.active.volatiles.Rage or side.active.volatiles.Thrashing;
+        if (overwrite) side.active.volatiles.state = accuracy;
 
         // GLITCH: max accuracy is 255 so 1/256 chance of miss
-        break :miss if (showdown)
-            !battle.rng.chance(u8, @intCast(u8, accuracy), 256)
-        else
-            battle.rng.next() >= accuracy;
+        break :miss !Rolls.hit(battle, accuracy);
     };
 
     // Pokémon Showdown reports miss instead of fail for moves blocked by Mist that 1/256 miss
@@ -1478,14 +1442,15 @@ fn handleResidual(battle: anytype, player: Player, log: anytype) !void {
             damage *= volatiles.toxic;
         }
 
-        // Pokémon Showdown erroneously updates last damage with uncapped Leech Seed damage
-        if (showdown) battle.last_damage = damage;
-
         const amount = @min(damage, stored.hp);
         stored.hp -= amount;
 
         // As above, Pokémon Showdown uses damageOf but its not relevant
-        if (amount > 0) try log.damage(ident, stored, .LeechSeed);
+        if (amount > 0) {
+            try log.damage(ident, stored, .LeechSeed);
+            // Pokémon Showdown erroneously updates last damage with uncapped Leech Seed damage
+            if (showdown) battle.last_damage = damage;
+        }
 
         const before = foe_stored.hp;
         // Uncapped damage is added back to the foe
@@ -1572,6 +1537,42 @@ fn checkEBC(battle: anytype) bool {
     return false;
 }
 
+fn disabled(side: *Side, ident: ID, log: anytype) !bool {
+    if (side.active.volatiles.disabled_move != 0) {
+        // A Pokémon that transforms after being disabled may end up with less move slots
+        const m = side.active.moves[side.active.volatiles.disabled_move - 1].id;
+        // side.last_selected_move can be Struggle here on Pokemon Showdown we need an extra check
+        const last = if (showdown and m == .Bide and side.active.volatiles.Bide)
+            m
+        else
+            side.last_selected_move;
+        if (m != .None and m == last) {
+            side.active.volatiles.Charging = false;
+            try log.disabled(ident, last);
+            return true;
+        }
+    }
+    return false;
+}
+
+inline fn buildRage(battle: anytype, who: Player, log: anytype) !void {
+    const side = battle.side(who);
+    if (side.active.volatiles.Rage and side.active.boosts.atk < 6) {
+        try Effects.boost(battle, who, Move.get(.Rage), log);
+    }
+}
+
+fn handleThrashing(battle: anytype, active: *ActivePokemon) bool {
+    var volatiles = &active.volatiles;
+    assert(volatiles.Thrashing);
+    if (volatiles.attacks > 0) return false;
+
+    volatiles.Thrashing = false;
+    volatiles.Confusion = true;
+    volatiles.confusion = Rolls.confusionDuration(battle);
+    return true;
+}
+
 inline fn onBegin(
     battle: anytype,
     player: Player,
@@ -1662,10 +1663,7 @@ pub const Effects = struct {
         side.active.volatiles.Bide = true;
         assert(!side.active.volatiles.Thrashing and !side.active.volatiles.Rage);
         side.active.volatiles.state = 0;
-        side.active.volatiles.attacks = @intCast(u3, if (showdown)
-            battle.rng.range(u4, 2, 4)
-        else
-            (battle.rng.next() & 1) + 2);
+        side.active.volatiles.attacks = Rolls.bideThrashDuration(battle);
 
         try log.start(battle.active(player), .Bide);
     }
@@ -1687,14 +1685,8 @@ pub const Effects = struct {
             return;
         }
 
-        const chance = !foe.active.types.includes(move.type) and if (showdown)
-            battle.rng.chance(u8, @as(u8, if (move.effect == .BurnChance1) 26 else 77), 256)
-        else
-            battle.rng.next() < 1 + (if (move.effect == .BurnChance1)
-                Gen12.percent(10)
-            else
-                Gen12.percent(30));
-        if (!chance) return;
+        if (foe.active.types.includes(move.type)) return;
+        if (!Rolls.secondaryChance(battle, move.effect == .BurnChance1)) return;
 
         foe_stored.status = Status.init(.BRN);
         foe.active.stats.atk = @max(foe.active.stats.atk / 2, 1);
@@ -1718,11 +1710,7 @@ pub const Effects = struct {
         const sub = foe.active.volatiles.Substitute;
 
         if (move.effect == .ConfusionChance) {
-            const chance = if (showdown)
-                battle.rng.chance(u8, 25, 256)
-            else
-                battle.rng.next() < Gen12.percent(10);
-            if (!chance) return;
+            if (!Rolls.confusionChance(battle)) return;
         } else {
             if (showdown) {
                 if (!try checkHit(battle, player, move, log)) {
@@ -1741,10 +1729,7 @@ pub const Effects = struct {
 
         if (foe.active.volatiles.Confusion) return;
         foe.active.volatiles.Confusion = true;
-        foe.active.volatiles.confusion = @intCast(u3, if (showdown)
-            battle.rng.range(u8, 2, 6)
-        else
-            (battle.rng.next() & 3) + 2);
+        foe.active.volatiles.confusion = Rolls.confusionDuration(battle);
 
         try log.start(battle.active(player.foe()), .Confusion);
     }
@@ -1794,11 +1779,8 @@ pub const Effects = struct {
             return Result.Error;
         }
 
-        volatiles.disabled_move = @intCast(u3, randomMoveSlot(&battle.rng, &foe.active.moves, n));
-        volatiles.disabled_duration = @intCast(u4, if (showdown)
-            battle.rng.range(u8, 1, 9)
-        else
-            (battle.rng.next() & 7) + 1);
+        volatiles.disabled_move = @intCast(u3, Rolls.moveSlot(battle, &foe.active.moves, n));
+        volatiles.disabled_duration = Rolls.disableDuration(battle);
 
         try log.startEffect(foe_ident, .Disable, foe.active.move(volatiles.disabled_move).id);
         return null;
@@ -1810,7 +1792,7 @@ pub const Effects = struct {
 
         if (battle.last_damage == 0) {
             assert(showdown);
-            return;
+            if (!battle.foe(player).active.volatiles.Substitute) return;
         }
 
         const drain = @max(battle.last_damage / 2, 1);
@@ -1837,15 +1819,7 @@ pub const Effects = struct {
         var volatiles = &battle.foe(player).active.volatiles;
 
         if (volatiles.Substitute) return;
-
-        const chance = if (showdown)
-            battle.rng.chance(u8, @as(u8, if (move.effect == .FlinchChance1) 26 else 77), 256)
-        else
-            battle.rng.next() < 1 + (if (move.effect == .FlinchChance1)
-                Gen12.percent(10)
-            else
-                Gen12.percent(30));
-        if (!chance) return;
+        if (!Rolls.secondaryChance(battle, move.effect == .FlinchChance1)) return;
 
         volatiles.Flinch = true;
         volatiles.Recharging = false;
@@ -1871,12 +1845,8 @@ pub const Effects = struct {
             return if (showdown and !foe.active.types.includes(move.type)) battle.rng.advance(1);
         }
 
-        const chance = !foe.active.types.includes(move.type) and if (showdown)
-            battle.rng.chance(u8, 26, 256)
-        else
-            battle.rng.next() < 1 + Gen12.percent(10);
-        if (!chance) return;
-
+        if (foe.active.types.includes(move.type)) return;
+        if (!Rolls.secondaryChance(battle, true)) return;
         // Freeze Clause Mod
         if (showdown) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
 
@@ -2021,7 +1991,7 @@ pub const Effects = struct {
         }
         if (!try checkHit(battle, player, move, log)) return;
 
-        const rslot = randomMoveSlot(&battle.rng, &foe.active.moves, 0);
+        const rslot = Rolls.moveSlot(battle, &foe.active.moves, 0);
         side.active.move(oslot).id = foe.active.move(rslot).id;
 
         try log.startEffect(battle.active(player), .Mimic, side.active.move(oslot).id);
@@ -2042,7 +2012,8 @@ pub const Effects = struct {
         assert(!side.active.volatiles.MultiHit);
         side.active.volatiles.MultiHit = true;
 
-        side.active.volatiles.attacks = if (move.effect == .MultiHit) distribution(battle) else 2;
+        side.active.volatiles.attacks =
+            if (move.effect == .MultiHit) Rolls.distribution(battle) else 2;
     }
 
     fn paralyze(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
@@ -2086,14 +2057,8 @@ pub const Effects = struct {
         }
 
         // Body Slam can't paralyze a Normal type Pokémon
-        const chance = !foe.active.types.includes(move.type) and if (showdown)
-            battle.rng.chance(u8, @as(u8, if (move.effect == .ParalyzeChance1) 26 else 77), 256)
-        else
-            battle.rng.next() < 1 + (if (move.effect == .ParalyzeChance1)
-                Gen12.percent(10)
-            else
-                Gen12.percent(30));
-        if (!chance) return;
+        if (foe.active.types.includes(move.type)) return;
+        if (!Rolls.secondaryChance(battle, move.effect == .ParalyzeChance1)) return;
 
         foe_stored.status = Status.init(.PAR);
         foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
@@ -2136,16 +2101,7 @@ pub const Effects = struct {
 
         if (move.effect == .Poison) {
             if (!showdown and !try checkHit(battle, player, move, log)) return;
-        } else {
-            const chance = if (showdown)
-                battle.rng.chance(u8, @as(u8, if (move.effect == .PoisonChance1) 52 else 103), 256)
-            else
-                battle.rng.next() < 1 + (if (move.effect == .PoisonChance1)
-                    Gen12.percent(20)
-                else
-                    Gen12.percent(40));
-            if (!chance) return;
-        }
+        } else if (!Rolls.poisonChance(battle, move.effect == .PoisonChance1)) return;
 
         foe_stored.status = Status.init(.PSN);
         if (toxic) {
@@ -2159,10 +2115,8 @@ pub const Effects = struct {
 
     fn rage(battle: anytype, player: Player) !void {
         var volatiles = &battle.side(player).active.volatiles;
-        if (volatiles.Rage) return;
-        volatiles.Rage = true;
         assert(!volatiles.Bide);
-        volatiles.state = 0;
+        volatiles.Rage = true;
     }
 
     fn recoil(battle: anytype, player: Player, residual: *bool, log: anytype) !void {
@@ -2214,16 +2168,7 @@ pub const Effects = struct {
         }
         foe.active.volatiles.Recharging = false;
 
-        const duration = @intCast(u3, if (showdown)
-            battle.rng.range(u8, 1, 8)
-        else loop: {
-            while (true) {
-                const r = battle.rng.next() & 7;
-                if (r != 0) break :loop r;
-            }
-        });
-
-        foe_stored.status = Status.slp(duration);
+        foe_stored.status = Status.slp(Rolls.sleepDuration(battle));
         try log.statusFrom(foe_ident, foe_stored.status, battle.side(player).last_selected_move);
     }
 
@@ -2276,11 +2221,7 @@ pub const Effects = struct {
         assert(!volatiles.Bide);
 
         volatiles.Thrashing = true;
-        volatiles.state = 0;
-        volatiles.attacks = @intCast(u3, if (showdown)
-            battle.rng.range(u8, 2, 4)
-        else
-            (battle.rng.next() & 1) + 2);
+        volatiles.attacks = Rolls.bideThrashDuration(battle);
     }
 
     fn transform(battle: anytype, player: Player, log: anytype) !void {
@@ -2322,7 +2263,7 @@ pub const Effects = struct {
         // (Pokémon Showdown unitentionally patches this glitch, preventing automatic selection)
         if (!showdown) foe.active.volatiles.Recharging = false;
 
-        side.active.volatiles.attacks = distribution(battle) - 1;
+        side.active.volatiles.attacks = Rolls.distribution(battle) - 1;
     }
 
     fn boost(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
@@ -2349,7 +2290,7 @@ pub const Effects = struct {
                     return try log.fail(ident, .None);
                 }
                 var mod = BOOSTS[@intCast(u4, @as(i8, boosts.atk) + 6)];
-                const stat = unmodifiedStats(battle, player).atk;
+                const stat = unmodifiedStats(battle, side).atk;
                 stats.atk = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, reason, n);
                 // Pokémon Showdown doesn't re-apply status modifiers after Rage boosts
@@ -2369,7 +2310,7 @@ pub const Effects = struct {
                     return try log.fail(ident, .None);
                 }
                 var mod = BOOSTS[@intCast(u4, @as(i8, boosts.def) + 6)];
-                const stat = unmodifiedStats(battle, player).def;
+                const stat = unmodifiedStats(battle, side).def;
                 stats.def = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, .Defense, n);
             },
@@ -2386,7 +2327,7 @@ pub const Effects = struct {
                     return try log.fail(ident, .None);
                 }
                 var mod = BOOSTS[@intCast(u4, @as(i8, boosts.spe) + 6)];
-                const stat = unmodifiedStats(battle, player).spe;
+                const stat = unmodifiedStats(battle, side).spe;
                 stats.spe = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, .Speed, 2);
             },
@@ -2406,7 +2347,7 @@ pub const Effects = struct {
                     return try log.fail(ident, .None);
                 }
                 var mod = BOOSTS[@intCast(u4, @as(i8, boosts.spc) + 6)];
-                const stat = unmodifiedStats(battle, player).spc;
+                const stat = unmodifiedStats(battle, side).spc;
                 stats.spc = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, .SpecialAttack, n);
                 try log.boost(ident, .SpecialDefense, n);
@@ -2433,11 +2374,7 @@ pub const Effects = struct {
         }
 
         if (move.effect.isStatDownChance()) {
-            const chance = if (showdown)
-                battle.rng.chance(u8, 85, 256)
-            else
-                battle.rng.next() < Gen12.percent(33) + 1;
-            if (!chance or foe.active.volatiles.Invulnerable) return;
+            if (!Rolls.unboost(battle) or foe.active.volatiles.Invulnerable) return;
         } else if (!showdown and !try checkHit(battle, player, move, log)) {
             return; // checkHit already checks for Invulnerable
         }
@@ -2459,7 +2396,7 @@ pub const Effects = struct {
                     return try log.fail(foe_ident, .None);
                 }
                 var mod = BOOSTS[@intCast(u4, @as(i8, boosts.atk) + 6)];
-                const stat = unmodifiedStats(battle, player.foe()).atk;
+                const stat = unmodifiedStats(battle, foe).atk;
                 stats.atk = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .Attack, -1);
             },
@@ -2477,7 +2414,7 @@ pub const Effects = struct {
                     return try log.fail(foe_ident, .None);
                 }
                 var mod = BOOSTS[@intCast(u4, @as(i8, boosts.def) + 6)];
-                const stat = unmodifiedStats(battle, player.foe()).def;
+                const stat = unmodifiedStats(battle, foe).def;
                 stats.def = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .Defense, -@as(i8, n));
             },
@@ -2494,7 +2431,7 @@ pub const Effects = struct {
                     return try log.fail(foe_ident, .None);
                 }
                 var mod = BOOSTS[@intCast(u4, @as(i8, boosts.spe) + 6)];
-                const stat = unmodifiedStats(battle, player.foe()).spe;
+                const stat = unmodifiedStats(battle, foe).spe;
                 stats.spe = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .Speed, -1);
                 assert(boosts.spe >= -6);
@@ -2514,7 +2451,7 @@ pub const Effects = struct {
                     return try log.fail(foe_ident, .None);
                 }
                 var mod = BOOSTS[@intCast(u4, @as(i8, boosts.spc) + 6)];
-                const stat = unmodifiedStats(battle, player.foe()).spc;
+                const stat = unmodifiedStats(battle, foe).spc;
                 stats.spc = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .SpecialAttack, -1);
                 try log.boost(foe_ident, .SpecialDefense, -1);
@@ -2533,8 +2470,7 @@ pub const Effects = struct {
     }
 };
 
-fn unmodifiedStats(battle: anytype, who: Player) *Stats(u16) {
-    const side = battle.side(who);
+fn unmodifiedStats(battle: anytype, side: *Side) *Stats(u16) {
     if (!side.active.volatiles.Transform) return &side.stored().stats;
     const id = ID.from(side.active.volatiles.transform);
     return &battle.side(id.player).pokemon[id.id - 1].stats;
@@ -2600,80 +2536,140 @@ fn clearVolatiles(battle: anytype, who: Player, log: anytype) !void {
     }
 }
 
-fn disabled(side: *Side, ident: ID, log: anytype) !bool {
-    if (side.active.volatiles.disabled_move != 0) {
-        // A Pokémon that transforms after being disabled may end up with less move slots
-        const m = side.active.moves[side.active.volatiles.disabled_move - 1].id;
-        // side.last_selected_move can be Struggle here on Pokemon Showdown we need an extra check
-        const last = if (showdown and m == .Bide and side.active.volatiles.Bide)
-            m
-        else
-            side.last_selected_move;
-        if (m != .None and m == last) {
-            side.active.volatiles.Charging = false;
-            try log.disabled(ident, last);
-            return true;
+pub const Rolls = struct {
+    inline fn speedTie(battle: anytype) bool {
+        if (showdown) return battle.rng.range(u8, 0, 2) == 0;
+        return battle.rng.next() < Gen12.percent(50) + 1;
+    }
+
+    inline fn criticalHit(battle: anytype, chance: u16) bool {
+        if (showdown) return battle.rng.chance(u8, @intCast(u8, chance), 256);
+        return std.math.rotl(u8, battle.rng.next(), 3) < chance;
+    }
+
+    inline fn damage(battle: anytype) u8 {
+        if (showdown) return battle.rng.range(u8, 217, 256);
+        while (true) {
+            const r = std.math.rotr(u8, battle.rng.next(), 1);
+            if (r >= 217) return r;
         }
     }
-    return false;
-}
 
-inline fn buildRage(battle: anytype, who: Player, log: anytype) !void {
-    const side = battle.side(who);
-    if (side.active.volatiles.Rage and side.active.boosts.atk < 6) {
-        try Effects.boost(battle, who, Move.get(.Rage), log);
+    inline fn hit(battle: anytype, accuracy: u16) bool {
+        if (showdown) return battle.rng.chance(u8, @intCast(u8, accuracy), 256);
+        return battle.rng.next() < accuracy;
     }
-}
 
-fn handleThrashing(battle: anytype, active: *ActivePokemon) bool {
-    var volatiles = &active.volatiles;
-    assert(volatiles.Thrashing);
-    if (volatiles.attacks > 0) return false;
+    inline fn confusionDuration(battle: anytype) u3 {
+        if (showdown) return @intCast(u3, battle.rng.range(u8, 2, 6));
+        return @intCast(u3, (battle.rng.next() & 3) + 2);
+    }
 
-    volatiles.Thrashing = false;
-    volatiles.Confusion = true;
-    volatiles.confusion = @intCast(u3, if (showdown)
-        battle.rng.range(u8, 2, 6)
-    else
-        (battle.rng.next() & 3) + 2);
+    inline fn confused(battle: anytype) bool {
+        if (showdown) return !battle.rng.chance(u8, 128, 256);
+        return battle.rng.next() >= Gen12.percent(50) + 1;
+    }
 
-    return true;
-}
+    inline fn paralyzed(battle: anytype) bool {
+        if (showdown) return battle.rng.chance(u8, 63, 256);
+        return battle.rng.next() < Gen12.percent(25);
+    }
 
-const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
+    inline fn confusionChance(battle: anytype) bool {
+        if (showdown) return battle.rng.chance(u8, 25, 256);
+        return battle.rng.next() < Gen12.percent(10);
+    }
 
-fn distribution(battle: anytype) u3 {
-    if (showdown) return DISTRIBUTION[battle.rng.range(u8, 0, DISTRIBUTION.len)];
-    const r = (battle.rng.next() & 3);
-    return @intCast(u3, (if (r < 2) r else battle.rng.next() & 3) + 2);
-}
+    inline fn secondaryChance(battle: anytype, low: bool) bool {
+        if (showdown) return battle.rng.chance(u8, @as(u8, if (low) 26 else 77), 256);
+        return battle.rng.next() < 1 + (if (low) Gen12.percent(10) else Gen12.percent(30));
+    }
 
-fn randomMoveSlot(rand: anytype, moves: []MoveSlot, check_pp: u4) u4 {
-    if (showdown) {
-        if (check_pp == 0) {
-            var i: usize = moves.len;
-            while (i > 0) {
-                i -= 1;
-                if (moves[i].id != .None) return rand.range(u4, 0, @intCast(u4, i + 1)) + 1;
-            }
-        } else {
-            var r = rand.range(u4, 0, @intCast(u4, check_pp)) + 1;
-            var i: usize = 0;
-            while (i < moves.len and r > 0) : (i += 1) {
-                if (moves[i].pp > 0) {
-                    r -= 1;
-                    if (r == 0) break;
+    inline fn poisonChance(battle: anytype, low: bool) bool {
+        if (showdown) return battle.rng.chance(u8, @as(u8, if (low) 52 else 103), 256);
+        return battle.rng.next() < 1 + (if (low) Gen12.percent(20) else Gen12.percent(40));
+    }
+
+    inline fn sleepDuration(battle: anytype) u3 {
+        if (showdown) return @intCast(u3, battle.rng.range(u8, 1, 8));
+        while (true) {
+            const r = battle.rng.next() & 7;
+            if (r != 0) return @intCast(u3, r);
+        }
+    }
+
+    inline fn bideThrashDuration(battle: anytype) u3 {
+        if (showdown) return @intCast(u3, battle.rng.range(u4, 2, 4));
+        return @intCast(u3, (battle.rng.next() & 1) + 2);
+    }
+
+    fn moveSlot(battle: anytype, moves: []MoveSlot, check_pp: u4) u4 {
+        if (showdown) {
+            if (check_pp == 0) {
+                var i: usize = moves.len;
+                while (i > 0) {
+                    i -= 1;
+                    if (moves[i].id != .None) {
+                        return battle.rng.range(u4, 0, @intCast(u4, i + 1)) + 1;
+                    }
                 }
+            } else {
+                var r = battle.rng.range(u4, 0, @intCast(u4, check_pp)) + 1;
+                var i: usize = 0;
+                while (i < moves.len and r > 0) : (i += 1) {
+                    if (moves[i].pp > 0) {
+                        r -= 1;
+                        if (r == 0) break;
+                    }
+                }
+                return @intCast(u4, i + 1);
             }
-            return @intCast(u4, i + 1);
+        }
+
+        while (true) {
+            const r = @intCast(u4, battle.rng.next() & 3);
+            if (moves[r].id != .None and (check_pp == 0 or moves[r].pp > 0)) return r + 1;
         }
     }
 
-    while (true) {
-        const r = @intCast(u4, rand.next() & 3);
-        if (moves[r].id != .None and (check_pp == 0 or moves[r].pp > 0)) return r + 1;
+    inline fn disableDuration(battle: anytype) u4 {
+        if (showdown) return @intCast(u4, battle.rng.range(u8, 1, 9));
+        return @intCast(u4, (battle.rng.next() & 7) + 1);
     }
-}
+
+    inline fn metronome(battle: anytype) Move {
+        if (showdown) {
+            const r = battle.rng.range(u8, 0, @enumToInt(Move.Struggle) - 2);
+            const mod = @as(u2, (if (r < @enumToInt(Move.Metronome) - 1) 1 else 2));
+            return @intToEnum(Move, r + mod);
+        }
+        while (true) {
+            const r = battle.rng.next();
+            if (r == 0 or r == @enumToInt(Move.Metronome)) continue;
+            if (r >= @enumToInt(Move.Struggle)) continue;
+            return @intToEnum(Move, r);
+        }
+    }
+
+    inline fn psywave(battle: anytype, max: u8) u8 {
+        if (showdown) return battle.rng.range(u8, 0, max);
+        while (true) {
+            const r = battle.rng.next();
+            if (r < max) return r;
+        }
+    }
+
+    inline fn distribution(battle: anytype) u3 {
+        if (showdown) return DISTRIBUTION[battle.rng.range(u8, 0, DISTRIBUTION.len)];
+        const r = (battle.rng.next() & 3);
+        return @intCast(u3, (if (r < 2) r else battle.rng.next() & 3) + 2);
+    }
+
+    inline fn unboost(battle: anytype) bool {
+        if (showdown) return battle.rng.chance(u8, 85, 256);
+        return battle.rng.next() < Gen12.percent(33) + 1;
+    }
+};
 
 test "RNG agreement" {
     if (!showdown) return;