@pkmn/engine 0.1.0-dev.b01cb48c → 0.1.0-dev.b14f2221

package/src/lib/gen1/chance.zig

@@ -1,26 +1,27 @@
-const std = @import("std");
-
-const assert = std.debug.assert;
-const print = std.debug.print;
-
-const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
-
 const DEBUG = @import("../common/debug.zig").print;
+
+const array = @import("../common/array.zig");
+const common = @import("../common/data.zig");
+const data = @import("data.zig");
+const optional = @import("../common/optional.zig");
 const options = @import("../common/options.zig");
 const rational = @import("../common/rational.zig");
+const std = @import("std");
 const util = @import("../common/util.zig");
 
-const Player = @import("../common/data.zig").Player;
-const Optional = @import("../common/optional.zig").Optional;
-
-const data = @import("data.zig");
-
+const Array = array.Array;
+const assert = std.debug.assert;
 const enabled = options.chance;
-const showdown = options.showdown;
-
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const isPointerTo = util.isPointerTo;
 const Move = data.Move;
 const MoveSlot = data.MoveSlot;
+const Optional = optional.Optional;
+const Player = common.Player;
+const PointerType = util.PointerType;
+const print = std.debug.print;
+const showdown = options.showdown;
 
 /// Actions taken by a hypothetical "chance player" that convey information about which RNG events
 /// were observed during a Generation I battle `update`. This can additionally be provided as input
@@ -37,8 +38,8 @@ pub const Actions = extern struct {
     }
 
     /// 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;
     }
 
@@ -51,15 +52,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))) {
-                    .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,
                 }
             }
@@ -67,7 +68,26 @@ pub const Actions = extern struct {
         return true;
     }
 
-    pub fn fmt(self: Actions, writer: anytype, shape: bool) !void {
+    /// TODO
+    pub fn matchesAny(a: Actions, bs: []Actions, i: usize) bool {
+        for (bs, 0..) |b, j| {
+            // TODO: is skipping this redundant check worth it?
+            if (i == j) continue;
+            if (b.matches(a)) return true;
+        }
+        return false;
+    }
+
+    /// TODO
+    pub fn relax(actions: Actions) Actions {
+        if (!options.overwrite) return actions;
+        var a = actions;
+        if (a.p1.confusion == .overwritten) a.p1.confusion = .continuing;
+        if (a.p2.confusion == .overwritten) a.p2.confusion = .continuing;
+        return a;
+    }
+
+    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 = ");
@@ -75,8 +95,7 @@ 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);
     }
 };
@@ -99,8 +118,42 @@ test Actions {
     try expect(!c.matches(a));
 }
 
-pub const Observation = enum { started, continuing, ended };
-pub const Confusion = enum { started, continuing, ended, overwritten };
+/// Observation made about a duration - whether the duration has started, been continued, or ended.
+pub fn Observation(comptime field: Duration.Field) type {
+    return switch (field) {
+        .attacking, .binding => enum(u2) {
+            started,
+            continuing,
+            ended,
+        },
+        .sleep, .disable => enum(u3) {
+            started,
+            continuing,
+            ended,
+            // TODO haze support
+            unused1,
+            unused2,
+            unused3,
+            unused4,
+        },
+        .confusion => enum(u4) {
+            started,
+            continuing,
+            ended,
+            /// An indicator that an existing confusion duration has been overwritten by a new
+            /// confusion duration due to a Thrashing move ending ("hidden" confusion). This is not
+            /// immediately observable to an opponent, to compute probabilities from an opponent's
+            /// point of view based solely on public information extra work must be done to correct
+            /// for the information leak
+            overwritten,
+            // TODO haze support
+            unused1,
+            unused2,
+            unused3,
+            unused4,
+        },
+    };
+}
 
 /// Information about the RNG that was observed during a Generation I battle `update` for a
 /// single player.
