@pkmn/engine 0.1.0-dev.d716e940 → 0.1.0-dev.d73cd76c

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");
+//! Code generated by `tools/generate` - manual edits will be overwritten.
 
 const gen1 = @import("../../gen1/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const Stats = gen1.Stats;
 const Types = gen1.Types;
 
@@ -1091,15 +1089,15 @@ 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[@enumToInt(id) - 1];
+        return CHANCES[@intFromEnum(id) - 1];
     }
 
     /// Returns the `Data` corresponding to the species.
     pub fn get(id: Species) Data {
         assert(id != .None);
-        return DATA[@enumToInt(id) - 1];
+        return DATA[@intFromEnum(id) - 1];
     }
 };

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

@@ -1,8 +1,7 @@
-//! Code generated by `tools/generate` - manual edits will be overwritten
-
-const std = @import("std");
+//! Code generated by `tools/generate` - manual edits will be overwritten.
 
 const gen1 = @import("../../gen1/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
 const Effectiveness = gen1.Effectiveness;
@@ -30,7 +29,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,26 +89,26 @@ 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 {
-        return @enumToInt(self) >= @enumToInt(Type.Fire);
+    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 {
-        return CHART[@enumToInt(t1)][@enumToInt(t2)];
+    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 `t1` vs. Type `t2`.
     pub fn precedence(t1: Type, t2: Type) u8 {
         for (PRECEDENCE, 0..) |matchup, i| {
-            if (matchup.type1 == t1 and matchup.type2 == t2) return @intCast(u8, i);
+            if (matchup.type1 == t1 and matchup.type2 == t2) return @intCast(i);
         }
         unreachable;
     }
 };
 
 /// Representation of a Pokémon's typing.
-pub const Types = packed struct {
+pub const Types = packed struct(u8) {
     /// A Pokémon's primary type.
     type1: Type = .Normal,
     /// A Pokémon's secondary type (may be identical to its primary type).
@@ -120,12 +119,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

@@ -1,16 +1,16 @@
-const std = @import("std");
 const builtin = @import("builtin");
-
+const calc = @import("calc.zig");
+const chance = @import("chance.zig");
 const data = @import("../common/data.zig");
-const options = @import("../common/options.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 moves = @import("data/moves.zig");
 const species = @import("data/species.zig");
+const std = @import("std");
 const types = @import("data/types.zig");
-
-const mechanics = @import("mechanics.zig");
+const util = @import("../common/util.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
@@ -18,11 +18,11 @@ const expect = std.testing.expect;
 
 /// The minimum size in bytes required to hold all Generation I choice options.
 pub const MAX_CHOICES: usize = 9; // move 1..4, switch 2..6
-/// The optimal size in bytes required to hold all Generation I choice options.
-/// At least as large as MAX_CHOICES.
+/// The maximum number of bytes possibly logged by a single Generation I update.
 pub const MAX_LOGS: usize = 180;
 
-/// The maximum number of bytes possibly logged by a single Generation I update.
+/// The optimal size in bytes required to hold all Generation I choice options.
+/// At least as large as MAX_CHOICES.
 pub const CHOICES_SIZE = if (builtin.mode == .ReleaseSmall)
     MAX_CHOICES
 else
@@ -34,12 +34,18 @@ 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 I.
+pub const NULL = pkmn.battle.options(protocol.NULL, chance.NULL, calc.NULL);
+
 const Choice = data.Choice;
 const ID = data.ID;
 const Player = data.Player;
 const Result = data.Result;
 
-const showdown = options.showdown;
+const PointerType = util.PointerType;
+const isPointerTo = util.isPointerTo;
+
+const showdown = pkmn.options.showdown;
 
 /// The pseudo random number generator used by Generation I.
 pub const PRNG = rng.PRNG(1);
@@ -56,29 +62,41 @@ pub fn Battle(comptime RNG: anytype) type {
         /// The last damage dealt by either side.
         last_damage: u16 = 0,
         /// Details about the last move selected/used by each player required to detect desyncs.
-        last_moves: MoveDetails = .{},
+        last_moves: [2]MoveDetails = @splat(.{}),
         /// The pseudo random number generator.
         rng: RNG,
 
         /// Returns the `Side` for the given `player`.
-        pub inline fn side(self: *Self, player: Player) *Side {
-            return &self.sides[@enumToInt(player)];
+        pub fn side(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+            assert(isPointerTo(self, Self));
+            return &self.sides[@intFromEnum(player)];
         }
 
         /// Returns the `Side` of the opponent for the given `player`
-        pub inline fn foe(self: *Self, player: Player) *Side {
-            return &self.sides[@enumToInt(player.foe())];
+        pub fn foe(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
+            assert(isPointerTo(self, Self));
+            return &self.sides[@intFromEnum(player.foe())];
         }
 
         /// Returns an identifier for the active Pokémon of `player`.
-        pub inline fn active(self: *Self, player: Player) ID {
-            return player.ident(@intCast(u3, self.side(player).order[0]));
+        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 fn lastMove(
+            self: anytype,
+            player: Player,
+        ) PointerType(@TypeOf(self), MoveDetails) {
+            assert(isPointerTo(self, Self));
+            return &self.last_moves[@intFromEnum(player)];
         }
 
         /// Returns the result of applying Player 1's choice `c1` and Player 2's choice `c2` to the
-        /// battle, optionally writing protocol message logs to `log` if `options.log` is enabled.
-        pub fn update(self: *Self, c1: Choice, c2: Choice, log: anytype) !Result {
-            return mechanics.update(self, c1, c2, log);
+        /// battle, optionally writing protocol message logs to `options.log` if `pkmn.options.log`
+        /// is enabled.
+        pub fn update(self: *Self, c1: Choice, c2: Choice, options: anytype) !Result {
+            return mechanics.update(self, c1, c2, options);
         }
 
         /// Fills in at most `out.len` possible choices for the `player` given the previous `result`
@@ -90,8 +108,8 @@ pub fn Battle(comptime RNG: anytype) type {
         /// interacts with Disable, in which case there are no possible choices for the player to
         /// make (i.e. on the cartridge a soft-lock occurs).
         ///
-        /// This function will always return a number of choices > 0 if options.showdown is true.
-        pub fn choices(self: *Self, player: Player, request: Choice.Type, out: []Choice) u8 {
+        /// This function will always return choices > 0 if `pkmn.options.showdown` is true.
+        pub fn choices(self: *const Self, player: Player, request: Choice.Type, out: []Choice) u8 {
             return mechanics.choices(self, player, request, out);
         }
     };
@@ -104,12 +122,12 @@ test Battle {
 /// Representation of one side of a Generation I Pokémon battle.
 pub const Side = extern struct {
     /// The player's party in its original order
-    pokemon: [6]Pokemon = [_]Pokemon{.{}} ** 6,
+    pokemon: [6]Pokemon = @splat(.{}),
     /// The active Pokémon for the side, zero initialized if the battle has yet to start.
     /// Note that fainted Pokémon are still consider "active" until their replacement switches in.
     active: ActivePokemon = .{},
     /// One-based slot indexes reflecting the current order of the player's party.
-    order: [6]u8 = [_]u8{0} ** 6,
+    order: [6]u8 = @splat(0),
     /// The last move the player selected.
     last_selected_move: Move = .None,
     /// The last move the player used.
@@ -120,7 +138,8 @@ pub const Side = extern struct {
     }
 
     /// Returns the stored `Pokemon` corresponding to the one-indexed party `slot`.
-    pub inline fn get(self: *Side, slot: u8) *Pokemon {
+    pub fn get(self: anytype, slot: u8) PointerType(@TypeOf(self), Pokemon) {
+        assert(isPointerTo(self, Side));
         assert(slot > 0 and slot <= 6);
         const id = self.order[slot - 1];
         assert(id > 0 and id <= 6);
@@ -128,7 +147,8 @@ pub const Side = extern struct {
     }
 
     /// Returns the stored `Pokemon` corresponding to the `active` Pokémon (slot 1).
-    pub inline fn stored(self: *Side) *Pokemon {
+    pub fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
+        assert(isPointerTo(self, Side));
         return self.get(1);
     }
 };
@@ -146,14 +166,15 @@ pub const ActivePokemon = extern struct {
     /// The active Pokémon's volatile statuses and associated data.
     volatiles: Volatiles = .{},
     /// The active Pokémon's current move slots.
-    moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
+    moves: [4]MoveSlot = @splat(.{}),
 
     comptime {
         assert(@sizeOf(ActivePokemon) == 32);
     }
 
     /// Returns the active Pokémon's current move slot located at the one-indexed `mslot`.
-    pub inline fn move(self: *ActivePokemon, mslot: u8) *MoveSlot {
+    pub fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
+        assert(isPointerTo(self, ActivePokemon));
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
         return &self.moves[mslot - 1];
@@ -165,7 +186,7 @@ pub const Pokemon = extern struct {
     /// The Pokémon's unmodified stats.
     stats: Stats(u16) = .{},
     /// The Pokémon's original stored move slots.
-    moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
+    moves: [4]MoveSlot = @splat(.{}),
     /// The Pokémon's current HP.
     hp: u16 = 0,
     /// The Pokémon's current status.
@@ -182,14 +203,15 @@ pub const Pokemon = extern struct {
     }
 
     /// Returns the Pokémon's original move slot located at the one-indexed `mslot`.
-    pub inline fn move(self: *Pokemon, mslot: u8) *MoveSlot {
+    pub fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
+        assert(isPointerTo(self, Pokemon));
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
         return &self.moves[mslot - 1];
     }
 };
 
-/// Representation of a Generation I & II Pokémon's move slot in a battle.
+/// Representation of a Generation I Pokémon's move slot in a battle.
 pub const MoveSlot = extern struct {
     /// The identifier for the move.
     id: Move = .None,
@@ -197,24 +219,16 @@ pub const MoveSlot = extern struct {
     pp: u8 = 0,
 
     comptime {
-        assert(@sizeOf(MoveSlot) == @sizeOf(u16));
+        assert(@sizeOf(MoveSlot) == 2);
     }
 };
 
 /// Details required to detect desyncs based on the move last selected/executed by players.
-pub const MoveDetails = packed struct {
-    /// The move slot index of the last move selected in the battle menu by Player 1
-    p1_index: if (showdown) u8 else u3 = 0,
-    /// Whether the last move executed by Player 1 was counterable.
-    p1_counterable: if (showdown) u8 else u1 = 0,
-    /// The move slot index of the last move selected in the battle menu by Player 2
-    p2_index: if (showdown) u8 else u3 = 0,
-    /// Whether the last move executed by Player 2 was counterable.
-    p2_counterable: if (showdown) u8 else u1 = 0,
-
-    comptime {
-        assert(@sizeOf(MoveDetails) == if (showdown) 4 else 1);
-    }
+pub const MoveDetails = packed struct(if (showdown) u16 else u8) {
+    /// The move slot index of the last move selected in the battle menu.
+    index: if (showdown) u8 else u4 = 0,
+    /// Whether the last move executed was counterable.
+    counterable: if (showdown) u8 else u4 = 0,
 };
 
 /// Bitfield representation of a Generation I & II Pokémon's major status condition.
@@ -238,39 +252,39 @@ 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 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(u3, @enumToInt(status))) & 1) != 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(u3, @enumToInt(status));
+        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 {
-        return @intCast(u3, num & SLP);
+    pub fn duration(num: u8) u3 {
+        return @intCast(num & SLEEP);
     }
 
     /// Returns whether `num` reflects any status.
-    pub inline fn any(num: u8) bool {
+    pub fn any(num: u8) bool {
         return num > 0;
     }
 
@@ -308,7 +322,7 @@ test Status {
 }
 
 /// Bitfield representation of volatile statuses and associated data in Generation I.
-pub const Volatiles = packed struct {
+pub const Volatiles = packed struct(u64) {
     /// Whether the "Bide" volatile status is present.
     Bide: bool = false,
     /// Whether the "Thrashing" volatile status is present.
@@ -361,19 +375,15 @@ pub const Volatiles = packed struct {
     /// 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,
-
-    comptime {
-        assert(@sizeOf(Volatiles) == 8);
-    }
 };
 
 test Volatiles {
-    var volatiles = Volatiles{};
+    var volatiles: Volatiles = .{};
     volatiles.Confusion = true;
     volatiles.confusion = 2;
     volatiles.Thrashing = true;
@@ -382,8 +392,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);
@@ -394,14 +404,14 @@ test Volatiles {
 
     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(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(u4, 3), volatiles.attacks);
+    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,
@@ -413,10 +423,11 @@ pub fn Stats(comptime T: type) type {
         /// Computes the value of `stat` given a `base`, `dv`, stat `exp` and `level`.
         pub fn calc(comptime stat: []const u8, base: T, dv: u4, exp: u16, level: u8) T {
             assert(level > 0 and level <= 100);
-            const evs = @min(255, @floatToInt(u16, @ceil(@sqrt(@intToFloat(f32, exp)))));
+            const float: f32 = @floatFromInt(exp);
+            const evs: u16 = @min(255, @as(u16, @intFromFloat(@ceil(@sqrt(float)))));
             const core: u32 = (2 *% (@as(u32, base) +% dv)) +% (evs / 4);
             const factor: u32 = if (std.mem.eql(u8, stat, "hp")) level + 10 else 5;
-            return @intCast(T, core *% @as(u32, level) / 100 +% factor);
+            return @intCast(core *% @as(u32, level) / 100 +% factor);
         }
     };
 }
@@ -434,7 +445,7 @@ test Stats {
 }
 
 /// Representation of a Pokémon's boosts in Generation I.
-pub const Boosts = packed struct {
+pub const Boosts = packed struct(u32) {
     /// A Pokémon's Attack boosts.
     atk: i4 = 0,
     /// A Pokémon's Defense boosts.
@@ -449,14 +460,10 @@ pub const Boosts = packed struct {
     evasion: i4 = 0,
 
     _: u8 = 0,
-
-    comptime {
-        assert(@sizeOf(Boosts) == 4);
-    }
 };
 
 test Boosts {
-    const boosts = Boosts{ .spc = -6 };
+    const boosts: Boosts = .{ .spc = -6 };
     try expectEqual(0, boosts.atk);
     try expectEqual(-6, boosts.spc);
 }
@@ -465,10 +472,10 @@ test Boosts {
 pub const Move = moves.Move;
 
 test Move {
-    try expectEqual(2, @enumToInt(Move.KarateChop));
+    try expectEqual(2, @intFromEnum(Move.KarateChop));
     const move = Move.get(.Fissure);
     try expectEqual(Move.Effect.OHKO, move.effect);
-    try expectEqual(@as(u8, 30), move.accuracy);
+    try expectEqual(rng.Gen12.percent(30), move.accuracy);
     try expectEqual(Type.Ground, move.type);
 
     try expect(!Move.Effect.onBegin(.None));
@@ -526,7 +533,7 @@ test Move {
 pub const Species = species.Species;
 
 test Species {
-    try expectEqual(2, @enumToInt(Species.Ivysaur));
+    try expectEqual(2, @intFromEnum(Species.Ivysaur));
     try expectEqual(@as(u8, 100), Species.get(.Mew).stats.def);
 }
 
@@ -543,9 +550,11 @@ pub const Effectiveness = enum(u8) {
     Super = 20,
 
     /// Used to determine the effectiness of a neutral damage hit.
-    pub const neutral: u16 = @enumToInt(Effectiveness.Neutral) * @enumToInt(Effectiveness.Neutral);
+    pub const neutral: u16 =
+        @intFromEnum(Effectiveness.Neutral) * @intFromEnum(Effectiveness.Neutral);
     /// Used to detect whether there is a mismatch in type effectivness (relevant for precedence).
-    pub const mismatch: u16 = @enumToInt(Effectiveness.Resisted) + @enumToInt(Effectiveness.Super);
+    pub const mismatch: u16 =
+        @intFromEnum(Effectiveness.Resisted) + @intFromEnum(Effectiveness.Super);
 
     comptime {
         assert(@sizeOf(Effectiveness) == 1);
@@ -553,8 +562,8 @@ pub const Effectiveness = enum(u8) {
 };
 
 test Types {
-    try expectEqual(14, @enumToInt(Type.Dragon));
-    try expectEqual(20, @enumToInt(Effectiveness.Super));
+    try expectEqual(14, @intFromEnum(Type.Dragon));
+    try expectEqual(20, @intFromEnum(Effectiveness.Super));
 
     try expect(!Type.Ghost.special());
     try expect(Type.Dragon.special());
@@ -604,16 +613,16 @@ pub const DVs = struct {
 };
 
 test DVs {
-    var dvs = DVs{ .spc = 15, .spe = 15 };
+    var dvs: DVs = .{ .spc = 15, .spe = 15 };
     try expectEqual(@as(u4, 15), dvs.hp());
-    dvs = DVs{
+    dvs = .{
         .atk = 5,
         .def = 15,
         .spe = 13,
         .spc = 13,
     };
     try expectEqual(@as(u4, 15), dvs.hp());
-    dvs = DVs{
+    dvs = .{
         .def = 3,
         .spe = 10,
         .spc = 11,