@pkmn/engine 0.1.0-dev.89cc1c98 → 0.1.0-dev.8b192003

package/src/lib/gen1/mechanics.zig

@@ -4,10 +4,12 @@ const pkmn = @import("../pkmn.zig");
 
 const common = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
+const optional = @import("../common/optional.zig");
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
 
 const data = @import("data.zig");
+const chance = @import("chance.zig");
 
 const assert = std.debug.assert;
 
@@ -22,6 +24,7 @@ const Result = common.Result;
 
 const Boost = protocol.Boost;
 const Damage = protocol.Damage;
+const Fail = protocol.Fail;
 const Heal = protocol.Heal;
 
 const Gen12 = rng.Gen12;
@@ -70,8 +73,8 @@ pub fn update(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Result
     var p1 = battle.side(.P1);
     var p2 = battle.side(.P2);
 
-    var r1 = showdown and p1.active.volatiles.Binding and c2.type == .Switch;
-    var r2 = showdown and p2.active.volatiles.Binding and c1.type == .Switch;
+    const r1 = showdown and p1.active.volatiles.Binding and c2.type == .Switch;
+    const r2 = showdown and p2.active.volatiles.Binding and c1.type == .Switch;
 
     if (try turnOrder(battle, c1, c2, options) == .P1) {
         if (try doTurn(battle, .P1, c1, r1, s1, .P2, c2, r2, s2, options)) |r| return r;
@@ -89,11 +92,11 @@ fn start(battle: anytype, options: anytype) !Result {
     const p1 = battle.side(.P1);
     const p2 = battle.side(.P2);
 
-    var p1_slot = findFirstAlive(p1);
+    const p1_slot = findFirstAlive(p1);
     assert(!showdown or p1_slot == 1);
     if (p1_slot == 0) return if (findFirstAlive(p2) == 0) Result.Tie else Result.Lose;
 
-    var p2_slot = findFirstAlive(p2);
+    const p2_slot = findFirstAlive(p2);
     assert(!showdown or p2_slot == 1);
     if (p2_slot == 0) return Result.Win;
 
@@ -165,7 +168,7 @@ fn selectMove(
             // to satisfy the conditions of the Desync Clause Mod. However, because Binding is still
             // set the selected move will not actually be used, it will just be reported as having
             // been used (this differs from how Pokémon Showdown works, but its impossible to
-            // replicate the incorrect behavior with the correct mechanisms).
+            // replicate the incorrect behavior with the correct mechanisms)
             saveMove(battle, player, choice);
         } else {
             assert(choice.data == 0);
@@ -255,14 +258,13 @@ fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, options: a
 
     foe.active.volatiles.Binding = false;
 
-    try options.log.switched(battle.active(player), incoming);
-    options.chance.switched(player, side.order[0], out);
+    try options.log.switched(.{ battle.active(player), incoming });
 
     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 options.log.status(battle.active(player), incoming.status, .Silent);
+        try options.log.status(.{ battle.active(player), incoming.status, .Silent });
     }
 }
 
@@ -346,10 +348,10 @@ fn doTurn(
     )) |r| return r;
     if (!replace) {
         if (player_choice.type != .Switch) {
-            if (try checkFaint(battle, foe_player, options)) |r| return r;
+            if (try checkFaint(battle, foe_player, true, options)) |r| return r;
         }
         if (residual) try handleResidual(battle, player, options);
-        if (try checkFaint(battle, player, options)) |r| return r;
+        if (try checkFaint(battle, player, false, options)) |r| return r;
     } else if (foe_choice.type == .Pass) return null;
 
     options.chance.clearPending();
@@ -368,10 +370,10 @@ fn doTurn(
     )) |r| return r;
     if (!replace) {
         if (!calc and foe_choice.type != .Switch) {
-            if (try checkFaint(battle, player, options)) |r| return r;
+            if (try checkFaint(battle, player, true, options)) |r| return r;
         }
         if (residual) try handleResidual(battle, foe_player, options);
-        if (try checkFaint(battle, foe_player, options)) |r| return r;
+        if (try checkFaint(battle, foe_player, false, options)) |r| return r;
     }
 
     // Flinch is bugged on Pokémon Showdown because it gets implemented with a duration which causes
