@pkmn/engine 0.1.0-dev.7fe22fc0 → 0.1.0-dev.84cc1a02

package/src/lib/common/protocol.zig

@@ -7,7 +7,7 @@ const options = @import("./options.zig");
 const assert = std.debug.assert;
 const print = std.debug.print;
 
-const enabled = options.log;
+const trace = options.trace;
 
 const Player = data.Player;
 const ID = data.ID;
@@ -230,7 +230,7 @@ pub fn Log(comptime Writer: type) type {
         pub const Error = Writer.Error;
 
         pub fn move(self: Self, source: ID, m: anytype, target: ID, from: anytype) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             assert(m != .None);
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Move),
@@ -253,7 +253,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn switched(self: Self, ident: ID, pokemon: anytype) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{ @enumToInt(ArgType.Switch), @bitCast(u8, ident) });
             try self.writer.writeAll(&.{ @enumToInt(pokemon.species), pokemon.level });
             try self.writer.writeIntNative(u16, pokemon.hp);
@@ -262,7 +262,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn cant(self: Self, ident: ID, reason: Cant) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             assert(reason != .Disable);
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Cant),
@@ -272,7 +272,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn disabled(self: Self, ident: ID, m: anytype) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Cant),
                 @bitCast(u8, ident),
@@ -282,20 +282,20 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn faint(self: Self, ident: ID, done: bool) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{ @enumToInt(ArgType.Faint), @bitCast(u8, ident) });
             if (done) try self.writer.writeByte(@enumToInt(ArgType.None));
         }
 
         pub fn turn(self: Self, num: u16) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeByte(@enumToInt(ArgType.Turn));
             try self.writer.writeIntNative(u16, num);
             try self.writer.writeByte(@enumToInt(ArgType.None));
         }
 
         pub fn win(self: Self, player: Player) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Win),
                 @enumToInt(player),
@@ -304,12 +304,12 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn tie(self: Self) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{ @enumToInt(ArgType.Tie), @enumToInt(ArgType.None) });
         }
 
         pub fn damage(self: Self, ident: ID, pokemon: anytype, reason: Damage) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             assert(@enumToInt(reason) <= @enumToInt(Damage.LeechSeed));
             try self.writer.writeAll(&.{ @enumToInt(ArgType.Damage), @bitCast(u8, ident) });
             try self.writer.writeIntNative(u16, pokemon.hp);
@@ -324,7 +324,7 @@ pub fn Log(comptime Writer: type) type {
             reason: Damage,
             source: ID,
         ) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             assert(@enumToInt(reason) == @enumToInt(Damage.RecoilOf));
             try self.writer.writeAll(&.{ @enumToInt(ArgType.Damage), @bitCast(u8, ident) });
             try self.writer.writeIntNative(u16, pokemon.hp);
@@ -337,7 +337,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn heal(self: Self, ident: ID, pokemon: anytype, reason: Heal) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             assert(reason != .Drain);
             try self.writer.writeAll(&.{ @enumToInt(ArgType.Heal), @bitCast(u8, ident) });
             try self.writer.writeIntNative(u16, pokemon.hp);
@@ -346,7 +346,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn drain(self: Self, source: ID, pokemon: anytype, target: ID) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{ @enumToInt(ArgType.Heal), @bitCast(u8, source) });
             try self.writer.writeIntNative(u16, pokemon.hp);
             try self.writer.writeIntNative(u16, pokemon.stats.hp);
@@ -358,7 +358,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn status(self: Self, ident: ID, value: u8, reason: Status) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             assert(reason != .From);
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Status),
@@ -369,7 +369,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn statusFrom(self: Self, ident: ID, value: u8, m: anytype) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Status),
                 @bitCast(u8, ident),
@@ -380,7 +380,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn curestatus(self: Self, ident: ID, value: u8, reason: CureStatus) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.CureStatus),
                 @bitCast(u8, ident),
