@pkmn/engine 0.1.0-dev.dd5b9081 → 0.1.0-dev.e0e37c1b

package/src/lib/gen1/mechanics.zig

@@ -7,23 +7,22 @@ const DEBUG = @import("../common/debug.zig").print;
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
 
-const Action = @import("chance.zig").Action;
-
 const data = @import("data.zig");
 
 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 = pkmn.options.showdown;
-
 const Boost = protocol.Boost;
 const Damage = protocol.Damage;
+const Fail = protocol.Fail;
 const Heal = protocol.Heal;
 
 const Gen12 = rng.Gen12;
@@ -59,23 +58,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, options: anytype) !Result {
-    // FIXME
-    // std.debug.print("\n", .{});
-    // DEBUG(battle.turn);
-    // std.debug.print("// ", .{});
     assert(c1.type != .Pass or c2.type != .Pass or battle.turn == 0);
     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);
@@ -84,9 +75,9 @@ pub fn update(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Result
     var 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, f1, .P2, c2, r2, s2, f2, options)) |r| return r;
+        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, options)) |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;
@@ -124,7 +115,6 @@ fn selectMove(
     choice: Choice,
     foe_choice: Choice,
     skip_turn: *bool,
-    from: *?Move,
 ) ?Result {
     if (choice.type == .Pass) return null;
 
@@ -141,7 +131,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);
@@ -151,7 +140,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);
@@ -172,9 +160,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
@@ -210,7 +196,7 @@ 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;
         };
@@ -229,7 +215,7 @@ 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
@@ -270,14 +256,14 @@ 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);
+    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 options.log.status(battle.active(player), incoming.status, .Silent);
+        try options.log.status(.{ battle.active(player), incoming.status, .Silent });
     }
 }
 
@@ -340,12 +326,10 @@ 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,
     options: anytype,
 ) !?Result {
     assert(player_choice.type != .Pass);
@@ -358,7 +342,6 @@ fn doTurn(
         player_choice,
         player_rewrap,
         player_skip,
-        player_from,
         &residual,
         options,
     )) |r| return r;
@@ -381,7 +364,6 @@ fn doTurn(
         foe_choice,
         foe_rewrap,
         foe_skip,
-        foe_from,
         &residual,
         options,
     )) |r| return r;
@@ -409,7 +391,6 @@ fn executeMove(
     choice: Choice,
     rewrap: bool,
     skip: bool,
-    from: ?Move,
     residual: *bool,
     options: anytype,
 ) !?Result {
@@ -426,7 +407,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;
     }
