@pkmn/engine 0.1.0-dev.b3f3e3a6 → 0.1.0-dev.b9015a94

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");
@@ -34,17 +33,12 @@ 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;
@@ -106,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
@@ -140,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;
 
@@ -256,7 +251,6 @@ 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);
@@ -403,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;
 
@@ -440,18 +436,9 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
     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) {
+        if (Status.duration(stored.status) == 0) {
             try log.curestatus(.{ ident, before, .Message });
             stored.status = 0; // clears EXT if present
             resetCant(volatiles);
@@ -481,12 +468,7 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
     }
 
     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;
@@ -496,13 +478,7 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
 
     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;
@@ -565,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();
@@ -663,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(
@@ -731,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);
@@ -997,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) {
@@ -1056,7 +1031,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 +1060,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 +1167,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 +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) {
@@ -1306,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 {
@@ -1325,14 +1315,7 @@ 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 });
 
             volatiles.Bide = false;
@@ -1478,8 +1461,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 +1582,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 +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 {
@@ -1888,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(
@@ -2185,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);
         }
     };
 
@@ -2397,17 +2427,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 +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| {
@@ -2563,7 +2613,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 +2684,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 +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));
     }
@@ -2743,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")) {
@@ -2766,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")) {
@@ -2794,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
@@ -2806,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)
@@ -2818,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)
@@ -2829,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);
@@ -2853,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)
@@ -2870,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)
@@ -2882,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)
@@ -2894,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)
@@ -2907,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)
@@ -2919,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)
@@ -2931,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))
@@ -2947,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);
@@ -2969,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);
@@ -2997,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)
@@ -3013,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);
@@ -3033,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| {
@@ -3067,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)
@@ -3089,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;
@@ -3126,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;
@@ -3170,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;
@@ -3196,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)]
@@ -3211,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)
@@ -3237,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;
@@ -3269,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)
@@ -3281,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
@@ -3295,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;
@@ -3313,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)
@@ -3326,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!
@@ -3340,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)
@@ -3354,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;
     }
 };
@@ -3467,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,