@pkmn/engine 0.1.0-dev.83de29ee → 0.1.0-dev.8b83af6b

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 {
@@ -80,7 +80,7 @@ pub const Gen12 = extern struct {
     }
 
     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 {
@@ -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

@@ -352,13 +352,16 @@ data in the browser for ease of debugging.
 | 373-376 | 384     | `rng`               | The RNG state                                           |
 
 - the current `turn` is 2 bytes, written in native-endianness
-- `last_moves` 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 3 bits of byte 372 stores the last selected move index of `side[0]` and the
+    next bit stores 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 4 bits
 - 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
@@ -489,8 +492,14 @@ Beyond the general bugs listed above, several move effects are implemented incor
 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.
+  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
@@ -601,10 +610,6 @@ Showdown's behavior for the following moves (the pkmn engine attempts to reprodu
 behavior that can be reproduced without making data structure changes or dramatically deviating from
 the correct control flow):
 
-- **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.
 - **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
   the `Binding` volatile of the opponent. This mistake results in choice locking not being reported
@@ -623,7 +628,8 @@ 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).
+  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
@@ -640,7 +646,7 @@ the correct control flow):
   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). 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 inccorect stats.
+  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)

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;
     }

package/src/lib/gen1/data.zig

@@ -55,24 +55,24 @@ pub fn Battle(comptime RNG: anytype) type {
         turn: u16 = 0,
         /// The last damage dealt by either side.
         last_damage: u16 = 0,
-        /// TODO
+        /// Details about the last move selected/used by each player required to detect desyncs.
         last_moves: MoveDetails = .{},
         /// The pseudo random number generator.
         rng: RNG,
 
         /// Returns the `Side` for the given `player`.
         pub inline fn side(self: *Self, player: Player) *Side {
-            return &self.sides[@enumToInt(player)];
+            return &self.sides[@intFromEnum(player)];
         }
 
         /// Returns the `Side` of the opponent for the given `player`
         pub inline fn foe(self: *Self, player: Player) *Side {
-            return &self.sides[@enumToInt(player.foe())];
+            return &self.sides[@intFromEnum(player.foe())];
         }
 
         /// Returns an identifier for the active Pokémon of `player`.
         pub inline fn active(self: *Self, player: Player) ID {
-            return player.ident(@intCast(u3, self.side(player).order[0]));
+            return player.ident(@intCast(self.side(player).order[0]));
         }
 
         /// Returns the result of applying Player 1's choice `c1` and Player 2's choice `c2` to the
@@ -201,7 +201,7 @@ pub const MoveSlot = extern struct {
     }
 };
 
