@pkmn/engine 0.1.0-dev.c5fe6d07 → 0.1.0-dev.ce4c0b2a

package/src/lib/{binding/node.zig → node.zig}

@@ -1,7 +1,8 @@
 const std = @import("std");
-const pkmn = @import("../pkmn.zig");
 
-const js = @import("../common/js.zig");
+const pkmn = @import("pkmn.zig");
+
+const js = @import("common/js.zig");
 
 const assert = std.debug.assert;
 
@@ -19,7 +20,7 @@ export fn napi_register_module_v1(env: c.napi_env, exports: c.napi_value) c.napi
 }
 
 pub fn register(env: c.napi_env) c.napi_value {
-    var object = js.Object.init(env);
+    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) }),
@@ -29,7 +30,7 @@ pub fn register(env: c.napi_env) c.napi_value {
 }
 
 fn options(env: c.napi_env) c.napi_value {
-    var object = js.Object.init(env);
+    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) }),
@@ -41,7 +42,7 @@ fn options(env: c.napi_env) c.napi_value {
 }
 
 fn bindings(env: c.napi_env) c.napi_value {
-    var array = js.Array.init(env, .{ .length = 1 });
+    const array = js.Array.init(env, .{ .length = 1 });
     js.Array.set(env, array, 0, bind(env, pkmn.gen1));
     return array;
 }
@@ -49,7 +50,7 @@ fn bindings(env: c.napi_env) c.napi_value {
 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);
-    var object = js.Object.init(env);
+    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) }),
@@ -72,7 +73,6 @@ fn update(gen: anytype) c.napi_callback {
             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)));
-            assert(data != null);
 
             var battle: *gen.Battle(gen.PRNG) = @alignCast(@ptrCast(data.?));
             const c1: pkmn.Choice = @bitCast(js.Number.get(env, argv[1], u8));
@@ -85,10 +85,9 @@ fn update(gen: anytype) c.napi_callback {
                 else => result: {
                     assert(c.napi_get_arraybuffer_info(env, argv[3], &data, &len) == c.napi_ok);
                     assert(len == gen.LOGS_SIZE);
-                    assert(data != null);
 
-                    var buf = @as([*]u8, @ptrCast(data.?))[0..gen.LOGS_SIZE];
-                    var stream = pkmn.protocol.ByteStream{ .buffer = buf };
+                    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() },
@@ -116,7 +115,6 @@ fn choices(gen: anytype) c.napi_callback {
             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)));
-            assert(data != null);
 
             var battle: *gen.Battle(gen.PRNG) = @alignCast(@ptrCast(data.?));
             const player: pkmn.Player = @enumFromInt(js.Number.get(env, argv[1], u8));
@@ -124,9 +122,8 @@ fn choices(gen: anytype) c.napi_callback {
 
             assert(c.napi_get_arraybuffer_info(env, argv[3], &data, &len) == c.napi_ok);
             assert(len == gen.CHOICES_SIZE);
-            assert(data != null);
 
-            var out = @as([*]pkmn.Choice, @ptrCast(data.?))[0..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)));
         }

package/src/lib/pkmn.zig

@@ -22,13 +22,16 @@ pub const Choice = @import("common/data.zig").Choice;
 /// considered terminal.
 pub const Result = @import("common/data.zig").Result;
 
