@pkmn/engine 0.1.0-dev.305a932f → 0.1.0-dev.32adfe77

package/src/lib/common/rational.zig

@@ -44,7 +44,7 @@ pub fn Rational(comptime T: type) type {
         /// Both p and q must be >= 1, and if computable at comptime must have no common factors.
         pub fn update(r: *Self, p: anytype, q: anytype) Error!void {
             // FIXME
-            // std.debug.print("({d}/{d}) * ", .{p, q});
+            // std.debug.print("({d}/{d}) * ", .{ p, q });
             assert(p >= 1);
             assert(q >= 1);
 
@@ -185,16 +185,16 @@ pub fn Rational(comptime T: type) type {
             try writer.print("{d}/{d}", .{ self.p, self.q });
         }
 
-        inline fn multiplication(r: *Self, p: anytype, q: anytype) !void {
+        fn multiplication(r: *Self, p: anytype, q: anytype) !void {
             r.p = try std.math.mul(T, r.p, p);
             r.q = try std.math.mul(T, r.q, q);
         }
 
-        inline fn addition(r: *Self, p: anytype, q: anytype) !void {
+        fn addition(r: *Self, p: anytype, q: anytype) !void {
             // (a/b) + (c/d) = (ad+bc)/(bd)
-            var d = try std.math.mul(T, r.q, q);
-            var n1 = try std.math.mul(T, r.p, q);
-            var n2 = try std.math.mul(T, r.q, p);
+            const d = try std.math.mul(T, r.q, q);
+            const n1 = try std.math.mul(T, r.p, q);
+            const n2 = try std.math.mul(T, r.q, p);
 
             r.p = try std.math.add(T, n1, n2);
             r.q = d;
@@ -203,7 +203,7 @@ pub fn Rational(comptime T: type) type {
 }
 
 // https://en.wikipedia.org/wiki/Euclidean_algorithm
-inline fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
+fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
     assert(p >= 1);
     assert(q >= 1);
 
@@ -234,6 +234,8 @@ test Rational {
         var r: Rational(t) = .{};
 
         var c: t = 128;
+        _ = &c;
+
         try r.update(c, 256);
         try doTurn(&r);
 
@@ -320,6 +322,8 @@ test BigRational {
     try r.reset();
 
     var c: u8 = 128;
+    _ = &c;
+
     try r.update(c, 256);
     try doTurn(&r);
 

package/src/lib/common/rng.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-const options = @import("./options.zig");
+const options = @import("options.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
@@ -25,6 +25,11 @@ pub fn PRNG(comptime gen: comptime_int) type {
         pub fn next(self: *Self) Output(gen) {
             return self.src.next();
         }
+
+        pub fn advance(self: *Self, n: usize) void {
+            if (!options.advance) return;
+            for (0..n) |_| self.src.advance();
+        }
     };
 }
 
@@ -61,11 +66,15 @@ pub const PSRNG = extern struct {
             (@as(u64, self.range(u16, 0, 0x10000)) << 16) |
             (@as(u64, self.range(u16, 0, 0x10000)));
     }
+
+    pub fn Bound(comptime T: type) type {
+        return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
+    }
 };
 
 test PSRNG {
     var psrng: PSRNG = .{ .src = .{ .seed = 0x0001000200030004 } };
-    try expectEqual(@as(u8, 121), psrng.range(u8, 0, 256));
+    try expectEqual(121, psrng.range(u8, 0, 256));
     try expectEqual(false, psrng.chance(u8, 128, 256)); // 226 < 128
 }
 
@@ -89,6 +98,10 @@ pub const Gen12 = extern struct {
         self.index = (self.index + 1) % 9;
         return val;
     }
+
+    pub fn advance(self: *Gen12) void {
+        _ = self.next();
+    }
 };
 
 test Gen12 {
@@ -98,9 +111,9 @@ test Gen12 {
         try expectEqual(e, rng.next());
     }
 
-    try expectEqual(@as(u8, 16), Gen12.percent(6) + 1);
-    try expectEqual(@as(u8, 16), Gen12.percent(7) - 1);
-    try expectEqual(@as(u8, 128), Gen12.percent(50) + 1);
+    try expectEqual(16, Gen12.percent(6) + 1);
+    try expectEqual(16, Gen12.percent(7) - 1);
+    try expectEqual(128, Gen12.percent(50) + 1);
 }
 
 // https://pkmn.cc/pokeemerald/src/random.c
@@ -188,7 +201,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             for (0..n) |_| _ = self.next();
         }
 
-        pub fn range(self: *Self, comptime T: type, from: T, to: Bound(T)) T {
+        pub fn range(self: *Self, comptime T: type, from: T, to: PSRNG.Bound(T)) T {
             assert(showdown);
             return @intCast(@as(u64, self.next()) * (to - from) / divisor + from);
         }
@@ -197,7 +210,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             self: *Self,
             comptime T: type,
             numerator: T,
-            denominator: Bound(T),
+            denominator: PSRNG.Bound(T),
         ) bool {
             assert(showdown);
             assert(denominator > 0);
@@ -228,7 +241,3 @@ fn Output(comptime gen: comptime_int) type {
         else => unreachable,
     };
 }
-
-fn Bound(comptime T: type) type {
-    return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
-}

package/src/lib/gen1/README.md

@@ -427,34 +427,34 @@ data in the browser for ease of debugging.
 
 > **NOTE:** The offsets in the following table represent *bits* and **not** bytes.
 
-| Start | End | Data                | Description                                                 |
-| ----- | --- | ------------------- | ----------------------------------------------------------- |
-| 0     | 1   | `Bide`              | Whether the "Bide" volatile status is present               |
-| 1     | 2   | `Thrashing`         | Whether the "Thrashing" volatile status is present          |
-| 2     | 3   | `MultiHit`          | Whether the "MultiHit" volatile status is present           |
-| 3     | 4   | `Flinch`            | Whether the "Flinch" volatile status is present             |
-| 4     | 5   | `Charging`          | Whether the "Charging" volatile status is present           |
-| 5     | 6   | `Binding`           | Whether the "Binding" volatile status is present            |
-| 6     | 7   | `Invulnerable`      | Whether the "Invulnerable" volatile status is present       |
-| 7     | 8   | `Confusion`         | Whether the "Confusion" volatile status is present          |
-| 8     | 9   | `Mist`              | Whether the "Mist" volatile status is present               |
-| 9     | 10  | `FocusEnergy`       | Whether the "FocusEnergy" volatile status is present        |
-| 10    | 11  | `Substitute`        | Whether the "Substitute" volatile status is present         |
-| 11    | 12  | `Recharging`        | Whether the "Recharging" volatile status is present         |
-| 12    | 13  | `Rage`              | Whether the "Rage" volatile status is present               |
-| 13    | 14  | `LeechSeed`         | Whether the "LeechSeed" volatile status is present          |
-| 14    | 15  | `Toxic`             | Whether the "Toxic" volatile status is present              |
-| 15    | 16  | `LightScreen`       | Whether the "LightScreen" volatile status is present        |
-| 16    | 17  | `Reflect`           | Whether the "Reflect" volatile status is present            |
-| 17    | 18  | `Transform`         | Whether the "Transform" volatile status is present          |
-| 18    | 21  | `confusion`         | The remaining turns of confusion                            |
-| 21    | 24  | `attacks`           | The number of attacks remaining                             |
-| 24    | 40  | `state`             | A union of either: <ul><li>the total accumulated damage from Bide</li><li>the overwritten accuracy of certain moves</li></ul> |
-| 40    | 48  | `substitute`        | The remaining HP of the Substitute                          |
-| 48    | 52  | `transform`         | The identity of whom the active Pokémon is transformed into |
-| 52    | 56  | `disabled_duration` | The remaining turns the move is disabled                    |
-| 56    | 59  | `disabled_move`     | The move slot (1-4) that's disabled                        |
-| 59    | 64  | `toxic`             | The number of turns toxic damage has been accumulating      |
+| Start | End | Data               | Description                                                 |
+| ----- | --- | -------------------| ----------------------------------------------------------- |
+| 0     | 1   | `Bide`             | Whether the "Bide" volatile status is present               |
+| 1     | 2   | `Thrashing`        | Whether the "Thrashing" volatile status is present          |
+| 2     | 3   | `MultiHit`         | Whether the "MultiHit" volatile status is present           |
+| 3     | 4   | `Flinch`           | Whether the "Flinch" volatile status is present             |
+| 4     | 5   | `Charging`         | Whether the "Charging" volatile status is present           |
+| 5     | 6   | `Binding`          | Whether the "Binding" volatile status is present            |
+| 6     | 7   | `Invulnerable`     | Whether the "Invulnerable" volatile status is present       |
+| 7     | 8   | `Confusion`        | Whether the "Confusion" volatile status is present          |
+| 8     | 9   | `Mist`             | Whether the "Mist" volatile status is present               |
+| 9     | 10  | `FocusEnergy`      | Whether the "FocusEnergy" volatile status is present        |
+| 10    | 11  | `Substitute`       | Whether the "Substitute" volatile status is present         |
+| 11    | 12  | `Recharging`       | Whether the "Recharging" volatile status is present         |
+| 12    | 13  | `Rage`             | Whether the "Rage" volatile status is present               |
+| 13    | 14  | `LeechSeed`        | Whether the "LeechSeed" volatile status is present          |
+| 14    | 15  | `Toxic`            | Whether the "Toxic" volatile status is present              |
+| 15    | 16  | `LightScreen`      | Whether the "LightScreen" volatile status is present        |
+| 16    | 17  | `Reflect`          | Whether the "Reflect" volatile status is present            |
+| 17    | 18  | `Transform`        | Whether the "Transform" volatile status is present          |
+| 18    | 21  | `confusion`        | The remaining turns of confusion                            |
+| 21    | 24  | `attacks`          | The number of attacks remaining                             |
+| 24    | 40  | `state`            | A union of either: <ul><li>the total accumulated damage from Bide</li><li>the overwritten accuracy of certain moves</li></ul> |
+| 40    | 48  | `substitute`       | The remaining HP of the Substitute                          |
+| 48    | 52  | `transform`        | The identity of whom the active Pokémon is transformed into |
+| 52    | 56  | `disable_duration` | The remaining turns the move is disabled                    |
+| 56    | 59  | `disable_move`     | The move slot (1-4) that's disabled                         |
+| 59    | 64  | `toxic`            | The number of turns toxic damage has been accumulating      |
 
 ### `Pokemon`
 

package/src/lib/gen1/calc.zig

@@ -50,7 +50,7 @@ pub const Summaries = extern struct {
     }
 
     /// Returns the `Summary` for the given `player`.
-    pub inline fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Summary) {
+    pub fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Summary) {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == Summaries);
         return if (player == .P1) &self.p1 else &self.p2;
     }
@@ -211,8 +211,8 @@ pub fn transitions(
 ) !?Stats {
     var stats: Stats = .{};
 
-    var actions = options.actions;
-    var cap = options.cap;
+    const actions = options.actions;
+    const cap = options.cap;
 
     var seen = std.AutoHashMap(Actions, void).init(allocator);
     defer seen.deinit();
@@ -232,8 +232,8 @@ pub fn transitions(
     _ = try b.update(c1, c2, &opts);
     stats.updates += 1;
 
-    var p1 = b.side(.P1);
-    var p2 = b.side(.P2);
+    const p1 = b.side(.P1);
+    const p2 = b.side(.P2);
 
     var p: Rational(u128) = .{ .p = 0, .q = 1 };
     try frontier.append(opts.chance.actions);
@@ -247,7 +247,7 @@ pub fn transitions(
     var i: usize = 0;
     assert(frontier.items.len == 1);
     while (i < frontier.items.len) : (i += 1) {
-        var template = frontier.items[i];
+        const template = frontier.items[i];
         opts.calc.overrides.durations = .{
             .p1 = template.p1.durations,
             .p2 = template.p2.durations,
@@ -387,7 +387,7 @@ pub fn transitions(
     return stats;
 }
 
-inline fn matches(actions: Actions, i: usize, frontier: []Actions) bool {
+fn matches(actions: Actions, i: usize, frontier: []Actions) bool {
     for (frontier, 0..) |f, j| {
         // TODO: is skipping this redundant check worth it?
         if (i == j) continue;

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));
     }
 
@@ -157,7 +159,7 @@ pub const Action = packed struct(u64) {
     pub const Field = std.meta.FieldEnum(Action);
 
     /// 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);
     }
 
@@ -514,22 +516,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;
 
@@ -546,6 +532,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;
 
@@ -593,7 +595,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;
         }
     };
@@ -704,19 +706,19 @@ 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, .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);
     }
 }
 
@@ -768,13 +770,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" {
@@ -782,32 +784,32 @@ 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" {
@@ -817,7 +819,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();
 
@@ -832,28 +834,6 @@ test "Chance.sleep" {
     }
 }
 
-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.confusion" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
@@ -862,7 +842,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();
         }
