@pkmn/engine 0.1.0-dev.46307385 → 0.1.0-dev.4c173f03

package/src/lib/gen2/README.md

@@ -32,25 +32,27 @@ 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.disable`            | `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`                       |
 
@@ -219,6 +221,81 @@ much overhead the preceding representations have after taking into consideration
 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
@@ -226,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/calc.zig

@@ -0,0 +1,143 @@
+const std = @import("std");
+
+const pkmn = @import("../pkmn.zig");
+
+const common = @import("../common/data.zig");
+const util = @import("../common/util.zig");
+
+const chance = @import("chance.zig");
+
+const assert = std.debug.assert;
+
+const enabled = pkmn.options.calc;
+
+const Player = common.Player;
+
+const PointerType = util.PointerType;
+
+const Actions = chance.Actions;
+const Action = chance.Action;
+
+/// Information relevant to damage calculation that occured during a Generation II battle `update`.
+pub const Summaries = extern struct {
+    /// Relevant information for Player 1.
+    p1: Summary = .{},
+    /// Relevant information for Player 2.
+    p2: Summary = .{},
+
+    comptime {
+        assert(@sizeOf(Summaries) == 12);
+    }
+
+    /// Returns the `Summary` for the given `player`.
+    pub inline fn get(self: anytype, player: Player) PointerType(@TypeOf(self), Summary) {
+        assert(@typeInfo(@TypeOf(self)).Pointer.child == Summaries);
+        return if (player == .P1) &self.p1 else &self.p2;
+    }
+};
+
+/// Information relevant to damage calculation that occured during a Generation II battle `update`
+/// for a single player.
+pub const Summary = extern struct {
+    /// The computed raw damage values.
+    damage: Damage = .{},
+
+    /// Intermediate raw damage values computed during a calculation.
+    pub const Damage = extern struct {
+        /// The base computed damage before the damage roll is applied.
+        base: u16 = 0,
+        /// The final computed damage that gets applied to the Pokémon. May exceed the target's HP
+        // (to determine the *actual* damage done compare the target's stored HP before and after).
+        final: u16 = 0,
+        /// Whether higher damage will saturate / result in the same outcome (e.g. additional damage
+        /// gets ignored due to it already breaking a Substitute or causing the target to faint).
+        capped: bool = false,
+
+        // NOTE: 15 bits padding
+
+        comptime {
+            assert(@sizeOf(Damage) == 6);
+        }
+    };
+
+    comptime {
+        assert(@sizeOf(Summary) == 6);
+    }
+};
+
+/// TODO
+pub const Overrides = extern struct {
+    /// TODO
+    actions: Actions = .{},
+};
+
+/// Allows for forcing the value of specific RNG events during a Generation II battle `update` via
+/// `overrides` and tracks `summaries` of information relevant to damage calculation.
+pub const Calc = struct {
+    /// Overrides the normal behavior of the RNG during an `update` to force specific outcomes.
+    overrides: Overrides = .{},
+    /// Information relevant to damage calculation.
+    summaries: Summaries = .{},
+
+    pub fn overridden(
+        self: Calc,
+        player: Player,
+        comptime field: Action.Field,
+    ) ?std.meta.FieldType(Action, field) {
+        if (!enabled) return null;
+
+        const overrides =
+            if (player == .P1) self.overrides.actions.p1 else self.overrides.actions.p2;
+        const val = @field(overrides, @tagName(field));
+        return if (switch (@typeInfo(@TypeOf(val))) {
+            .Enum => val != .None,
+            .Int => val != 0,
+            else => unreachable,
+        }) val else null;
+    }
+
+    pub fn base(self: *Calc, player: Player, val: u16) void {
+        if (!enabled) return;
+
+        self.summaries.get(player).damage.base = val;
+    }
+
+    pub fn final(self: *Calc, player: Player, val: u16) void {
+        if (!enabled) return;
+
+        self.summaries.get(player).damage.final = val;
+    }
+
+    pub fn capped(self: *Calc, player: Player) void {
+        if (!enabled) return;
+
+        self.summaries.get(player).damage.capped = true;
+    }
+};
+
+/// Null object pattern implementation of Generation II `Calc` which does nothing, though damage
+/// calculator support should additionally be turned off entirely via `options.calc`.
+pub const NULL: Null = .{};
+
+const Null = struct {
+    pub fn overridden(
+        self: Null,
+        player: Player,
+        comptime field: Action.Field,
+    ) ?std.meta.FieldType(Action, field) {
+        _ = .{ self, player };
+        return null;
+    }
+
+    pub fn base(self: Null, player: Player, val: u16) void {
+        _ = .{ self, player, val };
+    }
+
+    pub fn final(self: Null, player: Player, val: u16) void {
+        _ = .{ self, player, val };
+    }
+
+    pub fn capped(self: Null, player: Player) void {
+        _ = .{ self, player };
+    }
+};