+// TODO
+pub const Array = @import("common/array.zig").Array;
+// TODO
+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) struct {
-    pub usingnamespace @import("common/protocol.zig");
-} else struct {
+pub const protocol = if (options.internal) @import("common/protocol.zig") else struct {
     /// Logs protocol information to its `Writer` during a battle update when
     /// `options.log` is enabled.
     pub const Log = @import("common/protocol.zig").Log;
@@ -82,16 +85,12 @@ pub const gen1 = struct {
     /// 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) struct {
-        pub usingnamespace @import("gen1/calc.zig");
-    } else struct {
-        /// TODO
-        pub const Overrides = @import("gen1/calc.zig").Overrides;
+    pub const calc = if (options.internal) @import("gen1/calc.zig") else struct {
         /// 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.
+        /// 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
@@ -102,12 +101,30 @@ pub const gen1 = struct {
     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 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) struct {
-    pub usingnamespace @import("common/js.zig");
-} else struct {};
+pub const js = if (options.internal) @import("common/js.zig") else {};
 pub const bindings = if (options.internal) struct {
-    pub const node = @import("binding/node.zig");
-    pub const wasm = @import("binding/wasm.zig");
-} else struct {};
+    pub const node = @import("node.zig");
+    pub const wasm = @import("wasm.zig");
+} else {};

package/src/lib/{binding/wasm.zig → wasm.zig}

@@ -1,5 +1,6 @@
 const std = @import("std");
-const pkmn = @import("../pkmn.zig");
+
+const pkmn = @import("pkmn.zig");
 
 export const SHOWDOWN = pkmn.options.showdown;
 export const LOG = pkmn.options.log;

package/src/tools/display/dom.ts

@@ -0,0 +1,96 @@
+/** @license MIT modified from Vadim Demedes's https://github.com/vadimdemedes/dom-chef */
+type Attributes = JSX.IntrinsicElements['div'];
+type DocumentFragmentConstructor = typeof DocumentFragment;
+type ElementFunction = (props?: any) => HTMLElement;
+
+declare global {
+  namespace JSX {
+    interface Element extends HTMLElement, DocumentFragment {
+      addEventListener: HTMLElement['addEventListener'];
+      removeEventListener: HTMLElement['removeEventListener'];
+      className: HTMLElement['className'];
+    }
+  }
+}
+
+interface JSXElementClassDocumentFragment extends DocumentFragment, JSX.ElementClass { }
+interface Fragment {
+  prototype: JSXElementClassDocumentFragment;
+  new(): JSXElementClassDocumentFragment;
+}
+
+// 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 isFragment = (type: DocumentFragmentConstructor | ElementFunction):
+  type is DocumentFragmentConstructor => type === DocumentFragment;
+
+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: Element | DocumentFragment, children: Node[]) => {
+  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));
+    }
+  }
+};
+
+// 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 = (
+  type: DocumentFragmentConstructor | ElementFunction | string,
+  attributes?: Attributes,
+  ...children: Node[]
+) => {
+  if (typeof type !== 'string') {
+    const element = isFragment(type) ? document.createDocumentFragment() : 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);
+    } 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;
+    } else if (name !== 'key' && (FALSIFIABLE_ATTRIBUTES.includes(name) || value !== false)) {
+      setAttribute(element, name, value === true ? '' : value);
+    }
+  }
+
+  return element;
+};
+
+export const Fragment =
+  (typeof DocumentFragment === 'function' ? DocumentFragment : () => {}) as Fragment;

package/src/tools/display/ui.css

@@ -0,0 +1,351 @@
+#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;
+  --radius: 10px;
+}
+details > summary {
+  list-style: none;
+}
+details > summary::-webkit-details-marker {
+  display: none;
+}
+.battle > .details {
+  background: #eee;
+  border-bottom: 3px solid black;
+  border-radius: var(--radius) var(--radius) 0 0;
+  padding: 0 1em;
+  display: flex;
+  justify-content: space-between;
+}
+.inner {
+  display: flex;
+  justify-content: center;
+  flex-direction: column;
+}
+.side > .details {
+  padding: 0.5em 1em;
+  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;
+  border-radius: var(--radius);
+}
+summary {
+  border-top: 1px solid #eee;
+  text-align: center;
+  padding: 0.25em;
+}
+.good {
+  color: green;
+}
+.bad {
+  color: red;
+}
+.pokemon {
+  position: relative;
+  padding: 0.5em 1em;
+  border-top: 1px solid black;
+  display: flex;
+}
+.active > .pokemon {
+  border-top: 1px solid #eee;
+}
+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 {
+  display: grid;
+  grid-template-columns: repeat(2, auto);
+  gap: 0 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 {
+    grid-template-columns: repeat(1, auto);
+  }
+}
+@media(max-width: 1100px) {
+  .pokemon {
+    flex-direction: column;
+  }
+  .stats {
+    justify-content: center;
+    padding: 0;
+  }
+  .boosts {
+    margin-left: 5px;
+  }
+  .moves ul {
+    grid-template-columns: repeat(2, auto);
+  }
+  .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 {
+    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;
+}