@pkmn/engine 0.1.0-dev.6ef582f1 → 0.1.0-dev.736f7a8b

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};
@@ -535,72 +553,207 @@ test "Rolls.duration" {
     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" {

package/src/lib/gen1/mechanics.zig

@@ -2771,6 +2771,7 @@ pub const Rolls = struct {
             }
         };
 
+        assert(roll >= 217 and roll <= 255);
         try options.chance.damage(player, roll);
         return roll;
     }
@@ -2895,6 +2896,7 @@ pub const Rolls = struct {
             }
         };
 
+        assert(power < max);
         try options.chance.psywave(player, power, max);
         return power;
     }
@@ -2911,6 +2913,7 @@ pub const Rolls = struct {
             }
         };
 
+        assert(duration >= 1 and duration <= 7);
         options.chance.duration(.sleep, player, player.foe(), duration);
         return duration;
     }
@@ -2923,6 +2926,7 @@ pub const Rolls = struct {
         else
             @intCast((battle.rng.next() & 7) + 1);
 
+        assert(duration >= 1 and duration <= 8);
         options.chance.duration(.disable, player, player.foe(), duration);
         return duration;
     }
@@ -2935,6 +2939,7 @@ pub const Rolls = struct {
         else
             @intCast((battle.rng.next() & 3) + 2);
 
+        assert(duration >= 2 and duration <= 5);
         options.chance.duration(.confusion, player, if (self) player else player.foe(), duration);
         return duration;
     }
@@ -2947,6 +2952,7 @@ pub const Rolls = struct {
         else
             @intCast((battle.rng.next() & 1) + 2);
 
+        assert(duration >= 2 and duration <= 3);
         options.chance.duration(.attacking, player, player, duration);
         return duration;
     }
@@ -2967,6 +2973,7 @@ pub const Rolls = struct {
             break :n @intCast((if (r < 2) r else battle.rng.next() & 3) + 2);
         };
 