@@ -390,7 +390,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn boost(self: Self, ident: ID, reason: Boost, num: i8) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             assert(num != 0 and (reason != .Rage or num > 0));
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Boost),
@@ -401,12 +401,12 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn clearallboost(self: Self) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{@enumToInt(ArgType.ClearAllBoost)});
         }
 
         pub fn fail(self: Self, ident: ID, reason: Fail) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Fail),
                 @bitCast(u8, ident),
@@ -415,17 +415,17 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn miss(self: Self, source: ID) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{ @enumToInt(ArgType.Miss), @bitCast(u8, source) });
         }
 
         pub fn hitcount(self: Self, ident: ID, num: u8) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{ @enumToInt(ArgType.HitCount), @bitCast(u8, ident), num });
         }
 
         pub fn prepare(self: Self, source: ID, m: anytype) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Prepare),
                 @bitCast(u8, source),
@@ -434,12 +434,12 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn mustrecharge(self: Self, ident: ID) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{ @enumToInt(ArgType.MustRecharge), @bitCast(u8, ident) });
         }
 
         pub fn activate(self: Self, ident: ID, reason: Activate) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Activate),
                 @bitCast(u8, ident),
@@ -448,12 +448,12 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn fieldactivate(self: Self) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{@enumToInt(ArgType.FieldActivate)});
         }
 
         pub fn start(self: Self, ident: ID, reason: Start) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             assert(@enumToInt(reason) < @enumToInt(Start.TypeChange));
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Start),
@@ -463,7 +463,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn typechange(self: Self, source: ID, types: anytype, target: ID) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Start),
                 @bitCast(u8, source),
@@ -474,7 +474,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn startEffect(self: Self, ident: ID, reason: Start, m: anytype) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             assert(@enumToInt(reason) > @enumToInt(Start.TypeChange));
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Start),
@@ -485,7 +485,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn end(self: Self, ident: ID, reason: End) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.End),
                 @bitCast(u8, ident),
@@ -494,27 +494,27 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn ohko(self: Self) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{@enumToInt(ArgType.OHKO)});
         }
 
         pub fn crit(self: Self, ident: ID) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{ @enumToInt(ArgType.Crit), @bitCast(u8, ident) });
         }
 
         pub fn supereffective(self: Self, ident: ID) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{ @enumToInt(ArgType.SuperEffective), @bitCast(u8, ident) });
         }
 
         pub fn resisted(self: Self, ident: ID) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{ @enumToInt(ArgType.Resisted), @bitCast(u8, ident) });
         }
 
         pub fn immune(self: Self, ident: ID, reason: Immune) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Immune),
                 @bitCast(u8, ident),
@@ -523,7 +523,7 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn transform(self: Self, source: ID, target: ID) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{
                 @enumToInt(ArgType.Transform),
                 @bitCast(u8, source),
@@ -532,12 +532,12 @@ pub fn Log(comptime Writer: type) type {
         }
 
         pub fn laststill(self: Self) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{@enumToInt(ArgType.LastStill)});
         }
 
         pub fn lastmiss(self: Self) Error!void {
-            if (!enabled) return;
+            if (!trace) return;
             try self.writer.writeAll(&.{@enumToInt(ArgType.LastMiss)});
         }
     };
