@pkmn/engine 0.1.0-dev.abd68573 → 0.1.0-dev.ac9225d5

package/README.md

@@ -88,7 +88,9 @@ directly or build the addons manually and place the artifacts in the expected pa
 ### `pkmn`
 
 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):
+[`build.zig.zon`](https://github.com/ziglang/zig/blob/master/doc/build.zig.zon.md) using [Zig's
+Package Management
+system](https://ziglang.org/download/0.11.0/release-notes.html#Package-Management):
 
 
 ```zig
@@ -117,18 +119,18 @@ your `build.zig.zon` you will be able to import the `pkmn` package's build helpe
 
 ```zig
 const std = @import("std");
-const pkmn = @import("pkmn");
 
 pub fn build(b: *std.Build) void {
     ...
-    exe.addModule("pkmn", pkmn.module(b, .{ .showdown = true, .log = true }));
+    const pkmn = b.dependency("pkmn", .{ .showdown = true, .log = true });
+    exe.root_module.addImport("pkmn", pkmn.module("pkmn"));
     ...
 }
 ```
 
-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
+The `pkmn` package can be configured with various options such as 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 aren't officially supported, affect correctness, and may change meaning or behavior without

package/build.zig

@@ -1,26 +1,6 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
-pub const Options = struct {
-    showdown: ?bool = null,
-    log: ?bool = null,
-    chance: ?bool = null,
-    calc: ?bool = null,
-};
-
-pub fn module(b: *std.Build, options: Options) *std.Build.Module {
-    const dirname = comptime std.fs.path.dirname(@src().file) orelse ".";
-    const build_options = b.addOptions();
-    build_options.addOption(?bool, "showdown", options.showdown);
-    build_options.addOption(?bool, "log", options.log);
-    build_options.addOption(?bool, "chance", options.chance);
-    build_options.addOption(?bool, "calc", options.calc);
-    return b.createModule(.{
-        .root_source_file = .{ .cwd_relative = dirname ++ "/src/lib/pkmn.zig" },
-        .imports = &.{.{ .name = "build_options", .module = build_options.createModule() }},
-    });
-}
-
 pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
@@ -61,6 +41,13 @@ pub fn build(b: *std.Build) !void {
 
     const name = if (showdown) "pkmn-showdown" else "pkmn";
 
+    const module = b.addModule("pkmn", .{
+        .root_source_file = b.path("src/lib/pkmn.zig"),
+        .optimize = optimize,
+        .target = target,
+        .imports = &.{.{ .name = "build_options", .module = options.createModule() }},
+    });
+
     var c = false;
     if (node_headers) |headers| {
         const addon = b.fmt("{s}.node", .{name});
@@ -222,12 +209,8 @@ pub fn build(b: *std.Build) !void {
 
     var exes = std.ArrayList(*std.Build.Step.Compile).init(b.allocator);
     const tools: ToolConfig = .{
-        .options = .{
-            .showdown = showdown,
-            .log = log,
-            .chance = chance,
-            .calc = calc,
-        },
+        .showdown = showdown,
+        .module = module,
         .general = config,
         .tool = .{
             .tests = if (tests.build) tests else null,
@@ -326,7 +309,8 @@ const TestStep = struct {
 };
 
 const ToolConfig = struct {
-    options: Options,
+    showdown: ?bool,
+    module: *std.Build.Module,
     general: Config,
     tool: struct {
         tests: ?*TestStep,
@@ -343,7 +327,7 @@ fn tool(b: *std.Build, path: []const u8, config: ToolConfig) !?*std.Build.Step.R
     var name = config.tool.name orelse std.fs.path.basename(path);
     const index = std.mem.lastIndexOfScalar(u8, name, '.');
     if (index) |i| name = name[0..i];
-    if (config.options.showdown orelse false) name = b.fmt("{s}-showdown", .{name});
+    if (config.showdown orelse false) name = b.fmt("{s}-showdown", .{name});
 
     const exe = b.addExecutable(.{
         .name = name,
@@ -354,7 +338,7 @@ fn tool(b: *std.Build, path: []const u8, config: ToolConfig) !?*std.Build.Step.R
         .strip = config.general.strip,
         .pic = config.general.pic,
     });
-    exe.root_module.addImport("pkmn", module(b, config.options));
+    exe.root_module.addImport("pkmn", config.module);
 
     if (config.tool.tests) |ts| ts.step.dependOn(&exe.step);
     config.tool.exes.append(exe) catch @panic("OOM");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.abd68573",
+  "version": "0.1.0-dev.ac9225d5",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
@@ -75,20 +75,20 @@
     "access": "public"
   },
   "dependencies": {
-    "@pkmn/data": "^0.9.9",
+    "@pkmn/data": "^0.9.11",
     "@pkmn/protocol": "^0.6.25"
   },
   "devDependencies": {
-    "@pkmn/eslint-config": "^7.5.0",
-    "@pkmn/img": "^0.2.30",
+    "@pkmn/eslint-config": "^8.1.0",
+    "@pkmn/img": "^0.2.31",
     "@pkmn/sets": "^5.1.2",
-    "@pkmn/sim": "0.9.9",
+    "@pkmn/sim": "0.9.11",
     "@types/html-minifier": "^4.0.5",
     "@types/jest": "^29.5.12",
     "@types/minimist": "^1.2.5",
     "@types/mustache": "^4.2.5",
-    "@types/node": "^20.14.10",
-    "@vitest/coverage-v8": "^2.0.2",
+    "@types/node": "^22.0.2",
+    "@vitest/coverage-v8": "^2.0.5",
     "binaryen": "^118.0.0",
     "eslint": "<=8",
     "html-minifier": "^4.0.0",
@@ -98,8 +98,8 @@
     "source-map-support": "^0.5.21",
     "table": "^6.8.2",
     "trakr": "^0.2.0",
-    "typescript": "^5.5.3",
-    "vitest": "^2.0.2"
+    "typescript": "^5.5.4",
+    "vitest": "^2.0.5"
   },
   "scripts": {
     "lint": "eslint --cache src --ext ts,js && eslint src/bin/*",

package/src/lib/common/debug.zig

@@ -4,8 +4,8 @@ const debug = std.debug;
 const io = std.io;
 
 pub fn print(value: anytype) void {
-    debug.getStderrMutex().lock();
-    defer debug.getStderrMutex().unlock();
+    debug.lockStdErr();
+    defer debug.unlockStdErr();
     const stderr = io.getStdErr().writer();
 
     nosuspend {

package/src/lib/common/options.zig

@@ -10,6 +10,7 @@ pub const Options = struct {
     advance: ?bool = null,
     ebc: ?bool = null,
     key: ?bool = null,
+    miss: ?bool = null,
     internal: ?bool = null,
 };
 
@@ -25,6 +26,7 @@ pub const calc = get("calc", false);
 pub const advance = get("advance", true);
 pub const ebc = get("ebc", true);
 pub const key = get("key", false);
+pub const miss = get("miss", true);
 pub const internal = get("internal", false);
 
 fn get(comptime name: []const u8, default: bool) bool {

package/src/lib/common/rational.zig

@@ -43,8 +43,7 @@ pub fn Rational(comptime T: type) type {
         /// Update the rational by multiplying its numerator by p and its denominator by q.
         /// Both p and q must be >= 1, and if computable at comptime must have no common factors.
         pub fn update(r: *Self, p: anytype, q: anytype) Error!void {
-            // FIXME
-            // std.debug.print("({d}/{d}) * ", .{ p, q });
+            // std.debug.print("({d}/{d}) * ", .{ p, q }); // DEBUG
             assert(p >= 1);
             assert(q >= 1);
 
@@ -202,23 +201,81 @@ pub fn Rational(comptime T: type) type {
     };
 }
 
-// https://en.wikipedia.org/wiki/Euclidean_algorithm
+// https://lemire.me/blog/greatest-common-divisor-the-extended-euclidean-algorithm-and-speed/
 fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
     assert(p >= 1);
     assert(q >= 1);
 
-    var a = p;
-    var b = q;
-    var c: @TypeOf(p, q) = undefined;
+    const T = @TypeOf(p, q);
+    switch (@typeInfo(T)) {
+        .Int => {
+            var u: T = undefined;
+            var v: T = undefined;
+            if (p < q) {
+                u = q;
+                v = p;
+            } else {
+                u = p;
+                v = q;
+            }
+            assert(v <= u);
+            u %= v;
+            if (u == 0) return v;
+
+            const zu = @ctz(u);
+            const zv = @ctz(v);
+            const shift = @min(zu, zv);
+            u >>= @intCast(zu);
+            v >>= @intCast(zv);
+
+            while (true) {
+                const diff = u -% v;
+                if (u > v) {
+                    u = v;
+                    v = diff;
+                } else {
+                    v -= u;
+                }
+                if (diff != 0) v >>= @intCast(@ctz(diff));
+                if (v == 0) break;
+            }
+
+            const result = u << @intCast(shift);
+            assert(result > 0);
+            return result;
+        },
+        else => {
+            var a = p;
+            var b = q;
+            var c: T = undefined;
+
+            while (b != 0) {
+                c = b;
+                b = @mod(a, b);
+                a = c;
+            }
 
-    while (b != 0) {
-        c = b;
-        b = @mod(a, b);
-        a = c;
+            assert(a > 0);
+            return a;
+        },
     }
+}
+
+test gcd {
+    const seed = if (@hasDecl(std.testing, "random_seed")) std.testing.random_seed else 0x12345678;
+    var prng = std.Random.DefaultPrng.init(seed);
+    var random = prng.random();
 
-    assert(a > 0);
-    return a;
+    for (0..1000) |_| {
+        const a = random.int(u32);
+        const b = random.int(u32);
+        if (a == 0 or b == 0) continue;
+
+        try expectEqual(
+            gcd(a, b),
+            @as(u32, @intFromFloat(gcd(@as(f64, @floatFromInt(a)), @as(f64, @floatFromInt(b))))),
+        );
+    }
 }
 
 fn doTurn(r: anytype) !void {

package/src/lib/gen1/calc.zig

@@ -38,6 +38,9 @@ const Duration = chance.Duration;
 
 const Rolls = helpers.Rolls;
 
+const tty = true; // DEBUG
+const summary = false; // DEBUG
+
 /// Information relevant to damage calculation that occured during a Generation I battle `update`.
 pub const Summaries = extern struct {
     /// Relevant information for Player 1.
@@ -69,8 +72,10 @@ pub const Summary = extern struct {
         /// The final computed damage that gets applied to the Pokémon. May exceed the target's HP
         // (to determine the *actual* damage done compare the target's stored HP before and after).
         final: u16 = 0,
-        /// Whether higher damage will saturate / result in the same outcome (e.g. additional damage
-        /// gets ignored due to it already breaking a Substitute or causing the target to faint).
+        /// Whether higher direct damage will saturate / result in the same outcome (e.g. additional
+        /// direct damage gets ignored due to it already breaking a Substitute or causing the target
+        /// to faint). Note that this field does not get set in scenarios where the target would
+        /// only be guaranteed to faint due to some sort of subsequent recoil or residual damage.
         capped: bool = false,
 
         // NOTE: 15 bits padding
@@ -201,6 +206,8 @@ pub const Options = struct {
     metronome: bool = false,
 };
 
+pub const MAX_FRONTIER = 19;
+
 pub fn transitions(
     battle: anytype,
     c1: Choice,
@@ -253,7 +260,13 @@ pub fn transitions(
             .p2 = template.p2.durations,
         };
 
-        try debug(writer, template, true, .{ .color = i, .bold = true, .background = true });
+        try debug(writer, template, .{
+            .shape = true,
+            .color = i,
+            .bold = true,
+            .background = true,
+            .indent = false,
+        });
 
         var a: Actions = .{ .p1 = .{ .metronome = p1_move }, .p2 = .{ .metronome = p2_move } };
 
@@ -281,7 +294,7 @@ pub fn transitions(
         for (Rolls.moveSlot(template.p1, p1_hit)) |p1_slot| { a.p1.move_slot = p1_slot;
         for (Rolls.moveSlot(template.p2, p2_hit)) |p2_slot| { a.p2.move_slot = p2_slot;
         for (Rolls.multiHit(template.p1, p1_hit)) |p1_multi| { a.p1.multi_hit = p1_multi;
-        for (Rolls.multiHit(template.p2, p1_hit)) |p2_multi| { a.p2.multi_hit = p2_multi;
+        for (Rolls.multiHit(template.p2, p2_hit)) |p2_multi| { a.p2.multi_hit = p2_multi;
         for (Rolls.secondaryChance(template.p1, p1_hit)) |p1_sec| { a.p1.secondary_chance = p1_sec;
         for (Rolls.secondaryChance(template.p2, p2_hit)) |p2_sec| { a.p2.secondary_chance = p2_sec;
         for (Rolls.criticalHit(template.p1, p1_hit)) |p1_crit| { a.p1.critical_hit = p1_crit;
@@ -290,13 +303,17 @@ pub fn transitions(
         var p1_dmg = Rolls.damage(template.p1, p1_hit);
         while (p1_dmg.min < p1_dmg.max) : (p1_dmg.min += 1) {
             a.p1.damage = @intCast(p1_dmg.min);
-            var p1_min: u8 = 0;
 
             var p2_dmg = Rolls.damage(template.p2, p2_hit);
+
+            const p1_min: u9 = p1_dmg.min;
+            const p2_min: u9 = p2_dmg.min;
+
             while (p2_dmg.min < p2_dmg.max) : (p2_dmg.min += 1) {
                 a.p2.damage = @intCast(p2_dmg.min);
 
                 opts.calc.overrides.actions = a;
+                opts.calc.summaries = .{};
                 opts.chance = .{ .probability = .{}, .actions = actions };
                 const q = &opts.chance.probability;
 
@@ -304,28 +321,40 @@ pub fn transitions(
                 _ = try b.update(c1, c2, &opts);
                 stats.updates += 1;
 
-                const p1_max: u8 = @intCast(p1_dmg.min);
-                const p2_max: u8 = @intCast(p2_dmg.min);
-                _ = cap;
-
-                // var p1_max = if (p1_min != 0) p1_min else
-                //     try Rolls.coalesce(.P1, @intCast(u8, p1_dmg.min), &opts.calc.summaries, cap);
-                // var p2_max =
-                //     try Rolls.coalesce(.P2, @intCast(u8, p2_dmg.min), &opts.calc.summaries, cap);
+                const summaries = &opts.calc.summaries;
+                const p1_max: u9 = if (p2_dmg.min != p2_min)
+                    p1_dmg.min
+                else
+                    try Rolls.coalesce(.P1, @as(u8, @intCast(p1_dmg.min)), summaries, cap);
+                const p2_max: u9 =
+                    try Rolls.coalesce(.P2, @as(u8, @intCast(p2_dmg.min)), summaries, cap);
 
                 if (opts.chance.actions.matches(template)) {
                     if (!opts.chance.actions.eql(a)) {
-                        try debug(writer, opts.chance.actions, false, .{ .color = i, .dim = true });
+                        if (!summary) {
+                            try debug(writer, opts.chance.actions, .{
+                                .p1_max = p1_max,
+                                .p2_max = p2_max,
+                                .color = i,
+                                .dim = true,
+                            });
+                        }
 
-                        p1_min = p1_max;
+                        p1_dmg.min = p1_max;
                         p2_dmg.min = p2_max;
                         continue;
                     }
 
-                    try debug(writer, opts.chance.actions, false, .{ .color = i });
+                    if (!summary) {
+                        try debug(writer, opts.chance.actions, .{
+                            .p1_max = p1_max,
+                            .p2_max = p2_max,
+                            .color = i,
+                        });
+                    }
 
-                    for (p1_dmg.min..@as(u9, p1_max) + 1) |p1d| {
-                        for (p2_dmg.min..@as(u9, p2_max) + 1) |p2d| {
+                    for (p1_min..p1_max + 1) |p1d| {
+                        for (p2_dmg.min..p2_max + 1) |p2d| {
                             var acts = opts.chance.actions;
                             acts.p1.damage = @intCast(p1d);
                             acts.p2.damage = @intCast(p2d);
@@ -336,7 +365,7 @@ pub fn transitions(
                         }
                     }
 
-                    if (p1_max != p1_dmg.min) try q.update(p1_max - p1_dmg.min + 1, 1);
+                    if (p1_max != p1_min) try q.update(p1_max - p1_min + 1, 1);
                     if (p2_max != p2_dmg.min) try q.update(p2_max - p2_dmg.min + 1, 1);
                     try p.add(q);
                     stats.saved += 1;
@@ -346,27 +375,46 @@ pub fn transitions(
                         return error.TestUnexpectedResult;
                     }
                 } else {
-                    try debug(writer, opts.chance.actions, false, .{ .dim = true });
-
                     if (!matches(opts.chance.actions, i, frontier.items)) {
                         try frontier.append(opts.chance.actions);
 
-                        try debug(writer, opts.chance.actions, true, .{
+                        try debug(writer, opts.chance.actions, .{
+                            .p1_max = p1_max,
+                            .p2_max = p2_max,
+                            .dim = true,
+                            .newline = false,
+                        });
+                        try writer.writeAll(" → ");
+                        try debug(writer, opts.chance.actions, .{
+                            .shape = true,
                             .color = frontier.items.len - 1,
                             .dim = true,
-                            .background = true
+                            .background = true,
+                            .indent = false,
+                        });
+                    } else if (!summary) {
+                        try debug(writer, opts.chance.actions, .{
+                            .p1_max = p1_max,
+                            .p2_max = p2_max,
+                            .dim = true,
                         });
                     }
                 }
 
-                p1_min = p1_max;
+                p1_dmg.min = p1_max;
                 p2_dmg.min = p2_max;
             }
 
-            assert(p1_min > 0 or p1_dmg.min == 0);
-            p1_dmg.min = p1_min;
-
         }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
+
+        if (@TypeOf(writer) != @TypeOf(std.io.null_writer)) {
+            p.reduce();
+            try writer.print(
+                "  = {s} ({d:.2}%)\n\n",
+                .{p, 100 * @as(f128, @floatFromInt(p.p)) / @as(f128, @floatFromInt(p.q))},
+            );
+        }
+
     }
 
     assert(frontier.items.len == i);
@@ -387,6 +435,85 @@ pub fn transitions(
     return stats;
 }
 
+pub fn update(
+    battle: anytype,
+    c1: Choice,
+    c2: Choice,
+    options: anytype,
+    allocator: std.mem.Allocator,
+    writer: anytype,
+    transition: bool,
+) !Result {
+    options.chance.reset();
+
+    if (!pkmn.options.chance or !pkmn.options.calc or @TypeOf(battle.rng) != data.PRNG) {
+        return battle.update(c1, c2, options);
+    }
+
+    var copy = battle.*;
+    const actions = options.chance.actions;
+
+    // Perfom the actual update
+    const result = battle.update(c1, c2, options);
+
+    // Ensure we can encode the diffs in less than MAX_DIFFS bytes.
+    var buf: [helpers.MAX_DIFFS]u8 = undefined;
+    var stream: protocol.ByteStream = .{ .buffer = &buf };
+    const n = try helpers.diff(&copy, battle, stream.writer());
+
+    // Applying the diff to the battle should take us back to the original copy
+    // of the battle (ignoring the RNG).
+    var patched = battle.*;
+    patched.rng = copy.rng;
+    helpers.patch(&patched, buf[0..n]);
+    try expectEqual(copy, patched);
+
+    if (!pkmn.options.chance or !pkmn.options.calc) return result;
+
+    if (transition) {
+        // Ensure we can generate all transitions from the same original state
+        // (we must change the battle's RNG from a FixedRNG to a PRNG because
+        // the transitions function relies on RNG for discovery of states)
+        if (try transitions(unfix(copy), c1, c2, allocator, writer, .{
+            .actions = actions,
+            .cap = true,
+        })) |stats| try expect(stats.frontier <= MAX_FRONTIER);
+    }
+
+    // Demonstrate that we can produce the same state by forcing the RNG to behave the
+    // same as we observed - note that because we do not pass in a durations override
+    // mask none of the durations will be extended.
+    var override = pkmn.battle.options(
+        protocol.NULL,
+        chance.NULL,
+        Calc{ .overrides = .{ .actions = actions } },
+    );
+    const overridden = copy.update(c1, c2, &override);
+    try expectEqual(result, overridden);
+
+    // The actual battle excluding its RNG field should match a copy updated with
+    // overridden RNG (the copy RNG may have advanced because of no-ops)
+    copy.rng = battle.rng;
+    try expectEqual(copy, battle.*);
+
+    return result;
+}
+
+fn unfix(actual: anytype) data.Battle(data.PRNG) {
+    return .{
+        .sides = actual.sides,
+        .turn = actual.turn,
+        .last_damage = actual.last_damage,
+        .last_moves = actual.last_moves,
+        .rng = .{ .src = .{
+            .seed = if (pkmn.options.showdown)
+                0x12345678
+            else
+                .{ 123, 234, 56, 78, 9, 101, 112, 131, 4 },
+        } },
+    };
+}
+
 fn matches(actions: Actions, i: usize, frontier: []Actions) bool {
     for (frontier, 0..) |f, j| {
         // TODO: is skipping this redundant check worth it?
@@ -404,23 +531,66 @@ fn err(comptime fmt: []const u8, v: anytype, seed: ?u64) void {
 }
 
 const Style = struct {
+    shape: bool = false,
+    p1_max: u9 = 0,
+    p2_max: u9 = 0,
     color: ?usize = null,
     bold: bool = false,
     background: bool = false,
     dim: bool = false,
+    newline: bool = true,
+    indent: bool = true,
 };
 
-fn debug(writer: anytype, actions: Actions, shape: bool, style: Style) !void {
-    _ = .{ writer, actions, shape, style };
-    // const mod: usize = if (style.dim) 2 else 1;
-    // const background: usize = if (style.background) 4 else 3;
-    // const color: usize = if (style.color) |c| (c % 6) + 1 else 7;
-    // if (style.dim or style.bold) try writer.print("\x1b[{d}m", .{mod});
-    // try writer.print("\x1b[{d}{d}m", .{ background, color });
-    // try actions.fmt(writer, shape);
-    // try writer.writeAll("\x1b[0m\n");
-    // DEBUG
-    // if (style.dim) try writer.writeAll("    ");
-    // try actions.fmt(writer, shape);
-    // try writer.writeByte('\n');
+fn debug(writer: anytype, actions: Actions, style: Style) !void {
+    if (style.indent) try writer.writeAll("  ");
+    if (tty) {
+        const mod: usize = if (style.dim) 2 else 1;
+        const background: usize = if (style.background) 4 else 3;
+        const color: usize = if (style.color) |c| (c % 6) + 1 else 7;
+
+        if (style.dim or style.bold) try writer.print("\x1b[{d}m", .{mod});
+        try writer.print("\x1b[{d}{d}m", .{ background, color });
+        const p1 = if (style.p1_max != 0 and style.p1_max != actions.p1.damage) style.p1_max else 0;
+        const p2 = if (style.p2_max != 0 and style.p2_max != actions.p2.damage) style.p2_max else 0;
+        if (p1 != 0 or p2 != 0) {
+            assert(!style.shape);
+            try format(writer, actions, p1, p2);
+        } else {
+            try actions.fmt(writer, style.shape);
+        }
+        try writer.writeAll("\x1b[0m");
+    } else {
+        if (style.dim) try writer.writeAll("  ");
+        try actions.fmt(writer, style.shape);
+    }
+    if (style.newline) try writer.writeByte('\n');
+}
+
+fn format(writer: anytype, actions: Actions, p1: u9, p2: u9) !void {
+    var input: [1024]u8 = undefined;
+    var output: [1024]u8 = undefined;
+
+    var stream = std.io.fixedBufferStream(&input);
+    try actions.fmt(&stream.writer(), false);
+    var len = stream.getWritten().len;
+    @memcpy(output[0..len], input[0..len]);
+
+    var find: [16]u8 = undefined;
+    var repl: [22]u8 = undefined;
+    if (p1 != 0 and actions.p1.damage != 0) {
+        const n = try std.fmt.bufPrint(&find, "P1 = (damage:{d}", .{actions.p1.damage});
+        const r = try std.fmt.bufPrint(&repl, "P1 = (damage:{d}…{d}", .{ actions.p1.damage, p1 });
+        assert(std.mem.replace(u8, input[0..len], n, r, output[0 .. len + 6]) == 1);
+        @memcpy(input[0 .. len + 6], output[0 .. len + 6]);
+        len += 6;
+    }
+    if (p2 != 0 and actions.p2.damage != 0) {
+        const n = try std.fmt.bufPrint(&find, "P2 = (damage:{d}", .{actions.p2.damage});
+        const r = try std.fmt.bufPrint(&repl, "P2 = (damage:{d}…{d}", .{ actions.p2.damage, p2 });
+        assert(std.mem.replace(u8, input[0..len], n, r, output[0 .. len + 6]) == 1);
+        len += 6;
+    }
+
+    try writer.writeAll(output[0..len]);
 }