@pkmn/engine 0.1.0-dev.c5fe6d07 → 0.1.0-dev.d1b39ff0

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

@@ -1,4 +1,4 @@
-//! Code generated by `tools/generate` - manual edits will be overwritten
+//! Code generated by `tools/generate` - manual edits will be overwritten.
 
 const std = @import("std");
 

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

@@ -1,4 +1,4 @@
-//! Code generated by `tools/generate` - manual edits will be overwritten
+//! Code generated by `tools/generate` - manual edits will be overwritten.
 
 const std = @import("std");
 
@@ -14,15 +14,15 @@ const I = Effectiveness.Immune;
 
 /// Representation of a Generation II type in Pokémon.
 pub const Type = enum(u8) {
+    Ground,
+    Rock,
+    Steel,
     Normal,
     Fighting,
     Flying,
     Poison,
-    Ground,
-    Rock,
     Bug,
     Ghost,
-    Steel,
     @"???",
     Fire,
     Water,
@@ -33,37 +33,37 @@ pub const Type = enum(u8) {
     Dragon,
     Dark,
 
-    const CHART = [18][18]Effectiveness{
-        [_]Effectiveness{ N, N, N, N, N, R, N, I, R, N, N, N, N, N, N, N, N, N }, // Normal
-        [_]Effectiveness{ S, N, R, R, N, S, R, I, S, N, N, N, N, N, R, S, N, S }, // Fighting
-        [_]Effectiveness{ N, S, N, N, N, R, S, N, R, N, N, N, S, R, N, N, N, N }, // Flying
-        [_]Effectiveness{ N, N, N, R, R, R, N, R, I, N, N, N, S, N, N, N, N, N }, // Poison
-        [_]Effectiveness{ N, N, I, S, N, S, R, N, S, N, S, N, R, S, N, N, N, N }, // Ground
-        [_]Effectiveness{ N, R, S, N, R, N, S, N, R, N, S, N, N, N, N, S, N, N }, // Rock
-        [_]Effectiveness{ N, R, R, R, N, N, N, R, R, N, R, N, S, N, S, N, N, S }, // Bug
-        [_]Effectiveness{ I, N, N, N, N, N, N, S, R, N, N, N, N, N, S, N, N, R }, // Ghost
-        [_]Effectiveness{ N, N, N, N, N, S, N, N, R, N, R, R, N, R, N, S, N, N }, // Steel
+    const CHART: [18][18]Effectiveness = .{
+        [_]Effectiveness{ N, S, S, N, N, I, S, R, N, N, S, N, R, S, N, N, N, N }, // Ground
+        [_]Effectiveness{ R, N, R, N, R, S, N, S, N, N, S, N, N, N, N, S, N, N }, // Rock
+        [_]Effectiveness{ N, S, R, N, N, N, N, N, N, N, R, R, N, R, N, S, N, N }, // Steel
+        [_]Effectiveness{ N, R, R, N, N, N, N, N, I, N, N, N, N, N, N, N, N, N }, // Normal
+        [_]Effectiveness{ N, S, S, S, N, R, R, R, I, N, N, N, N, N, R, S, N, S }, // Fighting
+        [_]Effectiveness{ N, R, R, N, S, N, N, S, N, N, N, N, S, R, N, N, N, N }, // Flying
+        [_]Effectiveness{ R, R, I, N, N, N, R, N, R, N, N, N, S, N, N, N, N, N }, // Poison
+        [_]Effectiveness{ N, N, R, N, R, R, R, N, R, N, R, N, S, N, S, N, N, S }, // Bug
+        [_]Effectiveness{ N, N, R, I, N, N, N, N, S, N, N, N, N, N, S, N, N, R }, // Ghost
         [_]Effectiveness{ N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N }, // ???
-        [_]Effectiveness{ N, N, N, N, N, R, S, N, S, N, R, R, S, N, N, S, R, N }, // Fire
-        [_]Effectiveness{ N, N, N, N, S, S, N, N, N, N, S, R, R, N, N, N, R, N }, // Water
-        [_]Effectiveness{ N, N, R, R, S, S, R, N, R, N, R, S, R, N, N, N, R, N }, // Grass
-        [_]Effectiveness{ N, N, S, N, I, N, N, N, N, N, N, S, R, R, N, N, R, N }, // Electric
-        [_]Effectiveness{ N, S, N, S, N, N, N, N, R, N, N, N, N, N, R, N, N, I }, // Psychic
-        [_]Effectiveness{ N, N, S, N, S, N, N, N, R, N, R, R, S, N, N, R, S, N }, // Ice
-        [_]Effectiveness{ N, N, N, N, N, N, N, N, R, N, N, N, N, N, N, N, S, N }, // Dragon
-        [_]Effectiveness{ N, R, N, N, N, N, N, S, R, N, N, N, N, N, S, N, N, R }, // Dark
+        [_]Effectiveness{ N, R, S, N, N, N, N, S, N, N, R, R, S, N, N, S, R, N }, // Fire
+        [_]Effectiveness{ S, S, N, N, N, N, N, N, N, N, S, R, R, N, N, N, R, N }, // Water
+        [_]Effectiveness{ S, S, R, N, N, R, R, R, N, N, R, S, R, N, N, N, R, N }, // Grass
+        [_]Effectiveness{ I, N, N, N, N, S, N, N, N, N, N, S, R, R, N, N, R, N }, // Electric
+        [_]Effectiveness{ N, N, R, N, S, N, S, N, N, N, N, N, N, N, R, N, N, I }, // Psychic
+        [_]Effectiveness{ S, N, R, N, N, S, N, N, N, N, R, R, S, N, N, R, S, N }, // Ice
+        [_]Effectiveness{ N, N, R, N, N, N, N, N, N, N, N, N, N, N, N, N, S, N }, // Dragon
+        [_]Effectiveness{ N, N, R, N, R, N, N, N, S, N, N, N, N, N, S, N, N, R }, // Dark
     };
 
     const PRECEDENCE = [_]u8{
+        9, // Ground
+        13, // Rock
+        17, // Steel
         1, // Normal
         7, // Fighting
         10, // Flying
         8, // Poison
-        9, // Ground
-        13, // Rock
         12, // Bug
         14, // Ghost
-        17, // Steel
         0, // ???
         2, // Fire
         3, // Water
@@ -75,29 +75,126 @@ pub const Type = enum(u8) {
         16, // Dark
     };
 
+    const INDEXES = [_]u8{
+        4, // Ground
+        5, // Rock
+        9, // Steel
+        0, // Normal
+        1, // Fighting
+        2, // Flying
+        3, // Poison
+        7, // Bug
+        8, // Ghost
+        19, // ???
+        20, // Fire
+        21, // Water
+        22, // Grass
+        23, // Electric
+        24, // Psychic
+        25, // Ice
+        26, // Dragon
+        27, // Dark
+    };
+
+    const CONVERSION_2 = [_]Type{
+        .Normal,
+        .Fighting,
+        .Flying,
+        .Poison,
+        .Ground,
+        .Rock,
+        .@"???", // placeholder
+        .Bug,
+        .Ghost,
+        .Steel,
+    };
+
+    const HIDDEN_POWER = [_]Type{
+        .Fighting,
+        .Flying,
+        .Poison,
+        .Ground,
+        .Rock,
+        .Bug,
+        .Ghost,
+        .Steel,
+        .Fire,
+        .Water,
+        .Grass,
+        .Electric,
+        .Psychic,
+        .Ice,
+        .Dragon,
+        .Dark,
+    };
+
+    /// Order of Pokémon Showdown's types.
+    pub const SHOWDOWN = [_]Type{
+        .Fire,
+        .Ice,
+        .Steel,
+        .Electric,
+        .Ghost,
+        .Grass,
+        .Dark,
+        .Bug,
+        .Dragon,
+        .Fighting,
+        .Flying,
+        .Ground,
+        .Normal,
+        .Poison,
+        .Psychic,
+        .Rock,
+        .Water,
+        .@"???",
+    };
+
     comptime {
         assert(@bitSizeOf(Type) == 8);
         assert(@sizeOf(@TypeOf(CHART)) == 324);
         assert(@sizeOf(@TypeOf(PRECEDENCE)) == 18);
+        assert(@sizeOf(@TypeOf(INDEXES)) == 18);
+        assert(@sizeOf(@TypeOf(CONVERSION_2)) == 10);
+        assert(@sizeOf(@TypeOf(HIDDEN_POWER)) == 16);
+        assert(@sizeOf(@TypeOf(SHOWDOWN)) == 18);
     }
 
     /// The number of types in this generation.
     pub const size = 18;
 
     /// Whether or not this type is considered to be special as opposed to physical.
-    pub inline fn special(self: Type) bool {
+    pub fn special(self: Type) bool {
         return @intFromEnum(self) >= @intFromEnum(Type.Fire);
     }
 
     /// The `Effectiveness` of type `t2` vs. type `t1`.
-    pub inline fn effectiveness(t1: Type, t2: Type) Effectiveness {
+    pub fn effectiveness(t1: Type, t2: Type) Effectiveness {
         return CHART[@intFromEnum(t1)][@intFromEnum(t2)];
     }
 
-    /// The precedence order of type type.
-    pub inline fn precedence(self: Type) u8 {
+    /// The precedence order of Type `type`.
+    pub fn precedence(self: Type) u8 {
         return PRECEDENCE[@intFromEnum(self)];
     }
+
+    /// The internal index of this Type used by Present.
+    pub fn present(self: Type) u8 {
+        return INDEXES[@intFromEnum(self)];
+    }
+
+    /// The Type corresponding to a random roll of `num` for Conversion 2.
+    pub fn conversion2(num: u8) Type {
+        assert(num != 6);
+        assert(num < 10 or num >= 20);
+        assert(num <= 27);
+        return if (num < 10) CONVERSION_2[num] else @enumFromInt(num - 10);
+    }
+
+    /// The Type corresponding to a Hidden Power `index`.
+    pub fn hiddenPower(index: u8) Type {
+        return HIDDEN_POWER[index];
+    }
 };
 
 /// Representation of a Pokémon's typing.
@@ -112,12 +209,18 @@ pub const Types = extern struct {
     }
 
     /// Whether this typing is immune to type `t`.
-    pub inline fn immune(self: Types, t: Type) bool {
+    pub fn immune(self: Types, t: Type) bool {
         return t.effectiveness(self.type1) == I or t.effectiveness(self.type2) == I;
     }
 
     /// Whether this typing includes type `t`.
-    pub inline fn includes(self: Types, t: Type) bool {
+    pub fn includes(self: Types, t: Type) bool {
         return self.type1 == t or self.type2 == t;
     }
+
+    /// Whether this typing is immune to damage from Sandstorm.
+    pub fn sandstormImmune(self: Types) bool {
+        return @intFromEnum(self.type1) <= @intFromEnum(Type.Steel) or
+            @intFromEnum(self.type2) <= @intFromEnum(Type.Steel);
+    }
 };

package/src/lib/gen2/data.zig

@@ -5,6 +5,7 @@ const pkmn = @import("../pkmn.zig");
 
 const data = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
+const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
 const util = @import("../common/util.zig");
 
@@ -15,6 +16,8 @@ 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;
@@ -33,6 +36,9 @@ pub const LOGS_SIZE = if (builtin.mode == .ReleaseSmall)
 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;
@@ -45,6 +51,7 @@ const showdown = pkmn.options.showdown;
 pub const PRNG = rng.PRNG(2);
 
 pub fn Battle(comptime RNG: anytype) type {
+    const padding = if (!showdown) 3 else 5;
     return extern struct {
         const Self = @This();
 
@@ -53,17 +60,19 @@ pub fn Battle(comptime RNG: anytype) type {
         turn: u16 = 0,
         field: Field = .{},
 
-        pub inline fn side(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+        _: [padding]u8 = .{0} ** padding,
+
+        pub 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: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+        pub 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: *const Self, player: Player) ID {
+        pub fn active(self: *const Self, player: Player) ID {
             return player.ident(@intCast(self.side(player).pokemon[0].position));
         }
 
@@ -77,35 +86,32 @@ pub fn Battle(comptime RNG: anytype) type {
     };
 }
 
-// TODO
 test Battle {
-    try expectEqual(496, @sizeOf(Battle(PRNG)));
+    try expectEqual(512, @sizeOf(Battle(PRNG)));
 }
 
-const Field = packed struct {
+pub const Field = packed struct(u8) {
     weather: Weather = .None,
     weather_duration: u4 = 0,
-
-    comptime {
-        assert(@sizeOf(Field) == 1);
-    }
 };
 
-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,
+    active: ActivePokemon align(8) = .{},
+    conditions: Conditions = .{},
+    // NB: wLastPlayerCounterMove / wLastEnemyCounterMove (wLastPlayerMove / wLastEnemyMove)
     last_used_move: Move = .None,
-    _: u8 = 0,
 
-    const Conditions = packed struct {
+    _: [7]u8 = .{0} ** 7,
+
+    const Conditions = packed struct(u32) {
         Spikes: bool = false,
         Safeguard: bool = false,
         LightScreen: bool = false,
@@ -115,16 +121,19 @@ const Side = extern struct {
         light_screen: u4 = 0,
         reflect: u4 = 0,
 
-        comptime {
-            assert(@sizeOf(Conditions) == 2);
-        }
+        future_sight: FutureSight = .{},
+
+        const FutureSight = packed struct(u16) {
+            damage: u12 = 0,
+            count: u4 = 0,
+        };
     };
 
     comptime {
-        assert(@sizeOf(Side) == 240);
+        assert(@sizeOf(Side) == 248);
     }
 
-    pub inline fn get(self: anytype, slot: u8) PointerType(@TypeOf(self), Pokemon) {
+    pub 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;
@@ -132,28 +141,41 @@ const Side = extern struct {
         return &self.pokemon[id - 1];
     }
 
-    pub inline fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
+    pub fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
         return self.get(1);
     }
+
+    pub 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;
+    }
+
+    // TODO
+    // pub fn useMove(self: anytype) void {
+    //     assert(side.last_selected_move != .None);
+    //     self.last_used_move = side.last_selected_move;
+    //     self.active.volatiles.dirty = false;
+    // }
 };
 
 // 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: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
+    pub 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);
@@ -161,7 +183,7 @@ const ActivePokemon = extern struct {
     }
 };
 
-const Pokemon = extern struct {
+pub const Pokemon = extern struct {
     stats: Stats(u16) = .{},
     moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
     types: Types = .{},
@@ -178,7 +200,7 @@ const Pokemon = extern struct {
         assert(@sizeOf(Pokemon) == 32);
     }
 
-    pub inline fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
+    pub 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);
@@ -192,7 +214,7 @@ pub const Gender = enum(u2) {
     Unknown,
 };
 
-const DVs = packed struct {
+pub const DVs = packed struct(u16) {
     gender: Gender = .Male,
     pow: u6 = 40,
     type: Type = .Dark,
@@ -200,10 +222,10 @@ const DVs = packed struct {
     pub fn init(g: Gender, p: u6, t: Type) DVs {
         assert(p >= 1 and p <= 40);
         assert(t != .Normal and t != .@"???");
-        return DVs{ .gender = g, .pow = p, .type = t };
+        return .{ .gender = g, .pow = p, .type = t };
     }
 
-    pub inline fn power(dvs: DVs) u8 {
+    pub fn power(dvs: DVs) u8 {
         return @as(u8, dvs.pow) + 30;
     }
 
@@ -217,13 +239,8 @@ const DVs = packed struct {
         };
         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 >= @intFromEnum(Type.@"???")) t = t + 1;
-        return DVs{ .gender = g, .pow = p, .type = @enumFromInt(t) };
-    }
-
-    comptime {
-        assert(@sizeOf(DVs) == 2);
+        const t = @as(u8, dvs.def & 0b0011) + (@as(u8, dvs.atk & 0b0011) << 2);
+        return .{ .gender = g, .pow = p, .type = Type.hiddenPower(t) };
     }
 };
 
@@ -231,12 +248,12 @@ test DVs {
     var dvs = DVs.from(.Mewtwo, .{ .def = 13 });
     try expectEqual(Gender.Unknown, dvs.gender);
     try expectEqual(Type.Ice, dvs.type);
-    try expectEqual(@as(u8, 70), dvs.power());
+    try expectEqual(70, dvs.power());
 
     dvs = DVs.from(.Pikachu, .{ .spc = 14 });
     try expectEqual(Gender.Male, dvs.gender);
     try expectEqual(Type.Dark, dvs.type);
-    try expectEqual(@as(u8, 69), dvs.power());
+    try expectEqual(69, dvs.power());
 
     dvs = DVs.from(.Cyndaquil, .{ .atk = 1, .def = 3, .spe = 10, .spc = 9 });
     try expectEqual(Gender.Female, dvs.gender);
@@ -248,10 +265,12 @@ test DVs {
     try expectEqual(Gender.Female, dvs.gender);
 }
 
-const MoveSlot = packed struct {
+/// Representation of a Generation II Pokémon's move slot in a battle.
+pub const MoveSlot = extern struct {
+    /// The identifier for the move.
     id: Move = .None,
-    pp_ups: u2 = 3,
-    pp: u6 = 0,
+    /// The remaining PP of the move.
+    pp: u8 = 0,
 
     comptime {
         assert(@sizeOf(MoveSlot) == 2);
@@ -260,14 +279,19 @@ const MoveSlot = packed struct {
 
 pub const Status = gen1.Status;
 
-const Volatile = packed struct {
+/// TODO
+pub const TriAttack = enum(u2) { PAR, FRZ, BRN };
+
+pub const Volatiles = packed struct(u128) {
     Bide: bool = false,
     Thrashing: bool = false,
+    BeatUp: bool = false,
     Flinch: bool = false,
     Charging: bool = false,
     Underground: bool = false,
     Flying: bool = false,
     Confusion: bool = false,
+
     Mist: bool = false,
     FocusEnergy: bool = false,
     Substitute: bool = false,
@@ -278,52 +302,55 @@ const Volatile = packed struct {
     Transform: bool = false,
 
     Nightmare: bool = false,
-    Cure: bool = false,
+    Curse: bool = false,
     Protect: bool = false,
     Foresight: bool = false,
     PerishSong: bool = false,
     Endure: bool = false,
     Rollout: bool = false,
     Attract: bool = false,
+
     DefenseCurl: bool = false,
     Encore: bool = false,
     LockOn: bool = false,
     DestinyBond: bool = false,
-    BeatUp: bool = false,
+    Trapped: bool = false,
 
-    trapped: bool = false,
     switched: bool = false,
+    // TODO: replace with simply looking at Choice on Battle
     switching: bool = false,
+    // TODO: simply store both last moves on side
+    dirty: bool = false,
 
-    _: u5 = 0,
+    frozen: bool = false,
+    minimized: bool = false,
+    _: u10 = 0,
+    // TODO: is this needed for unmodified stats?
+    transform: u4 = 0,
 
-    bind: u4 = 0,
-    future_sight: FutureSight = .{},
     bide: u16 = 0,
-    disabled: Disabled = .{},
+    bind: Bind = .{},
+    disable: Disable = .{},
     rage: u8 = 0,
     substitute: u8 = 0,
     toxic: u8 = 0,
     confusion: u4 = 0,
     encore: u4 = 0,
+    // TODO merge with attacks (ie rollout/thrashing)? need to be zeroed at same time
     fury_cutter: u4 = 0,
     perish_song: u4 = 0,
     protect: u4 = 0,
-    rollout: u4 = 0,
+    attacks: u4 = 0, // bide/thrashing/rollout turns
 
-    const Disabled = packed struct {
-        move: u4 = 0,
+    const Bind = packed struct(u8) {
         duration: u4 = 0,
+        reason: u4 = 0,
     };
 
-    const FutureSight = packed struct {
-        damage: u12 = 0,
-        count: u4 = 0,
+    const Disable = packed struct(u8) {
+        move: u4 = 0,
+        duration: u4 = 0,
     };
-
-    comptime {
-        assert(@sizeOf(Volatile) == 16);
-    }
 };
 
 pub fn Stats(comptime T: type) type {
@@ -353,12 +380,12 @@ test Stats {
     try expectEqual(0, stats.def);
 
     var base = Species.get(.Gyarados).stats;
-    try expectEqual(@as(u16, 127), Stats(u16).calc("hp", base.hp, 0, 5120, 38));
+    try expectEqual(127, Stats(u16).calc("hp", base.hp, 0, 5120, 38));
     base = Species.get(.Pidgeot).stats;
-    try expectEqual(@as(u16, 279), Stats(u16).calc("spe", base.spe, 15, 63001, 100));
+    try expectEqual(279, Stats(u16).calc("spe", base.spe, 15, 63001, 100));
 }
 
-pub const Boosts = packed struct {
+pub const Boosts = packed struct(u32) {
     atk: i4 = 0,
     def: i4 = 0,
     spe: i4 = 0,
@@ -374,7 +401,7 @@ pub const Boosts = packed struct {
 };
 
 test Boosts {
-    const boosts = Boosts{ .spd = -6 };
+    const boosts: Boosts = .{ .spd = -6 };
     try expectEqual(0, boosts.atk);
     try expectEqual(-6, boosts.spd);
 }
@@ -387,15 +414,10 @@ test Item {
     try expectEqual(Type.Normal, Item.boost(.PolkadotBow).?);
     try expectEqual(Type.Dark, Item.boost(.BlackGlasses).?);
 
-    try expect(!Item.mail(.UpGrade));
-    try expect(Item.mail(.FlowerMail));
-    try expect(Item.mail(.MirageMail));
-    try expect(!Item.mail(.TownMap));
-
-    try expect(!Item.berry(.LightBall));
-    try expect(Item.berry(.PSNCureBerry));
-    try expect(Item.berry(.GoldBerry));
-    try expect(!Item.berry(.MasterBall));
+    try expect(!Item.isMail(.UpGrade));
+    try expect(Item.isMail(.FlowerMail));
+    try expect(Item.isMail(.MirageMail));
+    try expect(!Item.isMail(.TownMap));
 }
 
 pub const Move = moves.Move;
@@ -404,15 +426,20 @@ test Move {
     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(rng.Gen12.percent(50), move.accuracy);
+    try expectEqual(rng.Gen12.percent(100), move.chance);
+    try expectEqual(5, Move.pp(.DynamicPunch));
+    try expectEqual(-1, Move.get(.Counter).priority);
+    try expect(!move.effect.isHighCritical());
+    try expect(Move.get(.KarateChop).effect.isHighCritical());
+    try expect(Move.get(.RazorWind).effect.isHighCritical());
 }
 
 pub const Species = species.Species;
 
 test Species {
     try expectEqual(152, @intFromEnum(Species.Chikorita));
-    try expectEqual(@as(u8, 100), Species.get(.Celebi).stats.spd);
+    try expectEqual(100, Species.get(.Celebi).stats.spd);
 }
 
 pub const Type = types.Type;
@@ -425,7 +452,7 @@ test Types {
     try expect(!Type.Steel.special());
     try expect(Type.Dark.special());
 
-    try expectEqual(@as(u8, 3), Type.Water.precedence());
+    try expectEqual(3, Type.Water.precedence());
     try expect(Type.Bug.precedence() > Type.Poison.precedence());
 
     try expectEqual(Effectiveness.Super, Type.effectiveness(.Ghost, .Psychic));