@pkmn/engine 0.1.0-dev.21a51fe4 → 0.1.0-dev.21e728d9

package/src/lib/common/rational.zig

@@ -44,7 +44,7 @@ pub fn Rational(comptime T: type) type {
         /// 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 });
             assert(p >= 1);
             assert(q >= 1);
 
@@ -185,12 +185,12 @@ 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);
@@ -203,7 +203,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);
 
@@ -275,7 +275,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.

package/src/lib/common/rng.zig

@@ -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();
+        }
     };
 }
 
@@ -64,7 +69,7 @@ pub const PSRNG = extern struct {
 };
 
 test PSRNG {
-    var psrng = PSRNG{ .src = .{ .seed = 0x0001000200030004 } };
+    var psrng: PSRNG = .{ .src = .{ .seed = 0x0001000200030004 } };
     try expectEqual(@as(u8, 121), psrng.range(u8, 0, 256));
     try expectEqual(false, psrng.chance(u8, 128, 256)); // 226 < 128
 }
@@ -79,7 +84,7 @@ pub const Gen12 = extern struct {
         assert(@sizeOf(Gen12) == 10);
     }
 
-    pub fn percent(p: u8) u8 {
+    pub fn percent(comptime p: comptime_int) u8 {
         return @intCast((@as(u16, p) * 0xFF) / 100);
     }
 
@@ -89,11 +94,15 @@ 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());
     }
@@ -129,7 +138,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 +170,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);
     }
@@ -213,7 +222,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());
     }

package/src/lib/gen1/README.md

@@ -6,7 +6,9 @@ document](../../../docs/DESIGN.md). The Generation I engine is implemented and t
 following files:
 
 - [`data.zig`](data.zig) ([`data`](data)): contains definitions of all of the data structures used
