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

package/src/lib/gen2/chance.zig

@@ -14,7 +14,7 @@ const util = @import("../common/util.zig");
 const Player = @import("../common/data.zig").Player;
 const Optional = @import("../common/optional.zig").Optional;
 
-const data = @import("./data.zig");
+const data = @import("data.zig");
 
 const enabled = options.chance;
 const showdown = options.showdown;
@@ -48,6 +48,11 @@ pub const Actions = extern struct {
         self.p2.reset();
     }
 
+    /// TODO
+    pub fn durations(self: Actions) Durations {
+        return .{ .p1 = self.p1.durations(), .p2 = self.p2.durations() };
+    }
+
     /// Returns true if `a` is equal to `b`.
     pub fn eql(a: Actions, b: Actions) bool {
         return @as(u128, @bitCast(a.p1)) == @as(u128, @bitCast(b.p1)) and
@@ -64,15 +69,17 @@ pub const Actions = extern struct {
                 const b_val = @field(@field(b, player.name), field.name);
 
                 switch (@typeInfo(@TypeOf(a_val))) {
-                    .Struct => inline for (@typeInfo(@TypeOf(a_val)).Struct.fields) |f| {
-                        const a_val_f = @field(a_val, f.name);
-                        const b_val_f = @field(b_val, f.name);
-                        switch (@typeInfo(@TypeOf(a_val_f))) {
-                            .Int => if ((a_val_f > 0) != (b_val_f > 0)) return false,
-                            .Bool => if (a_val_f != b_val_f) return false,
-                            else => unreachable,
-                        }
-                    },
+                    // TODO: ziglang/zig#19730
+                    // .Struct => inline for (@typeInfo(@TypeOf(a_val)).Struct.fields) |f| {
+                    //     const a_val_f = @field(a_val, f.name);
+                    //     const b_val_f = @field(b_val, f.name);
+                    //     switch (@typeInfo(@TypeOf(a_val_f))) {
+                    //         .Int => if ((a_val_f > 0) != (b_val_f > 0)) return false,
+                    //         .Bool => if (a_val_f != b_val_f) return false,
+                    //         else => unreachable,
+                    //     }
+                    // },
+                    .Bool => if (a_val != b_val) return false, // TODO
                     .Enum => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
                         return false,
                     .Int => if ((a_val > 0) != (b_val > 0)) return false,
@@ -97,16 +104,17 @@ pub const Actions = extern struct {
     }
 };
 
+// TODO: ziglang/zig#19730
 test Actions {
     const a: Actions = .{ .p1 = .{ .hit = .true, .critical_hit = .false, .damage = 245 } };
     const b: Actions = .{ .p1 = .{ .hit = .false, .critical_hit = .true, .damage = 246 } };
     const c: Actions = .{ .p1 = .{ .hit = .true } };
-    const d: Actions = .{ .p2 = .{ .hit = .true, .durations = .{ .sleep = 2 } } };
-    const e: Actions = .{ .p2 = .{ .hit = .false, .durations = .{ .sleep = 4 } } };
-    const f: Actions = .{ .p1 = .{ .hit = .false, .durations = .{ .sleep = 4 } } };
-    const g: Actions = .{ .p1 = .{ .hit = .false, .durations = .{ .confusion = 1 } } };
+    const d: Actions = .{ .p2 = .{ .hit = .true, .durations_sleep = 2 } };
+    const e: Actions = .{ .p2 = .{ .hit = .false, .durations_sleep = 4 } };
+    const f: Actions = .{ .p1 = .{ .hit = .false, .durations_sleep = 4 } };
+    const g: Actions = .{ .p1 = .{ .hit = .false, .durations_confusion = 1 } };
     const h: Actions =
-        .{ .p1 = .{ .hit = .false, .durations = .{ .confusion = 1, .thrash = true } } };
+        .{ .p1 = .{ .hit = .false, .durations_confusion = 1, .durations_thrash = true } };
 
     try expect(a.eql(a));
     try expect(!a.eql(b));
@@ -188,10 +196,26 @@ pub const Action = packed struct(u128) {
     /// If not None, the Move to return for Rolls.metronome.
     metronome: Move = .None,
 
-    _: u16 = 0,
+    _: u28 = 0,
+
+    // TODO: ziglang/zig#19730
+    /// Observed values of various durations_ Does not influence future RNG calls. TODO
+    // durations: Duration = .{},
 
-    /// Observed values of various durations. Does not influence future RNG calls. TODO
-    durations: Duration = .{},
+    /// The number of turns a Pokémon has been observed to be sleeping.
+    durations_sleep: u3 = 0,
+    /// The number of turns a Pokémon has been observed to be confused.
+    durations_confusion: u3 = 0,
+    /// TODO
+    durations_thrash: bool = false,
+    /// The number of turns a Pokémon has been observed to be disabled.
+    durations_disable: u4 = 0,
+    /// The number of turns a Pokémon has been observed to be attacking.
+    durations_attacking: u3 = 0,
+    /// The number of turns a Pokémon has been observed to be binding their opponent.
+    durations_binding: u3 = 0,
+    /// The number of turns a Pokémon has been observed to be encored.
+    durations_encore: u3 = 0,
 
     pub const DURATIONS: u128 = 0xFFFFFFFF00000000_0000000000000000;
 
@@ -202,6 +226,19 @@ pub const Action = packed struct(u128) {
         self.* = @bitCast(@as(u128, @bitCast(self.*)) & DURATIONS);
     }
 
+    // TODO: ziglang/zig#19730
+    pub fn durations(self: Action) Duration {
+        return .{
+            .sleep = self.durations_sleep,
+            .confusion = self.durations_confusion,
+            .thrash = self.durations_thrash,
+            .disable = self.durations_disable,
+            .attacking = self.durations_attacking,
+            .binding = self.durations_binding,
+            .encore = self.durations_encore,
+        };
+    }
+
     pub fn format(a: Action, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
         _ = .{ f, o };
         try fmt(a, w, false);
@@ -213,18 +250,19 @@ pub const Action = packed struct(u128) {
         inline for (@typeInfo(Action).Struct.fields) |field| {
             const val = @field(self, field.name);
             switch (@typeInfo(@TypeOf(val))) {
-                .Struct => inline for (@typeInfo(@TypeOf(val)).Struct.fields) |f| {
-                    const v = @field(val, f.name);
-                    if (v != 0) {
-                        if (printed) try writer.writeAll(", ");
-                        if (shape) {
-                            try writer.print("{s}:?", .{f.name});
-                        } else {
-                            try writer.print("{s}:{d}", .{ f.name, v });
-                        }
-                        printed = true;
-                    }
-                },
+                // TODO: ziglang/zig#19730
+                // .Struct => inline for (@typeInfo(@TypeOf(val)).Struct.fields) |f| {
+                //     const v = @field(val, f.name);
+                //     if (v != 0) {
+                //         if (printed) try writer.writeAll(", ");
+                //         if (shape) {
+                //             try writer.print("{s}:?", .{f.name});
+                //         } else {
+                //             try writer.print("{s}:{d}", .{ f.name, v });
+                //         }
+                //         printed = true;
+                //     }
+                // },
                 .Enum => if (val != .None) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
@@ -256,12 +294,24 @@ pub const Action = packed struct(u128) {
 };
 
 test Action {
-    var a: Action = .{ .hit = .true, .durations = .{ .sleep = 3 }, .damage = 225 };
+    var a: Action = .{ .hit = .true, .durations_sleep = 3, .damage = 225 };
     a.reset();
 
-    try expectEqual(Action{ .hit = .None, .durations = .{ .sleep = 3 }, .damage = 0 }, a);
+    try expectEqual(Action{ .hit = .None, .durations_sleep = 3, .damage = 0 }, a);
 }
 
+/// TODO
+pub const Durations = extern struct {
+    /// Information about the durations for Player 1.
+    p1: Duration = .{},
+    /// Information about the durations for Player 2.
+    p2: Duration = .{},
+
+    comptime {
+        assert(@sizeOf(Durations) == 4);
+    }
+};
+
 /// Observed values for various durations that need to be tracked in order to properly
 /// deduplicate transitions with a primary key. TODO
 pub const Duration = packed struct(u32) {
@@ -323,11 +373,19 @@ pub fn Chance(comptime Rational: type) type {
 
             var action = self.actions.get(player);
 
-            const slp = action.durations.sleep;
-            action.durations = .{};
+            const slp = action.durations_sleep;
+            // TODO: ziglang/zig#19730
+            // action.durations = .{};
+            action.durations_sleep = 0;
+            action.durations_confusion = 0;
+            action.durations_thrash = false;
+            action.durations_disable = 0;
+            action.durations_attacking = 0;
+            action.durations_binding = 0;
+            action.durations_encore = 0;
 
             self.sleeps[@intFromEnum(player)][out - 1] = slp;
-            action.durations.sleep = @intCast(self.sleeps[@intFromEnum(player)][in - 1]);
+            action.durations_sleep = @intCast(self.sleeps[@intFromEnum(player)][in - 1]);
         }
 
         pub fn speedTie(self: *Self, p1: bool) Error!void {
@@ -526,95 +584,127 @@ pub fn Chance(comptime Rational: type) type {
         ) void {
             if (!enabled) return;
 
-            var durations = &self.actions.get(target).durations;
-            assert(@field(durations, @tagName(field)) == 0 or
-                (field == .confusion and player == target));
-            @field(durations, @tagName(field)) = 1;
-            if (field == .confusion) durations.thrash = player == target;
+            // TODO: ziglang/zig#19730
+            // var durations = &self.actions.get(target).durations;
+            // assert(@field(durations, @tagName(field)) == 0 or
+            //     (field == .confusion and player == target));
+            // @field(durations, @tagName(field)) = 1;
+            // if (field == .confusion) durations_thrash = player == target;
+            switch (field) {
+                .sleep => {
+                    assert(self.actions.get(target).durations_sleep == 0);
+                    self.actions.get(target).durations_sleep = 1;
+                },
+                .confusion => {
+                    assert(self.actions.get(target).durations_confusion == 0 or
+                        player == target);
+                    self.actions.get(target).durations_thrash = player == target;
+                    self.actions.get(target).durations_confusion = 1;
+                },
+                .thrash => unreachable,
+                .disable => {
+                    assert(self.actions.get(target).durations_disable == 0);
+                    self.actions.get(target).durations_disable = 1;
+                },
+                .attacking => {
+                    assert(self.actions.get(target).durations_attacking == 0);
+                    self.actions.get(target).durations_attacking = 1;
+                },
+                .binding => {
+                    assert(self.actions.get(target).durations_binding == 0);
+                    self.actions.get(target).durations_binding = 1;
+                },
+                .encore => {
+                    assert(self.actions.get(target).durations_encore == 0);
+                    self.actions.get(target).durations_encore = 1;
+                },
+                ._ => unreachable,
+            }
+
             self.actions.get(player).duration = if (options.key) 1 else turns;
         }
 
         pub fn sleep(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
-            var durations = &self.actions.get(player).durations;
-            const n = durations.sleep;
+            const durations_sleep = &self.actions.get(player).durations_sleep;
+            const n = durations_sleep.*;
             if (turns == 0) {
                 assert(n >= 1 and n <= 6);
                 if (n != 6) try self.probability.update(1, 7 - @as(u4, n));
-                durations.sleep = 0;
+                durations_sleep.* = 0;
             } else {
                 assert(n >= 1 and n < 6);
                 try self.probability.update(7 - @as(u4, n) - 1, 7 - @as(u4, n));
-                durations.sleep += 1;
+                durations_sleep.* += 1;
             }
         }
 
         pub fn confusion(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
-            var durations = &self.actions.get(player).durations;
-            const n = durations.confusion;
-            const hi: u8 = if (durations.thrash) 3 else 5;
+            const durations_confusion = &self.actions.get(player).durations_confusion;
+            const n = durations_confusion.*;
+            const hi: u8 = if (self.actions.get(player).durations_thrash) 3 else 5;
             const p = hi + 1;
             if (turns == 0) {
                 assert(n >= 2 and n <= hi);
                 if (n != hi) try self.probability.update(1, p - @as(u4, n));
-                durations.confusion = 0;
+                durations_confusion.* = 0;
             } else {
                 assert(n >= 1 and n < hi);
                 if (n > 1) try self.probability.update(p - @as(u4, n) - 1, p - @as(u4, n));
-                durations.confusion += 1;
+                durations_confusion.* += 1;
             }
         }
 
         pub fn disable(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
-            var durations = &self.actions.get(player).durations;
-            const n = durations.disable;
+            const durations_disable = &self.actions.get(player).durations_disable;
+            const n = durations_disable.*;
             const hi = if (showdown) 5 else 8;
             const p = hi + 1;
             if (turns == 0) {
                 assert(n >= 2 and n <= hi);
                 if (n != hi) try self.probability.update(1, p - n);
-                durations.disable = 0;
+                durations_disable.* = 0;
             } else {
                 assert(n >= 1 and n < hi);
                 if (n > 1) try self.probability.update(p - n - 1, p - n);
-                durations.disable += 1;
+                durations_disable.* += 1;
             }
         }
 
         pub fn attacking(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
-            var durations = &self.actions.get(player).durations;
-            const n = durations.attacking;
+            const durations_attacking = &self.actions.get(player).durations_attacking;
+            const n = durations_attacking.*;
             if (turns == 0) {
                 assert(n >= 2 and n <= 3);
                 if (n != 3) try self.probability.update(1, 4 - @as(u4, n));
-                durations.attacking = 0;
+                durations_attacking.* = 0;
             } else {
                 assert(n >= 1 and n < 3);
                 if (n > 1) try self.probability.update(4 - @as(u4, n) - 1, 4 - @as(u4, n));
-                durations.attacking += 1;
+                durations_attacking.* += 1;
             }
         }
 
         pub fn binding(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
-            var durations = &self.actions.get(player).durations;
-            const n = durations.binding;
+            const durations_binding = &self.actions.get(player).durations_binding;
+            const n = durations_binding.*;
             if (turns == 0) {
                 assert(n >= 2 and n <= 5);
                 if (n != 5) try self.probability.update(1, 6 - @as(u4, n));
-                durations.binding = 0;
+                durations_binding.* = 0;
             } else {
                 assert(n >= 1 and n < 5);
                 if (n > 1) try self.probability.update(6 - @as(u4, n) - 1, 6 - @as(u4, n));
-                durations.binding += 1;
+                durations_binding.* += 1;
             }
         }
 
@@ -622,16 +712,16 @@ pub fn Chance(comptime Rational: type) type {
         pub fn encore(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
-            var durations = &self.actions.get(player).durations;
-            const n = durations.encore;
+            const durations_encore = &self.actions.get(player).durations_encore;
+            const n = durations_encore.*;
             if (turns == 0) {
                 assert(n >= 2 and n <= 5);
                 if (n != 5) try self.probability.update(1, 6 - @as(u4, n));
-                durations.encore = 0;
+                durations_encore.* = 0;
             } else {
                 assert(n >= 1 and n < 5);
                 if (n > 1) try self.probability.update(6 - @as(u4, n) - 1, 6 - @as(u4, n));
-                durations.encore += 1;
+                durations_encore.* += 1;
             }
         }
     };
@@ -699,7 +789,7 @@ test "Chance.damage" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     try chance.damage(.P1, 217);
-    try expectValue(@as(u8, 217), chance.actions.p1.damage);
+    try expectValue(217, chance.actions.p1.damage);
     try expectProbability(&chance.probability, 1, 39);
 }
 
@@ -824,7 +914,7 @@ test "Chance.present" {
     } else {
         try expectProbability(&chance.probability, 25, 256);
     }
-    try expectValue(@as(u3, 4), chance.actions.p2.present);
+    try expectValue(4, chance.actions.p2.present);
 
     chance.reset();
 
@@ -834,7 +924,7 @@ test "Chance.present" {
     } else {
         try expectProbability(&chance.probability, 51, 256);
     }
-    try expectValue(@as(u3, 1), chance.actions.p1.present);
+    try expectValue(1, chance.actions.p1.present);
 }
 
 test "Chance.magnitude" {
@@ -846,7 +936,7 @@ test "Chance.magnitude" {
     } else {
         try expectProbability(&chance.probability, 13, 256);
     }
-    try expectValue(@as(u3, 7), chance.actions.p2.magnitude);
+    try expectValue(7, chance.actions.p2.magnitude);
 
     chance.reset();
 
@@ -856,7 +946,7 @@ test "Chance.magnitude" {
     } else {
         try expectProbability(&chance.probability, 51, 256);
     }
-    try expectValue(@as(u3, 5), chance.actions.p1.magnitude);
+    try expectValue(5, chance.actions.p1.magnitude);
 }
 
 test "Chance.tripleKick" {
@@ -864,7 +954,7 @@ test "Chance.tripleKick" {
 
     try chance.tripleKick(.P1, 2);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(@as(u2, 2), chance.actions.p1.triple_kick);
+    try expectValue(2, chance.actions.p1.triple_kick);
 }
 
 test "Chance.spite" {
@@ -872,7 +962,7 @@ test "Chance.spite" {
 
     try chance.spite(.P1, 3);
     try expectProbability(&chance.probability, 1, 4);
-    try expectValue(@as(u3, 3), chance.actions.p1.spite);
+    try expectValue(3, chance.actions.p1.spite);
 }
 
 test "Chance.conversion2" {
@@ -899,7 +989,7 @@ test "Chance.psywave" {
 
     try chance.psywave(.P2, 100, 150);
     try expectProbability(&chance.probability, 1, 150);
-    try expectValue(@as(u8, 100), chance.actions.p2.psywave);
+    try expectValue(100, chance.actions.p2.psywave);
 }
 
 test "Chance.metronome" {
@@ -915,19 +1005,19 @@ test "Chance.moveSlot" {
 
     try chance.moveSlot(.P2, 2, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(@as(u4, 2), chance.actions.p2.move_slot);
+    try expectValue(2, chance.actions.p2.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 1, 3);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(@as(u4, 1), chance.actions.p1.move_slot);
+    try expectValue(1, chance.actions.p1.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 4, 1);
     try expectProbability(&chance.probability, 1, 1);
-    try expectValue(@as(u4, 4), chance.actions.p1.move_slot);
+    try expectValue(4, chance.actions.p1.move_slot);
 }
 
 test "Chance.forceSwitch" {
@@ -935,19 +1025,19 @@ test "Chance.forceSwitch" {
 
     try chance.forceSwitch(.P2, 2, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(@as(u4, 2), chance.actions.p2.force_switch);
+    try expectValue(2, chance.actions.p2.force_switch);
 
     chance.reset();
 
     try chance.forceSwitch(.P1, 1, 3);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(@as(u4, 1), chance.actions.p1.force_switch);
+    try expectValue(1, chance.actions.p1.force_switch);
 
     chance.reset();
 
     try chance.forceSwitch(.P1, 4, 1);
     try expectProbability(&chance.probability, 1, 1);
-    try expectValue(@as(u4, 4), chance.actions.p1.force_switch);
+    try expectValue(4, chance.actions.p1.force_switch);
 }
 
 test "Chance.multiHit" {
@@ -955,39 +1045,39 @@ test "Chance.multiHit" {
 
     try chance.multiHit(.P1, 3);
     try expectProbability(&chance.probability, 3, 8);
-    try expectValue(@as(u4, 3), chance.actions.p1.multi_hit);
+    try expectValue(3, chance.actions.p1.multi_hit);
 
     chance.reset();
 
     try chance.multiHit(.P2, 5);
     try expectProbability(&chance.probability, 1, 8);
-    try expectValue(@as(u4, 5), chance.actions.p2.multi_hit);
+    try expectValue(5, chance.actions.p2.multi_hit);
 }
 
 test "Chance.duration" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     chance.duration(.sleep, .P1, .P2, 2);
-    try expectValue(@as(u4, 2), chance.actions.p1.duration);
-    try expectValue(@as(u3, 1), chance.actions.p2.durations.sleep);
+    try expectValue(2, chance.actions.p1.duration);
+    try expectValue(1, chance.actions.p2.durations_sleep);
 }
 
 test "Chance.sleep" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     for ([_]u8{ 6, 5, 4, 3, 2, 1 }, 1..7) |d, i| {
-        chance.actions.p1.durations.sleep = @intCast(i);
+        chance.actions.p1.durations_sleep = @intCast(i);
         try chance.sleep(.P1, 0);
         try expectProbability(&chance.probability, 1, d);
-        try expectValue(@as(u3, 0), chance.actions.p1.durations.sleep);
+        try expectValue(0, chance.actions.p1.durations_sleep);
 
         chance.reset();
 
         if (i < 6) {
-            chance.actions.p1.durations.sleep = @intCast(i);
+            chance.actions.p1.durations_sleep = @intCast(i);
             try chance.sleep(.P1, 1);
             try expectProbability(&chance.probability, d - 1, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p1.durations.sleep);
+            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p1.durations_sleep);
 
             chance.reset();
         }
@@ -997,24 +1087,24 @@ test "Chance.sleep" {
 test "Chance.confusion" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
-    chance.actions.p2.durations.thrash = false;
+    chance.actions.p2.durations_thrash = false;
     for ([_]u8{ 1, 4, 3, 2, 1 }, 1..6) |d, i| {
         if (i > 1) {
-            chance.actions.p2.durations.confusion = @intCast(i);
+            chance.actions.p2.durations_confusion = @intCast(i);
             try chance.confusion(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.confusion);
-            try expectValue(false, chance.actions.p2.durations.thrash);
+            try expectValue(0, chance.actions.p2.durations_confusion);
+            try expectValue(false, chance.actions.p2.durations_thrash);
 
             chance.reset();
         }
 
         if (i < 5) {
-            chance.actions.p2.durations.confusion = @intCast(i);
+            chance.actions.p2.durations_confusion = @intCast(i);
             try chance.confusion(.P2, 1);
             try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations.confusion);
-            try expectValue(false, chance.actions.p2.durations.thrash);
+            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations_confusion);
+            try expectValue(false, chance.actions.p2.durations_thrash);
 
             chance.reset();
         }
@@ -1022,24 +1112,24 @@ test "Chance.confusion" {
 
     chance.reset();
 
-    chance.actions.p2.durations.thrash = true;
+    chance.actions.p2.durations_thrash = true;
     for ([_]u8{ 1, 2, 1 }, 1..4) |d, i| {
         if (i > 1) {
-            chance.actions.p2.durations.confusion = @intCast(i);
+            chance.actions.p2.durations_confusion = @intCast(i);
             try chance.confusion(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.confusion);
-            try expectValue(true, chance.actions.p2.durations.thrash);
+            try expectValue(0, chance.actions.p2.durations_confusion);
+            try expectValue(true, chance.actions.p2.durations_thrash);
 
             chance.reset();
         }
 
         if (i < 3) {
-            chance.actions.p2.durations.confusion = @intCast(i);
+            chance.actions.p2.durations_confusion = @intCast(i);
             try chance.confusion(.P2, 1);
             try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations.confusion);
-            try expectValue(true, chance.actions.p2.durations.thrash);
+            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations_confusion);
+            try expectValue(true, chance.actions.p2.durations_thrash);
 
             chance.reset();
         }
@@ -1051,19 +1141,19 @@ test "Chance.disable" {
     if (showdown) {
         for ([_]u8{ 1, 4, 3, 2, 1 }, 1..6) |d, i| {
             if (i > 1) {
-                chance.actions.p2.durations.disable = @intCast(i);
+                chance.actions.p2.durations_disable = @intCast(i);
                 try chance.disable(.P2, 0);
                 try expectProbability(&chance.probability, 1, d);
-                try expectValue(@as(u4, 0), chance.actions.p2.durations.disable);
+                try expectValue(0, chance.actions.p2.durations_disable);
 
                 chance.reset();
             }
 
             if (i < 5) {
-                chance.actions.p2.durations.disable = @intCast(i);
+                chance.actions.p2.durations_disable = @intCast(i);
                 try chance.disable(.P2, 1);
                 try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-                try expectValue(@as(u4, @intCast(i)) + 1, chance.actions.p2.durations.disable);
+                try expectValue(@as(u4, @intCast(i)) + 1, chance.actions.p2.durations_disable);
 
                 chance.reset();
             }
@@ -1071,19 +1161,19 @@ test "Chance.disable" {
     } else {
         for ([_]u8{ 1, 7, 6, 5, 4, 3, 2, 1 }, 1..9) |d, i| {
             if (i > 1) {
-                chance.actions.p2.durations.disable = @intCast(i);
+                chance.actions.p2.durations_disable = @intCast(i);
                 try chance.disable(.P2, 0);
                 try expectProbability(&chance.probability, 1, d);
-                try expectValue(@as(u4, 0), chance.actions.p2.durations.disable);
+                try expectValue(0, chance.actions.p2.durations_disable);
 
                 chance.reset();
             }
 
             if (i < 8) {
-                chance.actions.p2.durations.disable = @intCast(i);
+                chance.actions.p2.durations_disable = @intCast(i);
                 try chance.disable(.P2, 1);
                 try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-                try expectValue(@as(u4, @intCast(i)) + 1, chance.actions.p2.durations.disable);
+                try expectValue(@as(u4, @intCast(i)) + 1, chance.actions.p2.durations_disable);
 
                 chance.reset();
             }
@@ -1096,19 +1186,19 @@ test "Chance.attacking" {
 
     for ([_]u8{ 1, 2, 1 }, 1..4) |d, i| {
         if (i > 1) {
-            chance.actions.p2.durations.attacking = @intCast(i);
+            chance.actions.p2.durations_attacking = @intCast(i);
             try chance.attacking(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.attacking);
+            try expectValue(0, chance.actions.p2.durations_attacking);
 
             chance.reset();
         }
 
         if (i < 3) {
-            chance.actions.p2.durations.attacking = @intCast(i);
+            chance.actions.p2.durations_attacking = @intCast(i);
             try chance.attacking(.P2, 1);
             try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations.attacking);
+            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations_attacking);
 
             chance.reset();
         }
@@ -1120,19 +1210,19 @@ test "Chance.binding" {
 
     for ([_]u8{ 1, 4, 3, 2, 1 }, 1..6) |d, i| {
         if (i > 1) {
-            chance.actions.p2.durations.binding = @intCast(i);
+            chance.actions.p2.durations_binding = @intCast(i);
             try chance.binding(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.binding);
+            try expectValue(0, chance.actions.p2.durations_binding);
 
             chance.reset();
         }
 
         if (i < 5) {
-            chance.actions.p2.durations.binding = @intCast(i);
+            chance.actions.p2.durations_binding = @intCast(i);
             try chance.binding(.P2, 1);
             try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations.binding);
+            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations_binding);
 
             chance.reset();
         }
@@ -1144,19 +1234,19 @@ test "Chance.encore" {
 
     for ([_]u8{ 1, 4, 3, 2, 1 }, 1..6) |d, i| {
         if (i > 1) {
-            chance.actions.p2.durations.encore = @intCast(i);
+            chance.actions.p2.durations_encore = @intCast(i);
             try chance.encore(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.encore);
+            try expectValue(0, chance.actions.p2.durations_encore);
 
             chance.reset();
         }
 
         if (i < 5) {
-            chance.actions.p2.durations.encore = @intCast(i);
+            chance.actions.p2.durations_encore = @intCast(i);
             try chance.encore(.P2, 1);
             try expectProbability(&chance.probability, if (d > 1) d - 1 else d, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations.encore);
+            try expectValue(@as(u3, @intCast(i)) + 1, chance.actions.p2.durations_encore);
 
             chance.reset();
         }