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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.683fba11",
+  "version": "0.1.0-dev.6b383c80",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
@@ -49,6 +49,9 @@
     "build/tools/display/ui.jsx",
     "build/tools/display/util.js.map",
     "build/tools/display/util.js",
+    "src/lib/bindings/c.zig",
+    "src/lib/bindings/node.zig",
+    "src/lib/bindings/wasm.zig",
     "src/lib/common/array.zig",
     "src/lib/common/battle.zig",
     "src/lib/common/data.zig",
@@ -78,6 +81,7 @@
     "src/lib/gen2/generated.zig",
     "src/lib/gen2/helpers.zig",
     "src/lib/gen2/mechanics.zig",
+    "src/lib/napi.h",
     "src/lib/node.zig",
     "src/lib/pkmn.zig",
     "src/lib/wasm.zig",
@@ -95,42 +99,41 @@
     "access": "public"
   },
   "dependencies": {
-    "@pkmn/data": "^0.9.19",
-    "@pkmn/protocol": "^0.6.26"
+    "@pkmn/data": "0.9.35",
+    "@pkmn/protocol": "^0.7.3"
   },
   "devDependencies": {
-    "@pkmn/eslint-config": "^8.4.0",
-    "@pkmn/img": "^0.2.32",
-    "@pkmn/sets": "^5.1.2",
-    "@pkmn/sim": "0.9.19",
-    "@pkmn/smogon": "^0.5.14",
-    "@types/html-minifier": "^4.0.5",
-    "@types/jest": "^29.5.13",
+    "@pkmn/dex-types": "0.9.35",
+    "@pkmn/eslint-config": "^10.0.0",
+    "@pkmn/img": "^0.3.4",
+    "@pkmn/sets": "^5.2.0",
+    "@pkmn/sim": "0.9.31",
+    "@pkmn/smogon": "0.5.21",
+    "@types/html-minifier": "^4.0.6",
+    "@types/jest": "^30.0.0",
     "@types/minimist": "^1.2.5",
-    "@types/mustache": "^4.2.5",
-    "@types/node": "^22.7.4",
-    "@types/react": "^18.3.10",
-    "@types/semver": "^7.5.8",
-    "@types/vscode": "^1.93.0",
-    "@vitest/coverage-v8": "^2.1.1",
-    "@vscode/vsce": "^3.1.1",
-    "binaryen": "^119.0.0",
-    "esbuild": "^0.24.0",
-    "eslint": "<=8",
+    "@types/mustache": "^4.2.6",
+    "@types/node": "^26.6.3",
+    "@types/react": "^19.3.0",
+    "@types/vscode": "^1.140.0",
+    "@vitest/coverage-v8": "^5.0.3",
+    "@vscode/vsce": "^4.0.0",
+    "binaryen": "^132.0.0",
+    "esbuild": "^0.28.2",
+    "eslint": "^10.11.0",
     "html-minifier": "^4.0.0",
     "json-stringify-pretty-compact": "3.0.0",
     "minimist": "^1.2.8",
     "mustache": "^4.2.0",
-    "semver": "^7.6.3",
     "source-map-support": "^0.5.21",
-    "table": "^6.8.2",
+    "table": "^6.9.0",
     "trakr": "^0.2.0",
-    "typescript": "^5.6.2",
-    "vitest": "^2.1.1"
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.3"
   },
   "scripts": {
-    "lint": "eslint --cache src --ext ts,js && eslint src/bin/*",
-    "fix": "eslint --fix src --ext ts,js && eslint --fix src/bin/*",
+    "lint": "eslint --cache src",
+    "fix": "eslint --fix src",
     "compile": "tsc -p .",
     "build": "npm run compile",
     "test": "vitest src/pkg",
@@ -144,110 +147,5 @@
     "integration": "npm run compile && node build/test/integration",
     "extension": "npm -C src/tools/vscode run build",
     "postinstall": "node src/bin/install-pkmn-engine"
-  },
-  "eslintConfig": {
-    "extends": "@pkmn",
-    "ignorePatterns": [
-      "dist/",
-      "node_modules/",
-      "examples/zig",
-      "build/",
-      "extension.js"
-    ],
-    "env": {
-      "es6": true,
-      "node": true,
-      "browser": true
-    },
-    "overrides": [
-      {
-        "files": [
-          "**/*.ts"
-        ],
-        "parserOptions": {
-          "project": [
-            "./tsconfig.json",
-            "./examples/js/tsconfig.json"
-          ]
-        }
-      },
-      {
-        "files": [
-          "src/pkg/common.ts",
-          "src/pkg/index.ts",
-          "src/test/integration.ts"
-        ],
-        "rules": {
-          "no-control-regex": "off",
-          "@typescript-eslint/no-empty-interface": "off",
-          "@typescript-eslint/no-shadow": "off",
-          "@typescript-eslint/no-unsafe-declaration-merging": "off"
-        }
-      },
-      {
-        "files": [
-          "src/pkg/addon/node.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/no-var-requires": "off"
-        }
-      },
-      {
-        "files": [
-          "src/test/benchmark*.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/no-unused-vars": "off",
-          "@typescript-eslint/no-redundant-type-constituents": "off"
-        }
-      },
-      {
-        "files": [
-          "src/pkg/protocol.test.ts"
-        ],
-        "rules": {
-          "jest/no-standalone-expect": "off",
-          "jest/no-conditional-expect": "off"
-        }
-      },
-      {
-        "files": [
-          "src/test/*.test.ts"
-        ],
-        "rules": {
-          "jest/no-standalone-expect": "off"
-        }
-      },
-      {
-        "files": [
-          "src/test/showdown/**"
-        ],
-        "rules": {
-          "jest/expect-expect": [
-            "warn",
-            {
-              "assertFunctionNames": [
-                "expect",
-                "expectLog",
-                "verify"
-              ]
-            }
-          ]
-        }
-      },
-      {
-        "files": [
-          "src/tools/generate.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/restrict-template-expressions": [
-            "error",
-            {
-              "allowBoolean": true
-            }
-          ]
-        }
-      }
-    ]
   }
 }

