@pkmn/engine 0.1.0-dev.5570b5c5 → 0.1.0-dev.587596a6

package/src/lib/gen2/chance.zig

@@ -8,9 +8,9 @@ const expectEqual = std.testing.expectEqual;
 
 const options = @import("../common/options.zig");
 const rational = @import("../common/rational.zig");
-const rng = @import("../common/rng.zig");
 const util = @import("../common/util.zig");
 
+const Array = @import("../common/array.zig").Array;
 const Player = @import("../common/data.zig").Player;
 const Optional = @import("../common/optional.zig").Optional;
 
@@ -19,7 +19,8 @@ const data = @import("data.zig");
 const enabled = options.chance;
 const showdown = options.showdown;
 
-const Gen12 = rng.Gen12;
+const PointerType = util.PointerType;
+const isPointerTo = util.isPointerTo;
 
 const Move = data.Move;
 const Type = data.Type;
@@ -37,17 +38,11 @@ pub const Actions = extern struct {
     p2: Action = .{},
 
     /// Returns the `Action` for the given `player`.
-    pub fn get(self: anytype, player: Player) util.PointerType(@TypeOf(self), Action) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Actions);
+    pub fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Action) {
+        assert(isPointerTo(self, Actions));
         return if (player == .P1) &self.p1 else &self.p2;
     }
 