-/// TODO
+/// Details required to detect desyncs based on the move last selected/executed by players.
 pub const MoveDetails = packed struct {
     /// The move slot index of the last move selected in the battle menu by Player 1
     p1_index: if (showdown) u8 else u3 = 0,
@@ -243,13 +243,13 @@ pub const Status = enum(u8) {
     /// Whether or not the status `num` is the same as `status`.
     pub inline fn is(num: u8, status: Status) bool {
         if (status == .SLP) return Status.duration(num) > 0;
-        return ((num >> @intCast(u3, @enumToInt(status))) & 1) != 0;
+        return ((num >> @intCast(@intFromEnum(status))) & 1) != 0;
     }
 
     /// Initializes a non-sleep `status`. Use `slp` or `slf` to initialize a sleep status.
     pub inline fn init(status: Status) u8 {
         assert(status != .SLP and status != .EXT);
-        return @as(u8, 1) << @intCast(u3, @enumToInt(status));
+        return @as(u8, 1) << @intCast(@intFromEnum(status));
     }
 
     /// Initializes a non self-inflicted sleep status with duration `dur`.
@@ -266,7 +266,7 @@ pub const Status = enum(u8) {
 
     /// Returns the duration of a sleep status.
     pub inline fn duration(num: u8) u3 {
-        return @intCast(u3, num & SLP);
+        return @intCast(num & SLP);
     }
 
     /// Returns whether `num` reflects any status.
@@ -413,10 +413,11 @@ pub fn Stats(comptime T: type) type {
         /// Computes the value of `stat` given a `base`, `dv`, stat `exp` and `level`.
         pub fn calc(comptime stat: []const u8, base: T, dv: u4, exp: u16, level: u8) T {
             assert(level > 0 and level <= 100);
-            const evs = @min(255, @floatToInt(u16, @ceil(@sqrt(@intToFloat(f32, exp)))));
+            const float: f32 = @floatFromInt(exp);
+            const evs = @min(255, @as(u16, @intFromFloat(@ceil(@sqrt(float)))));
             const core: u32 = (2 *% (@as(u32, base) +% dv)) +% (evs / 4);
             const factor: u32 = if (std.mem.eql(u8, stat, "hp")) level + 10 else 5;
-            return @intCast(T, core *% @as(u32, level) / 100 +% factor);
+            return @intCast(core *% @as(u32, level) / 100 +% factor);
         }
     };
 }
@@ -465,7 +466,7 @@ test Boosts {
 pub const Move = moves.Move;
 
 test Move {
-    try expectEqual(2, @enumToInt(Move.KarateChop));
+    try expectEqual(2, @intFromEnum(Move.KarateChop));
     const move = Move.get(.Fissure);
     try expectEqual(Move.Effect.OHKO, move.effect);
     try expectEqual(@as(u8, 30), move.accuracy);
@@ -526,7 +527,7 @@ test Move {
 pub const Species = species.Species;
 
 test Species {
-    try expectEqual(2, @enumToInt(Species.Ivysaur));
+    try expectEqual(2, @intFromEnum(Species.Ivysaur));
     try expectEqual(@as(u8, 100), Species.get(.Mew).stats.def);
 }
 
@@ -543,9 +544,11 @@ pub const Effectiveness = enum(u8) {
     Super = 20,
 
     /// Used to determine the effectiness of a neutral damage hit.
-    pub const neutral: u16 = @enumToInt(Effectiveness.Neutral) * @enumToInt(Effectiveness.Neutral);
+    pub const neutral: u16 =
+        @intFromEnum(Effectiveness.Neutral) * @intFromEnum(Effectiveness.Neutral);
     /// Used to detect whether there is a mismatch in type effectivness (relevant for precedence).
-    pub const mismatch: u16 = @enumToInt(Effectiveness.Resisted) + @enumToInt(Effectiveness.Super);
+    pub const mismatch: u16 =
+        @intFromEnum(Effectiveness.Resisted) + @intFromEnum(Effectiveness.Super);
 
     comptime {
         assert(@sizeOf(Effectiveness) == 1);
@@ -553,8 +556,8 @@ pub const Effectiveness = enum(u8) {
 };
 
 test Types {
-    try expectEqual(14, @enumToInt(Type.Dragon));
-    try expectEqual(20, @enumToInt(Effectiveness.Super));
+    try expectEqual(14, @intFromEnum(Type.Dragon));
+    try expectEqual(20, @intFromEnum(Effectiveness.Super));
 
     try expect(!Type.Ghost.special());
     try expect(Type.Dragon.special());

package/src/lib/gen1/helpers.zig

@@ -64,7 +64,7 @@ pub const Battle = struct {
     }
 };
 
-pub fn prng(rand: *PSRNG) data.PRNG {
+fn prng(rand: *PSRNG) data.PRNG {
     // GLITCH: initial bytes in seed can only range from 0-252, not 0-255
     const max: u8 = 253;
     return .{
@@ -90,7 +90,7 @@ pub const Side = struct {
 
         for (0..ps.len) |i| {
             side.pokemon[i] = Pokemon.init(ps[i]);
-            side.order[i] = @intCast(u4, i) + 1;
+            side.order[i] = @as(u4, @intCast(i)) + 1;
         }
         return side;
     }
@@ -101,7 +101,7 @@ pub const Side = struct {
 
         for (0..n) |i| {
             side.pokemon[i] = Pokemon.random(rand, opt);
-            side.order[i] = @intCast(u4, i) + 1;
+            side.order[i] = @as(u4, @intCast(i)) + 1;
         }
 
         return side;
@@ -139,7 +139,7 @@ pub const Pokemon = struct {
         for (p.moves, 0..) |m, j| {
             pokemon.moves[j].id = m;
             // NB: PP can be at most 61 legally (though can overflow to 63)
-            pokemon.moves[j].pp = @intCast(u8, @min(Move.pp(m) / 5 * 8, 61));
+            pokemon.moves[j].pp = @intCast(@min(Move.pp(m) / 5 * 8, 61));
         }
         if (p.hp) |hp| {
             pokemon.hp = hp;
@@ -153,7 +153,7 @@ pub const Pokemon = struct {
     }
 
     pub fn random(rand: *PSRNG, opt: Options) data.Pokemon {
-        const s = @intToEnum(Species, rand.range(u8, 1, Species.size + 1));
+        const s: Species = @enumFromInt(rand.range(u8, 1, Species.size + 1));
         const species = Species.get(s);
         const lvl = if (rand.chance(u8, 1, 20)) rand.range(u8, 1, 99 + 1) else 100;
         var stats: Stats(u16) = .{};
@@ -176,15 +176,15 @@ pub const Pokemon = struct {
         for (0..n) |i| {
             var m: Move = .None;
             sample: while (true) {
-                m = @intToEnum(Move, rand.range(u8, 1, Move.size - 1 + 1));
+                m = @enumFromInt(rand.range(u8, 1, Move.size - 1 + 1));
                 if (opt.block and blocked(m)) continue :sample;
                 for (0..i) |j| if (ms[j].id == m) continue :sample;
                 break;
             }
-            const pp_ups =
+            const pp_ups: u8 =
                 if (!opt.cleric and rand.chance(u8, 1, 10)) rand.range(u2, 0, 2 + 1) else 3;
             // NB: PP can be at most 61 legally (though can overflow to 63)
-            const max_pp = @intCast(u8, Move.pp(m) + @as(u8, pp_ups) * @min(Move.pp(m) / 5, 7));
+            const max_pp: u8 = @intCast(Move.pp(m) + pp_ups * @min(Move.pp(m) / 5, 7));
             ms[i] = .{
                 .id = m,
                 .pp = if (opt.cleric) max_pp else rand.range(u8, 0, max_pp + 1),
@@ -206,19 +206,10 @@ pub const Pokemon = struct {
     }
 };
 
-// TODO: uncomment once integration tests pass
-// 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 => true,
-//         else => false,
-//     };
-// }
-
 fn blocked(m: Move) bool {
-    if (Move.get(m).effect == .Binding) return true;
+    // Binding moves are borked but only via Mirror Move / Metronome which are already blocked
     return switch (m) {
-        .Counter, .Mimic, .Bide, .Metronome, .MirrorMove, .Transform => true,
+        .Mimic, .Metronome, .MirrorMove, .Transform => true,
         else => false,
     };
 }