-  by the engine, described in detail [below](#data-structures)
+  to implement the core mechanics of the engine, described in detail [below](#data-structures)
+- [`chance.zig`](chance.zig): TODO
+- [`calc.zig`](calc.zig): TODO
 - [`helpers.zig`](helpers.zig): helpers used to construct complex data types with
   sensible defaults (internally used by tests and tools)
 - [`mechanics.zig`](mechanics.zig): code which manipulates the data structures to implement the
@@ -245,9 +247,17 @@ engine maintains a `Type.PRECEDENCE` table with just the match-ups that are rele
 pruned for efficiency) and only looks up precedence when necessary to minimize expensive searches.
 Pokémon Showdown doesn't implement type precedence.
 
+### `Chance` / `Actions` / `Action` / `Durations` / `Duration`
+
+TODO
+
+### `Calc` / `Overrides` / `Summaries` / `Summary`
+
+TODO
+
 ## Information
 
-The information of each field (in terms of [bits of
+The information of each field required for mechanics (in terms of [bits of
 entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory))) is as follows:
 
 | Data            | Range     | Bits |     | Data              | Range    | Bits |
@@ -383,7 +393,7 @@ data in the browser for ease of debugging.
 - `order` is a 6 byte array where `order[i]` represents the "slot" of `pokemon[i]`, where the slot
   is usually a unique value from 1 to 6 but can be 0 in situations where a player brings less than six
   Pokémon to battle (note however that if `order[i]` is 0 than for all j > 0 `order[i+j]` **must**
-  equal 0).
+  equal 0)
 
 ### `ActivePokemon`
 
@@ -417,34 +427,34 @@ data in the browser for ease of debugging.
 
 > **NOTE:** The offsets in the following table represent *bits* and **not** bytes.
 
-| Start | End | Data                | Description                                                 |
-| ----- | --- | ------------------- | ----------------------------------------------------------- |
-| 0     | 1   | `Bide`              | Whether the "Bide" volatile status is present               |
-| 1     | 2   | `Thrashing`         | Whether the "Thrashing" volatile status is present          |
-| 2     | 3   | `MultiHit`          | Whether the "MultiHit" volatile status is present           |
-| 3     | 4   | `Flinch`            | Whether the "Flinch" volatile status is present             |
-| 4     | 5   | `Charging`          | Whether the "Charging" volatile status is present           |
-| 5     | 6   | `Binding`           | Whether the "Binding" volatile status is present            |
-| 6     | 7   | `Invulnerable`      | Whether the "Invulnerable" volatile status is present       |
-| 7     | 8   | `Confusion`         | Whether the "Confusion" volatile status is present          |
-| 8     | 9   | `Mist`              | Whether the "Mist" volatile status is present               |
-| 9     | 10  | `FocusEnergy`       | Whether the "FocusEnergy" volatile status is present        |
-| 10    | 11  | `Substitute`        | Whether the "Substitute" volatile status is present         |
-| 11    | 12  | `Recharging`        | Whether the "Recharging" volatile status is present         |
-| 12    | 13  | `Rage`              | Whether the "Rage" volatile status is present               |
-| 13    | 14  | `LeechSeed`         | Whether the "LeechSeed" volatile status is present          |
-| 14    | 15  | `Toxic`             | Whether the "Toxic" volatile status is present              |
-| 15    | 16  | `LightScreen`       | Whether the "LightScreen" volatile status is present        |
-| 16    | 17  | `Reflect`           | Whether the "Reflect" volatile status is present            |
-| 17    | 18  | `Transform`         | Whether the "Transform" volatile status is present          |
-| 18    | 21  | `confusion`         | The remaining turns of confusion                            |
-| 21    | 24  | `attacks`           | The number of attacks remaining                             |
-| 24    | 40  | `state`             | A union of either: <ul><li>the total accumulated damage from Bide</li><li>the overwritten accuracy of certain moves</li></ul> |
-| 40    | 48  | `substitute`        | The remaining HP of the Substitute                          |
-| 48    | 52  | `transform`         | The identity of whom the active Pokémon is transformed into |
-| 52    | 56  | `disabled_duration` | The remaining turns the move is disabled                    |
-| 56    | 59  | `disabled_move`     | The move slot (1-4) that's disabled                        |
-| 59    | 64  | `toxic`             | The number of turns toxic damage has been accumulating      |
+| Start | End | Data               | Description                                                 |
+| ----- | --- | -------------------| ----------------------------------------------------------- |
+| 0     | 1   | `Bide`             | Whether the "Bide" volatile status is present               |
+| 1     | 2   | `Thrashing`        | Whether the "Thrashing" volatile status is present          |
+| 2     | 3   | `MultiHit`         | Whether the "MultiHit" volatile status is present           |
+| 3     | 4   | `Flinch`           | Whether the "Flinch" volatile status is present             |
+| 4     | 5   | `Charging`         | Whether the "Charging" volatile status is present           |
+| 5     | 6   | `Binding`          | Whether the "Binding" volatile status is present            |
+| 6     | 7   | `Invulnerable`     | Whether the "Invulnerable" volatile status is present       |
+| 7     | 8   | `Confusion`        | Whether the "Confusion" volatile status is present          |
+| 8     | 9   | `Mist`             | Whether the "Mist" volatile status is present               |
+| 9     | 10  | `FocusEnergy`      | Whether the "FocusEnergy" volatile status is present        |
+| 10    | 11  | `Substitute`       | Whether the "Substitute" volatile status is present         |
+| 11    | 12  | `Recharging`       | Whether the "Recharging" volatile status is present         |
+| 12    | 13  | `Rage`             | Whether the "Rage" volatile status is present               |
+| 13    | 14  | `LeechSeed`        | Whether the "LeechSeed" volatile status is present          |
+| 14    | 15  | `Toxic`            | Whether the "Toxic" volatile status is present              |
+| 15    | 16  | `LightScreen`      | Whether the "LightScreen" volatile status is present        |
+| 16    | 17  | `Reflect`          | Whether the "Reflect" volatile status is present            |
+| 17    | 18  | `Transform`        | Whether the "Transform" volatile status is present          |
+| 18    | 21  | `confusion`        | The remaining turns of confusion                            |
+| 21    | 24  | `attacks`          | The number of attacks remaining                             |
+| 24    | 40  | `state`            | A union of either: <ul><li>the total accumulated damage from Bide</li><li>the overwritten accuracy of certain moves</li></ul> |
+| 40    | 48  | `substitute`       | The remaining HP of the Substitute                          |
+| 48    | 52  | `transform`        | The identity of whom the active Pokémon is transformed into |
+| 52    | 56  | `disable_duration` | The remaining turns the move is disabled                    |
+| 56    | 59  | `disable_move`     | The move slot (1-4) that's disabled                         |
+| 59    | 64  | `toxic`            | The number of turns toxic damage has been accumulating      |
 
 ### `Pokemon`
 
@@ -469,6 +479,76 @@ data in the browser for ease of debugging.
 | 22    | 23  | `type1`/`type2` | The Pokémon's stored types                 |
 | 23    | 24  | `level`         | The Pokémon's level                        |
 
+
+### `Action`
+
+`Actions` consist of an `Action` for Player 1 followed by an `Action` for Player 2.
+
+> **NOTE:** The offsets in the following table represent *bits* and **not** bytes.
+
+| Start | End | Data                     | Description                                                                     |
+| ----- | --- | ------------------------ | ------------------------------------------------------------------------------- |
+| 0     | 8   | `damage`                 | The roll to be returned damage (217-255).                                       |
+| 8     | 10  | `hit`                    | The roll to be returned for accuracy (1 for miss, 2 for hit).                   |
+| 10    | 12  | `critical_hit`           | The roll to be returned for critical hits (1 for no, 2 for yes).                |
+| 12    | 14  | `secondary_chance`       | The roll to be returned for secondary chance rolls (1 for no-proc, 2 for proc). |
+| 14    | 16  | `speed_tie`              | The player to return for speed ties (1 for Player 1, 2 for Player 2).           |
+| 16    | 18  | `confused`               | The roll to be returned for confusion self-hits (1 for no-proc, 2 for proc).    |
+| 18    | 20  | `paralyzed`              | The roll to be returned for full paralysis (1 for no-proc, 2 for proc).         |
+| 20    | 24  | `duration`               | The roll to be returned for the duration (including for binding moves).         |
+| 24    | 40  | [`durations`](#duration) | Values of various durations.                                                    |
+| 40    | 44  | `move_slot`              | The roll to be returned for the move slot (1-4, invalid values ignored).        |
+| 44    | 48  | `move_slot`              | The roll to be returned for a multi-hit move distribution (2-5).                |
+| 48    | 56  | `psywave`                | One greater than the roll to be returned for Psywave damage.                    |
+| 56    | 64  | `metronome`              | The move to return for Metronome.                                               |
+
+- for any field a value of 0 is considered to be unset
+- **both Player 1 and Player 2 must set the same value for `speed_tie`.**
+- `duration` determines the roll for any effect which lasts over multiple turns, whereas `durations` can either be used to
+  track how long these effects have lasted (for the purposes of computing probablities with `-Dchance`) or can be used to
+  [override](#overrides) (extend or end) the duration of specfic effects with `-Dcalc`.
+
+#### `Duration`
+
+> **NOTE:** The offsets in the following table represent *bits* and **not** bytes.
+
+| Start | End | Data        |
+| ----- | --- | ----------- |
+| 0     | 3   | `sleep`     |
+| 3     | 6   | `confusion` |
+| 4     | 10  | `disable`   |
+| 10    | 13  | `attacking` |
+| 13    | 16  | `binding`   |
+
+- the meaning of each field depends on the context in which `Duration` appears:
+  - within `Chance` `actions`, the durations tracked refer to the number of turns a Pokémon has been
+    observed to be under an effect
+  - within `Overrides` `actions`, the durations refer to the value the next `Chance` `actions`
+    should be made to take on
+  - within `Overrides` `durations`, the durations serve as a mask to determine to whether or not the
+    durations in `Overrides` `actions` should be considered to be set or not
+◊
+### `Overrides`
+
+| Start | End | Data                        | Description                                                                           |
+| ----- | --- | --------------------------- | ------------------------------------------------------------------------------------- |
+| 0     | 8   | [`action.p1`](#action)      | Rolls to force Player 1's RNG to return for specific events.                          |
+| 8     | 16  | [`action.p2`](#action)      | Rolls to force Player 2's RNG to return for specific events.                          |
+| 16    | 18  | [`durations.p1`](#duration) | Whether or not to modify Player 1's effect durations to match `actions.p1.durations`. |
+| 18    | 20  | [`durations.p2`](#duration) | Whether or not to modify Player 2's effect durations to match `actions.p1.durations`. |
+| 20    | 24  | -                           | *Zero padding*                                                                        |
+
+### `Summaries`
+
+| Start | End | Data               | Description                                                                     |
+| ----- | --- | ------------------ | ------------------------------------------------------------------------------- |
+| 0     | 2   | `p1.damage.base`   | Player 1's base computed damage before the damage roll is applied.              |
+| 2     | 4   | `p1.damage.final`  | Player 1's final computed damage that gets applied to the Pokémon.              |
+| 4     | 6   | `p1.damage.capped` | Whether higher damage from Player 1 will saturate / result in the same outcome. |
+| 6     | 8   | `p2.damage.base`   | Player 2's base computed damage before the damage roll is applied.              |
+| 8     | 10  | `p2.damage.final`  | Player 2's final computed damage that gets applied to the Pokémon.              |
+| 10    | 12  | `p2.damage.capped` | Whether higher damage from Player 2 will saturate / result in the same outcome. |
+
 ## Bugs
 
 In addition to its alternative [RNG semantics](#rng), Pokémon Showdown's implementation of the first
@@ -532,7 +612,8 @@ engine, but the following moves have their broken behavior preserved in `-Dshowd
 - **Roar** / **Whirlwind**: these moves can miss on Pokémon Showdown (and advance the RNG when
   checking) which is incorrect (these moves should always fail, but don't check accuracy or advance
   the RNG). More importantly, these moves should *not* cause the tracked last battle damage to be
-  zeroed, but on Pokémon Showdown they do.
+  zeroed, but on Pokémon Showdown they do. These should also `|-fail|...|[still]` instead of doing
+  nothing.
 - **Substitute**: in addition to the [Substitute + Confusion
   glitch](https://pkmn.cc/bulba-glitch-1#Substitute_.2B_Confusion_glitch) not being implemented
   correctly (covered earlier), the [Substitute 1/4
@@ -554,6 +635,7 @@ only pedantic UI correctness):
 
 - **Rage**: Rage should report the `|-boost|` before the Disable `|-miss|`, not after.
 - **Haze**: Haze clears the status/volatiles in an incorrect order.
+- **Teleport**: Teleport should `|-fail|...|[still]` instead of doing nothing.
 - **Twineedle**: the `|-hitcount|` ("Hit 2 times") should come before the `|-status|` message, not
   after.
 - **Thrash** / **Petal Dance**: confusion should silently get applied before the `|move|` message,

package/src/lib/gen1/calc.zig

@@ -29,7 +29,6 @@ const Optional = optional.Optional;
 const Rational = rational.Rational;
 
 const PointerType = util.PointerType;
-const FieldType = util.FieldType;
 
 const Actions = chance.Actions;
 const Action = chance.Action;
@@ -51,7 +50,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;
     }
@@ -158,7 +157,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(
@@ -256,7 +255,7 @@ pub fn transitions(
 
         try debug(writer, template, true, .{ .color = i, .bold = true, .background = true });
 
-        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;
@@ -388,7 +387,7 @@ pub fn transitions(
     return stats;
 }
 
-inline fn matches(actions: Actions, i: usize, frontier: []Actions) bool {
+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;

package/src/lib/gen1/chance.zig

@@ -14,12 +14,14 @@ const util = @import("../common/util.zig");
 const Player = @import("../common/data.zig").Player;
 const Optional = @import("../common/optional.zig").Optional;
 
-const Move = @import("data.zig").Move;
-const MoveSlot = @import("data.zig").MoveSlot;
+const data = @import("./data.zig");
 
 const enabled = options.chance;
 const showdown = options.showdown;
 
+const Move = data.Move;
+const MoveSlot = data.MoveSlot;
+
 /// Actions taken by a hypothetical "chance player" that convey information about which RNG events
 /// were observed during a Generation I battle `update`. This can additionally be provided as input
 /// to the `update` call to override the normal behavior of the RNG in order to force specific
@@ -35,19 +37,19 @@ pub const Actions = extern struct {
     }
 
     /// Returns the `Action` for the given `player`.
-    pub inline fn get(self: anytype, player: Player) util.PointerType(@TypeOf(self), Action) {
+    pub fn get(self: anytype, player: Player) util.PointerType(@TypeOf(self), Action) {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == Actions);
         return if (player == .P1) &self.p1 else &self.p2;
     }
 
     /// Perform a reset by clearing fields which should not persist across updates.
-    pub inline fn reset(self: *Actions) void {
+    pub fn reset(self: *Actions) void {
         self.p1.reset();
         self.p2.reset();
     }
 
     /// Returns true if `a` is equal to `b`.
-    pub inline fn eql(a: Actions, b: Actions) bool {
+    pub fn eql(a: Actions, b: Actions) bool {
         return @as(u128, @bitCast(a)) == @as(u128, @bitCast(b));
     }
 
@@ -115,7 +117,7 @@ test Actions {
 
 /// Information about the RNG that was observed during a Generation I battle `update` for a
 /// single player.
-pub const Action = packed struct {
+pub const Action = packed struct(u64) {
     /// If not 0, the roll to be returned Rolls.damage.
     damage: u8 = 0,
 
@@ -126,7 +128,7 @@ pub const Action = packed struct {
     /// If not None, the value to be returned for
     /// Rolls.{confusionChance,secondaryChance,poisonChance}.
     secondary_chance: Optional(bool) = .None,
-    /// If not None, the Playr to be returned by Rolls.speedTie.
+    /// If not None, the Player to be returned by Rolls.speedTie.
     speed_tie: Optional(Player) = .None,
 
     /// If not None, the value to return for Rolls.confused.
@@ -156,12 +158,8 @@ pub const Action = packed struct {
 
     pub const Field = std.meta.FieldEnum(Action);
 
-    comptime {
-        assert(@sizeOf(Action) == 8);
-    }
-
     /// Perform a reset by clearing fields which should not persist across updates.
-    pub inline fn reset(self: *Action) void {
+    pub fn reset(self: *Action) void {
         self.* = @bitCast(@as(u64, @bitCast(self.*)) & DURATIONS);
     }
 
@@ -181,9 +179,9 @@ pub const Action = packed struct {
                     if (v != 0) {
                         if (printed) try writer.writeAll(", ");
                         if (shape) {
-                            try writer.print("{s}:?", .{field.name});
+                            try writer.print("{s}:?", .{f.name});
                         } else {
-                            try writer.print("{s}:{d}", .{ field.name, v });
+                            try writer.print("{s}:{d}", .{ f.name, v });
                         }
                         printed = true;
                     }
@@ -219,7 +217,7 @@ pub const Action = packed struct {
 };
 
 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);
@@ -239,7 +237,7 @@ pub const Durations = extern struct {
 
 /// 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 {
+pub const Duration = packed struct(u16) {
     /// The number of turns a Pokémon has been observed to be sleeping.
     sleep: u3 = 0,
     /// The number of turns a Pokémon has been observed to be confused.
@@ -252,10 +250,6 @@ pub const Duration = packed struct {
     binding: u3 = 0,
 
     pub const Field = std.meta.FieldEnum(Duration);
-
-    comptime {
-        assert(@sizeOf(Duration) == 2);
-    }
 };
 
 pub const Commit = enum { hit, miss, binding };
@@ -522,22 +516,6 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        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;
-            if (turns == 0) {
-                assert(n >= 1 and n <= 8);
-                if (n != 8) try self.probability.update(1, 9 - @as(u4, n));
-                durations.disable = 0;
-            } else {
-                assert(n >= 1 and n < 8);
-                try self.probability.update(9 - @as(u4, n) - 1, 9 - @as(u4, n));
-                durations.disable += 1;
-            }
-        }
-
         pub fn confusion(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
@@ -554,6 +532,22 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
+        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;
+            if (turns == 0) {
+                assert(n >= 1 and n <= 8);
+                if (n != 8) try self.probability.update(1, 9 - @as(u4, n));
+                durations.disable = 0;
+            } else {
+                assert(n >= 1 and n < 8);
+                try self.probability.update(9 - @as(u4, n) - 1, 9 - @as(u4, n));
+                durations.disable += 1;
+            }
+        }
+
         pub fn attacking(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
@@ -601,7 +595,7 @@ pub fn Chance(comptime Rational: type) type {
         pub fn metronome(self: *Self, player: Player, move: Move) Error!void {
             if (!enabled) return;
 
-            try self.probability.update(1, Move.size - 2);
+            try self.probability.update(1, Move.METRONOME.len);
             self.actions.get(player).metronome = move;
         }
     };
@@ -864,6 +858,28 @@ test "Chance.confusion" {
     }
 }
 
+test "Chance.disable" {
+    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
+
+    for ([_]u8{ 8, 7, 6, 5, 4, 3, 2, 1 }, 1..9) |d, i| {
+        chance.actions.p1.durations.disable = @intCast(i);
+        try chance.disable(.P1, 0);
+        try expectProbability(&chance.probability, 1, d);
+        try expectValue(@as(u4, 0), chance.actions.p1.durations.disable);
+
+        chance.reset();
+
+        if (i < 8) {
+            chance.actions.p1.durations.disable = @intCast(i);
+            try chance.disable(.P1, 1);
+            try expectProbability(&chance.probability, d - 1, d);
+            try expectValue(@as(u4, @intCast(i)) + 1, chance.actions.p1.durations.disable);
+
+            chance.reset();
+        }
+    }
+}
+
 test "Chance.attacking" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
@@ -947,7 +963,7 @@ pub fn expectValue(a: anytype, b: anytype) !void {
 
 /// Null object pattern implementation of Generation I `Chance` which does nothing, though chance
 /// tracking should additionally be turned off entirely via `options.chance`.
-pub const NULL = Null{};
+pub const NULL: Null = .{};
 
 const Null = struct {
     pub const Error = error{};
@@ -984,10 +1000,6 @@ const Null = struct {
         _ = .{ self, player, roll };
     }
 
-    pub fn secondaryChance(self: Null, player: Player, proc: bool, rate: u8) Error!void {
-        _ = .{ self, player, proc, rate };
-    }
-
     pub fn confused(self: Null, player: Player, ok: bool) Error!void {
         _ = .{ self, player, ok };
     }
@@ -996,6 +1008,10 @@ const Null = struct {
         _ = .{ self, player, ok };
     }
 
+    pub fn secondaryChance(self: Null, player: Player, proc: bool, rate: u8) Error!void {
+        _ = .{ self, player, proc, rate };
+    }
+
     pub fn moveSlot(self: Null, player: Player, slot: u4, ms: []const MoveSlot, n: u4) Error!void {
         _ = .{ self, player, slot, ms, n };
     }