@pkmn/engine 0.1.0-dev.eaae4aa6 → 0.1.0-dev.f3aab252

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
@@ -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);
@@ -442,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);
@@ -483,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;
@@ -498,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;
@@ -665,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(
@@ -733,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);
@@ -1304,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 {
@@ -1323,13 +1315,7 @@ pub const Effects = struct {
 
             if (!volatiles.Bide) return;
 
-            // 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;
@@ -1596,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 {
@@ -1723,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 {
@@ -1885,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(
@@ -2393,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 {
@@ -2790,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
@@ -2802,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)
@@ -2814,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)
@@ -2825,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);
@@ -2849,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)
@@ -2866,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)
@@ -2878,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)
@@ -2890,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)
@@ -2903,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)
@@ -2915,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)
@@ -2927,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))
@@ -2943,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);
@@ -2965,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);
@@ -2993,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)
@@ -3009,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);
@@ -3029,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| {
@@ -3063,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)
@@ -3085,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;
@@ -3122,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;
@@ -3166,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;
@@ -3192,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)]
@@ -3207,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)
@@ -3233,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;
@@ -3265,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)
@@ -3277,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
@@ -3291,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;
@@ -3309,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)
@@ -3322,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!
@@ -3336,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)
@@ -3350,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;
     }
 };

package/src/lib/pkmn.zig

@@ -22,13 +22,16 @@ pub const Choice = @import("common/data.zig").Choice;
 /// considered terminal.
 pub const Result = @import("common/data.zig").Result;
 
+// TODO
+pub const Array = @import("common/array.zig").Array;
+// TODO
+pub const Optional = @import("common/optional.zig").Optional;
+
 /// Pokémon Showdown's RNG (backed by a Generation V & VI RNG).
 pub const PSRNG = @import("common/rng.zig").PSRNG;
 
 /// Namespace for helpers related to protocol message logging.
-pub const protocol = if (options.internal) struct {
-    pub usingnamespace @import("common/protocol.zig");
-} else struct {
+pub const protocol = if (options.internal) @import("common/protocol.zig") else struct {
     /// Logs protocol information to its `Writer` during a battle update when
     /// `options.log` is enabled.
     pub const Log = @import("common/protocol.zig").Log;
@@ -82,11 +85,7 @@ pub const gen1 = struct {
     /// via `overrides` and tracks `summaries` of information relevant to damage calculation.
     pub const Calc = @import("gen1/calc.zig").Calc;
     /// Namespace for types associated with supported Generation I Pokémon damage calc features.
-    pub const calc = if (options.internal) struct {
-        pub usingnamespace @import("gen1/calc.zig");
-    } else struct {
-        /// TODO
-        pub const Overrides = @import("gen1/calc.zig").Overrides;
+    pub const calc = if (options.internal) @import("gen1/calc.zig") else struct {
         /// Information relevant to damage calculation that occured during a Generation I
         /// battle `update`.
         pub const Summaries = @import("gen1/calc.zig").Summaries;
@@ -114,10 +113,7 @@ pub const gen2 = struct {
         pub const NULL = @import("gen2/chance.zig").NULL;
     };
     pub const Calc = @import("gen2/calc.zig").Calc;
-    pub const calc = if (options.internal) struct {
-        pub usingnamespace @import("gen2/calc.zig");
-    } else struct {
-        pub const Overrides = @import("gen2/calc.zig").Overrides;
+    pub const calc = if (options.internal) @import("gen2/calc.zig") else struct {
         pub const Summaries = @import("gen2/calc.zig").Summaries;
         pub const Summary = @import("gen2/calc.zig").Summary;
         pub const NULL = @import("gen2/calc.zig").NULL;
@@ -127,10 +123,8 @@ pub const gen2 = struct {
 
 // Internal APIs used by other pkmn libraries, not actually part of the public API.
 // NOTE: `pub usingnamespace struct { ... }` here results in a (false?) dependency loop
-pub const js = if (options.internal) struct {
-    pub usingnamespace @import("common/js.zig");
-} else struct {};
+pub const js = if (options.internal) @import("common/js.zig") else {};
 pub const bindings = if (options.internal) struct {
     pub const node = @import("node.zig");
     pub const wasm = @import("wasm.zig");
-} else struct {};
+} else {};