@pkmn/engine 0.1.0-dev.9f75c7ae → 0.1.0-dev.a0167a9d

package/src/lib/gen1/helpers.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
 const common = @import("../common/data.zig");
 const optional = @import("../common/optional.zig");
@@ -34,6 +35,9 @@ const Status = data.Status;
 
 const Action = chance.Action;
 const Actions = chance.Actions;
+const Duration = chance.Duration;
+
+const endian = builtin.cpu.arch.endian();
 
 /// Configuration options controlling the domain of valid Pokémon that can be generated by the
 /// random generator helpers.
@@ -43,6 +47,8 @@ pub const Options = struct {
     /// Whether to generate Pokémon with moves that contain bugs on Pokémon Showdown that are
     /// unimplementable in the engine.
     block: bool = showdown,
+    // FIXME: remove once durations work with -Dchance
+    durations: bool = false,
 };
 
 /// Helpers to simplify initialization of a Generation I battle.
@@ -86,18 +92,38 @@ pub const Battle = struct {
 };
 
 fn prng(rand: *PSRNG) data.PRNG {
-    // GLITCH: initial bytes in seed can only range from 0-252, not 0-255
-    const max: u8 = 253;
     return .{
         .src = .{
             .seed = if (showdown)
                 rand.newSeed()
-            else
-                .{
-                    rand.range(u8, 0, max), rand.range(u8, 0, max), rand.range(u8, 0, max),
-                    rand.range(u8, 0, max), rand.range(u8, 0, max), rand.range(u8, 0, max),
-                    rand.range(u8, 0, max), rand.range(u8, 0, max), rand.range(u8, 0, max),
-                },
+            else seed: {
+                // GLITCH: The initial RNG seed in Gen I link battles is heavily constrained
+                // https://www.smogon.com/forums/threads/rng-in-rby-link-battles.3746779
+                var seed = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+                // Bytes in seed can only range from 0-252, not 0-255
+                const max: u8 = 253;
+                // Instructions take multiples of 4 cycles to execute
+                var timer: u16 = 4 * rand.range(u16, 0, 16384);
+                var add: u8 = rand.range(u8, 0, 256);
+                var carry: u8 = 0;
+
+                var i: u8 = 0;
+                while (i < seed.len) {
+                    const div: u8 = @intCast(timer >> 8);
+                    add +%= div +% carry;
+                    if (add < max) {
+                        seed[i] = add;
+                        i += 1;
+                        timer +%= 472;
+                        carry = 1;
+                    } else {
+                        timer +%= 452;
+                        carry = 0;
+                    }
+                }
+                break :seed seed;
+            },
         },
     };
 }
