@pkmn/engine 0.1.0-dev.1da0f17c → 0.1.0-dev.207fa86a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.1da0f17c",
+  "version": "0.1.0-dev.207fa86a",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
@@ -9,96 +9,85 @@
   "types": "build/pkg/index.d.ts",
   "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/data.js",
-    "build/pkg/data/ids.json",
-    "build/pkg/data/layout.json",
-    "build/pkg/data/protocol.json",
-    "build/pkg/gen1.d.ts",
-    "build/pkg/gen1.js.map",
-    "build/pkg/gen1.js",
-    "build/pkg/index.d.ts",
-    "build/pkg/index.js.map",
-    "build/pkg/index.js",
-    "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",
     "src/lib/common/data.zig",
-    "src/lib/common/debug.zig",
     "src/lib/common/options.zig",
     "src/lib/common/protocol.zig",
     "src/lib/common/rng.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/data.zig",
     "src/lib/gen1/helpers.zig",
     "src/lib/gen1/mechanics.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/data.zig",
     "src/lib/gen2/helpers.zig",
     "src/lib/gen2/mechanics.zig",
     "src/lib/pkmn.zig",
-    "src/test/display/pkmn.html.tmpl"
+    "build/pkg/data/ids.json",
+    "build/pkg/data/layout.json",
+    "build/pkg/data/protocol.json",
+    "build/pkg/data.d.ts",
+    "build/pkg/data.js",
+    "build/pkg/data.js.map",
+    "build/pkg/gen1.d.ts",
+    "build/pkg/gen1.js",
+    "build/pkg/gen1.js.map",
+    "build/pkg/index.d.ts",
+    "build/pkg/index.js",
+    "build/pkg/index.js.map",
+    "build/pkg/protocol.d.ts",
+    "build/pkg/protocol.js",
+    "build/pkg/protocol.js.map"
   ],
   "engines": {
     "node": ">=16.0.0"
   },
   "bin": {
-    "install-pkmn-engine": "src/bin/install-pkmn-engine",
-    "pkmn-debug": "src/bin/pkmn-debug"
+    "install-pkmn-engine": "src/bin/install-pkmn-engine"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@pkmn/data": "^0.7.37",
+    "@pkmn/data": "^0.7.33",
     "@pkmn/protocol": "^0.6.11"
   },
   "devDependencies": {
-    "@pkmn/eslint-config": "^3.0.0",
+    "@pkmn/eslint-config": "^3.0.0-alpha.0",
     "@pkmn/img": "^0.2.8",
     "@pkmn/sets": "^5.0.4",
-    "@pkmn/sim": "0.7.37",
+    "@pkmn/sim": "0.7.33",
     "@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",
+    "@vitest/coverage-c8": "^0.29.8",
     "binaryen": "^112.0.0",
-    "eslint": "^8.38.0",
+    "eslint": "^8.37.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",
     "trakr": "^0.2.0",
-    "typescript": "^5.0.4",
-    "vitest": "^0.30.1"
+    "typescript": "^5.0.2",
+    "vitest": "^0.29.8"
   },
   "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 --ext ts,js && eslint src/bin/install-pkmn-engine",
+    "fix": "eslint --fix src --ext ts,js && eslint --fix src/bin/install-pkmn-engine",
     "compile": "tsc -p .",
     "build": "npm run compile",
     "test": "vitest src/pkg",
     "test:integration": "vitest src/test",
-    "debug": "npm run compile && node build/tools/debug",
     "fuzz": "npm run compile && node build/test/fuzz",
     "generate": "npm run compile && node build/tools/generate",
     "release": "npm run compile && node build/tools/release",
@@ -199,4 +188,4 @@
       }
     ]
   }
-}
+}

package/src/bin/install-pkmn-engine

@@ -10,15 +10,13 @@ const path = require('path');
 const {pipeline} = require('stream/promises');
 const tty = require('tty');
 
