@pkmn/engine 0.1.0-dev.30895c5a → 0.1.0-dev.3158fa12

package/src/lib/gen1/chance.zig

@@ -1,26 +1,31 @@
-const std = @import("std");
-
-const assert = std.debug.assert;
-const print = std.debug.print;
-
-const expect = std.testing.expect;
-const expectEqual = std.testing.expectEqual;
-
 const DEBUG = @import("../common/debug.zig").print;
+
+const array = @import("../common/array.zig");
+const common = @import("../common/data.zig");
+const data = @import("data.zig");
+const optional = @import("../common/optional.zig");
 const options = @import("../common/options.zig");
 const rational = @import("../common/rational.zig");
+const std = @import("std");
 const util = @import("../common/util.zig");
 
-const Player = @import("../common/data.zig").Player;
-const Optional = @import("../common/optional.zig").Optional;
-
-const data = @import("data.zig");
-
+const Array = array.Array;
+const assert = std.debug.assert;
 const enabled = options.chance;
-const showdown = options.showdown;
-
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const isPointerTo = util.isPointerTo;
 const Move = data.Move;
 const MoveSlot = data.MoveSlot;
+const Optional = optional.Optional;
+const Player = common.Player;
+const PointerType = util.PointerType;
+const print = std.debug.print;
+const showdown = options.showdown;
+
+const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
+const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
+const Struct = if (@hasField(std.builtin.Type, "struct")) .@"struct" else .Struct;
 
 /// 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
@@ -37,8 +42,8 @@ pub const Actions = extern struct {
     }
 
     /// Returns the `Action` for the given `player`.
-    pub fn get(self: anytype, player: Player) util.PointerType(@TypeOf(self), Action) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Actions);
+    pub fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Action) {
+        assert(isPointerTo(self, Actions));
         return if (player == .P1) &self.p1 else &self.p2;
     }
 
