@pkmn/engine 0.1.0-dev.a5a9f4b2 → 0.1.0-dev.af1565df

package/src/lib/gen1/mechanics.zig

@@ -62,26 +62,28 @@ pub fn update(battle: anytype, c1: Choice, c2: Choice, log: anytype) !Result {
     assert(c1.type != .Pass or c2.type != .Pass or battle.turn == 0);
     if (battle.turn == 0) return start(battle, log);
 
+    var s1 = false;
+    var s2 = false;
     var f1: ?Move = null;
     var f2: ?Move = null;
 
-    if (selectMove(battle, .P1, c1, c2, &f1)) |r| return r;
-    if (selectMove(battle, .P2, c2, c1, &f2)) |r| return r;
+    if (selectMove(battle, .P1, c1, c2, &s1, &f1)) |r| return r;
+    if (selectMove(battle, .P2, c2, c1, &s2, &f2)) |r| return r;
+
+    var p1 = battle.side(.P1);
+    var p2 = battle.side(.P2);
+
+    var r1 = showdown and p1.active.volatiles.Binding and c2.type == .Switch;
+    var r2 = showdown and p2.active.volatiles.Binding and c1.type == .Switch;
 
     if (turnOrder(battle, c1, c2) == .P1) {
-        if (try doTurn(battle, .P1, c1, f1, .P2, c2, f2, log)) |r| return r;
+        if (try doTurn(battle, .P1, c1, r1, s1, f1, .P2, c2, r2, s2, f2, log)) |r| return r;
     } else {
-        if (try doTurn(battle, .P2, c2, f2, .P1, c1, f1, log)) |r| return r;
+        if (try doTurn(battle, .P2, c2, r2, s2, f2, .P1, c1, r1, s1, f1, log)) |r| return r;
     }
 
-    var p1 = battle.side(.P1);
-    if (p1.active.volatiles.attacks == 0) {
-        p1.active.volatiles.Binding = false;
-    }
-    var p2 = battle.side(.P2);
-    if (p2.active.volatiles.attacks == 0) {
-        p2.active.volatiles.Binding = false;
-    }
+    if (p1.active.volatiles.attacks == 0) p1.active.volatiles.Binding = false;
+    if (p2.active.volatiles.attacks == 0) p2.active.volatiles.Binding = false;
 
     return endTurn(battle, log);
 }
