@pkmn/engine 0.1.0-dev.1220fbc5 → 0.1.0-dev.12e7292c

package/src/lib/common/protocol.zig

@@ -1,6 +1,8 @@
 const std = @import("std");
 const builtin = @import("builtin");
 
+const pkmn = @import("../pkmn.zig");
+
 const data = @import("./data.zig");
 const options = @import("./options.zig");
 
@@ -102,6 +104,7 @@ pub const ArgType = enum(u8) {
     // Gen 8
     CanDynamax,
     SwapSideConditions,
+    UpdatePoke,
 
     // Gen 9
     Terastallize,
@@ -213,6 +216,8 @@ pub const Activate = enum(u8) {
     DestinyBond,
 
     BeatUp, // FIXME of
+
+    Magnitude,
 };
 
 pub const Start = enum(u8) {
@@ -257,6 +262,7 @@ pub const End = enum(u8) {
     Encore,
     FutureSight,
     LeechSeed,
+
     Bind,
     Wrap,
     FireSpin,
@@ -272,6 +278,8 @@ pub const End = enum(u8) {
     LightScreenSilent,
     ReflectSilent,
     BideSilent,
+
+    LeechSeedFrom,
 };
 
 pub const Immune = enum(u8) {
@@ -315,519 +323,484 @@ pub fn Log(comptime Writer: type) type {
 
         pub const Error = Writer.Error;
 
-        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),
-            });
-        }
-
-        pub fn moveFrom(self: Self, source: ID, m: anytype, target: ID, from: anytype) Error!void {
+        // source: ID, move: <Move>, target: ID, from?: <Move>
+        pub fn move(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
-            assert(m != .None);
+            assert(args[1] != .None);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Move),
-                @as(u8, @bitCast(source)),
-                @intFromEnum(m),
-                @as(u8, @bitCast(target)),
+                @as(u8, @bitCast(args[0])),
+                @intFromEnum(args[1]),
+                @as(u8, @bitCast(args[2])),
             });
-            try self.writer.writeAll(if (@intFromEnum(from) == 0)
+            try self.writer.writeAll(if (args.len < 4 or @intFromEnum(args[3]) == 0)
                 &.{@intFromEnum(Move.None)}
             else
-                &.{ @intFromEnum(Move.From), @intFromEnum(from) });
+                &.{ @intFromEnum(Move.From), @intFromEnum(args[3]) });
         }
 
-        pub fn switched(self: Self, ident: ID, pokemon: anytype) Error!void {
-            return switchDrag(self, .Switch, ident, pokemon);
+        // ident: ID, pokemon: <Pokemon>
+        pub fn switched(self: Self, args: anytype) Error!void {
+            return switchDrag(self, .Switch, args);
         }
 
-        fn switchDrag(self: Self, arg: ArgType, ident: ID, pokemon: anytype) Error!void {
+        // ident: ID, pokemon: <Pokemon>
+        fn switchDrag(self: Self, arg: ArgType, args: anytype) Error!void {
             if (!enabled) return;
 
-            try self.writer.writeAll(&.{ @intFromEnum(arg), @as(u8, @bitCast(ident)) });
-            if (@hasField(@TypeOf(pokemon.*), "dvs")) {
+            try self.writer.writeAll(&.{ @intFromEnum(arg), @as(u8, @bitCast(args[0])) });
+            if (@hasField(@TypeOf(args[1].*), "dvs")) {
                 try self.writer.writeAll(&.{
-                    @intFromEnum(pokemon.species),
-                    @intFromEnum(pokemon.dvs.gender),
-                    pokemon.level,
+                    @intFromEnum(args[1].species),
+                    @intFromEnum(args[1].dvs.gender),
+                    args[1].level,
                 });
             } else {
-                try self.writer.writeAll(&.{ @intFromEnum(pokemon.species), pokemon.level });
+                try self.writer.writeAll(&.{ @intFromEnum(args[1].species), args[1].level });
             }
-            try self.writer.writeIntNative(u16, pokemon.hp);
-            try self.writer.writeIntNative(u16, pokemon.stats.hp);
-            try self.writer.writeAll(&.{pokemon.status});
-        }
-
-        pub fn cant(self: Self, ident: ID, reason: Cant) Error!void {
-            if (!enabled) return;
-
-            assert(reason != .Disable);
-            try self.writer.writeAll(&.{
-                @intFromEnum(ArgType.Cant),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(reason),
-            });
+            try self.writer.writeIntNative(u16, args[1].hp);
+            try self.writer.writeIntNative(u16, args[1].stats.hp);
+            try self.writer.writeAll(&.{args[1].status});
         }
 
-        pub fn disabled(self: Self, ident: ID, m: anytype) Error!void {
+        // ident: ID, reason: Cant
+        // ident: ID, reason: .Disable, move: <Move>
+        pub fn cant(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
+            assert(args[1] != .Disable or args.len == 3);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Cant),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(Cant.Disable),
-                @intFromEnum(m),
+                @as(u8, @bitCast(args[0])),
+                @intFromEnum(@as(Cant, args[1])),
             });
+            if (args.len == 3) try self.writer.writeByte(@intFromEnum(args[2]));
         }
 
-        pub fn faint(self: Self, ident: ID, done: bool) Error!void {
+        // ident: ID, done: bool
+        pub fn faint(self: Self, args: anytype) 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));
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Faint), @as(u8, @bitCast(args[0])) });
+            if (args[1]) try self.writer.writeByte(@intFromEnum(ArgType.None));
         }
 
