@pkmn/engine 0.1.0-dev.7963b917 → 0.1.0-dev.79957401

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,
@@ -48,7 +37,7 @@ pub const Battle = struct {
         comptime rolls: anytype,
         p1: []const Pokemon,
         p2: []const Pokemon,
-    ) data.Battle(rng.FixedRNG(1, rolls.len)) {
+    ) data.Battle(rng.FixedRNG(2, rolls.len)) {
         return .{
             .rng = .{ .rolls = rolls },
             .sides = .{ Side.init(p1), Side.init(p2) },
@@ -65,17 +54,47 @@ pub const Battle = struct {
 };
 
 pub fn prng(rand: *PSRNG) data.PRNG {
-    // FIXME: what is max range in gen2?
     return .{
         .src = .{
             .seed = if (showdown)
                 rand.newSeed()
-            else
-                .{
-                    rand.range(u8, 0, 256), rand.range(u8, 0, 256), rand.range(u8, 0, 256),
-                    rand.range(u8, 0, 256), rand.range(u8, 0, 256), rand.range(u8, 0, 256),
-                    rand.range(u8, 0, 256), rand.range(u8, 0, 256), rand.range(u8, 0, 256),
-                },
+            else seed: {
+                // GLITCH: The initial RNG seed in Gen II link battles is heavily constrained
+                // https://www.smogon.com/forums/threads/rng-in-rby-link-battles.3746779
+                var seed = [_]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+                // Bytes in seed can only range from 0-252, not 0-255
+                const max: u8 = 253;
+                // Instructions take multiples of 4 cycles to execute
+                var timer: u16 = 4 * rand.range(u16, 0, 16384);
+                var add: u8 = rand.range(u8, 0, 256);
+                var sub: u8 = rand.range(u8, 0, 256);
+                var carry: u8 = 0;
+                var div: u8 = 0;
+
+                var i: usize = 0;
+                while (i < seed.len) {
+                    div = @intCast(timer >> 8);
+                    // This is effectively @addWithOverflow but with three operands
+                    const result = @as(u16, add) + @as(u16, div) + @as(u16, carry);
+                    add = @intCast(result & 255);
+                    carry = @intFromBool(result > 255);
+                    timer +%= 44;
+                    div = @intCast(timer >> 8);
+                    sub -%= div +% carry;
+
+                    if (sub < max) {
+                        seed[i] = sub;
+                        i += 1;
+                        timer +%= 152;
+                        carry = 1;
+                    } else {
+                        timer +%= 132;
+                        carry = 0;
+                    }
+                }
+                break :seed seed;
+            },
         },
     };
 }
@@ -87,7 +106,7 @@ pub const Side = struct {
 
         for (0..ps.len) |i| {
             side.pokemon[i] = Pokemon.init(ps[i]);
-            // FIXME side.order[i] = i + 1;
+            side.pokemon[i].position = @as(u4, @intCast(i)) + 1;
         }
         return side;
     }
@@ -98,7 +117,7 @@ pub const Side = struct {
 
         for (0..n) |i| {
             side.pokemon[i] = Pokemon.random(rand, opt);
-            side.pokemon[i].position = i + 1;
+            side.pokemon[i].position = @as(u4, @intCast(i)) + 1;
         }
 
         return side;
@@ -121,26 +140,28 @@ 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| {
-            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,
             );
         }
         assert(p.moves.len > 0 and p.moves.len <= 4);
         for (p.moves, 0..) |m, j| {
-            pokemon.moves[j] = .{
-                .id = m,
-                .pp_ups = 3,
-                // NB: PP can be at most 61 legally (though can overflow to 63)
-                .pp = @intCast(@min(Move.pp(m) / 5 * 8, 61)),
-            };
+            pokemon.moves[j].id = m;
+            // NB: PP can be at most 61 legally (though can overflow to 63)
+            pokemon.moves[j].pp = @intCast(@min(Move.pp(m) / 5 * 8, 61));
         }
         pokemon.item = p.item;
         if (p.hp) |hp| {
@@ -151,7 +172,7 @@ pub const Pokemon = struct {
         pokemon.status = p.status;
         pokemon.types = species.types;
         pokemon.level = p.level;
-        pokemon.dvs = DVs.from(p.dvs);
+        pokemon.dvs = DVs.from(p.species, p.dvs);
         return pokemon;
     }
 
@@ -165,19 +186,24 @@ pub const Pokemon = struct {
 
         var stats: Stats(u16) = .{};
         const dvs = gen1.DVs.random(rand);
-        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(
-                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;
@@ -192,14 +218,13 @@ pub const Pokemon = struct {
             const max_pp: u8 = @intCast(Move.pp(m) + pp_ups * @min(Move.pp(m) / 5, 7));
             ms[i] = .{
                 .id = m,
-                .pp_ups = pp_ups,
                 .pp = if (opt.cleric) max_pp else rand.range(u8, 0, max_pp + 1),
             };
         }
         return .{
             .species = s,
             .types = species.types,
-            .dvs = DVs.from(dvs),
+            .dvs = DVs.from(s, dvs),
             .level = lvl,
             .stats = stats,
             .hp = if (opt.cleric) stats.hp else rand.range(u16, 0, stats.hp + 1),