@pkmn/engine 0.1.0-dev.30c63015 → 0.1.0-dev.3158fa12

package/src/lib/common/protocol.zig

@@ -1,16 +1,21 @@
-const std = @import("std");
 const builtin = @import("builtin");
-
-const data = @import("./data.zig");
-const options = @import("./options.zig");
+const data = @import("data.zig");
+const options = @import("options.zig");
+const pkmn = @import("../pkmn.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,
@@ -69,7 +74,7 @@ pub const ArgType = enum(u8) {
     EndAbility,
     ClearNegativeBoost,
     FormeChange,
-    NoTarget,
+    LastNoTarget, // FIXME
 
     // Gen 4
     SwapBoost,
@@ -102,6 +107,7 @@ pub const ArgType = enum(u8) {
     // Gen 8
     CanDynamax,
     SwapSideConditions,
+    UpdatePoke,
 
     // Gen 9
     Terastallize,
@@ -215,6 +221,7 @@ pub const Activate = enum(u8) {
     BeatUp, // FIXME of
 
     Magnitude,
+    Spite,
 };
 
 pub const Start = enum(u8) {
@@ -320,7 +327,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub const Error = Writer.Error;
 
-        // source: ID, m: anytype, target: ID, from?: anytype
+        // source: ID, move: <Move>, target: ID, from?: <Move>
         pub fn move(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -337,12 +344,12 @@ pub fn Log(comptime Writer: type) type {
                 &.{ @intFromEnum(Move.From), @intFromEnum(args[3]) });
         }
 
-        // ident: ID, pokemon: anytype
+        // ident: ID, pokemon: <Pokemon>
         pub fn switched(self: Self, args: anytype) Error!void {
             return switchDrag(self, .Switch, args);
         }
 
-        // ident: ID, pokemon: anytype
+        // ident: ID, pokemon: <Pokemon>
         fn switchDrag(self: Self, arg: ArgType, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -356,12 +363,13 @@ 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});
         }
 
-        // ident: ID, reason: Cant, m?: anytype
+        // ident: ID, reason: Cant
+        // ident: ID, reason: .Disable, move: <Move>
         pub fn cant(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -369,7 +377,7 @@ pub fn Log(comptime Writer: type) type {
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Cant),
                 @as(u8, @bitCast(args[0])),
-                @intFromEnum(args[1]),
+                @intFromEnum(@as(Cant, args[1])),
             });
             if (args.len == 3) try self.writer.writeByte(@intFromEnum(args[2]));
         }
@@ -387,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));
         }
 
@@ -397,7 +405,7 @@ pub fn Log(comptime Writer: type) type {
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Win),
-                @intFromEnum(args[0]),
+                @intFromEnum(@as(Player, args[0])),
                 @intFromEnum(ArgType.None),
             });
         }
@@ -409,34 +417,37 @@ pub fn Log(comptime Writer: type) type {
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Tie), @intFromEnum(ArgType.None) });
         }
 
-        // ident: ID, pokemon: anytype, reason: Damage, source?: ID
+        // ident: ID, pokemon: <Pokemon>, reason: Damage
+        // ident: ID, pokemon: <Pokemon>, reason: .RecoilOf, source: ID
         pub fn damage(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
-            assert(@intFromEnum(args[2]) <= @intFromEnum(Damage.LeechSeed) or args.len == 4);
+            assert(args[2] != .RecoilOf or args.len == 4);
             try self.writer.writeAll(&.{
                 @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.writeAll(&.{ args[1].status, @intFromEnum(args[2]) });
+            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])));
         }
 
-        // ident: ID, pokemon: anytype, reason: Heal, target?: ID)
+        // ident: ID, pokemon: <Pokemon>, reason: Heal
+        // ident: ID, pokemon: <Pokemon>, reason: .Drain, target: ID
         pub fn heal(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             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.writeAll(&.{ args[1].status, @intFromEnum(args[2]) });
+            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])));
         }
 
