@pkmn/engine 0.1.0-dev.a15b6c17 → 0.1.0-dev.a19bc07d

package/README.md

@@ -13,12 +13,10 @@
   </a>
 </p>
 
-> [!WARNING]  
+> [!WARNING]
 > **This project is under heavy development** and currently the `main` branch contains numerous breaking
 > changes which may not work and which are not fully documented. Please **wait for the forthcoming
-> initial v0.1 release** before depending on this project (code from the
-> [`old`](https://github.com/pkmn/engine/releases/tag/old) tag can also be used to experiment with a
-> more stable version of the codebase).
+> initial v0.1 release** before depending on this project.
 
 <hr />
 
@@ -86,8 +84,11 @@ lifecycle script](https://docs.npmjs.com/cli/v8/using-npm/scripts) runs
 it can't find one, as well as looking for (and downloading, if necessary) the required Node headers
 needed to successfully build the addons natively.
 
-**If you have configured `npm` to `--ignore-scripts` you must either run `npx install-pkmn-engine`
-directly or build the addons manually and place the artifacts in the expected paths.**
+> [!IMPORTANT]
+> If you have configured `npm` to `--ignore-scripts` (or are using [npm v12+ and have not
+> approved](https://github.blog/changelog/2026-06-09-upcoming-breaking-changes-for-npm-v12/)
+> `@pkmn/engine` via `npm approve-scripts @pkmn/engine`) **you must either run `npx install-pkmn-engine`
+> directly or build the addons manually and place the artifacts in the expected paths.**
 
 ### `pkmn`
 

package/build.zig

@@ -12,7 +12,12 @@ pub const Options = struct {
     calc: ?bool = null,
 };
 
-pub fn module(b: *std.Build, options: Options) *std.Build.Module {
+pub fn module(
+    b: *std.Build,
+    options: Options,
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+) *std.Build.Module {
     const build_options = b.addOptions();
     build_options.addOption(?bool, "showdown", options.showdown);
     build_options.addOption(?bool, "log", options.log);
@@ -22,7 +27,12 @@ pub fn module(b: *std.Build, options: Options) *std.Build.Module {
     const root_source_file = b.path("src/lib/pkmn.zig");
     const imports: []const std.Build.Module.Import =
         &.{.{ .name = "build_options", .module = build_options.createModule() }};
-    return b.createModule(.{ .root_source_file = root_source_file, .imports = imports });
+    return b.createModule(.{
+        .root_source_file = root_source_file,
+        .target = target,
+        .optimize = optimize,
+        .imports = imports,
+    });
 }
 
 pub fn build(b: *std.Build) !void {
@@ -45,7 +55,10 @@ pub fn build(b: *std.Build) !void {
     const emit_asm = b.option(bool, "emit-asm", "Output .s (assembly code)") orelse false;
     const emit_ll = b.option(bool, "emit-ll", "Output .ll (LLVM IR)") orelse false;
 
-    const cmd = b.findProgram(&.{"strip"}, &.{}) catch null;
+    const cmd = if (@hasDecl(std.Build, "FindProgramOptions"))
+        b.findProgram(.{ .names = &.{"strip"} })
+    else
+        b.findProgram(&.{"strip"}, &.{}) catch null;
 
     const json = @embedFile("package.json");
     var parsed = try std.json.parseFromSlice(std.json.Value, b.allocator, json, .{});
@@ -99,7 +112,8 @@ pub fn build(b: *std.Build) !void {
         const translate_c = b.addTranslateC(.{
             .root_source_file = b.path("src/lib/napi.h"),
             .target = target,
-            .optimize = optimize,
+            // TODO: workaround for ziglang/zig#35515
+            .optimize = .Debug,
         });
         translate_c.addSystemIncludePath(b.path(headers));
         const addon = b.fmt("{s}.node", .{name});
@@ -195,7 +209,9 @@ pub fn build(b: *std.Build) !void {
                 b.fmt("{s}.ll", .{name}),
             ).step);
         }
-        b.installArtifact(lib);
+        const install = b.addInstallArtifact(lib, .{});
+        b.getInstallStep().dependOn(&install.step);
+        maybeRanlib(b, lib, &install.step);
         c = true;
     }
 
@@ -204,34 +220,45 @@ pub fn build(b: *std.Build) !void {
         const header = b.addInstallFileWithDir(path, .header, "pkmn.h");
         b.getInstallStep().dependOn(&header.step);
 
-        const pc = b.fmt("lib{s}.pc", .{name});
-        const cwd = try std.process.currentPathAlloc(b.graph.io, b.allocator);
-        const file = try std.Io.Dir.path.relative(
-            b.allocator,
-            cwd,
-            &b.graph.environ_map,
-            cwd,
-            try b.cache_root.join(b.allocator, &.{pc}),
-        );
-        const pkgconfig_file = try std.Io.Dir.cwd().createFile(b.graph.io, file, .{});
-        defer pkgconfig_file.close(b.graph.io);
-
-        const dirname = comptime std.fs.path.dirname(@src().file) orelse ".";
-        var writer = pkgconfig_file.writer(b.graph.io, &.{});
-        try writer.interface.print(
-            \\prefix={0s}/{1s}
+        const content = try std.fmt.allocPrint(b.allocator,
+            \\prefix=${{pcfiledir}}/../..
             \\includedir=${{prefix}}/include
             \\libdir=${{prefix}}/lib
             \\
-            \\Name: lib{2s}
-            \\URL: https://github.com/{3s}
-            \\Description: {4s}
-            \\Version: {5s}
+            \\Name: lib{0s}
+            \\URL: https://github.com/{1s}
+            \\Description: {2s}
+            \\Version: {3s}
             \\Cflags: -I${{includedir}}
-            \\Libs: -L${{libdir}} -l{2s}
-        , .{ dirname, b.install_path, name, repository.next().?, description, version });
+            \\Libs: -L${{libdir}} -l{0s}
+        , .{ name, repository.next().?, description, version });
 
-        b.installFile(file, b.fmt("share/pkgconfig/{s}", .{pc}));
+        const pc = b.fmt("lib{s}.pc", .{name});
+        if (@hasDecl(std.Build, "FindProgramOptions")) {
+            const write_file = b.addWriteFiles();
+            const pkgconfig = write_file.add(pc, content);
+            b.getInstallStep().dependOn(&b.addInstallFileWithDir(
+                pkgconfig,
+                .prefix,
+                b.fmt("share/pkgconfig/{s}", .{pc}),
+            ).step);
+        } else {
+            const cwd = try std.process.currentPathAlloc(b.graph.io, b.allocator);
+            const file = try std.Io.Dir.path.relative(
+                b.allocator,
+                cwd,
+                &b.graph.environ_map,
+                cwd,
+                try b.cache_root.join(b.allocator, &.{pc}),
+            );
+            const pkgconfig = try std.Io.Dir.cwd().createFile(b.graph.io, file, .{});
+            defer pkgconfig.close(b.graph.io);
+
+            var writer = pkgconfig.writer(b.graph.io, &.{});
+            try writer.interface.writeAll(content);
+
+            b.installFile(file, b.fmt("share/pkgconfig/{s}", .{pc}));
+        }
     }
 
     const config: Config = .{
@@ -253,7 +280,6 @@ pub fn build(b: *std.Build) !void {
             .chance = chance,
             .calc = calc,
         },
-        .module = pkmn,
         .general = config,
         .tool = .{
             .tests = if (tests.build) tests else null,
@@ -285,8 +311,8 @@ pub fn build(b: *std.Build) !void {
     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("test", "Run all tests").dependOn(tests.step);
+    b.step("tools", "Install tools").dependOn(ToolsStep.create(b, &exes).step);
     if (transitions) |t| {
         b.step("transitions", "Visualize transitions algorithm search").dependOn(&t.step);
     }
@@ -356,7 +382,12 @@ fn buildWasm(
     exe.stack_size = wasm_stack_size;
     exe.root_module.addOptions("build_options", options);
 
-    const opt = b.findProgram(&.{"wasm-opt"}, &.{"./node_modules/.bin"}) catch null;
+    const opt = if (@hasDecl(std.Build, "FindProgramOptions")) blk: {
+        if (exists(b, "./node_modules/.bin/wasm-opt") catch false) {
+            break :blk "./node_modules/.bin/wasm-opt";
+        }
+        break :blk b.findProgram(.{ .names = &.{"wasm-opt"} });
+    } else b.findProgram(&.{"wasm-opt"}, &.{"./node_modules/.bin"}) catch null;
     if (optimize != .Debug and opt != null) {
         const out = b.fmt("build/lib/{s}.wasm", .{name});
         const sh = b.addSystemCommand(&.{ opt.?, "--enable-bulk-memory", "--enable-simd", "-O4" });
@@ -398,7 +429,7 @@ const Config = struct {
 };
 
 const TestStep = struct {
-    step: std.Build.Step,
+    step: *std.Build.Step,
     build: bool,
 
     pub fn create(b: *std.Build, options: *std.Build.Step.Options, config: Config) *TestStep {
@@ -407,8 +438,6 @@ const TestStep = struct {
             b.option([]const u8, "test-filter", "Skip tests that do not match filter");
 
         const self = b.allocator.create(TestStep) catch @panic("OOM");
-        const step = std.Build.Step.init(.{ .id = .custom, .name = "Run all tests", .owner = b });
-        self.* = .{ .step = step, .build = test_filter == null };
 
         const path = b.path("src/lib/test.zig");
         const tests = b.addTest(.{
@@ -428,7 +457,20 @@ const TestStep = struct {
         if (coverage) |c| {
             tests.setExecCmd(&.{ "kcov", "--include-pattern=src/lib", c, null });
         }
-        self.step.dependOn(&b.addRunArtifact(tests).step);
+
+        if (@hasDecl(std.Build, "FindProgramOptions")) {
+            const run_step = b.addRunArtifact(tests);
+            self.* = .{ .step = &run_step.step, .build = test_filter == null };
+        } else {
+            const custom_step = b.allocator.create(std.Build.Step) catch @panic("OOM");
+            custom_step.* = std.Build.Step.init(.{
+                .id = .custom,
+                .name = "Run all tests",
+                .owner = b,
+            });
+            custom_step.dependOn(&b.addRunArtifact(tests).step);
+            self.* = .{ .step = custom_step, .build = test_filter == null };
+        }
 
         return self;
     }
@@ -436,7 +478,6 @@ const TestStep = struct {
 
 const ToolConfig = struct {
     options: Options,
-    module: ?*std.Build.Module,
     general: Config,
     tool: struct {
         tests: ?*TestStep,
@@ -463,7 +504,7 @@ fn tool(b: *std.Build, path: []const u8, config: ToolConfig) !?*std.Build.Step.R
         }),
     });
 
-    const import = if (config.module) |m| m else module(b, config.options);
+    const import = module(b, config.options, config.general.target, config.general.optimize);
     exe.root_module.addImport("pkmn", import);
     if (config.general.target.result.os.tag == .windows) {
         exe.root_module.linkSystemLibrary("advapi32", .{});
@@ -474,7 +515,11 @@ fn tool(b: *std.Build, path: []const u8, config: ToolConfig) !?*std.Build.Step.R
 
     const run = b.addRunArtifact(exe);
     maybeStrip(b, exe, &run.step, config.general.strip, config.general.cmd);
-    if (b.args) |args| run.addArgs(args);
+    if (@hasDecl(std.Build, "FindProgramOptions")) {
+        run.addPassthruArgs();
+    } else {
+        if (b.args) |args| run.addArgs(args);
+    }
 
     return run;
 }
@@ -488,13 +533,33 @@ fn exists(b: *std.Build, path: []const u8) !bool {
 }
 
 const ToolsStep = struct {
-    step: std.Build.Step,
+    step: *std.Build.Step,
 
     pub fn create(b: *std.Build, exes: *ArrayList(*std.Build.Step.Compile)) *ToolsStep {
         const self = b.allocator.create(ToolsStep) catch @panic("OOM");
-        const step = std.Build.Step.init(.{ .id = .custom, .name = "Install tools", .owner = b });
-        self.* = .{ .step = step };
+
+        if (@hasDecl(std.Build, "FindProgramOptions")) {
+            const step = b.allocator.create(std.Build.Step.TopLevel) catch @panic("OOM");
+            step.* = .{
+                .step = std.Build.Step.init(.{
+                    .tag = .top_level,
+                    .name = "Install tools",
+                    .owner = b,
+                }),
+                .description = "Install tools",
+            };
+            self.* = .{ .step = &step.step };
+        } else {
+            const step = b.allocator.create(std.Build.Step) catch @panic("OOM");
+            step.* = std.Build.Step.init(.{
+                .id = .custom,
+                .name = "Install tools",
+                .owner = b,
+            });
+            self.* = .{ .step = step };
+        }
         for (exes.items) |t| self.step.dependOn(&b.addInstallArtifact(t, .{}).step);
+
         return self;
     }
 };
@@ -516,3 +581,21 @@ pub fn exports(b: *std.Build, bytes: []const u8) ![][]const u8 {
 
     return symbols.items;
 }
+
+fn maybeRanlib(
+    b: *std.Build,
+    artifact: *std.Build.Step.Compile,
+    install_step: *std.Build.Step,
+) void {
+    if (builtin.os.tag != .macos) return;
+    if (artifact.linkage != .static) return;
+
+    const ranlib = if (comptime @hasDecl(std.Build, "FindProgramOptions"))
+        b.findProgram(.{ .names = &.{"ranlib"} }) orelse return
+    else
+        b.findProgram(&[_][]const u8{"ranlib"}, &[_][]const u8{}) catch return;
+
+    const sh = b.addSystemCommand(&[_][]const u8{ranlib});
+    sh.addFileArg(artifact.getEmittedBin());
+    install_step.dependOn(&sh.step);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.a15b6c17",
+  "version": "0.1.0-dev.a19bc07d",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
@@ -100,12 +100,12 @@
   },
   "dependencies": {
     "@pkmn/data": "0.9.35",
-    "@pkmn/protocol": "^0.7.2"
+    "@pkmn/protocol": "^0.7.3"
   },
   "devDependencies": {
     "@pkmn/dex-types": "0.9.35",
-    "@pkmn/eslint-config": "^9.27.0",
-    "@pkmn/img": "^0.3.3",
+    "@pkmn/eslint-config": "^9.28.0",
+    "@pkmn/img": "^0.3.4",
     "@pkmn/sets": "^5.2.0",
     "@pkmn/sim": "0.9.31",
     "@pkmn/smogon": "0.5.21",
@@ -113,25 +113,25 @@
     "@types/jest": "^30.0.0",
     "@types/minimist": "^1.2.5",
     "@types/mustache": "^4.2.6",
-    "@types/node": "^25.6.0",
-    "@types/react": "^19.2.14",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.17",
     "@types/semver": "^7.7.1",
-    "@types/vscode": "^1.118.0",
-    "@vitest/coverage-v8": "^4.1.5",
-    "@vscode/vsce": "^3.9.1",
-    "binaryen": "^129.0.0",
-    "esbuild": "^0.28.0",
+    "@types/vscode": "^1.125.0",
+    "@vitest/coverage-v8": "^4.1.9",
+    "@vscode/vsce": "^3.9.2",
+    "binaryen": "^130.0.0",
+    "esbuild": "^0.28.1",
     "eslint": "<10",
     "html-minifier": "^4.0.0",
     "json-stringify-pretty-compact": "3.0.0",
     "minimist": "^1.2.8",
     "mustache": "^4.2.0",
-    "semver": "^7.7.4",
+    "semver": "^7.8.5",
     "source-map-support": "^0.5.21",
     "table": "^6.9.0",
     "trakr": "^0.2.0",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.9"
   },
   "scripts": {
     "lint": "eslint --cache src",

package/src/lib/bindings/c.zig

@@ -1,5 +1,6 @@
 const pkmn = @import("../pkmn.zig");
 const std = @import("std");
+const util = @import("../common/util.zig");
 
 const assert = std.debug.assert;
 
@@ -23,7 +24,7 @@ pub const MAX_LOGS = pkmn.MAX_LOGS;
 pub const LOGS_SIZE = pkmn.LOGS_SIZE;
 
 pub fn choice_init(choice: u8, data: u8) callconv(.c) u8 {
-    assert(choice <= @typeInfo(pkmn.Choice.Type).@"enum".fields.len);
+    assert(choice <= util.EnumFieldsLen(pkmn.Choice.Type));
     assert(data <= 6);
     return @bitCast(pkmn.Choice{ .type = @enumFromInt(choice), .data = @intCast(data) });
 }
@@ -190,8 +191,8 @@ pub fn gen(comptime num: comptime_int) type {
             out: [*]u8,
             n: usize,
         ) callconv(.c) u8 {
-            assert(player <= @typeInfo(pkmn.Player).@"enum".fields.len);
-            assert(request <= @typeInfo(pkmn.Choice.Type).@"enum".fields.len);
+            assert(player <= util.EnumFieldsLen(pkmn.Player));
+            assert(request <= util.EnumFieldsLen(pkmn.Choice.Type));
 
             assert(!pkmn.options.showdown or n > 0);
             return battle.choices(@enumFromInt(player), @enumFromInt(request), @ptrCast(out[0..n]));

package/src/lib/bindings/wasm.zig

@@ -1,5 +1,6 @@
 const pkmn = @import("../pkmn.zig");
 const std = @import("std");
+const util = @import("../common/util.zig");
 
 const assert = std.debug.assert;
 
@@ -36,8 +37,8 @@ pub fn gen(comptime num: comptime_int) type {
             request: u8,
             buf: [*]u8,
         ) callconv(.c) u8 {
-            assert(player <= @typeInfo(pkmn.Player).@"enum".fields.len);
-            assert(request <= @typeInfo(pkmn.Choice.Type).@"enum".fields.len);
+            assert(player <= util.EnumFieldsLen(pkmn.Player));
+            assert(request <= util.EnumFieldsLen(pkmn.Choice.Type));
 
             const n = CHOICES_SIZE;
             return battle.choices(@enumFromInt(player), @enumFromInt(request), @ptrCast(buf[0..n]));

package/src/lib/common/debug.zig

@@ -24,9 +24,20 @@ pub fn print(value: anytype) void {
             switch (@typeInfo(@TypeOf(value))) {
                 .@"struct" => |info| {
                     if (info.is_tuple) {
-                        inline for (info.fields, 0..) |f, i| {
-                            inspect(fw, @field(value, f.name));
-                            if (i < info.fields.len - 1) fw.interface.writeAll(" ") catch return;
+                        if (@hasField(@TypeOf(info), "fields")) {
+                            inline for (info.fields, 0..) |f, i| {
+                                inspect(fw, @field(value, f.name));
+                                if (i < info.fields.len - 1) {
+                                    fw.interface.writeAll(" ") catch return;
+                                }
+                            }
+                        } else {
+                            inline for (info.field_names, 0..) |name, i| {
+                                inspect(fw, @field(value, name));
+                                if (i < info.field_names.len - 1) {
+                                    fw.interface.writeAll(" ") catch return;
+                                }
+                            }
                         }
                     } else {
                         inspect(fw, value);

package/src/lib/common/optional.zig

@@ -6,21 +6,31 @@ const assert = std.debug.assert;
 /// Optimized optional representation which stores the empty None value as a sentinel.
 /// NOTE: ziglang/zig#104
 pub fn Optional(comptime T: type) type {
-    const fields = std.meta.fields(switch (@typeInfo(T)) {
-        .bool => enum { false, true },
-        else => T,
-    });
+    const names = if (@hasDecl(std.meta, "fieldNames"))
+        std.meta.fieldNames(switch (@typeInfo(T)) {
+            .bool => enum { false, true },
+            else => T,
+        })
+    else blk: {
+        const fields = std.meta.fields(switch (@typeInfo(T)) {
+            .bool => enum { false, true },
+            else => T,
+        });
+        var ns: [fields.len][:0]const u8 = undefined;
+        inline for (fields, 0..) |f, i| ns[i] = f.name;
+        break :blk &ns;
+    };
 
-    const TagType = std.math.IntFittingRange(0, fields.len);
-    var fieldNames: [fields.len + 1][]const u8 = undefined;
-    var fieldValues: [fields.len + 1]TagType = undefined;
+    const TagType = std.math.IntFittingRange(0, names.len);
+    var fieldNames: [names.len + 1][]const u8 = undefined;
+    var fieldValues: [names.len + 1]TagType = undefined;
 
     fieldNames[0] = "None";
     fieldValues[0] = 0;
 
-    inline for (fields, 1..) |field, i| {
-        assert(!std.mem.eql(u8, field.name, "None"));
-        fieldNames[i] = field.name;
+    inline for (names, 1..) |name, i| {
+        assert(!std.mem.eql(u8, name, "None"));
+        fieldNames[i] = name;
         fieldValues[i] = i;
     }
 

package/src/lib/common/util.zig

@@ -4,7 +4,12 @@ const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
 pub fn PointerType(comptime P: type, comptime C: type) type {
-    return if (@typeInfo(P).pointer.is_const) *const C else *C;
+    const ptr_info = @typeInfo(P).pointer;
+    const is_const = if (@hasField(@TypeOf(ptr_info), "attrs"))
+        ptr_info.attrs.@"const"
+    else
+        ptr_info.is_const;
+    return if (is_const) *const C else *C;
 }
 
 test PointerType {
@@ -12,6 +17,21 @@ test PointerType {
     try expectEqual(*const f64, PointerType(*const i32, f64));
 }
 
+pub fn EnumFieldsLen(comptime E: type) usize {
+    const info = @typeInfo(E).@"enum";
+    return if (@hasField(@TypeOf(info), "fields"))
+        info.fields.len
+    else
+        info.field_names.len;
+}
+
+test EnumFieldsLen {
+    const E1 = enum { A, B, C };
+    const E2 = enum(u8) { A = 0, B = 10, C = 20, D = 30 };
+    try expectEqual(3, EnumFieldsLen(E1));
+    try expectEqual(4, EnumFieldsLen(E2));
+}
+
 pub fn isPointerTo(p: anytype, comptime P: type) bool {
     const info = @typeInfo(@TypeOf(p));
     return switch (info) {

package/src/lib/gen1/chance.zig

@@ -52,10 +52,23 @@ 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| {
-                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))
@@ -216,31 +229,36 @@ pub const Action = packed struct(u64) {
     pub fn fmt(self: Action, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeByte('(');
         var printed = false;
-        inline for (@typeInfo(Action).@"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) {
                     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,
+                            field_name,
                         });
                     } else if (@TypeOf(val) != Move and @TypeOf(val) != Optional(Player)) {
-                        try writer.print("{s}{s}", .{ SYMBOLS[@intFromEnum(val) - 1], field.name });
+                        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) {
                     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;
                 },
@@ -293,20 +311,25 @@ pub const Duration = packed struct(u32) {
     ) !void {
         try writer.writeByte('(');
         var printed = false;
-        inline for (@typeInfo(Duration).@"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) {
                     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;
                 },

package/src/lib/gen1/helpers.zig

@@ -161,15 +161,20 @@ pub const Pokemon = struct {
         var pokemon = data.Pokemon{};
         pokemon.species = p.species;
         const species = Species.get(p.species);
-        inline for (@typeInfo(@TypeOf(pokemon.stats)).@"struct".fields) |field| {
-            const hp = comptime std.mem.eql(u8, field.name, "hp");
+        inline for (if (@hasField(@TypeOf(@typeInfo(@TypeOf(pokemon.stats)).@"struct"), "fields"))
+            @typeInfo(@TypeOf(pokemon.stats)).@"struct".fields
+        else
+            @typeInfo(@TypeOf(pokemon.stats)).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else field;
+            const hp = comptime std.mem.eql(u8, field_name, "hp");
             const spc =
-                comptime std.mem.eql(u8, field.name, "spa") or std.mem.eql(u8, field.name, "spd");
-            @field(pokemon.stats, field.name) = Stats(u16).calc(
-                field.name,
-                @field(species.stats, field.name),
-                if (hp) p.dvs.hp() else if (spc) p.dvs.spc else @field(p.dvs, field.name),
-                @field(p.stats, field.name),
+                comptime std.mem.eql(u8, field_name, "spa") or std.mem.eql(u8, field_name, "spd");
+            @field(pokemon.stats, field_name) = Stats(u16).calc(
+                field_name,
+                @field(species.stats, field_name),
+                if (hp) p.dvs.hp() else if (spc) p.dvs.spc else @field(p.dvs, field_name),
+                @field(p.stats, field_name),
                 p.level,
             );
         }
@@ -197,14 +202,19 @@ pub const Pokemon = struct {
         const lvl = if (rand.chance(u8, 1, 20)) rand.range(u8, 1, 99 + 1) else 100;
         var stats: Stats(u16) = .{};
         const dvs = DVs.random(rand);
-        inline for (@typeInfo(@TypeOf(stats)).@"struct".fields) |field| {
-            @field(stats, field.name) = Stats(u16).calc(
-                field.name,
-                @field(species.stats, field.name),
-                if (comptime std.mem.eql(u8, field.name, "hp"))
+        inline for (if (@hasField(@TypeOf(@typeInfo(@TypeOf(stats)).@"struct"), "fields"))
+            @typeInfo(@TypeOf(stats)).@"struct".fields
+        else
+            @typeInfo(@TypeOf(stats)).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else field;
+            @field(stats, field_name) = Stats(u16).calc(
+                field_name,
+                @field(species.stats, field_name),
+                if (comptime std.mem.eql(u8, field_name, "hp"))
                     dvs.hp()
                 else
-                    @field(dvs, field.name),
+                    @field(dvs, field_name),
                 if (rand.chance(u8, 1, 20)) rand.range(u16, 0, EXP + 1) else EXP,
                 lvl,
             );

package/src/lib/gen2/chance.zig

@@ -53,10 +53,23 @@ 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| {
-                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))
@@ -188,29 +201,34 @@ pub const Action = packed struct(u128) {
     pub fn fmt(self: Action, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeByte('(');
         var printed = false;
-        inline for (@typeInfo(Action).@"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) {
                     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,
+                            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) {
                     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;
                 },

package/src/lib/gen2/helpers.zig

@@ -140,15 +140,20 @@ pub const Pokemon = struct {
         var pokemon = data.Pokemon{};
         pokemon.species = p.species;
         const species = Species.get(p.species);
-        inline for (@typeInfo(@TypeOf(pokemon.stats)).@"struct".fields) |field| {
-            const hp = comptime std.mem.eql(u8, field.name, "hp");
+        inline for (if (@hasField(@TypeOf(@typeInfo(@TypeOf(pokemon.stats)).@"struct"), "fields"))
+            @typeInfo(@TypeOf(pokemon.stats)).@"struct".fields
+        else
+            @typeInfo(@TypeOf(pokemon.stats)).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else field;
+            const hp = comptime std.mem.eql(u8, field_name, "hp");
             const spc =
-                comptime std.mem.eql(u8, field.name, "spa") or std.mem.eql(u8, field.name, "spd");
-            @field(pokemon.stats, field.name) = Stats(u16).calc(
-                field.name,
-                @field(species.stats, field.name),
-                if (hp) p.dvs.hp() else if (spc) p.dvs.spc else @field(p.dvs, field.name),
-                @field(p.stats, field.name),
+                comptime std.mem.eql(u8, field_name, "spa") or std.mem.eql(u8, field_name, "spd");
+            @field(pokemon.stats, field_name) = Stats(u16).calc(
+                field_name,
+                @field(species.stats, field_name),
+                if (hp) p.dvs.hp() else if (spc) p.dvs.spc else @field(p.dvs, field_name),
+                @field(p.stats, field_name),
                 p.level,
             );
         }
@@ -181,13 +186,18 @@ pub const Pokemon = struct {
 
         var stats: Stats(u16) = .{};
         const dvs = gen1.DVs.random(rand);
-        inline for (@typeInfo(@TypeOf(stats)).@"struct".fields) |field| {
-            const hp = std.mem.eql(u8, field.name, "hp");
-            const spc = std.mem.eql(u8, field.name, "spa") or std.mem.eql(u8, field.name, "spd");
-            @field(stats, field.name) = Stats(u16).calc(
-                field.name,
-                @field(species.stats, field.name),
-                if (hp) dvs.hp() else if (spc) dvs.spc else @field(dvs, field.name),
+        inline for (if (@hasField(@TypeOf(@typeInfo(@TypeOf(stats)).@"struct"), "fields"))
+            @typeInfo(@TypeOf(stats)).@"struct".fields
+        else
+            @typeInfo(@TypeOf(stats)).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else field;
+            const hp = std.mem.eql(u8, field_name, "hp");
+            const spc = std.mem.eql(u8, field_name, "spa") or std.mem.eql(u8, field_name, "spd");
+            @field(stats, field_name) = Stats(u16).calc(
+                field_name,
+                @field(species.stats, field_name),
+                if (hp) dvs.hp() else if (spc) dvs.spc else @field(dvs, field_name),
                 if (rand.chance(u8, 1, 20)) rand.range(u8, 0, 255 + 1) else 255,
                 lvl,
             );