@pkmn/engine 0.1.0-dev.645b4750 → 0.1.0-dev.6b383c80

package/src/lib/gen2/mechanics.zig

@@ -1,6 +1,5 @@
 const DEBUG = @import("../common/debug.zig").print;
 
-const builtin = @import("builtin");
 const common = @import("../common/data.zig");
 const data = @import("data.zig");
 const generated = @import("generated.zig");
@@ -130,11 +129,11 @@ fn start(battle: anytype, options: anytype) !Result {
 
     const p1_slot = findFirstAlive(p1);
     assert(!showdown or p1_slot == 1);
-    if (p1_slot == 0) return if (findFirstAlive(p2) == 0) Result.Tie else Result.Lose;
+    if (p1_slot == 0) return if (findFirstAlive(p2) == 0) .Tie else .Lose;
 
     const p2_slot = findFirstAlive(p2);
     assert(!showdown or p2_slot == 1);
-    if (p2_slot == 0) return Result.Win;
+    if (p2_slot == 0) return .Win;
 
     try switchIn(battle, .P1, p1_slot, .Initial, options);
     try switchIn(battle, .P2, p2_slot, .Initial, options);
@@ -682,7 +681,7 @@ pub fn adjustDamage(battle: anytype, player: Player, state: *State, _: anytype)
 
     // Type effectiveness matchup precedence only matters with (NVE, SE)
     if (!showdown and (eff1 + eff2) == Effectiveness.mismatch and
-        types.type1.precedence() > types.type2.precedence())
+        Type.precedence(state.type, types.type1) > Type.precedence(state.type, types.type2))
     {
         assert(eff2 != neutral);
         d = d *% eff2 / 10;
@@ -819,13 +818,13 @@ fn checkFaint(
 
     if (player_out and foe_out) {
         try options.log.tie(.{});
-        return Result.Tie;
+        return .Tie;
     } else if (player_out) {
         try options.log.win(.{player.foe()});
-        return if (player == .P1) Result.Lose else Result.Win;
+        return if (player == .P1) .Lose else .Win;
     } else if (foe_out) {
         try options.log.win(.{player});
-        return if (player == .P1) Result.Win else Result.Lose;
+        return if (player == .P1) .Win else .Lose;
     }
 
     const foe_choice: Choice.Type = if (foe_fainted) .Switch else .Pass;
@@ -1195,14 +1194,14 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
 
     if (pkmn.options.mod and battle.turn >= 1000) {
         try options.log.tie(.{});
-        return Result.Tie;
+        return .Tie;
     } else if (battle.turn >= 65535) {
-        return Result.Error;
+        return .Error;
     }
 
     try options.log.turn(.{battle.turn});
 
-    return Result.Default;
+    return .Default;
 }
 
 pub fn buildRage(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1427,8 +1426,7 @@ pub const Effects = struct {
         if (move.type.special() != (last == .MirrorCoat)) return;
         if (state.damage == 0) return;
 
-        // NOTE: llvm/llvm-project#58557
-        state.damage = smul(state.damage, 2);
+        state.damage *|= 2;
         state.miss = false;
     }
 
@@ -1523,18 +1521,15 @@ pub const Effects = struct {
 
     pub const double = struct {
         pub fn flying(battle: anytype, player: Player, state: *State, _: anytype) !void {
-            if (!battle.foe(player).active.volatiles.Flying) return;
-            state.damage = smul(state.damage, 2);
+            if (battle.foe(player).active.volatiles.Flying) state.damage *|= 2;
         }
 
         pub fn underground(battle: anytype, player: Player, state: *State, _: anytype) !void {
-            if (!battle.foe(player).active.volatiles.Underground) return;
-            state.damage = smul(state.damage, 2);
+            if (battle.foe(player).active.volatiles.Underground) state.damage *|= 2;
         }
 
         pub fn minimize(battle: anytype, player: Player, state: *State, _: anytype) !void {
-            if (!battle.foe(player).active.volatiles.minimized) return;
-            state.damage = smul(state.damage, 2);
+            if (battle.foe(player).active.volatiles.minimized) state.damage *|= 2;
         }
     };
 
@@ -1558,7 +1553,7 @@ pub const Effects = struct {
         const last = battle.foe(player).lastMove(true);
         const failed = volatiles.Encore or
             (last == .None or last == .Struggle or
-            last == .Encore or .last == .MirrorMove);
+                last == .Encore or .last == .MirrorMove);
         if (failed) return options.log.fail(.{ foe_ident, .None });
 
         var slot: u3 = 0;
@@ -1732,7 +1727,7 @@ pub const Effects = struct {
             state.bp *= 2;
             assert(state.bp <= 160);
         } else {
-            state.damage = smul(state.damage, 2);
+            state.damage *|= 2;
         }
     }
 
@@ -2203,7 +2198,7 @@ pub const Effects = struct {
 
     pub fn pursuit(battle: anytype, player: Player, state: *State, _: anytype) !void {
         // TODO: remove switching variable and just look at Choice saved in Battle struct?
-        if (battle.foe(player).active.volatiles.switching) state.damage = smul(state.damage, 2);
+        if (battle.foe(player).active.volatiles.switching) state.damage *|= 2;
     }
 
     pub const rage = struct {
@@ -2216,7 +2211,7 @@ pub const Effects = struct {
             const side = battle.side(player);
 
             assert(side.active.volatiles.Rage);
-            state.damage = smul(state.damage, (side.active.volatiles.rage +| 1)); // TODO: |+
+            state.damage *|= (side.active.volatiles.rage +| 1);
         }
     };
 
@@ -2311,7 +2306,7 @@ pub const Effects = struct {
             side.active.volatiles.attacks += 1;
             side.active.volatiles.Rollout = side.active.volatiles.attacks != 5;
 
-            if (side.active.volatiles.DefenseCurl) state.damage = smul(state.damage, 2);
+            if (side.active.volatiles.DefenseCurl) state.damage *|= 2;
         }
     };
 
@@ -2839,12 +2834,6 @@ fn convertible(active: ActivePokemon, m: Move) bool {
     return t != .@"???" and !active.types.includes(t);
 }
 
-// NOTE: llvm/llvm-project#58557
-fn smul(a: anytype, b: @TypeOf(a)) @TypeOf(a) {
-    if (!comptime builtin.target.cpu.arch.isWasm()) return a *| b;
-    return @max(a *% b, std.math.maxInt(@TypeOf(a)));
-}
-
 pub const Rolls = struct {
     fn speedTie(battle: anytype, options: anytype) !bool {
         const p1 = if (options.calc.overridden(.P1, 0, .speed_tie)) |player|
@@ -3081,7 +3070,7 @@ pub const Rolls = struct {
     }
 
     // Conversion 2 can at most choose between 7 types (vs. a Grass-type attack)
-    var CONVERSION_2: [7]Type = [_]Type{.@"???"} ** 7;
+    var CONVERSION_2: [7]Type = @splat(.@"???");
 
     fn conversion2(battle: anytype, player: Player, mtype: Type, options: anytype) !Type {
         var i: u8 = 0;
@@ -3506,11 +3495,11 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
         },
         .Switch => {
             const side = battle.side(player);
-            var slot: u4 = 2;
+            var slot: usize = 2;
             while (slot <= 6) : (slot += 1) {
                 const id = side.order[slot - 1];
                 if (id == 0 or side.pokemon[id - 1].hp == 0) continue;
-                out[n] = .{ .type = .Switch, .data = slot };
+                out[n] = .{ .type = .Switch, .data = @intCast(slot) };
                 n += 1;
             }
             if (n == 0) {
@@ -3540,11 +3529,11 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                 return n;
             }
 
-            var slot: u4 = 2;
+            var slot: usize = 2;
             while (!active.volatiles.Trapped and slot <= 6) : (slot += 1) {
                 const id = side.order[slot - 1];
                 if (id == 0 or side.pokemon[id - 1].hp == 0) continue;
-                out[n] = .{ .type = .Switch, .data = slot };
+                out[n] = .{ .type = .Switch, .data = @intCast(slot) };
                 n += 1;
             }
 
@@ -3577,7 +3566,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                         const struggle =
                             m.id == .Bide and (m.pp == 0 or active.volatiles.disable.move == slot);
                         const s = if (struggle) 0 else slot;
-                        out[n] = .{ .type = .Move, .data = s };
+                        out[n] = .{ .type = .Move, .data = @intCast(s) };
                         n += 1;
                         return n;
                     }
@@ -3591,7 +3580,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                 if (m.id == .None) break;
                 if (m.pp == 0) continue;
                 if (active.volatiles.disable.move == slot) continue;
-                out[n] = .{ .type = .Move, .data = slot };
+                out[n] = .{ .type = .Move, .data = @intCast(slot) };
                 n += 1;
             }
             // Struggle (Pokémon Showdown would use 'move 1' here)

package/src/lib/napi.h

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

package/src/lib/node.zig

@@ -1,14 +1,10 @@
+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 = node.register(env) }),

package/src/lib/pkmn.zig

@@ -22,9 +22,9 @@ pub const Choice = @import("common/data.zig").Choice;
 /// considered terminal.
 pub const Result = @import("common/data.zig").Result;
 
-// TODO
+/// Helpers for working with bit-packed arrays of non-powers-of-2 types.
 pub const Array = @import("common/array.zig").Array;
-// TODO
+/// 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).
@@ -32,31 +32,78 @@ 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;
@@ -107,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;
@@ -126,8 +200,8 @@ 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 {};
+pub const util = if (options.internal) @import("common/util.zig") else {};
 pub const bindings = if (options.internal) struct {
     pub const c = @import("bindings/c.zig");
     pub const node = @import("bindings/node.zig");

package/src/lib/wasm.zig

@@ -9,9 +9,5 @@ export const CALC = wasm.options.calc;
 export const GEN1_CHOICES_SIZE = wasm.gen(1).CHOICES_SIZE;
 export const GEN1_LOGS_SIZE = wasm.gen(1).LOGS_SIZE;
 
-const exportable = @hasDecl(std.zig, "Zir") and !@hasField(std.zig.Zir.Inst.Tag, "export_value");
-
-usingnamespace if (exportable) struct {
-    export const GEN1_update = wasm.gen(1).update;
-    export const GEN1_choices = wasm.gen(1).choices;
-} else wasm.exports();
+export const GEN1_update = wasm.gen(1).update;
+export const GEN1_choices = wasm.gen(1).choices;

package/src/tools/display/dom.ts

@@ -1,23 +1,18 @@
 /** @license MIT modified from Vadim Demedes's https://github.com/vadimdemedes/dom-chef */
-type Attributes = JSX.IntrinsicElements['div'];
-type DocumentFragmentFunction = (props?: any) => DocumentFragment;
-type ElementFunction = (props?: any) => HTMLElement;
 
 declare global {
   namespace JSX {
-    interface Element extends HTMLElement, DocumentFragment {
-      addEventListener: HTMLElement['addEventListener'];
-      removeEventListener: HTMLElement['removeEventListener'];
-      className: HTMLElement['className'];
+    type Element = HTMLElement | DocumentFragment;
+    interface IntrinsicElements {
+      [elemName: string]: Record<string, unknown>;
     }
   }
 }
 
-interface JSXElementClassDocumentFragment extends DocumentFragment, JSX.ElementClass { }
-interface Fragment {
-  prototype: JSXElementClassDocumentFragment;
-  new(): JSXElementClassDocumentFragment;
-}
+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;
@@ -38,14 +33,14 @@ const setAttribute = (element: HTMLElement, name: string, value: string) => {
   if (value !== undefined && value !== null) element.setAttribute(name, value);
 };
 
-const addChildren = (parent: Element | DocumentFragment, children: Node[]) => {
+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(child));
+      parent.appendChild(document.createTextNode(String(child)));
     }
   }
 };
