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

package/LICENSE

@@ -1,6 +1,4 @@
-The MIT License (MIT)
-
-Copyright (c) 2021-2023 pkmn contributors
+Copyright (c) 2021-2024 pkmn contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

package/README.md

@@ -3,7 +3,7 @@
   <br />
   <br />
   <a href="https://github.com/pkmn/engine/actions/workflows/test.yml">
-    <img alt="Test Status" src="https://github.com/pkmn/engine/workflows/Tests/badge.svg" />
+    <img alt="Test Status" src="https://github.com/pkmn/engine/actions/workflows/test.yml/badge.svg" />
   </a>
   <a href="#status">
     <img alt="WIP" src="https://img.shields.io/badge/status-WIP-red.svg" />
@@ -12,13 +12,21 @@
     <img alt="License" src="https://img.shields.io/badge/License-MIT-blue.svg" />
   </a>
 </p>
+
+> [!WARNING]  
+> **This project is under heavy development** and currently the `main` branch contains numerous breaking
+> changes which may not work and which are not fully documented. Please **wait for the forthcoming
+> initial v0.1 release** before depending on this project (code from the
+> [`old`](https://github.com/pkmn/engine/releases/tag/old) tag can also be used to experiment with a
+> more stable version of the codebase).
+
 <hr />
 
 A minimal, complete, Pokémon battle simulation engine optimized for performance and
 [designed](docs/DESIGN.md) for tooling, embedded systems, and [artificial
 intelligence](https://github.com/pkmn/0-ERROR) use cases. This engine aims to be a frame-accurate and
 [bug-for-bug compatible](http://www.catb.org/jargon/html/B/bug-for-bug-compatible.html)
-implementation of both Pokémon battles as defined by the original game code, and the [Pokémon
+implementation of both Pokémon battles as defined by the original game code and the [Pokémon
 Showdown](https://pokemonshowdown.com/)[^1] simulator which represents Pokémon battling as practically
 interpreted online.
 
@@ -49,14 +57,14 @@ $ zig build --prefix /usr/local -Doptimize=ReleaseFast
 ```
 
 The Zig website has [installation instructions](https://ziglang.org/learn/getting-started/) which
-walk through how to install Zig on each platform - the engine code should work on Zig v0.11.0 dev
-build 2168 or greater, though tracks Zig's master branch so this may change in the future if
-breaking language changes are introduced:
+walk through how to install Zig on each platform - the engine code should work on Zig v0.13.0,
+though tracks Zig's master branch so this may change in the future if breaking language changes are
+introduced.
 
 `libpkmn` can be built with `-Dshowdown` to instead produce the Pokémon Showdown compatible
-`libpkmn-showdown` library. Furthermore, trace logging can be enabled through `-Dtrace`. The
-`libpkmn` and `libpkmn-showdown` objects available in the binary release are compiled with and
-without the `-Dtrace` flag respectively.
+`libpkmn-showdown` library. Furthermore, protocol message logging can be enabled through `-Dlog`.
+The `libpkmn` and `libpkmn-showdown` objects available in the binary release are both compiled with
+the `-Dlog` flag by default.
 
 ### `@pkmn/engine`
 
@@ -67,44 +75,67 @@ $ npm install @pkmn/engine
 ```
 
 The driver depends on being able to find compiled Node/WASM addons in
-`node_modules/@pkmn/engine/build/lib` in order to be useful. When you install the package a
-[`postinstall` lifecycle script](https://docs.npmjs.com/cli/v8/using-npm/scripts) will run
-[`install-pkmn-engine`](src/bin/install-pkmn-engine) which will check for a compatible `zig`
-compiler (see above regarding minimum version) and download one to
-`node_module/@pkmn/engine/build/bin` if it can't find one, as well as looking for (and downloading,
-if necessary) the required Node headers needed to successfully build the addons natively.
-
-**If you have configured NPM to `--ignore-scripts` you must either run `npx install-pkmn-engine`
+`node_modules/@pkmn/engine/build/lib` to be useful. When you install the package a [`postinstall`
+lifecycle script](https://docs.npmjs.com/cli/v8/using-npm/scripts) runs
+[`install-pkmn-engine`](src/bin/install-pkmn-engine) which checks for a compatible `zig` compiler
+(see earlier regarding minimum version) and download one to `node_module/@pkmn/engine/build/bin` if
+it can't find one, as well as looking for (and downloading, if necessary) the required Node headers
+needed to successfully build the addons natively.
+
+**If you have configured `npm` to `--ignore-scripts` you must either run `npx install-pkmn-engine`
 directly or build the addons manually and place the artifacts in the expected paths.**
 
 ### `pkmn`
 
-Until the [Zig package manager](https://github.com/ziglang/zig/projects/4) is completed, the
-recommended way of using the `pkmn` package in Zig is by either copying this repository into your
-project or by using [git submodules](https://git-scm.com/book/en/v2/Git-Tools-Submodules) and then
-adding the following to your `build.zig`:
+To include `pkmn`, add it as a dependency in your project's
+[`build.zig.zon`](https://github.com/ziglang/zig/blob/master/doc/build.zig.zon.md):
+
+
+```zig
+.dependencies = .{
+    .pkmn = .{
+        .url = "https://github.com/pkmn/engine/archive/RELEASE.tar.gz",
+    },
+},
+```
+
+Replace `RELEASE` with the tag for the [release](https://github.com/pkmn/engine/releases) you wish
+to use (e.g. `0.1.0` or `nightly`) or the specific hash of any commit. Next, run `zig build` and
+copy the expected hash from the error message into your `build.zig.zon` alongside the `.url`:
+
+```sh
+$ zig build
+error: dependency is missing hash field
+            .url = "https://github.com/pkmn/engine/archive/nightly.tar.gz",
+                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+note: expected .hash = "122056b93b403033cb7d9bed96a02c2eb8cc1275515976167726ada6eb4207e8ef8a",
+```
+
+Note that this hash is **not** going to be the same as the commit hash. After adding the hash to
+your `build.zig.zon` you will be able to import the `pkmn` package's build helpers into your
+`build.zig`:
 
 ```zig
 const std = @import("std");
-const pkmn = @import("lib/pkmn/build.zig");
+const pkmn = @import("pkmn");
 
-pub fn build(b: *std.build.Builder) void {
+pub fn build(b: *std.Build) void {
     ...
-    exe.addModule("pkmn", pkmn.module(b, .{ .showdown = true, .trace = true }));
+    exe.addModule("pkmn", pkmn.module(b, .{ .showdown = true, .log = true }));
     ...
 }
 ```
 
-The engine's `build.zig` exposes a `module` function that takes an options structure to allow for
-configuring whether or not Pokémon Showdown compatibility mode or trace logs should be enabled.
-Alternatively, you may set options via a `pkmn_options` [root source file
+The `pkmn` package exposes a `module` function that takes an options structure to allow for
+configuring whether or not Pokémon Showdown compatibility mode or protocol message logging should be
+enabled. Alternatively, you may set options via a `pkmn_options` [root source file
 declaration](https://ziglang.org/documentation/master/#Root-Source-File). There are several
 undocumented internal options that can be tweaked as well via build or root options, though these
-options are not officially supported, affect correctness, and may change meaning or behavior without
+options aren't officially supported, affect correctness, and may change meaning or behavior without
 warning. Use at your own risk.
 
 ```zig
-pub const pkmn_options = .{ .showdown = true, .trace = true };
+pub const pkmn_options = .{ .showdown = true, .log = true };
 ```
 
 ## Usage
@@ -112,63 +143,66 @@ pub const pkmn_options = .{ .showdown = true, .trace = true };
 For each Pokémon generation, the engine provides a battle structure with two functions - a function
 to `update` the battle's state based on both players' choices and a function that defines which
 `choices` are valid at that decision point (at the beginning of a battle both player's must "pass"
-as their first choice in order to switch in the first member of their party). If `-Dtrace` logging
-is enabled each update will produce logs which can be decoded into a buffer (`LOGS_SIZE` constants
-are provided to make it easy to allocate a buffer of the correct size). Each `update` will return a
-result to indicate either that the battle has terminated or which types of choices will be available
-for each player.
+as their first choice to switch in the first member of their party). If `-Dlog` protocol logging is
+enabled each update produces logs which can be decoded into a buffer (`LOGS_SIZE` constants are
+provided to make it easy to allocate a buffer of the correct size). Each `update` returns a result
+to indicate either that the battle has terminated or which types of choices are available for each
+player.
 
 Unlike [Pokémon Showdown's
 SIM-PROTOCOL](https://github.com/smogon/pokemon-showdown/blob/master/sim/SIM-PROTOCOL.md#choice-requests)
 which provides a rich request object at each decision point, the pkmn engine computes the possible
-choices on demand based on the result of the previous `update` and the battle state (`OPTIONS_SIZE`
+choices on demand based on the result of the previous `update` and the battle state (`CHOICES_SIZE`
 is a good size to initialize the buffer passed to `choices`). **Attempting to update the battle with
 a choice not present in the options returned by `choices` is undefined behavior and may corrupt
 state or cause the engine to crash.**
 
 Battles may be played out from any point but to freshly initialize a battle which is yet to start
 the turn count and active Pokémon should be zeroed out (driver code should handle this for you).
-Most driver code should also provide helpers to make initialize a battle convenient - check the
+Most driver code should also provide helpers to make initializing battle convenient - check the
 respective documentation and examples for the bindings being used. The engine's [protocol
 documentation](docs/PROTOCOL.md) goes into greater detail on the specifics of updates and the
 potential logs that may result.
 
 *The snippets below are meant to merely illustrate in broad strokes how the pkmn engine can be used
-\- the [`examples`](src/examples) directory contains fully commented and runnable code.*
+\- the [`examples`](examples) directory contains fully commented and runnable code.*
 
 ### C
 
 [`pkmn.h`](src/include/pkmn.h) exports the C API for `libpkmn`. Symbols are all prefixed with
-`pkmn_` to avoid name collisions. If `-Dtrace` is enabled and logging throws an error then the error
-will be encoded in the `pkmn_result` and can be checked with `pkmn_error`.
+`pkmn_` to avoid name collisions. If `-Dlog` is enabled and logging throws an error then the error
+is encoded in the `pkmn_result` and can be checked with `pkmn_error`.
 
 ```c
 #include <pkmn.h>
 
+pkmn_battle_options options;
+pkmn_gen1_battle_options_set(&options, ...);
 pkmn_battle battle = ...;
-uint8_t buf[PKMN_LOGS_SIZE];
+
 pkmn_result result;
 pkmn_choice c1 = 0, c2 = 0;
-while (!pkmn_result_type(result = pkmn_battle_update(&battle, c1, c2, buf, PKMN_LOGS_SIZE))) {
+while (!pkmn_result_type(result = pkmn_battle_update(&battle, c1, c2, &options))) {
   c1 = choose(PKMN_PLAYER_P1, pkmn_result_p1(result));
   c2 = choose(PKMN_PLAYER_P2, pkmn_result_p2(result));
+  pkmn_gen1_battle_options_set(&options, ...);
 }
 if (pkmn_error(result)) exit(1);
 ```
 
-[(full code)](src/examples/c/example.c)
+[(full code)](examples/c/example.c)
 
-The C API does not export any helpers for creating or accessing the opaque battle objects - it is
+The C API doesn't export any helpers for creating or accessing the opaque battle objects - it's
 instead intended to be used as the foundation for more ergonomic bindings in [other
 languages](#other) (the lack of namespaces and bit fields having an implementation-defined layout in
 C are the main contributing factors to the sparseness of what `libpkmn` chooses to expose).
 
 ### JavaScript / TypeScript
 
-`@pkmn/engine` depends on the [`@pkmn/data`](https://www.npmjs.com/package/@pkmn/data) which
+`@pkmn/engine` depends on the [`@pkmn/data`](https://www.npmjs.com/package/@pkmn/data) package which
 requires a `Dex` implementation to be provided as well. The `Battle.create` function can be used to
 initialize a `Battle` from the beginning, or `Battle.restore` can be used to re-instantiate a battle
-which is in already progress. If logging is enabled the output can be turned into Pokémon Showdown
+which is already in progress. If logging is enabled the output can be turned into Pokémon Showdown
 protocol via `Log.parse`.
 
 ```ts
@@ -191,20 +225,20 @@ while (!(result = battle.update(c1, c2)).type) {
 console.log(result);
 ```
 
-[(full code)](src/examples/js/example.ts)
+[(full code)](examples/js/example.ts)
 
-By default, the `@pkmn/engine` package will compile the engine with `-Dshowdown`, though by running
+By default, the `@pkmn/engine` package compiles the engine with `-Dshowdown`, though by running
 `install-pkmn-engine` directly and passing in `--options` you can override this default and build
 different configurations of the extension for the driver to use. The driver can support
 configurations both with and without Pokémon Showdown compatibility simultaneously if present. On
-update, the post-install script will attempt to rebuild whichever extensions it finds with the same
+update, the post-install script attempts to rebuild whichever extensions it finds with the same
 configuration parameters that were originally used meaning updating to the newest version of the
 library should be seamless.
 
 Despite relying on the native engine code, the `@pkmn/engine` code is designed to also work in
 browsers which support [WebAssembly](https://webassembly.org/). Running `npm run start:web` from the
-[`examples`](src/examples/js) directory will start a server that can be used to demonstrate the
-engine running in the browser.
+[`examples`](examples/js) directory starts a server that can be used to demonstrate the engine
+running in the browser.
 
 ### Zig
 
@@ -215,29 +249,29 @@ be used when logging is enabled to allow for easily printing e.g. to standard ou
 const std = @import("std");
 const pkmn = @import("pkmn");
 
-var random = std.rand.DefaultPrng.init(seed).random();
-var options: [pkmn.OPTIONS_SIZE]pkmn.Choice = undefined;
+var random = std.Random.DefaultPrng.init(seed).random();
+var choices: [pkmn.CHOICES_SIZE]pkmn.Choice = undefined;
 
 var battle = ...
-var log = ...
+var options = pkmn.battle.options(...);
 
 var c1 = pkmn.Choice{};
 var c2 = pkmn.Choice{};
 
-var result = try battle.update(c1, c2, log);
-while (result.type == .None) : (result = try battle.update(c1, c2, log)) {
-    c1 = options[random.uintLessThan(u8, battle.choices(.P1, result.p1, &options))];
-    c2 = options[random.uintLessThan(u8, battle.choices(.P2, result.p2, &options))];
+var result = try battle.update(c1, c2, &options);
+while (result.type == .None) : (result = try battle.update(c1, c2, &options)) {
+    c1 = choices[random.uintLessThan(u8, battle.choices(.P1, result.p1, &choices))];
+    c2 = choices[random.uintLessThan(u8, battle.choices(.P2, result.p2, &choices))];
 }
 
 std.debug.print("{}\n", .{result.type});
 ```
 
-[(full code)](src/examples/zig/example.zig)
+[(full code)](examples/zig/example.zig)
 
 The Zig package also supports some APIs which are difficult to expose elsewhere such as the
 `FixedRNG` which allows you to fully specify the exact RNG frames (which can be useful for ensuring
-certain outcomes/effects always occur) for a battle, though doing so will change the size of the
+certain outcomes/effects always occur) for a battle, though doing so changes the size of the
 `Battle` object.
 
 ### Other
@@ -248,12 +282,40 @@ simplify the process even further [`src/data`](src/data) contains JSON dumps of
 data, structure sizes and offsets, and protocol information used by the reference driver code. The
 following is a list of known `libpkmn` bindings written by developers outside of the [pkmn
 organization](https://github.com/pkmn) that may be helpful (though note that these projects may not
-necessarily be up-to-date/complete/correct - inclusion in this list does not imply endorsement):
+necessarily be up-to-date/complete/correct - inclusion in this list doesn't imply endorsement):
+
+| Language   | License   | URL                                  |
+| ---------- | --------- | ------------------------------------ |
+| **C++**    | `BSL-1.0` | https://github.com/pasyg/wrapsire    |
+| **Python** | `MIT`     | https://github.com/AnnikaCodes/PyKMN |
 
-| Language   | License   | URL                                     |
-| ---------- | --------- | --------------------------------------- |
-| **C++**    | `BSL-1.0` | https://github.com/pasyg/engine-wrapper |
-| **Python** | `MIT`     | https://github.com/AnnikaCodes/PyKMN    |
+
+#### `pkmn-debug`
+
+The [`@pkmn/engine`](#pkmnengine) package ships with a `pkmn-debug` tool which exists to decode the
+binary data structures and protocols used by the engine and to output a [standalone
+webpage](https://pkmn.cc/debug.html) that can be used for debugging. To use this tool in a folder
+that has the `@pkmn/engine` package installed locally you can use `npx pkmn-debug`, though you may
+also wish to install the package globally to be able to use this tool anywhere without
+[`npx`](https://docs.npmjs.com/cli/v7/commands/npx):
+
+```sh
+$ npm install --global @pkmn/engine
+```
+
+By default, `pkmn-debug` expects to read [binary debug protocol](docs/PROTOCOL.md#debugging) from
+[standard input](https://en.wikipedia.org/wiki/Standard_streams) and output HTML to standard output:
+
+```sh
+$ <cmd> | pkmn-debug > index.html
+```
+
+Alternatively, if a single filename argument is passed to the `pkmn-debug` it reads from that
+instead:
+
+```sh
+$ pkmn-debug <file> > index.html
+```
 
 ## Status
 
@@ -270,14 +332,14 @@ Currently, most of the foundational work from stage 0 is done:
   
 - [benchmark and integration testing](src/test) infrastructure
 - [documentation](docs) about design, research, methodology, etc
-- definition and implementation of the [protocol](docs/PROTOCOL.md) that will be used by the engine
+- definition and implementation of the [protocol](docs/PROTOCOL.md) that's used by the engine
 
-**Stage 1 is currently in progress** and will see the implementation of the actual Generation I & II
+**Stage 1 is currently in progress** and involves the implementation of the actual Generation I & II
 battle engines, followed by Generation III & IV in stage 2. The implementation of further Pokémon
-generations is in scope for the project but should not be considered as part of the immediate
-roadmap (i.e. exploring the options for broadening support for old generation APIs will be given
-higher priority than implementing more modern generations). Furthermore, implementation of modern
-generations is soft-blocked on the [availability of high quality
+generations is in scope for the project but shouldn't be considered part of the immediate roadmap
+(i.e. exploring the options for broadening support for old generation APIs is given higher priority
+than implementing more modern generations). Furthermore, implementation of modern generations is
+soft-blocked on the [availability of high quality
 decompilations](https://github.com/orgs/pret/repositories) of the original games in question.
 
 Certain features will always be deemed **out of scope**:
@@ -295,10 +357,10 @@ The pkmn engine is distributed under the terms of the [MIT License](LICENSE).
 [^1]: In the case of Pokémon Showdown, only bugs which stem from a misimplementation of specific
   effects are reproduced in the engine, bugs which are the result of a misunderstanding of the
   fundamental mechanics of Pokémon or which simply arise due to specific Pokémon Showdown
-  implementation details that are not replicable without making the same (incorrect) architectural
-  choices are not. Furthermore, the "Pokémon Showdown" code referenced by this project includes
+  implementation details that aren't replicable without making the same (incorrect) architectural
+  choices aren't. Furthermore, the "Pokémon Showdown" code referenced by this project includes
   several [patches](docs/TESTING.md#patches) to improve accuracy and smooth over some of the more
   egregious implementation issues. In practical terms, the vast majority of games played out in the
-  pkmn engine's compatibility mode and on this patched Pokémon Showdown simulator will be the same,
-  it is only in a well defined and documented set of circumstances where the two implementations
+  pkmn engine's compatibility mode and on this patched Pokémon Showdown simulator are the same,
+  it's only in a well defined and documented set of circumstances where the two implementations
   diverge.

package/build/pkg/addon.d.ts

@@ -0,0 +1,7 @@
+import { Choice, Player, Result } from '.';
+export declare function check(showdown: boolean): void;
+export declare function supports(showdown: boolean, log?: boolean): boolean;
+export declare function update(index: number, showdown: boolean, battle: ArrayBuffer, c1?: Choice, c2?: Choice, log?: ArrayBuffer): Result;
+export declare function choices(index: number, showdown: boolean, battle: ArrayBuffer, player: Player, choice: Choice['type'], buf: ArrayBuffer): Choice[];
+export declare function choose(index: number, showdown: boolean, battle: ArrayBuffer, player: Player, choice: Choice['type'], buf: ArrayBuffer, fn: (n: number) => number): Choice;
+export declare function size(index: number, type: 'choices' | 'log'): number;

package/build/pkg/addon.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = check;
+exports.supports = supports;
+exports.update = update;
+exports.choices = choices;
+exports.choose = choose;
+exports.size = size;
+const path = __importStar(require("path"));
+const _1 = require(".");
+const ROOT = path.join(__dirname, '..', '..');
+let ADDON = undefined;
+function load() {
+    if (ADDON)
+        return ADDON;
+    let pkmn = undefined;
+    let showdown = undefined;
+    try {
+        pkmn = require(path.join(ROOT, 'build', 'lib', 'pkmn.node')).engine;
+    }
+    catch { }
+    try {
+        showdown =
+            require(path.join(ROOT, 'build', 'lib', 'pkmn-showdown.node')).engine;
+    }
+    catch { }
+    if (!pkmn && !showdown) {
+        throw new Error('Could not find native addons - did you run `npx install-pkmn-engine`?');
+    }
+    return (ADDON = [pkmn, showdown]);
+}
+function check(showdown) {
+    if (!load()[+showdown]) {
+        const opts = ADDON[+!showdown].options.log ? ['-log'] : [];
+        if (showdown)
+            opts.push('-Dshowdown');
+        throw new Error(`@pkmn/engine has ${showdown ? 'not' : 'only'} been configured to support Pokémon Showdown.` +
+            `\n(running \`npx install-pkmn-engine --options='${opts.join(' ')}'\` can fix this issue).`);
+    }
+}
+function supports(showdown, log) {
+    if (!load()[+showdown])
+        return false;
+    if (log === undefined)
+        return true;
+    return ADDON[+showdown].options.log === log;
+}
+function update(index, showdown, battle, c1, c2, log) {
+    return _1.Result.decode(ADDON[+showdown].bindings[index]
+        .update(battle, _1.Choice.encode(c1), _1.Choice.encode(c2), log));
+}
+function choices(index, showdown, battle, player, choice, buf) {
+    const request = choice[0] === 'p' ? 0 : choice[0] === 'm' ? 1 : 2;
+    const n = ADDON[+showdown].bindings[index].choices(battle, +(player !== 'p1'), request, buf);
+    // The top-level API signature means our hands our tied with respect to
+    // writing really fast bindings here. The simplest approach would be to return
+    // the ArrayBuffer the bindings populate as well as its size and only decode a
+    // Choice after the selection. However, given that we need to return
+    // `Choices[]` we need to decode all of them even if they're not all being
+    // used which is wasteful. This shouldn't be *that* bad as its a very small
+    // list, but its still wasted work. Switching the top-level API to return an
+    // Iterable<Choice> doesn't help as we need both the length and the ability to
+    // randomly access it, so the best way to make the current API fast would be
+    // to have the Zig bindings create Choice objects directly, only that won't
+    // scale well as it would require us to basically rewrite the low-level
+    // choices function for each generation within node.zig. We could do something
+    // really galaxy-brained and return some sort of frankenstein subclass of
+    // Array backed by ArrayBuffer which would lazily decode the Choice on access,
+    // but thats ultimately not worth the effort. You can't have both a high-level
+    // idiomatic API and performance here, hence why the choose function below
+    // exists.
+    const options = new Array(n);
+    const data = new Uint8Array(buf);
+    for (let i = 0; i < n; i++)
+        options[i] = _1.Choice.decode(data[i]);
+    return options;
+}
+function choose(index, showdown, battle, player, choice, buf, fn) {
+    const request = choice[0] === 'p' ? 0 : choice[0] === 'm' ? 1 : 2;
+    const n = ADDON[+showdown].bindings[index].choices(battle, +(player !== 'p1'), request, buf);
+    const data = new Uint8Array(buf);
+    return _1.Choice.decode(data[fn(n)]);
+}
+function size(index, type) {
+    const bindings = (ADDON[1] ?? ADDON[0]).bindings[index];
+    return type[0] === 'c' ? bindings.CHOICES_SIZE : bindings.LOGS_SIZE;
+}
+//# sourceMappingURL=addon.js.map

package/build/pkg/addon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addon.js","sourceRoot":"","sources":["../../src/pkg/addon.ts"],"names":[],"mappings":"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"}

package/build/pkg/data/ids.json

@@ -20,15 +20,15 @@
     },
     {
         "types": [
+            "Ground",
+            "Rock",
+            "Steel",
             "Normal",
             "Fighting",
             "Flying",
             "Poison",
-            "Ground",
-            "Rock",
             "Bug",
             "Ghost",
-            "Steel",
             "???",
             "Fire",
             "Water",
@@ -40,15 +40,15 @@
             "Dark"
         ],
         "items": [
+            "softsand",
+            "hardstone",
+            "metalcoat",
             "pinkbow",
             "blackbelt",
             "sharpbeak",
             "poisonbarb",
-            "softsand",
-            "hardstone",
             "silverpowder",
             "spelltag",
-            "metalcoat",
             "polkadotbow",
             "charcoal",
             "mysticwater",
@@ -65,21 +65,21 @@
             "stick",
             "thickclub",
             "focusband",
-            "berryjuice",
             "scopelens",
             "leftovers",
             "berserkgene",
             "lightball",
+            "berry",
+            "berryjuice",
+            "goldberry",
+            "mintberry",
             "psncureberry",
             "przcureberry",
-            "burntberry",
             "iceberry",
-            "bitterberry",
-            "mintberry",
+            "burntberry",
             "miracleberry",
+            "bitterberry",
             "mysteryberry",
-            "berry",
-            "goldberry",
             "masterball",
             "ultraball",
             "greatball",

package/build/pkg/data/layout.json

@@ -4,15 +4,17 @@
             "Battle": 384,
             "Side": 184,
             "Pokemon": 24,
-            "ActivePokemon": 32
+            "ActivePokemon": 32,
+            "Actions": 16,
+            "Summaries": 12
         },
         "offsets": {
             "Battle": {
                 "sides": 0,
                 "turn": 368,
                 "last_damage": 370,
-                "last_selected_indexes": 372,
-                "rng": 373
+                "last_moves": 372,
+                "rng": 374
             },
             "Side": {
                 "pokemon": 0,
@@ -77,9 +79,29 @@
                 "state": 24,
                 "substitute": 40,
                 "transform": 48,
-                "disabled_duration": 52,
-                "disabled_move": 56,
+                "disable_duration": 52,
+                "disable_move": 56,
                 "toxic": 59
+            },
+            "Action": {
+                "damage": 0,
+                "hit": 8,
+                "critical_hit": 10,
+                "secondary_chance": 12,
+                "speed_tie": 14,
+                "confused": 16,
+                "paralyzed": 18,
+                "duration": 20,
+                "durations": 24,
+                "move_slot": 40,
+                "multi_hit": 44,
+                "psywave": 48,
+                "metronome": 56
+            },
+            "Damage": {
+                "base": 0,
+                "final": 2,
+                "capped": 4
             }
         }
     }