@pkmn/engine 0.1.0-dev.21e728d9 → 0.1.0-dev.29e0e9e1

package/src/lib/gen2/mechanics.zig

@@ -26,9 +26,9 @@ const Result = common.Result;
 
 const Activate = protocol.Activate;
 const Boost = protocol.Boost;
-const Cant = protocol.Cant;
 const Damage = protocol.Damage;
 const End = protocol.End;
+const Fail = protocol.Fail;
 const Heal = protocol.Heal;
 const Start = protocol.Start;
 
@@ -252,15 +252,15 @@ fn switchIn(battle: anytype, player: Player, slot: u8, kind: SwitchIn, options:
     statusModify(incoming.status, &active.stats);
 
     if (kind == .Drag) {
-        try options.log.drag(battle.active(player), incoming);
+        try options.log.drag(.{ battle.active(player), incoming });
     } else {
-        try options.log.switched(battle.active(player), incoming);
+        try options.log.switched(.{ battle.active(player), incoming });
     }
     options.chance.switched(player, side.pokemon[0].position, out);
 
     if (side.conditions.Spikes and !active.types.includes(.Flying)) {
         incoming.hp -|= @max(incoming.stats.hp / 8, 1);
-        try options.log.damage(battle.active(player), incoming, .Spikes);
+        try options.log.damage(.{ battle.active(player), incoming, .Spikes });
     }
 }
 
@@ -433,7 +433,7 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
     if (volatiles.Recharging) {
         volatiles.Recharging = false;
         resetCant(volatiles);
-        try log.cant(ident, .Recharge);
+        try log.cant(.{ ident, .Recharge });
         return false;
     }
 
@@ -452,12 +452,12 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
         }
 
         if (duration == 0) {
-            try log.curestatus(ident, before, .Message);
+            try log.curestatus(.{ ident, before, .Message });
             stored.status = 0; // clears EXT if present
             resetCant(volatiles);
             volatiles.Nightmare = false;
         } else {
-            try log.cant(ident, .Sleep);
+            try log.cant(.{ ident, .Sleep });
             if (move == .Snore or move == .SleepTalk) break :slp;
             resetCant(volatiles);
             return false;
@@ -466,7 +466,7 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
 
     if (Status.is(stored.status, .FRZ) and !(move == .FlameWheel or move == .SacredFire)) {
         resetCant(volatiles);
-        try log.cant(ident, .Freeze);
+        try log.cant(.{ ident, .Freeze });
         return false;
     }
 
@@ -476,7 +476,7 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
         // if (!showdown) volatiles.Flinch = false;
         volatiles.Flinch = false;
         resetCant(volatiles);
-        try log.cant(ident, .Flinch);
+        try log.cant(.{ ident, .Flinch });
         return false;
     }
 
@@ -490,7 +490,7 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
 
         if (volatiles.disable.duration == 0) {
             volatiles.disable.move = 0;
-            try log.end(ident, .Disable);
+            try log.end(.{ ident, .Disable });
         }
     }
 
@@ -506,9 +506,9 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
 
         if (volatiles.confusion == 0) {
             volatiles.Confusion = false;
-            try log.end(ident, .Confusion);
+            try log.end(.{ ident, .Confusion });
         } else {
-            try log.activate(ident, .Confusion);
+            try log.activate(.{ ident, .Confusion });
 
             if (try Rolls.confused(battle, player, options)) {
                 volatiles.BeatUp = false;
@@ -523,11 +523,11 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
     }
 
     if (volatiles.Attract) {
-        try log.activate(ident, .Attract);
+        try log.activate(.{ ident, .Attract });
 
         if (try Rolls.attract(battle, player, options)) {
             resetCant(volatiles);
-            try log.cant(ident, .Attract);
+            try log.cant(.{ ident, .Attract });
             return false;
         }
     }
@@ -538,14 +538,14 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
         if (m != .None and m == move) {
             side.active.volatiles.Charging = false;
             resetCant(volatiles);
-            try options.log.disabled(ident, move);
+            try options.log.cant(.{ ident, .Disable, move });
             return false;
         }
     }
 
     if (Status.is(stored.status, .PAR) and try Rolls.paralyzed(battle, player, options)) {
         resetCant(volatiles);
-        try log.cant(ident, .Paralysis);
+        try log.cant(.{ ident, .Paralysis });
         return false;
     }
 
@@ -569,7 +569,7 @@ pub fn canMove(battle: anytype, player: Player, state: *State, options: anytype)
 
     // FIXME: pass in target to avoid lookup?
     const target = if (Move.get(state.move).target == .Self) player else player.foe();
-    try options.log.moveFrom(battle.active(player), state.move, battle.active(target), state.from);
+    try options.log.move(.{ battle.active(player), state.move, battle.active(target), state.from });
 
     const charging = false; // TODO charging uses doUse
     const skip_pp = charging or state.move == .Struggle or
@@ -849,13 +849,13 @@ fn checkFaint(
     if (foe_fainted) try faint(battle, player.foe(), !more, options);
 
     if (player_out and foe_out) {
-        try options.log.tie();
+        try options.log.tie(.{});
         return Result.Tie;
     } else if (player_out) {
-        try options.log.win(player.foe());
+        try options.log.win(.{player.foe()});
         return if (player == .P1) Result.Lose else Result.Win;
     } else if (foe_out) {
-        try options.log.win(player);
+        try options.log.win(.{player});
         return if (player == .P1) Result.Win else Result.Lose;
     }
 
@@ -885,19 +885,19 @@ fn faint(battle: anytype, player: Player, done: bool, options: anytype) !void {
             side.stored().stats.spe;
     }
 
-    try options.log.faint(battle.active(player), done);
+    try options.log.faint(.{ battle.active(player), done });
     options.calc.capped(player);
 }
 
 // TODO: see if we can move *before* applyDamage and include failuretext logic
 pub fn reportOutcome(battle: anytype, player: Player, state: *State, options: anytype) !void {
     const foe_ident = battle.active(player.foe());
-    if (state.crit) try options.log.crit(foe_ident);
+    if (state.crit) try options.log.crit(.{foe_ident});
     if (!state.immune()) {
         if (state.effectiveness > Effectiveness.neutral) {
-            try options.log.supereffective(foe_ident);
+            try options.log.supereffective(.{foe_ident});
         } else if (state.effectiveness < Effectiveness.neutral) {
-            try options.log.resisted(foe_ident);
+            try options.log.resisted(.{foe_ident});
         }
     }
 }
@@ -930,8 +930,8 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !bool {
         }
 
         stored.hp -|= damage;
-        // Pokémon Showdown uses damageOf here but its not relevant in Generation II
-        try options.log.damage(ident, stored, if (brn) Damage.Burn else Damage.Poison);
+        // Pokémon Showdown uses damage [of] here but its not relevant in Generation II
+        try options.log.damage(.{ ident, stored, if (brn) Damage.Burn else Damage.Poison });
         if (stored.hp == 0) return true;
     }
 
@@ -947,27 +947,27 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !bool {
 
         const damage = @max(stored.stats.hp / 8, 1);
         stored.hp -|= damage;
-        // As above, Pokémon Showdown uses damageOf but its not relevant
-        try options.log.damage(ident, stored, .LeechSeed);
+        // As above, Pokémon Showdown uses damage [of] but its not relevant
+        try options.log.damage(.{ ident, stored, .LeechSeed });
 
         const before = foe_stored.hp;
         foe_stored.hp = @min(foe_stored.hp + damage, foe_stored.stats.hp);
         // Pokémon Showdown uses the less specific heal here instead of drain... because reasons?
-        if (foe_stored.hp > before) try options.log.heal(foe_ident, foe_stored, .Silent);
+        if (foe_stored.hp > before) try options.log.heal(.{ foe_ident, foe_stored, .Silent });
         if (stored.hp == 0) return true;
     }
 
     if (volatiles.Nightmare) {
         stored.hp -= @max(stored.stats.hp / 4, 1);
         // ibid
-        try options.log.damage(ident, stored, .Nightmare);
+        try options.log.damage(.{ ident, stored, .Nightmare });
         if (stored.hp == 0) return true;
     }
 
     if (volatiles.Curse) {
         stored.hp -= @max(stored.stats.hp / 4, 1);
         // ibid
-        try options.log.damage(ident, stored, .Curse);
+        try options.log.damage(.{ ident, stored, .Curse });
         if (stored.hp == 0) return true;
     }
 
