@pkmn/engine 0.1.0-dev.30c63015 → 0.1.0-dev.3393edb3

package/src/lib/gen2/mechanics.zig

@@ -6,7 +6,6 @@ const common = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
-const util = @import("../common/util.zig");
 
 const data = @import("data.zig");
 const generated = @import("generated.zig");
@@ -26,30 +25,20 @@ const Result = common.Result;
 
 const Activate = protocol.Activate;
 const Boost = protocol.Boost;
-const Cant = protocol.Cant;
-const CureStatus = protocol.CureStatus;
 const Damage = protocol.Damage;
 const End = protocol.End;
-const EndItem = protocol.EndItem;
 const Fail = protocol.Fail;
 const Heal = protocol.Heal;
-const Immune = protocol.Immune;
-const SetHP = protocol.SetHP;
 const Start = protocol.Start;
 
 const Gen12 = rng.Gen12;
 
-const PointerType = util.PointerType;
-
 const ActivePokemon = data.ActivePokemon;
 const Boosts = data.Boosts;
 const Effectiveness = data.Effectiveness;
 const Item = data.Item;
 const Move = data.Move;
-const MoveSlot = data.MoveSlot;
-const Pokemon = data.Pokemon;
 const Side = data.Side;
-const Species = data.Species;
 const Stats = data.Stats;
 const Status = data.Status;
 const TriAttack = data.TriAttack;
@@ -111,6 +100,7 @@ pub const State = struct {
     type: Type, // BATTLE_VARS_MOVE_TYPE
     accuracy: u8, // wEnemyMoveStruct + MOVE_ACC
     move: Move, // wCurPlayerMove
+    hit: u3 = 0,
     from: Move = .None,
     mslot: u4, // wCurMoveNum
     first: bool, // wEnemyGoesFirst
@@ -145,11 +135,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;
 
@@ -261,11 +251,10 @@ fn switchIn(battle: anytype, player: Player, slot: u8, kind: SwitchIn, options:
     } else {
         try options.log.switched(.{ battle.active(player), incoming });
     }
-    options.chance.switched(player, side.pokemon[0].position, out);
 
     if (side.conditions.Spikes and !active.types.includes(.Flying)) {
         incoming.hp -|= @max(incoming.stats.hp / 8, 1);
-        try options.log.damage(.{ battle.active(player), incoming, Damage.Spikes });
+        try options.log.damage(.{ battle.active(player), incoming, .Spikes });
     }
 }
 