@@ -126,21 +179,25 @@ pub const Action = packed struct(u64) {
     /// or Rolls.{sleepDuration,disableDuration,confusionDuration,attackingDuration} otherwise.
     duration: u4 = 0,
 
-    // TODO
-    sleep: Optional(Observation) = .None,
-    confusion: Optional(Confusion) = .None,
-    disable: Optional(Observation) = .None,
-    bide: Optional(Observation) = .None,
-    binding: Optional(Observation) = .None,
-    thrashing: Optional(Observation) = .None,
-
-    _: u3 = 0, // TODO
+    /// TODO
+    sleep: Optional(Observation(.sleep)) = .None,
+    /// TODO
+    confusion: Optional(Observation(.confusion)) = .None,
+    /// TODO
+    disable: Optional(Observation(.disable)) = .None,
+    /// TODO
+    attacking: Optional(Observation(.attacking)) = .None,
+    /// TODO
+    binding: Optional(Observation(.binding)) = .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 value (2-5) to return for Rolls.distribution for multi hit.
-    multi_hit: u4 = 0,
+    multi_hit: u3 = 0,
+
+    /// TODO
+    pp: u4 = 0,
 
     /// If not 0, psywave - 1 should be returned as the damage roll for Rolls.psywave.
     psywave: u8 = 0,
@@ -150,18 +207,19 @@ pub const Action = packed struct(u64) {
 
     pub const Field = std.meta.FieldEnum(Action);
 
-    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 {
+    const SYMBOLS = [_][]const u8{ "+", "", "-", "#" };
+
+    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))) {
-                .Enum => if (val != .None) {
+                .@"enum" => if (val != .None) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -170,33 +228,14 @@ pub const Action = packed struct(u64) {
                             if (val == .false) "!" else "",
                             field.name,
                         });
-                    } else if (@TypeOf(val) == Optional(Observation)) {
-                        try writer.print("{s}{s}", .{
-                            switch (val) {
-                                .started => "+",
-                                .continuing => "",
-                                .ended => "-",
-                                else => unreachable,
-                            },
-                            field.name,
-                        });
-                    } else if (@TypeOf(val) == Optional(Confusion)) {
-                        try writer.print("{s}{s}", .{
-                            switch (val) {
-                                .started => "+",
-                                .continuing => "",
-                                .ended => "-",
-                                .overwritten => "#",
-                                else => unreachable,
-                            },
-                            field.name,
-                        });
+                    } else if (@TypeOf(val) != Move and @TypeOf(val) != Optional(Player)) {
+                        try writer.print("{s}{s}", .{ SYMBOLS[@intFromEnum(val) - 1], field.name });
                     } else {
                         try writer.print("{s}:{s}", .{ field.name, @tagName(val) });
                     }
                     printed = true;
                 },
