@pkmn/engine 0.1.0-dev.c5fe6d07 → 0.1.0-dev.d3e796d5

package/build.zig

@@ -235,9 +235,9 @@ pub fn build(b: *std.Build) !void {
     const dump = tool(b, "src/tools/dump.zig", tools);
     const transitions = tool(b, "src/tools/transitions.zig", tools);
 
-    // FIXME: serde randomly fails to build in recent Windows release configurations...
+    // FIXME: serde randomly fails to build in some release configurations
     var hack = tools;
-    if (builtin.os.tag == .windows and optimize != .Debug) hack.tool.tests = null;
+    if (optimize != .Debug) hack.tool.tests = null;
     const serde = tool(b, "src/tools/serde.zig", hack);
 
     b.step("analyze", "Run LLVM analysis tool").dependOn(&analyze.step);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.c5fe6d07",
+  "version": "0.1.0-dev.d3e796d5",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",
@@ -73,30 +73,30 @@
     "access": "public"
   },
   "dependencies": {
-    "@pkmn/data": "^0.7.46",
-    "@pkmn/protocol": "^0.6.12"
+    "@pkmn/data": "^0.7.50",
+    "@pkmn/protocol": "^0.6.13"
   },
   "devDependencies": {
-    "@pkmn/eslint-config": "^5.0.0",
-    "@pkmn/img": "^0.2.13",
+    "@pkmn/eslint-config": "^5.2.0",
+    "@pkmn/img": "^0.2.15",
     "@pkmn/sets": "^5.0.4",
-    "@pkmn/sim": "0.7.46",
+    "@pkmn/sim": "0.7.50",
     "@types/html-minifier": "^4.0.2",
-    "@types/jest": "^29.5.3",
+    "@types/jest": "^29.5.4",
     "@types/minimist": "^1.2.2",
     "@types/mustache": "^4.2.2",
-    "@types/node": "^20.4.2",
+    "@types/node": "^20.5.9",
     "@vitest/coverage-c8": "^0.33.0",
     "binaryen": "^114.0.0",
-    "eslint": "^8.44.0",
+    "eslint": "^8.48.0",
     "html-minifier": "^4.0.0",
     "json-stringify-pretty-compact": "3.0.0",
     "minimist": "^1.2.8",
     "mustache": "^4.2.0",
     "source-map-support": "^0.5.21",
     "trakr": "^0.2.0",
-    "typescript": "^5.1.6",
-    "vitest": "^0.33.0"
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.4"
   },
   "scripts": {
     "lint": "eslint --cache src --ext ts,js && eslint src/bin/*",

package/src/lib/common/protocol.zig

@@ -136,6 +136,8 @@ pub const Damage = enum(u8) {
     Confusion,
     LeechSeed,
     RecoilOf,
+
+    Spikes,
 };
 
 pub const Status = enum(u8) {
@@ -264,7 +266,15 @@ pub fn Log(comptime Writer: type) type {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Switch), @as(u8, @bitCast(ident)) });
-            try self.writer.writeAll(&.{ @intFromEnum(pokemon.species), pokemon.level });
+            if (@hasField(@TypeOf(pokemon.*), "dvs")) {
+                try self.writer.writeAll(&.{
+                    @intFromEnum(pokemon.species),
+                    @intFromEnum(pokemon.dvs.gender),
+                    pokemon.level,
+                });
+            } else {
+                try self.writer.writeAll(&.{ @intFromEnum(pokemon.species), pokemon.level });
+            }
             try self.writer.writeIntNative(u16, pokemon.hp);
             try self.writer.writeIntNative(u16, pokemon.stats.hp);
             try self.writer.writeAll(&.{pokemon.status});
@@ -646,9 +656,13 @@ pub const ByteStream = struct {
 };
 
 pub const Kind = enum { Move, Species, Type, Status };
-pub const Formatter = fn (Kind, u8) []const u8;
 
-pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, color: bool) void {
+pub fn format(
+    comptime gen: anytype,
+    a: []const u8,
+    b: ?[]const u8,
+    color: bool,
+) void {
     print("\n", .{});
 
     var i: usize = 0;
@@ -701,17 +715,27 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .Move => {
                 const source = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(source.player), source.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
                 const target = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(target.player), target.id }, a, b, &i, 1, color);
                 const reason: Move = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
-                if (reason == .From) printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                if (reason == .From) {
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
+                }
             },
             .Switch => {
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Species, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Species, a[i])}, a, b, &i, 1, color);
+                if (@hasDecl(gen, "Gender")) {
+                    if (a[i] == N(gen.Gender.Unknown)) {
+                        i += 1;
+                    } else {
+                        var gender = if (a[i] == N(gen.Gender.Male)) "M" else "F";
+                        printc(", {s}", .{gender}, a, b, &i, 1, color);
+                    }
+                }
                 printc(" L{d}", .{a[i]}, a, b, &i, 1, color);
                 switch (endian) {
                     .Big => {
@@ -727,7 +751,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
                 }
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
             },
             .Cant => {
                 const id = ID.from(@intCast(a[i]));
@@ -735,7 +759,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                 const reason: Cant = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
                 if (reason == .Disable) {
-                    printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
                 }
             },
             .Faint,
