@pkmn/engine 0.1.0-dev.f918c3bd → 0.1.0-dev.fb6653d6

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

@@ -1,12 +1,10 @@
-//! Code generated by `tools/generate` - manual edits will be overwritten
+//! 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;
 
@@ -1599,43 +1597,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 +1836,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,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,8 +1089,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,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;
@@ -90,16 +89,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 +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,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;
@@ -22,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
@@ -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;
 
@@ -70,28 +67,28 @@ 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) {
-            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+        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: anytype, player: Player) PointerType(@TypeOf(self), Side) {
-            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+        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: *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) {
-            assert(@typeInfo(@TypeOf(self)).Pointer.child == Self);
+            assert(isPointerTo(self, Self));
             return &self.last_moves[@intFromEnum(player)];
         }
 
@@ -112,7 +109,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,8 +138,8 @@ 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) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
+    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);
@@ -150,8 +147,8 @@ 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) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
+    pub fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
+        assert(isPointerTo(self, Side));
         return self.get(1);
     }
 };
@@ -176,8 +173,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: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == ActivePokemon);
+    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];
@@ -206,8 +203,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: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Pokemon);
+    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];
@@ -255,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(@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 {
-        return @intCast(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;
     }
 
@@ -378,9 +375,9 @@ 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,
 };
@@ -395,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);
@@ -407,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,