@pkmn/engine 0.1.0-dev.6ef582f1 → 0.1.0-dev.736f7a8b

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
@@ -49,9 +57,9 @@ $ 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
-breaking language changes are introduced:
+walk through how to install Zig on each platform - the engine code should work on Zig v0.11.0 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
 `libpkmn-showdown` library. Furthermore, protocol message logging can be enabled through `-Dlog`.

package/build.zig

@@ -66,16 +66,16 @@ pub fn build(b: *std.Build) !void {
         const addon = b.fmt("{s}.node", .{name});
         const lib = b.addSharedLibrary(.{
             .name = addon,
+            .main_pkg_path = .{ .path = "." },
             .root_source_file = .{ .path = "src/lib/binding/node.zig" },
             .optimize = optimize,
             .target = target,
         });
         lib.addOptions("build_options", options);
-        lib.setMainPkgPath("./");
-        lib.addSystemIncludePath(headers);
+        lib.addSystemIncludePath(.{ .path = headers });
         lib.linkLibC();
         if (node_import_lib) |il| {
-            lib.addObjectFile(il);
+            lib.addObjectFile(.{ .path = il });
         } else if ((try std.zig.system.NativeTargetInfo.detect(target)).target.os.tag == .windows) {
             try std.io.getStdErr().writeAll("Must provide --node-import-library path on Windows\n");
             std.process.exit(1);
@@ -95,6 +95,7 @@ pub fn build(b: *std.Build) !void {
     } else if (wasm) {
         const lib = b.addSharedLibrary(.{
             .name = name,
+            .main_pkg_path = .{ .path = "." },
             .root_source_file = .{ .path = "src/lib/binding/wasm.zig" },
             .optimize = switch (optimize) {
                 .ReleaseFast, .ReleaseSafe => .ReleaseSmall,
@@ -103,7 +104,6 @@ pub fn build(b: *std.Build) !void {
             .target = .{ .cpu_arch = .wasm32, .os_tag = .freestanding },
         });
         lib.addOptions("build_options", options);
-        lib.setMainPkgPath("./");
         lib.stack_size = wasm_stack_size;
         lib.rdynamic = true;
         lib.strip = strip;
@@ -121,14 +121,14 @@ pub fn build(b: *std.Build) !void {
     } else if (dynamic) {
         const lib = b.addSharedLibrary(.{
             .name = name,
+            .main_pkg_path = .{ .path = "." },
             .root_source_file = .{ .path = "src/lib/binding/c.zig" },
             .version = try std.SemanticVersion.parse(version),
             .optimize = optimize,
             .target = target,
         });
         lib.addOptions("build_options", options);
-        lib.setMainPkgPath("./");
-        lib.addIncludePath("src/include");
+        lib.addIncludePath(.{ .path = "src/include" });
         maybeStrip(b, lib, b.getInstallStep(), strip, cmd);
         if (pic) lib.force_pic = pic;
         b.installArtifact(lib);
@@ -136,18 +136,30 @@ pub fn build(b: *std.Build) !void {
     } else {
         const lib = b.addStaticLibrary(.{
             .name = name,
+            .main_pkg_path = .{ .path = "." },
             .root_source_file = .{ .path = "src/lib/binding/c.zig" },
             .optimize = optimize,
             .target = target,
         });
         lib.addOptions("build_options", options);
-        lib.setMainPkgPath("./");
-        lib.addIncludePath("src/include");
+        lib.addIncludePath(.{ .path = "src/include" });
         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_ll) lib.emit_llvm_ir = .emit;
+        if (emit_asm) {
+            b.getInstallStep().dependOn(&b.addInstallFileWithDir(
+                lib.getEmittedAsm(),
+                .prefix,
+                b.fmt("{s}.s", .{name}),
+            ).step);
+        }
+        if (emit_ll) {
+            b.getInstallStep().dependOn(&b.addInstallFileWithDir(
+                lib.getEmittedLlvmIr(),
+                .prefix,
+                b.fmt("{s}.ll", .{name}),
+            ).step);
+        }
         b.installArtifact(lib);
         c = true;
     }
@@ -219,12 +231,16 @@ pub fn build(b: *std.Build) !void {
     fuzz_config.tool.name = "fuzz";
     const fuzz = tool(b, "src/test/fuzz.zig", fuzz_config);
 
-    const copies = tool(b, "src/tools/copies.zig", tools);
+    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);
 
-    b.step("copies", "Run copy detector").dependOn(&copies.step);
+    // FIXME: serde randomly fails to build in some release configurations
+    var hack = tools;
+    if (optimize != .Debug) hack.tool.tests = null;
+    const serde = tool(b, "src/tools/serde.zig", hack);
+
+    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);
@@ -281,12 +297,12 @@ const TestStep = struct {
                 std.fs.path.basename(std.fs.path.dirname(path).?),
                 std.fs.path.stem(std.fs.path.basename(path)),
             }),
+            .main_pkg_path = .{ .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);
@@ -343,7 +359,7 @@ const ToolsStep = struct {
         const self = b.allocator.create(ToolsStep) catch @panic("OOM");
         const step = std.Build.Step.init(.{ .id = .custom, .name = "Install tools", .owner = b });
         self.* = ToolsStep{ .step = step };
-        for (exes.items) |t| self.step.dependOn(&b.addInstallArtifact(t).step);
+        for (exes.items) |t| self.step.dependOn(&b.addInstallArtifact(t, .{}).step);
         return self;
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.6ef582f1",
+  "version": "0.1.0-dev.736f7a8b",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
@@ -73,30 +73,30 @@
     "access": "public"
   },
   "dependencies": {
-    "@pkmn/data": "^0.7.46",
-    "@pkmn/protocol": "^0.6.12"
+    "@pkmn/data": "^0.7.50",
+    "@pkmn/protocol": "^0.6.13"
   },
   "devDependencies": {
-    "@pkmn/eslint-config": "^5.0.0",
-    "@pkmn/img": "^0.2.13",
+    "@pkmn/eslint-config": "^5.2.0",
+    "@pkmn/img": "^0.2.15",
     "@pkmn/sets": "^5.0.4",
-    "@pkmn/sim": "0.7.46",
+    "@pkmn/sim": "0.7.50",
     "@types/html-minifier": "^4.0.2",
-    "@types/jest": "^29.5.3",
+    "@types/jest": "^29.5.4",
     "@types/minimist": "^1.2.2",
     "@types/mustache": "^4.2.2",
-    "@types/node": "^20.4.2",
+    "@types/node": "^20.5.9",
     "@vitest/coverage-c8": "^0.33.0",
     "binaryen": "^114.0.0",
-    "eslint": "^8.44.0",
+    "eslint": "^8.48.0",
     "html-minifier": "^4.0.0",
     "json-stringify-pretty-compact": "3.0.0",
     "minimist": "^1.2.8",
     "mustache": "^4.2.0",
     "source-map-support": "^0.5.21",
     "trakr": "^0.2.0",
-    "typescript": "^5.1.6",
-    "vitest": "^0.33.0"
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.4"
   },
   "scripts": {
     "lint": "eslint --cache src --ext ts,js && eslint src/bin/*",

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};
 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/common/protocol.zig

@@ -136,6 +136,8 @@ pub const Damage = enum(u8) {
     Confusion,
     LeechSeed,
     RecoilOf,
+
+    Spikes,
 };
 
 pub const Status = enum(u8) {
@@ -264,7 +266,15 @@ pub fn Log(comptime Writer: type) type {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Switch), @as(u8, @bitCast(ident)) });
-            try self.writer.writeAll(&.{ @intFromEnum(pokemon.species), pokemon.level });
+            if (@hasField(@TypeOf(pokemon.*), "dvs")) {
+                try self.writer.writeAll(&.{
+                    @intFromEnum(pokemon.species),
+                    @intFromEnum(pokemon.dvs.gender),
+                    pokemon.level,
+                });
+            } else {
+                try self.writer.writeAll(&.{ @intFromEnum(pokemon.species), pokemon.level });
+            }
             try self.writer.writeIntNative(u16, pokemon.hp);
             try self.writer.writeIntNative(u16, pokemon.stats.hp);
             try self.writer.writeAll(&.{pokemon.status});
@@ -646,9 +656,13 @@ pub const ByteStream = struct {
 };
 
 pub const Kind = enum { Move, Species, Type, Status };
-pub const Formatter = fn (Kind, u8) []const u8;
 
-pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, color: bool) void {
+pub fn format(
+    comptime gen: anytype,
+    a: []const u8,
+    b: ?[]const u8,
+    color: bool,
+) void {
     print("\n", .{});
 
     var i: usize = 0;
@@ -701,17 +715,27 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .Move => {
                 const source = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(source.player), source.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
                 const target = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(target.player), target.id }, a, b, &i, 1, color);
                 const reason: Move = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
-                if (reason == .From) printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                if (reason == .From) {
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
+                }
             },
             .Switch => {
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Species, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Species, a[i])}, a, b, &i, 1, color);
+                if (@hasDecl(gen, "Gender")) {
+                    if (a[i] == N(gen.Gender.Unknown)) {
+                        i += 1;
+                    } else {
+                        var gender = if (a[i] == N(gen.Gender.Male)) "M" else "F";
+                        printc(", {s}", .{gender}, a, b, &i, 1, color);
+                    }
+                }
                 printc(" L{d}", .{a[i]}, a, b, &i, 1, color);
                 switch (endian) {
                     .Big => {
@@ -727,7 +751,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
                 }
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
             },
             .Cant => {
                 const id = ID.from(@intCast(a[i]));
@@ -735,7 +759,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                 const reason: Cant = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
                 if (reason == .Disable) {
-                    printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
                 }
             },
             .Faint,
