@pkmn/engine 0.1.0-dev.deda8593 → 0.1.0-dev.e0a786f8

package/src/lib/gen2/mechanics.zig

@@ -1,50 +1,37 @@
-const std = @import("std");
-
-const pkmn = @import("../pkmn.zig");
-
-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 builtin = @import("builtin");
+const common = @import("../common/data.zig");
 const data = @import("data.zig");
 const generated = @import("generated.zig");
-
-const assert = std.debug.assert;
-
-const expectEqual = std.testing.expectEqual;
-const expectEqualSlices = std.testing.expectEqualSlices;
-const expectEqualStrings = std.testing.expectEqualStrings;
-
-const showdown = pkmn.options.showdown;
-
-const Choice = common.Choice;
-const ID = common.ID;
-const Player = common.Player;
-const Result = common.Result;
+const pkmn = @import("../pkmn.zig");
+const protocol = @import("../common/protocol.zig");
+const rng = @import("../common/rng.zig");
+const std = @import("std");
 
 const Activate = protocol.Activate;
+const ActivePokemon = data.ActivePokemon;
+const assert = std.debug.assert;
 const Boost = protocol.Boost;
+const Boosts = data.Boosts;
+const Choice = common.Choice;
 const Damage = protocol.Damage;
+const Effectiveness = data.Effectiveness;
 const End = protocol.End;
+const expectEqual = std.testing.expectEqual;
+const expectEqualSlices = std.testing.expectEqualSlices;
+const expectEqualStrings = std.testing.expectEqualStrings;
 const Fail = protocol.Fail;
-const Heal = protocol.Heal;
-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 Heal = protocol.Heal;
+const ID = common.ID;
 const Item = data.Item;
 const Move = data.Move;
-const MoveSlot = data.MoveSlot;
-const Pokemon = data.Pokemon;
+const Player = common.Player;
+const Result = common.Result;
+const showdown = pkmn.options.showdown;
 const Side = data.Side;
-const Species = data.Species;
+const Start = protocol.Start;
 const Stats = data.Stats;
 const Status = data.Status;
 const TriAttack = data.TriAttack;
