@pkmn/engine 0.1.0-dev.63cef311 → 0.1.0-dev.6cc9e067

package/src/lib/node.zig

@@ -0,0 +1,131 @@
+const std = @import("std");
+
+const pkmn = @import("pkmn.zig");
+
+const js = @import("common/js.zig");
+
+const assert = std.debug.assert;
+
+const c = @cImport({
+    @cDefine("NAPI_VERSION", "8");
+    @cInclude("node_api.h");
+});
+
+export fn napi_register_module_v1(env: c.napi_env, exports: c.napi_value) c.napi_value {
+    const properties = [_]c.napi_property_descriptor{
+        js.Property.init("engine", .{ .value = register(env) }),
+    };
+    assert(c.napi_define_properties(env, exports, properties.len, &properties) == c.napi_ok);
+    return exports;
+}
+
+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) = @alignCast(@ptrCast(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 stream: pkmn.protocol.ByteStream = .{ .buffer = buf };
+                    // TODO: extract out
+                    var opts = pkmn.battle.options(
+                        pkmn.protocol.FixedLog{ .writer = stream.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) = @alignCast(@ptrCast(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/pkmn.zig

@@ -1,13 +1,13 @@
-/// Configurated Options for the pkmn package.
+/// Configured Options for the pkmn package.
 pub const options = @import("common/options.zig");
 /// Configures the behavior of the pkmn package.
 pub const Options = options.Options;
 
 /// The minimum size in bytes required to hold all choice options.
-pub const MAX_OPTIONS = gen1.MAX_OPTIONS;
+pub const MAX_CHOICES = gen1.MAX_CHOICES;
 /// The optimal size in bytes required to hold all choice options.
-/// At least as large as `MAX_OPTIONS`.
-pub const OPTIONS_SIZE = gen1.OPTIONS_SIZE;
+/// At least as large as `MAX_CHOICES`.
+pub const CHOICES_SIZE = gen1.CHOICES_SIZE;
 /// The maximum number of bytes possibly logged by a single update.
 pub const MAX_LOGS = gen1.MAX_LOGS;
 /// The optimal size in bytes required to hold the largest amount of log data
@@ -25,12 +25,10 @@ pub const Result = @import("common/data.zig").Result;
 /// Pokémon Showdown's RNG (backed by a Generation V & VI RNG).
 pub const PSRNG = @import("common/rng.zig").PSRNG;
 
-/// Namespace for helpers related to protocol trace logging.
-pub const protocol = if (options.internal) struct {
-    pub usingnamespace @import("common/protocol.zig");
-} else struct {
+/// Namespace for helpers related to protocol message logging.
+pub const protocol = if (options.internal) @import("common/protocol.zig") else struct {
     /// Logs protocol information to its `Writer` during a battle update when
-    /// `options.trace` is enabled.
+    /// `options.log` is enabled.
     pub const Log = @import("common/protocol.zig").Log;
     /// Stripped down version of `std.io.FixedBufferStream` optimized for
     /// efficiently writing the individual protocol bytes. Note that the
@@ -41,14 +39,90 @@ pub const protocol = if (options.internal) struct {
     /// intialized with a `LOGS_SIZE`-sized buffer.
     pub const FixedLog = @import("common/protocol.zig").FixedLog;
     /// Null object pattern implementation of `Log` backed by a
-    /// `std.io.null_writer`. Ignores anything sent to it, though trace logging
-    /// should addtionally be turned off entirely by using `options.trace`.
+    /// `std.io.null_writer`. Ignores anything sent to it, though protocol
+    /// logging should additionally be turned off entirely with `options.log`.
     pub const NULL = @import("common/protocol.zig").NULL;
 };
 
-/// Namespace for Generation I Pokémon
+pub usingnamespace @import("common/rational.zig");
+
+/// Namespace for cross-generation battle-related types.
+pub const battle = @import("common/battle.zig");
+
+/// Namespace for Generation I Pokémon.
 pub const gen1 = struct {
     pub usingnamespace @import("gen1/data.zig");
+    /// Tracks chance actions and their associated probability during a
+    /// Generation I battle update when `options.chance` is enabled.
+    pub const Chance = @import("gen1/chance.zig").Chance;
+    /// Namespace for types associated with tracking Generation I Pokémon chance outcomes.
+    pub const chance = struct {
+        /// Actions taken by a hypothetical "chance player" that convey
+        /// information about which RNG events were observed during a Generation
+        /// I battle `update`. This can additionally be provided as input to the
+        /// `update` call via the `Calc` when `options.calc` is enabled to
+        /// override the normal behavior of the RNG in order to force specific
+        /// outcomes.
+        pub const Actions = @import("gen1/chance.zig").Actions;
+        /// Information about the RNG that was observed during a Generation I
+        /// battle `update` for a single player.
+        pub const Action = @import("gen1/chance.zig").Action;
+        /// TODO
+        pub const Durations = @import("gen1/chance.zig").Durations;
+        /// TODO
+        pub const Duration = @import("gen1/chance.zig").Duration;
+        /// Null object pattern implementation of Generation I `Chance` which
+        /// does nothing, though chance tracking should additionally be turned
+        /// off entirely via `options.chance`.
+        pub const NULL = @import("gen1/chance.zig").NULL;
+    };
+    /// Allows for forcing the value of specific RNG events during a Generation I battle `update`
+    /// via `overrides` and tracks `summaries` of information relevant to damage calculation.
+    pub const Calc = @import("gen1/calc.zig").Calc;
+    /// Namespace for types associated with supported Generation I Pokémon damage calc features.
+    pub const calc = if (options.internal) @import("gen1/calc.zig") else struct {
+        /// TODO
+        pub const Overrides = @import("gen1/calc.zig").Overrides;
+        /// Information relevant to damage calculation that occured during a Generation I
+        /// battle `update`.
+        pub const Summaries = @import("gen1/calc.zig").Summaries;
+        /// Information relevant to damage calculation that occured during a Generation I
+        /// battle `update` for a single player.
+        pub const Summary = @import("gen1/calc.zig").Summary;
+        /// Null object pattern implementation of Generation I `Calc` which does nothing,
+        /// though damage calculator support should additionally be turned off
+        /// entirely via `options.calc`.
+        pub const NULL = @import("gen1/calc.zig").NULL;
+    };
     /// Provides helpers for initializing Generation I Pokémon battles.
     pub const helpers = @import("gen1/helpers.zig");
 };
+
+/// TODO
+pub const gen2 = struct {
+    pub usingnamespace @import("gen2/data.zig");
+    pub const Chance = @import("gen2/chance.zig").Chance;
+    pub const chance = struct {
+        pub const Actions = @import("gen2/chance.zig").Actions;
+        pub const Action = @import("gen2/chance.zig").Action;
+        pub const Durations = @import("gen2/chance.zig").Durations;
+        pub const Duration = @import("gen2/chance.zig").Duration;
+        pub const NULL = @import("gen2/chance.zig").NULL;
+    };
+    pub const Calc = @import("gen2/calc.zig").Calc;
+    pub const calc = if (options.internal) @import("gen2/calc.zig") else struct {
+        pub const Overrides = @import("gen2/calc.zig").Overrides;
+        pub const Summaries = @import("gen2/calc.zig").Summaries;
+        pub const Summary = @import("gen2/calc.zig").Summary;
+        pub const NULL = @import("gen2/calc.zig").NULL;
+    };
+    pub const helpers = @import("gen2/helpers.zig");
+};
+
+// Internal APIs used by other pkmn libraries, not actually part of the public API.
+// NOTE: `pub usingnamespace struct { ... }` here results in a (false?) dependency loop
+pub const js = if (options.internal) @import("common/js.zig") else struct {};
+pub const bindings = if (options.internal) struct {
+    pub const node = @import("node.zig");
+    pub const wasm = @import("wasm.zig");
+} else struct {};

package/src/lib/wasm.zig

@@ -0,0 +1,13 @@
+const std = @import("std");
+
+const pkmn = @import("pkmn.zig");
+
+export const SHOWDOWN = pkmn.options.showdown;
+export const LOG = pkmn.options.log;
+export const CHANCE = pkmn.options.chance;
+export const CALC = pkmn.options.calc;
+
+export const GEN1_CHOICES_SIZE =
+    std.math.ceilPowerOfTwo(u32, @as(u32, @intCast(pkmn.gen1.CHOICES_SIZE))) catch unreachable;
+export const GEN1_LOGS_SIZE =
+    std.math.ceilPowerOfTwo(u32, @as(u32, @intCast(pkmn.gen1.LOGS_SIZE))) catch unreachable;

package/src/test/display/pkmn.html.tmpl

@@ -0,0 +1,368 @@
+<!doctype html>
+<html lang=en>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="icon" href="https://pkmn.cc/favicon.ico">
+    <title>@pkmn/engine</title>
+    <style>
+      #content {
+        font-family: "Roboto", "Helvetica Neue", "Helvetica", "Arial", sans-serif;
+        margin: 4em auto;
+        max-width: 1300px;
+        line-height: 1.4em;
+        --hp-bar: 151px;
+        --hp-text: 32px;
+      }
+      details > summary {
+        list-style: none;
+      }
+      details > summary::-webkit-details-marker {
+        display: none;
+      }
+      .battle > .details {
+        background: #eee;
+        border-bottom: 3px solid black;
+        padding: 0 0.5em;
+        display: flex;
+        justify-content: space-between;
+      }
+      .inner {
+        display: flex;
+        justify-content: center;
+        flex-direction: column;
+      }
+      .side > .details {
+        padding: 0.5em;
+        display: flex;
+        justify-content: space-between;
+        text-align: center;
+        flex: 0 1 auto;
+      }
+      .active {
+        flex: 1 1 auto;
+      }
+      details {
+        flex: 0 1 auto;
+      }
+      .sides {
+        display: flex;
+      }
+      .side {
+        flex: 1;
+        display: flex;
+        flex-flow: column;
+      }
+      .side.p1 {
+        border-right: 1px solid black;
+      }
+      .battle {
+        border: 3px solid black;
+      }
+      summary {
+        border-top: 1px solid black;
+        text-align: center;
+        padding: 0.25em;
+      }
+      .good {
+        color: green;
+      }
+      .bad {
+        color: red;
+      }
+      .pokemon {
+        position: relative;
+        padding: 0.5em;
+        border-top: 1px solid black;
+        display: flex;
+      }
+      table {
+        border-collapse: collapse;
+        border-style: hidden;
+        border-spacing: 0px;
+        line-height: 1.5em;
+      }
+      th, td {
+        border: 1px solid black;
+        padding: 0 0.5em;
+      }
+      .statbar {
+        display: none;
+        width: calc(var(--hp-bar) + var(--hp-text));
+        padding: 2px 0;
+        line-height: normal;
+      }
+      .statbar .name {
+        display: block;
+        text-align: center;
+        line-height: 1.25em;
+      }
+      .statbar strong {
+        color: #222222;
+        text-shadow:
+          #FFFFFF 1px 1px 0, #FFFFFF 1px -1px 0,
+          #FFFFFF -1px 1px 0, #FFFFFF -1px -1px 0;
+      }
+      .statbar strong small {
+        font-weight: normal;
+      }
+      .statbar .hpbar {
+        position: relative;
+        border: 1px solid #777777;
+        background: #FCFEFF;
+        padding: 1px;
+        height: 8px;
+        margin: 0 0 0 0;
+        width: calc(var(--hp-bar) + var(--hp-text) + 1px);
+        border-radius: 4px;
+      }
+      .statbar .hpbar .hp {
+        height: 4px;
+        border-top: 2px solid #00dd60;
+        background: #00bb51;
+        border-bottom: 2px solid #007734;
+        border-right: 1px solid #007734;
+        border-radius: 3px;
+      }
+      .statbar .hpbar .hp-yellow {
+        border-top-color: #f8e379;
+        background-color: #f5d538;
+        border-bottom-color: #be9f0a;
+        border-right-color: #be9f0a;
+      }
+      .statbar .hpbar .hp-red {
+        border-top-color: #f37f67;
+        background-color: #ee4928;
+        border-bottom-color: #a3260d;
+        border-right-color: #a3260d;
+      }
+      .statbar .hpbar .prevhp {
+        background: #BBEECC;
+        height: 8px;
+        border-radius: 3px;
+      }
+      .statbar .hpbar .prevhp-yellow {
+        background-color: #fcf4ca;
+      }
+      .statbar .hpbar .prevhp-red {
+        background-color: #facec5;
+      }
+      .statbar .hpbar .hptext {
+        position: absolute;
+        background: #777777;
+        color: #EEEEEE;
+        text-shadow: #000000 0 1px 0;
+        font-size: 10px;
+        width: 32px;
+        height: 12px;
+        top: -1px;
+        text-align: center;
+      }
+      .status, .volatile {
+        padding: 0px 1px;
+        border: 1px solid #FF4400;
+        border-radius: 3px;
+      }
+      .status {
+        min-height: 10px;
+        font-size: 7pt;
+        vertical-align: middle;
+        padding: 1px 2px;
+        border: 0;
+        border-radius: 3px;
+        text-transform: uppercase;
+        margin: 0 2px;
+      }
+      .status.brn {
+        background: #EE5533;
+        color: #FFFFFF;
+      }
+      .status.psn {
+        background: #A4009A;
+        color: #FFFFFF;
+      }
+      .status.par {
+        background: #9AA400;
+        color: #FFFFFF;
+      }
+      .status.slp {
+        background: #AA77AA;
+        color: #FFFFFF;
+      }
+      .status.frz {
+        background: #009AA4;
+        color: #FFFFFF;
+      }
+      .volatile {
+        display: inline-block;
+        padding: 0 5px;
+        margin: 2px
+      }
+      .volatile.bad {
+        background: #FFE5E0;
+        color: #FF4400;
+        border-color: #FF4400;
+      }
+      .volatile.good {
+        background: #E5FFE0;
+        color: #33AA00;
+        border-color: #33AA00;
+      }
+      .volatile.neutral {
+        background: #F0F0F0;
+        color: #555555;
+        border-color: #555555;
+      }
+      .rstatbar .hpbar .hptext {
+        right: 0px;
+        border-radius: 0 4px 4px 0;
+      }
+      .moves ul {
+        column-count: 2;
+        column-gap: 2em;
+      }
+      .left {
+        padding-right: 32px;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+      }
+      .stats {
+        display: flex;
+        padding: 0 1em;
+        justify-content: space-between;
+        text-align: center;
+        width: 100%;
+      }
+      .types {
+        display: inherit;
+      }
+      .disabled {
+        color: #AAAAAA;
+      }
+      .log {
+        display: flex;
+        justify-content: center;
+        padding-bottom: 2em;
+      }
+      .position {
+        position: absolute;
+        right: 10px;
+        color: #AAAAAA;
+      }
+      .left .position {
+        display: none;
+      }
+      .right .position {
+        display: block;
+      }
+      .teamicons {
+        display: inline-block;
+      }
+      @media(max-width: 1300px) {
+        #content {
+          font-size: 0.85em;
+          max-width: 95%;
+          margin: 2em auto;
+        }
+      }
+      @media(max-width: 1200px) {
+        .moves ul {
+          column-count: 1;
+        }
+      }
+      @media(max-width: 1100px) {
+        .pokemon {
+          flex-direction: column;
+        }
+        .stats {
+          justify-content: center;
+          padding: 0;
+        }
+        .boosts {
+          margin-left: 5px;
+        }
+        .moves ul {
+          column-count: 2;
+        }
+        .left {
+          padding-right: 0;
+        }
+        .right {
+          padding-top: 1em;
+        }
+        .volatiles {
+          display: flex;
+          justify-content: center;
+          flex-wrap: wrap;
+        }
+        .left .position {
+          display: block;
+        }
+        .right .position {
+          display: none;
+        }
+      }
+      @media(max-width: 800px) {
+        .moves {
+          display: flex;
+          justify-content: center;
+        }
+        .moves ul {
+          column-count: 1;
+          display: inline-block;
+          padding: 0;
+        }
+      }
+      @media(max-width: 680px) {
+        .stats {
+          flex-direction: column;
+          padding: 0;
+        }
+        .boosts {
+          display: flex;
+          justify-content: space-between;
+          margin-top: 0.5em;
+        }
+      }
+      @media(max-width: 550px) {
+        #content {
+          font-size: 0.65em;
+          max-width: 95%;
+          margin: 1em auto;
+          --hp-bar: 101px;
+        }
+      }
+      @media(max-width: 425px) {
+        .stats {
+          font-size: 0.9em;
+        }
+      }
+      h1 {
+        text-align: center;
+      }
+      .error {
+        overflow: auto;
+        scrollbar-width: none;
+        padding: 10px 20px;
+        border: 3px solid #DD4422;
+        background: #FFF8F2;
+      }
+      .error::-webkit-scrollbar {
+        display: none;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="content">{{{ content }}}</div>
+    <script>
+      for (const details of document.getElementsByTagName('details')) {
+        details.addEventListener('toggle', e => {
+          for (const d of details.parentElement.parentElement.getElementsByTagName('details')) {
+            if (d.open !== details.open) d.open = details.open;
+          }
+        });
+      }
+    </script>
+  </body>
+</html>