@pkmn/engine 0.1.0-dev.3de821b9 → 0.1.0-dev.3f3af84c

package/src/lib/gen1/chance.zig

@@ -1,26 +1,31 @@
-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;
+
+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
@@ -37,8 +42,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 +56,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 (@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);
 
                 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,6 +72,25 @@ pub const Actions = extern struct {
         return true;
     }
 
+    /// 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: anytype, shape: bool) !void {
         try writer.writeAll("<P1 = ");
         try self.p1.fmt(writer, shape);
@@ -144,15 +168,15 @@ pub const Action = packed struct(u64) {
     /// TODO
     disable: Optional(Observation) = .None,
     /// TODO
-    bide: Optional(Observation) = .None,
+    attacking: Optional(Observation) = .None,
     /// TODO
     binding: Optional(Observation) = .None,
-    /// TODO
-    thrashing: Optional(Observation) = .None,
+
+    _: u1 = 0,
 
     /// 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: u3 = 0,
+    move_slot: u4 = 0,
 
     /// TODO
     pp: u4 = 0,
@@ -175,10 +199,10 @@ pub const Action = packed struct(u64) {
     pub fn fmt(self: Action, writer: anytype, shape: bool) !void {
         try writer.writeByte('(');
         var printed = false;
-        inline for (@typeInfo(Action).Struct.fields) |field| {
+        inline for (@field(@typeInfo(Action), @tagName(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});
@@ -199,7 +223,7 @@ pub const Action = packed struct(u64) {
                     }
                     printed = true;
                 },
-                .Int => if (val != 0) {
+                Int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -216,15 +240,19 @@ 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;
     }
 
@@ -239,15 +267,18 @@ pub const Durations = struct {
     }
 };
 
+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 fn format(
         self: Duration,
         comptime fmt: []const u8,
@@ -257,27 +288,22 @@ pub const Duration = struct {
         _ = .{ fmt, opts };
         try writer.writeByte('(');
         var printed = false;
-        inline for (@typeInfo(Duration).Struct.fields) |field| {
+        inline for (@field(@typeInfo(Duration), @tagName(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,
             }
@@ -365,7 +391,7 @@ 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).
             //
@@ -381,7 +407,7 @@ pub fn Chance(comptime Rational: type) type {
                 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;
             }
@@ -408,14 +434,13 @@ pub fn Chance(comptime Rational: type) type {
 
             var d = self.durations.get(player);
 
-            const out = d.sleeps[0];
-            d.sleeps[0] = d.sleeps[slot - 1];
-            d.sleeps[slot - 1] = out;
+            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.bide = 0;
-            d.thrashing = 0;
+            d.attacking = 0;
             d.binding = 0;
 
             self.durations.get(player.foe()).binding = 0;
@@ -544,7 +569,8 @@ pub fn Chance(comptime Rational: type) type {
                 .None => {
                     @field(a, @tagName(field)) = .None;
                     if (field == .sleep) {
-                        self.durations.get(player).sleeps[0] = 0;
+                        var d = self.durations.get(player);
+                        d.sleeps = Sleeps.set(d.sleeps, 0, 0);
                     } else {
                         @field(self.durations.get(player), @tagName(field)) = 0;
                     }
@@ -558,7 +584,8 @@ pub fn Chance(comptime Rational: type) type {
                     });
                     @field(a, @tagName(field)) = .started;
                     if (field == .sleep) {
-                        self.durations.get(player).sleeps[0] = 1;
+                        var d = self.durations.get(player);
+                        d.sleeps = Sleeps.set(d.sleeps, 0, 1);
                     } else {
                         @field(self.durations.get(player), @tagName(field)) = 1;
                     }
@@ -575,19 +602,19 @@ pub fn Chance(comptime Rational: type) type {
             a.sleep = obs;
 
             var d = self.durations.get(player);
-            const n = d.sleeps[0];
+            const n = Sleeps.get(d.sleeps, 0);
 
             if (obs == .None) {
-                d.sleeps[0] = 0;
+                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[0] = 0;
+                d.sleeps = Sleeps.set(d.sleeps, 0, 0);
             } else {
                 assert(obs == .continuing);
                 assert(n >= 1 and n < 7);
                 try self.probability.update(8 - @as(u4, n) - 1, 8 - @as(u4, n));
-                d.sleeps[0] += 1;
+                d.sleeps = Sleeps.set(d.sleeps, 0, n + 1);
             }
         }
 
@@ -635,38 +662,25 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn bide(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
-            return self.attacking(.bide, player, obs);
-        }
-
-        pub fn thrashing(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
-            return self.attacking(.thrashing, player, obs);
-        }
-
-        fn attacking(
-            self: *Self,
-            comptime field: Action.Field,
-            player: Player,
-            obs: Optional(Observation),
-        ) Error!void {
+        pub fn attacking(self: *Self, player: Player, obs: Optional(Observation)) Error!void {
             if (!enabled) return;
 
-            const f = @tagName(field);
             var a = self.actions.get(player);
-            assert(@field(a, f) == .None or @field(a, f) == .started);
-            @field(a, f) = obs;
+            assert(a.attacking == .None or a.attacking == .started);
+            a.attacking = obs;
 
             var d = self.durations.get(player);
-            const n = @field(d, f);
+            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));
-                @field(d, f) = 0;
+                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));
-                @field(d, f) += 1;
+                d.attacking += 1;
             }
         }
 
@@ -685,6 +699,7 @@ pub fn Chance(comptime Rational: type) type {
             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;
@@ -710,7 +725,7 @@ pub fn Chance(comptime Rational: type) type {
             self.actions.get(player).metronome = move;
         }
 
-        pub fn incrementPP(self: *Self, player: Player, n: u4) bool {
+        pub fn pp(self: *Self, player: Player, n: u4) bool {
             if (!enabled) return true;
 
             var a = self.actions.get(player);
@@ -818,16 +833,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);
     }
 }
 
@@ -879,13 +894,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(u4, 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(u4, 1), chance.actions.p1.move_slot);
 }
 
 test "Chance.multiHit" {
@@ -893,43 +908,43 @@ 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[0] = @intCast(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(0, chance.durations.p1.sleeps[0]);
+        try expectValue(@as(u3, 0), Sleeps.get(chance.durations.p1.sleeps, 0));
 
         chance.reset();
 
         if (i < 7) {
-            chance.durations.p1.sleeps[0] = @intCast(i);
+            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, chance.durations.p1.sleeps[0]);
+            try expectValue(@as(u3, @intCast(i)) + 1, Sleeps.get(chance.durations.p1.sleeps, 0));
 
             chance.reset();
         }
@@ -944,7 +959,7 @@ test "Chance.confusion" {
             chance.durations.p2.confusion = @intCast(i);
             try chance.confusion(.P2, .ended);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(0, chance.durations.p2.confusion);
+            try expectValue(@as(u3, 0), chance.durations.p2.confusion);
 
             chance.reset();
         }
@@ -967,7 +982,7 @@ test "Chance.disable" {
         chance.durations.p1.disable = @intCast(i);
         try chance.disable(.P1, .ended);
         try expectProbability(&chance.probability, 1, d);
-        try expectValue(0, chance.durations.p1.disable);
+        try expectValue(@as(u4, 0), chance.durations.p1.disable);
 
         chance.reset();
 
@@ -985,25 +1000,23 @@ test "Chance.disable" {
 test "Chance.attacking" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
-    inline for (.{ .bide, .thrashing }) |f| {
-        for ([_]u8{ 1, 2, 1 }, 1..4) |d, i| {
-            if (i > 1) {
-                @field(chance.durations.p2, @tagName(f)) = @intCast(i);
-                try chance.attacking(f, .P2, .ended);
-                try expectProbability(&chance.probability, 1, d);
-                try expectValue(0, @field(chance.durations.p2, @tagName(f)));
+    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();
-            }
+            chance.reset();
+        }
 
-            if (i < 3) {
-                @field(chance.durations.p2, @tagName(f)) = @intCast(i);
-                try chance.attacking(f, .P2, .continuing);
-                try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-                try expectValue(@as(u3, @intCast(i)) + 1, @field(chance.durations.p2, @tagName(f)));
+        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();
-            }
+            chance.reset();
         }
     }
 }
@@ -1018,7 +1031,7 @@ test "Chance.binding" {
         chance.durations.p1.binding = @intCast(i);
         try chance.binding(.P1, .ended);
         try expectProbability(&chance.probability, p, q);
-        try expectValue(0, chance.durations.p1.binding);
+        try expectValue(@as(u3, 0), chance.durations.p1.binding);
 
         chance.reset();
 
@@ -1038,7 +1051,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" {
@@ -1149,11 +1162,7 @@ const Null = struct {
         _ = .{ self, player, obs };
     }
 
-    pub fn bide(self: Null, player: Player, obs: Optional(Observation)) Error!void {
-        _ = .{ self, player, obs };
-    }
-
-    pub fn thrashing(self: Null, player: Player, obs: Optional(Observation)) Error!void {
+    pub fn attacking(self: Null, player: Player, obs: Optional(Observation)) Error!void {
         _ = .{ self, player, obs };
     }
 
@@ -1169,7 +1178,7 @@ const Null = struct {
         _ = .{ self, player, move };
     }
 
-    pub fn incrementPP(self: Null, player: Player, n: u4) bool {
+    pub fn pp(self: Null, player: Player, n: u4) bool {
         _ = .{ self, player, n };
         return true;
     }

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

@@ -1,12 +1,10 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
-const rng = @import("../../common/rng.zig");
 const gen1 = @import("../../gen1/data.zig");
+const rng = @import("../../common/rng.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const percent = rng.Gen12.percent;
 const Type = gen1.Type;
 

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

@@ -1,11 +1,9 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const gen1 = @import("../../gen1/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const Stats = gen1.Stats;
 const Types = gen1.Types;
 

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

@@ -1,8 +1,7 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const gen1 = @import("../../gen1/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
 const Effectiveness = gen1.Effectiveness;