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

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;
@@ -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;
 
@@ -71,13 +68,13 @@ pub fn Battle(comptime RNG: anytype) type {
 
         /// Returns the `Side` for the given `player`.
         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)];
         }
 
         /// Returns the `Side` of the opponent for the given `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())];
         }
 
@@ -91,7 +88,7 @@ pub fn Battle(comptime RNG: anytype) type {
             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)];
         }
 
@@ -142,7 +139,7 @@ pub const Side = extern struct {
 
     /// Returns the stored `Pokemon` corresponding to the one-indexed party `slot`.
     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.order[slot - 1];
         assert(id > 0 and id <= 6);
@@ -151,7 +148,7 @@ pub const Side = extern struct {
 
     /// Returns the stored `Pokemon` corresponding to the `active` Pokémon (slot 1).
     pub fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
+        assert(isPointerTo(self, Side));
         return self.get(1);
     }
 };
@@ -177,7 +174,7 @@ pub const ActivePokemon = extern struct {
 
     /// Returns the active Pokémon's current move slot located at the one-indexed `mslot`.
     pub fn move(self: anytype, mslot: u8) PointerType(@TypeOf(self), MoveSlot) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == ActivePokemon);
+        assert(isPointerTo(self, ActivePokemon));
         assert(mslot > 0 and mslot <= 4);
         assert(self.moves[mslot - 1].id != .None);
         return &self.moves[mslot - 1];
@@ -207,7 +204,7 @@ pub const Pokemon = extern struct {
 
     /// Returns the Pokémon's original move slot located at the one-indexed `mslot`.
     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];