-        // ident: ID, value: u8, reason: Status, m?: anytype)
+        // ident: ID, value: u8, reason: Status
+        // ident: ID, value: u8, reason: .From, m: <Move>
         pub fn status(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -445,7 +456,7 @@ pub fn Log(comptime Writer: type) type {
                 @intFromEnum(ArgType.Status),
                 @as(u8, @bitCast(args[0])),
                 args[1],
-                @intFromEnum(args[2]),
+                @intFromEnum(@as(Status, args[2])),
             });
             if (args.len == 4) try self.writer.writeByte(@intFromEnum(args[3]));
         }
@@ -458,7 +469,7 @@ pub fn Log(comptime Writer: type) type {
                 @intFromEnum(ArgType.CureStatus),
                 @as(u8, @bitCast(args[0])),
                 args[1],
-                @intFromEnum(args[2]),
+                @intFromEnum(@as(CureStatus, args[2])),
             });
         }
 
@@ -470,7 +481,7 @@ pub fn Log(comptime Writer: type) type {
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Boost),
                 @as(u8, @bitCast(args[0])),
-                @intFromEnum(args[1]),
+                @intFromEnum(@as(Boost, args[1])),
                 @as(u8, @intCast(@as(i8, args[2]) + 6)),
             });
         }
@@ -489,7 +500,7 @@ pub fn Log(comptime Writer: type) type {
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Fail),
                 @as(u8, @bitCast(args[0])),
-                @intFromEnum(args[1]),
+                @intFromEnum(@as(Fail, args[1])),
             });
         }
 
@@ -511,7 +522,7 @@ pub fn Log(comptime Writer: type) type {
             });
         }
 
-        // source: ID, m: anytype
+        // source: ID, m: <Move>
         pub fn prepare(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -532,38 +543,31 @@ pub fn Log(comptime Writer: type) type {
             });
         }
 
-        pub fn activate(self: Self, ident: ID, reason: Activate) Error!void {
-            if (!enabled) return;
-
-            assert(reason != .SubstituteBlock); // TODO
-            try self.writer.writeAll(&.{
-                @intFromEnum(ArgType.Activate),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(reason),
-            });
-        }
-
-        pub fn activateMove(self: Self, ident: ID, reason: Activate, m: anytype) Error!void {
+        // 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;
 
-            assert(reason == .SubstituteBlock); // TODO
+            assert(args.len <= 4);
+            const reason: Activate = args[1];
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Activate),
-                @as(u8, @bitCast(ident)),
+                @as(u8, @bitCast(args[0])),
                 @intFromEnum(reason),
-                @intFromEnum(m),
-            });
-        }
-
-        pub fn magnitude(self: Self, ident: ID, num: u8) Error!void {
-            if (!enabled) return;
-
-            try self.writer.writeAll(&.{
-                @intFromEnum(ArgType.Activate),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(Activate.Magnitude),
-                num,
             });
+            if (args.len == 3) {
+                if (reason == .SubstituteBlock) {
+                    try self.writer.writeByte(@intFromEnum(args[2]));
+                } else {
+                    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] });
+            }
         }
 
         // -
@@ -573,49 +577,40 @@ pub fn Log(comptime Writer: type) type {
             try self.writer.writeAll(&.{@intFromEnum(ArgType.FieldActivate)});
         }
 
-        pub fn start(self: Self, ident: ID, reason: Start) Error!void {
-            if (!enabled) return;
-
-            assert(@intFromEnum(reason) < @intFromEnum(Start.TypeChange));
-            try self.writer.writeAll(&.{
-                @intFromEnum(ArgType.Start),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(reason),
-            });
-        }
-
-        pub fn typechange(self: Self, source: ID, types: anytype, target: ID) Error!void {
-            if (!enabled) return;
-
-            try self.writer.writeAll(&.{
-                @intFromEnum(ArgType.Start),
-                @as(u8, @bitCast(source)),
-                @intFromEnum(Start.TypeChange),
-                @as(u8, @bitCast(types)),
-                @as(u8, @bitCast(target)),
-            });
-        }
-
-        pub fn startEffect(self: Self, ident: ID, reason: Start, m: anytype) Error!void {
+        // ident: ID, reason: Start
+        // ident: ID, reason: .Disable | .Mimic | .Encore, m: <Move>
+        // ident: ID, reason: .TypeChange, types: <Types>, target: ID
+        pub fn start(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
-            assert(@intFromEnum(reason) > @intFromEnum(Start.TypeChange));
+            assert(args.len <= 4);
+            const reason: Start = args[1];
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Start),
-                @as(u8, @bitCast(ident)),
+                @as(u8, @bitCast(args[0])),
                 @intFromEnum(reason),
-                @intFromEnum(m),
             });
