@pkmn/engine 0.1.0-dev.b01cb48c → 0.1.0-dev.b14f2221

package/src/lib/gen2/data.zig

@@ -1,24 +1,20 @@
-const std = @import("std");
-const builtin = @import("builtin");
-
-const pkmn = @import("../pkmn.zig");
-
-const data = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
-const protocol = @import("../common/protocol.zig");
-const rng = @import("../common/rng.zig");
-const util = @import("../common/util.zig");
 
+const builtin = @import("builtin");
+const calc = @import("calc.zig");
+const chance = @import("chance.zig");
+const data = @import("../common/data.zig");
+const gen1 = @import("../gen1/data.zig");
 const items = @import("data/items.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 species = @import("data/species.zig");
+const std = @import("std");
 const types = @import("data/types.zig");
-
-const gen1 = @import("../gen1/data.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;
@@ -45,6 +41,7 @@ const Player = data.Player;
 const Result = data.Result;
 
 const PointerType = util.PointerType;
+const isPointerTo = util.isPointerTo;
 
 const showdown = pkmn.options.showdown;
 
@@ -60,15 +57,15 @@ pub fn Battle(comptime RNG: anytype) type {
         turn: u16 = 0,
         field: Field = .{},
 
-        _: [padding]u8 = .{0} ** padding,
+        _: [padding]u8 = @splat(0),
 
         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)];
         }
 
         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())];
         }
 
