@pkmn/engine 0.1.0-dev.21a51fe4 → 0.1.0-dev.2ad317f2

package/README.md

@@ -12,6 +12,14 @@
     <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
@@ -50,7 +58,7 @@ $ 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 3859 or greater, though tracks Zig's master branch so this may change in the future if
+build 4282 or greater, 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

package/build.zig

@@ -35,6 +35,7 @@ pub fn build(b: *std.Build) !void {
     const strip = b.option(bool, "strip", "Strip debugging symbols from binary") orelse false;
     const pic = b.option(bool, "pic", "Force position independent code") orelse false;
     const emit_asm = b.option(bool, "emit-asm", "Output .s (assembly code)") orelse false;
+    const emit_ll = b.option(bool, "emit-ll", "Output .ll (LLVM IR)") orelse false;
 
     const cmd = b.findProgram(&.{"strip"}, &.{}) catch null;
 
@@ -145,7 +146,8 @@ pub fn build(b: *std.Build) !void {
         lib.bundle_compiler_rt = true;
         maybeStrip(b, lib, b.getInstallStep(), strip, cmd);
         if (pic) lib.force_pic = pic;
-        if (emit_asm) lib.emit_asm = .emit;
+        if (emit_asm) lib.emit_asm = .{ .emit_to = b.fmt("{s}.S", .{name}) };
+        if (emit_ll) lib.emit_llvm_ir = .{ .emit_to = b.fmt("{s}.ll", .{name}) };
         b.installArtifact(lib);
         c = true;
     }
@@ -217,19 +219,15 @@ pub fn build(b: *std.Build) !void {
     fuzz_config.tool.name = "fuzz";
     const fuzz = tool(b, "src/test/fuzz.zig", fuzz_config);
 
+    const analyze = tool(b, "src/tools/analyze.zig", tools);
     const dump = tool(b, "src/tools/dump.zig", tools);
     const serde = tool(b, "src/tools/serde.zig", tools);
     const transitions = tool(b, "src/tools/transitions.zig", tools);
 
-    const lint_exe =
-        b.addExecutable(.{ .name = "lint", .root_source_file = .{ .path = "src/tools/lint.zig" } });
-    if (tests.build) tests.step.dependOn(&lint_exe.step);
-    const lint = b.addRunArtifact(lint_exe);
-
+    b.step("analyze", "Run LLVM analysis tool").dependOn(&analyze.step);
     b.step("benchmark", "Run benchmark code").dependOn(&benchmark.step);
     b.step("dump", "Run protocol dump tool").dependOn(&dump.step);
     b.step("fuzz", "Run fuzz tester").dependOn(&fuzz.step);
-    b.step("lint", "Lint source files").dependOn(&lint.step);
     b.step("serde", "Run serialization/deserialization tool").dependOn(&serde.step);
     b.step("test", "Run all tests").dependOn(&tests.step);
     b.step("tools", "Install tools").dependOn(&ToolsStep.create(b, &exes).step);
@@ -263,12 +261,6 @@ const Config = struct {
     cmd: ?[]const u8,
 };
 
-const TESTS = .{
-    "src/lib/common/test.zig",
-    "src/lib/gen1/test.zig",
-    "src/lib/gen2/test.zig",
-};
-
 const TestStep = struct {
     step: std.Build.Step,
     build: bool,
@@ -283,26 +275,27 @@ const TestStep = struct {
         const step = std.Build.Step.init(.{ .id = .custom, .name = "Run all tests", .owner = b });
         self.* = TestStep{ .step = step, .build = test_filter == null };
 
-        const paths: []const []const u8 =
-            if (test_file) |t| &.{t} else if (coverage != null) &.{"src/lib/test.zig"} else &TESTS;
-        for (paths) |path| {
-            const tests = b.addTest(.{
-                .name = std.fs.path.basename(std.fs.path.dirname(path).?),
-                .root_source_file = .{ .path = path },
-                .optimize = config.optimize,
-                .target = config.target,
-                .filter = test_filter,
-            });
-            tests.setMainPkgPath("./");
-            tests.addOptions("build_options", options);
-            tests.single_threaded = true;
-            maybeStrip(b, tests, &tests.step, config.strip, config.cmd);
-            if (config.pic) tests.force_pic = config.pic;
-            if (coverage) |c| {
-                tests.setExecCmd(&.{ "kcov", "--include-pattern=src/lib", c, null });
-            }
-            self.step.dependOn(&b.addRunArtifact(tests).step);
+        const path = test_file orelse "src/lib/test.zig";
+        const tests = b.addTest(.{
+            .name = b.fmt("{s}-{s}", .{
+                std.fs.path.basename(std.fs.path.dirname(path).?),
+                std.fs.path.stem(std.fs.path.basename(path)),
+            }),
+            .root_source_file = .{ .path = path },
+            .optimize = config.optimize,
+            .target = config.target,
+            .filter = test_filter,
+        });
+        tests.setMainPkgPath("./");
+        tests.addOptions("build_options", options);
+        tests.single_threaded = true;
+        maybeStrip(b, tests, &tests.step, config.strip, config.cmd);
+        if (config.pic) tests.force_pic = config.pic;
+        if (coverage) |c| {
+            tests.setExecCmd(&.{ "kcov", "--include-pattern=src/lib", c, null });
         }
+        self.step.dependOn(&b.addRunArtifact(tests).step);
+
         return self;
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.21a51fe4",
+  "version": "0.1.0-dev.2ad317f2",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",

package/src/bin/install-pkmn-engine

@@ -10,7 +10,7 @@ const path = require('path');
 const {pipeline} = require('stream/promises');
 const tty = require('tty');
 
-const ZIG_VERSION = {major: 0, minor: 11, patch: 0, dev: 3859};
+const ZIG_VERSION = {major: 0, minor: 11, patch: 0, dev: 4282};
 const DEV = ZIG_VERSION.dev ? `-dev.${ZIG_VERSION.dev}` : '';
 const VERSION = `${ZIG_VERSION.major}.${ZIG_VERSION.minor}.${ZIG_VERSION.patch}${DEV}`;
 const INDEX = 'https://ziglang.org/download/index.json';

package/src/lib/gen1/README.md

@@ -6,7 +6,9 @@ document](../../../docs/DESIGN.md). The Generation I engine is implemented and t
 following files:
 
 - [`data.zig`](data.zig) ([`data`](data)): contains definitions of all of the data structures used
-  by the engine, described in detail [below](#data-structures)
+  to implement the core mechanics of the engine, described in detail [below](#data-structures)
+- [`chance.zig`](chance.zig): TODO
+- [`calc.zig`](calc.zig): TODO
 - [`helpers.zig`](helpers.zig): helpers used to construct complex data types with
   sensible defaults (internally used by tests and tools)
 - [`mechanics.zig`](mechanics.zig): code which manipulates the data structures to implement the
@@ -245,9 +247,17 @@ engine maintains a `Type.PRECEDENCE` table with just the match-ups that are rele
 pruned for efficiency) and only looks up precedence when necessary to minimize expensive searches.
 Pokémon Showdown doesn't implement type precedence.
 
+### `Chance` / `Actions` / `Action` / `Durations` / `Duration`
+
+TODO
+
+### `Calc` / `Overrides` / `Summaries` / `Summary`
+
+TODO
+
 ## Information
 
-The information of each field (in terms of [bits of
+The information of each field required for mechanics (in terms of [bits of
 entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory))) is as follows:
 
 | Data            | Range     | Bits |     | Data              | Range    | Bits |
@@ -383,7 +393,7 @@ data in the browser for ease of debugging.
 - `order` is a 6 byte array where `order[i]` represents the "slot" of `pokemon[i]`, where the slot
   is usually a unique value from 1 to 6 but can be 0 in situations where a player brings less than six
   Pokémon to battle (note however that if `order[i]` is 0 than for all j > 0 `order[i+j]` **must**
-  equal 0).
+  equal 0)
 
 ### `ActivePokemon`
 
@@ -469,6 +479,76 @@ data in the browser for ease of debugging.
 | 22    | 23  | `type1`/`type2` | The Pokémon's stored types                 |
 | 23    | 24  | `level`         | The Pokémon's level                        |
 
+
+### `Action`
+
+`Actions` consist of an `Action` for Player 1 followed by an `Action` for Player 2.
+
+> **NOTE:** The offsets in the following table represent *bits* and **not** bytes.
+
+| Start | End | Data                     | Description                                                                     |
+| ----- | --- | ------------------------ | ------------------------------------------------------------------------------- |
+| 0     | 8   | `damage`                 | The roll to be returned damage (217-255).                                       |
+| 8     | 10  | `hit`                    | The roll to be returned for accuracy (1 for miss, 2 for hit).                   |
+| 10    | 12  | `critical_hit`           | The roll to be returned for critical hits (1 for no, 2 for yes).                |
+| 12    | 14  | `secondary_chance`       | The roll to be returned for secondary chance rolls (1 for no-proc, 2 for proc). |
+| 14    | 16  | `speed_tie`              | The player to return for speed ties (1 for Player 1, 2 for Player 2).           |
+| 16    | 18  | `confused`               | The roll to be returned for confusion self-hits (1 for no-proc, 2 for proc).    |
+| 18    | 20  | `paralyzed`              | The roll to be returned for full paralysis (1 for no-proc, 2 for proc).         |
+| 20    | 24  | `duration`               | The roll to be returned for the duration (including for binding moves).         |
+| 24    | 40  | [`durations`](#duration) | Values of various durations.                                                    |
+| 40    | 44  | `move_slot`              | The roll to be returned for the move slot (1-4, invalid values ignored).        |
+| 44    | 48  | `move_slot`              | The roll to be returned for a multi-hit move distribution (2-5).                |
+| 48    | 56  | `psywave`                | One greater than the roll to be returned for Psywave damage.                    |
+| 56    | 64  | `metronome`              | The move to return for Metronome.                                               |
+
+- for any field a value of 0 is considered to be unset
+- **both Player 1 and Player 2 must set the same value for `speed_tie`.**
+- `duration` determines the roll for any effect which lasts over multiple turns, whereas `durations` can either be used to
+  track how long these effects have lasted (for the purposes of computing probablities with `-Dchance`) or can be used to
+  [override](#overrides) (extend or end) the duration of specfic effects with `-Dcalc`.
+
+#### `Duration`
+
+> **NOTE:** The offsets in the following table represent *bits* and **not** bytes.
+
+| Start | End | Data        |
+| ----- | --- | ----------- |
+| 0     | 3   | `sleep`     |
+| 3     | 6   | `confusion` |
+| 4     | 10  | `disable`   |
+| 10    | 13  | `attacking` |
+| 13    | 16  | `binding`   |
+
+- the meaning of each field depends on the context in which `Duration` appears:
+  - within `Chance` `actions`, the durations tracked refer to the number of turns a Pokémon has been
+    observed to be under an effect
+  - within `Overrides` `actions`, the durations refer to the value the next `Chance` `actions`
+    should be made to take on
+  - within `Overrides` `durations`, the durations serve as a mask to determine to whether or not the
+    durations in `Overrides` `actions` should be considered to be set or not
+◊
+### `Overrides`
+
+| Start | End | Data                        | Description                                                                           |
+| ----- | --- | --------------------------- | ------------------------------------------------------------------------------------- |
+| 0     | 8   | [`action.p1`](#action)      | Rolls to force Player 1's RNG to return for specific events.                          |
+| 8     | 16  | [`action.p2`](#action)      | Rolls to force Player 2's RNG to return for specific events.                          |
+| 16    | 18  | [`durations.p1`](#duration) | Whether or not to modify Player 1's effect durations to match `actions.p1.durations`. |
+| 18    | 20  | [`durations.p2`](#duration) | Whether or not to modify Player 2's effect durations to match `actions.p1.durations`. |
+| 20    | 24  | -                           | *Zero padding*                                                                        |
+
+### `Summaries`
+
+| Start | End | Data               | Description                                                                     |
+| ----- | --- | ------------------ | ------------------------------------------------------------------------------- |
+| 0     | 2   | `p1.damage.base`   | Player 1's base computed damage before the damage roll is applied.              |
+| 2     | 4   | `p1.damage.final`  | Player 1's final computed damage that gets applied to the Pokémon.              |
+| 4     | 6   | `p1.damage.capped` | Whether higher damage from Player 1 will saturate / result in the same outcome. |
+| 6     | 8   | `p2.damage.base`   | Player 2's base computed damage before the damage roll is applied.              |
+| 8     | 10  | `p2.damage.final`  | Player 2's final computed damage that gets applied to the Pokémon.              |
+| 10    | 12  | `p2.damage.capped` | Whether higher damage from Player 2 will saturate / result in the same outcome. |
+
 ## Bugs
 
 In addition to its alternative [RNG semantics](#rng), Pokémon Showdown's implementation of the first

package/src/lib/gen1/chance.zig

@@ -126,7 +126,7 @@ pub const Action = packed struct {
     /// If not None, the value to be returned for
     /// Rolls.{confusionChance,secondaryChance,poisonChance}.
     secondary_chance: Optional(bool) = .None,
-    /// If not None, the Playr to be returned by Rolls.speedTie.
+    /// If not None, the Player to be returned by Rolls.speedTie.
     speed_tie: Optional(Player) = .None,
 
     /// If not None, the value to return for Rolls.confused.
@@ -181,9 +181,9 @@ pub const Action = packed struct {
                     if (v != 0) {
                         if (printed) try writer.writeAll(", ");
                         if (shape) {
-                            try writer.print("{s}:?", .{field.name});
+                            try writer.print("{s}:?", .{f.name});
                         } else {
-                            try writer.print("{s}:{d}", .{ field.name, v });
+                            try writer.print("{s}:{d}", .{ f.name, v });
                         }
                         printed = true;
                     }

package/src/lib/gen1/helpers.zig

@@ -350,47 +350,65 @@ pub const Rolls = struct {
     const U3_NONE = [_]u3{0};
     const U3_FORCED = [_]u3{1};
 
-    /// Returns a slice with a range of values for sleep given the `action` state.
+    /// Returns a slice with a range of values for sleep given the `action` and `origin` states.
     pub inline fn sleep(action: Action, origin: Action) []const u3 {
-        const turns = @field(action.durations, "sleep");
-        _ = origin;
-        return if (turns < 1 or turns >= 7) &U3_NONE else &[_]u3{ 0, turns };
+        const a = @field(action.durations, "sleep");
+        const o = @field(origin.durations, "sleep");
+        if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
+        assert(a == 0 or a == o + 1);
+        return if (o >= 7) &U3_NONE else &[_]u3{ 0, o + 1 };
     }
 
     const DISABLE_NONE = [_]u4{0};
 
-    /// Returns a slice with a range of values for disable given the `action` state
+    /// Returns a slice with a range of values for disable given the `action` and `origin` states
     /// and the state of the `parent` (the player's Pokémon's remaining sleep turns).
     pub inline fn disable(action: Action, origin: Action, parent: u4) []const u4 {
-        const turns = @field(action.durations, "disable");
-        _ = origin;
-        return if (parent > 0 or turns < 1 or turns >= 8) &DISABLE_NONE else &[_]u4{ 0, turns };
+        if (parent > 0) return &DISABLE_NONE;
+        const a = @field(action.durations, "disable");
+        const o = @field(origin.durations, "disable");
+        if (o == a) return if (o == 0) &DISABLE_NONE else &[_]u4{o};
+        assert(a == 0 or a == o + 1);
+        return if (o >= 8) &DISABLE_NONE else &[_]u4{ 0, o + 1 };
     }
 
-    /// Returns a slice with a range of values for confusion given the `action` state
+    /// Returns a slice with a range of values for confusion given the `action` and `origin` states
     /// and the state of the `parent` (the player's remaining sleep turns).
     pub inline fn confusion(action: Action, origin: Action, parent: u4) []const u3 {
-        const turns = @field(action.durations, "confusion");
-        _ = origin;
-        if (parent > 0 or turns < 1 or turns >= 5) return &U3_NONE;
-        return if (turns < 2) &U3_FORCED else &[_]u3{ 0, turns };
+        if (parent > 0) return &U3_NONE;
+        const a = @field(action.durations, "confusion");
+        const o = @field(origin.durations, "confusion");
+        if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
+        assert(a == 0 or a == o + 1);
+        return if (o >= 5) &U3_NONE else if (o < 2)
+            if (a == 0) &U3_NONE else &U3_FORCED
+        else
+            &[_]u3{ 0, o + 1 };
     }
 
-    /// Returns a slice with a range of values for attacking given the `action` state
+    /// Returns a slice with a range of values for attacking given the `action` and `origin` states
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
     pub inline fn attacking(action: Action, origin: Action, parent: Optional(bool)) []const u3 {
-        const turns = @field(action.durations, "attacking");
-        _ = origin;
-        if (parent == .true or turns < 1 or turns >= 3) return &U3_NONE;
-        return if (turns < 2) &U3_FORCED else &[_]u3{ 0, turns };
+        if (parent == .true) return &U3_NONE;
+        const a = @field(action.durations, "attacking");
+        const o = @field(origin.durations, "attacking");
+        if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
+        assert(a == 0 or a == o + 1);
+        return if (o >= 3) &U3_NONE else if (o < 2)
+            if (a == 0) &U3_NONE else &U3_FORCED
+        else
+            &[_]u3{ 0, o + 1 };
     }
 
-    /// Returns a slice with a range of values for binding given the `action` state
+    /// Returns a slice with a range of values for binding given the `action` and `origin` states
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
     pub inline fn binding(action: Action, origin: Action, parent: Optional(bool)) []const u3 {
-        const turns = @field(action.durations, "binding");
-        _ = origin;
-        return if (parent == .true or turns < 1 or turns >= 4) &U3_NONE else &[_]u3{ 0, turns };
+        if (parent == .true) return &U3_NONE;
+        const a = @field(action.durations, "binding");
+        const o = @field(origin.durations, "binding");
+        if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
+        assert(a == 0 or a == o + 1);
+        return if (o >= 4) &U3_NONE else &[_]u3{ 0, o + 1 };
     }
 
     const SLOT_NONE = [_]u4{0};
@@ -535,72 +553,207 @@ test "Rolls.duration" {
     try expectEqualSlices(u1, &.{0}, Rolls.duration(actions.p2, .false));
 }
 
-const FIXME: Action = .{};
-
 test "Rolls.sleep" {
-    try expectEqualSlices(u3, &.{0}, Rolls.sleep(.{ .durations = .{ .sleep = 0 } }, FIXME));
-    try expectEqualSlices(u3, &.{0}, Rolls.sleep(.{ .durations = .{ .sleep = 7 } }, FIXME));
-    try expectEqualSlices(u3, &.{ 0, 4 }, Rolls.sleep(.{ .durations = .{ .sleep = 4 } }, FIXME));
+    try expectEqualSlices(u3, &.{0}, Rolls.sleep(
+        .{ .durations = .{ .sleep = 0 } },
+        .{ .durations = .{ .sleep = 0 } },
+    ));
+    try expectEqualSlices(u3, &.{ 0, 1 }, Rolls.sleep(
+        .{ .durations = .{ .sleep = 1 } },
+        .{ .durations = .{ .sleep = 0 } },
+    ));
+    try expectEqualSlices(u3, &.{ 0, 2 }, Rolls.sleep(
+        .{ .durations = .{ .sleep = 0 } },
+        .{ .durations = .{ .sleep = 1 } },
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.sleep(
+        .{ .durations = .{ .sleep = 1 } },
+        .{ .durations = .{ .sleep = 1 } },
+    ));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.sleep(
+        .{ .durations = .{ .sleep = 0 } },
+        .{ .durations = .{ .sleep = 2 } },
+    ));
+    try expectEqualSlices(u3, &.{ 0, 7 }, Rolls.sleep(
+        .{ .durations = .{ .sleep = 7 } },
+        .{ .durations = .{ .sleep = 6 } },
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.sleep(
+        .{ .durations = .{ .sleep = 0 } },
+        .{ .durations = .{ .sleep = 7 } },
+    ));
 }
 
 test "Rolls.disable" {
-    try expectEqualSlices(u4, &.{0}, Rolls.disable(.{ .durations = .{ .disable = 0 } }, FIXME, 0));
-    try expectEqualSlices(u4, &.{0}, Rolls.disable(.{ .durations = .{ .disable = 8 } }, FIXME, 0));
-    try expectEqualSlices(u4, &.{0}, Rolls.disable(.{ .durations = .{ .disable = 4 } }, FIXME, 1));
-    try expectEqualSlices(u4, &.{ 0, 4 }, Rolls.disable(.{
-        .durations = .{ .disable = 4 },
-    }, FIXME, 0));
+    try expectEqualSlices(u4, &.{0}, Rolls.disable(
+        .{ .durations = .{ .disable = 0 } },
+        .{ .durations = .{ .disable = 0 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{ 0, 1 }, Rolls.disable(
+        .{ .durations = .{ .disable = 1 } },
+        .{ .durations = .{ .disable = 0 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{ 0, 2 }, Rolls.disable(
+        .{ .durations = .{ .disable = 0 } },
+        .{ .durations = .{ .disable = 1 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{1}, Rolls.disable(
+        .{ .durations = .{ .disable = 1 } },
+        .{ .durations = .{ .disable = 1 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{ 0, 3 }, Rolls.disable(
+        .{ .durations = .{ .disable = 0 } },
+        .{ .durations = .{ .disable = 2 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{0}, Rolls.disable(
+        .{ .durations = .{ .disable = 0 } },
+        .{ .durations = .{ .disable = 2 } },
+        1,
+    ));
+    try expectEqualSlices(u4, &.{ 0, 8 }, Rolls.disable(
+        .{ .durations = .{ .disable = 8 } },
+        .{ .durations = .{ .disable = 7 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{0}, Rolls.disable(
+        .{ .durations = .{ .disable = 0 } },
+        .{ .durations = .{ .disable = 8 } },
+        0,
+    ));
 }
 
 test "Rolls.confusion" {
-    try expectEqualSlices(u3, &.{0}, Rolls.confusion(.{
-        .durations = .{ .confusion = 0 },
-    }, FIXME, 0));
-    try expectEqualSlices(u3, &.{0}, Rolls.confusion(.{
-        .durations = .{ .confusion = 5 },
-    }, FIXME, 0));
-    try expectEqualSlices(u3, &.{0}, Rolls.confusion(.{
-        .durations = .{ .confusion = 3 },
-    }, FIXME, 1));
-    try expectEqualSlices(u3, &.{1}, Rolls.confusion(.{
-        .durations = .{ .confusion = 1 },
-    }, FIXME, 0));
-    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.confusion(.{
-        .durations = .{ .confusion = 3 },
-    }, FIXME, 0));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 0 } },
+        .{ .durations = .{ .confusion = 0 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 1 } },
+        .{ .durations = .{ .confusion = 0 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 0 } },
+        .{ .durations = .{ .confusion = 1 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 1 } },
+        .{ .durations = .{ .confusion = 1 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.confusion(
+        .{ .durations = .{ .confusion = 0 } },
+        .{ .durations = .{ .confusion = 2 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 0 } },
+        .{ .durations = .{ .confusion = 2 } },
+        1,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 5 }, Rolls.confusion(
+        .{ .durations = .{ .confusion = 5 } },
+        .{ .durations = .{ .confusion = 4 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 0 } },
+        .{ .durations = .{ .confusion = 5 } },
+        0,
+    ));
 }
 
 test "Rolls.attacking" {
-    try expectEqualSlices(u3, &.{0}, Rolls.attacking(.{
-        .durations = .{ .attacking = 0 },
-    }, FIXME, .false));
-    try expectEqualSlices(u3, &.{0}, Rolls.attacking(.{
-        .durations = .{ .attacking = 3 },
-    }, FIXME, .false));
-    try expectEqualSlices(u3, &.{0}, Rolls.attacking(.{
-        .durations = .{ .attacking = 2 },
-    }, FIXME, .true));
-    try expectEqualSlices(u3, &.{1}, Rolls.attacking(.{
-        .durations = .{ .attacking = 1 },
-    }, FIXME, .false));
-    try expectEqualSlices(u3, &.{ 0, 2 }, Rolls.attacking(.{
-        .durations = .{ .attacking = 2 },
-    }, FIXME, .false));
+    try expectEqualSlices(u3, &.{0}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 0 } },
+        .{ .durations = .{ .attacking = 0 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 1 } },
+        .{ .durations = .{ .attacking = 0 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 0 } },
+        .{ .durations = .{ .attacking = 1 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 1 } },
+        .{ .durations = .{ .attacking = 1 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.attacking(
+        .{ .durations = .{ .attacking = 0 } },
+        .{ .durations = .{ .attacking = 2 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 0 } },
+        .{ .durations = .{ .attacking = 2 } },
+        .true,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.attacking(
+        .{ .durations = .{ .attacking = 3 } },
+        .{ .durations = .{ .attacking = 2 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 0 } },
+        .{ .durations = .{ .attacking = 3 } },
+        .false,
+    ));
 }
 
 test "Rolls.binding" {
-    try expectEqualSlices(u3, &.{0}, Rolls.binding(.{
-        .durations = .{ .binding = 0 },
-    }, FIXME, .false));
-    try expectEqualSlices(u3, &.{0}, Rolls.binding(.{
-        .durations = .{ .binding = 4 },
-    }, FIXME, .false));
-    try expectEqualSlices(u3, &.{0}, Rolls.binding(.{
-        .durations = .{ .binding = 2 },
-    }, FIXME, .true));
-    try expectEqualSlices(u3, &.{ 0, 2 }, Rolls.binding(.{
-        .durations = .{ .binding = 2 },
-    }, FIXME, .false));
+    try expectEqualSlices(u3, &.{0}, Rolls.binding(
+        .{ .durations = .{ .binding = 0 } },
+        .{ .durations = .{ .binding = 0 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 1 }, Rolls.binding(
+        .{ .durations = .{ .binding = 1 } },
+        .{ .durations = .{ .binding = 0 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 2 }, Rolls.binding(
+        .{ .durations = .{ .binding = 0 } },
+        .{ .durations = .{ .binding = 1 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.binding(
+        .{ .durations = .{ .binding = 1 } },
+        .{ .durations = .{ .binding = 1 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.binding(
+        .{ .durations = .{ .binding = 0 } },
+        .{ .durations = .{ .binding = 2 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.binding(
+        .{ .durations = .{ .binding = 0 } },
+        .{ .durations = .{ .binding = 2 } },
+        .true,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 4 }, Rolls.binding(
+        .{ .durations = .{ .binding = 4 } },
+        .{ .durations = .{ .binding = 3 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.binding(
+        .{ .durations = .{ .binding = 0 } },
+        .{ .durations = .{ .binding = 4 } },
+        .false,
+    ));
 }
 
 test "Rolls.moveSlot" {

package/src/lib/gen1/mechanics.zig

@@ -1332,7 +1332,7 @@ fn mirrorMove(
     auto: bool,
     residual: *bool,
     options: anytype,
-) !?Result {
+) anyerror!?Result {
     var side = battle.side(player);
     const foe = battle.foe(player);
 
@@ -1359,7 +1359,7 @@ fn metronome(
     auto: bool,
     residual: *bool,
     options: anytype,
-) !?Result {
+) anyerror!?Result {
     var side = battle.side(player);
 
     side.last_selected_move = try Rolls.metronome(battle, player, options);
@@ -2680,7 +2680,7 @@ fn statusModify(status: u8, stats: *Stats(u16)) void {
     }
 }
 
-inline fn isForced(active: ActivePokemon) bool {
+inline fn isForced(active: anytype) bool {
     return active.volatiles.Recharging or active.volatiles.Rage or
         active.volatiles.Thrashing or active.volatiles.Charging;
 }
@@ -3072,7 +3072,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             const side = battle.side(player);
             const foe = battle.foe(player);
 
-            var active = side.active;
+            var active = &side.active;
             const stored = side.stored();
 
             // While players are not given any input options on the cartridge in these cases,