-                .Int => if (val != 0) {
+                .int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -213,68 +252,63 @@ pub const Action = packed struct(u64) {
 };
 
 /// TODO
-pub const Durations = struct {
+pub const Durations = extern struct {
     /// TODO
     p1: Duration = .{},
     /// TODO
     p2: Duration = .{},
 
+    comptime {
+        assert(@sizeOf(Durations) == 8);
+    }
+
     /// TODO
-    pub fn get(self: anytype, player: Player) util.PointerType(@TypeOf(self), Duration) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Durations);
+    pub fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Duration) {
+        assert(isPointerTo(self, Durations));
         return if (player == .P1) &self.p1 else &self.p2;
     }
 
-    pub fn format(
-        self: Durations,
-        comptime fmt: []const u8,
-        opts: std.fmt.FormatOptions,
-        writer: anytype,
-    ) !void {
-        _ = .{ fmt, opts };
-        try writer.print("[P1 = {}, P2 = {}]", .{ self.p1, self.p2 });
+    pub fn format(self: Durations, writer: *std.Io.Writer) !void {
+        try writer.print("[P1 = {f}, P2 = {f}]", .{ self.p1, self.p2 });
     }
 };
 
+pub const Sleeps = Array(6, u3);
+
 /// TODO
-pub const Duration = struct {
-    sleeps: [6]u3 = .{0} ** 6,
+pub const Duration = packed struct(u32) {
+    sleeps: Sleeps.T = 0,
     confusion: u3 = 0,
     disable: u4 = 0,
-    bide: u3 = 0,
-    thrashing: u3 = 0,
+    attacking: u3 = 0,
     binding: u3 = 0,
 
+    _: u1 = 0,
+
+    pub const Field = enum { attacking, binding, sleep, disable, confusion };
+
     pub fn format(
         self: Duration,
-        comptime fmt: []const u8,
-        opts: std.fmt.FormatOptions,
-        writer: anytype,
+        writer: *std.Io.Writer,
     ) !void {
-        _ = .{ fmt, opts };
         try writer.writeByte('(');
         var printed = false;
-        inline for (@typeInfo(Duration).Struct.fields) |field| {
+        inline for (@typeInfo(Duration).@"struct".fields) |field| {
             const val = @field(self, field.name);
             switch (@typeInfo(@TypeOf(val))) {
-                .Int => if (val != 0) {
+                .int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
-                    try writer.print("{s}:{d}", .{ field.name, val });
-                    printed = true;
-                },
-                .Array => {
-                    var total: usize = 0;
-                    for (val) |v| total += v;
-                    if (total > 0) {
-                        if (printed) try writer.writeAll(", ");
+                    if (comptime std.mem.eql(u8, field.name, "sleeps")) {
                         try writer.print("{s}:[", .{field.name});
-                        for (val, 0..) |v, i| {
+                        for (0..6) |i| {
                             if (i != 0) try writer.writeByte(',');
-                            try writer.print("{d}", .{v});
+                            try writer.print("{d}", .{Sleeps.get(val, i)});
                         }
                         try writer.writeAll("]");
-                        printed = true;
+                    } else {
+                        try writer.print("{s}:{d}", .{ field.name, val });
                     }
+                    printed = true;
                 },
                 else => unreachable,
             }
@@ -283,7 +317,7 @@ pub const Duration = struct {
     }
 };
 
-pub const Commit = enum { hit, miss, binding };
+pub const Commit = enum { hit, miss, binding, err, glitch };
 
 const uN = if (options.miss) u8 else u9;
 
@@ -323,6 +357,7 @@ pub fn Chance(comptime Rational: type) type {
             damage_roll: u8 = 0,
             hit: bool = false,
             hit_probablity: uN = 0,
+            glitch: bool = false,
         } = .{},
 
         /// Possible error returned by operations tracking chance probability.
@@ -342,10 +377,18 @@ pub fn Chance(comptime Rational: type) type {
 
             assert(!showdown);
 
+            if (kind == .glitch and !self.pending.glitch) return;
+
             var action = self.actions.get(player);
 
+            if (kind == .err and self.pending.crit_probablity != 0) {
+                try self.probability.update(self.pending.crit_probablity, 256);
+                action.critical_hit = if (self.pending.crit) .true else .false;
+                return;
+            }
+
             // Always commit the hit result if we make it here (commit won't be called at all if the
-            // target is immune/behind a sub/etc)
+            // target is immune*/behind a sub/etc)
             if (self.pending.hit_probablity != 0) {
                 try self.probability.update(self.pending.hit_probablity, 256);
                 action.hit = if (self.pending.hit) .true else .false;
@@ -353,28 +396,61 @@ pub fn Chance(comptime Rational: type) type {
 
             // If the move actually lands we can commit any past critical hit / damage rolls. Note
             // we can't rely on the presence or absence of a damage roll to determine whether a
-            // "critical hit" was spurious or not as moves that do 1 or less damage don't rol for
+            // "critical hit" was spurious or not as moves that do 1 or less damage don't roll for
             // damage but can still crit (instead, whether or not a roll is deemed to be a no-op is
-            // passed to the critical hit helper)
-            if (kind != .hit) return assert(!self.pending.crit or self.pending.crit_probablity > 0);
+            // passed to the critical hit helper).
+            //
+            // There is a special edge case with the division-by-zero freeze where we need to commit
+            // the status of critical hit roll the occured before the move missed to avoid missing
+            // out on the possibility that the alternative branch encountered an error
+            if (kind != .hit and !self.pending.glitch) {
+                return assert(!self.pending.crit or self.pending.crit_probablity > 0);
+            }
 
             if (self.pending.crit_probablity != 0) {
                 try self.probability.update(self.pending.crit_probablity, 256);
                 action.critical_hit = if (self.pending.crit) .true else .false;
-            }
+            } else assert(!self.pending.glitch);
 
-            if (self.pending.damage_roll > 0) {
+            if (self.pending.damage_roll > 0 and (!self.pending.glitch or self.pending.hit)) {
                 try self.probability.update(1, 39);
                 action.damage = self.pending.damage_roll;
             }
         }
 
+        pub fn glitch(self: *Self) void {
+            if (!enabled) return;
+
+            assert(!showdown);
+            self.pending.glitch = true;
+        }
+
         pub fn clearPending(self: *Self) void {
             if (!enabled) return;
 
+            assert(!showdown);
             self.pending = .{};
         }
 
+        pub fn switched(self: *Self, player: Player, slot: u8) void {
+            if (!enabled) return;
+
+            assert(slot >= 1 and slot <= 6);
+
+            var d = self.durations.get(player);
+
+            const out = Sleeps.get(d.sleeps, 0);
+            d.sleeps = Sleeps.set(d.sleeps, 0, Sleeps.get(d.sleeps, slot - 1));
+            d.sleeps = Sleeps.set(d.sleeps, slot - 1, out);
+
+            d.confusion = 0;
+            d.disable = 0;
+            d.attacking = 0;
+            d.binding = 0;
+
+            self.durations.get(player.foe()).binding = 0;
+        }
+
         pub fn speedTie(self: *Self, p1: bool) Error!void {
             if (!enabled) return;
 
@@ -474,36 +550,185 @@ pub fn Chance(comptime Rational: type) type {
         pub fn duration(self: *Self, player: Player, turns: u4) void {
             if (!enabled) return;
 
-            self.actions.get(player).duration = if (options.key) 1 else turns;
+            self.actions.get(player).duration = if (options.key) 2 else turns;
         }
 
         pub fn observe(
             self: *Self,
             comptime field: Action.Field,
             player: Player,
-            observation: Optional(Confusion),
+            obs: Optional(Observation(.confusion)),
         ) void {
             if (!enabled) return;
 
-            const val = @field(self.actions.get(player), @tagName(field));
-            if (observation == .overwritten) {
-                assert(field == .confusion);
-                assert(val == .started or val == .continuing);
-                assert(self.actions.get(player).duration > 0);
-                self.actions.get(player).confusion = observation;
+            var a = self.actions.get(player);
+            const val = @field(a, @tagName(field));
+            switch (obs) {
+                .overwritten => {
+                    assert(field == .confusion);
+                    assert(val == .started or val == .continuing);
+                    assert(a.duration > 0);
+                    a.confusion = obs;
+                    self.durations.get(player).confusion = 1;
+                },
+                .None => {
+                    @field(a, @tagName(field)) = .None;
+                    if (field == .sleep) {
+                        var d = self.durations.get(player);
+                        d.sleeps = Sleeps.set(d.sleeps, 0, 0);
+                    } else {
+                        @field(self.durations.get(player), @tagName(field)) = 0;
+                    }
+                },
+                .started => {
+                    assert(val == .None or val == .ended);
+                    assert(switch (field) {
+                        .confusion => a.duration > 0 or self.actions.get(player.foe()).duration > 0,
+                        .sleep, .disable => self.actions.get(player.foe()).duration > 0,
+                        else => a.duration > 0,
+                    });
+                    @field(a, @tagName(field)) = .started;
+                    if (field == .sleep) {
+                        var d = self.durations.get(player);
+                        d.sleeps = Sleeps.set(d.sleeps, 0, 1);
+                    } else {
+                        @field(self.durations.get(player), @tagName(field)) = 1;
+                    }
+                },
+                else => unreachable,
+            }
+        }
+
+        pub fn sleep(self: *Self, player: Player, obs: Optional(Observation(.sleep))) Error!void {
+            if (!enabled) return;
+
+            var a = self.actions.get(player);
+            assert(a.sleep == .None or a.sleep == .started);
+            a.sleep = obs;
+
+            var d = self.durations.get(player);
+            const n = Sleeps.get(d.sleeps, 0);
+
+            if (obs == .None) {
+                d.sleeps = Sleeps.set(d.sleeps, 0, 0);
+            } else if (obs == .ended) {
+                assert(n >= 1 and n <= 7);
+                if (n != 7) try self.probability.update(1, 8 - @as(u4, n));
+                d.sleeps = Sleeps.set(d.sleeps, 0, 0);
             } else {
-                assert(observation == .None or val == .None or
-                    (val == .started and observation != .started) or
-                    (val == .ended and observation == .started));
-                assert(observation != .started or (if (field == .confusion)
-                    self.actions.get(player).duration > 0 or
-                        self.actions.get(player.foe()).duration > 0
-                else if (field == .sleep or field == .disable)
-                    self.actions.get(player.foe()).duration > 0
-                else
-                    self.actions.get(player).duration > 0));
-                @field(self.actions.get(player), @tagName(field)) =
-                    @enumFromInt(@intFromEnum(observation));
+                assert(obs == .continuing);
+                assert(n >= 1 and n < 7);
+                try self.probability.update(8 - @as(u4, n) - 1, 8 - @as(u4, n));
+                d.sleeps = Sleeps.set(d.sleeps, 0, n + 1);
+            }
+        }
+
+        pub fn confusion(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.confusion)),
+        ) Error!void {
+            if (!enabled) return;
+
+            var a = self.actions.get(player);
+            assert(a.confusion == .None or a.confusion == .started);
+            a.confusion = obs;
+
+            var d = self.durations.get(player);
+            const n = d.confusion;
+
+            if (obs == .ended) {
+                assert(n >= 2 and n <= 5);
+                if (n != 5) try self.probability.update(1, 6 - @as(u4, n));
+                d.confusion = 0;
+            } else {
+                assert(obs == .continuing);
+                assert(n >= 1 and n < 5);
+                if (n > 1) try self.probability.update(6 - @as(u4, n) - 1, 6 - @as(u4, n));
+                d.confusion += 1;
+            }
+        }
+
+        pub fn disable(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.disable)),
+        ) Error!void {
+            if (!enabled) return;
+
+            var a = self.actions.get(player);
+            assert(a.disable == .None or a.disable == .started);
+            a.disable = obs;
+
+            var d = self.durations.get(player);
+            const n = d.disable;
+
+            if (obs == .ended) {
+                assert(n >= 1 and n <= 8);
+                if (n != 8) try self.probability.update(1, 9 - @as(u4, n));
+                d.disable = 0;
+            } else {
+                assert(obs == .continuing);
+                assert(n >= 1 and n < 8);
+                try self.probability.update(9 - @as(u4, n) - 1, 9 - @as(u4, n));
+                d.disable += 1;
+            }
+        }
+
+        pub fn attacking(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.attacking)),
+        ) Error!void {
+            if (!enabled) return;
+
+            var a = self.actions.get(player);
+            assert(a.attacking == .None or a.attacking == .started);
+            a.attacking = obs;
+
+            var d = self.durations.get(player);
+            const n = d.attacking;
+            if (obs == .ended) {
+                // "3-4 turns" includes the turn for the initial attack *plus* the forced attacks
+                assert(n >= 2 and n <= 3);
+                if (n != 3) try self.probability.update(1, 4 - @as(u4, n));
+                d.attacking = 0;
+            } else {
+                assert(obs == .continuing);
+                assert(n >= 1 and n < 3);
+                if (n > 1) try self.probability.update(4 - @as(u4, n) - 1, 4 - @as(u4, n));
+                d.attacking += 1;
+            }
+        }
+
+        pub fn binding(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.binding)),
+        ) Error!void {
+            if (!enabled) return;
+
+            var a = self.actions.get(player);
+            assert(a.binding == .None or a.binding == .started);
+            a.binding = obs;
+
+            var d = self.durations.get(player);
+            const n = d.binding;
+
+            assert(n > 0);
+            const p: u4 = if (n < 3) 3 else 1;
+            const q: u4 = if (n < 3) 8 - ((n - 1) * p) else 2;
+
+            if (obs == .ended) {
+                // "2-5 turns" includes the turn for the initial attack *plus* the forced attacks
+                assert(n >= 1 and n <= 4);
+                if (n != 4) try self.probability.update(p, q);
+                d.binding = 0;
+            } else {
+                assert(obs == .continuing);
+                assert(n >= 1 and n < 4);
+                try self.probability.update(q - p, q);
+                d.binding += 1;
             }
         }
 
@@ -520,6 +745,15 @@ pub fn Chance(comptime Rational: type) type {
             try self.probability.update(1, Move.METRONOME.len);
             self.actions.get(player).metronome = move;
         }
+
+        pub fn pp(self: *Self, player: Player, n: u4) bool {
+            if (!enabled) return true;
+
+            var a = self.actions.get(player);
+            if (n > 1 and a.pp == n) return false;
+            if (a.metronome != .None) a.pp += n;
+            return true;
+        }
     };
 }
 
@@ -620,16 +854,16 @@ test "Chance.damage" {
 
     try chance.damage(.P1, 217);
     if (showdown) {
-        try expectValue(217, chance.actions.p1.damage);
+        try expectValue(@as(u8, 217), chance.actions.p1.damage);
         try expectProbability(&chance.probability, 1, 39);
     } else {
         try expectProbability(&chance.probability, 1, 1);
-        try expectValue(0, chance.actions.p1.damage);
+        try expectValue(@as(u8, 0), chance.actions.p1.damage);
 
         try chance.commit(.P1, .hit);
 
         try expectProbability(&chance.probability, 1, 39);
-        try expectValue(217, chance.actions.p1.damage);
+        try expectValue(@as(u8, 217), chance.actions.p1.damage);
     }
 }
 
@@ -681,13 +915,13 @@ test "Chance.moveSlot" {
 
     try chance.moveSlot(.P2, 2, &ms, 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, &ms, 0);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(1, chance.actions.p1.move_slot);
+    try expectValue(@as(u3, 1), chance.actions.p1.move_slot);
 }
 
 test "Chance.multiHit" {
@@ -695,25 +929,142 @@ 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(u4, 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(u4, 5), chance.actions.p2.multi_hit);
 }
 
 test "Chance.duration" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     chance.duration(.P1, 2);
-    try expectValue(2, chance.actions.p1.duration);
+    try expectValue(@as(u4, 2), chance.actions.p1.duration);
 
     chance.reset();
 
     chance.duration(.P2, 4);
-    try expectValue(4, chance.actions.p2.duration);
+    try expectValue(@as(u4, 4), chance.actions.p2.duration);
+}
+
+test "Chance.sleep" {
+    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
+
+    for ([_]u8{ 7, 6, 5, 4, 3, 2, 1 }, 1..8) |d, i| {
+        chance.durations.p1.sleeps = Sleeps.set(chance.durations.p1.sleeps, 0, @intCast(i));
+        try chance.sleep(.P1, .ended);
+        try expectProbability(&chance.probability, 1, d);
+        try expectValue(@as(u3, 0), Sleeps.get(chance.durations.p1.sleeps, 0));
+
+        chance.reset();
+
+        if (i < 7) {
+            chance.durations.p1.sleeps = Sleeps.set(chance.durations.p1.sleeps, 0, @intCast(i));
+            try chance.sleep(.P1, .continuing);
+            try expectProbability(&chance.probability, d - 1, d);
+            try expectValue(@as(u3, @intCast(i)) + 1, Sleeps.get(chance.durations.p1.sleeps, 0));
+
+            chance.reset();
+        }
+    }
+}
+
+test "Chance.confusion" {
+    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
+
+    for ([_]u8{ 1, 4, 3, 2, 1 }, 1..6) |d, i| {
+        if (i > 1) {
+            chance.durations.p2.confusion = @intCast(i);
+            try chance.confusion(.P2, .ended);
+            try expectProbability(&chance.probability, 1, d);
+            try expectValue(@as(u3, 0), chance.durations.p2.confusion);
+
+            chance.reset();
+        }
+
+        if (i < 5) {
+            chance.durations.p2.confusion = @intCast(i);
+            try chance.confusion(.P2, .continuing);
+            try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
+            try expectValue(@as(u3, @intCast(i)) + 1, chance.durations.p2.confusion);
+
+            chance.reset();
+        }
+    }
+}
+
+test "Chance.disable" {
+    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
+
+    for ([_]u8{ 8, 7, 6, 5, 4, 3, 2, 1 }, 1..9) |d, i| {
+        chance.durations.p1.disable = @intCast(i);
+        try chance.disable(.P1, .ended);
+        try expectProbability(&chance.probability, 1, d);
+        try expectValue(@as(u4, 0), chance.durations.p1.disable);
+
+        chance.reset();
+
+        if (i < 8) {
+            chance.durations.p1.disable = @intCast(i);
+            try chance.disable(.P1, .continuing);
+            try expectProbability(&chance.probability, d - 1, d);
+            try expectValue(@as(u4, @intCast(i)) + 1, chance.durations.p1.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.durations.p2.attacking = @intCast(i);
+            try chance.attacking(.P2, .ended);
+            try expectProbability(&chance.probability, 1, d);
+            try expectValue(@as(u3, 0), chance.durations.p2.attacking);
+
+            chance.reset();
+        }
+
+        if (i < 3) {
+            chance.durations.p2.attacking = @intCast(i);
+            try chance.attacking(.P2, .continuing);
+            try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
+            try expectValue(@as(u3, @intCast(i)) + 1, chance.durations.p2.attacking);
+
+            chance.reset();
+        }
+    }
+}
+
+test "Chance.binding" {
+    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
+
+    const ps = [_]u8{ 3, 3, 1, 1 };
+    const qs = [_]u8{ 8, 5, 2, 1 };
+
+    for (ps, qs, 1..5) |p, q, i| {
+        chance.durations.p1.binding = @intCast(i);
+        try chance.binding(.P1, .ended);
+        try expectProbability(&chance.probability, p, q);
+        try expectValue(@as(u3, 0), chance.durations.p1.binding);
+
+        chance.reset();
+
+        if (i < 4) {
+            chance.durations.p1.binding = @intCast(i);
+            try chance.binding(.P1, .continuing);
+            try expectProbability(&chance.probability, q - p, q);
+            try expectValue(@as(u3, @intCast(i)) + 1, chance.durations.p1.binding);
+
+            chance.reset();
+        }
+    }
 }
 
 test "Chance.psywave" {
@@ -721,7 +1072,7 @@ test "Chance.psywave" {
 
     try chance.psywave(.P2, 100, 150);
     try expectProbability(&chance.probability, 1, 150);
-    try expectValue(101, chance.actions.p2.psywave);
+    try expectValue(@as(u8, 101), chance.actions.p2.psywave);
 }
 
 test "Chance.metronome" {
@@ -737,7 +1088,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;
     }
 }
@@ -759,12 +1110,16 @@ const Null = struct {
         _ = .{ self, player, kind };
     }
 
+    pub fn glitch(self: Null) void {
+        _ = .{self};
+    }
+
     pub fn clearPending(self: Null) void {
         _ = .{self};
     }
 
-    pub fn switched(self: Null, player: Player, in: u8, out: u8) void {
-        _ = .{ self, player, in, out };
+    pub fn switched(self: Null, player: Player, slot: u8) void {
+        _ = .{ self, player, slot };
     }
 
     pub fn speedTie(self: Null, p1: bool) Error!void {
@@ -803,17 +1158,53 @@ const Null = struct {
         _ = .{ self, player, n };
     }
 
+    pub fn duration(self: Null, player: Player, turns: u4) void {
+        _ = .{ self, player, turns };
+    }
+
     pub fn observe(
         self: Null,
         comptime field: Action.Field,
         player: Player,
-        observation: Optional(Confusion),
+        obs: Optional(Observation(.confusion)),
     ) void {
-        _ = .{ self, field, player, observation };
+        _ = .{ self, field, player, obs };
     }
 
-    pub fn duration(self: Null, player: Player, turns: u4) void {
-        _ = .{ self, player, turns };
+    pub fn sleep(self: Null, player: Player, obs: Optional(Observation(.sleep))) Error!void {
+        _ = .{ self, player, obs };
+    }
+
+    pub fn confusion(
+        self: Null,
+        player: Player,
+        obs: Optional(Observation(.confusion)),
+    ) Error!void {
+        _ = .{ self, player, obs };
+    }
+
+    pub fn disable(
+        self: Null,
+        player: Player,
+        obs: Optional(Observation(.disable)),
+    ) Error!void {
+        _ = .{ self, player, obs };
+    }
+
+    pub fn attacking(
+        self: Null,
+        player: Player,
+        obs: Optional(Observation(.attacking)),
+    ) Error!void {
+        _ = .{ self, player, obs };
+    }
+
+    pub fn binding(
+        self: Null,
+        player: Player,
+        obs: Optional(Observation(.binding)),
+    ) Error!void {
+        _ = .{ self, player, obs };
     }
 
     pub fn psywave(self: Null, player: Player, power: u8, max: u8) Error!void {
@@ -823,4 +1214,9 @@ const Null = struct {
     pub fn metronome(self: Null, player: Player, move: Move) Error!void {
         _ = .{ self, player, move };
     }
+
+    pub fn pp(self: Null, player: Player, n: u4) bool {
+        _ = .{ self, player, n };
+        return true;
+    }
 };