@pkmn/engine 0.1.0-dev.89cc1c98 → 0.1.0-dev.8b192003

package/src/lib/gen1/chance.zig

@@ -14,7 +14,7 @@ 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 data = @import("data.zig");
 
 const enabled = options.chance;
 const showdown = options.showdown;
@@ -42,12 +42,6 @@ pub const Actions = extern struct {
         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)) == @as(u128, @bitCast(b));
@@ -63,11 +57,6 @@ pub const Actions = extern struct {
                 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| {
-                        if ((@field(a_val, f.name) > 0) != (@field(b_val, f.name) > 0)) {
-                            return false;
-                        }
-                    },
                     .Enum => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
                         return false,
                     .Int => if ((a_val > 0) != (b_val > 0)) return false,
@@ -96,9 +85,6 @@ 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 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 } } };
 
     try expect(a.eql(a));
     try expect(!a.eql(b));
@@ -111,10 +97,10 @@ 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));
 }
 
+pub const Observation = enum { started, continuing, ended };
+
 /// Information about the RNG that was observed during a Generation I battle `update` for a
 /// single player.
 pub const Action = packed struct(u64) {
@@ -139,8 +125,15 @@ pub const Action = packed struct(u64) {
     /// or Rolls.{sleepDuration,disableDuration,confusionDuration,attackingDuration} otherwise.
     duration: u4 = 0,
 
-    /// Observed values of various durations. Does not influence future RNG calls. TODO
-    durations: Duration = .{},
+    // TODO
+    sleep: Optional(Observation) = .None,
+    confusion: Optional(Observation) = .None,
+    disable: Optional(Observation) = .None,
+    bide: Optional(Observation) = .None,
+    binding: Optional(Observation) = .None,
+    thrashing: Optional(Observation) = .None,
+
+    _: u4 = 0, // TODO
 
     /// 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.
@@ -154,15 +147,8 @@ pub const Action = packed struct(u64) {
     /// If not None, the Move to return for Rolls.metronome.
     metronome: Move = .None,
 
-    pub const DURATIONS: u64 = 0x000000FFFF000000;
-
     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(u64, @bitCast(self.*)) & DURATIONS);
-    }
-
     pub fn format(a: Action, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
         _ = .{ f, o };
         try fmt(a, w, false);
@@ -174,18 +160,6 @@ pub const Action = packed struct(u64) {
         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) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
@@ -195,6 +169,19 @@ 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 => if (std.mem.eql(u8, field.name, "thrashing"))
+                                    "~"
+                                else
+                                    "-",
+                                else => unreachable,
+                            },
+                            field.name,
+                        });
                     } else {
                         try writer.print("{s}:{s}", .{ field.name, @tagName(val) });
                     }
@@ -216,43 +203,111 @@ pub const Action = packed struct(u64) {
     }
 };
 
-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);
-}
-
 /// TODO
-pub const Durations = extern struct {
-    /// Information about the durations for Player 1.
+pub const Durations = struct {
+    /// TODO
     p1: Duration = .{},
-    /// Information about the durations for Player 2.
+    /// TODO
     p2: Duration = .{},
 
-    comptime {
-        assert(@sizeOf(Durations) == 4);
+    /// TODO
+    pub fn get(self: anytype, player: Player) util.PointerType(@TypeOf(self), Duration) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Durations);
+        return if (player == .P1) &self.p1 else &self.p2;
+    }
+
+    /// TODO
+    pub fn update(self: *Durations, battle: anytype, q: anytype, actions: Actions) !void {
+        for (&battle.sides, 0..) |*s, i| {
+            const p: Player = @enumFromInt(i);
+            const action = actions.get(p);
+            var duration = self.get(p);
+
+            // TODO sleeps
+
+            duration.confusion =
+                if (@intFromEnum(action.confusion) > 1) duration.confusion + 1 else 0;
+            duration.disable =
+                if (@intFromEnum(action.disable) > 1) duration.disable + 1 else 0;
+            duration.bide =
+                if (@intFromEnum(action.bide) > 1) duration.bide + 1 else 0;
+            duration.binding =
+                if (@intFromEnum(action.binding) > 1) duration.binding + 1 else 0;
+
+            // NOTE: this relies on private information!
+            if (action.thrashing == .ended) {
+                duration.thrashing =
+                    if (s.active.volatiles.Thrashing) duration.thrashing + 1 else 0;
+            } else {
+                duration.thrashing =
+                    if (@intFromEnum(action.thrashing) > 1) duration.thrashing + 1 else 0;
+            }
+
+            _ = q;
+        }
+    }
+
+    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 });
     }
 };
 