-        pub fn turn(self: Self, num: u16) Error!void {
+        // num: u16
+        pub fn turn(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeByte(@intFromEnum(ArgType.Turn));
-            try self.writer.writeIntNative(u16, num);
+            try self.writer.writeIntNative(u16, args[0]);
             try self.writer.writeByte(@intFromEnum(ArgType.None));
         }
 
-        pub fn win(self: Self, player: Player) Error!void {
+        // player: Player
+        pub fn win(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Win),
-                @intFromEnum(player),
+                @intFromEnum(@as(Player, args[0])),
                 @intFromEnum(ArgType.None),
             });
         }
 
-        pub fn tie(self: Self) Error!void {
+        // -
+        pub fn tie(self: Self, _: anytype) 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);
-            try self.writer.writeIntNative(u16, pokemon.stats.hp);
-            try self.writer.writeAll(&.{ pokemon.status, @intFromEnum(reason) });
-        }
-
-        pub fn damageOf(
-            self: Self,
-            ident: ID,
-            pokemon: anytype,
-            reason: Damage,
-            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);
-            try self.writer.writeIntNative(u16, pokemon.stats.hp);
-            try self.writer.writeAll(&.{
-                pokemon.status,
-                @intFromEnum(reason),
-                @as(u8, @bitCast(source)),
-            });
-        }
-
-        pub fn heal(self: Self, ident: ID, pokemon: anytype, reason: Heal) Error!void {
+        // 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(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) });
-        }
-
-        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);
+            assert(args[2] != .RecoilOf or args.len == 4);
             try self.writer.writeAll(&.{
-                pokemon.status,
-                @intFromEnum(Heal.Drain),
-                @as(u8, @bitCast(target)),
+                @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(@as(Damage, args[2])) });
+            if (args.len == 4) try self.writer.writeByte(@as(u8, @bitCast(args[3])));
         }
 
-        pub fn status(self: Self, ident: ID, value: u8, reason: Status) Error!void {
+        // 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(reason != .From);
-            try self.writer.writeAll(&.{
-                @intFromEnum(ArgType.Status),
-                @as(u8, @bitCast(ident)),
-                value,
-                @intFromEnum(reason),
-            });
+            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(@as(Heal, args[2])) });
+            if (args.len == 4) try self.writer.writeByte(@as(u8, @bitCast(args[3])));
         }
 
-        pub fn statusFrom(self: Self, ident: ID, value: u8, m: anytype) Error!void {
+        // 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;
 
+            assert(args[2] != .From or args.len == 4);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Status),
-                @as(u8, @bitCast(ident)),
-                value,
-                @intFromEnum(Status.From),
-                @intFromEnum(m),
+                @as(u8, @bitCast(args[0])),
+                args[1],
+                @intFromEnum(@as(Status, args[2])),
             });
+            if (args.len == 4) try self.writer.writeByte(@intFromEnum(args[3]));
         }
 
-        pub fn curestatus(self: Self, ident: ID, value: u8, reason: CureStatus) Error!void {
+        // ident: ID, value: u8, reason: CureStatus
+        pub fn curestatus(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.CureStatus),
-                @as(u8, @bitCast(ident)),
-                value,
-                @intFromEnum(reason),
+                @as(u8, @bitCast(args[0])),
+                args[1],
+                @intFromEnum(@as(CureStatus, args[2])),
             });
         }
 