-const ZIG_VERSION = {major: 0, minor: 11, patch: 0, dev: 2560};
+const ZIG_VERSION = {major: 0, minor: 11, patch: 0, dev: 2168};
 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';
 const ROOT = path.resolve(__dirname, '..', '..');
-let SILENT = false;
 
 const sh = (cmd, args) => execFileSync(cmd, args, {encoding: 'utf8', cwd: ROOT});
-const log = (...args) => { if (!SILENT) console.log(...args); };
 
 // This is hardly the browser fetch API, but it works for our primitive needs
 const fetch = url => new Promise((resolve, reject) => {
@@ -63,7 +61,7 @@ const unpack7 = (input, output) => new Promise((resolve, reject) => {
     require.resolve('7zip-min');
   } catch (err) {
     if (err.code !== 'MODULE_NOT_FOUND') throw err;
-    log('Installing 7zip-min package locally to unpack the archive...');
+    console.log('Installing 7zip-min package locally to unpack the archive...');
     sh('npm', ['install', '7zip-min', '--no-audit', '--no-save']);
   }
 
@@ -85,7 +83,7 @@ const unpack = async (input, output) => {
       sh('tar', ['xf', input, '-C', output]);
       return;
     } catch {
-      log('tar command not found, falling back to 7z');
+      console.log('tar command not found, falling back to 7z');
     }
   }
   // Try to use a 7z binary if we can, and only install 7zip-min as a last resort
@@ -122,10 +120,10 @@ const find = zig => {
         (!ZIG_VERSION.dev || (dev && dev >= ZIG_VERSION.dev)));
 
     if (compatible) {
-      log('Found existing compatible Zig executable:', zig_exe);
+      console.log('Found existing compatible Zig executable:', zig_exe);
       return zig_exe;
     } else {
-      log(`Existing Zig executable is not compatible (${version} < ${VERSION}):`, zig_exe);
+      console.log(`Existing Zig executable is not compatible (${version} < ${VERSION}):`, zig_exe);
     }
   } catch (err) {
     if (err.code !== 'ENOENT') throw err;
@@ -170,11 +168,11 @@ const install = async () => {
   let base = path.basename(url);
   const archive = path.join(dir, path.basename(url));
 
-  log(`Downloading Zig tarball from ${url} to ${archive}`);
+  console.log(`Downloading Zig tarball from ${url} to ${archive}`);
   try {
     await download(url, archive, release.shasum);
 
-    log(`Extracting tarball and installing to ${dir}`);
+    console.log(`Extracting tarball and installing to ${dir}`);
     await unpack(archive, dir);
     if (archive.endsWith('.zip')) {
       base = base.slice(0, -4);
@@ -189,17 +187,17 @@ const install = async () => {
     } catch (err) {
       if (err.code !== 'ENOENT') throw err;
     }
-    log(`Zig${version === 'master' ? '' : ` v${version}`} executable:`, zig,
+    console.log(`Zig${version === 'master' ? '' : ` v${version}`} executable:`, zig,
       '(this version of Zig will be retained to speed up future updates)');
     const [pre, post] = tty.isatty(1) ? ['\x1b[1m\x1b[35m', '\x1b[0m'] : ['', ''];
-    log(
+    console.log(
       `${pre}Consider moving the ${path.dirname(zig)} directory and adding it to your PATH`,
       `to use Zig on other projects, or delete this if you wish to save space.${post}`
     );
 
     return zig;
   } finally {
-    log(`Cleaning up ${archive}`);
+    console.log(`Cleaning up ${archive}`);
     try { fs.rmSync(archive); } catch {}
   }
 };
@@ -208,17 +206,17 @@ const install = async () => {
 const downloadHeaders = async () => {
   const include = path.resolve(process.execPath, '..', '..', 'include', 'node');
   if (fs.existsSync(path.join(include, 'node.h'))) {
-    log('Node headers:', include);
+    console.log('Node headers:', include);
     return include;
   }
 
   const dir = path.join(ROOT, 'build', 'include');
-  const dest = path.join(dir, 'node');
+  const dest = path.join(dir, `node-${process.version}`, 'include', 'node');
   if (fs.existsSync(path.join(dest, 'node.h'))) {
-    log('Node headers:', dest);
+    console.log('Node headers:', dest);
     return dest;
   } else {
-    log(`Could not find Node headers at ${include}, downloading...`);
+    console.log(`Could not find Node headers at ${include}, downloading...`);
   }
 
   try {
@@ -229,28 +227,20 @@ const downloadHeaders = async () => {
 
   const url = process.release.headersUrl;
   const targz = path.join(dir, path.basename(url));
-  const unpacked = path.join(dir, `node-${process.version}`, 'include');
 
-  log(`Downloading Node headers from ${url} to ${targz}`);
+  console.log(`Downloading Node headers from ${url} to ${targz}`);
+  await download(url, targz);
+  await unpack(targz, dir);
 
-  try {
-    await download(url, targz);
-    await unpack(targz, dir);
-    fs.renameSync(path.join(unpacked, 'node'), dest);
-
-    log('Node headers:', dest);
+  console.log('Node headers:', dest);
 
-    return dest;
-  } finally {
-    try { fs.rmSync(targz); } catch {}
-    try { fs.rmSync(unpacked, {recursive: true}); } catch {}
-  }
+  return dest;
 };
 
 const downloadImportLib = async () => {
   const library = path.resolve(process.execPath, '..', 'node.lib');
   if (fs.existsSync(path.join(library, 'node.h'))) {
-    log('Node import library:', library);
+    console.log('Node import library:', library);
     return library;
   }
 
@@ -258,10 +248,10 @@ const downloadImportLib = async () => {
   const url = new URL('./win-x64/node.lib', process.release.headersUrl).href;
   const dest = path.join(dir, path.basename(url));
   if (fs.existsSync(path.join(dest))) {
-    log('Node import library:', dest);
+    console.log('Node import library:', dest);
     return dest;
   } else {
-    log(`Could not find Node import library at ${library}, downloading...`);
+    console.log(`Could not find Node import library at ${library}, downloading...`);
   }
 
   try {
@@ -270,41 +260,24 @@ const downloadImportLib = async () => {
     if (err.code !== 'EEXIST') throw err;
   }
 
-  log(`Downloading Node import library from ${url} to ${dest}`);
+  console.log(`Downloading Node import library from ${url} to ${dest}`);
   await download(url, dest);
-  log('Node import library:', dest);
+  console.log('Node import library:', dest);
 
   return dest;
 };
 
 (async () => {
-  let only = false;
-  let options = undefined;
-  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(' ');
-    }
-    }
-  }
-  if (error) {
+  const options = (process.argv[2] || '').startsWith('--options=')
+    ? process.argv[2].slice(10).split(' ') : undefined;
+  if (process.argv.length > 3 ||
+    process.argv.length === 3 && !(process.argv[2] === '--zig' || options)) {
     console.error('Invalid arguments');
     process.exit(1);
   }
 
   const zig = await install();
-  if (only) process.exit(0);
+  if (process.argv[2] === '--zig') process.exit(0);
 
   let tmp;
   try {
@@ -337,13 +310,13 @@ const downloadImportLib = async () => {
         if (!options) {
           const addon = require(copy);
           if (addon.options.showdown) opts.push('-Dshowdown');
-          if (addon.options.log) opts.push('-Dlog');
+          if (addon.options.trace) opts.push('-Dtrace');
         }
       } 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.TRACE.value]) opts.push('-Dtrace');
       }
       const key = `${type} ${opts.sort().join(' ')}`;
       if (!configs.has(key)) configs.set(key, {type, options: opts});
@@ -374,7 +347,7 @@ const downloadImportLib = async () => {
       opts.includes('-Dshowdown') || opts.includes('-Dshowdown=true') ? '-showdown' : '';
     const flags = opts.length ? ` (${opts.join(' ')})` : '';
     const artifact = path.join('build', 'lib', `pkmn${suffix}.${config.type}`);
-    log(`Building ${artifact}${flags}`);
+    console.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') {
@@ -382,7 +355,7 @@ const downloadImportLib = async () => {
       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));
+      fs.renameSync(actual, artifact);
     }
   }
 })().catch(e => {

package/src/lib/binding/node.zig

@@ -21,7 +21,7 @@ fn options(env: c.napi_env) c.napi_value {
     var object = Object.init(env);
     const properties = [_]c.napi_property_descriptor{
         Property.init("showdown", .{ .value = Boolean.init(env, pkmn.options.showdown) }),
-        Property.init("log", .{ .value = Boolean.init(env, pkmn.options.log) }),
+        Property.init("trace", .{ .value = Boolean.init(env, pkmn.options.trace) }),
     };
     assert(c.napi_define_properties(env, object, properties.len, &properties) == c.napi_ok);
     return object;
@@ -34,11 +34,11 @@ fn bindings(env: c.napi_env) c.napi_value {
 }
 
 fn bind(env: c.napi_env, gen: anytype) c.napi_value {
-    const choices_size = @intCast(u32, gen.CHOICES_SIZE);
+    const options_size = @intCast(u32, gen.OPTIONS_SIZE);
     const logs_size = @intCast(u32, gen.LOGS_SIZE);
     var object = Object.init(env);
     const properties = [_]c.napi_property_descriptor{
-        Property.init("CHOICES_SIZE", .{ .value = Number.init(env, choices_size) }),
+        Property.init("OPTIONS_SIZE", .{ .value = Number.init(env, options_size) }),
         Property.init("LOGS_SIZE", .{ .value = Number.init(env, logs_size) }),
         Property.init("update", .{ .method = update(gen) }),
         Property.init("choices", .{ .method = choices(gen) }),
@@ -108,10 +108,10 @@ fn choices(gen: anytype) c.napi_callback {
             const request = @intToEnum(pkmn.Choice.Type, 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);
+            assert(len == gen.OPTIONS_SIZE);
             assert(data != null);
 
-            var out = @ptrCast([*]pkmn.Choice, data.?)[0..gen.CHOICES_SIZE];
+            var out = @ptrCast([*]pkmn.Choice, data.?)[0..gen.OPTIONS_SIZE];
             const n = battle.choices(player, request, out);
             return Number.init(env, @bitCast(u8, n));
         }

package/src/lib/binding/wasm.zig

@@ -2,9 +2,9 @@ const std = @import("std");
 const pkmn = @import("../pkmn.zig");
 
 export const SHOWDOWN = pkmn.options.showdown;
-export const LOG = pkmn.options.log;
+export const TRACE = pkmn.options.trace;
 
-export const GEN1_CHOICES_SIZE =
-    std.math.ceilPowerOfTwo(u32, @intCast(u32, pkmn.gen1.CHOICES_SIZE)) catch unreachable;
+export const GEN1_OPTIONS_SIZE =
+    std.math.ceilPowerOfTwo(u32, @intCast(u32, pkmn.gen1.OPTIONS_SIZE)) catch unreachable;
 export const GEN1_LOGS_SIZE =
     std.math.ceilPowerOfTwo(u32, @intCast(u32, pkmn.gen1.LOGS_SIZE)) catch unreachable;

package/src/lib/common/options.zig

@@ -3,7 +3,7 @@ const root = @import("root");
 
 pub const Options = struct {
     showdown: ?bool = null,
-    log: ?bool = null,
+    trace: ?bool = null,
     advance: ?bool = null,
     ebc: ?bool = null,
     internal: ?bool = null,
@@ -11,8 +11,8 @@ pub const Options = struct {
 
 /// Whether or not Pokémon Showdown compatibility mode is enabled.
 pub const showdown = get("showdown", false);
-/// Whether or not protocol message logging is enabled.
-pub const log = get("log", false);
+/// Whether or not protocol trace logging is enabled.
+pub const trace = get("trace", false);
 
 pub const advance = get("advance", true);
 pub const ebc = get("ebc", true);