@pkmn/engine 0.1.0-dev.d716e940 → 0.1.0-dev.d73cd76c

package/package.json

@@ -1,19 +1,31 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.d716e940",
+  "version": "0.1.0-dev.d73cd76c",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
   "sideEffects": false,
   "main": "build/pkg/index.js",
   "types": "build/pkg/index.d.ts",
+  "browser": {
+    "./build/pkg/addon/node.js": "./build/pkg/addon/browser.js"
+  },
   "files": [
     "build.zig",
-    "build/pkg/data.d.ts",
-    "build/pkg/data.js.map",
     "build/pkg/addon.d.ts",
     "build/pkg/addon.js.map",
     "build/pkg/addon.js",
+    "build/pkg/addon/browser.d.ts",
+    "build/pkg/addon/browser.js.map",
+    "build/pkg/addon/browser.js",
+    "build/pkg/addon/node.d.ts",
+    "build/pkg/addon/node.js.map",
+    "build/pkg/addon/node.js",
+    "build/pkg/addon/wasm.d.ts",
+    "build/pkg/addon/wasm.js.map",
+    "build/pkg/addon/wasm.js",
+    "build/pkg/data.d.ts",
+    "build/pkg/data.js.map",
     "build/pkg/data.js",
     "build/pkg/data/ids.json",
     "build/pkg/data/layout.json",
@@ -27,33 +39,54 @@
     "build/pkg/protocol.d.ts",
     "build/pkg/protocol.js.map",
     "build/pkg/protocol.js",
-    "build/test/display.js.map",
-    "build/test/display.js",
     "build/tools/debug.js.map",
     "build/tools/debug.js",
-    "src/bin/install-pkmn-engine",
-    "src/lib/binding/node.zig",
-    "src/lib/binding/wasm.zig",
+    "build/tools/display/index.js.map",
+    "build/tools/display/index.js",
+    "build/tools/display/debug.jsx.map",
+    "build/tools/display/debug.jsx",
+    "build/tools/display/ui.jsx.map",
+    "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",
     "src/lib/common/debug.zig",
+    "src/lib/common/js.zig",
+    "src/lib/common/optional.zig",
     "src/lib/common/options.zig",
     "src/lib/common/protocol.zig",
+    "src/lib/common/rational.zig",
     "src/lib/common/rng.zig",
+    "src/lib/common/util.zig",
+    "src/lib/gen1/calc.zig",
+    "src/lib/gen1/chance.zig",
     "src/lib/gen1/data.zig",
     "src/lib/gen1/data/moves.zig",
     "src/lib/gen1/data/species.zig",
     "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/napi.h",
+    "src/lib/node.zig",
     "src/lib/pkmn.zig",
-    "src/test/display/pkmn.html.tmpl"
+    "src/lib/wasm.zig",
+    "src/tools/display/dom.ts",
+    "src/tools/display/ui.css"
   ],
   "engines": {
     "node": ">=16.0.0"
@@ -66,138 +99,55 @@
     "access": "public"
   },
   "dependencies": {
-    "@pkmn/data": "^0.7.38",
-    "@pkmn/protocol": "^0.6.11"
+    "@pkmn/data": "0.9.35",
+    "@pkmn/protocol": "^0.7.3"
   },
   "devDependencies": {
-    "@pkmn/eslint-config": "^3.0.0",
-    "@pkmn/img": "^0.2.8",
-    "@pkmn/sets": "^5.0.4",
-    "@pkmn/sim": "0.7.38",
-    "@types/html-minifier": "^4.0.2",
-    "@types/jest": "^29.5.0",
-    "@types/minimist": "^1.2.2",
-    "@types/mustache": "^4.2.2",
-    "@types/node": "^18.15.11",
-    "@vitest/coverage-c8": "^0.30.1",
-    "binaryen": "^112.0.0",
-    "eslint": "^8.38.0",
+    "@pkmn/dex-types": "0.9.35",
+    "@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",
+    "@types/html-minifier": "^4.0.6",
+    "@types/jest": "^30.0.0",
+    "@types/minimist": "^1.2.5",
+    "@types/mustache": "^4.2.6",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.17",
+    "@types/semver": "^7.7.1",
+    "@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": "4.0.0",
+    "json-stringify-pretty-compact": "3.0.0",
     "minimist": "^1.2.8",
     "mustache": "^4.2.0",
+    "semver": "^7.8.5",
     "source-map-support": "^0.5.21",
+    "table": "^6.9.0",
     "trakr": "^0.2.0",
-    "typescript": "^5.0.4",
-    "vitest": "^0.30.1"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
   },
   "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",
     "test:integration": "vitest src/test",
     "debug": "npm run compile && node build/tools/debug",
