@pkmn/engine 0.1.0-dev.7f2014fa → 0.1.0-dev.7f37a47c

package/src/lib/gen1/mechanics.zig

@@ -56,34 +56,30 @@ 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);
 
-    var s1 = false;
-    var s2 = false;
     var f1: ?Move = null;
     var f2: ?Move = null;
 
-    if (selectMove(battle, .P1, c1, c2, &s1, &f1)) |r| return r;
-    if (selectMove(battle, .P2, c2, c1, &s2, &f2)) |r| return r;
-
-    var p1 = battle.side(.P1);
-    var p2 = battle.side(.P2);
-
-    var r1 = showdown and p1.active.volatiles.Binding and c2.type == .Switch;
-    var r2 = showdown and p2.active.volatiles.Binding and c1.type == .Switch;
+    if (selectMove(battle, .P1, c1, c2, &f1)) |r| return r;
+    if (selectMove(battle, .P2, c2, c1, &f2)) |r| return r;
 
     if (turnOrder(battle, c1, c2) == .P1) {
-        if (try doTurn(battle, .P1, c1, r1, s1, f1, .P2, c2, r2, s2, f2, log)) |r| return r;
+        if (try doTurn(battle, .P1, c1, f1, .P2, c2, f2, log)) |r| return r;
     } else {
-        if (try doTurn(battle, .P2, c2, r2, s2, f2, .P1, c1, r1, s1, f1, log)) |r| return r;
+        if (try doTurn(battle, .P2, c2, f2, .P1, c1, f1, log)) |r| return r;
     }
 
-    if (p1.active.volatiles.attacks == 0) p1.active.volatiles.Binding = false;
-    if (p2.active.volatiles.attacks == 0) p2.active.volatiles.Binding = false;
+    var p1 = battle.side(.P1);
+    if (p1.active.volatiles.attacks == 0) {
+        p1.active.volatiles.Binding = false;
+    }
+    var p2 = battle.side(.P2);
+    if (p2.active.volatiles.attacks == 0) {
+        p2.active.volatiles.Binding = false;
+    }
 
     return endTurn(battle, log);
 }
