@pkmn/engine 0.1.0-dev.dc33f678 → 0.1.0-dev.dfd46bbb

package/build.zig

@@ -224,30 +224,32 @@ pub fn build(b: *std.Build) !void {
     var benchmark_config = tools;
     benchmark_config.general.optimize = .ReleaseFast;
     benchmark_config.general.strip = true;
-    const benchmark = tool(b, "src/test/benchmark.zig", benchmark_config);
+    const benchmark = try tool(b, "src/test/benchmark.zig", benchmark_config);
 
     var fuzz_config = tools;
     fuzz_config.general.strip = false;
     fuzz_config.tool.name = "fuzz";
-    const fuzz = tool(b, "src/test/fuzz.zig", fuzz_config);
+    const fuzz = try tool(b, "src/test/fuzz.zig", fuzz_config);
 
-    const analyze = tool(b, "src/tools/analyze.zig", tools);
-    const dump = tool(b, "src/tools/dump.zig", tools);
-    const transitions = tool(b, "src/tools/transitions.zig", tools);
+    const analyze = try tool(b, "src/tools/analyze.zig", tools);
+    const dump = try tool(b, "src/tools/dump.zig", tools);
+    const transitions = try tool(b, "src/tools/transitions.zig", tools);
 
     // FIXME: serde randomly fails to build in some release configurations
     var hack = tools;
     if (optimize != .Debug) hack.tool.tests = null;
-    const serde = tool(b, "src/tools/serde.zig", hack);
+    const serde = try tool(b, "src/tools/serde.zig", hack);
 
-    b.step("analyze", "Run LLVM analysis tool").dependOn(&analyze.step);
-    b.step("benchmark", "Run benchmark code").dependOn(&benchmark.step);
-    b.step("dump", "Run protocol dump tool").dependOn(&dump.step);
-    b.step("fuzz", "Run fuzz tester").dependOn(&fuzz.step);
-    b.step("serde", "Run serialization/deserialization tool").dependOn(&serde.step);
+    if (analyze) |t| b.step("analyze", "Run LLVM analysis tool").dependOn(&t.step);
+    if (benchmark) |t| b.step("benchmark", "Run benchmark code").dependOn(&t.step);
+    if (dump) |t| b.step("dump", "Run protocol dump tool").dependOn(&t.step);
+    if (fuzz) |t| b.step("fuzz", "Run fuzz tester").dependOn(&t.step);
+    if (serde) |t| b.step("serde", "Run serialization/deserialization tool").dependOn(&t.step);
     b.step("test", "Run all tests").dependOn(&tests.step);
     b.step("tools", "Install tools").dependOn(&ToolsStep.create(b, &exes).step);
-    b.step("transitions", "Visualize transitions algorithm search").dependOn(&transitions.step);
+    if (transitions) |t| {
+        b.step("transitions", "Visualize transitions algorithm search").dependOn(&t.step);
+    }
 }
 
 fn maybeStrip(
@@ -326,7 +328,11 @@ const ToolConfig = struct {
     },
 };
 