+            if (args.len == 3) {
+                assert(reason == .Disable or reason == .Mimic or reason == .Encore);
+                try self.writer.writeByte(@intFromEnum(args[2]));
+            } else if (args.len == 4) {
+                assert(reason == .TypeChange);
+                // FIXME: u16 types in Generation II
+                try self.writer.writeAll(&.{
+                    @as(u8, @bitCast(args[2])),
+                    @as(u8, @bitCast(args[3])),
+                });
+            }
         }
 
-        // ident: ID, reason: End)
+        // ident: ID, reason: End
         pub fn end(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.End),
                 @as(u8, @bitCast(args[0])),
-                @intFromEnum(args[1]),
+                @intFromEnum(@as(End, args[1])),
             });
         }
 
@@ -660,7 +655,7 @@ pub fn Log(comptime Writer: type) type {
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Immune),
                 @as(u8, @bitCast(args[0])),
-                @intFromEnum(args[1]),
+                @intFromEnum(@as(Immune, args[1])),
             });
         }
 
@@ -675,12 +670,12 @@ pub fn Log(comptime Writer: type) type {
             });
         }
 
-        // ident: ID, pokemon: anytype
+        // ident: ID, pokemon: <Pokemon>
         pub fn drag(self: Self, args: anytype) Error!void {
             return switchDrag(self, .Drag, args);
         }
 
-        // target: ID, i: anytype, source: ID
+        // target: ID, item: <Item>, source: ID
         pub fn item(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -692,7 +687,7 @@ pub fn Log(comptime Writer: type) type {
             });
         }
 
-        // ident: ID, i: anytype, reason: EndItem
+        // ident: ID, item: <Item>, reason: EndItem
         pub fn enditem(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -700,7 +695,7 @@ pub fn Log(comptime Writer: type) type {
                 @intFromEnum(ArgType.EndItem),
                 @as(u8, @bitCast(args[0])),
                 @intFromEnum(args[1]),
-                @intFromEnum(args[2]),
+                @intFromEnum(@as(EndItem, args[2])),
             });
         }
 
@@ -714,15 +709,15 @@ pub fn Log(comptime Writer: type) type {
             });
         }
 
-        // ident: ID, pokemon: anytype, reason: SetHP
+        // ident: ID, pokemon: <Pokemon>, reason: SetHP
         pub fn sethp(self: Self, args: anytype) Error!void {
             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(args[2]));
+            try self.writer.writeByte(@intFromEnum(@as(SetHP, args[2])));
         }
 
         // ident: ID, num: i8
@@ -753,35 +748,36 @@ pub fn Log(comptime Writer: type) type {
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.SideStart),
-                @intFromEnum(args[0]),
-                @intFromEnum(args[1]),
+                @intFromEnum(@as(Player, args[0])),
+                @intFromEnum(@as(Side, args[1])),
             });
         }
 
-        // player: Player, reason: Side, source?: ID
+        // player: Player, reason: Side
+        // player: Player, reason: .Spikes, source: ID
         pub fn sideend(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
-            assert(@intFromEnum(args[1]) != @intFromEnum(Side.Spikes) or args.len == 3);
+            assert(args[1] != .Spikes or args.len == 3);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.SideEnd),
-                @intFromEnum(args[0]),
-                @intFromEnum(args[1]),
+                @intFromEnum(@as(Player, args[0])),
+                @intFromEnum(@as(Side, args[1])),
             });
             if (args.len == 3) try self.writer.writeByte(@as(u8, @bitCast(args[2])));
         }
 
-        // ident: ID, move: anytype
+        // ident: ID, move: <Move>
         pub fn singlemove(self: Self, args: anytype) Error!void {
             return single(self, .SingleMove, args);
         }
 
-        // ident: ID, m: anytype
+        // ident: ID, move: <Move>
         pub fn singleturn(self: Self, args: anytype) Error!void {
             return single(self, .SingleTurn, args);
         }
 
