@pkmn/engine 0.1.0-dev.3de821b9 → 0.1.0-dev.3ed876db

package/src/lib/gen1/mechanics.zig

@@ -1,39 +1,28 @@
-const std = @import("std");
-
-const pkmn = @import("../pkmn.zig");
+const DEBUG = @import("../common/debug.zig").print;
 
+const chance = @import("chance.zig");
 const common = @import("../common/data.zig");
-const DEBUG = @import("../common/debug.zig").print;
-const optional = @import("../common/optional.zig");
+const data = @import("data.zig");
+const pkmn = @import("../pkmn.zig");
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
-
-const data = @import("data.zig");
-const chance = @import("chance.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
-const expectEqual = std.testing.expectEqual;
-
-const showdown = pkmn.options.showdown;
-
-const Choice = common.Choice;
-const ID = common.ID;
-const Player = common.Player;
-const Result = common.Result;
-
 const Boost = protocol.Boost;
+const Choice = common.Choice;
 const Damage = protocol.Damage;
+const Effectiveness = data.Effectiveness;
+const expectEqual = std.testing.expectEqual;
 const Fail = protocol.Fail;
-const Heal = protocol.Heal;
-
 const Gen12 = rng.Gen12;
-
-const ActivePokemon = data.ActivePokemon;
-const Effectiveness = data.Effectiveness;
+const Heal = protocol.Heal;
+const ID = common.ID;
 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 Stats = data.Stats;
@@ -176,7 +165,10 @@ fn selectMove(
             if (foe_choice.type == .Switch) {
                 const last = side.active.move(battle.lastMove(player).index);
                 if (last.id == .Metronome) side.last_selected_move = last.id;
-                if (last.id == .MirrorMove) return Result.Error;
+                if (last.id == .MirrorMove) {
+                    if (!pkmn.options.mod) return Result.Error;
+                    side.last_selected_move = last.id;
+                }
             }
         }
         return null;
@@ -427,7 +419,7 @@ fn executeMove(
         mslot = @intCast(battle.lastMove(player).index);
         const stored = side.stored();
         // GLITCH: Struggle bypass PP underflow via Hyper Beam / Trapping-switch auto selection
-        auto = isForced(&side.active) or
+        auto = pkmn.options.mod or isForced(&side.active) or
             side.active.volatiles.Binding or side.active.volatiles.Bide or
             side.last_selected_move == .HyperBeam or
             Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP);
@@ -460,6 +452,25 @@ fn executeMove(
         .err => return @as(?Result, Result.Error),
     }
 
+    // Pokémon Showdown incorrectly implements PP deduction when handling the Hyper Beam automatic
+    // selection glitch - if the move was proced due to Metronome / Mirror Move it either subtracts
+    // from the Hyper Beam slot if present or skips PP deduction entirely...
+    if (showdown and !skip_pp and side.last_selected_move == .HyperBeam and
+        side.last_selected_move != side.active.move(battle.lastMove(player).index).id)
+    {
+        assert(mslot == 1);
+        const has_beam = has_beam: {
+            for (side.active.moves, 0..) |m, i| {
+                if (m.id == .HyperBeam) {
+                    mslot = @intCast(i + 1);
+                    break :has_beam true;
+                }
+            }
+            break :has_beam false;
+        };
+        if (!has_beam) skip_pp = true;
+    }
+
     const can = skip_can or
         try canMove(battle, player, mslot, auto, skip_pp, .None, residual, options);
     if (!can) return null;
@@ -557,18 +568,17 @@ fn beforeMove(
     // This can only happen if a Pokémon started the battle frozen/sleeping and was thawed/woken
     // before the side had a selected a move - we simply need to assume this leads to a desync
     if (side.last_selected_move == .None) {
-        assert(!showdown);
+        assert(!pkmn.options.mod);
         return .err;
     }
 
     if (volatiles.Confusion) {
         assert(volatiles.confusion > 0);
         if (options.calc.overridden(player, .confusion)) |obs| switch (obs) {
-            .started => volatiles.confusion -= 1,
+            .started, .ended => volatiles.confusion = 0,
             .continuing => if (volatiles.confusion > 1) {
                 volatiles.confusion -= 1;
             },
-            .ended => volatiles.confusion = 0,
             .overwritten => {},
             else => unreachable,
         } else {
@@ -594,8 +604,7 @@ fn beforeMove(
                 volatiles.Binding = false;
                 volatiles.Invulnerable = false;
 
-                options.chance.observe(.bide, player, .None);
-                options.chance.observe(.thrashing, player, .None);
+                options.chance.observe(.attacking, player, .None);
                 options.chance.observe(.binding, player, .None);
                 {
                     // This feels (and is) disgusting but the cartridge literally just overwrites
@@ -636,8 +645,7 @@ fn beforeMove(
         volatiles.Charging = false;
         volatiles.Binding = false;
 
-        options.chance.observe(.bide, player, .None);
-        options.chance.observe(.thrashing, player, .None);
+        options.chance.observe(.attacking, player, .None);
         options.chance.observe(.binding, player, .None);
 
         // GLITCH: Invulnerable is not cleared, resulting in permanent Fly/Dig invulnerability
@@ -657,8 +665,8 @@ fn beforeMove(
             volatiles.state +%= battle.last_damage;
         }
 
-        volatiles.attacks = decrement(.bide, player, options, volatiles.attacks);
-        try options.chance.bide(player, if (volatiles.attacks == 0) .ended else .continuing);
+        volatiles.attacks = decrement(.attacking, player, options, volatiles.attacks);
+        try options.chance.attacking(player, if (volatiles.attacks == 0) .ended else .continuing);
 
         if (volatiles.attacks != 0) {
             try log.activate(.{ ident, .Bide });
@@ -694,8 +702,8 @@ fn beforeMove(
     if (volatiles.Thrashing) {
         try log.move(.{ ident, side.last_selected_move, battle.active(player.foe()) });
 
-        volatiles.attacks = decrement(.thrashing, player, options, volatiles.attacks);
-        try options.chance.thrashing(player, if (volatiles.attacks == 0) .ended else .continuing);
+        volatiles.attacks = decrement(.attacking, player, options, volatiles.attacks);
+        try options.chance.attacking(player, if (volatiles.attacks == 0) .ended else .continuing);
 
         if (volatiles.attacks == 0) {
             const overwritten = volatiles.Confusion;
@@ -709,7 +717,11 @@ fn beforeMove(
             // can be expected to recognize this pattern and pass the information only to the
             // correct player)
             try log.start(.{ battle.active(player), .ConfusionSilent });
-            options.chance.observe(.confusion, player, if (overwritten) .overwritten else .started);
+            options.chance.observe(.confusion, player, if (overwritten)
+                if (pkmn.options.overwrite) .overwritten else .continuing
+            else
+                .started);
+            if (!overwritten) options.calc.confusion(player);
         }
 
         // This shouldn't actually set last_used_move, but Pokémon Showdown sets last
@@ -775,9 +787,14 @@ fn canMove(
 
     if (move.effect == .Thrashing) {
         Effects.thrashing(battle, player, options);
-    } else if (!showdown and move.effect == .Binding) {
-        // Pokémon Showdown handles this after hit/miss checks and damage calculation
-        try Effects.binding(battle, player, false, options);
+    } else if (move.effect == .Binding) {
+        // Pokémon Showdown handles this after hit/miss checks and damage calculation, though clears
+        // Recharging in onTryMove (required for the Hyper Beam automatic selection glitch)
+        if (showdown) {
+            battle.foe(player).active.volatiles.Recharging = false;
+        } else {
+            try Effects.binding(battle, player, false, options);
+        }
     }
 
     return true;
@@ -823,7 +840,7 @@ fn incrementPP(side: *Side, player: Player, mslot: u4, options: anytype) void {
     if (showdown and volatiles.Transform) return;
 
     const n = options.calc.overridden(player, .pp) orelse 1;
-    if (volatiles.Transform and !options.chance.incrementPP(player, n)) return;
+    if (volatiles.Transform and !options.chance.pp(player, n)) return;
 
     assert(mslot > 0 and mslot <= 4);
     side.stored().moves[mslot - 1].pp = @as(u6, @intCast(side.stored().moves[mslot - 1].pp)) +% n;
@@ -880,7 +897,7 @@ fn doMove(
 
     var late = showdown and move.effect != .Explode;
     const skip = status or immune;
-    if ((!showdown or (!skip or counter)) and !miss) blk: {
+    if ((!showdown or (!skip or counter)) and !miss) damage: {
         if (showdown and move.effect.isMulti()) {
             try Effects.multiHit(battle, player, move, options);
             hits = side.active.volatiles.attacks;
@@ -902,7 +919,7 @@ fn doMove(
                 ohko = if (!showdown) side.active.stats.spe >= foe.active.stats.spe else true;
                 // This can overflow after adjustDamage, but will still be sufficient to OHKO
                 battle.last_damage = if (ohko) 65535 else 0;
-                if (showdown) break :blk; // skip adjustDamage / randomizeDamage
+                if (showdown) break :damage; // skip adjustDamage / randomizeDamage
             } else if (!calcDamage(battle, player, player.foe(), move, crit, options)) {
                 if (!showdown) try options.chance.commit(player, .err);
                 return @as(?Result, Result.Error);
@@ -1037,22 +1054,20 @@ fn doMove(
             try Effects.poison(battle, player, Move.get(.PoisonSting), options);
         }
         try log.hitcount(.{ battle.active(player.foe()), hit });
-    } else if (showdown) {
+    } else if (showdown and move.effect == .Binding) {
         // This should be handled much earlier but Pokémon Showdown does it here... ¯\_(ツ)_/¯
-        if (move.effect == .Binding) {
-            try Effects.binding(battle, player, rewrap, options);
-            if (immune) {
-                battle.last_damage = 0;
-                assert(foe.stored().hp > 0);
-                // Pokémon Showdown logs |-damage| here instead of |-immune| because logic...
-                if (sub) {
-                    try log.activate(.{ battle.active(player.foe()), .Substitute });
-                } else {
-                    try log.damage(.{ battle.active(player.foe()), foe.stored(), .None });
-                    try buildRage(battle, player.foe(), options);
-                }
-                return null;
+        try Effects.binding(battle, player, rewrap, options);
+        if (immune) {
+            battle.last_damage = 0;
+            assert(foe.stored().hp > 0);
+            // Pokémon Showdown logs |-damage| here instead of |-immune| because logic...
+            if (sub) {
+                try log.activate(.{ battle.active(player.foe()), .Substitute });
+            } else {
+                try log.damage(.{ battle.active(player.foe()), foe.stored(), .None });
+                try buildRage(battle, player.foe(), options);
             }
+            return null;
         }
     }
 
@@ -1133,7 +1148,7 @@ fn calcDamage(
     if ((!showdown or !cfz) and (atk > 255 or def > 255)) {
         atk = @max((atk / 4) & 255, 1);
         // GLITCH: not adjusted to be a min of 1 on cartridge (can lead to division-by-zero freeze)
-        def = @max((def / 4) & 255, if (showdown) 1 else 0);
+        def = @max((def / 4) & 255, if (pkmn.options.mod) 1 else 0);
     }
 
     const lvl: u32 = side.stored().level * @as(u2, if (crit) 2 else 1);
@@ -1154,7 +1169,7 @@ fn calcDamage(
     // encountered so we need to make sure that in the event of a miss we commit the status of the
     // crit roll. The alternative to doing this extra work is to *always* commit the crit roll but
     // that results in counter intuitive probabilities in the common case
-    if (pkmn.options.chance and !showdown) {
+    if (pkmn.options.chance and !pkmn.options.mod) {
         atk = attack(side, !crit, special);
         def = defense(target, !crit, special, false);
         if ((atk > 255 or def > 255) and (def / 4) & 255 == 0) options.chance.glitch();
@@ -1239,13 +1254,13 @@ fn specialDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
         .Psywave => power: {
             const max: u8 = @intCast(@as(u16, side.stored().level) * 3 / 2);
             // GLITCH: Psywave infinite glitch loop
-            if (!showdown and max <= 1) return Result.Error;
+            if (!pkmn.options.mod and max <= 1) return Result.Error;
             break :power try Rolls.psywave(battle, player, max, options);
         },
         else => unreachable,
     };
 
-    if (battle.last_damage == 0) return if (showdown) null else Result.Error;
+    if (battle.last_damage == 0) return if (pkmn.options.mod) null else Result.Error;
 
     const sub = showdown and foe.active.volatiles.Substitute;
     _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
@@ -1282,7 +1297,7 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
 
     if (!used or !selected) {
         // GLITCH: Counter desync (covered by Desync Clause Mod on Pokémon Showdown)
-        if (!showdown) return Result.Error;
+        if (!pkmn.options.mod) return Result.Error;
         try options.log.fail(.{ battle.active(player), .None });
         return null;
     }
@@ -1319,7 +1334,7 @@ fn applyDamage(
             subbed.active.volatiles.Substitute = false;
             // battle.last_damage is not updated with the amount of HP the Substitute had
             try options.log.end(.{ battle.active(sub_player), .Substitute });
-            options.calc.capped(sub_player);
+            if (reason != .Confusion) options.calc.capped(sub_player);
             return true;
         } else {
             // Safe to truncate since less than subbed.volatiles.substitute which is a u8
@@ -1529,7 +1544,7 @@ fn faint(battle: anytype, player: Player, done: bool, cap: bool, options: anytyp
     assert(!foe_volatiles.MultiHit);
     if (foe_volatiles.Bide) {
         assert(!foe_volatiles.Thrashing and !foe_volatiles.Rage);
-        foe_volatiles.state = if (showdown) 0 else foe_volatiles.state & 255;
+        foe_volatiles.state = if (pkmn.options.mod) 0 else foe_volatiles.state & 255;
         if (foe_volatiles.state != 0) return Result.Error;
     }
 
@@ -1620,12 +1635,12 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
 
     battle.turn += 1;
 
-    if (showdown and pkmn.options.ebc and checkEBC(battle)) {
+    if (pkmn.options.mod and pkmn.options.ebc and checkEBC(battle)) {
         try options.log.tie(.{});
         return Result.Tie;
     }
 
-    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) {
@@ -1805,7 +1820,7 @@ pub const Effects = struct {
 
         side.active.volatiles.state = 0;
         side.active.volatiles.attacks = Rolls.attackingDuration(battle, player, options);
-        options.chance.observe(.bide, player, .started);
+        options.chance.observe(.attacking, player, .started);
 
         try options.log.start(.{ battle.active(player), .Bide });
     }
@@ -1874,6 +1889,7 @@ pub const Effects = struct {
 
         foe.active.volatiles.confusion = Rolls.confusionDuration(battle, player, options);
         options.chance.observe(.confusion, player.foe(), .started);
+        options.calc.confusion(player.foe());
 
         try options.log.start(.{ battle.active(player.foe()), .Confusion });
     }
@@ -1919,12 +1935,11 @@ pub const Effects = struct {
 
         // Technically this is still considered simply a "miss" on the cartridge,
         // but diverging from Pokémon Showdown here would mostly just be pedantic
-        if (n == 0) {
+        if (n == 0 or (pkmn.options.mod and err)) {
             try options.log.fail(.{ foe_ident, .None });
             return null;
         } else if (err) {
             // GLITCH: Transform + Mirror Move / Metronome PP softlock
-            assert(!showdown);
             return Result.Error;
         }
 
@@ -2002,7 +2017,7 @@ pub const Effects = struct {
         if (foe.active.types.includes(move.type)) return;
         if (!try Rolls.secondaryChance(battle, player, true, options)) 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);
         // GLITCH: Hyper Beam recharging status is not cleared
@@ -2343,7 +2358,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;
             }
@@ -2410,7 +2425,7 @@ pub const Effects = struct {
         volatiles.Thrashing = true;
         volatiles.attacks = Rolls.attackingDuration(battle, player, options);
 
-        options.chance.observe(.thrashing, player, .started);
+        options.chance.observe(.attacking, player, .started);
     }
 
     fn transform(battle: anytype, player: Player, options: anytype) !void {
@@ -2449,7 +2464,7 @@ pub const Effects = struct {
         if (side.active.volatiles.Binding) return;
         side.active.volatiles.Binding = true;
         // GLITCH: Hyper Beam automatic selection glitch if Recharging gets cleared on miss
-        // (Pokémon Showdown unitentionally patches this glitch, preventing automatic selection)
+        // (Pokémon Showdown clears Recharging in onTryMove instead)
         if (!showdown) {
             foe.active.volatiles.Recharging = false;
         } else if (foe.stored().hp == 0) return if (!rewrap) battle.rng.advance(1);
@@ -2946,9 +2961,10 @@ pub const Rolls = struct {
     }
 
     fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "sleepDuration"))
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 1 and val <= 7) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "sleepDuration"))
             battle.rng.sleepDuration(player)
         else if (showdown)
             battle.rng.range(u3, 1, 8)
@@ -2965,9 +2981,10 @@ pub const Rolls = struct {
     }
 
     fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
-        const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
-            val
-        else if (@hasDecl(@TypeOf(battle.rng), "disableDuration"))
+        const duration: u4 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 1 and val <= 8) val else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "disableDuration"))
             battle.rng.disableDuration(player)
         else if (showdown)
             battle.rng.range(u4, 1, 9)
@@ -2980,9 +2997,10 @@ pub const Rolls = struct {
     }
 
     fn confusionDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "confusionDuration"))
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 2 and val <= 5) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "confusionDuration"))
             battle.rng.confusionDuration(player)
         else if (showdown)
             battle.rng.range(u3, 2, 6)
@@ -2995,9 +3013,10 @@ pub const Rolls = struct {
     }
 
     fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "attackingDuration"))
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            if (val >= 2 and val <= 3) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "attackingDuration"))
             battle.rng.attackingDuration(player)
         else if (showdown)
             battle.rng.range(u3, 2, 4)
@@ -3018,9 +3037,10 @@ pub const Rolls = struct {
         options: anytype,
     ) !u3 {
         const roll = if (effect == .Binding) .duration else .multi_hit;
-        const n: u3 = if (options.calc.overridden(player, roll)) |val|
-            @intCast(val)
-        else if (@hasDecl(@TypeOf(battle.rng), "distribution"))
+        const n: u3 = (if (options.calc.overridden(player, roll)) |val|
+            if (val >= 2 and val <= 5) @as(u3, @intCast(val)) else null
+        else
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "distribution"))
             battle.rng.distribution(player)
         else if (showdown)
             DISTRIBUTION[battle.rng.range(u3, 0, DISTRIBUTION.len)]
@@ -3046,15 +3066,13 @@ pub const Rolls = struct {
         options: anytype,
     ) !u4 {
         // TODO: consider throwing error instead of rerolling?
-        const overridden = if (options.calc.overridden(player, .move_slot)) |val|
+        const slot: u4 = (if (options.calc.overridden(player, .move_slot)) |val|
             if (moves[val - 1].id != .None and (check_pp == 0 or moves[val - 1].pp > 0))
                 val
             else
                 null
         else
-            null;
-
-        const slot: u4 = overridden orelse if (@hasDecl(@TypeOf(battle.rng), "moveSlot"))
+            null) orelse if (@hasDecl(@TypeOf(battle.rng), "moveSlot"))
             battle.rng.moveSlot(player, moves, check_pp)
         else slot: {
             if (showdown) {
@@ -3212,7 +3230,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             // Struggle (Pokémon Showdown would use 'move 1' here)
             if (n == before) {
                 // GLITCH: Transform + Mirror Move / Metronome PP softlock
-                if (!showdown) {
+                if (!pkmn.options.mod) {
                     while (slot <= 4) : (slot += 1) {
                         if (active.moves[slot - 1].pp != 0) return n;
                     }

package/src/lib/gen2/calc.zig

@@ -1,22 +1,22 @@
-const std = @import("std");
-
-const pkmn = @import("../pkmn.zig");
-
+const chance = @import("chance.zig");
 const common = @import("../common/data.zig");
+const Optional = @import("../common/optional.zig").Optional;
+const pkmn = @import("../pkmn.zig");
+const std = @import("std");
 const util = @import("../common/util.zig");
 
-const chance = @import("chance.zig");
-
+const Action = chance.Action;
+const Actions = chance.Actions;
 const assert = std.debug.assert;
-
+const Criticals = chance.Criticals;
+const Damages = chance.Damages;
 const enabled = pkmn.options.calc;
-
+const isPointerTo = util.isPointerTo;
 const Player = common.Player;
-
 const PointerType = util.PointerType;
 
-const Actions = chance.Actions;
-const Action = chance.Action;
+const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
+const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
 
 /// Information relevant to damage calculation that occured during a Generation II battle `update`.
 pub const Summaries = extern struct {
@@ -31,7 +31,7 @@ pub const Summaries = extern struct {
 
     /// Returns the `Summary` for the given `player`.
     pub fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Summary) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Summaries);
+        assert(isPointerTo(self, Summaries));
         return if (player == .P1) &self.p1 else &self.p2;
     }
 };
@@ -65,33 +65,34 @@ pub const Summary = extern struct {
     }
 };
 
-/// TODO
-pub const Overrides = extern struct {
-    /// TODO
-    actions: Actions = .{},
-};
-
 /// Allows for forcing the value of specific RNG events during a Generation II battle `update` via
 /// `overrides` and tracks `summaries` of information relevant to damage calculation.
 pub const Calc = struct {
     /// Overrides the normal behavior of the RNG during an `update` to force specific outcomes.
-    overrides: Overrides = .{},
+    overrides: Actions = .{},
     /// Information relevant to damage calculation.
     summaries: Summaries = .{},
 
     pub fn overridden(
         self: Calc,
         player: Player,
+        hit: u3,
         comptime field: Action.Field,
-    ) ?std.meta.FieldType(Action, field) {
+    ) ReturnType(field) {
         if (!enabled) return null;
 
-        const overrides =
-            if (player == .P1) self.overrides.actions.p1 else self.overrides.actions.p2;
-        const val = @field(overrides, @tagName(field));
+        const val = switch (field) {
+            .damages => Damages.get(self.overrides.get(player).damages, hit),
+            .critical_hits => Criticals.get(self.overrides.get(player).critical_hits, hit),
+            else => val: {
+                assert(hit == 0);
+                break :val @field(self.overrides.get(player), @tagName(field));
+            },
+        };
+
         return if (switch (@typeInfo(@TypeOf(val))) {
-            .Enum => val != .None,
-            .Int => val != 0,
+            Enum => val != .None,
+            Int => val != 0,
             else => unreachable,
         }) val else null;
     }
@@ -123,9 +124,10 @@ const Null = struct {
     pub fn overridden(
         self: Null,
         player: Player,
+        hit: u3,
         comptime field: Action.Field,
-    ) ?std.meta.FieldType(Action, field) {
-        _ = .{ self, player };
+    ) ReturnType(field) {
+        _ = .{ self, player, hit };
         return null;
     }
 
@@ -141,3 +143,11 @@ const Null = struct {
         _ = .{ self, player };
     }
 };
+
+fn ReturnType(comptime field: Action.Field) type {
+    return ?(switch (field) {
+        .damages => u8,
+        .critical_hits => Optional(bool),
+        else => std.meta.FieldType(Action, field),
+    });
+}