-fn tool(b: *std.Build, path: []const u8, config: ToolConfig) *std.Build.RunStep {
+fn tool(b: *std.Build, path: []const u8, config: ToolConfig) !?*std.Build.RunStep {
+    std.fs.cwd().access(path, .{}) catch |err| switch (err) {
+        error.FileNotFound => return null,
+        else => |e| return e,
+    };
     var name = config.tool.name orelse std.fs.path.basename(path);
     const index = std.mem.lastIndexOfScalar(u8, name, '.');
     if (index) |i| name = name[0..i];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.dc33f678",
+  "version": "0.1.0-dev.dfd46bbb",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
@@ -52,11 +52,14 @@
     "src/lib/gen1/data/types.zig",
     "src/lib/gen1/helpers.zig",
     "src/lib/gen1/mechanics.zig",
+    "src/lib/gen2/calc.zig",
+    "src/lib/gen2/chance.zig",
     "src/lib/gen2/data.zig",
     "src/lib/gen2/data/items.zig",
     "src/lib/gen2/data/moves.zig",
     "src/lib/gen2/data/species.zig",
     "src/lib/gen2/data/types.zig",
+    "src/lib/gen2/generated.zig",
     "src/lib/gen2/helpers.zig",
     "src/lib/gen2/mechanics.zig",
     "src/lib/pkmn.zig",
@@ -90,7 +93,7 @@
     "binaryen": "^114.0.0",
     "eslint": "^8.51.0",
     "html-minifier": "^4.0.0",
-    "json-stringify-pretty-compact": "4.0.0",
+    "json-stringify-pretty-compact": "3.0.0",
     "minimist": "^1.2.8",
     "mustache": "^4.2.0",
     "source-map-support": "^0.5.21",

package/src/lib/common/data.zig

@@ -9,12 +9,12 @@ pub const Player = enum(u1) {
     P2,
 
     /// Returns a player's opponent.
-    pub inline fn foe(self: Player) Player {
+    pub fn foe(self: Player) Player {
         return @enumFromInt(~@intFromEnum(self));
     }
 
     /// Return's an identifier for the player's Pokémon at the one-indexed `id`.
-    pub inline fn ident(self: Player, id: u3) ID {
+    pub fn ident(self: Player, id: u3) ID {
         assert(id > 0 and id <= 6);
         return .{ .id = id, .player = self };
     }
@@ -35,12 +35,12 @@ pub const ID = packed struct(u8) {
     _: u4 = 0,
 
     /// Converts the identifier into a number.
-    pub inline fn int(self: ID) u4 {
+    pub fn int(self: ID) u4 {
         return @intCast(@as(u8, @bitCast(self)));
     }
 
     /// Decodes the identifier from a number.
-    pub inline fn from(id: u4) ID {
+    pub fn from(id: u4) ID {
         return @bitCast(@as(u8, id));
     }
 };

package/src/lib/common/protocol.zig

@@ -196,7 +196,7 @@ pub const Activate = enum(u8) {
     Haze,
     Mist,
     Struggle,
-    Substitute,
+    Substitute, // FIXME SubstituteDamage
     Splash,
 
     Rage, // TODO
@@ -208,6 +208,9 @@ pub const Activate = enum(u8) {
     FireSpin,
     Clamp,
     Whirlpool,
+    SubstituteBlock,
+
+    DestinyBond,
 
     BeatUp, // FIXME of
 };
@@ -254,6 +257,7 @@ pub const End = enum(u8) {
     Encore,
     FutureSight,
     LeechSeed,
+
     Bind,
     Wrap,
     FireSpin,
@@ -269,6 +273,8 @@ pub const End = enum(u8) {
     LightScreenSilent,
     ReflectSilent,
     BideSilent,
+
+    LeechSeedFrom,
 };
 
 pub const Immune = enum(u8) {
@@ -570,6 +576,7 @@ pub fn Log(comptime Writer: type) type {
         pub fn activate(self: Self, ident: ID, reason: Activate) Error!void {
             if (!enabled) return;
 
+            assert(reason != .SubstituteBlock); // TODO
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Activate),
                 @as(u8, @bitCast(ident)),
@@ -577,6 +584,18 @@ pub fn Log(comptime Writer: type) type {
             });
         }
 
+        pub fn activateMove(self: Self, ident: ID, reason: Activate, m: anytype) Error!void {
+            if (!enabled) return;
+
+            assert(reason == .SubstituteBlock); // TODO
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.Activate),
+                @as(u8, @bitCast(ident)),
+                @intFromEnum(reason),
+                @intFromEnum(m),
+            });
+        }
+
         pub fn fieldactivate(self: Self) Error!void {
             if (!enabled) return;
 
@@ -764,14 +783,13 @@ pub fn Log(comptime Writer: type) type {
             });
         }
 
-        pub fn spikesend(self: Self, player: Player, m: anytype, source: ID) Error!void {
+        pub fn spikesend(self: Self, source: ID) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.SideEnd),
-                @intFromEnum(player),
+                @intFromEnum(source.player),
                 @intFromEnum(Side.Spikes),
-                @intFromEnum(m),
                 @as(u8, @bitCast(source)),
             });
         }
@@ -1789,14 +1807,13 @@ test "|-sideend|" {
     try expectLog2(&.{ N(ArgType.SideEnd), 1, N(Side.LightScreen) }, buf[0..3]);
     stream.reset();
 
-    try log.spikesend(.P1, M2.RapidSpin, p1.ident(3));
+    try log.spikesend(p1.ident(3));
     try expectLog2(&.{
         N(ArgType.SideEnd),
         0,
         N(Side.Spikes),
-        N(M2.RapidSpin),
         0b0011,
-    }, buf[0..5]);
+    }, buf[0..4]);
     stream.reset();
 }
 

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,12 +185,12 @@ 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);
@@ -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);
 