@@ -838,7 +838,7 @@ pub fn expectLog(
     actual: []const u8,
     offset: usize,
 ) !void {
-    if (!enabled) return;
+    if (!trace) return;
     const color = color: {
         if (std.process.hasEnvVarConstant("ZIG_DEBUG_COLOR")) {
             break :color true;

package/src/lib/gen1/README.md

@@ -198,7 +198,7 @@ above, PP information isn't strictly necessary in Generation I so is dropped. `M
 a special sentinel value to indicate `null`. Move PP data is only included for testing and is not
 necessary for the actual engine implementation.
 
-In order to workaround various [Pokémon Showdown bugs](#bugs) and to support its protocol in logs,
+In order to workaround various [Pokémon Showdown bugs](#bugs) and to support its protocol in traces,
 additional information is stored in `Move.Data` (`targets`) about what Pokémon Showdown believes the
 `Move.Target` to be (despite the concept of targeting not existing until Generation III when Double
 battles were introduced). More specifically, a move's "targeting" status is required in various
@@ -331,10 +331,8 @@ does not produce an equivalent to Pokémon Showdown's `|request|` protocol messa
 must be gleaned through the `Battle` state). Useful size and offset information can be found in
 the [`layout.json`](../../data/layout.json) which exists to simplify writing driver code.
 
-Documentation of the wire protocol used for protocol message logging when `-Dlog` is enabled can be
-found in [PROTOCOL.md](../../../docs/PROTOCOL.md). Note that the
-[`pkmn-debug`](../../../README.md#pkmn-debug) tool exists to display the binary protocol and battle
-data in the browser for ease of debugging.
+Documentation of the wire protocol used for logging traces when `-Dtrace` is enabled can be found in
+[PROTOCOL.md](../../../docs/PROTOCOL.md).
 
 ### `Battle`
 
@@ -478,8 +476,7 @@ Smogon](https://www.smogon.com/forums/posts/5933177/show):
 - Confusion self-hits use the wrong damage formula resulting in off-by-one errors (and also fail to
   account for an opponent's Reflect). Furthermore, the confusion self-hit damage will erroneously be
   inflicted to the confused user's substitute if the confused user had been attempting to use a
-  self-targeting move. Finally, Pokémon Showdown erroneously considers the *uncapped* self-hit
-  damage for the purposes of tracking the battle's last damage.
+  self-targeting move.
 
 Beyond the general bugs listed above, several move effects are implemented incorrectly by Pokémon
 Showdown. Some of these moves are [too fundamentally broken to be implemented](#unimplementable) by
@@ -487,29 +484,18 @@ the pkmn engine, but the following moves have their broken behavior preserved in
 
 - **Bide**: If the opponent faints after Bide inflicts damage on Pokémon Showdown residual damage
   incorrectly still gets applied to Bide's user.
-- **Counter**: On Pokémon Showdown choices made while sleeping (which should not have been
-  registered) can erroneously cause Counter to trigger Desync Clause Mod behavior.
 - **Leech Seed**: Leech Seed fails to heal its source side if a seeded target faints due to
   recoil/crash damage on Pokémon Showdown. Pokémon Showdown also updates the battle's last damage
-  field with the uncapped Leech Seed damage if the residual damage is applied which has consequences
-  for Bide and Counter.
+  field with the uncapped Leech Seed damage which has consequences for Bide and Counter.
 - **Pay Day**: Pay Day should still scatter coins if it hits (but doesn't break) and opponent's
   Substitute but doesn't on Pokémon Showdown.
 - **Flinch**: Flinching does not get cleared during move selection on Pokémon Showdown and is
   instead cleared in Pokémon Showdown's "residual" phase, meaning the flinch status gets erroneously
   preserved across fainting (as fainting triggers Pokémon Showdown's "instaswitch" behavior which
   skips end-of-turn residuals).
-- **Rage**: Rage boosts should still result in burn/paralysis [stat modification
-  errors](https://pkmn.cc/bulba-glitch-1#Stat_modification_errors) but don't on Pokémon Showdown.
-  Furthermore, Pokémon Showdown only builds Rage for Disable/Explosion (hit/miss) when attacking
-  into a Substitute instead of all moves. Pokémon Showdown also implements the [Rage and Thrash /
-  Petal Dance accuracy bug]( https://www.youtube.com/watch?v=NC5gbJeExbs) incorrectly, as the
-  accuracy only gets written when the volatile is present which can lead to incorrect accuracy
-  values on turns where Rage is used on the same turn as a move which modifies accuracy or evasion.
 - **Thrash** / **Petal Dance**: once a Pokémon is locked into a thrashing move they will lose all
   speed ties on Pokémon Showdown (due to the fact that if they win the speed tie their action will
-  then get "changed" and inserted back into the queue after their opponent's action). Pokémon
-  Showdown also implements accuracy incorrectly, as covered above.
+  then get "changed" and inserted back into the queue after their opponent's action).
 - **Freeze** / **Sleep**: Pokémon Showdown requires a move to be selected when a Pokémon is frozen
   or sleeping and uses that in the event that the status is removed while on the cartridge no
   selection is possible and no turn exists for the thawed/woken Pokémon to act except in the case of
@@ -534,8 +520,7 @@ the pkmn engine, but the following moves have their broken behavior preserved in
   Pokémon Showdown implementing the health check based on floating point division instead of integer
   divison like on the cartridge (meaning the Substitute 1/4 glitch will only occur if the Pokémon's
   maximum HP is evenly divisible by 4). Finally, Substitute also incorrectly blocks Dream Eater on
-  Pokémon Showdown and will incorrectly still heal 1 HP for any draining moves if the attack does 0
-  damage.
+  Pokémon Showdown.
 
 In addition to numerous cases where Pokémon Showdown uses the wrong type of message (e.g. `|-fail`
 vs. `|-miss|` vs. `|-immune|`, e.g. in the case of Leech Seed) which are not documented here, Pokémon
@@ -605,13 +590,9 @@ the correct control flow):
   still gets a turn under the [trapping sleep
   glitch](https://glitchcity.wiki/Trapping_move_and_sleep_glitch), Wrap does 0 damage against
   Ghost-type Pokémon instead of properly respecting immunity, and binding effects are handled in the
-  wrong order in the code which results in either out of order messaging or, more consequentially,
-  Pokémon using Rage/Bide or Thrashing/Charging moves being incorrectly forced to skip a turn when
-  the Pokémon using the Binding move switches. The `partialtrappinglock` variable also separately
-  tracks its original damage in order to be able to correctly inflict damage on subsequent turns,
-  however, the pkmn engine isn't able to store this state and so must use the battle's last damage
-  like the cartridge which results in errors from Leech Seed overwriting the last damage on Pokémon
-  Showdown.
+  wrong order in the code.
+- **Counter**: On Pokémon Showdown choices made while sleeping (which should not have been
+  registered) can erroneously cause Counter to trigger Desync Clause Mod behavior.
 - **Mimic**: Pokémon Showdown checks that the user of Mimic has Mimic in one of their move slots,
   which means Mimic legally called via Metronome or Mirror Move will only work if the user also has
   Mimic (and the moved mimicked by Mimic called via Metronome / Mirror Move will erroneously
@@ -623,19 +604,15 @@ the correct control flow):
 - **Mirror Move**: Binding moves misbehave when used via Mirror Move (though Pokémon Showdown has
   its own weird behavior and does not implement the [partial trapping move Mirror Move
   glitch](https://glitchcity.wiki/Partial_trapping_move_Mirror_Move_link_battle_glitch) that exists
-  on the cartridge). Additionally, Pokémon Showdown sets the last used move every turn a Pokémon
-  is Thrashing instead of just on the turn it is actually selected meaning Mirror Move will
-  sometimes successfully mirror a Thrashing move when it should fail.
+  on the cartridge).
 - **Metronome**: In addition to the issues with binding moves, Metronome and Mirror Move cannot
   mutually call each other more than 3 times in a row without causing the Pokémon Showdown simulator
   to crash due to defensive safety checks that do not exist on the cartridge.
-- **Transform**: Pokémon Showdown permanently copies the DVs of Transform's target and recomputes
-  stats every switch, corrupting the Transform user's stats. Transform also screws up the effect of
-  Disable, because on Pokémon Showdown, Disable prevents moves of a given *name* from being used
-  (e.g. "Water Gun") as opposed to moves in a specific *slot* (e.g. the 2nd move slot), and a
-  Pokémon's moves can change after Transform (this is not an issue with Disable + Mimic because
-  Mimic happens to replace the same slot). Furthermore, transforming and then using Mirror Move /
-  Metronome can result in [glitchy behavior and
+- **Transform**:  Transform screws up the effect of Disable, because on Pokémon Showdown, Disable
+  prevents moves of a given *name* from being used (e.g. "Water Gun") as opposed to moves in a
+  specific *slot* (e.g. the 2nd move slot), and a Pokémon's moves can change after Transform (this
+  is not an issue with Disable + Mimic because Mimic happens to replace the same slot). Furthermore,
+  transforming and then using Mirror Move / Metronome can result in [glitchy behavior and
   softlocks](https://pkmn.cc/bulba/Transform_glitches#Transform_.2B_Mirror_Move.2FMetronome_PP_error)
   which Pokémon Showdown does not implement.
 

package/src/lib/gen1/data.zig

@@ -17,16 +17,16 @@ const expectEqual = std.testing.expectEqual;
 const expect = std.testing.expect;
 
 /// The minimum size in bytes required to hold all Generation I choice options.
-pub const MAX_CHOICES: usize = 9; // move 1..4, switch 2..6
+pub const MAX_OPTIONS: usize = 9; // move 1..4, switch 2..6
 /// The optimal size in bytes required to hold all Generation I choice options.
-/// At least as large as MAX_CHOICES.
+/// At least as large as MAX_OPTIONS.
 pub const MAX_LOGS: usize = 180;
 
 /// The maximum number of bytes possibly logged by a single Generation I update.
-pub const CHOICES_SIZE = if (builtin.mode == .ReleaseSmall)
-    MAX_CHOICES
+pub const OPTIONS_SIZE = if (builtin.mode == .ReleaseSmall)
+    MAX_OPTIONS
 else
-    std.math.ceilPowerOfTwo(usize, MAX_CHOICES) catch unreachable;
+    std.math.ceilPowerOfTwo(usize, MAX_OPTIONS) catch unreachable;
 /// The optimal size in bytes required to hold the largest amount of log data possible from a
 /// single Generation I update. At least as large as MAX_LOGS.
 pub const LOGS_SIZE = if (builtin.mode == .ReleaseSmall)
@@ -76,7 +76,7 @@ pub fn Battle(comptime RNG: anytype) type {
         }
 
         /// Returns the result of applying Player 1's choice `c1` and Player 2's choice `c2` to the
-        /// battle, optionally writing protocol message logs to `log` if `options.log` is enabled.
+        /// battle, optionally writing protocol logs to `log` if `options.trace` is enabled.
         pub fn update(self: *Self, c1: Choice, c2: Choice, log: anytype) !Result {
             return mechanics.update(self, c1, c2, log);
         }

package/src/lib/gen1/helpers.zig

@@ -211,19 +211,16 @@ pub const Pokemon = struct {
     }
 };
 
-// TODO: uncomment once integration tests pass (possibily remove Transform/LeechSeed)
-// fn blocked(m: Move) bool {
-//     // Binding moves are borked but only via Mirror Move / Metronome which are already blocked
-//     return switch (m) {
-//         .Mimic, .Metronome, .MirrorMove, .Transform, .LeechSeed => true,
-//         else => false,
-//     };
-// }
-
+// cat src/test/showdown/blocklist.json | jq '."1".moves'
 fn blocked(m: Move) bool {
     if (Move.get(m).effect == .Binding) return true;
     return switch (m) {
-        .Counter, .Mimic, .Metronome, .MirrorMove, .Transform => true,
+        .Counter,
+        .Mimic,
+        .Metronome,
+        .MirrorMove,
+        .Transform,
+        => true,
         else => false,
     };
 }