@pkmn/engine 0.1.0-dev.dd5b9081 → 0.1.0-dev.deda8593

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);
 
@@ -185,16 +184,16 @@ pub fn Rational(comptime T: type) type {
             try writer.print("{d}/{d}", .{ self.p, self.q });
         }
 
-        inline fn multiplication(r: *Self, p: anytype, q: anytype) !void {
+        fn multiplication(r: *Self, p: anytype, q: anytype) !void {
             r.p = try std.math.mul(T, r.p, p);
             r.q = try std.math.mul(T, r.q, q);
         }
 
-        inline fn addition(r: *Self, p: anytype, q: anytype) !void {
+        fn addition(r: *Self, p: anytype, q: anytype) !void {
             // (a/b) + (c/d) = (ad+bc)/(bd)
-            var d = try std.math.mul(T, r.q, q);
-            var n1 = try std.math.mul(T, r.p, q);
-            var n2 = try std.math.mul(T, r.q, p);
+            const d = try std.math.mul(T, r.q, q);
+            const n1 = try std.math.mul(T, r.p, q);
+            const n2 = try std.math.mul(T, r.q, p);
 
             r.p = try std.math.add(T, n1, n2);
             r.q = d;
@@ -203,7 +202,7 @@ pub fn Rational(comptime T: type) type {
 }
 
 // https://en.wikipedia.org/wiki/Euclidean_algorithm
-inline fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
+fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
     assert(p >= 1);
     assert(q >= 1);
 
@@ -234,6 +233,8 @@ test Rational {
         var r: Rational(t) = .{};
 
         var c: t = 128;
+        _ = &c;
+
         try r.update(c, 256);
         try doTurn(&r);
 
@@ -275,7 +276,7 @@ pub const BigRational = struct {
     /// Create a new BigRational wrapper.  A small amount of memory will be allocated on
     /// initialization. Not default initialized to 1 - you must explicitly `reset` first.
     pub fn init(alloc: std.mem.Allocator) !BigRational {
-        return BigRational{ .val = try std.math.big.Rational.init(alloc) };
+        return .{ .val = try std.math.big.Rational.init(alloc) };
     }
 
     /// Frees all memory associated with a rational.
@@ -320,6 +321,8 @@ test BigRational {
     try r.reset();
 
     var c: u8 = 128;
+    _ = &c;
+
     try r.update(c, 256);
     try doTurn(&r);
 

package/src/lib/common/rng.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-const options = @import("./options.zig");
+const options = @import("options.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
@@ -25,6 +25,11 @@ pub fn PRNG(comptime gen: comptime_int) type {
         pub fn next(self: *Self) Output(gen) {
             return self.src.next();
         }
+
+        pub fn advance(self: *Self, n: usize) void {
+            if (!options.advance) return;
+            for (0..n) |_| self.src.advance();
+        }
     };
 }
 
@@ -61,11 +66,15 @@ pub const PSRNG = extern struct {
             (@as(u64, self.range(u16, 0, 0x10000)) << 16) |
             (@as(u64, self.range(u16, 0, 0x10000)));
     }
+
+    pub fn Bound(comptime T: type) type {
+        return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
+    }
 };
 
 test PSRNG {
-    var psrng = PSRNG{ .src = .{ .seed = 0x0001000200030004 } };
-    try expectEqual(@as(u8, 121), psrng.range(u8, 0, 256));
+    var psrng: PSRNG = .{ .src = .{ .seed = 0x0001000200030004 } };
+    try expectEqual(121, psrng.range(u8, 0, 256));
     try expectEqual(false, psrng.chance(u8, 128, 256)); // 226 < 128
 }
 
@@ -89,18 +98,22 @@ pub const Gen12 = extern struct {
         self.index = (self.index + 1) % 9;
         return val;
     }
+
+    pub fn advance(self: *Gen12) void {
+        _ = self.next();
+    }
 };
 
 test Gen12 {
     const expected = [_]u8{ 6, 11, 16, 21, 26, 31, 36, 41, 46, 31, 56, 81 };
-    var rng = Gen12{ .seed = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9 } };
+    var rng: Gen12 = .{ .seed = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9 } };
     for (expected) |e| {
         try expectEqual(e, rng.next());
     }
 
-    try expectEqual(@as(u8, 16), Gen12.percent(6) + 1);
-    try expectEqual(@as(u8, 16), Gen12.percent(7) - 1);
-    try expectEqual(@as(u8, 128), Gen12.percent(50) + 1);
+    try expectEqual(16, Gen12.percent(6) + 1);
+    try expectEqual(16, Gen12.percent(7) - 1);
+    try expectEqual(128, Gen12.percent(50) + 1);
 }
 
 // https://pkmn.cc/pokeemerald/src/random.c
@@ -129,7 +142,7 @@ test Gen34 {
         .{ 0x80000000, 5, 0x0E425287 }, .{ 0x80000000, 10, 0x6F2CF4B2 },
     };
     for (data) |d| {
-        var rng = Gen34{ .seed = d[0] };
+        var rng: Gen34 = .{ .seed = d[0] };
         for (0..d[1]) |_| _ = rng.next();
         try expectEqual(d[2], rng.seed);
     }
@@ -161,7 +174,7 @@ test Gen56 {
         .{ 0x8000000000000000, 10, 0xE7795501267F125A },
     };
     for (data) |d| {
-        var rng = Gen56{ .seed = d[0] };
+        var rng: Gen56 = .{ .seed = d[0] };
         for (0..d[1]) |_| _ = rng.next();
         try expectEqual(d[2], rng.seed);
     }
@@ -188,7 +201,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             for (0..n) |_| _ = self.next();
         }
 
-        pub fn range(self: *Self, comptime T: type, from: T, to: Bound(T)) T {
+        pub fn range(self: *Self, comptime T: type, from: T, to: PSRNG.Bound(T)) T {
             assert(showdown);
             return @intCast(@as(u64, self.next()) * (to - from) / divisor + from);
         }
@@ -197,7 +210,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             self: *Self,
             comptime T: type,
             numerator: T,
-            denominator: Bound(T),
+            denominator: PSRNG.Bound(T),
         ) bool {
             assert(showdown);
             assert(denominator > 0);
@@ -213,7 +226,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
 test FixedRNG {
     const Type = if (showdown) u32 else u8;
     const expected = [_]Type{ 42, 255, 0 };
-    var rng = FixedRNG(1, expected.len){ .rolls = expected };
+    var rng: FixedRNG(1, expected.len) = .{ .rolls = expected };
     for (expected) |e| {
         try expectEqual(e, rng.next());
     }
@@ -228,7 +241,3 @@ fn Output(comptime gen: comptime_int) type {
         else => unreachable,
     };
 }
-
-fn Bound(comptime T: type) type {
-    return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
-}

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.
@@ -50,7 +53,7 @@ pub const Summaries = extern struct {
     }
 
     /// Returns the `Summary` for the given `player`.
-    pub inline fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Summary) {
+    pub fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Summary) {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == Summaries);
         return if (player == .P1) &self.p1 else &self.p2;
     }