-/// 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(u16) {
-    /// 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.
+/// TODO
+pub const Duration = struct {
+    sleeps: [6]u3 = .{0} ** 6,
     confusion: u3 = 0,
-    /// 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.
+    bide: u3 = 0,
+    thrashing: u3 = 0,
     binding: u3 = 0,
 
-    pub const Field = std.meta.FieldEnum(Duration);
+    pub fn format(
+        self: Duration,
+        comptime fmt: []const u8,
+        opts: std.fmt.FormatOptions,
+        writer: anytype,
+    ) !void {
+        _ = .{ fmt, opts };
+        try writer.writeByte('(');
+        var printed = false;
+        inline for (@typeInfo(Duration).Struct.fields) |field| {
+            const val = @field(self, field.name);
+            switch (@typeInfo(@TypeOf(val))) {
+                .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(", ");
+                        try writer.print("{s}:[", .{field.name});
+                        for (val, 0..) |v, i| {
+                            if (i != 0) try writer.writeByte(',');
+                            try writer.print("{d}", .{v});
+                        }
+                        try writer.writeAll("]");
+                        printed = true;
+                    }
+                },
+                else => unreachable,
+            }
+        }
+        try writer.writeByte(')');
+    }
 };
 
-pub const Commit = enum { hit, miss, binding };
+pub const Commit = enum { hit, miss };
+
+const uN = if (options.miss) u8 else u9;
 
 /// Tracks chance actions and their associated probability during a Generation I battle update when
 /// `options.chance` is enabled.
@@ -266,14 +321,6 @@ 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 },
-
         // In many cases on both the cartridge and on Pokémon Showdown rolls are made even though
         // later checks render their result irrelevant (missing when the target is actually immune,
         // rolling for damage when the move is later revealed to have missed, etc). We can't reorder
