@pkmn/engine 0.1.0-dev.942dbfa4 → 0.1.0-dev.954f650d

package/src/lib/common/protocol.zig

@@ -102,6 +102,9 @@ pub const ArgType = enum(u8) {
     // Gen 8
     CanDynamax,
     SwapSideConditions,
+
+    // Gen 9
+    Terastallize,
 };
 
 pub const Move = enum(u8) {
@@ -133,6 +136,8 @@ pub const Damage = enum(u8) {
     Confusion,
     LeechSeed,
     RecoilOf,
+
+    Spikes,
 };
 
 pub const Status = enum(u8) {
@@ -219,8 +224,12 @@ pub const Immune = enum(u8) {
     OHKO,
 };
 
+/// Null object pattern implementation of `Log` backed by a `std.io.null_writer`.
+/// Ignores anything sent to it, though protocol logging should additionally be turned off
+/// entirely with `options.log`.
 pub const NULL = Log(@TypeOf(std.io.null_writer)){ .writer = std.io.null_writer };
 
+/// Logs protocol information to its `Writer` during a battle update when `options.log` is enabled.
 pub fn Log(comptime Writer: type) type {
     return struct {
         const Self = @This();
@@ -231,12 +240,13 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn move(self: Self, source: ID, m: anytype, target: ID, from: anytype) Error!void {
             if (!enabled) return;
+
             assert(m != .None);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Move),
-                @bitCast(u8, source),
+                @as(u8, @bitCast(source)),
                 @intFromEnum(m),
-                @bitCast(u8, target),
+                @as(u8, @bitCast(target)),
             });
             const none = &[_]u8{@intFromEnum(Move.None)};
             try self.writer.writeAll(switch (@typeInfo(@TypeOf(from))) {
@@ -254,8 +264,17 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn switched(self: Self, ident: ID, pokemon: anytype) Error!void {
             if (!enabled) return;
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Switch), @bitCast(u8, ident) });
-            try self.writer.writeAll(&.{ @intFromEnum(pokemon.species), pokemon.level });
+
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Switch), @as(u8, @bitCast(ident)) });
+            if (@hasField(@TypeOf(pokemon.*), "dvs")) {
+                try self.writer.writeAll(&.{
+                    @intFromEnum(pokemon.species),
+                    @intFromEnum(pokemon.dvs.gender),
+                    pokemon.level,
+                });
+            } else {
+                try self.writer.writeAll(&.{ @intFromEnum(pokemon.species), pokemon.level });
+            }
             try self.writer.writeIntNative(u16, pokemon.hp);
             try self.writer.writeIntNative(u16, pokemon.stats.hp);
             try self.writer.writeAll(&.{pokemon.status});
@@ -263,19 +282,21 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn cant(self: Self, ident: ID, reason: Cant) Error!void {
             if (!enabled) return;
+
             assert(reason != .Disable);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Cant),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 @intFromEnum(reason),
             });
         }
 
         pub fn disabled(self: Self, ident: ID, m: anytype) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Cant),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 @intFromEnum(Cant.Disable),
                 @intFromEnum(m),
             });
@@ -283,12 +304,14 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn faint(self: Self, ident: ID, done: bool) Error!void {
             if (!enabled) return;
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Faint), @bitCast(u8, ident) });
+
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Faint), @as(u8, @bitCast(ident)) });
             if (done) try self.writer.writeByte(@intFromEnum(ArgType.None));
         }
 
         pub fn turn(self: Self, num: u16) Error!void {
             if (!enabled) return;
+
             try self.writer.writeByte(@intFromEnum(ArgType.Turn));
             try self.writer.writeIntNative(u16, num);
             try self.writer.writeByte(@intFromEnum(ArgType.None));
@@ -296,6 +319,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn win(self: Self, player: Player) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Win),
                 @intFromEnum(player),
@@ -305,13 +329,15 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn tie(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Tie), @intFromEnum(ArgType.None) });
         }
 
         pub fn damage(self: Self, ident: ID, pokemon: anytype, reason: Damage) Error!void {
             if (!enabled) return;
+
             assert(@intFromEnum(reason) <= @intFromEnum(Damage.LeechSeed));
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Damage), @bitCast(u8, ident) });
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Damage), @as(u8, @bitCast(ident)) });
             try self.writer.writeIntNative(u16, pokemon.hp);
             try self.writer.writeIntNative(u16, pokemon.stats.hp);
             try self.writer.writeAll(&.{ pokemon.status, @intFromEnum(reason) });
