@pkmn/engine 0.1.0-dev.3de821b9 → 0.1.0-dev.3f3af84c

package/src/lib/gen2/chance.zig

@@ -8,9 +8,9 @@ const expectEqual = std.testing.expectEqual;
 
 const options = @import("../common/options.zig");
 const rational = @import("../common/rational.zig");
-const rng = @import("../common/rng.zig");
 const util = @import("../common/util.zig");
 
+const Array = @import("../common/array.zig").Array;
 const Player = @import("../common/data.zig").Player;
 const Optional = @import("../common/optional.zig").Optional;
 
@@ -19,13 +19,18 @@ const data = @import("data.zig");
 const enabled = options.chance;
 const showdown = options.showdown;
 
-const Gen12 = rng.Gen12;
+const PointerType = util.PointerType;
+const isPointerTo = util.isPointerTo;
 
 const Move = data.Move;
 const Type = data.Type;
 const Effectiveness = data.Effectiveness;
 const TriAttack = data.TriAttack;
 
+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 II battle `update`. This can additionally be provided as input
 /// to the `update` call to override the normal behavior of the RNG in order to force specific
@@ -37,8 +42,8 @@ pub const Actions = extern struct {
     p2: Action = .{},
 
     /// 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;
     }
 
@@ -52,15 +57,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,
                 }
             }
@@ -82,10 +87,9 @@ pub const Actions = extern struct {
     }
 };
 
