@pkmn/engine 0.1.0-dev.028ab165 → 0.1.0-dev.047d6e71

package/src/lib/gen2/chance.zig

@@ -14,7 +14,7 @@ const util = @import("../common/util.zig");
 const Player = @import("../common/data.zig").Player;
 const Optional = @import("../common/optional.zig").Optional;
 
-const data = @import("./data.zig");
+const data = @import("data.zig");
 
 const enabled = options.chance;
 const showdown = options.showdown;
@@ -699,7 +699,7 @@ test "Chance.damage" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     try chance.damage(.P1, 217);
-    try expectValue(@as(u8, 217), chance.actions.p1.damage);
+    try expectValue(217, chance.actions.p1.damage);
     try expectProbability(&chance.probability, 1, 39);
 }
 
@@ -824,7 +824,7 @@ test "Chance.present" {
     } else {
         try expectProbability(&chance.probability, 25, 256);
     }
-    try expectValue(@as(u3, 4), chance.actions.p2.present);
+    try expectValue(4, chance.actions.p2.present);
 
     chance.reset();
 
@@ -834,7 +834,7 @@ test "Chance.present" {
     } else {
         try expectProbability(&chance.probability, 51, 256);
     }
-    try expectValue(@as(u3, 1), chance.actions.p1.present);
+    try expectValue(1, chance.actions.p1.present);
 }
 
 test "Chance.magnitude" {
@@ -846,7 +846,7 @@ test "Chance.magnitude" {
     } else {
         try expectProbability(&chance.probability, 13, 256);
     }
-    try expectValue(@as(u3, 7), chance.actions.p2.magnitude);
+    try expectValue(7, chance.actions.p2.magnitude);
 
     chance.reset();
 
@@ -856,7 +856,7 @@ test "Chance.magnitude" {
     } else {
         try expectProbability(&chance.probability, 51, 256);
     }
-    try expectValue(@as(u3, 5), chance.actions.p1.magnitude);
+    try expectValue(5, chance.actions.p1.magnitude);
 }
 
 test "Chance.tripleKick" {
@@ -864,7 +864,7 @@ test "Chance.tripleKick" {
 
     try chance.tripleKick(.P1, 2);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(@as(u2, 2), chance.actions.p1.triple_kick);
+    try expectValue(2, chance.actions.p1.triple_kick);
 }
 
 test "Chance.spite" {
@@ -872,7 +872,7 @@ test "Chance.spite" {
 
     try chance.spite(.P1, 3);
     try expectProbability(&chance.probability, 1, 4);
-    try expectValue(@as(u3, 3), chance.actions.p1.spite);
+    try expectValue(3, chance.actions.p1.spite);
 }
 
 test "Chance.conversion2" {
@@ -899,7 +899,7 @@ test "Chance.psywave" {
 
     try chance.psywave(.P2, 100, 150);
     try expectProbability(&chance.probability, 1, 150);
-    try expectValue(@as(u8, 100), chance.actions.p2.psywave);
+    try expectValue(100, chance.actions.p2.psywave);
 }
 
 test "Chance.metronome" {
@@ -915,19 +915,19 @@ test "Chance.moveSlot" {
 
     try chance.moveSlot(.P2, 2, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(@as(u4, 2), chance.actions.p2.move_slot);
+    try expectValue(2, chance.actions.p2.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 1, 3);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(@as(u4, 1), chance.actions.p1.move_slot);
+    try expectValue(1, chance.actions.p1.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 4, 1);
     try expectProbability(&chance.probability, 1, 1);
-    try expectValue(@as(u4, 4), chance.actions.p1.move_slot);
+    try expectValue(4, chance.actions.p1.move_slot);
 }
 
 test "Chance.forceSwitch" {
@@ -935,19 +935,19 @@ test "Chance.forceSwitch" {
 
     try chance.forceSwitch(.P2, 2, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(@as(u4, 2), chance.actions.p2.force_switch);
+    try expectValue(2, chance.actions.p2.force_switch);
 
     chance.reset();
 
     try chance.forceSwitch(.P1, 1, 3);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(@as(u4, 1), chance.actions.p1.force_switch);
+    try expectValue(1, chance.actions.p1.force_switch);
 
     chance.reset();
 
     try chance.forceSwitch(.P1, 4, 1);
     try expectProbability(&chance.probability, 1, 1);
-    try expectValue(@as(u4, 4), chance.actions.p1.force_switch);
+    try expectValue(4, chance.actions.p1.force_switch);
 }
 
 test "Chance.multiHit" {
@@ -955,21 +955,21 @@ test "Chance.multiHit" {
 
     try chance.multiHit(.P1, 3);
     try expectProbability(&chance.probability, 3, 8);
-    try expectValue(@as(u4, 3), chance.actions.p1.multi_hit);
+    try expectValue(3, chance.actions.p1.multi_hit);
 
     chance.reset();
 
     try chance.multiHit(.P2, 5);
     try expectProbability(&chance.probability, 1, 8);
-    try expectValue(@as(u4, 5), chance.actions.p2.multi_hit);
+    try expectValue(5, chance.actions.p2.multi_hit);
 }
 
 test "Chance.duration" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     chance.duration(.sleep, .P1, .P2, 2);
-    try expectValue(@as(u4, 2), chance.actions.p1.duration);
-    try expectValue(@as(u3, 1), chance.actions.p2.durations.sleep);
+    try expectValue(2, chance.actions.p1.duration);
+    try expectValue(1, chance.actions.p2.durations.sleep);
 }
 
 test "Chance.sleep" {
@@ -979,7 +979,7 @@ test "Chance.sleep" {
         chance.actions.p1.durations.sleep = @intCast(i);
         try chance.sleep(.P1, 0);
         try expectProbability(&chance.probability, 1, d);
-        try expectValue(@as(u3, 0), chance.actions.p1.durations.sleep);
+        try expectValue(0, chance.actions.p1.durations.sleep);
 
         chance.reset();
 
@@ -1003,7 +1003,7 @@ test "Chance.confusion" {
             chance.actions.p2.durations.confusion = @intCast(i);
             try chance.confusion(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.confusion);
+            try expectValue(0, chance.actions.p2.durations.confusion);
             try expectValue(false, chance.actions.p2.durations.thrash);
 
             chance.reset();
@@ -1028,7 +1028,7 @@ test "Chance.confusion" {
             chance.actions.p2.durations.confusion = @intCast(i);
             try chance.confusion(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.confusion);
+            try expectValue(0, chance.actions.p2.durations.confusion);
             try expectValue(true, chance.actions.p2.durations.thrash);
 
             chance.reset();
@@ -1054,7 +1054,7 @@ test "Chance.disable" {
                 chance.actions.p2.durations.disable = @intCast(i);
                 try chance.disable(.P2, 0);
                 try expectProbability(&chance.probability, 1, d);
-                try expectValue(@as(u4, 0), chance.actions.p2.durations.disable);
+                try expectValue(0, chance.actions.p2.durations.disable);
 
                 chance.reset();
             }
@@ -1074,7 +1074,7 @@ test "Chance.disable" {
                 chance.actions.p2.durations.disable = @intCast(i);
                 try chance.disable(.P2, 0);
                 try expectProbability(&chance.probability, 1, d);
-                try expectValue(@as(u4, 0), chance.actions.p2.durations.disable);
+                try expectValue(0, chance.actions.p2.durations.disable);
 
                 chance.reset();
             }
@@ -1099,7 +1099,7 @@ test "Chance.attacking" {
             chance.actions.p2.durations.attacking = @intCast(i);
             try chance.attacking(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.attacking);
+            try expectValue(0, chance.actions.p2.durations.attacking);
 
             chance.reset();
         }
@@ -1123,7 +1123,7 @@ test "Chance.binding" {
             chance.actions.p2.durations.binding = @intCast(i);
             try chance.binding(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.binding);
+            try expectValue(0, chance.actions.p2.durations.binding);
 
             chance.reset();
         }
@@ -1147,7 +1147,7 @@ test "Chance.encore" {
             chance.actions.p2.durations.encore = @intCast(i);
             try chance.encore(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.encore);
+            try expectValue(0, chance.actions.p2.durations.encore);
 
             chance.reset();
         }

package/src/lib/gen2/data.zig

@@ -239,7 +239,7 @@ pub const DVs = packed struct(u16) {
         };
         const p: u6 = @intCast(1 + ((5 * @as(u8, (dvs.atk & 0b1000) | ((dvs.def & 0b1000)) >> 1 |
             ((dvs.spe & 0b1000)) >> 2 | ((dvs.spc & 0b1000)) >> 3) + (dvs.spc & 0b0011)) >> 1));
-        var t = @as(u8, dvs.def & 0b0011) + (@as(u8, dvs.atk & 0b0011) << 2);
+        const t = @as(u8, dvs.def & 0b0011) + (@as(u8, dvs.atk & 0b0011) << 2);
         return .{ .gender = g, .pow = p, .type = Type.hiddenPower(t) };
     }
 };
@@ -248,12 +248,12 @@ test DVs {
     var dvs = DVs.from(.Mewtwo, .{ .def = 13 });
     try expectEqual(Gender.Unknown, dvs.gender);
     try expectEqual(Type.Ice, dvs.type);
-    try expectEqual(@as(u8, 70), dvs.power());
+    try expectEqual(70, dvs.power());
 
     dvs = DVs.from(.Pikachu, .{ .spc = 14 });
     try expectEqual(Gender.Male, dvs.gender);
     try expectEqual(Type.Dark, dvs.type);
-    try expectEqual(@as(u8, 69), dvs.power());
+    try expectEqual(69, dvs.power());
 
     dvs = DVs.from(.Cyndaquil, .{ .atk = 1, .def = 3, .spe = 10, .spc = 9 });
     try expectEqual(Gender.Female, dvs.gender);
@@ -380,9 +380,9 @@ test Stats {
     try expectEqual(0, stats.def);
 
     var base = Species.get(.Gyarados).stats;
-    try expectEqual(@as(u16, 127), Stats(u16).calc("hp", base.hp, 0, 5120, 38));
+    try expectEqual(127, Stats(u16).calc("hp", base.hp, 0, 5120, 38));
     base = Species.get(.Pidgeot).stats;
-    try expectEqual(@as(u16, 279), Stats(u16).calc("spe", base.spe, 15, 63001, 100));
+    try expectEqual(279, Stats(u16).calc("spe", base.spe, 15, 63001, 100));
 }
 
 pub const Boosts = packed struct(u32) {
@@ -428,8 +428,8 @@ test Move {
     try expectEqual(Move.Effect.ConfusionChance, move.effect);
     try expectEqual(rng.Gen12.percent(50), move.accuracy);
     try expectEqual(rng.Gen12.percent(100), move.chance);
-    try expectEqual(@as(u8, 5), Move.pp(.DynamicPunch));
-    try expectEqual(@as(i8, -1), Move.get(.Counter).priority);
+    try expectEqual(5, Move.pp(.DynamicPunch));
+    try expectEqual(-1, Move.get(.Counter).priority);
     try expect(!move.effect.isHighCritical());
     try expect(Move.get(.KarateChop).effect.isHighCritical());
     try expect(Move.get(.RazorWind).effect.isHighCritical());
@@ -439,7 +439,7 @@ pub const Species = species.Species;
 
 test Species {
     try expectEqual(152, @intFromEnum(Species.Chikorita));
-    try expectEqual(@as(u8, 100), Species.get(.Celebi).stats.spd);
+    try expectEqual(100, Species.get(.Celebi).stats.spd);
 }
 
 pub const Type = types.Type;
@@ -452,7 +452,7 @@ test Types {
     try expect(!Type.Steel.special());
     try expect(Type.Dark.special());
 
-    try expectEqual(@as(u8, 3), Type.Water.precedence());
+    try expectEqual(3, Type.Water.precedence());
     try expect(Type.Bug.precedence() > Type.Poison.precedence());
 
     try expectEqual(Effectiveness.Super, Type.effectiveness(.Ghost, .Psychic));

package/src/lib/gen2/generated.zig

@@ -7,8 +7,6 @@ const common = @import("../common/data.zig");
 const data = @import("data.zig");
 const mechanics = @import("mechanics.zig");
 
-const assert = std.debug.assert;
-
 const Player = common.Player;
 const Result = common.Result;
 
@@ -42,7 +40,7 @@ pub fn runMove(battle: anytype, player: Player, state: *State, options: anytype)
     var log = options.log;
 
     var side = battle.side(player);
-    var volatiles = &side.active.volatiles;
+    const volatiles = &side.active.volatiles;
 
     const ident = battle.active(player);
     const foe_ident = battle.active(player.foe());

package/src/lib/gen2/mechanics.zig

@@ -140,11 +140,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;
 
@@ -403,7 +403,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;
 
@@ -565,7 +567,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();
@@ -997,7 +999,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) {
@@ -1056,7 +1057,6 @@ 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);
@@ -1086,7 +1086,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
 
     // 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
@@ -1193,7 +1193,6 @@ 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) {
@@ -1215,7 +1214,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) {
@@ -1306,14 +1304,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 {
@@ -1325,7 +1341,6 @@ 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 {
@@ -1478,8 +1493,8 @@ pub const Effects = struct {
             side.stored().hp -= @max(side.stored().stats.hp / 2, 1);
             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;
@@ -1599,8 +1614,16 @@ pub const Effects = struct {
         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 {
@@ -1726,8 +1749,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 {
@@ -1888,7 +1929,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(
@@ -2185,11 +2248,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);
         }
     };
 
@@ -2397,17 +2459,37 @@ pub const Effects = struct {
     }
 
     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), .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 {
@@ -2541,8 +2623,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| {
@@ -2563,7 +2645,7 @@ pub const Effects = struct {
 
         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);
@@ -2634,7 +2716,7 @@ pub const Effects = struct {
 
         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);
@@ -2718,9 +2800,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));
     }
@@ -2743,7 +2825,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")) {
@@ -2766,7 +2848,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")) {
@@ -3013,13 +3095,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, .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);
@@ -3467,7 +3548,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,