-        pub fn boost(self: Self, ident: ID, reason: Boost, num: i8) Error!void {
+        // ident: ID, reason: Boost, num: i8
+        pub fn boost(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
-            assert(num != 0 and (reason != .Rage or num > 0));
+            assert(args[2] != 0 and (args[1] != .Rage or args[2] > 0));
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Boost),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(reason),
-                @as(u8, @intCast(num + 6)),
+                @as(u8, @bitCast(args[0])),
+                @intFromEnum(@as(Boost, args[1])),
+                @as(u8, @intCast(@as(i8, args[2]) + 6)),
             });
         }
 
-        pub fn clearallboost(self: Self) Error!void {
+        // -
+        pub fn clearallboost(self: Self, _: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{@intFromEnum(ArgType.ClearAllBoost)});
         }
 
-        pub fn fail(self: Self, ident: ID, reason: Fail) Error!void {
+        // ident: ID, reason: Fail
+        pub fn fail(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Fail),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(reason),
+                @as(u8, @bitCast(args[0])),
+                @intFromEnum(@as(Fail, args[1])),
             });
         }
 
-        pub fn miss(self: Self, source: ID) Error!void {
+        // source: ID
+        pub fn miss(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Miss), @as(u8, @bitCast(source)) });
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Miss), @as(u8, @bitCast(args[0])) });
         }
 
-        pub fn hitcount(self: Self, ident: ID, num: u8) Error!void {
+        // ident: ID, num: u8
+        pub fn hitcount(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.HitCount),
-                @as(u8, @bitCast(ident)),
-                num,
+                @as(u8, @bitCast(args[0])),
+                args[1],
             });
         }
 
-        pub fn prepare(self: Self, source: ID, m: anytype) Error!void {
+        // source: ID, m: <Move>
+        pub fn prepare(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Prepare),
-                @as(u8, @bitCast(source)),
-                @intFromEnum(m),
+                @as(u8, @bitCast(args[0])),
+                @intFromEnum(args[1]),
             });
         }
 
-        pub fn mustrecharge(self: Self, ident: ID) Error!void {
+        // ident: ID
+        pub fn mustrecharge(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.MustRecharge),
-                @as(u8, @bitCast(ident)),
+                @as(u8, @bitCast(args[0])),
             });
         }
 
-        pub fn activate(self: Self, ident: ID, reason: Activate) Error!void {
+        // ident: ID, reason: Activate
+        // ident: ID, reason: .SubstituteBlock, m: <Move>
+        // ident: ID, reason: .Magnitude, 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),
             });
+            if (args.len == 3) {
+                if (reason == .SubstituteBlock) {
+                    try self.writer.writeByte(@intFromEnum(args[2]));
+                } else {
+                    assert(reason == .Magnitude);
+                    try self.writer.writeByte(args[2]);
+                }
+            }
         }
 
-        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 fieldactivate(self: Self) Error!void {
+        // -
+        pub fn fieldactivate(self: Self, _: anytype) 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),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(reason),
-            });
-        }
-
-        pub fn typechange(self: Self, source: ID, types: anytype, target: ID) 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(args.len <= 4);
+            const reason: Start = args[1];
             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 {
-            if (!enabled) return;
-
-            assert(@intFromEnum(reason) > @intFromEnum(Start.TypeChange));
-            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])),
+                });
+            }
         }
 
-        pub fn end(self: Self, ident: ID, reason: End) Error!void {
+        // 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(ident)),
-                @intFromEnum(reason),
+                @as(u8, @bitCast(args[0])),
+                @intFromEnum(@as(End, args[1])),
             });
         }
 
-        pub fn ohko(self: Self) Error!void {
+        // -
+        pub fn ohko(self: Self, _: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{@intFromEnum(ArgType.OHKO)});
         }
 
-        pub fn crit(self: Self, ident: ID) Error!void {
+        // ident: ID
+        pub fn crit(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
-            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Crit), @as(u8, @bitCast(ident)) });
+            try self.writer.writeAll(&.{ @intFromEnum(ArgType.Crit), @as(u8, @bitCast(args[0])) });
         }
 
-        pub fn supereffective(self: Self, ident: ID) Error!void {
+        // ident: ID
+        pub fn supereffective(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.SuperEffective),
-                @as(u8, @bitCast(ident)),
+                @as(u8, @bitCast(args[0])),
             });
         }
 