@@ -255,7 +252,7 @@ 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 fn is(num: u8, status: Status) bool {
@@ -283,7 +280,7 @@ pub const Status = enum(u8) {
 
     /// Returns the duration of a sleep status.
     pub fn duration(num: u8) u3 {
-        return @intCast(num & SLP);
+        return @intCast(num & SLEEP);
     }
 
     /// Returns whether `num` reflects any status.
@@ -316,12 +313,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(5, Status.duration(Status.slp(5)));
+    try expectEqual(@as(u3, 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(1, Status.duration(Status.slp(1)));
+    try expectEqual(@as(u3, 1), Status.duration(Status.slp(1)));
 }
 
 /// Bitfield representation of volatile statuses and associated data in Generation I.
@@ -405,16 +402,16 @@ test Volatiles {
     try expect(!volatiles.Transform);
     try expect(!volatiles.MultiHit);
 
-    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);
+    try expectEqual(@as(u16, 235), volatiles.state);
+    try expectEqual(@as(u8, 42), volatiles.substitute);
+    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(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,
@@ -442,9 +439,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));
 }
 
 /// Representation of a Pokémon's boosts in Generation I.
@@ -537,7 +534,7 @@ pub const Species = species.Species;
 
 test Species {
     try expectEqual(2, @intFromEnum(Species.Ivysaur));
-    try expectEqual(100, Species.get(.Mew).stats.def);
+    try expectEqual(@as(u8, 100), Species.get(.Mew).stats.def);
 }
 
 /// Representation of a Generation I type in Pokémon.
@@ -576,8 +573,8 @@ test Types {
     try expectEqual(Effectiveness.Resisted, Type.effectiveness(.Fire, .Water));
     try expectEqual(Effectiveness.Neutral, Type.effectiveness(.Normal, .Grass));
 
-    try expectEqual(3, Type.precedence(.Water, .Water));
-    try expectEqual(26, Type.precedence(.Bug, .Ghost));
+    try expectEqual(@as(u8, 3), Type.precedence(.Water, .Water));
+    try expectEqual(@as(u8, 26), Type.precedence(.Bug, .Ghost));
     try expect(Type.precedence(.Poison, .Bug) > Type.precedence(.Poison, .Poison));
 
     const t: Types = .{ .type1 = .Rock, .type2 = .Ground };
@@ -617,18 +614,18 @@ pub const DVs = struct {
 
 test DVs {
     var dvs: DVs = .{ .spc = 15, .spe = 15 };
-    try expectEqual(15, dvs.hp());
+    try expectEqual(@as(u4, 15), dvs.hp());
     dvs = .{
         .atk = 5,
         .def = 15,
         .spe = 13,
         .spc = 13,
     };
-    try expectEqual(15, dvs.hp());
+    try expectEqual(@as(u4, 15), dvs.hp());
     dvs = .{
         .def = 3,
         .spe = 10,
         .spc = 11,
     };
-    try expectEqual(13, dvs.hp());
+    try expectEqual(@as(u4, 13), dvs.hp());
 }

package/src/lib/gen1/helpers.zig

@@ -1,32 +1,26 @@
-const std = @import("std");
 const builtin = @import("builtin");
-
 const common = @import("../common/data.zig");
+const data = @import("data.zig");
 const options = @import("../common/options.zig");
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
-
-const data = @import("data.zig");
+const std = @import("std");
+const util = @import("../common/util.zig");
 
 const assert = std.debug.assert;
-
 const Choice = common.Choice;
-const Player = common.Player;
-
-const showdown = options.showdown;
-const chance = options.chance;
-
-const PSRNG = rng.PSRNG;
-
 const DVs = data.DVs;
 const Move = data.Move;
 const MoveSlot = data.MoveSlot;
+const PSRNG = rng.PSRNG;
+const showdown = options.showdown;
 const Species = data.Species;
 const Stats = data.Stats;
-const Status = data.Status;
 
 const endian = builtin.cpu.arch.endian();
 
+const Struct = if (@hasField(std.builtin.Type, "struct")) .@"struct" else .Struct;
+
 /// Configuration options controlling the domain of valid Pokémon that can be generated by the
 /// random generator helpers.
 pub const Options = struct {
@@ -169,7 +163,7 @@ pub const Pokemon = struct {
         var pokemon = data.Pokemon{};
         pokemon.species = p.species;
         const species = Species.get(p.species);
-        inline for (@typeInfo(@TypeOf(pokemon.stats)).Struct.fields) |field| {
+        inline for (@field(@typeInfo(@TypeOf(pokemon.stats)), @tagName(Struct)).fields) |field| {
             const hp = comptime std.mem.eql(u8, field.name, "hp");
             const spc =
                 comptime std.mem.eql(u8, field.name, "spa") or std.mem.eql(u8, field.name, "spd");
@@ -205,7 +199,7 @@ pub const Pokemon = struct {
         const lvl = if (rand.chance(u8, 1, 20)) rand.range(u8, 1, 99 + 1) else 100;
         var stats: Stats(u16) = .{};
         const dvs = DVs.random(rand);
-        inline for (@typeInfo(@TypeOf(stats)).Struct.fields) |field| {
+        inline for (@field(@typeInfo(@TypeOf(stats)), @tagName(Struct)).fields) |field| {
             @field(stats, field.name) = Stats(u16).calc(
                 field.name,
                 @field(species.stats, field.name),
@@ -266,14 +260,7 @@ fn blocked(m: Move) bool {
 fn durations(m: Move) bool {
     // Any moves that have effects that result in duration tracking with -Dchance
     return switch (Move.get(m).effect) {
-        .Confusion,
-        .Bide,
-        .Sleep,
-        .Rage,
-        .Binding,
-        .Thrashing,
-        .ConfusionChance,
-        .Disable,
+        .Haze,
         .Metronome,
         => true,
         else => false,
@@ -314,8 +301,8 @@ pub fn diff(
 
     var i: usize = 0;
     while (i < size) : (i += 2) {
-        const val = std.mem.bytesAsValue(u16, std.mem.asBytes(a)[i .. i + 2]).*;
-        if (val != std.mem.bytesAsValue(u16, std.mem.asBytes(b)[i .. i + 2]).*) {
+        const val = util.bytesAsValue(u16, std.mem.asBytes(a)[i .. i + 2]).*;
+        if (val != util.bytesAsValue(u16, std.mem.asBytes(b)[i .. i + 2]).*) {
             try w.writeByte(@intCast(i / 2));
             try w.writeInt(u16, val, endian);
         }
@@ -329,7 +316,8 @@ pub fn patch(battle: *data.Battle(data.PRNG), buf: []u8) void {
     var i: usize = 0;
     while (i < buf.len) : (i += 3) {
         const off = @as(u16, @intCast(buf[i])) * 2;
-        const val = std.mem.readInt(u16, @ptrCast(buf[i + 1 .. i + 3]), endian);
-        std.mem.writeInt(u16, @ptrCast(std.mem.asBytes(battle)[off .. off + 2]), val, endian);
+        const val = std.mem.readInt(u16, @as(*const [2]u8, @ptrCast(buf[i + 1 .. i + 3])), endian);
+        const bytes: *[2]u8 = @ptrCast(std.mem.asBytes(battle)[off .. off + 2]);
+        std.mem.writeInt(u16, bytes, val, endian);
     }
 }