@@ -406,7 +408,7 @@ fn executeMove(
     if (side.last_selected_move == .SKIP_TURN) {
         assert(!showdown);
         if (battle.foe(player).active.volatiles.Binding) {
-            try options.log.cant(battle.active(player), .Bound);
+            try options.log.cant(.{ battle.active(player), .Bound });
         }
         return null;
     }
@@ -430,7 +432,7 @@ fn executeMove(
             Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP);
         // If it wasn't Hyper Beam or the continuation of a move effect then we must have just
         // thawed, in which case we will desync unless the last_selected_move happened to be at
-        // index 1 and the current Pokémon has the same move in its first slot.
+        // index 1 and the current Pokémon has the same move in its first slot
         if (!auto) {
             // side.active.moves(slot) is safe to check even though the slot in question might not
             // technically be from this Pokémon because it must be exactly 1 to not desync and
@@ -484,35 +486,29 @@ fn beforeMove(
     if (Status.is(stored.status, .SLP)) {
         const before = stored.status;
         // Even if the EXT bit is set this will still correctly modify the sleep duration
-        if (options.calc.modify(player, .sleep)) |extend| {
-            if (!extend) stored.status = 0;
-        } else {
-            stored.status -= 1;
-        }
+        stored.status -= 1;
 
         const duration = Status.duration(stored.status);
-        if (!Status.is(stored.status, .EXT)) {
-            try options.chance.sleep(player, duration);
-        }
+        options.chance.durations(.sleep, player, observation(duration));
 
         if (duration == 0) {
-            try log.curestatus(ident, before, .Message);
+            try log.curestatus(.{ ident, before, .Message });
             stored.status = 0; // clears EXT if present
         } else {
-            try log.cant(ident, .Sleep);
+            try log.cant(.{ ident, .Sleep });
         }
         side.last_used_move = .None;
         return .done;
     }
 
     if (Status.is(stored.status, .FRZ)) {
-        try log.cant(ident, .Freeze);
+        try log.cant(.{ ident, .Freeze });
         side.last_used_move = .None;
         return .done;
     }
 
     if (skip or foe.active.volatiles.Binding) {
-        try log.cant(ident, .Bound);
+        try log.cant(.{ ident, .Bound });
         return .done;
     }
 
@@ -520,27 +516,23 @@ fn beforeMove(
         // Pokémon Showdown doesn't clear Flinch until its imaginary "residual" phase, meaning
         // Pokémon can sometimes flinch multiple times from the same original hit
         if (!showdown) volatiles.Flinch = false;
-        try log.cant(ident, .Flinch);
+        try log.cant(.{ ident, .Flinch });
         return .done;
     }
 
     if (volatiles.Recharging) {
         volatiles.Recharging = false;
-        try log.cant(ident, .Recharge);
+        try log.cant(.{ ident, .Recharge });
         return .done;
     }
 
     if (volatiles.disable_duration > 0) {
-        if (options.calc.modify(player, .disable)) |extend| {
-            if (!extend) volatiles.disable_duration = 0;
-        } else {
-            volatiles.disable_duration -= 1;
-        }
-        try options.chance.disable(player, volatiles.disable_duration);
+        volatiles.disable_duration -= 1;
+        options.chance.durations(.disable, player, observation(volatiles.disable_duration));
 
         if (volatiles.disable_duration == 0) {
             volatiles.disable_move = 0;
-            try log.end(ident, .Disable);
+            try log.end(.{ ident, .Disable });
         }
     }
     // Pokémon Showdown's disable condition has a single onBeforeMove handler
@@ -555,19 +547,14 @@ fn beforeMove(
 
     if (volatiles.Confusion) {
         assert(volatiles.confusion > 0);
-
-        if (options.calc.modify(player, .confusion)) |extend| {
-            if (!extend) volatiles.confusion = 0;
-        } else {
-            volatiles.confusion -= 1;
-        }
-        try options.chance.confusion(player, volatiles.confusion);
+        volatiles.confusion -= 1;
+        options.chance.durations(.confusion, player, observation(volatiles.confusion));
 
         if (volatiles.confusion == 0) {
             volatiles.Confusion = false;
-            try log.end(ident, .Confusion);
+            try log.end(.{ ident, .Confusion });
         } else {
-            try log.activate(ident, .Confusion);
+            try log.activate(.{ ident, .Confusion });
 
             if (try Rolls.confused(battle, player, options)) {
                 assert(!volatiles.MultiHit);
@@ -579,7 +566,10 @@ fn beforeMove(
                 volatiles.Charging = false;
                 volatiles.Binding = false;
                 volatiles.Invulnerable = false;
-                options.chance.clearDurations(player, null);
+
+                options.chance.durations(.bide, player, .None);
+                options.chance.durations(.thrashing, player, .None);
+                options.chance.durations(.binding, player, .None);
                 {
                     // This feels (and is) disgusting but the cartridge literally just overwrites
                     // the opponent's defense with the user's defense and resets it after. As a
@@ -616,9 +606,13 @@ fn beforeMove(
         volatiles.Thrashing = false;
         volatiles.Charging = false;
         volatiles.Binding = false;
-        options.chance.clearDurations(player, null);
+
+        options.chance.durations(.bide, player, .None);
+        options.chance.durations(.thrashing, player, .None);
+        options.chance.durations(.binding, player, .None);
+
         // GLITCH: Invulnerable is not cleared, resulting in permanent Fly/Dig invulnerability
-        try log.cant(ident, .Paralysis);
+        try log.cant(.{ ident, .Paralysis });
         return .done;
     }
 
@@ -634,28 +628,22 @@ fn beforeMove(
             volatiles.state +%= battle.last_damage;
         }
 
-        assert(volatiles.attacks > 0);
-
-        if (options.calc.modify(player, .attacking)) |extend| {
-            if (!extend) volatiles.attacks = 0;
-        } else {
-            volatiles.attacks -= 1;
-        }
-        try options.chance.attacking(player, volatiles.attacks);
+        volatiles.attacks -= 1;
+        options.chance.durations(.bide, player, observation(volatiles.attacks));
 
         if (volatiles.attacks != 0) {
-            try log.activate(ident, .Bide);
+            try log.activate(.{ ident, .Bide });
             return .done;
         }
 
         volatiles.Bide = false;
-        try log.end(ident, .Bide);
+        try log.end(.{ ident, .Bide });
 
         battle.last_damage = volatiles.state *% 2;
         volatiles.state = 0;
 
         if (battle.last_damage == 0) {
-            try log.fail(ident, .None);
+            try log.fail(.{ ident, .None });
             return .done;
         }
 
@@ -675,41 +663,39 @@ fn beforeMove(
     }
 
     if (volatiles.Thrashing) {
-        assert(volatiles.attacks > 0);
+        try log.move(.{ ident, side.last_selected_move, battle.active(player.foe()) });
 
-        if (options.calc.modify(player, .attacking)) |extend| {
-            if (!extend) volatiles.attacks = 0;
-        } else {
-            volatiles.attacks -= 1;
-        }
-        try options.chance.attacking(player, volatiles.attacks);
+        volatiles.attacks -= 1;
+        options.chance.durations(
+            .thrashing,
+            player,
+            if (volatiles.attacks <= 1) .ended else .continuing,
+        );
 
-        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()));
-        if (showdown) {
-            // This shouldn't actually set last_used_move, but Pokémon Showdown sets last
-            // used in useMove and doesn't have the notion of skipping canMove semantics
-            side.last_used_move = side.last_selected_move;
-            if (handleThrashing(battle, active, player, options)) {
-                try log.start(battle.active(player), .ConfusionSilent);
-            }
+        if (volatiles.attacks == 0) {
+            volatiles.Thrashing = false;
+            volatiles.Confusion = true;
+            volatiles.confusion = Rolls.confusionDuration(battle, player, options);
+
+            // On Pokémon Showdown this could leak information to the opponent that thrashing has
+            // ended (the engine's protocol is always from the omniscient perspective and clients
+            // can be expected to recognize this pattern and pass the information only to the
+            // correct player)
+            try log.start(.{ battle.active(player), .ConfusionSilent });
         }
+
+        // This shouldn't actually set last_used_move, but Pokémon Showdown sets last
+        // used in useMove and doesn't have the notion of skipping canMove semantics
+        if (showdown) side.last_used_move = side.last_selected_move;
+
         return .skip_can;
     }
 
     if (volatiles.Binding) {
-        assert(volatiles.attacks > 0);
-
-        if (options.calc.modify(player, .binding)) |extend| {
-            if (!extend) volatiles.attacks = 0;
-        } else {
-            volatiles.attacks -= 1;
-        }
-        try options.chance.binding(player, volatiles.attacks);
+        volatiles.attacks -= 1;
+        options.chance.durations(.binding, player, observation(volatiles.attacks));
 
-        try log.move(battle.active(player), side.last_selected_move, battle.active(player.foe()));
+        try log.move(.{ ident, 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, options);
@@ -737,22 +723,21 @@ fn canMove(
     const player_ident = battle.active(player);
     const move = Move.get(side.last_selected_move);
 
-    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 options.log.moveFrom(player_ident, side.last_selected_move, .{}, from);
+        try options.log.move(.{ player_ident, side.last_selected_move, ID{}, from });
         setCounterable(battle, player, side, move);
         try Effects.charge(battle, player, options);
         return false;
     }
 
     side.last_used_move = side.last_selected_move;
-    if (!skip) decrementPP(side, mslot, auto);
+    if (!skip_pp) decrementPP(side, mslot, auto);
 
     const target = if (move.target == .Self) player else player.foe();
-    try options.log.moveFrom(player_ident, side.last_selected_move, battle.active(target), from);
+    try options.log.move(.{ player_ident, side.last_selected_move, battle.active(target), from });
     setCounterable(battle, player, side, move);
 
     if (move.effect.onBegin()) {
@@ -858,7 +843,7 @@ fn doMove(
             break :miss true;
         }
         break :miss (move.target != .Self and
-            !moveHit(battle, player, move, &immune, &mist, options));
+            !try moveHit(battle, player, move, &immune, &mist, options));
     };
     assert(!immune or miss or (showdown and move.effect == .Binding));
 
@@ -901,11 +886,11 @@ fn doMove(
         }
     }
 
-    var zero = battle.last_damage == 0;
+    const zero = battle.last_damage == 0;
     miss = if (showdown or skip)
         miss
     else
-        (!moveHit(battle, player, move, &immune, &mist, options) or zero);
+        (!try 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));
@@ -929,16 +914,16 @@ fn doMove(
         ohko = (!showdown or (!immune and !invulnerable)) and
             move.effect == .OHKO and side.active.stats.spe < foe.active.stats.spe;
         if (ohko) {
-            try log.immune(foe_ident, .OHKO);
+            try log.immune(.{ foe_ident, .OHKO });
         } else if (immune and !invulnerable and (!showdown or move.effect != .Binding)) {
-            try log.immune(foe_ident, .None);
+            try log.immune(.{ foe_ident, .None });
         } else if (mist) {
-            if (!foe.active.volatiles.Substitute) try log.activate(foe_ident, .Mist);
-            try log.fail(foe_ident, .None);
+            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));
+            if (!showdown and !zero) try options.chance.commit(player, .miss);
+            try log.lastmiss(.{});
+            try log.miss(.{battle.active(player)});
         }
         if (move.effect == .JumpKick) {
             // Recoil is supposed to be damage/8 but damage will always be 0 here
@@ -951,17 +936,15 @@ fn doMove(
             try buildRage(battle, player.foe(), options);
         } else if (showdown and move.effect == .Disable) {
             try buildRage(battle, player.foe(), options);
-        } else if (!showdown and immune and move.effect == .Binding) {
-            try options.chance.commit(player, .binding);
         }
         return null;
-    } else {
+    } else if (!showdown) {
         try options.chance.commit(player, .hit);
     }
 
     // On the cartridge MultiHit doesn't get set up until after damage has been applied for the
     // first time but its more convenient and efficient to set it up here (Pokémon Showdown sets
-    // it up above before damage calculation).
+    // it up above before damage calculation)
     if (!showdown and move.effect.isMulti()) {
         try Effects.multiHit(battle, player, move, options);
         hits = side.active.volatiles.attacks;
@@ -974,15 +957,15 @@ fn doMove(
     var hit: u4 = 0;
     while (hit < hits) {
         if (hit == 0) {
-            if (crit) try log.crit(battle.active(player.foe()));
+            if (crit) try log.crit(.{battle.active(player.foe())});
             if (effectiveness > Effectiveness.neutral) {
-                try log.supereffective(battle.active(player.foe()));
+                try log.supereffective(.{battle.active(player.foe())});
             } else if (effectiveness < Effectiveness.neutral) {
-                try log.resisted(battle.active(player.foe()));
+                try log.resisted(.{battle.active(player.foe())});
             }
         }
         if (!skip) nullified = try applyDamage(battle, player.foe(), player.foe(), .None, options);
-        if (hit == 0 and ohko) try log.ohko();
+        if (hit == 0 and ohko) try log.ohko(.{});
         hit += 1;
         if (foe.stored().hp == 0) break;
         if (!late and (!sub or move.effect == .Explode)) {
@@ -999,7 +982,7 @@ fn doMove(
         if (showdown and move.effect == .Twineedle and !nullified and foe.stored().hp > 0) {
             try Effects.poison(battle, player, Move.get(.PoisonSting), options);
         }
-        try log.hitcount(battle.active(player.foe()), hit);
+        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) {
@@ -1009,9 +992,9 @@ fn doMove(
                 assert(foe.stored().hp > 0);
                 // Pokémon Showdown logs |-damage| here instead of |-immune| because logic...
                 if (sub) {
-                    try log.activate(battle.active(player.foe()), .Substitute);
+                    try log.activate(.{ battle.active(player.foe()), .Substitute });
                 } else {
-                    try log.damage(battle.active(player.foe()), foe.stored(), .None);
+                    try log.damage(.{ battle.active(player.foe()), foe.stored(), .None });
                     try buildRage(battle, player.foe(), options);
                 }
                 return null;
@@ -1020,12 +1003,12 @@ fn doMove(
     }
 
     // Substitute being broken nullifies the move's effect completely so even
-    // if an effect was intended to "always happen" it will still get skipped.
+    // if an effect was intended to "always happen" it will still get skipped
     if (nullified) return null;
 
     // On the cartridge, "always happen" effect handlers are called in the applyDamage loop above,
     // but this is only done to setup the MultiHit looping in the first place. Moving the MultiHit
-    // setup before the loop means we can avoid having to waste time doing no-op handler searches.
+    // setup before the loop means we can avoid having to waste time doing no-op handler searches
     if (move.effect.alwaysHappens()) try alwaysHappens(battle, player, move, residual, options);
 
     if (foe.stored().hp == 0) return null;
@@ -1040,7 +1023,7 @@ fn doMove(
         // below). For Twineedle we change the data to that of one with PoisonChance1 given its
         // MultiHit behavior is complete after the loop above, though Pokémon Showdown handles the
         // Twineedle secondary effect in the MultiHit cleanup block above because it incorrectly
-        // puts the |-status| message before |-hitcount| instead of after.
+        // puts the |-status| message before |-hitcount| instead of after
         if (move.effect == .Twineedle) {
             if (!showdown) try Effects.poison(battle, player, Move.get(.PoisonSting), options);
         } else if (move.effect == .Disable) {
@@ -1059,12 +1042,14 @@ fn checkCriticalHit(battle: anytype, player: Player, move: Move.Data, options: a
     const side = battle.side(player);
 
     // Base speed is used for the critical hit calculation, even when Transform-ed
-    var rate = @as(u16, Species.chance(side.stored().species));
+    var rate: 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, player, @intCast(rate), options);
+    const spurious =
+        !showdown and ((move.bp == 0 and move.effect != .OHKO) or move.target == .Depends);
+    return Rolls.criticalHit(battle, player, @intCast(rate), spurious, options);
 }
 
 fn calcDamage(
@@ -1116,9 +1101,9 @@ fn calcDamage(
         def = @max((def / 4) & 255, if (showdown) 1 else 0);
     }
 
-    const lvl = @as(u32, side.stored().level * @as(u2, if (crit) 2 else 1));
+    const lvl: u32 = side.stored().level * @as(u2, if (crit) 2 else 1);
 
-    def = @as(u32, if (move.effect == .Explode) @max(def / 2, 1) else def);
+    def = if (move.effect == .Explode) @max(def / 2, 1) else def;
 
     if (def == 0) return false;
 
@@ -1179,7 +1164,6 @@ fn specialDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
     const foe = battle.foe(player);
 
     if (!try checkHit(battle, player, move, options)) return null;
-    try options.chance.commit(player, .hit);
 
     battle.last_damage = switch (side.last_selected_move) {
         .SuperFang => @max(foe.stored().hp / 2, 1),
@@ -1209,7 +1193,7 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
     const foe = battle.foe(player);
 
     if (battle.last_damage == 0) {
-        try options.log.fail(battle.active(player), .None);
+        try options.log.fail(.{ battle.active(player), .None });
         return null;
     }
 
@@ -1227,22 +1211,21 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
         foe_last_selected_move.type == .Fighting);
 
     if (!used and !selected) {
-        try options.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 options.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
+    // Pokémon Showdown calls moveHit before Counter
     if (!showdown and !try checkHit(battle, player, move, options)) return null;
-    try options.chance.commit(player, .hit);
 
     const sub = showdown and foe.active.volatiles.Substitute;
     _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
@@ -1270,20 +1253,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 options.log.end(battle.active(sub_player), .Substitute);
-            options.calc.capped(target_player);
+            try options.log.end(.{ battle.active(sub_player), .Substitute });
+            options.calc.capped(sub_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 options.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 options.log.damage(battle.active(target_player), target.stored(), reason);
+    try options.log.damage(.{ battle.active(target_player), target.stored(), reason });
     return false;
 }
 
@@ -1302,7 +1285,7 @@ fn mirrorMove(
     side.last_selected_move = foe.last_used_move;
 
     if (foe.last_used_move == .None or foe.last_used_move == .MirrorMove) {
-        try options.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);
@@ -1338,20 +1321,23 @@ fn checkHit(battle: anytype, player: Player, move: Move.Data, options: anytype)
     var immune = false;
     var mist = false;
 
-    if (moveHit(battle, player, move, &immune, &mist, options)) return true;
+    if (try moveHit(battle, player, move, &immune, &mist, options)) {
+        if (!showdown) try options.chance.commit(player, .hit);
+        return true;
+    }
 
     assert(!immune);
     if (mist) {
         assert(!showdown);
         const foe_ident = battle.active(player.foe());
-        try options.log.activate(foe_ident, .Mist);
-        try options.log.fail(foe_ident, .None);
+        try options.log.activate(.{ foe_ident, .Mist });
+        try options.log.fail(.{ foe_ident, .None });
     } else {
-        try options.chance.commit(player, .miss);
-        try options.log.lastmiss();
-        try options.log.miss(battle.active(player));
+        try options.log.lastmiss(.{});
+        try options.log.miss(.{battle.active(player)});
     }
 
+    if (!showdown) try options.chance.commit(player, .miss);
     return false;
 }
 
@@ -1362,7 +1348,7 @@ fn moveHit(
     immune: *bool,
     mist: *bool,
     options: anytype,
-) bool {
+) !bool {
     var side = battle.side(player);
     const foe = battle.foe(player);
 
@@ -1401,7 +1387,7 @@ fn moveHit(
         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, move.accuracy);
+        var accuracy: u16 = if (overwritten) state else move.accuracy;
         var boost = BOOSTS[@as(u4, @intCast(@as(i8, side.active.boosts.accuracy) + 6))];
         accuracy = accuracy * boost[0] / boost[1];
         boost = BOOSTS[@as(u4, @intCast(@as(i8, -foe.active.boosts.evasion) + 6))];
@@ -1413,7 +1399,7 @@ fn moveHit(
         if (overwrite) side.active.volatiles.state = accuracy;
 
         // GLITCH: max accuracy is 255 so 1/256 chance of miss
-        break :miss !Rolls.hit(battle, player, @intCast(accuracy), options);
+        break :miss !try Rolls.hit(battle, player, @intCast(accuracy), options);
     };
 
     // Pokémon Showdown reports miss instead of fail for moves blocked by Mist that 1/256 miss
@@ -1431,6 +1417,7 @@ fn moveHit(
 fn checkFaint(
     battle: anytype,
     player: Player,
+    cap: bool,
     options: anytype,
 ) @TypeOf(options.log).Error!?Result {
     const side = battle.side(player);
@@ -1443,20 +1430,20 @@ fn checkFaint(
     const foe_out = foe_fainted and findFirstAlive(foe) == 0;
     const more = player_out or foe_out;
 
-    if (try faint(battle, player, !(more or foe_fainted), options)) |r| return r;
-    if (foe_fainted) if (try faint(battle, player.foe(), !more, options)) |r| return r;
+    if (try faint(battle, player, !(more or foe_fainted), cap, options)) |r| return r;
+    if (foe_fainted) if (try faint(battle, player.foe(), !more, false, options)) |r| return r;
 
     assert(!side.active.volatiles.MultiHit);
     assert(!foe.active.volatiles.MultiHit);
 
     if (player_out and foe_out) {
-        try options.log.tie();
+        try options.log.tie(.{});
         return Result.Tie;
     } else if (player_out) {
-        try options.log.win(player.foe());
+        try options.log.win(.{player.foe()});
         return if (player == .P1) Result.Lose else Result.Win;
     } else if (foe_out) {
-        try options.log.win(player);
+        try options.log.win(.{player});
         return if (player == .P1) Result.Win else Result.Lose;
     }
 
@@ -1465,7 +1452,7 @@ fn checkFaint(
     return .{ .p1 = foe_choice, .p2 = .Switch };
 }
 
-fn faint(battle: anytype, player: Player, done: bool, options: anytype) !?Result {
+fn faint(battle: anytype, player: Player, done: bool, cap: bool, options: anytype) !?Result {
     var side = battle.side(player);
     var foe = battle.foe(player);
     assert(side.stored().hp == 0);
@@ -1498,8 +1485,10 @@ fn faint(battle: anytype, player: Player, done: bool, options: anytype) !?Result
             side.stored().stats.spe;
     }
 
-    try options.log.faint(battle.active(player), done);
-    options.calc.capped(player);
+    try options.log.faint(.{ battle.active(player), done });
+    // We can only safely set capped if the faint occured as the direct result of an opponent's
+    // move (as opposed to due to residual damage, recoil, Explosion, etc)
+    if (cap) options.calc.capped(player);
     return null;
 }
 
@@ -1520,8 +1509,8 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !void {
 
         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);
+            // Pokémon Showdown uses damage [of] here but its not relevant in Generation I
+            try options.log.damage(.{ ident, stored, if (brn) Damage.Burn else Damage.Poison });
         }
     }
 
@@ -1546,14 +1535,14 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !void {
         const amount = @min(damage, stored.hp);
         stored.hp -= amount;
 
-        // As above, Pokémon Showdown uses damageOf but its not relevant
-        if (amount > 0) try options.log.damage(ident, stored, .LeechSeed);
+        // As above, Pokémon Showdown uses damage [of] but its not relevant
+        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 options.log.heal(foe_ident, foe_stored, .Silent);
+        if (foe_stored.hp > before) try options.log.heal(.{ foe_ident, foe_stored, .Silent });
     }
 }
 
@@ -1564,18 +1553,18 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
     battle.turn += 1;
 
     if (showdown and pkmn.options.ebc and checkEBC(battle)) {
-        try options.log.tie();
+        try options.log.tie(.{});
         return Result.Tie;
     }
 
     if (showdown and battle.turn >= 1000) {
-        try options.log.tie();
+        try options.log.tie(.{});
         return Result.Tie;
     } else if (battle.turn >= 65535) {
         return Result.Error;
     }
 
-    try options.log.turn(battle.turn);
+    try options.log.turn(.{battle.turn});
 
     return Result.Default;
 }
@@ -1645,7 +1634,7 @@ fn disabled(side: *Side, ident: ID, options: anytype) !bool {
             side.last_selected_move;
         if (m != .None and m == last) {
             side.active.volatiles.Charging = false;
-            try options.log.disabled(ident, last);
+            try options.log.cant(.{ ident, .Disable, last });
             return true;
         }
     }
@@ -1659,17 +1648,6 @@ fn buildRage(battle: anytype, who: Player, options: anytype) !void {
     }
 }
 
-fn handleThrashing(battle: anytype, active: *ActivePokemon, player: Player, options: anytype) bool {
-    var volatiles = &active.volatiles;
-    assert(volatiles.Thrashing);
-    if (volatiles.attacks > 0) return false;
-
-    volatiles.Thrashing = false;
-    volatiles.Confusion = true;
-    volatiles.confusion = Rolls.confusionDuration(battle, player, true, options);
-    return true;
-}
-
 fn onBegin(
     battle: anytype,
     player: Player,
@@ -1678,7 +1656,6 @@ fn onBegin(
     residual: *bool,
     options: anytype,
 ) !void {
-    assert(move.effect.onBegin());
     return switch (move.effect) {
         .Confusion => Effects.confusion(battle, player, move, options),
         .Conversion => Effects.conversion(battle, player, options),
@@ -1701,7 +1678,6 @@ fn onBegin(
 }
 
 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, options),
         // zig fmt: off
@@ -1723,7 +1699,6 @@ fn alwaysHappens(
     residual: *bool,
     options: anytype,
 ) !void {
-    assert(move.effect.alwaysHappens());
     return switch (move.effect) {
         .DrainHP, .DreamEater => Effects.drainHP(battle, player, options),
         .Explode => Effects.explode(battle, player),
@@ -1759,10 +1734,12 @@ pub const Effects = struct {
 
         side.active.volatiles.Bide = true;
         assert(!side.active.volatiles.Thrashing and !side.active.volatiles.Rage);
+
         side.active.volatiles.state = 0;
         side.active.volatiles.attacks = Rolls.attackingDuration(battle, player, options);
+        options.chance.durations(.bide, player, .started);
 
-        try options.log.start(battle.active(player), .Bide);
+        try options.log.start(.{ battle.active(player), .Bide });
     }
 
     fn burnChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
@@ -1776,11 +1753,11 @@ 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 options.log.curestatus(
+                try options.log.curestatus(.{
                     battle.active(player.foe()),
                     foe_stored.status,
                     .Message,
-                );
+                });
                 foe_stored.status = 0;
             }
             return;
@@ -1794,7 +1771,7 @@ pub const Effects = struct {
         foe_stored.status = Status.init(.BRN);
         foe.active.stats.atk = @max(foe.active.stats.atk / 2, 1);
 
-        try options.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, options: anytype) !void {
@@ -1804,8 +1781,8 @@ pub const Effects = struct {
         volatiles.Charging = true;
         const move = side.last_selected_move;
         if (move == .Fly or move == .Dig) volatiles.Invulnerable = true;
-        try options.log.laststill();
-        try options.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, options: anytype) !void {
@@ -1816,42 +1793,38 @@ pub const Effects = struct {
             if (!try Rolls.confusionChance(battle, player, options)) return;
         } else {
             if (showdown) {
-                if (!try checkHit(battle, player, move, options)) {
-                    return;
-                } else if (sub) {
-                    return options.log.fail(battle.active(player.foe()), .None);
-                }
+                if (!try checkHit(battle, player, move, options)) return;
+                if (sub) return options.log.fail(.{ battle.active(player.foe()), .None });
             } else {
-                if (sub) {
-                    return options.log.fail(battle.active(player.foe()), .None);
-                } else if (!try checkHit(battle, player, move, options)) {
-                    return;
-                }
+                if (sub) return options.log.fail(.{ battle.active(player.foe()), .None });
+                if (!try checkHit(battle, player, move, options)) return;
             }
-            try options.chance.commit(player, .hit);
         }
 
         if (foe.active.volatiles.Confusion) return;
         foe.active.volatiles.Confusion = true;
-        foe.active.volatiles.confusion = Rolls.confusionDuration(battle, player, false, options);
 
-        try options.log.start(battle.active(player.foe()), .Confusion);
+        foe.active.volatiles.confusion = Rolls.confusionDuration(battle, player, options);
+        options.chance.durations(.confusion, player.foe(), .started);
+
+        try options.log.start(.{ battle.active(player.foe()), .Confusion });
     }
 
     fn conversion(battle: anytype, player: Player, options: anytype) !void {
         const foe = battle.foe(player);
 
         if (foe.active.volatiles.Invulnerable) {
-            try options.log.lastmiss();
-            return options.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 options.log.typechange(
+        return options.log.start(.{
             battle.active(player),
+            .TypeChange,
             foe.active.types,
             battle.active(player.foe()),
-        );
+        });
     }
 
     fn disable(battle: anytype, player: Player, move: Move.Data, options: anytype) !?Result {
@@ -1860,13 +1833,10 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
 
         // Pokémon Showdown handles hit/miss earlier in doMove
-        if (!showdown) {
-            if (!try checkHit(battle, player, move, options)) return null;
-            try options.chance.commit(player, .hit);
-        }
+        if (!showdown and !try checkHit(battle, player, move, options)) return null;
 
         if (volatiles.disable_move != 0) {
-            try options.log.fail(foe_ident, .None);
+            try options.log.fail(.{ foe_ident, .None });
             return null;
         }
 
@@ -1882,7 +1852,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 options.log.fail(foe_ident, .None);
+            try options.log.fail(.{ foe_ident, .None });
             return null;
         } else if (err) {
             // GLITCH: Transform + Mirror Move / Metronome PP softlock
@@ -1893,14 +1863,16 @@ pub const Effects = struct {
         volatiles.disable_move =
             @intCast(try Rolls.moveSlot(battle, player, &foe.active.moves, n, options));
         volatiles.disable_duration = Rolls.disableDuration(battle, player, options);
+        options.chance.durations(.disable, player.foe(), .started);
 
         const id = foe.active.move(volatiles.disable_move).id;
-        try options.log.startEffect(foe_ident, .Disable, id);
+        try options.log.start(.{ foe_ident, .Disable, id });
         return null;
     }
 
     fn drainHP(battle: anytype, player: Player, options: anytype) !void {
         var stored = battle.side(player).stored();
+        const ident = battle.active(player);
 
         if (battle.last_damage == 0) {
             assert(showdown);
@@ -1913,7 +1885,7 @@ pub const Effects = struct {
         if (stored.hp == stored.stats.hp) return;
         stored.hp = @min(stored.stats.hp, stored.hp + drain);
 
-        try options.log.drain(battle.active(player), stored, battle.active(player.foe()));
+        try options.log.heal(.{ ident, stored, .Drain, battle.active(player.foe()) });
     }
 
     fn explode(battle: anytype, player: Player) !void {
@@ -1945,7 +1917,7 @@ pub const Effects = struct {
         if (side.active.volatiles.FocusEnergy) return;
         side.active.volatiles.FocusEnergy = true;
 
-        try options.log.start(battle.active(player), .FocusEnergy);
+        try options.log.start(.{ battle.active(player), .FocusEnergy });
     }
 
     fn freezeChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
@@ -1967,7 +1939,7 @@ pub const Effects = struct {
         foe_stored.status = Status.init(.FRZ);
         // GLITCH: Hyper Beam recharging status is not cleared
 
-        try options.log.status(foe_ident, foe_stored.status, .None);
+        try options.log.status(.{ foe_ident, foe_stored.status, .None });
     }
 
     fn haze(battle: anytype, player: Player, options: anytype) !void {
@@ -1975,7 +1947,7 @@ pub const Effects = struct {
         var side = battle.side(player);
         var foe = battle.foe(player);
 
-        var side_stored = side.stored();
+        const side_stored = side.stored();
         var foe_stored = foe.stored();
 
         const player_ident = battle.active(player);
@@ -1987,8 +1959,8 @@ pub const Effects = struct {
         side.active.stats = side_stored.stats;
         foe.active.stats = foe_stored.stats;
 
-        try log.activate(player_ident, .Haze);
-        try log.clearallboost();
+        try log.activate(.{ player_ident, .Haze });
+        try log.clearallboost(.{});
 
         // Pokémon Showdown clears P1 then P2 instead of status -> side -> foe
         if (showdown) {
@@ -1996,24 +1968,26 @@ pub const Effects = struct {
                 const p: Player = @enumFromInt(i);
                 // Pokémon Showdown incorrectly does not prevent sleep/freeze from moving
                 if (p != player and Status.any(s.stored().status)) {
-                    try log.curestatus(foe_ident, foe_stored.status, .Silent);
+                    try log.curestatus(.{ foe_ident, foe_stored.status, .Silent });
                     s.stored().status = 0;
+                    options.chance.durations(.sleep, p, .None);
                 } else if (showdown and s.stored().status == Status.TOX) {
                     s.stored().status = Status.init(.PSN);
-                    try log.status(battle.active(p), s.stored().status, .None);
+                    try log.status(.{ battle.active(p), s.stored().status, .None });
                 }
-                try clearVolatiles(battle, p, p != player, options);
+                try clearVolatiles(battle, p, options);
             }
         } else {
             if (Status.any(foe_stored.status)) {
                 if (Status.is(foe_stored.status, .FRZ) or Status.is(foe_stored.status, .SLP)) {
                     foe.last_selected_move = .SKIP_TURN;
+                    options.chance.durations(.sleep, player.foe(), .None);
                 }
-                try log.curestatus(foe_ident, foe_stored.status, .Silent);
+                try log.curestatus(.{ foe_ident, foe_stored.status, .Silent });
                 foe_stored.status = 0;
             }
-            try clearVolatiles(battle, player, false, options);
-            try clearVolatiles(battle, player.foe(), true, options);
+            try clearVolatiles(battle, player, options);
+            try clearVolatiles(battle, player.foe(), options);
         }
     }
 
@@ -2025,7 +1999,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 options.log.fail(ident, .None);
+            return options.log.fail(.{ ident, .None });
         }
 
         const rest = side.last_selected_move == .Rest;
@@ -2033,17 +2007,17 @@ 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 options.log.statusFrom(ident, stored.status, Move.Rest);
+            try options.log.status(.{ ident, stored.status, .From, Move.Rest });
             stored.hp = stored.stats.hp;
         } else {
             stored.hp = @min(stored.stats.hp, stored.hp + (stored.stats.hp / 2));
         }
-        try options.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, options: anytype) !void {
         battle.side(player).active.volatiles.Recharging = true;
-        try options.log.mustrecharge(battle.active(player));
+        try options.log.mustrecharge(.{battle.active(player)});
     }
 
     fn leechSeed(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
@@ -2052,33 +2026,31 @@ pub const Effects = struct {
         if (showdown) {
             // Invulnerability trumps type immunity on Pokémon Showdown
             if (!foe.active.volatiles.Invulnerable and foe.active.types.includes(.Grass)) {
-                return options.log.immune(battle.active(player.foe()), .None);
+                return options.log.immune(.{ battle.active(player.foe()), .None });
             }
             if (!try checkHit(battle, player, move, options)) return;
             if (foe.active.volatiles.LeechSeed) return;
         } else {
             if (!try checkHit(battle, player, move, options)) return;
             if (foe.active.types.includes(.Grass) or foe.active.volatiles.LeechSeed) {
-                try options.log.lastmiss();
-                return options.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 options.log.start(battle.active(player.foe()), .LeechSeed);
+        try options.log.start(.{ battle.active(player.foe()), .LeechSeed });
     }
 
     fn lightScreen(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
+        const ident = battle.active(player);
 
-        if (side.active.volatiles.LightScreen) {
-            return options.log.fail(battle.active(player), .None);
-        }
+        if (side.active.volatiles.LightScreen) return options.log.fail(.{ ident, .None });
         side.active.volatiles.LightScreen = true;
 
-        try options.log.start(battle.active(player), .LightScreen);
+        try options.log.start(.{ ident, .LightScreen });
     }
 
     fn mimic(battle: anytype, player: Player, move: Move.Data, mslot: u8, options: anytype) !void {
@@ -2106,17 +2078,15 @@ pub const Effects = struct {
             if (!has_mimic) {
                 // Invulnerable foes or 1/256 miss can trigger |-miss| instead of |-fail|
                 if (!try checkHit(battle, player, move, options)) return;
-                try options.chance.commit(player, .hit);
-                return try options.log.fail(battle.active(player.foe()), .None);
+                return options.log.fail(.{ battle.active(player.foe()), .None });
             }
         }
         if (!try checkHit(battle, player, move, options)) return;
-        try options.chance.commit(player, .hit);
 
         const rslot = try Rolls.moveSlot(battle, player, &foe.active.moves, 0, options);
         side.active.move(oslot).id = foe.active.move(rslot).id;
 
-        try options.log.startEffect(battle.active(player), .Mimic, side.active.move(oslot).id);
+        try options.log.start(.{ battle.active(player), .Mimic, side.active.move(oslot).id });
     }
 
     fn mist(battle: anytype, player: Player, options: anytype) !void {
@@ -2125,7 +2095,7 @@ pub const Effects = struct {
         if (side.active.volatiles.Mist) return;
         side.active.volatiles.Mist = true;
 
-        try options.log.start(battle.active(player), .Mist);
+        try options.log.start(.{ battle.active(player), .Mist });
     }
 
     fn multiHit(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
@@ -2151,25 +2121,25 @@ 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, options)) return;
+            if (immune and !foe.active.volatiles.Invulnerable) {
+                return log.immune(.{ foe_ident, .None });
+            } else if (!try checkHit(battle, player, move, options)) return;
         }
         if (Status.any(foe_stored.status)) {
-            return log.fail(
+            return log.fail(.{
                 foe_ident,
-                if (Status.is(foe_stored.status, .PAR)) .Paralysis else .None,
-            );
+                if (Status.is(foe_stored.status, .PAR)) Fail.Paralysis else Fail.None,
+            });
         }
         if (!showdown) {
-            if (immune) return log.immune(foe_ident, .None);
+            if (immune) return log.immune(.{ foe_ident, .None });
             if (!try checkHit(battle, player, move, options)) return;
         }
-        try options.chance.commit(player, .hit);
 
         foe_stored.status = Status.init(.PAR);
         foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
 
-        try log.status(foe_ident, foe_stored.status, .None);
+        try log.status(.{ foe_ident, foe_stored.status, .None });
     }
 
     fn paralyzeChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
@@ -2191,12 +2161,12 @@ pub const Effects = struct {
         foe_stored.status = Status.init(.PAR);
         foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
 
-        try options.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, options: anytype) !void {
         if (!showdown or !battle.foe(player).active.volatiles.Substitute) {
-            try options.log.fieldactivate();
+            try options.log.fieldactivate(.{});
         }
     }
 
@@ -2211,28 +2181,27 @@ pub const Effects = struct {
             return;
         } else if (foe.active.volatiles.Substitute) {
             if (move.effect != .Poison) return;
-            return log.fail(foe_ident, .None);
+            return log.fail(.{ foe_ident, .None });
         } else if (Status.any(foe_stored.status)) {
             if (move.effect != .Poison) return if (showdown) battle.rng.advance(1);
             // Pokémon Showdown considers Toxic to be a status even in Generation I and so
             // will not include a fail reason for Toxic vs. Poison or vice-versa...
-            return log.fail(foe_ident, if (Status.is(foe_stored.status, .PSN))
+            return log.fail(.{ foe_ident, if (Status.is(foe_stored.status, .PSN))
                 if (!showdown)
-                    .Poison
+                    Fail.Poison
                 else if (toxic == (foe_stored.status == Status.TOX))
-                    if (toxic) .Toxic else .Poison
+                    if (toxic) Fail.Toxic else Fail.Poison
                 else
-                    .None
+                    Fail.None
             else
-                .None);
+                Fail.None });
         } else if (foe.active.types.includes(.Poison)) {
             if (move.effect != .Poison) return if (showdown) battle.rng.advance(1);
-            return log.immune(foe_ident, .None);
+            return log.immune(.{ foe_ident, .None });
         }
 
         if (move.effect == .Poison) {
             if (!showdown and !try checkHit(battle, player, move, options)) return;
-            try options.chance.commit(player, .hit);
         } else {
             if (!try Rolls.poisonChance(battle, player, move.effect == .PoisonChance1, options)) {
                 return;
@@ -2246,7 +2215,7 @@ pub const Effects = struct {
             foe.active.volatiles.toxic = 0;
         }
 
-        try log.status(foe_ident, foe_stored.status, .None);
+        try log.status(.{ foe_ident, foe_stored.status, .None });
     }
 
     fn rage(battle: anytype, player: Player) !void {
@@ -2266,22 +2235,23 @@ 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 options.log.damageOf(
+        try options.log.damage(.{
             battle.active(player),
             stored,
             .RecoilOf,
             battle.active(player.foe()),
-        );
+        });
         if (showdown and stored.hp == 0) residual.* = false;
     }
 
     fn reflect(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
+        const ident = battle.active(player);
 
-        if (side.active.volatiles.Reflect) return options.log.fail(battle.active(player), .None);
+        if (side.active.volatiles.Reflect) return options.log.fail(.{ ident, .None });
         side.active.volatiles.Reflect = true;
 
-        try options.log.start(battle.active(player), .Reflect);
+        try options.log.start(.{ ident, .Reflect });
     }
 
     fn sleep(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
@@ -2295,14 +2265,13 @@ pub const Effects = struct {
             // the Sleep Clause Mod might activate, causing us to not actually bypass
         } else {
             if (Status.any(foe_stored.status)) {
-                return options.log.fail(
+                return options.log.fail(.{
                     foe_ident,
-                    if (Status.is(foe_stored.status, .SLP)) .Sleep else .None,
-                );
+                    if (Status.is(foe_stored.status, .SLP)) Fail.Sleep else Fail.None,
+                });
             }
-            // If checkHit in doMove didn't return true Pokémon Showdown wouldn't be in here
+            // If moveHit in doMove didn't return true Pokémon Showdown wouldn't be in here
             if (!showdown and !try checkHit(battle, player, move, options)) return;
-            try options.chance.commit(player, .hit);
         }
 
         // Sleep Clause Mod
@@ -2314,19 +2283,20 @@ pub const Effects = struct {
         foe.active.volatiles.Recharging = false;
 
         foe_stored.status = Status.slp(Rolls.sleepDuration(battle, player, options));
+        options.chance.durations(.sleep, player.foe(), .started);
+
         const last = battle.side(player).last_selected_move;
-        try options.log.statusFrom(foe_ident, foe_stored.status, last);
+        try options.log.status(.{ foe_ident, foe_stored.status, .From, last });
     }
 
     fn splash(battle: anytype, player: Player, options: anytype) !void {
-        try options.log.activate(battle.active(player), .Splash);
+        try options.log.activate(.{ battle.active(player), .Splash });
     }
 
     fn substitute(battle: anytype, player: Player, residual: *bool, options: anytype) !void {
         var side = battle.side(player);
         if (side.active.volatiles.Substitute) {
-            try options.log.fail(battle.active(player), .Substitute);
-            return;
+            return options.log.fail(.{ battle.active(player), .Substitute });
         }
 
         assert(side.stored().stats.hp <= 1023);
@@ -2338,17 +2308,16 @@ pub const Effects = struct {
         // 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 options.log.fail(battle.active(player), .Weak);
-            return;
+            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 options.log.start(battle.active(player), .Substitute);
+        try options.log.start(.{ battle.active(player), .Substitute });
         if (hp > 0) {
-            try options.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;
         }
     }
@@ -2357,13 +2326,11 @@ pub const Effects = struct {
         // Whirlwind/Roar should not roll to hit/reset damage but Pokémon Showdown does anyway
         if (showdown) {
             if (battle.side(player).last_selected_move == .Teleport) return;
-            if (try checkHit(battle, player, move, options)) {
-                try options.chance.commit(player, .hit);
-            }
+            _ = try checkHit(battle, player, move, options);
             battle.last_damage = 0;
         } else {
-            try options.log.fail(battle.active(player), .None);
-            try options.log.laststill();
+            try options.log.fail(.{ battle.active(player), .None });
+            try options.log.laststill(.{});
         }
     }
 
@@ -2374,6 +2341,8 @@ pub const Effects = struct {
 
         volatiles.Thrashing = true;
         volatiles.attacks = Rolls.attackingDuration(battle, player, options);
+
+        options.chance.durations(.thrashing, player, .started);
     }
 
     fn transform(battle: anytype, player: Player, options: anytype) !void {
@@ -2402,7 +2371,7 @@ pub const Effects = struct {
             side.active.moves[i].pp = if (m.id != .None) 5 else 0;
         }
 
-        try options.log.transform(battle.active(player), foe_ident);
+        try options.log.transform(.{ battle.active(player), foe_ident });
     }
 
     fn binding(battle: anytype, player: Player, rewrap: bool, options: anytype) !void {
@@ -2419,6 +2388,7 @@ pub const Effects = struct {
 
         side.active.volatiles.attacks =
             try Rolls.distribution(battle, .Binding, player, options) - 1;
+        options.chance.durations(.binding, player, .started);
     }
 
     fn boost(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
@@ -2432,87 +2402,87 @@ 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 = @as(i4, @intCast(@min(6, @as(i8, boosts.atk) + n)));
-                const reason = if (move.effect == .Rage) Boost.Rage else Boost.Attack;
+                const reason: Boost = if (move.effect == .Rage) .Rage else .Attack;
                 if (stats.atk == MAX_STAT_VALUE) {
                     boosts.atk -= 1;
                     if (showdown) {
-                        try log.boost(ident, reason, n);
-                        try log.boost(ident, Boost.Attack, -1);
+                        try log.boost(.{ ident, reason, n });
+                        try log.boost(.{ ident, .Attack, -1 });
                         if (move.effect == .Rage) return;
                     }
-                    return try log.fail(ident, .None);
+                    return log.fail(.{ ident, .None });
                 }
-                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.atk) + 6))];
+                const 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);
+                try log.boost(.{ ident, reason, n });
                 // Pokémon Showdown doesn't re-apply status modifiers after Rage boosts
                 if (showdown and move.effect == .Rage) return;
             },
             .DefenseUp1, .DefenseUp2 => {
                 assert(boosts.def >= -6 and boosts.def <= 6);
-                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) {
                     boosts.def -= 1;
                     if (showdown) {
-                        try log.boost(ident, .Defense, n);
-                        try log.boost(ident, .Defense, -1);
+                        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[@as(u4, @intCast(@as(i8, boosts.def) + 6))];
+                const 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);
+                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;
                     if (showdown) {
-                        try log.boost(ident, .Speed, 2);
-                        try log.boost(ident, .Speed, -1);
+                        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[@as(u4, @intCast(@as(i8, boosts.spe) + 6))];
+                const 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);
+                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) {
                     boosts.spc -= 1;
                     if (showdown) {
-                        try log.boost(ident, .SpecialAttack, n);
-                        try log.boost(ident, .SpecialAttack, -1);
-                        try log.boost(ident, .SpecialDefense, n);
-                        try log.boost(ident, .SpecialDefense, -1);
+                        try log.boost(.{ ident, .SpecialAttack, n });
+                        try log.boost(.{ ident, .SpecialAttack, -1 });
+                        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[@as(u4, @intCast(@as(i8, boosts.spc) + 6))];
+                const 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);
-                try log.boost(ident, .SpecialDefense, n);
+                try log.boost(.{ ident, .SpecialAttack, n });
+                try log.boost(.{ ident, .SpecialDefense, n });
             },
             .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);
+                try log.boost(.{ ident, .Evasion, 1 });
             },
             else => unreachable,
         }
@@ -2527,7 +2497,7 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
         const secondary = move.effect.isStatDownChance();
 
-        if (foe.active.volatiles.Substitute) return if (!secondary) log.fail(foe_ident, .None);
+        if (foe.active.volatiles.Substitute) return if (!secondary) log.fail(.{ foe_ident, .None });
 
         if (secondary) {
             const proc = try Rolls.unboost(battle, player, options);
@@ -2535,7 +2505,6 @@ pub const Effects = struct {
         } else {
             // checkHit already checks for Invulnerable
             if (!showdown and !try checkHit(battle, player, move, options)) return;
-            try options.chance.commit(player, .hit);
         }
 
         var stats = &foe.active.stats;
@@ -2545,82 +2514,82 @@ pub const Effects = struct {
         switch (move.effect) {
             .AttackDown1, .AttackDownChance => {
                 assert(boosts.atk >= -6 and boosts.atk <= 6);
-                if (boosts.atk == -6) return if (fail) try log.fail(foe_ident, .None);
+                if (boosts.atk == -6) return if (fail) try log.fail(.{ foe_ident, .None });
                 boosts.atk = @intCast(@max(-6, @as(i8, boosts.atk) - 1));
                 if (stats.atk == 1) {
                     boosts.atk += 1;
                     if (showdown) {
-                        try log.boost(foe_ident, .Attack, -1);
-                        try log.boost(foe_ident, .Attack, 1);
+                        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[@as(u4, @intCast(@as(i8, boosts.atk) + 6))];
+                const 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);
+                try log.boost(.{ foe_ident, .Attack, -1 });
             },
             .DefenseDown1, .DefenseDown2, .DefenseDownChance => {
                 assert(boosts.def >= -6 and boosts.def <= 6);
-                if (boosts.def == -6) return if (fail) try log.fail(foe_ident, .None);
+                if (boosts.def == -6) return if (fail) try log.fail(.{ foe_ident, .None });
                 const n: u2 = if (move.effect == .DefenseDown2) 2 else 1;
                 boosts.def = @intCast(@max(-6, @as(i8, boosts.def) - n));
                 if (stats.def == 1) {
                     boosts.def += 1;
                     if (showdown) {
-                        try log.boost(foe_ident, .Defense, -@as(i8, n));
-                        try log.boost(foe_ident, .Defense, 1);
+                        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[@as(u4, @intCast(@as(i8, boosts.def) + 6))];
+                const 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));
+                try log.boost(.{ foe_ident, .Defense, -@as(i8, n) });
             },
             .SpeedDown1, .SpeedDownChance => {
                 assert(boosts.spe >= -6 and boosts.spe <= 6);
-                if (boosts.spe == -6) return if (fail) try log.fail(foe_ident, .None);
+                if (boosts.spe == -6) return if (fail) try log.fail(.{ foe_ident, .None });
                 boosts.spe = @intCast(@max(-6, @as(i8, boosts.spe) - 1));
                 if (stats.spe == 1) {
                     boosts.spe += 1;
                     if (showdown) {
-                        try log.boost(foe_ident, .Speed, -1);
-                        try log.boost(foe_ident, .Speed, 1);
+                        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[@as(u4, @intCast(@as(i8, boosts.spe) + 6))];
+                const 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);
+                try log.boost(.{ foe_ident, .Speed, -1 });
                 assert(boosts.spe >= -6);
             },
             .SpecialDownChance => {
                 assert(boosts.spc >= -6 and boosts.spc <= 6);
-                if (boosts.spc == -6) return if (fail) try log.fail(foe_ident, .None);
+                if (boosts.spc == -6) return if (fail) try log.fail(.{ foe_ident, .None });
                 boosts.spc = @intCast(@max(-6, @as(i8, boosts.spc) - 1));
                 if (stats.spc == 1) {
                     boosts.spc += 1;
                     if (showdown) {
-                        try log.boost(foe_ident, .SpecialAttack, -1);
-                        try log.boost(foe_ident, .SpecialAttack, 1);
-                        try log.boost(foe_ident, .SpecialDefense, -1);
-                        try log.boost(foe_ident, .SpecialDefense, 1);
+                        try log.boost(.{ foe_ident, .SpecialAttack, -1 });
+                        try log.boost(.{ foe_ident, .SpecialAttack, 1 });
+                        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[@as(u4, @intCast(@as(i8, boosts.spc) + 6))];
+                const 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);
-                try log.boost(foe_ident, .SpecialDefense, -1);
+                try log.boost(.{ foe_ident, .SpecialAttack, -1 });
+                try log.boost(.{ foe_ident, .SpecialDefense, -1 });
             },
             .AccuracyDown1 => {
                 assert(boosts.accuracy >= -6 and boosts.accuracy <= 6);
-                if (boosts.accuracy == -6) return if (fail) try log.fail(foe_ident, .None);
+                if (boosts.accuracy == -6) return if (fail) try log.fail(.{ foe_ident, .None });
                 boosts.accuracy = @intCast(@max(-6, @as(i8, boosts.accuracy) - 1));
-                try log.boost(foe_ident, .Accuracy, -1);
+                try log.boost(.{ foe_ident, .Accuracy, -1 });
             },
             else => unreachable,
         }
@@ -2649,35 +2618,35 @@ fn isForced(active: anytype) bool {
         active.volatiles.Thrashing or active.volatiles.Charging;
 }
 
-fn clearVolatiles(battle: anytype, who: Player, clear: bool, options: anytype) !void {
+fn clearVolatiles(battle: anytype, who: Player, options: anytype) !void {
     var log = options.log;
     var side = battle.side(who);
     var volatiles = &side.active.volatiles;
     const ident = battle.active(who);
 
-    options.chance.clearDurations(who, clear);
-
     if (volatiles.disable_move != 0) {
         volatiles.disable_move = 0;
         volatiles.disable_duration = 0;
-        try log.end(ident, .DisableSilent);
+        options.chance.durations(.disable, who, .None);
+        try log.end(.{ ident, .DisableSilent });
     }
     if (volatiles.Confusion) {
         // volatiles.confusion is left unchanged
         volatiles.Confusion = false;
-        try log.end(ident, .ConfusionSilent);
+        options.chance.durations(.confusion, who, .None);
+        try log.end(.{ ident, .ConfusionSilent });
     }
     if (volatiles.Mist) {
         volatiles.Mist = false;
-        try log.end(ident, .MistSilent);
+        try log.end(.{ ident, .MistSilent });
     }
     if (volatiles.FocusEnergy) {
         volatiles.FocusEnergy = false;
-        try log.end(ident, .FocusEnergySilent);
+        try log.end(.{ ident, .FocusEnergySilent });
     }
     if (volatiles.LeechSeed) {
         volatiles.LeechSeed = false;
-        try log.end(ident, .LeechSeedSilent);
+        try log.end(.{ ident, .LeechSeedSilent });
     }
     if (!showdown and volatiles.Toxic) {
         volatiles.Toxic = false;
@@ -2685,24 +2654,30 @@ fn clearVolatiles(battle: anytype, who: Player, clear: bool, options: anytype) !
     }
     if (volatiles.LightScreen) {
         volatiles.LightScreen = false;
-        try log.end(ident, .LightScreenSilent);
+        try log.end(.{ ident, .LightScreenSilent });
     }
     if (volatiles.Reflect) {
         volatiles.Reflect = false;
-        try log.end(ident, .ReflectSilent);
+        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, .ToxicSilent);
+        try log.end(.{ ident, .ToxicSilent });
     }
 }
 
+fn observation(n: anytype) optional.Optional(chance.Observation) {
+    return if (n == 0) .ended else .continuing;
+}
+
 pub const Rolls = struct {
     fn speedTie(battle: anytype, options: anytype) !bool {
         const p1 = if (options.calc.overridden(.P1, .speed_tie)) |player|
             player == .P1
+        else if (@hasDecl(@TypeOf(battle.rng), "speedTie"))
+            battle.rng.speedTie()
         else if (showdown)
             battle.rng.range(u8, 0, 2) == 0
         else
@@ -2712,21 +2687,31 @@ pub const Rolls = struct {
         return p1;
     }
 
-    fn criticalHit(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
+    fn criticalHit(
+        battle: anytype,
+        player: Player,
+        rate: u8,
+        spurious: bool,
+        options: anytype,
+    ) !bool {
         const crit = if (options.calc.overridden(player, .critical_hit)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "criticalHit"))
+            battle.rng.criticalHit(player, rate)
         else if (showdown)
             battle.rng.chance(u8, rate, 256)
         else
             std.math.rotl(u8, battle.rng.next(), 3) < rate;
 
-        try options.chance.criticalHit(player, crit, rate);
+        if (!spurious) try options.chance.criticalHit(player, crit, rate);
         return crit;
     }
 
     fn damage(battle: anytype, player: Player, options: anytype) !u8 {
         const roll = if (options.calc.overridden(player, .damage)) |val|
             val
+        else if (@hasDecl(@TypeOf(battle.rng), "damage"))
+            battle.rng.damage(player)
         else roll: {
             if (showdown) break :roll battle.rng.range(u8, 217, 256);
             while (true) {
@@ -2740,21 +2725,27 @@ pub const Rolls = struct {
         return roll;
     }
 
-    fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) bool {
+    const uN = if (pkmn.options.miss) u8 else u9;
+    fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) !bool {
+        const acc: uN = if (pkmn.options.miss) accuracy else @as(uN, accuracy) + 1;
         const ok = if (options.calc.overridden(player, .hit)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "hit"))
+            battle.rng.hit(player, acc)
         else if (showdown)
-            battle.rng.chance(u8, accuracy, 256)
+            battle.rng.chance(uN, acc, 256)
         else
-            battle.rng.next() < accuracy;
+            battle.rng.next() < acc;
 
-        options.chance.hit(ok, accuracy);
+        try options.chance.hit(player, ok, acc);
         return ok;
     }
 
     fn confused(battle: anytype, player: Player, options: anytype) !bool {
         const cfz = if (options.calc.overridden(player, .confused)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "confused"))
+            battle.rng.confused(player)
         else if (showdown)
             !battle.rng.chance(u8, 128, 256)
         else
@@ -2767,6 +2758,8 @@ pub const Rolls = struct {
     fn paralyzed(battle: anytype, player: Player, options: anytype) !bool {
         const par = if (options.calc.overridden(player, .paralyzed)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "paralyzed"))
+            battle.rng.paralyzed(player)
         else if (showdown)
             battle.rng.chance(u8, 63, 256)
         else
@@ -2779,6 +2772,8 @@ pub const Rolls = struct {
     fn confusionChance(battle: anytype, player: Player, options: anytype) !bool {
         const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "secondaryChance"))
+            battle.rng.secondaryChance(player, 25)
         else if (showdown)
             battle.rng.chance(u8, 25, 256)
         else
@@ -2793,6 +2788,8 @@ pub const Rolls = struct {
 
         const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "secondaryChance"))
+            battle.rng.secondaryChance(player, rate)
         else if (showdown)
             battle.rng.chance(u8, rate, 256)
         else
@@ -2807,6 +2804,8 @@ pub const Rolls = struct {
 
         const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "secondaryChance"))
+            battle.rng.secondaryChance(player, rate)
         else if (showdown)
             battle.rng.chance(u8, rate, 256)
         else
@@ -2819,6 +2818,8 @@ pub const Rolls = struct {
     fn unboost(battle: anytype, player: Player, options: anytype) !bool {
         const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "secondaryChance"))
+            battle.rng.secondaryChance(player, 85)
         else if (showdown)
             battle.rng.chance(u8, 85, 256)
         else
@@ -2831,6 +2832,8 @@ pub const Rolls = struct {
     fn metronome(battle: anytype, player: Player, options: anytype) !Move {
         const move: Move = if (options.calc.overridden(player, .metronome)) |val|
             val
+        else if (@hasDecl(@TypeOf(battle.rng), "metronome"))
+            battle.rng.metronome(player)
         else if (showdown)
             Move.METRONOME[battle.rng.range(u8, 0, Move.METRONOME.len)]
         else move: {
@@ -2849,6 +2852,8 @@ pub const Rolls = struct {
     fn psywave(battle: anytype, player: Player, max: u8, options: anytype) !u8 {
         const power = if (options.calc.overridden(player, .psywave)) |val|
             val - 1
+        else if (@hasDecl(@TypeOf(battle.rng), "psywave"))
+            battle.rng.psywave(player)
         else if (showdown)
             battle.rng.range(u8, 0, max)
         else power: {
@@ -2866,6 +2871,8 @@ pub const Rolls = struct {
     fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
+        else if (@hasDecl(@TypeOf(battle.rng), "sleepDuration"))
+            battle.rng.sleepDuration(player)
         else if (showdown)
             battle.rng.range(u3, 1, 8)
         else duration: {
@@ -2876,46 +2883,52 @@ pub const Rolls = struct {
         };
 
         assert(duration >= 1 and duration <= 7);
-        options.chance.duration(.sleep, player, player.foe(), duration);
+        options.chance.duration(player, duration);
         return duration;
     }
 
     fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
         const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
             val
+        else if (@hasDecl(@TypeOf(battle.rng), "disableDuration"))
+            battle.rng.disableDuration(player)
         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);
+        options.chance.duration(player, duration);
         return duration;
     }
 
-    fn confusionDuration(battle: anytype, player: Player, self: bool, options: anytype) u3 {
+    fn confusionDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
+        else if (@hasDecl(@TypeOf(battle.rng), "confusionDuration"))
+            battle.rng.confusionDuration(player)
         else if (showdown)
             battle.rng.range(u3, 2, 6)
         else
             @intCast((battle.rng.next() & 3) + 2);
 
         assert(duration >= 2 and duration <= 5);
-        options.chance.duration(.confusion, player, if (self) player else player.foe(), duration);
+        options.chance.duration(player, duration);
         return duration;
     }
 
     fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
+        else if (@hasDecl(@TypeOf(battle.rng), "attackingDuration"))
+            battle.rng.attackingDuration(player)
         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);
+        options.chance.duration(player, duration);
         return duration;
     }
 
@@ -2930,6 +2943,8 @@ pub const Rolls = struct {
         const roll = if (effect == .Binding) .duration else .multi_hit;
         const n: u3 = if (options.calc.overridden(player, roll)) |val|
             @intCast(val)
+        else if (@hasDecl(@TypeOf(battle.rng), "distribution"))
+            battle.rng.distribution(player)
         else if (showdown)
             DISTRIBUTION[battle.rng.range(u3, 0, DISTRIBUTION.len)]
         else n: {
@@ -2939,7 +2954,7 @@ pub const Rolls = struct {
 
         assert(n >= 2 and n <= 5);
         if (effect == .Binding) {
-            options.chance.duration(.binding, player, player, n);
+            options.chance.duration(player, n);
         } else {
             try options.chance.multiHit(player, n);
         }
@@ -2962,7 +2977,9 @@ pub const Rolls = struct {
         else
             null;
 
-        const slot: u4 = overridden orelse slot: {
+        const slot: u4 = overridden orelse if (@hasDecl(@TypeOf(battle.rng), "moveSlot"))
+            battle.rng.moveSlot(player, moves, check_pp)
+        else slot: {
             if (showdown) {
                 if (check_pp == 0) {
                     var i: usize = moves.len;
@@ -3042,11 +3059,11 @@ 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;
+            const active = &side.active;
             const stored = side.stored();
 
             // While players are not given any input options on the cartridge in these cases,
-            // Pokémon Showdown instead produces a list with a single move that must be chosen.
+            // Pokémon Showdown instead produces a list with a single move that must be chosen
             //
             // Given that no input is allowed on the cartridge 'Pass' seems like it would be logical
             // here when not in compatibility mode, but the engine needs to be able to differentiate
@@ -3054,7 +3071,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             // passing due to being forced into using a move. Instead of introducing another option
             // we simply repurpose Move with no move slot, even though pedantically this is not
             // strictly correct as the player would not have been presented the option to move or
-            // switch at all.
+            // switch at all
             if (isForced(active)) {
                 out[n] = .{ .type = .Move, .data = @intFromBool(showdown) };
                 n += 1;
@@ -3073,7 +3090,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             // On the cartridge, all of these happen after "FIGHT" (indicating you are not
             // switching) but before you are allowed to select a move. Pokémon Showdown instead
             // either disables all other moves in the case of limited or requires you to select a
-            // move normally if sleeping/frozen/bound.
+            // move normally if sleeping/frozen/bound
             if (!showdown and (limited or foe.active.volatiles.Binding or
                 Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP)))
             {
@@ -3086,7 +3103,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             // Pokémon Showdown handles Bide and Binding moves by checking if the move in question
             // is present in the Pokémon's moveset (which means moves called via Metronome / Mirror
             // Move will not result in forcing the subsequent use unless the user also had the
-            // proc-ed move in their moveset) and disabling all other moves.
+            // proc-ed move in their moveset) and disabling all other moves
             if (limited) {
                 assert(showdown);
                 assert(side.last_selected_move != .None);