@pkmn/engine 0.1.0-dev.ce4c0b2a → 0.1.0-dev.d127cb34

package/src/lib/gen2/calc.zig

@@ -1,30 +1,19 @@
-const std = @import("std");
-
-const pkmn = @import("../pkmn.zig");
-
+const chance = @import("chance.zig");
 const common = @import("../common/data.zig");
-const util = @import("../common/util.zig");
-
 const Optional = @import("../common/optional.zig").Optional;
+const pkmn = @import("../pkmn.zig");
+const std = @import("std");
+const util = @import("../common/util.zig");
 
-const chance = @import("chance.zig");
-
+const Action = chance.Action;
+const Actions = chance.Actions;
 const assert = std.debug.assert;
-
+const Criticals = chance.Criticals;
+const Damages = chance.Damages;
 const enabled = pkmn.options.calc;
-
+const isPointerTo = util.isPointerTo;
 const Player = common.Player;
-
 const PointerType = util.PointerType;
-const isPointerTo = util.isPointerTo;
-
-const Actions = chance.Actions;
-const Action = chance.Action;
-const Criticals = chance.Criticals;
-const Damages = chance.Damages;
-
-const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
-const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
 
 /// Information relevant to damage calculation that occured during a Generation II battle `update`.
 pub const Summaries = extern struct {
@@ -99,8 +88,8 @@ pub const Calc = struct {
         };
 
         return if (switch (@typeInfo(@TypeOf(val))) {
-            Enum => val != .None,
-            Int => val != 0,
+            .@"enum" => val != .None,
+            .int => val != 0,
             else => unreachable,
         }) val else null;
     }
@@ -156,6 +145,6 @@ fn ReturnType(comptime field: Action.Field) type {
     return ?(switch (field) {
         .damages => u8,
         .critical_hits => Optional(bool),
-        else => std.meta.FieldType(Action, field),
+        else => @FieldType(Action, @tagName(field)),
     });
 }

package/src/lib/gen2/chance.zig

@@ -27,10 +27,6 @@ const Type = data.Type;
 const Effectiveness = data.Effectiveness;
 const TriAttack = data.TriAttack;
 
-const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
-const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
-const Struct = if (@hasField(std.builtin.Type, "struct")) .@"struct" else .Struct;
-
 /// Actions taken by a hypothetical "chance player" that convey information about which RNG events
 /// were observed during a Generation II battle `update`. This can additionally be provided as input
 /// to the `update` call to override the normal behavior of the RNG in order to force specific
