@pkmn/engine 0.1.0-dev.8b83af6b → 0.1.0-dev.900756a9

package/src/lib/gen1/mechanics.zig

@@ -1,8 +1,9 @@
 const std = @import("std");
 
+const pkmn = @import("../pkmn.zig");
+
 const common = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
-const options = @import("../common/options.zig");
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
 
@@ -12,13 +13,13 @@ 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 showdown = options.showdown;
-
 const Boost = protocol.Boost;
 const Damage = protocol.Damage;
 const Heal = protocol.Heal;
@@ -56,19 +57,15 @@ 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 {
+pub fn update(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Result {
     assert(c1.type != .Pass or c2.type != .Pass or battle.turn == 0);
-    if (battle.turn == 0) return start(battle, log);
+    if (battle.turn == 0) return start(battle, options);
 
     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;
+    if (selectMove(battle, .P1, c1, c2, &s1)) |r| return r;
+    if (selectMove(battle, .P2, c2, c1, &s2)) |r| return r;
 
     var p1 = battle.side(.P1);
     var p2 = battle.side(.P2);
@@ -76,19 +73,19 @@ pub fn update(battle: anytype, c1: Choice, c2: Choice, log: anytype) !Result {
     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 (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 turnOrder(battle, c1, c2, options) == .P1) {
+        if (try doTurn(battle, .P1, c1, r1, s1, .P2, c2, r2, s2, options)) |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, r2, s2, .P1, c1, r1, s1, options)) |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;
 
-    return endTurn(battle, log);
+    return endTurn(battle, options);
 }
 
-fn start(battle: anytype, log: anytype) !Result {
+fn start(battle: anytype, options: anytype) !Result {
     const p1 = battle.side(.P1);
     const p2 = battle.side(.P2);
 
@@ -100,10 +97,10 @@ fn start(battle: anytype, log: anytype) !Result {
     assert(!showdown or p2_slot == 1);
     if (p2_slot == 0) return Result.Win;
 
-    try switchIn(battle, .P1, p1_slot, true, log);
-    try switchIn(battle, .P2, p2_slot, true, log);
+    try switchIn(battle, .P1, p1_slot, true, options);
+    try switchIn(battle, .P2, p2_slot, true, options);
 
-    return endTurn(battle, log);
+    return endTurn(battle, options);
 }
 
 fn findFirstAlive(side: *const Side) u8 {
@@ -117,7 +114,6 @@ fn selectMove(
     choice: Choice,
     foe_choice: Choice,
     skip_turn: *bool,
-    from: *?Move,
 ) ?Result {
     if (choice.type == .Pass) return null;
 
@@ -134,7 +130,6 @@ fn selectMove(
         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);
@@ -144,7 +139,6 @@ fn selectMove(
     // 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);
@@ -165,9 +159,7 @@ fn selectMove(
         return null;
     }
     if (volatiles.Binding) {
-        from.* = side.last_used_move;
         if (showdown) {
-            if (foe_choice.type == .Switch) from.* = null;
             // Pokémon Showdown overwrites Mirror Move with whatever was selected - really this
             // should set side.last_selected_move = last.id to reuse Mirror Move and fail in order
             // to satisfy the conditions of the Desync Clause Mod. However, because Binding is still
@@ -179,11 +171,7 @@ fn selectMove(
             assert(choice.data == 0);
             // 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
-                else
-                    battle.last_moves.p2_index;
-                const last = side.active.move(slot);
+                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;
             }
@@ -207,16 +195,13 @@ fn selectMove(
     if (choice.data == 0) {
         const struggle = ok: {
             for (side.active.moves, 0..) |move, i| {
-                if (move.pp > 0 and volatiles.disabled_move != i + 1) break :ok false;
+                if (move.pp > 0 and volatiles.disable_move != i + 1) break :ok false;
             }
             break :ok true;
         };
-
         assert(struggle);
-        saveMove(battle, player, choice);
-    } else {
-        saveMove(battle, player, choice);
     }
+    saveMove(battle, player, choice);
 
     return null;
 }
@@ -229,23 +214,19 @@ fn saveMove(battle: anytype, player: Player, choice: ?Choice) void {
         if (c.data == 0) {
             side.last_selected_move = .Struggle;
         } else {
-            assert(showdown or side.active.volatiles.disabled_move != c.data);
+            assert(showdown or side.active.volatiles.disable_move != c.data);
             const move = side.active.move(c.data);
             // You cannot *select* a move with 0 PP (except on Pokémon Showdown where that is
             // sometimes required...), but a 0 PP move can be used automatically
             assert(showdown or move.pp != 0);
 
             side.last_selected_move = move.id;
-            if (player == .P1) {
-                battle.last_moves.p1_index = @intCast(c.data);
-            } else {
-                battle.last_moves.p2_index = @intCast(c.data);
-            }
+            battle.lastMove(player).index = @intCast(c.data);
         }
     }
 }
 
-fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, log: anytype) !void {
+fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, options: anytype) !void {
     var side = battle.side(player);
     var foe = battle.foe(player);
     var active = &side.active;
@@ -258,11 +239,7 @@ fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, log: anyty
     side.order[0] = side.order[slot - 1];
     side.order[slot - 1] = out;
 
-    if (player == .P1) {
-        battle.last_moves.p1_index = 1;
-    } else {
-        battle.last_moves.p2_index = 1;
-    }
+    battle.lastMove(player).index = 1;
 
     side.last_used_move = .None;
     foe.last_used_move = .None;
@@ -278,17 +255,18 @@ fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, log: anyty
 
     foe.active.volatiles.Binding = false;
 
-    try log.switched(battle.active(player), incoming);
+    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);
         // Technically, Pokémon Showdown adds these after *both* Pokémon have switched, but we'd
         // rather not clutter up turnOrder just for this (incorrect) log message
-        try log.status(battle.active(player), incoming.status, .Silent);
+        try options.log.status(battle.active(player), incoming.status, .Silent);
     }
 }
 
-fn turnOrder(battle: anytype, c1: Choice, c2: Choice) Player {
+fn turnOrder(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Player {
     assert(c1.type != .Pass or c2.type != .Pass);
 
     if (c1.type == .Pass) return .P2;
@@ -322,7 +300,7 @@ fn turnOrder(battle: anytype, c1: Choice, c2: Choice) Player {
             battle.rng.advance(1);
         }
 
-        const p1 = Rolls.speedTie(battle);
+        const p1 = try Rolls.speedTie(battle, options);
         if (!showdown) return if (p1) .P1 else .P2;
 
         // Pokémon Showdown's "lockedmove" volatile's onBeforeTurn uses BattleQueue#changeAction,
@@ -347,13 +325,11 @@ fn doTurn(
     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,
+    options: anytype,
 ) !?Result {
     assert(player_choice.type != .Pass);
 
@@ -365,36 +341,37 @@ fn doTurn(
         player_choice,
         player_rewrap,
         player_skip,
-        player_from,
         &residual,
-        log,
+        options,
     )) |r| return r;
     if (!replace) {
         if (player_choice.type != .Switch) {
-            if (try checkFaint(battle, foe_player, log)) |r| return r;
+            if (try checkFaint(battle, foe_player, options)) |r| return r;
         }
-        if (residual) try handleResidual(battle, player, log);
-        if (try checkFaint(battle, player, log)) |r| return r;
+        if (residual) try handleResidual(battle, player, options);
+        if (try checkFaint(battle, player, options)) |r| return r;
     } else if (foe_choice.type == .Pass) return null;
 
+    options.chance.clearPending();
+
     residual = true;
     replace = battle.side(foe_player).stored().hp == 0;
-    if (try executeMove(
+    const calc = pkmn.options.calc and foe_choice.type == .Pass;
+    if (if (calc) null else try executeMove(
         battle,
         foe_player,
         foe_choice,
         foe_rewrap,
         foe_skip,
-        foe_from,
         &residual,
-        log,
+        options,
     )) |r| return r;
     if (!replace) {
-        if (foe_choice.type != .Switch) {
-            if (try checkFaint(battle, player, log)) |r| return r;
+        if (!calc and foe_choice.type != .Switch) {
+            if (try checkFaint(battle, player, options)) |r| return r;
         }
-        if (residual) try handleResidual(battle, foe_player, log);
-        if (try checkFaint(battle, foe_player, log)) |r| return r;
+        if (residual) try handleResidual(battle, foe_player, options);
+        if (try checkFaint(battle, foe_player, options)) |r| return r;
     }
 
     // Flinch is bugged on Pokémon Showdown because it gets implemented with a duration which causes
@@ -413,14 +390,13 @@ fn executeMove(
     choice: Choice,
     rewrap: bool,
     skip: bool,
-    from: ?Move,
     residual: *bool,
-    log: anytype,
+    options: anytype,
 ) !?Result {
     var side = battle.side(player);
 
     if (choice.type == .Switch) {
-        try switchIn(battle, player, choice.data, false, log);
+        try switchIn(battle, player, choice.data, false, options);
         return null;
     }
 
@@ -430,7 +406,7 @@ fn executeMove(
     if (side.last_selected_move == .SKIP_TURN) {
         assert(!showdown);
         if (battle.foe(player).active.volatiles.Binding) {
-            try log.cant(battle.active(player), .Bound);
+            try options.log.cant(battle.active(player), .Bound);
         }
         return null;
     }
@@ -445,14 +421,13 @@ fn executeMove(
     if (mslot == 0 and side.last_selected_move != .None and side.last_selected_move != .Struggle) {
         // choice.data == 0 only happens with Struggle on Pokémon Showdown
         assert(!showdown);
-        mslot = @intCast(if (player == .P1)
-            battle.last_moves.p1_index
-        else
-            battle.last_moves.p2_index);
+        mslot = @intCast(battle.lastMove(player).index);
         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
-            from != null or Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP);
+        auto = 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.
@@ -469,15 +444,12 @@ fn executeMove(
     } else if (showdown and side.active.volatiles.Charging) {
         // Incorrect mslot with Pokémon Showdown choice semantics so we need to recover from index
         assert(mslot == 1);
-        mslot = @intCast(if (player == .P1)
-            battle.last_moves.p1_index
-        else
-            battle.last_moves.p2_index);
+        mslot = @intCast(battle.lastMove(player).index);
     }
 
     var skip_can = false;
     var skip_pp = false;
-    switch (try beforeMove(battle, player, skip, from, residual, log)) {
+    switch (try beforeMove(battle, player, skip, residual, options)) {
         .done => return null,
         .skip_can => skip_can = true,
         .skip_pp => skip_pp = true,
@@ -485,11 +457,11 @@ 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;
-    }
+    const can = skip_can or
+        try canMove(battle, player, mslot, auto, skip_pp, .None, residual, options);
+    if (!can) return null;
 
-    return doMove(battle, player, mslot, rewrap, auto, residual, log);
+    return doMove(battle, player, mslot, rewrap, auto, residual, options);
 }
 
 const BeforeMove = enum { done, skip_can, skip_pp, ok, err };
@@ -498,10 +470,10 @@ fn beforeMove(
     battle: anytype,
     player: Player,
     skip: bool,
-    from: ?Move,
     residual: *bool,
-    log: anytype,
+    options: anytype,
 ) !BeforeMove {
+    var log = options.log;
     var side = battle.side(player);
     const foe = battle.foe(player);
     var active = &side.active;
@@ -510,11 +482,21 @@ fn beforeMove(
     var volatiles = &active.volatiles;
 
     if (Status.is(stored.status, .SLP)) {
-        const status = stored.status;
+        const before = stored.status;
         // Even if the EXT bit is set this will still correctly modify the sleep duration
-        stored.status -= 1;
-        if (Status.duration(stored.status) == 0) {
-            try log.curestatus(ident, status, .Message);
+        if (options.calc.modify(player, .sleep)) |extend| {
+            if (!extend) stored.status = 0;
+        } else {
+            stored.status -= 1;
+        }
+
+        const duration = Status.duration(stored.status);
+        if (!Status.is(stored.status, .EXT)) {
+            try options.chance.sleep(player, duration);
+        }
+
+        if (duration == 0) {
+            try log.curestatus(ident, before, .Message);
             stored.status = 0; // clears EXT if present
         } else {
             try log.cant(ident, .Sleep);
@@ -548,15 +530,21 @@ fn beforeMove(
         return .done;
     }
 
-    if (volatiles.disabled_duration > 0) {
-        volatiles.disabled_duration -= 1;
-        if (volatiles.disabled_duration == 0) {
-            volatiles.disabled_move = 0;
+    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);
+
+        if (volatiles.disable_duration == 0) {
+            volatiles.disable_move = 0;
             try log.end(ident, .Disable);
         }
     }
     // Pokémon Showdown's disable condition has a single onBeforeMove handler
-    if (showdown and try disabled(side, ident, log)) return .done;
+    if (showdown and try disabled(side, ident, options)) 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
@@ -568,14 +556,20 @@ fn beforeMove(
     if (volatiles.Confusion) {
         assert(volatiles.confusion > 0);
 
-        volatiles.confusion -= 1;
+        if (options.calc.modify(player, .confusion)) |extend| {
+            if (!extend) volatiles.confusion = 0;
+        } else {
+            volatiles.confusion -= 1;
+        }
+        try options.chance.confusion(player, volatiles.confusion);
+
         if (volatiles.confusion == 0) {
             volatiles.Confusion = false;
             try log.end(ident, .Confusion);
         } else {
             try log.activate(ident, .Confusion);
 
-            if (Rolls.confused(battle)) {
+            if (try Rolls.confused(battle, player, options)) {
                 assert(!volatiles.MultiHit);
                 if (!volatiles.Rage) volatiles.state = 0;
                 volatiles.Bide = false;
@@ -585,6 +579,7 @@ fn beforeMove(
                 volatiles.Charging = false;
                 volatiles.Binding = false;
                 volatiles.Invulnerable = false;
+                options.chance.clearDurations(player, null);
                 {
                     // 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
@@ -604,7 +599,7 @@ fn beforeMove(
 
                 const uncapped = battle.last_damage;
                 // Skipping adjustDamage / randomizeDamage / checkHit
-                _ = try applyDamage(battle, player, target, .Confusion, log);
+                _ = try applyDamage(battle, player, target, .Confusion, options);
                 // Pokémon Showdown thinks that confusion damage is uncapped ¯\_(ツ)_/¯
                 if (showdown) battle.last_damage = uncapped;
 
@@ -613,14 +608,15 @@ fn beforeMove(
         }
     }
 
-    if (!showdown and try disabled(side, ident, log)) return .done;
+    if (!showdown and try disabled(side, ident, options)) return .done;
 
-    if (Status.is(stored.status, .PAR) and Rolls.paralyzed(battle)) {
+    if (Status.is(stored.status, .PAR) and try Rolls.paralyzed(battle, player, options)) {
         if (!volatiles.Rage) volatiles.state = 0;
         volatiles.Bide = false;
         volatiles.Thrashing = false;
         volatiles.Charging = false;
         volatiles.Binding = false;
+        options.chance.clearDurations(player, null);
         // GLITCH: Invulnerable is not cleared, resulting in permanent Fly/Dig invulnerability
         try log.cant(ident, .Paralysis);
         return .done;
@@ -640,7 +636,13 @@ fn beforeMove(
 
         assert(volatiles.attacks > 0);
 
-        volatiles.attacks -= 1;
+        if (options.calc.modify(player, .attacking)) |extend| {
+            if (!extend) volatiles.attacks = 0;
+        } else {
+            volatiles.attacks -= 1;
+        }
+        try options.chance.attacking(player, volatiles.attacks);
+
         if (volatiles.attacks != 0) {
             try log.activate(ident, .Bide);
             return .done;
@@ -658,15 +660,15 @@ fn beforeMove(
         }
 
         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);
+        _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
+        if (foe.stored().hp > 0 and !sub) try buildRage(battle, player.foe(), options);
 
         // 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);
+            try handleResidual(battle, player, options);
         }
 
         return .done;
@@ -674,17 +676,23 @@ fn beforeMove(
 
     if (volatiles.Thrashing) {
         assert(volatiles.attacks > 0);
-        assert(from != null);
-        volatiles.attacks -= 1;
-        if (!showdown and handleThrashing(battle, active)) {
+
+        if (options.calc.modify(player, .attacking)) |extend| {
+            if (!extend) volatiles.attacks = 0;
+        } else {
+            volatiles.attacks -= 1;
+        }
+        try options.chance.attacking(player, volatiles.attacks);
+
+        if (!showdown and handleThrashing(battle, active, player, options)) {
             try log.start(battle.active(player), .ConfusionSilent);
         }
-        try log.move(ident, side.last_selected_move, battle.active(player.foe()), from);
+        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)) {
+            if (handleThrashing(battle, active, player, options)) {
                 try log.start(battle.active(player), .ConfusionSilent);
             }
         }
@@ -693,18 +701,20 @@ fn beforeMove(
 
     if (volatiles.Binding) {
         assert(volatiles.attacks > 0);
-        volatiles.attacks -= 1;
-        try log.move(
-            battle.active(player),
-            side.last_selected_move,
-            battle.active(player.foe()),
-            side.last_selected_move,
-        );
+
+        if (options.calc.modify(player, .binding)) |extend| {
+            if (!extend) volatiles.attacks = 0;
+        } else {
+            volatiles.attacks -= 1;
+        }
+        try options.chance.binding(player, volatiles.attacks);
+
+        try log.move(battle.active(player), side.last_selected_move, battle.active(player.foe()));
         if (showdown or battle.last_damage != 0) {
             const sub = showdown and foe.active.volatiles.Substitute;
-            _ = try applyDamage(battle, player.foe(), player.foe(), .None, log);
+            _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
             if (battle.foe(player).stored().hp > 0 and !sub) {
-                try buildRage(battle, player.foe(), log);
+                try buildRage(battle, player.foe(), options);
             }
         }
         return .done;
@@ -719,53 +729,42 @@ fn canMove(
     mslot: u4,
     auto: bool,
     skip_pp: bool,
-    from: ?Move,
+    from: Move,
     residual: *bool,
-    log: anytype,
+    options: anytype,
 ) !bool {
     var side = battle.side(player);
     const player_ident = battle.active(player);
     const move = Move.get(side.last_selected_move);
 
-    const foe_last = battle.foe(player).last_used_move;
-    const special = from != null and (from.? == .Metronome and
-        (from.? == .MirrorMove and !(foe_last == .None or foe_last == .MirrorMove)));
-
     var skip = skip_pp;
     if (side.active.volatiles.Charging) {
         side.active.volatiles.Charging = false;
         side.active.volatiles.Invulnerable = false;
     } else if (move.effect == .Charge) {
-        try log.move(player_ident, side.last_selected_move, .{}, from);
+        try options.log.moveFrom(player_ident, side.last_selected_move, .{}, from);
         setCounterable(battle, player, side, move);
-        try Effects.charge(battle, player, log);
+        try Effects.charge(battle, player, options);
         return false;
     }
 
-    if (!showdown or !special) side.last_used_move = side.last_selected_move;
+    side.last_used_move = side.last_selected_move;
     if (!skip) decrementPP(side, mslot, auto);
 
     const target = if (move.target == .Self) player else player.foe();
-    // Pokémon Showdown's protocol for Rage and Binding moves should come with a [from], though we
-    // don't have space to be able to track it in all circumstances and thus usually try to infer it
-    // from side.last_used_move. However, this gets reset by the opponent switching or fainting,
-    // meaning sometimes we lose this information. from is still set because it not being null is
-    // relevant for control flow, but we don't have anything useful to put in the log. This is
-    // regrettable, but this information is more "nice to have" than required
-    const f = if (from != null and from.? == .None) null else from;
-    try log.move(player_ident, side.last_selected_move, battle.active(target), f);
+    try options.log.moveFrom(player_ident, side.last_selected_move, battle.active(target), from);
     setCounterable(battle, player, side, move);
 
     if (move.effect.onBegin()) {
-        try onBegin(battle, player, move, mslot, residual, log);
+        try onBegin(battle, player, move, mslot, residual, options);
         return false;
     }
 
     if (move.effect == .Thrashing) {
-        Effects.thrashing(battle, player);
+        Effects.thrashing(battle, player, options);
     } else if (!showdown and move.effect == .Binding) {
         // Pokémon Showdown handles this after hit/miss checks and damage calculation
-        Effects.binding(battle, player, false);
+        try Effects.binding(battle, player, false, options);
     }
 
     return true;
@@ -779,11 +778,7 @@ fn setCounterable(battle: anytype, player: Player, side: *Side, move: Move.Data)
     // 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 = @intFromBool(counterable);
-    } else {
-        battle.last_moves.p2_counterable = @intFromBool(counterable);
-    }
+    battle.lastMove(player).counterable = @intFromBool(counterable);
 }
 
 fn decrementPP(side: *Side, mslot: u4, auto: bool) void {
@@ -795,12 +790,14 @@ fn decrementPP(side: *Side, mslot: u4, auto: bool) void {
     assert(!volatiles.Rage and !volatiles.Thrashing and !volatiles.MultiHit);
     if (volatiles.Bide) return;
 
-    assert(active.move(mslot).pp > 0 or auto);
-    active.move(mslot).pp = @as(u6, @intCast(active.move(mslot).pp)) -% 1;
+    var move_slot = active.move(mslot);
+    assert(move_slot.pp > 0 or auto);
+    move_slot.pp = @as(u6, @intCast(move_slot.pp)) -% 1;
     if (volatiles.Transform) return;
 
-    assert(side.stored().move(mslot).pp > 0 or auto);
-    side.stored().move(mslot).pp = @as(u6, @intCast(side.stored().move(mslot).pp)) -% 1;
+    move_slot = side.stored().move(mslot);
+    assert(move_slot.pp > 0 or auto);
+    move_slot.pp = @as(u6, @intCast(move_slot.pp)) -% 1;
     assert(active.move(mslot).pp == side.stored().move(mslot).pp);
 }
 
@@ -824,8 +821,9 @@ fn doMove(
     rewrap: bool,
     auto: bool,
     residual: *bool,
-    log: anytype,
+    options: anytype,
 ) !?Result {
+    var log = options.log;
     var side = battle.side(player);
     const foe = battle.foe(player);
 
@@ -840,9 +838,12 @@ fn doMove(
     var hits: u4 = 1;
     var effectiveness = Effectiveness.neutral;
 
+    // Due to control flow shenanigans we need to clear last_damage for Pokémon Showdown
+    if (showdown and !counter) battle.last_damage = 0;
+
     // The cartridge handles set damage moves in applyDamage but we short circuit to simplify things
     if (move.effect == .SuperFang or move.effect == .SpecialDamage) {
-        return specialDamage(battle, player, move, log);
+        return specialDamage(battle, player, move, options);
     }
 
     // Pokémon Showdown runs invulnerability / immunity checks before checking accuracy - simply
@@ -856,7 +857,8 @@ fn doMove(
             battle.last_damage = 0;
             break :miss true;
         }
-        break :miss move.target != .Self and !moveHit(battle, player, move, &immune, &mist);
+        break :miss (move.target != .Self and
+            !moveHit(battle, player, move, &immune, &mist, options));
     };
     assert(!immune or miss or (showdown and move.effect == .Binding));
 
@@ -864,16 +866,16 @@ fn doMove(
     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);
+            try Effects.multiHit(battle, player, move, options);
             hits = side.active.volatiles.attacks;
             late = false;
         }
 
         // Cartridge rolls for crit even for moves that can't crit (Counter/Metronome/status/OHKO)
         const check = !showdown or (!counter and move.effect != .OHKO);
-        if (check) crit = checkCriticalHit(battle, player, move);
+        if (check) crit = try checkCriticalHit(battle, player, move, options);
 
-        if (counter) return counterDamage(battle, player, move, log);
+        if (counter) return counterDamage(battle, player, move, options);
 
         battle.last_damage = 0;
 
@@ -895,17 +897,15 @@ fn doMove(
                 effectiveness = adjustDamage(battle, player);
                 immune = effectiveness == 0;
             }
-            randomizeDamage(battle);
+            try randomizeDamage(battle, player, options);
         }
     }
 
-    // Due to control flow shenanigans we need to clear last_damage for Pokémon Showdown
-    if (showdown and skip) battle.last_damage = 0;
-
+    var zero = battle.last_damage == 0;
     miss = if (showdown or skip)
         miss
     else
-        (!moveHit(battle, player, move, &immune, &mist) or battle.last_damage == 0);
+        (!moveHit(battle, player, move, &immune, &mist, options) or zero);
 
     assert(showdown or miss or battle.last_damage > 0 or skip);
     assert((!showdown and miss) or !(ohko and immune));
@@ -913,11 +913,11 @@ fn doMove(
 
     if (!showdown or !miss) {
         if (move.effect == .MirrorMove) {
-            return mirrorMove(battle, player, mslot, rewrap, auto, residual, log);
+            return mirrorMove(battle, player, mslot, rewrap, auto, residual, options);
         } else if (move.effect == .Metronome) {
-            return metronome(battle, player, mslot, rewrap, auto, residual, log);
+            return metronome(battle, player, mslot, rewrap, auto, residual, options);
         } else if (move.effect.onEnd()) {
-            try onEnd(battle, player, move, log);
+            try onEnd(battle, player, move, options);
             return null;
         }
     }
@@ -936,6 +936,7 @@ fn doMove(
             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);
             try log.lastmiss();
             try log.miss(battle.active(player));
         }
@@ -943,22 +944,26 @@ fn doMove(
             // Recoil is supposed to be damage/8 but damage will always be 0 here
             assert(showdown or battle.last_damage == 0);
             battle.last_damage = 1;
-            _ = try applyDamage(battle, player, player.foe(), .None, log);
+            _ = try applyDamage(battle, player, player.foe(), .None, options);
             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);
+            try buildRage(battle, player.foe(), options);
         } else if (showdown and move.effect == .Disable) {
-            try buildRage(battle, player.foe(), log);
+            try buildRage(battle, player.foe(), options);
+        } else if (!showdown and immune and move.effect == .Binding) {
+            try options.chance.commit(player, .binding);
         }
         return null;
+    } else {
+        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).
     if (!showdown and move.effect.isMulti()) {
-        Effects.multiHit(battle, player, move);
+        try Effects.multiHit(battle, player, move, options);
         hits = side.active.volatiles.attacks;
     }
 
@@ -976,11 +981,13 @@ fn doMove(
                 try log.resisted(battle.active(player.foe()));
             }
         }
-        if (!skip) nullified = try applyDamage(battle, player.foe(), player.foe(), .None, log);
+        if (!skip) nullified = try applyDamage(battle, player.foe(), player.foe(), .None, options);
         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 (!late and (!sub or move.effect == .Explode)) {
+            try buildRage(battle, player.foe(), options);
+        }
         // If the substitute breaks during a multi-hit attack, the attack ends
         if (nullified) break;
     }
@@ -990,13 +997,13 @@ fn doMove(
         assert(nullified or foe.stored().hp == 0 or side.active.volatiles.attacks - hit == 0);
         side.active.volatiles.attacks = 0;
         if (showdown and move.effect == .Twineedle and !nullified and foe.stored().hp > 0) {
-            try Effects.poison(battle, player, Move.get(.PoisonSting), log);
+            try Effects.poison(battle, player, Move.get(.PoisonSting), options);
         }
         try log.hitcount(battle.active(player.foe()), hit);
     } 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);
+            try Effects.binding(battle, player, rewrap, options);
             if (immune) {
                 battle.last_damage = 0;
                 assert(foe.stored().hp > 0);
@@ -1005,7 +1012,7 @@ fn doMove(
                     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 buildRage(battle, player.foe(), options);
                 }
                 return null;
             }
@@ -1019,12 +1026,12 @@ fn doMove(
     // 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.
-    if (move.effect.alwaysHappens()) try alwaysHappens(battle, player, move, residual, log);
+    if (move.effect.alwaysHappens()) try alwaysHappens(battle, player, move, residual, options);
 
     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 (late and !sub and move.effect != .Disable) try buildRage(battle, player.foe(), options);
 
     if (!move.effect.isSpecial()) {
         // On the cartridge Rage is not considered to be "special" and thus gets executed for a
@@ -1035,29 +1042,29 @@ fn doMove(
         // Twineedle secondary effect in the MultiHit cleanup block above because it incorrectly
         // puts the |-status| message before |-hitcount| instead of after.
         if (move.effect == .Twineedle) {
-            if (!showdown) try Effects.poison(battle, player, Move.get(.PoisonSting), log);
+            if (!showdown) try Effects.poison(battle, player, Move.get(.PoisonSting), options);
         } else if (move.effect == .Disable) {
-            const result = try Effects.disable(battle, player, move, log);
-            if (showdown) try buildRage(battle, player.foe(), log);
+            const result = try Effects.disable(battle, player, move, options);
+            if (showdown) try buildRage(battle, player.foe(), options);
             return result;
         } else {
-            try moveEffect(battle, player, move, log);
+            try moveEffect(battle, player, move, options);
         }
     }
 
     return null;
 }
 
-fn checkCriticalHit(battle: anytype, player: Player, move: Move.Data) bool {
+fn checkCriticalHit(battle: anytype, player: Player, move: Move.Data, options: anytype) !bool {
     const side = battle.side(player);
 
     // Base speed is used for the critical hit calculation, even when Transform-ed
-    var chance = @as(u16, Species.chance(side.stored().species));
-    // GLITCH: Focus Energy reduces critical hit chance instead of increasing it
-    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;
+    var rate = @as(u16, Species.chance(side.stored().species));
+    // GLITCH: Focus Energy reduces critical hit rate instead of increasing it
+    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, chance);
+    return Rolls.criticalHit(battle, player, @intCast(rate), options);
 }
 
 fn calcDamage(
@@ -1159,17 +1166,20 @@ fn adjustDamage(battle: anytype, player: Player) u16 {
     return if (types.type1 == types.type2) eff1 * neutral else eff1 * eff2;
 }
 
-fn randomizeDamage(battle: anytype) void {
+fn randomizeDamage(battle: anytype, player: Player, options: anytype) !void {
     if (battle.last_damage <= 1) return;
-    const random = Rolls.damage(battle);
+    const random = try Rolls.damage(battle, player, options);
+    options.calc.base(player.foe(), battle.last_damage);
     battle.last_damage = @intCast(@as(u32, battle.last_damage) *% random / 255);
+    options.calc.final(player.foe(), battle.last_damage);
 }
 
-fn specialDamage(battle: anytype, player: Player, move: Move.Data, log: anytype) !?Result {
+fn specialDamage(battle: anytype, player: Player, move: Move.Data, options: anytype) !?Result {
     const side = battle.side(player);
     const foe = battle.foe(player);
 
-    if (!try checkHit(battle, player, move, log)) return null;
+    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),
@@ -1181,7 +1191,7 @@ fn specialDamage(battle: anytype, player: Player, move: Move.Data, log: anytype)
             const max: u8 = @intCast(@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);
+            break :power try Rolls.psywave(battle, player, max, options);
         },
         else => unreachable,
     };
@@ -1189,17 +1199,17 @@ fn specialDamage(battle: anytype, player: Player, move: Move.Data, log: anytype)
     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);
+    _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
+    if (battle.foe(player).stored().hp > 0 and !sub) try buildRage(battle, player.foe(), options);
 
     return null;
 }
 
-fn counterDamage(battle: anytype, player: Player, move: Move.Data, log: anytype) !?Result {
+fn counterDamage(battle: anytype, player: Player, move: Move.Data, options: anytype) !?Result {
     const foe = battle.foe(player);
 
     if (battle.last_damage == 0) {
-        try log.fail(battle.active(player), .None);
+        try options.log.fail(battle.active(player), .None);
         return null;
     }
 
@@ -1210,36 +1220,33 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, log: anytype)
     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 = battle.lastMove(player.foe()).counterable != 0;
     const selected = foe_last_selected_move.bp > 0 and
         foe.last_selected_move != .Counter and
         (foe_last_selected_move.type == .Normal or
         foe_last_selected_move.type == .Fighting);
 
     if (!used and !selected) {
-        try log.fail(battle.active(player), .None);
+        try options.log.fail(battle.active(player), .None);
         return null;
     }
 
     if (!used or !selected) {
         // GLITCH: Counter desync (covered by Desync Clause Mod on Pokémon Showdown)
         if (!showdown) return Result.Error;
-        try log.fail(battle.active(player), .None);
+        try options.log.fail(battle.active(player), .None);
         return null;
     }
 
     battle.last_damage *|= 2;
 
     // Pokémon Showdown calls checkHit before Counter
-    if (!showdown and !try checkHit(battle, player, move, log)) return null;
+    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, log);
-    if (battle.foe(player).stored().hp > 0 and !sub) try buildRage(battle, player.foe(), log);
+    _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
+    if (battle.foe(player).stored().hp > 0 and !sub) try buildRage(battle, player.foe(), options);
     return null;
 }
 
@@ -1248,7 +1255,7 @@ fn applyDamage(
     target_player: Player,
     sub_player: Player,
     reason: Damage,
-    log: anytype,
+    options: anytype,
 ) !bool {
     assert(showdown or battle.last_damage != 0);
 
@@ -1263,19 +1270,20 @@ fn applyDamage(
             subbed.active.volatiles.substitute = 0;
             subbed.active.volatiles.Substitute = false;
             // battle.last_damage is not updated with the amount of HP the Substitute had
-            try log.end(battle.active(sub_player), .Substitute);
+            try options.log.end(battle.active(sub_player), .Substitute);
+            options.calc.capped(target_player);
             return true;
         } else {
             // Safe to truncate since less than subbed.volatiles.substitute which is a u8
             subbed.active.volatiles.substitute -= @intCast(battle.last_damage);
-            try log.activate(battle.active(sub_player), .Substitute);
+            try options.log.activate(battle.active(sub_player), .Substitute);
             return false;
         }
     }
 
     if (battle.last_damage > target.stored().hp) battle.last_damage = target.stored().hp;
     target.stored().hp -= battle.last_damage;
-    try log.damage(battle.active(target_player), target.stored(), reason);
+    try options.log.damage(battle.active(target_player), target.stored(), reason);
     return false;
 }
 
@@ -1286,22 +1294,24 @@ fn mirrorMove(
     rewrap: bool,
     auto: bool,
     residual: *bool,
-    log: anytype,
-) !?Result {
+    options: anytype,
+) anyerror!?Result {
     var side = battle.side(player);
     const foe = battle.foe(player);
 
     side.last_selected_move = foe.last_used_move;
 
     if (foe.last_used_move == .None or foe.last_used_move == .MirrorMove) {
-        try log.fail(battle.active(player), .None);
+        try options.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);
+    if (!try canMove(battle, player, mslot, auto, false, .MirrorMove, residual, options)) {
+        return null;
+    }
+    return doMove(battle, player, mslot, rewrap, auto, residual, options);
 }
 
 fn metronome(
@@ -1311,35 +1321,48 @@ fn metronome(
     rewrap: bool,
     auto: bool,
     residual: *bool,
-    log: anytype,
-) !?Result {
+    options: anytype,
+) anyerror!?Result {
     var side = battle.side(player);
 
-    side.last_selected_move = Rolls.metronome(battle);
+    side.last_selected_move = try Rolls.metronome(battle, player, options);
     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, residual, options)) {
+        return null;
+    }
+    return doMove(battle, player, mslot, rewrap, auto, residual, options);
 }
 
-fn checkHit(battle: anytype, player: Player, move: Move.Data, log: anytype) !bool {
+fn checkHit(battle: anytype, player: Player, move: Move.Data, options: anytype) !bool {
     var immune = false;
     var mist = false;
-    if (moveHit(battle, player, move, &immune, &mist)) return true;
+
+    if (moveHit(battle, player, move, &immune, &mist, options)) return true;
+
     assert(!immune);
     if (mist) {
         assert(!showdown);
         const foe_ident = battle.active(player.foe());
-        try log.activate(foe_ident, .Mist);
-        try log.fail(foe_ident, .None);
+        try options.log.activate(foe_ident, .Mist);
+        try options.log.fail(foe_ident, .None);
     } else {
-        try log.lastmiss();
-        try log.miss(battle.active(player));
+        try options.chance.commit(player, .miss);
+        try options.log.lastmiss();
+        try options.log.miss(battle.active(player));
     }
+
     return false;
 }
 
-fn moveHit(battle: anytype, player: Player, move: Move.Data, immune: *bool, mist: *bool) bool {
+fn moveHit(
+    battle: anytype,
+    player: Player,
+    move: Move.Data,
+    immune: *bool,
+    mist: *bool,
+    options: anytype,
+) bool {
     var side = battle.side(player);
     const foe = battle.foe(player);
 
@@ -1378,10 +1401,10 @@ fn moveHit(battle: anytype, player: Player, move: Move.Data, immune: *bool, mist
         const overwritten = overwrite and state > 0;
         assert(!overwritten or (0 < state and state <= 255 and !side.active.volatiles.Bide));
 
-        var accuracy = if (overwritten) state else @as(u16, Gen12.percent(move.accuracy));
-        var boost = BOOSTS[@intCast(@as(i8, side.active.boosts.accuracy) + 6)];
+        var accuracy = if (overwritten) state else @as(u16, move.accuracy);
+        var boost = BOOSTS[@as(u4, @intCast(@as(i8, side.active.boosts.accuracy) + 6))];
         accuracy = accuracy * boost[0] / boost[1];
-        boost = BOOSTS[@intCast(@as(i8, -foe.active.boosts.evasion) + 6)];
+        boost = BOOSTS[@as(u4, @intCast(@as(i8, -foe.active.boosts.evasion) + 6))];
         accuracy = accuracy * boost[0] / boost[1];
         accuracy = @min(255, @max(1, accuracy));
 
@@ -1390,7 +1413,7 @@ fn moveHit(battle: anytype, player: Player, move: Move.Data, immune: *bool, mist
         if (overwrite) side.active.volatiles.state = accuracy;
 
         // GLITCH: max accuracy is 255 so 1/256 chance of miss
-        break :miss !Rolls.hit(battle, accuracy);
+        break :miss !Rolls.hit(battle, player, @intCast(accuracy), options);
     };
 
     // Pokémon Showdown reports miss instead of fail for moves blocked by Mist that 1/256 miss
@@ -1408,8 +1431,8 @@ fn moveHit(battle: anytype, player: Player, move: Move.Data, immune: *bool, mist
 fn checkFaint(
     battle: anytype,
     player: Player,
-    log: anytype,
-) @TypeOf(log).Error!?Result {
+    options: anytype,
+) @TypeOf(options.log).Error!?Result {
     const side = battle.side(player);
     if (side.stored().hp > 0) return null;
 
@@ -1417,33 +1440,32 @@ fn checkFaint(
     const foe_fainted = foe.stored().hp == 0;
 
     const player_out = findFirstAlive(side) == 0;
-    const foe_out = findFirstAlive(foe) == 0;
-    const tie = player_out and foe_out;
-    const more = tie or player_out or foe_out;
+    const foe_out = foe_fainted and findFirstAlive(foe) == 0;
+    const more = player_out or foe_out;
 
-    if (try faint(battle, player, log, !(more or foe_fainted))) |r| return r;
-    if (foe_fainted) if (try faint(battle, player.foe(), log, !more)) |r| return r;
+    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;
 
     assert(!side.active.volatiles.MultiHit);
     assert(!foe.active.volatiles.MultiHit);
 
-    if (tie) {
-        try log.tie();
+    if (player_out and foe_out) {
+        try options.log.tie();
         return Result.Tie;
     } else if (player_out) {
-        try log.win(player.foe());
+        try options.log.win(player.foe());
         return if (player == .P1) Result.Lose else Result.Win;
     } else if (foe_out) {
-        try log.win(player);
+        try options.log.win(player);
         return if (player == .P1) Result.Win else Result.Lose;
     }
 
     const foe_choice: Choice.Type = if (foe_fainted) .Switch else .Pass;
-    if (player == .P1) return Result{ .p1 = .Switch, .p2 = foe_choice };
-    return Result{ .p1 = foe_choice, .p2 = .Switch };
+    if (player == .P1) return .{ .p1 = .Switch, .p2 = foe_choice };
+    return .{ .p1 = foe_choice, .p2 = .Switch };
 }
 
-fn faint(battle: anytype, player: Player, log: anytype, done: bool) !?Result {
+fn faint(battle: anytype, player: Player, done: bool, options: anytype) !?Result {
     var side = battle.side(player);
     var foe = battle.foe(player);
     assert(side.stored().hp == 0);
@@ -1476,32 +1498,31 @@ fn faint(battle: anytype, player: Player, log: anytype, done: bool) !?Result {
             side.stored().stats.spe;
     }
 
-    try log.faint(battle.active(player), done);
+    try options.log.faint(battle.active(player), done);
+    options.calc.capped(player);
     return null;
 }
 
-fn handleResidual(battle: anytype, player: Player, log: anytype) !void {
+fn handleResidual(battle: anytype, player: Player, options: anytype) !void {
     var side = battle.side(player);
     var stored = side.stored();
     const ident = battle.active(player);
     var volatiles = &side.active.volatiles;
 
     const brn = Status.is(stored.status, .BRN);
-    if (brn or Status.is(stored.status, .PSN)) blk: {
+    if (brn or Status.is(stored.status, .PSN)) {
         var damage = @max(stored.stats.hp / 16, 1);
-
         if (volatiles.Toxic) {
             volatiles.toxic += 1;
             damage *= volatiles.toxic;
         }
+        damage = @min(damage, stored.hp);
 
-        const amount = @min(damage, stored.hp);
-        if (showdown and amount == 0) break :blk;
-
-        stored.hp -= amount;
-
-        // Pokémon Showdown uses damageOf here but its not relevant in Generation I
-        try log.damage(ident, stored, if (brn) Damage.Burn else Damage.Poison);
+        if (!showdown or damage > 0) {
+            stored.hp -= damage;
+            // Pokémon Showdown uses damageOf here but its not relevant in Generation I
+            try options.log.damage(ident, stored, if (brn) Damage.Burn else Damage.Poison);
+        }
     }
 
     if (volatiles.LeechSeed) {
@@ -1526,35 +1547,35 @@ fn handleResidual(battle: anytype, player: Player, log: anytype) !void {
         stored.hp -= amount;
 
         // As above, Pokémon Showdown uses damageOf but its not relevant
-        if (amount > 0) try log.damage(ident, stored, .LeechSeed);
+        if (amount > 0) try options.log.damage(ident, stored, .LeechSeed);
 
         const before = foe_stored.hp;
         // Uncapped damage is added back to the foe
         foe_stored.hp = @min(foe_stored.hp + damage, foe_stored.stats.hp);
         // Pokémon Showdown uses the less specific heal here instead of drain... because reasons?
-        if (foe_stored.hp > before) try log.heal(foe_ident, foe_stored, .Silent);
+        if (foe_stored.hp > before) try options.log.heal(.{ foe_ident, foe_stored, Heal.Silent });
     }
 }
 
-fn endTurn(battle: anytype, log: anytype) @TypeOf(log).Error!Result {
+fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result {
     assert(!battle.side(.P1).active.volatiles.MultiHit);
     assert(!battle.side(.P2).active.volatiles.MultiHit);
 
     battle.turn += 1;
 
-    if (showdown and options.ebc and checkEBC(battle)) {
-        try log.tie();
+    if (showdown and pkmn.options.ebc and checkEBC(battle)) {
+        try options.log.tie();
         return Result.Tie;
     }
 
     if (showdown and battle.turn >= 1000) {
-        try log.tie();
+        try options.log.tie();
         return Result.Tie;
     } else if (battle.turn >= 65535) {
         return Result.Error;
     }
 
-    try log.turn(battle.turn);
+    try options.log.turn(battle.turn);
 
     return Result.Default;
 }
@@ -1613,10 +1634,10 @@ fn checkEBC(battle: anytype) bool {
     return false;
 }
 
-fn disabled(side: *Side, ident: ID, log: anytype) !bool {
-    if (side.active.volatiles.disabled_move != 0) {
+fn disabled(side: *Side, ident: ID, options: anytype) !bool {
+    if (side.active.volatiles.disable_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;
+        const m = side.active.moves[side.active.volatiles.disable_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
@@ -1624,127 +1645,127 @@ fn disabled(side: *Side, ident: ID, log: anytype) !bool {
             side.last_selected_move;
         if (m != .None and m == last) {
             side.active.volatiles.Charging = false;
-            try log.disabled(ident, last);
+            try options.log.disabled(ident, last);
             return true;
         }
     }
     return false;
 }
 
-inline fn buildRage(battle: anytype, who: Player, log: anytype) !void {
+fn buildRage(battle: anytype, who: Player, options: 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);
+        try Effects.boost(battle, who, Move.get(.Rage), options);
     }
 }
 
-fn handleThrashing(battle: anytype, active: *ActivePokemon) bool {
+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);
+    volatiles.confusion = Rolls.confusionDuration(battle, player, true, options);
     return true;
 }
 
-inline fn onBegin(
+fn onBegin(
     battle: anytype,
     player: Player,
     move: Move.Data,
     mslot: u8,
     residual: *bool,
-    log: anytype,
+    options: anytype,
 ) !void {
     assert(move.effect.onBegin());
     return switch (move.effect) {
-        .Confusion => Effects.confusion(battle, player, move, log),
-        .Conversion => Effects.conversion(battle, player, log),
-        .FocusEnergy => Effects.focusEnergy(battle, player, log),
-        .Haze => Effects.haze(battle, player, log),
-        .Heal => Effects.heal(battle, player, log),
-        .LeechSeed => Effects.leechSeed(battle, player, move, log),
-        .LightScreen => Effects.lightScreen(battle, player, log),
-        .Mimic => Effects.mimic(battle, player, move, mslot, log),
-        .Mist => Effects.mist(battle, player, log),
-        .Paralyze => Effects.paralyze(battle, player, move, log),
-        .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),
-        .SwitchAndTeleport => Effects.switchAndTeleport(battle, player, move, log),
-        .Transform => Effects.transform(battle, player, log),
+        .Confusion => Effects.confusion(battle, player, move, options),
+        .Conversion => Effects.conversion(battle, player, options),
+        .FocusEnergy => Effects.focusEnergy(battle, player, options),
+        .Haze => Effects.haze(battle, player, options),
+        .Heal => Effects.heal(battle, player, options),
+        .LeechSeed => Effects.leechSeed(battle, player, move, options),
+        .LightScreen => Effects.lightScreen(battle, player, options),
+        .Mimic => Effects.mimic(battle, player, move, mslot, options),
+        .Mist => Effects.mist(battle, player, options),
+        .Paralyze => Effects.paralyze(battle, player, move, options),
+        .Poison => Effects.poison(battle, player, move, options),
+        .Reflect => Effects.reflect(battle, player, options),
+        .Splash => Effects.splash(battle, player, options),
+        .Substitute => Effects.substitute(battle, player, residual, options),
+        .SwitchAndTeleport => Effects.switchAndTeleport(battle, player, move, options),
+        .Transform => Effects.transform(battle, player, options),
         else => unreachable,
     };
 }
 
-inline fn onEnd(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+fn onEnd(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
     assert(move.effect.onEnd());
     return switch (move.effect) {
-        .Bide => Effects.bide(battle, player, log),
+        .Bide => Effects.bide(battle, player, options),
         // zig fmt: off
         .AttackUp1, .AttackUp2, .DefenseUp1, .DefenseUp2,
         .EvasionUp1, .SpecialUp1, .SpecialUp2, .SpeedUp2 =>
-            Effects.boost(battle, player, move, log),
+            Effects.boost(battle, player, move, options),
         .AccuracyDown1, .AttackDown1, .DefenseDown1, .DefenseDown2, .SpeedDown1 =>
-            Effects.unboost(battle, player, move, log),
+            Effects.unboost(battle, player, move, options),
         // zig fmt: on
-        .Sleep => Effects.sleep(battle, player, move, log),
+        .Sleep => Effects.sleep(battle, player, move, options),
         else => unreachable,
     };
 }
 
-inline fn alwaysHappens(
+fn alwaysHappens(
     battle: anytype,
     player: Player,
     move: Move.Data,
     residual: *bool,
-    log: anytype,
+    options: anytype,
 ) !void {
     assert(move.effect.alwaysHappens());
     return switch (move.effect) {
-        .DrainHP, .DreamEater => Effects.drainHP(battle, player, log),
+        .DrainHP, .DreamEater => Effects.drainHP(battle, player, options),
         .Explode => Effects.explode(battle, player),
-        .PayDay => Effects.payDay(battle, player, log),
+        .PayDay => Effects.payDay(battle, player, options),
         .Rage => Effects.rage(battle, player),
-        .Recoil => Effects.recoil(battle, player, residual, log),
+        .Recoil => Effects.recoil(battle, player, residual, options),
         .JumpKick, .Binding => {},
         else => unreachable,
     };
 }
 
-inline fn moveEffect(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+fn moveEffect(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
     return switch (move.effect) {
-        .BurnChance1, .BurnChance2 => Effects.burnChance(battle, player, move, log),
-        .ConfusionChance => Effects.confusion(battle, player, move, log),
-        .FlinchChance1, .FlinchChance2 => Effects.flinchChance(battle, player, move),
-        .FreezeChance => Effects.freezeChance(battle, player, move, log),
-        .HyperBeam => Effects.hyperBeam(battle, player, log),
+        .BurnChance1, .BurnChance2 => Effects.burnChance(battle, player, move, options),
+        .ConfusionChance => Effects.confusion(battle, player, move, options),
+        .FlinchChance1, .FlinchChance2 => Effects.flinchChance(battle, player, move, options),
+        .FreezeChance => Effects.freezeChance(battle, player, move, options),
+        .HyperBeam => Effects.hyperBeam(battle, player, options),
         .MultiHit, .DoubleHit, .Twineedle => unreachable,
-        .ParalyzeChance1, .ParalyzeChance2 => Effects.paralyzeChance(battle, player, move, log),
-        .PoisonChance1, .PoisonChance2 => Effects.poison(battle, player, move, log),
+        .ParalyzeChance1, .ParalyzeChance2 => Effects.paralyzeChance(battle, player, move, options),
+        .PoisonChance1, .PoisonChance2 => Effects.poison(battle, player, move, options),
         // zig fmt: off
         .AttackDownChance, .DefenseDownChance, .SpecialDownChance, .SpeedDownChance =>
-            Effects.unboost(battle, player, move, log),
+            Effects.unboost(battle, player, move, options),
         // zig fmt: on
         else => {},
     };
 }
 
 pub const Effects = struct {
-    fn bide(battle: anytype, player: Player, log: anytype) !void {
+    fn bide(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
 
         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 = Rolls.attackingDuration(battle, player, options);
 
-        try log.start(battle.active(player), .Bide);
+        try options.log.start(battle.active(player), .Bide);
     }
 
-    fn burnChance(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+    fn burnChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
         var foe = battle.foe(player);
         var foe_stored = foe.stored();
 
@@ -1755,83 +1776,97 @@ pub const Effects = struct {
             // GLITCH: Freeze top move selection desync can occur if thawed Pokémon is slower
             if (Status.is(foe_stored.status, .FRZ)) {
                 assert(move.type == .Fire);
-                try log.curestatus(battle.active(player.foe()), foe_stored.status, .Message);
+                try options.log.curestatus(
+                    battle.active(player.foe()),
+                    foe_stored.status,
+                    .Message,
+                );
                 foe_stored.status = 0;
             }
             return;
         }
 
         if (foe.active.types.includes(move.type)) return;
-        if (!Rolls.secondaryChance(battle, move.effect == .BurnChance1)) return;
+        if (!try Rolls.secondaryChance(battle, player, move.effect == .BurnChance1, options)) {
+            return;
+        }
 
         foe_stored.status = Status.init(.BRN);
         foe.active.stats.atk = @max(foe.active.stats.atk / 2, 1);
 
-        try log.status(battle.active(player.foe()), foe_stored.status, .None);
+        try options.log.status(battle.active(player.foe()), foe_stored.status, .None);
     }
 
-    fn charge(battle: anytype, player: Player, log: anytype) !void {
+    fn charge(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
         var volatiles = &side.active.volatiles;
 
         volatiles.Charging = true;
         const move = side.last_selected_move;
         if (move == .Fly or move == .Dig) volatiles.Invulnerable = true;
-        try log.laststill();
-        try log.prepare(battle.active(player), move);
+        try options.log.laststill();
+        try options.log.prepare(battle.active(player), move);
     }
 
-    fn confusion(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+    fn confusion(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
         var foe = battle.foe(player);
         const sub = foe.active.volatiles.Substitute;
 
         if (move.effect == .ConfusionChance) {
-            if (!Rolls.confusionChance(battle)) return;
+            if (!try Rolls.confusionChance(battle, player, options)) return;
         } else {
             if (showdown) {
-                if (!try checkHit(battle, player, move, log)) {
+                if (!try checkHit(battle, player, move, options)) {
                     return;
                 } else if (sub) {
-                    return log.fail(battle.active(player.foe()), .None);
+                    return options.log.fail(battle.active(player.foe()), .None);
                 }
             } else {
                 if (sub) {
-                    return log.fail(battle.active(player.foe()), .None);
-                } else if (!try checkHit(battle, player, move, log)) {
+                    return options.log.fail(battle.active(player.foe()), .None);
+                } else 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);
+        foe.active.volatiles.confusion = Rolls.confusionDuration(battle, player, false, options);
 
-        try log.start(battle.active(player.foe()), .Confusion);
+        try options.log.start(battle.active(player.foe()), .Confusion);
     }
 
-    fn conversion(battle: anytype, player: Player, log: anytype) !void {
+    fn conversion(battle: anytype, player: Player, options: anytype) !void {
         const foe = battle.foe(player);
 
         if (foe.active.volatiles.Invulnerable) {
-            try log.lastmiss();
-            return log.miss(battle.active(player));
+            try options.log.lastmiss();
+            return options.log.miss(battle.active(player));
         }
 
         battle.side(player).active.types = foe.active.types;
-        return log.typechange(battle.active(player), foe.active.types, battle.active(player.foe()));
+        return options.log.typechange(
+            battle.active(player),
+            foe.active.types,
+            battle.active(player.foe()),
+        );
     }
 
-    fn disable(battle: anytype, player: Player, move: Move.Data, log: anytype) !?Result {
+    fn disable(battle: anytype, player: Player, move: Move.Data, options: anytype) !?Result {
         var foe = battle.foe(player);
         var volatiles = &foe.active.volatiles;
         const foe_ident = battle.active(player.foe());
 
         // Pokémon Showdown handles hit/miss earlier in doMove
-        if (!showdown and !try checkHit(battle, player, move, log)) return null;
+        if (!showdown) {
+            if (!try checkHit(battle, player, move, options)) return null;
+            try options.chance.commit(player, .hit);
+        }
 
-        if (volatiles.disabled_move != 0) {
-            try log.fail(foe_ident, .None);
+        if (volatiles.disable_move != 0) {
+            try options.log.fail(foe_ident, .None);
             return null;
         }
 
@@ -1847,7 +1882,7 @@ 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) {
-            try log.fail(foe_ident, .None);
+            try options.log.fail(foe_ident, .None);
             return null;
         } else if (err) {
             // GLITCH: Transform + Mirror Move / Metronome PP softlock
@@ -1855,16 +1890,17 @@ pub const Effects = struct {
             return Result.Error;
         }
 
-        volatiles.disabled_move = @intCast(Rolls.moveSlot(battle, &foe.active.moves, n));
-        volatiles.disabled_duration = Rolls.disableDuration(battle);
+        volatiles.disable_move =
+            @intCast(try Rolls.moveSlot(battle, player, &foe.active.moves, n, options));
+        volatiles.disable_duration = Rolls.disableDuration(battle, player, options);
 
-        try log.startEffect(foe_ident, .Disable, foe.active.move(volatiles.disabled_move).id);
+        const id = foe.active.move(volatiles.disable_move).id;
+        try options.log.startEffect(foe_ident, .Disable, id);
         return null;
     }
 
-    fn drainHP(battle: anytype, player: Player, log: anytype) !void {
-        var side = battle.side(player);
-        var stored = side.stored();
+    fn drainHP(battle: anytype, player: Player, options: anytype) !void {
+        var stored = battle.side(player).stored();
 
         if (battle.last_damage == 0) {
             assert(showdown);
@@ -1877,7 +1913,7 @@ pub const Effects = struct {
         if (stored.hp == stored.stats.hp) return;
         stored.hp = @min(stored.stats.hp, stored.hp + drain);
 
-        try log.drain(battle.active(player), stored, battle.active(player.foe()));
+        try options.log.drain(battle.active(player), stored, battle.active(player.foe()));
     }
 
     fn explode(battle: anytype, player: Player) !void {
@@ -1891,26 +1927,28 @@ pub const Effects = struct {
         side.active.volatiles.LeechSeed = false;
     }
 
-    fn flinchChance(battle: anytype, player: Player, move: Move.Data) void {
+    fn flinchChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
         var volatiles = &battle.foe(player).active.volatiles;
 
         if (volatiles.Substitute) return;
-        if (!Rolls.secondaryChance(battle, move.effect == .FlinchChance1)) return;
+        if (!try Rolls.secondaryChance(battle, player, move.effect == .FlinchChance1, options)) {
+            return;
+        }
 
         volatiles.Flinch = true;
         volatiles.Recharging = false;
     }
 
-    fn focusEnergy(battle: anytype, player: Player, log: anytype) !void {
+    fn focusEnergy(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
 
         if (side.active.volatiles.FocusEnergy) return;
         side.active.volatiles.FocusEnergy = true;
 
-        try log.start(battle.active(player), .FocusEnergy);
+        try options.log.start(battle.active(player), .FocusEnergy);
     }
 
-    fn freezeChance(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+    fn freezeChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
         var foe = battle.foe(player);
         var foe_stored = foe.stored();
         const foe_ident = battle.active(player.foe());
@@ -1922,17 +1960,18 @@ pub const Effects = struct {
         }
 
         if (foe.active.types.includes(move.type)) return;
-        if (!Rolls.secondaryChance(battle, true)) 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;
 
         foe_stored.status = Status.init(.FRZ);
         // GLITCH: Hyper Beam recharging status is not cleared
 
-        try log.status(foe_ident, foe_stored.status, .None);
+        try options.log.status(foe_ident, foe_stored.status, .None);
     }
 
-    fn haze(battle: anytype, player: Player, log: anytype) !void {
+    fn haze(battle: anytype, player: Player, options: anytype) !void {
+        var log = options.log;
         var side = battle.side(player);
         var foe = battle.foe(player);
 
@@ -1963,7 +2002,7 @@ pub const Effects = struct {
                     s.stored().status = Status.init(.PSN);
                     try log.status(battle.active(p), s.stored().status, .None);
                 }
-                try clearVolatiles(battle, p, log);
+                try clearVolatiles(battle, p, p != player, options);
             }
         } else {
             if (Status.any(foe_stored.status)) {
@@ -1973,12 +2012,12 @@ pub const Effects = struct {
                 try log.curestatus(foe_ident, foe_stored.status, .Silent);
                 foe_stored.status = 0;
             }
-            try clearVolatiles(battle, player, log);
-            try clearVolatiles(battle, player.foe(), log);
+            try clearVolatiles(battle, player, false, options);
+            try clearVolatiles(battle, player.foe(), true, options);
         }
     }
 
-    fn heal(battle: anytype, player: Player, log: anytype) !void {
+    fn heal(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
         var stored = side.stored();
         const ident = battle.active(player);
@@ -1986,7 +2025,7 @@ pub const Effects = struct {
         // GLITCH: HP recovery move failure glitches
         const delta = stored.stats.hp - stored.hp;
         if (delta == 0 or (delta & 255 == 255 and stored.hp % 256 != 0)) {
-            return try log.fail(ident, .None);
+            return options.log.fail(ident, .None);
         }
 
         const rest = side.last_selected_move == .Rest;
@@ -1994,52 +2033,55 @@ pub const Effects = struct {
             // Adding the sleep status runs the sleep condition handler to roll duration
             if (showdown) battle.rng.advance(1);
             stored.status = Status.slf(2);
-            try log.statusFrom(ident, stored.status, Move.Rest);
+            try options.log.statusFrom(ident, stored.status, Move.Rest);
             stored.hp = stored.stats.hp;
         } else {
             stored.hp = @min(stored.stats.hp, stored.hp + (stored.stats.hp / 2));
         }
-        try log.heal(ident, stored, if (rest) Heal.Silent else Heal.None);
+        try options.log.heal(.{ ident, stored, if (rest) Heal.Silent else Heal.None });
     }
 
-    fn hyperBeam(battle: anytype, player: Player, log: anytype) !void {
+    fn hyperBeam(battle: anytype, player: Player, options: anytype) !void {
         battle.side(player).active.volatiles.Recharging = true;
-        try log.mustrecharge(battle.active(player));
+        try options.log.mustrecharge(battle.active(player));
     }
 
-    fn leechSeed(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+    fn leechSeed(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
         var foe = battle.foe(player);
 
         if (showdown) {
             // Invulnerability trumps type immunity on Pokémon Showdown
             if (!foe.active.volatiles.Invulnerable and foe.active.types.includes(.Grass)) {
-                return log.immune(battle.active(player.foe()), .None);
+                return options.log.immune(battle.active(player.foe()), .None);
             }
-            if (!try checkHit(battle, player, move, log)) return;
+            if (!try checkHit(battle, player, move, options)) return;
             if (foe.active.volatiles.LeechSeed) return;
         } else {
-            if (!try checkHit(battle, player, move, log)) return;
+            if (!try checkHit(battle, player, move, options)) return;
             if (foe.active.types.includes(.Grass) or foe.active.volatiles.LeechSeed) {
-                try log.lastmiss();
-                return log.miss(battle.active(player));
+                try options.log.lastmiss();
+                return options.log.miss(battle.active(player));
             }
         }
 
+        try options.chance.commit(player, .hit);
         foe.active.volatiles.LeechSeed = true;
 
-        try log.start(battle.active(player.foe()), .LeechSeed);
+        try options.log.start(battle.active(player.foe()), .LeechSeed);
     }
 
-    fn lightScreen(battle: anytype, player: Player, log: anytype) !void {
+    fn lightScreen(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
 
-        if (side.active.volatiles.LightScreen) return log.fail(battle.active(player), .None);
+        if (side.active.volatiles.LightScreen) {
+            return options.log.fail(battle.active(player), .None);
+        }
         side.active.volatiles.LightScreen = true;
 
-        try log.start(battle.active(player), .LightScreen);
+        try options.log.start(battle.active(player), .LightScreen);
     }
 
-    fn mimic(battle: anytype, player: Player, move: Move.Data, mslot: u8, log: anytype) !void {
+    fn mimic(battle: anytype, player: Player, move: Move.Data, mslot: u8, options: anytype) !void {
         var side = battle.side(player);
         var foe = battle.foe(player);
 
@@ -2063,38 +2105,43 @@ 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, log)) return;
-                return try log.fail(battle.active(player.foe()), .None);
+                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, log)) return;
+        if (!try checkHit(battle, player, move, options)) return;
+        try options.chance.commit(player, .hit);
 
-        const rslot = Rolls.moveSlot(battle, &foe.active.moves, 0);
+        const rslot = try Rolls.moveSlot(battle, player, &foe.active.moves, 0, options);
         side.active.move(oslot).id = foe.active.move(rslot).id;
 
-        try log.startEffect(battle.active(player), .Mimic, side.active.move(oslot).id);
+        try options.log.startEffect(battle.active(player), .Mimic, side.active.move(oslot).id);
     }
 
-    fn mist(battle: anytype, player: Player, log: anytype) !void {
+    fn mist(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
 
         if (side.active.volatiles.Mist) return;
         side.active.volatiles.Mist = true;
 
-        try log.start(battle.active(player), .Mist);
+        try options.log.start(battle.active(player), .Mist);
     }
 
-    fn multiHit(battle: anytype, player: Player, move: Move.Data) void {
+    fn multiHit(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
         var side = battle.side(player);
 
         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)
+            try Rolls.distribution(battle, .MultiHit, player, options)
+        else
+            2;
     }
 
-    fn paralyze(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+    fn paralyze(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        var log = options.log;
         var foe = battle.foe(player);
         var foe_stored = foe.stored();
         const foe_ident = battle.active(player.foe());
@@ -2105,7 +2152,7 @@ pub const Effects = struct {
         if (showdown) {
             // Invulnerability trumps type immunity on Pokémon Showdown
             if (immune and !foe.active.volatiles.Invulnerable) return log.immune(foe_ident, .None);
-            if (!try checkHit(battle, player, move, log)) return;
+            if (!try checkHit(battle, player, move, options)) return;
         }
         if (Status.any(foe_stored.status)) {
             return log.fail(
@@ -2115,8 +2162,9 @@ pub const Effects = struct {
         }
         if (!showdown) {
             if (immune) return log.immune(foe_ident, .None);
-            if (!try checkHit(battle, player, move, log)) return;
+            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);
@@ -2124,7 +2172,7 @@ pub const Effects = struct {
         try log.status(foe_ident, foe_stored.status, .None);
     }
 
-    fn paralyzeChance(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+    fn paralyzeChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
         var foe = battle.foe(player);
         var foe_stored = foe.stored();
 
@@ -2136,25 +2184,30 @@ 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;
+        if (!try Rolls.secondaryChance(battle, player, move.effect == .ParalyzeChance1, options)) {
+            return;
+        }
 
         foe_stored.status = Status.init(.PAR);
         foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
 
-        try log.status(battle.active(player.foe()), foe_stored.status, .None);
+        try options.log.status(battle.active(player.foe()), foe_stored.status, .None);
     }
 
-    fn payDay(battle: anytype, player: Player, log: anytype) !void {
-        if (!showdown or !battle.foe(player).active.volatiles.Substitute) try log.fieldactivate();
+    fn payDay(battle: anytype, player: Player, options: anytype) !void {
+        if (!showdown or !battle.foe(player).active.volatiles.Substitute) {
+            try options.log.fieldactivate();
+        }
     }
 
-    fn poison(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+    fn poison(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        var log = options.log;
         var foe = battle.foe(player);
         var foe_stored = foe.stored();
         const foe_ident = battle.active(player.foe());
         const toxic = battle.side(player).last_selected_move == .Toxic;
 
-        if (showdown and move.effect == .Poison and !try checkHit(battle, player, move, log)) {
+        if (showdown and move.effect == .Poison and !try checkHit(battle, player, move, options)) {
             return;
         } else if (foe.active.volatiles.Substitute) {
             if (move.effect != .Poison) return;
@@ -2178,8 +2231,13 @@ 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;
+            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;
+            }
+        }
 
         foe_stored.status = Status.init(.PSN);
         if (toxic) {
@@ -2197,7 +2255,7 @@ pub const Effects = struct {
         volatiles.Rage = true;
     }
 
-    fn recoil(battle: anytype, player: Player, residual: *bool, log: anytype) !void {
+    fn recoil(battle: anytype, player: Player, residual: *bool, options: anytype) !void {
         var side = battle.side(player);
         var stored = side.stored();
 
@@ -2208,20 +2266,25 @@ pub const Effects = struct {
             @as(u8, if (side.last_selected_move == .Struggle) 2 else 4), 1));
         stored.hp = @intCast(@max(@as(i16, @intCast(stored.hp)) - damage, 0));
 
-        try log.damageOf(battle.active(player), stored, .RecoilOf, battle.active(player.foe()));
+        try options.log.damageOf(
+            battle.active(player),
+            stored,
+            .RecoilOf,
+            battle.active(player.foe()),
+        );
         if (showdown and stored.hp == 0) residual.* = false;
     }
 
-    fn reflect(battle: anytype, player: Player, log: anytype) !void {
+    fn reflect(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
 
-        if (side.active.volatiles.Reflect) return log.fail(battle.active(player), .None);
+        if (side.active.volatiles.Reflect) return options.log.fail(battle.active(player), .None);
         side.active.volatiles.Reflect = true;
 
-        try log.start(battle.active(player), .Reflect);
+        try options.log.start(battle.active(player), .Reflect);
     }
 
-    fn sleep(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+    fn sleep(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
         var foe = battle.foe(player);
         var foe_stored = foe.stored();
         const foe_ident = battle.active(player.foe());
@@ -2232,13 +2295,14 @@ pub const Effects = struct {
             // the Sleep Clause Mod might activate, causing us to not actually bypass
         } else {
             if (Status.any(foe_stored.status)) {
-                return log.fail(
+                return options.log.fail(
                     foe_ident,
                     if (Status.is(foe_stored.status, .SLP)) .Sleep else .None,
                 );
             }
             // If checkHit in doMove didn't return true Pokémon Showdown wouldn't be in here
-            if (!showdown and !try checkHit(battle, player, move, log)) return;
+            if (!showdown and !try checkHit(battle, player, move, options)) return;
+            try options.chance.commit(player, .hit);
         }
 
         // Sleep Clause Mod
@@ -2249,19 +2313,19 @@ pub const Effects = struct {
         }
         foe.active.volatiles.Recharging = false;
 
-        foe_stored.status = Status.slp(Rolls.sleepDuration(battle));
-        try log.statusFrom(foe_ident, foe_stored.status, battle.side(player).last_selected_move);
+        foe_stored.status = Status.slp(Rolls.sleepDuration(battle, player, options));
+        const last = battle.side(player).last_selected_move;
+        try options.log.statusFrom(foe_ident, foe_stored.status, last);
     }
 
-    fn splash(battle: anytype, player: Player, log: anytype) !void {
-        try log.activate(battle.active(player), .Splash);
+    fn splash(battle: anytype, player: Player, options: anytype) !void {
+        try options.log.activate(battle.active(player), .Splash);
     }
 
-    fn substitute(battle: anytype, player: Player, residual: *bool, log: anytype) !void {
+    fn substitute(battle: anytype, player: Player, residual: *bool, options: anytype) !void {
         var side = battle.side(player);
         if (side.active.volatiles.Substitute) {
-            try log.fail(battle.active(player), .Substitute);
-            return;
+            return options.log.fail(battle.active(player), .Substitute);
         }
 
         assert(side.stored().stats.hp <= 1023);
@@ -2272,40 +2336,43 @@ pub const Effects = struct {
         // the target's HP is exactly divisible by 4 (here we're using an inlined divCeil routine to
         // avoid having to convert to floating point)
         const required_hp = if (showdown) @divFloor(side.stored().stats.hp - 1, 4) + 1 else hp;
-        if (side.stored().hp < required_hp) {
-            try log.fail(battle.active(player), .Weak);
-            return;
-        }
+        if (side.stored().hp < required_hp) return options.log.fail(battle.active(player), .Weak);
 
         // GLITCH: can leave the user with 0 HP (faints later) because didn't check '<=' above
         side.stored().hp -= hp;
         side.active.volatiles.substitute = hp + 1;
         side.active.volatiles.Substitute = true;
-        try log.start(battle.active(player), .Substitute);
+        try options.log.start(battle.active(player), .Substitute);
         if (hp > 0) {
-            try log.damage(battle.active(player), side.stored(), .None);
+            try options.log.damage(battle.active(player), side.stored(), .None);
             if (showdown and side.stored().hp == 0) residual.* = false;
         }
     }
 
-    fn switchAndTeleport(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
-        if (!showdown or battle.side(player).last_selected_move == .Teleport) return;
-
+    fn switchAndTeleport(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
         // Whirlwind/Roar should not roll to hit/reset damage but Pokémon Showdown does anyway
-        _ = try checkHit(battle, player, move, log);
-        battle.last_damage = 0;
+        if (showdown) {
+            if (battle.side(player).last_selected_move == .Teleport) return;
+            if (try checkHit(battle, player, move, options)) {
+                try options.chance.commit(player, .hit);
+            }
+            battle.last_damage = 0;
+        } else {
+            try options.log.fail(battle.active(player), .None);
+            try options.log.laststill();
+        }
     }
 
-    fn thrashing(battle: anytype, player: Player) void {
+    fn thrashing(battle: anytype, player: Player, options: anytype) void {
         var volatiles = &battle.side(player).active.volatiles;
         assert(!volatiles.Thrashing);
         assert(!volatiles.Bide);
 
         volatiles.Thrashing = true;
-        volatiles.attacks = Rolls.bideThrashDuration(battle);
+        volatiles.attacks = Rolls.attackingDuration(battle, player, options);
     }
 
-    fn transform(battle: anytype, player: Player, log: anytype) !void {
+    fn transform(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
         const foe = battle.foe(player);
         const foe_ident = battle.active(player.foe());
@@ -2331,10 +2398,10 @@ pub const Effects = struct {
             side.active.moves[i].pp = if (m.id != .None) 5 else 0;
         }
 
-        try log.transform(battle.active(player), foe_ident);
+        try options.log.transform(battle.active(player), foe_ident);
     }
 
-    fn binding(battle: anytype, player: Player, rewrap: bool) void {
+    fn binding(battle: anytype, player: Player, rewrap: bool, options: anytype) !void {
         var side = battle.side(player);
         var foe = battle.foe(player);
 
@@ -2346,10 +2413,12 @@ pub const Effects = struct {
             foe.active.volatiles.Recharging = false;
         } else if (foe.stored().hp == 0) return if (!rewrap) battle.rng.advance(1);
 
-        side.active.volatiles.attacks = Rolls.distribution(battle) - 1;
+        side.active.volatiles.attacks =
+            try Rolls.distribution(battle, .Binding, player, options) - 1;
     }
 
-    fn boost(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+    fn boost(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        var log = options.log;
         var side = battle.side(player);
         const ident = battle.active(player);
 
@@ -2359,9 +2428,9 @@ pub const Effects = struct {
         switch (move.effect) {
             .AttackUp1, .AttackUp2, .Rage => {
                 assert(boosts.atk >= -6 and boosts.atk <= 6);
-                if (boosts.atk == 6) return try log.fail(ident, .None);
+                if (boosts.atk == 6) return log.fail(ident, .None);
                 const n: u2 = if (move.effect == .AttackUp2) 2 else 1;
-                boosts.atk = @intCast(@min(6, @as(i8, boosts.atk) + n));
+                boosts.atk = @as(i4, @intCast(@min(6, @as(i8, boosts.atk) + n)));
                 const reason = if (move.effect == .Rage) Boost.Rage else Boost.Attack;
                 if (stats.atk == MAX_STAT_VALUE) {
                     boosts.atk -= 1;
@@ -2370,9 +2439,9 @@ pub const Effects = struct {
                         try log.boost(ident, Boost.Attack, -1);
                         if (move.effect == .Rage) return;
                     }
-                    return try log.fail(ident, .None);
+                    return log.fail(ident, .None);
                 }
-                var mod = BOOSTS[@intCast(@as(i8, boosts.atk) + 6)];
+                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.atk) + 6))];
                 const stat = unmodifiedStats(battle, side).atk;
                 stats.atk = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, reason, n);
@@ -2381,7 +2450,7 @@ pub const Effects = struct {
             },
             .DefenseUp1, .DefenseUp2 => {
                 assert(boosts.def >= -6 and boosts.def <= 6);
-                if (boosts.def == 6) return try log.fail(ident, .None);
+                if (boosts.def == 6) return log.fail(ident, .None);
                 const n: u2 = if (move.effect == .DefenseUp2) 2 else 1;
                 boosts.def = @intCast(@min(6, @as(i8, boosts.def) + n));
                 if (stats.def == MAX_STAT_VALUE) {
@@ -2390,16 +2459,16 @@ pub const Effects = struct {
                         try log.boost(ident, .Defense, n);
                         try log.boost(ident, .Defense, -1);
                     }
-                    return try log.fail(ident, .None);
+                    return log.fail(ident, .None);
                 }
-                var mod = BOOSTS[@intCast(@as(i8, boosts.def) + 6)];
+                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.def) + 6))];
                 const stat = unmodifiedStats(battle, side).def;
                 stats.def = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, .Defense, n);
             },
             .SpeedUp2 => {
                 assert(boosts.spe >= -6 and boosts.spe <= 6);
-                if (boosts.spe == 6) return try log.fail(ident, .None);
+                if (boosts.spe == 6) return log.fail(ident, .None);
                 boosts.spe = @intCast(@min(6, @as(i8, boosts.spe) + 2));
                 if (stats.spe == MAX_STAT_VALUE) {
                     boosts.spe -= 1;
@@ -2407,16 +2476,16 @@ pub const Effects = struct {
                         try log.boost(ident, .Speed, 2);
                         try log.boost(ident, .Speed, -1);
                     }
-                    return try log.fail(ident, .None);
+                    return log.fail(ident, .None);
                 }
-                var mod = BOOSTS[@intCast(@as(i8, boosts.spe) + 6)];
+                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spe) + 6))];
                 const stat = unmodifiedStats(battle, side).spe;
                 stats.spe = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, .Speed, 2);
             },
             .SpecialUp1, .SpecialUp2 => {
                 assert(boosts.spc >= -6 and boosts.spc <= 6);
-                if (boosts.spc == 6) return try log.fail(ident, .None);
+                if (boosts.spc == 6) return log.fail(ident, .None);
                 const n: u2 = if (move.effect == .SpecialUp2) 2 else 1;
                 boosts.spc = @intCast(@min(6, @as(i8, boosts.spc) + n));
                 if (stats.spc == MAX_STAT_VALUE) {
@@ -2427,9 +2496,9 @@ pub const Effects = struct {
                         try log.boost(ident, .SpecialDefense, n);
                         try log.boost(ident, .SpecialDefense, -1);
                     }
-                    return try log.fail(ident, .None);
+                    return log.fail(ident, .None);
                 }
-                var mod = BOOSTS[@intCast(@as(i8, boosts.spc) + 6)];
+                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spc) + 6))];
                 const stat = unmodifiedStats(battle, side).spc;
                 stats.spc = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(ident, .SpecialAttack, n);
@@ -2437,7 +2506,7 @@ pub const Effects = struct {
             },
             .EvasionUp1 => {
                 assert(boosts.evasion >= -6 and boosts.evasion <= 6);
-                if (boosts.evasion == 6) return try log.fail(ident, .None);
+                if (boosts.evasion == 6) return log.fail(ident, .None);
                 boosts.evasion = @intCast(@min(6, @as(i8, boosts.evasion) + 1));
                 try log.boost(ident, .Evasion, 1);
             },
@@ -2448,7 +2517,8 @@ pub const Effects = struct {
         statusModify(battle.foe(player).stored().status, &battle.foe(player).active.stats);
     }
 
-    fn unboost(battle: anytype, player: Player, move: Move.Data, log: anytype) !void {
+    fn unboost(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        var log = options.log;
         var foe = battle.foe(player);
         const foe_ident = battle.active(player.foe());
         const secondary = move.effect.isStatDownChance();
@@ -2456,9 +2526,12 @@ pub const Effects = struct {
         if (foe.active.volatiles.Substitute) return if (!secondary) log.fail(foe_ident, .None);
 
         if (secondary) {
-            if (!Rolls.unboost(battle) or foe.active.volatiles.Invulnerable) return;
-        } else if (!showdown and !try checkHit(battle, player, move, log)) {
-            return; // checkHit already checks for Invulnerable
+            const proc = try Rolls.unboost(battle, player, options);
+            if (!proc or foe.active.volatiles.Invulnerable) return;
+        } 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;
@@ -2476,9 +2549,9 @@ pub const Effects = struct {
                         try log.boost(foe_ident, .Attack, -1);
                         try log.boost(foe_ident, .Attack, 1);
                     }
-                    return try log.fail(foe_ident, .None);
+                    return log.fail(foe_ident, .None);
                 }
-                var mod = BOOSTS[@intCast(@as(i8, boosts.atk) + 6)];
+                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.atk) + 6))];
                 const stat = unmodifiedStats(battle, foe).atk;
                 stats.atk = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .Attack, -1);
@@ -2494,9 +2567,9 @@ pub const Effects = struct {
                         try log.boost(foe_ident, .Defense, -@as(i8, n));
                         try log.boost(foe_ident, .Defense, 1);
                     }
-                    return try log.fail(foe_ident, .None);
+                    return log.fail(foe_ident, .None);
                 }
-                var mod = BOOSTS[@intCast(@as(i8, boosts.def) + 6)];
+                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.def) + 6))];
                 const stat = unmodifiedStats(battle, foe).def;
                 stats.def = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .Defense, -@as(i8, n));
@@ -2511,9 +2584,9 @@ pub const Effects = struct {
                         try log.boost(foe_ident, .Speed, -1);
                         try log.boost(foe_ident, .Speed, 1);
                     }
-                    return try log.fail(foe_ident, .None);
+                    return log.fail(foe_ident, .None);
                 }
-                var mod = BOOSTS[@intCast(@as(i8, boosts.spe) + 6)];
+                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spe) + 6))];
                 const stat = unmodifiedStats(battle, foe).spe;
                 stats.spe = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .Speed, -1);
@@ -2531,9 +2604,9 @@ pub const Effects = struct {
                         try log.boost(foe_ident, .SpecialDefense, -1);
                         try log.boost(foe_ident, .SpecialDefense, 1);
                     }
-                    return try log.fail(foe_ident, .None);
+                    return log.fail(foe_ident, .None);
                 }
-                var mod = BOOSTS[@intCast(@as(i8, boosts.spc) + 6)];
+                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spc) + 6))];
                 const stat = unmodifiedStats(battle, foe).spc;
                 stats.spc = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(foe_ident, .SpecialAttack, -1);
@@ -2567,19 +2640,22 @@ fn statusModify(status: u8, stats: *Stats(u16)) void {
     }
 }
 
-inline fn isForced(active: ActivePokemon) bool {
+fn isForced(active: anytype) bool {
     return active.volatiles.Recharging or active.volatiles.Rage or
         active.volatiles.Thrashing or active.volatiles.Charging;
 }
 
-fn clearVolatiles(battle: anytype, who: Player, log: anytype) !void {
+fn clearVolatiles(battle: anytype, who: Player, clear: bool, options: anytype) !void {
+    var log = options.log;
     var side = battle.side(who);
     var volatiles = &side.active.volatiles;
     const ident = battle.active(who);
 
-    if (volatiles.disabled_move != 0) {
-        volatiles.disabled_move = 0;
-        volatiles.disabled_duration = 0;
+    options.chance.clearDurations(who, clear);
+
+    if (volatiles.disable_move != 0) {
+        volatiles.disable_move = 0;
+        volatiles.disable_duration = 0;
         try log.end(ident, .DisableSilent);
     }
     if (volatiles.Confusion) {
@@ -2589,15 +2665,15 @@ fn clearVolatiles(battle: anytype, who: Player, log: anytype) !void {
     }
     if (volatiles.Mist) {
         volatiles.Mist = false;
-        try log.end(ident, .Mist);
+        try log.end(ident, .MistSilent);
     }
     if (volatiles.FocusEnergy) {
         volatiles.FocusEnergy = false;
-        try log.end(ident, .FocusEnergy);
+        try log.end(ident, .FocusEnergySilent);
     }
     if (volatiles.LeechSeed) {
         volatiles.LeechSeed = false;
-        try log.end(ident, .LeechSeed);
+        try log.end(ident, .LeechSeedSilent);
     }
     if (!showdown and volatiles.Toxic) {
         volatiles.Toxic = false;
@@ -2605,152 +2681,313 @@ fn clearVolatiles(battle: anytype, who: Player, log: anytype) !void {
     }
     if (volatiles.LightScreen) {
         volatiles.LightScreen = false;
-        try log.end(ident, .LightScreen);
+        try log.end(ident, .LightScreenSilent);
     }
     if (volatiles.Reflect) {
         volatiles.Reflect = false;
-        try log.end(ident, .Reflect);
+        try log.end(ident, .ReflectSilent);
     }
     if (showdown and volatiles.Toxic) {
         volatiles.Toxic = false;
         // Pokémon Showdown erroneously clears the toxic counter
         volatiles.toxic = 0;
-        try log.end(ident, .Toxic);
+        try log.end(ident, .ToxicSilent);
     }
 }
 
 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;
-    }
+    fn speedTie(battle: anytype, options: anytype) !bool {
+        const p1 = if (options.calc.overridden(.P1, .speed_tie)) |player|
+            player == .P1
+        else if (showdown)
+            battle.rng.range(u8, 0, 2) == 0
+        else
+            battle.rng.next() < Gen12.percent(50) + 1;
 
-    inline fn criticalHit(battle: anytype, chance: u16) bool {
-        if (showdown) return battle.rng.chance(u8, @as(u8, @intCast(chance)), 256);
-        return std.math.rotl(u8, battle.rng.next(), 3) < chance;
+        try options.chance.speedTie(p1);
+        return p1;
     }
 
-    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 criticalHit(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
+        const crit = if (options.calc.overridden(player, .critical_hit)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, rate, 256)
+        else
+            std.math.rotl(u8, battle.rng.next(), 3) < rate;
 
-    inline fn hit(battle: anytype, accuracy: u16) bool {
-        if (showdown) return battle.rng.chance(u8, @as(u8, @intCast(accuracy)), 256);
-        return battle.rng.next() < accuracy;
+        try options.chance.criticalHit(player, crit, rate);
+        return crit;
     }
 
-    inline fn confusionDuration(battle: anytype) u3 {
-        if (showdown) return @intCast(battle.rng.range(u8, 2, 6));
-        return @intCast((battle.rng.next() & 3) + 2);
-    }
+    fn damage(battle: anytype, player: Player, options: anytype) !u8 {
+        const roll = if (options.calc.overridden(player, .damage)) |val|
+            val
+        else roll: {
+            if (showdown) break :roll battle.rng.range(u8, 217, 256);
+            while (true) {
+                const r = std.math.rotr(u8, battle.rng.next(), 1);
+                if (r >= 217) break :roll r;
+            }
+        };
 
-    inline fn confused(battle: anytype) bool {
-        if (showdown) return !battle.rng.chance(u8, 128, 256);
-        return battle.rng.next() >= Gen12.percent(50) + 1;
+        assert(roll >= 217 and roll <= 255);
+        try options.chance.damage(player, roll);
+        return roll;
     }
 
-    inline fn paralyzed(battle: anytype) bool {
-        if (showdown) return battle.rng.chance(u8, 63, 256);
-        return battle.rng.next() < Gen12.percent(25);
+    fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) bool {
+        const ok = if (options.calc.overridden(player, .hit)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, accuracy, 256)
+        else
+            battle.rng.next() < accuracy;
+
+        options.chance.hit(ok, accuracy);
+        return ok;
     }
 
-    inline fn confusionChance(battle: anytype) bool {
-        if (showdown) return battle.rng.chance(u8, 25, 256);
-        return battle.rng.next() < Gen12.percent(10);
+    fn confused(battle: anytype, player: Player, options: anytype) !bool {
+        const cfz = if (options.calc.overridden(player, .confused)) |val|
+            val == .true
+        else if (showdown)
+            !battle.rng.chance(u8, 128, 256)
+        else
+            battle.rng.next() >= Gen12.percent(50) + 1;
+
+        try options.chance.confused(player, cfz);
+        return cfz;
     }
 
-    inline fn secondaryChance(battle: anytype, low: bool) bool {
-        if (showdown) return battle.rng.chance(u8, @as(u8, if (low) 26 else 77), 256);
-        return battle.rng.next() < 1 + (if (low) Gen12.percent(10) else Gen12.percent(30));
+    fn paralyzed(battle: anytype, player: Player, options: anytype) !bool {
+        const par = if (options.calc.overridden(player, .paralyzed)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, 63, 256)
+        else
+            battle.rng.next() < Gen12.percent(25);
+
+        try options.chance.paralyzed(player, par);
+        return par;
     }
 
-    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));
+    fn confusionChance(battle: anytype, player: Player, options: anytype) !bool {
+        const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, 25, 256)
+        else
+            battle.rng.next() < Gen12.percent(10);
+
+        try options.chance.secondaryChance(player, proc, 25);
+        return proc;
     }
 
-    inline fn sleepDuration(battle: anytype) u3 {
-        if (showdown) return @intCast(battle.rng.range(u8, 1, 8));
-        while (true) {
-            const r = battle.rng.next() & 7;
-            if (r != 0) return @intCast(r);
-        }
+    fn secondaryChance(battle: anytype, player: Player, low: bool, options: anytype) !bool {
+        const rate: u8 = if (low) 26 else 77;
+
+        const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, rate, 256)
+        else
+            battle.rng.next() < 1 + (if (low) Gen12.percent(10) else Gen12.percent(30));
+
+        try options.chance.secondaryChance(player, proc, rate);
+        return proc;
     }
 
-    inline fn bideThrashDuration(battle: anytype) u3 {
-        if (showdown) return @intCast(battle.rng.range(u4, 2, 4));
-        return @intCast((battle.rng.next() & 1) + 2);
+    fn poisonChance(battle: anytype, player: Player, low: bool, options: anytype) !bool {
+        const rate: u8 = if (low) 52 else 103;
+
+        const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, rate, 256)
+        else
+            battle.rng.next() < 1 + (if (low) Gen12.percent(20) else Gen12.percent(40));
+
+        try options.chance.secondaryChance(player, proc, rate);
+        return proc;
     }
 
-    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, @as(u4, @intCast(i + 1))) + 1;
-                    }
-                }
-            } else {
-                var r = battle.rng.range(u4, 0, 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(i + 1);
+    fn unboost(battle: anytype, player: Player, options: anytype) !bool {
+        const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, 85, 256)
+        else
+            battle.rng.next() < Gen12.percent(33) + 1;
+
+        try options.chance.secondaryChance(player, proc, 85);
+        return proc;
+    }
+
+    fn metronome(battle: anytype, player: Player, options: anytype) !Move {
+        const move: Move = if (options.calc.overridden(player, .metronome)) |val|
+            val
+        else if (showdown)
+            Move.METRONOME[battle.rng.range(u8, 0, Move.METRONOME.len)]
+        else move: {
+            while (true) {
+                const r = battle.rng.next();
+                if (r == 0 or r == @intFromEnum(Move.Metronome)) continue;
+                if (r >= @intFromEnum(Move.Struggle)) continue;
+                break :move @enumFromInt(r);
             }
-        }
+        };
 
-        while (true) {
-            const r: u4 = @intCast(battle.rng.next() & 3);
-            if (moves[r].id != .None and (check_pp == 0 or moves[r].pp > 0)) return r + 1;
-        }
+        try options.chance.metronome(player, move);
+        return move;
     }
 
-    inline fn disableDuration(battle: anytype) u4 {
-        if (showdown) return @intCast(battle.rng.range(u8, 1, 9));
-        return @intCast((battle.rng.next() & 7) + 1);
+    fn psywave(battle: anytype, player: Player, max: u8, options: anytype) !u8 {
+        const power = if (options.calc.overridden(player, .psywave)) |val|
+            val - 1
+        else if (showdown)
+            battle.rng.range(u8, 0, max)
+        else power: {
+            while (true) {
+                const r = battle.rng.next();
+                if (r < max) break :power r;
+            }
+        };
+
+        assert(power < max);
+        try options.chance.psywave(player, power, max);
+        return power;
     }
 
-    inline fn metronome(battle: anytype) Move {
-        if (showdown) {
-            const r = battle.rng.range(u8, 0, @intFromEnum(Move.Struggle) - 2);
-            const mod = @as(u2, (if (r < @intFromEnum(Move.Metronome) - 1) 1 else 2));
-            return @enumFromInt(r + mod);
-        }
-        while (true) {
-            const r = battle.rng.next();
-            if (r == 0 or r == @intFromEnum(Move.Metronome)) continue;
-            if (r >= @intFromEnum(Move.Struggle)) continue;
-            return @enumFromInt(r);
-        }
+    fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            battle.rng.range(u3, 1, 8)
+        else duration: {
+            while (true) {
+                const r = battle.rng.next() & 7;
+                if (r != 0) break :duration @intCast(r);
+            }
+        };
+
+        assert(duration >= 1 and duration <= 7);
+        options.chance.duration(.sleep, player, player.foe(), duration);
+        return duration;
     }
 
-    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;
-        }
+    fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
+        const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
+            val
+        else if (showdown)
+            battle.rng.range(u4, 1, 9)
+        else
+            @intCast((battle.rng.next() & 7) + 1);
+
+        assert(duration >= 1 and duration <= 8);
+        options.chance.duration(.disable, player, player.foe(), duration);
+        return duration;
     }
 
-    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((if (r < 2) r else battle.rng.next() & 3) + 2);
+    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 (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);
+        return duration;
     }
 
-    inline fn unboost(battle: anytype) bool {
-        if (showdown) return battle.rng.chance(u8, 85, 256);
-        return battle.rng.next() < Gen12.percent(33) + 1;
+    fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            battle.rng.range(u3, 2, 4)
+        else
+            @intCast((battle.rng.next() & 1) + 2);
+
+        assert(duration >= 2 and duration <= 3);
+        options.chance.duration(.attacking, player, player, duration);
+        return duration;
+    }
+
+    const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
+
+    fn distribution(
+        battle: anytype,
+        comptime effect: Move.Effect,
+        player: Player,
+        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 (showdown)
+            DISTRIBUTION[battle.rng.range(u3, 0, DISTRIBUTION.len)]
+        else n: {
+            const r = (battle.rng.next() & 3);
+            break :n @intCast((if (r < 2) r else battle.rng.next() & 3) + 2);
+        };
+
+        assert(n >= 2 and n <= 5);
+        if (effect == .Binding) {
+            options.chance.duration(.binding, player, player, n);
+        } else {
+            try options.chance.multiHit(player, n);
+        }
+        return n;
+    }
+
+    fn moveSlot(
+        battle: anytype,
+        player: Player,
+        moves: []MoveSlot,
+        check_pp: u4,
+        options: anytype,
+    ) !u4 {
+        // TODO: consider throwing error instead of rerolling?
+        const overridden = 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 slot: {
+            if (showdown) {
+                if (check_pp == 0) {
+                    var i: usize = moves.len;
+                    while (i > 0) {
+                        i -= 1;
+                        if (moves[i].id != .None) {
+                            break :slot battle.rng.range(u4, 0, @as(u4, @intCast(i + 1))) + 1;
+                        }
+                    }
+                } else {
+                    var r = battle.rng.range(u4, 0, 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 :slot @intCast(i + 1);
+                        }
+                    }
+                }
+            }
+
+            while (true) {
+                const r: u4 = @intCast(battle.rng.next() & 3);
+                if (moves[r].id != .None and (check_pp == 0 or moves[r].pp > 0)) break :slot r + 1;
+            }
+        };
+
+        try options.chance.moveSlot(player, slot, moves, check_pp);
+        return slot;
     }
 };
 
@@ -2761,11 +2998,11 @@ test "RNG agreement" {
         expected[i] = @intCast(i * 0x1000000);
     }
 
-    var spe = rng.FixedRNG(1, expected.len){ .rolls = expected };
-    var cfz = rng.FixedRNG(1, expected.len){ .rolls = expected };
-    var par = rng.FixedRNG(1, expected.len){ .rolls = expected };
-    var brn = rng.FixedRNG(1, expected.len){ .rolls = expected };
-    var eff = rng.FixedRNG(1, expected.len){ .rolls = expected };
+    var spe: rng.FixedRNG(1, expected.len) = .{ .rolls = expected };
+    var cfz: rng.FixedRNG(1, expected.len) = .{ .rolls = expected };
+    var par: rng.FixedRNG(1, expected.len) = .{ .rolls = expected };
+    var brn: rng.FixedRNG(1, expected.len) = .{ .rolls = expected };
+    var eff: rng.FixedRNG(1, expected.len) = .{ .rolls = expected };
 
     for (0..expected.len) |i| {
         try expectEqual(spe.range(u8, 0, 2) == 0, i < Gen12.percent(50) + 1);
@@ -2801,7 +3038,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             const side = battle.side(player);
             const foe = battle.foe(player);
 
-            var active = side.active;
+            var active = &side.active;
             const stored = side.stored();
 
             // While players are not given any input options on the cartridge in these cases,
@@ -2855,7 +3092,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                     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);
+                            m.id == .Bide and (m.pp == 0 or active.volatiles.disable_move == slot);
                         const s = if (struggle) 0 else slot;
                         out[n] = .{ .type = .Move, .data = s };
                         n += 1;
@@ -2870,7 +3107,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                 const m = active.moves[slot - 1];
                 if (m.id == .None) break;
                 if (m.pp == 0) continue;
-                if (active.volatiles.disabled_move == slot) continue;
+                if (active.volatiles.disable_move == slot) continue;
                 out[n] = .{ .type = .Move, .data = slot };
                 n += 1;
             }