@pkmn/engine 0.1.0-dev.29e0e9e1 → 0.1.0-dev.2b11d5c7

package/src/lib/common/protocol.zig

@@ -1,18 +1,21 @@
-const std = @import("std");
 const builtin = @import("builtin");
-
+const data = @import("data.zig");
+const options = @import("options.zig");
 const pkmn = @import("../pkmn.zig");
-
-const data = @import("./data.zig");
-const options = @import("./options.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
+const enabled = options.log;
+const ID = data.ID;
+const Player = data.Player;
 const print = std.debug.print;
 
-const enabled = options.log;
+const endian = builtin.cpu.arch.endian();
+const Endian = std.builtin.Endian;
+const big = if (@hasField(Endian, "big")) Endian.big else Endian.Big;
+const little = if (@hasField(Endian, "little")) Endian.little else Endian.Little;
 
-const Player = data.Player;
-const ID = data.ID;
+const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
 
 pub const ArgType = enum(u8) {
     None,
@@ -71,7 +74,7 @@ pub const ArgType = enum(u8) {
     EndAbility,
     ClearNegativeBoost,
     FormeChange,
-    NoTarget,
+    LastNoTarget, // FIXME
 
     // Gen 4
     SwapBoost,
@@ -218,6 +221,7 @@ pub const Activate = enum(u8) {
     BeatUp, // FIXME of
 
     Magnitude,
+    Spite,
 };
 
 pub const Start = enum(u8) {
@@ -359,8 +363,8 @@ pub fn Log(comptime Writer: type) type {
             } else {
                 try self.writer.writeAll(&.{ @intFromEnum(args[1].species), args[1].level });
             }
-            try self.writer.writeIntNative(u16, args[1].hp);
-            try self.writer.writeIntNative(u16, args[1].stats.hp);
+            try self.writer.writeInt(u16, args[1].hp, endian);
+            try self.writer.writeInt(u16, args[1].stats.hp, endian);
             try self.writer.writeAll(&.{args[1].status});
         }
 
@@ -391,7 +395,7 @@ pub fn Log(comptime Writer: type) type {
             if (!enabled) return;
 
             try self.writer.writeByte(@intFromEnum(ArgType.Turn));
-            try self.writer.writeIntNative(u16, args[0]);
+            try self.writer.writeInt(u16, args[0], endian);
             try self.writer.writeByte(@intFromEnum(ArgType.None));
         }
 
@@ -423,8 +427,8 @@ pub fn Log(comptime Writer: type) type {
                 @intFromEnum(ArgType.Damage),
                 @as(u8, @bitCast(args[0])),
             });
-            try self.writer.writeIntNative(u16, args[1].hp);
-            try self.writer.writeIntNative(u16, args[1].stats.hp);
+            try self.writer.writeInt(u16, args[1].hp, endian);
+            try self.writer.writeInt(u16, args[1].stats.hp, endian);
             try self.writer.writeAll(&.{ args[1].status, @intFromEnum(@as(Damage, args[2])) });
             if (args.len == 4) try self.writer.writeByte(@as(u8, @bitCast(args[3])));
         }
@@ -436,8 +440,8 @@ pub fn Log(comptime Writer: type) type {
 
             assert(args[2] != .Drain or args.len == 4);
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Heal), @as(u8, @bitCast(args[0])) });
-            try self.writer.writeIntNative(u16, args[1].hp);
-            try self.writer.writeIntNative(u16, args[1].stats.hp);
+            try self.writer.writeInt(u16, args[1].hp, endian);
+            try self.writer.writeInt(u16, args[1].stats.hp, endian);
             try self.writer.writeAll(&.{ args[1].status, @intFromEnum(@as(Heal, args[2])) });
             if (args.len == 4) try self.writer.writeByte(@as(u8, @bitCast(args[3])));
         }
@@ -542,6 +546,7 @@ pub fn Log(comptime Writer: type) type {
         // ident: ID, reason: Activate
         // ident: ID, reason: .SubstituteBlock, m: <Move>
         // ident: ID, reason: .Magnitude, num: u8
+        // ident: ID, reason: .Spite, m: <Move>, num: u8
         pub fn activate(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -559,6 +564,9 @@ pub fn Log(comptime Writer: type) type {
                     assert(reason == .Magnitude);
                     try self.writer.writeByte(args[2]);
                 }
+            } else if (args.len == 4) {
+                assert(reason == .Spite);
+                try self.writer.writeAll(&.{ @intFromEnum(args[2]), args[3] });
             }
         }
 
