@pkmn/engine 0.1.0-dev.6158d5ad → 0.1.0-dev.62399ed5

package/src/lib/gen1/chance.zig

@@ -14,12 +14,14 @@ const util = @import("../common/util.zig");
 const Player = @import("../common/data.zig").Player;
 const Optional = @import("../common/optional.zig").Optional;
 
-const Move = @import("data.zig").Move;
-const MoveSlot = @import("data.zig").MoveSlot;
+const data = @import("data.zig");
 
 const enabled = options.chance;
 const showdown = options.showdown;
 
+const Move = data.Move;
+const MoveSlot = data.MoveSlot;
+
 /// 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
 /// to the `update` call to override the normal behavior of the RNG in order to force specific
@@ -35,19 +37,19 @@ pub const Actions = extern struct {
     }
 
     /// Returns the `Action` for the given `player`.
-    pub inline fn get(self: anytype, player: Player) util.PointerType(@TypeOf(self), Action) {
+    pub fn get(self: anytype, player: Player) util.PointerType(@TypeOf(self), Action) {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == Actions);
         return if (player == .P1) &self.p1 else &self.p2;
     }
 
     /// Perform a reset by clearing fields which should not persist across updates.
-    pub inline fn reset(self: *Actions) void {
+    pub fn reset(self: *Actions) void {
         self.p1.reset();
         self.p2.reset();
     }
 
     /// Returns true if `a` is equal to `b`.
-    pub inline fn eql(a: Actions, b: Actions) bool {
+    pub fn eql(a: Actions, b: Actions) bool {
         return @as(u128, @bitCast(a)) == @as(u128, @bitCast(b));
     }
 
@@ -90,13 +92,14 @@ pub const Actions = extern struct {
     }
 };
 
+// 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 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 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));
@@ -109,13 +112,13 @@ 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(d.matches(e));
+    // try expect(!d.matches(f));
 }
 
 /// Information about the RNG that was observed during a Generation I battle `update` for a
 /// single player.
-pub const Action = packed struct {
+pub const Action = packed struct(u64) {
     /// If not 0, the roll to be returned Rolls.damage.
     damage: u8 = 0,
 
@@ -156,12 +159,8 @@ pub const Action = packed struct {
 
     pub const Field = std.meta.FieldEnum(Action);
 
-    comptime {
-        assert(@sizeOf(Action) == 8);
-    }
-
     /// Perform a reset by clearing fields which should not persist across updates.
-    pub inline fn reset(self: *Action) void {
+    pub fn reset(self: *Action) void {
         self.* = @bitCast(@as(u64, @bitCast(self.*)) & DURATIONS);
     }
 
@@ -219,7 +218,7 @@ pub const Action = packed struct {
 };
 
 test Action {
-    var a = Action{ .hit = .true, .durations = .{ .sleep = 3 }, .damage = 225 };
+    var a: Action = .{ .hit = .true, .durations = .{ .sleep = 3 }, .damage = 225 };
     a.reset();
 
     try expectEqual(Action{ .hit = .None, .durations = .{ .sleep = 3 }, .damage = 0 }, a);
@@ -239,7 +238,7 @@ pub const Durations = extern struct {
 
 /// 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 {
+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.
@@ -252,14 +251,12 @@ pub const Duration = packed struct {
     binding: u3 = 0,
 
     pub const Field = std.meta.FieldEnum(Duration);
-
-    comptime {
-        assert(@sizeOf(Duration) == 2);
-    }
 };
 
 pub const Commit = enum { hit, miss, binding };
 
+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.
 pub fn Chance(comptime Rational: type) type {
@@ -296,15 +293,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,
+            hit_probablity: uN = 0,
             binding: u8 = 0,
         } = .{},
 
@@ -313,25 +307,29 @@ 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.pending = .{};
         }
 
         pub fn commit(self: *Self, player: Player, kind: Commit) Error!void {
+            if (!enabled) return;
+
+            assert(!showdown);
+
             var action = self.actions.get(player);
 
             // 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);
+            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;
 
             // 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)
@@ -340,19 +338,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. 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 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 (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;
             }
@@ -403,12 +401,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 {
@@ -522,22 +525,6 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        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 confusion(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
@@ -554,6 +541,22 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
+        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;
 
@@ -601,7 +604,7 @@ pub fn Chance(comptime Rational: type) type {
         pub fn metronome(self: *Self, player: Player, move: Move) Error!void {
             if (!enabled) return;
 
-            try self.probability.update(1, Move.size - 2);
+            try self.probability.update(1, Move.METRONOME.len);
             self.actions.get(player).metronome = move;
         }
     };
@@ -626,19 +629,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);
 }
@@ -654,26 +663,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);
-
-        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, .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);
     }
@@ -688,20 +689,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);
     }
@@ -712,19 +707,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);
     }
 }
 
@@ -776,13 +768,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" {
@@ -790,32 +782,33 @@ 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);
+    try expectValue(2, chance.actions.p1.duration);
+    try expectValue(1, chance.actions.p2.durations.sleep);
 
     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 expectValue(0, chance.actions.p2.duration);
+        try expectValue(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);
+    try expectValue(4, chance.actions.p2.duration);
+    try expectValue(1, chance.actions.p2.durations.binding);
 }
 
 test "Chance.sleep" {
@@ -825,7 +818,7 @@ test "Chance.sleep" {
         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);
+        try expectValue(0, chance.actions.p1.durations.sleep);
 
         chance.reset();
 
@@ -848,7 +841,7 @@ test "Chance.confusion" {
             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);
+            try expectValue(0, chance.actions.p2.durations.confusion);
 
             chance.reset();
         }
@@ -864,6 +857,28 @@ test "Chance.confusion" {
     }
 }
 
+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(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 = .{} };
 
@@ -872,7 +887,7 @@ test "Chance.attacking" {
             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);
+            try expectValue(0, chance.actions.p2.durations.attacking);
 
             chance.reset();
         }
@@ -898,7 +913,7 @@ test "Chance.binding" {
         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);
+        try expectValue(0, chance.actions.p1.durations.binding);
 
         chance.reset();
 
@@ -918,7 +933,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" {
@@ -947,7 +962,7 @@ pub fn expectValue(a: anytype, b: anytype) !void {
 
 /// Null object pattern implementation of Generation I `Chance` which does nothing, though chance
 /// tracking should additionally be turned off entirely via `options.chance`.
-pub const NULL = Null{};
+pub const NULL: Null = .{};
 
 const Null = struct {
     pub const Error = error{};
@@ -972,8 +987,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 {
@@ -984,10 +999,6 @@ const Null = struct {
         _ = .{ self, player, roll };
     }
 
-    pub fn secondaryChance(self: Null, player: Player, proc: bool, rate: u8) Error!void {
-        _ = .{ self, player, proc, rate };
-    }
-
     pub fn confused(self: Null, player: Player, ok: bool) Error!void {
         _ = .{ self, player, ok };
     }
@@ -996,6 +1007,10 @@ const Null = struct {
         _ = .{ self, player, ok };
     }
 
+    pub fn secondaryChance(self: Null, player: Player, proc: bool, rate: u8) Error!void {
+        _ = .{ self, player, proc, rate };
+    }
+
     pub fn moveSlot(self: Null, player: Player, slot: u4, ms: []const MoveSlot, n: u4) Error!void {
         _ = .{ self, player, slot, ms, n };
     }