-        // ident: ID, move: anytype
+        // ident: ID, move: <Move>
         fn single(self: Self, arg: ArgType, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -792,7 +788,7 @@ pub fn Log(comptime Writer: type) type {
             });
         }
 
-        // w: anytype, reason: Weather
+        // weather: <Weather>, reason: Weather
         pub fn weather(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -800,7 +796,7 @@ pub fn Log(comptime Writer: type) type {
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Weather),
                 @intFromEnum(args[0]),
-                @intFromEnum(args[1]),
+                @intFromEnum(@as(Weather, args[1])),
             });
         }
 
@@ -843,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);
         }
     };
@@ -869,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,
@@ -955,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]);
@@ -998,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);
             },
@@ -1010,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]);
@@ -1081,7 +1077,13 @@ pub fn format(
             .Activate => {
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{@tagName(@as(Activate, @enumFromInt(a[i])))}, a, b, &i, 1, color);
+                const reason: Activate = @enumFromInt(a[i]);
+                printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
+                if (reason == .SubstituteBlock) {
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
+                } else if (reason == .Magnitude) {
+                    printc(" {d}", .{a[i]}, a, b, &i, 1, color);
+                }
             },
             .Start => {
                 const id = ID.from(@intCast(a[i]));
@@ -1089,6 +1091,7 @@ 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) {
+                    // FIXME
                     const types = @as(gen1.Types, @bitCast(a[i]));
                     const args = .{
                         formatter(gen, .Type, @intFromEnum(types.type1)),
@@ -1131,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]);
@@ -1205,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) {
@@ -1244,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);
 }
@@ -1253,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: [gen1.LOGS_SIZE]u8 = undefined;
+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;
 
@@ -1355,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();
@@ -1366,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();
@@ -1375,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();
@@ -1394,19 +1385,19 @@ 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();
 }
 
 test "|cant|" {
-    try log.cant(.{ p2.ident(6), Cant.Bound });
+    try log.cant(.{ p2.ident(6), .Bound });
     try expectLog1(&.{ N(ArgType.Cant), 0b1110, N(Cant.Bound) }, buf[0..3]);
     stream.reset();
 
-    try log.cant(.{ p1.ident(2), Cant.Disable, M1.Earthquake });
+    try log.cant(.{ p1.ident(2), .Disable, M1.Earthquake });
     try expectLog1(&.{ N(ArgType.Cant), 2, N(Cant.Disable), N(M1.Earthquake) }, buf[0..4]);
     stream.reset();
 }
@@ -1423,16 +1414,16 @@ 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();
 }
 
 test "|win|" {
-    try log.win(.{Player.P2});
+    try log.win(.{.P2});
     try expectLog1(&.{ N(ArgType.Win), 1, N(ArgType.None) }, buf[0..3]);
     stream.reset();
 }
