@pkmn/engine 0.1.0-dev.cf6f5d2c → 0.1.0-dev.d97c6e03

package/src/lib/gen1/mechanics.zig

@@ -62,28 +62,26 @@ 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, &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 (selectMove(battle, .P1, c1, c2, &f1)) |r| return r;
+    if (selectMove(battle, .P2, c2, c1, &f2)) |r| return r;
 
     if (turnOrder(battle, c1, c2) == .P1) {
-        if (try doTurn(battle, .P1, c1, r1, s1, f1, .P2, c2, r2, s2, f2, log)) |r| return r;
+        if (try doTurn(battle, .P1, c1, f1, .P2, c2, f2, log)) |r| return r;
     } else {
-        if (try doTurn(battle, .P2, c2, r2, s2, f2, .P1, c1, r1, s1, f1, log)) |r| return r;
+        if (try doTurn(battle, .P2, c2, f2, .P1, c1, f1, log)) |r| return r;
     }
 
-    if (p1.active.volatiles.attacks == 0) p1.active.volatiles.Binding = false;
-    if (p2.active.volatiles.attacks == 0) p2.active.volatiles.Binding = false;
+    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;
+    }
 
     return endTurn(battle, log);
 }
@@ -116,7 +114,6 @@ fn selectMove(
     player: Player,
     choice: Choice,
     foe_choice: Choice,
-    skip_turn: *bool,
     from: *?Move,
 ) ?Result {
     if (choice.type == .Pass) return null;
@@ -129,26 +126,17 @@ fn selectMove(
         (choice.type == .Move and choice.data == @boolToInt(showdown)));
 
     // pre-battle menu
-    if (volatiles.Recharging) {
-        if (showdown and battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
-        return null;
-    }
+    if (volatiles.Recharging) return null;
     if (volatiles.Rage) {
         from.* = side.last_used_move;
-        if (showdown) {
-            if (battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
-            saveMove(battle, player, null);
-        }
+        if (showdown) 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) {
-            if (battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
-            saveMove(battle, player, null);
-        }
+        if (showdown) saveMove(battle, player, null);
         return null;
     }
 
@@ -158,10 +146,7 @@ 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) {
-            if (volatiles.Bide and battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
-            saveMove(battle, player, choice);
-        }
+        if (showdown) saveMove(battle, player, choice);
         return null;
     }
     if (volatiles.Binding) {
@@ -192,7 +177,6 @@ fn selectMove(
     }
 
     if (battle.foe(player).active.volatiles.Binding) {
-        skip_turn.* = true;
         if (showdown) {
             saveMove(battle, player, choice);
         } else {
@@ -343,13 +327,9 @@ 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 {
@@ -357,16 +337,7 @@ fn doTurn(
 
     var residual = true;
     var replace = battle.side(player).stored().hp == 0;
-    if (try executeMove(
-        battle,
-        player,
-        player_choice,
-        player_rewrap,
-        player_skip,
-        player_from,
-        &residual,
-        log,
-    )) |r| return r;
+    if (try executeMove(battle, player, player_choice, player_from, &residual, log)) |r| return r;
     if (!replace) {
         if (player_choice.type != .Switch) {
             if (try checkFaint(battle, foe_player, log)) |r| return r;
@@ -377,16 +348,7 @@ fn doTurn(
 
     residual = true;
     replace = battle.side(foe_player).stored().hp == 0;
-    if (try executeMove(
-        battle,
-        foe_player,
-        foe_choice,
-        foe_rewrap,
-        foe_skip,
-        foe_from,
-        &residual,
-        log,
-    )) |r| return r;
+    if (try executeMove(battle, foe_player, foe_choice, foe_from, &residual, log)) |r| return r;
     if (!replace) {
         if (foe_choice.type != .Switch) {
             if (try checkFaint(battle, player, log)) |r| return r;
@@ -409,8 +371,6 @@ fn executeMove(
     battle: anytype,
     player: Player,
     choice: Choice,
-    rewrap: bool,
-    skip: bool,
     from: ?Move,
     residual: *bool,
     log: anytype,
@@ -422,10 +382,9 @@ 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);
@@ -475,7 +434,7 @@ fn executeMove(
 
     var skip_can = false;
     var skip_pp = false;
-    switch (try beforeMove(battle, player, skip, from, residual, log)) {
+    switch (try beforeMove(battle, player, from, residual, log)) {
         .done => return null,
         .skip_can => skip_can = true,
         .skip_pp => skip_pp = true,
@@ -487,7 +446,7 @@ fn executeMove(
         return null;
     }
 
-    return doMove(battle, player, mslot, rewrap, auto, residual, log);
+    return doMove(battle, player, mslot, auto, residual, log);
 }
 
 const BeforeMove = enum { done, skip_can, skip_pp, ok, err };
@@ -495,7 +454,6 @@ const BeforeMove = enum { done, skip_can, skip_pp, ok, err };
 fn beforeMove(
     battle: anytype,
     player: Player,
-    skip: bool,
     from: ?Move,
     residual: *bool,
     log: anytype,
@@ -527,15 +485,13 @@ fn beforeMove(
         return .done;
     }
 
-    if (skip or foe.active.volatiles.Binding) {
+    if (foe.active.volatiles.Binding) {
         try log.cant(ident, .Bound);
         return .done;
     }
 
-    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;
+    if (!showdown and volatiles.Flinch) {
+        volatiles.Flinch = false;
         try log.cant(ident, .Flinch);
         return .done;
     }
@@ -556,6 +512,14 @@ 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) {
@@ -671,13 +635,8 @@ fn beforeMove(
             try log.start(battle.active(player), .ConfusionSilent);
         }
         try log.move(ident, side.last_selected_move, battle.active(player.foe()), from);
-        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);
-            }
+        if (showdown and handleThrashing(battle, active)) {
+            try log.start(battle.active(player), .ConfusionSilent);
         }
         return .skip_can;
     }
@@ -692,11 +651,7 @@ 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;
     }
@@ -754,7 +709,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, false);
+        Effects.binding(battle, player);
     }
 
     return true;
@@ -795,7 +750,6 @@ fn doMove(
     battle: anytype,
     player: Player,
     mslot: u4,
-    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
@@ -887,9 +841,9 @@ fn doMove(
 
     if (!showdown or !miss) {
         if (move.effect == .MirrorMove) {
-            return mirrorMove(battle, player, mslot, rewrap, auto, residual, log);
+            return mirrorMove(battle, player, mslot, auto, residual, log);
         } else if (move.effect == .Metronome) {
-            return metronome(battle, player, mslot, rewrap, auto, residual, log);
+            return metronome(battle, player, mslot, auto, residual, log);
         } else if (move.effect.onEnd()) {
             try onEnd(battle, player, move, log);
             return null;
@@ -904,7 +858,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 and (!showdown or move.effect != .Binding)) {
+        } else if (immune and !invulnerable) {
             try log.immune(foe_ident, .None);
         } else if (mist) {
             if (!foe.active.volatiles.Substitute) try log.activate(foe_ident, .Mist);
@@ -970,17 +924,11 @@ 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, rewrap);
+            Effects.binding(battle, player);
             if (immune) {
                 battle.last_damage = 0;
-                assert(foe.stored().hp > 0);
                 // Pokémon Showdown logs |-damage| here instead of |-immune| because logic...
-                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);
-                }
+                try log.damage(battle.active(player.foe()), foe.stored(), .None);
                 return null;
             }
         }
@@ -1213,9 +1161,7 @@ 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;
 }
 
@@ -1259,7 +1205,6 @@ fn mirrorMove(
     battle: anytype,
     player: Player,
     mslot: u4,
-    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
@@ -1272,19 +1217,18 @@ 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, rewrap, auto, residual, log);
+    return doMove(battle, player, mslot, auto, residual, log);
 }
 
 fn metronome(
     battle: anytype,
     player: Player,
     mslot: u4,
-    rewrap: bool,
     auto: bool,
     residual: *bool,
     log: anytype,
@@ -1295,7 +1239,7 @@ fn metronome(
     incrementPP(side, mslot);
 
     if (!try canMove(battle, player, mslot, auto, false, .Metronome, residual, log)) return null;
-    return doMove(battle, player, mslot, rewrap, auto, residual, log);
+    return doMove(battle, player, mslot, auto, residual, log);
 }
 
 fn checkHit(battle: anytype, player: Player, move: Move.Data, log: anytype) !bool {
@@ -1502,7 +1446,11 @@ 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);
+        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;
+        }
 
         const before = foe_stored.hp;
         // Uncapped damage is added back to the foe
@@ -2035,9 +1983,9 @@ pub const Effects = struct {
                 }
                 break :has_mimic false;
             };
-            if (!has_mimic) {
-                // Invulnerable foes or 1/256 miss can trigger |-miss| instead of |-fail|
-                if (!try checkHit(battle, player, move, log)) return;
+            // 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) {
                 return try log.fail(battle.active(player.foe()), .None);
             }
         }
@@ -2305,7 +2253,7 @@ pub const Effects = struct {
         try log.transform(battle.active(player), foe_ident);
     }
 
-    fn binding(battle: anytype, player: Player, rewrap: bool) void {
+    fn binding(battle: anytype, player: Player) void {
         var side = battle.side(player);
         var foe = battle.foe(player);
 
@@ -2313,9 +2261,7 @@ 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;
-        } else if (foe.stored().hp == 0) return if (!rewrap) battle.rng.advance(1);
+        if (!showdown) foe.active.volatiles.Recharging = false;
 
         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 message logging.
+/// Namespace for helpers related to protocol trace 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.log` is enabled.
+    /// `options.trace` 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 protocol
-    /// logging should additionally be turned off entirely with `options.log`.
+    /// `std.io.null_writer`. Ignores anything sent to it, though trace logging
+    /// should addtionally be turned off entirely by using `options.trace`.
     pub const NULL = @import("common/protocol.zig").NULL;
 };