@@ -706,8 +714,8 @@ pub fn Log(comptime Writer: type) type {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.SetHP), @as(u8, @bitCast(args[0])) });
-            try self.writer.writeIntNative(u16, args[1].hp);
-            try self.writer.writeIntNative(u16, args[1].stats.hp);
+            try self.writer.writeInt(u16, args[1].hp, endian);
+            try self.writer.writeInt(u16, args[1].stats.hp, endian);
             try self.writer.writeAll(&.{args[1].status});
             try self.writer.writeByte(@intFromEnum(@as(SetHP, args[2])));
         }
@@ -831,10 +839,10 @@ pub const ByteStream = struct {
             try self.stream.writeByte(byte);
         }
 
-        pub fn writeIntNative(self: Writer, comptime T: type, value: T) Error!void {
+        pub fn writeInt(self: Writer, comptime T: type, v: T, end: std.builtin.Endian) Error!void {
             // TODO: rework this to write directly to the buffer?
-            var bytes: [(@typeInfo(T).Int.bits + 7) / 8]u8 = undefined;
-            std.mem.writeIntNative(T, &bytes, value);
+            var bytes: [@divExact(@field(@typeInfo(T), @tagName(Int)).bits, 8)]u8 = undefined;
+            std.mem.writeInt(std.math.ByteAlignedInt(@TypeOf(v)), &bytes, v, end);
             return self.writeAll(&bytes);
         }
     };
