@pkmn/engine 0.1.0-dev.a0447192 → 0.1.0-dev.a15b6c17

package/src/lib/gen2/data.zig

@@ -1,24 +1,20 @@
-const std = @import("std");
-const builtin = @import("builtin");
-
-const pkmn = @import("../pkmn.zig");
-
-const data = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
-const protocol = @import("../common/protocol.zig");
-const rng = @import("../common/rng.zig");
-const util = @import("../common/util.zig");
 
+const builtin = @import("builtin");
+const calc = @import("calc.zig");
+const chance = @import("chance.zig");
+const data = @import("../common/data.zig");
+const gen1 = @import("../gen1/data.zig");
 const items = @import("data/items.zig");
+const mechanics = @import("mechanics.zig");
 const moves = @import("data/moves.zig");
+const pkmn = @import("../pkmn.zig");
+const protocol = @import("../common/protocol.zig");
+const rng = @import("../common/rng.zig");
 const species = @import("data/species.zig");
+const std = @import("std");
 const types = @import("data/types.zig");
-
-const gen1 = @import("../gen1/data.zig");
-
-const calc = @import("calc.zig");
-const chance = @import("chance.zig");
-const mechanics = @import("mechanics.zig");
+const util = @import("../common/util.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
@@ -61,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));
@@ -104,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,
@@ -165,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,
@@ -186,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,
@@ -453,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/generated.zig

@@ -1,37 +1,32 @@
 //! Code generated by `tools/generate` - manual edits will be overwritten.
 
-const std = @import("std");
-
 const common = @import("../common/data.zig");
-
 const data = @import("data.zig");
 const mechanics = @import("mechanics.zig");
+const std = @import("std");
 
-const Player = common.Player;
-const Result = common.Result;
-
-const Effectiveness = data.Effectiveness;
-const Move = data.Move;
-
-const Effects = mechanics.Effects;
-const State = mechanics.State;
-
-const canMove = mechanics.canMove;
+const adjustDamage = mechanics.adjustDamage;
+const afterMove = mechanics.afterMove;
+const applyDamage = mechanics.applyDamage;
+const buildRage = mechanics.buildRage;
+const calcDamage = mechanics.calcDamage;
 const canCharge = mechanics.canCharge;
+const canMove = mechanics.canMove;
+const checkCriticalHit = mechanics.checkCriticalHit;
+const checkHit = mechanics.checkHit;
 const decrementPP = mechanics.decrementPP;
+const destinyBond = mechanics.destinyBond;
 const doMove = mechanics.doMove;
-const checkHit = mechanics.checkHit;
-const checkCriticalHit = mechanics.checkCriticalHit;
-const calcDamage = mechanics.calcDamage;
-const adjustDamage = mechanics.adjustDamage;
-const randomizeDamage = mechanics.randomizeDamage;
-const applyDamage = mechanics.applyDamage;
-const reportOutcome = mechanics.reportOutcome;
 const effectChance = mechanics.effectChance;
-const afterMove = mechanics.afterMove;
-const buildRage = mechanics.buildRage;
+const Effectiveness = data.Effectiveness;
+const Effects = mechanics.Effects;
 const kingsRock = mechanics.kingsRock;
-const destinyBond = mechanics.destinyBond;
+const Move = data.Move;
+const Player = common.Player;
+const randomizeDamage = mechanics.randomizeDamage;
+const reportOutcome = mechanics.reportOutcome;
+const Result = common.Result;
+const State = mechanics.State;
 
 const SECONDARY = true;
 const KINGS = true;

package/src/lib/gen2/helpers.zig

@@ -1,30 +1,21 @@
-const std = @import("std");
-
 const common = @import("../common/data.zig");
+const data = @import("data.zig");
+const gen1 = @import("../gen1/data.zig");
 const options = @import("../common/options.zig");
 const rng = @import("../common/rng.zig");
-
-const gen1 = @import("../gen1/data.zig");
-
-const data = @import("data.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
-
 const Choice = common.Choice;
-
-const showdown = options.showdown;
-
-const PSRNG = rng.PSRNG;
-
 const DVs = data.DVs;
 const Item = data.Item;
 const Move = data.Move;
 const MoveSlot = data.MoveSlot;
+const PSRNG = rng.PSRNG;
+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,
 };
