@pkmn/engine 0.1.0-dev.8b83af6b → 0.1.0-dev.900756a9

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) {
@@ -118,12 +121,19 @@ pub const Cant = enum(u8) {
     Disable,
     Recharge,
     PP,
+
+    Attract,
 };
 
 pub const Heal = enum(u8) {
     None,
     Silent,
     Drain,
+
+    Leftovers,
+    Berry,
+    BerryJuice,
+    GoldBerry,
 };
 
 pub const Damage = enum(u8) {
@@ -133,6 +143,17 @@ pub const Damage = enum(u8) {
     Confusion,
     LeechSeed,
     RecoilOf,
+
+    Bind,
+    Wrap,
+    FireSpin,
+    Clamp,
+    Whirlpool,
+    Spikes,
+
+    Nightmare,
+    Curse,
+    Sandstorm,
 };
 
 pub const Status = enum(u8) {
@@ -175,8 +196,25 @@ pub const Activate = enum(u8) {
     Haze,
     Mist,
     Struggle,
-    Substitute,
+    Substitute, // FIXME SubstituteDamage
     Splash,
+
+    Rage, // TODO
+
+    Attract,
+    LockOn,
+    Bind,
+    Wrap,
+    FireSpin,
+    Clamp,
+    Whirlpool,
+    SubstituteBlock,
+
+    DestinyBond,
+
+    BeatUp, // FIXME of
+
+    Magnitude,
 };
 
 pub const Start = enum(u8) {
@@ -194,6 +232,19 @@ pub const Start = enum(u8) {
 
     Disable,
     Mimic,
+
+    Attract,
+    Nightmare,
+    Curse,
+    Foresight,
+    Encore,
+    FutureSight,
+
+    PerishSong0,
+    PerishSong1,
+    PerishSong2,
+    PerishSong3,
+    PerishSong3Silent,
 };
 
 pub const End = enum(u8) {
@@ -202,16 +253,30 @@ pub const End = enum(u8) {
     Bide,
     Substitute,
 
-    // Silent
+    Nightmare,
+    Curse,
+    Foresight,
+    Encore,
+    FutureSight,
+    LeechSeed,
+
+    Bind,
+    Wrap,
+    FireSpin,
+    Clamp,
+    Whirlpool,
+
     DisableSilent,
     ConfusionSilent,
-
-    Mist,
-    FocusEnergy,
-    LeechSeed,
-    Toxic,
-    LightScreen,
-    Reflect,
+    MistSilent,
+    FocusEnergySilent,
+    LeechSeedSilent,
+    ToxicSilent,
+    LightScreenSilent,
+    ReflectSilent,
+    BideSilent,
+
+    LeechSeedFrom,
 };
 
 pub const Immune = enum(u8) {
@@ -219,8 +284,34 @@ pub const Immune = enum(u8) {
     OHKO,
 };
 
+pub const EndItem = enum(u8) {
+    None,
+    Eat,
+};
+
+pub const SetHP = enum(u8) {
+    None,
+    Silent,
+};
+
+pub const Side = enum(u8) {
+    Safeguard,
+    Reflect,
+    LightScreen,
+    Spikes,
+};
+
+pub const Weather = enum(u8) {
+    None,
+    Upkeep,
+};
+
+/// 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();
@@ -229,33 +320,52 @@ pub fn Log(comptime Writer: type) type {
 
         pub const Error = Writer.Error;
 
-        pub fn move(self: Self, source: ID, m: anytype, target: ID, from: anytype) Error!void {
+        pub fn move(self: Self, source: ID, m: anytype, target: ID) Error!void {
             if (!enabled) return;
+
             assert(m != .None);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Move),
                 @as(u8, @bitCast(source)),
                 @intFromEnum(m),
                 @as(u8, @bitCast(target)),
+                @intFromEnum(Move.None),
             });
-            const none = &[_]u8{@intFromEnum(Move.None)};
-            try self.writer.writeAll(switch (@typeInfo(@TypeOf(from))) {
-                .Null => none,
-                .Optional => if (from) |f| blk: {
-                    assert(@intFromEnum(f) != 0);
-                    break :blk &[_]u8{ @intFromEnum(Move.From), @intFromEnum(f) };
-                } else none,
-                else => blk: {
-                    assert(@intFromEnum(from) != 0);
-                    break :blk &[_]u8{ @intFromEnum(Move.From), @intFromEnum(from) };
-                },
+        }
+
+        pub fn moveFrom(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),
+                @as(u8, @bitCast(source)),
+                @intFromEnum(m),
+                @as(u8, @bitCast(target)),
             });
+            try self.writer.writeAll(if (@intFromEnum(from) == 0)
+                &.{@intFromEnum(Move.None)}
+            else
+                &.{ @intFromEnum(Move.From), @intFromEnum(from) });
         }
 
         pub fn switched(self: Self, ident: ID, pokemon: anytype) Error!void {
+            return switchDrag(self, .Switch, ident, pokemon);
+        }
+
+        fn switchDrag(self: Self, arg: ArgType, ident: ID, pokemon: anytype) Error!void {
             if (!enabled) return;
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Switch), @as(u8, @bitCast(ident)) });
-            try self.writer.writeAll(&.{ @intFromEnum(pokemon.species), pokemon.level });
+
+            try self.writer.writeAll(&.{ @intFromEnum(arg), @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,6 +373,7 @@ 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),
@@ -273,6 +384,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn disabled(self: Self, ident: ID, m: anytype) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Cant),
                 @as(u8, @bitCast(ident)),
@@ -283,12 +395,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), @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 +410,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,11 +420,13 @@ 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), @as(u8, @bitCast(ident)) });
             try self.writer.writeIntNative(u16, pokemon.hp);
