@pkmn/engine 0.1.0-dev.2c13d3ec → 0.1.0-dev.305a932f

package/src/lib/gen1/mechanics.zig

@@ -62,10 +62,6 @@ const MAX_STAT_VALUE = 999;
 const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
 
 pub fn update(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Result {
-    // FIXME
-    // std.debug.print("\n", .{});
-    // DEBUG(battle.turn);
-    // std.debug.print("// ", .{});
     assert(c1.type != .Pass or c2.type != .Pass or battle.turn == 0);
     if (battle.turn == 0) return start(battle, options);
 
@@ -186,10 +182,7 @@ fn selectMove(
             assert(choice.data == 0);
             // GLITCH: https://glitchcity.wiki/Partial_trapping_move_Mirror_Move_link_battle_glitch
             if (foe_choice.type == .Switch) {
-                const last = side.active.move(if (player == .P1)
-                    battle.last_moves.p1_index
-                else
-                    battle.last_moves.p2_index);
+                const last = side.active.move(battle.lastMove(player).index);
                 if (last.id == .Metronome) side.last_selected_move = last.id;
                 if (last.id == .MirrorMove) return Result.Error;
             }
@@ -217,12 +210,9 @@ fn selectMove(
             }
             break :ok true;
         };
-
         assert(struggle);
-        saveMove(battle, player, choice);
-    } else {
-        saveMove(battle, player, choice);
     }
+    saveMove(battle, player, choice);
 
     return null;
 }
@@ -242,11 +232,7 @@ fn saveMove(battle: anytype, player: Player, choice: ?Choice) void {
             assert(showdown or move.pp != 0);
 
             side.last_selected_move = move.id;
-            if (player == .P1) {
-                battle.last_moves.p1_index = @intCast(c.data);
-            } else {
-                battle.last_moves.p2_index = @intCast(c.data);
-            }
+            battle.lastMove(player).index = @intCast(c.data);
         }
     }
 }
@@ -264,11 +250,7 @@ fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, options: a
     side.order[0] = side.order[slot - 1];
     side.order[slot - 1] = out;
 
-    if (player == .P1) {
-        battle.last_moves.p1_index = 1;
-    } else {
-        battle.last_moves.p2_index = 1;
-    }
+    battle.lastMove(player).index = 1;
 
     side.last_used_move = .None;
     foe.last_used_move = .None;