@@ -325,21 +351,23 @@ pub fn Log(comptime Writer: type) type {
             source: ID,
         ) Error!void {
             if (!enabled) return;
+
             assert(@intFromEnum(reason) == @intFromEnum(Damage.RecoilOf));
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Damage), @bitCast(u8, ident) });
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Damage), @as(u8, @bitCast(ident)) });
             try self.writer.writeIntNative(u16, pokemon.hp);
             try self.writer.writeIntNative(u16, pokemon.stats.hp);
             try self.writer.writeAll(&.{
                 pokemon.status,
                 @intFromEnum(reason),
-                @bitCast(u8, source),
+                @as(u8, @bitCast(source)),
             });
         }
 
         pub fn heal(self: Self, ident: ID, pokemon: anytype, reason: Heal) Error!void {
             if (!enabled) return;
+
             assert(reason != .Drain);
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Heal), @bitCast(u8, ident) });
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Heal), @as(u8, @bitCast(ident)) });
             try self.writer.writeIntNative(u16, pokemon.hp);
             try self.writer.writeIntNative(u16, pokemon.stats.hp);
             try self.writer.writeAll(&.{ pokemon.status, @intFromEnum(reason) });
@@ -347,22 +375,24 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn drain(self: Self, source: ID, pokemon: anytype, target: ID) Error!void {
             if (!enabled) return;
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Heal), @bitCast(u8, source) });
+
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Heal), @as(u8, @bitCast(source)) });
             try self.writer.writeIntNative(u16, pokemon.hp);
             try self.writer.writeIntNative(u16, pokemon.stats.hp);
             try self.writer.writeAll(&.{
                 pokemon.status,
                 @intFromEnum(Heal.Drain),
-                @bitCast(u8, target),
+                @as(u8, @bitCast(target)),
             });
         }
 
         pub fn status(self: Self, ident: ID, value: u8, reason: Status) Error!void {
             if (!enabled) return;
+
             assert(reason != .From);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Status),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 value,
                 @intFromEnum(reason),
             });
@@ -370,9 +400,10 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn statusFrom(self: Self, ident: ID, value: u8, m: anytype) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Status),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 value,
                 @intFromEnum(Status.From),
                 @intFromEnum(m),
@@ -381,9 +412,10 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn curestatus(self: Self, ident: ID, value: u8, reason: CureStatus) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.CureStatus),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 value,
                 @intFromEnum(reason),
             });
@@ -391,98 +423,113 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn boost(self: Self, ident: ID, reason: Boost, num: i8) Error!void {
             if (!enabled) return;
+
             assert(num != 0 and (reason != .Rage or num > 0));
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Boost),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 @intFromEnum(reason),
-                @intCast(u8, num + 6),
+                @as(u8, @intCast(num + 6)),
             });
         }
 
         pub fn clearallboost(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{@intFromEnum(ArgType.ClearAllBoost)});
         }
 
         pub fn fail(self: Self, ident: ID, reason: Fail) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Fail),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 @intFromEnum(reason),
             });
         }
 
         pub fn miss(self: Self, source: ID) Error!void {
             if (!enabled) return;
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Miss), @bitCast(u8, source) });
+
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Miss), @as(u8, @bitCast(source)) });
         }
 
         pub fn hitcount(self: Self, ident: ID, num: u8) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.HitCount),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 num,
             });
         }
 
         pub fn prepare(self: Self, source: ID, m: anytype) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Prepare),
-                @bitCast(u8, source),
+                @as(u8, @bitCast(source)),
                 @intFromEnum(m),
             });
         }
 
         pub fn mustrecharge(self: Self, ident: ID) Error!void {
             if (!enabled) return;
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.MustRecharge), @bitCast(u8, ident) });
+
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.MustRecharge),
+                @as(u8, @bitCast(ident)),
+            });
         }
 
         pub fn activate(self: Self, ident: ID, reason: Activate) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Activate),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 @intFromEnum(reason),
             });
         }
 
         pub fn fieldactivate(self: Self) Error!void {
             if (!enabled) return;
+
             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),