@@ -1447,10 +1438,10 @@ test "|-damage|" {
     var chansey = gen1.helpers.Pokemon.init(.{ .species = .Chansey, .moves = &.{.Splash} });
     chansey.hp = 612;
     chansey.status = gen1.Status.slp(1);
-    try log.damage(.{ p2.ident(2), &chansey, Damage.None });
+    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();
@@ -1458,19 +1449,19 @@ test "|-damage|" {
     chansey.hp = 100;
     chansey.stats.hp = 256;
     chansey.status = 0;
-    try log.damage(.{ p2.ident(2), &chansey, Damage.Confusion });
+    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();
 
     chansey.status = gen1.Status.init(.PSN);
-    try log.damage(.{ p2.ident(2), &chansey, Damage.RecoilOf, p1.ident(1) });
+    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();
@@ -1480,10 +1471,10 @@ test "|-heal|" {
     var chansey = gen1.helpers.Pokemon.init(.{ .species = .Chansey, .moves = &.{.Splash} });
     chansey.hp = 612;
     chansey.status = gen1.Status.slp(1);
-    try log.heal(.{ p2.ident(2), &chansey, Heal.None });
+    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();
@@ -1491,33 +1482,33 @@ test "|-heal|" {
     chansey.hp = 100;
     chansey.stats.hp = 256;
     chansey.status = 0;
-    try log.heal(.{ p2.ident(2), &chansey, Heal.Silent });
+    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, Heal.Drain, p1.ident(1) });
+    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();
 }
 
 test "|-status|" {
-    try log.status(.{ p2.ident(6), gen1.Status.init(.BRN), Status.None });
+    try log.status(.{ p2.ident(6), gen1.Status.init(.BRN), .None });
     try expectLog1(&.{ N(ArgType.Status), 0b1110, 0b10000, N(Status.None) }, buf[0..4]);
     stream.reset();
 
-    try log.status(.{ p2.ident(2), gen1.Status.init(.PSN), Status.Silent });
+    try log.status(.{ p2.ident(2), gen1.Status.init(.PSN), .Silent });
     try expectLog1(&.{ N(ArgType.Status), 0b1010, 0b1000, N(Status.Silent) }, buf[0..4]);
     stream.reset();
 
-    try log.status(.{ p1.ident(1), gen1.Status.init(.PAR), Status.From, M1.BodySlam });
+    try log.status(.{ p1.ident(1), gen1.Status.init(.PAR), .From, M1.BodySlam });
     try expectLog1(
         &.{ N(ArgType.Status), 0b0001, 0b1000000, N(Status.From), N(M1.BodySlam) },
         buf[0..5],
@@ -1526,11 +1517,11 @@ test "|-status|" {
 }
 
 test "|-curestatus|" {
-    try log.curestatus(.{ p2.ident(6), gen1.Status.slp(7), CureStatus.Message });
+    try log.curestatus(.{ p2.ident(6), gen1.Status.slp(7), .Message });
     try expectLog1(&.{ N(ArgType.CureStatus), 0b1110, 0b111, N(CureStatus.Message) }, buf[0..4]);
     stream.reset();
 
-    try log.curestatus(.{ p1.ident(2), gen1.Status.TOX, CureStatus.Silent });
+    try log.curestatus(.{ p1.ident(2), gen1.Status.TOX, .Silent });
     try expectLog1(&.{
         N(ArgType.CureStatus),
         0b0010,
@@ -1541,15 +1532,15 @@ test "|-curestatus|" {
 }
 
 test "|-boost|" {
-    try log.boost(.{ p2.ident(6), Boost.Speed, 2 });
+    try log.boost(.{ p2.ident(6), .Speed, 2 });
     try expectLog1(&.{ N(ArgType.Boost), 0b1110, N(Boost.Speed), 8 }, buf[0..4]);
     stream.reset();
 
-    try log.boost(.{ p1.ident(2), Boost.Rage, 1 });
+    try log.boost(.{ p1.ident(2), .Rage, 1 });
     try expectLog1(&.{ N(ArgType.Boost), 0b0010, N(Boost.Rage), 7 }, buf[0..4]);
     stream.reset();
 
-    try log.boost(.{ p2.ident(3), Boost.Defense, -2 });
+    try log.boost(.{ p2.ident(3), .Defense, -2 });
     try expectLog1(&.{ N(ArgType.Boost), 0b1011, N(Boost.Defense), 4 }, buf[0..4]);
     stream.reset();
 }
@@ -1561,19 +1552,19 @@ test "|-clearallboost|" {
 }
 
 test "|-fail|" {
-    try log.fail(.{ p2.ident(6), Fail.None });
+    try log.fail(.{ p2.ident(6), .None });
     try expectLog1(&.{ N(ArgType.Fail), 0b1110, N(Fail.None) }, buf[0..3]);
     stream.reset();
 
-    try log.fail(.{ p2.ident(6), Fail.Sleep });
+    try log.fail(.{ p2.ident(6), .Sleep });
     try expectLog1(&.{ N(ArgType.Fail), 0b1110, N(Fail.Sleep) }, buf[0..3]);
     stream.reset();
 
-    try log.fail(.{ p2.ident(6), Fail.Substitute });
+    try log.fail(.{ p2.ident(6), .Substitute });
     try expectLog1(&.{ N(ArgType.Fail), 0b1110, N(Fail.Substitute) }, buf[0..3]);
     stream.reset();
 
-    try log.fail(.{ p2.ident(6), Fail.Weak });
+    try log.fail(.{ p2.ident(6), .Weak });
     try expectLog1(&.{ N(ArgType.Fail), 0b1110, N(Fail.Weak) }, buf[0..3]);
     stream.reset();
 }
@@ -1602,25 +1593,32 @@ test "|-mustrecharge|" {
 }
 
 test "|-activate|" {
-    try log.activate(p1.ident(2), .Struggle);
+    try log.activate(.{ p1.ident(2), .Struggle });
     try expectLog1(&.{ N(ArgType.Activate), 0b0010, N(Activate.Struggle) }, buf[0..3]);
     stream.reset();
 
-    try log.activate(p2.ident(4), .Mist);
+    try log.activate(.{ p2.ident(4), .Mist });
     try expectLog1(&.{ N(ArgType.Activate), 0b1100, N(Activate.Mist) }, buf[0..3]);
     stream.reset();
 
-    try log.activate(p2.ident(6), .Substitute);
+    try log.activate(.{ p2.ident(6), .Substitute });
     try expectLog1(&.{ N(ArgType.Activate), 0b1110, N(Activate.Substitute) }, buf[0..3]);
     stream.reset();
 
-    try log.activate(p1.ident(2), .Splash);
+    try log.activate(.{ p1.ident(2), .Splash });
     try expectLog1(&.{ N(ArgType.Activate), 0b0010, N(Activate.Splash) }, buf[0..3]);
     stream.reset();
 
-    // TODO activateMove
+    try log.activate(.{ p1.ident(4), .SubstituteBlock, M2.Spite });
+    try expectLog1(&.{
+        N(ArgType.Activate),
+        0b0100,
+        N(Activate.SubstituteBlock),
+        N(M2.Spite),
+    }, buf[0..4]);
+    stream.reset();
 
-    try log.magnitude(p1.ident(3), 5);
+    try log.activate(.{ p1.ident(3), .Magnitude, 5 });
     try expectLog1(&.{ N(ArgType.Activate), 0b0011, N(Activate.Magnitude), 5 }, buf[0..4]);
     stream.reset();
 }
@@ -1632,43 +1630,53 @@ test "|-fieldactivate|" {
 }
 
 test "|-start|" {
-    try log.start(p2.ident(6), .Bide);
+    try log.start(.{ p2.ident(6), .Bide });
     try expectLog1(&.{ N(ArgType.Start), 0b1110, N(Start.Bide) }, buf[0..3]);
     stream.reset();
 
-    try log.start(p1.ident(2), .ConfusionSilent);
+    try log.start(.{ p1.ident(2), .ConfusionSilent });
     try expectLog1(&.{ N(ArgType.Start), 0b0010, N(Start.ConfusionSilent) }, buf[0..3]);
     stream.reset();
 
-    try log.typechange(p2.ident(6), gen1.Types{ .type1 = .Fire, .type2 = .Fire }, p2.ident(5));
+    try log.start(.{
+        p2.ident(6),
+        .TypeChange,
+        gen1.Types{ .type1 = .Fire, .type2 = .Fire },
+        p2.ident(5),
+    });
     try expectLog1(
         &.{ N(ArgType.Start), 0b1110, N(Start.TypeChange), 0b1000_1000, 0b1101 },
         buf[0..5],
     );
     stream.reset();
 
-    try log.typechange(p1.ident(2), gen1.Types{ .type1 = .Bug, .type2 = .Poison }, p2.ident(4));
+    try log.start(.{
+        p1.ident(2),
+        .TypeChange,
+        gen1.Types{ .type1 = .Bug, .type2 = .Poison },
+        p2.ident(4),
+    });
     try expectLog1(
         &.{ N(ArgType.Start), 0b0010, N(Start.TypeChange), 0b0011_0110, 0b1100 },
         buf[0..5],
     );
     stream.reset();
 
-    try log.startEffect(p1.ident(2), .Disable, M1.Surf);
+    try log.start(.{ p1.ident(2), .Disable, M1.Surf });
     try expectLog1(&.{ N(ArgType.Start), 0b0010, N(Start.Disable), N(M1.Surf) }, buf[0..4]);
     stream.reset();
 
-    try log.startEffect(p1.ident(2), .Mimic, M1.Surf);
+    try log.start(.{ p1.ident(2), .Mimic, M1.Surf });
     try expectLog1(&.{ N(ArgType.Start), 0b0010, N(Start.Mimic), N(M1.Surf) }, buf[0..4]);
     stream.reset();
 }
 
 test "|-end|" {
-    try log.end(.{ p2.ident(6), End.Bide });
+    try log.end(.{ p2.ident(6), .Bide });
     try expectLog1(&.{ N(ArgType.End), 0b1110, N(End.Bide) }, buf[0..3]);
     stream.reset();
 
-    try log.end(.{ p1.ident(2), End.ConfusionSilent });
+    try log.end(.{ p1.ident(2), .ConfusionSilent });
     try expectLog1(&.{ N(ArgType.End), 0b0010, N(End.ConfusionSilent) }, buf[0..3]);
     stream.reset();
 }
@@ -1698,11 +1706,11 @@ test "|-resisted|" {
 }
 
 test "|-immune|" {
-    try log.immune(.{ p1.ident(3), Immune.None });
+    try log.immune(.{ p1.ident(3), .None });
     try expectLog1(&.{ N(ArgType.Immune), 0b0011, N(Immune.None) }, buf[0..3]);
     stream.reset();
 
-    try log.immune(.{ p2.ident(2), Immune.OHKO });
+    try log.immune(.{ p2.ident(2), .OHKO });
     try expectLog1(&.{ N(ArgType.Immune), 0b1010, N(Immune.OHKO) }, buf[0..3]);
     stream.reset();
 }
@@ -1728,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();
@@ -1742,11 +1750,11 @@ test "|-item|" {
 }
 
 test "|-enditem|" {
-    try log.enditem(.{ p1.ident(1), I2.BerserkGene, EndItem.None });
+    try log.enditem(.{ p1.ident(1), I2.BerserkGene, .None });
     try expectLog2(&.{ N(ArgType.EndItem), 0b0001, N(I2.BerserkGene), N(EndItem.None) }, buf[0..4]);
     stream.reset();
 
-    try log.enditem(.{ p2.ident(4), I2.PRZCureBerry, EndItem.Eat });
+    try log.enditem(.{ p2.ident(4), I2.PRZCureBerry, .Eat });
     try expectLog2(&.{ N(ArgType.EndItem), 0b1100, N(I2.PRZCureBerry), N(EndItem.Eat) }, buf[0..4]);
     stream.reset();
 }
@@ -1760,10 +1768,10 @@ test "|-cureteam|" {
 test "|-sethp|" {
     var blissey = gen2.helpers.Pokemon.init(.{ .species = .Blissey, .moves = &.{.PainSplit} });
     blissey.hp = 612;
-    try log.sethp(.{ p2.ident(2), &blissey, SetHP.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) },
+    try log.sethp(.{ p2.ident(2), &blissey, .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();
@@ -1786,17 +1794,17 @@ test "|-copyboost|" {
 }
 
 test "|-sidestart|" {
-    try log.sidestart(.{ Player.P2, Side.Reflect });
+    try log.sidestart(.{ .P2, .Reflect });
     try expectLog2(&.{ N(ArgType.SideStart), 1, N(Side.Reflect) }, buf[0..3]);
     stream.reset();
 }
 
 test "|-sideend|" {
-    try log.sideend(.{ Player.P2, Side.LightScreen });
+    try log.sideend(.{ .P2, .LightScreen });
     try expectLog2(&.{ N(ArgType.SideEnd), 1, N(Side.LightScreen) }, buf[0..3]);
     stream.reset();
 
-    try log.sideend(.{ Player.P1, Side.Spikes, p1.ident(3) });
+    try log.sideend(.{ .P1, .Spikes, p1.ident(3) });
     try expectLog2(&.{
         N(ArgType.SideEnd),
         0,
@@ -1819,11 +1827,11 @@ test "|-singleturn|" {
 }
 
 test "|-weather|" {
-    try log.weather(.{ W2.Rain, Weather.Upkeep });
+    try log.weather(.{ W2.Rain, .Upkeep });
     try expectLog2(&.{ N(ArgType.Weather), N(W2.Rain), N(Weather.Upkeep) }, buf[0..3]);
     stream.reset();
 
-    try log.weather(.{ W2.None, Weather.None });
+    try log.weather(.{ W2.None, .None });
     try expectLog2(&.{ N(ArgType.Weather), N(W2.None), N(Weather.None) }, buf[0..3]);
     stream.reset();
 }