@@ -775,7 +799,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
                 }
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
                 if (arg == .Damage) {
                     const reason: Damage = @enumFromInt(a[i]);
                     printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
@@ -795,15 +819,17 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .Status => {
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
                 const reason: Status = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
-                if (reason == .From) printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                if (reason == .From) {
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
+                }
             },
             .CureStatus => {
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Status, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Status, a[i])}, a, b, &i, 1, color);
                 const reason: CureStatus = @enumFromInt(a[i]);
                 printc(" {s}", .{@tagName(reason)}, a, b, &i, 1, color);
             },
@@ -826,7 +852,7 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
             .Prepare => {
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
-                printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
             },
             .Activate => {
                 const id = ID.from(@intCast(a[i]));
@@ -841,12 +867,12 @@ pub fn format(comptime formatter: Formatter, a: []const u8, b: ?[]const u8, colo
                 if (@as(Start, @enumFromInt(reason)) == .TypeChange) {
                     const types = @as(gen1.Types, @bitCast(a[i]));
                     const args = .{
-                        formatter(.Type, @intFromEnum(types.type1)),
-                        formatter(.Type, @intFromEnum(types.type2)),
+                        formatter(gen, .Type, @intFromEnum(types.type1)),
+                        formatter(gen, .Type, @intFromEnum(types.type2)),
                     };
                     printc(" {s}/{s}", args, a, b, &i, 1, color);
                 } else if (reason >= @intFromEnum(Start.Disable)) {
-                    printc(" {s}", .{formatter(.Move, a[i])}, a, b, &i, 1, color);
+                    printc(" {s}", .{formatter(gen, .Move, a[i])}, a, b, &i, 1, color);
                 }
             },
             .End => {
@@ -896,7 +922,7 @@ fn printc(
 }
 
 pub fn expectLog(
-    comptime formatter: Formatter,
+    comptime gen: anytype,
     expected: []const u8,
     actual: []const u8,
     offset: usize,
@@ -915,8 +941,8 @@ pub fn expectLog(
 
     expectEqualBytes(expected, actual, offset) catch |err| switch (err) {
         error.TestExpectedEqual => {
-            format(formatter, expected, null, color);
-            format(formatter, actual, expected, color);
+            format(gen, expected, null, color);
+            format(gen, actual, expected, color);
             return err;
         },
         else => return err,
@@ -956,6 +982,11 @@ const gen1 = struct {
     pub const helpers = @import("../gen1/helpers.zig");
 };
 
+const gen2 = struct {
+    pub usingnamespace @import("../gen2/data.zig");
+    pub const helpers = @import("../gen2/helpers.zig");
+};
+
 var buf: [gen1.LOGS_SIZE]u8 = undefined;
 var stream = ByteStream{ .buffer = &buf };
 var log: FixedLog = .{ .writer = stream.writer() };
@@ -964,15 +995,19 @@ const M = gen1.Move;
 const S = gen1.Species;
 
 fn expectLog1(expected: []const u8, actual: []const u8) !void {
-    return expectLog(gen1Formatter, expected, actual, 0);
+    return expectLog(gen1, expected, actual, 0);
 }
 
-fn gen1Formatter(kind: Kind, byte: u8) []const u8 {
+fn expectLog2(expected: []const u8, actual: []const u8) !void {
+    return expectLog(gen2, expected, actual, 0);
+}
+
+fn formatter(comptime gen: anytype, kind: Kind, byte: u8) []const u8 {
     return switch (kind) {
-        .Move => @tagName(@as(M, @enumFromInt(byte))),
-        .Species => @tagName(@as(S, @enumFromInt(byte))),
-        .Type => @tagName(@as(gen1.Type, @enumFromInt(byte))),
-        .Status => gen1.Status.name(byte),
+        .Move => @tagName(@as(gen.Move, @enumFromInt(byte))),
+        .Species => @tagName(@as(gen.Species, @enumFromInt(byte))),
+        .Type => @tagName(@as(gen.Type, @enumFromInt(byte))),
+        .Status => gen.Status.name(byte),
     };
 }
 
@@ -1057,6 +1092,25 @@ test "|switch|" {
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
+
+    var blissey = gen2.helpers.Pokemon.init(.{ .species = .Blissey, .moves = &.{.Splash} });
+    blissey.level = 91;
+    blissey.hp = 200;
+    blissey.stats.hp = 400;
+    blissey.status = gen2.Status.init(.PAR);
+    try log.switched(p2.ident(3), &blissey);
+    expected = &(.{
+        N(ArgType.Switch),
+        0b1011,
+        N(gen2.Species.Blissey),
+        N(gen2.Gender.Female),
+        91,
+    } ++ switch (endian) {
+        .Big => .{ 0, 200, 1, 144, par },
+        .Little => .{ 200, 0, 144, 1, par },
+    });
+    try expectLog2(expected, buf[0..10]);
+    stream.reset();
 }
 
 test "|cant|" {

package/src/lib/gen1/calc.zig

@@ -29,7 +29,6 @@ const Optional = optional.Optional;
 const Rational = rational.Rational;
 
 const PointerType = util.PointerType;
-const FieldType = util.FieldType;
 
 const Actions = chance.Actions;
 const Action = chance.Action;

package/src/lib/gen1/mechanics.zig

@@ -214,12 +214,9 @@ fn selectMove(
             }
             break :ok true;
         };
-
         assert(struggle);
-        saveMove(battle, player, choice);
-    } else {
-        saveMove(battle, player, choice);
     }
+    saveMove(battle, player, choice);
 
     return null;
 }

package/src/lib/gen2/README.md

@@ -219,6 +219,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

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

@@ -279,9 +279,11 @@ pub const Move = enum(u8) {
         target: Target,
         /// The chance of the move's secondary effect occurring.
         chance: u8 = 0,
+        /// The priority of the move
+        priority: i8 = 0,
 
         comptime {
-            assert(@sizeOf(Data) == 7);
+            assert(@sizeOf(Data) == 8);
         }
     };
 
@@ -450,6 +452,7 @@ pub const Move = enum(u8) {
             .pp = 20,
             .accuracy = 100,
             .target = .Other,
+            .priority = -1,
         },
         // Fly
         .{
@@ -709,6 +712,7 @@ pub const Move = enum(u8) {
             .pp = 20,
             .accuracy = 100,
             .target = .Other,
+            .priority = -1,
         },
         // Sing
         .{
@@ -916,6 +920,7 @@ pub const Move = enum(u8) {
             .pp = 20,
             .accuracy = 100,
             .target = .Depends,
+            .priority = -1,
         },
         // SeismicToss
         .{
@@ -1191,6 +1196,7 @@ pub const Move = enum(u8) {
             .pp = 30,
             .accuracy = 100,
             .target = .Other,
+            .priority = 1,
         },
         // Rage
         .{
@@ -1962,6 +1968,7 @@ pub const Move = enum(u8) {
             .pp = 10,
             .accuracy = 100,
             .target = .Self,
+            .priority = 2,
         },
         // MachPunch
         .{
@@ -1971,6 +1978,7 @@ pub const Move = enum(u8) {
             .pp = 30,
             .accuracy = 100,
             .target = .Other,
+            .priority = 1,
         },
         // ScaryFace
         .{
@@ -2102,6 +2110,7 @@ pub const Move = enum(u8) {
             .pp = 5,
             .accuracy = 100,
             .target = .Self,
+            .priority = 2,
         },
         // BoneRush
         .{
@@ -2156,6 +2165,7 @@ pub const Move = enum(u8) {
             .pp = 10,
             .accuracy = 100,
             .target = .Self,
+            .priority = 2,
         },
         // Charm
         .{
@@ -2433,6 +2443,7 @@ pub const Move = enum(u8) {
             .pp = 10,
             .accuracy = 100,
             .target = .Other,
+            .priority = -1,
         },
         // MorningSun
         .{
@@ -2525,6 +2536,7 @@ pub const Move = enum(u8) {
             .pp = 20,
             .accuracy = 100,
             .target = .Depends,
+            .priority = -1,
         },
         // PsychUp
         .{
@@ -2543,6 +2555,7 @@ pub const Move = enum(u8) {
             .pp = 5,
             .accuracy = 100,
             .target = .Other,
+            .priority = 1,
         },
         // AncientPower
         .{
@@ -2770,7 +2783,7 @@ pub const Move = enum(u8) {
 
     comptime {
         assert(@sizeOf(Move) == 1);
-        assert(@sizeOf(@TypeOf(DATA)) == 1757);
+        assert(@sizeOf(@TypeOf(DATA)) == 2008);
     }
 
     /// The number of Pokémon moves in this generation.

package/src/lib/gen2/data.zig

@@ -5,6 +5,7 @@ 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");
 
@@ -15,6 +16,8 @@ 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 assert = std.debug.assert;
@@ -33,6 +36,9 @@ pub const LOGS_SIZE = if (builtin.mode == .ReleaseSmall)
 else
     std.math.ceilPowerOfTwo(usize, MAX_LOGS) catch unreachable;
 
+///  Null object pattern implementation of pkmn.battle.Options for Generation II.
+pub const NULL = pkmn.battle.options(protocol.NULL, chance.NULL, calc.NULL);
+
 const Choice = data.Choice;
 const ID = data.ID;
 const Player = data.Player;
@@ -82,7 +88,7 @@ test Battle {
     try expectEqual(496, @sizeOf(Battle(PRNG)));
 }
 
-const Field = packed struct {
+pub const Field = packed struct {
     weather: Weather = .None,
     weather_duration: u4 = 0,
 
@@ -91,19 +97,21 @@ const Field = packed struct {
     }
 };
 
-const Weather = enum(u4) {
+pub const Weather = enum(u4) {
     None,
     Rain,
     Sun,
     Sandstorm,
 };
 
-const Side = extern struct {
+pub const Side = extern struct {
     pokemon: [6]Pokemon = [_]Pokemon{.{}} ** 6,
     active: ActivePokemon = .{},
-    conditions: Conditions,
-    last_used_move: Move = .None,
+    conditions: Conditions = .{},
+    // NB: wCurPlayerMove / wCurEnemyMove (?)
     _: u8 = 0,
+    // NB: wLastPlayerCounterMove / wLastEnemyCounterMove (wLastPlayerMove / wLastEnemyMove)
+    last_used_move: Move = .None,
 
     const Conditions = packed struct {
         Spikes: bool = false,
@@ -136,17 +144,30 @@ const Side = extern struct {
         assert(@typeInfo(@TypeOf(self)).Pointer.child == Side);
         return self.get(1);
     }
+
+    pub inline fn lastMove(self: anytype, encore: bool) Move {
+        assert(self.last_used_move != .None or !self.active.volatiles.dirty);
+        if (encore) return self.last_used_move;
+        return if (self.active.volatiles.dirty) .None else self.last_used_move;
+    }
+
+    // TODO
+    // pub inline fn useMove(self: anytype) void {
+    //     assert(side.last_selected_move != .None);
+    //     self.last_used_move = side.last_selected_move;
+    //     self.active.volatiles.dirty = false;
+    // }
 };
 
 // NOTE: DVs (Gender & Hidden Power) and Happiness are stored only in Pokemon
-const ActivePokemon = extern struct {
-    volatiles: Volatile align(4) = .{},
+pub const ActivePokemon = extern struct {
+    volatiles: Volatiles align(4) = .{},
     stats: Stats(u16) = .{},
     moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
     boosts: Boosts = .{},
+    types: Types = .{},
     species: Species = .None,
-    item: Item = .None,
-    last_move: Move = .None,
+
     _: u8 = 0,
 
     comptime {
@@ -161,7 +182,7 @@ const ActivePokemon = extern struct {
     }
 };
 
-const Pokemon = extern struct {
+pub const Pokemon = extern struct {
     stats: Stats(u16) = .{},
     moves: [4]MoveSlot = [_]MoveSlot{.{}} ** 4,
     types: Types = .{},
@@ -192,7 +213,7 @@ pub const Gender = enum(u2) {
     Unknown,
 };
 
-const DVs = packed struct {
+pub const DVs = packed struct {
     gender: Gender = .Male,
     pow: u6 = 40,
     type: Type = .Dark,
@@ -248,7 +269,7 @@ test DVs {
     try expectEqual(Gender.Female, dvs.gender);
 }
 
-const MoveSlot = packed struct {
+pub const MoveSlot = packed struct {
     id: Move = .None,
     pp_ups: u2 = 3,
     pp: u6 = 0,
@@ -260,7 +281,7 @@ const MoveSlot = packed struct {
 
 pub const Status = gen1.Status;
 
-const Volatile = packed struct {
+pub const Volatiles = packed struct {
     Bide: bool = false,
     Thrashing: bool = false,
     Flinch: bool = false,
@@ -294,8 +315,9 @@ const Volatile = packed struct {
     trapped: bool = false,
     switched: bool = false,
     switching: bool = false,
+    dirty: bool = false,
 
-    _: u5 = 0,
+    _: u4 = 0,
 
     bind: u4 = 0,
     future_sight: FutureSight = .{},
@@ -306,10 +328,11 @@ const Volatile = packed struct {
     toxic: u8 = 0,
     confusion: u4 = 0,
     encore: u4 = 0,
+    // TODO merge with attacks (ie rollout/thrashing)? need to be zeroed at same time
     fury_cutter: u4 = 0,
     perish_song: u4 = 0,
     protect: u4 = 0,
-    rollout: u4 = 0,
+    attacks: u4 = 0, // bide/thrashing/rollout turns
 
     const Disabled = packed struct {
         move: u4 = 0,
@@ -322,7 +345,7 @@ const Volatile = packed struct {
     };
 
     comptime {
-        assert(@sizeOf(Volatile) == 16);
+        assert(@sizeOf(Volatiles) == 16);
     }
 };
 
@@ -406,6 +429,7 @@ test Move {
     try expectEqual(Move.Effect.ConfusionChance, move.effect);
     try expectEqual(@as(u8, 50), move.accuracy);
     try expectEqual(@as(u8, 5), move.pp);
+    try expectEqual(@as(i8, -1), Move.get(.Counter).priority);
 }
 
 pub const Species = species.Species;

package/src/lib/gen2/helpers.zig

@@ -48,7 +48,7 @@ pub const Battle = struct {
         comptime rolls: anytype,
         p1: []const Pokemon,
         p2: []const Pokemon,
-    ) data.Battle(rng.FixedRNG(1, rolls.len)) {
+    ) data.Battle(rng.FixedRNG(2, rolls.len)) {
         return .{
             .rng = .{ .rolls = rolls },
             .sides = .{ Side.init(p1), Side.init(p2) },
@@ -87,7 +87,7 @@ pub const Side = struct {
 
         for (0..ps.len) |i| {
             side.pokemon[i] = Pokemon.init(ps[i]);
-            // FIXME side.order[i] = i + 1;
+            side.pokemon[i].position = @as(u4, @intCast(i)) + 1;
         }
         return side;
     }
@@ -98,7 +98,7 @@ pub const Side = struct {
 
         for (0..n) |i| {
             side.pokemon[i] = Pokemon.random(rand, opt);
-            side.pokemon[i].position = i + 1;
+            side.pokemon[i].position = @as(u4, @intCast(i)) + 1;
         }
 
         return side;
@@ -139,7 +139,7 @@ pub const Pokemon = struct {
                 .id = m,
                 .pp_ups = 3,
                 // NB: PP can be at most 61 legally (though can overflow to 63)
-                .pp = @intCast(@min(Move.pp(m) / 5 * 8, 61)),
+                .pp = @intCast(@min(Move.get(m).pp / 5 * 8, 61)),
             };
         }
         pokemon.item = p.item;
@@ -151,7 +151,7 @@ pub const Pokemon = struct {
         pokemon.status = p.status;
         pokemon.types = species.types;
         pokemon.level = p.level;
-        pokemon.dvs = DVs.from(p.dvs);
+        pokemon.dvs = DVs.from(p.species, p.dvs);
         return pokemon;
     }
 
@@ -189,7 +189,8 @@ pub const Pokemon = struct {
             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: u8 = @intCast(Move.pp(m) + pp_ups * @min(Move.pp(m) / 5, 7));
+            var base = Move.get(m).pp;
+            const max_pp: u8 = @intCast(base + pp_ups * @min(base / 5, 7));
             ms[i] = .{
                 .id = m,
                 .pp_ups = pp_ups,
@@ -199,7 +200,7 @@ pub const Pokemon = struct {
         return .{
             .species = s,
             .types = species.types,
-            .dvs = DVs.from(dvs),
+            .dvs = DVs.from(s, dvs),
             .level = lvl,
             .stats = stats,
             .hp = if (opt.cleric) stats.hp else rand.range(u16, 0, stats.hp + 1),

package/src/lib/gen2/mechanics.zig

@@ -36,19 +36,483 @@ const Stats = data.Stats;
 const Status = data.Status;
 
 pub fn update(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Result {
+    assert(c1.type != .Pass or c2.type != .Pass or battle.turn == 0);
+    if (battle.turn == 0) return start(battle, options);
+
+    if (try turnOrder(battle, c1, c2, options) == .P1) {
+        if (try doTurn(battle, .P1, c1, .P2, c2, options)) |r| return r;
+    } else {
+        if (try doTurn(battle, .P2, c2, .P1, c1, options)) |r| return r;
+    }
+
+    return endTurn(battle, options);
+}
+
+fn start(battle: anytype, options: anytype) !Result {
+    const p1 = battle.side(.P1);
+    const p2 = battle.side(.P2);
+
+    var p1_slot = findFirstAlive(p1);
+    assert(!showdown or p1_slot == 1);
+    if (p1_slot == 0) return if (findFirstAlive(p2) == 0) Result.Tie else Result.Lose;
+
+    var p2_slot = findFirstAlive(p2);
+    assert(!showdown or p2_slot == 1);
+    if (p2_slot == 0) return Result.Win;
+
+    try switchIn(battle, .P1, p1_slot, true, options);
+    try switchIn(battle, .P2, p2_slot, true, options);
+
+    return endTurn(battle, options);
+}
+
+fn findFirstAlive(side: *const Side) u8 {
+    for (side.pokemon, 0..) |pokemon, i| if (pokemon.hp > 0) return side.pokemon[i].position;
+    return 0;
+}
+
+fn selectMove(battle: anytype, player: Player, choice: Choice) void {
+    if (choice.type == .Pass) return; // FIXME BATON PASS
+
+    var side = battle.side(player);
+    var volatiles = &side.active.volatiles;
+
+    // pre-battle menu
+    const forced = forced: {
+        if (volatiles.Recharging) break :forced true;
+        // Pokémon Showdown removes Flinch at the end-of-turn in its residual handler
+        if (!showdown) {
+            volatiles.Flinch = false;
+            battle.foe(player).active.volatiles.Flinch = false;
+        }
+        break :forced (volatiles.Thrashing or volatiles.Charging or volatiles.Rollout);
+    };
+
+    // battle menu
+    if (choice.type == .Switch) return;
+    assert(choice.type == .Move and (!forced or choice.data == @intFromBool(showdown)));
+
+    done: {
+        if (forced) break :done;
+        // pre-move select
+        if (volatiles.Encore) {
+            // TODO wCurPlayerMove = side.lastMove(true);
+            // assert(wCurPlayerMove != .None);
+            volatiles.Bide = false; // FIXME wPlayerCharging vs. SUBSTATUS_BIDE?
+            const effect = Move.get(.Pound).effect; // TODO
+            if (effect != .FuryCutter) volatiles.fury_cutter = false;
+            if (effect != .Rage) {
+                volatiles.Rage = false;
+                volatiles.rage = 0;
+            }
+            if (effect != .Protect and effect != .Endure) volatiles.protect = 0;
+            return;
+        }
+        if (volatiles.Bide) break :done;
+        // move select
+        if (choice.data == 0) {
+            const struggle = ok: {
+                for (side.active.moves, 0..) |move, i| {
+                    if (move.pp > 0 and volatiles.disabled_move != i + 1) break :ok false;
+                }
+                break :ok true;
+            };
+            assert(struggle);
+            // TODO wCurPlayerMove = .Struggle;
+        } else {
+            assert(showdown or side.active.volatiles.disabled_move != choice.data);
+            const move = side.active.move(choice.data);
+            // You cannot *select* a move with 0 PP
+            assert(move.pp != 0);
+            // TODO wCurPlayerMove = move.id;
+            // battle.lastMove(player).index = @intCast(c.data);
+        }
+    }
+
+    volatiles.Rage = false;
+    volatiles.rage = 0;
+    volatiles.fury_cutter = 0;
+    volatiles.protect = 0;
+}
+
+fn saveMove(battle: anytype) void {
     _ = battle;
-    _ = c1;
-    _ = c2;
+    return null;
+}
+
+fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, options: anytype) !void {
+    var side = battle.side(player);
+    var foe = battle.foe(player);
+
+    var active = &side.active;
+    const incoming = side.get(slot);
+
+    assert(incoming.hp != 0);
+    assert(slot != 1 or initial);
+
+    const out = side.pokemon[0].position;
+    side.pokemon[0].position = side.pokemon[slot - 1].position;
+    side.pokemon[slot - 1].position = out;
+
+    side.last_used_move = .None;
+    foe.active.volatiles.dirty = true;
+
+    active.volatiles = .{};
+    active.stats = incoming.stats;
+    active.moves = incoming.moves;
+    active.boosts = .{};
+    active.types = incoming.types;
+    active.species = incoming.species;
+
+    statusModify(incoming.status, &active.stats);
+
+    try options.log.switched(battle.active(player), incoming);
+    // TODO: options.chance.switched(player, side.order[0], out);
+
+    if (side.conditions.Spikes and !active.types.includes(.Flying)) {
+        incoming.hp -|= @max(incoming.stats.hp / 8, 1);
+        try options.log.damage(battle.active(player), incoming, .Spikes);
+    }
+}
+
+fn turnOrder(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Player {
+    assert(c1.type != .Pass or c2.type != .Pass);
+
+    if (c1.type == .Pass) return .P2;
+    if (c2.type == .Pass) return .P1;
+
+    // Pokémon Showdown always rolls for Quick Claw every turn, even if no Pokémon hold Quick Claw
+    // TODO: add to pending and only commit roll on Pokémon Showdown if roll is used
+    const qkc = showdown and try Rolls.quickClaw(battle, .P1, options);
+
+    if ((c1.type == .Switch) != (c2.type == .Switch)) return if (c1.type == .Switch) .P1 else .P2;
+
+    // https://www.smogon.com/forums/threads/adv-switch-priority.3622189/
+    // > In Gen 1 it's irrelevant [which player switches first] because switches happen instantly on
+    // > your own screen without waiting for the other player's choice (and their choice will appear
+    // > to happen first for them too, unless they attacked in which case your switch happens first)
+    // A cartridge-compatible implemention must not advance the RNG so we simply default to P1
+    const double_switch = c1.type == .Switch and c2.type == .Switch;
+    if (!showdown and double_switch) return .P1;
+
+    const m1 = .Pound; // TODO battle.side(.P1).last_selected_move;
+    const m2 = .Pound; // TODO battle.side(.P2).last_selected_move;
+    if (!showdown or !double_switch) {
+        const pri1 = Move.get(m1).priority;
+        const pri2 = Move.get(m2).priority;
+        if (pri1 != pri2) return if (pri1 > pri2) .P1 else .P2;
+
+        const qkc1 = battle.side(.P1).stored().item == .QuickClaw;
+        const qkc2 = battle.side(.P2).stored().item == .QuickClaw;
+        if (!showdown and qkc1 and qkc2) {
+            // If both Pokémon have Quick Claw the cartridge checks them in order and exits early if
+            // the first one procs, meaning the host has a slightly higher chance of going first
+            if (try Rolls.quickClaw(battle, .P1, options)) return .P1;
+            if (try Rolls.quickClaw(battle, .P2, options)) return .P2;
+        } else if (qkc1) {
+            const proc = if (showdown) qkc else try Rolls.quickClaw(battle, .P1, options);
+            if (proc) return .P1;
+        } else if (qkc2) {
+            const proc = if (showdown) qkc else try Rolls.quickClaw(battle, .P2, options);
+            if (proc) return .P2;
+        }
+    }
+
+    const spe1 = battle.side(.P1).active.stats.spe;
+    const spe2 = battle.side(.P2).active.stats.spe;
+    if (spe1 == spe2) {
+        // Pokémon Showdown's beforeTurnCallback shenanigans
+        if (showdown and !double_switch and hasCallback(m1) and hasCallback(m2)) {
+            battle.rng.advance(1);
+        }
+
+        const p1 = try Rolls.speedTie(battle, options);
+        if (!showdown) return if (p1) .P1 else .P2;
+
+        // Pokémon Showdown's "lockedmove" volatile's onBeforeTurn uses BattleQueue#changeAction,
+        // meaning that if a side is locked into a thrashing move and wins the speed tie, it
+        // actually uses its priority to simply insert its actual changed action into the queue,
+        // causing it to then execute *after* the side which should go second...
+        const t1 = battle.side(.P1).active.volatiles.Thrashing;
+        const t2 = battle.side(.P2).active.volatiles.Thrashing;
+        // If *both* sides are thrashing it really should be another speed tie, but we've patched
+        // that out and enforce host ordering of events, so P1 just goes first regardless of who
+        // won the original coin flip
+        if (t1 and t2) return .P1;
+        return if (p1) if (t1 and !t2) .P2 else .P1 else if (t2 and !t1) .P1 else .P2;
+    }
+
+    return if (spe1 > spe2) .P1 else .P2;
+}
+
+fn hasCallback(m: Move) bool {
+    return switch (m) {
+        .Counter, .MirrorCoat, .Pursuit => true,
+        else => false,
+    };
+}
+
+fn doTurn(
+    battle: anytype,
+    player: Player,
+    player_choice: Choice,
+    foe_player: Player,
+    foe_choice: Choice,
+    options: anytype,
+) !?Result {
+    assert(player_choice.type != .Pass);
+
+    const volatiles = &battle.side(player).active.volatiles;
+    const foe_volatiles = &battle.foe(player).active.volatiles;
+
+    volatiles.DestinyBond = false;
+    if (try executeMove(battle, player, player_choice, options)) |r| return r;
+    foe_volatiles.Protect = false;
+    foe_volatiles.Endure = false;
+    foe_volatiles.DestinyBond = false;
+
+    // foe_volatiles.DestinyBond = false;
+    if (try executeMove(battle, foe_player, foe_choice, options)) |r| return r;
+    volatiles.Protect = false;
+    volatiles.Endure = false;
+    volatiles.DestinyBond = false;
+
+    return null;
+}
+
+fn executeMove(battle: anytype, player: Player, choice: Choice, options: anytype) !?Result {
+    if (choice.type == .Switch) {
+        try switchIn(battle, player, choice.data, false, options);
+        return null;
+    }
+
+    assert(choice.type == .Move);
+    var mslot: u4 = @intCast(choice.data);
+
+    // const move = Move.get(side.last_selected_move);
+
+    // CheckTurn
+
+    return doMove(battle, player, options, mslot);
+}
+
+fn decrementPP(side: *Side, mslot: u4) void {
+    var active = &side.active;
+    const volatiles = &active.volatiles;
+
+    // TODO assert(side.last_selected_move != .Struggle);
+    assert(!volatiles.Charging and !volatiles.BeatUp and !volatiles.Thrashing and !volatiles.Bide);
+
+    assert(active.move(mslot).pp > 0);
+    active.move(mslot).pp = @as(u6, @intCast(active.move(mslot).pp)) -% 1;
+    if (volatiles.Transform) return;
+
+    // FIXME mimic
+
+    assert(side.stored().move(mslot).pp > 0);
+    side.stored().move(mslot).pp = @as(u6, @intCast(side.stored().move(mslot).pp)) -% 1;
+    assert(active.move(mslot).pp == side.stored().move(mslot).pp);
+}
+
+fn doMove(battle: anytype, player: Player, options: anytype, mslot: u4) !?Result {
     _ = options;
+    var side = battle.side(player);
+    const move = Move.get(.Teleport); // side.last_selected_move
+    switch (move.effect) {
+        .Teleport => {
+            // side.useMove();
+            decrementPP(side, mslot);
+        },
+        else => @panic("TODO"),
+    }
+    return null;
+}
+
+fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result {
+    battle.turn += 1;
+
+    if (showdown and battle.turn >= 1000) {
+        try options.log.tie();
+        return Result.Tie;
+    } else if (battle.turn >= 65535) {
+        return Result.Error;
+    }
+
+    try options.log.turn(battle.turn);
 
     return Result.Default;
 }
 
+pub const Effects = struct {
+    fn teleport(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        _ = battle;
+        _ = player;
+        _ = move;
+        _ = options;
+    }
+};
+
+fn statusModify(status: u8, stats: *Stats(u16)) void {
+    if (Status.is(status, .PAR)) {
+        stats.spe = @max(stats.spe / 4, 1);
+    } else if (Status.is(status, .BRN)) {
+        stats.atk = @max(stats.atk / 2, 1);
+    }
+}
+
+inline fn isForced(active: anytype) bool {
+    return active.volatiles.Recharging or active.volatiles.Rage or
+        active.volatiles.Thrashing or active.volatiles.Charging or
+        // FIXME TODO Underground or Flying?
+        active.volatiles.Underground or active.volatiles.Flying or
+        active.volatiles.Rollout;
+}
+
+pub const Rolls = struct {
+    inline fn speedTie(battle: anytype, options: anytype) !bool {
+        const p1 = if (options.calc.overridden(.P1, .speed_tie)) |player|
+            player == .P1
+        else if (showdown)
+            battle.rng.range(u8, 0, 2) == 0
+        else
+            battle.rng.next() < Gen12.percent(50) + 1;
+
+        try options.chance.speedTie(p1);
+        return p1;
+    }
+
+    inline fn quickClaw(battle: anytype, player: Player, options: anytype) !bool {
+        const qkc = if (options.calc.overridden(player, .quick_claw)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, 60, 256)
+        else
+            battle.rng.next() < 60;
+
+        try options.chance.quickClaw(player, qkc);
+        return qkc;
+    }
+};
+
+test "RNG agreement" {
+    if (!showdown) return;
+    var expected: [256]u32 = undefined;
+    for (0..expected.len) |i| {
+        expected[i] = @intCast(i * 0x1000000);
+    }
+
+    var spe = rng.FixedRNG(2, expected.len){ .rolls = expected };
+    var qkc = rng.FixedRNG(2, expected.len){ .rolls = expected };
+
+    for (0..expected.len) |i| {
+        try expectEqual(spe.range(u8, 0, 2) == 0, i < Gen12.percent(50) + 1);
+        try expectEqual(qkc.chance(u8, 60, 256), i < 60);
+    }
+}
+
 pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Choice) u8 {
-    _ = battle;
-    _ = player;
-    _ = request;
-    _ = out;
+    var n: u8 = 0;
+    switch (request) {
+        .Pass => {
+            out[n] = .{};
+            n += 1;
+        },
+        .Switch => {
+            const side = battle.side(player);
+            var slot: u4 = 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 };
+                n += 1;
+            }
+            if (n == 0) {
+                out[n] = .{};
+                n += 1;
+            }
+        },
+        .Move => {
+            const side = battle.side(player);
 
-    return 0;
+            var active = &side.active;
+            const stored = side.stored();
+
+            // While players are not given any input options on the cartridge in these cases,
+            // Pokémon Showdown instead produces a list with a single move that must be chosen.
+            //
+            // Given that no input is allowed on the cartridge 'Pass' seems like it would be logical
+            // here when not in compatibility mode, but the engine needs to be able to differentiate
+            // between passing while waiting for an opponent's forced switch after fainting and
+            // passing due to being forced into using a move. Instead of introducing another option
+            // we simply repurpose Move with no move slot, even though pedantically this is not
+            // strictly correct as the player would not have been presented the option to move or
+            // switch at all.
+            if (isForced(active)) {
+                out[n] = .{ .type = .Move, .data = @intFromBool(showdown) };
+                n += 1;
+                return n;
+            }
+
+            var slot: u4 = 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 };
+                n += 1;
+            }
+
+            const limited = active.volatiles.Bide or active.volatiles.bind > 0;
+            // On the cartridge, all of these happen after "FIGHT" (indicating you are not
+            // switching) but before you are allowed to select a move. Pokémon Showdown instead
+            // either disables all other moves in the case of limited or requires you to select a
+            // move normally if sleeping/frozen/bound.
+            if (!showdown and (limited or
+                Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP)))
+            {
+                out[n] = .{ .type = .Move, .data = 0 };
+                n += 1;
+                return n;
+            }
+
+            slot = 1;
+            // Pokémon Showdown handles Bide and Binding moves by checking if the move in question
+            // is present in the Pokémon's moveset (which means moves called via Metronome / Mirror
+            // Move will not result in forcing the subsequent use unless the user also had the
+            // proc-ed move in their moveset) and disabling all other moves.
+            if (limited) {
+                assert(showdown);
+                assert(side.last_selected_move != .None);
+                while (slot <= 4) : (slot += 1) {
+                    const m = active.moves[slot - 1];
+                    if (m.id == .None) break;
+                    if (m.id == if (active.volatiles.Bide) .Bide else side.last_selected_move) {
+                        // Pokémon Showdown displays Struggle if limited to Bide but unable to pick
+                        const struggle =
+                            m.id == .Bide and (m.pp == 0 or active.volatiles.disabled_move == slot);
+                        const s = if (struggle) 0 else slot;
+                        out[n] = .{ .type = .Move, .data = s };
+                        n += 1;
+                        return n;
+                    }
+                }
+            }
+
+            const before = n;
+            slot = 1;
+            while (slot <= 4) : (slot += 1) {
+                const m = active.moves[slot - 1];
+                if (m.id == .None) break;
+                if (m.pp == 0) continue;
+                if (active.volatiles.disabled_move == slot) continue;
+                out[n] = .{ .type = .Move, .data = slot };
+                n += 1;
+            }
+            // Struggle (Pokémon Showdown would use 'move 1' here)
+            if (n == before) {
+                out[n] = .{ .type = .Move, .data = 0 };
+                n += 1;
+            }
+        },
+    }
+    return n;
 }