@pkmn/engine 0.1.0-dev.abd68573 → 0.1.0-dev.ac652f4e

package/src/lib/gen1/mechanics.zig

@@ -1,37 +1,29 @@
-const std = @import("std");
-
-const pkmn = @import("../pkmn.zig");
+const DEBUG = @import("../common/debug.zig").print;
 
+const builtin = @import("builtin");
+const chance = @import("chance.zig");
 const common = @import("../common/data.zig");
-const DEBUG = @import("../common/debug.zig").print;
+const data = @import("data.zig");
+const pkmn = @import("../pkmn.zig");
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
-
-const data = @import("data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
-const expectEqual = std.testing.expectEqual;
-
-const showdown = pkmn.options.showdown;
-
-const Choice = common.Choice;
-const ID = common.ID;
-const Player = common.Player;
-const Result = common.Result;
-
 const Boost = protocol.Boost;
+const Choice = common.Choice;
 const Damage = protocol.Damage;
+const Effectiveness = data.Effectiveness;
+const expectEqual = std.testing.expectEqual;
 const Fail = protocol.Fail;
-const Heal = protocol.Heal;
-
 const Gen12 = rng.Gen12;
-
-const ActivePokemon = data.ActivePokemon;
-const Effectiveness = data.Effectiveness;
+const Heal = protocol.Heal;
+const ID = common.ID;
 const Move = data.Move;
 const MoveSlot = data.MoveSlot;
-const Pokemon = data.Pokemon;
+const Player = common.Player;
+const Result = common.Result;
+const showdown = pkmn.options.showdown;
 const Side = data.Side;
 const Species = data.Species;
 const Stats = data.Stats;
@@ -166,7 +158,7 @@ fn selectMove(
             // to satisfy the conditions of the Desync Clause Mod. However, because Binding is still
             // set the selected move will not actually be used, it will just be reported as having
             // been used (this differs from how Pokémon Showdown works, but its impossible to
-            // replicate the incorrect behavior with the correct mechanisms).
+            // replicate the incorrect behavior with the correct mechanisms)
             saveMove(battle, player, choice);
         } else {
             assert(choice.data == 0);
@@ -174,7 +166,10 @@ fn selectMove(
             if (foe_choice.type == .Switch) {
                 const last = side.active.move(battle.lastMove(player).index);
                 if (last.id == .Metronome) side.last_selected_move = last.id;
-                if (last.id == .MirrorMove) return Result.Error;
+                if (last.id == .MirrorMove) {
+                    if (!pkmn.options.mod) return Result.Error;
+                    side.last_selected_move = last.id;
+                }
             }
         }
         return null;
@@ -253,11 +248,11 @@ fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, options: a
     active.moves = incoming.moves;
 
     statusModify(incoming.status, &active.stats);
+    options.chance.switched(player, slot);
 
     foe.active.volatiles.Binding = false;
 
     try options.log.switched(.{ battle.active(player), incoming });
-    options.chance.switched(player, side.order[0], out);
 
     if (showdown and incoming.status == Status.TOX) {
         incoming.status = Status.init(.PSN);
@@ -347,13 +342,13 @@ fn doTurn(
     )) |r| return r;
     if (!replace) {
         if (player_choice.type != .Switch) {
-            if (try checkFaint(battle, foe_player, options)) |r| return r;
+            if (try checkFaint(battle, foe_player, true, options)) |r| return r;
         }
         if (residual) try handleResidual(battle, player, options);
-        if (try checkFaint(battle, player, options)) |r| return r;
+        if (try checkFaint(battle, player, false, options)) |r| return r;
     } else if (foe_choice.type == .Pass) return null;
 
-    options.chance.clearPending();
+    if (!showdown) options.chance.clearPending();
 
     residual = true;
     replace = battle.side(foe_player).stored().hp == 0;
@@ -369,10 +364,10 @@ fn doTurn(
     )) |r| return r;
     if (!replace) {
         if (!calc and foe_choice.type != .Switch) {
-            if (try checkFaint(battle, player, options)) |r| return r;
+            if (try checkFaint(battle, player, true, options)) |r| return r;
         }
         if (residual) try handleResidual(battle, foe_player, options);
-        if (try checkFaint(battle, foe_player, options)) |r| return r;
+        if (try checkFaint(battle, foe_player, false, options)) |r| return r;
     }
 
     // Flinch is bugged on Pokémon Showdown because it gets implemented with a duration which causes
@@ -425,13 +420,13 @@ fn executeMove(
         mslot = @intCast(battle.lastMove(player).index);
         const stored = side.stored();
         // GLITCH: Struggle bypass PP underflow via Hyper Beam / Trapping-switch auto selection
-        auto = isForced(&side.active) or
+        auto = pkmn.options.mod or isForced(&side.active) or
             side.active.volatiles.Binding or side.active.volatiles.Bide or
             side.last_selected_move == .HyperBeam or
             Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP);
         // If it wasn't Hyper Beam or the continuation of a move effect then we must have just
         // thawed, in which case we will desync unless the last_selected_move happened to be at
-        // index 1 and the current Pokémon has the same move in its first slot.
+        // index 1 and the current Pokémon has the same move in its first slot
         if (!auto) {
             // side.active.moves(slot) is safe to check even though the slot in question might not
             // technically be from this Pokémon because it must be exactly 1 to not desync and
@@ -458,6 +453,25 @@ fn executeMove(
         .err => return @as(?Result, Result.Error),
     }
 
+    // Pokémon Showdown incorrectly implements PP deduction when handling the Hyper Beam automatic
+    // selection glitch - if the move was proced due to Metronome / Mirror Move it either subtracts
+    // from the Hyper Beam slot if present or skips PP deduction entirely...
+    if (showdown and !skip_pp and side.last_selected_move == .HyperBeam and
+        side.last_selected_move != side.active.move(mslot).id)
+    {
+        assert(mslot == 1);
+        const has_beam = has_beam: {
+            for (side.active.moves, 0..) |m, i| {
+                if (m.id == .HyperBeam) {
+                    mslot = @intCast(i + 1);
+                    break :has_beam true;
+                }
+            }
+            break :has_beam false;
+        };
+        if (!has_beam) skip_pp = true;
+    }
+
     const can = skip_can or
         try canMove(battle, player, mslot, auto, skip_pp, .None, residual, options);
     if (!can) return null;
@@ -484,17 +498,22 @@ fn beforeMove(
 
     if (Status.is(stored.status, .SLP)) {
         const before = stored.status;
+        const slf = Status.is(stored.status, .EXT);
         // Even if the EXT bit is set this will still correctly modify the sleep duration
-        if (options.calc.modify(player, .sleep)) |extend| {
-            if (!extend) stored.status = 0;
+        if (options.calc.overridden(player, .sleep)) |obs| switch (obs) {
+            .started, .ended => stored.status = 0,
+            .continuing => if (Status.duration(stored.status) > 1) {
+                stored.status -= 1;
+            },
+            else => unreachable,
         } else {
             stored.status -= 1;
         }
 
         const duration = Status.duration(stored.status);
-        if (!Status.is(stored.status, .EXT)) {
-            try options.chance.sleep(player, duration);
-        }
+        try options.chance.sleep(player, if (slf)
+            .None
+        else if (duration == 0) .ended else .continuing);
 
         if (duration == 0) {
             try log.curestatus(.{ ident, before, .Message });
@@ -532,12 +551,12 @@ fn beforeMove(
     }
 
     if (volatiles.disable_duration > 0) {
-        if (options.calc.modify(player, .disable)) |extend| {
-            if (!extend) volatiles.disable_duration = 0;
-        } else {
-            volatiles.disable_duration -= 1;
-        }
-        try options.chance.disable(player, volatiles.disable_duration);
+        volatiles.disable_duration =
+            decrement(.disable, player, options, volatiles.disable_duration);
+        try options.chance.disable(
+            player,
+            if (volatiles.disable_duration == 0) .ended else .continuing,
+        );
 
         if (volatiles.disable_duration == 0) {
             volatiles.disable_move = 0;
@@ -550,19 +569,24 @@ fn beforeMove(
     // 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) {
-        assert(!showdown);
+        assert(!pkmn.options.mod);
         return .err;
     }
 
     if (volatiles.Confusion) {
         assert(volatiles.confusion > 0);
-
-        if (options.calc.modify(player, .confusion)) |extend| {
-            if (!extend) volatiles.confusion = 0;
+        if (options.calc.overridden(player, .confusion)) |obs| switch (obs) {
+            .started, .ended => volatiles.confusion = 0,
+            .continuing => if (volatiles.confusion > 1) {
+                volatiles.confusion -= 1;
+            },
+            .overwritten => {},
+            else => unreachable,
         } else {
             volatiles.confusion -= 1;
         }
-        try options.chance.confusion(player, volatiles.confusion);
+
+        try options.chance.confusion(player, if (volatiles.confusion == 0) .ended else .continuing);
 
         if (volatiles.confusion == 0) {
             volatiles.Confusion = false;
@@ -580,7 +604,9 @@ fn beforeMove(
                 volatiles.Charging = false;
                 volatiles.Binding = false;
                 volatiles.Invulnerable = false;
-                options.chance.clearDurations(player, null);
+
+                options.chance.observe(.attacking, player, .None);
+                options.chance.observe(.binding, player, .None);
                 {
                     // This feels (and is) disgusting but the cartridge literally just overwrites
                     // the opponent's defense with the user's defense and resets it after. As a
@@ -588,19 +614,14 @@ fn beforeMove(
                     const def = foe.active.stats.def;
                     foe.active.stats.def = active.stats.def;
                     defer foe.active.stats.def = def;
-                    if (!calcDamage(battle, player, player.foe(), null, false)) return .err;
+                    if (!calcDamage(battle, player, player.foe(), null, false, options)) {
+                        return .err;
+                    }
                 }
-                // Pokémon Showdown incorrectly changes the "target" of the confusion self-hit based
-                // on the targeting behavior of the confused Pokémon's selected move which results
-                // in the wrong behavior with respect to the Substitute + Confusion glitch
-                const target = if (showdown and Move.get(side.last_selected_move).target == .Self)
-                    player
-                else
-                    player.foe();
 
                 const uncapped = battle.last_damage;
                 // Skipping adjustDamage / randomizeDamage / checkHit
-                _ = try applyDamage(battle, player, target, .Confusion, options);
+                _ = try applyDamage(battle, player, player.foe(), .Confusion, options);
                 // Pokémon Showdown thinks that confusion damage is uncapped ¯\_(ツ)_/¯
                 if (showdown) battle.last_damage = uncapped;
 
@@ -617,7 +638,10 @@ fn beforeMove(
         volatiles.Thrashing = false;
         volatiles.Charging = false;
         volatiles.Binding = false;
-        options.chance.clearDurations(player, null);
+
+        options.chance.observe(.attacking, player, .None);
+        options.chance.observe(.binding, player, .None);
+
         // GLITCH: Invulnerable is not cleared, resulting in permanent Fly/Dig invulnerability
         try log.cant(.{ ident, .Paralysis });
         return .done;
@@ -635,12 +659,8 @@ fn beforeMove(
             volatiles.state +%= battle.last_damage;
         }
 
-        if (options.calc.modify(player, .attacking)) |extend| {
-            if (!extend) volatiles.attacks = 0;
-        } else {
-            volatiles.attacks -= 1;
-        }
-        try options.chance.attacking(player, volatiles.attacks);
+        volatiles.attacks = decrement(.attacking, player, options, volatiles.attacks);
+        try options.chance.attacking(player, if (volatiles.attacks == 0) .ended else .continuing);
 
         if (volatiles.attacks != 0) {
             try log.activate(.{ ident, .Bide });
@@ -674,35 +694,40 @@ fn beforeMove(
     }
 
     if (volatiles.Thrashing) {
-        if (options.calc.modify(player, .attacking)) |extend| {
-            if (!extend) volatiles.attacks = 0;
-        } else {
-            volatiles.attacks -= 1;
-        }
-        try options.chance.attacking(player, volatiles.attacks);
+        try log.move(.{ ident, side.last_selected_move, battle.active(player.foe()) });
+
+        volatiles.attacks = decrement(.attacking, player, options, volatiles.attacks);
+        try options.chance.attacking(player, if (volatiles.attacks == 0) .ended else .continuing);
 
-        if (!showdown and handleThrashing(battle, active, player, options)) {
+        if (volatiles.attacks == 0) {
+            const overwritten = volatiles.Confusion;
+
+            volatiles.Thrashing = false;
+            volatiles.Confusion = true;
+            volatiles.confusion = Rolls.confusionDuration(battle, player, options);
+
+            // On Pokémon Showdown this could leak information to the opponent that thrashing has
+            // ended (the engine's protocol is always from the omniscient perspective and clients
+            // can be expected to recognize this pattern and pass the information only to the
+            // correct player)
             try log.start(.{ battle.active(player), .ConfusionSilent });
+            options.chance.observe(.confusion, player, if (overwritten)
+                if (pkmn.options.overwrite) .overwritten else .continuing
+            else
+                .started);
+            if (!overwritten) options.calc.confusion(player);
         }
-        try log.move(.{ ident, side.last_selected_move, battle.active(player.foe()) });
-        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, player, options)) {
-                try log.start(.{ battle.active(player), .ConfusionSilent });
-            }
-        }
+
+        // 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
+        if (showdown) side.last_used_move = side.last_selected_move;
+
         return .skip_can;
     }
 
     if (volatiles.Binding) {
-        if (options.calc.modify(player, .binding)) |extend| {
-            if (!extend) volatiles.attacks = 0;
-        } else {
-            volatiles.attacks -= 1;
-        }
-        try options.chance.binding(player, volatiles.attacks);
+        volatiles.attacks = decrement(.binding, player, options, volatiles.attacks);
+        try options.chance.binding(player, if (volatiles.attacks == 0) .ended else .continuing);
 
         try log.move(.{ ident, side.last_selected_move, battle.active(player.foe()) });
         if (showdown or battle.last_damage != 0) {
@@ -756,9 +781,14 @@ fn canMove(
 
     if (move.effect == .Thrashing) {
         Effects.thrashing(battle, player, options);
-    } else if (!showdown and move.effect == .Binding) {
-        // Pokémon Showdown handles this after hit/miss checks and damage calculation
-        try Effects.binding(battle, player, false, options);
+    } else if (move.effect == .Binding) {
+        // Pokémon Showdown handles this after hit/miss checks and damage calculation, though clears
+        // Recharging in onTryMove (required for the Hyper Beam automatic selection glitch)
+        if (showdown) {
+            battle.foe(player).active.volatiles.Recharging = false;
+        } else {
+            try Effects.binding(battle, player, false, options);
+        }
     }
 
     return true;
@@ -795,7 +825,7 @@ fn decrementPP(side: *Side, mslot: u4, auto: bool) void {
     assert(active.move(mslot).pp == side.stored().move(mslot).pp);
 }
 
-fn incrementPP(side: *Side, mslot: u4) void {
+fn incrementPP(side: *Side, player: Player, mslot: u4, options: anytype) void {
     var active = &side.active;
     const volatiles = &active.volatiles;
 
@@ -803,8 +833,11 @@ fn incrementPP(side: *Side, mslot: u4) void {
     // GLITCH: No check for Transform means an empty/incorrect stored slot can get incremented
     if (showdown and volatiles.Transform) return;
 
+    const n = options.calc.overridden(player, .pp) orelse 1;
+    if (volatiles.Transform and !options.chance.pp(player, n)) return;
+
     assert(mslot > 0 and mslot <= 4);
-    side.stored().moves[mslot - 1].pp = @as(u6, @intCast(side.stored().moves[mslot - 1].pp)) +% 1;
+    side.stored().moves[mslot - 1].pp = @as(u6, @intCast(side.stored().moves[mslot - 1].pp)) +% n;
 }
 
 // Pokémon Showdown does hit/multi/crit/damage instead of crit/damage/hit/multi
@@ -852,13 +885,13 @@ fn doMove(
             break :miss true;
         }
         break :miss (move.target != .Self and
-            !moveHit(battle, player, move, &immune, &mist, options));
+            !try moveHit(battle, player, move, &immune, &mist, options));
     };
     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 or (!skip or counter)) and !miss) damage: {
         if (showdown and move.effect.isMulti()) {
             try Effects.multiHit(battle, player, move, options);
             hits = side.active.volatiles.attacks;
@@ -880,8 +913,9 @@ fn doMove(
                 ohko = if (!showdown) side.active.stats.spe >= foe.active.stats.spe else true;
                 // This can overflow after adjustDamage, but will still be sufficient to OHKO
                 battle.last_damage = if (ohko) 65535 else 0;
-                if (showdown) break :blk; // skip adjustDamage / randomizeDamage
-            } else if (!calcDamage(battle, player, player.foe(), move, crit)) {
+                if (showdown) break :damage; // skip adjustDamage / randomizeDamage
+            } else if (!calcDamage(battle, player, player.foe(), move, crit, options)) {
+                if (!showdown) try options.chance.commit(player, .err);
                 return @as(?Result, Result.Error);
             }
             if (battle.last_damage == 0) {
@@ -895,11 +929,12 @@ fn doMove(
         }
     }
 
+    var missed: bool = undefined;
     const zero = battle.last_damage == 0;
-    miss = if (showdown or skip)
-        miss
-    else
-        (!moveHit(battle, player, move, &immune, &mist, options) or zero);
+    if (!showdown and !skip) {
+        missed = !try moveHit(battle, player, move, &immune, &mist, options);
+        miss = missed or zero;
+    }
 
     assert(showdown or miss or battle.last_damage > 0 or skip);
     assert((!showdown and miss) or !(ohko and immune));
@@ -926,11 +961,32 @@ fn doMove(
             try log.immune(.{ foe_ident, .OHKO });
         } else if (immune and !invulnerable and (!showdown or move.effect != .Binding)) {
             try log.immune(.{ foe_ident, .None });
+            if (!showdown) {
+                if (move.effect == .Binding) {
+                    // Rather obnoxiously, the cartridge sets the Binding volatile in canMove and
+                    // then simply clears it later on if the move happens to miss in moveHit.
+                    // However, moveHit can return true and we'll still end up in the outer miss
+                    // handling block because attacking into an immune Pokemon does zero damage
+                    // (considered missing)
+                    assert(zero);
+                    // Thus we still need to actually save the hit result (but not the crit roll).
+                    // Using .miss for this commit would accomplish what we want, but is somewhat
+                    // misleading as its entirely possible the move actually did hit (and the target
+                    // is now trapped) so we use the .binding value instead which is effectively
+                    // identical, just doesn't claim to know about the actual results of the hit
+                    // roll)
+                    try options.chance.commit(player, .binding);
+                } else {
+                    // The .glitch option allows for conditionally committing if we are in a
+                    // division-by-zero freeze alternative timeline scenario
+                    try options.chance.commit(player, .glitch);
+                }
+            }
         } else if (mist) {
             if (!foe.active.volatiles.Substitute) try log.activate(.{ foe_ident, .Mist });
             try log.fail(.{ foe_ident, .None });
         } else {
-            if (showdown or !zero) try options.chance.commit(player, .miss);
+            if (!showdown) try options.chance.commit(player, if (zero and !missed) .hit else .miss);
             try log.lastmiss(.{});
             try log.miss(.{battle.active(player)});
         }
@@ -945,17 +1001,15 @@ fn doMove(
             try buildRage(battle, player.foe(), options);
         } else if (showdown and move.effect == .Disable) {
             try buildRage(battle, player.foe(), options);
-        } else if (!showdown and immune and move.effect == .Binding) {
-            try options.chance.commit(player, .binding);
         }
         return null;
-    } else {
+    } else if (!showdown) {
         try options.chance.commit(player, .hit);
     }
 
     // On the cartridge MultiHit doesn't get set up until after damage has been applied for the
     // first time but its more convenient and efficient to set it up here (Pokémon Showdown sets
-    // it up above before damage calculation).
+    // it up above before damage calculation)
     if (!showdown and move.effect.isMulti()) {
         try Effects.multiHit(battle, player, move, options);
         hits = side.active.volatiles.attacks;
@@ -994,32 +1048,30 @@ fn doMove(
             try Effects.poison(battle, player, Move.get(.PoisonSting), options);
         }
         try log.hitcount(.{ battle.active(player.foe()), hit });
-    } else if (showdown) {
+    } else if (showdown and move.effect == .Binding) {
         // This should be handled much earlier but Pokémon Showdown does it here... ¯\_(ツ)_/¯
-        if (move.effect == .Binding) {
-            try Effects.binding(battle, player, rewrap, options);
-            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(), options);
-                }
-                return null;
+        try Effects.binding(battle, player, rewrap, options);
+        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(), options);
             }
+            return null;
         }
     }
 
     // Substitute being broken nullifies the move's effect completely so even
-    // if an effect was intended to "always happen" it will still get skipped.
+    // if an effect was intended to "always happen" it will still get skipped
     if (nullified) return null;
 
     // On the cartridge, "always happen" effect handlers are called in the applyDamage loop above,
     // but this is only done to setup the MultiHit looping in the first place. Moving the MultiHit
-    // setup before the loop means we can avoid having to waste time doing no-op handler searches.
+    // setup before the loop means we can avoid having to waste time doing no-op handler searches
     if (move.effect.alwaysHappens()) try alwaysHappens(battle, player, move, residual, options);
 
     if (foe.stored().hp == 0) return null;
@@ -1034,7 +1086,7 @@ fn doMove(
         // below). For Twineedle we change the data to that of one with PoisonChance1 given its
         // MultiHit behavior is complete after the loop above, though Pokémon Showdown handles the
         // Twineedle secondary effect in the MultiHit cleanup block above because it incorrectly
-        // puts the |-status| message before |-hitcount| instead of after.
+        // puts the |-status| message before |-hitcount| instead of after
         if (move.effect == .Twineedle) {
             if (!showdown) try Effects.poison(battle, player, Move.get(.PoisonSting), options);
         } else if (move.effect == .Disable) {
@@ -1058,7 +1110,9 @@ fn checkCriticalHit(battle: anytype, player: Player, move: Move.Data, options: a
     rate = if (side.active.volatiles.FocusEnergy) rate / 2 else @min(rate * 2, 255);
     rate = if (move.effect == .HighCritical) @min(rate * 4, 255) else rate / 2;
 
-    return Rolls.criticalHit(battle, player, @intCast(rate), options);
+    const spurious =
+        !showdown and ((move.bp == 0 and move.effect != .OHKO) or move.target == .Depends);
+    return Rolls.criticalHit(battle, player, @intCast(rate), spurious, options);
 }
 
 fn calcDamage(
@@ -1067,6 +1121,7 @@ fn calcDamage(
     target_player: Player,
     m: ?Move.Data,
     crit: bool,
+    options: anytype,
 ) bool {
     // Confusion (indicated when m == null) just needs a 40 BP physical move
     const cfz = m == null;
@@ -1078,28 +1133,8 @@ fn calcDamage(
 
     const special = move.type.special();
 
-    // zig fmt: off
-    var atk: u32 =
-        if (crit)
-            if (special) side.stored().stats.spc
-            else side.stored().stats.atk
-        else
-            if (special) side.active.stats.spc
-            else side.active.stats.atk;
-    var def: u32 =
-        if (crit)
-            if (special) target.stored().stats.spc
-            else target.stored().stats.def
-        else
-            // GLITCH: not capped to MAX_STAT_VALUE, can be 999 * 2 = 1998
-            if (special)
-                target.active.stats.spc *
-                    @as(u2, if (target.active.volatiles.LightScreen) 2 else 1)
-            // Pokémon Showdown doesn't apply the opponent's Reflect to confusion's self-hit
-            else
-                target.active.stats.def *
-                    @as(u2, if ((!showdown or !cfz) and target.active.volatiles.Reflect) 2 else 1);
-    // zig fmt: on
+    var atk = attack(side, crit, special);
+    var def = defense(target, crit, special, cfz);
 
     // Pokémon Showdown erroneously skips this for confusion's self-hit damage, but thankfully we
     // will not overflow because the hit is only 40 BP and unboosted (the highest legal unboosted
@@ -1107,7 +1142,7 @@ fn calcDamage(
     if ((!showdown or !cfz) and (atk > 255 or def > 255)) {
         atk = @max((atk / 4) & 255, 1);
         // GLITCH: not adjusted to be a min of 1 on cartridge (can lead to division-by-zero freeze)
-        def = @max((def / 4) & 255, if (showdown) 1 else 0);
+        def = @max((def / 4) & 255, if (pkmn.options.mod) 1 else 0);
     }
 
     const lvl: u32 = side.stored().level * @as(u2, if (crit) 2 else 1);
@@ -1124,11 +1159,41 @@ fn calcDamage(
     d = @min(997, d);
     d += 2;
 
+    // Whether or not a critical hit occurred can change whether a division-by-zero freeze is
+    // encountered so we need to make sure that in the event of a miss we commit the status of the
+    // crit roll. The alternative to doing this extra work is to *always* commit the crit roll but
+    // that results in counter intuitive probabilities in the common case
+    if (pkmn.options.chance and !pkmn.options.mod and move.effect != .Explode) {
+        atk = attack(side, !crit, special);
+        def = defense(target, !crit, special, false);
+        if ((atk > 255 or def > 255) and (def / 4) & 255 == 0) options.chance.glitch();
+    }
+
     battle.last_damage = @intCast(d);
 
     return true;
 }
 
+fn attack(side: *Side, crit: bool, special: bool) u32 {
+    return if (crit)
+        if (special) side.stored().stats.spc else side.stored().stats.atk
+    else if (special) side.active.stats.spc else side.active.stats.atk;
+}
+
+fn defense(target: *Side, crit: bool, special: bool, cfz: bool) u32 {
+    return if (crit)
+        if (special) target.stored().stats.spc else target.stored().stats.def
+    else
+    // GLITCH: not capped to MAX_STAT_VALUE, can be 999 * 2 = 1998
+    if (special)
+        target.active.stats.spc *
+            @as(u2, if (target.active.volatiles.LightScreen) 2 else 1)
+    else
+        // Pokémon Showdown doesn't apply the opponent's Reflect to confusion's self-hit
+        target.active.stats.def *
+            @as(u2, if ((!showdown or !cfz) and target.active.volatiles.Reflect) 2 else 1);
+}
+
 fn adjustDamage(battle: anytype, player: Player) u16 {
     const side = battle.side(player);
     const foe = battle.foe(player);
@@ -1173,7 +1238,6 @@ fn specialDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
     const foe = battle.foe(player);
 
     if (!try checkHit(battle, player, move, options)) return null;
-    try options.chance.commit(player, .hit);
 
     battle.last_damage = switch (side.last_selected_move) {
         .SuperFang => @max(foe.stored().hp / 2, 1),
@@ -1184,13 +1248,13 @@ fn specialDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
         .Psywave => power: {
             const max: u8 = @intCast(@as(u16, side.stored().level) * 3 / 2);
             // GLITCH: Psywave infinite glitch loop
-            if (!showdown and max <= 1) return Result.Error;
+            if (!pkmn.options.mod and max <= 1) return Result.Error;
             break :power try Rolls.psywave(battle, player, max, options);
         },
         else => unreachable,
     };
 
-    if (battle.last_damage == 0) return if (showdown) null else Result.Error;
+    if (battle.last_damage == 0) return if (pkmn.options.mod) null else Result.Error;
 
     const sub = showdown and foe.active.volatiles.Substitute;
     _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
@@ -1227,16 +1291,19 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
 
     if (!used or !selected) {
         // GLITCH: Counter desync (covered by Desync Clause Mod on Pokémon Showdown)
-        if (!showdown) return Result.Error;
+        if (!pkmn.options.mod) return Result.Error;
         try options.log.fail(.{ battle.active(player), .None });
         return null;
     }
 
-    battle.last_damage *|= 2;
+    // NOTE: llvm/llvm-project#58557
+    battle.last_damage = if (comptime builtin.target.cpu.arch.isWasm())
+        @max(battle.last_damage *% 2, std.math.maxInt(u16))
+    else
+        battle.last_damage *| 2;
 
-    // Pokémon Showdown calls checkHit before Counter
+    // Pokémon Showdown calls moveHit before Counter
     if (!showdown and !try checkHit(battle, player, move, options)) return null;
-    try options.chance.commit(player, .hit);
 
     const sub = showdown and foe.active.volatiles.Substitute;
     _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
@@ -1265,7 +1332,7 @@ fn applyDamage(
             subbed.active.volatiles.Substitute = false;
             // battle.last_damage is not updated with the amount of HP the Substitute had
             try options.log.end(.{ battle.active(sub_player), .Substitute });
-            options.calc.capped(target_player);
+            if (reason != .Confusion) options.calc.capped(sub_player);
             return true;
         } else {
             // Safe to truncate since less than subbed.volatiles.substitute which is a u8
@@ -1299,7 +1366,7 @@ fn mirrorMove(
         try options.log.fail(.{ battle.active(player), .None });
         return null;
     } else if (!showdown or foe.last_used_move != .Struggle) {
-        incrementPP(side, mslot);
+        incrementPP(side, player, mslot, options);
     }
 
     if (!try canMove(battle, player, mslot, auto, false, .MirrorMove, residual, options)) {
@@ -1320,7 +1387,7 @@ fn metronome(
     var side = battle.side(player);
 
     side.last_selected_move = try Rolls.metronome(battle, player, options);
-    incrementPP(side, mslot);
+    incrementPP(side, player, mslot, options);
 
     if (!try canMove(battle, player, mslot, auto, false, .Metronome, residual, options)) {
         return null;
@@ -1332,7 +1399,10 @@ fn checkHit(battle: anytype, player: Player, move: Move.Data, options: anytype)
     var immune = false;
     var mist = false;
 
-    if (moveHit(battle, player, move, &immune, &mist, options)) return true;
+    if (try moveHit(battle, player, move, &immune, &mist, options)) {
+        if (!showdown) try options.chance.commit(player, .hit);
+        return true;
+    }
 
     assert(!immune);
     if (mist) {
@@ -1341,11 +1411,11 @@ fn checkHit(battle: anytype, player: Player, move: Move.Data, options: anytype)
         try options.log.activate(.{ foe_ident, .Mist });
         try options.log.fail(.{ foe_ident, .None });
     } else {
-        try options.chance.commit(player, .miss);
         try options.log.lastmiss(.{});
         try options.log.miss(.{battle.active(player)});
     }
 
+    if (!showdown) try options.chance.commit(player, .miss);
     return false;
 }
 
@@ -1356,7 +1426,7 @@ fn moveHit(
     immune: *bool,
     mist: *bool,
     options: anytype,
-) bool {
+) !bool {
     var side = battle.side(player);
     const foe = battle.foe(player);
 
@@ -1407,7 +1477,7 @@ fn moveHit(
         if (overwrite) side.active.volatiles.state = accuracy;
 
         // GLITCH: max accuracy is 255 so 1/256 chance of miss
-        break :miss !Rolls.hit(battle, player, @intCast(accuracy), options);
+        break :miss !try Rolls.hit(battle, player, @intCast(accuracy), options);
     };
 
     // Pokémon Showdown reports miss instead of fail for moves blocked by Mist that 1/256 miss
@@ -1418,13 +1488,17 @@ fn moveHit(
 
     if (!miss) return true;
     if (!showdown or !foe.active.volatiles.Invulnerable) battle.last_damage = 0;
+
     side.active.volatiles.Binding = false;
+    options.chance.observe(.binding, player, .None);
+
     return false;
 }
 
 fn checkFaint(
     battle: anytype,
     player: Player,
+    cap: bool,
     options: anytype,
 ) @TypeOf(options.log).Error!?Result {
     const side = battle.side(player);
@@ -1437,8 +1511,8 @@ fn checkFaint(
     const foe_out = foe_fainted and findFirstAlive(foe) == 0;
     const more = player_out or foe_out;
 
-    if (try faint(battle, player, !(more or foe_fainted), options)) |r| return r;
-    if (foe_fainted) if (try faint(battle, player.foe(), !more, options)) |r| return r;
+    if (try faint(battle, player, !(more or foe_fainted), cap, options)) |r| return r;
+    if (foe_fainted) if (try faint(battle, player.foe(), !more, false, options)) |r| return r;
 
     assert(!side.active.volatiles.MultiHit);
     assert(!foe.active.volatiles.MultiHit);
@@ -1459,7 +1533,7 @@ fn checkFaint(
     return .{ .p1 = foe_choice, .p2 = .Switch };
 }
 
-fn faint(battle: anytype, player: Player, done: bool, options: anytype) !?Result {
+fn faint(battle: anytype, player: Player, done: bool, cap: bool, options: anytype) !?Result {
     var side = battle.side(player);
     var foe = battle.foe(player);
     assert(side.stored().hp == 0);
@@ -1468,7 +1542,7 @@ fn faint(battle: anytype, player: Player, done: bool, options: anytype) !?Result
     assert(!foe_volatiles.MultiHit);
     if (foe_volatiles.Bide) {
         assert(!foe_volatiles.Thrashing and !foe_volatiles.Rage);
-        foe_volatiles.state = if (showdown) 0 else foe_volatiles.state & 255;
+        foe_volatiles.state = if (pkmn.options.mod) 0 else foe_volatiles.state & 255;
         if (foe_volatiles.state != 0) return Result.Error;
     }
 
@@ -1493,7 +1567,9 @@ fn faint(battle: anytype, player: Player, done: bool, options: anytype) !?Result
     }
 
     try options.log.faint(.{ battle.active(player), done });
-    options.calc.capped(player);
+    // We can only safely set capped if the faint occured as the direct result of an opponent's
+    // move (as opposed to due to residual damage, recoil, Explosion, etc)
+    if (cap) options.calc.capped(player);
     return null;
 }
 
@@ -1557,12 +1633,12 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
 
     battle.turn += 1;
 
-    if (showdown and pkmn.options.ebc and checkEBC(battle)) {
+    if (pkmn.options.mod and pkmn.options.ebc and checkEBC(battle)) {
         try options.log.tie(.{});
         return Result.Tie;
     }
 
-    if (showdown and battle.turn >= 1000) {
+    if (pkmn.options.mod and battle.turn >= 1000) {
         try options.log.tie(.{});
         return Result.Tie;
     } else if (battle.turn >= 65535) {
@@ -1653,17 +1729,6 @@ fn buildRage(battle: anytype, who: Player, options: anytype) !void {
     }
 }
 
-fn handleThrashing(battle: anytype, active: *ActivePokemon, player: Player, options: anytype) 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, player, true, options);
-    return true;
-}
-
 fn onBegin(
     battle: anytype,
     player: Player,
@@ -1750,8 +1815,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.attackingDuration(battle, player, options);
+        options.chance.observe(.attacking, player, .started);
 
         try options.log.start(.{ battle.active(player), .Bide });
     }
@@ -1813,12 +1880,14 @@ pub const Effects = struct {
                 if (sub) return options.log.fail(.{ battle.active(player.foe()), .None });
                 if (!try checkHit(battle, player, move, options)) return;
             }
-            try options.chance.commit(player, .hit);
         }
 
         if (foe.active.volatiles.Confusion) return;
         foe.active.volatiles.Confusion = true;
-        foe.active.volatiles.confusion = Rolls.confusionDuration(battle, player, false, options);
+
+        foe.active.volatiles.confusion = Rolls.confusionDuration(battle, player, options);
+        options.chance.observe(.confusion, player.foe(), .started);
+        options.calc.confusion(player.foe());
 
         try options.log.start(.{ battle.active(player.foe()), .Confusion });
     }
@@ -1846,10 +1915,7 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
 
         // Pokémon Showdown handles hit/miss earlier in doMove
-        if (!showdown) {
-            if (!try checkHit(battle, player, move, options)) return null;
-            try options.chance.commit(player, .hit);
-        }
+        if (!showdown and !try checkHit(battle, player, move, options)) return null;
 
         if (volatiles.disable_move != 0) {
             try options.log.fail(.{ foe_ident, .None });
@@ -1867,18 +1933,18 @@ pub const Effects = struct {
 
         // Technically this is still considered simply a "miss" on the cartridge,
         // but diverging from Pokémon Showdown here would mostly just be pedantic
-        if (n == 0) {
+        if (n == 0 or (pkmn.options.mod and err)) {
             try options.log.fail(.{ foe_ident, .None });
             return null;
         } else if (err) {
             // GLITCH: Transform + Mirror Move / Metronome PP softlock
-            assert(!showdown);
             return Result.Error;
         }
 
         volatiles.disable_move =
             @intCast(try Rolls.moveSlot(battle, player, &foe.active.moves, n, options));
         volatiles.disable_duration = Rolls.disableDuration(battle, player, options);
+        options.chance.observe(.disable, player.foe(), .started);
 
         const id = foe.active.move(volatiles.disable_move).id;
         try options.log.start(.{ foe_ident, .Disable, id });
@@ -1949,7 +2015,7 @@ pub const Effects = struct {
         if (foe.active.types.includes(move.type)) return;
         if (!try Rolls.secondaryChance(battle, player, true, options)) return;
         // Freeze Clause Mod
-        if (showdown) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
+        if (pkmn.options.mod) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
 
         foe_stored.status = Status.init(.FRZ);
         // GLITCH: Hyper Beam recharging status is not cleared
@@ -1985,22 +2051,24 @@ pub const Effects = struct {
                 if (p != player and Status.any(s.stored().status)) {
                     try log.curestatus(.{ foe_ident, foe_stored.status, .Silent });
                     s.stored().status = 0;
+                    options.chance.observe(.sleep, p, .None);
                 } else if (showdown and s.stored().status == Status.TOX) {
                     s.stored().status = Status.init(.PSN);
                     try log.status(.{ battle.active(p), s.stored().status, .None });
                 }
-                try clearVolatiles(battle, p, p != player, options);
+                try clearVolatiles(battle, p, options);
             }
         } else {
             if (Status.any(foe_stored.status)) {
                 if (Status.is(foe_stored.status, .FRZ) or Status.is(foe_stored.status, .SLP)) {
                     foe.last_selected_move = .SKIP_TURN;
+                    options.chance.observe(.sleep, player.foe(), .None);
                 }
                 try log.curestatus(.{ foe_ident, foe_stored.status, .Silent });
                 foe_stored.status = 0;
             }
-            try clearVolatiles(battle, player, false, options);
-            try clearVolatiles(battle, player.foe(), true, options);
+            try clearVolatiles(battle, player, options);
+            try clearVolatiles(battle, player.foe(), options);
         }
     }
 
@@ -2051,7 +2119,6 @@ pub const Effects = struct {
             }
         }
 
-        try options.chance.commit(player, .hit);
         foe.active.volatiles.LeechSeed = true;
 
         try options.log.start(.{ battle.active(player.foe()), .LeechSeed });
@@ -2092,12 +2159,10 @@ pub const Effects = struct {
             if (!has_mimic) {
                 // Invulnerable foes or 1/256 miss can trigger |-miss| instead of |-fail|
                 if (!try checkHit(battle, player, move, options)) return;
-                try options.chance.commit(player, .hit);
                 return options.log.fail(.{ battle.active(player.foe()), .None });
             }
         }
         if (!try checkHit(battle, player, move, options)) return;
-        try options.chance.commit(player, .hit);
 
         const rslot = try Rolls.moveSlot(battle, player, &foe.active.moves, 0, options);
         side.active.move(oslot).id = foe.active.move(rslot).id;
@@ -2151,7 +2216,6 @@ pub const Effects = struct {
             if (immune) return log.immune(.{ foe_ident, .None });
             if (!try checkHit(battle, player, move, options)) return;
         }
-        try options.chance.commit(player, .hit);
 
         foe_stored.status = Status.init(.PAR);
         foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
@@ -2219,7 +2283,6 @@ pub const Effects = struct {
 
         if (move.effect == .Poison) {
             if (!showdown and !try checkHit(battle, player, move, options)) return;
-            try options.chance.commit(player, .hit);
         } else {
             if (!try Rolls.poisonChance(battle, player, move.effect == .PoisonChance1, options)) {
                 return;
@@ -2288,13 +2351,12 @@ pub const Effects = struct {
                     if (Status.is(foe_stored.status, .SLP)) Fail.Sleep else Fail.None,
                 });
             }
-            // If checkHit in doMove didn't return true Pokémon Showdown wouldn't be in here
+            // If moveHit in doMove didn't return true Pokémon Showdown wouldn't be in here
             if (!showdown and !try checkHit(battle, player, move, options)) return;
-            try options.chance.commit(player, .hit);
         }
 
         // Sleep Clause Mod
-        if (showdown) {
+        if (pkmn.options.mod) {
             for (foe.pokemon) |p| {
                 if (Status.is(p.status, .SLP) and !Status.is(p.status, .EXT)) return;
             }
@@ -2302,6 +2364,8 @@ pub const Effects = struct {
         foe.active.volatiles.Recharging = false;
 
         foe_stored.status = Status.slp(Rolls.sleepDuration(battle, player, options));
+        options.chance.observe(.sleep, player.foe(), .started);
+
         const last = battle.side(player).last_selected_move;
         try options.log.status(.{ foe_ident, foe_stored.status, .From, last });
     }
@@ -2343,9 +2407,7 @@ pub const Effects = struct {
         // Whirlwind/Roar should not roll to hit/reset damage but Pokémon Showdown does anyway
         if (showdown) {
             if (battle.side(player).last_selected_move == .Teleport) return;
-            if (try checkHit(battle, player, move, options)) {
-                try options.chance.commit(player, .hit);
-            }
+            _ = try checkHit(battle, player, move, options);
             battle.last_damage = 0;
         } else {
             try options.log.fail(.{ battle.active(player), .None });
@@ -2360,6 +2422,8 @@ pub const Effects = struct {
 
         volatiles.Thrashing = true;
         volatiles.attacks = Rolls.attackingDuration(battle, player, options);
+
+        options.chance.observe(.attacking, player, .started);
     }
 
     fn transform(battle: anytype, player: Player, options: anytype) !void {
@@ -2398,13 +2462,14 @@ pub const Effects = struct {
         if (side.active.volatiles.Binding) return;
         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)
+        // (Pokémon Showdown clears Recharging in onTryMove instead)
         if (!showdown) {
             foe.active.volatiles.Recharging = false;
         } else if (foe.stored().hp == 0) return if (!rewrap) battle.rng.advance(1);
 
         side.active.volatiles.attacks =
             try Rolls.distribution(battle, .Binding, player, options) - 1;
+        options.chance.observe(.binding, player, .started);
     }
 
     fn boost(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
@@ -2521,7 +2586,6 @@ pub const Effects = struct {
         } else {
             // checkHit already checks for Invulnerable
             if (!showdown and !try checkHit(battle, player, move, options)) return;
-            try options.chance.commit(player, .hit);
         }
 
         var stats = &foe.active.stats;
@@ -2635,22 +2699,22 @@ fn isForced(active: anytype) bool {
         active.volatiles.Thrashing or active.volatiles.Charging;
 }
 
-fn clearVolatiles(battle: anytype, who: Player, clear: bool, options: anytype) !void {
+fn clearVolatiles(battle: anytype, who: Player, options: anytype) !void {
     var log = options.log;
     var side = battle.side(who);
     var volatiles = &side.active.volatiles;
     const ident = battle.active(who);
 
-    options.chance.clearDurations(who, clear);
-
     if (volatiles.disable_move != 0) {
         volatiles.disable_move = 0;
         volatiles.disable_duration = 0;
+        options.chance.observe(.disable, who, .None);
         try log.end(.{ ident, .DisableSilent });
     }
     if (volatiles.Confusion) {
         // volatiles.confusion is left unchanged
         volatiles.Confusion = false;
+        options.chance.observe(.confusion, who, .None);
         try log.end(.{ ident, .ConfusionSilent });
     }
     if (volatiles.Mist) {
@@ -2685,6 +2749,19 @@ fn clearVolatiles(battle: anytype, who: Player, clear: bool, options: anytype) !
     }
 }
 
+fn decrement(
+    comptime field: chance.Action.Field,
+    player: Player,
+    options: anytype,
+    n: anytype,
+) @TypeOf(n) {
+    return if (options.calc.overridden(player, field)) |obs| switch (obs) {
+        .started, .ended => 0,
+        .continuing => if (n > 1) n - 1 else n,
+        else => unreachable,
+    } else n - 1;
+}
+
 pub const Rolls = struct {
     fn speedTie(battle: anytype, options: anytype) !bool {
         const p1 = if (options.calc.overridden(.P1, .speed_tie)) |player|
@@ -2700,7 +2777,13 @@ pub const Rolls = struct {
         return p1;
     }
 
-    fn criticalHit(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
+    fn criticalHit(
+        battle: anytype,
+        player: Player,
+        rate: u8,
+        spurious: bool,
+        options: anytype,
+    ) !bool {
         const crit = if (options.calc.overridden(player, .critical_hit)) |val|
             val == .true
         else if (@hasDecl(@TypeOf(battle.rng), "criticalHit"))
@@ -2710,7 +2793,7 @@ pub const Rolls = struct {
         else
             std.math.rotl(u8, battle.rng.next(), 3) < rate;
 
-        try options.chance.criticalHit(player, crit, rate);
+        if (!spurious) try options.chance.criticalHit(player, crit, rate);
         return crit;
     }
 
@@ -2732,17 +2815,19 @@ pub const Rolls = struct {
         return roll;
     }
 
-    fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) bool {
+    const uN = if (pkmn.options.miss) u8 else u9;
+    fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) !bool {
+        const acc: uN = if (pkmn.options.miss) accuracy else @as(uN, accuracy) + 1;
         const ok = if (options.calc.overridden(player, .hit)) |val|
             val == .true
         else if (@hasDecl(@TypeOf(battle.rng), "hit"))
-            battle.rng.hit(player, accuracy)
+            battle.rng.hit(player, acc)
         else if (showdown)
-            battle.rng.chance(u8, accuracy, 256)
+            battle.rng.chance(uN, acc, 256)
         else
-            battle.rng.next() < accuracy;
+            battle.rng.next() < acc;
 
-        options.chance.hit(ok, accuracy);
+        try options.chance.hit(player, ok, acc);
         return ok;
     }
 
@@ -2874,9 +2959,10 @@ pub const Rolls = struct {
     }
 
     fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "sleepDuration"))
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 1 and val <= 7) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "sleepDuration"))
             battle.rng.sleepDuration(player)
         else if (showdown)
             battle.rng.range(u3, 1, 8)
@@ -2888,14 +2974,15 @@ pub const Rolls = struct {
         };
 
         assert(duration >= 1 and duration <= 7);
-        options.chance.duration(.sleep, player, player.foe(), duration);
+        options.chance.duration(player, duration);
         return duration;
     }
 
     fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
-        const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
-            val
-        else if (@hasDecl(@TypeOf(battle.rng), "disableDuration"))
+        const duration: u4 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 1 and val <= 8) val else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "disableDuration"))
             battle.rng.disableDuration(player)
         else if (showdown)
             battle.rng.range(u4, 1, 9)
@@ -2903,29 +2990,31 @@ pub const Rolls = struct {
             @intCast((battle.rng.next() & 7) + 1);
 
         assert(duration >= 1 and duration <= 8);
-        options.chance.duration(.disable, player, player.foe(), duration);
+        options.chance.duration(player, duration);
         return duration;
     }
 
-    fn confusionDuration(battle: anytype, player: Player, self: bool, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "confusionDuration"))
-            battle.rng.confusionDuration(player, self)
+    fn confusionDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 2 and val <= 5) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "confusionDuration"))
+            battle.rng.confusionDuration(player)
         else if (showdown)
             battle.rng.range(u3, 2, 6)
         else
             @intCast((battle.rng.next() & 3) + 2);
 
         assert(duration >= 2 and duration <= 5);
-        options.chance.duration(.confusion, player, if (self) player else player.foe(), duration);
+        options.chance.duration(player, duration);
         return duration;
     }
 
     fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "attackingDuration"))
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 2 and val <= 3) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "attackingDuration"))
             battle.rng.attackingDuration(player)
         else if (showdown)
             battle.rng.range(u3, 2, 4)
@@ -2933,7 +3022,7 @@ pub const Rolls = struct {
             @intCast((battle.rng.next() & 1) + 2);
 
         assert(duration >= 2 and duration <= 3);
-        options.chance.duration(.attacking, player, player, duration);
+        options.chance.duration(player, duration);
         return duration;
     }
 
@@ -2946,9 +3035,10 @@ pub const Rolls = struct {
         options: anytype,
     ) !u3 {
         const roll = if (effect == .Binding) .duration else .multi_hit;
-        const n: u3 = if (options.calc.overridden(player, roll)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "distribution"))
+        const n: u3 = (if (options.calc.overridden(player, roll)) |val|
+            if (val >= 2 and val <= 5) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "distribution"))
             battle.rng.distribution(player)
         else if (showdown)
             DISTRIBUTION[battle.rng.range(u3, 0, DISTRIBUTION.len)]
@@ -2959,7 +3049,7 @@ pub const Rolls = struct {
 
         assert(n >= 2 and n <= 5);
         if (effect == .Binding) {
-            options.chance.duration(.binding, player, player, n);
+            options.chance.duration(player, n);
         } else {
             try options.chance.multiHit(player, n);
         }
@@ -2974,15 +3064,13 @@ pub const Rolls = struct {
         options: anytype,
     ) !u4 {
         // TODO: consider throwing error instead of rerolling?
-        const overridden = if (options.calc.overridden(player, .move_slot)) |val|
+        const slot: u4 = (if (options.calc.overridden(player, .move_slot)) |val|
             if (moves[val - 1].id != .None and (check_pp == 0 or moves[val - 1].pp > 0))
                 val
             else
                 null
         else
-            null;
-
-        const slot: u4 = overridden orelse if (@hasDecl(@TypeOf(battle.rng), "moveSlot"))
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "moveSlot"))
             battle.rng.moveSlot(player, moves, check_pp)
         else slot: {
             if (showdown) {
@@ -3068,7 +3156,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             const stored = side.stored();
 
             // While players are not given any input options on the cartridge in these cases,
-            // Pokémon Showdown instead produces a list with a single move that must be chosen.
+            // Pokémon Showdown instead produces a list with a single move that must be chosen
             //
             // Given that no input is allowed on the cartridge 'Pass' seems like it would be logical
             // here when not in compatibility mode, but the engine needs to be able to differentiate
@@ -3076,7 +3164,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             // passing due to being forced into using a move. Instead of introducing another option
             // we simply repurpose Move with no move slot, even though pedantically this is not
             // strictly correct as the player would not have been presented the option to move or
-            // switch at all.
+            // switch at all
             if (isForced(active)) {
                 out[n] = .{ .type = .Move, .data = @intFromBool(showdown) };
                 n += 1;
@@ -3095,7 +3183,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             // On the cartridge, all of these happen after "FIGHT" (indicating you are not
             // switching) but before you are allowed to select a move. Pokémon Showdown instead
             // either disables all other moves in the case of limited or requires you to select a
-            // move normally if sleeping/frozen/bound.
+            // move normally if sleeping/frozen/bound
             if (!showdown and (limited or foe.active.volatiles.Binding or
                 Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP)))
             {
@@ -3108,7 +3196,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             // Pokémon Showdown handles Bide and Binding moves by checking if the move in question
             // is present in the Pokémon's moveset (which means moves called via Metronome / Mirror
             // Move will not result in forcing the subsequent use unless the user also had the
-            // proc-ed move in their moveset) and disabling all other moves.
+            // proc-ed move in their moveset) and disabling all other moves
             if (limited) {
                 assert(showdown);
                 assert(side.last_selected_move != .None);
@@ -3140,7 +3228,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             // Struggle (Pokémon Showdown would use 'move 1' here)
             if (n == before) {
                 // GLITCH: Transform + Mirror Move / Metronome PP softlock
-                if (!showdown) {
+                if (!pkmn.options.mod) {
                     while (slot <= 4) : (slot += 1) {
                         if (active.moves[slot - 1].pp != 0) return n;
                     }