package/src/bin/install-pkmn-engine

@@ -10,7 +10,7 @@ const path = require('path');
 const {pipeline} = require('stream/promises');
 const tty = require('tty');
 
-const ZIG_VERSION = {major: 0, minor: 11, patch: 0};
+const ZIG_VERSION = {major: 0, minor: 16, patch: 0};
 const DEV = ZIG_VERSION.dev ? `-dev.${ZIG_VERSION.dev}` : '';
 const VERSION = `${ZIG_VERSION.major}.${ZIG_VERSION.minor}.${ZIG_VERSION.patch}${DEV}`;
 const INDEX = 'https://ziglang.org/download/index.json';
@@ -111,15 +111,31 @@ const unpack = async (input, output) => {
   }
 };
 
+const parse = s => {
+  try {
+    return JSON.parse(s);
+  } catch (e) {
+    if (!(e instanceof SyntaxError)) throw e;
+    const json = s
+      // "key": -> "key": (ensures keys are quoted)
+      .replace(/\.([a-zA-Z_][a-zA-Z0-9_]*)\s*=/g, '"$1":')
+      // .{ -> { (converts ZON struct to JSON object)
+      .replace(/\.\{/g, '{')
+      // Remove trailing commas, which are invalid in JSON
+      .replace(/,\s*([}\]])/g, '$1');
+    return JSON.parse(json);
+  }
+};
+
 const find = zig => {
   try {
-    const {zig_exe, version} = JSON.parse(sh(zig, ['env']));
-    const [major, minor, patch, dev] = version.split('.').map(n => parseInt(n));
+    const {zig_exe, version} = parse(sh(zig, ['env']));
+    const [major, minor, patch, dev] = version.split('.').map(n => parseInt(n, 10));
 
     const compatible = major > ZIG_VERSION.major ||
       (major >= ZIG_VERSION.major && minor > ZIG_VERSION.minor) ||
       (major >= ZIG_VERSION.major && minor >= ZIG_VERSION.minor && patch >= ZIG_VERSION.patch &&
-        (!ZIG_VERSION.dev || (dev && dev >= ZIG_VERSION.dev)));
+        (!ZIG_VERSION.dev || (dev && dev >= parseInt(ZIG_VERSION.dev, 10))));
 
     if (compatible) {
       log('Found existing compatible Zig executable:', zig_exe);
@@ -163,10 +179,9 @@ const install = async () => {
   }
 
   const index = JSON.parse(await fetch(INDEX));
-  // TODO: ziglang/zig#17768
-  // const version = Object.keys(index)[+!ZIG_VERSION.dev];
-  const version = VERSION;
-  const release = index[VERSION][`${arch}-${platform}`];
+  const version = Object.keys(index)[+!ZIG_VERSION.dev];
+  // const version = VERSION; // TODO
+  const release = index[version][`${arch}-${platform}`];
   const url = release.tarball;
 
   let base = path.basename(url);
@@ -325,6 +340,7 @@ const downloadImportLib = async () => {
   const libs = path.join(ROOT, 'build', 'lib');
   if (fs.existsSync(libs)) {
     for (const file of fs.readdirSync(libs)) {
+      if (!file.startsWith('pkmn')) continue;
       const type = path.extname(file).slice(1);
       if (type !== 'node' && type !== 'wasm') continue;
       // If we don't copy the addon before loading it Windows will return an
@@ -385,20 +401,6 @@ const downloadImportLib = async () => {
     const artifact = path.join('build', 'lib', `pkmn${suffix}.${config.type}`);
     log(`Building ${artifact}${flags}`);
     sh(zig, args);
-    // TODO: ziglang/zig#14647 broke emit_to so we get to rename the file ourselves...
-    if (config.type === 'node') {
-      const prefix = process.platform === 'win32' ? '' : 'lib';
-      const ext = process.platform === 'darwin'
-        ? 'dylib' : process.platform === 'win32' ? 'dll' : 'so';
-      try {
-        const actual = path.join(ROOT, 'build', 'lib', `${prefix}pkmn${suffix}.node.${ext}`);
-        fs.renameSync(actual, artifact);
-      } catch (err) {
-        // ziglang/zig#19743 changed this path
-        const actual = path.join(ROOT, 'build', 'bin', `${prefix}pkmn${suffix}.node.${ext}`);
-        fs.renameSync(actual, artifact);
-      }
-    }
   }
 })().catch(e => {
   console.error(e);

package/src/lib/bindings/c.zig

@@ -0,0 +1,201 @@
+const pkmn = @import("../pkmn.zig");
+const std = @import("std");
+const util = @import("../common/util.zig");
+
+const assert = std.debug.assert;
+
+const ERROR: u8 = 0b1100;
+
+pub const OPTIONS: extern struct {
+    showdown: bool,
+    log: bool,
+    chance: bool,
+    calc: bool,
+} = .{
+    .showdown = pkmn.options.showdown,
+    .log = pkmn.options.log,
+    .chance = pkmn.options.chance,
+    .calc = pkmn.options.calc,
+};
+
+pub const MAX_CHOICES = pkmn.MAX_CHOICES;
+pub const CHOICES_SIZE = pkmn.CHOICES_SIZE;
+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 <= util.EnumFieldsLen(pkmn.Choice.Type));
+    assert(data <= 6);
+    return @bitCast(pkmn.Choice{ .type = @enumFromInt(choice), .data = @intCast(data) });
+}
+
+pub fn choice_type(choice: u8) callconv(.c) u8 {
+    return @intFromEnum(@as(pkmn.Choice, @bitCast(choice)).type);
+}
+
+pub fn choice_data(choice: u8) callconv(.c) u8 {
+    return @as(u8, @as(pkmn.Choice, @bitCast(choice)).data);
+}
+
+pub fn result_type(result: u8) callconv(.c) u8 {
+    return @intFromEnum(@as(pkmn.Result, @bitCast(result)).type);
+}
+
+pub fn result_p1(result: u8) callconv(.c) u8 {
+    assert(!err(result));
+    return @intFromEnum(@as(pkmn.Result, @bitCast(result)).p1);
+}
+
+pub fn result_p2(result: u8) callconv(.c) u8 {
+    assert(!err(result));
+    return @intFromEnum(@as(pkmn.Result, @bitCast(result)).p2);
+}
+
+pub fn err(result: u8) callconv(.c) bool {
+    return result == ERROR;
+}
+
+pub fn psrng_init(prng: *pkmn.PSRNG, seed: u64) callconv(.c) void {
+    prng.src = .{ .seed = seed };
+}
+
+pub fn psrng_next(prng: *pkmn.PSRNG) callconv(.c) u32 {
+    return prng.next();
+}
+
+pub fn rational_init(rational: *pkmn.Rational(f64)) callconv(.c) void {
+    rational.reset();
+}
+
+pub fn rational_reduce(rational: *pkmn.Rational(f64)) callconv(.c) void {
+    rational.reduce();
+}
+
+pub fn rational_numerator(rational: *const pkmn.Rational(f64)) callconv(.c) f64 {
+    return rational.p;
+}
+
+pub fn rational_denominator(rational: *const pkmn.Rational(f64)) callconv(.c) f64 {
+    return rational.q;
+}
+
+const log_options = extern struct {
+    buf: [*]u8,
+    len: usize,
+};
+
+pub fn gen(comptime num: comptime_int) type {
+    const g = @field(pkmn, "gen" ++ std.fmt.comptimePrint("{d}", .{num}));
+
+    return struct {
+        pub const MAX_CHOICES = g.MAX_CHOICES;
+        pub const CHOICES_SIZE = g.CHOICES_SIZE;
+        pub const MAX_LOGS = g.MAX_LOGS;
+        pub const LOGS_SIZE = g.LOGS_SIZE;
+
+        const chance_options = extern struct {
+            probability: pkmn.Rational(f64),
+            actions: g.chance.Actions,
+            durations: g.chance.Durations,
+        };
+
+        const calc_options = extern struct {
+            overrides: g.chance.Actions,
+        };
+
+        const battle_options = struct {
+            writer: pkmn.protocol.Writer,
+            log: pkmn.protocol.FixedLog,
+            chance: g.Chance(pkmn.Rational(f64)),
+            calc: g.Calc,
+
+            comptime {
+                assert(@sizeOf(battle_options) <= 128);
+            }
+        };
+
+        pub fn battle_options_set(
+            options: *battle_options,
+            log: ?*const log_options,
+            chance: ?*const chance_options,
+            calc: ?*const calc_options,
+        ) callconv(.c) void {
+            if (pkmn.options.log) {
+                if (log) |l| {
+                    options.writer = .{ .buffer = l.buf[0..l.len] };
+                    options.log = .{ .writer = &options.writer };
+                } else {
+                    options.writer.reset();
+                }
+            }
+            if (pkmn.options.chance) {
+                if (chance) |c| {
+                    options.chance = .{
+                        .probability = c.probability,
+                        .actions = c.actions,
+                        .durations = c.durations,
+                    };
+                } else {
+                    options.chance.reset();
+                }
+            }
+            if (pkmn.options.calc) {
+                if (calc) |c| {
+                    options.calc = .{ .overrides = c.overrides };
+                } else {
+                    options.calc = .{};
+                }
+            }
+        }
+
+        pub fn battle_options_chance_probability(
+            options: *battle_options,
+        ) callconv(.c) *pkmn.Rational(f64) {
+            return &options.chance.probability;
+        }
+
+        pub fn battle_options_chance_actions(
+            options: *battle_options,
+        ) callconv(.c) *g.chance.Actions {
+            return &options.chance.actions;
+        }
+
+        pub fn battle_options_chance_durations(
+            options: *battle_options,
+        ) callconv(.c) *g.chance.Durations {
+            return &options.chance.durations;
+        }
+
+        pub fn battle_options_calc_summaries(
+            options: *battle_options,
+        ) callconv(.c) *g.calc.Summaries {
+            return &options.calc.summaries;
+        }
+
+        pub fn battle_update(
+            battle: *g.Battle(g.PRNG),
+            c1: pkmn.Choice,
+            c2: pkmn.Choice,
+            opts: ?*battle_options,
+        ) callconv(.c) pkmn.Result {
+            if ((pkmn.options.log or pkmn.options.chance or pkmn.options.calc) and opts != null) {
+                return battle.update(c1, c2, opts.?) catch return @bitCast(ERROR);
+            }
+            return battle.update(c1, c2, &g.NULL) catch unreachable;
+        }
+
+        pub fn battle_choices(
+            battle: *const g.Battle(g.PRNG),
+            player: u8,
+            request: u8,
+            out: [*]u8,
+            n: usize,
+        ) callconv(.c) u8 {
+            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/node.zig

@@ -0,0 +1,117 @@
+const c = @import("napi");
+const js = @import("../common/js.zig");
+const pkmn = @import("../pkmn.zig");
+const std = @import("std");
+
+const assert = std.debug.assert;
+
+pub fn register(env: c.napi_env) c.napi_value {
+    const object = js.Object.init(env);
+    const properties = [_]c.napi_property_descriptor{
+        js.Property.init("options", .{ .value = options(env) }),
+        js.Property.init("bindings", .{ .value = bindings(env) }),
+    };
+    assert(c.napi_define_properties(env, object, properties.len, &properties) == c.napi_ok);
+    return object;
+}
+
+fn options(env: c.napi_env) c.napi_value {
+    const object = js.Object.init(env);
+    const properties = [_]c.napi_property_descriptor{
+        js.Property.init("showdown", .{ .value = js.Boolean.init(env, pkmn.options.showdown) }),
+        js.Property.init("log", .{ .value = js.Boolean.init(env, pkmn.options.log) }),
+        js.Property.init("chance", .{ .value = js.Boolean.init(env, pkmn.options.chance) }),
+        js.Property.init("calc", .{ .value = js.Boolean.init(env, pkmn.options.calc) }),
+    };
+    assert(c.napi_define_properties(env, object, properties.len, &properties) == c.napi_ok);
+    return object;
+}
+
+fn bindings(env: c.napi_env) c.napi_value {
+    const array = js.Array.init(env, .{ .length = 1 });
+    js.Array.set(env, array, 0, bind(env, pkmn.gen1));
+    return array;
+}
+
+fn bind(env: c.napi_env, gen: anytype) c.napi_value {
+    const choices_size: u32 = @intCast(gen.CHOICES_SIZE);
+    const logs_size: u32 = @intCast(gen.LOGS_SIZE);
+    const object = js.Object.init(env);
+    const properties = [_]c.napi_property_descriptor{
+        js.Property.init("CHOICES_SIZE", .{ .value = js.Number.init(env, choices_size) }),
+        js.Property.init("LOGS_SIZE", .{ .value = js.Number.init(env, logs_size) }),
+        js.Property.init("update", .{ .method = update(gen) }),
+        js.Property.init("choices", .{ .method = choices(gen) }),
+    };
+    assert(c.napi_define_properties(env, object, properties.len, &properties) == c.napi_ok);
+    return object;
+}
+
+fn update(gen: anytype) c.napi_callback {
+    return struct {
+        fn call(env: c.napi_env, info: c.napi_callback_info) callconv(.c) c.napi_value {
+            var argc: usize = 4;
+            var argv: [4]c.napi_value = undefined;
+            assert(c.napi_get_cb_info(env, info, &argc, &argv, null, null) == c.napi_ok);
+            assert(argc == 4);
+
+            var data: ?*anyopaque = undefined;
+            var len: usize = 0;
+            assert(c.napi_get_arraybuffer_info(env, argv[0], &data, &len) == c.napi_ok);
+            assert(len == @sizeOf(gen.Battle(gen.PRNG)));
+
+            var battle: *gen.Battle(gen.PRNG) = @ptrCast(@alignCast(data.?));
+            const c1: pkmn.Choice = @bitCast(js.Number.get(env, argv[1], u8));
+            const c2: pkmn.Choice = @bitCast(js.Number.get(env, argv[2], u8));
+
+            var vtype: c.napi_valuetype = undefined;
+            assert(c.napi_typeof(env, argv[3], &vtype) == c.napi_ok);
+            const result = switch (vtype) {
+                c.napi_undefined, c.napi_null => battle.update(c1, c2, &gen.NULL),
+                else => result: {
+                    assert(c.napi_get_arraybuffer_info(env, argv[3], &data, &len) == c.napi_ok);
+                    assert(len == gen.LOGS_SIZE);
+
+                    const buf = @as([*]u8, @ptrCast(data.?))[0..gen.LOGS_SIZE];
+                    var writer: pkmn.protocol.Writer = .{ .buffer = buf };
+                    // TODO: extract out
+                    var opts = pkmn.battle.options(
+                        pkmn.protocol.FixedLog{ .writer = &writer },
+                        gen.chance.NULL,
+                        gen.calc.NULL,
+                    );
+                    break :result battle.update(c1, c2, &opts);
+                },
+            } catch unreachable;
+
+            return js.Number.init(env, @as(u8, @bitCast(result)));
+        }
+    }.call;
+}
+
+fn choices(gen: anytype) c.napi_callback {
+    return struct {
+        fn call(env: c.napi_env, info: c.napi_callback_info) callconv(.c) c.napi_value {
+            var argc: usize = 4;
+            var argv: [4]c.napi_value = undefined;
+            assert(c.napi_get_cb_info(env, info, &argc, &argv, null, null) == c.napi_ok);
+            assert(argc == 4);
+
+            var data: ?*anyopaque = undefined;
+            var len: usize = 0;
+            assert(c.napi_get_arraybuffer_info(env, argv[0], &data, &len) == c.napi_ok);
+            assert(len == @sizeOf(gen.Battle(gen.PRNG)));
+
+            var battle: *gen.Battle(gen.PRNG) = @ptrCast(@alignCast(data.?));
+            const player: pkmn.Player = @enumFromInt(js.Number.get(env, argv[1], u8));
+            const request: pkmn.Choice.Type = @enumFromInt(js.Number.get(env, argv[2], u8));
+
+            assert(c.napi_get_arraybuffer_info(env, argv[3], &data, &len) == c.napi_ok);
+            assert(len == gen.CHOICES_SIZE);
+
+            const out = @as([*]pkmn.Choice, @ptrCast(data.?))[0..gen.CHOICES_SIZE];
+            const n = battle.choices(player, request, out);
+            return js.Number.init(env, @as(u8, @bitCast(n)));
+        }
+    }.call;
+}

package/src/lib/bindings/wasm.zig

@@ -0,0 +1,51 @@
+const pkmn = @import("../pkmn.zig");
+const std = @import("std");
+const util = @import("../common/util.zig");
+
+const assert = std.debug.assert;
+
+pub const options = pkmn.options;
+
+pub fn gen(comptime num: comptime_int) type {
+    const g = @field(pkmn, "gen" ++ std.fmt.comptimePrint("{d}", .{num}));
+    return struct {
+        pub const CHOICES_SIZE = size(g.CHOICES_SIZE);
+        pub const LOGS_SIZE = size(g.LOGS_SIZE);
+
+        pub fn update(
+            battle: *g.Battle(g.PRNG),
+            c1: pkmn.Choice,
+            c2: pkmn.Choice,
+            options_: ?[*]u8,
+        ) callconv(.c) pkmn.Result {
+            return (if (options_) |o| result: {
+                const buf = @as([*]u8, @ptrCast(o))[0..g.LOGS_SIZE];
+                var writer: pkmn.protocol.Writer = .{ .buffer = buf };
+                // TODO: extract out
+                var opts = pkmn.battle.options(
+                    pkmn.protocol.FixedLog{ .writer = &writer },
+                    g.chance.NULL,
+                    g.calc.NULL,
+                );
+                break :result battle.update(c1, c2, &opts);
+            } else battle.update(c1, c2, &g.NULL)) catch unreachable;
+        }
+
+        pub fn choices(
+            battle: *g.Battle(g.PRNG),
+            player: u8,
+            request: u8,
+            buf: [*]u8,
+        ) callconv(.c) u8 {
+            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]));
+        }
+    };
+}
+
+fn size(n: usize) u32 {
+    return std.math.ceilPowerOfTwo(u32, @as(u32, @intCast(n))) catch unreachable;
+}