-        pub fn resisted(self: Self, ident: ID) Error!void {
+        // ident: ID
+        pub fn resisted(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Resisted),
-                @as(u8, @bitCast(ident)),
+                @as(u8, @bitCast(args[0])),
             });
         }
 
-        pub fn immune(self: Self, ident: ID, reason: Immune) Error!void {
+        // ident: ID, reason: Immune
+        pub fn immune(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Immune),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(reason),
+                @as(u8, @bitCast(args[0])),
+                @intFromEnum(@as(Immune, args[1])),
             });
         }
 
-        pub fn transform(self: Self, source: ID, target: ID) Error!void {
+        // source: ID, target: ID
+        pub fn transform(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Transform),
-                @as(u8, @bitCast(source)),
-                @as(u8, @bitCast(target)),
+                @as(u8, @bitCast(args[0])),
+                @as(u8, @bitCast(args[1])),
             });
         }
 
-        pub fn drag(self: Self, ident: ID, pokemon: anytype) Error!void {
-            return switchDrag(self, .Drag, ident, pokemon);
+        // ident: ID, pokemon: <Pokemon>
+        pub fn drag(self: Self, args: anytype) Error!void {
+            return switchDrag(self, .Drag, args);
         }
 
-        pub fn item(self: Self, target: ID, i: anytype, source: ID) Error!void {
+        // target: ID, item: <Item>, source: ID
+        pub fn item(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Item),
-                @as(u8, @bitCast(target)),
-                @intFromEnum(i),
-                @as(u8, @bitCast(source)),
+                @as(u8, @bitCast(args[0])),
+                @intFromEnum(args[1]),
+                @as(u8, @bitCast(args[2])),
             });
         }
 
-        pub fn enditem(self: Self, ident: ID, i: anytype, reason: EndItem) Error!void {
+        // ident: ID, item: <Item>, reason: EndItem
+        pub fn enditem(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.EndItem),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(i),
-                @intFromEnum(reason),
+                @as(u8, @bitCast(args[0])),
+                @intFromEnum(args[1]),
+                @intFromEnum(@as(EndItem, args[2])),
             });
         }
 
-        pub fn cureteam(self: Self, source: ID) Error!void {
+        // source: ID
+        pub fn cureteam(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.CureTeam),
-                @as(u8, @bitCast(source)),
+                @as(u8, @bitCast(args[0])),
             });
         }
 
-        pub fn sethp(self: Self, ident: ID, pokemon: anytype, reason: SetHP) Error!void {
+        // 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(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));
+            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.writeAll(&.{args[1].status});
+            try self.writer.writeByte(@intFromEnum(@as(SetHP, args[2])));
         }
 
-        pub fn setboost(self: Self, ident: ID, num: i8) Error!void {
+        // ident: ID, num: i8
+        pub fn setboost(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.SetBoost),
-                @as(u8, @bitCast(ident)),
-                @as(u8, @intCast(num + 6)),
+                @as(u8, @bitCast(args[0])),
+                @as(u8, @intCast(args[1] + 6)),
             });
         }
 
-        pub fn copyboost(self: Self, source: ID, target: ID) Error!void {
+        // source: ID, target: ID
+        pub fn copyboost(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.CopyBoost),
-                @as(u8, @bitCast(source)),
-                @as(u8, @bitCast(target)),
+                @as(u8, @bitCast(args[0])),
+                @as(u8, @bitCast(args[1])),
             });
         }
 
-        pub fn sidestart(self: Self, player: Player, reason: Side) Error!void {
+        // player: Player, reason: Side
+        pub fn sidestart(self: Self, args: anytype) 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),
+                @intFromEnum(@as(Player, args[0])),
+                @intFromEnum(@as(Side, args[1])),
             });
         }
 
-        pub fn spikesend(self: Self, player: Player, m: anytype, source: ID) Error!void {
+        // player: Player, reason: Side
+        // player: Player, reason: .Spikes, source: ID
+        pub fn sideend(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
+            assert(args[1] != .Spikes or args.len == 3);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.SideEnd),
-                @intFromEnum(player),
-                @intFromEnum(Side.Spikes),
-                @intFromEnum(m),
-                @as(u8, @bitCast(source)),
+                @intFromEnum(@as(Player, args[0])),
+                @intFromEnum(@as(Side, args[1])),
             });
+            if (args.len == 3) try self.writer.writeByte(@as(u8, @bitCast(args[2])));
         }
 