@@ -988,7 +988,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
             future_sight.count -= 1;
             assert(future_sight.count != 0);
             if (future_sight.count == 1) {
-                try options.log.end(battle.active(player), .FutureSight);
+                try options.log.end(.{ battle.active(player), .FutureSight });
                 // TODO doMove
             }
         }
@@ -1002,16 +1002,20 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
 
         if (battle.field.weather_duration == 0) {
             battle.field.weather = .None;
-            try options.log.weather(battle.field.weather, .None);
+            try options.log.weather(.{ battle.field.weather, protocol.Weather.None });
         } else {
-            try options.log.weather(battle.field.weather, .Upkeep);
+            try options.log.weather(.{ battle.field.weather, protocol.Weather.Upkeep });
             if (battle.field.weather == .Sandstorm) {
                 inline for (players) |player| {
                     var side = battle.side(player);
                     const active = side.active;
                     if (!(active.volatiles.Underground or active.types.sandstormImmune())) {
                         side.stored().hp -|= @max(side.stored().stats.hp / 8, 1);
-                        try options.log.damage(battle.active(player), side.stored(), .Sandstorm);
+                        try options.log.damage(.{
+                            battle.active(player),
+                            side.stored(),
+                            .Sandstorm,
+                        });
                     }
                 }
                 if (try checkFaint(battle, .P1, options)) |r| return r;
@@ -1023,19 +1027,24 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
     inline for (players) |player| {
         var side = battle.side(player);
         var volatiles = &side.active.volatiles;
+        const ident = battle.active(player);
 
         if (volatiles.bind.duration > 0 and !volatiles.Substitute) {
             volatiles.bind.duration -= 1;
             if (volatiles.bind.duration == 0) {
                 const reason = @intFromEnum(End.Bind) + volatiles.bind.reason - 1;
-                try options.log.end(battle.active(player), @enumFromInt(reason));
+                try options.log.end(.{ ident, @as(End, @enumFromInt(reason)) });
             } else {
                 var reason = @intFromEnum(Activate.Bind) + volatiles.bind.reason - 1;
-                try options.log.activate(battle.active(player), @enumFromInt(reason));
+                try options.log.activate(.{ ident, @as(Activate, @enumFromInt(reason)) });
 
                 reason = @intFromEnum(Damage.Bind) + volatiles.bind.reason - 1;
                 side.stored().hp -|= @max(side.stored().stats.hp / 16, 1);
-                try options.log.damage(battle.active(player), side.stored(), @enumFromInt(reason));
+                try options.log.damage(.{
+                    ident,
+                    side.stored(),
+                    @as(Damage, @enumFromInt(reason)),
+                });
             }
         }
     }
@@ -1052,7 +1061,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
 
             assert(volatiles.perish_song < 3);
             const reason = @intFromEnum(Start.PerishSong0) + volatiles.perish_song;
-            try options.log.start(battle.active(player), @enumFromInt(reason));
+            try options.log.start(.{ battle.active(player), @as(Start, @enumFromInt(reason)) });
 
             if (volatiles.perish_song == 0) {
                 volatiles.PerishSong = false;
@@ -1069,7 +1078,9 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
         if (stored.item == .Leftovers) {
             const before = stored.hp;
             stored.hp = @min(stored.hp + @max(stored.stats.hp / 16, 1), stored.stats.hp);
-            if (stored.hp > before) try options.log.heal(battle.active(player), stored, .Leftovers);
+            if (stored.hp > before) {
+                try options.log.heal(.{ battle.active(player), stored, .Leftovers });
+            }
         }
     }
 
@@ -1090,7 +1101,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
             !side.active.volatiles.frozen and
             try Rolls.defrost(battle, player, options))
         {
-            try options.log.curestatus(battle.active(player), side.stored().status, .Message);
+            try options.log.curestatus(.{ battle.active(player), side.stored().status, .Message });
             side.stored().status = 0;
         }
     }
@@ -1131,14 +1142,14 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
                     stored.hp < stored.stats.hp;
                 if (proc) {
                     assert(stored.hp != 0);
-                    try options.log.enditem(ident, stored.item, .Eat);
+                    try options.log.enditem(.{ ident, stored.item, .Eat });
                     stored.item = .None;
 
                     const offset = num - @intFromEnum(Item.Berry);
                     assert(offset < 3);
                     stored.hp = @min(stored.hp + ((offset + 1) * 10), stored.stats.hp);
                     const reason: Heal = @enumFromInt(@intFromEnum(Heal.Berry) + offset);
-                    try options.log.heal(ident, stored, reason);
+                    try options.log.heal(.{ ident, stored, reason });
                 }
             } else if (num < @intFromEnum(Item.BitterBerry)) {
                 const proc = if (stored.item == .MiracleBerry)
@@ -1148,7 +1159,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
 
                 if (proc) {
                     assert(Status.any(stored.status));
-                    try options.log.enditem(ident, stored.item, .Eat);
+                    try options.log.enditem(.{ ident, stored.item, .Eat });
                     stored.item = .None;
 
                     // FIXME wtf?
@@ -1156,21 +1167,21 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
                     // side.active.volatiles.Nightmare = false;
                     if (stored.item == .MiracleBerry) {
                         side.active.volatiles.Confusion = false;
-                        try options.log.end(ident, .Confusion);
+                        try options.log.end(.{ ident, .Confusion });
                     }
                     stored.status = 0;
 
                     // FIXME recalc stats
 
-                    try options.log.curestatus(ident, stored.status, .Message);
+                    try options.log.curestatus(.{ ident, stored.status, .Message });
                 }
             } else if (num == @intFromEnum(Item.BitterBerry)) {
                 if (side.active.volatiles.Confusion) {
-                    try options.log.enditem(ident, stored.item, .Eat);
+                    try options.log.enditem(.{ ident, stored.item, .Eat });
                     stored.item = .None;
 
                     side.active.volatiles.Confusion = false;
-                    try options.log.end(ident, .Confusion);
+                    try options.log.end(.{ ident, .Confusion });
                 }
             }
         }
@@ -1187,7 +1198,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
 
             if (volatiles.encore == 0 or side.active.move(mslot).pp == 0) {
                 volatiles.Encore = false;
-                try options.log.end(battle.active(player), .Encore);
+                try options.log.end(.{ battle.active(player), .Encore });
             }
         }
     }
@@ -1209,7 +1220,7 @@ fn updateSideCondition(
 
         if (@field(side.conditions, value) == 0) {
             @field(side.conditions, key) = false;
-            try options.log.sideend(player, @field(protocol.Side, key));
+            try options.log.sideend(.{ player, @field(protocol.Side, key) });
         }
     }
 }
@@ -1218,13 +1229,13 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
     battle.turn += 1;
 
     if (showdown and battle.turn >= 1000) {
-        try options.log.tie();
+        try options.log.tie(.{});
         return Result.Tie;
     } else if (battle.turn >= 65535) {
         return Result.Error;
     }
 
-    try options.log.turn(battle.turn);
+    try options.log.turn(.{battle.turn});
 
     return Result.Default;
 }
@@ -1240,7 +1251,7 @@ pub fn buildRage(battle: anytype, player: Player, state: *State, options: anytyp
             }
         } else {
             foe.active.volatiles.rage +|= 1;
-            try options.log.activate(battle.active(player), .Rage);
+            try options.log.activate(.{ battle.active(player), .Rage });
         }
     }
 }
@@ -1263,7 +1274,7 @@ pub fn destinyBond(battle: anytype, player: Player, _: *State, options: anytype)
 
     if (foe.active.volatiles.DestinyBond) {
         battle.side(player).stored().hp = 0;
-        try options.log.activate(battle.active(player.foe()), .DestinyBond);
+        try options.log.activate(.{ battle.active(player.foe()), .DestinyBond });
     }
     return true;
 }
