@pkmn/engine 0.1.0-dev.683fba11 → 0.1.0-dev.6b383c80

package/src/lib/gen1/chance.zig

@@ -23,10 +23,6 @@ const PointerType = util.PointerType;
 const print = std.debug.print;
 const showdown = options.showdown;
 
-const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
-const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
-const Struct = if (@hasField(std.builtin.Type, "struct")) .@"struct" else .Struct;
-
 /// 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
@@ -49,22 +45,36 @@ pub const Actions = extern struct {
 
     /// 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));
+        return @as(u64, @bitCast(a.p1)) == @as(u64, @bitCast(b.p1)) and
+            @as(u64, @bitCast(a.p2)) == @as(u64, @bitCast(b.p2));
     }
 
     /// Returns true if `a` has the same "shape" as `b`, where `Actions` are defined to have the
     /// 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 (@field(@typeInfo(Actions), @tagName(Struct)).fields) |player| {
-            inline for (@field(@typeInfo(Action), @tagName(Struct)).fields) |field| {
-                const a_val = @field(@field(a, player.name), field.name);
-                const b_val = @field(@field(b, player.name), field.name);
+        inline for (if (@hasField(@TypeOf(@typeInfo(Actions).@"struct"), "fields"))
+            @typeInfo(Actions).@"struct".fields
+        else
+            @typeInfo(Actions).@"struct".field_names) |player|
+        {
+            const player_name = if (@hasField(@TypeOf(player), "name"))
+                player.name
+            else
+                player;
+            inline for (if (@hasField(@TypeOf(@typeInfo(Action).@"struct"), "fields"))
+                @typeInfo(Action).@"struct".fields
+            else
+                @typeInfo(Action).@"struct".field_names) |field|
+            {
+                const field_name = if (@hasField(@TypeOf(field), "name")) field.name else 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,
                 }
             }
@@ -91,7 +101,7 @@ pub const Actions = extern struct {
         return a;
     }
 
-    pub fn fmt(self: Actions, writer: anytype, shape: bool) !void {
+    pub fn fmt(self: Actions, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeAll("<P1 = ");
         try self.p1.fmt(writer, shape);
         try writer.writeAll(", P2 = ");
@@ -99,8 +109,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);
     }
 };
@@ -124,18 +133,41 @@ test Actions {
 }
 
 /// Observation made about a duration - whether the duration has started, been continued, or ended.
-pub const Observation = enum { started, continuing, ended };
-/// An extension of Observation to account for "hidden" confusion.
-pub const Confusion = enum {
-    started,
-    continuing,
-    ended,
-    /// An indicator that an existing confusion duration has been overwritten by a new confusion
-    /// duration due to a Thrashing move ending. 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,
-};
+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.
@@ -162,26 +194,24 @@ pub const Action = packed struct(u64) {
     duration: u4 = 0,
 
     /// TODO
-    sleep: Optional(Observation) = .None,
+    sleep: Optional(Observation(.sleep)) = .None,
     /// TODO
-    confusion: Optional(Confusion) = .None,
+    confusion: Optional(Observation(.confusion)) = .None,
     /// TODO
-    disable: Optional(Observation) = .None,
+    disable: Optional(Observation(.disable)) = .None,
     /// TODO
-    attacking: Optional(Observation) = .None,
+    attacking: Optional(Observation(.attacking)) = .None,
     /// TODO
-    binding: Optional(Observation) = .None,
-
-    _: u1 = 0,
+    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: u3 = 0,
 
     /// TODO
     pp: u4 = 0,
-    /// If not 0, the value (2-5) to return for Rolls.distribution for multi hit.
-    multi_hit: u4 = 0,
 
     /// If not 0, psywave - 1 should be returned as the damage roll for Rolls.psywave.
     psywave: u8 = 0,
@@ -191,44 +221,45 @@ 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 (@field(@typeInfo(Action), @tagName(Struct)).fields) |field| {
-            const val = @field(self, field.name);
+        inline for (if (@hasField(@TypeOf(@typeInfo(Action).@"struct"), "fields"))
+            @typeInfo(Action).@"struct".fields
+        else
+            @typeInfo(Action).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else 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});
+                        try writer.print("{s}:?", .{field_name});
                     } else if (@TypeOf(val) == Optional(bool)) {
                         try writer.print("{s}{s}", .{
                             if (val == .false) "!" else "",
-                            field.name,
-                        });
-                    } else if (@TypeOf(val) == Optional(Observation) or
-                        @TypeOf(val) == Optional(Confusion))
-                    {
-                        try writer.print("{s}{s}", .{
-                            ([_][]const u8{ "+", "", "-", "#" })[@intFromEnum(val) - 1],
-                            field.name,
+                            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) });
+                        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});
+                        try writer.print("{s}:?", .{field_name});
                     } else {
-                        try writer.print("{s}:{d}", .{ field.name, val });
+                        try writer.print("{s}:{d}", .{ field_name, val });
                     }
                     printed = true;
                 },
@@ -256,14 +287,8 @@ pub const Durations = extern struct {
         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 });
     }
 };
 