+    "demo": "npm run compile && node build/tools/demo",
     "fuzz": "npm run compile && node build/test/fuzz",
     "generate": "npm run compile && node build/tools/generate",
     "release": "npm run compile && node build/tools/release",
     "benchmark": "npm run compile && node build/test/benchmark",
     "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/",
-      "src/examples/zig",
-      "build/"
-    ],
-    "env": {
-      "es6": true,
-      "node": true,
-      "browser": true
-    },
-    "overrides": [
-      {
-        "files": [
-          "**/*.ts"
-        ],
-        "parserOptions": {
-          "project": [
-            "./tsconfig.json",
-            "./src/examples/js/tsconfig.json"
-          ]
-        }
-      },
-      {
-        "files": [
-          "src/pkg/index.ts",
-          "src/test/display.ts",
-          "src/test/integration.ts"
-        ],
-        "rules": {
-          "no-control-regex": "off",
-          "@typescript-eslint/no-empty-interface": "off",
-          "@typescript-eslint/no-shadow": "off"
-        }
-      },
-      {
-        "files": [
-          "src/pkg/addon.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/no-var-requires": "off"
-        }
-      },
-      {
-        "files": [
-          "src/test/benchmark*.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/no-unused-vars": "off"
-        }
-      },
-      {
-        "files": [
-          "src/test/*.test.ts",
-          "src/test/regression/*.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, dev: 2750};
+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 {zig_exe, version} = parse(sh(zig, ['env']));
     const [major, minor, patch, dev] = version.split('.').map(n => parseInt(n));
 
     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))));
 
     if (compatible) {
       log('Found existing compatible Zig executable:', zig_exe);
@@ -164,6 +180,7 @@ const install = async () => {
 
   const index = JSON.parse(await fetch(INDEX));
   const version = Object.keys(index)[+!ZIG_VERSION.dev];
+  // const version = VERSION; // TODO
   const release = index[version][`${arch}-${platform}`];
   const url = release.tarball;
 
@@ -255,7 +272,7 @@ const downloadImportLib = async () => {
   }
 
   const dir = path.join(ROOT, 'build', 'lib');
-  const url = new URL('./win-x64/node.lib', process.release.headersUrl).href;
+  const url = process.release.libUrl;
   const dest = path.join(dir, path.basename(url));
   if (fs.existsSync(path.join(dest))) {
     log('Node import library:', dest);
@@ -283,19 +300,19 @@ const downloadImportLib = async () => {
   let error = false;
   for (let i = 2; i < process.argv.length; i++) {
     switch (process.argv[i]) {
-    case "--silent": {
-      SILENT = true;
-      break;
-    }
-    case "--zig": {
-      if (options || only) error = true;
-      only = true;
-      break;
-    }
-    default: {
-      if (options || only || !process.argv[i].startsWith('--options=')) error = true;
-      options = process.argv[i].slice(10).split(' ');
-    }
+      case "--silent": {
+        SILENT = true;
+        break;
+      }
+      case "--zig": {
+        if (options || only) error = true;
+        only = true;
+        break;
+      }
+      default: {
+        if (options || only || !process.argv[i].startsWith('--options=')) error = true;
+        options = process.argv[i].slice(10).split(' ');
+      }
     }
   }
   if (error) {
@@ -323,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
@@ -336,14 +354,18 @@ const downloadImportLib = async () => {
         node = true;
         if (!options) {
           const addon = require(copy);
-          if (addon.options.showdown) opts.push('-Dshowdown');
-          if (addon.options.log) opts.push('-Dlog');
+          if (addon.engine.options.showdown) opts.push('-Dshowdown');
+          if (addon.engine.options.log) opts.push('-Dlog');
+          if (addon.engine.options.chance) opts.push('-Dchance');
+          if (addon.engine.options.calc) opts.push('-Dcalc');
         }
       } else if (!options) {
         const addon = await WebAssembly.instantiate(fs.readFileSync(copy));
         const values = new Uint8Array(addon.instance.exports.memory.buffer);
         if (values[addon.instance.exports.SHOWDOWN.value]) opts.push('-Dshowdown');
         if (values[addon.instance.exports.LOG.value]) opts.push('-Dlog');
+        if (values[addon.instance.exports.CHANCE.value]) opts.push('-Dchance');
+        if (values[addon.instance.exports.CALC.value]) opts.push('-Dcalc');
       }
       const key = `${type} ${opts.sort().join(' ')}`;
       if (!configs.has(key)) configs.set(key, {type, options: opts});
@@ -354,8 +376,9 @@ const downloadImportLib = async () => {
   // either the default options or whatever was passed in
   if (!configs.size) {
     node = true;
-    configs.set('node', {type: 'node', options: options || ['-Dshowdown']});
-    configs.set('wasm', {type: 'wasm', options: options || ['-Dshowdown']});
+    const DEFAULT = ['-Dshowdown'];
+    configs.set('node', {type: 'node', options: options || DEFAULT});
+    configs.set('wasm', {type: 'wasm', options: options || DEFAULT});
   }
 
   const headers = node ? await downloadHeaders() : undefined;
@@ -365,8 +388,10 @@ const downloadImportLib = async () => {
     const args = ['build', '-p', 'build', ...opts];
     if (!process.env.DEBUG_PKMN_ENGINE) args.push('-Doptimize=ReleaseFast', '-Dstrip');
     if (config.type === 'node') {
-      args.push(`-Dnode-headers=${headers}`);
-      if (process.platform === 'win32') args.push(`-Dnode-import-library=${lib}`);
+      args.push(`-Dnode-headers=${path.relative(ROOT, headers)}`);
+      if (process.platform === 'win32') {
+        args.push(`-Dnode-import-library=${path.relative(ROOT, lib)}`);
+      }
     } else {
       args.push('-Dwasm');
     }
@@ -381,8 +406,14 @@ const downloadImportLib = async () => {
       const prefix = process.platform === 'win32' ? '' : 'lib';
       const ext = process.platform === 'darwin'
         ? 'dylib' : process.platform === 'win32' ? 'dll' : 'so';
-      const actual = path.join('build', 'lib', `${prefix}pkmn${suffix}.node.${ext}`);
-      fs.renameSync(path.join(ROOT, actual), path.join(ROOT, artifact));
+      try {
+        const actual = path.join(ROOT, 'build', 'lib', `${prefix}pkmn${suffix}.node.${ext}`);
+        fs.renameSync(actual, artifact);
+      } catch {
+        // ziglang/zig#19743 changed this path
+        const actual = path.join(ROOT, 'build', 'bin', `${prefix}pkmn${suffix}.node.${ext}`);
+        fs.renameSync(actual, artifact);
+      }
     }
   }
 })().catch(e => {

package/src/bin/pkmn-debug

@@ -15,7 +15,7 @@ const ROOT = resolve(__dirname, '..', '..');
 const packageJSON = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'));
 
 const missing = [];
-for (const dep of ['@pkmn/img', 'html-minifier', 'mustache']) {
+for (const dep of ['@pkmn/img', 'html-minifier', 'esbuild']) {
   try {
     require.resolve(dep);
   } catch (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]));
+        }
+    };
+}