@@ -1276,14 +1287,14 @@ pub const Effects = struct {
         const gender: u8 = @intFromEnum(side.stored().dvs.gender);
         const foe_gender: u8 = @intFromEnum(foe.stored().dvs.gender);
         if (gender + foe_gender != 1) {
-            return options.log.immune(battle.active(player.foe()), .None);
+            return options.log.immune(.{ battle.active(player.foe()), .None });
         } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-            try options.log.lastmiss();
-            return options.log.miss(battle.active(player));
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
         }
 
         foe.active.volatiles.Attract = true;
-        try options.log.start(battle.active(player.foe()), .Attract);
+        try options.log.start(.{ battle.active(player.foe()), .Attract });
     }
 
     pub fn batonPass(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1322,10 +1333,10 @@ pub const Effects = struct {
             // }
             try options.chance.attacking(player, volatiles.attacks);
 
-            if (volatiles.attacks != 0) return options.log.activate(ident, .Bide);
+            if (volatiles.attacks != 0) return options.log.activate(.{ ident, .Bide });
 
             volatiles.Bide = false;
-            try options.log.end(ident, .Bide);
+            try options.log.end(.{ ident, .Bide });
 
             state.damage = volatiles.bide *% 2;
             volatiles.bide = 0;
@@ -1359,11 +1370,11 @@ pub const Effects = struct {
         if (Status.any(foe_stored.status)) {
             if (Status.is(foe_stored.status, .FRZ)) {
                 assert(Move.get(state.move).type == .Fire or state.move == .TriAttack);
-                try options.log.curestatus(
+                try options.log.curestatus(.{
                     battle.active(player.foe()),
                     foe_stored.status,
                     .Message,
-                );
+                });
                 foe_stored.status = 0;
             }
             return;
@@ -1378,7 +1389,8 @@ pub const Effects = struct {
 
         foe_stored.status = Status.init(.BRN);
         foe.active.stats.atk = @max(foe.active.stats.atk / 2, 1);
-        try options.log.status(battle.active(player.foe()), foe_stored.status, .None);
+
+        try options.log.status(.{ battle.active(player.foe()), foe_stored.status, .None });
 
         // TODO: check for status berry
     }
@@ -1398,7 +1410,7 @@ pub const Effects = struct {
         for (side.active.moves) |m| {
             if (convertible(side.active, m.id)) n += 1;
         }
-        if (n == 0) return options.log.fail(battle.active(player), .None);
+        if (n == 0) return options.log.fail(.{ battle.active(player), .None });
 
         side.active.types.type1 = try Rolls.conversion(battle, player, n, options);
         side.active.types.type2 = side.active.types.type1;
@@ -1408,9 +1420,9 @@ pub const Effects = struct {
         var side = battle.side(player);
 
         const last = battle.foe(player).lastMove(false);
-        if (last == .None) return options.log.fail(battle.active(player), .None);
+        if (last == .None) return options.log.fail(.{ battle.active(player), .None });
         const move = Move.get(last);
-        if (move.type == .@"???") return options.log.fail(battle.active(player), .None);
+        if (move.type == .@"???") return options.log.fail(.{ battle.active(player), .None });
 
         side.active.types.type1 = try Rolls.conversion2(battle, player, move.type, options);
         side.active.types.type2 = side.active.types.type1;
@@ -1452,41 +1464,41 @@ pub const Effects = struct {
 
         if (side.active.types.includes(.Ghost)) {
             if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-                try options.log.lastmiss();
-                return options.log.miss(battle.active(player));
+                try options.log.lastmiss(.{});
+                return options.log.miss(.{battle.active(player)});
             } else if (foe.active.volatiles.Substitute) {
-                return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+                return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
             } else if (foe.active.volatiles.Curse) {
-                return options.log.fail(foe_ident, .None);
+                return options.log.fail(.{ foe_ident, .None });
             }
 
             foe.active.volatiles.Curse = true;
-            try options.log.start(foe_ident, .Curse);
+            try options.log.start(.{ foe_ident, .Curse });
 
             side.stored().hp -= @max(side.stored().stats.hp / 2, 1);
-            try options.log.damage(ident, side.stored(), .Curse);
+            try options.log.damage(.{ ident, side.stored(), .Curse });
         } else {
             var stats = &side.active.stats;
             var boosts = &side.active.boosts;
 
             const max_atk = boosts.atk == 6 or stats.atk == MAX_STAT_VALUE;
             const max_def = boosts.def == 6 or stats.def == MAX_STAT_VALUE;
-            if (max_atk and max_def) return options.log.fail(ident, .None);
+            if (max_atk and max_def) return options.log.fail(.{ ident, .None });
 
             if (!(boosts.spe == -6 or stats.spe == 1)) {
                 assert(boosts.spe >= -6 and boosts.spe <= 6);
                 try unboostStat(battle, side, stats, boosts, "spe", 1);
-                try options.log.boost(ident, .Speed, @as(i8, -1));
+                try options.log.boost(.{ ident, .Speed, @as(i8, -1) });
             }
             if (!max_atk) {
                 assert(boosts.atk >= -6 and boosts.atk <= 6);
                 try boostStat(battle, side, stats, boosts, "atk", 1);
-                try options.log.boost(ident, .Attack, @as(i8, 1));
+                try options.log.boost(.{ ident, .Attack, @as(i8, 1) });
             }
             if (!max_def) {
                 assert(boosts.def >= -6 and boosts.def <= 6);
                 try boostStat(battle, side, stats, boosts, "def", 1);
-                try options.log.boost(ident, .Defense, @as(i8, 1));
+                try options.log.boost(.{ ident, .Defense, @as(i8, 1) });
             }
         }
     }
@@ -1498,14 +1510,13 @@ pub const Effects = struct {
     pub fn defrost(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var side = battle.side(player);
         assert(Status.is(side.stored().status, .FRZ));
-
-        try options.log.curestatus(battle.active(player), side.stored().status, .Message);
+        try options.log.curestatus(.{ battle.active(player), side.stored().status, .Message });
         side.stored().status = 0;
     }
 
     pub fn destinyBond(battle: anytype, player: Player, _: *State, options: anytype) !void {
         battle.side(player).active.volatiles.DestinyBond = true;
-        try options.log.singlemove(battle.active(player), Move.DestinyBond);
+        try options.log.singlemove(.{ battle.active(player), Move.DestinyBond });
     }
 
     pub fn disable(battle: anytype, player: Player, _: *State, options: anytype) !void {
@@ -1513,14 +1524,10 @@ pub const Effects = struct {
         var volatiles = &foe.active.volatiles;
         const foe_ident = battle.active(player.foe());
 
-        if (volatiles.disable.move != 0) {
-            return options.log.fail(foe_ident, .None);
-        }
+        if (volatiles.disable.move != 0) return options.log.fail(.{ foe_ident, .None });
 
         const last = battle.foe(player).lastMove(false);
-        if (last == .None or last == .Struggle) {
-            return options.log.fail(foe_ident, .None);
-        }
+        if (last == .None or last == .Struggle) return options.log.fail(.{ foe_ident, .None });
 
         var slot: u3 = 0;
         for (foe.active.moves) |m| {
@@ -1529,12 +1536,12 @@ pub const Effects = struct {
             if (m.id == last) break;
         }
         const move = foe.active.move(slot);
-        if (move.pp == 0) return options.log.fail(foe_ident, .None);
+        if (move.pp == 0) return options.log.fail(.{ foe_ident, .None });
 
         volatiles.disable.move = slot;
         volatiles.disable.duration = Rolls.disableDuration(battle, player, options);
 
-        try options.log.startEffect(foe_ident, .Disable, move.id);
+        try options.log.start(.{ foe_ident, .Disable, move.id });
     }
 
     pub const double = struct {
@@ -1553,13 +1560,14 @@ pub const Effects = struct {
 
     pub fn drainHP(battle: anytype, player: Player, state: *State, options: anytype) !void {
         var stored = battle.side(player).stored();
+        const ident = battle.active(player);
 
         assert(state.damage != 0);
 
         if (stored.hp == stored.stats.hp) return;
         stored.hp = @min(stored.stats.hp, stored.hp + @max(state.damage / 2, 1));
 
-        try options.log.drain(battle.active(player), stored, battle.active(player.foe()));
+        try options.log.heal(.{ ident, stored, .Drain, battle.active(player.foe()) });
     }
 
     pub fn encore(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1571,7 +1579,7 @@ pub const Effects = struct {
         const failed = volatiles.Encore or
             (last == .None or last == .Struggle or
             last == .Encore or .last == .MirrorMove);
-        if (failed) return options.log.fail(foe_ident, .None);
+        if (failed) return options.log.fail(.{ foe_ident, .None });
 
         var slot: u3 = 0;
         for (foe.active.moves) |m| {
@@ -1580,7 +1588,7 @@ pub const Effects = struct {
             if (m.id == last) break;
         }
         const move = foe.active.move(slot);
-        if (move.pp == 0) return options.log.fail(foe_ident, .None);
+        if (move.pp == 0) return options.log.fail(.{ foe_ident, .None });
 
         volatiles.Encore = true;
         volatiles.encore = Rolls.encoreDuration(battle, player, options);
@@ -1588,7 +1596,7 @@ pub const Effects = struct {
         // TODO ???
         _ = state;
 
-        try options.log.startEffect(foe_ident, .Encore, move.id);
+        try options.log.start(.{ foe_ident, .Encore, move.id });
     }
 
     pub fn explode(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1642,12 +1650,11 @@ pub const Effects = struct {
         var side = battle.side(player);
 
         if (side.active.volatiles.FocusEnergy) {
-            if (!showdown) try options.log.fail(battle.active(player), .None);
-            return;
+            return if (!showdown) try options.log.fail(.{ battle.active(player), .None });
         }
 
         side.active.volatiles.FocusEnergy = true;
-        try options.log.start(battle.active(player), .FocusEnergy);
+        try options.log.start(.{ battle.active(player), .FocusEnergy });
     }
 
     var SLOTS: [5]u4 = .{ 0, 0, 0, 0, 0 };
@@ -1657,7 +1664,7 @@ pub const Effects = struct {
 
         const foe = battle.foe(player);
 
-        if (state.first) return options.log.fail(battle.active(player), .None);
+        if (state.first) return options.log.fail(.{ battle.active(player), .None });
 
         var n: u4 = 0;
         var i: u4 = 0;
@@ -1671,7 +1678,7 @@ pub const Effects = struct {
             }
         }
 
-        if (n == 0) return options.log.fail(battle.active(player), .None);
+        if (n == 0) return options.log.fail(.{ battle.active(player), .None });
 
         const slot = try Rolls.forceSwitch(battle, player, SLOTS[0..i], n, options);
         try switchIn(battle, player.foe(), slot, .Drag, options);
@@ -1681,14 +1688,14 @@ pub const Effects = struct {
         var foe = battle.foe(player);
 
         if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-            try options.log.lastmiss();
-            return options.log.miss(battle.active(player));
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
         } else if (foe.active.volatiles.Foresight) {
-            return options.log.fail(battle.active(player), .None);
+            return options.log.fail(.{ battle.active(player), .None });
         }
 
         foe.active.volatiles.Foresight = true;
-        try options.log.start(battle.active(player.foe()), .FocusEnergy);
+        try options.log.start(.{ battle.active(player.foe()), .FocusEnergy });
     }
 
     pub fn freezeChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1711,7 +1718,7 @@ pub const Effects = struct {
         if (showdown) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
 
         foe_stored.status = Status.init(.FRZ);
-        try options.log.status(foe_ident, foe_stored.status, .None);
+        try options.log.status(.{ foe_ident, foe_stored.status, .None });
 
         // TODO: check for status berry
 
@@ -1746,7 +1753,7 @@ pub const Effects = struct {
         inline for (STATS) |s| @field(foe.active.stats, s) = @field(stats, s);
         statusModify(foe.stored().status, &foe.active.stats);
 
-        try options.log.clearallboost();
+        try options.log.clearallboost(.{});
     }
 
     pub fn heal(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1754,7 +1761,7 @@ pub const Effects = struct {
         var stored = side.stored();
         const ident = battle.active(player);
 
-        if (stored.stats.hp == stored.hp) return options.log.fail(ident, .None);
+        if (stored.stats.hp == stored.hp) return options.log.fail(.{ ident, .None });
 
         const rest = state.move == .Rest;
         if (rest) {
@@ -1763,19 +1770,19 @@ pub const Effects = struct {
             side.active.volatiles.Toxic = false;
             stored.status = Status.slf(2);
             recomputeStats(battle, side);
-            try options.log.statusFrom(ident, stored.status, Move.Rest);
+            try options.log.status(.{ ident, stored.status, .From, Move.Rest });
             stored.hp = stored.stats.hp;
         } else {
             stored.hp = @min(stored.stats.hp, stored.hp + (stored.stats.hp / 2));
         }
-        try options.log.heal(ident, stored, if (rest) Heal.Silent else Heal.None);
+        try options.log.heal(.{ ident, stored, if (rest) Heal.Silent else Heal.None });
     }
 
     pub fn healBell(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var side = battle.side(player);
         side.active.volatiles.Nightmare = false;
 
-        try options.log.cureteam(battle.active(player));
+        try options.log.cureteam(.{battle.active(player)});
         for (&side.pokemon) |*p| p.status = 0;
 
         // We technically only need to recompute stats if the active Pokémon was burned/paralyzed,
@@ -1791,7 +1798,7 @@ pub const Effects = struct {
 
     pub fn hyperBeam(battle: anytype, player: Player, _: *State, options: anytype) !void {
         battle.side(player).active.volatiles.Recharging = true;
-        try options.log.mustrecharge(battle.active(player));
+        try options.log.mustrecharge(.{battle.active(player)});
     }
 
     pub fn leechSeed(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1801,12 +1808,12 @@ pub const Effects = struct {
             // Invulnerability trumps type immunity on Pokémon Showdown
             const invulnerable = foe.active.volatiles.Underground or foe.active.volatiles.Flying;
             if (!invulnerable and foe.active.types.includes(.Grass)) {
-                return options.log.immune(battle.active(player.foe()), .None);
+                return options.log.immune(.{ battle.active(player.foe()), .None });
             }
             try checkHit(battle, player, state, options);
             if (state.miss) {
-                try options.log.lastmiss();
-                return options.log.miss(battle.active(player));
+                try options.log.lastmiss(.{});
+                return options.log.miss(.{battle.active(player)});
             }
             if (foe.active.volatiles.LeechSeed) return;
         } else {
@@ -1814,14 +1821,14 @@ pub const Effects = struct {
             const miss =
                 state.miss or foe.active.types.includes(.Grass) or foe.active.volatiles.LeechSeed;
             if (miss) {
-                try options.log.lastmiss();
-                return options.log.miss(battle.active(player));
+                try options.log.lastmiss(.{});
+                return options.log.miss(.{battle.active(player)});
             }
         }
 
         foe.active.volatiles.LeechSeed = true;
 
-        try options.log.start(battle.active(player.foe()), .LeechSeed);
+        try options.log.start(.{ battle.active(player.foe()), .LeechSeed });
     }
 
     pub fn lockOn(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1829,20 +1836,20 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
 
         if (foe.active.volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         } else if (state.miss) {
-            return options.log.fail(foe_ident, .None);
+            return options.log.fail(.{ foe_ident, .None });
         }
 
         foe.active.volatiles.LockOn = true;
-        try options.log.activate(battle.active(player), .LockOn);
+        try options.log.activate(.{ battle.active(player), .LockOn });
     }
 
     const MAGNITUDE_POWER = [_]u8{ 10, 30, 50, 70, 90, 110, 150 };
 
     pub fn magnitude(battle: anytype, player: Player, state: *State, options: anytype) !void {
         const num = try Rolls.magnitude(battle, player, options);
-        try options.log.magnitude(battle.active(player), num);
+        try options.log.activate(.{ battle.active(player), .Magnitude, num });
         state.bp = MAGNITUDE_POWER[num - 4];
     }
 
@@ -1850,11 +1857,11 @@ pub const Effects = struct {
         var foe = battle.foe(player);
 
         if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-            if (!showdown) return options.log.fail(battle.active(player.foe()), .None);
-            try options.log.lastmiss();
-            return options.log.miss(battle.active(player));
+            if (!showdown) return options.log.fail(.{ battle.active(player.foe()), .None });
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
         } else if (foe.active.volatiles.Trapped) {
-            return options.log.fail(battle.active(player.foe()), .None);
+            return options.log.fail(.{ battle.active(player.foe()), .None });
         }
 
         foe.active.volatiles.Trapped = true;
@@ -1898,11 +1905,11 @@ pub const Effects = struct {
 
         const last = foe.lastMove(false);
 
-        if (last == .None) return options.log.fail(battle.active(player), .None);
+        if (last == .None) return options.log.fail(.{ battle.active(player), .None });
         const knows = knows: for (side.active.moves) |m| {
             if (last == m.id) break :knows true;
         } else false;
-        if (knows) return options.log.fail(battle.active(player), .None);
+        if (knows) return options.log.fail(.{ battle.active(player), .None });
 
         // if (wPlayerCharging) ???
         // wPlayerCharging = 1
@@ -1916,17 +1923,17 @@ pub const Effects = struct {
     pub fn mist(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var side = battle.side(player);
 
-        if (side.active.volatiles.Mist) return options.log.fail(battle.active(player), .None);
+        if (side.active.volatiles.Mist) return options.log.fail(.{ battle.active(player), .None });
         side.active.volatiles.Mist = true;
 
-        try options.log.start(battle.active(player), .Mist);
+        try options.log.start(.{ battle.active(player), .Mist });
     }
 
     pub fn weatherHeal(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var stored = battle.side(player).stored();
         const ident = battle.active(player);
 
-        if (stored.hp == stored.stats.hp) return options.log.fail(ident, .None);
+        if (stored.hp == stored.stats.hp) return options.log.fail(.{ ident, .None });
 
         stored.hp = switch (battle.field.weather) {
             .Sun => stored.stats.hp,
@@ -1934,7 +1941,7 @@ pub const Effects = struct {
             else => @min(stored.stats.hp, stored.hp + (stored.stats.hp / 4)),
         };
 
-        try options.log.heal(ident, stored, Heal.None);
+        try options.log.heal(.{ ident, stored, .None });
     }
 
     pub fn multiHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1947,17 +1954,17 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
 
         if (foe_volatiles.Flying or foe_volatiles.Underground) {
-            if (!showdown) return options.log.fail(battle.active(player.foe()), .None);
-            try options.log.lastmiss();
-            return options.log.miss(battle.active(player));
+            if (!showdown) return options.log.fail(.{ battle.active(player.foe()), .None });
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
         } else if (foe_volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         } else if (!Status.is(foe.stored().status, .SLP) or foe_volatiles.Nightmare) {
-            return options.log.fail(foe_ident, .None);
+            return options.log.fail(.{ foe_ident, .None });
         }
 
         foe_volatiles.Nightmare = true;
-        try options.log.start(battle.active(player.foe()), .Nightmare);
+        try options.log.start(.{ battle.active(player.foe()), .Nightmare });
     }
 
     pub const ohko = struct {
@@ -1981,9 +1988,9 @@ pub const Effects = struct {
             const foe_ident = battle.active(player.foe());
 
             state.damage = 0;
-            if (state.immune()) return options.log.immune(foe_ident, .None);
+            if (state.immune()) return options.log.immune(.{ foe_ident, .None });
             const delta = side.stored().level -| foe.stored().level;
-            if (delta == 0) return options.log.immune(foe_ident, .OHKO);
+            if (delta == 0) return options.log.immune(.{ foe_ident, .OHKO });
 
             state.accuracy = 2 * delta +| Gen12.percent(30);
             try checkHit(battle, player, state, options);
@@ -1999,37 +2006,39 @@ pub const Effects = struct {
         const ident = battle.active(player);
         const foe_ident = battle.active(player.foe());
 
-        if (state.miss) return options.log.fail(foe_ident, .None);
+        if (state.miss) return options.log.fail(.{ foe_ident, .None });
         if (foe.active.volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         }
 
         const avg = @max((foe.stored().hp + side.stored().hp) / 2, 1);
         foe.stored().hp -= avg;
         side.stored().hp = avg;
 
-        try options.log.sethp(foe_ident, foe.stored(), .Silent);
-        try options.log.sethp(ident, side.stored(), .None);
+        try options.log.sethp(.{ foe_ident, foe.stored(), .Silent });
+        try options.log.sethp(.{ ident, side.stored(), .None });
     }
 
     pub fn paralyze(battle: anytype, player: Player, state: *State, options: anytype) !void {
         var foe = battle.foe(player);
         const foe_ident = battle.active(player.foe());
 
-        if (Status.is(foe.stored().status, .PAR)) return options.log.fail(foe_ident, .Paralysis);
-        if (state.immune()) return options.log.immune(foe_ident, .None);
-        if (Status.any(foe.stored().status)) return options.log.fail(foe_ident, .None);
+        if (Status.is(foe.stored().status, .PAR)) {
+            return options.log.fail(.{ foe_ident, .Paralysis });
+        }
+        if (state.immune()) return options.log.immune(.{ foe_ident, .None });
+        if (Status.any(foe.stored().status)) return options.log.fail(.{ foe_ident, .None });
         if (state.miss) {
-            try options.log.lastmiss();
-            return options.log.miss(battle.active(player));
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
         } else if (foe.active.volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         }
 
         foe.stored().status = Status.init(.PAR);
         foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
 
-        try options.log.status(foe_ident, foe.stored().status, .None);
+        try options.log.status(.{ foe_ident, foe.stored().status, .None });
     }
 
     pub fn paralyzeChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -2044,14 +2053,15 @@ pub const Effects = struct {
 
         foe_stored.status = Status.init(.PAR);
         foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
-        try options.log.status(battle.active(player.foe()), foe_stored.status, .None);
+
+        try options.log.status(.{ battle.active(player.foe()), foe_stored.status, .None });
 
         // TODO: check for status berry
     }
 
     pub fn payDay(battle: anytype, player: Player, _: *State, options: anytype) !void {
         if (!showdown or !battle.foe(player).active.volatiles.Substitute) {
-            try options.log.fieldactivate(); // FIXME .PayDay
+            try options.log.fieldactivate(.{}); // FIXME .PayDay
         }
     }
 
@@ -2060,17 +2070,17 @@ pub const Effects = struct {
         var foe = battle.foe(player);
 
         if (foe.active.volatiles.PerishSong) {
-            return options.log.fail(battle.active(player.foe()), .None);
+            return options.log.fail(.{ battle.active(player.foe()), .None });
         } else if (!side.active.volatiles.PerishSong) {
             side.active.volatiles.PerishSong = true;
             side.active.volatiles.perish_song = 4;
-            try options.log.start(battle.active(player), .PerishSong3Silent);
+            try options.log.start(.{ battle.active(player), .PerishSong3Silent });
         }
         foe.active.volatiles.PerishSong = true;
         foe.active.volatiles.perish_song = 4;
-        try options.log.start(battle.active(player.foe()), .PerishSong3Silent);
+        try options.log.start(.{ battle.active(player.foe()), .PerishSong3Silent });
 
-        try options.log.fieldactivate(); // FIXME .PerishSong
+        try options.log.fieldactivate(.{}); // FIXME .PerishSong
     }
 
     pub fn poison(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -2080,24 +2090,24 @@ pub const Effects = struct {
 
         const toxic = state.move == .Toxic;
         if (state.immune() or foe.active.types.includes(.Poison)) {
-            return options.log.immune(foe_ident, .None);
+            return options.log.immune(.{ foe_ident, .None });
         } else if (Status.any(foe_stored.status)) {
             // Pokémon Showdown considers Toxic to be a status even in Generation II and so
             // will not include a fail reason for Toxic vs. Poison or vice-versa...
-            return options.log.fail(foe_ident, if (Status.is(foe_stored.status, .PSN))
+            return options.log.fail(.{ foe_ident, if (Status.is(foe_stored.status, .PSN))
                 if (!showdown)
-                    .Poison
+                    Fail.Poison
                 else if (toxic == (foe_stored.status == Status.TOX))
-                    if (toxic) .Toxic else .Poison
+                    if (toxic) Fail.Toxic else Fail.Poison
                 else
-                    .None
+                    Fail.None
             else
-                .None);
+                Fail.None });
         } else if (foe.active.volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         } else if (state.miss) {
-            try options.log.lastmiss();
-            return options.log.miss(battle.active(player));
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
         }
 
         foe_stored.status = Status.init(.PSN);
@@ -2107,7 +2117,7 @@ pub const Effects = struct {
             foe.active.volatiles.toxic = 0;
         }
 
-        try options.log.status(foe_ident, foe_stored.status, .None);
+        try options.log.status(.{ foe_ident, foe_stored.status, .None });
 
         // TODO: check for status berry
     }
@@ -2123,7 +2133,8 @@ pub const Effects = struct {
         if (foe.conditions.Safeguard) return;
 
         foe_stored.status = Status.init(.PSN);
-        try options.log.status(battle.active(player.foe()), foe_stored.status, .None);
+
+        try options.log.status(.{ battle.active(player.foe()), foe_stored.status, .None });
 
         // TODO: check for status berry
     }
@@ -2138,9 +2149,7 @@ pub const Effects = struct {
 
         const failed = !state.first or volatiles.Substitute or
             !try Rolls.protect(battle, player, volatiles.protect, options);
-        if (failed) {
-            return options.log.fail(battle.active(player), .None);
-        }
+        if (failed) return options.log.fail(.{ battle.active(player), .None });
 
         volatiles.protect = @max(8, volatiles.protect + 1);
         if (state.move == .Endure) {
@@ -2148,7 +2157,7 @@ pub const Effects = struct {
         } else {
             volatiles.Protect = true;
         }
-        try options.log.singleturn(battle.active(player), state.move);
+        try options.log.singleturn(.{ battle.active(player), state.move });
     }
 
     pub fn psychUp(battle: anytype, player: Player, _: *State, options: anytype) !void {
@@ -2157,11 +2166,11 @@ pub const Effects = struct {
 
         // Pokémon Showdown should fail when the enemy has no boosts/unboosts but doesn't
         if (!showdown and @as(u32, @bitCast(foe.active.boosts)) == 0) {
-            return options.log.fail(battle.active(player), .None);
+            return options.log.fail(.{ battle.active(player), .None });
         }
 
         side.active.boosts = foe.active.boosts;
-        try options.log.copyboost(battle.active(player), battle.active(player.foe()));
+        try options.log.copyboost(.{ battle.active(player), battle.active(player.foe()) });
     }
 
     pub fn pursuit(battle: anytype, player: Player, state: *State, _: anytype) !void {
@@ -2172,7 +2181,7 @@ pub const Effects = struct {
     pub const rage = struct {
         pub fn start(battle: anytype, player: Player, _: *State, options: anytype) !void {
             battle.side(player).active.volatiles.Rage = true;
-            try options.log.singlemove(battle.active(player), Move.Rage);
+            try options.log.singlemove(.{ battle.active(player), Move.Rage });
         }
 
         pub fn damage(battle: anytype, player: Player, state: *State, _: anytype) !void {
@@ -2192,18 +2201,18 @@ pub const Effects = struct {
         var side = battle.side(player);
 
         if (side.active.volatiles.LeechSeed) {
-            try options.log.end(battle.active(player), .LeechSeedFrom);
+            try options.log.end(.{ battle.active(player), .LeechSeedFrom });
             side.active.volatiles.LeechSeed = false;
         }
 
         if (side.conditions.Spikes) {
-            try options.log.spikesend(battle.active(player));
+            try options.log.sideend(.{ player, protocol.Side.Spikes, battle.active(player) });
             side.conditions.Spikes = false;
         }
 
         if (side.active.volatiles.bind.duration > 0) {
             const reason = @intFromEnum(End.Bind) + side.active.volatiles.bind.reason - 1;
-            try options.log.end(battle.active(player), @enumFromInt(reason));
+            try options.log.end(.{ battle.active(player), @as(End, @enumFromInt(reason)) });
             side.active.volatiles.bind = .{};
         }
     }
@@ -2211,18 +2220,14 @@ pub const Effects = struct {
     pub fn recoil(battle: anytype, player: Player, state: *State, options: anytype) !void {
         var side = battle.side(player);
         var stored = side.stored();
+        const ident = battle.active(player);
 
         assert(state.damage > 0);
 
         const damage: i16 = @intCast(@max(state.damage / 4, 1));
         stored.hp = @intCast(@max(@as(i16, @intCast(stored.hp)) - damage, 0));
 
-        try options.log.damageOf(
-            battle.active(player),
-            stored,
-            .RecoilOf,
-            battle.active(player.foe()),
-        );
+        try options.log.damage(.{ ident, stored, .RecoilOf, battle.active(player.foe()) });
     }
 
     pub fn reversal(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -2285,7 +2290,7 @@ pub const Effects = struct {
 
     pub fn sandstorm(battle: anytype, player: Player, _: *State, options: anytype) !void {
         if (battle.field.weather != .Sandstorm) return weather(battle, .Sandstorm, options);
-        return options.log.fail(battle.active(player), .None);
+        return options.log.fail(.{ battle.active(player), .None });
     }
 
     pub fn safeguard(battle: anytype, player: Player, _: *State, options: anytype) !void {
@@ -2309,11 +2314,13 @@ pub const Effects = struct {
     ) !void {
         var side = battle.side(player);
 
-        if (@field(side.conditions, key)) return options.log.fail(battle.active(player), .None);
+        if (@field(side.conditions, key)) {
+            return options.log.fail(.{ battle.active(player), .None });
+        }
 
         @field(side.conditions, key) = true;
         @field(side.conditions, value) = 5;
-        try options.log.sidestart(player, @field(protocol.Side, key));
+        try options.log.sidestart(.{ player, @field(protocol.Side, key) });
     }
 
     pub fn sketch(battle: anytype, player: Player, _: *State, options: anytype) !void {
@@ -2324,9 +2331,9 @@ pub const Effects = struct {
 
         if (showdown) {
             // yes, actually "Splash". '|nothing' gets blindly mapped to  '|-activate||move:Splash'
-            try options.log.activate(battle.active(player), .Splash);
+            try options.log.activate(.{ battle.active(player), .Splash });
         } else {
-            try options.log.fail(battle.active(player), .None);
+            try options.log.fail(.{ battle.active(player), .None });
         }
     }
 
@@ -2336,14 +2343,14 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
 
         if (Status.any(foe_stored.status)) {
-            return options.log.fail(
+            return options.log.fail(.{
                 foe_ident,
-                if (Status.is(foe_stored.status, .SLP)) .Sleep else .None,
-            );
+                if (Status.is(foe_stored.status, .SLP)) Fail.Sleep else Fail.None,
+            });
         }
 
         if (foe.active.volatiles.Substitute) {
-            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
         }
 
         // Sleep Clause Mod
@@ -2354,22 +2361,21 @@ pub const Effects = struct {
         }
 
         foe_stored.status = Status.slp(Rolls.sleepDuration(battle, player, options));
-        try options.log.statusFrom(foe_ident, foe_stored.status, state.move);
+        try options.log.status(.{ foe_ident, foe_stored.status, .From, state.move });
     }
 
     pub fn sleepTalk(battle: anytype, player: Player, state: *State, options: anytype) !void {
         const side = battle.side(player);
 
         if (!Status.is(side.stored().status, .SLP)) {
-            if (!showdown) try options.log.fail(battle.active(player), .None);
-            return;
+            return if (!showdown) try options.log.fail(.{ battle.active(player), .None });
         }
 
         var n: u3 = 0;
         for (side.active.moves, 0..) |m, i| {
             if (state.mslot - 1 != i and Move.get(m.id).extra.sleep_talk) n += 1;
         }
-        if (n == 0) return options.log.fail(battle.active(player), .None);
+        if (n == 0) return options.log.fail(.{ battle.active(player), .None });
 
         _ = try Rolls.sleepTalk(battle, player, n, state.mslot, options); // TODO
     }
@@ -2378,23 +2384,23 @@ pub const Effects = struct {
         if (Status.is(battle.side(player).stored().status, .SLP)) return true;
         state.damage = 0;
         state.miss = true; // TODO is this necessary?
-        if (!showdown) try options.log.fail(battle.active(player), .None);
+        if (!showdown) try options.log.fail(.{ battle.active(player), .None });
         return false;
     }
 
     pub fn spikes(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var foe = battle.foe(player);
-        if (foe.conditions.Spikes) return options.log.fail(battle.active(player), .None);
+        if (foe.conditions.Spikes) return options.log.fail(.{ battle.active(player), .None });
 
         foe.conditions.Spikes = true;
-        try options.log.sidestart(player.foe(), .Spikes);
+        try options.log.sidestart(.{ player.foe(), protocol.Side.Spikes });
     }
 
     pub fn spite(battle: anytype, player: Player, state: *State, options: anytype) !void {
         _ = .{ battle, player, state, options }; // TODO
         // var foe = battle.foe(player);
 
-        // if (state.miss) return options.log.fail(battle.active(player), .None);
+        // if (state.miss) return options.log.fail(.{ battle.active(player), .None });
 
         // const last = foe.lastMove(false);
         // if (showdown) {
@@ -2405,28 +2411,28 @@ pub const Effects = struct {
     }
 
     pub fn splash(battle: anytype, player: Player, _: *State, options: anytype) !void {
-        try options.log.activate(battle.active(player), .Splash);
+        try options.log.activate(.{ battle.active(player), .Splash });
     }
 
     pub fn substitute(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var side = battle.side(player);
         if (side.active.volatiles.Substitute) {
-            return options.log.fail(battle.active(player), .Substitute);
+            return options.log.fail(.{ battle.active(player), .Substitute });
         }
 
         assert(side.stored().stats.hp <= 1023);
         const hp: u8 = @intCast(side.stored().stats.hp / 4);
 
         if (hp == 0 or side.stored().hp <= hp) {
-            return options.log.fail(battle.active(player), .Weak);
+            return options.log.fail(.{ battle.active(player), .Weak });
         }
 
         side.stored().hp -= hp;
         side.active.volatiles.substitute = hp;
         side.active.volatiles.Substitute = true;
         side.active.volatiles.bind = .{};
-        try options.log.start(battle.active(player), .Substitute);
-        try options.log.damage(battle.active(player), side.stored(), .None);
+        try options.log.start(.{ battle.active(player), .Substitute });
+        try options.log.damage(.{ battle.active(player), side.stored(), .None });
     }
 
     pub fn sunnyDay(battle: anytype, _: Player, _: *State, options: anytype) !void {
@@ -2436,14 +2442,14 @@ pub const Effects = struct {
     fn weather(battle: anytype, w: Weather, options: anytype) !void {
         battle.field.weather = w;
         battle.field.weather_duration = 5;
-        try options.log.weather(w, .None);
+        try options.log.weather(.{ w, protocol.Weather.None });
     }
 
     pub fn teleport(battle: anytype, player: Player, _: *State, options: anytype) !void {
         if (showdown) return;
 
-        try options.log.fail(battle.active(player), .None);
-        try options.log.laststill();
+        try options.log.fail(.{ battle.active(player), .None });
+        try options.log.laststill(.{});
     }
 
     pub fn thief(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -2458,11 +2464,11 @@ pub const Effects = struct {
         side.stored().item = foe.stored().item;
         foe.stored().item = .None;
 
-        try options.log.item(
+        try options.log.item(.{
             battle.active(player),
             side.stored().item,
             battle.active(player.foe()),
-        );
+        });
     }
 
     pub fn thrashing(battle: anytype, player: Player, _: *State, options: anytype) !void {
@@ -2484,11 +2490,11 @@ pub const Effects = struct {
         side.active.volatiles.dirty = false;
 
         if (foe.active.volatiles.Transform) {
-            return options.log.fail(battle.active(player), .None);
+            return options.log.fail(.{ battle.active(player), .None });
         } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-            if (!showdown) return options.log.fail(battle.active(player), .None);
-            try options.log.lastmiss();
-            return options.log.miss(battle.active(player));
+            if (!showdown) return options.log.fail(.{ battle.active(player), .None });
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
         }
 
         side.active.volatiles.Transform = true;
@@ -2510,7 +2516,7 @@ pub const Effects = struct {
             side.active.moves[i].pp = if (m.id != .None) if (m.id == .Sketch) 1 else 5 else 0;
         }
 
-        try options.log.transform(battle.active(player), foe_ident);
+        try options.log.transform(.{ battle.active(player), foe_ident });
     }
 
     pub fn triAttack(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -2542,10 +2548,10 @@ pub const Effects = struct {
         inline for (STATS, STAT_UP_REASONS) |s, r| {
             assert(@field(boosts, s) >= -6 and @field(boosts, s) <= 6);
             if (@field(boosts, s) == 6 or @field(stats, s) == MAX_STAT_VALUE) {
-                try options.log.boost(battle.active(player), r, 0);
+                try options.log.boost(.{ battle.active(player), r, 0 });
             } else {
                 try boostStat(battle, side, stats, boosts, s, 1);
-                try options.log.boost(battle.active(player), r, 1);
+                try options.log.boost(.{ battle.active(player), r, 1 });
             }
         }
     }
@@ -2555,7 +2561,7 @@ pub const Effects = struct {
         var side = battle.side(player);
         const ident = battle.active(player);
 
-        if (state.miss) return log.fail(ident, .None);
+        if (state.miss) return log.fail(.{ ident, .None });
 
         var stats = &side.active.stats;
         var boosts = &side.active.boosts;
@@ -2564,42 +2570,52 @@ pub const Effects = struct {
         switch (move.effect) {
             .AttackUp1, .AttackUp2, .Rage, .Swagger => {
                 assert(boosts.atk >= -6 and boosts.atk <= 6);
-                if (boosts.atk == 6 or stats.atk == MAX_STAT_VALUE) return log.fail(ident, .None);
+                if (boosts.atk == 6 or stats.atk == MAX_STAT_VALUE) {
+                    return log.fail(.{ ident, .None });
+                }
                 const n: u2 = if (move.effect == .AttackUp2 or move.effect == .Swagger) 2 else 1;
                 try boostStat(battle, side, stats, boosts, "atk", n);
                 const reason = if (showdown and move.effect == .Rage) Boost.Rage else Boost.Attack;
-                try log.boost(ident, reason, n);
+                try log.boost(.{ ident, reason, n });
             },
             .DefenseUp1, .DefenseUp2, .SkullBash => {
                 assert(boosts.def >= -6 and boosts.def <= 6);
-                if (boosts.def == 6 or stats.def == MAX_STAT_VALUE) return log.fail(ident, .None);
+                if (boosts.def == 6 or stats.def == MAX_STAT_VALUE) {
+                    return log.fail(.{ ident, .None });
+                }
                 const n: u2 = if (move.effect == .DefenseUp2) 2 else 1;
                 try boostStat(battle, side, stats, boosts, "def", n);
-                try log.boost(ident, .Defense, n);
+                try log.boost(.{ ident, .Defense, n });
             },
             .SpeedUp2 => {
                 assert(boosts.spe >= -6 and boosts.spe <= 6);
-                if (boosts.spe == 6 or stats.spe == MAX_STAT_VALUE) return log.fail(ident, .None);
+                if (boosts.spe == 6 or stats.spe == MAX_STAT_VALUE) {
+                    return log.fail(.{ ident, .None });
+                }
                 try boostStat(battle, side, stats, boosts, "spe", 2);
-                try log.boost(ident, .Speed, 2);
+                try log.boost(.{ ident, .Speed, 2 });
             },
             .SpAtkUp1 => {
                 assert(boosts.spa >= -6 and boosts.spa <= 6);
-                if (boosts.spa == 6 or stats.spa == MAX_STAT_VALUE) return log.fail(ident, .None);
+                if (boosts.spa == 6 or stats.spa == MAX_STAT_VALUE) {
+                    return log.fail(.{ ident, .None });
+                }
                 try boostStat(battle, side, stats, boosts, "spa", 1);
-                try log.boost(ident, .SpecialAttack, 1);
+                try log.boost(.{ ident, .SpecialAttack, 1 });
             },
             .SpDefUp2 => {
                 assert(boosts.spd >= -6 and boosts.spd <= 6);
-                if (boosts.spd == 6 or stats.spd == MAX_STAT_VALUE) return log.fail(ident, .None);
+                if (boosts.spd == 6 or stats.spd == MAX_STAT_VALUE) {
+                    return log.fail(.{ ident, .None });
+                }
                 try boostStat(battle, side, stats, boosts, "spd", 2);
-                try log.boost(ident, .SpecialDefense, 2);
+                try log.boost(.{ ident, .SpecialDefense, 2 });
             },
             .EvasionUp1 => {
                 assert(boosts.evasion >= -6 and boosts.evasion <= 6);
-                if (boosts.evasion == 6) return log.fail(ident, .None);
+                if (boosts.evasion == 6) return log.fail(.{ ident, .None });
                 boosts.evasion = @intCast(@min(6, @as(i8, boosts.evasion) + 1));
-                try log.boost(ident, .Evasion, 1);
+                try log.boost(.{ ident, .Evasion, 1 });
                 if (state.move == .Minimize) side.active.volatiles.minimized = true;
             },
             else => unreachable,
@@ -2612,8 +2628,8 @@ pub const Effects = struct {
         const foe_ident = battle.active(player.foe());
 
         if (foe.active.volatiles.Mist) {
-            try log.activate(foe_ident, .Mist);
-            return log.fail(foe_ident, .None);
+            try log.activate(.{ foe_ident, .Mist });
+            return log.fail(.{ foe_ident, .None });
         }
 
         const fail = foe.active.volatiles.Substitute or state.miss or !state.proc;
@@ -2622,69 +2638,73 @@ pub const Effects = struct {
         var boosts = &foe.active.boosts;
 
         const move = Move.get(state.move);
+        const none: Fail = .None;
         switch (move.effect) {
             .AttackDown1, .AttackDown2, .AttackDownChance => {
                 assert(boosts.atk >= -6 and boosts.atk <= 6);
                 if (fail or boosts.atk == -6) {
-                    return if (move.effect != .AttackDownChance) try log.fail(foe_ident, .None);
+                    return if (move.effect != .AttackDownChance) try log.fail(.{ foe_ident, none });
                 } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-                    try options.log.lastmiss();
-                    return options.log.miss(battle.active(player));
+                    try options.log.lastmiss(.{});
+                    return options.log.miss(.{battle.active(player)});
                 } else if (stats.atk == 1) {
-                    return if (move.effect != .AttackDownChance) try log.fail(foe_ident, .None);
+                    return if (move.effect != .AttackDownChance) try log.fail(.{ foe_ident, none });
                 }
                 const n: u2 = if (move.effect == .AttackDown2) 2 else 1;
                 try unboostStat(battle, foe, stats, boosts, "atk", n);
-                try log.boost(foe_ident, .Attack, -@as(i8, n));
+                try log.boost(.{ foe_ident, .Attack, -@as(i8, n) });
             },
             .DefenseDown1, .DefenseDown2, .DefenseDownChance => {
                 assert(boosts.def >= -6 and boosts.def <= 6);
                 if (fail or boosts.def == -6) {
-                    return if (move.effect != .DefenseDownChance) try log.fail(foe_ident, .None);
+                    if (move.effect != .DefenseDownChance) try log.fail(.{ foe_ident, none });
+                    return;
                 } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-                    try options.log.lastmiss();
-                    return options.log.miss(battle.active(player));
+                    try options.log.lastmiss(.{});
+                    return options.log.miss(.{battle.active(player)});
                 } else if (stats.def == 1) {
-                    return if (move.effect != .DefenseDownChance) try log.fail(foe_ident, .None);
+                    if (move.effect != .DefenseDownChance) try log.fail(.{ foe_ident, none });
+                    return;
                 }
                 const n: u2 = if (move.effect == .DefenseDown2) 2 else 1;
                 try unboostStat(battle, foe, stats, boosts, "def", n);
-                try log.boost(foe_ident, .Defense, -@as(i8, n));
+                try log.boost(.{ foe_ident, .Defense, -@as(i8, n) });
             },
             .SpeedDown1, .SpeedDown2, .SpeedDownChance => {
                 assert(boosts.spe >= -6 and boosts.spe <= 6);
                 if (fail or boosts.spe == -6) {
-                    return if (move.effect != .SpeedDownChance) try log.fail(foe_ident, .None);
+                    return if (move.effect != .SpeedDownChance) try log.fail(.{ foe_ident, none });
                 } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-                    try options.log.lastmiss();
-                    return options.log.miss(battle.active(player));
+                    try options.log.lastmiss(.{});
+                    return options.log.miss(.{battle.active(player)});
                 } else if (stats.spe == 1) {
-                    return if (move.effect != .SpeedDownChance) try log.fail(foe_ident, .None);
+                    return if (move.effect != .SpeedDownChance) try log.fail(.{ foe_ident, none });
                 }
                 const n: u2 = if (move.effect == .SpeedDown2) 2 else 1;
                 try unboostStat(battle, foe, stats, boosts, "spe", n);
-                try log.boost(foe_ident, .Speed, -@as(i8, n));
+                try log.boost(.{ foe_ident, .Speed, -@as(i8, n) });
             },
             .SpDefDownChance => {
                 assert(boosts.spd >= -6 and boosts.spd <= 6);
                 if (fail or boosts.spd == -6) return;
                 if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-                    try options.log.lastmiss();
-                    return options.log.miss(battle.active(player));
+                    try options.log.lastmiss(.{});
+                    return options.log.miss(.{battle.active(player)});
                 } else if (stats.spd == 1) return;
                 try unboostStat(battle, foe, stats, boosts, "spd", 1);
-                try log.boost(foe_ident, .SpecialDefense, -1);
+                try log.boost(.{ foe_ident, .SpecialDefense, -1 });
             },
             .AccuracyDown1, .AccuracyDownChance => {
                 assert(boosts.accuracy >= -6 and boosts.accuracy <= 6);
                 if (fail or boosts.accuracy == -6) {
-                    return if (move.effect != .AccuracyDownChance) try log.fail(foe_ident, .None);
+                    if (move.effect != .AccuracyDownChance) try log.fail(.{ foe_ident, none });
+                    return;
                 } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-                    try options.log.lastmiss();
-                    return options.log.miss(battle.active(player));
+                    try options.log.lastmiss(.{});
+                    return options.log.miss(.{battle.active(player)});
                 }
                 boosts.accuracy = @intCast(@max(-6, @as(i8, boosts.accuracy) - 1));
-                try log.boost(foe_ident, .Accuracy, -1);
+                try log.boost(.{ foe_ident, .Accuracy, -1 });
             },
             else => unreachable,
         }
@@ -3224,7 +3244,7 @@ pub const Rolls = struct {
 
         const move: Move = overridden orelse move: {
             if (showdown) {
-                var r = battle.rng.range(u8, 0, @intCast(Move.METRONOME.len - n));
+                var r = battle.rng.range(u8, 0, @as(u8, @intCast(Move.METRONOME.len - n)));
                 for (moves) |m| {
                     if (m.id == .None) break;
                     if (@intFromEnum(m.id) > @intFromEnum(Move.METRONOME[r])) break;