@@ -103,13 +100,13 @@ pub const Weather = enum(u4) {
 };
 
 pub const Side = extern struct {
-    pokemon: [6]Pokemon = [_]Pokemon{.{}} ** 6,
+    pokemon: [6]Pokemon = @splat(.{}),
     active: ActivePokemon align(8) = .{},
     conditions: Conditions = .{},
     // NB: wLastPlayerCounterMove / wLastEnemyCounterMove (wLastPlayerMove / wLastEnemyMove)
     last_used_move: Move = .None,
 
-    _: [7]u8 = .{0} ** 7,
+    _: [7]u8 = @splat(0),
 
     const Conditions = packed struct(u32) {
         Spikes: bool = false,
@@ -134,7 +131,7 @@ pub const Side = extern struct {
     }
 
     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.pokemon[slot - 1].position;
         assert(id > 0 and id <= 6);
@@ -142,7 +139,7 @@ pub const Side = extern struct {
     }
 
     pub fn stored(self: anytype) PointerType(@TypeOf(self), Pokemon) {
-        assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
+        assert(isPointerTo(self, Side));
         return self.get(1);
     }
 
@@ -164,7 +161,7 @@ pub const Side = extern struct {
 pub const ActivePokemon = extern struct {
     volatiles: Volatiles align(4) = .{},
     stats: Stats(u16) = .{},
-    moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
+    moves: [4]MoveSlot = @splat(.{}),
     boosts: Boosts = .{},
     types: Types = .{},
     species: Species = .None,
@@ -176,7 +173,7 @@ pub const ActivePokemon = extern struct {
     }
 
     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];
@@ -185,7 +182,7 @@ pub const ActivePokemon = extern struct {
 
 pub const Pokemon = extern struct {
     stats: Stats(u16) = .{},
-    moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
+    moves: [4]MoveSlot = @splat(.{}),
     types: Types = .{},
     dvs: DVs = .{},
     hp: u16 = 0,
@@ -201,7 +198,7 @@ pub const Pokemon = extern struct {
     }
 
     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];
@@ -248,12 +245,12 @@ test DVs {
     var dvs = DVs.from(.Mewtwo, .{ .def = 13 });
     try expectEqual(Gender.Unknown, dvs.gender);
     try expectEqual(Type.Ice, dvs.type);
-    try expectEqual(70, dvs.power());
+    try expectEqual(@as(u8, 70), dvs.power());
 
     dvs = DVs.from(.Pikachu, .{ .spc = 14 });
     try expectEqual(Gender.Male, dvs.gender);
     try expectEqual(Type.Dark, dvs.type);
-    try expectEqual(69, dvs.power());
+    try expectEqual(@as(u8, 69), dvs.power());
 
     dvs = DVs.from(.Cyndaquil, .{ .atk = 1, .def = 3, .spe = 10, .spc = 9 });
     try expectEqual(Gender.Female, dvs.gender);
@@ -380,9 +377,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));
 }
 
 pub const Boosts = packed struct(u32) {
@@ -428,8 +425,8 @@ test Move {
     try expectEqual(Move.Effect.ConfusionChance, move.effect);
     try expectEqual(rng.Gen12.percent(50), move.accuracy);
     try expectEqual(rng.Gen12.percent(100), move.chance);
-    try expectEqual(5, Move.pp(.DynamicPunch));
-    try expectEqual(-1, Move.get(.Counter).priority);
+    try expectEqual(@as(u8, 5), Move.pp(.DynamicPunch));
+    try expectEqual(@as(i8, -1), Move.get(.Counter).priority);
     try expect(!move.effect.isHighCritical());
     try expect(Move.get(.KarateChop).effect.isHighCritical());
     try expect(Move.get(.RazorWind).effect.isHighCritical());
@@ -439,7 +436,7 @@ pub const Species = species.Species;
 
 test Species {
     try expectEqual(152, @intFromEnum(Species.Chikorita));
-    try expectEqual(100, Species.get(.Celebi).stats.spd);
+    try expectEqual(@as(u8, 100), Species.get(.Celebi).stats.spd);
 }
 
 pub const Type = types.Type;
@@ -452,8 +449,9 @@ test Types {
     try expect(!Type.Steel.special());
     try expect(Type.Dark.special());
 
-    try expectEqual(3, Type.Water.precedence());
-    try expect(Type.Bug.precedence() > Type.Poison.precedence());
+    try expectEqual(@as(u8, 3), Type.precedence(.Water, .Water));
+    try expect(Type.precedence(.Poison, .Bug) > Type.precedence(.Poison, .Poison));
+    try expect(Type.precedence(.Ice, .Fire) > Type.precedence(.Ice, .Water));
 
     try expectEqual(Effectiveness.Super, Type.effectiveness(.Ghost, .Psychic));
     try expectEqual(Effectiveness.Super, Type.effectiveness(.Water, .Fire));

package/src/lib/gen2/generated.zig

@@ -1,37 +1,32 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const common = @import("../common/data.zig");
-
 const data = @import("data.zig");
 const mechanics = @import("mechanics.zig");
+const std = @import("std");
 
-const Player = common.Player;
-const Result = common.Result;
-
-const Effectiveness = data.Effectiveness;
-const Move = data.Move;
-
-const Effects = mechanics.Effects;
-const State = mechanics.State;
-
-const canMove = mechanics.canMove;
+const adjustDamage = mechanics.adjustDamage;
+const afterMove = mechanics.afterMove;
+const applyDamage = mechanics.applyDamage;
+const buildRage = mechanics.buildRage;
+const calcDamage = mechanics.calcDamage;
 const canCharge = mechanics.canCharge;
+const canMove = mechanics.canMove;
+const checkCriticalHit = mechanics.checkCriticalHit;
+const checkHit = mechanics.checkHit;
 const decrementPP = mechanics.decrementPP;
+const destinyBond = mechanics.destinyBond;
 const doMove = mechanics.doMove;
-const checkHit = mechanics.checkHit;
-const checkCriticalHit = mechanics.checkCriticalHit;
-const calcDamage = mechanics.calcDamage;
-const adjustDamage = mechanics.adjustDamage;
-const randomizeDamage = mechanics.randomizeDamage;
-const applyDamage = mechanics.applyDamage;
-const reportOutcome = mechanics.reportOutcome;
 const effectChance = mechanics.effectChance;
-const afterMove = mechanics.afterMove;
-const buildRage = mechanics.buildRage;
+const Effectiveness = data.Effectiveness;
+const Effects = mechanics.Effects;
 const kingsRock = mechanics.kingsRock;
-const destinyBond = mechanics.destinyBond;
+const Move = data.Move;
+const Player = common.Player;
+const randomizeDamage = mechanics.randomizeDamage;
+const reportOutcome = mechanics.reportOutcome;
+const Result = common.Result;
+const State = mechanics.State;
 
 const SECONDARY = true;
 const KINGS = true;

package/src/lib/gen2/helpers.zig

@@ -1,31 +1,20 @@
-const std = @import("std");
-
 const common = @import("../common/data.zig");
+const data = @import("data.zig");
+const gen1 = @import("../gen1/data.zig");
 const options = @import("../common/options.zig");
-const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
-
-const gen1 = @import("../gen1/data.zig");
-
-const data = @import("data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
-const expectEqual = std.testing.expectEqual;
-
 const Choice = common.Choice;
-
-const showdown = options.showdown;
-
-const PSRNG = rng.PSRNG;
-
 const DVs = data.DVs;
 const Item = data.Item;
 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;
 
 pub const Options = struct {
     cleric: bool = showdown,
@@ -83,7 +72,7 @@ pub fn prng(rand: *PSRNG) data.PRNG {
                 var carry: u8 = 0;
                 var div: u8 = 0;
 
-                var i: u8 = 0;
+                var i: usize = 0;
                 while (i < seed.len) {
                     div = @intCast(timer >> 8);
                     // This is effectively @addWithOverflow but with three operands
@@ -151,7 +140,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 (@typeInfo(@TypeOf(pokemon.stats)).@"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");
@@ -192,7 +181,7 @@ pub const Pokemon = struct {
 
         var stats: Stats(u16) = .{};
         const dvs = gen1.DVs.random(rand);
-        inline for (@typeInfo(@TypeOf(stats)).Struct.fields) |field| {
+        inline for (@typeInfo(@TypeOf(stats)).@"struct".fields) |field| {
             const hp = std.mem.eql(u8, field.name, "hp");
             const spc = std.mem.eql(u8, field.name, "spa") or std.mem.eql(u8, field.name, "spd");
             @field(stats, field.name) = Stats(u16).calc(
@@ -204,7 +193,7 @@ pub const Pokemon = struct {
             );
         }
 
-        var ms = [_]MoveSlot{.{}} ** 4;
+        var ms: [4]MoveSlot = @splat(.{});
         const n = if (rand.chance(u8, 1, 100)) rand.range(u4, 1, 3 + 1) else 4;
         for (0..n) |i| {
             var m: Move = .None;