@@ -325,6 +442,7 @@ 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), @as(u8, @bitCast(ident)) });
             try self.writer.writeIntNative(u16, pokemon.hp);
@@ -336,17 +454,20 @@ pub fn Log(comptime Writer: type) type {
             });
         }
 
-        pub fn heal(self: Self, ident: ID, pokemon: anytype, reason: Heal) Error!void {
+        // args: ident: ID, pokemon: anytype, reason: Heal
+        pub fn heal(self: Self, args: anytype) Error!void {
             if (!enabled) return;
-            assert(reason != .Drain);
-            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) });
+
+            assert(args[2] != .Drain);
+            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]) });
         }
 
         pub fn drain(self: Self, source: ID, pokemon: anytype, target: ID) Error!void {
             if (!enabled) return;
+
             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);
@@ -359,6 +480,7 @@ pub fn Log(comptime Writer: type) type {
 
         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),
@@ -370,6 +492,7 @@ 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),
                 @as(u8, @bitCast(ident)),
@@ -381,6 +504,7 @@ 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),
                 @as(u8, @bitCast(ident)),
@@ -391,6 +515,7 @@ 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),
@@ -402,11 +527,13 @@ pub fn Log(comptime Writer: type) type {
 
         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),
                 @as(u8, @bitCast(ident)),
@@ -416,11 +543,13 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn miss(self: Self, source: ID) Error!void {
             if (!enabled) return;
+
             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),
                 @as(u8, @bitCast(ident)),
@@ -430,6 +559,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn prepare(self: Self, source: ID, m: anytype) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Prepare),
                 @as(u8, @bitCast(source)),
@@ -439,6 +569,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn mustrecharge(self: Self, ident: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.MustRecharge),
                 @as(u8, @bitCast(ident)),
@@ -447,20 +578,47 @@ 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 {
+            if (!enabled) return;
+
+            assert(reason == .SubstituteBlock); // TODO
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Activate),
                 @as(u8, @bitCast(ident)),
                 @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,
             });
         }
 
         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),
@@ -471,6 +629,7 @@ pub fn Log(comptime Writer: type) type {
 
         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)),
@@ -482,6 +641,7 @@ pub fn Log(comptime Writer: type) type {
 
         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),
@@ -493,6 +653,7 @@ 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),
                 @as(u8, @bitCast(ident)),