@@ -279,29 +304,33 @@ pub const Duration = packed struct(u32) {
 
     _: 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 (@field(@typeInfo(Duration), @tagName(Struct)).fields) |field| {
-            const val = @field(self, field.name);
+        inline for (if (@hasField(@TypeOf(@typeInfo(Duration).@"struct"), "fields"))
+            @typeInfo(Duration).@"struct".fields
+        else
+            @typeInfo(Duration).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else field;
+            const val = @field(self, field_name);
             switch (@typeInfo(@TypeOf(val))) {
-                Int => if (val != 0) {
+                .int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
-                    if (comptime std.mem.eql(u8, field.name, "sleeps")) {
-                        try writer.print("{s}:[", .{field.name});
+                    if (comptime std.mem.eql(u8, field_name, "sleeps")) {
+                        try writer.print("{s}:[", .{field_name});
                         for (0..6) |i| {
                             if (i != 0) try writer.writeByte(',');
                             try writer.print("{d}", .{Sleeps.get(val, i)});
                         }
                         try writer.writeAll("]");
                     } else {
-                        try writer.print("{s}:{d}", .{ field.name, val });
+                        try writer.print("{s}:{d}", .{ field_name, val });
                     }
                     printed = true;
                 },
@@ -552,7 +581,7 @@ pub fn Chance(comptime Rational: type) type {
             self: *Self,
             comptime field: Action.Field,
             player: Player,
-            obs: Optional(Confusion),
+            obs: Optional(Observation(.confusion)),
         ) void {
             if (!enabled) return;
 
@@ -594,7 +623,7 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn sleep(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
+        pub fn sleep(self: *Self, player: Player, obs: Optional(Observation(.sleep))) Error!void {
             if (!enabled) return;
 
             var a = self.actions.get(player);
@@ -618,7 +647,11 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn confusion(self: *Self, player: Player, obs: Optional(Confusion)) Error!void {
+        pub fn confusion(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.confusion)),
+        ) Error!void {
             if (!enabled) return;
 
             var a = self.actions.get(player);
@@ -640,7 +673,11 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn disable(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
+        pub fn disable(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.disable)),
+        ) Error!void {
             if (!enabled) return;
 
             var a = self.actions.get(player);
@@ -662,7 +699,11 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn attacking(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
+        pub fn attacking(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.attacking)),
+        ) Error!void {
             if (!enabled) return;
 
             var a = self.actions.get(player);
@@ -684,7 +725,11 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn binding(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
+        pub fn binding(
+            self: *Self,
+            player: Player,
+            obs: Optional(Observation(.binding)),
+        ) Error!void {
             if (!enabled) return;
 
             var a = self.actions.get(player);
@@ -833,16 +878,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 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);
     }
 }
 
@@ -894,13 +939,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" {
@@ -908,25 +953,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(.P1, 2);
-    try expectValue(@as(u4, 2), chance.actions.p1.duration);
+    try expectValue(2, chance.actions.p1.duration);
 
     chance.reset();
 
     chance.duration(.P2, 4);
-    try expectValue(@as(u4, 4), chance.actions.p2.duration);
+    try expectValue(4, chance.actions.p2.duration);
 }
 
 test "Chance.sleep" {
@@ -936,7 +981,7 @@ test "Chance.sleep" {
         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));
+        try expectValue(0, Sleeps.get(chance.durations.p1.sleeps, 0));
 
         chance.reset();
 
@@ -959,7 +1004,7 @@ test "Chance.confusion" {
             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);
+            try expectValue(0, chance.durations.p2.confusion);
 
             chance.reset();
         }
@@ -982,7 +1027,7 @@ test "Chance.disable" {
         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);
+        try expectValue(0, chance.durations.p1.disable);
 
         chance.reset();
 
@@ -1005,7 +1050,7 @@ test "Chance.attacking" {
             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);
+            try expectValue(0, chance.durations.p2.attacking);
 
             chance.reset();
         }
@@ -1031,7 +1076,7 @@ test "Chance.binding" {
         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);
+        try expectValue(0, chance.durations.p1.binding);
 
         chance.reset();
 
@@ -1051,7 +1096,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" {
@@ -1067,7 +1112,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;
     }
 }
@@ -1145,28 +1190,44 @@ const Null = struct {
         self: Null,
         comptime field: Action.Field,
         player: Player,
-        obs: Optional(Confusion),
+        obs: Optional(Observation(.confusion)),
     ) void {
         _ = .{ self, field, player, obs };
     }
 
-    pub fn sleep(self: Null, player: Player, obs: Optional(Observation)) Error!void {
+    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(Confusion)) Error!void {
+    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)) Error!void {
+    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)) Error!void {
+    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)) Error!void {
+    pub fn binding(
+        self: Null,
+        player: Player,
+        obs: Optional(Observation(.binding)),
+    ) Error!void {
         _ = .{ self, player, obs };
     }
 

package/src/lib/gen1/data/types.zig

@@ -98,7 +98,7 @@ pub const Type = enum(u4) {
         return CHART[@intFromEnum(t1)][@intFromEnum(t2)];
     }
 
-    /// The precedence order of Type `t2` vs. Type `t1`.
+    /// The precedence order of Type `t1` vs. Type `t2`.
     pub fn precedence(t1: Type, t2: Type) u8 {
         for (PRECEDENCE, 0..) |matchup, i| {
             if (matchup.type1 == t1 and matchup.type2 == t2) return @intCast(i);
@@ -108,7 +108,7 @@ pub const Type = enum(u4) {
 };
 
 /// Representation of a Pokémon's typing.
-pub const Types = packed struct {
+pub const Types = packed struct(u8) {
     /// A Pokémon's primary type.
     type1: Type = .Normal,
     /// A Pokémon's secondary type (may be identical to its primary type).