-                @bitCast(u8, ident),
+                @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),
-                @bitCast(u8, source),
+                @as(u8, @bitCast(source)),
                 @intFromEnum(Start.TypeChange),
-                @bitCast(u8, types),
-                @bitCast(u8, target),
+                @as(u8, @bitCast(types)),
+                @as(u8, @bitCast(target)),
             });
         }
 
         pub fn startEffect(self: Self, ident: ID, reason: Start, m: anytype) Error!void {
             if (!enabled) return;
+
             assert(@intFromEnum(reason) > @intFromEnum(Start.TypeChange));
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Start),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 @intFromEnum(reason),
                 @intFromEnum(m),
             });
@@ -490,68 +537,84 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn end(self: Self, ident: ID, reason: End) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.End),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 @intFromEnum(reason),
             });
         }
 
         pub fn ohko(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{@intFromEnum(ArgType.OHKO)});
         }
 
         pub fn crit(self: Self, ident: ID) Error!void {
             if (!enabled) return;
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Crit), @bitCast(u8, ident) });
+
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Crit), @as(u8, @bitCast(ident)) });
         }
 
         pub fn supereffective(self: Self, ident: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.SuperEffective),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
             });
         }
 
         pub fn resisted(self: Self, ident: ID) Error!void {
             if (!enabled) return;
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Resisted), @bitCast(u8, ident) });
+
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.Resisted),
+                @as(u8, @bitCast(ident)),
+            });
         }
 
         pub fn immune(self: Self, ident: ID, reason: Immune) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Immune),
-                @bitCast(u8, ident),
+                @as(u8, @bitCast(ident)),
                 @intFromEnum(reason),
             });
         }
 
         pub fn transform(self: Self, source: ID, target: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Transform),
-                @bitCast(u8, source),
-                @bitCast(u8, target),
+                @as(u8, @bitCast(source)),
+                @as(u8, @bitCast(target)),
             });
         }
 
         pub fn laststill(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{@intFromEnum(ArgType.LastStill)});
         }
 
         pub fn lastmiss(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{@intFromEnum(ArgType.LastMiss)});
         }
     };
 }
 
+/// `Log` type backed by the optimized `ByteStream.Writer`.
 pub const FixedLog = Log(ByteStream.Writer);
 
+/// Stripped down version of `std.io.FixedBufferStream` optimized for efficiently writing the
+/// individual protocol bytes. Note that the `ByteStream.Writer` is **not** a `std.io.Writer` and
+/// should not be used for general purpose writing.
 pub const ByteStream = struct {
     buffer: []u8,
     pos: usize = 0,
@@ -593,14 +656,18 @@ pub const ByteStream = struct {
 };
 
 pub const Kind = enum { Move, Species, Type, Status };
-pub const Formatter = fn (Kind, u8) []const u8;
 
-pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, color: bool) void {
+pub fn format(
+    comptime gen: anytype,
+    a: []const u8,
+    b: ?[]const u8,
+    color: bool,
+) void {
     print("\n", .{});
 
     var i: usize = 0;
     while (i < a.len) {
-        const arg = @enumFromInt(ArgType, a[i]);
+        const arg: ArgType = @enumFromInt(a[i]);
         const name = switch (arg) {
             .None => if (color) "\x1b[2m-\x1b[0m" else "-",
             .LastStill => "|[still]",
@@ -646,19 +713,29 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .OHKO,
             => {},
             .Move => {
-                const source = ID.from(@intCast(u4, a[i]));
+                const source = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(source.player), source.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
-                const target = ID.from(@intCast(u4, a[i]));
+                printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
+                const target = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(target.player), target.id }, a, b, &i, 1, color);
-                const reason = @enumFromInt(Move, a[i]);
+                const reason: Move = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
-                if (reason == .From) printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                if (reason == .From) {
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
+                }
             },
             .Switch => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Species, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Species, a[i])}, a, b, &i, 1, color);
