@pkmn/engine 0.1.0-dev.729b1e87 → 0.1.0-dev.736f7a8b

package/src/lib/gen2/README.md

@@ -54,13 +54,12 @@ The following information is required to simulate a Generation II Pokémon battl
 |                                |                                   |                                       |
 | `active.last_used_move`        | `PlayerUsedMove`                  | `side.lastMove`                       |
 
-- Pokémon Showdown does not implement the correct Generation II RNG and as such its `seed` is
+- Pokémon Showdown doesn't implement the correct Generation II RNG and as such its `seed` is
   different
-- `battle.turn` only needs to be tracked in order to be compatible with the Pokémon Showdown
-  protocol
+- `battle.turn` only needs to be tracked to be compatible with the Pokémon Showdown protocol
 - Battle results (win, lose, draw) or request states are communicated via the return code of
   `Battle.update`
-- Nicknames (`BattleMonNick`/`pokemon.name`) are not handled by the pkmn engine as they are expected
+- Nicknames (`BattleMonNick`/`pokemon.name`) aren't handled by the pkmn engine as they're expected
   to be handled by driver code if required
 
 ==**TODO**==
@@ -77,9 +76,9 @@ between the data structure for the "active" Pokémon and its party members (see
 
 ### `Pokemon` / `ActivePokemon`
 
-Similar to the cartridge, in order to save space different information is stored depending on
-whether a [Pokémon](https://pkmn.cc/bulba/Pok%c3%a9mon_data_structure_%28Generation_II%29) is
-actively participating in battle vs. is switched out (pret's [`battle_struct` vs.
+Similar to the cartridge, to save space different information is stored depending on whether a
+[Pokémon](https://pkmn.cc/bulba/Pok%c3%a9mon_data_structure_%28Generation_II%29) is actively
+participating in battle vs. is switched out (pret's [`battle_struct` vs.
 `party_struct`](https://pkmn.cc/pokecrystal/macros/ram.asm)). In Pokémon Showdown, all the Pokemon
 are represented by the same
 [`Pokemon`](https://github.com/smogon/pokemon-showdown/blob/master/sim/pokemon.ts) class, and static
@@ -93,14 +92,14 @@ A `MoveSlot` is a data-type for a `(move, current pp)` pair. A pared down versio
 Showdown's `Pokemon#moveSlot`, it also stores data from the cartridge's `battle_struct::Move` macro
 and can be used to replace the `PlayerMove*` data. Move PP is stored as a full byte instead of how
 the cartridge (`battle_struct::PP`) stores it (6 bits for current PP and the remaining 2 bits used
-to store the number of applied PP Ups). PP Up bits do not actually need to be stored on move slot
+to store the number of applied PP Ups). PP Up bits don't actually need to be stored on move slot
 as max PP is never relevant in Generation II (the Mystery Berry always increases PP from 0 -> 5).
 
 #### `Status`
 
 Bitfield representation of a Pokémon's major [status
-condition](https://pkmn.cc/bulba/Status_condition), mirroring how it is stored on the cartridge. A
-value of `0x00` means that the Pokémon is not affected by any major status, otherwise the lower 3
+condition](https://pkmn.cc/bulba/Status_condition), mirroring how it's stored on the cartridge. A
+value of `0x00` means that the Pokémon isn't affected by any major status, otherwise the lower 3
 bits represent the remaining duration for Sleep. Other status are denoted by the presence of
 individual bits - at most one status should be set at any given time.
 
@@ -161,7 +160,7 @@ boosts should always range from `-6`...`6` instead of `1`...`13` as on the cartr
 
 `Moves` serves as an identifier for a unique [Pokémon move](https://pkmn.cc/bulba/Move) that can be
 used to retrieve a `Move` with information regarding base power, accuracy and type. As covered
-above, PP information isn't strictly necessary in Generation I, but fits neatly into the 4 bits of
+earlier, PP information isn't strictly necessary in Generation I, but fits neatly into the 4 bits of
 padding after noticing that all PP values are multiples of 5. `Moves.None` exists as a special
 sentinel value to indicate `null`.
 
@@ -215,11 +214,86 @@ entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory))) is as foll
 | **wrap**       | 0...5   | 3    |     | **perish song**   | 0...4    | 3    |
 | **item**       | TODO    | 5?   |     | **gender**        | 0..1     | 1    |
 
-From this we can determine the minimum bits required to store each data structure to determine how
-much overhead the representations above have after taking into consideration [alignment &
+From this one can determine the minimum bits required to store each data structure to determine how
+much overhead the preceding representations have after taking into consideration [alignment &
 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/items.zig

@@ -219,18 +219,18 @@ pub const Item = enum(u8) {
     pub inline fn boost(item: Item) ?Type {
         assert(item != .None);
         if (item == .PolkadotBow) return .Normal;
-        return if (@enumToInt(item) <= 18) @intToEnum(Type, @enumToInt(item) - 1) else null;
+        return if (@intFromEnum(item) <= 18) @enumFromInt(@intFromEnum(item) - 1) else null;
     }
 
     /// Whether or not this item is a Berry.
     pub inline fn berry(item: Item) bool {
         assert(item != .None);
-        return @enumToInt(item) > 30 and @enumToInt(item) <= 40;
+        return @intFromEnum(item) > 30 and @intFromEnum(item) <= 40;
     }
 
     /// Whether or not this item is Mail.
     pub inline fn mail(item: Item) bool {
         assert(item != .None);
-        return @enumToInt(item) > 60 and @enumToInt(item) <= 70;
+        return @intFromEnum(item) > 60 and @intFromEnum(item) <= 70;
     }
 };

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.
@@ -2779,6 +2792,6 @@ pub const Move = enum(u8) {
     /// Returns the `Data` corresponding to the move.
     pub inline fn get(id: Move) Data {
         assert(id != .None);
-        return DATA[@enumToInt(id) - 1];
+        return DATA[@intFromEnum(id) - 1];
     }
 };

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

@@ -1793,6 +1793,6 @@ pub const Species = enum(u8) {
     /// Returns the `Data` corresponding to the species.
     pub fn get(id: Species) Data {
         assert(id != .None);
-        return DATA[@enumToInt(id) - 1];
+        return DATA[@intFromEnum(id) - 1];
     }
 };

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

@@ -86,17 +86,17 @@ pub const Type = enum(u8) {
 
     /// Whether or not this type is considered to be special as opposed to physical.
     pub inline fn special(self: Type) bool {
-        return @enumToInt(self) >= @enumToInt(Type.Fire);
+        return @intFromEnum(self) >= @intFromEnum(Type.Fire);
     }
 
     /// The `Effectiveness` of type `t2` vs. type `t1`.
     pub inline fn effectiveness(t1: Type, t2: Type) Effectiveness {
-        return CHART[@enumToInt(t1)][@enumToInt(t2)];
+        return CHART[@intFromEnum(t1)][@intFromEnum(t2)];
     }
 
     /// The precedence order of type type.
     pub inline fn precedence(self: Type) u8 {
-        return PRECEDENCE[@enumToInt(self)];
+        return PRECEDENCE[@intFromEnum(self)];
     }
 };
 

package/src/lib/gen2/data.zig

@@ -1,10 +1,13 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
+const pkmn = @import("../pkmn.zig");
+
 const data = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
-const options = @import("../common/options.zig");
+const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
+const util = @import("../common/util.zig");
 
 const items = @import("data/items.zig");
 const moves = @import("data/moves.zig");
@@ -13,30 +16,37 @@ const types = @import("data/types.zig");
 
 const gen1 = @import("../gen1/data.zig");
 
+const calc = @import("calc.zig");
+const chance = @import("chance.zig");
 const mechanics = @import("mechanics.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
 const expect = std.testing.expect;
 
-pub const MAX_OPTIONS: usize = 9; // move 1..4, switch 2..6
+pub const MAX_CHOICES: usize = 9; // move 1..4, switch 2..6
 pub const MAX_LOGS: usize = 180; // TODO
 
-pub const OPTIONS_SIZE = if (builtin.mode == .ReleaseSmall)
-    MAX_OPTIONS
+pub const CHOICES_SIZE = if (builtin.mode == .ReleaseSmall)
+    MAX_CHOICES
 else
-    std.math.ceilPowerOfTwo(usize, MAX_OPTIONS) catch unreachable;
+    std.math.ceilPowerOfTwo(usize, MAX_CHOICES) catch unreachable;
 pub const LOGS_SIZE = if (builtin.mode == .ReleaseSmall)
     MAX_LOGS
 else
     std.math.ceilPowerOfTwo(usize, MAX_LOGS) catch unreachable;
 
+///  Null object pattern implementation of pkmn.battle.Options for Generation II.
+pub const NULL = pkmn.battle.options(protocol.NULL, chance.NULL, calc.NULL);
+
 const Choice = data.Choice;
 const ID = data.ID;
 const Player = data.Player;
 const Result = data.Result;
 
-const showdown = options.showdown;
+const PointerType = util.PointerType;
+
+const showdown = pkmn.options.showdown;
 
 pub const PRNG = rng.PRNG(2);
 
@@ -49,20 +59,22 @@ pub fn Battle(comptime RNG: anytype) type {
         turn: u16 = 0,
         field: Field = .{},
 
-        pub inline fn side(self: *Self, player: Player) *Side {
-            return &self.sides[@enumToInt(player)];
+        pub inline fn side(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+            return &self.sides[@intFromEnum(player)];
         }
 
-        pub inline fn foe(self: *Self, player: Player) *Side {
-            return &self.sides[@enumToInt(player.foe())];
+        pub inline fn foe(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+            return &self.sides[@intFromEnum(player.foe())];
         }
 
-        pub inline fn active(self: *Self, player: Player) ID {
-            return player.ident(@intCast(u3, self.side(player).pokemon[0].position));
+        pub inline fn active(self: *const Self, player: Player) ID {
+            return player.ident(@intCast(self.side(player).pokemon[0].position));
         }
 
-        pub fn update(self: *Self, c1: Choice, c2: Choice, log: anytype) !Result {
-            return mechanics.update(self, c1, c2, log);
+        pub fn update(self: *Self, c1: Choice, c2: Choice, options: anytype) !Result {
+            return mechanics.update(self, c1, c2, options);
         }
 
         pub fn choices(self: *Self, player: Player, request: Choice.Type, out: []Choice) u8 {
@@ -76,7 +88,7 @@ test Battle {
     try expectEqual(496, @sizeOf(Battle(PRNG)));
 }
 
-const Field = packed struct {
+pub const Field = packed struct {
     weather: Weather = .None,
     weather_duration: u4 = 0,
 
@@ -85,19 +97,21 @@ const Field = packed struct {
     }
 };
 
-const Weather = enum(u4) {
+pub const Weather = enum(u4) {
     None,
     Rain,
     Sun,
     Sandstorm,
 };
 
-const Side = extern struct {
+pub const Side = extern struct {
     pokemon: [6]Pokemon = [_]Pokemon{.{}} ** 6,
     active: ActivePokemon = .{},
-    conditions: Conditions,
+    conditions: Conditions = .{},
+    // NB: wCurPlayerMove / wCurEnemyMove
+    last_selected_move: Move = .None,
+    // NB: wLastPlayerCounterMove / wLastEnemyCounterMove (wLastPlayerMove / wLastEnemyMove)
     last_used_move: Move = .None,
-    _: u8 = 0,
 
     const Conditions = packed struct {
         Spikes: bool = false,
@@ -118,41 +132,49 @@ const Side = extern struct {
         assert(@sizeOf(Side) == 240);
     }
 
-    pub inline fn get(self: *const Side, slot: u8) *Pokemon {
+    pub inline fn get(self: anytype, slot: u8) PointerType(@TypeOf(self), Pokemon) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
         assert(slot > 0 and slot <= 6);
         const id = self.pokemon[slot - 1].position;
         assert(id > 0 and id <= 6);
         return &self.pokemon[id - 1];
     }
 
-    pub inline fn stored(self: *Side) *Pokemon {
+    pub inline fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
         return self.get(1);
     }
+
+    pub inline fn lastMove(self: anytype, encore: bool) Move {
+        assert(self.last_used_move != .None or !self.active.volatiles.dirty);
+        if (encore) return self.last_used_move;
+        return if (self.active.volatiles.dirty) .None else self.last_used_move;
+    }
 };
 
 // NOTE: DVs (Gender & Hidden Power) and Happiness are stored only in Pokemon
-const ActivePokemon = extern struct {
-    volatiles: Volatile align(4) = .{},
+pub const ActivePokemon = extern struct {
+    volatiles: Volatiles align(4) = .{},
     stats: Stats(u16) = .{},
     moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
     boosts: Boosts = .{},
+    types: Types = .{},
     species: Species = .None,
     item: Item = .None,
-    last_move: Move = .None,
-    _: u8 = 0,
 
     comptime {
         assert(@sizeOf(ActivePokemon) == 44);
     }
 
-    pub inline fn move(self: *ActivePokemon, mslot: u8) *MoveSlot {
+    pub inline fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Pokemon);
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
         return &self.moves[mslot - 1];
     }
 };
 
-const Pokemon = extern struct {
+pub const Pokemon = extern struct {
     stats: Stats(u16) = .{},
     moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
     types: Types = .{},
@@ -169,7 +191,8 @@ const Pokemon = extern struct {
         assert(@sizeOf(Pokemon) == 32);
     }
 
-    pub inline fn move(self: *Pokemon, mslot: u8) *MoveSlot {
+    pub inline fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Pokemon);
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
         return &self.moves[mslot - 1];
@@ -182,7 +205,7 @@ pub const Gender = enum(u2) {
     Unknown,
 };
 
-const DVs = packed struct {
+pub const DVs = packed struct {
     gender: Gender = .Male,
     pow: u6 = 40,
     type: Type = .Dark,
@@ -205,11 +228,11 @@ const DVs = packed struct {
             0xFF => .Unknown,
             else => if ((@as(u8, dvs.atk) << 4 | dvs.spe) < ratio) Gender.Female else Gender.Male,
         };
-        const p = @intCast(u6, 1 + ((5 * @as(u8, (dvs.atk & 0b1000) | ((dvs.def & 0b1000)) >> 1 |
+        const p: u6 = @intCast(1 + ((5 * @as(u8, (dvs.atk & 0b1000) | ((dvs.def & 0b1000)) >> 1 |
             ((dvs.spe & 0b1000)) >> 2 | ((dvs.spc & 0b1000)) >> 3) + (dvs.spc & 0b0011)) >> 1));
         var t = @as(u8, dvs.def & 0b0011) + (@as(u8, dvs.atk & 0b0011) << 2) + 1;
-        if (t >= @enumToInt(Type.@"???")) t = t + 1;
-        return DVs{ .gender = g, .pow = p, .type = @intToEnum(Type, t) };
+        if (t >= @intFromEnum(Type.@"???")) t = t + 1;
+        return DVs{ .gender = g, .pow = p, .type = @enumFromInt(t) };
     }
 
     comptime {
@@ -238,7 +261,7 @@ test DVs {
     try expectEqual(Gender.Female, dvs.gender);
 }
 
-const MoveSlot = packed struct {
+pub const MoveSlot = packed struct {
     id: Move = .None,
     pp_ups: u2 = 3,
     pp: u6 = 0,
@@ -250,7 +273,7 @@ const MoveSlot = packed struct {
 
 pub const Status = gen1.Status;
 
-const Volatile = packed struct {
+pub const Volatiles = packed struct {
     Bide: bool = false,
     Thrashing: bool = false,
     Flinch: bool = false,
@@ -284,8 +307,9 @@ const Volatile = packed struct {
     trapped: bool = false,
     switched: bool = false,
     switching: bool = false,
+    dirty: bool = false,
 
-    _: u5 = 0,
+    _: u4 = 0,
 
     bind: u4 = 0,
     future_sight: FutureSight = .{},
@@ -312,7 +336,7 @@ const Volatile = packed struct {
     };
 
     comptime {
-        assert(@sizeOf(Volatile) == 16);
+        assert(@sizeOf(Volatiles) == 16);
     }
 };
 
@@ -327,10 +351,11 @@ pub fn Stats(comptime T: type) type {
 
         pub fn calc(comptime stat: []const u8, base: T, dv: u4, exp: u16, level: u8) T {
             assert(level > 0 and level <= 100);
-            const evs = @min(255, @floatToInt(u16, @ceil(@sqrt(@intToFloat(f32, exp)))));
+            const float: f32 = @floatFromInt(exp);
+            const evs: u16 = @min(255, @as(u16, @intFromFloat(@ceil(@sqrt(float)))));
             const core: u32 = (2 *% (@as(u32, base) +% dv)) +% (evs / 4);
             const factor: u32 = if (std.mem.eql(u8, stat, "hp")) level + 10 else 5;
-            return @intCast(T, core *% @as(u32, level) / 100 +% factor);
+            return @intCast(core *% @as(u32, level) / 100 +% factor);
         }
     };
 }
@@ -390,17 +415,18 @@ test Item {
 pub const Move = moves.Move;
 
 test Move {
-    try expectEqual(251, @enumToInt(Move.BeatUp));
+    try expectEqual(251, @intFromEnum(Move.BeatUp));
     const move = Move.get(.DynamicPunch);
     try expectEqual(Move.Effect.ConfusionChance, move.effect);
     try expectEqual(@as(u8, 50), move.accuracy);
     try expectEqual(@as(u8, 5), move.pp);
+    try expectEqual(@as(i8, -1), Move.get(.Counter).priority);
 }
 
 pub const Species = species.Species;
 
 test Species {
-    try expectEqual(152, @enumToInt(Species.Chikorita));
+    try expectEqual(152, @intFromEnum(Species.Chikorita));
     try expectEqual(@as(u8, 100), Species.get(.Celebi).stats.spd);
 }
 
@@ -409,7 +435,7 @@ pub const Types = types.Types;
 pub const Effectiveness = gen1.Effectiveness;
 
 test Types {
-    try expectEqual(13, @enumToInt(Type.Electric));
+    try expectEqual(13, @intFromEnum(Type.Electric));
 
     try expect(!Type.Steel.special());
     try expect(Type.Dark.special());