@pkmn/engine 0.1.0-dev.e5b5a998 → 0.1.0-dev.f3aaee39

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

@@ -102,7 +102,7 @@ pub const Type = enum(u4) {
     /// 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(u8, i);
+            if (matchup.type1 == t1 and matchup.type2 == t2) return @intCast(i);
         }
         unreachable;
     }

package/src/lib/gen1/data.zig

@@ -1,15 +1,19 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
+const pkmn = @import("../pkmn.zig");
+
 const data = @import("../common/data.zig");
-const options = @import("../common/options.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 types = @import("data/types.zig");
 
+const calc = @import("calc.zig");
+const chance = @import("chance.zig");
 const mechanics = @import("mechanics.zig");
 
 const assert = std.debug.assert;
@@ -34,12 +38,17 @@ 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 showdown = pkmn.options.showdown;
 
 /// The pseudo random number generator used by Generation I.
 pub const PRNG = rng.PRNG(1);
@@ -56,29 +65,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 = [_]MoveDetails{.{}} ** 2,
         /// The pseudo random number generator.
         rng: RNG,
 
         /// Returns the `Side` for the given `player`.
-        pub inline fn side(self: *Self, player: Player) *Side {
+        pub inline 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: *Self, player: Player) *Side {
+        pub inline 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: *Self, player: Player) ID {
-            return player.ident(@intCast(u3, self.side(player).order[0]));
+        pub inline 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(
+            self: anytype,
+            player: Player,
+        ) PointerType(@TypeOf(self), MoveDetails) {
+            assert(@typeInfo(@TypeOf(self)).Pointer.child == 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,7 +111,7 @@ 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.
+        /// 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 {
             return mechanics.choices(self, player, request, out);
         }
@@ -120,7 +141,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 inline 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];
         assert(id > 0 and id <= 6);
@@ -128,7 +150,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 inline fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
         return self.get(1);
     }
 };
@@ -153,7 +176,8 @@ 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: *ActivePokemon, mslot: u8) *MoveSlot {
+    pub inline 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);
         return &self.moves[mslot - 1];
@@ -182,7 +206,8 @@ 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 inline 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);
         return &self.moves[mslot - 1];
@@ -203,17 +228,13 @@ pub const MoveSlot = extern struct {
 
 /// 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,
+    /// 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,
 
     comptime {
-        assert(@sizeOf(MoveDetails) == if (showdown) 4 else 1);
+        assert(@sizeOf(MoveDetails) == if (showdown) 2 else 1);
     }
 };
 
@@ -243,13 +264,13 @@ pub const Status = enum(u8) {
     /// Whether or not the status `num` is the same as `status`.
     pub inline fn is(num: u8, status: Status) bool {
         if (status == .SLP) return Status.duration(num) > 0;
-        return ((num >> @intCast(u3, @intFromEnum(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 {
         assert(status != .SLP and status != .EXT);
-        return @as(u8, 1) << @intCast(u3, @intFromEnum(status));
+        return @as(u8, 1) << @intCast(@intFromEnum(status));
     }
 
     /// Initializes a non self-inflicted sleep status with duration `dur`.
@@ -266,7 +287,7 @@ pub const Status = enum(u8) {
 
     /// Returns the duration of a sleep status.
     pub inline fn duration(num: u8) u3 {
-        return @intCast(u3, num & SLP);
+        return @intCast(num & SLP);
     }
 
     /// Returns whether `num` reflects any status.
@@ -413,10 +434,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, @intFromFloat(u16, @ceil(@sqrt(@floatFromInt(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);
         }
     };
 }