@@ -81,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
@@ -149,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");
@@ -190,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(
@@ -202,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

@@ -1,44 +1,37 @@
-const std = @import("std");
-
-const pkmn = @import("../pkmn.zig");
-
-const common = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
-const protocol = @import("../common/protocol.zig");
-const rng = @import("../common/rng.zig");
 
+const builtin = @import("builtin");
+const common = @import("../common/data.zig");
 const data = @import("data.zig");
 const generated = @import("generated.zig");
-
-const assert = std.debug.assert;
-
-const expectEqual = std.testing.expectEqual;
-const expectEqualSlices = std.testing.expectEqualSlices;
-const expectEqualStrings = std.testing.expectEqualStrings;
-
-const showdown = pkmn.options.showdown;
-
-const Choice = common.Choice;
-const ID = common.ID;
-const Player = common.Player;
-const Result = common.Result;
+const pkmn = @import("../pkmn.zig");
+const protocol = @import("../common/protocol.zig");
+const rng = @import("../common/rng.zig");
+const std = @import("std");
 
 const Activate = protocol.Activate;
+const ActivePokemon = data.ActivePokemon;
+const assert = std.debug.assert;
 const Boost = protocol.Boost;
+const Boosts = data.Boosts;
+const Choice = common.Choice;
 const Damage = protocol.Damage;
+const Effectiveness = data.Effectiveness;
 const End = protocol.End;
+const expectEqual = std.testing.expectEqual;
+const expectEqualSlices = std.testing.expectEqualSlices;
+const expectEqualStrings = std.testing.expectEqualStrings;
 const Fail = protocol.Fail;
-const Heal = protocol.Heal;
-const Start = protocol.Start;
-
 const Gen12 = rng.Gen12;
-
-const ActivePokemon = data.ActivePokemon;
-const Boosts = data.Boosts;
-const Effectiveness = data.Effectiveness;
+const Heal = protocol.Heal;
+const ID = common.ID;
 const Item = data.Item;
 const Move = data.Move;
+const Player = common.Player;
+const Result = common.Result;
+const showdown = pkmn.options.showdown;
 const Side = data.Side;
+const Start = protocol.Start;
 const Stats = data.Stats;
 const Status = data.Status;
 const TriAttack = data.TriAttack;
@@ -137,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);
@@ -689,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;
@@ -826,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;
@@ -1200,16 +1193,16 @@ fn updateSideCondition(
 fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result {
     battle.turn += 1;
 
-    if (showdown and battle.turn >= 1000) {
+    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 {
@@ -1434,7 +1427,8 @@ pub const Effects = struct {
         if (move.type.special() != (last == .MirrorCoat)) return;
         if (state.damage == 0) return;
 
-        state.damage *|= 2;
+        // NOTE: llvm/llvm-project#58557
+        state.damage = smul(state.damage, 2);
         state.miss = false;
     }
 
@@ -1529,15 +1523,18 @@ pub const Effects = struct {
 
     pub const double = struct {
         pub fn flying(battle: anytype, player: Player, state: *State, _: anytype) !void {
-            if (battle.foe(player).active.volatiles.Flying) state.damage *|= 2;
+            if (!battle.foe(player).active.volatiles.Flying) return;
+            state.damage = smul(state.damage, 2);
         }
 
         pub fn underground(battle: anytype, player: Player, state: *State, _: anytype) !void {
-            if (battle.foe(player).active.volatiles.Underground) state.damage *|= 2;
+            if (!battle.foe(player).active.volatiles.Underground) return;
+            state.damage = smul(state.damage, 2);
         }
 
         pub fn minimize(battle: anytype, player: Player, state: *State, _: anytype) !void {
-            if (battle.foe(player).active.volatiles.minimized) state.damage *|= 2;
+            if (!battle.foe(player).active.volatiles.minimized) return;
+            state.damage = smul(state.damage, 2);
         }
     };
 
@@ -1561,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;
@@ -1706,7 +1703,7 @@ pub const Effects = struct {
         if (!state.proc) return;
         if (foe.conditions.Safeguard) return;
         // Freeze Clause Mod
-        if (showdown) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
+        if (pkmn.options.mod) for (foe.pokemon) |p| if (Status.is(p.status, .FRZ)) return;
 
         foe_stored.status = Status.init(.FRZ);
         try options.log.status(.{ foe_ident, foe_stored.status, .None });
@@ -1735,7 +1732,7 @@ pub const Effects = struct {
             state.bp *= 2;
             assert(state.bp <= 160);
         } else {
-            state.damage *|= 2;
+            state.damage = smul(state.damage, 2);
         }
     }
 
@@ -2206,7 +2203,7 @@ pub const Effects = struct {
 
     pub fn pursuit(battle: anytype, player: Player, state: *State, _: anytype) !void {
         // TODO: remove switching variable and just look at Choice saved in Battle struct?
-        if (battle.foe(player).active.volatiles.switching) state.damage *|= 2;
+        if (battle.foe(player).active.volatiles.switching) state.damage = smul(state.damage, 2);
     }
 
     pub const rage = struct {
@@ -2219,7 +2216,7 @@ pub const Effects = struct {
             const side = battle.side(player);
 
             assert(side.active.volatiles.Rage);
-            state.damage *|= (side.active.volatiles.rage +| 1);
+            state.damage = smul(state.damage, (side.active.volatiles.rage +| 1)); // TODO: |+
         }
     };
 
@@ -2314,7 +2311,7 @@ pub const Effects = struct {
             side.active.volatiles.attacks += 1;
             side.active.volatiles.Rollout = side.active.volatiles.attacks != 5;
 
-            if (side.active.volatiles.DefenseCurl) state.damage *|= 2;
+            if (side.active.volatiles.DefenseCurl) state.damage = smul(state.damage, 2);
         }
     };
 
@@ -2384,7 +2381,7 @@ pub const Effects = struct {
         }
 
         // Sleep Clause Mod
-        if (showdown) {
+        if (pkmn.options.mod) {
             for (foe.pokemon) |p| {
                 if (Status.is(p.status, .SLP) and !Status.is(p.status, .EXT)) return;
             }
@@ -2842,6 +2839,12 @@ fn convertible(active: ActivePokemon, m: Move) bool {
     return t != .@"???" and !active.types.includes(t);
 }
 
+// NOTE: llvm/llvm-project#58557
+fn smul(a: anytype, b: @TypeOf(a)) @TypeOf(a) {
+    if (!comptime builtin.target.cpu.arch.isWasm()) return a *| b;
+    return @max(a *% b, std.math.maxInt(@TypeOf(a)));
+}
+
 pub const Rolls = struct {
     fn speedTie(battle: anytype, options: anytype) !bool {
         const p1 = if (options.calc.overridden(.P1, 0, .speed_tie)) |player|
@@ -3078,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;
@@ -3503,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) {
@@ -3537,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;
             }
 
@@ -3574,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;
                     }
@@ -3588,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,131 +1,14 @@
-const std = @import("std");
-
-const pkmn = @import("pkmn.zig");
-
+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 = register(env) }),
+        js.Property.init("engine", .{ .value = node.register(env) }),
     };
     assert(c.napi_define_properties(env, exports, properties.len, &properties) == c.napi_ok);
     return exports;
 }
-
-pub fn register(env: c.napi_env) c.napi_value {
-    const object = js.Object.init(env);
-    const properties = [_]c.napi_property_descriptor{
-        js.Property.init("options", .{ .value = options(env) }),
-        js.Property.init("bindings", .{ .value = bindings(env) }),
-    };
-    assert(c.napi_define_properties(env, object, properties.len, &properties) == c.napi_ok);
-    return object;
-}
-
-fn options(env: c.napi_env) c.napi_value {
-    const object = js.Object.init(env);
-    const properties = [_]c.napi_property_descriptor{
-        js.Property.init("showdown", .{ .value = js.Boolean.init(env, pkmn.options.showdown) }),
-        js.Property.init("log", .{ .value = js.Boolean.init(env, pkmn.options.log) }),
-        js.Property.init("chance", .{ .value = js.Boolean.init(env, pkmn.options.chance) }),
-        js.Property.init("calc", .{ .value = js.Boolean.init(env, pkmn.options.calc) }),
-    };
-    assert(c.napi_define_properties(env, object, properties.len, &properties) == c.napi_ok);
-    return object;
-}
-
-fn bindings(env: c.napi_env) c.napi_value {
-    const array = js.Array.init(env, .{ .length = 1 });
-    js.Array.set(env, array, 0, bind(env, pkmn.gen1));
-    return array;
-}
-
-fn bind(env: c.napi_env, gen: anytype) c.napi_value {
-    const choices_size: u32 = @intCast(gen.CHOICES_SIZE);
-    const logs_size: u32 = @intCast(gen.LOGS_SIZE);
-    const object = js.Object.init(env);
-    const properties = [_]c.napi_property_descriptor{
-        js.Property.init("CHOICES_SIZE", .{ .value = js.Number.init(env, choices_size) }),
-        js.Property.init("LOGS_SIZE", .{ .value = js.Number.init(env, logs_size) }),
-        js.Property.init("update", .{ .method = update(gen) }),
-        js.Property.init("choices", .{ .method = choices(gen) }),
-    };
-    assert(c.napi_define_properties(env, object, properties.len, &properties) == c.napi_ok);
-    return object;
-}
-
-fn update(gen: anytype) c.napi_callback {
-    return struct {
-        fn call(env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value {
-            var argc: usize = 4;
-            var argv: [4]c.napi_value = undefined;
-            assert(c.napi_get_cb_info(env, info, &argc, &argv, null, null) == c.napi_ok);
-            assert(argc == 4);
-
-            var data: ?*anyopaque = undefined;
-            var len: usize = 0;
-            assert(c.napi_get_arraybuffer_info(env, argv[0], &data, &len) == c.napi_ok);
-            assert(len == @sizeOf(gen.Battle(gen.PRNG)));
-
-            var battle: *gen.Battle(gen.PRNG) = @alignCast(@ptrCast(data.?));
-            const c1: pkmn.Choice = @bitCast(js.Number.get(env, argv[1], u8));
-            const c2: pkmn.Choice = @bitCast(js.Number.get(env, argv[2], u8));
-
-            var vtype: c.napi_valuetype = undefined;
-            assert(c.napi_typeof(env, argv[3], &vtype) == c.napi_ok);
-            const result = switch (vtype) {
-                c.napi_undefined, c.napi_null => battle.update(c1, c2, &gen.NULL),
-                else => result: {
-                    assert(c.napi_get_arraybuffer_info(env, argv[3], &data, &len) == c.napi_ok);
-                    assert(len == gen.LOGS_SIZE);
-
-                    const buf = @as([*]u8, @ptrCast(data.?))[0..gen.LOGS_SIZE];
-                    var stream: pkmn.protocol.ByteStream = .{ .buffer = buf };
-                    // TODO: extract out
-                    var opts = pkmn.battle.options(
-                        pkmn.protocol.FixedLog{ .writer = stream.writer() },
-                        gen.chance.NULL,
-                        gen.calc.NULL,
-                    );
-                    break :result battle.update(c1, c2, &opts);
-                },
-            } catch unreachable;
-
-            return js.Number.init(env, @as(u8, @bitCast(result)));
-        }
-    }.call;
-}
-
-fn choices(gen: anytype) c.napi_callback {
-    return struct {
-        fn call(env: c.napi_env, info: c.napi_callback_info) callconv(.C) c.napi_value {
-            var argc: usize = 4;
-            var argv: [4]c.napi_value = undefined;
-            assert(c.napi_get_cb_info(env, info, &argc, &argv, null, null) == c.napi_ok);
-            assert(argc == 4);
-
-            var data: ?*anyopaque = undefined;
-            var len: usize = 0;
-            assert(c.napi_get_arraybuffer_info(env, argv[0], &data, &len) == c.napi_ok);
-            assert(len == @sizeOf(gen.Battle(gen.PRNG)));
-
-            var battle: *gen.Battle(gen.PRNG) = @alignCast(@ptrCast(data.?));
-            const player: pkmn.Player = @enumFromInt(js.Number.get(env, argv[1], u8));
-            const request: pkmn.Choice.Type = @enumFromInt(js.Number.get(env, argv[2], u8));
-
-            assert(c.napi_get_arraybuffer_info(env, argv[3], &data, &len) == c.napi_ok);
-            assert(len == gen.CHOICES_SIZE);
-
-            const out = @as([*]pkmn.Choice, @ptrCast(data.?))[0..gen.CHOICES_SIZE];
-            const n = battle.choices(player, request, out);
-            return js.Number.init(env, @as(u8, @bitCast(n)));
-        }
-    }.call;
-}