@pkmn/engine 0.1.0-dev.3a273268 → 0.1.0-dev.47feedd9

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;
@@ -129,14 +132,20 @@ fn selectMove(
     if (volatiles.Recharging) 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 +155,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) {
@@ -177,6 +189,7 @@ fn selectMove(
     }
 
     if (battle.foe(player).active.volatiles.Binding) {
+        skip_turn.* = true;
         if (showdown) {
             saveMove(battle, player, choice);
         } else {
@@ -327,9 +340,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 +354,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 +374,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 +406,8 @@ fn executeMove(
     battle: anytype,
     player: Player,
     choice: Choice,
+    rewrap: bool,
+    skip: bool,
     from: ?Move,
     residual: *bool,
     log: anytype,
@@ -382,9 +419,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);
@@ -434,7 +472,7 @@ fn executeMove(
 
     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,14 +484,15 @@ fn executeMove(
         return null;
     }
 
-    return doMove(battle, player, mslot, auto, residual, log);
+    return doMove(battle, player, mslot, rewrap, auto, residual, log);
 }
 
-const BeforeMove = union(enum) { done, skip_can, skip_pp, ok, err };
+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 +524,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,13 +553,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
-    if (showdown and volatiles.Flinch) {
-        volatiles.Flinch = false;
-        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) {
@@ -634,8 +668,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;
     }
@@ -650,7 +689,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;
     }
@@ -708,7 +751,7 @@ 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;
@@ -749,6 +792,7 @@ fn doMove(
     battle: anytype,
     player: Player,
     mslot: u4,
+    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
@@ -840,9 +884,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;
@@ -857,7 +901,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);
@@ -923,7 +967,7 @@ 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;
                 // Pokémon Showdown logs |-damage| here instead of |-immune| because logic...
@@ -1160,7 +1204,9 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, log: anytype)
     // 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;
 }
 
@@ -1204,6 +1250,7 @@ fn mirrorMove(
     battle: anytype,
     player: Player,
     mslot: u4,
+    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
@@ -1216,18 +1263,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,
@@ -1238,7 +1286,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 {
@@ -1445,11 +1493,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
@@ -1662,7 +1706,7 @@ pub const Effects = struct {
         side.active.volatiles.Bide = true;
         assert(!side.active.volatiles.Thrashing and !side.active.volatiles.Rage);
         side.active.volatiles.state = 0;
-        side.active.volatiles.attacks = Rolls.duration(battle);
+        side.active.volatiles.attacks = Rolls.bideThrashDuration(battle);
 
         try log.start(battle.active(player), .Bide);
     }
@@ -1982,9 +2026,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);
             }
         }
@@ -2167,7 +2211,7 @@ pub const Effects = struct {
         }
         foe.active.volatiles.Recharging = false;
 
-        foe_stored.status = Status.slp(Rolls.sleep(battle));
+        foe_stored.status = Status.slp(Rolls.sleepDuration(battle));
         try log.statusFrom(foe_ident, foe_stored.status, battle.side(player).last_selected_move);
     }
 
@@ -2220,7 +2264,7 @@ pub const Effects = struct {
         assert(!volatiles.Bide);
 
         volatiles.Thrashing = true;
-        volatiles.attacks = Rolls.duration(battle);
+        volatiles.attacks = Rolls.bideThrashDuration(battle);
     }
 
     fn transform(battle: anytype, player: Player, log: anytype) !void {
@@ -2252,7 +2296,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);
 
@@ -2260,7 +2304,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;
     }
@@ -2589,7 +2635,7 @@ pub const Rolls = struct {
         return battle.rng.next() < 1 + (if (low) Gen12.percent(20) else Gen12.percent(40));
     }
 
-    inline fn sleep(battle: anytype) u3 {
+    inline fn sleepDuration(battle: anytype) u3 {
         if (showdown) return @intCast(u3, battle.rng.range(u8, 1, 8));
         while (true) {
             const r = battle.rng.next() & 7;
@@ -2597,7 +2643,7 @@ pub const Rolls = struct {
         }
     }
 
-    inline fn duration(battle: anytype) u3 {
+    inline fn bideThrashDuration(battle: anytype) u3 {
         if (showdown) return @intCast(u3, battle.rng.range(u4, 2, 4));
         return @intCast(u3, (battle.rng.next() & 1) + 2);
     }

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;
 };