-        pub fn singlemove(self: Self, ident: ID, m: anytype) Error!void {
-            return single(self, .SingleMove, ident, m);
+        // ident: ID, move: <Move>
+        pub fn singlemove(self: Self, args: anytype) Error!void {
+            return single(self, .SingleMove, args);
         }
 
-        pub fn singleturn(self: Self, ident: ID, m: anytype) Error!void {
-            return single(self, .SingleTurn, ident, m);
+        // ident: ID, move: <Move>
+        pub fn singleturn(self: Self, args: anytype) Error!void {
+            return single(self, .SingleTurn, args);
         }
 
-        fn single(self: Self, arg: ArgType, ident: ID, m: anytype) Error!void {
+        // ident: ID, move: <Move>
+        fn single(self: Self, arg: ArgType, args: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{
                 @intFromEnum(arg),
-                @as(u8, @bitCast(ident)),
-                @intFromEnum(m),
+                @as(u8, @bitCast(args[0])),
+                @intFromEnum(args[1]),
             });
         }
 
-        pub fn weather(self: Self, w: anytype, reason: Weather) Error!void {
+        // weather: <Weather>, reason: Weather
+        pub fn weather(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
-            assert(!(w == .None and reason == .Upkeep));
+            assert(!(args[0] == .None and args[1] == .Upkeep));
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Weather),
-                @intFromEnum(w),
-                @intFromEnum(reason),
+                @intFromEnum(args[0]),
+                @intFromEnum(@as(Weather, args[1])),
             });
         }
 
-        pub fn laststill(self: Self) Error!void {
+        // -
+        pub fn laststill(self: Self, _: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{@intFromEnum(ArgType.LastStill)});
         }
 
-        pub fn lastmiss(self: Self) Error!void {
+        // -
+        pub fn lastmiss(self: Self, _: anytype) Error!void {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{@intFromEnum(ArgType.LastMiss)});
@@ -1096,7 +1069,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]));
@@ -1104,6 +1083,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)),
@@ -1278,7 +1258,7 @@ const gen2 = struct {
     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() };
 