@@ -106,6 +93,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 +244,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 +429,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 +461,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 +471,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 +632,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 +700,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);
@@ -1226,7 +1193,7 @@ fn updateSideCondition(
 fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result {
     battle.turn += 1;
 
-    if (showdown and battle.turn >= 1000) {
+    if (pkmn.options.mod and battle.turn >= 1000) {
         try options.log.tie(.{});
         return Result.Tie;
     } else if (battle.turn >= 65535) {
@@ -1341,13 +1308,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;
@@ -1466,7 +1427,8 @@ pub const Effects = struct {
         if (move.type.special() != (last == .MirrorCoat)) return;
         if (state.damage == 0) return;
 
-        state.damage *|= 2;
+        // NOTE: llvm/llvm-project#58557
+        state.damage = smul(state.damage, 2);
         state.miss = false;
     }
 
@@ -1561,15 +1523,18 @@ pub const Effects = struct {
 
     pub const double = struct {
         pub fn flying(battle: anytype, player: Player, state: *State, _: anytype) !void {
-            if (battle.foe(player).active.volatiles.Flying) state.damage *|= 2;
+            if (!battle.foe(player).active.volatiles.Flying) return;
+            state.damage = smul(state.damage, 2);
         }
 
         pub fn underground(battle: anytype, player: Player, state: *State, _: anytype) !void {
-            if (battle.foe(player).active.volatiles.Underground) state.damage *|= 2;
+            if (!battle.foe(player).active.volatiles.Underground) return;
+            state.damage = smul(state.damage, 2);
         }
 
         pub fn minimize(battle: anytype, player: Player, state: *State, _: anytype) !void {
-            if (battle.foe(player).active.volatiles.minimized) state.damage *|= 2;
+            if (!battle.foe(player).active.volatiles.minimized) return;
+            state.damage = smul(state.damage, 2);
         }
     };
 
@@ -1738,7 +1703,7 @@ pub const Effects = struct {
         if (!state.proc) return;
         if (foe.conditions.Safeguard) return;
         // Freeze Clause Mod
-        if (showdown) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
+        if (pkmn.options.mod) 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, .None });
@@ -1767,7 +1732,7 @@ pub const Effects = struct {
             state.bp *= 2;
             assert(state.bp <= 160);
         } else {
-            state.damage *|= 2;
+            state.damage = smul(state.damage, 2);
         }
     }
 
@@ -2238,7 +2203,7 @@ pub const Effects = struct {
 
     pub fn pursuit(battle: anytype, player: Player, state: *State, _: anytype) !void {
         // TODO: remove switching variable and just look at Choice saved in Battle struct?
-        if (battle.foe(player).active.volatiles.switching) state.damage *|= 2;
+        if (battle.foe(player).active.volatiles.switching) state.damage = smul(state.damage, 2);
     }
 
     pub const rage = struct {
@@ -2251,7 +2216,7 @@ pub const Effects = struct {
             const side = battle.side(player);
 
             assert(side.active.volatiles.Rage);
-            state.damage *|= (side.active.volatiles.rage +| 1);
+            state.damage = smul(state.damage, (side.active.volatiles.rage +| 1)); // TODO: |+
         }
     };
 
@@ -2346,7 +2311,7 @@ pub const Effects = struct {
             side.active.volatiles.attacks += 1;
             side.active.volatiles.Rollout = side.active.volatiles.attacks != 5;
 
-            if (side.active.volatiles.DefenseCurl) state.damage *|= 2;
+            if (side.active.volatiles.DefenseCurl) state.damage = smul(state.damage, 2);
         }
     };
 
@@ -2416,7 +2381,7 @@ pub const Effects = struct {
         }
 
         // Sleep Clause Mod
-        if (showdown) {
+        if (pkmn.options.mod) {
             for (foe.pokemon) |p| {
                 if (Status.is(p.status, .SLP) and !Status.is(p.status, .EXT)) return;
             }
@@ -2874,9 +2839,15 @@ fn convertible(active: ActivePokemon, m: Move) bool {
     return t != .@"???" and !active.types.includes(t);
 }
 
+// NOTE: llvm/llvm-project#58557
+fn smul(a: anytype, b: @TypeOf(a)) @TypeOf(a) {
+    if (!comptime builtin.target.isWasm()) return a *| b;
+    return @max(a *% b, std.math.maxInt(@TypeOf(a)));
+}
+
 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
@@ -2888,7 +2859,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)
@@ -2900,7 +2871,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)
@@ -2911,20 +2882,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);
@@ -2935,12 +2908,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)
@@ -2952,7 +2925,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)
@@ -2964,7 +2937,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)
@@ -2976,7 +2949,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)
@@ -2989,7 +2962,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)
@@ -3001,7 +2974,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)
@@ -3013,7 +2986,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))
@@ -3029,7 +3002,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);
@@ -3051,7 +3024,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);
@@ -3079,7 +3052,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)
@@ -3097,7 +3070,7 @@ pub const Rolls = struct {
 
     fn spite(battle: anytype, player: Player, options: anytype) !u3 {
         assert(!showdown);
-        const pp: u3 = if (options.calc.overridden(player, .spite)) |val|
+        const pp: u3 = if (options.calc.overridden(player, 0, .spite)) |val|
             val + 1
         else
             @intCast((battle.rng.next() & 3) + 2);
@@ -3114,7 +3087,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| {
@@ -3148,7 +3121,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)
@@ -3170,7 +3143,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;
@@ -3207,7 +3180,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;
@@ -3251,7 +3224,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;
@@ -3277,7 +3250,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)]
@@ -3292,7 +3265,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)
@@ -3318,7 +3291,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;
@@ -3350,7 +3323,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)
@@ -3362,12 +3335,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
@@ -3376,16 +3349,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;
@@ -3394,12 +3367,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)
@@ -3407,12 +3380,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!
@@ -3421,13 +3394,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)
@@ -3435,7 +3408,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;
     }
 };