@@ -878,6 +858,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 = .{} };
 
@@ -886,7 +888,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();
         }
@@ -912,7 +914,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();
 
@@ -932,7 +934,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" {
@@ -998,10 +1000,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 };
     }
@@ -1010,6 +1008,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 };
     }

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

@@ -1,4 +1,4 @@
-//! Code generated by `tools/generate` - manual edits will be overwritten
+//! Code generated by `tools/generate` - manual edits will be overwritten.
 
 const std = @import("std");
 
@@ -1599,43 +1599,43 @@ pub const Move = enum(u8) {
         }
 
         /// Whether this effect activates during the "begin" step of move execution.
-        pub inline fn onBegin(effect: Effect) bool {
+        pub fn onBegin(effect: Effect) bool {
             return @intFromEnum(effect) > 0 and @intFromEnum(effect) <= 16;
         }
 
         /// Whether this effect lowers stats.
-        pub inline fn isStatDown(effect: Effect) bool {
+        pub fn isStatDown(effect: Effect) bool {
             return @intFromEnum(effect) > 16 and @intFromEnum(effect) <= 21;
         }
 
         /// Whether this effect activates during the "end" step of move execution.
-        pub inline fn onEnd(effect: Effect) bool {
+        pub fn onEnd(effect: Effect) bool {
             return @intFromEnum(effect) > 16 and @intFromEnum(effect) <= 31;
         }
 
         /// Whether this effect is considered to "always happen".
-        pub inline fn alwaysHappens(effect: Effect) bool {
+        pub fn alwaysHappens(effect: Effect) bool {
             return @intFromEnum(effect) > 31 and @intFromEnum(effect) <= 38;
         }
 
         /// Whether this effect is handled specially by the engine.
-        pub inline fn isSpecial(effect: Effect) bool {
+        pub fn isSpecial(effect: Effect) bool {
             // NB: isSpecial includes isMulti up to Twineedle
             return @intFromEnum(effect) > 31 and @intFromEnum(effect) <= 46;
         }
 
         /// Whether this effect is a multi-hit effect.
-        pub inline fn isMulti(effect: Effect) bool {
+        pub fn isMulti(effect: Effect) bool {
             return @intFromEnum(effect) > 44 and @intFromEnum(effect) <= 47;
         }
 
         /// Whether this effect is has chance of lowering stats.
-        pub inline fn isStatDownChance(effect: Effect) bool {
+        pub fn isStatDownChance(effect: Effect) bool {
             return @intFromEnum(effect) > 47 and @intFromEnum(effect) <= 51;
         }
 
         /// Whether this effect has a secondary chance.
-        pub inline fn isSecondaryChance(effect: Effect) bool {
+        pub fn isSecondaryChance(effect: Effect) bool {
             // NB: isSecondaryChance includes isStatDownChance as well as Twineedle
             return (@intFromEnum(effect) > 46 and @intFromEnum(effect) <= 61);
         }
@@ -1838,8 +1838,22 @@ pub const Move = enum(u8) {
     /// The number of Pokémon moves in this generation.
     pub const size = 165;
 
+    /// Pokémon moves that can be called by Metronome in this generation.
+    pub const METRONOME = init: {
+        var num = 0;
+        var moves: [163]Move = undefined;
+        for (1..Move.size) |i| {
+            if (i != @intFromEnum(Move.Metronome)) {
+                moves[num] = @enumFromInt(i);
+                num += 1;
+            }
+        }
+        assert(num == moves.len);
+        break :init moves;
+    };
+
     /// Returns the `Data` corresponding to the move.
-    pub inline fn get(id: Move) Data {
+    pub fn get(id: Move) Data {
         assert(id != .None and id != .SKIP_TURN);
         return DATA[@intFromEnum(id) - 1];
     }

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

@@ -1,4 +1,4 @@
-//! Code generated by `tools/generate` - manual edits will be overwritten
+//! Code generated by `tools/generate` - manual edits will be overwritten.
 
 const std = @import("std");
 
@@ -1091,8 +1091,8 @@ pub const Species = enum(u8) {
     /// The number of Pokémon species in this generation.
     pub const size = 151;
 
-    /// The Pokémon's critical hit rate=io out of 256.
-    pub inline fn chance(id: Species) u8 {
+    /// The Pokémon's critical hit ratio out of 256.
+    pub fn chance(id: Species) u8 {
         assert(id != .None);
         return CHANCES[@intFromEnum(id) - 1];
     }