@@ -455,10 +437,7 @@ fn executeMove(
     if (mslot == 0 and side.last_selected_move != .None and side.last_selected_move != .Struggle) {
         // choice.data == 0 only happens with Struggle on Pokémon Showdown
         assert(!showdown);
-        mslot = @intCast(if (player == .P1)
-            battle.last_moves.p1_index
-        else
-            battle.last_moves.p2_index);
+        mslot = @intCast(battle.lastMove(player).index);
         const stored = side.stored();
         // GLITCH: Struggle bypass PP underflow via Hyper Beam / Trapping-switch auto selection
         auto = side.last_selected_move == .HyperBeam or side.active.volatiles.Bide or
@@ -479,10 +458,7 @@ fn executeMove(
     } else if (showdown and side.active.volatiles.Charging) {
         // Incorrect mslot with Pokémon Showdown choice semantics so we need to recover from index
         assert(mslot == 1);
-        mslot = @intCast(if (player == .P1)
-            battle.last_moves.p1_index
-        else
-            battle.last_moves.p2_index);
+        mslot = @intCast(battle.lastMove(player).index);
     }
 
     var skip_can = false;
@@ -834,11 +810,7 @@ fn setCounterable(battle: anytype, player: Player, side: *Side, move: Move.Data)
     // as the desync results from actually having two separate battle states that subtly disagree
     const counterable = side.last_selected_move != .Counter and move.bp > 0 and
         (move.type == .Normal or move.type == .Fighting);
-    if (player == .P1) {
-        battle.last_moves.p1_counterable = @intFromBool(counterable);
-    } else {
-        battle.last_moves.p2_counterable = @intFromBool(counterable);
-    }
+    battle.lastMove(player).counterable = @intFromBool(counterable);
 }
 
 fn decrementPP(side: *Side, mslot: u4, auto: bool) void {
@@ -1278,11 +1250,7 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
     else
         foe.last_selected_move);
 
-    const used = (if (player.foe() == .P1)
-        battle.last_moves.p1_counterable
-    else
-        battle.last_moves.p2_counterable) != 0;
-
+    const used = battle.lastMove(player.foe()).counterable != 0;
     const selected = foe_last_selected_move.bp > 0 and
         foe.last_selected_move != .Counter and
         (foe_last_selected_move.type == .Normal or
@@ -1357,7 +1325,7 @@ fn mirrorMove(
     auto: bool,
     residual: *bool,
     options: anytype,
-) !?Result {
+) anyerror!?Result {
     var side = battle.side(player);
     const foe = battle.foe(player);
 
@@ -1384,7 +1352,7 @@ fn metronome(
     auto: bool,
     residual: *bool,
     options: anytype,
-) !?Result {
+) anyerror!?Result {
     var side = battle.side(player);
 
     side.last_selected_move = try Rolls.metronome(battle, player, options);
@@ -1463,7 +1431,7 @@ fn moveHit(
         const overwritten = overwrite and state > 0;
         assert(!overwritten or (0 < state and state <= 255 and !side.active.volatiles.Bide));
 
-        var accuracy = if (overwritten) state else @as(u16, Gen12.percent(move.accuracy));
+        var accuracy = if (overwritten) state else @as(u16, move.accuracy);
         var boost = BOOSTS[@as(u4, @intCast(@as(i8, side.active.boosts.accuracy) + 6))];
         accuracy = accuracy * boost[0] / boost[1];
         boost = BOOSTS[@as(u4, @intCast(@as(i8, -foe.active.boosts.evasion) + 6))];
@@ -1524,8 +1492,8 @@ fn checkFaint(
     }
 
     const foe_choice: Choice.Type = if (foe_fainted) .Switch else .Pass;
-    if (player == .P1) return Result{ .p1 = .Switch, .p2 = foe_choice };
-    return Result{ .p1 = foe_choice, .p2 = .Switch };
+    if (player == .P1) return .{ .p1 = .Switch, .p2 = foe_choice };
+    return .{ .p1 = foe_choice, .p2 = .Switch };
 }
 
 fn faint(battle: anytype, player: Player, done: bool, options: anytype) !?Result {
@@ -1573,21 +1541,19 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !void {
     var volatiles = &side.active.volatiles;
 
     const brn = Status.is(stored.status, .BRN);
-    if (brn or Status.is(stored.status, .PSN)) blk: {
+    if (brn or Status.is(stored.status, .PSN)) {
         var damage = @max(stored.stats.hp / 16, 1);
-
         if (volatiles.Toxic) {
             volatiles.toxic += 1;
             damage *= volatiles.toxic;
         }
+        damage = @min(damage, stored.hp);
 
-        const amount = @min(damage, stored.hp);
-        if (showdown and amount == 0) break :blk;
-
-        stored.hp -= amount;
-
-        // Pokémon Showdown uses damageOf here but its not relevant in Generation I
-        try options.log.damage(ident, stored, if (brn) Damage.Burn else Damage.Poison);
+        if (!showdown or damage > 0) {
+            stored.hp -= damage;
+            // Pokémon Showdown uses damageOf here but its not relevant in Generation I
+            try options.log.damage(ident, stored, if (brn) Damage.Burn else Damage.Poison);
+        }
     }
 
     if (volatiles.LeechSeed) {
@@ -2420,12 +2386,17 @@ pub const Effects = struct {
     }
 
     fn switchAndTeleport(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        if (!showdown or battle.side(player).last_selected_move == .Teleport) return;
-
         // Whirlwind/Roar should not roll to hit/reset damage but Pokémon Showdown does anyway
-        if (try checkHit(battle, player, move, options)) try options.chance.commit(player, .hit);
-
-        battle.last_damage = 0;
+        if (showdown) {
+            if (battle.side(player).last_selected_move == .Teleport) return;
+            if (try checkHit(battle, player, move, options)) {
+                try options.chance.commit(player, .hit);
+            }
+            battle.last_damage = 0;
+        } else {
+            try options.log.fail(battle.active(player), .None);
+            try options.log.laststill();
+        }
     }
 
     fn thrashing(battle: anytype, player: Player, options: anytype) void {
@@ -2705,7 +2676,7 @@ fn statusModify(status: u8, stats: *Stats(u16)) void {
     }
 }
 
-inline fn isForced(active: ActivePokemon) bool {
+inline fn isForced(active: anytype) bool {
     return active.volatiles.Recharging or active.volatiles.Rage or
         active.volatiles.Thrashing or active.volatiles.Charging;
 }
@@ -2730,15 +2701,15 @@ fn clearVolatiles(battle: anytype, who: Player, clear: bool, options: anytype) !
     }
     if (volatiles.Mist) {
         volatiles.Mist = false;
-        try log.end(ident, .Mist);
+        try log.end(ident, .MistSilent);
     }
     if (volatiles.FocusEnergy) {
         volatiles.FocusEnergy = false;
-        try log.end(ident, .FocusEnergy);
+        try log.end(ident, .FocusEnergySilent);
     }
     if (volatiles.LeechSeed) {
         volatiles.LeechSeed = false;
-        try log.end(ident, .LeechSeed);
+        try log.end(ident, .LeechSeedSilent);
     }
     if (!showdown and volatiles.Toxic) {
         volatiles.Toxic = false;
@@ -2746,17 +2717,17 @@ fn clearVolatiles(battle: anytype, who: Player, clear: bool, options: anytype) !
     }
     if (volatiles.LightScreen) {
         volatiles.LightScreen = false;
-        try log.end(ident, .LightScreen);
+        try log.end(ident, .LightScreenSilent);
     }
     if (volatiles.Reflect) {
         volatiles.Reflect = false;
-        try log.end(ident, .Reflect);
+        try log.end(ident, .ReflectSilent);
     }
     if (showdown and volatiles.Toxic) {
         volatiles.Toxic = false;
         // Pokémon Showdown erroneously clears the toxic counter
         volatiles.toxic = 0;
-        try log.end(ident, .Toxic);
+        try log.end(ident, .ToxicSilent);
     }
 }
 
@@ -2796,6 +2767,7 @@ pub const Rolls = struct {
             }
         };
 
+        assert(roll >= 217 and roll <= 255);
         try options.chance.damage(player, roll);
         return roll;
     }
@@ -2920,6 +2892,7 @@ pub const Rolls = struct {
             }
         };
 
+        assert(power < max);
         try options.chance.psywave(player, power, max);
         return power;
     }
@@ -2936,6 +2909,7 @@ pub const Rolls = struct {
             }
         };
 
+        assert(duration >= 1 and duration <= 7);
         options.chance.duration(.sleep, player, player.foe(), duration);
         return duration;
     }
@@ -2948,6 +2922,7 @@ pub const Rolls = struct {
         else
             @intCast((battle.rng.next() & 7) + 1);
 
+        assert(duration >= 1 and duration <= 8);
         options.chance.duration(.disable, player, player.foe(), duration);
         return duration;
     }
@@ -2960,6 +2935,7 @@ pub const Rolls = struct {
         else
             @intCast((battle.rng.next() & 3) + 2);
 
+        assert(duration >= 2 and duration <= 5);
         options.chance.duration(.confusion, player, if (self) player else player.foe(), duration);
         return duration;
     }
@@ -2972,6 +2948,7 @@ pub const Rolls = struct {
         else
             @intCast((battle.rng.next() & 1) + 2);
 
+        assert(duration >= 2 and duration <= 3);
         options.chance.duration(.attacking, player, player, duration);
         return duration;
     }
@@ -2992,6 +2969,7 @@ pub const Rolls = struct {
             break :n @intCast((if (r < 2) r else battle.rng.next() & 3) + 2);
         };
 
+        assert(n >= 2 and n <= 5);
         if (effect == .Binding) {
             options.chance.duration(.binding, player, player, n);
         } else {
@@ -3057,11 +3035,11 @@ test "RNG agreement" {
         expected[i] = @intCast(i * 0x1000000);
     }
 
-    var spe = rng.FixedRNG(1, expected.len){ .rolls = expected };
-    var cfz = rng.FixedRNG(1, expected.len){ .rolls = expected };
-    var par = rng.FixedRNG(1, expected.len){ .rolls = expected };
-    var brn = rng.FixedRNG(1, expected.len){ .rolls = expected };
-    var eff = rng.FixedRNG(1, expected.len){ .rolls = expected };
+    var spe: rng.FixedRNG(1, expected.len) = .{ .rolls = expected };
+    var cfz: rng.FixedRNG(1, expected.len) = .{ .rolls = expected };
+    var par: rng.FixedRNG(1, expected.len) = .{ .rolls = expected };
+    var brn: rng.FixedRNG(1, expected.len) = .{ .rolls = expected };
+    var eff: rng.FixedRNG(1, expected.len) = .{ .rolls = expected };
 
     for (0..expected.len) |i| {
         try expectEqual(spe.range(u8, 0, 2) == 0, i < Gen12.percent(50) + 1);
@@ -3097,7 +3075,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             const side = battle.side(player);
             const foe = battle.foe(player);
 
-            var active = side.active;
+            var active = &side.active;
             const stored = side.stored();
 
             // While players are not given any input options on the cartridge in these cases,

package/src/lib/gen2/README.md

@@ -32,35 +32,36 @@ The following information is required to simulate a Generation II Pokémon battl
 | `pokemon.species`              | `party_struct.Species`            | `pokemon.baseSpecies`                 |
 | `active.species`               | `battle_struct.Species`           | `pokemon.species`                     |
 | `active.stats`                 | `TODO modified`                   | `pokemon.storedStats`                 |
-| `active.trapped FIXME`         | `PlayerTrappingMove`              | `pokemon.trapped`                     |
-| `active.switching`             | `PlayerIsSwitching`               | `pokemon.switchFlag`                  |
 | `active.boosts`                | `PlayerStatLevels`                | `pokemon.boosts`                      |
 | `active.volatiles`             | `PlayerBattleStatus{1,2,3}`       | `pokemon.volatiles`                   |
-| `volatiles.data.bide`          | `PlayerDamageTaken`               | `volatiles.bide.totalDamage`          |
-| `volatiles.data.substitute`    | `PlayerSubstituteHP`              | `volatiles.substitute.hp`             |
-| `volatiles.data.rollout`       | `PlayerRolloutCount`              | `volatiles.rollout.hitCount`          |
-| `volatiles.data.confusion`     | `PlayerConfuseCount`              | `volatiles.confusion.duration`        |
-| `volatiles.data.toxic`         | `PlayerToxicCount`                | `volatiles.residualdmg.counter`       |
-| `volatiles.data.disabled`      | `PlayerDisableCount`              | `moveSlots.disabled`                  |
-| `volatiles.data.encore`        | `PlayerEncoreCount`               | `volatiles.encore.duration`           |
-| `volatiles.data.perish_song`   | `PlayerPerishCount`               | `volatiles.perishsong.duration`       |
-| `volatiles.data.fury_cutter`   | `PlayerFuryCutterCount`           | `volatiles.furycutter.multiplier`     |
-| `volatiles.data.protect`       | `PlayerProtectCount`              | `volatiles.stall.counter`             |
-| `volatiles.data.future_sight`  | `PlayerFutureSight{Damage,Count}` | `slotConditions[i].futuremove`        |
-| `volatiles.data.rage`          | `PlayerRageCounter`               | **BUG**                               |
-| `volatiles.data.bind`          | `PlayerWrapCount`                 | `volatiles.partiallytrapped.duration` |
+| `volatiles.bide`               | `PlayerDamageTaken`               | `volatiles.bide.totalDamage`          |
+| `volatiles.substitute`         | `PlayerSubstituteHP`              | `volatiles.substitute.hp`             |
+| `volatiles.rollout`            | `PlayerRolloutCount`              | `volatiles.rollout.hitCount`          |
+| `volatiles.confusion`          | `PlayerConfuseCount`              | `volatiles.confusion.duration`        |
+| `volatiles.toxic`              | `PlayerToxicCount`                | `volatiles.residualdmg.counter`       |
+| `volatiles.disabled`           | `PlayerDisableCount`              | `moveSlots.disabled`                  |
+| `volatiles.encore`             | `PlayerEncoreCount`               | `volatiles.encore.duration`           |
+| `volatiles.perish_song`        | `PlayerPerishCount`               | `volatiles.perishsong.duration`       |
+| `volatiles.fury_cutter`        | `PlayerFuryCutterCount`           | `volatiles.furycutter.multiplier`     |
+| `volatiles.protect`            | `PlayerProtectCount`              | `volatiles.stall.counter`             |
+| `volatiles.future_sight`       | `PlayerFutureSight{Damage,Count}` | `slotConditions[i].futuremove`        |
+| `volatiles.rage`               | `PlayerRageCounter`               | **BUG**                               |
+| `volatiles.bind`               | `PlayerWrapCount`                 | `volatiles.partiallytrapped.duration` |
+| `volatiles.bind_reason`        | `PlayerTrappingMove`              | `volatiles.effectState.sourceEffect`  |
 |                                | `PlayerCharging`                  |                                       |
-|                                | `PlayerJustGotFrozen`             |                                       |
+| `volatiles.trapped FIXME`      | `FIXME`                           | `pokemon.trapped`                     |
+| `volatiles.switched`           | `TODO`                            | `pokemon.switchFlag`                  |
+| `volatiles.switching`          | `PlayerIsSwitching`               | `pokemon.switchFlag`                  |
+| `volatiles.frozen`             | `PlayerJustGotFrozen`             | `volatiles.frozen`                    |
 |                                |                                   |                                       |
 | `active.last_used_move`        | `PlayerUsedMove`                  | `side.lastMove`                       |
 
-- Pokémon Showdown does not implement the correct Generation II RNG and as such its `seed` is
+- Pokémon Showdown doesn't implement the correct Generation II RNG and as such its `seed` is
   different
-- `battle.turn` only needs to be tracked in order to be compatible with the Pokémon Showdown
-  protocol
+- `battle.turn` only needs to be tracked to be compatible with the Pokémon Showdown protocol
 - Battle results (win, lose, draw) or request states are communicated via the return code of
   `Battle.update`
-- Nicknames (`BattleMonNick`/`pokemon.name`) are not handled by the pkmn engine as they are expected
+- Nicknames (`BattleMonNick`/`pokemon.name`) aren't handled by the pkmn engine as they're expected
   to be handled by driver code if required
 
 ==**TODO**==
@@ -77,9 +78,9 @@ between the data structure for the "active" Pokémon and its party members (see
 
 ### `Pokemon` / `ActivePokemon`
 
-Similar to the cartridge, in order to save space different information is stored depending on
-whether a [Pokémon](https://pkmn.cc/bulba/Pok%c3%a9mon_data_structure_%28Generation_II%29) is
-actively participating in battle vs. is switched out (pret's [`battle_struct` vs.
+Similar to the cartridge, to save space different information is stored depending on whether a
+[Pokémon](https://pkmn.cc/bulba/Pok%c3%a9mon_data_structure_%28Generation_II%29) is actively
+participating in battle vs. is switched out (pret's [`battle_struct` vs.
 `party_struct`](https://pkmn.cc/pokecrystal/macros/ram.asm)). In Pokémon Showdown, all the Pokemon
 are represented by the same
 [`Pokemon`](https://github.com/smogon/pokemon-showdown/blob/master/sim/pokemon.ts) class, and static
@@ -93,14 +94,14 @@ A `MoveSlot` is a data-type for a `(move, current pp)` pair. A pared down versio
 Showdown's `Pokemon#moveSlot`, it also stores data from the cartridge's `battle_struct::Move` macro
 and can be used to replace the `PlayerMove*` data. Move PP is stored as a full byte instead of how
 the cartridge (`battle_struct::PP`) stores it (6 bits for current PP and the remaining 2 bits used
-to store the number of applied PP Ups). PP Up bits do not actually need to be stored on move slot
+to store the number of applied PP Ups). PP Up bits don't actually need to be stored on move slot
 as max PP is never relevant in Generation II (the Mystery Berry always increases PP from 0 -> 5).
 
 #### `Status`
 
 Bitfield representation of a Pokémon's major [status
-condition](https://pkmn.cc/bulba/Status_condition), mirroring how it is stored on the cartridge. A
-value of `0x00` means that the Pokémon is not affected by any major status, otherwise the lower 3
+condition](https://pkmn.cc/bulba/Status_condition), mirroring how it's stored on the cartridge. A
+value of `0x00` means that the Pokémon isn't affected by any major status, otherwise the lower 3
 bits represent the remaining duration for Sleep. Other status are denoted by the presence of
 individual bits - at most one status should be set at any given time.
 
@@ -161,7 +162,7 @@ boosts should always range from `-6`...`6` instead of `1`...`13` as on the cartr
 
 `Moves` serves as an identifier for a unique [Pokémon move](https://pkmn.cc/bulba/Move) that can be
 used to retrieve a `Move` with information regarding base power, accuracy and type. As covered
-above, PP information isn't strictly necessary in Generation I, but fits neatly into the 4 bits of
+earlier, PP information isn't strictly necessary in Generation I, but fits neatly into the 4 bits of
 padding after noticing that all PP values are multiples of 5. `Moves.None` exists as a special
 sentinel value to indicate `null`.
 
@@ -215,11 +216,86 @@ entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory))) is as foll
 | **wrap**       | 0...5   | 3    |     | **perish song**   | 0...4    | 3    |
 | **item**       | TODO    | 5?   |     | **gender**        | 0..1     | 1    |
 
-From this we can determine the minimum bits required to store each data structure to determine how
-much overhead the representations above have after taking into consideration [alignment &
+From this one can determine the minimum bits required to store each data structure to determine how
+much overhead the preceding representations have after taking into consideration [alignment &
 padding](https://en.wikipedia.org/wiki/Data_structure_alignment) and
 [denormalization](https://en.wikipedia.org/wiki/Denormalization):
 
+## Details
+
+| pkmn                      | Pokémon Crystal (pret)                            |
+| ------------------------- | ------------------------------------------------- |
+| `start`                   | `DoBattle`                                        |
+| `update`                  | `BattleTurn`                                      |
+| `selectMove` / `saveMove` | `CheckPlayerLockedIn` / `ParsePlayerAction`       |
+| `switchIn`                | `SwitchPlayerMon` / `SendOutPlayerMon`            |
+| `turnOrder`               | `DetermineMoveOrder`                              |
+| `doTurn`                  | `DoTurn`                                          |
+| `executeMove`             | `DoMove`                                          |
+| `beforeMove`              | `CheckTurn`                                       |
+| `canMove`                 |                                                   |
+| `decrementPP`             |                                                   |
+| `doMove`                  |                                                   |
+| `checkCriticalHit`        | `BattleCommand_Critical`                          |
+| `calcDamage`              | `BattleCommand_DamageCalc` / `PlayerAttackDamage` |
+| `adjustDamage`            | `BattleCommand_Stab`                              |
+| `randomizeDamage`         | `BattleCommand_DamageVariation`                   |
+| `specialDamage`           | `BattleCommand_ConstantDamage`                    |
+| `applyDamage`             | `BattleCommand_ApplyDamage`                       |
+| `checkHit`                | `BattleCommand_CheckHit`                          |
+| `checkFaint`              | `CheckFaint`                                      |
+| `handleResidual`          | `ResidualDamage`                                  |
+| `endTurn`                 | `EndTurn`                                         |
+
+DoBattle
+BattleTurn
+- HandleBerserkGene
+- CheckPlayerLockedIn
+- BattleMenu
+- ParsePlayerAction
+- DetermineMoveOrder
+  - CompareMovePriority
+  - GetMovePriority
+- Battle_*
+  - Handle*Switch
+    - SwitchPlayerMon
+      - BreakAttraction
+      - SendOutPlayerMon
+    - SpikesDamage
+  - *Turn_EndOpponentProtectEndureDestinyBond
+    - EndUserDestinyBond
+    - Do*Turn
+    - EndOpponentProtectEndureDestinyBond
+  - ResidualDamage
+  - CheckFaint_*
+  - HandleBetweenTurnEffects
+    - HandleFutureSight
+    - HandleWeather
+    - HandleWrap
+    - HandlePerishSong
+    - HandleLeftovers
+    - HandleMysteryBerry
+    - HandleDefrost
+    - HandleSafeguard
+    - HandleScreens
+    - HandleStatBoostingHeldItems
+    - HandleHealingItems
+    - HandleEncore
+
+DoTurn
+DoMove = executeMove
+CheckTurn = beforeMove
+BattleCommand_Critical = checkCriticalHit
+BattleCommand_Stab = adjustDamage
+BattleCommand_DamageVariation = randomizeDamage
+BattleCommand_CheckHit = checkHit
+BattleCommand_ApplyDamage = applyDamage
+BattleCommand_CheckFaint
+BattleCommand_BuildOpponentRage = buildRage
+BattleCommand_DamageCalc (PlayerAttackDamage / EnemyAttackDamage) = calcDamage
+BattleCommand_ConstantDamage = specialDamage
+DoEnemyDamage / DoPlayerDamage / DoSubstituteDamage
+
 ==**TODO**==
 
 ## Protocol
@@ -227,62 +303,7 @@ padding](https://en.wikipedia.org/wiki/Data_structure_alignment) and
 TODO
 
 ```txt
--activate: _, damage, move, name, number, of
--anim: _
--block: _
--boost: _, from, silent
--clearallboost: _
--copyboost: from
--crit: _
--curestatus: msg
--cureteam: from
--damage: _, from, of, partiallytrapped
--end: _, from, of, partiallytrapped, silent
--enditem: _, eat
--fail: _, block, weak
--fieldactivate: _
--heal: _, from, of, silent
--hint: _
--hitcount: _
--immune: _, ohko
--item: from, of
--miss: _
--mustrecharge: _
--ohko: _
--prepare: _
--resisted: _
--setboost: from
--sethp: from, silent
--sideend: _, from, of
--sidestart: _
--singlemove: _
--singleturn: _
--start: _, of, silent
--status: _, from, silent
--supereffective: _
--transform: _
--unboost: _
--weather: _, upkeep
-cant: _
-debug: _
-done: _
-drag: _
-faint: _
-gametype: _
-gen: _
-move: _, from, miss, still
-player: _
-request: _
-rule: _
-start: _
-switch: _, from
-t:: _
-teamsize: _
-tie: _
-tier: _
-turn: _
-upkeep: _
-win: _
+-activate: _,  move, name, number
 ```
 
 ## Bugs

package/src/lib/gen2/data/items.zig

@@ -11,15 +11,15 @@ const Type = data.Type;
 /// Representation of a held item in Generation II Pokémon.
 pub const Item = enum(u8) {
     None,
+    SoftSand, // Ground
+    HardStone, // Rock
+    MetalCoat, // Steel
     PinkBow, // Normal
     BlackBelt, // Fighting
     SharpBeak, // Flying
     PoisonBarb, // Poison
-    SoftSand, // Ground
-    HardStone, // Rock
     SilverPowder, // Bug
     SpellTag, // Ghost
-    MetalCoat, // Steel
     PolkadotBow, // ??? (Normal)
     Charcoal, // Fire
     MysticWater, // Water
@@ -36,21 +36,21 @@ pub const Item = enum(u8) {
     Stick,
     ThickClub,
     FocusBand, // FocusBand
-    BerryJuice, // Berry
     ScopeLens, // CriticalUp
     Leftovers, // Leftovers
     BerserkGene,
     LightBall,
+    Berry, // Berry
+    BerryJuice, // Berry
+    GoldBerry, // Berry
+    MintBerry, // HealSleep
     PSNCureBerry, // HealPoison
     PRZCureBerry, // HealParalyze
-    BurntBerry, // HealFreeze
     IceBerry, // HealBurn
-    BitterBerry, // HealConfusion
-    MintBerry, // HealSleep
+    BurntBerry, // HealFreeze
     MiracleBerry, // HealStatus
+    BitterBerry, // HealConfusion
     MysteryBerry, // RestorePP
-    Berry, // Berry
-    GoldBerry, // Berry
     MasterBall,
     UltraBall,
     GreatBall,
@@ -222,14 +222,8 @@ pub const Item = enum(u8) {
         return if (@intFromEnum(item) <= 18) @enumFromInt(@intFromEnum(item) - 1) else null;
     }
 
-    /// Whether or not this item is a Berry.
-    pub inline fn berry(item: Item) bool {
-        assert(item != .None);
-        return @intFromEnum(item) > 30 and @intFromEnum(item) <= 40;
-    }
-
     /// Whether or not this item is Mail.
-    pub inline fn mail(item: Item) bool {
+    pub inline fn isMail(item: Item) bool {
         assert(item != .None);
         return @intFromEnum(item) > 60 and @intFromEnum(item) <= 70;
     }