@pkmn/engine 0.1.0-dev.207fa86a → 0.1.0-dev.2c13d3ec

package/src/lib/common/rng.zig

@@ -47,7 +47,7 @@ pub const PSRNG = extern struct {
     }
 
     pub fn range(self: *PSRNG, comptime T: type, from: T, to: Bound(T)) T {
-        return @intCast(T, @as(u64, self.src.next()) * (to - from) / divisor + from);
+        return @intCast(@as(u64, self.src.next()) * (to - from) / divisor + from);
     }
 
     pub fn chance(self: *PSRNG, comptime T: type, numerator: T, denominator: Bound(T)) bool {
@@ -72,28 +72,28 @@ test PSRNG {
 // https://pkmn.cc/pokered/engine/battle/core.asm#L6644-L6693
 // https://pkmn.cc/pokecrystal/engine/battle/core.asm#L6922-L6938
 pub const Gen12 = extern struct {
-    seed: [10]u8,
+    seed: [9]u8,
     index: u8 = 0,
 
     comptime {
-        assert(@sizeOf(Gen12) == 11);
+        assert(@sizeOf(Gen12) == 10);
     }
 
     pub fn percent(p: u8) u8 {
-        return @intCast(u8, (@as(u16, p) * 0xFF) / 100);
+        return @intCast((@as(u16, p) * 0xFF) / 100);
     }
 
     pub fn next(self: *Gen12) u8 {
         const val = 5 *% self.seed[self.index] +% 1;
         self.seed[self.index] = val;
-        self.index = (self.index + 1) % 10;
+        self.index = (self.index + 1) % 9;
         return val;
     }
 };
 
 test Gen12 {
-    const expected = [_]u8{ 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 31, 56, 81 };
-    var rng = Gen12{ .seed = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } };
+    const expected = [_]u8{ 6, 11, 16, 21, 26, 31, 36, 41, 46, 31, 56, 81 };
+    var rng = Gen12{ .seed = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9 } };
     for (expected) |e| {
         try expectEqual(e, rng.next());
     }
@@ -114,7 +114,7 @@ pub const Gen34 = extern struct {
 
     pub fn next(self: *Gen34) u16 {
         self.advance();
-        return @intCast(u16, self.seed >> 16);
+        return @intCast(self.seed >> 16);
     }
 
     pub fn advance(self: *Gen34) void {
@@ -144,7 +144,7 @@ pub const Gen56 = extern struct {
 
     pub fn next(self: *Gen56) u32 {
         self.advance();
-        return @intCast(u32, self.seed >> 32);
+        return @intCast(self.seed >> 32);
     }
 
     pub fn advance(self: *Gen56) void {
@@ -190,7 +190,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
 
         pub fn range(self: *Self, comptime T: type, from: T, to: Bound(T)) T {
             assert(showdown);
-            return @intCast(T, @as(u64, self.next()) * (to - from) / divisor + from);
+            return @intCast(@as(u64, self.next()) * (to - from) / divisor + from);
         }
 
         pub fn chance(

package/src/lib/gen1/README.md

@@ -28,35 +28,36 @@ list of additional reference [**resources**](#resources).
 
 The following information is required to simulate a Generation I Pokémon battle:
 
-| pkmn                                 | Pokémon Red (pret)                 | Pokémon Showdown                       |
-| ------------------------------------ | ---------------------------------- | -------------------------------------- |
-| `battle.seed`                        | `Random{Add,Sub}`                  | `battle.seed`                          |
-| `battle.turn`                        | -                                  | `battle.turn`                          |
-| `battle.last_damage`                 | `Damage`                           | `battle.lastDamage`                    |
-| `side.{active,pokemon}`              | `PlayerMonNumber`/`BattleMon`      | `side.active`                          |
-| `side.team`                          | `PartyMons`                        | `side.pokemon`                         |
-| `side.last_used_move`                | `PlayerUsedMove`                   | `pokemon.lastMove`                     |
-| `side.last_selected_move`            | `PlayerSelectedMove`               | `side.lastSelectedMove`                |
-| `battle.last_selected_indexes`       | `PlayerMoveListIndex`              | `side.lastMove`                        |
-| `side.order`                         | -                                  | `pokemon.position`                     |
-| `{pokemon,active}.moves`             | `{party,battle}_struct.{Moves,PP}` | `pokemon.{baseMoveSlots,moveSlots}`    |
-| `pokemon.hp`                         | `{party,battle}_struct.HP`         | `pokemon.hp`                           |
-| `{pokemon,active}.status`            | `{party,battle}_struct.Status`     | `pokemon.status`                       |
-| `{pokemon,active}.level`             | `PlayerMonUnmodifiedLevel`         | `pokemon.level`                        |
-| `pokemon.species`                    | `party_struct.Species`             | `pokemon.baseSpecies`                  |
-| `pokemon.stats`                      | `box_struct.Stats`                 | `pokemon.baseStoredStats`              |
-| `active.stats`                       | `battle_struct.Stats`              | `pokemon.modifiedStats`                |
-| `volatiles.transform`                | `PlayerMonUnmodified*`             | `pokemon.storedStats`                  |
-| `active.species`                     | `battle_struct.Species`            | `pokemon.species`                      |
-| `{pokemon,active}.types`             | `{party,battle}_struct.Type`       | `pokemon.types`                        |
-| `active.boosts`                      | `PlayerMon*Mod`                    | `pokemon.boosts`                       |
-| `active.volatiles`                   | `PlayerBattleStatus{1,2,3}`        | `pokemon.volatiles`                    |
-| `volatiles.state`                    | `PlayerBideAccumulatedDamage`      | `volatiles.bide.totalDamage`           |
-| `volatiles.attacks`                  | `PlayerNumAttacksLeft`             | `volatiles.{bide,lockedmove}.duration` |
-| `volatiles.confusion`                | `PlayerConfusedCounter`            | `volatiles.confusion.duration`         |
-| `volatiles.toxic`                    | `PlayerToxicCounter`               | `volatiles.residualdmg.counter`        |
-| `volatiles.substitute`               | `PlayerSubstituteHP`               | `volatiles.substitute.hp`              |
-| `volatiles.disabled_{move,duration}` | `PlayerDisabledMove{,Number}`      | `volatiles.disable.{move,time}`        |
+| pkmn                                    | Pokémon Red (pret)                 | Pokémon Showdown                       |
+| --------------------------------------- | ---------------------------------- | -------------------------------------- |
+| `battle.seed`                           | `Random{Add,Sub}`                  | `battle.seed`                          |
+| `battle.turn`                           | -                                  | `battle.turn`                          |
+| `battle.last_damage`                    | `Damage`                           | `battle.lastDamage`                    |
+| `side.{active,pokemon}`                 | `PlayerMonNumber`/`BattleMon`      | `side.active`                          |
+| `side.team`                             | `PartyMons`                        | `side.pokemon`                         |
+| `side.last_used_move`                   | `PlayerUsedMove`                   | `pokemon.lastMove`                     |
+| `side.last_selected_move`               | `PlayerSelectedMove`               | `side.lastSelectedMove`                |
+| `battle.last_moves.{p1,p2}_index`       | `PlayerMoveListIndex`              | -                                      |
+| `battle.last_moves.{p1,p2}_counterable` | -                                  | `side.lastMove`                        |
+| `side.order`                            | -                                  | `pokemon.position`                     |
+| `{pokemon,active}.moves`                | `{party,battle}_struct.{Moves,PP}` | `pokemon.{baseMoveSlots,moveSlots}`    |
+| `pokemon.hp`                            | `{party,battle}_struct.HP`         | `pokemon.hp`                           |
+| `{pokemon,active}.status`               | `{party,battle}_struct.Status`     | `pokemon.status`                       |
+| `{pokemon,active}.level`                | `PlayerMonUnmodifiedLevel`         | `pokemon.level`                        |
+| `pokemon.species`                       | `party_struct.Species`             | `pokemon.baseSpecies`                  |
+| `pokemon.stats`                         | `box_struct.Stats`                 | `pokemon.baseStoredStats`              |
+| `active.stats`                          | `battle_struct.Stats`              | `pokemon.modifiedStats`                |
+| `volatiles.transform`                   | `PlayerMonUnmodified*`             | `pokemon.storedStats`                  |
+| `active.species`                        | `battle_struct.Species`            | `pokemon.species`                      |
+| `{pokemon,active}.types`                | `{party,battle}_struct.Type`       | `pokemon.types`                        |
+| `active.boosts`                         | `PlayerMon*Mod`                    | `pokemon.boosts`                       |
+| `active.volatiles`                      | `PlayerBattleStatus{1,2,3}`        | `pokemon.volatiles`                    |
+| `volatiles.state`                       | `PlayerBideAccumulatedDamage`      | `volatiles.bide.totalDamage`           |
+| `volatiles.attacks`                     | `PlayerNumAttacksLeft`             | `volatiles.{bide,lockedmove}.duration` |
+| `volatiles.confusion`                   | `PlayerConfusedCounter`            | `volatiles.confusion.duration`         |
+| `volatiles.toxic`                       | `PlayerToxicCounter`               | `volatiles.residualdmg.counter`        |
+| `volatiles.substitute`                  | `PlayerSubstituteHP`               | `volatiles.substitute.hp`              |
+| `volatiles.disabled_{move,duration}`    | `PlayerDisabledMove{,Number}`      | `volatiles.disable.{move,time}`        |
 
 - Pokémon Showdown [does not implement the correct Generation I RNG](#rng) and as such its `seed` is
   different
@@ -68,6 +69,9 @@ The following information is required to simulate a Generation I Pokémon battle
   Counter and is not set and cleared in the correct locations. `Pokemon.lastMove` matches
   `PlayerUsedMove` more often so is what the engine attempts to model, despite the implications for
   Counter)
+- `battle.last_moves` doesn't map precisely to cartridge concepts because it is used to track desyncs
+  which instead are represented on the cartridge as discrepancies between the two separate battle states
+  that exist in the link battle.
 - Pokémon Showdown does not implement the [partial-trapping move Mirror Move
   glitch](https://glitchcity.wiki/Partial_trapping_move_Mirror_Move_link_battle_glitch) and as such
   does not need to keep track of a player's last selected move index (`PlayerMoveListIndex`)
@@ -98,8 +102,8 @@ The following information is required to simulate a Generation I Pokémon battle
 store general information about the battle. Unlike in Pokémon Showdown there is a distinction
 between the data structure for the "active" Pokémon and its party members (see below).
 
-Due to layout constraints, the index of the last selected move for a side is stored in what would
-otherwise be the padding bytes of`Battle` (the `last_selected_indexes` field) instead of in `Side`.
+Due to layout constraints, details about the last moves for a side are stored in what would
+otherwise be the padding bytes of`Battle` (the `last_moves` field) instead of in `Side`.
 
 ### `Pokemon` / `ActivePokemon`
 
@@ -198,7 +202,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 traces,
+In order to workaround various [Pokémon Showdown bugs](#bugs) and to support its protocol in logs,
 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
@@ -282,9 +286,9 @@ padding](https://en.wikipedia.org/wiki/Data_structure_alignment) and
   - the active Pokémon's level and current and max HP can always be referred to the `Pokemon`
     struct
 - **`Side`**: `ActivePokemon` + 6× `Pokemon` + active (`3`) + last used (`8`) + last selected
-  (`8`)
+  (`8`) + counterable (`1`) + last move index (`3`)
   - `order` does not need to be stored as the party can always be rearranged as switches occur
-- **`Battle`**: 6× `Side` + seed (10× `8` + `4`) + turn (`10`) + last damage (`10`)
+- **`Battle`**: 6× `Side` + seed (9× `8` + `4`) + turn (`10`) + last damage (`10`)
 - **`Type.CHART`**: attacking types (`15`) × defending types (`15`) × effectiveness (`2`)[^2]
 - **`Type.PRECEDENCE`**: 29× attacking type (`4`) + defending type (`4`) pairs
 - **`Moves.DATA`**: 165× base power (`6`) + effect (`7`) + accuracy (`4`) + type (`4`) + target
@@ -295,8 +299,8 @@ padding](https://en.wikipedia.org/wiki/Data_structure_alignment) and
 | ----------------- | ----------- | ------------ | -------- |
 | `Pokemon`         | 192         | 147          | 30.6%    |
 | `ActivePokemon`   | 256         | 202          | 26.7%    |
-| `Side`            | 1472        | 1056         | 33.5%    |
-| `Battle`          | 3088        | 2216         | 33.7%    |
+| `Side`            | 1472        | 1107         | 33.0%    |
+| `Battle`          | 3088        | 2310         | 33.7%    |
 | `Type.CHART`      | 1800        | 450          | 300.0%   |
 | `Type.PRECEDENCE` | 232         | 232          | 0.0%     |
 | `Moves.DATA`      | 5280        | 3960         | 33.3%    |
@@ -331,32 +335,37 @@ 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 logging traces when `-Dtrace` is enabled can be found in
-[PROTOCOL.md](../../../docs/PROTOCOL.md).
+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.
 
 ### `Battle`
 
-| Start   | End     | Data                    | Description                                             |
-| ------- | ------- | ----------------------- | ------------------------------------------------------- |
-| 0       | 184     | [`sides[0]`](#side)     | Player 1's side                                         |
-| 184     | 368     | [`sides[1]`](#side)     | Player 2's side                                         |
-| 368     | 370     | `turn`                  | The current turn number                                 |
-| 370     | 372     | `last_damage`           | The last damage dealt by either side                    |
-| 372     | 373-376 | `last_selected_indexes` | The slot index of the last selected moves for each side |
-| 373-376 | 384     | `rng`                   | The RNG state                                           |
+| Start   | End     | Data                | Description                                             |
+| ------- | ------- | ------------------- | ------------------------------------------------------- |
+| 0       | 184     | [`sides[0]`](#side) | Player 1's side                                         |
+| 184     | 368     | [`sides[1]`](#side) | Player 2's side                                         |
+| 368     | 370     | `turn`              | The current turn number                                 |
+| 370     | 372     | `last_damage`       | The last damage dealt by either side                    |
+| 372     | 374-376 | `last_moves`        | The slot index of the last selected moves for each side |
+| 374-376 | 384     | `rng`               | The RNG state                                           |
 
 - the current `turn` is 2 bytes, written in native-endianness
-- `last_selected_indexes` layout depends on whether or not Pokémon Showdown compatibility mode is
-  enabled (`-Dshowdown`). In either case it stores a move "slot", where 0 is used as an empty value and
-  1-4 represent actual moves:
-  - if `showdown` is enabled bytes 372 and 373 are used to store the last selected move index of
-    `side[0]` and bytes 374 and 375 store the last selected move index of `side[1]`
-  - otherwise byte 372 stores the last selected move index of `side[0]` in its first 4 bits and
-    `side[1]`'s in its second 4 bits
+- `last_moves` layout depends on whether or not Pokémon Showdown compatibility mode is enabled
+  (`-Dshowdown`). In either case it stores the last selected move index and last executed move for
+  each player (required to detect desyncs). In the case of the move index, 0 is used as an empty
+  value and 1-4 represent actual moves:
+  - if `showdown` is enabled byte 372 is used to store the last selected move index of `side[0]` and
+    byte 373 is used to store whether or not the side's last executed move would have been considered
+    "counterable"; and bytes 374 and 375 store the same information for `side[1]`
+  - otherwise the first 4 bits of byte 372 stores the last selected move index of `side[0]` and the
+    next 4 bits store whether that side's last executed move would have been considered
+    "counterable", with the same information for `side[1]`'s being stored in the second byte
 - the `rng` depends on whether or not Pokémon Showdown compatibility mode is enabled (`-Dshowdown`):
   - if `showdown` is enabled, the RNG state begins on byte 376 and consists of a 64-bit seed,
     written in native-endianness
-  - otherwise the RNG state begins on byte 373 and consists of the 10 bytes of the seed followed by
+  - otherwise the RNG state begins on byte 374 and consists of the 9 bytes of the seed followed by
     the index pointing to which byte of the seed is currently being used
 
 ### `Side`
@@ -467,7 +476,7 @@ Documentation of the wire protocol used for logging traces when `-Dtrace` is ena
 
 In addition to its alternative [RNG semantics](#rng), Pokémon Showdown's implementation of the first
 generation of Pokémon contains a number bugs, [many of which are known and have been documented on
-Smogon](https://www.smogon.com/forums/threads/rby-tradebacks-bug-report-thread.3524844/#post-5933177):
+Smogon](https://www.smogon.com/forums/posts/5933177/show):
 
 - moves on Pokémon Showdown can do 0 damage instead of failing or causing a [division-by-zero
   freeze](https://pkmn.cc/bulba-glitch-1#Division_by_0).
@@ -476,12 +485,21 @@ Smogon](https://www.smogon.com/forums/threads/rby-tradebacks-bug-report-thread.3
 - 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.
+  self-targeting move. Finally, Pokémon Showdown erroneously considers the *uncapped* self-hit
+  damage for the purposes of tracking the battle's last damage.
 
 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
 the pkmn engine, but the following moves have their broken behavior preserved in `-Dshowdown` mode:
 
+- **Bide**: Bide's damage can overflow if OHKO moves are involved because OHKO moves work by setting
+  the damage to 65535 - Pokémon Showdown doesn't implement this overflow and instead lets Bide's
+  damage grow unbounded. Additionally, 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. Additionally,
+  because Pokémon Showdown neglects to zero the last battle damage if a move misses due to immunity
+  or invulnerability Counter will occasionally work on Pokémon Showdown when it should fail.
 - **Leech Seed**: Leech Seed fails to heal its source side if a seeded target faints due to
   recoil/crash damage on Pokémon Showdown.
 - **Pay Day**: Pay Day should still scatter coins if it hits (but doesn't break) and opponent's
@@ -490,9 +508,17 @@ the pkmn engine, but the following moves have their broken behavior preserved in
   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).
+  then get "changed" and inserted back into the queue after their opponent's action). Pokémon
+  Showdown also implements accuracy incorrectly, as covered above.
 - **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
@@ -508,14 +534,21 @@ the pkmn engine, but the following moves have their broken behavior preserved in
   implement by Pokémon Showdown.
 - **Roar** / **Whirlwind**: these moves can miss on Pokémon Showdown (and advance the RNG when
   checking) which is incorrect (these moves should always fail, but do not check accuracy or advance
-  the RNG).
+  the RNG). More importantly, these moves should *not* cause the tracked last battle damage to be
+  zeroed, but on Pokémon Showdown they do.
 - **Substitute**: in addition to the [Substitute + Confusion
   glitch](https://pkmn.cc/bulba-glitch-1#Substitute_.2B_Confusion_glitch) not being implemented
   correctly (covered above), the [Substitute 1/4
   glitch](https://glitchcity.wiki/Substitute_%C2%BC_HP_glitch) also fails in many cases due to
   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).
+  maximum HP is evenly divisible by 4). 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. Finally, Pokémon Showdown uses a `subFainted` field to track whether a Substitute was
+  broken in order to know when to nullify a move's effect, only it doesn't get cleared at the end of
+  the turn and can result in incorrect behavior on subsequent turns with the moves Mirror Move and
+  Metronome that invoke `runMove` (which is where `subFainted` gets cleared) on the user but skips
+  calling it for the eventual true target.
 
 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
@@ -549,7 +582,7 @@ called out in the `|rule|` section at the beginning of a battle's log):
   `|rule|` section** in Generation I (or II) as the actual order of switches here does not have
   competitive implications like it does in Generation III, but it is still contrary to how the games
   work where the [host (Player 1)'s Pokemon would switch
-  first](https://www.smogon.com/forums/threads/gen-3-on-ps-final-fixes.3527268/post-5989318).
+  first](https://www.smogon.com/forums/posts/5989318/show).
 
 Pokémon Showdown enforces several clauses *before* the battle: **Cleric Clause** (all Pokémon must
 have full HP and PP, and not have any status conditions prior to the battle), **Stat Tradeback
@@ -570,13 +603,12 @@ left up to a client to support.
 
 Numerous moves on Pokémon Showdown are broken not simply due to local issues in the implementation
 of their effects but instead due to **global issues** related to fundamental mechanics such as
-[broken move
-selection](https://www.smogon.com/forums/threads/rby-fight-button-simulation-improvements-fix-partial-trapping-improve-counter.3673280/#post-8655897),
-using move name instead of slot to determine move identity, implementing volatile statuses
-incorrectly or not understanding how moves which call other moves work means that it isn't possible
-to completely implement Pokémon Showdown's behavior for the following moves (the pkmn engine
-attempts to reproduce as much of the behavior that can be reproduced without making data structure
-changes or dramatically deviating from the correct control flow):
+[broken move selection](https://www.smogon.com/forums/posts/8655897/show), using move name instead
+of slot to determine move identity, implementing volatile statuses incorrectly or not understanding
+how moves which call other moves work means that it isn't possible to completely implement Pokémon
+Showdown's behavior for the following moves (the pkmn engine attempts to reproduce as much of the
+behavior that can be reproduced without making data structure changes or dramatically deviating from
+the correct control flow):
 
 - **Wrap**: Binding moves like Wrap are implemented on Pokémon Showdown with an artificial
   `partialtrappinglock` volatile as opposed to how it works on the cartridge which simply relies on
@@ -586,9 +618,9 @@ changes or dramatically deviating from 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.
-- **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.
+  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.
 - **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
@@ -596,19 +628,27 @@ changes or dramatically deviating from the correct control flow):
   because Pokémon Showdown deducts PP based on a move's name instead of slot, if Mimic copies a move
   the Pokémon already knows, PP deduction for using either the original move of the mimicked move
   will instead deduct PP for whichever appears at the lower move slot index and the PP will be
-  allowed to go negative (effectively allowing for infinite PP use).
-- **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
+  allowed to go negative (effectively allowing for infinite PP use). Pokémon Showdown also doesn't
+  deduct PP from using Transform if it was copied by Mimic.
+- **Mirror Move**: As covered above, both Substitute and 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).
-- **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**:  Transform screws up the effect of Disable, because on Pokémon Showdown, Disable
+  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. Finally, if Mirror Move copies
+  Struggle it should not deduct PP but on Pokémon Showdown it does.
+- **Metronome**: In addition to the issues with binding moves and Substitute, 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**: 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
+  is not an issue with Disable + Mimic because Mimic happens to replace the same slot). Transform
+  also has a bad interaction with Pokémon Showdown's buggy Haze implementation, as Haze on Pokémon
+  Showdown does not copy unmodified stats, leaving the Transformed Pokémon with incorrect stats.
+  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.
 
@@ -627,7 +667,7 @@ the pkmn engine aims to be as compatible with Pokémon Showdown as possible when
 compatibility mode, the implications of these differences are outlined below:
 
 - **RNG**: Pokémon Showdown uses the RNG from Generation V & VI in every generation, despite
-  the seeds and algorithm being different. Pokémon Red uses a simple 8-bit RNG with 10 distinct
+  the seeds and algorithm being different. Pokémon Red uses a simple 8-bit RNG with 9 distinct
   seeds generated when the link connection is established, whereas Pokémon Showdown uses a 64-bit
   RNG with a 32-bit output.
 - **Algorithm**: As detailed in the table below, the algorithm used by Pokémon Showdown in the
@@ -662,13 +702,13 @@ compatibility mode, the implications of these differences are outlined below:
   when they are not relevant:
   - Roar / Whirlwind roll to hit and can "miss" as opposed to simply failing
 
-Finally, the **initial 10-byte seed for link battles on Pokémon Red cannot include bytes larger than
+Finally, the **initial 9-byte seed for link battles on Pokémon Red cannot include bytes larger than
 the `SERIAL_PREAMBLE_BYTE`**, so must be in the range $\left[0, 252\right]$. This has implications
-on the first 10 random numbers generated during the battle and has [**non-trivial competitive
-implications**](https://www.smogon.com/forums/threads/rby-tradebacks-bug-report-thread.3524844/page-16#post-9068411)
-(at the start of the battle move effects become more likely, the ["1/256-miss"
-glitch](https://glitchcity.wiki/1/256_miss_glitch) cannot happen, Player 1 is more likely to win
-speed ties, etc) that Pokémon Showdown cannot replicate due to everything described above.
+on the first 9 random numbers generated during the battle and has [**non-trivial competitive
+implications**](https://www.smogon.com/forums/posts/9068411/show) (at the start of the battle move
+effects become more likely, the ["1/256-miss" glitch](https://glitchcity.wiki/1/256_miss_glitch)
+cannot happen, Player 1 is more likely to win speed ties, etc) that Pokémon Showdown cannot
+replicate due to everything described above.
 
 All of places in the link battle code where randomness is required are outlined below:
 
@@ -688,7 +728,7 @@ All of places in the link battle code where randomness is required are outlined
 | **Paralysis** (full)     | `beforeMove`             | Trigger if $X < 63$                                                                                                                                                                                       |
 | **Poison** (chance)      | `Effects.poison`         | Trigger if $X < 52$ ($103$ for Smog / Sludge)                                                                                                                                                             |
 | **Sleep** (duration)     | `Effects.sleep`          | <dl><dt>Pokémon Red</dt><dd>Continue generating until $X \land 7 \neq 0$</dd><dt>Pokémon Showdown</dt><dd>Generate $X \in \left[1, 8\right)$</dd></dl>                                                    |
-| **Bide** (duration)      | `Effects.bide`           | <dl><dt>Pokémon Red</dt><dd>Last for $\left(X \land 1\right) + 2$ turns</dd><dt>Pokémon Showdown</dt><dd>Last for $X \in \left[2, 4\right)$ turns</dd></dl>                                           |
+| **Bide** (duration)      | `Effects.bide`           | <dl><dt>Pokémon Red</dt><dd>Last for $\left(X \land 1\right) + 2$ turns</dd><dt>Pokémon Showdown</dt><dd>Last for $X \in \left[2, 4\right)$ turns</dd></dl>                                               |
 | **Disable** (move)       | `Effects.disable`        | <dl><dt>Pokémon Red</dt><dd>Continue generating until $X \land 3$ is the index of a non-empty move slot</dd><dt>Pokémon Showdown</dt><dd>Generate $X \in \left[0, \|movesSlots\|\right)$</dd></dl>        |
 | **Disable** (duration)   | `Effects.disable`        | <dl><dt>Pokémon Red</dt><dd>Last for $\left(X \land 7\right) + 1$ turns</dd><dt>Pokémon Showdown</dt><dd>Last for $X \in \left[1, 9\right)$ turns</dd></dl>                                               |
 | **Metronome** (move)     | `metronome`              | <dl><dt>Pokémon Red</dt><dd>Continue generating until $X$ matches the index of a move which is not Struggle or Metronome</dd><dt>Pokémon Showdown</dt><dd>Generate $X \in \left[0, \|validMoves\|\right)$, where $validMoves$ is ordered set of moves with  Struggle and Metronome removed <i>(indexes of moves > Metronome will be shifted down)</i></dd></dl> |
@@ -696,7 +736,7 @@ All of places in the link battle code where randomness is required are outlined
 | **Psywave** (power)      | `specialDamage`          | <dl><dt>Pokémon Red</dt><dd>Continue generating until $X < {3\over2} \cdot level$</dd><dt>Pokémon Showdown</dt><dd>Generate $X \in \left[0, {3\over2} \cdot level\right)$</dd></dl>                       |
 | **Thrash** (rampage)     | `Effects.thrash`         | <dl><dt>Pokémon Red</dt><dd>Last for $\left(X \land 1\right) + 2$ turns</dd><dt>Pokémon Showdown</dt><dd>Last for $X \in \left[2, 4\right)$ turns</dd></dl>                                               |
 | **Thrash** (confusion)   | `beforeMove`             | <dl><dt>Pokémon Red</dt><dd>Last for $\left(X \land 3\right) + 2$ turns</dd><dt>Pokémon Showdown</dt><dd>Last for $X \in \left[2, 6\right)$ turns</dd></dl>                                               |
-| **Binding** (duration)   | `Effects.binding`        | <dl><dt>Pokémon Red</dt><dd>Last for $\left(X \land 3\right) + 1$ further turns if $\left(X \land 3\right) < 2$<br /> otherwise last for $\left(Y \land 3\right) + 1$ further turns (reroll)</dd><dt>Pokémon Showdown</dt><dd>Last for $X \in \{2, 2, 3, 3, 4, 5\} - 1$ further turns</dd></dl> |
+| **Binding** (duration)   | `Effects.binding`        | <dl><dt>Pokémon Red</dt><dd>Last for $\left(X \land 3\right) + 1$ further turns if $\left(X \land 3\right) < 2$<br /> otherwise last for $\left(Y \land 3\right) + 1$ further turns (reroll)</dd><dt>Pokémon Showdown</dt><dd>Last for $X \in \{2, 2, 2, 3, 3, 3, 4, 5 \} - 1$ further turns</dd></dl> |
 | **Multi-Hit** (hits)     | `Effects.multiHit`       | *Ibid.*                                                                                                                                                                                                   |
 | **Unboost** (chance)     | `Effects.unboost`        | Trigger if $X < 85$                                                                                                                                                                                       |
 
@@ -767,11 +807,8 @@ The pkmn engine attempts to adhere to certain naming conventions:
 ## Resources
 
 - [pret/pokered](https://github.com/pret/pokered/) disassembly
-- [Gen I Main Battle
-  Function](https://www.smogon.com/forums/threads/past-gens-research-thread.3506992/#post-5878612) -
-  Crystal_
+- [Gen I Main Battle Function](https://www.smogon.com/forums/posts/5878612/show) - Crystal_
 - [Pokemon Showdown!](https://github.com/smogon/pokemon-showdown)
 - [List of glitches (Generation
   I)](https://bulbapedia.bulbagarden.net/wiki/List_of_glitches_(Generation_I))
-- [Pokémon Showdown RBY
-  Bugs](https://www.smogon.com/forums/threads/rby-tradebacks-bug-report-thread.3524844/#post-5933177)
+- [Pokémon Showdown RBY Bugs](https://www.smogon.com/forums/posts/5933177/show)

package/src/lib/gen1/data/moves.zig

@@ -1602,44 +1602,44 @@ pub const Move = enum(u8) {
 
         /// Whether this effect activates during the "begin" step of move execution.
         pub inline fn onBegin(effect: Effect) bool {
-            return @enumToInt(effect) > 0 and @enumToInt(effect) <= 16;
+            return @intFromEnum(effect) > 0 and @intFromEnum(effect) <= 16;
         }
 
         /// Whether this effect lowers stats.
         pub inline fn isStatDown(effect: Effect) bool {
-            return @enumToInt(effect) > 16 and @enumToInt(effect) <= 21;
+            return @intFromEnum(effect) > 16 and @intFromEnum(effect) <= 21;
         }
 
         /// Whether this effect activates during the "end" step of move execution.
         pub inline fn onEnd(effect: Effect) bool {
-            return @enumToInt(effect) > 16 and @enumToInt(effect) <= 31;
+            return @intFromEnum(effect) > 16 and @intFromEnum(effect) <= 31;
         }
 
         /// Whether this effect is considered to "always happen".
         pub inline fn alwaysHappens(effect: Effect) bool {
-            return @enumToInt(effect) > 31 and @enumToInt(effect) <= 38;
+            return @intFromEnum(effect) > 31 and @intFromEnum(effect) <= 38;
         }
 
         /// Whether this effect is handled specially by the engine.
         pub inline fn isSpecial(effect: Effect) bool {
             // NB: isSpecial includes isMulti up to Twineedle
-            return @enumToInt(effect) > 31 and @enumToInt(effect) <= 46;
+            return @intFromEnum(effect) > 31 and @intFromEnum(effect) <= 46;
         }
 
         /// Whether this effect is a multi-hit effect.
         pub inline fn isMulti(effect: Effect) bool {
-            return @enumToInt(effect) > 44 and @enumToInt(effect) <= 47;
+            return @intFromEnum(effect) > 44 and @intFromEnum(effect) <= 47;
         }
 
         /// Whether this effect is has chance of lowering stats.
         pub inline fn isStatDownChance(effect: Effect) bool {
-            return @enumToInt(effect) > 47 and @enumToInt(effect) <= 51;
+            return @intFromEnum(effect) > 47 and @intFromEnum(effect) <= 51;
         }
 
         /// Whether this effect has a secondary chance.
         pub inline fn isSecondaryChance(effect: Effect) bool {
             // NB: isSecondaryChance includes isStatDownChance as well as Twineedle
-            return (@enumToInt(effect) > 46 and @enumToInt(effect) <= 61);
+            return (@intFromEnum(effect) > 46 and @intFromEnum(effect) <= 61);
         }
     };
 
@@ -1843,12 +1843,12 @@ pub const Move = enum(u8) {
     /// Returns the `Data` corresponding to the move.
     pub inline fn get(id: Move) Data {
         assert(id != .None and id != .SKIP_TURN);
-        return DATA[@enumToInt(id) - 1];
+        return DATA[@intFromEnum(id) - 1];
     }
 
     /// Returns the base PP of the move.
     pub fn pp(id: Move) u8 {
         assert(id != .None);
-        return PP[@enumToInt(id) - 1];
+        return PP[@intFromEnum(id) - 1];
     }
 };

package/src/lib/gen1/data/species.zig

@@ -1094,12 +1094,12 @@ pub const Species = enum(u8) {
     /// The Pokémon's critical hit rate=io out of 256.
     pub inline fn chance(id: Species) u8 {
         assert(id != .None);
-        return CHANCES[@enumToInt(id) - 1];
+        return CHANCES[@intFromEnum(id) - 1];
     }
 
     /// Returns the `Data` corresponding to the species.
     pub fn get(id: Species) Data {
         assert(id != .None);
-        return DATA[@enumToInt(id) - 1];
+        return DATA[@intFromEnum(id) - 1];
     }
 };

package/src/lib/gen1/data/types.zig

@@ -91,18 +91,18 @@ pub const Type = enum(u4) {
 
     /// Whether or not this type is considered to be special as opposed to physical.
     pub inline fn special(self: Type) bool {
-        return @enumToInt(self) >= @enumToInt(Type.Fire);
+        return @intFromEnum(self) >= @intFromEnum(Type.Fire);
     }
 
     /// The `Effectiveness` of type `t2` vs. type `t1`.
     pub inline fn effectiveness(t1: Type, t2: Type) Effectiveness {
-        return CHART[@enumToInt(t1)][@enumToInt(t2)];
+        return CHART[@intFromEnum(t1)][@intFromEnum(t2)];
     }
 
     /// The precedence order of type `t2` vs. type  `t1`.
     pub fn precedence(t1: Type, t2: Type) u8 {
         for (PRECEDENCE, 0..) |matchup, i| {
-            if (matchup.type1 == t1 and matchup.type2 == t2) return @intCast(u8, i);
+            if (matchup.type1 == t1 and matchup.type2 == t2) return @intCast(i);
         }
         unreachable;
     }