@@ -857,7 +865,7 @@ pub const ByteStream = struct {
 pub const Kind = enum { Move, Species, Type, Status, Item, Weather };
 
 pub fn format(
-    comptime gen: anytype,
+    gen: anytype,
     a: []const u8,
     b: ?[]const u8,
     color: bool,
@@ -943,19 +951,19 @@ pub fn format(
                     if (a[i] == N(gen.Gender.Unknown)) {
                         i += 1;
                     } else {
-                        var gender = if (a[i] == N(gen.Gender.Male)) "M" else "F";
+                        const gender = if (a[i] == N(gen.Gender.Male)) "M" else "F";
                         printc(", {s}", .{gender}, a, b, &i, 1, color);
                     }
                 }
                 printc(" L{d}", .{a[i]}, a, b, &i, 1, color);
                 switch (endian) {
-                    .Big => {
+                    big => {
                         var hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
-                    .Little => {
+                    little => {
                         var hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
@@ -986,8 +994,8 @@ pub fn format(
             },
             .Turn => {
                 const turn = switch (endian) {
-                    .Big => @as(u16, a[i]) << 8 | @as(u16, a[i + 1]),
-                    .Little => @as(u16, a[i + 1]) << 8 | @as(u16, a[i]),
+                    big => @as(u16, a[i]) << 8 | @as(u16, a[i + 1]),
+                    little => @as(u16, a[i + 1]) << 8 | @as(u16, a[i]),
                 };
                 printc(" {d}", .{turn}, a, b, &i, 2, color);
             },
@@ -998,13 +1006,13 @@ pub fn format(
                 var id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                 switch (endian) {
-                    .Big => {
+                    big => {
                         var hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
-                    .Little => {
+                    little => {
                         var hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
@@ -1083,7 +1091,8 @@ pub fn format(
                 const reason = a[i];
                 printc(" {s}", .{@tagName(@as(Start, @enumFromInt(reason)))}, a, b, &i, 1, color);
                 if (@as(Start, @enumFromInt(reason)) == .TypeChange) {
-                    const types = @as(gen.Types, @bitCast(a[i]));
+                    // FIXME
+                    const types = @as(gen1.Types, @bitCast(a[i]));
                     const args = .{
                         formatter(gen, .Type, @intFromEnum(types.type1)),
                         formatter(gen, .Type, @intFromEnum(types.type2)),
@@ -1125,13 +1134,13 @@ pub fn format(
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                 switch (endian) {
-                    .Big => {
+                    big => {
                         var hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
-                    .Little => {
+                    little => {
                         var hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
@@ -1199,14 +1208,11 @@ pub fn expectLog(
 ) !void {
     if (!enabled) return;
 
-    const color = color: {
-        if (std.process.hasEnvVarConstant("ZIG_DEBUG_COLOR")) {
-            break :color true;
-        } else if (std.process.hasEnvVarConstant("NO_COLOR")) {
-            break :color false;
-        } else {
-            break :color std.io.getStdErr().supportsAnsiEscapeCodes();
-        }
+    const color = if (std.process.hasEnvVarConstant("ZIG_DEBUG_COLOR"))
+        true
+    else switch (std.io.tty.detectConfig(std.io.getStdErr())) {
+        .escape_codes => true,
+        else => false,
     };
 
     expectEqualBytes(expected, actual, offset) catch |err| switch (err) {
@@ -1238,8 +1244,6 @@ fn expectEqualBytes(expected: []const u8, actual: []const u8, offset: usize) !vo
     }
 }
 
-const endian = builtin.target.cpu.arch.endian();
-
 fn N(e: anytype) u8 {
     return @intFromEnum(e);
 }
@@ -1247,20 +1251,13 @@ fn N(e: anytype) u8 {
 const p1 = Player.P1;
 const p2 = Player.P2;
 
-const gen1 = struct {
-    pub usingnamespace @import("../gen1/data.zig");
-    pub const helpers = @import("../gen1/helpers.zig");
-};
-
-const gen2 = struct {
-    pub usingnamespace @import("../gen2/data.zig");
-    pub const helpers = @import("../gen2/helpers.zig");
-};
-
 var buf: [pkmn.LOGS_SIZE]u8 = undefined;
 var stream: ByteStream = .{ .buffer = &buf };
 var log: FixedLog = .{ .writer = stream.writer() };
 
+const gen1 = pkmn.gen1;
+const gen2 = pkmn.gen2;
+
 const M1 = gen1.Move;
 const S1 = gen1.Species;
 
@@ -1349,8 +1346,8 @@ test "|switch|" {
     try log.switched(.{ p2.ident(3), &snorlax });
     const par = 0b1000000;
     var expected: []const u8 = switch (endian) {
-        .Big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 91, 0, 200, 1, 144, par },
-        .Little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 91, 200, 0, 144, 1, par },
+        big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 91, 0, 200, 1, 144, par },
+        little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 91, 200, 0, 144, 1, par },
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
@@ -1360,8 +1357,8 @@ test "|switch|" {
     snorlax.status = 0;
     try log.switched(.{ p2.ident(3), &snorlax });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 0, 0, 1, 144, 0 },
-        .Little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 0, 0, 144, 1, 0 },
+        big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 0, 0, 1, 144, 0 },
+        little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 0, 0, 144, 1, 0 },
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
@@ -1369,8 +1366,8 @@ test "|switch|" {
     snorlax.hp = 400;
     try log.switched(.{ p2.ident(3), &snorlax });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 1, 144, 1, 144, 0 },
-        .Little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 144, 1, 144, 1, 0 },
+        big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 1, 144, 1, 144, 0 },
+        little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 144, 1, 144, 1, 0 },
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
@@ -1388,8 +1385,8 @@ test "|switch|" {
         N(gen2.Gender.Female),
         91,
     } ++ switch (endian) {
-        .Big => .{ 0, 200, 1, 144, par },
-        .Little => .{ 200, 0, 144, 1, par },
+        big => .{ 0, 200, 1, 144, par },
+        little => .{ 200, 0, 144, 1, par },
     });
     try expectLog2(expected, buf[0..10]);
     stream.reset();
@@ -1417,9 +1414,9 @@ test "|faint|" {
 
 test "|turn|" {
     try log.turn(.{42});
-    var expected = switch (endian) {
-        .Big => &.{ N(ArgType.Turn), 0, 42, N(ArgType.None) },
-        .Little => &.{ N(ArgType.Turn), 42, 0, N(ArgType.None) },
+    const expected = switch (endian) {
+        big => &.{ N(ArgType.Turn), 0, 42, N(ArgType.None) },
+        little => &.{ N(ArgType.Turn), 42, 0, N(ArgType.None) },
     };
     try expectLog1(expected, buf[0..4]);
     stream.reset();
@@ -1443,8 +1440,8 @@ test "|-damage|" {
     chansey.status = gen1.Status.slp(1);
     try log.damage(.{ p2.ident(2), &chansey, .None });
     var expected: []const u8 = switch (endian) {
-        .Big => &.{ N(ArgType.Damage), 0b1010, 2, 100, 2, 191, 1, N(Damage.None) },
-        .Little => &.{ N(ArgType.Damage), 0b1010, 100, 2, 191, 2, 1, N(Damage.None) },
+        big => &.{ N(ArgType.Damage), 0b1010, 2, 100, 2, 191, 1, N(Damage.None) },
+        little => &.{ N(ArgType.Damage), 0b1010, 100, 2, 191, 2, 1, N(Damage.None) },
     };
     try expectLog1(expected, buf[0..8]);
     stream.reset();
@@ -1454,8 +1451,8 @@ test "|-damage|" {
     chansey.status = 0;
     try log.damage(.{ p2.ident(2), &chansey, .Confusion });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Damage), 0b1010, 0, 100, 1, 0, 0, N(Damage.Confusion) },
-        .Little => &.{ N(ArgType.Damage), 0b1010, 100, 0, 0, 1, 0, N(Damage.Confusion) },
+        big => &.{ N(ArgType.Damage), 0b1010, 0, 100, 1, 0, 0, N(Damage.Confusion) },
+        little => &.{ N(ArgType.Damage), 0b1010, 100, 0, 0, 1, 0, N(Damage.Confusion) },
     };
     try expectLog1(expected, buf[0..8]);
     stream.reset();
@@ -1463,8 +1460,8 @@ test "|-damage|" {
     chansey.status = gen1.Status.init(.PSN);
     try log.damage(.{ p2.ident(2), &chansey, .RecoilOf, p1.ident(1) });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Damage), 0b1010, 0, 100, 1, 0, 0b1000, N(Damage.RecoilOf), 1 },
-        .Little => &.{ N(ArgType.Damage), 0b1010, 100, 0, 0, 1, 0b1000, N(Damage.RecoilOf), 1 },
+        big => &.{ N(ArgType.Damage), 0b1010, 0, 100, 1, 0, 0b1000, N(Damage.RecoilOf), 1 },
+        little => &.{ N(ArgType.Damage), 0b1010, 100, 0, 0, 1, 0b1000, N(Damage.RecoilOf), 1 },
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
@@ -1476,8 +1473,8 @@ test "|-heal|" {
     chansey.status = gen1.Status.slp(1);
     try log.heal(.{ p2.ident(2), &chansey, .None });
     var expected: []const u8 = switch (endian) {
-        .Big => &.{ N(ArgType.Heal), 0b1010, 2, 100, 2, 191, 1, N(Heal.None) },
-        .Little => &.{ N(ArgType.Heal), 0b1010, 100, 2, 191, 2, 1, N(Heal.None) },
+        big => &.{ N(ArgType.Heal), 0b1010, 2, 100, 2, 191, 1, N(Heal.None) },
+        little => &.{ N(ArgType.Heal), 0b1010, 100, 2, 191, 2, 1, N(Heal.None) },
     };
     try expectLog1(expected, buf[0..8]);
     stream.reset();
@@ -1487,16 +1484,16 @@ test "|-heal|" {
     chansey.status = 0;
     try log.heal(.{ p2.ident(2), &chansey, .Silent });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Heal), 0b1010, 0, 100, 1, 0, 0, N(Heal.Silent) },
-        .Little => &.{ N(ArgType.Heal), 0b1010, 100, 0, 0, 1, 0, N(Heal.Silent) },
+        big => &.{ N(ArgType.Heal), 0b1010, 0, 100, 1, 0, 0, N(Heal.Silent) },
+        little => &.{ N(ArgType.Heal), 0b1010, 100, 0, 0, 1, 0, N(Heal.Silent) },
     };
     try expectLog1(expected, buf[0..8]);
     stream.reset();
 
     try log.heal(.{ p2.ident(2), &chansey, .Drain, p1.ident(1) });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Heal), 0b1010, 0, 100, 1, 0, 0, N(Heal.Drain), 1 },
-        .Little => &.{ N(ArgType.Heal), 0b1010, 100, 0, 0, 1, 0, N(Heal.Drain), 1 },
+        big => &.{ N(ArgType.Heal), 0b1010, 0, 100, 1, 0, 0, N(Heal.Drain), 1 },
+        little => &.{ N(ArgType.Heal), 0b1010, 100, 0, 0, 1, 0, N(Heal.Drain), 1 },
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
@@ -1739,8 +1736,8 @@ test "|drag|" {
         N(gen2.Gender.Female),
         91,
     } ++ switch (endian) {
-        .Big => .{ 0, 200, 1, 144, par },
-        .Little => .{ 200, 0, 144, 1, par },
+        big => .{ 0, 200, 1, 144, par },
+        little => .{ 200, 0, 144, 1, par },
     });
     try expectLog2(expected, buf[0..10]);
     stream.reset();
@@ -1772,9 +1769,9 @@ test "|-sethp|" {
     var blissey = gen2.helpers.Pokemon.init(.{ .species = .Blissey, .moves = &.{.PainSplit} });
     blissey.hp = 612;
     try log.sethp(.{ p2.ident(2), &blissey, .Silent });
-    var expected: []const u8 = switch (endian) {
-        .Big => &.{ N(ArgType.SetHP), 0b1010, 2, 100, 2, 201, 0, N(SetHP.Silent) },
-        .Little => &.{ N(ArgType.SetHP), 0b1010, 100, 2, 201, 2, 0, N(SetHP.Silent) },
+    const expected: []const u8 = switch (endian) {
+        big => &.{ N(ArgType.SetHP), 0b1010, 2, 100, 2, 201, 0, N(SetHP.Silent) },
+        little => &.{ N(ArgType.SetHP), 0b1010, 100, 2, 201, 2, 0, N(SetHP.Silent) },
     };
     try expectLog2(expected, buf[0..8]);
     stream.reset();