@pkmn/engine 0.1.0-dev.62399ed5 → 0.1.0-dev.62eefbc0

package/src/lib/napi.h

@@ -0,0 +1,2 @@
+#define NAPI_VERSION 8
+#include <node_api.h>

package/src/lib/node.zig

@@ -1,131 +1,14 @@
-const std = @import("std");
-
-const pkmn = @import("pkmn.zig");
-
+const c = @import("napi");
 const js = @import("common/js.zig");
+const node = @import("bindings/node.zig");
+const std = @import("std");
 
 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) }),
+        js.Property.init("engine", .{ .value = node.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

@@ -22,36 +22,88 @@ pub const Choice = @import("common/data.zig").Choice;
 /// considered terminal.
 pub const Result = @import("common/data.zig").Result;
 
+/// Helpers for working with bit-packed arrays of non-powers-of-2 types.
+pub const Array = @import("common/array.zig").Array;
+/// Optimized optional representation which stores the empty None value as a sentinel.
+pub const Optional = @import("common/optional.zig").Optional;
+
 /// 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 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
+    /// Logs protocol information to its `WriterT` during a battle update when
     /// `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
-    /// `ByteStream.Writer` is **not** a `std.io.Writer` and should not be
-    /// used for general purpose writing.
-    pub const ByteStream = @import("common/protocol.zig").ByteStream;
-    /// `Log` type backed by the optimized `ByteStream.Writer`. Intended to be
-    /// intialized with a `LOGS_SIZE`-sized buffer.
+    /// `Log` type backed by the optimized `Writer`. Intended to be 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 protocol
-    /// logging should additionally be turned off entirely with `options.log`.
+    /// Minimal logging helper optimized for efficiently writing the individual
+    /// protocol bytes into a fixed buffer. Note that this is **not** a
+    /// `std.Io.Writer` and should not be used for general purpose writing.
+    pub const Writer = @import("common/protocol.zig").Writer;
+    /// Null object pattern implementation of `Log` backed by a 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;
 };
 
-pub usingnamespace @import("common/rational.zig");
+/// Specialization of a rational number used by the engine to compute probabilties.
+pub const Rational = @import("common/rational.zig").Rational;
 
 /// 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");
+    const data = @import("gen1/data.zig");
+    /// The minimum size in bytes required to hold all Generation I choice options.
+    pub const MAX_CHOICES = data.MAX_CHOICES;
+    /// The maximum number of bytes possibly logged by a single Generation I update.
+    pub const MAX_LOGS = data.MAX_LOGS;
+    /// The optimal size in bytes required to hold all Generation I choice options.
+    /// At least as large as MAX_CHOICES.
+    pub const CHOICES_SIZE = data.CHOICES_SIZE;
+    /// The optimal size in bytes required to hold the largest amount of log data possible from a
+    /// single Generation I update. At least as large as MAX_LOGS.
+    pub const LOGS_SIZE = data.LOGS_SIZE;
+    ///  Null object pattern implementation of pkmn.battle.Options for Generation I.
+    pub const NULL = data.NULL;
+    /// The pseudo random number generator used by Generation I.
+    pub const PRNG = data.PRNG;
+    /// Representation of a Generation I battle.
+    pub const Battle = data.Battle;
+    /// Representation of one side of a Generation I Pokémon battle.
+    pub const Side = data.Side;
+    /// Representation of the state for single Generation I Pokémon while active in battle.
+    pub const ActivePokemon = data.ActivePokemon;
+    /// Representation of the state for single Generation I Pokémon while inactive in the party.
+    pub const Pokemon = data.Pokemon;
+    /// Representation of a Generation I Pokémon's move slot in a battle.
+    pub const MoveSlot = data.MoveSlot;
+    /// Details required to detect desyncs based on the move last selected/executed by players.
+    pub const MoveDetails = data.MoveDetails;
+    /// Bitfield representation of a Generation I & II Pokémon's major status condition.
+    pub const Status = data.Status;
+    /// Bitfield representation of volatile statuses and associated data in Generation I.
+    pub const Volatiles = data.Volatiles;
+    /// Representation of a Pokémon's stats in Generation I.
+    pub const Stats = data.Stats;
+    /// Representation of a Pokémon's boosts in Generation I.
+    pub const Boosts = data.Boosts;
+    /// Representation of a Generation I Pokémon move.
+    pub const Move = data.Move;
+    /// Representation of a Generation I Pokémon species.
+    pub const Species = data.Species;
+    /// Representation of a Generation I type in Pokémon.
+    pub const Type = data.Type;
+    /// Representation of a Generation I Pokémon's typing.
+    pub const Types = data.Types;
+    /// Modifiers for the effectiveness of a type vs. another type in Pokémon.
+    pub const Effectiveness = data.Effectiveness;
+    /// Representation of a Generation I Pokémon's determinant values.
+    pub const DVs = data.DVs;
+
     /// 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;
@@ -81,8 +133,6 @@ pub const gen1 = struct {
     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;
@@ -93,6 +143,10 @@ pub const gen1 = struct {
         /// though damage calculator support should additionally be turned off
         /// entirely via `options.calc`.
         pub const NULL = @import("gen1/calc.zig").NULL;
+        /// TODO
+        pub const MAX_FRONTIER = @import("gen1/calc.zig").MAX_FRONTIER;
+        /// TODO
+        pub const Rolls = @import("gen1/calc.zig").Rolls;
     };
     /// Provides helpers for initializing Generation I Pokémon battles.
     pub const helpers = @import("gen1/helpers.zig");
@@ -100,7 +154,34 @@ pub const gen1 = struct {
 
 /// TODO
 pub const gen2 = struct {
-    pub usingnamespace @import("gen2/data.zig");
+    const data = @import("gen2/data.zig");
+    pub const MAX_CHOICES = data.MAX_CHOICES;
+    pub const MAX_LOGS = data.MAX_LOGS;
+    pub const CHOICES_SIZE = data.CHOICES_SIZE;
+    pub const LOGS_SIZE = data.LOGS_SIZE;
+    pub const NULL = data.NULL;
+    pub const PRNG = data.PRNG;
+    pub const Battle = data.Battle;
+    pub const Field = data.Field;
+    pub const Weather = data.Weather;
+    pub const Side = data.Side;
+    pub const ActivePokemon = data.ActivePokemon;
+    pub const Pokemon = data.Pokemon;
+    pub const Gender = data.Gender;
+    pub const DVs = data.DVs;
+    pub const MoveSlot = data.MoveSlot;
+    pub const Status = data.Status;
+    pub const TriAttack = data.TriAttack;
+    pub const Volatiles = data.Volatiles;
+    pub const Stats = data.Stats;
+    pub const Boosts = data.Boosts;
+    pub const Item = data.Item;
+    pub const Move = data.Move;
+    pub const Species = data.Species;
+    pub const Type = data.Type;
+    pub const Types = data.Types;
+    pub const Effectiveness = data.Effectiveness;
+
     pub const Chance = @import("gen2/chance.zig").Chance;
     pub const chance = struct {
         pub const Actions = @import("gen2/chance.zig").Actions;
@@ -111,7 +192,6 @@ pub const gen2 = struct {
     };
     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;
@@ -120,9 +200,10 @@ pub const gen2 = struct {
 };
 
 // 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 js = if (options.internal) @import("common/js.zig") else {};
+pub const util = if (options.internal) @import("common/util.zig") else {};
 pub const bindings = if (options.internal) struct {
-    pub const node = @import("node.zig");
-    pub const wasm = @import("wasm.zig");
-} else struct {};
+    pub const c = @import("bindings/c.zig");
+    pub const node = @import("bindings/node.zig");
+    pub const wasm = @import("bindings/wasm.zig");
+} else {};

package/src/lib/wasm.zig

@@ -1,13 +1,13 @@
 const std = @import("std");
+const wasm = @import("bindings/wasm.zig");
 
-const pkmn = @import("pkmn.zig");
+export const SHOWDOWN = wasm.options.showdown;
+export const LOG = wasm.options.log;
+export const CHANCE = wasm.options.chance;
+export const CALC = wasm.options.calc;
 
-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 = wasm.gen(1).CHOICES_SIZE;
+export const GEN1_LOGS_SIZE = wasm.gen(1).LOGS_SIZE;
 
-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;
+export const GEN1_update = wasm.gen(1).update;
+export const GEN1_choices = wasm.gen(1).choices;

package/src/tools/display/dom.ts

@@ -0,0 +1,108 @@
+/** @license MIT modified from Vadim Demedes's https://github.com/vadimdemedes/dom-chef */
+
+declare global {
+  namespace JSX {
+    type Element = HTMLElement | DocumentFragment;
+    interface IntrinsicElements {
+      [elemName: string]: Record<string, unknown>;
+    }
+  }
+}
+
+type Child = Node | string | number | boolean | null | undefined | Child[];
+
+type DocumentFragmentFunction = (props?: any) => DocumentFragment;
+type ElementFunction = (props?: any) => HTMLElement;
+
+// https://github.com/preactjs/preact/blob/1bbd687c/src/constants.js#L3
+const IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;
+
+const setCSSProps = (element: HTMLElement, style: CSSStyleDeclaration) => {
+  for (const [name, value] of Object.entries(style)) {
+    if (name.startsWith('-')) {
+      element.style.setProperty(name, value);
+    } else if (typeof value === 'number' && !IS_NON_DIMENSIONAL.test(name)) {
+      element.style[name as any] = `${value as string}px`;
+    } else {
+      element.style[name as any] = value;
+    }
+  }
+};
+
+const setAttribute = (element: HTMLElement, name: string, value: string) => {
+  if (value !== undefined && value !== null) element.setAttribute(name, value);
+};
+
+const addChildren = (parent: Node, children: Child[]) => {
+  for (const child of children) {
+    if (child instanceof Node) {
+      parent.appendChild(child);
+    } else if (Array.isArray(child)) {
+      addChildren(parent, child);
+    } else if (typeof child !== 'boolean' && typeof child !== 'undefined' && child !== null) {
+      parent.appendChild(document.createTextNode(String(child)));
+    }
+  }
+};
+
+// https://github.com/facebook/react/blob/3f899089/packages/react-dom/src/shared/DOMProperty.js#L288-L322
+const FALSIFIABLE_ATTRIBUTES = ['contentEditable', 'draggable', 'spellCheck', 'value'];
+
+export function h<K extends keyof HTMLElementTagNameMap>(
+  type: K,
+  attributes?: any,
+  ...children: Child[]
+): HTMLElementTagNameMap[K];
+export function h(
+  type: DocumentFragmentFunction,
+  attributes?: any,
+  ...children: Child[]
+): DocumentFragment;
+export function h<T extends HTMLElement>(
+  type: (props: any) => T,
+  attributes?: any,
+  ...children: Child[]
+): T;
+export function h(
+  type: string,
+  attributes?: any,
+  ...children: Child[]
+): HTMLElement;
+export function h(
+  type: DocumentFragmentFunction | ElementFunction | string,
+  attributes?: any,
+  ...children: Child[]
+): JSX.Element {
+  if (typeof type !== 'string') {
+    const element = type(attributes);
+    addChildren(element, children);
+    return element;
+  }
+
+  const element = document.createElement(type);
+  addChildren(element, children);
+  if (!attributes) return element;
+
+  for (let [name, value] of Object.entries(attributes)) {
+    if (name === 'htmlFor') name = 'for';
+
+    if (name === 'class' || name === 'className') {
+      const existingClassname = element.getAttribute('class') ?? '';
+      setAttribute(element, 'class', (existingClassname + ' ' + String(value)).trim());
+    } else if (name === 'style') {
+      setCSSProps(element, value as CSSStyleDeclaration);
+    } else if (name.startsWith('on')) {
+      const eventName = name.slice(2).toLowerCase().replace(/^-/, '');
+      element.addEventListener(eventName, value as EventListenerOrEventListenerObject);
+    } else if (name === 'dangerouslySetInnerHTML' && value && (value as any).__html) {
+      element.innerHTML = (value as any).__html;
+    } else if (name !== 'key' && (FALSIFIABLE_ATTRIBUTES.includes(name) || value !== false)) {
+      setAttribute(element, name, value === true ? '' : String(value));
+    }
+  }
+
+  return element;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const Fragment = (unused?: any) => document.createDocumentFragment();