-// TODO: ziglang/zig#19730
 test Actions {
-    const a: Actions = .{ .p1 = .{ .hit = .true, .critical_hit = .false, .damage = 245 } };
-    const b: Actions = .{ .p1 = .{ .hit = .false, .critical_hit = .true, .damage = 246 } };
+    const a: Actions = .{ .p1 = .{ .hit = .true, .confused = .false, .damages = 245 } };
+    const b: Actions = .{ .p1 = .{ .hit = .false, .confused = .true, .damages = 246 } };
     const c: Actions = .{ .p1 = .{ .hit = .true } };
 
     try expect(a.eql(a));
@@ -101,11 +105,19 @@ test Actions {
     try expect(!c.matches(a));
 }
 
+/// Observation made about a duration - whether the duration has started, been continued, or ended.
+pub const Observation = enum { started, continuing, ended };
+
+pub const Damages = Array(5, u8);
+pub const Criticals = Array(5, Optional(bool));
+
 /// Information about the RNG that was observed during a Generation II battle `update` for a
 /// single player.
 pub const Action = packed struct(u128) {
-    /// If not 0, the roll to be returned Rolls.damage.
-    damage: u8 = 0,
+    /// TODO
+    damages: Damages.T = 0,
+    // TODO
+    critical_hits: Criticals.T = 0,
 
     /// If not None, the Player to be returned by Rolls.speedTie.
     speed_tie: Optional(Player) = .None,
@@ -113,50 +125,58 @@ pub const Action = packed struct(u128) {
     quick_claw: Optional(bool) = .None,
     /// If not None, the value to return for Rolls.hit.
     hit: Optional(bool) = .None,
-    /// If not None, the value to be returned by Rolls.criticalHit.
-    critical_hit: Optional(bool) = .None,
-
     /// If not None, the value to return for Rolls.confused.
     confused: Optional(bool) = .None,
+
     /// If not None, the value to return for Rolls.attract.
     attract: Optional(bool) = .None,
     /// If not None, the value to return for Rolls.paralyzed.
     paralyzed: Optional(bool) = .None,
     /// If not None, the value to return for Rolls.defrost.
     defrost: Optional(bool) = .None,
-
     /// If not None, the value to be returned for Rolls.secondaryChance.
     secondary_chance: Optional(bool) = .None,
+
     /// If not None, the value to be returned for Rolls.item (Focus Band / King's Rock).
     item: Optional(bool) = .None,
     /// If not None, the value to be returned for Rolls.protect.
     protect: Optional(bool) = .None,
     /// If not None, the value to return for Rolls.triAttack.
     tri_attack: Optional(TriAttack) = .None,
+    /// If not 0, the value to return for Rolls.tripleKick.
+    triple_kick: u2 = 0,
 
     /// If not 0, (present - 1) * 40 should be returned as the base power for Rolls.present.
     present: u3 = 0,
     /// If not 0, magnitude + 3 should be returned as the number for Rolls.magnitude.
     magnitude: u3 = 0,
-    /// If not 0, the value to return for Rolls.tripleKick.
-    triple_kick: u2 = 0,
-
-    /// If not 0,  the amount of PP to deduct for Rolls.spite.
+    /// If not 0, the amount of PP to deduct for Rolls.spite.
     spite: u3 = 0,
-    /// If not None, the value to return for Rolls.conversion2.
-    conversion_2: Optional(Type) = .None,
-
     /// If not 0, the move slot (1-4) to return in Rolls.moveSlot. If present as an override,
     /// invalid values (eg. due to empty move slots or 0 PP) will be ignored.
-    move_slot: u4 = 0,
+    move_slot: u3 = 0,
     /// If not 0, the party slot (1-6) to return in Rolls.forceSwitch. If present as an override,
     /// invalid values (eg. due to empty party slots or fainted members) will be ignored.
-    force_switch: u4 = 0,
-
+    force_switch: u3 = 0,
     /// If not 0, the value (2-5) to return for Rolls.distribution for multi hit.
-    multi_hit: u4 = 0,
+    multi_hit: u3 = 0,
+
+    sleep: Optional(Observation) = .None,
+    /// TODO
+    confusion: Optional(Observation) = .None,
+    /// TODO
+    disable: Optional(Observation) = .None,
+    /// TODO
+    attacking: Optional(Observation) = .None,
+    /// TODO
+    binding: Optional(Observation) = .None,
+    /// TODO
+    encore: Optional(Observation) = .None,
+
     /// If not 0, the value to by one of the Rolls.*Duration rolls.
-    duration: u4 = 0,
+    duration: u3 = 0,
+    /// If not None, the value to return for Rolls.conversion2.
+    conversion_2: Optional(Type) = .None,
 
     /// If not 0, psywave should be returned as the damage roll for Rolls.psywave.
     psywave: u8 = 0,
@@ -164,8 +184,6 @@ pub const Action = packed struct(u128) {
     /// If not None, the Move to return for Rolls.metronome.
     metronome: Move = .None,
 
-    _: u48 = 0, // TODO
-
     pub const Field = std.meta.FieldEnum(Action);
 
     pub fn format(a: Action, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
@@ -176,10 +194,10 @@ pub const Action = packed struct(u128) {
     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});
@@ -193,7 +211,7 @@ pub const Action = packed struct(u128) {
                     }
                     printed = true;
                 },
-                .Int => if (val != 0) {
+                Int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -255,19 +273,21 @@ pub fn Chance(comptime Rational: type) type {
             self.actions.get(player).hit = if (ok) .true else .false;
         }
 
-        pub fn criticalHit(self: *Self, player: Player, crit: bool, rate: u8) Error!void {
+        pub fn criticalHit(self: *Self, player: Player, i: u3, crit: bool, rate: u8) Error!void {
             if (!enabled) return;
 
             const n = if (crit) rate else @as(u8, @intCast(256 - @as(u9, rate)));
             try self.probability.update(n, 256);
-            self.actions.get(player).critical_hit = if (crit) .true else .false;
+            var a = self.actions.get(player);
+            a.critical_hits = Criticals.set(a.critical_hits, i, if (crit) .true else .false);
         }
 
-        pub fn damage(self: *Self, player: Player, roll: u8) Error!void {
+        pub fn damage(self: *Self, player: Player, i: u3, roll: u8) Error!void {
             if (!enabled) return;
 
             try self.probability.update(1, 39);
-            self.actions.get(player).damage = roll;
+            var a = self.actions.get(player);
+            a.damages = Damages.set(a.damages, i, roll);
         }
 
         pub fn confused(self: *Self, player: Player, cfz: bool) Error!void {
@@ -419,7 +439,7 @@ pub fn Chance(comptime Rational: type) type {
             self.actions.get(player).multi_hit = n;
         }
 
-        pub fn duration(self: *Self, player: Player, turns: u4) void {
+        pub fn duration(self: *Self, player: Player, turns: u3) void {
             if (!enabled) return;
 
             self.actions.get(player).duration = if (options.key) 2 else turns;
@@ -474,22 +494,22 @@ test "Chance.hit" {
 test "Chance.criticalHit" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
-    try chance.criticalHit(.P1, true, 17);
-    try expectValue(Optional(bool).true, chance.actions.p1.critical_hit);
+    try chance.criticalHit(.P1, 0, true, 17);
+    try expectValue(Optional(bool).true, Criticals.get(chance.actions.p1.critical_hits, 0));
     try expectProbability(&chance.probability, 17, 256);
 
     chance.reset();
 
-    try chance.criticalHit(.P2, false, 5);
+    try chance.criticalHit(.P2, 1, false, 5);
     try expectProbability(&chance.probability, 251, 256);
-    try expectValue(Optional(bool).false, chance.actions.p2.critical_hit);
+    try expectValue(Optional(bool).false, Criticals.get(chance.actions.p2.critical_hits, 1));
 }
 
 test "Chance.damage" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
-    try chance.damage(.P1, 217);
-    try expectValue(217, chance.actions.p1.damage);
+    try chance.damage(.P1, 0, 219);
+    try expectValue(@as(u8, 219), Damages.get(chance.actions.p1.damages, 0));
     try expectProbability(&chance.probability, 1, 39);
 }
 
@@ -614,7 +634,7 @@ test "Chance.present" {
     } else {
         try expectProbability(&chance.probability, 25, 256);
     }
-    try expectValue(4, chance.actions.p2.present);
+    try expectValue(@as(u3, 4), chance.actions.p2.present);
 
     chance.reset();
 
@@ -624,7 +644,7 @@ test "Chance.present" {
     } else {
         try expectProbability(&chance.probability, 51, 256);
     }
-    try expectValue(1, chance.actions.p1.present);
+    try expectValue(@as(u3, 1), chance.actions.p1.present);
 }
 
 test "Chance.magnitude" {
@@ -636,7 +656,7 @@ test "Chance.magnitude" {
     } else {
         try expectProbability(&chance.probability, 13, 256);
     }
-    try expectValue(7, chance.actions.p2.magnitude);
+    try expectValue(@as(u3, 7), chance.actions.p2.magnitude);
 
     chance.reset();
 
@@ -646,7 +666,7 @@ test "Chance.magnitude" {
     } else {
         try expectProbability(&chance.probability, 51, 256);
     }
-    try expectValue(5, chance.actions.p1.magnitude);
+    try expectValue(@as(u3, 5), chance.actions.p1.magnitude);
 }
 
 test "Chance.tripleKick" {
@@ -654,7 +674,7 @@ test "Chance.tripleKick" {
 
     try chance.tripleKick(.P1, 2);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(2, chance.actions.p1.triple_kick);
+    try expectValue(@as(u2, 2), chance.actions.p1.triple_kick);
 }
 
 test "Chance.spite" {
@@ -662,7 +682,7 @@ test "Chance.spite" {
 
     try chance.spite(.P1, 3);
     try expectProbability(&chance.probability, 1, 4);
-    try expectValue(3, chance.actions.p1.spite);
+    try expectValue(@as(u3, 3), chance.actions.p1.spite);
 }
 
 test "Chance.conversion2" {
@@ -689,7 +709,7 @@ test "Chance.psywave" {
 
     try chance.psywave(.P2, 100, 150);
     try expectProbability(&chance.probability, 1, 150);
-    try expectValue(100, chance.actions.p2.psywave);
+    try expectValue(@as(u8, 100), chance.actions.p2.psywave);
 }
 
 test "Chance.metronome" {
@@ -705,19 +725,19 @@ test "Chance.moveSlot" {
 
     try chance.moveSlot(.P2, 2, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(2, chance.actions.p2.move_slot);
+    try expectValue(@as(u3, 2), chance.actions.p2.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 1, 3);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(1, chance.actions.p1.move_slot);
+    try expectValue(@as(u3, 1), chance.actions.p1.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 4, 1);
     try expectProbability(&chance.probability, 1, 1);
-    try expectValue(4, chance.actions.p1.move_slot);
+    try expectValue(@as(u3, 4), chance.actions.p1.move_slot);
 }
 
 test "Chance.forceSwitch" {
@@ -725,19 +745,19 @@ test "Chance.forceSwitch" {
 
     try chance.forceSwitch(.P2, 2, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(2, chance.actions.p2.force_switch);
+    try expectValue(@as(u3, 2), chance.actions.p2.force_switch);
 
     chance.reset();
 
     try chance.forceSwitch(.P1, 1, 3);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(1, chance.actions.p1.force_switch);
+    try expectValue(@as(u3, 1), chance.actions.p1.force_switch);
 
     chance.reset();
 
     try chance.forceSwitch(.P1, 4, 1);
     try expectProbability(&chance.probability, 1, 1);
-    try expectValue(4, chance.actions.p1.force_switch);
+    try expectValue(@as(u3, 4), chance.actions.p1.force_switch);
 }
 
 test "Chance.multiHit" {
@@ -745,20 +765,20 @@ 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(u3, 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(u3, 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(u3, 2), chance.actions.p1.duration);
 }
 
 pub fn expectProbability(r: anytype, p: u64, q: u64) !void {
@@ -800,12 +820,12 @@ const Null = struct {
         _ = .{ self, player, ok, accuracy };
     }
 
-    pub fn criticalHit(self: Null, player: Player, crit: bool, rate: u8) Error!void {
-        _ = .{ self, player, crit, rate };
+    pub fn criticalHit(self: Null, player: Player, i: u3, crit: bool, rate: u8) Error!void {
+        _ = .{ self, player, i, crit, rate };
     }
 
-    pub fn damage(self: Null, player: Player, roll: u8) Error!void {
-        _ = .{ self, player, roll };
+    pub fn damage(self: Null, player: Player, i: u3, roll: u8) Error!void {
+        _ = .{ self, player, i, roll };
     }
 
     pub fn confused(self: Null, player: Player, ok: bool) Error!void {
@@ -876,7 +896,7 @@ const Null = struct {
         _ = .{ self, player, move, n };
     }
 
-    pub fn duration(self: Null, player: Player, turns: u4) void {
+    pub fn duration(self: Null, player: Player, turns: u3) void {
         _ = .{ self, player, turns };
     }
 };

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

@@ -1,11 +1,9 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const data = @import("../../gen2/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const Type = data.Type;
 
 /// Representation of a held item in Generation II Pokémon.

package/src/lib/gen2/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 gen2 = @import("../../gen2/data.zig");
+const rng = @import("../../common/rng.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const percent = rng.Gen12.percent;
 const Type = gen2.Type;
 

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

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

package/src/lib/gen2/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/gen2/data.zig

@@ -1,24 +1,20 @@
-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 protocol = @import("../common/protocol.zig");
-const rng = @import("../common/rng.zig");
-const util = @import("../common/util.zig");
 
+const builtin = @import("builtin");
+const calc = @import("calc.zig");
+const chance = @import("chance.zig");
+const data = @import("../common/data.zig");
+const gen1 = @import("../gen1/data.zig");
 const items = @import("data/items.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 species = @import("data/species.zig");
+const std = @import("std");
 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 util = @import("../common/util.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
@@ -45,6 +41,7 @@ const Player = data.Player;
 const Result = data.Result;
 
 const PointerType = util.PointerType;
+const isPointerTo = util.isPointerTo;
 
 const showdown = pkmn.options.showdown;
 
@@ -63,12 +60,12 @@ pub fn Battle(comptime RNG: anytype) type {
         _: [padding]u8 = .{0} ** padding,
 
         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)];
         }
 
         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())];
         }
 
@@ -134,7 +131,7 @@ pub const Side = extern struct {
     }
 
     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.pokemon[slot - 1].position;
         assert(id > 0 and id <= 6);
@@ -142,7 +139,7 @@ pub const Side = extern struct {
     }
 
     pub fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
+        assert(isPointerTo(self, Side));
         return self.get(1);
     }
 
@@ -176,7 +173,7 @@ pub const ActivePokemon = extern struct {
     }
 
     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];
@@ -201,7 +198,7 @@ pub const Pokemon = extern struct {
     }
 
     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];
@@ -248,12 +245,12 @@ test DVs {
     var dvs = DVs.from(.Mewtwo, .{ .def = 13 });
     try expectEqual(Gender.Unknown, dvs.gender);
     try expectEqual(Type.Ice, dvs.type);
-    try expectEqual(70, dvs.power());
+    try expectEqual(@as(u8, 70), dvs.power());
 
     dvs = DVs.from(.Pikachu, .{ .spc = 14 });
     try expectEqual(Gender.Male, dvs.gender);
     try expectEqual(Type.Dark, dvs.type);
-    try expectEqual(69, dvs.power());
+    try expectEqual(@as(u8, 69), dvs.power());
 
     dvs = DVs.from(.Cyndaquil, .{ .atk = 1, .def = 3, .spe = 10, .spc = 9 });
     try expectEqual(Gender.Female, dvs.gender);
@@ -380,9 +377,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));
 }
 
 pub const Boosts = packed struct(u32) {
@@ -428,8 +425,8 @@ test Move {
     try expectEqual(Move.Effect.ConfusionChance, move.effect);
     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 expectEqual(@as(u8, 5), Move.pp(.DynamicPunch));
+    try expectEqual(@as(i8, -1), Move.get(.Counter).priority);
     try expect(!move.effect.isHighCritical());
     try expect(Move.get(.KarateChop).effect.isHighCritical());
     try expect(Move.get(.RazorWind).effect.isHighCritical());
@@ -439,7 +436,7 @@ pub const Species = species.Species;
 
 test Species {
     try expectEqual(152, @intFromEnum(Species.Chikorita));
-    try expectEqual(100, Species.get(.Celebi).stats.spd);
+    try expectEqual(@as(u8, 100), Species.get(.Celebi).stats.spd);
 }
 
 pub const Type = types.Type;
@@ -452,7 +449,7 @@ test Types {
     try expect(!Type.Steel.special());
     try expect(Type.Dark.special());
 
-    try expectEqual(3, Type.Water.precedence());
+    try expectEqual(@as(u8, 3), Type.Water.precedence());
     try expect(Type.Bug.precedence() > Type.Poison.precedence());
 
     try expectEqual(Effectiveness.Super, Type.effectiveness(.Ghost, .Psychic));

package/src/lib/gen2/generated.zig

@@ -1,37 +1,32 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const common = @import("../common/data.zig");
-
 const data = @import("data.zig");
 const mechanics = @import("mechanics.zig");
+const std = @import("std");
 
-const Player = common.Player;
-const Result = common.Result;
-
-const Effectiveness = data.Effectiveness;
-const Move = data.Move;
-
-const Effects = mechanics.Effects;
-const State = mechanics.State;
-
-const canMove = mechanics.canMove;
+const adjustDamage = mechanics.adjustDamage;
+const afterMove = mechanics.afterMove;
+const applyDamage = mechanics.applyDamage;
+const buildRage = mechanics.buildRage;
+const calcDamage = mechanics.calcDamage;
 const canCharge = mechanics.canCharge;
+const canMove = mechanics.canMove;
+const checkCriticalHit = mechanics.checkCriticalHit;
+const checkHit = mechanics.checkHit;
 const decrementPP = mechanics.decrementPP;
+const destinyBond = mechanics.destinyBond;
 const doMove = mechanics.doMove;
-const checkHit = mechanics.checkHit;
-const checkCriticalHit = mechanics.checkCriticalHit;
-const calcDamage = mechanics.calcDamage;
-const adjustDamage = mechanics.adjustDamage;
-const randomizeDamage = mechanics.randomizeDamage;
-const applyDamage = mechanics.applyDamage;
-const reportOutcome = mechanics.reportOutcome;
 const effectChance = mechanics.effectChance;
-const afterMove = mechanics.afterMove;
-const buildRage = mechanics.buildRage;
+const Effectiveness = data.Effectiveness;
+const Effects = mechanics.Effects;
 const kingsRock = mechanics.kingsRock;
-const destinyBond = mechanics.destinyBond;
+const Move = data.Move;
+const Player = common.Player;
+const randomizeDamage = mechanics.randomizeDamage;
+const reportOutcome = mechanics.reportOutcome;
+const Result = common.Result;
+const State = mechanics.State;
 
 const SECONDARY = true;
 const KINGS = true;