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

package/src/lib/gen1/helpers.zig

@@ -1,32 +1,24 @@
-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 std = @import("std");
 const util = @import("../common/util.zig");
 
-const data = @import("data.zig");
-
 const assert = std.debug.assert;
-
 const Choice = common.Choice;
-
-const showdown = options.showdown;
-
-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 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,15 +161,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,
             );
         }
@@ -205,20 +202,25 @@ 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 (@field(@typeInfo(@TypeOf(stats)), @tagName(Struct)).fields) |field| {
-            @field(stats, field.name) = Stats(u16).calc(
-                field.name,
-                @field(species.stats, field.name),
-                if (comptime std.mem.eql(u8, field.name, "hp"))
+        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;
+            @field(stats, field_name) = Stats(u16).calc(
+                field_name,
+                @field(species.stats, field_name),
+                if (comptime std.mem.eql(u8, field_name, "hp"))
                     dvs.hp()
                 else
-                    @field(dvs, field.name),
+                    @field(dvs, field_name),
                 if (rand.chance(u8, 1, 20)) rand.range(u16, 0, EXP + 1) else EXP,
                 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;
@@ -266,14 +268,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,
@@ -305,23 +300,23 @@ else
 pub fn diff(
     a: *const data.Battle(data.PRNG),
     b: *const data.Battle(data.PRNG),
-    w: protocol.ByteStream.Writer,
+    w: *protocol.Writer,
 ) !usize {
-    const pos = w.stream.pos;
+    const pos = w.pos;
     const size = @sizeOf(data.Battle(data.PRNG)) - @sizeOf(data.PRNG);
     assert(size % 2 == 0);
     assert(size / 2 < 255);
 
     var i: usize = 0;
     while (i < size) : (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]).*) {
+        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]).*) {
             try w.writeByte(@intCast(i / 2));
             try w.writeInt(u16, val, endian);
         }
     }
 
-    return w.stream.pos - pos;
+    return w.pos - pos;
 }
 
 /// TODO