@@ -114,6 +116,7 @@ fn selectMove(
     player: Player,
     choice: Choice,
     foe_choice: Choice,
+    skip_turn: *bool,
     from: *?Move,
 ) ?Result {
     if (choice.type == .Pass) return null;
@@ -126,17 +129,26 @@ fn selectMove(
         (choice.type == .Move and choice.data == @boolToInt(showdown)));
 
     // pre-battle menu
-    if (volatiles.Recharging) return null;
+    if (volatiles.Recharging) {
+        if (showdown and battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
+        return null;
+    }
     if (volatiles.Rage) {
         from.* = side.last_used_move;
-        if (showdown) saveMove(battle, player, null);
+        if (showdown) {
+            if (battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
+            saveMove(battle, player, null);
+        }
         return null;
     }
     // Pokémon Showdown removes Flinch at the end-of-turn in its residual handler
     if (!showdown) volatiles.Flinch = false;
     if (volatiles.Thrashing or volatiles.Charging) {
         from.* = side.last_selected_move;
-        if (showdown) saveMove(battle, player, null);
+        if (showdown) {
+            if (battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
+            saveMove(battle, player, null);
+        }
         return null;
     }
 
@@ -146,7 +158,10 @@ fn selectMove(
     // pre-move select
     if (Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP) or volatiles.Bide) {
         assert(showdown or choice.data == 0);
-        if (showdown) saveMove(battle, player, choice);
+        if (showdown) {
+            if (volatiles.Bide and battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
+            saveMove(battle, player, choice);
+        }
         return null;
     }
     if (volatiles.Binding) {
@@ -165,9 +180,9 @@ fn selectMove(
             // GLITCH: https://glitchcity.wiki/Partial_trapping_move_Mirror_Move_link_battle_glitch
             if (foe_choice.type == .Switch) {
                 const slot = if (player == .P1)
-                    battle.last_selected_indexes.p1
+                    battle.last_moves.p1_index
                 else
-                    battle.last_selected_indexes.p2;
+                    battle.last_moves.p2_index;
                 const last = side.active.move(@intCast(u4, slot));
                 if (last.id == .Metronome) side.last_selected_move = last.id;
                 if (last.id == .MirrorMove) return Result.Error;
@@ -177,6 +192,7 @@ fn selectMove(
     }
 
     if (battle.foe(player).active.volatiles.Binding) {
+        skip_turn.* = true;
         if (showdown) {
             saveMove(battle, player, choice);
         } else {
@@ -221,9 +237,9 @@ fn saveMove(battle: anytype, player: Player, choice: ?Choice) void {
 
             side.last_selected_move = move.id;
             if (player == .P1) {
-                battle.last_selected_indexes.p1 = @intCast(u4, c.data);
+                battle.last_moves.p1_index = @intCast(u3, c.data);
             } else {
-                battle.last_selected_indexes.p2 = @intCast(u4, c.data);
+                battle.last_moves.p2_index = @intCast(u3, c.data);
             }
         }
     }
@@ -243,9 +259,9 @@ fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, log: anyty
     side.order[slot - 1] = out;
 
     if (player == .P1) {
-        battle.last_selected_indexes.p1 = 1;
+        battle.last_moves.p1_index = 1;
     } else {
-        battle.last_selected_indexes.p2 = 1;
+        battle.last_moves.p2_index = 1;
     }
 
     side.last_used_move = .None;
@@ -302,7 +318,9 @@ fn turnOrder(battle: anytype, c1: Choice, c2: Choice) Player {
     const spe2 = battle.side(.P2).active.stats.spe;
     if (spe1 == spe2) {
         // Pokémon Showdown's beforeTurnCallback shenanigans
-        if (showdown and m1 == .Counter and m2 == .Counter) battle.rng.advance(1);
+        if (showdown and !double_switch and m1 == .Counter and m2 == .Counter) {
+            battle.rng.advance(1);
+        }
 
         const p1 = Rolls.speedTie(battle);
         if (!showdown) return if (p1) .P1 else .P2;
@@ -327,9 +345,13 @@ fn doTurn(
     battle: anytype,
     player: Player,
     player_choice: Choice,
+    player_rewrap: bool,
+    player_skip: bool,
     player_from: ?Move,
     foe_player: Player,
     foe_choice: Choice,
+    foe_rewrap: bool,
+    foe_skip: bool,
     foe_from: ?Move,
     log: anytype,
 ) !?Result {
@@ -337,7 +359,16 @@ fn doTurn(
 
     var residual = true;
     var replace = battle.side(player).stored().hp == 0;
-    if (try executeMove(battle, player, player_choice, player_from, &residual, log)) |r| return r;
+    if (try executeMove(
+        battle,
+        player,
+        player_choice,
+        player_rewrap,
+        player_skip,
+        player_from,
+        &residual,
+        log,
+    )) |r| return r;
     if (!replace) {
         if (player_choice.type != .Switch) {
             if (try checkFaint(battle, foe_player, log)) |r| return r;
@@ -348,7 +379,16 @@ fn doTurn(
 
     residual = true;
     replace = battle.side(foe_player).stored().hp == 0;
-    if (try executeMove(battle, foe_player, foe_choice, foe_from, &residual, log)) |r| return r;
+    if (try executeMove(
+        battle,
+        foe_player,
+        foe_choice,
+        foe_rewrap,
+        foe_skip,
+        foe_from,
+        &residual,
+        log,
+    )) |r| return r;
     if (!replace) {
         if (foe_choice.type != .Switch) {
             if (try checkFaint(battle, player, log)) |r| return r;
@@ -371,6 +411,8 @@ fn executeMove(
     battle: anytype,
     player: Player,
     choice: Choice,
+    rewrap: bool,
+    skip: bool,
     from: ?Move,
     residual: *bool,
     log: anytype,
@@ -382,9 +424,10 @@ fn executeMove(
         return null;
     }
 
+    // This is the correct place to check for SKIP_TURN and abort early, however since Pokémon
+    // Showdown overwrites the SKIP_TURN sentinel with its botched move select we need to add an
+    // additional skip boolean to accomplish the same thing in the Binding check of BeforeMove
     if (side.last_selected_move == .SKIP_TURN) {
-        // Pokémon Showdown overwrites the SKIP_TURN sentinel with its botched move select,
-        // Binding instead gets handled in beforeMove after sleep and freeze
         assert(!showdown);
         if (battle.foe(player).active.volatiles.Binding) {
             try log.cant(battle.active(player), .Bound);
@@ -403,9 +446,9 @@ fn executeMove(
         // choice.data == 0 only happens with Struggle on Pokémon Showdown
         assert(!showdown);
         mslot = @intCast(u4, if (player == .P1)
-            battle.last_selected_indexes.p1
+            battle.last_moves.p1_index
         else
-            battle.last_selected_indexes.p2);
+            battle.last_moves.p2_index);
         const stored = side.stored();
         // GLITCH: Struggle bypass PP underflow via Hyper Beam / Trapping-switch auto selection
         auto = side.last_selected_move == .HyperBeam or side.active.volatiles.Bide or
@@ -427,14 +470,14 @@ fn executeMove(
         // Incorrect mslot with Pokémon Showdown choice semantics so we need to recover from index
         assert(mslot == 1);
         mslot = @intCast(u4, if (player == .P1)
-            battle.last_selected_indexes.p1
+            battle.last_moves.p1_index
         else
-            battle.last_selected_indexes.p2);
+            battle.last_moves.p2_index);
     }
 
     var skip_can = false;
     var skip_pp = false;
-    switch (try beforeMove(battle, player, from, residual, log)) {
+    switch (try beforeMove(battle, player, skip, from, residual, log)) {
         .done => return null,
         .skip_can => skip_can = true,
         .skip_pp => skip_pp = true,
@@ -446,7 +489,7 @@ fn executeMove(
         return null;
     }
 
-    return doMove(battle, player, mslot, auto, residual, log);
+    return doMove(battle, player, mslot, rewrap, auto, residual, log);
 }
 
 const BeforeMove = enum { done, skip_can, skip_pp, ok, err };
@@ -454,6 +497,7 @@ const BeforeMove = enum { done, skip_can, skip_pp, ok, err };
 fn beforeMove(
     battle: anytype,
     player: Player,
+    skip: bool,
     from: ?Move,
     residual: *bool,
     log: anytype,
@@ -485,13 +529,15 @@ fn beforeMove(
         return .done;
     }
 
-    if (foe.active.volatiles.Binding) {
+    if (skip or foe.active.volatiles.Binding) {
         try log.cant(ident, .Bound);
         return .done;
     }
 
-    if (!showdown and volatiles.Flinch) {
-        volatiles.Flinch = false;
+    if (volatiles.Flinch) {
+        // Pokémon Showdown doesn't clear Flinch until its imaginary "residual" phase, meaning
+        // Pokémon can sometimes flinch multiple times from the same original hit
+        if (!showdown) volatiles.Flinch = false;
         try log.cant(ident, .Flinch);
         return .done;
     }
@@ -512,14 +558,6 @@ fn beforeMove(
     // Pokémon Showdown's disable condition has a single onBeforeMove handler
     if (showdown and try disabled(side, ident, log)) return .done;
 
-    // Pokémon Showdown checks for Flinch *after* instead of before... and doesn't clear Flinch
-    // until its imaginary "residual" phase, meaning Pokémon can sometimes flinch multiple times
-    // from the same original hit
-    if (showdown and volatiles.Flinch) {
-        try log.cant(ident, .Flinch);
-        return .done;
-    }
-
     // This can only happen if a Pokémon started the battle frozen/sleeping and was thawed/woken
     // before the side had a selected a move - we simply need to assume this leads to a desync
     if (side.last_selected_move == .None) {
@@ -591,7 +629,14 @@ fn beforeMove(
     if (volatiles.Bide) {
         assert(!volatiles.Thrashing and !volatiles.Rage);
 
-        volatiles.state +%= battle.last_damage;
+        if (showdown) {
+            // Pokémon Showdown doesn't implement Bide potentially overflowing in the event of
+            // OHKO-move damage, but we can fake this incorrect behavior by simply saturating the
+            // addition because 65535 is sufficient to faint any Pokémon anyway
+            volatiles.state +|= battle.last_damage;
+        } else {
+            volatiles.state +%= battle.last_damage;
+        }
 
         assert(volatiles.attacks > 0);
 
@@ -635,8 +680,13 @@ fn beforeMove(
             try log.start(battle.active(player), .ConfusionSilent);
         }
         try log.move(ident, side.last_selected_move, battle.active(player.foe()), from);
-        if (showdown and handleThrashing(battle, active)) {
-            try log.start(battle.active(player), .ConfusionSilent);
+        if (showdown) {
+            // This shouldn't actually set last_used_move, but Pokémon Showdown sets last
+            // used in useMove and doesn't have the notion of skipping canMove semantics
+            side.last_used_move = side.last_selected_move;
+            if (handleThrashing(battle, active)) {
+                try log.start(battle.active(player), .ConfusionSilent);
+            }
         }
         return .skip_can;
     }
@@ -651,7 +701,11 @@ fn beforeMove(
             side.last_selected_move,
         );
         if (showdown or battle.last_damage != 0) {
+            const sub = showdown and foe.active.volatiles.Substitute;
             _ = try applyDamage(battle, player.foe(), player.foe(), .None, log);
+            if (battle.foe(player).stored().hp > 0 and !sub) {
+                try buildRage(battle, player.foe(), log);
+            }
         }
         return .done;
     }
@@ -683,6 +737,7 @@ fn canMove(
         side.active.volatiles.Invulnerable = false;
     } else if (move.effect == .Charge) {
         try log.move(player_ident, side.last_selected_move, .{}, from);
+        setCounterable(battle, player, side, move);
         try Effects.charge(battle, player, log);
         return false;
     }
@@ -699,6 +754,7 @@ fn canMove(
     // regrettable, but this information is more "nice to have" than required
     const f = if (from != null and from.? == .None) null else from;
     try log.move(player_ident, side.last_selected_move, battle.active(target), f);
+    setCounterable(battle, player, side, move);
 
     if (move.effect.onBegin()) {
         try onBegin(battle, player, move, mslot, residual, log);
@@ -709,12 +765,27 @@ fn canMove(
         Effects.thrashing(battle, player);
     } else if (!showdown and move.effect == .Binding) {
         // Pokémon Showdown handles this after hit/miss checks and damage calculation
-        Effects.binding(battle, player);
+        Effects.binding(battle, player, false);
     }
 
     return true;
 }
 
+fn setCounterable(battle: anytype, player: Player, side: *Side, move: Move.Data) void {
+    // The Counter desync is caused by the cartridge not calling GetCurrentMove until now, meaning
+    // in cases where an early return happens the data for a players last selected move does not get
+    // reloaded and HandleCounterMove actually bases its success/failure off of stale information.
+    // This boolean state we track here doesn't exist on the cartridge because it instead manifests
+    // as the desync results from actually having two separate battle states that subtly disagree
+    const counterable = side.last_selected_move != .Counter and move.bp > 0 and
+        (move.type == .Normal or move.type == .Fighting);
+    if (player == .P1) {
+        battle.last_moves.p1_counterable = @boolToInt(counterable);
+    } else {
+        battle.last_moves.p2_counterable = @boolToInt(counterable);
+    }
+}
+
 fn decrementPP(side: *Side, mslot: u4, auto: bool) void {
     if (side.last_selected_move == .Struggle) return;
 
@@ -750,6 +821,7 @@ fn doMove(
     battle: anytype,
     player: Player,
     mslot: u4,
+    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
@@ -841,9 +913,9 @@ fn doMove(
 
     if (!showdown or !miss) {
         if (move.effect == .MirrorMove) {
-            return mirrorMove(battle, player, mslot, auto, residual, log);
+            return mirrorMove(battle, player, mslot, rewrap, auto, residual, log);
         } else if (move.effect == .Metronome) {
-            return metronome(battle, player, mslot, auto, residual, log);
+            return metronome(battle, player, mslot, rewrap, auto, residual, log);
         } else if (move.effect.onEnd()) {
             try onEnd(battle, player, move, log);
             return null;
@@ -858,7 +930,7 @@ fn doMove(
             move.effect == .OHKO and side.active.stats.spe < foe.active.stats.spe;
         if (ohko) {
             try log.immune(foe_ident, .OHKO);
-        } else if (immune and !invulnerable) {
+        } else if (immune and !invulnerable and (!showdown or move.effect != .Binding)) {
             try log.immune(foe_ident, .None);
         } else if (mist) {
             if (!foe.active.volatiles.Substitute) try log.activate(foe_ident, .Mist);
@@ -924,11 +996,17 @@ fn doMove(
     } else if (showdown) {
         // This should be handled much earlier but Pokémon Showdown does it here... ¯\_(ツ)_/¯
         if (move.effect == .Binding) {
-            Effects.binding(battle, player);
+            Effects.binding(battle, player, rewrap);
             if (immune) {
                 battle.last_damage = 0;
+                assert(foe.stored().hp > 0);
                 // Pokémon Showdown logs |-damage| here instead of |-immune| because logic...
-                try log.damage(battle.active(player.foe()), foe.stored(), .None);
+                if (sub) {
+                    try log.activate(battle.active(player.foe()), .Substitute);
+                } else {
+                    try log.damage(battle.active(player.foe()), foe.stored(), .None);
+                    try buildRage(battle, player.foe(), log);
+                }
                 return null;
             }
         }
@@ -1125,19 +1203,17 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, log: anytype)
         return null;
     }
 
-    // Pretend Counter was used as a stand-in when no move has been used to fail below with 0 BP
-    const foe_last_used_move =
-        Move.get(if (foe.last_used_move == .None) .Counter else foe.last_used_move);
+    // Pretend Splash was used as a stand-in when no move has been used to fail below with 0 BP
     const foe_last_selected_move =
         Move.get(if (foe.last_selected_move == .None or foe.last_selected_move == .SKIP_TURN)
-        .Counter
+        .Splash
     else
         foe.last_selected_move);
 
-    const used = foe_last_used_move.bp > 0 and
-        foe.last_used_move != .Counter and
-        (foe_last_used_move.type == .Normal or
-        foe_last_used_move.type == .Fighting);
+    const used = (if (player.foe() == .P1)
+        battle.last_moves.p1_counterable
+    else
+        battle.last_moves.p2_counterable) != 0;
 
     const selected = foe_last_selected_move.bp > 0 and
         foe.last_selected_move != .Counter and
@@ -1156,12 +1232,14 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, log: anytype)
         return null;
     }
 
-    battle.last_damage = if (battle.last_damage > 0x7FFF) 0xFFFF else battle.last_damage * 2;
+    battle.last_damage *|= 2;
 
     // Pokémon Showdown calls checkHit before Counter
     if (!showdown and !try checkHit(battle, player, move, log)) return null;
 
+    const sub = showdown and foe.active.volatiles.Substitute;
     _ = try applyDamage(battle, player.foe(), player.foe(), .None, log);
+    if (battle.foe(player).stored().hp > 0 and !sub) try buildRage(battle, player.foe(), log);
     return null;
 }
 
@@ -1205,6 +1283,7 @@ fn mirrorMove(
     battle: anytype,
     player: Player,
     mslot: u4,
+    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
@@ -1217,18 +1296,19 @@ fn mirrorMove(
     if (foe.last_used_move == .None or foe.last_used_move == .MirrorMove) {
         try log.fail(battle.active(player), .None);
         return null;
+    } else if (!showdown or foe.last_used_move != .Struggle) {
+        incrementPP(side, mslot);
     }
 
-    incrementPP(side, mslot);
-
     if (!try canMove(battle, player, mslot, auto, false, .MirrorMove, residual, log)) return null;
-    return doMove(battle, player, mslot, auto, residual, log);
+    return doMove(battle, player, mslot, rewrap, auto, residual, log);
 }
 
 fn metronome(
     battle: anytype,
     player: Player,
     mslot: u4,
+    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
@@ -1239,7 +1319,7 @@ fn metronome(
     incrementPP(side, mslot);
 
     if (!try canMove(battle, player, mslot, auto, false, .Metronome, residual, log)) return null;
-    return doMove(battle, player, mslot, auto, residual, log);
+    return doMove(battle, player, mslot, rewrap, auto, residual, log);
 }
 
 fn checkHit(battle: anytype, player: Player, move: Move.Data, log: anytype) !bool {
@@ -1446,11 +1526,7 @@ fn handleResidual(battle: anytype, player: Player, log: anytype) !void {
         stored.hp -= amount;
 
         // As above, Pokémon Showdown uses damageOf but its not relevant
-        if (amount > 0) {
-            try log.damage(ident, stored, .LeechSeed);
-            // Pokémon Showdown erroneously updates last damage with uncapped Leech Seed damage
-            if (showdown) battle.last_damage = damage;
-        }
+        if (amount > 0) try log.damage(ident, stored, .LeechSeed);
 
         const before = foe_stored.hp;
         // Uncapped damage is added back to the foe
@@ -1464,13 +1540,13 @@ fn endTurn(battle: anytype, log: anytype) @TypeOf(log).Error!Result {
     assert(!battle.side(.P1).active.volatiles.MultiHit);
     assert(!battle.side(.P2).active.volatiles.MultiHit);
 
+    battle.turn += 1;
+
     if (showdown and options.ebc and checkEBC(battle)) {
         try log.tie();
         return Result.Tie;
     }
 
-    battle.turn += 1;
-
     if (showdown and battle.turn >= 1000) {
         try log.tie();
         return Result.Tie;
@@ -1983,9 +2059,9 @@ pub const Effects = struct {
                 }
                 break :has_mimic false;
             };
-            // If the foe is Invulnerable we still want to fall through to checkHit to be able to
-            // trigger |-miss| instead of |-fail|
-            if (!has_mimic and !foe.active.volatiles.Invulnerable) {
+            if (!has_mimic) {
+                // Invulnerable foes or 1/256 miss can trigger |-miss| instead of |-fail|
+                if (!try checkHit(battle, player, move, log)) return;
                 return try log.fail(battle.active(player.foe()), .None);
             }
         }
@@ -2253,7 +2329,7 @@ pub const Effects = struct {
         try log.transform(battle.active(player), foe_ident);
     }
 
-    fn binding(battle: anytype, player: Player) void {
+    fn binding(battle: anytype, player: Player, rewrap: bool) void {
         var side = battle.side(player);
         var foe = battle.foe(player);
 
@@ -2261,7 +2337,9 @@ pub const Effects = struct {
         side.active.volatiles.Binding = true;
         // GLITCH: Hyper Beam automatic selection glitch if Recharging gets cleared on miss
         // (Pokémon Showdown unitentionally patches this glitch, preventing automatic selection)
-        if (!showdown) foe.active.volatiles.Recharging = false;
+        if (!showdown) {
+            foe.active.volatiles.Recharging = false;
+        } else if (foe.stored().hp == 0) return if (!rewrap) battle.rng.advance(1);
 
         side.active.volatiles.attacks = Rolls.distribution(battle) - 1;
     }

package/src/lib/pkmn.zig

@@ -25,12 +25,12 @@ pub const Result = @import("common/data.zig").Result;
 /// Pokémon Showdown's RNG (backed by a Generation V & VI RNG).
 pub const PSRNG = @import("common/rng.zig").PSRNG;
 
-/// Namespace for helpers related to protocol trace logging.
+/// Namespace for helpers related to protocol message logging.
 pub const protocol = if (options.internal) struct {
     pub usingnamespace @import("common/protocol.zig");
 } else struct {
     /// Logs protocol information to its `Writer` during a battle update when
-    /// `options.trace` is enabled.
+    /// `options.log` is enabled.
     pub const Log = @import("common/protocol.zig").Log;
     /// Stripped down version of `std.io.FixedBufferStream` optimized for
     /// efficiently writing the individual protocol bytes. Note that the
@@ -41,8 +41,8 @@ pub const protocol = if (options.internal) struct {
     /// intialized with a `LOGS_SIZE`-sized buffer.
     pub const FixedLog = @import("common/protocol.zig").FixedLog;
     /// Null object pattern implementation of `Log` backed by a
-    /// `std.io.null_writer`. Ignores anything sent to it, though trace logging
-    /// should addtionally be turned off entirely by using `options.trace`.
+    /// `std.io.null_writer`. Ignores anything sent to it, though protocol
+    /// logging should additionally be turned off entirely with `options.log`.
     pub const NULL = @import("common/protocol.zig").NULL;
 };