@@ -408,7 +397,9 @@ fn executeMove(
 
     assert(choice.type == .Move);
     var mslot: u4 = @intCast(choice.data);
+    _ = &mslot;
     var move = Move.Pound; // TODO
+    _ = &move;
 
     if (!try beforeMove(battle, player, move, options)) return null;
 
@@ -438,31 +429,22 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
     if (volatiles.Recharging) {
         volatiles.Recharging = false;
         resetCant(volatiles);
-        try log.cant(.{ ident, Cant.Recharge });
+        try log.cant(.{ ident, .Recharge });
         return false;
     }
 
     if (Status.is(stored.status, .SLP)) 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;
-        // }
-
-        const duration = Status.duration(stored.status);
-        if (!Status.is(stored.status, .EXT)) {
-            try options.chance.sleep(player, duration);
-        }
 
-        if (duration == 0) {
-            try log.curestatus(.{ ident, before, CureStatus.Message });
+        if (Status.duration(stored.status) == 0) {
+            try log.curestatus(.{ ident, before, .Message });
             stored.status = 0; // clears EXT if present
             resetCant(volatiles);
             volatiles.Nightmare = false;
         } else {
-            try log.cant(.{ ident, Cant.Sleep });
+            try log.cant(.{ ident, .Sleep });
             if (move == .Snore or move == .SleepTalk) break :slp;
             resetCant(volatiles);
             return false;
@@ -471,7 +453,7 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
 
     if (Status.is(stored.status, .FRZ) and !(move == .FlameWheel or move == .SacredFire)) {
         resetCant(volatiles);
-        try log.cant(.{ ident, Cant.Freeze });
+        try log.cant(.{ ident, .Freeze });
         return false;
     }
 
@@ -481,39 +463,28 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
         // if (!showdown) volatiles.Flinch = false;
         volatiles.Flinch = false;
         resetCant(volatiles);
-        try log.cant(.{ ident, Cant.Flinch });
+        try log.cant(.{ ident, .Flinch });
         return false;
     }
 
     if (volatiles.disable.duration > 0) {
-        // if (options.calc.modify(player, .disable)) |extend| {
-        //     if (!extend) volatiles.disable.duration = 0;
-        // } else {
         volatiles.disable.duration -= 1;
-        // }
-        try options.chance.disable(player, volatiles.disable.duration);
 
         if (volatiles.disable.duration == 0) {
             volatiles.disable.move = 0;
-            try log.end(.{ ident, End.Disable });
+            try log.end(.{ ident, .Disable });
         }
     }
 
     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);
 
         if (volatiles.confusion == 0) {
             volatiles.Confusion = false;
-            try log.end(.{ ident, End.Confusion });
+            try log.end(.{ ident, .Confusion });
         } else {
-            try log.activate(ident, .Confusion);
+            try log.activate(.{ ident, .Confusion });
 
             if (try Rolls.confused(battle, player, options)) {
                 volatiles.BeatUp = false;
@@ -528,11 +499,11 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
     }
 
     if (volatiles.Attract) {
-        try log.activate(ident, .Attract);
+        try log.activate(.{ ident, .Attract });
 
         if (try Rolls.attract(battle, player, options)) {
             resetCant(volatiles);
-            try log.cant(.{ ident, Cant.Attract });
+            try log.cant(.{ ident, .Attract });
             return false;
         }
     }
@@ -543,14 +514,14 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
         if (m != .None and m == move) {
             side.active.volatiles.Charging = false;
             resetCant(volatiles);
-            try options.log.cant(.{ ident, Cant.Disable, move });
+            try options.log.cant(.{ ident, .Disable, move });
             return false;
         }
     }
 
     if (Status.is(stored.status, .PAR) and try Rolls.paralyzed(battle, player, options)) {
         resetCant(volatiles);
-        try log.cant(.{ ident, Cant.Paralysis });
+        try log.cant(.{ ident, .Paralysis });
         return false;
     }
 
@@ -570,7 +541,7 @@ fn resetCant(volatiles: *align(8) Volatiles) void {
 
 pub fn canMove(battle: anytype, player: Player, state: *State, options: anytype) !bool {
     var side = battle.side(player);
-    var volatiles = &side.active.volatiles;
+    const volatiles = &side.active.volatiles;
 
     // FIXME: pass in target to avoid lookup?
     const target = if (Move.get(state.move).target == .Self) player else player.foe();
@@ -668,7 +639,7 @@ pub fn checkCriticalHit(battle: anytype, player: Player, state: *State, options:
     }
     assert(stage <= 4);
 
-    state.crit = try Rolls.criticalHit(battle, player, CRITICAL_HITS[stage], options);
+    state.crit = try Rolls.criticalHit(battle, player, state.hit, CRITICAL_HITS[stage], options);
 }
 
 pub fn calcDamage(
@@ -736,7 +707,7 @@ pub fn adjustDamage(battle: anytype, player: Player, state: *State, _: anytype)
 
 pub fn randomizeDamage(battle: anytype, player: Player, state: *State, options: anytype) !void {
     if (state.damage <= 1) return;
-    const random = try Rolls.damage(battle, player, options);
+    const random = try Rolls.damage(battle, player, state.hit, options);
     options.calc.base(player.foe(), state.damage);
     state.damage = @intCast(@as(u32, state.damage) *% random / 255);
     options.calc.final(player.foe(), state.damage);
@@ -953,26 +924,26 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !bool {
         const damage = @max(stored.stats.hp / 8, 1);
         stored.hp -|= damage;
         // As above, Pokémon Showdown uses damage [of] but its not relevant
-        try options.log.damage(.{ ident, stored, Damage.LeechSeed });
+        try options.log.damage(.{ ident, stored, .LeechSeed });
 
         const before = foe_stored.hp;
         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, Heal.Silent });
+        if (foe_stored.hp > before) try options.log.heal(.{ foe_ident, foe_stored, .Silent });
         if (stored.hp == 0) return true;
     }
 
     if (volatiles.Nightmare) {
         stored.hp -= @max(stored.stats.hp / 4, 1);
         // ibid
-        try options.log.damage(.{ ident, stored, Damage.Nightmare });
+        try options.log.damage(.{ ident, stored, .Nightmare });
         if (stored.hp == 0) return true;
     }
 
     if (volatiles.Curse) {
         stored.hp -= @max(stored.stats.hp / 4, 1);
         // ibid
-        try options.log.damage(.{ ident, stored, Damage.Curse });
+        try options.log.damage(.{ ident, stored, .Curse });
         if (stored.hp == 0) return true;
     }
 
@@ -993,7 +964,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
             future_sight.count -= 1;
             assert(future_sight.count != 0);
             if (future_sight.count == 1) {
-                try options.log.end(.{ battle.active(player), End.FutureSight });
+                try options.log.end(.{ battle.active(player), .FutureSight });
                 // TODO doMove
             }
         }
@@ -1002,7 +973,6 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
 
     // Weather
     if (battle.field.weather != .None) {
-        assert(battle.field.weather_duration > 0);
         battle.field.weather_duration -= 1;
 
         if (battle.field.weather_duration == 0) {
@@ -1019,7 +989,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
                         try options.log.damage(.{
                             battle.active(player),
                             side.stored(),
-                            Damage.Sandstorm,
+                            .Sandstorm,
                         });
                     }
                 }
@@ -1032,20 +1002,21 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
     inline for (players) |player| {
         var side = battle.side(player);
         var volatiles = &side.active.volatiles;
+        const ident = battle.active(player);
 
         if (volatiles.bind.duration > 0 and !volatiles.Substitute) {
             volatiles.bind.duration -= 1;
             if (volatiles.bind.duration == 0) {
                 const reason = @intFromEnum(End.Bind) + volatiles.bind.reason - 1;
-                try options.log.end(.{ battle.active(player), @as(End, @enumFromInt(reason)) });
+                try options.log.end(.{ ident, @as(End, @enumFromInt(reason)) });
             } else {
                 var reason = @intFromEnum(Activate.Bind) + volatiles.bind.reason - 1;
-                try options.log.activate(battle.active(player), @enumFromInt(reason));
+                try options.log.activate(.{ ident, @as(Activate, @enumFromInt(reason)) });
 
                 reason = @intFromEnum(Damage.Bind) + volatiles.bind.reason - 1;
                 side.stored().hp -|= @max(side.stored().stats.hp / 16, 1);
                 try options.log.damage(.{
-                    battle.active(player),
+                    ident,
                     side.stored(),
                     @as(Damage, @enumFromInt(reason)),
                 });
@@ -1060,12 +1031,11 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
         var volatiles = &side.active.volatiles;
 
         if (volatiles.PerishSong) {
-            assert(volatiles.perish_song > 0);
             volatiles.perish_song -= 1;
 
             assert(volatiles.perish_song < 3);
             const reason = @intFromEnum(Start.PerishSong0) + volatiles.perish_song;
-            try options.log.start(battle.active(player), @enumFromInt(reason));
+            try options.log.start(.{ battle.active(player), @as(Start, @enumFromInt(reason)) });
 
             if (volatiles.perish_song == 0) {
                 volatiles.PerishSong = false;
@@ -1083,14 +1053,14 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
             const before = stored.hp;
             stored.hp = @min(stored.hp + @max(stored.stats.hp / 16, 1), stored.stats.hp);
             if (stored.hp > before) {
-                try options.log.heal(.{ battle.active(player), stored, Heal.Leftovers });
+                try options.log.heal(.{ battle.active(player), stored, .Leftovers });
             }
         }
     }
 
     // Mystery Berry
     inline for (players) |player| {
-        var stored = battle.side(player).stored();
+        const stored = battle.side(player).stored();
 
         if (stored.item == .MysteryBerry) {
             // TODO stored and active moves, transform, etc
@@ -1105,8 +1075,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
             !side.active.volatiles.frozen and
             try Rolls.defrost(battle, player, options))
         {
-            const reason: CureStatus = .Message;
-            try options.log.curestatus(.{ battle.active(player), side.stored().status, reason });
+            try options.log.curestatus(.{ battle.active(player), side.stored().status, .Message });
             side.stored().status = 0;
         }
     }
@@ -1147,7 +1116,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
                     stored.hp < stored.stats.hp;
                 if (proc) {
                     assert(stored.hp != 0);
-                    try options.log.enditem(.{ ident, stored.item, EndItem.Eat });
+                    try options.log.enditem(.{ ident, stored.item, .Eat });
                     stored.item = .None;
 
                     const offset = num - @intFromEnum(Item.Berry);
@@ -1164,7 +1133,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
 
                 if (proc) {
                     assert(Status.any(stored.status));
-                    try options.log.enditem(.{ ident, stored.item, EndItem.Eat });
+                    try options.log.enditem(.{ ident, stored.item, .Eat });
                     stored.item = .None;
 
                     // FIXME wtf?
@@ -1172,21 +1141,21 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
                     // side.active.volatiles.Nightmare = false;
                     if (stored.item == .MiracleBerry) {
                         side.active.volatiles.Confusion = false;
-                        try options.log.end(.{ ident, End.Confusion });
+                        try options.log.end(.{ ident, .Confusion });
                     }
                     stored.status = 0;
 
                     // FIXME recalc stats
 
-                    try options.log.curestatus(.{ ident, stored.status, CureStatus.Message });
+                    try options.log.curestatus(.{ ident, stored.status, .Message });
                 }
             } else if (num == @intFromEnum(Item.BitterBerry)) {
                 if (side.active.volatiles.Confusion) {
-                    try options.log.enditem(.{ ident, stored.item, EndItem.Eat });
+                    try options.log.enditem(.{ ident, stored.item, .Eat });
                     stored.item = .None;
 
                     side.active.volatiles.Confusion = false;
-                    try options.log.end(.{ ident, End.Confusion });
+                    try options.log.end(.{ ident, .Confusion });
                 }
             }
         }
@@ -1198,12 +1167,11 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
         var volatiles = &side.active.volatiles;
 
         if (volatiles.Encore) {
-            assert(volatiles.encore > 0);
             volatiles.encore -= 1;
 
             if (volatiles.encore == 0 or side.active.move(mslot).pp == 0) {
                 volatiles.Encore = false;
-                try options.log.end(.{ battle.active(player), End.Encore });
+                try options.log.end(.{ battle.active(player), .Encore });
             }
         }
     }
@@ -1220,7 +1188,6 @@ fn updateSideCondition(
 ) !void {
     var side = battle.side(player);
     if (@field(side.conditions, key)) {
-        assert(@field(side.conditions, value) > 0);
         @field(side.conditions, value) -= 1;
 
         if (@field(side.conditions, value) == 0) {
@@ -1256,7 +1223,7 @@ pub fn buildRage(battle: anytype, player: Player, state: *State, options: anytyp
             }
         } else {
             foe.active.volatiles.rage +|= 1;
-            try options.log.activate(battle.active(player), .Rage);
+            try options.log.activate(.{ battle.active(player), .Rage });
         }
     }
 }
@@ -1279,7 +1246,7 @@ pub fn destinyBond(battle: anytype, player: Player, _: *State, options: anytype)
 
     if (foe.active.volatiles.DestinyBond) {
         battle.side(player).stored().hp = 0;
-        try options.log.activate(battle.active(player.foe()), .DestinyBond);
+        try options.log.activate(.{ battle.active(player.foe()), .DestinyBond });
     }
     return true;
 }
@@ -1292,14 +1259,14 @@ pub const Effects = struct {
         const gender: u8 = @intFromEnum(side.stored().dvs.gender);
         const foe_gender: u8 = @intFromEnum(foe.stored().dvs.gender);
         if (gender + foe_gender != 1) {
-            return options.log.immune(.{ battle.active(player.foe()), Immune.None });
+            return options.log.immune(.{ battle.active(player.foe()), .None });
         } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
             try options.log.lastmiss(.{});
             return options.log.miss(.{battle.active(player)});
         }
 
         foe.active.volatiles.Attract = true;
-        try options.log.start(battle.active(player.foe()), .Attract);
+        try options.log.start(.{ battle.active(player.foe()), .Attract });
     }
 
     pub fn batonPass(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1311,14 +1278,32 @@ pub const Effects = struct {
     }
 
     pub fn bellyDrum(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-        // assert(!state.miss);
-        // var side = battle.side(player);
-        // try boostStat(battle, side, &side.active.stats, &side.active.boosts, "atk", 2);
-        // TODO
-        // |-boost|p1a: Poliwag|atk|2|[silent]
-        // |-fail|p1a: Poliwag
-        //
+        assert(!state.miss);
+        var side = battle.side(player);
+
+        const ident = battle.active(player);
+
+        assert(side.active.boosts.atk >= -6 and side.active.boosts.atk <= 6);
+        if (side.active.boosts.atk == 6 or side.active.boosts.atk == MAX_STAT_VALUE) {
+            return options.log.fail(.{ ident, .None });
+        }
+
+        const hp = @max(side.stored().stats.hp / 2, 1);
+        if (side.stored().hp <= hp) {
+            try boostStat(battle, side, &side.active.stats, &side.active.boosts, "atk", 2);
+            try options.log.boost(.{ ident, .Attack, @as(i8, 2), .Silent });
+            return options.log.fail(.{ ident, .None });
+        } else {
+            side.stored().hp -= hp;
+            try options.log.damage(.{ ident, side.stored(), .None });
+
+            const before = side.active.boosts.atk;
+            var i: usize = 0;
+            while (i < 6 and side.active.stats.atk < MAX_STAT_VALUE) : (i += 1) {
+                try boostStat(battle, side, &side.active.stats, &side.active.boosts, "atk", 2);
+            }
+            try options.log.boost(.{ ident, .Attack, @as(i8, side.active.boosts.atk - before) });
+        }
     }
 
     pub const bide = struct {
@@ -1330,18 +1315,11 @@ pub const Effects = struct {
 
             if (!volatiles.Bide) return;
 
-            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);
-
-            if (volatiles.attacks != 0) return options.log.activate(ident, .Bide);
+            if (volatiles.attacks != 0) return options.log.activate(.{ ident, .Bide });
 
             volatiles.Bide = false;
-            try options.log.end(.{ ident, End.Bide });
+            try options.log.end(.{ ident, .Bide });
 
             state.damage = volatiles.bide *% 2;
             volatiles.bide = 0;
@@ -1378,7 +1356,7 @@ pub const Effects = struct {
                 try options.log.curestatus(.{
                     battle.active(player.foe()),
                     foe_stored.status,
-                    CureStatus.Message,
+                    .Message,
                 });
                 foe_stored.status = 0;
             }
@@ -1395,8 +1373,7 @@ pub const Effects = struct {
         foe_stored.status = Status.init(.BRN);
         foe.active.stats.atk = @max(foe.active.stats.atk / 2, 1);
 
-        const reason: protocol.Status = .None;
-        try options.log.status(.{ battle.active(player.foe()), foe_stored.status, reason });
+        try options.log.status(.{ battle.active(player.foe()), foe_stored.status, .None });
 
         // TODO: check for status berry
     }
@@ -1416,7 +1393,7 @@ pub const Effects = struct {
         for (side.active.moves) |m| {
             if (convertible(side.active, m.id)) n += 1;
         }
-        if (n == 0) return options.log.fail(.{ battle.active(player), Fail.None });
+        if (n == 0) return options.log.fail(.{ battle.active(player), .None });
 
         side.active.types.type1 = try Rolls.conversion(battle, player, n, options);
         side.active.types.type2 = side.active.types.type1;
@@ -1426,9 +1403,9 @@ pub const Effects = struct {
         var side = battle.side(player);
 
         const last = battle.foe(player).lastMove(false);
-        if (last == .None) return options.log.fail(.{ battle.active(player), Fail.None });
+        if (last == .None) return options.log.fail(.{ battle.active(player), .None });
         const move = Move.get(last);
-        if (move.type == .@"???") return options.log.fail(.{ battle.active(player), Fail.None });
+        if (move.type == .@"???") return options.log.fail(.{ battle.active(player), .None });
 
         side.active.types.type1 = try Rolls.conversion2(battle, player, move.type, options);
         side.active.types.type2 = side.active.types.type1;
@@ -1473,38 +1450,38 @@ pub const Effects = struct {
                 try options.log.lastmiss(.{});
                 return options.log.miss(.{battle.active(player)});
             } else if (foe.active.volatiles.Substitute) {
-                return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+                return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
             } else if (foe.active.volatiles.Curse) {
-                return options.log.fail(.{ foe_ident, Fail.None });
+                return options.log.fail(.{ foe_ident, .None });
             }
 
             foe.active.volatiles.Curse = true;
-            try options.log.start(foe_ident, .Curse);
+            try options.log.start(.{ foe_ident, .Curse });
 
             side.stored().hp -= @max(side.stored().stats.hp / 2, 1);
-            try options.log.damage(.{ ident, side.stored(), Damage.Curse });
+            try options.log.damage(.{ ident, side.stored(), .Curse });
         } else {
-            var stats = &side.active.stats;
-            var boosts = &side.active.boosts;
+            const stats = &side.active.stats;
+            const boosts = &side.active.boosts;
 
             const max_atk = boosts.atk == 6 or stats.atk == MAX_STAT_VALUE;
             const max_def = boosts.def == 6 or stats.def == MAX_STAT_VALUE;
-            if (max_atk and max_def) return options.log.fail(.{ ident, Fail.None });
+            if (max_atk and max_def) return options.log.fail(.{ ident, .None });
 
             if (!(boosts.spe == -6 or stats.spe == 1)) {
                 assert(boosts.spe >= -6 and boosts.spe <= 6);
                 try unboostStat(battle, side, stats, boosts, "spe", 1);
-                try options.log.boost(.{ ident, Boost.Speed, @as(i8, -1) });
+                try options.log.boost(.{ ident, .Speed, @as(i8, -1) });
             }
             if (!max_atk) {
                 assert(boosts.atk >= -6 and boosts.atk <= 6);
                 try boostStat(battle, side, stats, boosts, "atk", 1);
-                try options.log.boost(.{ ident, Boost.Attack, @as(i8, 1) });
+                try options.log.boost(.{ ident, .Attack, @as(i8, 1) });
             }
             if (!max_def) {
                 assert(boosts.def >= -6 and boosts.def <= 6);
                 try boostStat(battle, side, stats, boosts, "def", 1);
-                try options.log.boost(.{ ident, Boost.Defense, @as(i8, 1) });
+                try options.log.boost(.{ ident, .Defense, @as(i8, 1) });
             }
         }
     }
@@ -1516,9 +1493,7 @@ pub const Effects = struct {
     pub fn defrost(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var side = battle.side(player);
         assert(Status.is(side.stored().status, .FRZ));
-
-        const reason: CureStatus = .Message;
-        try options.log.curestatus(.{ battle.active(player), side.stored().status, reason });
+        try options.log.curestatus(.{ battle.active(player), side.stored().status, .Message });
         side.stored().status = 0;
     }
 
@@ -1532,14 +1507,10 @@ pub const Effects = struct {
         var volatiles = &foe.active.volatiles;
         const foe_ident = battle.active(player.foe());
 
-        if (volatiles.disable.move != 0) {
-            return options.log.fail(.{ foe_ident, Fail.None });
-        }
+        if (volatiles.disable.move != 0) return options.log.fail(.{ foe_ident, .None });
 
         const last = battle.foe(player).lastMove(false);
-        if (last == .None or last == .Struggle) {
-            return options.log.fail(.{ foe_ident, Fail.None });
-        }
+        if (last == .None or last == .Struggle) return options.log.fail(.{ foe_ident, .None });
 
         var slot: u3 = 0;
         for (foe.active.moves) |m| {
@@ -1548,12 +1519,12 @@ pub const Effects = struct {
             if (m.id == last) break;
         }
         const move = foe.active.move(slot);
-        if (move.pp == 0) return options.log.fail(.{ foe_ident, Fail.None });
+        if (move.pp == 0) return options.log.fail(.{ foe_ident, .None });
 
         volatiles.disable.move = slot;
         volatiles.disable.duration = Rolls.disableDuration(battle, player, options);
 
-        try options.log.startEffect(foe_ident, .Disable, move.id);
+        try options.log.start(.{ foe_ident, .Disable, move.id });
     }
 
     pub const double = struct {
@@ -1579,7 +1550,7 @@ pub const Effects = struct {
         if (stored.hp == stored.stats.hp) return;
         stored.hp = @min(stored.stats.hp, stored.hp + @max(state.damage / 2, 1));
 
-        try options.log.heal(.{ ident, stored, Heal.Drain, battle.active(player.foe()) });
+        try options.log.heal(.{ ident, stored, .Drain, battle.active(player.foe()) });
     }
 
     pub fn encore(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1591,7 +1562,7 @@ pub const Effects = struct {
         const failed = volatiles.Encore or
             (last == .None or last == .Struggle or
             last == .Encore or .last == .MirrorMove);
-        if (failed) return options.log.fail(.{ foe_ident, Fail.None });
+        if (failed) return options.log.fail(.{ foe_ident, .None });
 
         var slot: u3 = 0;
         for (foe.active.moves) |m| {
@@ -1600,7 +1571,7 @@ pub const Effects = struct {
             if (m.id == last) break;
         }
         const move = foe.active.move(slot);
-        if (move.pp == 0) return options.log.fail(.{ foe_ident, Fail.None });
+        if (move.pp == 0) return options.log.fail(.{ foe_ident, .None });
 
         volatiles.Encore = true;
         volatiles.encore = Rolls.encoreDuration(battle, player, options);
@@ -1608,11 +1579,19 @@ pub const Effects = struct {
         // TODO ???
         _ = state;
 
-        try options.log.startEffect(foe_ident, .Encore, move.id);
+        try options.log.start(.{ foe_ident, .Encore, move.id });
     }
 
-    pub fn explode(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn explode(battle: anytype, player: Player, _: *State, _: anytype) !void {
+        var side = battle.side(player);
+        var stored = side.stored();
+
+        stored.hp = 0;
+        // Pokémon Showdown sets the status to 0 on faint(), and we need to do the same to be able
+        // to correctly implement Pokémon Showdown's dumb speed-based switch mechanics
+        if (!showdown) stored.status = 0;
+        side.active.volatiles.LeechSeed = false;
+        side.active.volatiles.DestinyBond = false;
     }
 
     pub fn falseSwipe(battle: anytype, player: Player, state: *State, _: anytype) !void {
@@ -1662,12 +1641,11 @@ pub const Effects = struct {
         var side = battle.side(player);
 
         if (side.active.volatiles.FocusEnergy) {
-            if (!showdown) try options.log.fail(.{ battle.active(player), Fail.None });
-            return;
+            return if (!showdown) try options.log.fail(.{ battle.active(player), .None });
         }
 
         side.active.volatiles.FocusEnergy = true;
-        try options.log.start(battle.active(player), .FocusEnergy);
+        try options.log.start(.{ battle.active(player), .FocusEnergy });
     }
 
     var SLOTS: [5]u4 = .{ 0, 0, 0, 0, 0 };
@@ -1677,7 +1655,7 @@ pub const Effects = struct {
 
         const foe = battle.foe(player);
 
-        if (state.first) return options.log.fail(.{ battle.active(player), Fail.None });
+        if (state.first) return options.log.fail(.{ battle.active(player), .None });
 
         var n: u4 = 0;
         var i: u4 = 0;
@@ -1691,7 +1669,7 @@ pub const Effects = struct {
             }
         }
 
-        if (n == 0) return options.log.fail(.{ battle.active(player), Fail.None });
+        if (n == 0) return options.log.fail(.{ battle.active(player), .None });
 
         const slot = try Rolls.forceSwitch(battle, player, SLOTS[0..i], n, options);
         try switchIn(battle, player.foe(), slot, .Drag, options);
@@ -1704,11 +1682,11 @@ pub const Effects = struct {
             try options.log.lastmiss(.{});
             return options.log.miss(.{battle.active(player)});
         } else if (foe.active.volatiles.Foresight) {
-            return options.log.fail(.{ battle.active(player), Fail.None });
+            return options.log.fail(.{ battle.active(player), .None });
         }
 
         foe.active.volatiles.Foresight = true;
-        try options.log.start(battle.active(player.foe()), .FocusEnergy);
+        try options.log.start(.{ battle.active(player.foe()), .FocusEnergy });
     }
 
     pub fn freezeChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1731,7 +1709,7 @@ pub const Effects = struct {
         if (showdown) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
 
         foe_stored.status = Status.init(.FRZ);
-        try options.log.status(.{ foe_ident, foe_stored.status, protocol.Status.None });
+        try options.log.status(.{ foe_ident, foe_stored.status, .None });
 
         // TODO: check for status berry
 
@@ -1739,8 +1717,26 @@ pub const Effects = struct {
         foe.active.volatiles.frozen = true;
     }
 
-    pub fn furyCutter(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    // TODO FIXME showdown calls this before calcDamage (after checkHit) and modifies state.bp!
+    pub fn furyCutter(battle: anytype, player: Player, state: *State, _: anytype) !void {
+        var side = battle.side(player);
+        var volatiles = &side.active.volatiles;
+
+        if (state.miss) {
+            volatiles.fury_cutter = 0;
+            return;
+        }
+
+        assert(volatiles.fury_cutter >= 0 and volatiles.fury_cutter <= 5);
+        if (volatiles.fury_cutter == 5) return;
+        volatiles.fury_cutter += 1;
+
+        if (showdown) {
+            state.bp *= 2;
+            assert(state.bp <= 160);
+        } else {
+            state.damage *|= 2;
+        }
     }
 
     pub fn futureSight(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1774,7 +1770,7 @@ pub const Effects = struct {
         var stored = side.stored();
         const ident = battle.active(player);
 
-        if (stored.stats.hp == stored.hp) return options.log.fail(.{ ident, Fail.None });
+        if (stored.stats.hp == stored.hp) return options.log.fail(.{ ident, .None });
 
         const rest = state.move == .Rest;
         if (rest) {
@@ -1783,7 +1779,7 @@ pub const Effects = struct {
             side.active.volatiles.Toxic = false;
             stored.status = Status.slf(2);
             recomputeStats(battle, side);
-            try options.log.status(.{ ident, stored.status, protocol.Status.From, 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));
@@ -1821,7 +1817,7 @@ pub const Effects = struct {
             // Invulnerability trumps type immunity on Pokémon Showdown
             const invulnerable = foe.active.volatiles.Underground or foe.active.volatiles.Flying;
             if (!invulnerable and foe.active.types.includes(.Grass)) {
-                return options.log.immune(.{ battle.active(player.foe()), Immune.None });
+                return options.log.immune(.{ battle.active(player.foe()), .None });
             }
             try checkHit(battle, player, state, options);
             if (state.miss) {
@@ -1841,7 +1837,7 @@ pub const Effects = struct {
 
         foe.active.volatiles.LeechSeed = true;
 
-        try options.log.start(battle.active(player.foe()), .LeechSeed);
+        try options.log.start(.{ battle.active(player.foe()), .LeechSeed });
     }
 
     pub fn lockOn(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1849,20 +1845,20 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
 
         if (foe.active.volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         } else if (state.miss) {
-            return options.log.fail(.{ foe_ident, Fail.None });
+            return options.log.fail(.{ foe_ident, .None });
         }
 
         foe.active.volatiles.LockOn = true;
-        try options.log.activate(battle.active(player), .LockOn);
+        try options.log.activate(.{ battle.active(player), .LockOn });
     }
 
     const MAGNITUDE_POWER = [_]u8{ 10, 30, 50, 70, 90, 110, 150 };
 
     pub fn magnitude(battle: anytype, player: Player, state: *State, options: anytype) !void {
         const num = try Rolls.magnitude(battle, player, options);
-        try options.log.magnitude(battle.active(player), num);
+        try options.log.activate(.{ battle.active(player), .Magnitude, num });
         state.bp = MAGNITUDE_POWER[num - 4];
     }
 
@@ -1870,11 +1866,11 @@ pub const Effects = struct {
         var foe = battle.foe(player);
 
         if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-            if (!showdown) return options.log.fail(.{ battle.active(player.foe()), Fail.None });
+            if (!showdown) return options.log.fail(.{ battle.active(player.foe()), .None });
             try options.log.lastmiss(.{});
             return options.log.miss(.{battle.active(player)});
         } else if (foe.active.volatiles.Trapped) {
-            return options.log.fail(.{ battle.active(player.foe()), Fail.None });
+            return options.log.fail(.{ battle.active(player.foe()), .None });
         }
 
         foe.active.volatiles.Trapped = true;
@@ -1901,7 +1897,29 @@ pub const Effects = struct {
     }
 
     pub fn mimic(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+        var side = battle.side(player);
+
+        if (state.miss) {
+            if (!showdown) return options.log.fail(.{ battle.active(player.foe()), .None });
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
+        }
+
+        const move = battle.foe(player).lastMove(false);
+        if (move == .None or move == .Struggle) {
+            return options.log.fail(.{ battle.active(player.foe()), .None });
+        }
+
+        var slot: u4 = 0;
+        for (side.active.moves, 0..) |m, i| {
+            if (m.id == move) return options.log.fail(.{ battle.active(player.foe()), .None });
+            if (m.id == .Mimic) slot = @intCast(i + 1);
+        }
+        assert(slot != 0 and slot == state.mslot);
+
+        side.active.move(slot).id = move;
+        side.active.move(slot).pp = 5;
+        try options.log.start(.{ battle.active(player), .Mimic, move });
     }
 
     pub fn mirrorMove(
@@ -1918,11 +1936,11 @@ pub const Effects = struct {
 
         const last = foe.lastMove(false);
 
-        if (last == .None) return options.log.fail(.{ battle.active(player), Fail.None });
+        if (last == .None) return options.log.fail(.{ battle.active(player), .None });
         const knows = knows: for (side.active.moves) |m| {
             if (last == m.id) break :knows true;
         } else false;
-        if (knows) return options.log.fail(.{ battle.active(player), Fail.None });
+        if (knows) return options.log.fail(.{ battle.active(player), .None });
 
         // if (wPlayerCharging) ???
         // wPlayerCharging = 1
@@ -1936,19 +1954,17 @@ pub const Effects = struct {
     pub fn mist(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var side = battle.side(player);
 
-        if (side.active.volatiles.Mist) {
-            return options.log.fail(.{ battle.active(player), Fail.None });
-        }
+        if (side.active.volatiles.Mist) return options.log.fail(.{ battle.active(player), .None });
         side.active.volatiles.Mist = true;
 
-        try options.log.start(battle.active(player), .Mist);
+        try options.log.start(.{ battle.active(player), .Mist });
     }
 
     pub fn weatherHeal(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var stored = battle.side(player).stored();
         const ident = battle.active(player);
 
-        if (stored.hp == stored.stats.hp) return options.log.fail(.{ ident, Fail.None });
+        if (stored.hp == stored.stats.hp) return options.log.fail(.{ ident, .None });
 
         stored.hp = switch (battle.field.weather) {
             .Sun => stored.stats.hp,
@@ -1956,7 +1972,7 @@ pub const Effects = struct {
             else => @min(stored.stats.hp, stored.hp + (stored.stats.hp / 4)),
         };
 
-        try options.log.heal(.{ ident, stored, Heal.None });
+        try options.log.heal(.{ ident, stored, .None });
     }
 
     pub fn multiHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1969,17 +1985,17 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
 
         if (foe_volatiles.Flying or foe_volatiles.Underground) {
-            if (!showdown) return options.log.fail(.{ battle.active(player.foe()), Fail.None });
+            if (!showdown) return options.log.fail(.{ battle.active(player.foe()), .None });
             try options.log.lastmiss(.{});
             return options.log.miss(.{battle.active(player)});
         } else if (foe_volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         } else if (!Status.is(foe.stored().status, .SLP) or foe_volatiles.Nightmare) {
-            return options.log.fail(.{ foe_ident, Fail.None });
+            return options.log.fail(.{ foe_ident, .None });
         }
 
         foe_volatiles.Nightmare = true;
-        try options.log.start(battle.active(player.foe()), .Nightmare);
+        try options.log.start(.{ battle.active(player.foe()), .Nightmare });
     }
 
     pub const ohko = struct {
@@ -2003,9 +2019,9 @@ pub const Effects = struct {
             const foe_ident = battle.active(player.foe());
 
             state.damage = 0;
-            if (state.immune()) return options.log.immune(.{ foe_ident, Immune.None });
+            if (state.immune()) return options.log.immune(.{ foe_ident, .None });
             const delta = side.stored().level -| foe.stored().level;
-            if (delta == 0) return options.log.immune(.{ foe_ident, Immune.OHKO });
+            if (delta == 0) return options.log.immune(.{ foe_ident, .OHKO });
 
             state.accuracy = 2 * delta +| Gen12.percent(30);
             try checkHit(battle, player, state, options);
@@ -2021,17 +2037,17 @@ pub const Effects = struct {
         const ident = battle.active(player);
         const foe_ident = battle.active(player.foe());
 
-        if (state.miss) return options.log.fail(.{ foe_ident, Fail.None });
+        if (state.miss) return options.log.fail(.{ foe_ident, .None });
         if (foe.active.volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         }
 
         const avg = @max((foe.stored().hp + side.stored().hp) / 2, 1);
         foe.stored().hp -= avg;
         side.stored().hp = avg;
 
-        try options.log.sethp(.{ foe_ident, foe.stored(), SetHP.Silent });
-        try options.log.sethp(.{ ident, side.stored(), SetHP.None });
+        try options.log.sethp(.{ foe_ident, foe.stored(), .Silent });
+        try options.log.sethp(.{ ident, side.stored(), .None });
     }
 
     pub fn paralyze(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -2039,21 +2055,21 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
 
         if (Status.is(foe.stored().status, .PAR)) {
-            return options.log.fail(.{ foe_ident, Fail.Paralysis });
+            return options.log.fail(.{ foe_ident, .Paralysis });
         }
-        if (state.immune()) return options.log.immune(.{ foe_ident, Immune.None });
-        if (Status.any(foe.stored().status)) return options.log.fail(.{ foe_ident, Fail.None });
+        if (state.immune()) return options.log.immune(.{ foe_ident, .None });
+        if (Status.any(foe.stored().status)) return options.log.fail(.{ foe_ident, .None });
         if (state.miss) {
             try options.log.lastmiss(.{});
             return options.log.miss(.{battle.active(player)});
         } else if (foe.active.volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         }
 
         foe.stored().status = Status.init(.PAR);
         foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
 
-        try options.log.status(.{ foe_ident, foe.stored().status, protocol.Status.None });
+        try options.log.status(.{ foe_ident, foe.stored().status, .None });
     }
 
     pub fn paralyzeChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -2069,8 +2085,7 @@ pub const Effects = struct {
         foe_stored.status = Status.init(.PAR);
         foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
 
-        const reason: protocol.Status = .None;
-        try options.log.status(.{ battle.active(player.foe()), foe_stored.status, reason });
+        try options.log.status(.{ battle.active(player.foe()), foe_stored.status, .None });
 
         // TODO: check for status berry
     }
@@ -2086,15 +2101,15 @@ pub const Effects = struct {
         var foe = battle.foe(player);
 
         if (foe.active.volatiles.PerishSong) {
-            return options.log.fail(.{ battle.active(player.foe()), Fail.None });
+            return options.log.fail(.{ battle.active(player.foe()), .None });
         } else if (!side.active.volatiles.PerishSong) {
             side.active.volatiles.PerishSong = true;
             side.active.volatiles.perish_song = 4;
-            try options.log.start(battle.active(player), .PerishSong3Silent);
+            try options.log.start(.{ battle.active(player), .PerishSong3Silent });
         }
         foe.active.volatiles.PerishSong = true;
         foe.active.volatiles.perish_song = 4;
-        try options.log.start(battle.active(player.foe()), .PerishSong3Silent);
+        try options.log.start(.{ battle.active(player.foe()), .PerishSong3Silent });
 
         try options.log.fieldactivate(.{}); // FIXME .PerishSong
     }
@@ -2106,7 +2121,7 @@ pub const Effects = struct {
 
         const toxic = state.move == .Toxic;
         if (state.immune() or foe.active.types.includes(.Poison)) {
-            return options.log.immune(.{ foe_ident, Immune.None });
+            return options.log.immune(.{ foe_ident, .None });
         } else if (Status.any(foe_stored.status)) {
             // Pokémon Showdown considers Toxic to be a status even in Generation II and so
             // will not include a fail reason for Toxic vs. Poison or vice-versa...
@@ -2120,7 +2135,7 @@ pub const Effects = struct {
             else
                 Fail.None });
         } else if (foe.active.volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         } else if (state.miss) {
             try options.log.lastmiss(.{});
             return options.log.miss(.{battle.active(player)});
@@ -2133,7 +2148,7 @@ pub const Effects = struct {
             foe.active.volatiles.toxic = 0;
         }
 
-        try options.log.status(.{ foe_ident, foe_stored.status, protocol.Status.None });
+        try options.log.status(.{ foe_ident, foe_stored.status, .None });
 
         // TODO: check for status berry
     }
@@ -2149,8 +2164,8 @@ pub const Effects = struct {
         if (foe.conditions.Safeguard) return;
 
         foe_stored.status = Status.init(.PSN);
-        const reason: protocol.Status = .None;
-        try options.log.status(.{ battle.active(player.foe()), foe_stored.status, reason });
+
+        try options.log.status(.{ battle.active(player.foe()), foe_stored.status, .None });
 
         // TODO: check for status berry
     }
@@ -2165,9 +2180,7 @@ pub const Effects = struct {
 
         const failed = !state.first or volatiles.Substitute or
             !try Rolls.protect(battle, player, volatiles.protect, options);
-        if (failed) {
-            return options.log.fail(.{ battle.active(player), Fail.None });
-        }
+        if (failed) return options.log.fail(.{ battle.active(player), .None });
 
         volatiles.protect = @max(8, volatiles.protect + 1);
         if (state.move == .Endure) {
@@ -2184,7 +2197,7 @@ pub const Effects = struct {
 
         // Pokémon Showdown should fail when the enemy has no boosts/unboosts but doesn't
         if (!showdown and @as(u32, @bitCast(foe.active.boosts)) == 0) {
-            return options.log.fail(.{ battle.active(player), Fail.None });
+            return options.log.fail(.{ battle.active(player), .None });
         }
 
         side.active.boosts = foe.active.boosts;
@@ -2203,11 +2216,10 @@ pub const Effects = struct {
         }
 
         pub fn damage(battle: anytype, player: Player, state: *State, _: anytype) !void {
-            var side = battle.side(player);
-            var volatiles = &side.active.volatiles;
+            const side = battle.side(player);
 
-            assert(volatiles.Rage);
-            state.damage *|= (volatiles.rage +| 1);
+            assert(side.active.volatiles.Rage);
+            state.damage *|= (side.active.volatiles.rage +| 1);
         }
     };
 
@@ -2219,7 +2231,7 @@ pub const Effects = struct {
         var side = battle.side(player);
 
         if (side.active.volatiles.LeechSeed) {
-            try options.log.end(.{ battle.active(player), End.LeechSeedFrom });
+            try options.log.end(.{ battle.active(player), .LeechSeedFrom });
             side.active.volatiles.LeechSeed = false;
         }
 
@@ -2238,18 +2250,14 @@ pub const Effects = struct {
     pub fn recoil(battle: anytype, player: Player, state: *State, options: anytype) !void {
         var side = battle.side(player);
         var stored = side.stored();
+        const ident = battle.active(player);
 
         assert(state.damage > 0);
 
         const damage: i16 = @intCast(@max(state.damage / 4, 1));
         stored.hp = @intCast(@max(@as(i16, @intCast(stored.hp)) - damage, 0));
 
-        try options.log.damage(.{
-            battle.active(player),
-            stored,
-            Damage.RecoilOf,
-            battle.active(player.foe()),
-        });
+        try options.log.damage(.{ ident, stored, .RecoilOf, battle.active(player.foe()) });
     }
 
     pub fn reversal(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -2312,7 +2320,7 @@ pub const Effects = struct {
 
     pub fn sandstorm(battle: anytype, player: Player, _: *State, options: anytype) !void {
         if (battle.field.weather != .Sandstorm) return weather(battle, .Sandstorm, options);
-        return options.log.fail(.{ battle.active(player), Fail.None });
+        return options.log.fail(.{ battle.active(player), .None });
     }
 
     pub fn safeguard(battle: anytype, player: Player, _: *State, options: anytype) !void {
@@ -2337,7 +2345,7 @@ pub const Effects = struct {
         var side = battle.side(player);
 
         if (@field(side.conditions, key)) {
-            return options.log.fail(.{ battle.active(player), Fail.None });
+            return options.log.fail(.{ battle.active(player), .None });
         }
 
         @field(side.conditions, key) = true;
@@ -2353,9 +2361,9 @@ pub const Effects = struct {
 
         if (showdown) {
             // yes, actually "Splash". '|nothing' gets blindly mapped to  '|-activate||move:Splash'
-            try options.log.activate(battle.active(player), .Splash);
+            try options.log.activate(.{ battle.active(player), .Splash });
         } else {
-            try options.log.fail(.{ battle.active(player), Fail.None });
+            try options.log.fail(.{ battle.active(player), .None });
         }
     }
 
@@ -2372,7 +2380,7 @@ pub const Effects = struct {
         }
 
         if (foe.active.volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         }
 
         // Sleep Clause Mod
@@ -2383,22 +2391,21 @@ pub const Effects = struct {
         }
 
         foe_stored.status = Status.slp(Rolls.sleepDuration(battle, player, options));
-        try options.log.status(.{ foe_ident, foe_stored.status, protocol.Status.From, state.move });
+        try options.log.status(.{ foe_ident, foe_stored.status, .From, state.move });
     }
 
     pub fn sleepTalk(battle: anytype, player: Player, state: *State, options: anytype) !void {
         const side = battle.side(player);
 
         if (!Status.is(side.stored().status, .SLP)) {
-            if (!showdown) try options.log.fail(.{ battle.active(player), Fail.None });
-            return;
+            return if (!showdown) try options.log.fail(.{ battle.active(player), .None });
         }
 
         var n: u3 = 0;
         for (side.active.moves, 0..) |m, i| {
             if (state.mslot - 1 != i and Move.get(m.id).extra.sleep_talk) n += 1;
         }
-        if (n == 0) return options.log.fail(.{ battle.active(player), Fail.None });
+        if (n == 0) return options.log.fail(.{ battle.active(player), .None });
 
         _ = try Rolls.sleepTalk(battle, player, n, state.mslot, options); // TODO
     }
@@ -2407,55 +2414,75 @@ pub const Effects = struct {
         if (Status.is(battle.side(player).stored().status, .SLP)) return true;
         state.damage = 0;
         state.miss = true; // TODO is this necessary?
-        if (!showdown) try options.log.fail(.{ battle.active(player), Fail.None });
+        if (!showdown) try options.log.fail(.{ battle.active(player), .None });
         return false;
     }
 
     pub fn spikes(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var foe = battle.foe(player);
-        if (foe.conditions.Spikes) return options.log.fail(.{ battle.active(player), Fail.None });
+        if (foe.conditions.Spikes) return options.log.fail(.{ battle.active(player), .None });
 
         foe.conditions.Spikes = true;
         try options.log.sidestart(.{ player.foe(), protocol.Side.Spikes });
     }
 
     pub fn spite(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-        // var foe = battle.foe(player);
+        var foe = battle.foe(player);
 
-        // if (state.miss) return options.log.fail(.{ battle.active(player), Fail.None });
+        const last = foe.lastMove(false);
+        if (state.miss or last == .None or last == .Struggle) {
+            return options.log.fail(.{ battle.active(player.foe()), .None });
+        }
 
-        // const last = foe.lastMove(false);
-        // if (showdown) {
-        //     const roll = try Rolls.spite(battle, player, options);
-        // } else {
-        //     if (last != .None) {}
-        // }
+        var slot: u4 = 0;
+        for (foe.active.moves, 0..) |m, i| {
+            if (m.id == last) slot = @intCast(i + 1);
+        }
+        // If the move was called via Metronome it might not exist
+        if (slot == 0 or foe.active.move(slot).pp == 0) {
+            return options.log.fail(.{ battle.active(player.foe()), .None });
+        }
+
+        // Pokémon Showdown always deducts 4 instead of randomizing
+        const pp = @min(
+            foe.active.move(slot).pp,
+            if (showdown) 4 else try Rolls.spite(battle, player, options),
+        );
+        foe.active.move(slot).pp -= pp;
+        if (!foe.active.volatiles.Transform) {
+            var move_slot = foe.stored().move(slot);
+            assert(move_slot.pp > 0);
+
+            move_slot.pp = @as(u6, @intCast(move_slot.pp)) -% 1;
+            assert(foe.active.move(slot).pp == foe.stored().move(slot).pp);
+        }
+
+        try options.log.activate(.{ battle.active(player.foe()), .Spite, last, pp });
     }
 
     pub fn splash(battle: anytype, player: Player, _: *State, options: anytype) !void {
-        try options.log.activate(battle.active(player), .Splash);
+        try options.log.activate(.{ battle.active(player), .Splash });
     }
 
     pub fn substitute(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var side = battle.side(player);
         if (side.active.volatiles.Substitute) {
-            return options.log.fail(.{ battle.active(player), Fail.Substitute });
+            return options.log.fail(.{ battle.active(player), .Substitute });
         }
 
         assert(side.stored().stats.hp <= 1023);
         const hp: u8 = @intCast(side.stored().stats.hp / 4);
 
         if (hp == 0 or side.stored().hp <= hp) {
-            return options.log.fail(.{ battle.active(player), Fail.Weak });
+            return options.log.fail(.{ battle.active(player), .Weak });
         }
 
         side.stored().hp -= hp;
         side.active.volatiles.substitute = hp;
         side.active.volatiles.Substitute = true;
         side.active.volatiles.bind = .{};
-        try options.log.start(battle.active(player), .Substitute);
-        try options.log.damage(.{ battle.active(player), side.stored(), Damage.None });
+        try options.log.start(.{ battle.active(player), .Substitute });
+        try options.log.damage(.{ battle.active(player), side.stored(), .None });
     }
 
     pub fn sunnyDay(battle: anytype, _: Player, _: *State, options: anytype) !void {
@@ -2471,7 +2498,7 @@ pub const Effects = struct {
     pub fn teleport(battle: anytype, player: Player, _: *State, options: anytype) !void {
         if (showdown) return;
 
-        try options.log.fail(.{ battle.active(player), Fail.None });
+        try options.log.fail(.{ battle.active(player), .None });
         try options.log.laststill(.{});
     }
 
@@ -2513,9 +2540,9 @@ pub const Effects = struct {
         side.active.volatiles.dirty = false;
 
         if (foe.active.volatiles.Transform) {
-            return options.log.fail(.{ battle.active(player), Fail.None });
+            return options.log.fail(.{ battle.active(player), .None });
         } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-            if (!showdown) return options.log.fail(.{ battle.active(player), Fail.None });
+            if (!showdown) return options.log.fail(.{ battle.active(player), .None });
             try options.log.lastmiss(.{});
             return options.log.miss(.{battle.active(player)});
         }
@@ -2564,8 +2591,8 @@ pub const Effects = struct {
     pub fn allStatUpChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
         var side = battle.side(player);
 
-        var stats = &side.active.stats;
-        var boosts = &side.active.boosts;
+        const stats = &side.active.stats;
+        const boosts = &side.active.boosts;
 
         if (!state.proc) return;
         inline for (STATS, STAT_UP_REASONS) |s, r| {
@@ -2584,9 +2611,9 @@ pub const Effects = struct {
         var side = battle.side(player);
         const ident = battle.active(player);
 
-        if (state.miss) return log.fail(.{ ident, Fail.None });
+        if (state.miss) return log.fail(.{ ident, .None });
 
-        var stats = &side.active.stats;
+        const stats = &side.active.stats;
         var boosts = &side.active.boosts;
 
         const move = Move.get(state.move);
@@ -2594,7 +2621,7 @@ pub const Effects = struct {
             .AttackUp1, .AttackUp2, .Rage, .Swagger => {
                 assert(boosts.atk >= -6 and boosts.atk <= 6);
                 if (boosts.atk == 6 or stats.atk == MAX_STAT_VALUE) {
-                    return log.fail(.{ ident, Fail.None });
+                    return log.fail(.{ ident, .None });
                 }
                 const n: u2 = if (move.effect == .AttackUp2 or move.effect == .Swagger) 2 else 1;
                 try boostStat(battle, side, stats, boosts, "atk", n);
@@ -2604,41 +2631,41 @@ pub const Effects = struct {
             .DefenseUp1, .DefenseUp2, .SkullBash => {
                 assert(boosts.def >= -6 and boosts.def <= 6);
                 if (boosts.def == 6 or stats.def == MAX_STAT_VALUE) {
-                    return log.fail(.{ ident, Fail.None });
+                    return log.fail(.{ ident, .None });
                 }
                 const n: u2 = if (move.effect == .DefenseUp2) 2 else 1;
                 try boostStat(battle, side, stats, boosts, "def", n);
-                try log.boost(.{ ident, Boost.Defense, n });
+                try log.boost(.{ ident, .Defense, n });
             },
             .SpeedUp2 => {
                 assert(boosts.spe >= -6 and boosts.spe <= 6);
                 if (boosts.spe == 6 or stats.spe == MAX_STAT_VALUE) {
-                    return log.fail(.{ ident, Fail.None });
+                    return log.fail(.{ ident, .None });
                 }
                 try boostStat(battle, side, stats, boosts, "spe", 2);
-                try log.boost(.{ ident, Boost.Speed, 2 });
+                try log.boost(.{ ident, .Speed, 2 });
             },
             .SpAtkUp1 => {
                 assert(boosts.spa >= -6 and boosts.spa <= 6);
                 if (boosts.spa == 6 or stats.spa == MAX_STAT_VALUE) {
-                    return log.fail(.{ ident, Fail.None });
+                    return log.fail(.{ ident, .None });
                 }
                 try boostStat(battle, side, stats, boosts, "spa", 1);
-                try log.boost(.{ ident, Boost.SpecialAttack, 1 });
+                try log.boost(.{ ident, .SpecialAttack, 1 });
             },
             .SpDefUp2 => {
                 assert(boosts.spd >= -6 and boosts.spd <= 6);
                 if (boosts.spd == 6 or stats.spd == MAX_STAT_VALUE) {
-                    return log.fail(.{ ident, Fail.None });
+                    return log.fail(.{ ident, .None });
                 }
                 try boostStat(battle, side, stats, boosts, "spd", 2);
-                try log.boost(.{ ident, Boost.SpecialDefense, 2 });
+                try log.boost(.{ ident, .SpecialDefense, 2 });
             },
             .EvasionUp1 => {
                 assert(boosts.evasion >= -6 and boosts.evasion <= 6);
-                if (boosts.evasion == 6) return log.fail(.{ ident, Fail.None });
+                if (boosts.evasion == 6) return log.fail(.{ ident, .None });
                 boosts.evasion = @intCast(@min(6, @as(i8, boosts.evasion) + 1));
-                try log.boost(.{ ident, Boost.Evasion, 1 });
+                try log.boost(.{ ident, .Evasion, 1 });
                 if (state.move == .Minimize) side.active.volatiles.minimized = true;
             },
             else => unreachable,
@@ -2651,13 +2678,13 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
 
         if (foe.active.volatiles.Mist) {
-            try log.activate(foe_ident, .Mist);
-            return log.fail(.{ foe_ident, Fail.None });
+            try log.activate(.{ foe_ident, .Mist });
+            return log.fail(.{ foe_ident, .None });
         }
 
         const fail = foe.active.volatiles.Substitute or state.miss or !state.proc;
 
-        var stats = &foe.active.stats;
+        const stats = &foe.active.stats;
         var boosts = &foe.active.boosts;
 
         const move = Move.get(state.move);
@@ -2675,7 +2702,7 @@ pub const Effects = struct {
                 }
                 const n: u2 = if (move.effect == .AttackDown2) 2 else 1;
                 try unboostStat(battle, foe, stats, boosts, "atk", n);
-                try log.boost(.{ foe_ident, Boost.Attack, -@as(i8, n) });
+                try log.boost(.{ foe_ident, .Attack, -@as(i8, n) });
             },
             .DefenseDown1, .DefenseDown2, .DefenseDownChance => {
                 assert(boosts.def >= -6 and boosts.def <= 6);
@@ -2691,7 +2718,7 @@ pub const Effects = struct {
                 }
                 const n: u2 = if (move.effect == .DefenseDown2) 2 else 1;
                 try unboostStat(battle, foe, stats, boosts, "def", n);
-                try log.boost(.{ foe_ident, Boost.Defense, -@as(i8, n) });
+                try log.boost(.{ foe_ident, .Defense, -@as(i8, n) });
             },
             .SpeedDown1, .SpeedDown2, .SpeedDownChance => {
                 assert(boosts.spe >= -6 and boosts.spe <= 6);
@@ -2705,7 +2732,7 @@ pub const Effects = struct {
                 }
                 const n: u2 = if (move.effect == .SpeedDown2) 2 else 1;
                 try unboostStat(battle, foe, stats, boosts, "spe", n);
-                try log.boost(.{ foe_ident, Boost.Speed, -@as(i8, n) });
+                try log.boost(.{ foe_ident, .Speed, -@as(i8, n) });
             },
             .SpDefDownChance => {
                 assert(boosts.spd >= -6 and boosts.spd <= 6);
@@ -2715,7 +2742,7 @@ pub const Effects = struct {
                     return options.log.miss(.{battle.active(player)});
                 } else if (stats.spd == 1) return;
                 try unboostStat(battle, foe, stats, boosts, "spd", 1);
-                try log.boost(.{ foe_ident, Boost.SpecialDefense, -1 });
+                try log.boost(.{ foe_ident, .SpecialDefense, -1 });
             },
             .AccuracyDown1, .AccuracyDownChance => {
                 assert(boosts.accuracy >= -6 and boosts.accuracy <= 6);
@@ -2727,7 +2754,7 @@ pub const Effects = struct {
                     return options.log.miss(.{battle.active(player)});
                 }
                 boosts.accuracy = @intCast(@max(-6, @as(i8, boosts.accuracy) - 1));
-                try log.boost(.{ foe_ident, Boost.Accuracy, -1 });
+                try log.boost(.{ foe_ident, .Accuracy, -1 });
             },
             else => unreachable,
         }
@@ -2741,9 +2768,9 @@ fn unmodifiedStats(battle: anytype, side: *Side) *Stats(u16) {
 }
 
 fn recomputeStats(battle: anytype, side: *Side) void {
-    var stats = unmodifiedStats(battle, side);
+    const stats = unmodifiedStats(battle, side);
     inline for (STATS) |s| {
-        var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, @field(side.active.boosts, s)) + 6))];
+        const mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, @field(side.active.boosts, s)) + 6))];
         const val = @field(stats, s) * mod[0] / mod[1];
         @field(side.active.stats, s) = @max(1, @min(MAX_STAT_VALUE, val));
     }
@@ -2766,7 +2793,7 @@ fn boostStat(
     n: u2,
 ) !void {
     @field(boosts, s) = @intCast(@min(6, @as(i8, @field(boosts, s)) + n));
-    var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, @field(boosts, s)) + 6))];
+    const mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, @field(boosts, s)) + 6))];
     const stat = @field(unmodifiedStats(battle, side), s);
     @field(stats, s) = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
     if (comptime std.mem.eql(u8, s, "atk")) {
@@ -2789,7 +2816,7 @@ fn unboostStat(
     n: u2,
 ) !void {
     @field(boosts, s) = @intCast(@max(-6, @as(i8, @field(boosts, s)) - n));
-    var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, @field(boosts, s)) + 6))];
+    const mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, @field(boosts, s)) + 6))];
     const stat = @field(unmodifiedStats(battle, side), s);
     @field(stats, s) = @max(1, stat * mod[0] / mod[1]);
     if (comptime std.mem.eql(u8, s, "atk")) {
@@ -2817,7 +2844,7 @@ fn convertible(active: ActivePokemon, m: Move) bool {
 
 pub const Rolls = struct {
     fn speedTie(battle: anytype, options: anytype) !bool {
-        const p1 = if (options.calc.overridden(.P1, .speed_tie)) |player|
+        const p1 = if (options.calc.overridden(.P1, 0, .speed_tie)) |player|
             player == .P1
         else if (showdown)
             battle.rng.range(u8, 0, 2) == 0
@@ -2829,7 +2856,7 @@ pub const Rolls = struct {
     }
 
     fn quickClaw(battle: anytype, player: Player, options: anytype) !bool {
-        const qkc = if (options.calc.overridden(player, .quick_claw)) |val|
+        const qkc = if (options.calc.overridden(player, 0, .quick_claw)) |val|
             val == .true
         else if (showdown)
             battle.rng.chance(u8, 60, 256)
@@ -2841,7 +2868,7 @@ pub const Rolls = struct {
     }
 
     fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) !bool {
-        const ok = if (options.calc.overridden(player, .hit)) |val|
+        const ok = if (options.calc.overridden(player, 0, .hit)) |val|
             val == .true
         else if (showdown)
             battle.rng.chance(u8, accuracy, 256)
@@ -2852,20 +2879,22 @@ pub const Rolls = struct {
         return ok;
     }
 
-    fn criticalHit(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
-        const crit = if (options.calc.overridden(player, .critical_hit)) |val|
+    fn criticalHit(battle: anytype, player: Player, i: u3, rate: u8, options: anytype) !bool {
+        _ = .{ player, options };
+        const crit = if (options.calc.overridden(player, i, .critical_hits)) |val|
             val == .true
         else if (showdown)
             battle.rng.chance(u8, rate, 256)
         else
             battle.rng.next() < rate;
 
-        try options.chance.criticalHit(player, crit, rate);
+        try options.chance.criticalHit(player, i, crit, rate);
         return crit;
     }
 
-    fn damage(battle: anytype, player: Player, options: anytype) !u8 {
-        const roll = if (options.calc.overridden(player, .damage)) |val|
+    fn damage(battle: anytype, player: Player, i: u3, options: anytype) !u8 {
+        _ = .{ player, options };
+        const roll = if (options.calc.overridden(player, i, .damages)) |val|
             val
         else roll: {
             if (showdown) break :roll battle.rng.range(u8, 217, 256);
@@ -2876,12 +2905,12 @@ pub const Rolls = struct {
         };
 
         assert(roll >= 217 and roll <= 255);
-        try options.chance.damage(player, roll);
+        try options.chance.damage(player, i, roll);
         return roll;
     }
 
     fn confused(battle: anytype, player: Player, options: anytype) !bool {
-        const cfz = if (options.calc.overridden(player, .confused)) |val|
+        const cfz = if (options.calc.overridden(player, 0, .confused)) |val|
             val == .true
         else if (showdown)
             !battle.rng.chance(u8, 128, 256)
@@ -2893,7 +2922,7 @@ pub const Rolls = struct {
     }
 
     fn attract(battle: anytype, player: Player, options: anytype) !bool {
-        const cant = if (options.calc.overridden(player, .attract)) |val|
+        const cant = if (options.calc.overridden(player, 0, .attract)) |val|
             val == .true
         else if (showdown)
             battle.rng.chance(u8, 1, 2)
@@ -2905,7 +2934,7 @@ pub const Rolls = struct {
     }
 
     fn paralyzed(battle: anytype, player: Player, options: anytype) !bool {
-        const par = if (options.calc.overridden(player, .paralyzed)) |val|
+        const par = if (options.calc.overridden(player, 0, .paralyzed)) |val|
             val == .true
         else if (showdown)
             battle.rng.chance(u8, 63, 256)
@@ -2917,7 +2946,7 @@ pub const Rolls = struct {
     }
 
     fn defrost(battle: anytype, player: Player, options: anytype) !bool {
-        const thaw = if (options.calc.overridden(player, .defrost)) |val|
+        const thaw = if (options.calc.overridden(player, 0, .defrost)) |val|
             val == .true
         else if (showdown)
             battle.rng.chance(u8, 25, 256)
@@ -2930,7 +2959,7 @@ pub const Rolls = struct {
 
     fn secondaryChance(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
         // GLITCH: 100% secondary chance will still fail 1/256 of the time
-        const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
+        const proc = if (options.calc.overridden(player, 0, .secondary_chance)) |val|
             val == .true
         else if (showdown)
             battle.rng.chance(u8, rate, 256)
@@ -2942,7 +2971,7 @@ pub const Rolls = struct {
     }
 
     fn item(battle: anytype, player: Player, options: anytype) !bool {
-        const proc = if (options.calc.overridden(player, .item)) |val|
+        const proc = if (options.calc.overridden(player, 0, .item)) |val|
             val == .true
         else if (showdown)
             battle.rng.chance(u8, 30, 256)
@@ -2954,7 +2983,7 @@ pub const Rolls = struct {
     }
 
     fn triAttack(battle: anytype, player: Player, options: anytype) !TriAttack {
-        const status: TriAttack = if (options.calc.overridden(player, .tri_attack)) |val|
+        const status: TriAttack = if (options.calc.overridden(player, 0, .tri_attack)) |val|
             @enumFromInt(@intFromEnum(val) - 1)
         else if (showdown)
             @enumFromInt(battle.rng.range(u2, 0, 2))
@@ -2970,7 +2999,7 @@ pub const Rolls = struct {
     }
 
     fn present(battle: anytype, player: Player, options: anytype) !u8 {
-        const power = if (options.calc.overridden(player, .present)) |val|
+        const power = if (options.calc.overridden(player, 0, .present)) |val|
             (val - 1) * 40
         else if (showdown) power: {
             const r = battle.rng.range(u8, 0, 10);
@@ -2992,7 +3021,7 @@ pub const Rolls = struct {
     }
 
     fn magnitude(battle: anytype, player: Player, options: anytype) !u8 {
-        const num: u8 = if (options.calc.overridden(player, .magnitude)) |val|
+        const num: u8 = if (options.calc.overridden(player, 0, .magnitude)) |val|
             val + 3
         else if (showdown) num: {
             const r = battle.rng.range(u8, 0, 100);
@@ -3020,7 +3049,7 @@ pub const Rolls = struct {
     }
 
     fn tripleKick(battle: anytype, player: Player, options: anytype) !u2 {
-        const hits = if (options.calc.overridden(player, .triple_kick)) |val|
+        const hits = if (options.calc.overridden(player, 0, .triple_kick)) |val|
             val
         else if (showdown)
             battle.rng.range(u2, 1, 4)
@@ -3036,13 +3065,12 @@ pub const Rolls = struct {
         return hits;
     }
 
-    fn spite(battle: anytype, player: Player, options: anytype) !u8 {
-        const pp = if (options.calc.overridden(player, .spite)) |val|
+    fn spite(battle: anytype, player: Player, options: anytype) !u3 {
+        assert(!showdown);
+        const pp: u3 = if (options.calc.overridden(player, 0, .spite)) |val|
             val + 1
-        else if (showdown)
-            battle.rng.range(u8, 2, 6)
         else
-            (battle.rng.next() & 3) + 2;
+            @intCast((battle.rng.next() & 3) + 2);
 
         assert(pp >= 2 and pp <= 5);
         try options.chance.spite(player, pp);
@@ -3056,7 +3084,7 @@ pub const Rolls = struct {
         var i: u8 = 0;
         const neutral = @intFromEnum(Effectiveness.Neutral);
         assert(mtype != .@"???");
-        const ty: Type = if (options.calc.overridden(player, .conversion_2)) |val|
+        const ty: Type = if (options.calc.overridden(player, 0, .conversion_2)) |val|
             @enumFromInt(@intFromEnum(val) - 1)
         else if (showdown) ty: {
             for (Type.SHOWDOWN) |t| {
@@ -3090,7 +3118,7 @@ pub const Rolls = struct {
         assert(count <= 8);
         const num = if (count == 8) 0 else @as(u8, 255) >> @intCast(count);
 
-        const ok = if (options.calc.overridden(player, .protect)) |val|
+        const ok = if (options.calc.overridden(player, 0, .protect)) |val|
             val == .true
         else if (showdown)
             battle.rng.chance(u8, num, 255)
@@ -3112,7 +3140,7 @@ pub const Rolls = struct {
         const moves = active.moves;
 
         // TODO: consider throwing error instead of rerolling?
-        const overridden = if (options.calc.overridden(player, .move_slot)) |val|
+        const overridden = if (options.calc.overridden(player, 0, .move_slot)) |val|
             if (convertible(active, moves[val - 1].id)) val else null
         else
             null;
@@ -3149,7 +3177,7 @@ pub const Rolls = struct {
         const moves = active.moves;
 
         // TODO: consider throwing error instead of rerolling?
-        const overridden = if (options.calc.overridden(player, .move_slot)) |val|
+        const overridden = if (options.calc.overridden(player, 0, .move_slot)) |val|
             if (val != mslot and Move.get(moves[val - 1].id).extra.sleep_talk) val else null
         else
             null;
@@ -3193,7 +3221,7 @@ pub const Rolls = struct {
         assert(n > 0 and n <= 6);
 
         // TODO: consider throwing error instead of rerolling?
-        const overridden = if (options.calc.overridden(player, .force_switch)) |val| val: {
+        const overridden = if (options.calc.overridden(player, 0, .force_switch)) |val| val: {
             for (slots) |slot| if (slot == val) break :val if (foe.get(slot).hp > 0) val else null;
             break :val null;
         } else null;
@@ -3219,7 +3247,7 @@ pub const Rolls = struct {
     const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
 
     fn multiHit(battle: anytype, player: Player, options: anytype) !u3 {
-        const n: u3 = if (options.calc.overridden(player, .multi_hit)) |val|
+        const n: u3 = if (options.calc.overridden(player, 0, .multi_hit)) |val|
             @intCast(val)
         else if (showdown)
             DISTRIBUTION[battle.rng.range(u3, 0, DISTRIBUTION.len)]
@@ -3234,7 +3262,7 @@ pub const Rolls = struct {
     }
 
     fn psywave(battle: anytype, player: Player, max: u8, options: anytype) !u8 {
-        const power = if (options.calc.overridden(player, .psywave)) |val|
+        const power = if (options.calc.overridden(player, 0, .psywave)) |val|
             val
         else if (showdown)
             battle.rng.range(u8, 1, max)
@@ -3260,7 +3288,7 @@ pub const Rolls = struct {
         }
 
         // TODO: consider throwing error instead of rerolling?
-        const overridden = if (options.calc.overridden(player, .metronome)) |val| val: {
+        const overridden = if (options.calc.overridden(player, 0, .metronome)) |val| val: {
             for (moves) |m| if (m.id == val) break :val null;
             break :val val;
         } else null;
@@ -3292,7 +3320,7 @@ pub const Rolls = struct {
     }
 
     fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
+        const duration: u3 = if (options.calc.overridden(player, 0, .duration)) |val|
             @intCast(val)
         else if (showdown)
             battle.rng.range(u3, 1, 7)
@@ -3304,12 +3332,12 @@ pub const Rolls = struct {
         };
 
         assert(duration >= 1 and duration <= 6);
-        options.chance.duration(.sleep, player, player.foe(), duration);
+        options.chance.duration(player, duration);
         return duration + 1;
     }
 
     fn confusionDuration(battle: anytype, player: Player, self: bool, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
+        const duration: u3 = if (options.calc.overridden(player, 0, .duration)) |val|
             @intCast(val)
         else if (showdown)
             // Pokémon Showdown incorrectly uses the same duration for self-confusion
@@ -3318,16 +3346,16 @@ pub const Rolls = struct {
             @intCast((battle.rng.next() & if (self) 1 else 3) + 2);
 
         assert(duration >= 2 and duration <= if (!showdown and self) 3 else 5);
-        options.chance.duration(.confusion, player, if (self) player else 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|
+        const duration: u3 = if (options.calc.overridden(player, 0, .duration)) |val|
             @intCast(val)
         else if (showdown)
             // Pokémon Showdown incorrectly inherits Generation III's Disable duration
-            battle.rng.range(u4, 2, 6)
+            battle.rng.range(u3, 2, 6)
         else duration: {
             while (true) {
                 const r = battle.rng.next() & 7;
@@ -3336,12 +3364,12 @@ pub const Rolls = struct {
         };
 
         assert(duration >= 2 and duration <= (if (showdown) 5 else 7));
-        options.chance.duration(.disable, player, 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|
+        const duration: u3 = if (options.calc.overridden(player, 0, .duration)) |val|
             @intCast(val)
         else if (showdown)
             battle.rng.range(u3, 2, 4)
@@ -3349,12 +3377,12 @@ pub const Rolls = struct {
             @intCast((battle.rng.next() & 1) + 2); // BUG: thrash is + 1 not +2
 
         assert(duration >= 2 and duration <= 3);
-        options.chance.duration(.attacking, player, player, duration);
+        options.chance.duration(player, duration);
         return duration;
     }
 
     fn bindingDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+        const duration: u3 = (if (options.calc.overridden(player, 0, .duration)) |val|
             @intCast(val)
         else if (showdown)
             // TODO: PS does range(3, 6) here which after subtracting 1 is actually 2-4 not 2-5!
@@ -3363,13 +3391,13 @@ pub const Rolls = struct {
             @intCast(battle.rng.next() & 3 + 2));
 
         assert(duration >= 2 and duration <= 5);
-        options.chance.duration(.binding, player, player.foe(), duration);
+        options.chance.duration(player, duration);
         return duration + 1;
     }
 
     // TODO: consider sharing implementation with bindingDuration
     fn encoreDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+        const duration: u3 = (if (options.calc.overridden(player, 0, .duration)) |val|
             @intCast(val)
         else if (showdown)
             battle.rng.range(u3, 2, 6)
@@ -3377,7 +3405,7 @@ pub const Rolls = struct {
             @intCast(battle.rng.next() & 3 + 2));
 
         assert(duration >= 2 and duration <= 5);
-        options.chance.duration(.encore, player, player.foe(), duration);
+        options.chance.duration(player, duration);
         return duration + 1;
     }
 };
@@ -3490,7 +3518,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
         .Move => {
             const side = battle.side(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,