@@ -53,11 +48,31 @@ const addChildren = (parent: Element | DocumentFragment, children: Node[]) => {
 // https://github.com/facebook/react/blob/3f899089/packages/react-dom/src/shared/DOMProperty.js#L288-L322
 const FALSIFIABLE_ATTRIBUTES = ['contentEditable', 'draggable', 'spellCheck', 'value'];
 
-export const h = (
+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?: Attributes,
-  ...children: Node[]
-) => {
+  attributes?: any,
+  ...children: Child[]
+): JSX.Element {
   if (typeof type !== 'string') {
     const element = type(attributes);
     addChildren(element, children);
@@ -75,19 +90,19 @@ export const h = (
       const existingClassname = element.getAttribute('class') ?? '';
       setAttribute(element, 'class', (existingClassname + ' ' + String(value)).trim());
     } else if (name === 'style') {
-      setCSSProps(element, value);
+      setCSSProps(element, value as CSSStyleDeclaration);
     } else if (name.startsWith('on')) {
       const eventName = name.slice(2).toLowerCase().replace(/^-/, '');
-      element.addEventListener(eventName, value);
-    } else if (name === 'dangerouslySetInnerHTML' && '__html' in value) {
-      element.innerHTML = value.__html;
+      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 ? '' : value);
+      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();
+export const Fragment = (unused?: any) => document.createDocumentFragment();