-    /// Perform a reset by clearing fields which should not persist across updates.
-    pub fn reset(self: *Actions) void {
-        self.p1.reset();
-        self.p2.reset();
-    }
-
     /// Returns true if `a` is equal to `b`.
     pub fn eql(a: Actions, b: Actions) bool {
         return @as(u128, @bitCast(a.p1)) == @as(u128, @bitCast(b.p1)) and
@@ -58,24 +53,15 @@ pub const Actions = extern struct {
     /// same shape if they have the same fields set (though those fields need not necessarily be
     /// set to the same value).
     pub fn matches(a: Actions, b: Actions) bool {
-        inline for (@typeInfo(Actions).Struct.fields) |player| {
-            inline for (@typeInfo(Action).Struct.fields) |field| {
+        inline for (@typeInfo(Actions).@"struct".fields) |player| {
+            inline for (@typeInfo(Action).@"struct".fields) |field| {
                 const a_val = @field(@field(a, player.name), field.name);
                 const b_val = @field(@field(b, player.name), field.name);
 
                 switch (@typeInfo(@TypeOf(a_val))) {
-                    .Struct => inline for (@typeInfo(@TypeOf(a_val)).Struct.fields) |f| {
-                        const a_val_f = @field(a_val, f.name);
-                        const b_val_f = @field(b_val, f.name);
-                        switch (@typeInfo(@TypeOf(a_val_f))) {
-                            .Int => if ((a_val_f > 0) != (b_val_f > 0)) return false,
-                            .Bool => if (a_val_f != b_val_f) return false,
-                            else => unreachable,
-                        }
-                    },
-                    .Enum => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
+                    .@"enum" => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
                         return false,
-                    .Int => if ((a_val > 0) != (b_val > 0)) return false,
+                    .int => if ((a_val > 0) != (b_val > 0)) return false,
                     else => unreachable,
                 }
             }
@@ -83,7 +69,7 @@ pub const Actions = extern struct {
         return true;
     }
 
-    pub fn fmt(self: Actions, writer: anytype, shape: bool) !void {
+    pub fn fmt(self: Actions, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeAll("<P1 = ");
         try self.p1.fmt(writer, shape);
         try writer.writeAll(", P2 = ");
@@ -91,23 +77,15 @@ pub const Actions = extern struct {
         try writer.writeAll(">");
     }
 
-    pub fn format(a: Actions, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
-        _ = .{ f, o };
+    pub fn format(a: Actions, w: *std.Io.Writer) !void {
         try fmt(a, w, false);
     }
 };
 
-// TODO: ziglang/zig#19730
 test Actions {
-    const a: Actions = .{ .p1 = .{ .hit = .true, .critical_hit = .false, .damage = 245 } };
-    const b: Actions = .{ .p1 = .{ .hit = .false, .critical_hit = .true, .damage = 246 } };
+    const a: Actions = .{ .p1 = .{ .hit = .true, .confused = .false, .damages = 245 } };
+    const b: Actions = .{ .p1 = .{ .hit = .false, .confused = .true, .damages = 246 } };
     const c: Actions = .{ .p1 = .{ .hit = .true } };
-    // const d: Actions = .{ .p2 = .{ .hit = .true, .durations = .{ .sleep = 2 } } };
-    // const e: Actions = .{ .p2 = .{ .hit = .false, .durations = .{ .sleep = 4 } } };
-    // const f: Actions = .{ .p1 = .{ .hit = .false, .durations = .{ .sleep = 4 } } };
-    // const g: Actions = .{ .p1 = .{ .hit = .false, .durations = .{ .confusion = 1 } } };
-    // const h: Actions =
-    //     .{ .p1 = .{ .hit = .false, .durations = .{ .confusion = 1, .thrash = true } } };
 
     try expect(a.eql(a));
     try expect(!a.eql(b));
@@ -120,17 +98,21 @@ test Actions {
     try expect(b.matches(a));
     try expect(!a.matches(c));
     try expect(!c.matches(a));
-    // try expect(d.matches(e));
-    // try expect(!d.matches(f));
-    // try expect(!g.matches(h));
-    // try expect(h.matches(h));
 }
 
+/// Observation made about a duration - whether the duration has started, been continued, or ended.
+pub const Observation = enum { started, continuing, ended };
+
+pub const Damages = Array(5, u8);
+pub const Criticals = Array(5, Optional(bool));
+
 /// Information about the RNG that was observed during a Generation II battle `update` for a
 /// single player.
 pub const Action = packed struct(u128) {
-    /// If not 0, the roll to be returned Rolls.damage.
-    damage: u8 = 0,
+    /// TODO
+    damages: Damages.T = 0,
+    // TODO
+    critical_hits: Criticals.T = 0,
 
     /// If not None, the Player to be returned by Rolls.speedTie.
     speed_tie: Optional(Player) = .None,
@@ -138,50 +120,58 @@ pub const Action = packed struct(u128) {
     quick_claw: Optional(bool) = .None,
     /// If not None, the value to return for Rolls.hit.
     hit: Optional(bool) = .None,
-    /// If not None, the value to be returned by Rolls.criticalHit.
-    critical_hit: Optional(bool) = .None,
-
     /// If not None, the value to return for Rolls.confused.
     confused: Optional(bool) = .None,
+
     /// If not None, the value to return for Rolls.attract.
     attract: Optional(bool) = .None,
     /// If not None, the value to return for Rolls.paralyzed.
     paralyzed: Optional(bool) = .None,
     /// If not None, the value to return for Rolls.defrost.
     defrost: Optional(bool) = .None,
-
     /// If not None, the value to be returned for Rolls.secondaryChance.
     secondary_chance: Optional(bool) = .None,
+
     /// If not None, the value to be returned for Rolls.item (Focus Band / King's Rock).
     item: Optional(bool) = .None,
     /// If not None, the value to be returned for Rolls.protect.
     protect: Optional(bool) = .None,
     /// If not None, the value to return for Rolls.triAttack.
     tri_attack: Optional(TriAttack) = .None,
+    /// If not 0, the value to return for Rolls.tripleKick.
+    triple_kick: u2 = 0,
 
     /// If not 0, (present - 1) * 40 should be returned as the base power for Rolls.present.
     present: u3 = 0,
     /// If not 0, magnitude + 3 should be returned as the number for Rolls.magnitude.
     magnitude: u3 = 0,
-    /// If not 0, the value to return for Rolls.tripleKick.
-    triple_kick: u2 = 0,
-
-    /// If not 0,  the amount of PP to deduct for Rolls.spite.
+    /// If not 0, the amount of PP to deduct for Rolls.spite.
     spite: u3 = 0,
-    /// If not None, the value to return for Rolls.conversion2.
-    conversion_2: Optional(Type) = .None,
-
     /// If not 0, the move slot (1-4) to return in Rolls.moveSlot. If present as an override,
     /// invalid values (eg. due to empty move slots or 0 PP) will be ignored.
-    move_slot: u4 = 0,
+    move_slot: u3 = 0,
     /// If not 0, the party slot (1-6) to return in Rolls.forceSwitch. If present as an override,
     /// invalid values (eg. due to empty party slots or fainted members) will be ignored.
-    force_switch: u4 = 0,
-
+    force_switch: u3 = 0,
     /// If not 0, the value (2-5) to return for Rolls.distribution for multi hit.
-    multi_hit: u4 = 0,
+    multi_hit: u3 = 0,
+
+    sleep: Optional(Observation) = .None,
+    /// TODO
+    confusion: Optional(Observation) = .None,
+    /// TODO
+    disable: Optional(Observation) = .None,
+    /// TODO
+    attacking: Optional(Observation) = .None,
+    /// TODO
+    binding: Optional(Observation) = .None,
+    /// TODO
+    encore: Optional(Observation) = .None,
+
     /// If not 0, the value to by one of the Rolls.*Duration rolls.
-    duration: u4 = 0,
+    duration: u3 = 0,
+    /// If not None, the value to return for Rolls.conversion2.
+    conversion_2: Optional(Type) = .None,
 
     /// If not 0, psywave should be returned as the damage roll for Rolls.psywave.
     psywave: u8 = 0,
@@ -189,44 +179,19 @@ pub const Action = packed struct(u128) {
     /// If not None, the Move to return for Rolls.metronome.
     metronome: Move = .None,
 
-    _: u16 = 0,
-
-    /// Observed values of various durations. Does not influence future RNG calls. TODO
-    durations: Duration = .{},
-
-    pub const DURATIONS: u128 = 0xFFFFFFFF00000000_0000000000000000;
-
     pub const Field = std.meta.FieldEnum(Action);
 
-    /// Perform a reset by clearing fields which should not persist across updates.
-    pub fn reset(self: *Action) void {
-        self.* = @bitCast(@as(u128, @bitCast(self.*)) & DURATIONS);
-    }
-
-    pub fn format(a: Action, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
-        _ = .{ f, o };
+    pub fn format(a: Action, w: *std.Io.Writer) !void {
         try fmt(a, w, false);
     }
 
-    pub fn fmt(self: Action, writer: anytype, shape: bool) !void {
+    pub fn fmt(self: Action, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeByte('(');
         var printed = false;
-        inline for (@typeInfo(Action).Struct.fields) |field| {
+        inline for (@typeInfo(Action).@"struct".fields) |field| {
             const val = @field(self, field.name);
             switch (@typeInfo(@TypeOf(val))) {
-                .Struct => inline for (@typeInfo(@TypeOf(val)).Struct.fields) |f| {
-                    const v = @field(val, f.name);
-                    if (v != 0) {
-                        if (printed) try writer.writeAll(", ");
-                        if (shape) {
-                            try writer.print("{s}:?", .{f.name});
-                        } else {
-                            try writer.print("{s}:{d}", .{ f.name, v });
-                        }
-                        printed = true;
-                    }
-                },
-                .Enum => if (val != .None) {
+                .@"enum" => if (val != .None) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -240,7 +205,7 @@ pub const Action = packed struct(u128) {
                     }
                     printed = true;
                 },
-                .Int => if (val != 0) {
+                .int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -256,36 +221,6 @@ pub const Action = packed struct(u128) {
     }
 };
 
-test Action {
-    var a: Action = .{ .hit = .true, .durations = .{ .sleep = 3 }, .damage = 225 };
-    a.reset();
-
-    try expectEqual(Action{ .hit = .None, .durations = .{ .sleep = 3 }, .damage = 0 }, a);
-}
-
-/// Observed values for various durations that need to be tracked in order to properly
-/// deduplicate transitions with a primary key. TODO
-pub const Duration = packed struct(u32) {
-    /// The number of turns a Pokémon has been observed to be sleeping.
-    sleep: u3 = 0,
-    /// The number of turns a Pokémon has been observed to be confused.
-    confusion: u3 = 0,
-    /// TODO
-    thrash: bool = false,
-    /// The number of turns a Pokémon has been observed to be disabled.
-    disable: u4 = 0,
-    /// The number of turns a Pokémon has been observed to be attacking.
-    attacking: u3 = 0,
-    /// The number of turns a Pokémon has been observed to be binding their opponent.
-    binding: u3 = 0,
-    /// The number of turns a Pokémon has been observed to be encored.
-    encore: u3 = 0,
-
-    _: u12 = 0,
-
-    pub const Field = std.meta.FieldEnum(Duration);
-};
-
 /// Tracks chance actions and their associated probability during a Generation II battle update when
 /// `options.chance` is enabled.
 pub fn Chance(comptime Rational: type) type {
@@ -298,37 +233,15 @@ pub fn Chance(comptime Rational: type) type {
         /// RNG events were observed during a battle `update`.
         actions: Actions = .{},
 
-        // Tracks the observed sleep durations for the Pokémon in both player's parties. Unlike
-        // other durations which are all tied to volatiles, sleep's counter persists through
-        // switching and so we must store it here. The indices of these arrays correspond to the
-        // `order` field of a Side. This information could be stored in actions but size is a
-        // concern so this is tracked separately as actions only purports to track RNG events
-        // observed during a single `update` (not across updates).
-        sleeps: [2][6]u3 = .{ .{0} ** 6, .{0} ** 6 },
-
         /// Possible error returned by operations tracking chance probability.
         pub const Error = Rational.Error;
 
         /// Convenience helper to clear fields which typically should be cleared between updates.
         pub fn reset(self: *Self) void {
-            self.probability.reset();
-            self.actions.reset();
-            // TODO: self.pending = .{};
-        }
-
-        pub fn switched(self: *Self, player: Player, in: u8, out: u8) void {
             if (!enabled) return;
 
-            assert(in >= 1 and in <= 6);
-            assert(out >= 1 and out <= 6);
-
-            var action = self.actions.get(player);
-
-            const slp = action.durations.sleep;
-            action.durations = .{};
-
-            self.sleeps[@intFromEnum(player)][out - 1] = slp;
-            action.durations.sleep = @intCast(self.sleeps[@intFromEnum(player)][in - 1]);
+            self.probability.reset();
+            self.actions = .{};
         }
 
         pub fn speedTie(self: *Self, p1: bool) Error!void {
@@ -354,19 +267,21 @@ pub fn Chance(comptime Rational: type) type {
             self.actions.get(player).hit = if (ok) .true else .false;
         }
 
-        pub fn criticalHit(self: *Self, player: Player, crit: bool, rate: u8) Error!void {
+        pub fn criticalHit(self: *Self, player: Player, i: u3, crit: bool, rate: u8) Error!void {
             if (!enabled) return;
 
             const n = if (crit) rate else @as(u8, @intCast(256 - @as(u9, rate)));
             try self.probability.update(n, 256);
-            self.actions.get(player).critical_hit = if (crit) .true else .false;
+            var a = self.actions.get(player);
+            a.critical_hits = Criticals.set(a.critical_hits, i, if (crit) .true else .false);
         }
 
-        pub fn damage(self: *Self, player: Player, roll: u8) Error!void {
+        pub fn damage(self: *Self, player: Player, i: u3, roll: u8) Error!void {
             if (!enabled) return;
 
             try self.probability.update(1, 39);
-            self.actions.get(player).damage = roll;
+            var a = self.actions.get(player);
+            a.damages = Damages.set(a.damages, i, roll);
         }
 
         pub fn confused(self: *Self, player: Player, cfz: bool) Error!void {
@@ -518,122 +433,10 @@ pub fn Chance(comptime Rational: type) type {
             self.actions.get(player).multi_hit = n;
         }
 
-        pub fn duration(
-            self: *Self,
-            comptime field: Duration.Field,
-            player: Player,
-            target: Player,
-            turns: u4,
-        ) void {
-            if (!enabled) return;
-
-            var durations = &self.actions.get(target).durations;
-            assert(@field(durations, @tagName(field)) == 0 or
-                (field == .confusion and player == target));
-            @field(durations, @tagName(field)) = 1;
-            if (field == .confusion) durations.thrash = player == target;
-            self.actions.get(player).duration = if (options.key) 1 else turns;
-        }
-
-        pub fn sleep(self: *Self, player: Player, turns: u4) Error!void {
-            if (!enabled) return;
-
-            var durations = &self.actions.get(player).durations;
-            const n = durations.sleep;
-            if (turns == 0) {
-                assert(n >= 1 and n <= 6);
-                if (n != 6) try self.probability.update(1, 7 - @as(u4, n));
-                durations.sleep = 0;
-            } else {
-                assert(n >= 1 and n < 6);
-                try self.probability.update(7 - @as(u4, n) - 1, 7 - @as(u4, n));
-                durations.sleep += 1;
-            }
-        }
-
-        pub fn confusion(self: *Self, player: Player, turns: u4) Error!void {
-            if (!enabled) return;
-
-            var durations = &self.actions.get(player).durations;
-            const n = durations.confusion;
-            const hi: u8 = if (durations.thrash) 3 else 5;
-            const p = hi + 1;
-            if (turns == 0) {
-                assert(n >= 2 and n <= hi);
-                if (n != hi) try self.probability.update(1, p - @as(u4, n));
-                durations.confusion = 0;
-            } else {
-                assert(n >= 1 and n < hi);
-                if (n > 1) try self.probability.update(p - @as(u4, n) - 1, p - @as(u4, n));
-                durations.confusion += 1;
-            }
-        }
-
-        pub fn disable(self: *Self, player: Player, turns: u4) Error!void {
-            if (!enabled) return;
-
-            var durations = &self.actions.get(player).durations;
-            const n = durations.disable;
-            const hi = if (showdown) 5 else 8;
-            const p = hi + 1;
-            if (turns == 0) {
-                assert(n >= 2 and n <= hi);
-                if (n != hi) try self.probability.update(1, p - n);
-                durations.disable = 0;
-            } else {
-                assert(n >= 1 and n < hi);
-                if (n > 1) try self.probability.update(p - n - 1, p - n);
-                durations.disable += 1;
-            }
-        }
-
-        pub fn attacking(self: *Self, player: Player, turns: u4) Error!void {
+        pub fn duration(self: *Self, player: Player, turns: u3) void {
             if (!enabled) return;
 
-            var durations = &self.actions.get(player).durations;
-            const n = durations.attacking;
-            if (turns == 0) {
-                assert(n >= 2 and n <= 3);
-                if (n != 3) try self.probability.update(1, 4 - @as(u4, n));
-                durations.attacking = 0;
-            } else {
-                assert(n >= 1 and n < 3);
-                if (n > 1) try self.probability.update(4 - @as(u4, n) - 1, 4 - @as(u4, n));
-                durations.attacking += 1;
-            }
-        }
-
-        pub fn binding(self: *Self, player: Player, turns: u4) Error!void {
-            if (!enabled) return;
-
-            var durations = &self.actions.get(player).durations;
-            const n = durations.binding;
-            if (turns == 0) {
-                assert(n >= 2 and n <= 5);
-                if (n != 5) try self.probability.update(1, 6 - @as(u4, n));
-                durations.binding = 0;
-            } else {
-                assert(n >= 1 and n < 5);
-                if (n > 1) try self.probability.update(6 - @as(u4, n) - 1, 6 - @as(u4, n));
-                durations.binding += 1;
-            }
-        }
-
-        // TODO: consider sharing implementation with binding
-        pub fn encore(self: *Self, player: Player, turns: u4) Error!void {
-            if (!enabled) return;
-
-            var durations = &self.actions.get(player).durations;
-            const n = durations.encore;
-            if (turns == 0) {
-                assert(n >= 2 and n <= 5);
-                if (n != 5) try self.probability.update(1, 6 - @as(u4, n));
-                durations.encore = 0;
-            } else {
-                assert(n >= 1 and n < 5);
-                if (n > 1) try self.probability.update(6 - @as(u4, n) - 1, 6 - @as(u4, n));
-                durations.encore += 1;
-            }
+            self.actions.get(player).duration = if (options.key) 2 else turns;
         }
     };
 }
@@ -685,22 +488,22 @@ test "Chance.hit" {
 test "Chance.criticalHit" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
-    try chance.criticalHit(.P1, true, 17);
-    try expectValue(Optional(bool).true, chance.actions.p1.critical_hit);
+    try chance.criticalHit(.P1, 0, true, 17);
+    try expectValue(Optional(bool).true, Criticals.get(chance.actions.p1.critical_hits, 0));
     try expectProbability(&chance.probability, 17, 256);
 
     chance.reset();
 
-    try chance.criticalHit(.P2, false, 5);
+    try chance.criticalHit(.P2, 1, false, 5);
     try expectProbability(&chance.probability, 251, 256);
-    try expectValue(Optional(bool).false, chance.actions.p2.critical_hit);
+    try expectValue(Optional(bool).false, Criticals.get(chance.actions.p2.critical_hits, 1));
 }
 
 test "Chance.damage" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
-    try chance.damage(.P1, 217);
-    try expectValue(217, chance.actions.p1.damage);
+    try chance.damage(.P1, 0, 219);
+    try expectValue(@as(u8, 219), Damages.get(chance.actions.p1.damages, 0));
     try expectProbability(&chance.probability, 1, 39);
 }
 
@@ -825,7 +628,7 @@ test "Chance.present" {
     } else {
         try expectProbability(&chance.probability, 25, 256);
     }
-    try expectValue(4, chance.actions.p2.present);
+    try expectValue(@as(u3, 4), chance.actions.p2.present);
 
     chance.reset();
 
@@ -835,7 +638,7 @@ test "Chance.present" {
     } else {
         try expectProbability(&chance.probability, 51, 256);
     }
-    try expectValue(1, chance.actions.p1.present);
+    try expectValue(@as(u3, 1), chance.actions.p1.present);
 }
 
 test "Chance.magnitude" {
@@ -847,7 +650,7 @@ test "Chance.magnitude" {
     } else {
         try expectProbability(&chance.probability, 13, 256);
     }
-    try expectValue(7, chance.actions.p2.magnitude);
+    try expectValue(@as(u3, 7), chance.actions.p2.magnitude);
 
     chance.reset();
 
@@ -857,7 +660,7 @@ test "Chance.magnitude" {
     } else {
         try expectProbability(&chance.probability, 51, 256);
     }
-    try expectValue(5, chance.actions.p1.magnitude);
+    try expectValue(@as(u3, 5), chance.actions.p1.magnitude);
 }
 
 test "Chance.tripleKick" {
@@ -865,7 +668,7 @@ test "Chance.tripleKick" {
 
     try chance.tripleKick(.P1, 2);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(2, chance.actions.p1.triple_kick);
+    try expectValue(@as(u2, 2), chance.actions.p1.triple_kick);
 }
 
 test "Chance.spite" {
@@ -873,7 +676,7 @@ test "Chance.spite" {
 
     try chance.spite(.P1, 3);
     try expectProbability(&chance.probability, 1, 4);
-    try expectValue(3, chance.actions.p1.spite);
+    try expectValue(@as(u3, 3), chance.actions.p1.spite);
 }
 
 test "Chance.conversion2" {
@@ -900,7 +703,7 @@ test "Chance.psywave" {
 
     try chance.psywave(.P2, 100, 150);
     try expectProbability(&chance.probability, 1, 150);
-    try expectValue(100, chance.actions.p2.psywave);
+    try expectValue(@as(u8, 100), chance.actions.p2.psywave);
 }
 
 test "Chance.metronome" {
@@ -916,19 +719,19 @@ test "Chance.moveSlot" {
 
     try chance.moveSlot(.P2, 2, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(2, chance.actions.p2.move_slot);
+    try expectValue(@as(u3, 2), chance.actions.p2.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 1, 3);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(1, chance.actions.p1.move_slot);
+    try expectValue(@as(u3, 1), chance.actions.p1.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 4, 1);
     try expectProbability(&chance.probability, 1, 1);
-    try expectValue(4, chance.actions.p1.move_slot);
+    try expectValue(@as(u3, 4), chance.actions.p1.move_slot);
 }
 
 test "Chance.forceSwitch" {
@@ -936,19 +739,19 @@ test "Chance.forceSwitch" {
 
     try chance.forceSwitch(.P2, 2, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(2, chance.actions.p2.force_switch);
+    try expectValue(@as(u3, 2), chance.actions.p2.force_switch);
 
     chance.reset();
 
     try chance.forceSwitch(.P1, 1, 3);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(1, chance.actions.p1.force_switch);
+    try expectValue(@as(u3, 1), chance.actions.p1.force_switch);
 
     chance.reset();
 
     try chance.forceSwitch(.P1, 4, 1);
     try expectProbability(&chance.probability, 1, 1);
-    try expectValue(4, chance.actions.p1.force_switch);
+    try expectValue(@as(u3, 4), chance.actions.p1.force_switch);
 }
 
 test "Chance.multiHit" {
@@ -956,212 +759,20 @@ test "Chance.multiHit" {
 
     try chance.multiHit(.P1, 3);
     try expectProbability(&chance.probability, 3, 8);
-    try expectValue(3, chance.actions.p1.multi_hit);
+    try expectValue(@as(u3, 3), chance.actions.p1.multi_hit);
 
     chance.reset();
 
     try chance.multiHit(.P2, 5);
     try expectProbability(&chance.probability, 1, 8);
-    try expectValue(5, chance.actions.p2.multi_hit);
+    try expectValue(@as(u3, 5), chance.actions.p2.multi_hit);
 }
 
 test "Chance.duration" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
-    chance.duration(.sleep, .P1, .P2, 2);
-    try expectValue(2, chance.actions.p1.duration);
-    try expectValue(1, chance.actions.p2.durations.sleep);
-}
-
-test "Chance.sleep" {
-    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
-
-    for ([_]u8{ 6, 5, 4, 3, 2, 1 }, 1..7) |d, i| {
-        chance.actions.p1.durations.sleep = @intCast(i);
-        try chance.sleep(.P1, 0);
-        try expectProbability(&chance.probability, 1, d);
-        try expectValue(0, chance.actions.p1.durations.sleep);
-
-        chance.reset();
-
-        if (i < 6) {
-            chance.actions.p1.durations.sleep = @intCast(i);
-            try chance.sleep(.P1, 1);
-            try expectProbability(&chance.probability, d - 1, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p1.durations.sleep);
-
-            chance.reset();
-        }
-    }
-}
-
-test "Chance.confusion" {
-    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
-
-    chance.actions.p2.durations.thrash = false;
-    for ([_]u8{ 1, 4, 3, 2, 1 }, 1..6) |d, i| {
-        if (i > 1) {
-            chance.actions.p2.durations.confusion = @intCast(i);
-            try chance.confusion(.P2, 0);
-            try expectProbability(&chance.probability, 1, d);
-            try expectValue(0, chance.actions.p2.durations.confusion);
-            try expectValue(false, chance.actions.p2.durations.thrash);
-
-            chance.reset();
-        }
-
-        if (i < 5) {
-            chance.actions.p2.durations.confusion = @intCast(i);
-            try chance.confusion(.P2, 1);
-            try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations.confusion);
-            try expectValue(false, chance.actions.p2.durations.thrash);
-
-            chance.reset();
-        }
-    }
-
-    chance.reset();
-
-    chance.actions.p2.durations.thrash = true;
-    for ([_]u8{ 1, 2, 1 }, 1..4) |d, i| {
-        if (i > 1) {
-            chance.actions.p2.durations.confusion = @intCast(i);
-            try chance.confusion(.P2, 0);
-            try expectProbability(&chance.probability, 1, d);
-            try expectValue(0, chance.actions.p2.durations.confusion);
-            try expectValue(true, chance.actions.p2.durations.thrash);
-
-            chance.reset();
-        }
-
-        if (i < 3) {
-            chance.actions.p2.durations.confusion = @intCast(i);
-            try chance.confusion(.P2, 1);
-            try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations.confusion);
-            try expectValue(true, chance.actions.p2.durations.thrash);
-
-            chance.reset();
-        }
-    }
-}
-
-test "Chance.disable" {
-    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
-    if (showdown) {
-        for ([_]u8{ 1, 4, 3, 2, 1 }, 1..6) |d, i| {
-            if (i > 1) {
-                chance.actions.p2.durations.disable = @intCast(i);
-                try chance.disable(.P2, 0);
-                try expectProbability(&chance.probability, 1, d);
-                try expectValue(0, chance.actions.p2.durations.disable);
-
-                chance.reset();
-            }
-
-            if (i < 5) {
-                chance.actions.p2.durations.disable = @intCast(i);
-                try chance.disable(.P2, 1);
-                try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-                try expectValue(@as(u4, @intCast(i)) + 1, chance.actions.p2.durations.disable);
-
-                chance.reset();
-            }
-        }
-    } else {
-        for ([_]u8{ 1, 7, 6, 5, 4, 3, 2, 1 }, 1..9) |d, i| {
-            if (i > 1) {
-                chance.actions.p2.durations.disable = @intCast(i);
-                try chance.disable(.P2, 0);
-                try expectProbability(&chance.probability, 1, d);
-                try expectValue(0, chance.actions.p2.durations.disable);
-
-                chance.reset();
-            }
-
-            if (i < 8) {
-                chance.actions.p2.durations.disable = @intCast(i);
-                try chance.disable(.P2, 1);
-                try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-                try expectValue(@as(u4, @intCast(i)) + 1, chance.actions.p2.durations.disable);
-
-                chance.reset();
-            }
-        }
-    }
-}
-
-test "Chance.attacking" {
-    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
-
-    for ([_]u8{ 1, 2, 1 }, 1..4) |d, i| {
-        if (i > 1) {
-            chance.actions.p2.durations.attacking = @intCast(i);
-            try chance.attacking(.P2, 0);
-            try expectProbability(&chance.probability, 1, d);
-            try expectValue(0, chance.actions.p2.durations.attacking);
-
-            chance.reset();
-        }
-
-        if (i < 3) {
-            chance.actions.p2.durations.attacking = @intCast(i);
-            try chance.attacking(.P2, 1);
-            try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations.attacking);
-
-            chance.reset();
-        }
-    }
-}
-
-test "Chance.binding" {
-    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
-
-    for ([_]u8{ 1, 4, 3, 2, 1 }, 1..6) |d, i| {
-        if (i > 1) {
-            chance.actions.p2.durations.binding = @intCast(i);
-            try chance.binding(.P2, 0);
-            try expectProbability(&chance.probability, 1, d);
-            try expectValue(0, chance.actions.p2.durations.binding);
-
-            chance.reset();
-        }
-
-        if (i < 5) {
-            chance.actions.p2.durations.binding = @intCast(i);
-            try chance.binding(.P2, 1);
-            try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations.binding);
-
-            chance.reset();
-        }
-    }
-}
-
-test "Chance.encore" {
-    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
-
-    for ([_]u8{ 1, 4, 3, 2, 1 }, 1..6) |d, i| {
-        if (i > 1) {
-            chance.actions.p2.durations.encore = @intCast(i);
-            try chance.encore(.P2, 0);
-            try expectProbability(&chance.probability, 1, d);
-            try expectValue(0, chance.actions.p2.durations.encore);
-
-            chance.reset();
-        }
-
-        if (i < 5) {
-            chance.actions.p2.durations.encore = @intCast(i);
-            try chance.encore(.P2, 1);
-            try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations.encore);
-
-            chance.reset();
-        }
-    }
+    chance.duration(.P1, 2);
+    try expectValue(@as(u3, 2), chance.actions.p1.duration);
 }
 
 pub fn expectProbability(r: anytype, p: u64, q: u64) !void {
@@ -1169,7 +780,7 @@ pub fn expectProbability(r: anytype, p: u64, q: u64) !void {
 
     r.reduce();
     if (r.p != p or r.q != q) {
-        print("expected {d}/{d}, found {}\n", .{ p, q, r });
+        print("expected {d}/{d}, found {f}\n", .{ p, q, r });
         return error.TestExpectedEqual;
     }
 }
@@ -1203,12 +814,12 @@ const Null = struct {
         _ = .{ self, player, ok, accuracy };
     }
 
-    pub fn criticalHit(self: Null, player: Player, crit: bool, rate: u8) Error!void {
-        _ = .{ self, player, crit, rate };
+    pub fn criticalHit(self: Null, player: Player, i: u3, crit: bool, rate: u8) Error!void {
+        _ = .{ self, player, i, crit, rate };
     }
 
-    pub fn damage(self: Null, player: Player, roll: u8) Error!void {
-        _ = .{ self, player, roll };
+    pub fn damage(self: Null, player: Player, i: u3, roll: u8) Error!void {
+        _ = .{ self, player, i, roll };
     }
 
     pub fn confused(self: Null, player: Player, ok: bool) Error!void {
@@ -1279,37 +890,7 @@ const Null = struct {
         _ = .{ self, player, move, n };
     }
 
-    pub fn duration(
-        self: Null,
-        comptime field: Duration.Field,
-        player: Player,
-        target: Player,
-        turns: u4,
-    ) void {
-        _ = .{ self, field, player, target, turns };
-    }
-
-    pub fn sleep(self: Null, player: Player, turns: u4) Error!void {
-        _ = .{ self, player, turns };
-    }
-
-    pub fn confusion(self: Null, player: Player, turns: u4) Error!void {
-        _ = .{ self, player, turns };
-    }
-
-    pub fn disable(self: Null, player: Player, turns: u4) Error!void {
-        _ = .{ self, player, turns };
-    }
-
-    pub fn attacking(self: Null, player: Player, turns: u4) Error!void {
-        _ = .{ self, player, turns };
-    }
-
-    pub fn binding(self: Null, player: Player, turns: u4) Error!void {
-        _ = .{ self, player, turns };
-    }
-
-    pub fn encore(self: Null, player: Player, turns: u4) Error!void {
+    pub fn duration(self: Null, player: Player, turns: u3) void {
         _ = .{ self, player, turns };
     }
 };