+                if (@hasDecl(gen, "Gender")) {
+                    if (a[i] == N(gen.Gender.Unknown)) {
+                        i += 1;
+                    } else {
+                        var 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 => {
@@ -674,15 +751,15 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
                 }
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
             },
             .Cant => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                const reason = @enumFromInt(Cant, a[i]);
+                const reason: Cant = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
                 if (reason == .Disable) {
-                    printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
                 }
             },
             .Faint,
@@ -692,7 +769,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .SuperEffective,
             .Resisted,
             => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
             },
             .Turn => {
@@ -702,9 +779,11 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                 };
                 printc(" {d}", .{turn}, a, b, &i, 2, color);
             },
-            .Win => printc(" {s}", .{@tagName(@enumFromInt(Player, a[i]))}, a, b, &i, 1, color),
+            .Win => {
+                printc(" {s}", .{@tagName(@as(Player, @enumFromInt(a[i])))}, a, b, &i, 1, color);
+            },
             .Damage, .Heal => {
-                var id = ID.from(@intCast(u4, a[i]));
+                var id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                 switch (endian) {
                     .Big => {
@@ -720,93 +799,96 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
                 }
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
                 if (arg == .Damage) {
-                    const reason = a[i];
-                    printc(" {s}", .{@tagName(@enumFromInt(Damage, reason))}, a, b, &i, 1, color);
-                    if (reason == @intFromEnum(Damage.RecoilOf)) {
-                        id = ID.from(@intCast(u4, a[i]));
+                    const reason: Damage = @enumFromInt(a[i]);
+                    printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
+                    if (reason == .RecoilOf) {
+                        id = ID.from(@intCast(a[i]));
                         printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                     }
                 } else {
-                    const reason = @enumFromInt(Heal, a[i]);
+                    const reason: Heal = @enumFromInt(a[i]);
                     printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
                     if (reason == .Drain) {
-                        id = ID.from(@intCast(u4, a[i]));
+                        id = ID.from(@intCast(a[i]));
                         printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                     }
                 }
             },
             .Status => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
-                const reason = @enumFromInt(Status, a[i]);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
+                const reason: Status = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
-                if (reason == .From) printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                if (reason == .From) {
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
+                }
             },
             .CureStatus => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
-                printc(" {s}", .{@tagName(@enumFromInt(CureStatus, a[i]))}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
+                const reason: CureStatus = @enumFromInt(a[i]);
+                printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
             },
             .Boost => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{@tagName(@enumFromInt(Boost, a[i]))}, a, b, &i, 1, color);
+                printc(" {s}", .{@tagName(@as(Boost, @enumFromInt(a[i])))}, a, b, &i, 1, color);
                 printc(" {d}", .{a[i]}, a, b, &i, 1, color);
             },
             .Fail => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{@tagName(@enumFromInt(Fail, a[i]))}, a, b, &i, 1, color);
+                printc(" {s}", .{@tagName(@as(Fail, @enumFromInt(a[i])))}, a, b, &i, 1, color);
             },
             .HitCount => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                 printc(" {d}", .{a[i]}, a, b, &i, 1, color);
             },
             .Prepare => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
             },
             .Activate => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{@tagName(@enumFromInt(Activate, a[i]))}, a, b, &i, 1, color);
+                printc(" {s}", .{@tagName(@as(Activate, @enumFromInt(a[i])))}, a, b, &i, 1, color);
             },
             .Start => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                 const reason = a[i];
-                printc(" {s}", .{@tagName(@enumFromInt(Start, reason))}, a, b, &i, 1, color);
-                if (@enumFromInt(Start, reason) == .TypeChange) {
-                    const types = @bitCast(gen1.Types, a[i]);
+                printc(" {s}", .{@tagName(@as(Start, @enumFromInt(reason)))}, a, b, &i, 1, color);
+                if (@as(Start, @enumFromInt(reason)) == .TypeChange) {
+                    const types = @as(gen1.Types, @bitCast(a[i]));
                     const args = .{
-                        formatter(.Type, @intFromEnum(types.type1)),
-                        formatter(.Type, @intFromEnum(types.type2)),
+                        formatter(gen, .Type, @intFromEnum(types.type1)),
+                        formatter(gen, .Type, @intFromEnum(types.type2)),
                     };
                     printc(" {s}/{s}", args, a, b, &i, 1, color);
                 } else if (reason >= @intFromEnum(Start.Disable)) {
-                    printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
                 }
             },
             .End => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{@tagName(@enumFromInt(End, a[i]))}, a, b, &i, 1, color);