@@ -57,15 +53,28 @@ pub const Actions = extern struct {
     /// same shape if they have the same fields set (though those fields need not necessarily be
     /// set to the same value).
     pub fn matches(a: Actions, b: Actions) bool {
-        inline for (@field(@typeInfo(Actions), @tagName(Struct)).fields) |player| {
-            inline for (@field(@typeInfo(Action), @tagName(Struct)).fields) |field| {
-                const a_val = @field(@field(a, player.name), field.name);
-                const b_val = @field(@field(b, player.name), field.name);
+        inline for (if (@hasField(@TypeOf(@typeInfo(Actions).@"struct"), "fields"))
+            @typeInfo(Actions).@"struct".fields
+        else
+            @typeInfo(Actions).@"struct".field_names) |player|
+        {
+            const player_name = if (@hasField(@TypeOf(player), "name"))
+                player.name
+            else
+                player;
+            inline for (if (@hasField(@TypeOf(@typeInfo(Action).@"struct"), "fields"))
+                @typeInfo(Action).@"struct".fields
+            else
+                @typeInfo(Action).@"struct".field_names) |field|
+            {
+                const field_name = if (@hasField(@TypeOf(field), "name")) field.name else field;
+                const a_val = @field(@field(a, player_name), field_name);
+                const b_val = @field(@field(b, player_name), field_name);
 
                 switch (@typeInfo(@TypeOf(a_val))) {
-                    Enum => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
+                    .@"enum" => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
                         return false,
-                    Int => if ((a_val > 0) != (b_val > 0)) return false,
+                    .int => if ((a_val > 0) != (b_val > 0)) return false,
                     else => unreachable,
                 }
             }
@@ -73,7 +82,7 @@ pub const Actions = extern struct {
         return true;
     }
 
-    pub fn fmt(self: Actions, writer: anytype, shape: bool) !void {
+    pub fn fmt(self: Actions, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeAll("<P1 = ");
         try self.p1.fmt(writer, shape);
         try writer.writeAll(", P2 = ");
@@ -81,8 +90,7 @@ pub const Actions = extern struct {
         try writer.writeAll(">");
     }
 
-    pub fn format(a: Actions, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
-        _ = .{ f, o };
+    pub fn format(a: Actions, w: *std.Io.Writer) !void {
         try fmt(a, w, false);
     }
 };
@@ -186,37 +194,41 @@ pub const Action = packed struct(u128) {
 
     pub const Field = std.meta.FieldEnum(Action);
 
-    pub fn format(a: Action, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
-        _ = .{ f, o };
+    pub fn format(a: Action, w: *std.Io.Writer) !void {
         try fmt(a, w, false);
     }
 
-    pub fn fmt(self: Action, writer: anytype, shape: bool) !void {
+    pub fn fmt(self: Action, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeByte('(');
         var printed = false;
-        inline for (@field(@typeInfo(Action), @tagName(Struct)).fields) |field| {
-            const val = @field(self, field.name);
+        inline for (if (@hasField(@TypeOf(@typeInfo(Action).@"struct"), "fields"))
+            @typeInfo(Action).@"struct".fields
+        else
+            @typeInfo(Action).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else field;
+            const val = @field(self, field_name);
             switch (@typeInfo(@TypeOf(val))) {
-                Enum => if (val != .None) {
+                .@"enum" => if (val != .None) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
-                        try writer.print("{s}:?", .{field.name});
+                        try writer.print("{s}:?", .{field_name});
                     } else if (@TypeOf(val) == Optional(bool)) {
                         try writer.print("{s}{s}", .{
                             if (val == .false) "!" else "",
-                            field.name,
+                            field_name,
                         });
                     } else {
-                        try writer.print("{s}:{s}", .{ field.name, @tagName(val) });
+                        try writer.print("{s}:{s}", .{ field_name, @tagName(val) });
                     }
                     printed = true;
                 },
-                Int => if (val != 0) {
+                .int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
-                        try writer.print("{s}:?", .{field.name});
+                        try writer.print("{s}:?", .{field_name});
                     } else {
-                        try writer.print("{s}:{d}", .{ field.name, val });
+                        try writer.print("{s}:{d}", .{ field_name, val });
                     }
                     printed = true;
                 },
@@ -786,7 +798,7 @@ pub fn expectProbability(r: anytype, p: u64, q: u64) !void {
 
     r.reduce();
     if (r.p != p or r.q != q) {
-        print("expected {d}/{d}, found {}\n", .{ p, q, r });
+        print("expected {d}/{d}, found {f}\n", .{ p, q, r });
         return error.TestExpectedEqual;
     }
 }

package/src/lib/gen2/data/items.zig

@@ -1,11 +1,9 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const data = @import("../../gen2/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const Type = data.Type;
 
 /// Representation of a held item in Generation II Pokémon.

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

@@ -1,12 +1,10 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
-const rng = @import("../../common/rng.zig");
 const gen2 = @import("../../gen2/data.zig");
+const rng = @import("../../common/rng.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const percent = rng.Gen12.percent;
 const Type = gen2.Type;
 

package/src/lib/gen2/data/species.zig

@@ -1,11 +1,9 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const gen2 = @import("../../gen2/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const Stats = gen2.Stats;
 const Types = gen2.Types;
 

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

@@ -1,8 +1,7 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const gen1 = @import("../../gen1/data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
 const Effectiveness = gen1.Effectiveness;
@@ -173,9 +172,12 @@ pub const Type = enum(u8) {
         return CHART[@intFromEnum(t1)][@intFromEnum(t2)];
     }
 
-    /// The precedence order of Type `type`.
-    pub fn precedence(self: Type) u8 {
-        return PRECEDENCE[@intFromEnum(self)];
+    /// The precedence order of Type `t1` vs. Type `t2`.
+    pub fn precedence(t1: Type, t2: Type) u8 {
+        // The Ice vs. Fire matchup is out of order - return a higher
+        // number than anything else so that it sorts last correctly
+        if (t1 == .Ice and t2 == .Fire) return 18;
+        return PRECEDENCE[@intFromEnum(t2)];
     }
 
     /// The internal index of this Type used by Present.

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;
@@ -61,7 +57,7 @@ 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(isPointerTo(self, Self));
@@ -104,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,
@@ -165,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,
@@ -186,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,
@@ -453,8 +449,9 @@ test Types {
     try expect(!Type.Steel.special());
     try expect(Type.Dark.special());
 
-    try expectEqual(@as(u8, 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,30 +1,21 @@
-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 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 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 Struct = if (@hasField(std.builtin.Type, "struct")) .@"struct" else .Struct;
-
 pub const Options = struct {
     cleric: bool = showdown,
 };
@@ -81,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
@@ -149,15 +140,20 @@ pub const Pokemon = struct {
         var pokemon = data.Pokemon{};
         pokemon.species = p.species;
         const species = Species.get(p.species);
-        inline for (@field(@typeInfo(@TypeOf(pokemon.stats)), @tagName(Struct)).fields) |field| {
-            const hp = comptime std.mem.eql(u8, field.name, "hp");
+        inline for (if (@hasField(@TypeOf(@typeInfo(@TypeOf(pokemon.stats)).@"struct"), "fields"))
+            @typeInfo(@TypeOf(pokemon.stats)).@"struct".fields
+        else
+            @typeInfo(@TypeOf(pokemon.stats)).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else 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");
-            @field(pokemon.stats, field.name) = Stats(u16).calc(
-                field.name,
-                @field(species.stats, field.name),
-                if (hp) p.dvs.hp() else if (spc) p.dvs.spc else @field(p.dvs, field.name),
-                @field(p.stats, field.name),
+                comptime std.mem.eql(u8, field_name, "spa") or std.mem.eql(u8, field_name, "spd");
+            @field(pokemon.stats, field_name) = Stats(u16).calc(
+                field_name,
+                @field(species.stats, field_name),
+                if (hp) p.dvs.hp() else if (spc) p.dvs.spc else @field(p.dvs, field_name),
+                @field(p.stats, field_name),
                 p.level,
             );
         }
@@ -190,19 +186,24 @@ pub const Pokemon = struct {
 
         var stats: Stats(u16) = .{};
         const dvs = gen1.DVs.random(rand);
-        inline for (@field(@typeInfo(@TypeOf(stats)), @tagName(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(
-                field.name,
-                @field(species.stats, field.name),
-                if (hp) dvs.hp() else if (spc) dvs.spc else @field(dvs, field.name),
+        inline for (if (@hasField(@TypeOf(@typeInfo(@TypeOf(stats)).@"struct"), "fields"))
+            @typeInfo(@TypeOf(stats)).@"struct".fields
+        else
+            @typeInfo(@TypeOf(stats)).@"struct".field_names) |field|
+        {
+            const field_name = if (@hasField(@TypeOf(field), "name")) field.name else 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(
+                field_name,
+                @field(species.stats, field_name),
+                if (hp) dvs.hp() else if (spc) dvs.spc else @field(dvs, field_name),
                 if (rand.chance(u8, 1, 20)) rand.range(u8, 0, 255 + 1) else 255,
                 lvl,
             );
         }
 
-        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;