@pkmn/engine 0.1.0-dev.954f650d → 0.1.0-dev.95e81bfe

package/src/lib/gen1/data/moves.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");
 
@@ -1599,43 +1599,43 @@ pub const Move = enum(u8) {
         }
 
         /// Whether this effect activates during the "begin" step of move execution.
-        pub inline fn onBegin(effect: Effect) bool {
+        pub fn onBegin(effect: Effect) bool {
             return @intFromEnum(effect) > 0 and @intFromEnum(effect) <= 16;
         }
 
         /// Whether this effect lowers stats.
-        pub inline fn isStatDown(effect: Effect) bool {
+        pub fn isStatDown(effect: Effect) bool {
             return @intFromEnum(effect) > 16 and @intFromEnum(effect) <= 21;
         }
 
         /// Whether this effect activates during the "end" step of move execution.
-        pub inline fn onEnd(effect: Effect) bool {
+        pub fn onEnd(effect: Effect) bool {
             return @intFromEnum(effect) > 16 and @intFromEnum(effect) <= 31;
         }
 
         /// Whether this effect is considered to "always happen".
-        pub inline fn alwaysHappens(effect: Effect) bool {
+        pub fn alwaysHappens(effect: Effect) bool {
             return @intFromEnum(effect) > 31 and @intFromEnum(effect) <= 38;
         }
 
         /// Whether this effect is handled specially by the engine.
-        pub inline fn isSpecial(effect: Effect) bool {
+        pub fn isSpecial(effect: Effect) bool {
             // NB: isSpecial includes isMulti up to Twineedle
             return @intFromEnum(effect) > 31 and @intFromEnum(effect) <= 46;
         }
 
         /// Whether this effect is a multi-hit effect.
-        pub inline fn isMulti(effect: Effect) bool {
+        pub fn isMulti(effect: Effect) bool {
             return @intFromEnum(effect) > 44 and @intFromEnum(effect) <= 47;
         }
 
         /// Whether this effect is has chance of lowering stats.
-        pub inline fn isStatDownChance(effect: Effect) bool {
+        pub fn isStatDownChance(effect: Effect) bool {
             return @intFromEnum(effect) > 47 and @intFromEnum(effect) <= 51;
         }
 
         /// Whether this effect has a secondary chance.
-        pub inline fn isSecondaryChance(effect: Effect) bool {
+        pub fn isSecondaryChance(effect: Effect) bool {
             // NB: isSecondaryChance includes isStatDownChance as well as Twineedle
             return (@intFromEnum(effect) > 46 and @intFromEnum(effect) <= 61);
         }
@@ -1838,8 +1838,22 @@ pub const Move = enum(u8) {
     /// The number of Pokémon moves in this generation.
     pub const size = 165;
 
+    /// Pokémon moves that can be called by Metronome in this generation.
+    pub const METRONOME = init: {
+        var num = 0;
+        var moves: [163]Move = undefined;
+        for (1..Move.size) |i| {
+            if (i != @intFromEnum(Move.Metronome)) {
+                moves[num] = @enumFromInt(i);
+                num += 1;
+            }
+        }
+        assert(num == moves.len);
+        break :init moves;
+    };
+
     /// Returns the `Data` corresponding to the move.
-    pub inline fn get(id: Move) Data {
+    pub fn get(id: Move) Data {
         assert(id != .None and id != .SKIP_TURN);
         return DATA[@intFromEnum(id) - 1];
     }

package/src/lib/gen1/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");
 
@@ -1091,8 +1091,8 @@ pub const Species = enum(u8) {
     /// The number of Pokémon species in this generation.
     pub const size = 151;
 
-    /// The Pokémon's critical hit rate=io out of 256.
-    pub inline fn chance(id: Species) u8 {
+    /// The Pokémon's critical hit ratio out of 256.
+    pub fn chance(id: Species) u8 {
         assert(id != .None);
         return CHANCES[@intFromEnum(id) - 1];
     }

package/src/lib/gen1/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");
 
@@ -30,7 +30,7 @@ pub const Type = enum(u4) {
     Ice,
     Dragon,
 
-    const CHART = [15][15]Effectiveness{
+    const CHART: [15][15]Effectiveness = .{
         [_]Effectiveness{ N, N, N, N, N, R, N, I, N, N, N, N, N, N, N }, // Normal
         [_]Effectiveness{ S, N, R, R, N, S, R, I, N, N, N, N, R, S, N }, // Fighting
         [_]Effectiveness{ N, S, N, N, N, R, S, N, N, N, S, R, N, N, N }, // Flying
@@ -90,16 +90,16 @@ pub const Type = enum(u4) {
     pub const size = 15;
 
     /// 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 `t2` vs. type  `t1`.
+    /// The precedence order of Type `t2` vs. Type `t1`.
     pub fn precedence(t1: Type, t2: Type) u8 {
         for (PRECEDENCE, 0..) |matchup, i| {
             if (matchup.type1 == t1 and matchup.type2 == t2) return @intCast(i);
@@ -120,12 +120,12 @@ pub const Types = packed 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;
     }
 };

package/src/lib/gen1/data.zig

@@ -70,24 +70,24 @@ pub fn Battle(comptime RNG: anytype) type {
         rng: RNG,
 
         /// Returns the `Side` for the given `player`.
-        pub inline fn side(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+        pub fn side(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
             assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
             return &self.sides[@intFromEnum(player)];
         }
 
         /// Returns the `Side` of the opponent for the given `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())];
         }
 
         /// Returns an identifier for the active Pokémon of `player`.
-        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).order[0]));
         }
 
         /// Returns the `MoveDetails` for the given `player`.
-        pub inline fn lastMove(
+        pub fn lastMove(
             self: anytype,
             player: Player,
         ) PointerType(@TypeOf(self), MoveDetails) {
@@ -112,7 +112,7 @@ pub fn Battle(comptime RNG: anytype) type {
         /// make (i.e. on the cartridge a soft-lock occurs).
         ///
         /// This function will always return choices > 0 if `pkmn.options.showdown` is true.
-        pub fn choices(self: *Self, player: Player, request: Choice.Type, out: []Choice) u8 {
+        pub fn choices(self: *const Self, player: Player, request: Choice.Type, out: []Choice) u8 {
             return mechanics.choices(self, player, request, out);
         }
     };
@@ -141,7 +141,7 @@ pub const Side = extern struct {
     }
 
     /// Returns the stored `Pokemon` corresponding to the one-indexed party `slot`.
-    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.order[slot - 1];
@@ -150,7 +150,7 @@ pub const Side = extern struct {
     }
 
     /// Returns the stored `Pokemon` corresponding to the `active` Pokémon (slot 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);
     }
@@ -176,7 +176,7 @@ pub const ActivePokemon = extern struct {
     }
 
     /// Returns the active Pokémon's current move slot located at the one-indexed `mslot`.
-    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 == ActivePokemon);
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
@@ -206,7 +206,7 @@ pub const Pokemon = extern struct {
     }
 
     /// Returns the Pokémon's original move slot located at the one-indexed `mslot`.
-    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);
@@ -258,36 +258,36 @@ pub const Status = enum(u8) {
     const SLP = 0b111;
 
     /// Whether or not the status `num` is the same as `status`.
-    pub inline fn is(num: u8, status: Status) bool {
+    pub fn is(num: u8, status: Status) bool {
         if (status == .SLP) return Status.duration(num) > 0;
         return ((num >> @intCast(@intFromEnum(status))) & 1) != 0;
     }
 
     /// Initializes a non-sleep `status`. Use `slp` or `slf` to initialize a sleep status.
-    pub inline fn init(status: Status) u8 {
+    pub fn init(status: Status) u8 {
         assert(status != .SLP and status != .EXT);
         return @as(u8, 1) << @intCast(@intFromEnum(status));
     }
 
     /// Initializes a non self-inflicted sleep status with duration `dur`.
-    pub inline fn slp(dur: u3) u8 {
+    pub fn slp(dur: u3) u8 {
         assert(dur > 0);
         return @as(u8, dur);
     }
 
     /// Initializes a self-inflicted sleep status with duration `dur`.
-    pub inline fn slf(dur: u3) u8 {
+    pub fn slf(dur: u3) u8 {
         assert(dur > 0);
         return 0x80 | slp(dur);
     }
 
     /// Returns the duration of a sleep status.
-    pub inline fn duration(num: u8) u3 {
+    pub fn duration(num: u8) u3 {
         return @intCast(num & SLP);
     }
 
     /// Returns whether `num` reflects any status.
-    pub inline fn any(num: u8) bool {
+    pub fn any(num: u8) bool {
         return num > 0;
     }
 
@@ -316,12 +316,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(@as(u3, 5), Status.duration(Status.slp(5)));
+    try expectEqual(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(@as(u3, 1), Status.duration(Status.slp(1)));
+    try expectEqual(1, Status.duration(Status.slp(1)));
 }
 
 /// Bitfield representation of volatile statuses and associated data in Generation I.
@@ -378,15 +378,15 @@ pub const Volatiles = packed struct(u64) {
     /// The identity of whom the active Pokémon is transformed into.
     transform: u4 = 0,
     /// The remaining turns the move is disabled.
-    disabled_duration: u4 = 0,
+    disable_duration: u4 = 0,
     /// The move slot (1-4) that is disabled.
-    disabled_move: u3 = 0,
+    disable_move: u3 = 0,
     /// The number of turns toxic damage has been accumulating.
     toxic: u5 = 0,
 };
 
 test Volatiles {
-    var volatiles = Volatiles{};
+    var volatiles: Volatiles = .{};
     volatiles.Confusion = true;
     volatiles.confusion = 2;
     volatiles.Thrashing = true;
@@ -395,8 +395,8 @@ test Volatiles {
     volatiles.Substitute = true;
     volatiles.substitute = 42;
     volatiles.toxic = 4;
-    volatiles.disabled_move = 2;
-    volatiles.disabled_duration = 4;
+    volatiles.disable_move = 2;
+    volatiles.disable_duration = 4;
 
     try expect(volatiles.Confusion);
     try expect(volatiles.Thrashing);
@@ -405,13 +405,13 @@ test Volatiles {
     try expect(!volatiles.Transform);
     try expect(!volatiles.MultiHit);
 
-    try expectEqual(@as(u16, 235), volatiles.state);
-    try expectEqual(@as(u8, 42), volatiles.substitute);
-    try expectEqual(@as(u4, 2), volatiles.disabled_move);
-    try expectEqual(@as(u4, 4), volatiles.disabled_duration);
-    try expectEqual(@as(u4, 2), volatiles.confusion);
-    try expectEqual(@as(u5, 4), volatiles.toxic);
-    try expectEqual(@as(u4, 3), volatiles.attacks);
+    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);
 }
 
 /// Representaiton of a Pokémon's stats in Generation I.
@@ -442,9 +442,9 @@ 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));
 }
 
 /// Representation of a Pokémon's boosts in Generation I.
@@ -466,7 +466,7 @@ pub const Boosts = packed struct(u32) {
 };
 
 test Boosts {
-    const boosts = Boosts{ .spc = -6 };
+    const boosts: Boosts = .{ .spc = -6 };
     try expectEqual(0, boosts.atk);
     try expectEqual(-6, boosts.spc);
 }
@@ -537,7 +537,7 @@ pub const Species = species.Species;
 
 test Species {
     try expectEqual(2, @intFromEnum(Species.Ivysaur));
-    try expectEqual(@as(u8, 100), Species.get(.Mew).stats.def);
+    try expectEqual(100, Species.get(.Mew).stats.def);
 }
 
 /// Representation of a Generation I type in Pokémon.
@@ -576,8 +576,8 @@ test Types {
     try expectEqual(Effectiveness.Resisted, Type.effectiveness(.Fire, .Water));
     try expectEqual(Effectiveness.Neutral, Type.effectiveness(.Normal, .Grass));
 
-    try expectEqual(@as(u8, 3), Type.precedence(.Water, .Water));
-    try expectEqual(@as(u8, 26), Type.precedence(.Bug, .Ghost));
+    try expectEqual(3, Type.precedence(.Water, .Water));
+    try expectEqual(26, Type.precedence(.Bug, .Ghost));
     try expect(Type.precedence(.Poison, .Bug) > Type.precedence(.Poison, .Poison));
 
     const t: Types = .{ .type1 = .Rock, .type2 = .Ground };
@@ -616,19 +616,19 @@ pub const DVs = struct {
 };
 
 test DVs {
-    var dvs = DVs{ .spc = 15, .spe = 15 };
-    try expectEqual(@as(u4, 15), dvs.hp());
-    dvs = DVs{
+    var dvs: DVs = .{ .spc = 15, .spe = 15 };
+    try expectEqual(15, dvs.hp());
+    dvs = .{
         .atk = 5,
         .def = 15,
         .spe = 13,
         .spc = 13,
     };
-    try expectEqual(@as(u4, 15), dvs.hp());
-    dvs = DVs{
+    try expectEqual(15, dvs.hp());
+    dvs = .{
         .def = 3,
         .spe = 10,
         .spc = 11,
     };
-    try expectEqual(@as(u4, 13), dvs.hp());
+    try expectEqual(13, dvs.hp());
 }

package/src/lib/gen1/helpers.zig

@@ -266,7 +266,7 @@ pub const Rolls = struct {
     const PLAYERS = [_]Optional(Player){ .P1, .P2 };
 
     /// Returns a slice with the correct range of values for speed ties given the `action` state.
-    pub inline fn speedTie(action: Action) []const Optional(Player) {
+    pub fn speedTie(action: Action) []const Optional(Player) {
         return if (@field(action, "speed_tie") == .None) &PLAYER_NONE else &PLAYERS;
     }
 
@@ -275,14 +275,14 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for hits given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
-    pub inline fn hit(action: Action, parent: Optional(bool)) []const Optional(bool) {
+    pub fn hit(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .true) return &BOOL_NONE;
         return if (@field(action, "hit") == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for critical hits given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn criticalHit(
+    pub fn criticalHit(
         action: Action,
         parent: Optional(bool),
     ) []const Optional(bool) {
@@ -292,7 +292,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for secondary chances hits given the
     /// `action` state and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn secondaryChance(
+    pub fn secondaryChance(
         action: Action,
         parent: Optional(bool),
     ) []const Optional(bool) {
@@ -305,7 +305,7 @@ pub const Rolls = struct {
 
     /// Returns the range bounding damage rolls given the `action` state and the state of
     /// the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn damage(action: Action, parent: Optional(bool)) Range {
+    pub fn damage(action: Action, parent: Optional(bool)) Range {
         return if (parent == .false or @field(action, "damage") == 0)
             .{ .min = 0, .max = 1 }
         else
@@ -314,7 +314,7 @@ pub const Rolls = struct {
 
     /// Returns the max damage roll which will produce the same damage as `roll`
     /// given the base damage in `summaries`.
-    pub inline fn coalesce(player: Player, roll: u8, summaries: *calc.Summaries, cap: bool) !u8 {
+    pub fn coalesce(player: Player, roll: u8, summaries: *calc.Summaries, cap: bool) !u8 {
         if (roll == 0) return roll;
 
         const dmg = summaries.get(player.foe()).damage;
@@ -326,13 +326,13 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for confused given the `action` state
     /// and the state of the `parent` (the player's Pokémon's remaining confusion turns).
-    pub inline fn confused(action: Action, parent: u4) []const Optional(bool) {
+    pub fn confused(action: Action, parent: u4) []const Optional(bool) {
         return if (parent == 0 or @field(action, "confused") == .None) &BOOL_NONE else &BOOLS;
     }
 
     /// Returns a slice with the correct range of values for paralysis given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon was confused).
-    pub inline fn paralyzed(action: Action, parent: Optional(bool)) []const Optional(bool) {
+    pub fn paralyzed(action: Action, parent: Optional(bool)) []const Optional(bool) {
         if (parent == .true) return &BOOL_NONE;
         return if (@field(action, "paralyzed") == .None) &BOOL_NONE else &BOOLS;
     }
@@ -342,7 +342,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with a range of values for duration given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn duration(action: Action, parent: Optional(bool)) []const u1 {
+    pub fn duration(action: Action, parent: Optional(bool)) []const u1 {
         if (parent == .false) return &DURATION_NONE;
         return if (@field(action, "duration") == 0) &DURATION_NONE else &DURATION;
     }
@@ -418,7 +418,7 @@ pub const Rolls = struct {
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
     ///
     /// These slots may or **may not be valid** as slots may be unset / have 0 PP.
-    pub inline fn moveSlot(action: Action, parent: Optional(bool)) []const u4 {
+    pub fn moveSlot(action: Action, parent: Optional(bool)) []const u4 {
         if (parent == .false) return &SLOT_NONE;
         return if (@field(action, "move_slot") == 0) &SLOT_NONE else &SLOT;
     }
@@ -428,7 +428,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for multi hit given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn multiHit(action: Action, parent: Optional(bool)) []const u4 {
+    pub fn multiHit(action: Action, parent: Optional(bool)) []const u4 {
         if (parent == .false) return &MULTI_NONE;
         return if (@field(action, "multi_hit") == 0) &MULTI_NONE else &MULTI;
     }
@@ -442,7 +442,7 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for psywave given the `action` state,
     /// the `side`, and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub inline fn psywave(
+    pub fn psywave(
         action: Action,
         side: *data.Side,
         parent: Optional(bool),
@@ -455,36 +455,21 @@ pub const Rolls = struct {
     }
 
     const MOVE_NONE = [_]Move{.None};
-    const MOVES = init: {
-        var moves: [Move.size - 2]Move = undefined;
-        var i: usize = 0;
-        for (@typeInfo(Move).Enum.fields) |f| {
-            if (!(std.mem.eql(u8, f.name, "None") or
-                std.mem.eql(u8, f.name, "Metronome") or
-                std.mem.eql(u8, f.name, "Struggle") or
-                std.mem.eql(u8, f.name, "SKIP_TURN")))
-            {
-                moves[i] = @field(Move, f.name);
-                i += 1;
-            }
-        }
-        break :init moves;
-    };
 
     /// Returns a slice with the correct range of values for metronome given the `action` state.
-    pub inline fn metronome(action: Action) []const Move {
-        return if (@field(action, "metronome") == .None) &MOVE_NONE else &MOVES;
+    pub fn metronome(action: Action) []const Move {
+        return if (@field(action, "metronome") == .None) &MOVE_NONE else &Move.METRONOME;
     }
 };
 
 test "Rolls.speedTie" {
-    const actions = Actions{ .p1 = .{ .speed_tie = .P2 } };
+    const actions: Actions = .{ .p1 = .{ .speed_tie = .P2 } };
     try expectEqualSlices(Optional(Player), &.{ .P1, .P2 }, Rolls.speedTie(actions.p1));
     try expectEqualSlices(Optional(Player), &.{.None}, Rolls.speedTie(actions.p2));
 }
 
 test "Rolls.damage" {
-    const actions = Actions{ .p2 = .{ .damage = 221 } };
+    const actions: Actions = .{ .p2 = .{ .damage = 221 } };
     try expectEqual(Rolls.Range{ .min = 0, .max = 1 }, Rolls.damage(actions.p1, .None));
     try expectEqual(Rolls.Range{ .min = 217, .max = 256 }, Rolls.damage(actions.p2, .None));
     try expectEqual(Rolls.Range{ .min = 0, .max = 1 }, Rolls.damage(actions.p2, .false));
@@ -493,16 +478,16 @@ test "Rolls.damage" {
 test "Rolls.coalesce" {
     var summaries =
         calc.Summaries{ .p1 = .{ .damage = .{ .base = 74, .final = 69, .capped = true } } };
-    try expectEqual(@as(u8, 0), try Rolls.coalesce(.P2, 0, &summaries, false));
-    try expectEqual(@as(u8, 241), try Rolls.coalesce(.P2, 238, &summaries, false));
-    try expectEqual(@as(u8, 255), try Rolls.coalesce(.P2, 238, &summaries, true));
+    try expectEqual(0, try Rolls.coalesce(.P2, 0, &summaries, false));
+    try expectEqual(241, try Rolls.coalesce(.P2, 238, &summaries, false));
+    try expectEqual(255, try Rolls.coalesce(.P2, 238, &summaries, true));
     summaries.p1.damage.final = 74;
-    try expectEqual(@as(u8, 217), try Rolls.coalesce(.P2, 217, &summaries, false));
-    try expectEqual(@as(u8, 255), try Rolls.coalesce(.P2, 217, &summaries, true));
+    try expectEqual(217, try Rolls.coalesce(.P2, 217, &summaries, false));
+    try expectEqual(255, try Rolls.coalesce(.P2, 217, &summaries, true));
 }
 
 test "Rolls.hit" {
-    const actions = Actions{ .p2 = .{ .hit = .true } };
+    const actions: Actions = .{ .p2 = .{ .hit = .true } };
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.hit(actions.p1, .None));
     try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.hit(actions.p2, .None));
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.hit(actions.p2, .true));
@@ -510,7 +495,7 @@ test "Rolls.hit" {
 }
 
 test "Rolls.secondaryChance" {
-    const actions = Actions{ .p1 = .{ .secondary_chance = .true } };
+    const actions: Actions = .{ .p1 = .{ .secondary_chance = .true } };
     try expectEqualSlices(
         Optional(bool),
         &.{ .false, .true },
@@ -521,7 +506,7 @@ test "Rolls.secondaryChance" {
 }
 
 test "Rolls.criticalHit" {
-    const actions = Actions{ .p1 = .{ .critical_hit = .true } };
+    const actions: Actions = .{ .p1 = .{ .critical_hit = .true } };
     try expectEqualSlices(
         Optional(bool),
         &.{ .false, .true },
@@ -532,14 +517,14 @@ test "Rolls.criticalHit" {
 }
 
 test "Rolls.confused" {
-    const actions = Actions{ .p2 = .{ .confused = .true } };
+    const actions: Actions = .{ .p2 = .{ .confused = .true } };
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.confused(actions.p1, 1));
     try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.confused(actions.p2, 1));
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.confused(actions.p2, 0));
 }
 
 test "Rolls.paralyzed" {
-    const actions = Actions{ .p2 = .{ .paralyzed = .true } };
+    const actions: Actions = .{ .p2 = .{ .paralyzed = .true } };
     try expectEqualSlices(Optional(bool), &.{.None}, Rolls.paralyzed(actions.p1, .None));
     try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.paralyzed(actions.p2, .None));
     try expectEqualSlices(Optional(bool), &.{ .false, .true }, Rolls.paralyzed(actions.p2, .false));
@@ -547,7 +532,7 @@ test "Rolls.paralyzed" {
 }
 
 test "Rolls.duration" {
-    const actions = Actions{ .p2 = .{ .duration = 3 } };
+    const actions: Actions = .{ .p2 = .{ .duration = 3 } };
     try expectEqualSlices(u1, &.{0}, Rolls.duration(actions.p1, .None));
     try expectEqualSlices(u1, &.{1}, Rolls.duration(actions.p2, .None));
     try expectEqualSlices(u1, &.{0}, Rolls.duration(actions.p2, .false));
@@ -757,27 +742,27 @@ test "Rolls.binding" {
 }
 
 test "Rolls.moveSlot" {
-    const actions = Actions{ .p2 = .{ .move_slot = 3 } };
+    const actions: Actions = .{ .p2 = .{ .move_slot = 3 } };
     try expectEqualSlices(u4, &.{0}, Rolls.moveSlot(actions.p1, .None));
     try expectEqualSlices(u4, &.{ 1, 2, 3, 4 }, Rolls.moveSlot(actions.p2, .None));
     try expectEqualSlices(u4, &.{0}, Rolls.moveSlot(actions.p2, .false));
 }
 
 test "Rolls.multiHit" {
-    const actions = Actions{ .p2 = .{ .multi_hit = 3 } };
+    const actions: Actions = .{ .p2 = .{ .multi_hit = 3 } };
     try expectEqualSlices(u4, &.{0}, Rolls.multiHit(actions.p1, .None));
     try expectEqualSlices(u4, &.{ 2, 3, 4, 5 }, Rolls.multiHit(actions.p2, .None));
     try expectEqualSlices(u4, &.{0}, Rolls.multiHit(actions.p2, .false));
 }
 
 test "Rolls.metronome" {
-    const actions = Actions{ .p2 = .{ .metronome = .Surf } };
+    const actions: Actions = .{ .p2 = .{ .metronome = .Surf } };
     try expectEqualSlices(Move, &.{.None}, Rolls.metronome(actions.p1));
     try expectEqual(@as(Move, @enumFromInt(24)), Rolls.metronome(actions.p2)[23]);
 }
 
 test "Rolls.psywave" {
-    const actions = Actions{ .p2 = .{ .psywave = 79 } };
+    const actions: Actions = .{ .p2 = .{ .psywave = 79 } };
     var side = Side.init(&[_]Pokemon{.{
         .species = .Bulbasaur,
         .level = 100,
@@ -786,9 +771,9 @@ test "Rolls.psywave" {
 
     try expectEqualSlices(u8, &.{0}, Rolls.psywave(actions.p1, &side, .None));
     var rolls = Rolls.psywave(actions.p2, &side, .None);
-    try expectEqual(@as(u8, 150), rolls[rolls.len - 1]);
+    try expectEqual(150, rolls[rolls.len - 1]);
     side.stored().level = 81;
     rolls = Rolls.psywave(actions.p2, &side, .None);
-    try expectEqual(@as(u8, 121), rolls[rolls.len - 1]);
+    try expectEqual(121, rolls[rolls.len - 1]);
     try expectEqualSlices(u8, &.{0}, Rolls.psywave(actions.p2, &side, .false));
 }