@pkmn/engine 0.1.0-dev.6ebbd3bc → 0.1.0-dev.724afcb1

package/src/lib/gen1/mechanics.zig

@@ -84,11 +84,11 @@ fn start(battle: anytype, options: anytype) !Result {
 
     const p1_slot = findFirstAlive(p1);
     assert(!showdown or p1_slot == 1);
-    if (p1_slot == 0) return if (findFirstAlive(p2) == 0) Result.Tie else Result.Lose;
+    if (p1_slot == 0) return if (findFirstAlive(p2) == 0) .Tie else .Lose;
 
     const p2_slot = findFirstAlive(p2);
     assert(!showdown or p2_slot == 1);
-    if (p2_slot == 0) return Result.Win;
+    if (p2_slot == 0) return .Win;
 
     try switchIn(battle, .P1, p1_slot, true, options);
     try switchIn(battle, .P2, p2_slot, true, options);
@@ -167,7 +167,7 @@ fn selectMove(
                 const last = side.active.move(battle.lastMove(player).index);
                 if (last.id == .Metronome) side.last_selected_move = last.id;
                 if (last.id == .MirrorMove) {
-                    if (!pkmn.options.mod) return Result.Error;
+                    if (!pkmn.options.mod) return .Error;
                     side.last_selected_move = last.id;
                 }
             }
@@ -432,7 +432,7 @@ fn executeMove(
             // technically be from this Pokémon because it must be exactly 1 to not desync and
             // every Pokémon must have at least one move
             if (mslot != 1 or side.active.move(mslot).id != side.last_selected_move) {
-                return Result.Error;
+                return .Error;
             } else {
                 auto = true;
             }
@@ -450,7 +450,7 @@ fn executeMove(
         .skip_can => skip_can = true,
         .skip_pp => skip_pp = true,
         .ok => {},
-        .err => return @as(?Result, Result.Error),
+        .err => return .Error,
     }
 
     // Pokémon Showdown incorrectly implements PP deduction when handling the Hyper Beam automatic
@@ -618,17 +618,10 @@ fn beforeMove(
                         return .err;
                     }
                 }
-                // Pokémon Showdown incorrectly changes the "target" of the confusion self-hit based
-                // on the targeting behavior of the confused Pokémon's selected move which results
-                // in the wrong behavior with respect to the Substitute + Confusion glitch
-                const target = if (showdown and Move.get(side.last_selected_move).target == .Self)
-                    player
-                else
-                    player.foe();
 
                 const uncapped = battle.last_damage;
                 // Skipping adjustDamage / randomizeDamage / checkHit
-                _ = try applyDamage(battle, player, target, .Confusion, options);
+                _ = try applyDamage(battle, player, player.foe(), .Confusion, options);
                 // Pokémon Showdown thinks that confusion damage is uncapped ¯\_(ツ)_/¯
                 if (showdown) battle.last_damage = uncapped;
 
@@ -885,7 +878,7 @@ fn doMove(
     var miss = showdown and miss: {
         immune = move.target != .Self and !status and !counter and
             (@intFromEnum(move.type.effectiveness(foe.active.types.type1)) == 0 or
-            @intFromEnum(move.type.effectiveness(foe.active.types.type2)) == 0);
+                @intFromEnum(move.type.effectiveness(foe.active.types.type2)) == 0);
         if (immune and move.effect != .Binding) break :miss true;
         if (move.effect == .OHKO and side.active.stats.spe < foe.active.stats.spe) {
             battle.last_damage = 0;
@@ -923,7 +916,7 @@ fn doMove(
                 if (showdown) break :damage; // skip adjustDamage / randomizeDamage
             } else if (!calcDamage(battle, player, player.foe(), move, crit, options)) {
                 if (!showdown) try options.chance.commit(player, .err);
-                return @as(?Result, Result.Error);
+                return .Error;
             }
             if (battle.last_damage == 0) {
                 immune = true;
@@ -1026,7 +1019,7 @@ fn doMove(
     const sub = showdown and foe.active.volatiles.Substitute;
 
     var nullified = false;
-    var hit: u4 = 0;
+    var hit: usize = 0;
     while (hit < hits) {
         if (hit == 0) {
             if (crit) try log.crit(.{battle.active(player.foe())});
@@ -1054,7 +1047,7 @@ fn doMove(
         if (showdown and move.effect == .Twineedle and !nullified and foe.stored().hp > 0) {
             try Effects.poison(battle, player, Move.get(.PoisonSting), options);
         }
-        try log.hitcount(.{ battle.active(player.foe()), hit });
+        try log.hitcount(.{ battle.active(player.foe()), @as(u4, @intCast(hit)) });
     } else if (showdown and move.effect == .Binding) {
         // This should be handled much earlier but Pokémon Showdown does it here... ¯\_(ツ)_/¯
         try Effects.binding(battle, player, rewrap, options);
@@ -1255,13 +1248,13 @@ fn specialDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
         .Psywave => power: {
             const max: u8 = @intCast(@as(u16, side.stored().level) * 3 / 2);
             // GLITCH: Psywave infinite glitch loop
-            if (!pkmn.options.mod and max <= 1) return Result.Error;
+            if (!pkmn.options.mod and max <= 1) return .Error;
             break :power try Rolls.psywave(battle, player, max, options);
         },
         else => unreachable,
     };
 
-    if (battle.last_damage == 0) return if (pkmn.options.mod) null else Result.Error;
+    if (battle.last_damage == 0) return if (pkmn.options.mod) null else .Error;
 
     const sub = showdown and foe.active.volatiles.Substitute;
     _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
@@ -1281,15 +1274,15 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
     // Pretend Splash was used as a stand-in when no move has been used to fail below with 0 BP
     const foe_last_selected_move =
         Move.get(if (foe.last_selected_move == .None or foe.last_selected_move == .SKIP_TURN)
-        .Splash
-    else
-        foe.last_selected_move);
+            .Splash
+        else
+            foe.last_selected_move);
 
     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
-        foe_last_selected_move.type == .Fighting);
+            foe_last_selected_move.type == .Fighting);
 
     if (!used and !selected) {
         try options.log.fail(.{ battle.active(player), .None });
@@ -1298,13 +1291,13 @@ fn counterDamage(battle: anytype, player: Player, move: Move.Data, options: anyt
 
     if (!used or !selected) {
         // GLITCH: Counter desync (covered by Desync Clause Mod on Pokémon Showdown)
-        if (!pkmn.options.mod) return Result.Error;
+        if (!pkmn.options.mod) return .Error;
         try options.log.fail(.{ battle.active(player), .None });
         return null;
     }
 
     // NOTE: llvm/llvm-project#58557
-    battle.last_damage = if (comptime builtin.target.isWasm())
+    battle.last_damage = if (comptime builtin.target.cpu.arch.isWasm())
         @max(battle.last_damage *% 2, std.math.maxInt(u16))
     else
         battle.last_damage *| 2;
@@ -1453,7 +1446,16 @@ fn moveHit(
             break :miss true;
         }
         if (!showdown) {
-            if (move.effect == .Swift) return true;
+            if (move.effect == .Swift) {
+                // If Swift could cause a division-by-zero freeze (which doesn't exist on Pokémon
+                // Showdown, hence why the block above doesn't include this code), we need the
+                // damage roll to be committed. However, the commit code will not save this roll if
+                // the glitch occurs and the move was not marked as having hit. To work around this
+                // we flag that the move hit (as Swift trivially does), but pass the probability of
+                // the hit as zero to ensure it doesn't actually get saved.
+                try options.chance.hit(player, true, 0);
+                return true;
+            }
             if (foe.active.volatiles.Invulnerable) break :miss true;
         }
 
@@ -1526,13 +1528,13 @@ fn checkFaint(
 
     if (player_out and foe_out) {
         try options.log.tie(.{});
-        return Result.Tie;
+        return .Tie;
     } else if (player_out) {
         try options.log.win(.{player.foe()});
-        return if (player == .P1) Result.Lose else Result.Win;
+        return if (player == .P1) .Lose else .Win;
     } else if (foe_out) {
         try options.log.win(.{player});
-        return if (player == .P1) Result.Win else Result.Lose;
+        return if (player == .P1) .Win else .Lose;
     }
 
     const foe_choice: Choice.Type = if (foe_fainted) .Switch else .Pass;
@@ -1550,7 +1552,7 @@ fn faint(battle: anytype, player: Player, done: bool, cap: bool, options: anytyp
     if (foe_volatiles.Bide) {
         assert(!foe_volatiles.Thrashing and !foe_volatiles.Rage);
         foe_volatiles.state = if (pkmn.options.mod) 0 else foe_volatiles.state & 255;
-        if (foe_volatiles.state != 0) return Result.Error;
+        if (foe_volatiles.state != 0) return .Error;
     }
 
     // Clearing these is not strictly necessary as provided the battle hasn't ended the side that
@@ -1642,19 +1644,19 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
 
     if (pkmn.options.mod and pkmn.options.ebc and checkEBC(battle)) {
         try options.log.tie(.{});
-        return Result.Tie;
+        return .Tie;
     }
 
     if (pkmn.options.mod and battle.turn >= 1000) {
         try options.log.tie(.{});
-        return Result.Tie;
+        return .Tie;
     } else if (battle.turn >= 65535) {
-        return Result.Error;
+        return .Error;
     }
 
     try options.log.turn(.{battle.turn});
 
-    return Result.Default;
+    return .Default;
 }
 
 fn checkEBC(battle: anytype) bool {
@@ -1945,7 +1947,7 @@ pub const Effects = struct {
             return null;
         } else if (err) {
             // GLITCH: Transform + Mirror Move / Metronome PP softlock
-            return Result.Error;
+            return .Error;
         }
 
         volatiles.disable_move =
@@ -3143,11 +3145,11 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
         },
         .Switch => {
             const side = battle.side(player);
-            var slot: u4 = 2;
+            var slot: usize = 2;
             while (slot <= 6) : (slot += 1) {
                 const id = side.order[slot - 1];
                 if (id == 0 or side.pokemon[id - 1].hp == 0) continue;
-                out[n] = .{ .type = .Switch, .data = slot };
+                out[n] = .{ .type = .Switch, .data = @intCast(slot) };
                 n += 1;
             }
             if (n == 0) {
@@ -3178,11 +3180,11 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                 return n;
             }
 
-            var slot: u4 = 2;
+            var slot: usize = 2;
             while (slot <= 6) : (slot += 1) {
                 const id = side.order[slot - 1];
                 if (id == 0 or side.pokemon[id - 1].hp == 0) continue;
-                out[n] = .{ .type = .Switch, .data = slot };
+                out[n] = .{ .type = .Switch, .data = @intCast(slot) };
                 n += 1;
             }
 
@@ -3215,7 +3217,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                         const struggle =
                             m.id == .Bide and (m.pp == 0 or active.volatiles.disable_move == slot);
                         const s = if (struggle) 0 else slot;
-                        out[n] = .{ .type = .Move, .data = s };
+                        out[n] = .{ .type = .Move, .data = @intCast(s) };
                         n += 1;
                         return n;
                     }
@@ -3229,7 +3231,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                 if (m.id == .None) break;
                 if (m.pp == 0) continue;
                 if (active.volatiles.disable_move == slot) continue;
-                out[n] = .{ .type = .Move, .data = slot };
+                out[n] = .{ .type = .Move, .data = @intCast(slot) };
                 n += 1;
             }
             // Struggle (Pokémon Showdown would use 'move 1' here)

package/src/lib/gen2/calc.zig

@@ -15,9 +15,6 @@ const isPointerTo = util.isPointerTo;
 const Player = common.Player;
 const PointerType = util.PointerType;
 
-const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
-const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
-
 /// Information relevant to damage calculation that occured during a Generation II battle `update`.
 pub const Summaries = extern struct {
     /// Relevant information for Player 1.
@@ -91,8 +88,8 @@ pub const Calc = struct {
         };
 
         return if (switch (@typeInfo(@TypeOf(val))) {
-            Enum => val != .None,
-            Int => val != 0,
+            .@"enum" => val != .None,
+            .int => val != 0,
             else => unreachable,
         }) val else null;
     }
@@ -148,6 +145,6 @@ fn ReturnType(comptime field: Action.Field) type {
     return ?(switch (field) {
         .damages => u8,
         .critical_hits => Optional(bool),
-        else => std.meta.FieldType(Action, field),
+        else => @FieldType(Action, @tagName(field)),
     });
 }

package/src/lib/gen2/chance.zig

@@ -27,10 +27,6 @@ const Type = data.Type;
 const Effectiveness = data.Effectiveness;
 const TriAttack = data.TriAttack;
 
-const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
-const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
-const Struct = if (@hasField(std.builtin.Type, "struct")) .@"struct" else .Struct;
-
 /// Actions taken by a hypothetical "chance player" that convey information about which RNG events
 /// were observed during a Generation II battle `update`. This can additionally be provided as input
 /// to the `update` call to override the normal behavior of the RNG in order to force specific
@@ -57,15 +53,15 @@ pub const Actions = extern struct {
     /// same shape if they have the same fields set (though those fields need not necessarily be
     /// set to the same value).
     pub fn matches(a: Actions, b: Actions) bool {
-        inline for (@field(@typeInfo(Actions), @tagName(Struct)).fields) |player| {
-            inline for (@field(@typeInfo(Action), @tagName(Struct)).fields) |field| {
+        inline for (@typeInfo(Actions).@"struct".fields) |player| {
+            inline for (@typeInfo(Action).@"struct".fields) |field| {
                 const a_val = @field(@field(a, player.name), field.name);
                 const b_val = @field(@field(b, player.name), field.name);
 
                 switch (@typeInfo(@TypeOf(a_val))) {
-                    Enum => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
+                    .@"enum" => if ((@intFromEnum(a_val) > 0) != (@intFromEnum(b_val) > 0))
                         return false,
-                    Int => if ((a_val > 0) != (b_val > 0)) return false,
+                    .int => if ((a_val > 0) != (b_val > 0)) return false,
                     else => unreachable,
                 }
             }
@@ -73,7 +69,7 @@ pub const Actions = extern struct {
         return true;
     }
 
-    pub fn fmt(self: Actions, writer: anytype, shape: bool) !void {
+    pub fn fmt(self: Actions, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeAll("<P1 = ");
         try self.p1.fmt(writer, shape);
         try writer.writeAll(", P2 = ");
@@ -81,8 +77,7 @@ pub const Actions = extern struct {
         try writer.writeAll(">");
     }
 
-    pub fn format(a: Actions, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
-        _ = .{ f, o };
+    pub fn format(a: Actions, w: *std.Io.Writer) !void {
         try fmt(a, w, false);
     }
 };
@@ -186,18 +181,17 @@ pub const Action = packed struct(u128) {
 
     pub const Field = std.meta.FieldEnum(Action);
 
-    pub fn format(a: Action, comptime f: []const u8, o: std.fmt.FormatOptions, w: anytype) !void {
-        _ = .{ f, o };
+    pub fn format(a: Action, w: *std.Io.Writer) !void {
         try fmt(a, w, false);
     }
 
-    pub fn fmt(self: Action, writer: anytype, shape: bool) !void {
+    pub fn fmt(self: Action, writer: *std.Io.Writer, shape: bool) !void {
         try writer.writeByte('(');
         var printed = false;
-        inline for (@field(@typeInfo(Action), @tagName(Struct)).fields) |field| {
+        inline for (@typeInfo(Action).@"struct".fields) |field| {
             const val = @field(self, field.name);
             switch (@typeInfo(@TypeOf(val))) {
-                Enum => if (val != .None) {
+                .@"enum" => if (val != .None) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -211,7 +205,7 @@ pub const Action = packed struct(u128) {
                     }
                     printed = true;
                 },
-                Int => if (val != 0) {
+                .int => if (val != 0) {
                     if (printed) try writer.writeAll(", ");
                     if (shape) {
                         try writer.print("{s}:?", .{field.name});
@@ -786,7 +780,7 @@ pub fn expectProbability(r: anytype, p: u64, q: u64) !void {
 
     r.reduce();
     if (r.p != p or r.q != q) {
-        print("expected {d}/{d}, found {}\n", .{ p, q, r });
+        print("expected {d}/{d}, found {f}\n", .{ p, q, r });
         return error.TestExpectedEqual;
     }
 }

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

@@ -172,9 +172,12 @@ pub const Type = enum(u8) {
         return CHART[@intFromEnum(t1)][@intFromEnum(t2)];
     }
 
-    /// The precedence order of Type `type`.
-    pub fn precedence(self: Type) u8 {
-        return PRECEDENCE[@intFromEnum(self)];
+    /// The precedence order of Type `t1` vs. Type `t2`.
+    pub fn precedence(t1: Type, t2: Type) u8 {
+        // The Ice vs. Fire matchup is out of order - return a higher
+        // number than anything else so that it sorts last correctly
+        if (t1 == .Ice and t2 == .Fire) return 18;
+        return PRECEDENCE[@intFromEnum(t2)];
     }
 
     /// The internal index of this Type used by Present.

package/src/lib/gen2/data.zig

@@ -57,7 +57,7 @@ pub fn Battle(comptime RNG: anytype) type {
         turn: u16 = 0,
         field: Field = .{},
 
-        _: [padding]u8 = .{0} ** padding,
+        _: [padding]u8 = @splat(0),
 
         pub fn side(self: anytype, player: Player) PointerType(@TypeOf(self), Side) {
             assert(isPointerTo(self, Self));
@@ -100,13 +100,13 @@ pub const Weather = enum(u4) {
 };
 
 pub const Side = extern struct {
-    pokemon: [6]Pokemon = [_]Pokemon{.{}} ** 6,
+    pokemon: [6]Pokemon = @splat(.{}),
     active: ActivePokemon align(8) = .{},
     conditions: Conditions = .{},
     // NB: wLastPlayerCounterMove / wLastEnemyCounterMove (wLastPlayerMove / wLastEnemyMove)
     last_used_move: Move = .None,
 
-    _: [7]u8 = .{0} ** 7,
+    _: [7]u8 = @splat(0),
 
     const Conditions = packed struct(u32) {
         Spikes: bool = false,
@@ -161,7 +161,7 @@ pub const Side = extern struct {
 pub const ActivePokemon = extern struct {
     volatiles: Volatiles align(4) = .{},
     stats: Stats(u16) = .{},
-    moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
+    moves: [4]MoveSlot = @splat(.{}),
     boosts: Boosts = .{},
     types: Types = .{},
     species: Species = .None,
@@ -182,7 +182,7 @@ pub const ActivePokemon = extern struct {
 
 pub const Pokemon = extern struct {
     stats: Stats(u16) = .{},
-    moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
+    moves: [4]MoveSlot = @splat(.{}),
     types: Types = .{},
     dvs: DVs = .{},
     hp: u16 = 0,
@@ -449,8 +449,9 @@ test Types {
     try expect(!Type.Steel.special());
     try expect(Type.Dark.special());
 
-    try expectEqual(@as(u8, 3), Type.Water.precedence());
-    try expect(Type.Bug.precedence() > Type.Poison.precedence());
+    try expectEqual(@as(u8, 3), Type.precedence(.Water, .Water));
+    try expect(Type.precedence(.Poison, .Bug) > Type.precedence(.Poison, .Poison));
+    try expect(Type.precedence(.Ice, .Fire) > Type.precedence(.Ice, .Water));
 
     try expectEqual(Effectiveness.Super, Type.effectiveness(.Ghost, .Psychic));
     try expectEqual(Effectiveness.Super, Type.effectiveness(.Water, .Fire));

package/src/lib/gen2/helpers.zig

@@ -16,8 +16,6 @@ const showdown = options.showdown;
 const Species = data.Species;
 const Stats = data.Stats;
 
-const Struct = if (@hasField(std.builtin.Type, "struct")) .@"struct" else .Struct;
-
 pub const Options = struct {
     cleric: bool = showdown,
 };
@@ -74,7 +72,7 @@ pub fn prng(rand: *PSRNG) data.PRNG {
                 var carry: u8 = 0;
                 var div: u8 = 0;
 
-                var i: u8 = 0;
+                var i: usize = 0;
                 while (i < seed.len) {
                     div = @intCast(timer >> 8);
                     // This is effectively @addWithOverflow but with three operands
@@ -142,7 +140,7 @@ pub const Pokemon = struct {
         var pokemon = data.Pokemon{};
         pokemon.species = p.species;
         const species = Species.get(p.species);
-        inline for (@field(@typeInfo(@TypeOf(pokemon.stats)), @tagName(Struct)).fields) |field| {
+        inline for (@typeInfo(@TypeOf(pokemon.stats)).@"struct".fields) |field| {
             const hp = comptime std.mem.eql(u8, field.name, "hp");
             const spc =
                 comptime std.mem.eql(u8, field.name, "spa") or std.mem.eql(u8, field.name, "spd");
@@ -183,7 +181,7 @@ pub const Pokemon = struct {
 
         var stats: Stats(u16) = .{};
         const dvs = gen1.DVs.random(rand);
-        inline for (@field(@typeInfo(@TypeOf(stats)), @tagName(Struct)).fields) |field| {
+        inline for (@typeInfo(@TypeOf(stats)).@"struct".fields) |field| {
             const hp = std.mem.eql(u8, field.name, "hp");
             const spc = std.mem.eql(u8, field.name, "spa") or std.mem.eql(u8, field.name, "spd");
             @field(stats, field.name) = Stats(u16).calc(
@@ -195,7 +193,7 @@ pub const Pokemon = struct {
             );
         }
 
-        var ms = [_]MoveSlot{.{}} ** 4;
+        var ms: [4]MoveSlot = @splat(.{});
         const n = if (rand.chance(u8, 1, 100)) rand.range(u4, 1, 3 + 1) else 4;
         for (0..n) |i| {
             var m: Move = .None;

package/src/lib/gen2/mechanics.zig

@@ -130,11 +130,11 @@ fn start(battle: anytype, options: anytype) !Result {
 
     const p1_slot = findFirstAlive(p1);
     assert(!showdown or p1_slot == 1);
-    if (p1_slot == 0) return if (findFirstAlive(p2) == 0) Result.Tie else Result.Lose;
+    if (p1_slot == 0) return if (findFirstAlive(p2) == 0) .Tie else .Lose;
 
     const p2_slot = findFirstAlive(p2);
     assert(!showdown or p2_slot == 1);
-    if (p2_slot == 0) return Result.Win;
+    if (p2_slot == 0) return .Win;
 
     try switchIn(battle, .P1, p1_slot, .Initial, options);
     try switchIn(battle, .P2, p2_slot, .Initial, options);
@@ -682,7 +682,7 @@ pub fn adjustDamage(battle: anytype, player: Player, state: *State, _: anytype)
 
     // Type effectiveness matchup precedence only matters with (NVE, SE)
     if (!showdown and (eff1 + eff2) == Effectiveness.mismatch and
-        types.type1.precedence() > types.type2.precedence())
+        Type.precedence(state.type, types.type1) > Type.precedence(state.type, types.type2))
     {
         assert(eff2 != neutral);
         d = d *% eff2 / 10;
@@ -819,13 +819,13 @@ fn checkFaint(
 
     if (player_out and foe_out) {
         try options.log.tie(.{});
-        return Result.Tie;
+        return .Tie;
     } else if (player_out) {
         try options.log.win(.{player.foe()});
-        return if (player == .P1) Result.Lose else Result.Win;
+        return if (player == .P1) .Lose else .Win;
     } else if (foe_out) {
         try options.log.win(.{player});
-        return if (player == .P1) Result.Win else Result.Lose;
+        return if (player == .P1) .Win else .Lose;
     }
 
     const foe_choice: Choice.Type = if (foe_fainted) .Switch else .Pass;
@@ -1195,14 +1195,14 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
 
     if (pkmn.options.mod and battle.turn >= 1000) {
         try options.log.tie(.{});
-        return Result.Tie;
+        return .Tie;
     } else if (battle.turn >= 65535) {
-        return Result.Error;
+        return .Error;
     }
 
     try options.log.turn(.{battle.turn});
 
-    return Result.Default;
+    return .Default;
 }
 
 pub fn buildRage(battle: anytype, player: Player, state: *State, options: anytype) !void {
@@ -1558,7 +1558,7 @@ pub const Effects = struct {
         const last = battle.foe(player).lastMove(true);
         const failed = volatiles.Encore or
             (last == .None or last == .Struggle or
-            last == .Encore or .last == .MirrorMove);
+                last == .Encore or .last == .MirrorMove);
         if (failed) return options.log.fail(.{ foe_ident, .None });
 
         var slot: u3 = 0;
@@ -2841,7 +2841,7 @@ fn convertible(active: ActivePokemon, m: Move) bool {
 
 // NOTE: llvm/llvm-project#58557
 fn smul(a: anytype, b: @TypeOf(a)) @TypeOf(a) {
-    if (!comptime builtin.target.isWasm()) return a *| b;
+    if (!comptime builtin.target.cpu.arch.isWasm()) return a *| b;
     return @max(a *% b, std.math.maxInt(@TypeOf(a)));
 }
 
@@ -3081,7 +3081,7 @@ pub const Rolls = struct {
     }
 
     // Conversion 2 can at most choose between 7 types (vs. a Grass-type attack)
-    var CONVERSION_2: [7]Type = [_]Type{.@"???"} ** 7;
+    var CONVERSION_2: [7]Type = @splat(.@"???");
 
     fn conversion2(battle: anytype, player: Player, mtype: Type, options: anytype) !Type {
         var i: u8 = 0;
@@ -3506,11 +3506,11 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
         },
         .Switch => {
             const side = battle.side(player);
-            var slot: u4 = 2;
+            var slot: usize = 2;
             while (slot <= 6) : (slot += 1) {
                 const id = side.order[slot - 1];
                 if (id == 0 or side.pokemon[id - 1].hp == 0) continue;
-                out[n] = .{ .type = .Switch, .data = slot };
+                out[n] = .{ .type = .Switch, .data = @intCast(slot) };
                 n += 1;
             }
             if (n == 0) {
@@ -3540,11 +3540,11 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                 return n;
             }
 
-            var slot: u4 = 2;
+            var slot: usize = 2;
             while (!active.volatiles.Trapped and slot <= 6) : (slot += 1) {
                 const id = side.order[slot - 1];
                 if (id == 0 or side.pokemon[id - 1].hp == 0) continue;
-                out[n] = .{ .type = .Switch, .data = slot };
+                out[n] = .{ .type = .Switch, .data = @intCast(slot) };
                 n += 1;
             }
 
@@ -3577,7 +3577,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                         const struggle =
                             m.id == .Bide and (m.pp == 0 or active.volatiles.disable.move == slot);
                         const s = if (struggle) 0 else slot;
-                        out[n] = .{ .type = .Move, .data = s };
+                        out[n] = .{ .type = .Move, .data = @intCast(s) };
                         n += 1;
                         return n;
                     }
@@ -3591,7 +3591,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                 if (m.id == .None) break;
                 if (m.pp == 0) continue;
                 if (active.volatiles.disable.move == slot) continue;
-                out[n] = .{ .type = .Move, .data = slot };
+                out[n] = .{ .type = .Move, .data = @intCast(slot) };
                 n += 1;
             }
             // Struggle (Pokémon Showdown would use 'move 1' here)

package/src/lib/napi.h

@@ -0,0 +1,2 @@
+#define NAPI_VERSION 8
+#include <node_api.h>

package/src/lib/node.zig

@@ -1,14 +1,10 @@
+const c = @import("napi");
 const js = @import("common/js.zig");
 const node = @import("bindings/node.zig");
 const std = @import("std");
 
 const assert = std.debug.assert;
 
-const c = @cImport({
-    @cDefine("NAPI_VERSION", "8");
-    @cInclude("node_api.h");
-});
-
 export fn napi_register_module_v1(env: c.napi_env, exports: c.napi_value) c.napi_value {
     const properties = [_]c.napi_property_descriptor{
         js.Property.init("engine", .{ .value = node.register(env) }),