+                printc(" {s}", .{@tagName(@as(End, @enumFromInt(a[i])))}, a, b, &i, 1, color);
             },
             .Immune => {
-                const id = ID.from(@intCast(u4, a[i]));
+                const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{@tagName(@enumFromInt(Immune, a[i]))}, a, b, &i, 1, color);
+                printc(" {s}", .{@tagName(@as(Immune, @enumFromInt(a[i])))}, a, b, &i, 1, color);
             },
             .Transform => {
-                const source = ID.from(@intCast(u4, a[i]));
+                const source = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(source.player), source.id }, a, b, &i, 1, color);
-                const target = ID.from(@intCast(u4, a[i]));
+                const target = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(target.player), target.id }, a, b, &i, 1, color);
             },
             else => unreachable,
@@ -840,12 +922,13 @@ fn printc(
 }
 
 pub fn expectLog(
-    comptime formatter: Formatter,
+    comptime gen: anytype,
     expected: []const u8,
     actual: []const u8,
     offset: usize,
 ) !void {
     if (!enabled) return;
+
     const color = color: {
         if (std.process.hasEnvVarConstant("ZIG_DEBUG_COLOR")) {
             break :color true;
@@ -858,8 +941,8 @@ pub fn expectLog(
 
     expectEqualBytes(expected, actual, offset) catch |err| switch (err) {
         error.TestExpectedEqual => {
-            format(formatter, expected, null, color);
-            format(formatter, actual, expected, color);
+            format(gen, expected, null, color);
+            format(gen, actual, expected, color);
             return err;
         },
         else => return err,
@@ -899,6 +982,11 @@ const gen1 = struct {
     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 stream = ByteStream{ .buffer = &buf };
 var log: FixedLog = .{ .writer = stream.writer() };
@@ -907,15 +995,19 @@ const M = gen1.Move;
 const S = gen1.Species;
 
 fn expectLog1(expected: []const u8, actual: []const u8) !void {
-    return expectLog(gen1Formatter, expected, actual, 0);
+    return expectLog(gen1, expected, actual, 0);
 }
 
-fn gen1Formatter(kind: Kind, byte: u8) []const u8 {
+fn expectLog2(expected: []const u8, actual: []const u8) !void {
+    return expectLog(gen2, expected, actual, 0);
+}
+
+fn formatter(comptime gen: anytype, kind: Kind, byte: u8) []const u8 {
     return switch (kind) {
-        .Move => @tagName(@enumFromInt(M, byte)),
-        .Species => @tagName(@enumFromInt(S, byte)),
-        .Type => @tagName(@enumFromInt(gen1.Type, byte)),
-        .Status => gen1.Status.name(byte),
+        .Move => @tagName(@as(gen.Move, @enumFromInt(byte))),
+        .Species => @tagName(@as(gen.Species, @enumFromInt(byte))),
+        .Type => @tagName(@as(gen.Type, @enumFromInt(byte))),
+        .Status => gen.Status.name(byte),
     };
 }
 
@@ -1000,6 +1092,25 @@ test "|switch|" {
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
+
+    var blissey = gen2.helpers.Pokemon.init(.{ .species = .Blissey, .moves = &.{.Splash} });
+    blissey.level = 91;
+    blissey.hp = 200;
+    blissey.stats.hp = 400;
+    blissey.status = gen2.Status.init(.PAR);
+    try log.switched(p2.ident(3), &blissey);
+    expected = &(.{
+        N(ArgType.Switch),
+        0b1011,
+        N(gen2.Species.Blissey),
+        N(gen2.Gender.Female),
+        91,
+    } ++ switch (endian) {
+        .Big => .{ 0, 200, 1, 144, par },
+        .Little => .{ 200, 0, 144, 1, par },
+    });
+    try expectLog2(expected, buf[0..10]);
+    stream.reset();
 }
 
 test "|cant|" {