@@ -775,7 +799,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
                 }
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
                 if (arg == .Damage) {
                     const reason: Damage = @enumFromInt(a[i]);
                     printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
@@ -795,15 +819,17 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .Status => {
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
                 const reason: Status = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
-                if (reason == .From) printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                if (reason == .From) {
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
+                }
             },
             .CureStatus => {
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
                 const reason: CureStatus = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
             },
@@ -826,7 +852,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .Prepare => {
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
             },
             .Activate => {
                 const id = ID.from(@intCast(a[i]));
@@ -841,12 +867,12 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                 if (@as(Start, @enumFromInt(reason)) == .TypeChange) {
                     const types = @as(gen1.Types, @bitCast(a[i]));
                     const args = .{
-                        formatter(.Type, @intFromEnum(types.type1)),
-                        formatter(.Type, @intFromEnum(types.type2)),
+                        formatter(gen, .Type, @intFromEnum(types.type1)),
+                        formatter(gen, .Type, @intFromEnum(types.type2)),
                     };
                     printc(" {s}/{s}", args, a, b, &i, 1, color);
                 } else if (reason >= @intFromEnum(Start.Disable)) {
-                    printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
                 }
             },
             .End => {
@@ -896,7 +922,7 @@ fn printc(
 }
 
 pub fn expectLog(
-    comptime formatter: Formatter,
+    comptime gen: anytype,
     expected: []const u8,
     actual: []const u8,
     offset: usize,
@@ -915,8 +941,8 @@ pub fn expectLog(
 
     expectEqualBytes(expected, actual, offset) catch |err| switch (err) {
         error.TestExpectedEqual => {
-            format(formatter, expected, null, color);
-            format(formatter, actual, expected, color);
+            format(gen, expected, null, color);
+            format(gen, actual, expected, color);
             return err;
         },
         else => return err,
@@ -956,6 +982,11 @@ const gen1 = struct {
     pub const helpers = @import("../gen1/helpers.zig");
 };
 
+const gen2 = struct {
+    pub usingnamespace @import("../gen2/data.zig");
+    pub const helpers = @import("../gen2/helpers.zig");
+};
+
 var buf: [gen1.LOGS_SIZE]u8 = undefined;
 var stream = ByteStream{ .buffer = &buf };
 var log: FixedLog = .{ .writer = stream.writer() };
@@ -964,15 +995,19 @@ const M = gen1.Move;
 const S = gen1.Species;
 
 fn expectLog1(expected: []const u8, actual: []const u8) !void {
-    return expectLog(gen1Formatter, expected, actual, 0);
+    return expectLog(gen1, expected, actual, 0);
 }
 
-fn gen1Formatter(kind: Kind, byte: u8) []const u8 {
+fn expectLog2(expected: []const u8, actual: []const u8) !void {
+    return expectLog(gen2, expected, actual, 0);
+}
+
+fn formatter(comptime gen: anytype, kind: Kind, byte: u8) []const u8 {
     return switch (kind) {
-        .Move => @tagName(@as(M, @enumFromInt(byte))),
-        .Species => @tagName(@as(S, @enumFromInt(byte))),
-        .Type => @tagName(@as(gen1.Type, @enumFromInt(byte))),
-        .Status => gen1.Status.name(byte),
+        .Move => @tagName(@as(gen.Move, @enumFromInt(byte))),
+        .Species => @tagName(@as(gen.Species, @enumFromInt(byte))),
+        .Type => @tagName(@as(gen.Type, @enumFromInt(byte))),
+        .Status => gen.Status.name(byte),
     };
 }
 
@@ -1057,6 +1092,25 @@ test "|switch|" {
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
+
+    var blissey = gen2.helpers.Pokemon.init(.{ .species = .Blissey, .moves = &.{.Splash} });
+    blissey.level = 91;
+    blissey.hp = 200;
+    blissey.stats.hp = 400;
+    blissey.status = gen2.Status.init(.PAR);
+    try log.switched(p2.ident(3), &blissey);
+    expected = &(.{
+        N(ArgType.Switch),
+        0b1011,
+        N(gen2.Species.Blissey),
+        N(gen2.Gender.Female),
+        91,
+    } ++ switch (endian) {
+        .Big => .{ 0, 200, 1, 144, par },
+        .Little => .{ 200, 0, 144, 1, par },
+    });
+    try expectLog2(expected, buf[0..10]);
+    stream.reset();
 }
 
 test "|cant|" {

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/calc.zig

@@ -29,7 +29,6 @@ const Optional = optional.Optional;
 const Rational = rational.Rational;
 
 const PointerType = util.PointerType;
-const FieldType = util.FieldType;
 
 const Actions = chance.Actions;
 const Action = chance.Action;

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;
                     }