@@ -444,8 +425,10 @@ fn executeMove(
         mslot = @intCast(battle.lastMove(player).index);
         const stored = side.stored();
         // GLITCH: Struggle bypass PP underflow via Hyper Beam / Trapping-switch auto selection
-        auto = 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.
@@ -467,7 +450,7 @@ fn executeMove(
 
     var skip_can = false;
     var skip_pp = false;
-    switch (try beforeMove(battle, player, skip, from, residual, options)) {
+    switch (try beforeMove(battle, player, skip, residual, options)) {
         .done => return null,
         .skip_can => skip_can = true,
         .skip_pp => skip_pp = true,
@@ -475,9 +458,9 @@ fn executeMove(
         .err => return @as(?Result, Result.Error),
     }
 
-    if (!skip_can and !try canMove(battle, player, mslot, auto, skip_pp, from, residual, options)) {
-        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, options);
 }
@@ -488,7 +471,6 @@ fn beforeMove(
     battle: anytype,
     player: Player,
     skip: bool,
-    from: ?Move,
     residual: *bool,
     options: anytype,
 ) !BeforeMove {
@@ -515,23 +497,23 @@ fn beforeMove(
         }
 
         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;
     }
 
@@ -539,27 +521,27 @@ 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.disabled_duration > 0) {
+    if (volatiles.disable_duration > 0) {
         if (options.calc.modify(player, .disable)) |extend| {
-            if (!extend) volatiles.disabled_duration = 0;
+            if (!extend) volatiles.disable_duration = 0;
         } else {
-            volatiles.disabled_duration -= 1;
+            volatiles.disable_duration -= 1;
         }
-        try options.chance.disable(player, volatiles.disabled_duration);
+        try options.chance.disable(player, volatiles.disable_duration);
 
-        if (volatiles.disabled_duration == 0) {
-            volatiles.disabled_move = 0;
-            try log.end(ident, .Disable);
+        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
@@ -584,9 +566,9 @@ fn beforeMove(
 
         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);
@@ -637,7 +619,7 @@ fn beforeMove(
         volatiles.Binding = false;
         options.chance.clearDurations(player, null);
         // GLITCH: Invulnerable is not cleared, resulting in permanent Fly/Dig invulnerability
-        try log.cant(ident, .Paralysis);
+        try log.cant(.{ ident, .Paralysis });
         return .done;
     }
 
@@ -663,18 +645,18 @@ fn beforeMove(
         try options.chance.attacking(player, 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;
         }
 
@@ -695,7 +677,6 @@ fn beforeMove(
 
     if (volatiles.Thrashing) {
         assert(volatiles.attacks > 0);
-        assert(from != null);
 
         if (options.calc.modify(player, .attacking)) |extend| {
             if (!extend) volatiles.attacks = 0;
@@ -705,15 +686,15 @@ fn beforeMove(
         try options.chance.attacking(player, volatiles.attacks);
 
         if (!showdown and handleThrashing(battle, active, player, options)) {
-            try log.start(battle.active(player), .ConfusionSilent);
+            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, player, options)) {
-                try log.start(battle.active(player), .ConfusionSilent);
+                try log.start(.{ battle.active(player), .ConfusionSilent });
             }
         }
         return .skip_can;
@@ -729,12 +710,7 @@ fn beforeMove(
         }
         try options.chance.binding(player, volatiles.attacks);
 
-        try log.move(
-            battle.active(player),
-            side.last_selected_move,
-            battle.active(player.foe()),
-            side.last_selected_move,
-        );
+        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);
@@ -754,7 +730,7 @@ fn canMove(
     mslot: u4,
     auto: bool,
     skip_pp: bool,
-    from: ?Move,
+    from: Move,
     residual: *bool,
     options: anytype,
 ) !bool {
@@ -762,33 +738,22 @@ fn canMove(
     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 options.log.move(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;
     }
 
-    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 options.log.move(player_ident, side.last_selected_move, battle.active(target), f);
+    try options.log.move(.{ player_ident, side.last_selected_move, battle.active(target), from });
     setCounterable(battle, player, side, move);
 
     if (move.effect.onBegin()) {
@@ -826,12 +791,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);
 }
 
@@ -963,16 +930,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));
+            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
@@ -1008,15 +975,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)) {
@@ -1033,7 +1000,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) {
@@ -1043,9 +1010,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;
@@ -1243,7 +1210,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;
     }
 
@@ -1261,14 +1228,14 @@ 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;
     }
 
@@ -1304,20 +1271,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);
+            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 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;
 }
 
@@ -1336,7 +1303,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);
@@ -1378,12 +1345,12 @@ fn checkHit(battle: anytype, player: Player, move: Move.Data, options: anytype)
     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)});
     }
 
     return false;
@@ -1474,9 +1441,8 @@ 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, !(more or foe_fainted), options)) |r| return r;
     if (foe_fainted) if (try faint(battle, player.foe(), !more, options)) |r| return r;
@@ -1484,20 +1450,20 @@ fn checkFaint(
     assert(!side.active.volatiles.MultiHit);
     assert(!foe.active.volatiles.MultiHit);
 
-    if (tie) {
-        try options.log.tie();
+    if (player_out and foe_out) {
+        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;
     }
 
     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, done: bool, options: anytype) !?Result {
@@ -1533,7 +1499,7 @@ fn faint(battle: anytype, player: Player, done: bool, options: anytype) !?Result
             side.stored().stats.spe;
     }
 
-    try options.log.faint(battle.active(player), done);
+    try options.log.faint(.{ battle.active(player), done });
     options.calc.capped(player);
     return null;
 }
@@ -1555,8 +1521,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 });
         }
     }
 
@@ -1581,14 +1547,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 });
     }
 }
 
@@ -1599,18 +1565,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;
 }