@@ -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
@@ -157,7 +162,7 @@ pub const Calc = struct {
 
 /// Null object pattern implementation of Generation I `Calc` which does nothing, though damage
 /// calculator support should additionally be turned off entirely via `options.calc`.
-pub const NULL = Null{};
+pub const NULL: Null = .{};
 
 const Null = struct {
     pub fn overridden(
@@ -201,6 +206,8 @@ pub const Options = struct {
     metronome: bool = false,
 };
 
+pub const MAX_FRONTIER = 19;
+
 pub fn transitions(
     battle: anytype,
     c1: Choice,
@@ -211,8 +218,8 @@ pub fn transitions(
 ) !?Stats {
     var stats: Stats = .{};
 
-    var actions = options.actions;
-    var cap = options.cap;
+    const actions = options.actions;
+    const cap = options.cap;
 
     var seen = std.AutoHashMap(Actions, void).init(allocator);
     defer seen.deinit();
@@ -232,8 +239,8 @@ pub fn transitions(
     _ = try b.update(c1, c2, &opts);
     stats.updates += 1;
 
-    var p1 = b.side(.P1);
-    var p2 = b.side(.P2);
+    const p1 = b.side(.P1);
+    const p2 = b.side(.P2);
 
     var p: Rational(u128) = .{ .p = 0, .q = 1 };
     try frontier.append(opts.chance.actions);
@@ -247,15 +254,21 @@ pub fn transitions(
     var i: usize = 0;
     assert(frontier.items.len == 1);
     while (i < frontier.items.len) : (i += 1) {
-        var template = frontier.items[i];
+        const template = frontier.items[i];
         opts.calc.overrides.durations = .{
             .p1 = template.p1.durations,
             .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 } };
+        var a: Actions = .{ .p1 = .{ .metronome = p1_move }, .p2 = .{ .metronome = p2_move } };
 
         for (Rolls.speedTie(template.p1)) |tie| { a.p1.speed_tie = tie; a.p2.speed_tie = tie;
         for (Rolls.sleep(template.p1, actions.p1)) |p1_slp| { a.p1.durations.sleep = p1_slp;
@@ -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,7 +435,86 @@ pub fn transitions(
     return stats;
 }
 
-inline fn matches(actions: Actions, i: usize, frontier: []Actions) bool {
+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?
         if (i == j) continue;
@@ -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]);
 }