@@ -1316,22 +1296,22 @@ fn formatter(comptime gen: anytype, kind: Kind, byte: u8) []const u8 {
 }
 
 test "|move|" {
-    try log.move(p2.ident(4), M1.Thunderbolt, p1.ident(5));
+    try log.move(.{ p2.ident(4), M1.Thunderbolt, p1.ident(5) });
     try expectLog1(
         &.{ N(ArgType.Move), 0b1100, N(M1.Thunderbolt), 0b0101, N(Move.None) },
         buf[0..5],
     );
     stream.reset();
 
-    try log.moveFrom(p2.ident(4), M1.Pound, p1.ident(5), M1.Metronome);
+    try log.move(.{ p2.ident(4), M1.Pound, p1.ident(5), M1.Metronome });
     try expectLog1(
         &.{ 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), M1.SkullBash, .{});
-    try log.laststill();
+    try log.move(.{ p2.ident(4), M1.SkullBash, ID{} });
+    try log.laststill(.{});
     try expectLog1(
         &.{
             N(ArgType.Move),
@@ -1345,8 +1325,8 @@ test "|move|" {
     );
     stream.reset();
 
-    try log.move(p2.ident(4), M1.Tackle, p1.ident(5));
-    try log.lastmiss();
+    try log.move(.{ p2.ident(4), M1.Tackle, p1.ident(5) });
+    try log.lastmiss(.{});
     try expectLog1(
         &.{
             N(ArgType.Move),
@@ -1367,7 +1347,7 @@ test "|switch|" {
     snorlax.hp = 200;
     snorlax.stats.hp = 400;
     snorlax.status = gen1.Status.init(.PAR);
-    try log.switched(p2.ident(3), &snorlax);
+    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 },
@@ -1379,7 +1359,7 @@ test "|switch|" {
     snorlax.level = 100;
     snorlax.hp = 0;
     snorlax.status = 0;
-    try log.switched(p2.ident(3), &snorlax);
+    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 },
@@ -1388,7 +1368,7 @@ test "|switch|" {
     stream.reset();
 
     snorlax.hp = 400;
-    try log.switched(p2.ident(3), &snorlax);
+    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 },
@@ -1401,7 +1381,7 @@ test "|switch|" {
     blissey.hp = 200;
     blissey.stats.hp = 400;
     blissey.status = gen2.Status.init(.PAR);
-    try log.switched(p2.ident(3), &blissey);
+    try log.switched(.{ p2.ident(3), &blissey });
     expected = &(.{
         N(ArgType.Switch),
         0b1011,
@@ -1417,27 +1397,27 @@ test "|switch|" {
 }
 
 test "|cant|" {
-    try log.cant(p2.ident(6), .Bound);
+    try log.cant(.{ p2.ident(6), .Bound });
     try expectLog1(&.{ N(ArgType.Cant), 0b1110, N(Cant.Bound) }, buf[0..3]);
     stream.reset();
 
-    try log.disabled(p1.ident(2), 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();
 }
 
 test "|faint|" {
-    try log.faint(p2.ident(2), false);
+    try log.faint(.{ p2.ident(2), false });
     try expectLog1(&.{ N(ArgType.Faint), 0b1010 }, buf[0..2]);
     stream.reset();
 
-    try log.faint(p2.ident(2), true);
+    try log.faint(.{ p2.ident(2), true });
     try expectLog1(&.{ N(ArgType.Faint), 0b1010, N(ArgType.None) }, buf[0..3]);
     stream.reset();
 }
 
 test "|turn|" {
-    try log.turn(42);
+    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) },
@@ -1447,13 +1427,13 @@ test "|turn|" {
 }
 
 test "|win|" {
-    try log.win(.P2);
+    try log.win(.{.P2});
     try expectLog1(&.{ N(ArgType.Win), 1, N(ArgType.None) }, buf[0..3]);
     stream.reset();
 }
 
 test "|tie|" {
-    try log.tie();
+    try log.tie(.{});
     try expectLog1(&.{ N(ArgType.Tie), N(ArgType.None) }, buf[0..2]);
     stream.reset();
 }
@@ -1462,7 +1442,7 @@ 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, .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) },
@@ -1473,7 +1453,7 @@ test "|-damage|" {
     chansey.hp = 100;
     chansey.stats.hp = 256;
     chansey.status = 0;
-    try log.damage(p2.ident(2), &chansey, .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) },
@@ -1482,7 +1462,7 @@ test "|-damage|" {
     stream.reset();
 
     chansey.status = gen1.Status.init(.PSN);
-    try log.damageOf(p2.ident(2), &chansey, .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 },
@@ -1495,7 +1475,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, .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) },
@@ -1506,7 +1486,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, .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) },
@@ -1514,7 +1494,7 @@ test "|-heal|" {
     try expectLog1(expected, buf[0..8]);
     stream.reset();
 
-    try log.drain(p2.ident(2), &chansey, 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 },
@@ -1524,15 +1504,15 @@ test "|-heal|" {
 }
 
 test "|-status|" {
-    try log.status(p2.ident(6), gen1.Status.init(.BRN), .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), .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.statusFrom(p1.ident(1), gen1.Status.init(.PAR), 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],
@@ -1541,11 +1521,11 @@ test "|-status|" {
 }
 
 test "|-curestatus|" {
-    try log.curestatus(p2.ident(6), gen1.Status.slp(7), .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, .Silent);
+    try log.curestatus(.{ p1.ident(2), gen1.Status.TOX, .Silent });
     try expectLog1(&.{
         N(ArgType.CureStatus),
         0b0010,
@@ -1556,168 +1536,191 @@ test "|-curestatus|" {
 }
 
 test "|-boost|" {
-    try log.boost(p2.ident(6), .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), .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), .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();
 }
 
 test "|-clearallboost|" {
-    try log.clearallboost();
+    try log.clearallboost(.{});
     try expectLog1(&.{N(ArgType.ClearAllBoost)}, buf[0..1]);
     stream.reset();
 }
 
 test "|-fail|" {
-    try log.fail(p2.ident(6), .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), .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), .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), .Weak);
+    try log.fail(.{ p2.ident(6), .Weak });
     try expectLog1(&.{ N(ArgType.Fail), 0b1110, N(Fail.Weak) }, buf[0..3]);
     stream.reset();
 }
 
 test "|-miss|" {
-    try log.miss(p2.ident(4));
+    try log.miss(.{p2.ident(4)});
     try expectLog1(&.{ N(ArgType.Miss), 0b1100 }, buf[0..2]);
     stream.reset();
 }
 test "|-hitcount|" {
-    try log.hitcount(p2.ident(1), 5);
+    try log.hitcount(.{ p2.ident(1), 5 });
     try expectLog1(&.{ N(ArgType.HitCount), 0b1001, 5 }, buf[0..3]);
     stream.reset();
 }
 
 test "|-prepare|" {
-    try log.prepare(p2.ident(2), M1.Dig);
+    try log.prepare(.{ p2.ident(2), M1.Dig });
     try expectLog1(&.{ N(ArgType.Prepare), 0b1010, N(M1.Dig) }, buf[0..3]);
     stream.reset();
 }
 
 test "|-mustrecharge|" {
-    try log.mustrecharge(p1.ident(6));
+    try log.mustrecharge(.{p1.ident(6)});
     try expectLog1(&.{ N(ArgType.MustRecharge), 0b0110 }, buf[0..2]);
     stream.reset();
 }
 
 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();
+
+    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.activate(.{ p1.ident(3), .Magnitude, 5 });
+    try expectLog1(&.{ N(ArgType.Activate), 0b0011, N(Activate.Magnitude), 5 }, buf[0..4]);
+    stream.reset();
 }
 
 test "|-fieldactivate|" {
-    try log.fieldactivate();
+    try log.fieldactivate(.{});
     try expectLog1(&.{N(ArgType.FieldActivate)}, buf[0..1]);
     stream.reset();
 }
 
 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), .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), .ConfusionSilent);