@@ -210,6 +236,7 @@ pub const Pokemon = struct {
             var m: Move = .None;
             sample: while (true) {
                 m = @enumFromInt(rand.range(u8, 1, Move.size - 1 + 1));
+                if (opt.durations and durationsX(m)) continue :sample;
                 if (opt.block and blocked(m)) continue :sample;
                 for (0..i) |j| if (ms[j].id == m) continue :sample;
                 break;
@@ -247,6 +274,23 @@ fn blocked(m: Move) bool {
     };
 }
 
+fn durationsX(m: Move) bool {
+    // Any moves that have effects that result in duration tracking with -Dchance
+    return switch (Move.get(m).effect) {
+        .Confusion,
+        .Bide,
+        .Sleep,
+        .Rage,
+        .Binding,
+        .Thrashing,
+        .ConfusionChance,
+        .Disable,
+        .Metronome,
+        => true,
+        else => false,
+    };
+}
+
 /// Convenience helper to create a move-type choice for the provided move slot.
 pub fn move(slot: u4) Choice {
     return .{ .type = .Move, .data = slot };
@@ -267,7 +311,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for speed ties given the `action` state.
     pub fn speedTie(action: Action) []const Optional(Player) {
-        return if (@field(action, "speed_tie") == .None) &PLAYER_NONE else &PLAYERS;
+        return if (action.speed_tie == .None) &PLAYER_NONE else &PLAYERS;
     }
 
     const BOOL_NONE = [_]Optional(bool){.None};
@@ -277,25 +321,19 @@ pub const Rolls = struct {
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
     pub fn hit(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .true) return &BOOL_NONE;
-        return if (@field(action, "hit") == .None) &BOOL_NONE else &BOOLS;
+        return if (action.hit == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for critical hits given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub fn criticalHit(
-        action: Action,
-        parent: Optional(bool),
-    ) []const Optional(bool) {
+    pub fn criticalHit(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .false) return &BOOL_NONE;
-        return if (@field(action, "critical_hit") == .None) &BOOL_NONE else &BOOLS;
+        return if (action.critical_hit == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for secondary chances hits given the
     /// `action` state and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub fn secondaryChance(
-        action: Action,
-        parent: Optional(bool),
-    ) []const Optional(bool) {
+    pub fn secondaryChance(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .false) return &BOOL_NONE;
         return if (@field(action, "secondary_chance") == .None) &BOOL_NONE else &BOOLS;
     }
@@ -306,7 +344,7 @@ pub const Rolls = struct {
     /// Returns the range bounding damage rolls given the `action` state and the state of
     /// the `parent` (whether the player's Pokémon's move hit).
     pub fn damage(action: Action, parent: Optional(bool)) Range {
-        return if (parent == .false or @field(action, "damage") == 0)
+        return if (parent == .false or action.damage == 0)
             .{ .min = 0, .max = 1 }
         else
             .{ .min = 217, .max = 256 };
@@ -327,14 +365,14 @@ pub const Rolls = struct {
     /// Returns a slice with the correct range of values for confused given the `action` state
     /// and the state of the `parent` (the player's Pokémon's remaining confusion turns).
     pub fn confused(action: Action, parent: u4) []const Optional(bool) {
-        return if (parent == 0 or @field(action, "confused") == .None) &BOOL_NONE else &BOOLS;
+        return if (parent == 0 or action.confused == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for paralysis given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon was confused).
     pub fn paralyzed(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .true) return &BOOL_NONE;
-        return if (@field(action, "paralyzed") == .None) &BOOL_NONE else &BOOLS;
+        return if (action.paralyzed == .None) &BOOL_NONE else &BOOLS;
     }
 
     const DURATION_NONE = [_]u1{0};
@@ -344,40 +382,38 @@ pub const Rolls = struct {
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
     pub fn duration(action: Action, parent: Optional(bool)) []const u1 {
         if (parent == .false) return &DURATION_NONE;
-        return if (@field(action, "duration") == 0) &DURATION_NONE else &DURATION;
+        return if (action.duration == 0) &DURATION_NONE else &DURATION;
     }
 
     const U3_NONE = [_]u3{0};
     const U3_FORCED = [_]u3{1};
 
-    /// 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 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);
+    /// TODO
+    pub inline fn sleep(dur: Duration, origin: Duration) []const u3 {
+        const d = dur.sleep;
+        const o = origin.sleep;
+        if (o == d) return if (o == 0) &U3_NONE else &[_]u3{o};
+        assert(d == 0 or d == 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` 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 {
+    /// TODO
+    pub inline fn disable(dur: Duration, origin: Duration, parent: u4) []const u4 {
         if (parent > 0) return &DISABLE_NONE;
-        const a = @field(action.durations, "disable");
-        const o = @field(origin.durations, "disable");
+        const a = dur.disable;
+        const o = origin.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` 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 {
+    /// TODO
+    pub inline fn confusion(dur: Duration, origin: Duration, parent: u4) []const u3 {
         if (parent > 0) return &U3_NONE;
-        const a = @field(action.durations, "confusion");
-        const o = @field(origin.durations, "confusion");
+        const a = dur.confusion;
+        const o = origin.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)
@@ -386,12 +422,11 @@ pub const Rolls = struct {
             &[_]u3{ 0, o + 1 };
     }
 
-    /// 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 {
+    /// TODO
+    pub inline fn attacking(dur: Duration, origin: Duration, parent: Optional(bool)) []const u3 {
         if (parent == .true) return &U3_NONE;
-        const a = @field(action.durations, "attacking");
-        const o = @field(origin.durations, "attacking");
+        const a = dur.attacking;
+        const o = origin.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)
@@ -400,12 +435,11 @@ pub const Rolls = struct {
             &[_]u3{ 0, o + 1 };
     }
 
-    /// 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 {
+    /// TODO
+    pub inline fn binding(dur: Duration, origin: Duration, parent: Optional(bool)) []const u3 {
         if (parent == .true) return &U3_NONE;
-        const a = @field(action.durations, "binding");
-        const o = @field(origin.durations, "binding");
+        const a = dur.binding;
+        const o = origin.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 };
@@ -420,7 +454,7 @@ pub const Rolls = struct {
     /// These slots may or **may not be valid** as slots may be unset / have 0 PP.
     pub fn moveSlot(action: Action, parent: Optional(bool)) []const u4 {
         if (parent == .false) return &SLOT_NONE;
-        return if (@field(action, "move_slot") == 0) &SLOT_NONE else &SLOT;
+        return if (action.move_slot == 0) &SLOT_NONE else &SLOT;
     }
 
     const MULTI_NONE = [_]u4{0};
@@ -430,7 +464,7 @@ pub const Rolls = struct {
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
     pub fn multiHit(action: Action, parent: Optional(bool)) []const u4 {
         if (parent == .false) return &MULTI_NONE;
-        return if (@field(action, "multi_hit") == 0) &MULTI_NONE else &MULTI;
+        return if (action.multi_hit == 0) &MULTI_NONE else &MULTI;
     }
 
     const PSYWAVE_NONE = [_]u8{0};
@@ -448,7 +482,7 @@ pub const Rolls = struct {
         parent: Optional(bool),
     ) []const u8 {
         if (parent == .false) return &PSYWAVE_NONE;
-        return if (@field(action, "psywave") == 0)
+        return if (action.psywave == 0)
             &PSYWAVE_NONE
         else
             PSYWAVE[0 .. @as(u16, side.stored().level) * 3 / 2];
@@ -458,7 +492,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for metronome given the `action` state.
     pub fn metronome(action: Action) []const Move {
-        return if (@field(action, "metronome") == .None) &MOVE_NONE else &Move.METRONOME;
+        return if (action.metronome == .None) &MOVE_NONE else &Move.METRONOME;
     }
 };
 
@@ -478,12 +512,12 @@ test "Rolls.damage" {
 test "Rolls.coalesce" {
     var summaries =
         calc.Summaries{ .p1 = .{ .damage = .{ .base = 74, .final = 69, .capped = true } } };
-    try expectEqual(@as(u8, 0), try Rolls.coalesce(.P2, 0, &summaries, false));
-    try expectEqual(@as(u8, 241), try Rolls.coalesce(.P2, 238, &summaries, false));
-    try expectEqual(@as(u8, 255), try Rolls.coalesce(.P2, 238, &summaries, true));
+    try expectEqual(0, try Rolls.coalesce(.P2, 0, &summaries, false));
+    try expectEqual(241, try Rolls.coalesce(.P2, 238, &summaries, false));
+    try expectEqual(255, try Rolls.coalesce(.P2, 238, &summaries, true));
     summaries.p1.damage.final = 74;
-    try expectEqual(@as(u8, 217), try Rolls.coalesce(.P2, 217, &summaries, false));
-    try expectEqual(@as(u8, 255), try Rolls.coalesce(.P2, 217, &summaries, true));
+    try expectEqual(217, try Rolls.coalesce(.P2, 217, &summaries, false));
+    try expectEqual(255, try Rolls.coalesce(.P2, 217, &summaries, true));
 }
 
 test "Rolls.hit" {
@@ -539,206 +573,113 @@ test "Rolls.duration" {
 }
 
 test "Rolls.sleep" {
-    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 } },
-    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.sleep(.{ .sleep = 0 }, .{ .sleep = 0 }));
+    try expectEqualSlices(u3, &.{ 0, 1 }, Rolls.sleep(.{ .sleep = 1 }, .{ .sleep = 0 }));
+    try expectEqualSlices(u3, &.{ 0, 2 }, Rolls.sleep(.{ .sleep = 0 }, .{ .sleep = 1 }));
+    try expectEqualSlices(u3, &.{1}, Rolls.sleep(.{ .sleep = 1 }, .{ .sleep = 1 }));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.sleep(.{ .sleep = 0 }, .{ .sleep = 2 }));
+    try expectEqualSlices(u3, &.{ 0, 7 }, Rolls.sleep(.{ .sleep = 7 }, .{ .sleep = 6 }));
+    try expectEqualSlices(u3, &.{0}, Rolls.sleep(.{ .sleep = 0 }, .{ .sleep = 7 }));
 }
 
 test "Rolls.disable" {
-    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,
-    ));
+    try expectEqualSlices(u4, &.{0}, Rolls.disable(.{ .disable = 0 }, .{ .disable = 0 }, 0));
+    try expectEqualSlices(u4, &.{ 0, 1 }, Rolls.disable(.{ .disable = 1 }, .{ .disable = 0 }, 0));
+    try expectEqualSlices(u4, &.{ 0, 2 }, Rolls.disable(.{ .disable = 0 }, .{ .disable = 1 }, 0));
+    try expectEqualSlices(u4, &.{1}, Rolls.disable(.{ .disable = 1 }, .{ .disable = 1 }, 0));
+    try expectEqualSlices(u4, &.{ 0, 3 }, Rolls.disable(.{ .disable = 0 }, .{ .disable = 2 }, 0));
+    try expectEqualSlices(u4, &.{0}, Rolls.disable(.{ .disable = 0 }, .{ .disable = 2 }, 1));
+    try expectEqualSlices(u4, &.{ 0, 8 }, Rolls.disable(.{ .disable = 8 }, .{ .disable = 7 }, 0));
+    try expectEqualSlices(u4, &.{0}, Rolls.disable(.{ .disable = 0 }, .{ .disable = 8 }, 0));
 }
 
 test "Rolls.confusion" {
-    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}, Rolls.confusion(.{ .confusion = 0 }, .{ .confusion = 0 }, 0));
+    try expectEqualSlices(u3, &.{1}, Rolls.confusion(.{ .confusion = 1 }, .{ .confusion = 0 }, 0));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(.{ .confusion = 0 }, .{ .confusion = 1 }, 0));
+    try expectEqualSlices(u3, &.{1}, Rolls.confusion(.{ .confusion = 1 }, .{ .confusion = 1 }, 0));
     try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.confusion(
-        .{ .durations = .{ .confusion = 0 } },
-        .{ .durations = .{ .confusion = 2 } },
+        .{ .confusion = 0 },
+        .{ .confusion = 2 },
         0,
     ));
-    try expectEqualSlices(u3, &.{0}, Rolls.confusion(
-        .{ .durations = .{ .confusion = 0 } },
-        .{ .durations = .{ .confusion = 2 } },
-        1,
-    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(.{ .confusion = 0 }, .{ .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 } },
+        .{ .confusion = 5 },
+        .{ .confusion = 4 },
         0,
     ));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(.{ .confusion = 0 }, .{ .confusion = 5 }, 0));
 }
 
 test "Rolls.attacking" {
     try expectEqualSlices(u3, &.{0}, Rolls.attacking(
-        .{ .durations = .{ .attacking = 0 } },
-        .{ .durations = .{ .attacking = 0 } },
+        .{ .attacking = 0 },
+        .{ .attacking = 0 },
         .false,
     ));
     try expectEqualSlices(u3, &.{1}, Rolls.attacking(
-        .{ .durations = .{ .attacking = 1 } },
-        .{ .durations = .{ .attacking = 0 } },
+        .{ .attacking = 1 },
+        .{ .attacking = 0 },
         .false,
     ));
     try expectEqualSlices(u3, &.{0}, Rolls.attacking(
-        .{ .durations = .{ .attacking = 0 } },
-        .{ .durations = .{ .attacking = 1 } },
+        .{ .attacking = 0 },
+        .{ .attacking = 1 },
         .false,
     ));
     try expectEqualSlices(u3, &.{1}, Rolls.attacking(
-        .{ .durations = .{ .attacking = 1 } },
-        .{ .durations = .{ .attacking = 1 } },
+        .{ .attacking = 1 },
+        .{ .attacking = 1 },
         .false,
     ));
     try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.attacking(
-        .{ .durations = .{ .attacking = 0 } },
-        .{ .durations = .{ .attacking = 2 } },
+        .{ .attacking = 0 },
+        .{ .attacking = 2 },
         .false,
     ));
     try expectEqualSlices(u3, &.{0}, Rolls.attacking(
-        .{ .durations = .{ .attacking = 0 } },
-        .{ .durations = .{ .attacking = 2 } },
+        .{ .attacking = 0 },
+        .{ .attacking = 2 },
         .true,
     ));
     try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.attacking(
-        .{ .durations = .{ .attacking = 3 } },
-        .{ .durations = .{ .attacking = 2 } },
+        .{ .attacking = 3 },
+        .{ .attacking = 2 },
         .false,
     ));
     try expectEqualSlices(u3, &.{0}, Rolls.attacking(
-        .{ .durations = .{ .attacking = 0 } },
-        .{ .durations = .{ .attacking = 3 } },
+        .{ .attacking = 0 },
+        .{ .attacking = 3 },
         .false,
     ));
 }
 
 test "Rolls.binding" {
-    try expectEqualSlices(u3, &.{0}, Rolls.binding(
-        .{ .durations = .{ .binding = 0 } },
-        .{ .durations = .{ .binding = 0 } },
-        .false,
-    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.binding(.{ .binding = 0 }, .{ .binding = 0 }, .false));
     try expectEqualSlices(u3, &.{ 0, 1 }, Rolls.binding(
-        .{ .durations = .{ .binding = 1 } },
-        .{ .durations = .{ .binding = 0 } },
+        .{ .binding = 1 },
+        .{ .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 } },
+        .{ .binding = 0 },
+        .{ .binding = 1 },
         .false,
     ));
+    try expectEqualSlices(u3, &.{1}, Rolls.binding(.{ .binding = 1 }, .{ .binding = 1 }, .false));
     try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.binding(
-        .{ .durations = .{ .binding = 0 } },
-        .{ .durations = .{ .binding = 2 } },
+        .{ .binding = 0 },
+        .{ .binding = 2 },
         .false,
     ));
-    try expectEqualSlices(u3, &.{0}, Rolls.binding(
-        .{ .durations = .{ .binding = 0 } },
-        .{ .durations = .{ .binding = 2 } },
-        .true,
-    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.binding(.{ .binding = 0 }, .{ .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 } },
+        .{ .binding = 4 },
+        .{ .binding = 3 },
         .false,
     ));
+    try expectEqualSlices(u3, &.{0}, Rolls.binding(.{ .binding = 0 }, .{ .binding = 4 }, .false));
 }
 
 test "Rolls.moveSlot" {
@@ -771,9 +712,53 @@ test "Rolls.psywave" {
 
     try expectEqualSlices(u8, &.{0}, Rolls.psywave(actions.p1, &side, .None));
     var rolls = Rolls.psywave(actions.p2, &side, .None);
-    try expectEqual(@as(u8, 150), rolls[rolls.len - 1]);
+    try expectEqual(150, rolls[rolls.len - 1]);
     side.stored().level = 81;
     rolls = Rolls.psywave(actions.p2, &side, .None);
-    try expectEqual(@as(u8, 121), rolls[rolls.len - 1]);
+    try expectEqual(121, rolls[rolls.len - 1]);
     try expectEqualSlices(u8, &.{0}, Rolls.psywave(actions.p2, &side, .false));
 }
+
+/// Empirically determined maximum number of bytes possibly required to store the diff between two
+/// Generation I battles.
+pub const MAX_DIFFS: usize = 117;
+
+/// The optimal size in bytes required to hold the diff between two Generation I battles.
+/// At least as large as MAX_DIFFS.
+pub const DIFFS_SIZE = if (builtin.mode == .ReleaseSmall)
+    MAX_DIFFS
+else
+    std.math.ceilPowerOfTwo(usize, MAX_DIFFS) catch unreachable;
+
+/// TODO
+pub fn diff(
+    a: *const data.Battle(data.PRNG),
+    b: *const data.Battle(data.PRNG),
+    w: protocol.ByteStream.Writer,
+) !usize {
+    const pos = w.stream.pos;
+    const size = @sizeOf(data.Battle(data.PRNG)) - @sizeOf(data.PRNG);
+    assert(size % 2 == 0);
+    assert(size / 2 < 255);
+
+    var i: usize = 0;
+    while (i < size) : (i += 2) {
+        const val = std.mem.bytesAsValue(u16, std.mem.asBytes(a)[i .. i + 2]).*;
+        if (val != std.mem.bytesAsValue(u16, std.mem.asBytes(b)[i .. i + 2]).*) {
+            try w.writeByte(@intCast(i / 2));
+            try w.writeInt(u16, val, endian);
+        }
+    }
+
+    return w.stream.pos - pos;
+}
+
+/// TODO
+pub fn patch(battle: *data.Battle(data.PRNG), buf: []u8) void {
+    var i: usize = 0;
+    while (i < buf.len) : (i += 3) {
+        const off = @as(u16, @intCast(buf[i])) * 2;
+        const val = std.mem.readInt(u16, @ptrCast(buf[i + 1 .. i + 3]), endian);
+        std.mem.writeInt(u16, @ptrCast(std.mem.asBytes(battle)[off .. off + 2]), val, endian);
+    }
+}