@@ -51,15 +56,15 @@ pub const Actions = extern struct {
     /// same shape if they have the same fields set (though those fields need not necessarily be
     /// set to the same value).
     pub fn matches(a: Actions, b: Actions) bool {
-        inline for (@typeInfo(Actions).Struct.fields) |player| {
-            inline for (@typeInfo(Action).Struct.fields) |field| {
+        inline for (@field(@typeInfo(Actions), @tagName(Struct)).fields) |player| {
+            inline for (@field(@typeInfo(Action), @tagName(Struct)).fields) |field| {
                 const a_val = @field(@field(a, player.name), field.name);
                 const b_val = @field(@field(b, player.name), field.name);
 
                 switch (@typeInfo(@TypeOf(a_val))) {
-                    .Enum => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
+                    Enum => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
                         return false,
-                    .Int => if ((a_val > 0) != (b_val > 0)) return false,
+                    Int => if ((a_val > 0) != (b_val > 0)) return false,
                     else => unreachable,
                 }
             }
@@ -67,6 +72,25 @@ pub const Actions = extern struct {
         return true;
     }
 
+    /// TODO
+    pub fn matchesAny(a: Actions, bs: []Actions, i: usize) bool {
+        for (bs, 0..) |b, j| {
+            // TODO: is skipping this redundant check worth it?
+            if (i == j) continue;
+            if (b.matches(a)) return true;
+        }
+        return false;
+    }
+
+    /// TODO
+    pub fn relax(actions: Actions) Actions {
+        if (!options.overwrite) return actions;
+        var a = actions;
+        if (a.p1.confusion == .overwritten) a.p1.confusion = .continuing;
+        if (a.p2.confusion == .overwritten) a.p2.confusion = .continuing;
+        return a;
+    }
+
     pub fn fmt(self: Actions, writer: anytype, shape: bool) !void {
         try writer.writeAll("<P1 = ");
         try self.p1.fmt(writer, shape);
@@ -175,10 +199,10 @@ pub const Action = packed struct(u64) {
     pub fn fmt(self: Action, writer: anytype, shape: bool) !void {
         try writer.writeByte('(');
         var printed = false;
-        inline for (@typeInfo(Action).Struct.fields) |field| {
+        inline for (@field(@typeInfo(Action), @tagName(Struct)).fields) |field| {
             const val = @field(self, field.name);
             switch (@typeInfo(@TypeOf(val))) {
-                .Enum => if (val != .None) {
+                Enum => if (val != .None) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -199,7 +223,7 @@ pub const Action = packed struct(u64) {
                     }
                     printed = true;
                 },
-                .Int => if (val != 0) {
+                Int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -216,15 +240,19 @@ pub const Action = packed struct(u64) {
 };
 
 /// TODO
-pub const Durations = struct {
+pub const Durations = extern struct {
     /// TODO
     p1: Duration = .{},
     /// TODO
     p2: Duration = .{},
 
+    comptime {
+        assert(@sizeOf(Durations) == 8);
+    }
+
     /// TODO
-    pub fn get(self: anytype, player: Player) util.PointerType(@TypeOf(self), Duration) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Durations);
+    pub fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Duration) {
+        assert(isPointerTo(self, Durations));
         return if (player == .P1) &self.p1 else &self.p2;
     }
 
@@ -239,14 +267,18 @@ pub const Durations = struct {
     }
 };
 
+pub const Sleeps = Array(6, u3);
+
 /// TODO
-pub const Duration = struct {
-    sleeps: [6]u3 = .{0} ** 6,
+pub const Duration = packed struct(u32) {
+    sleeps: Sleeps.T = 0,
     confusion: u3 = 0,
     disable: u4 = 0,
     attacking: u3 = 0,
     binding: u3 = 0,
 
+    _: u1 = 0,
+
     pub fn format(
         self: Duration,
         comptime fmt: []const u8,
@@ -256,27 +288,22 @@ pub const Duration = struct {
         _ = .{ fmt, opts };
         try writer.writeByte('(');
         var printed = false;
-        inline for (@typeInfo(Duration).Struct.fields) |field| {
+        inline for (@field(@typeInfo(Duration), @tagName(Struct)).fields) |field| {
             const val = @field(self, field.name);
             switch (@typeInfo(@TypeOf(val))) {
-                .Int => if (val != 0) {
+                Int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
-                    try writer.print("{s}:{d}", .{ field.name, val });
-                    printed = true;
-                },
-                .Array => {
-                    var total: usize = 0;
-                    for (val) |v| total += v;
-                    if (total > 0) {
-                        if (printed) try writer.writeAll(", ");
+                    if (comptime std.mem.eql(u8, field.name, "sleeps")) {
                         try writer.print("{s}:[", .{field.name});
-                        for (val, 0..) |v, i| {
+                        for (0..6) |i| {
                             if (i != 0) try writer.writeByte(',');
-                            try writer.print("{d}", .{v});
+                            try writer.print("{d}", .{Sleeps.get(val, i)});
                         }
                         try writer.writeAll("]");
-                        printed = true;
+                    } else {
+                        try writer.print("{s}:{d}", .{ field.name, val });
                     }
+                    printed = true;
                 },
                 else => unreachable,
             }
@@ -364,7 +391,7 @@ pub fn Chance(comptime Rational: type) type {
 
             // If the move actually lands we can commit any past critical hit / damage rolls. Note
             // we can't rely on the presence or absence of a damage roll to determine whether a
-            // "critical hit" was spurious or not as moves that do 1 or less damage don't rol for
+            // "critical hit" was spurious or not as moves that do 1 or less damage don't roll for
             // damage but can still crit (instead, whether or not a roll is deemed to be a no-op is
             // passed to the critical hit helper).
             //
@@ -380,7 +407,7 @@ pub fn Chance(comptime Rational: type) type {
                 action.critical_hit = if (self.pending.crit) .true else .false;
             } else assert(!self.pending.glitch);
 
-            if (self.pending.damage_roll > 0) {
+            if (self.pending.damage_roll > 0 and (!self.pending.glitch or self.pending.hit)) {
                 try self.probability.update(1, 39);
                 action.damage = self.pending.damage_roll;
             }
@@ -407,9 +434,9 @@ pub fn Chance(comptime Rational: type) type {
 
             var d = self.durations.get(player);
 
-            const out = d.sleeps[0];
-            d.sleeps[0] = d.sleeps[slot - 1];
-            d.sleeps[slot - 1] = out;
+            const out = Sleeps.get(d.sleeps, 0);
+            d.sleeps = Sleeps.set(d.sleeps, 0, Sleeps.get(d.sleeps, slot - 1));
+            d.sleeps = Sleeps.set(d.sleeps, slot - 1, out);
 
             d.confusion = 0;
             d.disable = 0;
@@ -542,7 +569,8 @@ pub fn Chance(comptime Rational: type) type {
                 .None => {
                     @field(a, @tagName(field)) = .None;
                     if (field == .sleep) {
-                        self.durations.get(player).sleeps[0] = 0;
+                        var d = self.durations.get(player);
+                        d.sleeps = Sleeps.set(d.sleeps, 0, 0);
                     } else {
                         @field(self.durations.get(player), @tagName(field)) = 0;
                     }
@@ -556,7 +584,8 @@ pub fn Chance(comptime Rational: type) type {
                     });
                     @field(a, @tagName(field)) = .started;
                     if (field == .sleep) {
-                        self.durations.get(player).sleeps[0] = 1;
+                        var d = self.durations.get(player);
+                        d.sleeps = Sleeps.set(d.sleeps, 0, 1);
                     } else {
                         @field(self.durations.get(player), @tagName(field)) = 1;
                     }
@@ -573,19 +602,19 @@ pub fn Chance(comptime Rational: type) type {
             a.sleep = obs;
 
             var d = self.durations.get(player);
-            const n = d.sleeps[0];
+            const n = Sleeps.get(d.sleeps, 0);
 
             if (obs == .None) {
-                d.sleeps[0] = 0;
+                d.sleeps = Sleeps.set(d.sleeps, 0, 0);
             } else if (obs == .ended) {
                 assert(n >= 1 and n <= 7);
                 if (n != 7) try self.probability.update(1, 8 - @as(u4, n));
-                d.sleeps[0] = 0;
+                d.sleeps = Sleeps.set(d.sleeps, 0, 0);
             } else {
                 assert(obs == .continuing);
                 assert(n >= 1 and n < 7);
                 try self.probability.update(8 - @as(u4, n) - 1, 8 - @as(u4, n));
-                d.sleeps[0] += 1;
+                d.sleeps = Sleeps.set(d.sleeps, 0, n + 1);
             }
         }
 
@@ -643,6 +672,7 @@ pub fn Chance(comptime Rational: type) type {
             var d = self.durations.get(player);
             const n = d.attacking;
             if (obs == .ended) {
+                // "3-4 turns" includes the turn for the initial attack *plus* the forced attacks
                 assert(n >= 2 and n <= 3);
                 if (n != 3) try self.probability.update(1, 4 - @as(u4, n));
                 d.attacking = 0;
@@ -669,6 +699,7 @@ pub fn Chance(comptime Rational: type) type {
             const q: u4 = if (n < 3) 8 - ((n - 1) * p) else 2;
 
             if (obs == .ended) {
+                // "2-5 turns" includes the turn for the initial attack *plus* the forced attacks
                 assert(n >= 1 and n <= 4);
                 if (n != 4) try self.probability.update(p, q);
                 d.binding = 0;
@@ -802,16 +833,16 @@ test "Chance.damage" {
 
     try chance.damage(.P1, 217);
     if (showdown) {
-        try expectValue(217, chance.actions.p1.damage);
+        try expectValue(@as(u8, 217), chance.actions.p1.damage);
         try expectProbability(&chance.probability, 1, 39);
     } else {
         try expectProbability(&chance.probability, 1, 1);
-        try expectValue(0, chance.actions.p1.damage);
+        try expectValue(@as(u8, 0), chance.actions.p1.damage);
 
         try chance.commit(.P1, .hit);
 
         try expectProbability(&chance.probability, 1, 39);
-        try expectValue(217, chance.actions.p1.damage);
+        try expectValue(@as(u8, 217), chance.actions.p1.damage);
     }
 }
 
@@ -863,13 +894,13 @@ test "Chance.moveSlot" {
 
     try chance.moveSlot(.P2, 2, &ms, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(2, chance.actions.p2.move_slot);
+    try expectValue(@as(u4, 2), chance.actions.p2.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 1, &ms, 0);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(1, chance.actions.p1.move_slot);
+    try expectValue(@as(u4, 1), chance.actions.p1.move_slot);
 }
 
 test "Chance.multiHit" {
@@ -877,43 +908,43 @@ test "Chance.multiHit" {
 
     try chance.multiHit(.P1, 3);
     try expectProbability(&chance.probability, 3, 8);
-    try expectValue(3, chance.actions.p1.multi_hit);
+    try expectValue(@as(u4, 3), chance.actions.p1.multi_hit);
 
     chance.reset();
 
     try chance.multiHit(.P2, 5);
     try expectProbability(&chance.probability, 1, 8);
-    try expectValue(5, chance.actions.p2.multi_hit);
+    try expectValue(@as(u4, 5), chance.actions.p2.multi_hit);
 }
 
 test "Chance.duration" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     chance.duration(.P1, 2);
-    try expectValue(2, chance.actions.p1.duration);
+    try expectValue(@as(u4, 2), chance.actions.p1.duration);
 
     chance.reset();
 
     chance.duration(.P2, 4);
-    try expectValue(4, chance.actions.p2.duration);
+    try expectValue(@as(u4, 4), chance.actions.p2.duration);
 }
 
 test "Chance.sleep" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     for ([_]u8{ 7, 6, 5, 4, 3, 2, 1 }, 1..8) |d, i| {
-        chance.durations.p1.sleeps[0] = @intCast(i);
+        chance.durations.p1.sleeps = Sleeps.set(chance.durations.p1.sleeps, 0, @intCast(i));
         try chance.sleep(.P1, .ended);
         try expectProbability(&chance.probability, 1, d);
-        try expectValue(0, chance.durations.p1.sleeps[0]);
+        try expectValue(@as(u3, 0), Sleeps.get(chance.durations.p1.sleeps, 0));
 
         chance.reset();
 
         if (i < 7) {
-            chance.durations.p1.sleeps[0] = @intCast(i);
+            chance.durations.p1.sleeps = Sleeps.set(chance.durations.p1.sleeps, 0, @intCast(i));
             try chance.sleep(.P1, .continuing);
             try expectProbability(&chance.probability, d - 1, d);
-            try expectValue(@as(u3, @intCast(i)) + 1, chance.durations.p1.sleeps[0]);
+            try expectValue(@as(u3, @intCast(i)) + 1, Sleeps.get(chance.durations.p1.sleeps, 0));
 
             chance.reset();
         }
@@ -928,7 +959,7 @@ test "Chance.confusion" {
             chance.durations.p2.confusion = @intCast(i);
             try chance.confusion(.P2, .ended);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(0, chance.durations.p2.confusion);
+            try expectValue(@as(u3, 0), chance.durations.p2.confusion);
 
             chance.reset();
         }
@@ -951,7 +982,7 @@ test "Chance.disable" {
         chance.durations.p1.disable = @intCast(i);
         try chance.disable(.P1, .ended);
         try expectProbability(&chance.probability, 1, d);
-        try expectValue(0, chance.durations.p1.disable);
+        try expectValue(@as(u4, 0), chance.durations.p1.disable);
 
         chance.reset();
 
@@ -974,7 +1005,7 @@ test "Chance.attacking" {
             chance.durations.p2.attacking = @intCast(i);
             try chance.attacking(.P2, .ended);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(0, chance.durations.p2.attacking);
+            try expectValue(@as(u3, 0), chance.durations.p2.attacking);
 
             chance.reset();
         }
@@ -1000,7 +1031,7 @@ test "Chance.binding" {
         chance.durations.p1.binding = @intCast(i);
         try chance.binding(.P1, .ended);
         try expectProbability(&chance.probability, p, q);
-        try expectValue(0, chance.durations.p1.binding);
+        try expectValue(@as(u3, 0), chance.durations.p1.binding);
 
         chance.reset();
 
@@ -1020,7 +1051,7 @@ test "Chance.psywave" {
 
     try chance.psywave(.P2, 100, 150);
     try expectProbability(&chance.probability, 1, 150);
-    try expectValue(101, chance.actions.p2.psywave);
+    try expectValue(@as(u8, 101), chance.actions.p2.psywave);
 }
 
 test "Chance.metronome" {

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

@@ -1,12 +1,10 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
-const rng = @import("../../common/rng.zig");
 const gen1 = @import("../../gen1/data.zig");
+const rng = @import("../../common/rng.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const percent = rng.Gen12.percent;
 const Type = gen1.Type;
 

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

@@ -1,11 +1,9 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const gen1 = @import("../../gen1/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const Stats = gen1.Stats;
 const Types = gen1.Types;
 

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

@@ -1,8 +1,7 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const gen1 = @import("../../gen1/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
 const Effectiveness = gen1.Effectiveness;

package/src/lib/gen1/data.zig

@@ -1,20 +1,16 @@
-const std = @import("std");
 const builtin = @import("builtin");
-
-const pkmn = @import("../pkmn.zig");
-
+const calc = @import("calc.zig");
+const chance = @import("chance.zig");
 const data = @import("../common/data.zig");
+const mechanics = @import("mechanics.zig");
+const moves = @import("data/moves.zig");
+const pkmn = @import("../pkmn.zig");
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
-const util = @import("../common/util.zig");
-
-const moves = @import("data/moves.zig");
 const species = @import("data/species.zig");
+const std = @import("std");
 const types = @import("data/types.zig");
-
-const calc = @import("calc.zig");
-const chance = @import("chance.zig");
-const mechanics = @import("mechanics.zig");
+const util = @import("../common/util.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
@@ -47,6 +43,7 @@ const Player = data.Player;
 const Result = data.Result;
 
 const PointerType = util.PointerType;
+const isPointerTo = util.isPointerTo;
 
 const showdown = pkmn.options.showdown;
 
@@ -71,13 +68,13 @@ pub fn Battle(comptime RNG: anytype) type {
 
         /// Returns the `Side` for the given `player`.
         pub fn side(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
-            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+            assert(isPointerTo(self, Self));
             return &self.sides[@intFromEnum(player)];
         }
 
         /// Returns the `Side` of the opponent for the given `player`
         pub fn foe(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
-            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+            assert(isPointerTo(self, Self));
             return &self.sides[@intFromEnum(player.foe())];
         }
 
@@ -91,7 +88,7 @@ pub fn Battle(comptime RNG: anytype) type {
             self: anytype,
             player: Player,
         ) PointerType(@TypeOf(self), MoveDetails) {
-            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+            assert(isPointerTo(self, Self));
             return &self.last_moves[@intFromEnum(player)];
         }
 
@@ -142,7 +139,7 @@ pub const Side = extern struct {
 
     /// Returns the stored `Pokemon` corresponding to the one-indexed party `slot`.
     pub fn get(self: anytype, slot: u8) PointerType(@TypeOf(self), Pokemon) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
+        assert(isPointerTo(self, Side));
         assert(slot > 0 and slot <= 6);
         const id = self.order[slot - 1];
         assert(id > 0 and id <= 6);
@@ -151,7 +148,7 @@ pub const Side = extern struct {
 
     /// Returns the stored `Pokemon` corresponding to the `active` Pokémon (slot 1).
     pub fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
+        assert(isPointerTo(self, Side));
         return self.get(1);
     }
 };
@@ -177,7 +174,7 @@ pub const ActivePokemon = extern struct {
 
     /// Returns the active Pokémon's current move slot located at the one-indexed `mslot`.
     pub fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == ActivePokemon);
+        assert(isPointerTo(self, ActivePokemon));
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
         return &self.moves[mslot - 1];
@@ -207,7 +204,7 @@ pub const Pokemon = extern struct {
 
     /// Returns the Pokémon's original move slot located at the one-indexed `mslot`.
     pub fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Pokemon);
+        assert(isPointerTo(self, Pokemon));
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
         return &self.moves[mslot - 1];
@@ -255,7 +252,7 @@ pub const Status = enum(u8) {
 
     pub const TOX = 0b10001000;
 
-    const SLP = 0b111;
+    const SLEEP = 0b111;
 
     /// Whether or not the status `num` is the same as `status`.
     pub fn is(num: u8, status: Status) bool {
@@ -283,7 +280,7 @@ pub const Status = enum(u8) {
 
     /// Returns the duration of a sleep status.
     pub fn duration(num: u8) u3 {
-        return @intCast(num & SLP);
+        return @intCast(num & SLEEP);
     }
 
     /// Returns whether `num` reflects any status.
@@ -316,12 +313,12 @@ test Status {
     try expect(Status.is(Status.slp(5), .SLP));
     try expect(!Status.is(Status.slp(5), .EXT));
     try expect(!Status.is(Status.slp(7), .PSN));
-    try expectEqual(5, Status.duration(Status.slp(5)));
+    try expectEqual(@as(u3, 5), Status.duration(Status.slp(5)));
     try expect(Status.is(Status.slf(2), .SLP));
     try expect(Status.is(Status.slf(2), .EXT));
     try expect(Status.is(Status.TOX, .PSN));
     try expect(Status.is(Status.TOX, .EXT));
-    try expectEqual(1, Status.duration(Status.slp(1)));
+    try expectEqual(@as(u3, 1), Status.duration(Status.slp(1)));
 }
 
 /// Bitfield representation of volatile statuses and associated data in Generation I.
@@ -405,16 +402,16 @@ test Volatiles {
     try expect(!volatiles.Transform);
     try expect(!volatiles.MultiHit);
 
-    try expectEqual(235, volatiles.state);
-    try expectEqual(42, volatiles.substitute);
-    try expectEqual(2, volatiles.disable_move);
-    try expectEqual(4, volatiles.disable_duration);
-    try expectEqual(2, volatiles.confusion);
-    try expectEqual(4, volatiles.toxic);
-    try expectEqual(3, volatiles.attacks);
+    try expectEqual(@as(u16, 235), volatiles.state);
+    try expectEqual(@as(u8, 42), volatiles.substitute);
+    try expectEqual(@as(u4, 2), volatiles.disable_move);
+    try expectEqual(@as(u4, 4), volatiles.disable_duration);
+    try expectEqual(@as(u3, 2), volatiles.confusion);
+    try expectEqual(@as(u5, 4), volatiles.toxic);
+    try expectEqual(@as(u3, 3), volatiles.attacks);
 }
 
-/// Representaiton of a Pokémon's stats in Generation I.
+/// Representation of a Pokémon's stats in Generation I.
 pub fn Stats(comptime T: type) type {
     return extern struct {
         hp: T = 0,
@@ -442,9 +439,9 @@ test Stats {
     try expectEqual(0, stats.def);
 
     var base = Species.get(.Gyarados).stats;
-    try expectEqual(127, Stats(u16).calc("hp", base.hp, 0, 5120, 38));
+    try expectEqual(@as(u16, 127), Stats(u16).calc("hp", base.hp, 0, 5120, 38));
     base = Species.get(.Pidgeot).stats;
-    try expectEqual(279, Stats(u16).calc("spe", base.spe, 15, 63001, 100));
+    try expectEqual(@as(u16, 279), Stats(u16).calc("spe", base.spe, 15, 63001, 100));
 }
 
 /// Representation of a Pokémon's boosts in Generation I.
@@ -537,7 +534,7 @@ pub const Species = species.Species;
 
 test Species {
     try expectEqual(2, @intFromEnum(Species.Ivysaur));
-    try expectEqual(100, Species.get(.Mew).stats.def);
+    try expectEqual(@as(u8, 100), Species.get(.Mew).stats.def);
 }
 
 /// Representation of a Generation I type in Pokémon.
@@ -576,8 +573,8 @@ test Types {
     try expectEqual(Effectiveness.Resisted, Type.effectiveness(.Fire, .Water));
     try expectEqual(Effectiveness.Neutral, Type.effectiveness(.Normal, .Grass));
 
-    try expectEqual(3, Type.precedence(.Water, .Water));
-    try expectEqual(26, Type.precedence(.Bug, .Ghost));
+    try expectEqual(@as(u8, 3), Type.precedence(.Water, .Water));
+    try expectEqual(@as(u8, 26), Type.precedence(.Bug, .Ghost));
     try expect(Type.precedence(.Poison, .Bug) > Type.precedence(.Poison, .Poison));
 
     const t: Types = .{ .type1 = .Rock, .type2 = .Ground };
@@ -617,18 +614,18 @@ pub const DVs = struct {
 
 test DVs {
     var dvs: DVs = .{ .spc = 15, .spe = 15 };
-    try expectEqual(15, dvs.hp());
+    try expectEqual(@as(u4, 15), dvs.hp());
     dvs = .{
         .atk = 5,
         .def = 15,
         .spe = 13,
         .spc = 13,
     };
-    try expectEqual(15, dvs.hp());
+    try expectEqual(@as(u4, 15), dvs.hp());
     dvs = .{
         .def = 3,
         .spe = 10,
         .spc = 11,
     };
-    try expectEqual(13, dvs.hp());
+    try expectEqual(@as(u4, 13), dvs.hp());
 }