+    try log.end(.{ p1.ident(2), .ConfusionSilent });
     try expectLog1(&.{ N(ArgType.End), 0b0010, N(End.ConfusionSilent) }, buf[0..3]);
     stream.reset();
 }
 
 test "|-ohko|" {
-    try log.ohko();
+    try log.ohko(.{});
     try expectLog1(&.{N(ArgType.OHKO)}, buf[0..1]);
     stream.reset();
 }
 
 test "|-crit|" {
-    try log.crit(p2.ident(5));
+    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 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 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 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), .OHKO);
+    try log.immune(.{ p2.ident(2), .OHKO });
     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 log.transform(.{ p2.ident(4), p1.ident(5) });
     try expectLog1(&.{ N(ArgType.Transform), 0b1100, 0b0101 }, buf[0..3]);
     stream.reset();
 }
@@ -1728,7 +1731,7 @@ test "|drag|" {
     blissey.hp = 200;
     blissey.stats.hp = 400;
     blissey.status = gen2.Status.init(.PAR);
-    try log.drag(p2.ident(3), &blissey);
+    try log.drag(.{ p2.ident(3), &blissey });
     const par = 0b1000000;
     const expected = &(.{
         N(ArgType.Drag),
@@ -1745,23 +1748,23 @@ test "|drag|" {
 }
 
 test "|-item|" {
-    try log.item(p2.ident(2), I2.GoldBerry, p1.ident(4));
+    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 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 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 log.cureteam(.{p2.ident(5)});
     try expectLog2(&.{ N(ArgType.CureTeam), 0b1101 }, buf[0..2]);
     stream.reset();
 }
@@ -1769,7 +1772,7 @@ test "|-cureteam|" {
 test "|-sethp|" {
     var blissey = gen2.helpers.Pokemon.init(.{ .species = .Blissey, .moves = &.{.PainSplit} });
     blissey.hp = 612;
-    try log.sethp(p2.ident(2), &blissey, .Silent);
+    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) },
@@ -1779,61 +1782,60 @@ test "|-sethp|" {
 }
 
 test "|-setboost|" {
-    try log.setboost(p2.ident(6), 6);
+    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 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 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 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 log.sideend(.{ .P2, .LightScreen });
     try expectLog2(&.{ N(ArgType.SideEnd), 1, N(Side.LightScreen) }, buf[0..3]);
     stream.reset();
 
-    try log.spikesend(.P1, M2.RapidSpin, p1.ident(3));
+    try log.sideend(.{ .P1, .Spikes, p1.ident(3) });
     try expectLog2(&.{
         N(ArgType.SideEnd),
         0,
         N(Side.Spikes),
-        N(M2.RapidSpin),
         0b0011,
-    }, buf[0..5]);
+    }, buf[0..4]);
     stream.reset();
 }
 
 test "|-singlemove|" {
-    try log.singlemove(p2.ident(2), M2.DestinyBond);
+    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 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 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 log.weather(.{ W2.None, .None });
     try expectLog2(&.{ N(ArgType.Weather), N(W2.None), N(Weather.None) }, buf[0..3]);
     stream.reset();
 }