@@ -502,16 +663,19 @@ pub fn Log(comptime Writer: type) type {
 
         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), @as(u8, @bitCast(ident)) });
         }
 
         pub fn supereffective(self: Self, ident: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.SuperEffective),
                 @as(u8, @bitCast(ident)),
@@ -520,6 +684,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn resisted(self: Self, ident: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Resisted),
                 @as(u8, @bitCast(ident)),
@@ -528,6 +693,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn immune(self: Self, ident: ID, reason: Immune) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Immune),
                 @as(u8, @bitCast(ident)),
@@ -537,6 +703,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn transform(self: Self, source: ID, target: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Transform),
                 @as(u8, @bitCast(source)),
@@ -544,20 +711,152 @@ pub fn Log(comptime Writer: type) type {
             });
         }
 
+        pub fn drag(self: Self, ident: ID, pokemon: anytype) Error!void {
+            return switchDrag(self, .Drag, ident, pokemon);
+        }
+
+        pub fn item(self: Self, target: ID, i: anytype, source: ID) Error!void {
+            if (!enabled) return;
+
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.Item),
+                @as(u8, @bitCast(target)),
+                @intFromEnum(i),
+                @as(u8, @bitCast(source)),
+            });
+        }
+
+        pub fn enditem(self: Self, ident: ID, i: anytype, reason: EndItem) Error!void {
+            if (!enabled) return;
+
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.EndItem),
+                @as(u8, @bitCast(ident)),
+                @intFromEnum(i),
+                @intFromEnum(reason),
+            });
+        }
+
+        pub fn cureteam(self: Self, source: ID) Error!void {
+            if (!enabled) return;
+
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.CureTeam),
+                @as(u8, @bitCast(source)),
+            });
+        }
+
+        pub fn sethp(self: Self, ident: ID, pokemon: anytype, reason: SetHP) Error!void {
+            if (!enabled) return;
+
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.SetHP), @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});
+            try self.writer.writeByte(@intFromEnum(reason));
+        }
+
+        pub fn setboost(self: Self, ident: ID, num: i8) Error!void {
+            if (!enabled) return;
+
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.SetBoost),
+                @as(u8, @bitCast(ident)),
+                @as(u8, @intCast(num + 6)),
+            });
+        }
+
+        pub fn copyboost(self: Self, source: ID, target: ID) Error!void {
+            if (!enabled) return;
+
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.CopyBoost),
+                @as(u8, @bitCast(source)),
+                @as(u8, @bitCast(target)),
+            });
+        }
+
+        pub fn sidestart(self: Self, player: Player, reason: Side) Error!void {
+            if (!enabled) return;
+
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.SideStart),
+                @intFromEnum(player),
+                @intFromEnum(reason),
+            });
+        }
+
+        pub fn sideend(self: Self, player: Player, reason: Side) Error!void {
+            if (!enabled) return;
+
+            assert(@intFromEnum(reason) != @intFromEnum(Side.Spikes));
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.SideEnd),
+                @intFromEnum(player),
+                @intFromEnum(reason),
+            });
+        }
+
+        pub fn spikesend(self: Self, source: ID) Error!void {
+            if (!enabled) return;
+
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.SideEnd),
+                @intFromEnum(source.player),
+                @intFromEnum(Side.Spikes),
+                @as(u8, @bitCast(source)),
+            });
+        }
+
+        pub fn singlemove(self: Self, ident: ID, m: anytype) Error!void {
+            return single(self, .SingleMove, ident, m);
+        }
+
+        pub fn singleturn(self: Self, ident: ID, m: anytype) Error!void {
+            return single(self, .SingleTurn, ident, m);
+        }
+
+        fn single(self: Self, arg: ArgType, ident: ID, m: anytype) Error!void {
+            if (!enabled) return;
+
+            try self.writer.writeAll(&.{
+                @intFromEnum(arg),
+                @as(u8, @bitCast(ident)),
+                @intFromEnum(m),
+            });
+        }
+
+        pub fn weather(self: Self, w: anytype, reason: Weather) Error!void {
+            if (!enabled) return;
+
+            assert(!(w == .None and reason == .Upkeep));
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.Weather),
+                @intFromEnum(w),
+                @intFromEnum(reason),
+            });
+        }
+
         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,