@@ -290,16 +337,12 @@ pub fn Chance(comptime Rational: type) type {
         //
         // Finally, because each player's actions are processed sequentially we only need a single
         // shared structure to track this information (though it needs to be cleared appropriately)
-        pending: if (showdown) struct {
-            hit: bool = false,
-            hit_probablity: u8 = 0,
-        } else struct {
+        pending: if (showdown) struct {} else struct {
             crit: bool = false,
             crit_probablity: u8 = 0,
             damage_roll: u8 = 0,
             hit: bool = false,
-            hit_probablity: u8 = 0,
-            binding: u8 = 0,
+            hit_probablity: uN = 0,
         } = .{},
 
         /// Possible error returned by operations tracking chance probability.
@@ -307,25 +350,19 @@ pub fn Chance(comptime Rational: type) type {
 
         /// Convenience helper to clear fields which typically should be cleared between updates.
         pub fn reset(self: *Self) void {
+            if (!enabled) return;
+
             self.probability.reset();
-            self.actions.reset();
+            self.actions = .{};
             self.pending = .{};
         }
 
         pub fn commit(self: *Self, player: Player, kind: Commit) Error!void {
-            var action = self.actions.get(player);
+            if (!enabled) return;
 
-            // We need to handle binding specially because we still need to commit it when attacking
-            // into a Pokémon that is immune
-            if (!showdown) {
-                if (kind != .miss and self.pending.binding != 0) {
-                    assert(action.duration == 0);
-                    action.duration = @intCast(self.pending.binding);
-                    assert(action.durations.binding == 0);
-                    action.durations.binding = 1;
-                }
-                if (kind == .binding) return;
-            } else assert(kind != .binding);
+            assert(!showdown);
+
+            var action = self.actions.get(player);
 
             // 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)
@@ -334,19 +371,19 @@ pub fn Chance(comptime Rational: type) type {
                 action.hit = if (self.pending.hit) .true else .false;
             }
 
-            if (showdown) return;
-
-            // If the move actually lands we can commit any past critical hit / damage rolls. We
-            // avoid updating anything if there wasn't a damage roll as any "critical hit" not tied
-            // to a damage roll is actually a no-op
-            if (kind == .hit and self.pending.damage_roll > 0) {
-                assert(!self.pending.crit or self.pending.crit_probablity > 0);
+            // 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
+            // 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);
 
-                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;
-                }
+            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;
+            }
 
+            if (self.pending.damage_roll > 0) {
                 try self.probability.update(1, 39);
                 action.damage = self.pending.damage_roll;
             }
@@ -358,37 +395,6 @@ pub fn Chance(comptime Rational: type) type {
             self.pending = .{};
         }
 
-        pub fn clearDurations(self: *Self, player: Player, haze: ?bool) void {
-            if (!enabled) return;
-
-            var action = self.actions.get(player);
-            if (haze) |status| {
-                if (status) action.durations.sleep = 0;
-                action.durations.confusion = 0;
-                action.durations.disable = 0;
-            } else {
-                action.durations.attacking = 0;
-                action.durations.binding = 0;
-            }
-        }
-
-        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.actions.get(player.foe()).durations.binding = 0;
-        }
-
         pub fn speedTie(self: *Self, p1: bool) Error!void {
             if (!enabled) return;
 
@@ -397,12 +403,17 @@ pub fn Chance(comptime Rational: type) type {
             self.actions.p2.speed_tie = self.actions.p1.speed_tie;
         }
 
-        pub fn hit(self: *Self, ok: bool, accuracy: u8) void {
+        pub fn hit(self: *Self, player: Player, ok: bool, accuracy: uN) Error!void {
             if (!enabled) return;
 
             const p = if (ok) accuracy else @as(u8, @intCast(256 - @as(u9, accuracy)));
-            self.pending.hit = ok;
-            self.pending.hit_probablity = p;
+            if (showdown) {
+                try self.probability.update(p, 256);
+                self.actions.get(player).hit = if (ok) .true else .false;
+            } else {
+                self.pending.hit = ok;
+                self.pending.hit_probablity = p;
+            }
         }
 
         pub fn criticalHit(self: *Self, player: Player, crit: bool, rate: u8) Error!void {
@@ -480,109 +491,21 @@ 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;
-
-            if (!showdown and field == .binding) {
-                self.pending.binding = if (options.key) 1 else turns;
-            } else {
-                var durations = &self.actions.get(target).durations;
-                assert(@field(durations, @tagName(field)) == 0 or
-                    (field == .confusion and player == target));
-                @field(durations, @tagName(field)) = 1;
-                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 <= 7);
-                if (n != 7) try self.probability.update(1, 8 - @as(u4, n));
-                durations.sleep = 0;
-            } else {
-                assert(n >= 1 and n < 7);
-                try self.probability.update(8 - @as(u4, n) - 1, 8 - @as(u4, n));
-                durations.sleep += 1;
-            }
-        }
-
-        pub fn confusion(self: *Self, player: Player, turns: u4) Error!void {
+        pub fn duration(self: *Self, player: Player, turns: u4) void {
             if (!enabled) return;
 
-            var durations = &self.actions.get(player).durations;
-            const n = durations.confusion;
-            if (turns == 0) {
-                assert(n >= 2 and n <= 5);
-                if (n != 5) try self.probability.update(1, 6 - @as(u4, n));
-                durations.confusion = 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.confusion += 1;
-            }
+            self.actions.get(player).duration = if (options.key) 1 else turns;
         }
 
-        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;
-            if (turns == 0) {
-                assert(n >= 1 and n <= 8);
-                if (n != 8) try self.probability.update(1, 9 - @as(u4, n));
-                durations.disable = 0;
-            } else {
-                assert(n >= 1 and n < 8);
-                try self.probability.update(9 - @as(u4, n) - 1, 9 - @as(u4, n));
-                durations.disable += 1;
-            }
-        }
-
-        pub fn attacking(self: *Self, player: Player, turns: u4) Error!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 {
+        pub fn durations(
+            self: *Self,
+            comptime f: Action.Field,
+            player: Player,
+            observation: Optional(Observation),
+        ) void {
             if (!enabled) return;
 
-            var durations = &self.actions.get(player).durations;
-            const n = durations.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 (turns == 0) {
-                assert(n >= 1 and n <= 4);
-                if (n != 4) try self.probability.update(p, q);
-                durations.binding = 0;
-            } else {
-                assert(n >= 1 and n < 4);
-                try self.probability.update(q - p, q);
-                durations.binding += 1;
-            }
+            @field(self.actions.get(player), @tagName(f)) = observation;
         }
 
         pub fn psywave(self: *Self, player: Player, power: u8, max: u8) Error!void {
@@ -620,19 +543,25 @@ test "Chance.speedTie" {
 test "Chance.hit" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
-    chance.hit(true, 229);
-    try expectProbability(&chance.probability, 1, 1);
-    try expectValue(Optional(bool).None, chance.actions.p1.hit);
-    try chance.commit(.P1, .hit);
+    try chance.hit(.P1, true, 229);
+    if (!showdown) {
+        try expectProbability(&chance.probability, 1, 1);
+        try expectValue(Optional(bool).None, chance.actions.p1.hit);
+
+        try chance.commit(.P1, .hit);
+    }
     try expectValue(Optional(bool).true, chance.actions.p1.hit);
     try expectProbability(&chance.probability, 229, 256);
 
     chance.reset();
 
-    chance.hit(false, 255);
-    try expectProbability(&chance.probability, 1, 1);
-    try expectValue(Optional(bool).None, chance.actions.p2.hit);
-    try chance.commit(.P2, .miss);
+    try chance.hit(.P2, false, 255);
+    if (!showdown) {
+        try expectProbability(&chance.probability, 1, 1);
+        try expectValue(Optional(bool).None, chance.actions.p2.hit);
+
+        try chance.commit(.P2, .miss);
+    }
     try expectValue(Optional(bool).false, chance.actions.p2.hit);
     try expectProbability(&chance.probability, 1, 256);
 }
@@ -648,26 +577,18 @@ test "Chance.criticalHit" {
         try expectProbability(&chance.probability, 1, 1);
         try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
 
-        try chance.commit(.P1, .hit);
-        try expectProbability(&chance.probability, 1, 1);
-        try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
+        try chance.hit(.P1, true, 128);
 
-        chance.hit(true, 128);
-
-        try chance.commit(.P1, .hit);
-        try expectProbability(&chance.probability, 1, 2);
+        try expectProbability(&chance.probability, 1, 1);
         try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
 
-        chance.probability.reset();
         try chance.damage(.P1, 217);
 
-        try chance.commit(.P1, .miss);
-        try expectProbability(&chance.probability, 1, 2);
+        try expectProbability(&chance.probability, 1, 1);
         try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
 
-        chance.probability.reset();
-
         try chance.commit(.P1, .hit);
+
         try expectProbability(&chance.probability, 17, 19968); // (1/2) * (17/256) * (1/39)
         try expectValue(Optional(bool).true, chance.actions.p1.critical_hit);
     }
@@ -682,20 +603,14 @@ test "Chance.criticalHit" {
         try expectProbability(&chance.probability, 1, 1);
         try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
 
-        try chance.commit(.P1, .hit);
-        try expectProbability(&chance.probability, 1, 1);
-        try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
-
-        chance.hit(true, 128);
+        try chance.hit(.P1, true, 128);
 
-        try chance.commit(.P1, .hit);
-        try expectProbability(&chance.probability, 1, 2);
+        try expectProbability(&chance.probability, 1, 1);
         try expectValue(Optional(bool).None, chance.actions.p1.critical_hit);
 
-        chance.probability.reset();
         try chance.damage(.P1, 217);
-
         try chance.commit(.P1, .hit);
+
         try expectProbability(&chance.probability, 251, 19968); // (1/2) * (251/256) * (1/39)
         try expectValue(Optional(bool).false, chance.actions.p1.critical_hit);
     }
@@ -706,19 +621,16 @@ test "Chance.damage" {
 
     try chance.damage(.P1, 217);
     if (showdown) {
-        try expectValue(@as(u8, 217), chance.actions.p1.damage);
+        try expectValue(217, chance.actions.p1.damage);
         try expectProbability(&chance.probability, 1, 39);
     } else {
         try expectProbability(&chance.probability, 1, 1);
-        try expectValue(@as(u8, 0), chance.actions.p1.damage);
-
-        try chance.commit(.P1, .miss);
-        try expectProbability(&chance.probability, 1, 1);
-        try expectValue(@as(u8, 0), chance.actions.p1.damage);
+        try expectValue(0, chance.actions.p1.damage);
 
         try chance.commit(.P1, .hit);
+
         try expectProbability(&chance.probability, 1, 39);
-        try expectValue(@as(u8, 217), chance.actions.p1.damage);
+        try expectValue(217, chance.actions.p1.damage);
     }
 }
 
@@ -770,13 +682,13 @@ test "Chance.moveSlot" {
 
     try chance.moveSlot(.P2, 2, &ms, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(@as(u4, 2), chance.actions.p2.move_slot);
+    try expectValue(2, chance.actions.p2.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 1, &ms, 0);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(@as(u4, 1), chance.actions.p1.move_slot);
+    try expectValue(1, chance.actions.p1.move_slot);
 }
 
 test "Chance.multiHit" {
@@ -784,149 +696,25 @@ test "Chance.multiHit" {
 
     try chance.multiHit(.P1, 3);
     try expectProbability(&chance.probability, 3, 8);
-    try expectValue(@as(u4, 3), chance.actions.p1.multi_hit);
+    try expectValue(3, chance.actions.p1.multi_hit);
 
     chance.reset();
 
     try chance.multiHit(.P2, 5);
     try expectProbability(&chance.probability, 1, 8);
-    try expectValue(@as(u4, 5), chance.actions.p2.multi_hit);
+    try expectValue(5, chance.actions.p2.multi_hit);
 }
 
 test "Chance.duration" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
-    chance.duration(.sleep, .P1, .P2, 2);
-    try expectValue(@as(u4, 2), chance.actions.p1.duration);
-    try expectValue(@as(u3, 1), chance.actions.p2.durations.sleep);
+    chance.duration(.P1, 2);
+    try expectValue(2, chance.actions.p1.duration);
 
     chance.reset();
 
-    chance.duration(.binding, .P2, .P2, 4);
-    if (!showdown) {
-        try expectValue(@as(u4, 0), chance.actions.p2.duration);
-        try expectValue(@as(u3, 0), chance.actions.p2.durations.binding);
-        try chance.commit(.P2, .hit);
-    }
-    try expectValue(@as(u4, 4), chance.actions.p2.duration);
-    try expectValue(@as(u3, 1), chance.actions.p2.durations.binding);
-}
-
-test "Chance.sleep" {
-    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
-
-    for ([_]u8{ 7, 6, 5, 4, 3, 2, 1 }, 1..8) |d, i| {
-        chance.actions.p1.durations.sleep = @intCast(i);
-        try chance.sleep(.P1, 0);
-        try expectProbability(&chance.probability, 1, d);
-        try expectValue(@as(u3, 0), chance.actions.p1.durations.sleep);
-
-        chance.reset();
-
-        if (i < 7) {
-            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 = .{} };
-
-    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(@as(u3, 0), chance.actions.p2.durations.confusion);
-
-            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);
-
-            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.actions.p1.durations.disable = @intCast(i);
-        try chance.disable(.P1, 0);
-        try expectProbability(&chance.probability, 1, d);
-        try expectValue(@as(u4, 0), chance.actions.p1.durations.disable);
-
-        chance.reset();
-
-        if (i < 8) {
-            chance.actions.p1.durations.disable = @intCast(i);
-            try chance.disable(.P1, 1);
-            try expectProbability(&chance.probability, d - 1, d);
-            try expectValue(@as(u4, @intCast(i)) + 1, chance.actions.p1.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(@as(u3, 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 = .{} };
-
-    const ps = [_]u8{ 3, 3, 1, 1 };
-    const qs = [_]u8{ 8, 5, 2, 1 };
-
-    for (ps, qs, 1..5) |p, q, i| {
-        chance.actions.p1.durations.binding = @intCast(i);
-        try chance.binding(.P1, 0);
-        try expectProbability(&chance.probability, p, q);
-        try expectValue(@as(u3, 0), chance.actions.p1.durations.binding);
-
-        chance.reset();
-
-        if (i < 4) {
-            chance.actions.p1.durations.binding = @intCast(i);
-            try chance.binding(.P1, 1);
-            try expectProbability(&chance.probability, q - p, q);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p1.durations.binding);
-
-            chance.reset();
-        }
-    }
+    chance.duration(.P2, 4);
+    try expectValue(4, chance.actions.p2.duration);
 }
 
 test "Chance.psywave" {
@@ -934,7 +722,7 @@ test "Chance.psywave" {
 
     try chance.psywave(.P2, 100, 150);
     try expectProbability(&chance.probability, 1, 150);
-    try expectValue(@as(u8, 101), chance.actions.p2.psywave);
+    try expectValue(101, chance.actions.p2.psywave);
 }
 
 test "Chance.metronome" {
@@ -976,10 +764,6 @@ const Null = struct {
         _ = .{self};
     }
 
-    pub fn clearDurations(self: Null, player: Player, haze: ?bool) void {
-        _ = .{ self, player, haze };
-    }
-
     pub fn switched(self: Null, player: Player, in: u8, out: u8) void {
         _ = .{ self, player, in, out };
     }
@@ -988,8 +772,8 @@ const Null = struct {
         _ = .{ self, p1 };
     }
 
-    pub fn hit(self: Null, ok: bool, accuracy: u8) void {
-        _ = .{ self, ok, accuracy };
+    pub fn hit(self: Null, player: Player, ok: bool, accuracy: uN) Error!void {
+        _ = .{ self, player, ok, accuracy };
     }
 
     pub fn criticalHit(self: Null, player: Player, crit: bool, rate: u8) Error!void {
@@ -1020,33 +804,16 @@ const Null = struct {
         _ = .{ self, player, n };
     }
 
-    pub fn duration(
+    pub fn durations(
         self: Null,
-        comptime field: Duration.Field,
+        comptime f: Action.Field,
         player: Player,
-        target: Player,
-        turns: u4,
+        observation: Optional(Observation),
     ) void {
-        _ = .{ self, field, player, target, turns };
-    }
-
-    pub fn sleep(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 confusion(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 };
+        _ = .{ self, f, player, observation };
     }
 
-    pub fn binding(self: Null, player: Player, turns: u4) Error!void {
+    pub fn duration(self: Null, player: Player, turns: u4) void {
         _ = .{ self, player, turns };
     }