@pkmn/engine 0.1.0-dev.2c13d3ec → 0.1.0-dev.305a932f

package/src/lib/gen1/data/types.zig

@@ -30,7 +30,7 @@ pub const Type = enum(u4) {
     Ice,
     Dragon,
 
-    const CHART = [15][15]Effectiveness{
+    const CHART: [15][15]Effectiveness = .{
         [_]Effectiveness{ N, N, N, N, N, R, N, I, N, N, N, N, N, N, N }, // Normal
         [_]Effectiveness{ S, N, R, R, N, S, R, I, N, N, N, N, R, S, N }, // Fighting
         [_]Effectiveness{ N, S, N, N, N, R, S, N, N, N, S, R, N, N, N }, // Flying
@@ -99,7 +99,7 @@ pub const Type = enum(u4) {
         return CHART[@intFromEnum(t1)][@intFromEnum(t2)];
     }
 
-    /// The precedence order of type `t2` vs. type  `t1`.
+    /// The precedence order of Type `t2` vs. Type `t1`.
     pub fn precedence(t1: Type, t2: Type) u8 {
         for (PRECEDENCE, 0..) |matchup, i| {
             if (matchup.type1 == t1 and matchup.type2 == t2) return @intCast(i);

package/src/lib/gen1/data.zig

@@ -65,7 +65,7 @@ pub fn Battle(comptime RNG: anytype) type {
         /// The last damage dealt by either side.
         last_damage: u16 = 0,
         /// Details about the last move selected/used by each player required to detect desyncs.
-        last_moves: MoveDetails = .{},
+        last_moves: [2]MoveDetails = [_]MoveDetails{.{}} ** 2,
         /// The pseudo random number generator.
         rng: RNG,
 
@@ -86,6 +86,15 @@ pub fn Battle(comptime RNG: anytype) type {
             return player.ident(@intCast(self.side(player).order[0]));
         }
 
+        /// Returns the `MoveDetails` for the given `player`.
+        pub inline fn lastMove(
+            self: anytype,
+            player: Player,
+        ) PointerType(@TypeOf(self), MoveDetails) {
+            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+            return &self.last_moves[@intFromEnum(player)];
+        }
+
         /// Returns the result of applying Player 1's choice `c1` and Player 2's choice `c2` to the
         /// battle, optionally writing protocol message logs to `options.log` if `pkmn.options.log`
         /// is enabled.
@@ -205,7 +214,7 @@ pub const Pokemon = extern struct {
     }
 };
 
-/// Representation of a Generation I & II Pokémon's move slot in a battle.
+/// Representation of a Generation I Pokémon's move slot in a battle.
 pub const MoveSlot = extern struct {
     /// The identifier for the move.
     id: Move = .None,
@@ -213,24 +222,16 @@ pub const MoveSlot = extern struct {
     pp: u8 = 0,
 
     comptime {
-        assert(@sizeOf(MoveSlot) == @sizeOf(u16));
+        assert(@sizeOf(MoveSlot) == 2);
     }
 };
 
 /// Details required to detect desyncs based on the move last selected/executed by players.
-pub const MoveDetails = packed struct {
-    /// The move slot index of the last move selected in the battle menu by Player 1
-    p1_index: if (showdown) u8 else u4 = 0,
-    /// Whether the last move executed by Player 1 was counterable.
-    p1_counterable: if (showdown) u8 else u4 = 0,
-    /// The move slot index of the last move selected in the battle menu by Player 2
-    p2_index: if (showdown) u8 else u4 = 0,
-    /// Whether the last move executed by Player 2 was counterable.
-    p2_counterable: if (showdown) u8 else u4 = 0,
-
-    comptime {
-        assert(@sizeOf(MoveDetails) == if (showdown) 4 else 2);
-    }
+pub const MoveDetails = packed struct(if (showdown) u16 else u8) {
+    /// The move slot index of the last move selected in the battle menu.
+    index: if (showdown) u8 else u4 = 0,
+    /// Whether the last move executed was counterable.
+    counterable: if (showdown) u8 else u4 = 0,
 };
 
 /// Bitfield representation of a Generation I & II Pokémon's major status condition.
@@ -324,7 +325,7 @@ test Status {
 }
 
 /// Bitfield representation of volatile statuses and associated data in Generation I.
-pub const Volatiles = packed struct {
+pub const Volatiles = packed struct(u64) {
     /// Whether the "Bide" volatile status is present.
     Bide: bool = false,
     /// Whether the "Thrashing" volatile status is present.
@@ -382,14 +383,10 @@ pub const Volatiles = packed struct {
     disabled_move: u3 = 0,
     /// The number of turns toxic damage has been accumulating.
     toxic: u5 = 0,
-
-    comptime {
-        assert(@sizeOf(Volatiles) == 8);
-    }
 };
 
 test Volatiles {
-    var volatiles = Volatiles{};
+    var volatiles: Volatiles = .{};
     volatiles.Confusion = true;
     volatiles.confusion = 2;
     volatiles.Thrashing = true;
@@ -451,7 +448,7 @@ test Stats {
 }
 
 /// Representation of a Pokémon's boosts in Generation I.
-pub const Boosts = packed struct {
+pub const Boosts = packed struct(u32) {
     /// A Pokémon's Attack boosts.
     atk: i4 = 0,
     /// A Pokémon's Defense boosts.
@@ -466,14 +463,10 @@ pub const Boosts = packed struct {
     evasion: i4 = 0,
 
     _: u8 = 0,
-
-    comptime {
-        assert(@sizeOf(Boosts) == 4);
-    }
 };
 
 test Boosts {
-    const boosts = Boosts{ .spc = -6 };
+    const boosts: Boosts = .{ .spc = -6 };
     try expectEqual(0, boosts.atk);
     try expectEqual(-6, boosts.spc);
 }
@@ -485,7 +478,7 @@ test Move {
     try expectEqual(2, @intFromEnum(Move.KarateChop));
     const move = Move.get(.Fissure);
     try expectEqual(Move.Effect.OHKO, move.effect);
-    try expectEqual(@as(u8, 30), move.accuracy);
+    try expectEqual(rng.Gen12.percent(30), move.accuracy);
     try expectEqual(Type.Ground, move.type);
 
     try expect(!Move.Effect.onBegin(.None));
@@ -623,16 +616,16 @@ pub const DVs = struct {
 };
 
 test DVs {
-    var dvs = DVs{ .spc = 15, .spe = 15 };
+    var dvs: DVs = .{ .spc = 15, .spe = 15 };
     try expectEqual(@as(u4, 15), dvs.hp());
-    dvs = DVs{
+    dvs = .{
         .atk = 5,
         .def = 15,
         .spe = 13,
         .spc = 13,
     };
     try expectEqual(@as(u4, 15), dvs.hp());
-    dvs = DVs{
+    dvs = .{
         .def = 3,
         .spe = 10,
         .spc = 11,

package/src/lib/gen1/helpers.zig

@@ -350,47 +350,65 @@ pub const Rolls = struct {
     const U3_NONE = [_]u3{0};
     const U3_FORCED = [_]u3{1};
 
-    /// Returns a slice with a range of values for sleep given the `action` state.
+    /// Returns a slice with a range of values for sleep given the `action` and `origin` states.
     pub inline fn sleep(action: Action, origin: Action) []const u3 {
-        const turns = @field(action.durations, "sleep");
-        _ = origin;
-        return if (turns < 1 or turns >= 7) &U3_NONE else &[_]u3{ 0, turns };
+        const a = @field(action.durations, "sleep");
+        const o = @field(origin.durations, "sleep");
+        if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
+        assert(a == 0 or a == o + 1);
+        return if (o >= 7) &U3_NONE else &[_]u3{ 0, o + 1 };
     }
 
     const DISABLE_NONE = [_]u4{0};
 
-    /// Returns a slice with a range of values for disable given the `action` state
+    /// Returns a slice with a range of values for disable given the `action` and `origin` states
     /// and the state of the `parent` (the player's Pokémon's remaining sleep turns).
     pub inline fn disable(action: Action, origin: Action, parent: u4) []const u4 {
-        const turns = @field(action.durations, "disable");
-        _ = origin;
-        return if (parent > 0 or turns < 1 or turns >= 8) &DISABLE_NONE else &[_]u4{ 0, turns };
+        if (parent > 0) return &DISABLE_NONE;
+        const a = @field(action.durations, "disable");
+        const o = @field(origin.durations, "disable");
+        if (o == a) return if (o == 0) &DISABLE_NONE else &[_]u4{o};
+        assert(a == 0 or a == o + 1);
+        return if (o >= 8) &DISABLE_NONE else &[_]u4{ 0, o + 1 };
     }
 
-    /// Returns a slice with a range of values for confusion given the `action` state
+    /// Returns a slice with a range of values for confusion given the `action` and `origin` states
     /// and the state of the `parent` (the player's remaining sleep turns).
     pub inline fn confusion(action: Action, origin: Action, parent: u4) []const u3 {
-        const turns = @field(action.durations, "confusion");
-        _ = origin;
-        if (parent > 0 or turns < 1 or turns >= 5) return &U3_NONE;
-        return if (turns < 2) &U3_FORCED else &[_]u3{ 0, turns };
+        if (parent > 0) return &U3_NONE;
+        const a = @field(action.durations, "confusion");
+        const o = @field(origin.durations, "confusion");
+        if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
+        assert(a == 0 or a == o + 1);
+        return if (o >= 5) &U3_NONE else if (o < 2)
+            if (a == 0) &U3_NONE else &U3_FORCED
+        else
+            &[_]u3{ 0, o + 1 };
     }
 
-    /// Returns a slice with a range of values for attacking given the `action` state
+    /// Returns a slice with a range of values for attacking given the `action` and `origin` states
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
     pub inline fn attacking(action: Action, origin: Action, parent: Optional(bool)) []const u3 {
-        const turns = @field(action.durations, "attacking");
-        _ = origin;
-        if (parent == .true or turns < 1 or turns >= 3) return &U3_NONE;
-        return if (turns < 2) &U3_FORCED else &[_]u3{ 0, turns };
+        if (parent == .true) return &U3_NONE;
+        const a = @field(action.durations, "attacking");
+        const o = @field(origin.durations, "attacking");
+        if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
+        assert(a == 0 or a == o + 1);
+        return if (o >= 3) &U3_NONE else if (o < 2)
+            if (a == 0) &U3_NONE else &U3_FORCED
+        else
+            &[_]u3{ 0, o + 1 };
     }
 
-    /// Returns a slice with a range of values for binding given the `action` state
+    /// Returns a slice with a range of values for binding given the `action` and `origin` states
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
     pub inline fn binding(action: Action, origin: Action, parent: Optional(bool)) []const u3 {
-        const turns = @field(action.durations, "binding");
-        _ = origin;
-        return if (parent == .true or turns < 1 or turns >= 4) &U3_NONE else &[_]u3{ 0, turns };
+        if (parent == .true) return &U3_NONE;
+        const a = @field(action.durations, "binding");
+        const o = @field(origin.durations, "binding");
+        if (o == a) return if (o == 0) &U3_NONE else &[_]u3{o};
+        assert(a == 0 or a == o + 1);
+        return if (o >= 4) &U3_NONE else &[_]u3{ 0, o + 1 };
     }
 
     const SLOT_NONE = [_]u4{0};
@@ -460,13 +478,13 @@ pub const Rolls = struct {
 };
 
 test "Rolls.speedTie" {
-    const actions = Actions{ .p1 = .{ .speed_tie = .P2 } };
+    const actions: Actions = .{ .p1 = .{ .speed_tie = .P2 } };
     try expectEqualSlices(Optional(Player), &.{ .P1, .P2 }, Rolls.speedTie(actions.p1));
     try expectEqualSlices(Optional(Player), &.{.None}, Rolls.speedTie(actions.p2));
 }
 
 test "Rolls.damage" {
-    const actions = Actions{ .p2 = .{ .damage = 221 } };
+    const actions: Actions = .{ .p2 = .{ .damage = 221 } };
     try expectEqual(Rolls.Range{ .min = 0, .max = 1 }, Rolls.damage(actions.p1, .None));
     try expectEqual(Rolls.Range{ .min = 217, .max = 256 }, Rolls.damage(actions.p2, .None));
     try expectEqual(Rolls.Range{ .min = 0, .max = 1 }, Rolls.damage(actions.p2, .false));
@@ -484,7 +502,7 @@ test "Rolls.coalesce" {
 }
 
 test "Rolls.hit" {
-    const actions = Actions{ .p2 = .{ .hit = .true } };
+    const actions: Actions = .{ .p2 = .{ .hit = .true } };
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.hit(actions.p1, .None));
     try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.hit(actions.p2, .None));
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.hit(actions.p2, .true));
@@ -492,7 +510,7 @@ test "Rolls.hit" {
 }
 
 test "Rolls.secondaryChance" {
-    const actions = Actions{ .p1 = .{ .secondary_chance = .true } };
+    const actions: Actions = .{ .p1 = .{ .secondary_chance = .true } };
     try expectEqualSlices(
         Optional(bool),
         &.{ .false, .true },
@@ -503,7 +521,7 @@ test "Rolls.secondaryChance" {
 }
 
 test "Rolls.criticalHit" {
-    const actions = Actions{ .p1 = .{ .critical_hit = .true } };
+    const actions: Actions = .{ .p1 = .{ .critical_hit = .true } };
     try expectEqualSlices(
         Optional(bool),
         &.{ .false, .true },
@@ -514,14 +532,14 @@ test "Rolls.criticalHit" {
 }
 
 test "Rolls.confused" {
-    const actions = Actions{ .p2 = .{ .confused = .true } };
+    const actions: Actions = .{ .p2 = .{ .confused = .true } };
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.confused(actions.p1, 1));
     try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.confused(actions.p2, 1));
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.confused(actions.p2, 0));
 }
 
 test "Rolls.paralyzed" {
-    const actions = Actions{ .p2 = .{ .paralyzed = .true } };
+    const actions: Actions = .{ .p2 = .{ .paralyzed = .true } };
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.paralyzed(actions.p1, .None));
     try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.paralyzed(actions.p2, .None));
     try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.paralyzed(actions.p2, .false));
@@ -529,102 +547,237 @@ test "Rolls.paralyzed" {
 }
 
 test "Rolls.duration" {
-    const actions = Actions{ .p2 = .{ .duration = 3 } };
+    const actions: Actions = .{ .p2 = .{ .duration = 3 } };
     try expectEqualSlices(u1, &.{0}, Rolls.duration(actions.p1, .None));
     try expectEqualSlices(u1, &.{1}, Rolls.duration(actions.p2, .None));
     try expectEqualSlices(u1, &.{0}, Rolls.duration(actions.p2, .false));
 }
 
-const FIXME: Action = .{};
-
 test "Rolls.sleep" {
-    try expectEqualSlices(u3, &.{0}, Rolls.sleep(.{ .durations = .{ .sleep = 0 } }, FIXME));
-    try expectEqualSlices(u3, &.{0}, Rolls.sleep(.{ .durations = .{ .sleep = 7 } }, FIXME));
-    try expectEqualSlices(u3, &.{ 0, 4 }, Rolls.sleep(.{ .durations = .{ .sleep = 4 } }, FIXME));
+    try expectEqualSlices(u3, &.{0}, Rolls.sleep(
+        .{ .durations = .{ .sleep = 0 } },
+        .{ .durations = .{ .sleep = 0 } },
+    ));
+    try expectEqualSlices(u3, &.{ 0, 1 }, Rolls.sleep(
+        .{ .durations = .{ .sleep = 1 } },
+        .{ .durations = .{ .sleep = 0 } },
+    ));
+    try expectEqualSlices(u3, &.{ 0, 2 }, Rolls.sleep(
+        .{ .durations = .{ .sleep = 0 } },
+        .{ .durations = .{ .sleep = 1 } },
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.sleep(
+        .{ .durations = .{ .sleep = 1 } },
+        .{ .durations = .{ .sleep = 1 } },
+    ));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.sleep(
+        .{ .durations = .{ .sleep = 0 } },
+        .{ .durations = .{ .sleep = 2 } },
+    ));
+    try expectEqualSlices(u3, &.{ 0, 7 }, Rolls.sleep(
+        .{ .durations = .{ .sleep = 7 } },
+        .{ .durations = .{ .sleep = 6 } },
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.sleep(
+        .{ .durations = .{ .sleep = 0 } },
+        .{ .durations = .{ .sleep = 7 } },
+    ));
 }
 
 test "Rolls.disable" {
-    try expectEqualSlices(u4, &.{0}, Rolls.disable(.{ .durations = .{ .disable = 0 } }, FIXME, 0));
-    try expectEqualSlices(u4, &.{0}, Rolls.disable(.{ .durations = .{ .disable = 8 } }, FIXME, 0));
-    try expectEqualSlices(u4, &.{0}, Rolls.disable(.{ .durations = .{ .disable = 4 } }, FIXME, 1));
-    try expectEqualSlices(u4, &.{ 0, 4 }, Rolls.disable(.{
-        .durations = .{ .disable = 4 },
-    }, FIXME, 0));
+    try expectEqualSlices(u4, &.{0}, Rolls.disable(
+        .{ .durations = .{ .disable = 0 } },
+        .{ .durations = .{ .disable = 0 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{ 0, 1 }, Rolls.disable(
+        .{ .durations = .{ .disable = 1 } },
+        .{ .durations = .{ .disable = 0 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{ 0, 2 }, Rolls.disable(
+        .{ .durations = .{ .disable = 0 } },
+        .{ .durations = .{ .disable = 1 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{1}, Rolls.disable(
+        .{ .durations = .{ .disable = 1 } },
+        .{ .durations = .{ .disable = 1 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{ 0, 3 }, Rolls.disable(
+        .{ .durations = .{ .disable = 0 } },
+        .{ .durations = .{ .disable = 2 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{0}, Rolls.disable(
+        .{ .durations = .{ .disable = 0 } },
+        .{ .durations = .{ .disable = 2 } },
+        1,
+    ));
+    try expectEqualSlices(u4, &.{ 0, 8 }, Rolls.disable(
+        .{ .durations = .{ .disable = 8 } },
+        .{ .durations = .{ .disable = 7 } },
+        0,
+    ));
+    try expectEqualSlices(u4, &.{0}, Rolls.disable(
+        .{ .durations = .{ .disable = 0 } },
+        .{ .durations = .{ .disable = 8 } },
+        0,
+    ));
 }
 
 test "Rolls.confusion" {
-    try expectEqualSlices(u3, &.{0}, Rolls.confusion(.{
-        .durations = .{ .confusion = 0 },
-    }, FIXME, 0));
-    try expectEqualSlices(u3, &.{0}, Rolls.confusion(.{
-        .durations = .{ .confusion = 5 },
-    }, FIXME, 0));
-    try expectEqualSlices(u3, &.{0}, Rolls.confusion(.{
-        .durations = .{ .confusion = 3 },
-    }, FIXME, 1));
-    try expectEqualSlices(u3, &.{1}, Rolls.confusion(.{
-        .durations = .{ .confusion = 1 },
-    }, FIXME, 0));
-    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.confusion(.{
-        .durations = .{ .confusion = 3 },
-    }, FIXME, 0));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 0 } },
+        .{ .durations = .{ .confusion = 0 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 1 } },
+        .{ .durations = .{ .confusion = 0 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 0 } },
+        .{ .durations = .{ .confusion = 1 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 1 } },
+        .{ .durations = .{ .confusion = 1 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.confusion(
+        .{ .durations = .{ .confusion = 0 } },
+        .{ .durations = .{ .confusion = 2 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 0 } },
+        .{ .durations = .{ .confusion = 2 } },
+        1,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 5 }, Rolls.confusion(
+        .{ .durations = .{ .confusion = 5 } },
+        .{ .durations = .{ .confusion = 4 } },
+        0,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.confusion(
+        .{ .durations = .{ .confusion = 0 } },
+        .{ .durations = .{ .confusion = 5 } },
+        0,
+    ));
 }
 
 test "Rolls.attacking" {
-    try expectEqualSlices(u3, &.{0}, Rolls.attacking(.{
-        .durations = .{ .attacking = 0 },
-    }, FIXME, .false));
-    try expectEqualSlices(u3, &.{0}, Rolls.attacking(.{
-        .durations = .{ .attacking = 3 },
-    }, FIXME, .false));
-    try expectEqualSlices(u3, &.{0}, Rolls.attacking(.{
-        .durations = .{ .attacking = 2 },
-    }, FIXME, .true));
-    try expectEqualSlices(u3, &.{1}, Rolls.attacking(.{
-        .durations = .{ .attacking = 1 },
-    }, FIXME, .false));
-    try expectEqualSlices(u3, &.{ 0, 2 }, Rolls.attacking(.{
-        .durations = .{ .attacking = 2 },
-    }, FIXME, .false));
+    try expectEqualSlices(u3, &.{0}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 0 } },
+        .{ .durations = .{ .attacking = 0 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 1 } },
+        .{ .durations = .{ .attacking = 0 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 0 } },
+        .{ .durations = .{ .attacking = 1 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 1 } },
+        .{ .durations = .{ .attacking = 1 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.attacking(
+        .{ .durations = .{ .attacking = 0 } },
+        .{ .durations = .{ .attacking = 2 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 0 } },
+        .{ .durations = .{ .attacking = 2 } },
+        .true,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.attacking(
+        .{ .durations = .{ .attacking = 3 } },
+        .{ .durations = .{ .attacking = 2 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.attacking(
+        .{ .durations = .{ .attacking = 0 } },
+        .{ .durations = .{ .attacking = 3 } },
+        .false,
+    ));
 }
 
 test "Rolls.binding" {
-    try expectEqualSlices(u3, &.{0}, Rolls.binding(.{
-        .durations = .{ .binding = 0 },
-    }, FIXME, .false));
-    try expectEqualSlices(u3, &.{0}, Rolls.binding(.{
-        .durations = .{ .binding = 4 },
-    }, FIXME, .false));
-    try expectEqualSlices(u3, &.{0}, Rolls.binding(.{
-        .durations = .{ .binding = 2 },
-    }, FIXME, .true));
-    try expectEqualSlices(u3, &.{ 0, 2 }, Rolls.binding(.{
-        .durations = .{ .binding = 2 },
-    }, FIXME, .false));
+    try expectEqualSlices(u3, &.{0}, Rolls.binding(
+        .{ .durations = .{ .binding = 0 } },
+        .{ .durations = .{ .binding = 0 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 1 }, Rolls.binding(
+        .{ .durations = .{ .binding = 1 } },
+        .{ .durations = .{ .binding = 0 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 2 }, Rolls.binding(
+        .{ .durations = .{ .binding = 0 } },
+        .{ .durations = .{ .binding = 1 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{1}, Rolls.binding(
+        .{ .durations = .{ .binding = 1 } },
+        .{ .durations = .{ .binding = 1 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 3 }, Rolls.binding(
+        .{ .durations = .{ .binding = 0 } },
+        .{ .durations = .{ .binding = 2 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.binding(
+        .{ .durations = .{ .binding = 0 } },
+        .{ .durations = .{ .binding = 2 } },
+        .true,
+    ));
+    try expectEqualSlices(u3, &.{ 0, 4 }, Rolls.binding(
+        .{ .durations = .{ .binding = 4 } },
+        .{ .durations = .{ .binding = 3 } },
+        .false,
+    ));
+    try expectEqualSlices(u3, &.{0}, Rolls.binding(
+        .{ .durations = .{ .binding = 0 } },
+        .{ .durations = .{ .binding = 4 } },
+        .false,
+    ));
 }
 
 test "Rolls.moveSlot" {
-    const actions = Actions{ .p2 = .{ .move_slot = 3 } };
+    const actions: Actions = .{ .p2 = .{ .move_slot = 3 } };
     try expectEqualSlices(u4, &.{0}, Rolls.moveSlot(actions.p1, .None));
     try expectEqualSlices(u4, &.{ 1, 2, 3, 4 }, Rolls.moveSlot(actions.p2, .None));
     try expectEqualSlices(u4, &.{0}, Rolls.moveSlot(actions.p2, .false));
 }
 
 test "Rolls.multiHit" {
-    const actions = Actions{ .p2 = .{ .multi_hit = 3 } };
+    const actions: Actions = .{ .p2 = .{ .multi_hit = 3 } };
     try expectEqualSlices(u4, &.{0}, Rolls.multiHit(actions.p1, .None));
     try expectEqualSlices(u4, &.{ 2, 3, 4, 5 }, Rolls.multiHit(actions.p2, .None));
     try expectEqualSlices(u4, &.{0}, Rolls.multiHit(actions.p2, .false));
 }
 
 test "Rolls.metronome" {
-    const actions = Actions{ .p2 = .{ .metronome = .Surf } };
+    const actions: Actions = .{ .p2 = .{ .metronome = .Surf } };
     try expectEqualSlices(Move, &.{.None}, Rolls.metronome(actions.p1));
     try expectEqual(@as(Move, @enumFromInt(24)), Rolls.metronome(actions.p2)[23]);
 }
 
 test "Rolls.psywave" {
-    const actions = Actions{ .p2 = .{ .psywave = 79 } };
+    const actions: Actions = .{ .p2 = .{ .psywave = 79 } };
     var side = Side.init(&[_]Pokemon{.{
         .species = .Bulbasaur,
         .level = 100,