@@ -116,7 +112,6 @@ fn selectMove(
     player: Player,
     choice: Choice,
     foe_choice: Choice,
-    skip_turn: *bool,
     from: *?Move,
 ) ?Result {
     if (choice.type == .Pass) return null;
@@ -129,26 +124,17 @@ fn selectMove(
         (choice.type == .Move and choice.data == @boolToInt(showdown)));
 
     // pre-battle menu
-    if (volatiles.Recharging) {
-        if (showdown and battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
-        return null;
-    }
+    if (volatiles.Recharging) return null;
     if (volatiles.Rage) {
         from.* = side.last_used_move;
-        if (showdown) {
-            if (battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
-            saveMove(battle, player, null);
-        }
+        if (showdown) saveMove(battle, player, null);
         return null;
     }
     // Pokémon Showdown removes Flinch at the end-of-turn in its residual handler
     if (!showdown) volatiles.Flinch = false;
     if (volatiles.Thrashing or volatiles.Charging) {
         from.* = side.last_selected_move;
-        if (showdown) {
-            if (battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
-            saveMove(battle, player, null);
-        }
+        if (showdown) saveMove(battle, player, null);
         return null;
     }
 
@@ -158,10 +144,7 @@ fn selectMove(
     // pre-move select
     if (Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP) or volatiles.Bide) {
         assert(showdown or choice.data == 0);
-        if (showdown) {
-            if (volatiles.Bide and battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
-            saveMove(battle, player, choice);
-        }
+        if (showdown) saveMove(battle, player, choice);
         return null;
     }
     if (volatiles.Binding) {
@@ -180,9 +163,9 @@ fn selectMove(
             // GLITCH: https://glitchcity.wiki/Partial_trapping_move_Mirror_Move_link_battle_glitch
             if (foe_choice.type == .Switch) {
                 const slot = if (player == .P1)
-                    battle.last_moves.p1_index
+                    battle.last_selected_indexes.p1
                 else
-                    battle.last_moves.p2_index;
+                    battle.last_selected_indexes.p2;
                 const last = side.active.move(@intCast(u4, slot));
                 if (last.id == .Metronome) side.last_selected_move = last.id;
                 if (last.id == .MirrorMove) return Result.Error;
@@ -192,7 +175,6 @@ fn selectMove(
     }
 
     if (battle.foe(player).active.volatiles.Binding) {
-        skip_turn.* = true;
         if (showdown) {
             saveMove(battle, player, choice);
         } else {
@@ -203,7 +185,6 @@ fn selectMove(
     }
 
     // move select
-    volatiles.state = 0;
     if (choice.data == 0) {
         const struggle = ok: {
             for (side.active.moves, 0..) |move, i| {
@@ -237,9 +218,9 @@ fn saveMove(battle: anytype, player: Player, choice: ?Choice) void {
 
             side.last_selected_move = move.id;
             if (player == .P1) {
-                battle.last_moves.p1_index = @intCast(u3, c.data);
+                battle.last_selected_indexes.p1 = @intCast(u4, c.data);
             } else {
-                battle.last_moves.p2_index = @intCast(u3, c.data);
+                battle.last_selected_indexes.p2 = @intCast(u4, c.data);
             }
         }
     }
@@ -259,9 +240,9 @@ fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, log: anyty
     side.order[slot - 1] = out;
 
     if (player == .P1) {
-        battle.last_moves.p1_index = 1;
+        battle.last_selected_indexes.p1 = 1;
     } else {
-        battle.last_moves.p2_index = 1;
+        battle.last_selected_indexes.p2 = 1;
     }
 
     side.last_used_move = .None;
@@ -320,7 +301,11 @@ 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 = Rolls.speedTie(battle);
+        const p1 = if (showdown)
+            battle.rng.range(u8, 0, 2) == 0
+        else
+            battle.rng.next() < Gen12.percent(50) + 1;
+
         if (!showdown) return if (p1) .P1 else .P2;
 
         // Pokémon Showdown's "lockedmove" volatile's onBeforeTurn uses BattleQueue#changeAction,
@@ -330,7 +315,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 regardless of who
+        // that out and enforce host ordering of events, so P1 just goes first reqgardless 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;
@@ -343,13 +328,9 @@ fn doTurn(
     battle: anytype,
     player: Player,
     player_choice: Choice,
-    player_rewrap: bool,
-    player_skip: bool,
     player_from: ?Move,
     foe_player: Player,
     foe_choice: Choice,
-    foe_rewrap: bool,
-    foe_skip: bool,
     foe_from: ?Move,
     log: anytype,
 ) !?Result {
@@ -357,16 +338,7 @@ fn doTurn(
 
     var residual = true;
     var replace = battle.side(player).stored().hp == 0;
-    if (try executeMove(
-        battle,
-        player,
-        player_choice,
-        player_rewrap,
-        player_skip,
-        player_from,
-        &residual,
-        log,
-    )) |r| return r;
+    if (try executeMove(battle, player, player_choice, player_from, &residual, log)) |r| return r;
     if (!replace) {
         if (player_choice.type != .Switch) {
             if (try checkFaint(battle, foe_player, log)) |r| return r;
@@ -375,18 +347,8 @@ fn doTurn(
         if (try checkFaint(battle, player, log)) |r| return r;
     } else if (foe_choice.type == .Pass) return null;
 
-    residual = true;
     replace = battle.side(foe_player).stored().hp == 0;
-    if (try executeMove(
-        battle,
-        foe_player,
-        foe_choice,
-        foe_rewrap,
-        foe_skip,
-        foe_from,
-        &residual,
-        log,
-    )) |r| return r;
+    if (try executeMove(battle, foe_player, foe_choice, foe_from, &residual, log)) |r| return r;
     if (!replace) {
         if (foe_choice.type != .Switch) {
             if (try checkFaint(battle, player, log)) |r| return r;
@@ -409,8 +371,6 @@ fn executeMove(
     battle: anytype,
     player: Player,
     choice: Choice,
-    rewrap: bool,
-    skip: bool,
     from: ?Move,
     residual: *bool,
     log: anytype,
@@ -422,10 +382,9 @@ fn executeMove(
         return null;
     }
 
-    // This is the correct place to check for SKIP_TURN and abort early, however since Pokémon
-    // Showdown overwrites the SKIP_TURN sentinel with its botched move select we need to add an
-    // additional skip boolean to accomplish the same thing in the Binding check of BeforeMove
     if (side.last_selected_move == .SKIP_TURN) {
+        // Pokémon Showdown overwrites the SKIP_TURN sentinel with its botched move select,
+        // Binding instead gets handled in beforeMove after sleep and freeze
         assert(!showdown);
         if (battle.foe(player).active.volatiles.Binding) {
             try log.cant(battle.active(player), .Bound);
@@ -444,9 +403,9 @@ fn executeMove(
         // choice.data == 0 only happens with Struggle on Pokémon Showdown
         assert(!showdown);
         mslot = @intCast(u4, if (player == .P1)
-            battle.last_moves.p1_index
+            battle.last_selected_indexes.p1
         else
-            battle.last_moves.p2_index);
+            battle.last_selected_indexes.p2);
         const stored = side.stored();
         // GLITCH: Struggle bypass PP underflow via Hyper Beam / Trapping-switch auto selection
         auto = side.last_selected_move == .HyperBeam or side.active.volatiles.Bide or
@@ -468,14 +427,14 @@ fn executeMove(
         // Incorrect mslot with Pokémon Showdown choice semantics so we need to recover from index
         assert(mslot == 1);
         mslot = @intCast(u4, if (player == .P1)
-            battle.last_moves.p1_index
+            battle.last_selected_indexes.p1
         else
-            battle.last_moves.p2_index);
+            battle.last_selected_indexes.p2);
     }
 
     var skip_can = false;
     var skip_pp = false;
-    switch (try beforeMove(battle, player, skip, from, residual, log)) {
+    switch (try beforeMove(battle, player, from, log)) {
         .done => return null,
         .skip_can => skip_can = true,
         .skip_pp => skip_pp = true,
@@ -483,23 +442,14 @@ fn executeMove(
         .err => return @as(?Result, Result.Error),
     }
 
-    if (!skip_can and !try canMove(battle, player, mslot, auto, skip_pp, from, residual, log)) {
-        return null;
-    }
+    if (!skip_can and !try canMove(battle, player, mslot, auto, skip_pp, from, log)) return null;
 
-    return doMove(battle, player, mslot, rewrap, auto, residual, log);
+    return doMove(battle, player, mslot, auto, residual, log);
 }
 
-const BeforeMove = enum { done, skip_can, skip_pp, ok, err };
+const BeforeMove = union(enum) { done, skip_can, skip_pp, ok, err };
 
-fn beforeMove(
-    battle: anytype,
-    player: Player,
-    skip: bool,
-    from: ?Move,
-    residual: *bool,
-    log: anytype,
-) !BeforeMove {
+fn beforeMove(battle: anytype, player: Player, from: ?Move, log: anytype) !BeforeMove {
     var side = battle.side(player);
     const foe = battle.foe(player);
     var active = &side.active;
@@ -527,15 +477,13 @@ fn beforeMove(
         return .done;
     }
 
-    if (skip or foe.active.volatiles.Binding) {
+    if (foe.active.volatiles.Binding) {
         try log.cant(ident, .Bound);
         return .done;
     }
 
-    if (volatiles.Flinch) {
-        // Pokémon Showdown doesn't clear Flinch until its imaginary "residual" phase, meaning
-        // Pokémon can sometimes flinch multiple times from the same original hit
-        if (!showdown) volatiles.Flinch = false;
+    if (!showdown and volatiles.Flinch) {
+        volatiles.Flinch = false;
         try log.cant(ident, .Flinch);
         return .done;
     }
@@ -556,6 +504,13 @@ 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
+    if (showdown and volatiles.Flinch) {
+        volatiles.Flinch = false;
+        try log.cant(ident, .Flinch);
+        return .done;
+    }
+
     // This can only happen if a Pokémon started the battle frozen/sleeping and was thawed/woken
     // before the side had a selected a move - we simply need to assume this leads to a desync
     if (side.last_selected_move == .None) {
@@ -573,9 +528,14 @@ fn beforeMove(
         } else {
             try log.activate(ident, .Confusion);
 
-            if (Rolls.confused(battle)) {
+            const confused = if (showdown)
+                !battle.rng.chance(u8, 128, 256)
+            else
+                battle.rng.next() >= Gen12.percent(50) + 1;
+
+            if (confused) {
                 assert(!volatiles.MultiHit);
-                if (!volatiles.Rage) volatiles.state = 0;
+                volatiles.state = 0;
                 volatiles.Bide = false;
                 volatiles.Thrashing = false;
                 volatiles.MultiHit = false;
@@ -599,12 +559,8 @@ 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;
             }
@@ -613,15 +569,22 @@ fn beforeMove(
 
     if (!showdown and try disabled(side, ident, log)) 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 (Status.is(stored.status, .PAR)) {
+        const paralyzed = if (showdown)
+            battle.rng.chance(u8, 63, 256)
+        else
+            battle.rng.next() < Gen12.percent(25);
+
+        if (paralyzed) {
+            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) {
@@ -648,18 +611,7 @@ fn beforeMove(
             return .done;
         }
 
-        const sub = showdown and foe.active.volatiles.Substitute;
         _ = try applyDamage(battle, player.foe(), player.foe(), .None, log);
-        if (foe.stored().hp > 0 and !sub) try buildRage(battle, player.foe(), log);
-
-        // For reasons passing understanding, Pokémon Showdown still inflicts residual damage to
-        // Bide's user even if the above damage has caused the foe to faint. It's simpler to always
-        // run residual here regardless of whether the foe fainted and opt-out of the default flow
-        if (showdown) {
-            residual.* = false;
-            try handleResidual(battle, player, log);
-        }
-
         return .done;
     }
 
@@ -671,13 +623,8 @@ fn beforeMove(
             try log.start(battle.active(player), .ConfusionSilent);
         }
         try log.move(ident, side.last_selected_move, battle.active(player.foe()), from);
-        if (showdown) {
-            // This shouldn't actually set last_used_move, but Pokémon Showdown sets last
-            // used in useMove and doesn't have the notion of skipping canMove semantics
-            side.last_used_move = side.last_selected_move;
-            if (handleThrashing(battle, active)) {
-                try log.start(battle.active(player), .ConfusionSilent);
-            }
+        if (showdown and handleThrashing(battle, active)) {
+            try log.start(battle.active(player), .ConfusionSilent);
         }
         return .skip_can;
     }
@@ -692,11 +639,7 @@ fn beforeMove(
             side.last_selected_move,
         );
         if (showdown or battle.last_damage != 0) {
-            const sub = showdown and foe.active.volatiles.Substitute;
             _ = try applyDamage(battle, player.foe(), player.foe(), .None, log);
-            if (battle.foe(player).stored().hp > 0 and !sub) {
-                try buildRage(battle, player.foe(), log);
-            }
         }
         return .done;
     }
@@ -711,7 +654,6 @@ fn canMove(
     auto: bool,
     skip_pp: bool,
     from: ?Move,
-    residual: *bool,
     log: anytype,
 ) !bool {
     var side = battle.side(player);
@@ -745,21 +687,8 @@ fn canMove(
     const f = if (from != null and from.? == .None) null else from;
     try log.move(player_ident, side.last_selected_move, battle.active(target), f);
 
-    // The Counter desync is caused by the cartridge not calling GetCurrentMove until now, meaning
-    // in cases where an early return happens the data for a players last selected move does not get
-    // reloaded and HandleCounterMove actually bases its success/failure off of stale information.
-    // This boolean state we track here doesn't exist on the cartridge because it instead manifests
-    // as the desync results from actually having two separate battle states that subtly disagree.
-    const counterable = side.last_selected_move != .Counter and move.bp > 0 and
-        (move.type == .Normal or move.type == .Fighting);
-    if (player == .P1) {
-        battle.last_moves.p1_counterable = @boolToInt(counterable);
-    } else {
-        battle.last_moves.p2_counterable = @boolToInt(counterable);
-    }
-
     if (move.effect.onBegin()) {
-        try onBegin(battle, player, move, mslot, residual, log);
+        try onBegin(battle, player, move, mslot, log);
         return false;
     }
 
@@ -767,7 +696,7 @@ fn canMove(
         Effects.thrashing(battle, player);
     } else if (!showdown and move.effect == .Binding) {
         // Pokémon Showdown handles this after hit/miss checks and damage calculation
-        Effects.binding(battle, player, false);
+        Effects.binding(battle, player);
     }
 
     return true;
@@ -808,7 +737,6 @@ fn doMove(
     battle: anytype,
     player: Player,
     mslot: u4,
-    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
@@ -839,21 +767,16 @@ fn doMove(
             (@enumToInt(move.type.effectiveness(foe.active.types.type1)) == 0 or
             @enumToInt(move.type.effectiveness(foe.active.types.type2)) == 0);
         if (immune and move.effect != .Binding) break :miss true;
-        if (move.effect == .OHKO and side.active.stats.spe < foe.active.stats.spe) {
-            battle.last_damage = 0;
-            break :miss true;
-        }
+        if (move.effect == .OHKO and side.active.stats.spe < foe.active.stats.spe) break :miss true;
         break :miss move.target != .Self and !moveHit(battle, player, move, &immune, &mist);
     };
     assert(!immune or miss or (showdown and move.effect == .Binding));
 
-    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()) {
             Effects.multiHit(battle, player, move);
             hits = side.active.volatiles.attacks;
-            late = false;
         }
 
         // Cartridge rolls for crit even for moves that can't crit (Counter/Metronome/status/OHKO)
@@ -887,7 +810,7 @@ fn doMove(
     }
 
     // Due to control flow shenanigans we need to clear last_damage for Pokémon Showdown
-    if (showdown and skip) battle.last_damage = 0;
+    if (showdown and skip and move.effect != .Bide) battle.last_damage = 0;
 
     miss = if (showdown or skip)
         miss
@@ -900,9 +823,9 @@ fn doMove(
 
     if (!showdown or !miss) {
         if (move.effect == .MirrorMove) {
-            return mirrorMove(battle, player, mslot, rewrap, auto, residual, log);
+            return mirrorMove(battle, player, mslot, auto, residual, log);
         } else if (move.effect == .Metronome) {
-            return metronome(battle, player, mslot, rewrap, auto, residual, log);
+            return metronome(battle, player, mslot, auto, residual, log);
         } else if (move.effect.onEnd()) {
             try onEnd(battle, player, move, log);
             return null;
@@ -917,7 +840,7 @@ fn doMove(
             move.effect == .OHKO and side.active.stats.spe < foe.active.stats.spe;
         if (ohko) {
             try log.immune(foe_ident, .OHKO);
-        } else if (immune and !invulnerable and (!showdown or move.effect != .Binding)) {
+        } else if (immune and !invulnerable) {
             try log.immune(foe_ident, .None);
         } else if (mist) {
             if (!foe.active.volatiles.Substitute) try log.activate(foe_ident, .Mist);
@@ -934,9 +857,15 @@ fn doMove(
             if (showdown and side.stored().hp == 0) residual.* = false;
         } else if (move.effect == .Explode) {
             try Effects.explode(battle, player);
-            try buildRage(battle, player.foe(), log);
-        } else if (showdown and move.effect == .Disable) {
-            try buildRage(battle, player.foe(), log);
+            if (foe.active.volatiles.Rage and foe.active.boosts.atk < 6) {
+                try Effects.boost(battle, player.foe(), Move.get(.Rage), log);
+            }
+        } else if (showdown) {
+            if (move.effect == .Disable) {
+                if (foe.active.volatiles.Rage and foe.active.boosts.atk < 6) {
+                    try Effects.boost(battle, player.foe(), Move.get(.Rage), log);
+                }
+            }
         }
         return null;
     }
@@ -949,9 +878,6 @@ fn doMove(
         hits = side.active.volatiles.attacks;
     }
 
-    // Pokémon Showdown only builds Rage for Disable/Explosion (hit/miss) when attacking into a sub
-    const sub = showdown and foe.active.volatiles.Substitute;
-
     var nullified = false;
     var hit: u4 = 0;
     while (hit < hits) {
@@ -967,7 +893,9 @@ fn doMove(
         if (hit == 0 and ohko) try log.ohko();
         hit += 1;
         if (foe.stored().hp == 0) break;
-        if (!late and (!sub or move.effect == .Explode)) try buildRage(battle, player.foe(), log);
+        if (foe.active.volatiles.Rage and foe.active.boosts.atk < 6) {
+            try Effects.boost(battle, player.foe(), Move.get(.Rage), log);
+        }
         // If the substitute breaks during a multi-hit attack, the attack ends
         if (nullified) break;
     }
@@ -983,17 +911,11 @@ fn doMove(
     } else if (showdown) {
         // This should be handled much earlier but Pokémon Showdown does it here... ¯\_(ツ)_/¯
         if (move.effect == .Binding) {
-            Effects.binding(battle, player, rewrap);
+            Effects.binding(battle, player);
             if (immune) {
                 battle.last_damage = 0;
-                assert(foe.stored().hp > 0);
                 // Pokémon Showdown logs |-damage| here instead of |-immune| because logic...
-                if (sub) {
-                    try log.activate(battle.active(player.foe()), .Substitute);
-                } else {
-                    try log.damage(battle.active(player.foe()), foe.stored(), .None);
-                    try buildRage(battle, player.foe(), log);
-                }
+                try log.damage(battle.active(player.foe()), foe.stored(), .None);
                 return null;
             }
         }
@@ -1010,9 +932,6 @@ fn doMove(
 
     if (foe.stored().hp == 0) return null;
 
-    // Pokémon Showdown builds Rage at the wrong time for non-MultiHit move
-    if (late and !sub and move.effect != .Disable) try buildRage(battle, player.foe(), log);
-
     if (!move.effect.isSpecial()) {
         // On the cartridge Rage is not considered to be "special" and thus gets executed for a
         // second time here (after being executed in the "always happens" block above) but that
@@ -1024,9 +943,7 @@ fn doMove(
         if (move.effect == .Twineedle) {
             if (!showdown) try Effects.poison(battle, player, Move.get(.PoisonSting), log);
         } else if (move.effect == .Disable) {
-            const result = try Effects.disable(battle, player, move, log);
-            if (showdown) try buildRage(battle, player.foe(), log);
-            return result;
+            return Effects.disable(battle, player, move, log);
         } else {
             try moveEffect(battle, player, move, log);
         }
@@ -1044,7 +961,8 @@ 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;
 
-    return Rolls.criticalHit(battle, chance);
+    if (showdown) return battle.rng.chance(u8, @intCast(u8, chance), 256);
+    return std.math.rotl(u8, battle.rng.next(), 3) < chance;
 }
 
 fn calcDamage(
@@ -1148,37 +1066,49 @@ fn adjustDamage(battle: anytype, player: Player) u16 {
 
 fn randomizeDamage(battle: anytype) void {
     if (battle.last_damage <= 1) return;
-    const random = Rolls.damage(battle);
+
+    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;
+        }
+    };
+
     battle.last_damage = @intCast(u16, @as(u32, battle.last_damage) *% random / 255);
 }
 
 fn specialDamage(battle: anytype, player: Player, move: Move.Data, log: anytype) !?Result {
     const side = battle.side(player);
-    const foe = battle.foe(player);
 
     if (!try checkHit(battle, player, move, log)) return null;
 
     battle.last_damage = switch (side.last_selected_move) {
-        .SuperFang => @max(foe.stored().hp / 2, 1),
+        .SuperFang => @max(battle.foe(player).stored().hp / 2, 1),
         .SeismicToss, .NightShade => side.stored().level,
         .SonicBoom => 20,
         .DragonRage => 40,
         // 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);
-            // GLITCH: Psywave infinite glitch loop
-            if (!showdown and max <= 1) return Result.Error;
-            break :power Rolls.psywave(battle, max);
+            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;
+                }
+            }
         },
         else => unreachable,
     };
 
     if (battle.last_damage == 0) return if (showdown) null else Result.Error;
 
-    const sub = showdown and foe.active.volatiles.Substitute;
     _ = try applyDamage(battle, player.foe(), player.foe(), .None, log);
-    if (battle.foe(player).stored().hp > 0 and !sub) try buildRage(battle, player.foe(), log);
-
     return null;
 }
 
@@ -1190,17 +1120,19 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, log: anytype)
         return null;
     }
 
-    // Pretend Splash was used as a stand-in when no move has been used to fail below with 0 BP
+    // Pretend Counter was used as a stand-in when no move has been used to fail below with 0 BP
+    const foe_last_used_move =
+        Move.get(if (foe.last_used_move == .None) .Counter else foe.last_used_move);
     const foe_last_selected_move =
         Move.get(if (foe.last_selected_move == .None or foe.last_selected_move == .SKIP_TURN)
-        .Splash
+        .Counter
     else
         foe.last_selected_move);
 
-    const used = (if (player.foe() == .P1)
-        battle.last_moves.p1_counterable
-    else
-        battle.last_moves.p2_counterable) != 0;
+    const used = foe_last_used_move.bp > 0 and
+        foe.last_used_move != .Counter and
+        (foe_last_used_move.type == .Normal or
+        foe_last_used_move.type == .Fighting);
 
     const selected = foe_last_selected_move.bp > 0 and
         foe.last_selected_move != .Counter and
@@ -1224,9 +1156,7 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, log: anytype)
     // Pokémon Showdown calls checkHit before Counter
     if (!showdown and !try checkHit(battle, player, move, log)) return null;
 
-    const sub = showdown and foe.active.volatiles.Substitute;
     _ = try applyDamage(battle, player.foe(), player.foe(), .None, log);
-    if (battle.foe(player).stored().hp > 0 and !sub) try buildRage(battle, player.foe(), log);
     return null;
 }
 
@@ -1270,7 +1200,6 @@ fn mirrorMove(
     battle: anytype,
     player: Player,
     mslot: u4,
-    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
@@ -1283,30 +1212,41 @@ fn mirrorMove(
     if (foe.last_used_move == .None or foe.last_used_move == .MirrorMove) {
         try log.fail(battle.active(player), .None);
         return null;
-    } else if (!showdown or foe.last_used_move != .Struggle) {
-        incrementPP(side, mslot);
     }
 
-    if (!try canMove(battle, player, mslot, auto, false, .MirrorMove, residual, log)) return null;
-    return doMove(battle, player, mslot, rewrap, auto, residual, log);
+    incrementPP(side, mslot);
+
+    if (!try canMove(battle, player, mslot, auto, false, .MirrorMove, log)) return null;
+    return doMove(battle, player, mslot, auto, residual, log);
 }
 
 fn metronome(
     battle: anytype,
     player: Player,
     mslot: u4,
-    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
 ) !?Result {
     var side = battle.side(player);
 
-    side.last_selected_move = Rolls.metronome(battle);
+    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);
+        }
+    };
+
     incrementPP(side, mslot);
 
-    if (!try canMove(battle, player, mslot, auto, false, .Metronome, residual, log)) return null;
-    return doMove(battle, player, mslot, rewrap, auto, residual, log);
+    if (!try canMove(battle, player, mslot, auto, false, .Metronome, log)) return null;
+    return doMove(battle, player, mslot, auto, residual, log);
 }
 
 fn checkHit(battle: anytype, player: Player, move: Move.Data, log: anytype) !bool {
@@ -1338,9 +1278,7 @@ fn moveHit(battle: anytype, player: Player, move: Move.Data, immune: *bool, mist
             if (move.effect == .Swift) return true;
             if (foe.active.volatiles.Invulnerable) break :miss true;
         }
-        if (move.effect == .DreamEater and (!Status.is(foe.stored().status, .SLP) or
-            (showdown and foe.active.volatiles.Substitute)))
-        {
+        if (move.effect == .DreamEater and !Status.is(foe.stored().status, .SLP)) {
             immune.* = true;
             if (showdown) return false;
             break :miss true;
@@ -1360,24 +1298,23 @@ fn moveHit(battle: anytype, player: Player, move: Move.Data, immune: *bool, mist
         }
 
         // GLITCH: Thrash / Petal Dance / Rage get their accuracy overwritten on subsequent hits
-        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 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));
         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));
 
-        // 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;
+        if (move.effect == .Thrashing or move.effect == .Rage) state.* = accuracy;
 
         // GLITCH: max accuracy is 255 so 1/256 chance of miss
-        break :miss !Rolls.hit(battle, accuracy);
+        break :miss if (showdown)
+            !battle.rng.chance(u8, @intCast(u8, accuracy), 256)
+        else
+            battle.rng.next() >= accuracy;
     };
 
     // Pokémon Showdown reports miss instead of fail for moves blocked by Mist that 1/256 miss
@@ -1492,15 +1429,6 @@ fn handleResidual(battle: anytype, player: Player, log: anytype) !void {
     }
 
     if (volatiles.LeechSeed) {
-        var foe = battle.foe(player);
-        var foe_stored = foe.stored();
-        const foe_ident = battle.active(player.foe());
-
-        if (foe_stored.hp == 0) {
-            assert(showdown);
-            return;
-        }
-
         var damage = @max(stored.stats.hp / 16, 1);
 
         // GLITCH: Leech Seed + Toxic glitch
@@ -1512,6 +1440,10 @@ fn handleResidual(battle: anytype, player: Player, log: anytype) !void {
         const amount = @min(damage, stored.hp);
         stored.hp -= amount;
 
+        var foe = battle.foe(player);
+        var foe_stored = foe.stored();
+        const foe_ident = battle.active(player.foe());
+
         // As above, Pokémon Showdown uses damageOf but its not relevant
         if (amount > 0) try log.damage(ident, stored, .LeechSeed);
 
@@ -1548,20 +1480,16 @@ fn endTurn(battle: anytype, log: anytype) @TypeOf(log).Error!Result {
 
 fn checkEBC(battle: anytype) bool {
     for (battle.sides, 0..) |side, i| {
-        const foe = battle.sides[~@intCast(u1, i)];
-
         var foe_all_ghosts = true;
         var foe_all_transform = true;
-        for (foe.order, 0..) |id, j| {
-            if (id == 0) break;
-            const active = j == 0;
-            const pokemon = foe.pokemon[id - 1];
 
-            const ghost = pokemon.hp == 0 or
-                (if (active) foe.active.types else pokemon.types).includes(.Ghost);
+        for (battle.sides[~@intCast(u1, i)].pokemon) |pokemon| {
+            if (pokemon.species == .None) continue;
+
+            const ghost = pokemon.hp == 0 or pokemon.types.includes(.Ghost);
             foe_all_ghosts = foe_all_ghosts and ghost;
             foe_all_transform = foe_all_transform and pokemon.hp == 0 or transform: {
-                for (if (active) foe.active.moves else pokemon.moves) |m| {
+                for (pokemon.moves) |m| {
                     if (m.id == .None) break :transform true;
                     if (m.id != .Transform) break :transform false;
                 }
@@ -1569,14 +1497,10 @@ fn checkEBC(battle: anytype) bool {
             };
         }
 
-        for (side.order, 0..) |id, j| {
-            if (id == 0) break;
-            const active = j == 0;
-            const pokemon = side.pokemon[id - 1];
-
+        for (side.pokemon) |pokemon| {
             if (pokemon.hp == 0 or Status.is(pokemon.status, .FRZ)) continue;
             const transform = foe_all_transform and transform: {
-                for (if (active) side.active.moves else pokemon.moves) |m| {
+                for (pokemon.moves) |m| {
                     if (m.id == .None) break :transform true;
                     if (m.id != .Transform) break :transform false;
                 }
@@ -1584,7 +1508,7 @@ fn checkEBC(battle: anytype) bool {
             };
             if (transform) continue;
             const no_pp = foe_all_ghosts and no_pp: {
-                for (if (active) side.active.moves else pokemon.moves) |m| {
+                for (pokemon.moves) |m| {
                     if (m.pp != 0) break :no_pp false;
                 }
                 break :no_pp true;
@@ -1600,50 +1524,7 @@ 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,
-    move: Move.Data,
-    mslot: u8,
-    residual: *bool,
-    log: anytype,
-) !void {
+inline fn onBegin(battle: anytype, player: Player, move: Move.Data, mslot: u8, log: anytype) !void {
     assert(move.effect.onBegin());
     return switch (move.effect) {
         .Confusion => Effects.confusion(battle, player, move, log),
@@ -1659,7 +1540,7 @@ inline fn onBegin(
         .Poison => Effects.poison(battle, player, move, log),
         .Reflect => Effects.reflect(battle, player, log),
         .Splash => Effects.splash(battle, player, log),
-        .Substitute => Effects.substitute(battle, player, residual, log),
+        .Substitute => Effects.substitute(battle, player, log),
         .SwitchAndTeleport => Effects.switchAndTeleport(battle, player, move, log),
         .Transform => Effects.transform(battle, player, log),
         else => unreachable,
@@ -1726,7 +1607,10 @@ 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 = Rolls.bideThrashDuration(battle);
+        side.active.volatiles.attacks = @intCast(u3, if (showdown)
+            battle.rng.range(u4, 2, 4)
+        else
+            (battle.rng.next() & 1) + 2);
 
         try log.start(battle.active(player), .Bide);
     }
@@ -1748,8 +1632,14 @@ pub const Effects = struct {
             return;
         }
 
-        if (foe.active.types.includes(move.type)) return;
-        if (!Rolls.secondaryChance(battle, move.effect == .BurnChance1)) 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;
 
         foe_stored.status = Status.init(.BRN);
         foe.active.stats.atk = @max(foe.active.stats.atk / 2, 1);
@@ -1773,7 +1663,11 @@ pub const Effects = struct {
         const sub = foe.active.volatiles.Substitute;
 
         if (move.effect == .ConfusionChance) {
-            if (!Rolls.confusionChance(battle)) return;
+            const chance = if (showdown)
+                battle.rng.chance(u8, 25, 256)
+            else
+                battle.rng.next() < Gen12.percent(10);
+            if (!chance) return;
         } else {
             if (showdown) {
                 if (!try checkHit(battle, player, move, log)) {
@@ -1792,7 +1686,10 @@ pub const Effects = struct {
 
         if (foe.active.volatiles.Confusion) return;
         foe.active.volatiles.Confusion = true;
-        foe.active.volatiles.confusion = Rolls.confusionDuration(battle);
+        foe.active.volatiles.confusion = @intCast(u3, if (showdown)
+            battle.rng.range(u8, 2, 6)
+        else
+            (battle.rng.next() & 3) + 2);
 
         try log.start(battle.active(player.foe()), .Confusion);
     }
@@ -1842,8 +1739,11 @@ pub const Effects = struct {
             return Result.Error;
         }
 
-        volatiles.disabled_move = @intCast(u3, Rolls.moveSlot(battle, &foe.active.moves, n));
-        volatiles.disabled_duration = Rolls.disableDuration(battle);
+        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);
 
         try log.startEffect(foe_ident, .Disable, foe.active.move(volatiles.disabled_move).id);
         return null;
@@ -1853,11 +1753,6 @@ pub const Effects = struct {
         var side = battle.side(player);
         var stored = side.stored();
 
-        if (battle.last_damage == 0) {
-            assert(showdown);
-            if (!battle.foe(player).active.volatiles.Substitute) return;
-        }
-
         const drain = @max(battle.last_damage / 2, 1);
         battle.last_damage = drain;
 
@@ -1882,7 +1777,15 @@ pub const Effects = struct {
         var volatiles = &battle.foe(player).active.volatiles;
 
         if (volatiles.Substitute) return;
-        if (!Rolls.secondaryChance(battle, move.effect == .FlinchChance1)) 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;
 
         volatiles.Flinch = true;
         volatiles.Recharging = false;
@@ -1908,8 +1811,12 @@ pub const Effects = struct {
             return if (showdown and !foe.active.types.includes(move.type)) battle.rng.advance(1);
         }
 
-        if (foe.active.types.includes(move.type)) return;
-        if (!Rolls.secondaryChance(battle, true)) return;
+        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;
+
         // Freeze Clause Mod
         if (showdown) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
 
@@ -2046,15 +1953,15 @@ pub const Effects = struct {
                 }
                 break :has_mimic false;
             };
-            if (!has_mimic) {
-                // Invulnerable foes or 1/256 miss can trigger |-miss| instead of |-fail|
-                if (!try checkHit(battle, player, move, log)) return;
+            // If the foe is Invulnerable we still want to fall through to checkHit to be able to
+            // trigger |-miss| instead of |-fail|
+            if (!has_mimic and !foe.active.volatiles.Invulnerable) {
                 return try log.fail(battle.active(player.foe()), .None);
             }
         }
         if (!try checkHit(battle, player, move, log)) return;
 
-        const rslot = Rolls.moveSlot(battle, &foe.active.moves, 0);
+        const rslot = randomMoveSlot(&battle.rng, &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);
@@ -2075,8 +1982,7 @@ pub const Effects = struct {
         assert(!side.active.volatiles.MultiHit);
         side.active.volatiles.MultiHit = true;
 
-        side.active.volatiles.attacks =
-            if (move.effect == .MultiHit) Rolls.distribution(battle) else 2;
+        side.active.volatiles.attacks = if (move.effect == .MultiHit) distribution(battle) else 2;
     }
 
     fn paralyze(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
@@ -2120,8 +2026,14 @@ pub const Effects = struct {
         }
 
         // Body Slam can't paralyze a Normal type Pokémon
-        if (foe.active.types.includes(move.type)) return;
-        if (!Rolls.secondaryChance(battle, move.effect == .ParalyzeChance1)) return;
+        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;
 
         foe_stored.status = Status.init(.PAR);
         foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
@@ -2151,7 +2063,7 @@ pub const Effects = struct {
             return log.fail(foe_ident, if (Status.is(foe_stored.status, .PSN))
                 if (!showdown)
                     .Poison
-                else if (toxic == (foe_stored.status == Status.TOX))
+                else if (toxic == foe.active.volatiles.Toxic)
                     if (toxic) .Toxic else .Poison
                 else
                     .None
@@ -2164,7 +2076,16 @@ pub const Effects = struct {
 
         if (move.effect == .Poison) {
             if (!showdown and !try checkHit(battle, player, move, log)) return;
-        } else if (!Rolls.poisonChance(battle, move.effect == .PoisonChance1)) 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;
+        }
 
         foe_stored.status = Status.init(.PSN);
         if (toxic) {
@@ -2178,8 +2099,10 @@ pub const Effects = struct {
 
     fn rage(battle: anytype, player: Player) !void {
         var volatiles = &battle.side(player).active.volatiles;
-        assert(!volatiles.Bide);
+        if (volatiles.Rage) return;
         volatiles.Rage = true;
+        assert(!volatiles.Bide);
+        volatiles.state = 0;
     }
 
     fn recoil(battle: anytype, player: Player, residual: *bool, log: anytype) !void {
@@ -2231,7 +2154,16 @@ pub const Effects = struct {
         }
         foe.active.volatiles.Recharging = false;
 
-        foe_stored.status = Status.slp(Rolls.sleepDuration(battle));
+        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);
         try log.statusFrom(foe_ident, foe_stored.status, battle.side(player).last_selected_move);
     }
 
@@ -2239,7 +2171,7 @@ pub const Effects = struct {
         try log.activate(battle.active(player), .Splash);
     }
 
-    fn substitute(battle: anytype, player: Player, residual: *bool, log: anytype) !void {
+    fn substitute(battle: anytype, player: Player, log: anytype) !void {
         var side = battle.side(player);
         if (side.active.volatiles.Substitute) {
             try log.fail(battle.active(player), .Substitute);
@@ -2264,18 +2196,14 @@ pub const Effects = struct {
         side.active.volatiles.substitute = hp + 1;
         side.active.volatiles.Substitute = true;
         try log.start(battle.active(player), .Substitute);
-        if (hp > 0) {
-            try log.damage(battle.active(player), side.stored(), .None);
-            if (showdown and side.stored().hp == 0) residual.* = false;
-        }
+        if (hp > 0) try log.damage(battle.active(player), side.stored(), .None);
     }
 
     fn switchAndTeleport(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
         if (!showdown or battle.side(player).last_selected_move == .Teleport) return;
 
-        // Whirlwind/Roar should not roll to hit/reset damage but Pokémon Showdown does anyway
+        // Whirlwind/Roar should not roll to hit but Pokémon Showdown does anyway
         _ = try checkHit(battle, player, move, log);
-        battle.last_damage = 0;
     }
 
     fn thrashing(battle: anytype, player: Player) void {
@@ -2284,7 +2212,11 @@ pub const Effects = struct {
         assert(!volatiles.Bide);
 
         volatiles.Thrashing = true;
-        volatiles.attacks = Rolls.bideThrashDuration(battle);
+        volatiles.state = 0;
+        volatiles.attacks = @intCast(u3, if (showdown)
+            battle.rng.range(u8, 2, 4)
+        else
+            (battle.rng.next() & 1) + 2);
     }
 
     fn transform(battle: anytype, player: Player, log: anytype) !void {
@@ -2316,7 +2248,7 @@ pub const Effects = struct {
         try log.transform(battle.active(player), foe_ident);
     }
 
-    fn binding(battle: anytype, player: Player, rewrap: bool) void {
+    fn binding(battle: anytype, player: Player) void {
         var side = battle.side(player);
         var foe = battle.foe(player);
 
@@ -2324,11 +2256,9 @@ pub const Effects = struct {
         side.active.volatiles.Binding = true;
         // GLITCH: Hyper Beam automatic selection glitch if Recharging gets cleared on miss
         // (Pokémon Showdown unitentionally patches this glitch, preventing automatic selection)
-        if (!showdown) {
-            foe.active.volatiles.Recharging = false;
-        } else if (foe.stored().hp == 0) return if (!rewrap) battle.rng.advance(1);
+        if (!showdown) foe.active.volatiles.Recharging = false;
 
-        side.active.volatiles.attacks = Rolls.distribution(battle) - 1;
+        side.active.volatiles.attacks = distribution(battle) - 1;
     }
 
     fn boost(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
@@ -2355,11 +2285,9 @@ pub const Effects = struct {
                     return try log.fail(ident, .None);
                 }
                 var mod = BOOSTS[@intCast(u4, @as(i8, boosts.atk) + 6)];
-                const stat = unmodifiedStats(battle, side).atk;
+                const stat = unmodifiedStats(battle, player).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
-                if (showdown and move.effect == .Rage) return;
             },
             .DefenseUp1, .DefenseUp2 => {
                 assert(boosts.def >= -6 and boosts.def <= 6);
@@ -2375,7 +2303,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, side).def;
+                const stat = unmodifiedStats(battle, player).def;
                 stats.def = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, .Defense, n);
             },
@@ -2392,7 +2320,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, side).spe;
+                const stat = unmodifiedStats(battle, player).spe;
                 stats.spe = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, .Speed, 2);
             },
@@ -2412,7 +2340,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, side).spc;
+                const stat = unmodifiedStats(battle, player).spc;
                 stats.spc = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, .SpecialAttack, n);
                 try log.boost(ident, .SpecialDefense, n);
@@ -2439,7 +2367,11 @@ pub const Effects = struct {
         }
 
         if (move.effect.isStatDownChance()) {
-            if (!Rolls.unboost(battle) or foe.active.volatiles.Invulnerable) return;
+            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;
         } else if (!showdown and !try checkHit(battle, player, move, log)) {
             return; // checkHit already checks for Invulnerable
         }
@@ -2461,7 +2393,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, foe).atk;
+                const stat = unmodifiedStats(battle, player.foe()).atk;
                 stats.atk = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .Attack, -1);
             },
@@ -2479,7 +2411,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, foe).def;
+                const stat = unmodifiedStats(battle, player.foe()).def;
                 stats.def = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .Defense, -@as(i8, n));
             },
@@ -2496,7 +2428,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, foe).spe;
+                const stat = unmodifiedStats(battle, player.foe()).spe;
                 stats.spe = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .Speed, -1);
                 assert(boosts.spe >= -6);
@@ -2516,7 +2448,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, foe).spc;
+                const stat = unmodifiedStats(battle, player.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);
@@ -2535,7 +2467,8 @@ pub const Effects = struct {
     }
 };
 
-fn unmodifiedStats(battle: anytype, side: *Side) *Stats(u16) {
+fn unmodifiedStats(battle: anytype, who: Player) *Stats(u16) {
+    const side = battle.side(who);
     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;
@@ -2549,7 +2482,7 @@ fn statusModify(status: u8, stats: *Stats(u16)) void {
     }
 }
 
-inline fn isForced(active: ActivePokemon) bool {
+fn isForced(active: ActivePokemon) bool {
     return active.volatiles.Recharging or active.volatiles.Rage or
         active.volatiles.Thrashing or active.volatiles.Charging;
 }
@@ -2581,9 +2514,13 @@ fn clearVolatiles(battle: anytype, who: Player, log: anytype) !void {
         volatiles.LeechSeed = false;
         try log.end(ident, .LeechSeed);
     }
-    if (!showdown and volatiles.Toxic) {
+    if (volatiles.Toxic) {
         volatiles.Toxic = false;
-        // volatiles.toxic is left unchanged, except on Pokémon Showdown which clears it (below)
+        // volatiles.toxic is left unchanged, except on Pokémon Showdown which clears it
+        if (showdown) {
+            volatiles.toxic = 0;
+            try log.end(ident, .Toxic);
+        }
     }
     if (volatiles.LightScreen) {
         volatiles.LightScreen = false;
@@ -2593,148 +2530,70 @@ fn clearVolatiles(battle: anytype, who: Player, log: anytype) !void {
         volatiles.Reflect = false;
         try log.end(ident, .Reflect);
     }
-    if (showdown and volatiles.Toxic) {
-        volatiles.Toxic = false;
-        // Pokémon Showdown erroneously clears the toxic counter
-        volatiles.toxic = 0;
-        try log.end(ident, .Toxic);
-    }
 }
 
-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;
+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;
+        if (m != .None and m == side.last_selected_move) {
+            side.active.volatiles.Charging = false;
+            try log.disabled(ident, side.last_selected_move);
+            return true;
         }
     }
+    return false;
+}
 
-    inline fn hit(battle: anytype, accuracy: u16) bool {
-        if (showdown) return battle.rng.chance(u8, @intCast(u8, accuracy), 256);
-        return battle.rng.next() < accuracy;
-    }
-
-    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);
-    }
-
-    inline fn confused(battle: anytype) bool {
-        if (showdown) return !battle.rng.chance(u8, 128, 256);
-        return battle.rng.next() >= Gen12.percent(50) + 1;
-    }
-
-    inline fn paralyzed(battle: anytype) bool {
-        if (showdown) return battle.rng.chance(u8, 63, 256);
-        return battle.rng.next() < Gen12.percent(25);
-    }
-
-    inline fn confusionChance(battle: anytype) bool {
-        if (showdown) return battle.rng.chance(u8, 25, 256);
-        return battle.rng.next() < Gen12.percent(10);
-    }
+fn handleThrashing(battle: anytype, active: *ActivePokemon) bool {
+    var volatiles = &active.volatiles;
+    assert(volatiles.Thrashing);
+    if (volatiles.attacks > 0) return false;
 
-    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));
-    }
+    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 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));
-    }
+    return true;
+}
 
-    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);
-        }
-    }
+const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
 
-    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 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);
+}
 
-    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;
-                    }
+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;
                 }
-                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;
-        }
-    }
-
-    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);
+            return @intCast(u4, i + 1);
         }
     }
 
-    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);
+    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 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;
@@ -2834,11 +2693,9 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                 while (slot <= 4) : (slot += 1) {
                     const m = active.moves[slot - 1];
                     if (m.id == .None) break;
-                    if (m.id == if (active.volatiles.Bide) .Bide else side.last_selected_move) {
-                        // Pokémon Showdown displays Struggle if limited to Bide but unable to pick
-                        const struggle =
-                            m.id == .Bide and (m.pp == 0 or active.volatiles.disabled_move == slot);
-                        const s = if (struggle) 0 else slot;
+                    if (m.id == side.last_selected_move) {
+                        // Pokémon Showdown displays Struggle if limited to Bide when out of PP
+                        const s = if (m.pp == 0 and m.id == .Bide) 0 else slot;
                         out[n] = .{ .type = .Move, .data = s };
                         n += 1;
                         return n;