@pkmn/engine 0.1.0-dev.3a62fd35 → 0.1.0-dev.3de821b9

package/build.zig

@@ -1,26 +1,6 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-pub const Options = struct {
-    showdown: ?bool = null,
-    log: ?bool = null,
-    chance: ?bool = null,
-    calc: ?bool = null,
-};
-
-pub fn module(b: *std.Build, options: Options) *std.Build.Module {
-    const dirname = comptime std.fs.path.dirname(@src().file) orelse ".";
-    const build_options = b.addOptions();
-    build_options.addOption(?bool, "showdown", options.showdown);
-    build_options.addOption(?bool, "log", options.log);
-    build_options.addOption(?bool, "chance", options.chance);
-    build_options.addOption(?bool, "calc", options.calc);
-    return b.createModule(.{
-        .root_source_file = .{ .path = dirname ++ "/src/lib/pkmn.zig" },
-        .imports = &.{.{ .name = "build_options", .module = build_options.createModule() }},
-    });
-}
-
 pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
@@ -44,7 +24,7 @@ pub fn build(b: *std.Build) !void {
     defer parsed.deinit();
     const version = parsed.value.object.get("version").?.string;
     const description = parsed.value.object.get("description").?.string;
-    var repository = std.mem.split(u8, parsed.value.object.get("repository").?.string, ":");
+    var repository = std.mem.splitSequence(u8, parsed.value.object.get("repository").?.string, ":");
     std.debug.assert(std.mem.eql(u8, repository.first(), "github"));
 
     const showdown =
@@ -61,22 +41,29 @@ pub fn build(b: *std.Build) !void {
 
     const name = if (showdown) "pkmn-showdown" else "pkmn";
 
+    const module = b.addModule("pkmn", .{
+        .root_source_file = b.path("src/lib/pkmn.zig"),
+        .optimize = optimize,
+        .target = target,
+        .imports = &.{.{ .name = "build_options", .module = options.createModule() }},
+    });
+
     var c = false;
     if (node_headers) |headers| {
         const addon = b.fmt("{s}.node", .{name});
         const lib = b.addSharedLibrary(.{
             .name = addon,
-            .root_source_file = .{ .path = "src/lib/node.zig" },
+            .root_source_file = b.path("src/lib/node.zig"),
             .optimize = optimize,
             .target = target,
             .strip = strip,
             .pic = pic,
         });
         lib.root_module.addOptions("build_options", options);
-        lib.addSystemIncludePath(.{ .path = headers });
+        lib.addSystemIncludePath(b.path(headers));
         lib.linkLibC();
         if (node_import_lib) |il| {
-            lib.addObjectFile(.{ .path = il });
+            lib.addObjectFile(b.path(il));
         } else if (target.result.os.tag == .windows) {
             try std.io.getStdErr().writeAll("Must provide --node-import-library path on Windows\n");
             std.process.exit(1);
@@ -84,7 +71,7 @@ pub fn build(b: *std.Build) !void {
         lib.linker_allow_shlib_undefined = true;
         maybeStrip(b, lib, b.getInstallStep(), strip, cmd);
         // Always emit to build/lib because this is where the driver code expects to find it
-        // TODO(ziglang/zig#2231): using the following used to work (though was hacky):
+        // TODO: ziglang/zig#2231 - using the following used to work (though was hacky):
         //
         //    lib.emit_bin = .{ .emit_to = b.fmt("build/lib/{s}", .{addon}) };
         //    b.getInstallStep().dependOn(&lib.step);
@@ -95,7 +82,7 @@ pub fn build(b: *std.Build) !void {
     } else if (wasm) {
         const exe = b.addExecutable(.{
             .name = name,
-            .root_source_file = .{ .path = "src/lib/wasm.zig" },
+            .root_source_file = b.path("src/lib/wasm.zig"),
             .optimize = switch (optimize) {
                 .ReleaseFast, .ReleaseSafe => .ReleaseSmall,
                 else => optimize,
@@ -121,7 +108,7 @@ pub fn build(b: *std.Build) !void {
             const sh = b.addSystemCommand(&.{ opt.?, "-O4" });
             sh.addArtifactArg(exe);
             sh.addArg("-o");
-            sh.addFileArg(.{ .path = out });
+            sh.addFileArg(b.path(out));
             b.getInstallStep().dependOn(&sh.step);
         } else {
             b.getInstallStep().dependOn(&b.addInstallArtifact(exe, .{
@@ -131,7 +118,7 @@ pub fn build(b: *std.Build) !void {
     } else if (dynamic) {
         const lib = b.addSharedLibrary(.{
             .name = name,
-            .root_source_file = .{ .path = "src/lib/c.zig" },
+            .root_source_file = b.path("src/lib/c.zig"),
             .version = try std.SemanticVersion.parse(version),
             .optimize = optimize,
             .target = target,
@@ -139,21 +126,21 @@ pub fn build(b: *std.Build) !void {
             .pic = pic,
         });
         lib.root_module.addOptions("build_options", options);
-        lib.addIncludePath(.{ .path = "src/include" });
+        lib.addIncludePath(b.path("src/include"));
         maybeStrip(b, lib, b.getInstallStep(), strip, cmd);
         b.installArtifact(lib);
         c = true;
     } else {
         const lib = b.addStaticLibrary(.{
             .name = name,
-            .root_source_file = .{ .path = "src/lib/c.zig" },
+            .root_source_file = b.path("src/lib/c.zig"),
             .optimize = optimize,
             .target = target,
             .strip = strip,
             .pic = pic,
         });
         lib.root_module.addOptions("build_options", options);
-        lib.addIncludePath(.{ .path = "src/include" });
+        lib.addIncludePath(b.path("src/include"));
         lib.bundle_compiler_rt = true;
         maybeStrip(b, lib, b.getInstallStep(), strip, cmd);
         if (emit_asm) {
@@ -176,14 +163,18 @@ pub fn build(b: *std.Build) !void {
 
     if (c) {
         const header = b.addInstallFileWithDir(
-            .{ .path = "src/include/pkmn.h" },
+            b.path("src/include/pkmn.h"),
             .header,
             "pkmn.h",
         );
         b.getInstallStep().dependOn(&header.step);
 
         const pc = b.fmt("lib{s}.pc", .{name});
-        const file = try b.cache_root.join(b.allocator, &.{pc});
+        const file = try std.fs.path.relative(
+            b.allocator,
+            try std.process.getCwdAlloc(b.allocator),
+            try b.cache_root.join(b.allocator, &.{pc}),
+        );
         const pkgconfig_file = try std.fs.cwd().createFile(file, .{});
 
         const dirname = comptime std.fs.path.dirname(@src().file) orelse ".";
@@ -218,12 +209,8 @@ pub fn build(b: *std.Build) !void {
 
     var exes = std.ArrayList(*std.Build.Step.Compile).init(b.allocator);
     const tools: ToolConfig = .{
-        .options = .{
-            .showdown = showdown,
-            .log = log,
-            .chance = chance,
-            .calc = calc,
-        },
+        .showdown = showdown,
+        .module = module,
         .general = config,
         .tool = .{
             .tests = if (tests.build) tests else null,
@@ -294,7 +281,6 @@ const TestStep = struct {
 
     pub fn create(b: *std.Build, options: *std.Build.Step.Options, config: Config) *TestStep {
         const coverage = b.option([]const u8, "test-coverage", "Generate test coverage");
-        const test_file = b.option([]const u8, "test-file", "Input file for test");
         const test_filter =
             b.option([]const u8, "test-filter", "Skip tests that do not match filter");
 
@@ -302,13 +288,8 @@ const TestStep = struct {
         const step = std.Build.Step.init(.{ .id = .custom, .name = "Run all tests", .owner = b });
         self.* = .{ .step = step, .build = test_filter == null };
 
-        const path = test_file orelse "src/lib/test.zig";
         const tests = b.addTest(.{
-            .name = b.fmt("{s}-{s}", .{
-                std.fs.path.basename(std.fs.path.dirname(path).?),
-                std.fs.path.stem(std.fs.path.basename(path)),
-            }),
-            .root_source_file = .{ .path = path },
+            .root_source_file = b.path("src/lib/test.zig"),
             .optimize = config.optimize,
             .target = config.target,
             .filter = test_filter,
@@ -328,7 +309,8 @@ const TestStep = struct {
 };
 
 const ToolConfig = struct {
-    options: Options,
+    showdown: ?bool,
+    module: *std.Build.Module,
     general: Config,
     tool: struct {
         tests: ?*TestStep,
@@ -345,18 +327,18 @@ fn tool(b: *std.Build, path: []const u8, config: ToolConfig) !?*std.Build.Step.R
     var name = config.tool.name orelse std.fs.path.basename(path);
     const index = std.mem.lastIndexOfScalar(u8, name, '.');
     if (index) |i| name = name[0..i];
-    if (config.options.showdown orelse false) name = b.fmt("{s}-showdown", .{name});
+    if (config.showdown orelse false) name = b.fmt("{s}-showdown", .{name});
 
     const exe = b.addExecutable(.{
         .name = name,
-        .root_source_file = .{ .path = path },
+        .root_source_file = b.path(path),
         .target = config.general.target,
         .optimize = config.general.optimize,
         .single_threaded = true,
         .strip = config.general.strip,
         .pic = config.general.pic,
     });
-    exe.root_module.addImport("pkmn", module(b, config.options));
+    exe.root_module.addImport("pkmn", config.module);
 
     if (config.tool.tests) |ts| ts.step.dependOn(&exe.step);
     config.tool.exes.append(exe) catch @panic("OOM");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.3a62fd35",
+  "version": "0.1.0-dev.3de821b9",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
@@ -31,7 +31,6 @@
     "build/test/display.js",
     "build/tools/debug.js.map",
     "build/tools/debug.js",
-    "src/bin/install-pkmn-engine",
     "src/lib/common/battle.zig",
     "src/lib/common/data.zig",
     "src/lib/common/debug.zig",
@@ -76,31 +75,31 @@
     "access": "public"
   },
   "dependencies": {
-    "@pkmn/data": "^0.8.1",
-    "@pkmn/protocol": "^0.6.17"
+    "@pkmn/data": "^0.9.11",
+    "@pkmn/protocol": "^0.6.25"
   },
   "devDependencies": {
-    "@pkmn/eslint-config": "^6.4.0",
-    "@pkmn/img": "^0.2.20",
-    "@pkmn/sets": "^5.1.0",
-    "@pkmn/sim": "0.8.1",
+    "@pkmn/eslint-config": "^8.1.0",
+    "@pkmn/img": "^0.2.31",
+    "@pkmn/sets": "^5.1.2",
+    "@pkmn/sim": "0.9.11",
     "@types/html-minifier": "^4.0.5",
-    "@types/jest": "^29.5.11",
+    "@types/jest": "^29.5.12",
     "@types/minimist": "^1.2.5",
     "@types/mustache": "^4.2.5",
-    "@types/node": "^20.10.5",
-    "@vitest/coverage-v8": "^1.0.4",
-    "binaryen": "^116.0.0",
-    "eslint": "^8.56.0",
+    "@types/node": "^22.0.2",
+    "@vitest/coverage-v8": "^2.0.5",
+    "binaryen": "^118.0.0",
+    "eslint": "<=8",
     "html-minifier": "^4.0.0",
-    "json-stringify-pretty-compact": "3.0.0",
+    "json-stringify-pretty-compact": "4.0.0",
     "minimist": "^1.2.8",
     "mustache": "^4.2.0",
     "source-map-support": "^0.5.21",
-    "table": "^6.8.1",
+    "table": "^6.8.2",
     "trakr": "^0.2.0",
-    "typescript": "^5.3.3",
-    "vitest": "^1.0.4"
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5"
   },
   "scripts": {
     "lint": "eslint --cache src --ext ts,js && eslint src/bin/*",
@@ -142,6 +141,14 @@
           ]
         }
       },
+      {
+        "files": [
+          "src/test/display.ts"
+        ],
+        "rules": {
+          "@typescript-eslint/no-unnecessary-type-assertion": "off"
+        }
+      },
       {
         "files": [
           "src/pkg/index.ts",

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: 12, patch: 0, dev: 2036};
+const ZIG_VERSION = {major: 0, minor: 13, 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';
@@ -370,8 +370,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');
     }
@@ -386,8 +388,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('build', 'lib', `${prefix}pkmn${suffix}.node.${ext}`);
+        fs.renameSync(actual, artifact);
+      } catch (err) {
+        // ziglang/zig#19743 changed this path
+        const actual = path.join('build', 'bin', `${prefix}pkmn${suffix}.node.${ext}`);
+        fs.renameSync(actual, artifact);
+      }
     }
   }
 })().catch(e => {

package/src/lib/common/debug.zig

@@ -4,8 +4,8 @@ const debug = std.debug;
 const io = std.io;
 
 pub fn print(value: anytype) void {
-    debug.getStderrMutex().lock();
-    defer debug.getStderrMutex().unlock();
+    debug.lockStdErr();
+    defer debug.unlockStdErr();
     const stderr = io.getStdErr().writer();
 
     nosuspend {

package/src/lib/common/options.zig

@@ -10,6 +10,7 @@ pub const Options = struct {
     advance: ?bool = null,
     ebc: ?bool = null,
     key: ?bool = null,
+    miss: ?bool = null,
     internal: ?bool = null,
 };
 
@@ -25,6 +26,7 @@ pub const calc = get("calc", false);
 pub const advance = get("advance", true);
 pub const ebc = get("ebc", true);
 pub const key = get("key", false);
+pub const miss = get("miss", true);
 pub const internal = get("internal", false);
 
 fn get(comptime name: []const u8, default: bool) bool {

package/src/lib/common/protocol.zig

@@ -220,6 +220,7 @@ pub const Activate = enum(u8) {
     BeatUp, // FIXME of
 
     Magnitude,
+    Spite,
 };
 
 pub const Start = enum(u8) {
@@ -544,6 +545,7 @@ pub fn Log(comptime Writer: type) type {
         // ident: ID, reason: Activate
         // ident: ID, reason: .SubstituteBlock, m: <Move>
         // ident: ID, reason: .Magnitude, num: u8
+        // ident: ID, reason: .Spite, m: <Move>, num: u8
         pub fn activate(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -561,6 +563,9 @@ pub fn Log(comptime Writer: type) type {
                     assert(reason == .Magnitude);
                     try self.writer.writeByte(args[2]);
                 }
+            } else if (args.len == 4) {
+                assert(reason == .Spite);
+                try self.writer.writeAll(&.{ @intFromEnum(args[2]), args[3] });
             }
         }
 
@@ -859,7 +864,7 @@ pub const ByteStream = struct {
 pub const Kind = enum { Move, Species, Type, Status, Item, Weather };
 
 pub fn format(
-    comptime gen: anytype,
+    gen: anytype,
     a: []const u8,
     b: ?[]const u8,
     color: bool,
@@ -1202,14 +1207,11 @@ pub fn expectLog(
 ) !void {
     if (!enabled) return;
 
-    const color = color: {
-        if (std.process.hasEnvVarConstant("ZIG_DEBUG_COLOR")) {
-            break :color true;
-        } else if (std.process.hasEnvVarConstant("NO_COLOR")) {
-            break :color false;
-        } else {
-            break :color std.io.getStdErr().supportsAnsiEscapeCodes();
-        }
+    const color = if (std.process.hasEnvVarConstant("ZIG_DEBUG_COLOR"))
+        true
+    else switch (std.io.tty.detectConfig(std.io.getStdErr())) {
+        .escape_codes => true,
+        else => false,
     };
 
     expectEqualBytes(expected, actual, offset) catch |err| switch (err) {

package/src/lib/common/rational.zig

@@ -43,8 +43,7 @@ pub fn Rational(comptime T: type) type {
         /// Update the rational by multiplying its numerator by p and its denominator by q.
         /// Both p and q must be >= 1, and if computable at comptime must have no common factors.
         pub fn update(r: *Self, p: anytype, q: anytype) Error!void {
-            // FIXME
-            // std.debug.print("({d}/{d}) * ", .{ p, q });
+            // std.debug.print("({d}/{d}) * ", .{ p, q }); // DEBUG
             assert(p >= 1);
             assert(q >= 1);
 
@@ -202,23 +201,81 @@ pub fn Rational(comptime T: type) type {
     };
 }
 
-// https://en.wikipedia.org/wiki/Euclidean_algorithm
+// https://lemire.me/blog/greatest-common-divisor-the-extended-euclidean-algorithm-and-speed/
 fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
     assert(p >= 1);
     assert(q >= 1);
 
-    var a = p;
-    var b = q;
-    var c: @TypeOf(p, q) = undefined;
+    const T = @TypeOf(p, q);
+    switch (@typeInfo(T)) {
+        .Int => {
+            var u: T = undefined;
+            var v: T = undefined;
+            if (p < q) {
+                u = q;
+                v = p;
+            } else {
+                u = p;
+                v = q;
+            }
+            assert(v <= u);
+            u %= v;
+            if (u == 0) return v;
+
+            const zu = @ctz(u);
+            const zv = @ctz(v);
+            const shift = @min(zu, zv);
+            u >>= @intCast(zu);
+            v >>= @intCast(zv);
+
+            while (true) {
+                const diff = u -% v;
+                if (u > v) {
+                    u = v;
+                    v = diff;
+                } else {
+                    v -= u;
+                }
+                if (diff != 0) v >>= @intCast(@ctz(diff));
+                if (v == 0) break;
+            }
+
+            const result = u << @intCast(shift);
+            assert(result > 0);
+            return result;
+        },
+        else => {
+            var a = p;
+            var b = q;
+            var c: T = undefined;
+
+            while (b != 0) {
+                c = b;
+                b = @mod(a, b);
+                a = c;
+            }
 
-    while (b != 0) {
-        c = b;
-        b = @mod(a, b);
-        a = c;
+            assert(a > 0);
+            return a;
+        },
     }
+}
+
+test gcd {
+    const seed = if (@hasDecl(std.testing, "random_seed")) std.testing.random_seed else 0x12345678;
+    var prng = std.Random.DefaultPrng.init(seed);
+    var random = prng.random();
 
-    assert(a > 0);
-    return a;
+    for (0..1000) |_| {
+        const a = random.int(u32);
+        const b = random.int(u32);
+        if (a == 0 or b == 0) continue;
+
+        try expectEqual(
+            gcd(a, b),
+            @as(u32, @intFromFloat(gcd(@as(f64, @floatFromInt(a)), @as(f64, @floatFromInt(b))))),
+        );
+    }
 }
 
 fn doTurn(r: anytype) !void {
@@ -355,3 +412,36 @@ test BigRational {
     try s.setRatio(71, 78);
     try expect((try s.order(r.val)) == .eq);
 }
+
+test "minimum" {
+    // TODO: ziglang/zig#21069
+    if (builtin.mode == .ReleaseFast or builtin.mode == .ReleaseSmall) {
+        return error.SkipZigTest;
+    }
+    var r = try BigRational.init(std.testing.allocator);
+    defer r.deinit();
+    var s = try std.math.big.Rational.init(std.testing.allocator);
+    defer s.deinit();
+
+    try r.reset();
+
+    try r.update(1, 2); // Speed Tie
+    for (0..2) |_| {
+        try r.update(1, 2); // Confusion
+        try r.update(1, 2); // Infatuation
+        try r.update(3, 4); // Paralysis
+        // Population Bomb
+        for (0..10) |_| {
+            try r.update(9, 10); // Accuracy
+            try r.update(1, 15); // Damage roll
+            try r.update(1, 24); // Critical Hit
+            try r.update(9, 10); // King's Rock non-proc
+        }
+    }
+
+    const ZEROS = std.math.pow(u310, 10, 31);
+    const n = 36472996377170786403;
+    const d: u310 = 146267071761884981524886149560653378220687632500762654519853056 * ZEROS;
+    try s.setRatio(n, d);
+    try expect((try s.order(r.val)) == .eq);
+}

package/src/lib/common/rng.zig

@@ -66,6 +66,10 @@ pub const PSRNG = extern struct {
             (@as(u64, self.range(u16, 0, 0x10000)) << 16) |
             (@as(u64, self.range(u16, 0, 0x10000)));
     }
+
+    pub fn Bound(comptime T: type) type {
+        return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
+    }
 };
 
 test PSRNG {
@@ -197,7 +201,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             for (0..n) |_| _ = self.next();
         }
 
-        pub fn range(self: *Self, comptime T: type, from: T, to: Bound(T)) T {
+        pub fn range(self: *Self, comptime T: type, from: T, to: PSRNG.Bound(T)) T {
             assert(showdown);
             return @intCast(@as(u64, self.next()) * (to - from) / divisor + from);
         }
@@ -206,7 +210,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             self: *Self,
             comptime T: type,
             numerator: T,
-            denominator: Bound(T),
+            denominator: PSRNG.Bound(T),
         ) bool {
             assert(showdown);
             assert(denominator > 0);
@@ -237,7 +241,3 @@ fn Output(comptime gen: comptime_int) type {
         else => unreachable,
     };
 }
-
-fn Bound(comptime T: type) type {
-    return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
-}