+        assert(n >= 2 and n <= 5);
         if (effect == .Binding) {
             options.chance.duration(.binding, player, player, n);
         } else {

package/src/lib/gen2/README.md

@@ -219,6 +219,81 @@ much overhead the preceding representations have after taking into consideration
 padding](https://en.wikipedia.org/wiki/Data_structure_alignment) and
 [denormalization](https://en.wikipedia.org/wiki/Denormalization):
 
+## Details
+
+| pkmn                      | Pokémon Crystal (pret)                            |
+| ------------------------- | ------------------------------------------------- |
+| `start`                   | `DoBattle`                                        |
+| `update`                  | `BattleTurn`                                      |
+| `selectMove` / `saveMove` | `CheckPlayerLockedIn` / `ParsePlayerAction`       |
+| `switchIn`                | `SwitchPlayerMon` / `SendOutPlayerMon`            |
+| `turnOrder`               | `DetermineMoveOrder`                              |
+| `doTurn`                  | `DoTurn`                                          |
+| `executeMove`             | `DoMove`                                          |
+| `beforeMove`              | `CheckTurn`                                       |
+| `canMove`                 |                                                   |
+| `decrementPP`             |                                                   |
+| `doMove`                  |                                                   |
+| `checkCriticalHit`        | `BattleCommand_Critical`                          |
+| `calcDamage`              | `BattleCommand_DamageCalc` / `PlayerAttackDamage` |
+| `adjustDamage`            | `BattleCommand_Stab`                              |
+| `randomizeDamage`         | `BattleCommand_DamageVariation`                   |
+| `specialDamage`           | `BattleCommand_ConstantDamage`                    |
+| `applyDamage`             | `BattleCommand_ApplyDamage`                       |
+| `checkHit`                | `BattleCommand_CheckHit`                          |
+| `checkFaint`              | `CheckFaint`                                      |
+| `handleResidual`          | `ResidualDamage`                                  |
+| `endTurn`                 | `EndTurn`                                         |
+
+DoBattle
+BattleTurn
+- HandleBerserkGene
+- CheckPlayerLockedIn
+- BattleMenu
+- ParsePlayerAction
+- DetermineMoveOrder
+  - CompareMovePriority
+  - GetMovePriority
+- Battle_*
+  - Handle*Switch
+    - SwitchPlayerMon
+      - BreakAttraction
+      - SendOutPlayerMon
+    - SpikesDamage
+  - *Turn_EndOpponentProtectEndureDestinyBond
+    - EndUserDestinyBond
+    - Do*Turn
+    - EndOpponentProtectEndureDestinyBond
+  - ResidualDamage
+  - CheckFaint_*
+  - HandleBetweenTurnEffects
+    - HandleFutureSight
+    - HandleWeather
+    - HandleWrap
+    - HandlePerishSong
+    - HandleLeftovers
+    - HandleMysteryBerry
+    - HandleDefrost
+    - HandleSafeguard
+    - HandleScreens
+    - HandleStatBoostingHeldItems
+    - HandleHealingItems
+    - HandleEncore
+
+DoTurn
+DoMove = executeMove
+CheckTurn = beforeMove
+BattleCommand_Critical = checkCriticalHit
+BattleCommand_Stab = adjustDamage
+BattleCommand_DamageVariation = randomizeDamage
+BattleCommand_CheckHit = checkHit
+BattleCommand_ApplyDamage = applyDamage
+BattleCommand_CheckFaint
+BattleCommand_BuildOpponentRage = buildRage
+BattleCommand_DamageCalc (PlayerAttackDamage / EnemyAttackDamage) = calcDamage
+BattleCommand_ConstantDamage = specialDamage
+DoEnemyDamage / DoPlayerDamage / DoSubstituteDamage
+
 ==**TODO**==
 
 ## Protocol

package/src/lib/gen2/data/moves.zig

@@ -279,9 +279,11 @@ pub const Move = enum(u8) {
         target: Target,
         /// The chance of the move's secondary effect occurring.
         chance: u8 = 0,
+        /// The priority of the move
+        priority: i8 = 0,
 
         comptime {
-            assert(@sizeOf(Data) == 7);
+            assert(@sizeOf(Data) == 8);
         }
     };
 
@@ -450,6 +452,7 @@ pub const Move = enum(u8) {
             .pp = 20,
             .accuracy = 100,
             .target = .Other,
+            .priority = -1,
         },
         // Fly
         .{
@@ -709,6 +712,7 @@ pub const Move = enum(u8) {
             .pp = 20,
             .accuracy = 100,
             .target = .Other,
+            .priority = -1,
         },
         // Sing
         .{
@@ -916,6 +920,7 @@ pub const Move = enum(u8) {
             .pp = 20,
             .accuracy = 100,
             .target = .Depends,
+            .priority = -1,
         },
         // SeismicToss
         .{
@@ -1191,6 +1196,7 @@ pub const Move = enum(u8) {
             .pp = 30,
             .accuracy = 100,
             .target = .Other,
+            .priority = 1,
         },
         // Rage
         .{
@@ -1962,6 +1968,7 @@ pub const Move = enum(u8) {
             .pp = 10,
             .accuracy = 100,
             .target = .Self,
+            .priority = 2,
         },
         // MachPunch
         .{
@@ -1971,6 +1978,7 @@ pub const Move = enum(u8) {
             .pp = 30,
             .accuracy = 100,
             .target = .Other,
+            .priority = 1,
         },
         // ScaryFace
         .{
@@ -2102,6 +2110,7 @@ pub const Move = enum(u8) {
             .pp = 5,
             .accuracy = 100,
             .target = .Self,
+            .priority = 2,
         },
         // BoneRush
         .{
@@ -2156,6 +2165,7 @@ pub const Move = enum(u8) {
             .pp = 10,
             .accuracy = 100,
             .target = .Self,
+            .priority = 2,
         },
         // Charm
         .{
@@ -2433,6 +2443,7 @@ pub const Move = enum(u8) {
             .pp = 10,
             .accuracy = 100,
             .target = .Other,
+            .priority = -1,
         },
         // MorningSun
         .{
@@ -2525,6 +2536,7 @@ pub const Move = enum(u8) {
             .pp = 20,
             .accuracy = 100,
             .target = .Depends,
+            .priority = -1,
         },
         // PsychUp
         .{
@@ -2543,6 +2555,7 @@ pub const Move = enum(u8) {
             .pp = 5,
             .accuracy = 100,
             .target = .Other,
+            .priority = 1,
         },
         // AncientPower
         .{
@@ -2770,7 +2783,7 @@ pub const Move = enum(u8) {
 
     comptime {
         assert(@sizeOf(Move) == 1);
-        assert(@sizeOf(@TypeOf(DATA)) == 1757);
+        assert(@sizeOf(@TypeOf(DATA)) == 2008);
     }
 
     /// The number of Pokémon moves in this generation.