@@ -1670,9 +1636,9 @@ fn checkEBC(battle: anytype) bool {
 }
 
 fn disabled(side: *Side, ident: ID, options: anytype) !bool {
-    if (side.active.volatiles.disabled_move != 0) {
+    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
@@ -1680,14 +1646,14 @@ 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;
         }
     }
     return false;
 }
 
-inline fn buildRage(battle: anytype, who: Player, options: 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), options);
@@ -1705,7 +1671,7 @@ fn handleThrashing(battle: anytype, active: *ActivePokemon, player: Player, opti
     return true;
 }
 
-inline fn onBegin(
+fn onBegin(
     battle: anytype,
     player: Player,
     move: Move.Data,
@@ -1735,7 +1701,7 @@ inline fn onBegin(
     };
 }
 
-inline fn onEnd(battle: anytype, player: Player, move: Move.Data, options: 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, options),
@@ -1751,7 +1717,7 @@ inline fn onEnd(battle: anytype, player: Player, move: Move.Data, options: anyty
     };
 }
 
-inline fn alwaysHappens(
+fn alwaysHappens(
     battle: anytype,
     player: Player,
     move: Move.Data,
@@ -1770,7 +1736,7 @@ inline fn alwaysHappens(
     };
 }
 
-inline fn moveEffect(battle: anytype, player: Player, move: Move.Data, options: 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, options),
         .ConfusionChance => Effects.confusion(battle, player, move, options),
@@ -1797,7 +1763,7 @@ pub const Effects = struct {
         side.active.volatiles.state = 0;
         side.active.volatiles.attacks = Rolls.attackingDuration(battle, player, options);
 
-        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 {
@@ -1811,11 +1777,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;
@@ -1829,7 +1795,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 {
@@ -1839,8 +1805,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 {
@@ -1851,17 +1817,11 @@ 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);
         }
@@ -1870,23 +1830,24 @@ pub const Effects = struct {
         foe.active.volatiles.Confusion = true;
         foe.active.volatiles.confusion = Rolls.confusionDuration(battle, player, false, options);
 
-        try options.log.start(battle.active(player.foe()), .Confusion);
+        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 {
@@ -1900,8 +1861,8 @@ pub const Effects = struct {
             try options.chance.commit(player, .hit);
         }
 
-        if (volatiles.disabled_move != 0) {
-            try options.log.fail(foe_ident, .None);
+        if (volatiles.disable_move != 0) {
+            try options.log.fail(.{ foe_ident, .None });
             return null;
         }
 
@@ -1917,7 +1878,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
@@ -1925,18 +1886,18 @@ pub const Effects = struct {
             return Result.Error;
         }
 
-        volatiles.disabled_move =
+        volatiles.disable_move =
             @intCast(try Rolls.moveSlot(battle, player, &foe.active.moves, n, options));
-        volatiles.disabled_duration = Rolls.disableDuration(battle, player, options);
+        volatiles.disable_duration = Rolls.disableDuration(battle, player, options);
 
-        const id = foe.active.move(volatiles.disabled_move).id;
-        try options.log.startEffect(foe_ident, .Disable, id);
+        const id = foe.active.move(volatiles.disable_move).id;
+        try options.log.start(.{ foe_ident, .Disable, id });
         return null;
     }
 
     fn drainHP(battle: anytype, player: Player, options: anytype) !void {
-        var side = battle.side(player);
-        var stored = side.stored();
+        var stored = battle.side(player).stored();
+        const ident = battle.active(player);
 
         if (battle.last_damage == 0) {
             assert(showdown);
@@ -1949,7 +1910,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 {
@@ -1981,7 +1942,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 {
@@ -2003,7 +1964,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 {
@@ -2023,8 +1984,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) {
@@ -2032,11 +1993,11 @@ 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;
                 } 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);
             }
@@ -2045,7 +2006,7 @@ pub const Effects = struct {
                 if (Status.is(foe_stored.status, .FRZ) or Status.is(foe_stored.status, .SLP)) {
                     foe.last_selected_move = .SKIP_TURN;
                 }
-                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);
@@ -2061,7 +2022,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;
@@ -2069,17 +2030,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 {
@@ -2088,33 +2049,32 @@ 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 {
@@ -2143,7 +2103,7 @@ pub const Effects = struct {
                 // 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;
@@ -2152,7 +2112,7 @@ pub const Effects = struct {
         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 {
@@ -2161,7 +2121,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 {
@@ -2187,17 +2147,18 @@ 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);
@@ -2205,7 +2166,7 @@ pub const Effects = struct {
         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 {
@@ -2227,12 +2188,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(.{});
         }
     }
 
@@ -2247,23 +2208,23 @@ 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) {
@@ -2282,7 +2243,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 {
@@ -2302,22 +2263,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 {
@@ -2331,10 +2293,10 @@ 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 (!showdown and !try checkHit(battle, player, move, options)) return;
@@ -2351,18 +2313,17 @@ pub const Effects = struct {
 
         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);
+        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);
@@ -2374,17 +2335,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;
         }
     }
@@ -2398,8 +2358,8 @@ pub const Effects = struct {
             }
             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(.{});
         }
     }
 
@@ -2438,7 +2398,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 {
@@ -2468,87 +2428,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 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 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 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 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,
         }
@@ -2563,7 +2523,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);
@@ -2581,82 +2541,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 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 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 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 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,
         }
@@ -2680,7 +2640,7 @@ fn statusModify(status: u8, stats: *Stats(u16)) void {
     }
 }
 
-inline fn isForced(active: anytype) bool {
+fn isForced(active: anytype) bool {
     return active.volatiles.Recharging or active.volatiles.Rage or
         active.volatiles.Thrashing or active.volatiles.Charging;
 }
@@ -2693,27 +2653,27 @@ fn clearVolatiles(battle: anytype, who: Player, clear: bool, options: anytype) !
 
     options.chance.clearDurations(who, clear);
 
-    if (volatiles.disabled_move != 0) {
-        volatiles.disabled_move = 0;
-        volatiles.disabled_duration = 0;
-        try log.end(ident, .DisableSilent);
+    if (volatiles.disable_move != 0) {
+        volatiles.disable_move = 0;
+        volatiles.disable_duration = 0;
+        try log.end(.{ ident, .DisableSilent });
     }
     if (volatiles.Confusion) {
         // volatiles.confusion is left unchanged
         volatiles.Confusion = false;
-        try log.end(ident, .ConfusionSilent);
+        try log.end(.{ ident, .ConfusionSilent });
     }
     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;
@@ -2721,22 +2681,22 @@ fn clearVolatiles(battle: anytype, who: Player, clear: bool, options: anytype) !
     }
     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, options: anytype) !bool {
+    fn speedTie(battle: anytype, options: anytype) !bool {
         const p1 = if (options.calc.overridden(.P1, .speed_tie)) |player|
             player == .P1
         else if (showdown)
@@ -2748,7 +2708,7 @@ pub const Rolls = struct {
         return p1;
     }
 
-    inline fn criticalHit(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
+    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)
@@ -2760,7 +2720,7 @@ pub const Rolls = struct {
         return crit;
     }
 
-    inline fn damage(battle: anytype, player: anytype, options: anytype) !u8 {
+    fn damage(battle: anytype, player: Player, options: anytype) !u8 {
         const roll = if (options.calc.overridden(player, .damage)) |val|
             val
         else roll: {
@@ -2776,7 +2736,7 @@ pub const Rolls = struct {
         return roll;
     }
 
-    inline fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) bool {
+    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)
@@ -2788,7 +2748,7 @@ pub const Rolls = struct {
         return ok;
     }
 
-    inline fn confused(battle: anytype, player: Player, options: anytype) !bool {
+    fn confused(battle: anytype, player: Player, options: anytype) !bool {
         const cfz = if (options.calc.overridden(player, .confused)) |val|
             val == .true
         else if (showdown)
@@ -2800,7 +2760,7 @@ pub const Rolls = struct {
         return cfz;
     }
 
-    inline fn paralyzed(battle: anytype, player: Player, options: anytype) !bool {
+    fn paralyzed(battle: anytype, player: Player, options: anytype) !bool {
         const par = if (options.calc.overridden(player, .paralyzed)) |val|
             val == .true
         else if (showdown)
@@ -2812,7 +2772,7 @@ pub const Rolls = struct {
         return par;
     }
 
-    inline fn confusionChance(battle: anytype, player: Player, options: anytype) !bool {
+    fn confusionChance(battle: anytype, player: Player, options: anytype) !bool {
         const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
             val == .true
         else if (showdown)
@@ -2824,7 +2784,7 @@ pub const Rolls = struct {
         return proc;
     }
 
-    inline fn secondaryChance(battle: anytype, player: Player, low: bool, options: anytype) !bool {
+    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|
@@ -2838,7 +2798,7 @@ pub const Rolls = struct {
         return proc;
     }
 
-    inline fn poisonChance(battle: anytype, player: Player, low: bool, options: anytype) !bool {
+    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|
@@ -2852,7 +2812,7 @@ pub const Rolls = struct {
         return proc;
     }
 
-    inline fn unboost(battle: anytype, player: Player, options: anytype) !bool {
+    fn unboost(battle: anytype, player: Player, options: anytype) !bool {
         const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
             val == .true
         else if (showdown)
@@ -2864,14 +2824,12 @@ pub const Rolls = struct {
         return proc;
     }
 
-    inline fn metronome(battle: anytype, player: Player, options: anytype) !Move {
+    fn metronome(battle: anytype, player: Player, options: anytype) !Move {
         const move: Move = if (options.calc.overridden(player, .metronome)) |val|
             val
-        else if (showdown) move: {
-            const r = battle.rng.range(u8, 0, @intFromEnum(Move.Struggle) - 2);
-            const mod = @as(u2, (if (r < @intFromEnum(Move.Metronome) - 1) 1 else 2));
-            break :move @enumFromInt(r + mod);
-        } else move: {
+        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;
@@ -2884,7 +2842,7 @@ pub const Rolls = struct {
         return move;
     }
 
-    inline fn psywave(battle: anytype, player: Player, max: u8, options: anytype) !u8 {
+    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)
@@ -2901,11 +2859,11 @@ pub const Rolls = struct {
         return power;
     }
 
-    inline fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
+    fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
         else if (showdown)
-            @intCast(battle.rng.range(u8, 1, 8))
+            battle.rng.range(u3, 1, 8)
         else duration: {
             while (true) {
                 const r = battle.rng.next() & 7;
@@ -2918,11 +2876,11 @@ pub const Rolls = struct {
         return duration;
     }
 
-    inline fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
+    fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
         const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
             val
         else if (showdown)
-            @intCast(battle.rng.range(u8, 1, 9))
+            battle.rng.range(u4, 1, 9)
         else
             @intCast((battle.rng.next() & 7) + 1);
 
@@ -2931,11 +2889,11 @@ pub const Rolls = struct {
         return duration;
     }
 
-    inline fn confusionDuration(battle: anytype, player: Player, self: bool, options: anytype) u3 {
+    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)
-            @intCast(battle.rng.range(u8, 2, 6))
+            battle.rng.range(u3, 2, 6)
         else
             @intCast((battle.rng.next() & 3) + 2);
 
@@ -2944,11 +2902,11 @@ pub const Rolls = struct {
         return duration;
     }
 
-    inline fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
+    fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
         else if (showdown)
-            @intCast(battle.rng.range(u4, 2, 4))
+            battle.rng.range(u3, 2, 4)
         else
             @intCast((battle.rng.next() & 1) + 2);
 
@@ -2957,7 +2915,9 @@ pub const Rolls = struct {
         return duration;
     }
 
-    inline fn distribution(
+    const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
+
+    fn distribution(
         battle: anytype,
         comptime effect: Move.Effect,
         player: Player,
@@ -2967,7 +2927,7 @@ pub const Rolls = struct {
         const n: u3 = if (options.calc.overridden(player, roll)) |val|
             @intCast(val)
         else if (showdown)
-            DISTRIBUTION[battle.rng.range(u8, 0, DISTRIBUTION.len)]
+            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);
@@ -3014,10 +2974,9 @@ pub const Rolls = struct {
                     while (i < moves.len and r > 0) : (i += 1) {
                         if (moves[i].pp > 0) {
                             r -= 1;
-                            if (r == 0) break;
+                            if (r == 0) break :slot @intCast(i + 1);
                         }
                     }
-                    break :slot @intCast(i + 1);
                 }
             }
 
@@ -3039,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);
@@ -3133,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;
@@ -3148,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;
             }