package/src/lib/common/rng.zig

@@ -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();
+        }
     };
 }
 
@@ -89,6 +94,10 @@ pub const Gen12 = extern struct {
         self.index = (self.index + 1) % 9;
         return val;
     }
+
+    pub fn advance(self: *Gen12) void {
+        _ = self.next();
+    }
 };
 
 test Gen12 {

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;
     }
@@ -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

@@ -37,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));
     }
 
@@ -159,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);
     }
 

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);
         }
@@ -1853,7 +1853,7 @@ pub const Move = enum(u8) {
     };
 
     /// 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");
 
@@ -1092,7 +1092,7 @@ pub const Species = enum(u8) {
     pub const size = 151;
 
     /// The Pokémon's critical hit rate=io out of 256.
-    pub inline fn chance(id: Species) u8 {
+    pub fn chance(id: Species) u8 {
         assert(id != .None);
         return CHANCES[@intFromEnum(id) - 1];
     }

package/src/lib/gen1/data/types.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");
 
@@ -90,12 +90,12 @@ pub const Type = enum(u4) {
     pub const size = 15;
 
     /// Whether or not this type is considered to be special as opposed to physical.
-    pub inline fn special(self: Type) bool {
+    pub fn special(self: Type) bool {
         return @intFromEnum(self) >= @intFromEnum(Type.Fire);
     }
 
     /// The `Effectiveness` of type `t2` vs. type `t1`.
-    pub inline fn effectiveness(t1: Type, t2: Type) Effectiveness {
+    pub fn effectiveness(t1: Type, t2: Type) Effectiveness {
         return CHART[@intFromEnum(t1)][@intFromEnum(t2)];
     }
 
@@ -120,12 +120,12 @@ pub const Types = packed struct {
     }
 
     /// Whether this typing is immune to type `t`.
-    pub inline fn immune(self: Types, t: Type) bool {
+    pub fn immune(self: Types, t: Type) bool {
         return t.effectiveness(self.type1) == I or t.effectiveness(self.type2) == I;
     }
 
     /// Whether this typing includes type `t`.
-    pub inline fn includes(self: Types, t: Type) bool {
+    pub fn includes(self: Types, t: Type) bool {
         return self.type1 == t or self.type2 == t;
     }
 };

package/src/lib/gen1/data.zig

@@ -70,24 +70,24 @@ pub fn Battle(comptime RNG: anytype) type {
         rng: RNG,
 
         /// Returns the `Side` for the given `player`.
-        pub inline fn side(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+        pub fn side(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
             assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
             return &self.sides[@intFromEnum(player)];
         }
 
         /// Returns the `Side` of the opponent for the given `player`
-        pub inline fn foe(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+        pub fn foe(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
             assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
             return &self.sides[@intFromEnum(player.foe())];
         }
 
         /// Returns an identifier for the active Pokémon of `player`.
-        pub inline fn active(self: *const Self, player: Player) ID {
+        pub fn active(self: *const Self, player: Player) ID {
             return player.ident(@intCast(self.side(player).order[0]));
         }
 
         /// Returns the `MoveDetails` for the given `player`.
-        pub inline fn lastMove(
+        pub fn lastMove(
             self: anytype,
             player: Player,
         ) PointerType(@TypeOf(self), MoveDetails) {
@@ -141,7 +141,7 @@ pub const Side = extern struct {
     }
 
     /// Returns the stored `Pokemon` corresponding to the one-indexed party `slot`.
-    pub inline fn get(self: anytype, slot: u8) PointerType(@TypeOf(self), Pokemon) {
+    pub fn get(self: anytype, slot: u8) PointerType(@TypeOf(self), Pokemon) {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
         assert(slot > 0 and slot <= 6);
         const id = self.order[slot - 1];
@@ -150,7 +150,7 @@ pub const Side = extern struct {
     }
 
     /// Returns the stored `Pokemon` corresponding to the `active` Pokémon (slot 1).
-    pub inline fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
+    pub fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
         return self.get(1);
     }
@@ -176,7 +176,7 @@ pub const ActivePokemon = extern struct {
     }
 
     /// Returns the active Pokémon's current move slot located at the one-indexed `mslot`.
-    pub inline fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
+    pub fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == ActivePokemon);
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
@@ -206,7 +206,7 @@ pub const Pokemon = extern struct {
     }
 
     /// Returns the Pokémon's original move slot located at the one-indexed `mslot`.
-    pub inline fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
+    pub fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == Pokemon);
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
@@ -258,36 +258,36 @@ pub const Status = enum(u8) {
     const SLP = 0b111;
 
     /// Whether or not the status `num` is the same as `status`.
-    pub inline fn is(num: u8, status: Status) bool {
+    pub fn is(num: u8, status: Status) bool {
         if (status == .SLP) return Status.duration(num) > 0;
         return ((num >> @intCast(@intFromEnum(status))) & 1) != 0;
     }
 
     /// Initializes a non-sleep `status`. Use `slp` or `slf` to initialize a sleep status.
-    pub inline fn init(status: Status) u8 {
+    pub fn init(status: Status) u8 {
         assert(status != .SLP and status != .EXT);
         return @as(u8, 1) << @intCast(@intFromEnum(status));
     }
 
     /// Initializes a non self-inflicted sleep status with duration `dur`.
-    pub inline fn slp(dur: u3) u8 {
+    pub fn slp(dur: u3) u8 {
         assert(dur > 0);
         return @as(u8, dur);
     }
 
     /// Initializes a self-inflicted sleep status with duration `dur`.
-    pub inline fn slf(dur: u3) u8 {
+    pub fn slf(dur: u3) u8 {
         assert(dur > 0);
         return 0x80 | slp(dur);
     }
 
     /// Returns the duration of a sleep status.
-    pub inline fn duration(num: u8) u3 {
+    pub fn duration(num: u8) u3 {
         return @intCast(num & SLP);
     }
 
     /// Returns whether `num` reflects any status.
-    pub inline fn any(num: u8) bool {
+    pub fn any(num: u8) bool {
         return num > 0;
     }
 

package/src/lib/gen1/helpers.zig

@@ -266,7 +266,7 @@ pub const Rolls = struct {
     const PLAYERS = [_]Optional(Player){ .P1, .P2 };
 
     /// Returns a slice with the correct range of values for speed ties given the `action` state.
-    pub inline fn speedTie(action: Action) []const Optional(Player) {
+    pub fn speedTie(action: Action) []const Optional(Player) {
         return if (@field(action, "speed_tie") == .None) &PLAYER_NONE else &PLAYERS;
     }
 
@@ -275,14 +275,14 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for hits given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
-    pub inline fn hit(action: Action, parent: Optional(bool)) []const Optional(bool) {
+    pub fn hit(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .true) return &BOOL_NONE;
         return if (@field(action, "hit") == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for critical hits given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn criticalHit(
+    pub fn criticalHit(
         action: Action,
         parent: Optional(bool),
     ) []const Optional(bool) {
@@ -292,7 +292,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for secondary chances hits given the
     /// `action` state and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn secondaryChance(
+    pub fn secondaryChance(
         action: Action,
         parent: Optional(bool),
     ) []const Optional(bool) {
@@ -305,7 +305,7 @@ pub const Rolls = struct {
 
     /// Returns the range bounding damage rolls given the `action` state and the state of
     /// the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn damage(action: Action, parent: Optional(bool)) Range {
+    pub fn damage(action: Action, parent: Optional(bool)) Range {
         return if (parent == .false or @field(action, "damage") == 0)
             .{ .min = 0, .max = 1 }
         else
@@ -314,7 +314,7 @@ pub const Rolls = struct {
 
     /// Returns the max damage roll which will produce the same damage as `roll`
     /// given the base damage in `summaries`.
-    pub inline fn coalesce(player: Player, roll: u8, summaries: *calc.Summaries, cap: bool) !u8 {
+    pub fn coalesce(player: Player, roll: u8, summaries: *calc.Summaries, cap: bool) !u8 {
         if (roll == 0) return roll;
 
         const dmg = summaries.get(player.foe()).damage;
@@ -326,13 +326,13 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for confused given the `action` state
     /// and the state of the `parent` (the player's Pokémon's remaining confusion turns).
-    pub inline fn confused(action: Action, parent: u4) []const Optional(bool) {
+    pub fn confused(action: Action, parent: u4) []const Optional(bool) {
         return if (parent == 0 or @field(action, "confused") == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for paralysis given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon was confused).
-    pub inline fn paralyzed(action: Action, parent: Optional(bool)) []const Optional(bool) {
+    pub fn paralyzed(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .true) return &BOOL_NONE;
         return if (@field(action, "paralyzed") == .None) &BOOL_NONE else &BOOLS;
     }
@@ -342,7 +342,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with a range of values for duration given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn duration(action: Action, parent: Optional(bool)) []const u1 {
+    pub fn duration(action: Action, parent: Optional(bool)) []const u1 {
         if (parent == .false) return &DURATION_NONE;
         return if (@field(action, "duration") == 0) &DURATION_NONE else &DURATION;
     }
@@ -418,7 +418,7 @@ pub const Rolls = struct {
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
     ///
     /// These slots may or **may not be valid** as slots may be unset / have 0 PP.
-    pub inline fn moveSlot(action: Action, parent: Optional(bool)) []const u4 {
+    pub fn moveSlot(action: Action, parent: Optional(bool)) []const u4 {
         if (parent == .false) return &SLOT_NONE;
         return if (@field(action, "move_slot") == 0) &SLOT_NONE else &SLOT;
     }
@@ -428,7 +428,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for multi hit given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn multiHit(action: Action, parent: Optional(bool)) []const u4 {
+    pub fn multiHit(action: Action, parent: Optional(bool)) []const u4 {
         if (parent == .false) return &MULTI_NONE;
         return if (@field(action, "multi_hit") == 0) &MULTI_NONE else &MULTI;
     }
@@ -442,7 +442,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for psywave given the `action` state,
     /// the `side`, and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn psywave(
+    pub fn psywave(
         action: Action,
         side: *data.Side,
         parent: Optional(bool),
@@ -457,7 +457,7 @@ pub const Rolls = struct {
     const MOVE_NONE = [_]Move{.None};
 
     /// Returns a slice with the correct range of values for metronome given the `action` state.
-    pub inline fn metronome(action: Action) []const Move {
+    pub fn metronome(action: Action) []const Move {
         return if (@field(action, "metronome") == .None) &MOVE_NONE else &Move.METRONOME;
     }
 };