@@ -598,10 +897,14 @@ pub const ByteStream = struct {
     }
 };
 
-pub const Kind = enum { Move, Species, Type, Status };
-pub const Formatter = fn (Kind, u8) []const u8;
+pub const Kind = enum { Move, Species, Type, Status, Item, Weather };
 
-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;
@@ -639,6 +942,18 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .Resisted => "|-resisted|",
             .Immune => "|-immune|",
             .Transform => "|-transform|",
+            .Drag => "|drag|",
+            .Item => "|-item|",
+            .EndItem => "|-enditem|",
+            .CureTeam => "|-cureteam|",
+            .SetHP => "|-sethp|",
+            .SetBoost => "|-setboost|",
+            .CopyBoost => "|-copyboost|",
+            .SideStart => "|-sidestart|",
+            .SideEnd => "|-sideend|",
+            .SingleMove => "|-singlemove|",
+            .SingleTurn => "|-singleturn|",
+            .Weather => "|-weather|",
             else => unreachable,
         };
         printc("{s}", .{name}, a, b, &i, 1, color);
@@ -654,17 +969,27 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .Move => {
                 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);
+                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: 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 => {
+            .Switch, .Drag => {
                 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 => {
@@ -680,7 +1005,7 @@ 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(a[i]));
@@ -688,7 +1013,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                 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,
@@ -697,6 +1022,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .Crit,
             .SuperEffective,
             .Resisted,
+            .CureTeam,
             => {
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
@@ -728,7 +1054,7 @@ 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: Damage = @enumFromInt(a[i]);
                     printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
@@ -748,15 +1074,17 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .Status => {
                 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}", .{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(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}", .{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);
             },
@@ -771,15 +1099,15 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                 printc(" {s}", .{@tagName(@as(Fail, @enumFromInt(a[i])))}, a, b, &i, 1, color);
             },
-            .HitCount => {
+            .HitCount, .SetBoost => {
                 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 => {
+            .Prepare, .SingleMove, .SingleTurn => {
                 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(a[i]));
@@ -794,12 +1122,12 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                 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 => {
@@ -812,12 +1140,64 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                 printc(" {s}", .{@tagName(@as(Immune, @enumFromInt(a[i])))}, a, b, &i, 1, color);
             },
-            .Transform => {
+            .Transform, .CopyBoost => {
                 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(a[i]));
                 printc(" {s}({d})", .{ @tagName(target.player), target.id }, a, b, &i, 1, color);
             },
+            .Item, .EndItem => {
+                var id = ID.from(@intCast(a[i]));
+                printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Item, a[i])}, a, b, &i, 1, color);
+                if (arg == .Item) {
+                    id = ID.from(@intCast(a[i]));
+                    printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
+                } else {
+                    const reason: EndItem = @enumFromInt(a[i]);
+                    printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
+                }
+            },
+            .SetHP => {
+                const id = ID.from(@intCast(a[i]));
+                printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
+                switch (endian) {
+                    .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 => {
+                        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]);
+                        printc("/{d}", .{hp}, a, b, &i, 2, color);
+                    },
+                }
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{@tagName(@as(SetHP, @enumFromInt(a[i])))}, a, b, &i, 1, color);
+            },
+            .SideStart => {
+                const id = ID.from(@intCast(a[i]));
+                printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
+                printc(" {s}", .{@tagName(@as(Side, @enumFromInt(a[i])))}, a, b, &i, 1, color);
+            },
+            .SideEnd => {
+                var id = ID.from(@intCast(a[i]));
+                printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
+                const reason: Side = @enumFromInt(a[i]);
+                printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
+                if (reason == .Spikes) {
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
+                    id = ID.from(@intCast(a[i]));
+                    printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
+                }
+            },
+            .Weather => {
+                printc(" {s}", .{formatter(gen, .Weather, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{@tagName(@as(Weather, @enumFromInt(a[i])))}, a, b, &i, 1, color);
+            },
             else => unreachable,
         }
         print("\n", .{});
@@ -849,12 +1229,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;
@@ -867,8 +1248,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,
@@ -908,49 +1289,70 @@ 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 stream: ByteStream = .{ .buffer = &buf };
 var log: FixedLog = .{ .writer = stream.writer() };
 
-const M = gen1.Move;
-const S = gen1.Species;
+const M1 = gen1.Move;
+const S1 = gen1.Species;
+
+const M2 = gen2.Move;
+const S2 = gen2.Species;
+const I2 = gen2.Item;
+const W2 = gen2.Weather;
 
 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(@as(M, @enumFromInt(byte))),
-        .Species => @tagName(@as(S, @enumFromInt(byte))),
-        .Type => @tagName(@as(gen1.Type, @enumFromInt(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),
+        .Item => if (@hasDecl(gen, "Item"))
+            @tagName(@as(gen.Item, @enumFromInt(byte)))
+        else
+            unreachable,
+        .Weather => if (@hasDecl(gen, "Weather"))
+            @tagName(@as(gen.Weather, @enumFromInt(byte)))
+        else
+            unreachable,
     };
 }
 
 test "|move|" {
-    try log.move(p2.ident(4), M.Thunderbolt, p1.ident(5), null);
+    try log.move(p2.ident(4), M1.Thunderbolt, p1.ident(5));
     try expectLog1(
-        &.{ N(ArgType.Move), 0b1100, N(M.Thunderbolt), 0b0101, N(Move.None) },
+        &.{ N(ArgType.Move), 0b1100, N(M1.Thunderbolt), 0b0101, N(Move.None) },
         buf[0..5],
     );
     stream.reset();
 
-    try log.move(p2.ident(4), M.Wrap, p1.ident(5), M.Wrap);
-    const wrap = N(M.Wrap);
+    try log.moveFrom(p2.ident(4), M1.Pound, p1.ident(5), M1.Metronome);
     try expectLog1(
-        &.{ N(ArgType.Move), 0b1100, wrap, 0b0101, N(Move.From), wrap },
+        &.{ N(ArgType.Move), 0b1100, N(M1.Pound), 0b0101, N(Move.From), N(M1.Metronome) },
         buf[0..6],
     );
     stream.reset();
 
-    try log.move(p2.ident(4), M.SkullBash, .{}, null);
+    try log.move(p2.ident(4), M1.SkullBash, .{});
     try log.laststill();
     try expectLog1(
         &.{
             N(ArgType.Move),
             0b1100,
-            N(M.SkullBash),
+            N(M1.SkullBash),
             0,
             N(Move.None),
             N(ArgType.LastStill),
@@ -959,13 +1361,13 @@ test "|move|" {
     );
     stream.reset();
 
-    try log.move(p2.ident(4), M.Tackle, p1.ident(5), null);
+    try log.move(p2.ident(4), M1.Tackle, p1.ident(5));
     try log.lastmiss();
     try expectLog1(
         &.{
             N(ArgType.Move),
             0b1100,
-            N(M.Tackle),
+            N(M1.Tackle),
             0b0101,
             N(Move.None),
             N(ArgType.LastMiss),
@@ -984,8 +1386,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(S.Snorlax), 91, 0, 200, 1, 144, par },
-        .Little => &.{ N(ArgType.Switch), 0b1011, N(S.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();
@@ -995,8 +1397,8 @@ test "|switch|" {
     snorlax.status = 0;
     try log.switched(p2.ident(3), &snorlax);
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Switch), 0b1011, N(S.Snorlax), 100, 0, 0, 1, 144, 0 },
-        .Little => &.{ N(ArgType.Switch), 0b1011, N(S.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();
@@ -1004,11 +1406,30 @@ test "|switch|" {
     snorlax.hp = 400;
     try log.switched(p2.ident(3), &snorlax);
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Switch), 0b1011, N(S.Snorlax), 100, 1, 144, 1, 144, 0 },
-        .Little => &.{ N(ArgType.Switch), 0b1011, N(S.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();
+
+    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(S2.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|" {
@@ -1016,8 +1437,8 @@ test "|cant|" {
     try expectLog1(&.{ N(ArgType.Cant), 0b1110, N(Cant.Bound) }, buf[0..3]);
     stream.reset();
 
-    try log.disabled(p1.ident(2), M.Earthquake);
-    try expectLog1(&.{ N(ArgType.Cant), 2, N(Cant.Disable), N(M.Earthquake) }, buf[0..4]);
+    try log.disabled(p1.ident(2), M1.Earthquake);
+    try expectLog1(&.{ N(ArgType.Cant), 2, N(Cant.Disable), N(M1.Earthquake) }, buf[0..4]);
     stream.reset();
 }
 
@@ -1090,7 +1511,7 @@ 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, .None);
+    try log.heal(.{ p2.ident(2), &chansey, Heal.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) },
@@ -1101,7 +1522,7 @@ test "|-heal|" {
     chansey.hp = 100;
     chansey.stats.hp = 256;
     chansey.status = 0;
-    try log.heal(p2.ident(2), &chansey, .Silent);
+    try log.heal(.{ p2.ident(2), &chansey, Heal.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) },
@@ -1127,9 +1548,9 @@ test "|-status|" {
     try expectLog1(&.{ N(ArgType.Status), 0b1010, 0b1000, N(Status.Silent) }, buf[0..4]);
     stream.reset();
 
-    try log.statusFrom(p1.ident(1), gen1.Status.init(.PAR), M.BodySlam);
+    try log.statusFrom(p1.ident(1), gen1.Status.init(.PAR), M1.BodySlam);
     try expectLog1(
-        &.{ N(ArgType.Status), 0b0001, 0b1000000, N(Status.From), N(M.BodySlam) },
+        &.{ N(ArgType.Status), 0b0001, 0b1000000, N(Status.From), N(M1.BodySlam) },
         buf[0..5],
     );
     stream.reset();
@@ -1200,8 +1621,8 @@ test "|-hitcount|" {
 }
 
 test "|-prepare|" {
-    try log.prepare(p2.ident(2), M.Dig);
-    try expectLog1(&.{ N(ArgType.Prepare), 0b1010, N(M.Dig) }, buf[0..3]);
+    try log.prepare(p2.ident(2), M1.Dig);
+    try expectLog1(&.{ N(ArgType.Prepare), 0b1010, N(M1.Dig) }, buf[0..3]);
     stream.reset();
 }
 
@@ -1227,6 +1648,12 @@ test "|-activate|" {
     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.magnitude(p1.ident(3), 5);
+    try expectLog1(&.{ N(ArgType.Activate), 0b0011, N(Activate.Magnitude), 5 }, buf[0..4]);
+    stream.reset();
 }
 
 test "|-fieldactivate|" {
@@ -1258,12 +1685,12 @@ test "|-start|" {
     );
     stream.reset();
 
-    try log.startEffect(p1.ident(2), .Disable, M.Surf);
-    try expectLog1(&.{ N(ArgType.Start), 0b0010, N(Start.Disable), N(M.Surf) }, buf[0..4]);
+    try log.startEffect(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, M.Surf);
-    try expectLog1(&.{ N(ArgType.Start), 0b0010, N(Start.Mimic), N(M.Surf) }, buf[0..4]);
+    try log.startEffect(p1.ident(2), .Mimic, M1.Surf);
+    try expectLog1(&.{ N(ArgType.Start), 0b0010, N(Start.Mimic), N(M1.Surf) }, buf[0..4]);
     stream.reset();
 }
 
@@ -1282,21 +1709,25 @@ test "|-ohko|" {
     try expectLog1(&.{N(ArgType.OHKO)}, buf[0..1]);
     stream.reset();
 }
+
 test "|-crit|" {
     try log.crit(p2.ident(5));
     try expectLog1(&.{ N(ArgType.Crit), 0b1101 }, buf[0..2]);
     stream.reset();
 }
+
 test "|-supereffective|" {
     try log.supereffective(p1.ident(1));
     try expectLog1(&.{ N(ArgType.SuperEffective), 0b0001 }, buf[0..2]);
     stream.reset();
 }
+
 test "|-resisted|" {
     try log.resisted(p2.ident(2));
     try expectLog1(&.{ N(ArgType.Resisted), 0b1010 }, buf[0..2]);
     stream.reset();
 }
+
 test "|-immune|" {
     try log.immune(p1.ident(3), .None);
     try expectLog1(&.{ N(ArgType.Immune), 0b0011, N(Immune.None) }, buf[0..3]);
@@ -1306,8 +1737,124 @@ test "|-immune|" {
     try expectLog1(&.{ N(ArgType.Immune), 0b1010, N(Immune.OHKO) }, buf[0..3]);
     stream.reset();
 }
+
 test "|-transform|" {
     try log.transform(p2.ident(4), p1.ident(5));
     try expectLog1(&.{ N(ArgType.Transform), 0b1100, 0b0101 }, buf[0..3]);
     stream.reset();
 }
+
+test "|drag|" {
+    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.drag(p2.ident(3), &blissey);
+    const par = 0b1000000;
+    const expected = &(.{
+        N(ArgType.Drag),
+        0b1011,
+        N(S2.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 "|-item|" {
+    try log.item(p2.ident(2), I2.GoldBerry, p1.ident(4));
+    try expectLog2(&.{ N(ArgType.Item), 0b1010, N(I2.GoldBerry), 0b0100 }, buf[0..4]);
+    stream.reset();
+}
+
+test "|-enditem|" {
+    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, .Eat);
+    try expectLog2(&.{ N(ArgType.EndItem), 0b1100, N(I2.PRZCureBerry), N(EndItem.Eat) }, buf[0..4]);
+    stream.reset();
+}
+
+test "|-cureteam|" {
+    try log.cureteam(p2.ident(5));
+    try expectLog2(&.{ N(ArgType.CureTeam), 0b1101 }, buf[0..2]);
+    stream.reset();
+}
+
+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) },
+    };
+    try expectLog2(expected, buf[0..8]);
+    stream.reset();
+}
+
+test "|-setboost|" {
+    try log.setboost(p2.ident(6), 6);
+    try expectLog2(&.{ N(ArgType.SetBoost), 0b1110, 12 }, buf[0..3]);
+    stream.reset();
+
+    try log.setboost(p2.ident(3), 2);
+    try expectLog2(&.{ N(ArgType.SetBoost), 0b1011, 8 }, buf[0..3]);
+    stream.reset();
+}
+
+test "|-copyboost|" {
+    try log.copyboost(p2.ident(3), p1.ident(6));
+    try expectLog2(&.{ N(ArgType.CopyBoost), 0b1011, 0b0110 }, buf[0..3]);
+    stream.reset();
+}
+
+test "|-sidestart|" {
+    try log.sidestart(.P2, .Reflect);
+    try expectLog2(&.{ N(ArgType.SideStart), 1, N(Side.Reflect) }, buf[0..3]);
+    stream.reset();
+}
+
+test "|-sideend|" {
+    try log.sideend(.P2, .LightScreen);
+    try expectLog2(&.{ N(ArgType.SideEnd), 1, N(Side.LightScreen) }, buf[0..3]);
+    stream.reset();
+
+    try log.spikesend(p1.ident(3));
+    try expectLog2(&.{
+        N(ArgType.SideEnd),
+        0,
+        N(Side.Spikes),
+        0b0011,
+    }, buf[0..4]);
+    stream.reset();
+}
+
+test "|-singlemove|" {
+    try log.singlemove(p2.ident(2), M2.DestinyBond);
+    try expectLog2(&.{ N(ArgType.SingleMove), 0b1010, N(M2.DestinyBond) }, buf[0..3]);
+    stream.reset();
+}
+
+test "|-singleturn|" {
+    try log.singleturn(p1.ident(3), M2.Protect);
+    try expectLog2(&.{ N(ArgType.SingleTurn), 0b0011, N(M2.Protect) }, buf[0..3]);
+    stream.reset();
+}
+
+test "|-weather|" {
+    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, .None);
+    try expectLog2(&.{ N(ArgType.Weather), N(W2.None), N(Weather.None) }, buf[0..3]);
+    stream.reset();
+}