@pkmn/engine 0.1.0-dev.bcb16a6c → 0.1.0-dev.be951af1

package/src/lib/gen2/mechanics.zig

@@ -6,22 +6,26 @@ 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 util = @import("../common/util.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 showdown = pkmn.options.showdown;
-
 const Activate = protocol.Activate;
+const Boost = protocol.Boost;
 const Cant = protocol.Cant;
 const Damage = protocol.Damage;
 const End = protocol.End;
@@ -30,6 +34,8 @@ const Start = protocol.Start;
 
 const Gen12 = rng.Gen12;
 
+const PointerType = util.PointerType;
+
 const ActivePokemon = data.ActivePokemon;
 const Effectiveness = data.Effectiveness;
 const Item = data.Item;
@@ -89,7 +95,25 @@ const CRITICAL_HITS = &[_]u8{
 
 const MAX_STAT_VALUE = 999;
 
-const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
+pub const State = struct {
+    damage: u16 = 0, // wCurDamage
+    effectiveness: u16 = Effectiveness.neutral, // wTypeModifier
+    bp: u8 = 0, // wPlayerMoveStructPower
+    move: Move = .None, // wCurPlayerMove
+    mslot: u4 = 0, // wCurMoveNum
+    first: bool = false, // wEnemyGoesFirst
+    miss: bool = false, // wAttackMissed
+    crit: bool = false, // wCriticalHit (NB: used on device for OHKO as well)
+    proc: bool = true, // wEffectFailed
+
+    comptime {
+        assert(@sizeOf(State) == 12);
+    }
+
+    inline fn immune(self: *State) bool {
+        return self.effectiveness == 0;
+    }
+};
 
 pub fn update(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Result {
     assert(c1.type != .Pass or c2.type != .Pass or battle.turn == 0);
@@ -169,14 +193,14 @@ fn selectMove(battle: anytype, player: Player, choice: Choice) void {
         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;
+                    if (move.pp > 0 and volatiles.disable.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);
+            assert(showdown or side.active.volatiles.disable.move != choice.data);
             const move = side.active.move(choice.data);
             // You cannot *select* a move with 0 PP
             assert(move.pp != 0);
@@ -316,22 +340,42 @@ fn doTurn(
     const volatiles = &battle.side(player).active.volatiles;
     const foe_volatiles = &battle.foe(player).active.volatiles;
 
+    // Technically this happens at the very beginning of update but its unused until now
+    // TODO: move into state and pass into betweenTurns
+    volatiles.frozen = false;
+    foe_volatiles.frozen = false;
+
     volatiles.DestinyBond = false;
-    if (try executeMove(battle, player, player_choice, options)) |r| return r;
+    if (try executeMove(battle, player, player_choice, true, options)) |r| return r;
     foe_volatiles.Protect = false;
     foe_volatiles.Endure = false;
     foe_volatiles.DestinyBond = false;
+    if (try checkFaint(battle, foe_player, options)) |r| return r;
+    if (try handleResidual(battle, player, options)) {
+        if (try checkFaint(battle, player, options)) |r| return r;
+    }
 
     // foe_volatiles.DestinyBond = false;
-    if (try executeMove(battle, foe_player, foe_choice, options)) |r| return r;
+    if (try executeMove(battle, foe_player, foe_choice, false, options)) |r| return r;
     volatiles.Protect = false;
     volatiles.Endure = false;
     volatiles.DestinyBond = false;
+    if (try checkFaint(battle, player, options)) |r| return r;
+    if (try handleResidual(battle, foe_player, options)) {
+        if (try checkFaint(battle, foe_player, options)) |r| return r;
+    }
 
-    return null;
+    // FIXME
+    return betweenTurns(battle, 0, options);
 }
 
-fn executeMove(battle: anytype, player: Player, choice: Choice, options: anytype) !?Result {
+fn executeMove(
+    battle: anytype,
+    player: Player,
+    choice: Choice,
+    first: bool,
+    options: anytype,
+) !?Result {
     if (choice.type == .Switch) {
         try switchIn(battle, player, choice.data, false, options);
         return null;
@@ -339,15 +383,17 @@ fn executeMove(battle: anytype, player: Player, choice: Choice, options: anytype
 
     assert(choice.type == .Move);
     var mslot: u4 = @intCast(choice.data);
+    var move = Move.Pound; // TODO
 
-    // const move = Move.get(side.last_selected_move);
+    if (!try beforeMove(battle, player, move, options)) return null;
 
-    // CheckTurn
-
-    return doMove(battle, player, options, mslot);
+    // FIXME: need damage from doTurn
+    var state: State = .{ .move = move, .mslot = mslot, .first = first };
+    _ = try TODO(battle, player, &state, options);
+    return generated.doMove(battle, player, &state, options);
 }
 
-fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
+fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bool {
     var log = options.log;
     var side = battle.side(player);
     // const foe = battle.foe(player);
@@ -356,8 +402,6 @@ fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
     const ident = battle.active(player);
     var volatiles = &active.volatiles;
 
-    const move = Move.Pound; // TODO
-
     if (volatiles.Recharging) {
         volatiles.Recharging = false;
         cantMove(volatiles);
@@ -408,16 +452,16 @@ fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
         return false;
     }
 
-    if (volatiles.disabled_duration > 0) {
+    if (volatiles.disable.duration > 0) {
         // if (options.calc.modify(player, .disable)) |extend| {
-        //     if (!extend) volatiles.disabled_duration = 0;
+        //     if (!extend) volatiles.disable.duration = 0;
         // } else {
-        volatiles.disabled_duration -= 1;
+        volatiles.disable.duration -= 1;
         // }
-        try options.chance.disable(player, volatiles.disabled_duration);
+        try options.chance.disable(player, volatiles.disable.duration);
 
-        if (volatiles.disabled_duration == 0) {
-            volatiles.disabled_move = 0;
+        if (volatiles.disable.duration == 0) {
+            volatiles.disable.move = 0;
             try log.end(ident, .Disable);
         }
     }
@@ -451,7 +495,7 @@ fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
     }
 
     if (volatiles.Attract) {
-        try log.atrract(ident, .Attract);
+        try log.activate(ident, .Attract);
 
         if (try Rolls.attract(battle, player, options)) {
             cantMove(volatiles);
@@ -460,9 +504,9 @@ fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
         }
     }
 
-    if (side.active.volatiles.disabled_move != 0) {
-        // A Pokémon that transforms after being disabled may end up with less move slots
-        const m = side.active.moves[side.active.volatiles.disabled_move - 1].id;
+    if (side.active.volatiles.disable.move != 0) {
+        // A Pokémon that transforms after being disable may end up with less move slots
+        const m = side.active.moves[side.active.volatiles.disable.move - 1].id;
         if (m != .None and m == move) {
             side.active.volatiles.Charging = false;
             cantMove(volatiles);
@@ -480,7 +524,7 @@ fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
     return true;
 }
 
-fn cantMove(volatiles: *Volatiles) void {
+fn cantMove(volatiles: *align(8) Volatiles) void {
     volatiles.Bide = false;
     volatiles.Thrashing = false;
     volatiles.Charging = false;
@@ -491,47 +535,82 @@ fn cantMove(volatiles: *Volatiles) void {
     volatiles.fury_cutter = 0;
 }
 
-fn canMove(battle: anytype, player: Player, options: anytype) !bool {
+fn canMove(battle: anytype, player: Player, options: anytype) !void {
     _ = battle;
     _ = player;
     _ = options;
     return false;
 }
 
-fn decrementPP(side: *Side, mslot: u4) void {
+pub fn decrementPP(side: *Side, move: Move, mslot: u4) bool {
     var active = &side.active;
     const volatiles = &active.volatiles;
 
-    // TODO assert(side.last_selected_move != .Struggle);
+    assert(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;
+    var move_slot = active.move(mslot);
+    if (move_slot.pp == 0) return false;
 
-    // FIXME mimic
+    move_slot.pp = @as(u6, @intCast(move_slot.pp)) -% 1;
+    if (volatiles.Transform) return true;
 
-    assert(side.stored().move(mslot).pp > 0);
-    side.stored().move(mslot).pp = @as(u6, @intCast(side.stored().move(mslot).pp)) -% 1;
+    move_slot = side.stored().move(mslot);
+    assert(move_slot.pp > 0);
+
+    if (move_slot.id == .Mimic and move != .Mimic) return true;
+
+    move_slot.pp = @as(u6, @intCast(move_slot.pp)) -% 1;
     assert(active.move(mslot).pp == side.stored().move(mslot).pp);
+
+    return true;
 }
 
-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"),
-    }
+fn TODO(battle: anytype, player: Player, state: *State, options: anytype) !?Result {
+    try checkHit(battle, player, state, options);
+    try checkCriticalHit(battle, player, state, options);
+    try calcDamage(battle, player, state, options);
+    try adjustDamage(battle, player, state, options);
+    try randomizeDamage(battle, player, state, options);
+    try applyDamage(battle, player, state, options);
+    try buildRage(battle, player, state, options);
+    try rageDamage(battle, player, state, options);
+    try kingsRock(battle, player, state, options);
+    _ = try destinyBond(battle, player, state, options);
+
+    try Effects.attract(battle, player, state, options);
+    try Effects.boost(battle, player, state, options);
+    try Effects.burnChance(battle, player, state, options);
+    try Effects.conversion(battle, player, state, options);
+    try Effects.conversion2(battle, player, state, options);
+    try Effects.defrost(battle, player, state, options);
+    try Effects.destinyBond(battle, player, state, options);
+    try Effects.disable(battle, player, state, options);
+    try Effects.drainHP(battle, player, state, options);
+    try Effects.encore(battle, player, state, options);
+    try Effects.falseSwipe(battle, player, state, options);
+    try Effects.fixedDamage(battle, player, state, options);
+    try Effects.focusEnergy(battle, player, state, options);
+    try Effects.forceSwitch(battle, player, state, options);
+    try Effects.foresight(battle, player, state, options);
+    try Effects.freezeChance(battle, player, state, options);
+    try Effects.happiness(battle, player, state, options);
+    try Effects.paralyzeChance(battle, player, state, options);
+    try Effects.poison(battle, player, state, options);
+    try Effects.poisonChance(battle, player, state, options);
+    try Effects.protect(battle, player, state, options);
+    try Effects.rage(battle, player, state, options);
+    try Effects.reversal(battle, player, state, options);
+    try Effects.sleep(battle, player, state, options);
+    try Effects.unboost(battle, player, state, options);
+    try Effects.weatherHeal(battle, player, state, options);
+
     return null;
 }
 
-fn checkCriticalHit(battle: anytype, player: Player, move: Move.Data, options: anytype) !bool {
-    if (move.bp == 0) return false;
+pub fn checkCriticalHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    const move = Move.get(state.move);
+    if (move.bp == 0) return;
 
     const side = battle.side(player);
     const pokemon = side.stored();
@@ -546,41 +625,38 @@ fn checkCriticalHit(battle: anytype, player: Player, move: Move.Data, options: a
     }
     assert(stage <= 4);
 
-    return Rolls.criticalHit(battle, player, CRITICAL_HITS[stage], options);
+    state.crit = try Rolls.criticalHit(battle, player, CRITICAL_HITS[stage], options);
 }
 
-fn calcDamage(
+pub fn calcDamage(
     battle: anytype,
     player: Player,
-    target_player: Player,
-    m: ?Move.Data,
-    crit: bool,
-) u16 {
+    state: *State,
+    options: anytype,
+) !void {
     _ = battle;
     _ = player;
-    _ = target_player;
-    _ = m;
-    _ = crit;
-    return 0;
+    _ = state;
+    _ = options;
 }
 
 const FORESIGHT: Types = .{ .type1 = .Normal, .type2 = .Fighting };
 
-fn adjustDamage(battle: anytype, player: Player, m: Move, damage: u16, effectiveness: *u16) u16 {
-    if (m == .Struggle) return;
+pub fn adjustDamage(battle: anytype, player: Player, state: *State, _: anytype) !void {
+    if (state.move == .Struggle) return;
 
     const side = battle.side(player);
     const foe = battle.foe(player);
     const types = foe.active.types;
-    const move = Move.get(side.m);
+    const move = Move.get(state.move);
 
-    var d = damage;
+    var d = state.damage;
     if ((move.type == .Water and battle.field.weather == .Rain) or
         (move.type == .Fire and battle.field.weather == .Sun))
     {
         d = d *% @intFromEnum(Effectiveness.Super) / 10;
     } else if ((move.type == .Water and battle.field.weather == .Sun) or
-        ((move.type == .Fire or m == .SolarBeam) and battle.field.weather == .Rain))
+        ((move.type == .Fire or state.move == .SolarBeam) and battle.field.weather == .Rain))
     {
         d = d *% @intFromEnum(Effectiveness.Resisted) / 10;
     }
@@ -590,17 +666,17 @@ fn adjustDamage(battle: anytype, player: Player, m: Move, damage: u16, effective
     const neutral = @intFromEnum(Effectiveness.Neutral);
     const foresight = foe.active.volatiles.Foresight and FORESIGHT.includes(move.type);
     const eff1: u16 = if (foresight and types.type1 == .Ghost)
-        10
+        neutral
     else
         @intFromEnum(move.type.effectiveness(types.type1));
     const eff2: u16 = if (foresight and types.type2 == .Ghost)
-        10
+        neutral
     else
         @intFromEnum(move.type.effectiveness(types.type2));
 
     // Type effectiveness matchup precedence only matters with (NVE, SE)
     if (!showdown and (eff1 + eff2) == Effectiveness.mismatch and
-        Type.precedence(move.type, types.type1) > Type.precedence(move.type, types.type2))
+        types.type1.precedence() > types.type2.precedence())
     {
         assert(eff2 != neutral);
         d = d *% eff2 / 10;
@@ -612,65 +688,79 @@ fn adjustDamage(battle: anytype, player: Player, m: Move, damage: u16, effective
         if (types.type1 != types.type2 and eff2 != neutral) d = d *% eff2 / 10;
     }
 
-    effectiveness.* = if (types.type1 == types.type2) eff1 * neutral else eff1 * eff2;
-    return d;
+    state.effectiveness = if (types.type1 == types.type2) eff1 * neutral else eff1 * eff2;
+    state.damage = d;
 }
 
-fn randomizeDamage(battle: anytype, player: Player, damage: u16, options: anytype) !u16 {
-    if (damage <= 1) return;
+pub fn randomizeDamage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    if (state.damage <= 1) return;
     const random = try Rolls.damage(battle, player, options);
-    options.calc.base(player.foe(), damage);
-    damage = @intCast(@as(u32, damage) *% random / 255);
-    options.calc.final(player.foe(), damage);
-    return damage;
+    options.calc.base(player.foe(), state.damage);
+    state.damage = @intCast(@as(u32, state.damage) *% random / 255);
+    options.calc.final(player.foe(), state.damage);
 }
 
-fn applyDamage(
+pub fn applyDamage(
     battle: anytype,
     player: Player,
+    state: *State,
     options: anytype,
-) !bool {
+) !void {
     _ = battle;
     _ = player;
+    _ = state;
     _ = options;
-    return false;
-}
-
-fn checkHit(battle: anytype, player: Player, move: Move.Data, options: anytype) !bool {
-    if (moveHit(battle, player, move, options)) return true;
-
-    // try options.chance.commit(player, .miss);
-    try options.log.lastmiss();
-    try options.log.miss(battle.active(player));
-
-    return false;
 }
 
 // TODO: set damage = 0 if missed and not (High) Jump Kick
-fn moveHit(
+pub fn checkHit(
     battle: anytype,
     player: Player,
-    move: Move.Data,
+    state: *State,
     options: anytype,
-) !bool {
+) !void {
     const side = battle.side(player);
     const foe = battle.foe(player);
 
-    if (move.effect == .DreamEater and !Status.is(foe.stored().status, .SLP)) return false;
-    if (foe.active.volatiles.Protect) return false;
+    const move = Move.get(state.move);
+
+    if (move.effect == .DreamEater and !Status.is(foe.stored().status, .SLP)) {
+        state.miss = true;
+        return;
+    }
+    if (foe.active.volatiles.Protect) {
+        state.miss = true;
+        return;
+    }
     const drain = move.effect == .DrainHP or move.effect == .DreamEater;
-    if (drain and foe.active.volatiles.Substitute) return false;
+    if (drain and foe.active.volatiles.Substitute) {
+        state.miss = true;
+        return;
+    }
     if (side.active.volatiles.LockOn) {
-        return !(foe.active.volatiles.Flying and move.extra.undeground);
+        state.miss = !(foe.active.volatiles.Flying and move.extra.underground);
+        return;
     }
     assert(!(foe.active.volatiles.Flying and foe.active.volatiles.Underground));
     if (foe.active.volatiles.Flying) {
-        if (!move.extra.flying) return false;
+        if (!move.extra.flying) {
+            state.miss = true;
+            return;
+        }
     } else if (foe.active.volatiles.Underground) {
-        if (!move.extra.underground) return false;
+        if (!move.extra.underground) {
+            state.miss = true;
+            return;
+        }
+    }
+    if (move.effect == .Thunder and battle.field.weather == .Rain) {
+        state.miss = false;
+        return;
+    }
+    if (move.effect == .AlwaysHit) {
+        state.miss = false;
+        return;
     }
-    if (move.effect == .Thunder and battle.field.weather == .Rain) return true;
-    if (move.effect == .AlwaysHit) return true;
 
     var accuracy: u16 = move.accuracy;
     if (foe.active.boosts.evasion <= side.active.boosts.accuracy or
@@ -688,8 +778,10 @@ fn moveHit(
     }
 
     // The accuracy roll is skipped entirely if maxed
-    if (accuracy == 255) return true;
-    return !try Rolls.hit(battle, player, @intCast(accuracy), options);
+    state.miss = if (accuracy == 255)
+        false
+    else
+        !try Rolls.hit(battle, player, @intCast(accuracy), options);
 }
 
 fn checkFaint(
@@ -697,20 +789,62 @@ fn checkFaint(
     player: Player,
     options: anytype,
 ) @TypeOf(options.log).Error!?Result {
-    _ = battle;
-    _ = player;
-    return null;
+    const side = battle.side(player);
+    const foe = battle.foe(player);
+
+    const player_fainted = side.stored().hp == 0;
+    const foe_fainted = foe.stored().hp == 0;
+    if (!(player_fainted or foe_fainted)) return null;
+
+    const player_out = player_fainted and findFirstAlive(side) == 0;
+    const foe_out = foe_fainted and findFirstAlive(foe) == 0;
+    const more = player_out or foe_out;
+
+    if (player_fainted) try faint(battle, player, !(more or foe_fainted), options);
+    if (foe_fainted) try faint(battle, player.foe(), !more, options);
+
+    if (player_out and foe_out) {
+        try options.log.tie();
+        return Result.Tie;
+    } else if (player_out) {
+        try options.log.win(player.foe());
+        return if (player == .P1) Result.Lose else Result.Win;
+    } else if (foe_out) {
+        try options.log.win(player);
+        return if (player == .P1) Result.Win else Result.Lose;
+    }
+
+    const foe_choice: Choice.Type = if (foe_fainted) .Switch else .Pass;
+    if (player == .P1) return .{ .p1 = .Switch, .p2 = foe_choice };
+    return .{ .p1 = foe_choice, .p2 = .Switch };
 }
 
-fn faint(battle: anytype, player: Player, done: bool, options: anytype) !?Result {
-    _ = battle;
-    _ = player;
-    _ = done;
-    _ = options;
-    return null;
+fn faint(battle: anytype, player: Player, done: bool, options: anytype) !void {
+    var side = battle.side(player);
+    var foe = battle.foe(player);
+    assert(side.stored().hp == 0);
+
+    var foe_volatiles = &foe.active.volatiles;
+    foe_volatiles.BeatUp = false;
+
+    // We always need to clear status for Pokémon Showdown's Sleep/Freeze Clause Mod
+    const status = side.stored().status;
+
+    side.stored().status = 0;
+    // This shouldn't matter, but Pokémon Showdown decides double switching priority based on speed,
+    // and resets a Pokémon's stats when it faints... only it still factors in paralysis -_-
+    if (showdown) {
+        side.active.stats.spe = if (Status.is(status, .PAR))
+            @max(side.stored().stats.spe / 4, 1)
+        else
+            side.stored().stats.spe;
+    }
+
+    try options.log.faint(battle.active(player), done);
+    options.calc.capped(player);
 }
 
-fn handleResidual(battle: anytype, player: Player, options: anytype) !void {
+fn handleResidual(battle: anytype, player: Player, options: anytype) !bool {
     var side = battle.side(player);
     var stored = side.stored();
     const ident = battle.active(player);
@@ -732,7 +866,7 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !void {
         stored.hp -|= damage;
         // Pokémon Showdown uses damageOf here but its not relevant in Generation II
         try options.log.damage(ident, stored, if (brn) Damage.Burn else Damage.Poison);
-        if (stored.hp == 0) return;
+        if (stored.hp == 0) return true;
     }
 
     if (volatiles.LeechSeed) {
@@ -754,28 +888,30 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !void {
         foe_stored.hp = @min(foe_stored.hp + damage, foe_stored.stats.hp);
         // Pokémon Showdown uses the less specific heal here instead of drain... because reasons?
         if (foe_stored.hp > before) try options.log.heal(foe_ident, foe_stored, .Silent);
-        if (stored.hp == 0) return;
+        if (stored.hp == 0) return true;
     }
 
     if (volatiles.Nightmare) {
         stored.hp -= @max(stored.stats.hp / 4, 1);
         // ibid
-        try options.log.damage(ident, stored, Damage.Nightmare);
-        if (stored.hp == 0) return;
+        try options.log.damage(ident, stored, .Nightmare);
+        if (stored.hp == 0) return true;
     }
 
     if (volatiles.Curse) {
         stored.hp -= @max(stored.stats.hp / 4, 1);
         // ibid
-        try options.log.damage(ident, stored, Damage.Curse);
-        if (stored.hp == 0) return;
+        try options.log.damage(ident, stored, .Curse);
+        if (stored.hp == 0) return true;
     }
+
+    return false;
 }
 
-fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
-    const players = std.enums.values(Player);
+fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !?Result {
+    const players = comptime std.enums.values(Player);
 
-    // TODO checkFaintThen(p1, p2);
+    if (try checkFaint(battle, .P1, options)) |r| return r;
 
     // Future Sight
     inline for (players) |player| {
@@ -791,7 +927,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
             }
         }
     }
-    // TODO checkFaintThen(p1, p2);
+    if (try checkFaint(battle, .P1, options)) |r| return r;
 
     // Weather
     if (battle.field.weather != .None) {
@@ -807,12 +943,12 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
                 inline for (players) |player| {
                     var side = battle.side(player);
                     const active = side.active;
-                    if (!(active.volatiles.underground or active.types.sandstormImmune())) {
+                    if (!(active.volatiles.Underground or active.types.sandstormImmune())) {
                         side.stored().hp -|= @max(side.stored().stats.hp / 8, 1);
                         try options.log.damage(battle.active(player), side.stored(), .Sandstorm);
                     }
                 }
-                // TODO checkFaintThen(p1, p2);
+                if (try checkFaint(battle, .P1, options)) |r| return r;
             }
         }
     }
@@ -822,22 +958,22 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
         var side = battle.side(player);
         var volatiles = &side.active.volatiles;
 
-        if (volatiles.bind > 0 and !volatiles.Substitute) {
-            volatiles.bind -= 1;
-            if (volatiles.bind == 0) {
-                const reason = @intFromEnum(End.Bind) + volatiles.bind_reason - 1;
+        if (volatiles.bind.duration > 0 and !volatiles.Substitute) {
+            volatiles.bind.duration -= 1;
+            if (volatiles.bind.duration == 0) {
+                const reason = @intFromEnum(End.Bind) + volatiles.bind.reason - 1;
                 try options.log.end(battle.active(player), @enumFromInt(reason));
             } else {
-                var reason = @intFromEnum(Activate.Bind) + volatiles.bind_reason - 1;
+                var reason = @intFromEnum(Activate.Bind) + volatiles.bind.reason - 1;
                 try options.log.activate(battle.active(player), @enumFromInt(reason));
 
-                reason = @intFromEnum(Activate.Damage) + volatiles.bind_reason - 1;
+                reason = @intFromEnum(Damage.Bind) + volatiles.bind.reason - 1;
                 side.stored().hp -|= @max(side.stored().stats.hp / 16, 1);
-                try options.log.damage(battle.active(player), side.stored(), reason);
+                try options.log.damage(battle.active(player), side.stored(), @enumFromInt(reason));
             }
         }
     }
-    // TODO checkFaintThen(p1, p2);
+    if (try checkFaint(battle, .P1, options)) |r| return r;
 
     // Perish Song
     inline for (players) |player| {
@@ -850,7 +986,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
 
             assert(volatiles.perish_song < 3);
             const reason = @intFromEnum(Start.PerishSong0) + volatiles.perish_song;
-            try options.log.start(battle.active(player), reason);
+            try options.log.start(battle.active(player), @enumFromInt(reason));
 
             if (volatiles.perish_song == 0) {
                 volatiles.PerishSong = false;
@@ -858,7 +994,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
             }
         }
     }
-    // TODO checkFaintThen(p1, p2);
+    if (try checkFaint(battle, .P1, options)) |r| return r;
 
     // Leftovers
     inline for (players) |player| {
@@ -896,22 +1032,21 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
     // Side Conditions
     if (showdown) {
         inline for (players) |player| {
-            updateSideCondition(battle, player, "Reflect", "reflect");
+            try updateSideCondition(battle, player, "Reflect", "reflect", options);
         }
         inline for (players) |player| {
-            updateSideCondition(battle, player, "LightScreen", "light_screen");
+            try updateSideCondition(battle, player, "LightScreen", "light_screen", options);
         }
         inline for (players) |player| {
-            updateSideCondition(battle, player, "Safeguard", "safeguard");
+            try updateSideCondition(battle, player, "Safeguard", "safeguard", options);
         }
     } else {
         inline for (players) |player| {
-            updateSideCondition(battle, player, "Safeguard", "safeguard");
+            try updateSideCondition(battle, player, "Safeguard", "safeguard", options);
         }
-
         inline for (players) |player| {
-            updateSideCondition(battle, player, "LightScreen", "light_screen");
-            updateSideCondition(battle, player, "Reflect", "reflect");
+            try updateSideCondition(battle, player, "LightScreen", "light_screen", options);
+            try updateSideCondition(battle, player, "Reflect", "reflect", options);
         }
     }
 
@@ -984,12 +1119,14 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
             assert(volatiles.encore > 0);
             volatiles.encore -= 1;
 
-            if (volatiles.encore == 0 or side.active.moves(mslot).pp == 0) {
+            if (volatiles.encore == 0 or side.active.move(mslot).pp == 0) {
                 volatiles.Encore = false;
                 try options.log.end(battle.active(player), .Encore);
             }
         }
     }
+
+    return null;
 }
 
 inline fn updateSideCondition(
@@ -1006,7 +1143,7 @@ inline fn updateSideCondition(
 
         if (@field(side.conditions, value) == 0) {
             @field(side.conditions, key) = false;
-            try options.log.sideend(battle.active(player), @field(protocol.Side, key));
+            try options.log.sideend(player, @field(protocol.Side, key));
         }
     }
 }
@@ -1026,206 +1163,1178 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
     return Result.Default;
 }
 
-pub const Effects = struct {
-    fn protect(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        var side = battle.side(player);
-        var volatiles = &side.active.volatiles;
-
-        // TODO or if we didn't go first
-        if (volatiles.Substitute) return try options.log.fail(battle.active(player), .None);
-
-        // TODO
-
-        if (move.effect == .Endure) {
-            volatiles.Endure = true;
+pub fn buildRage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    var foe = battle.foe(player);
+    if (foe.active.volatiles.Rage) {
+        if (showdown) {
+            // TODO if showdown boost
+            if (foe.active.boosts.atk < 6) {
+                try Effects.boost(battle, player, state, options);
+            }
         } else {
-            volatiles.Protect = true;
+            foe.active.volatiles.rage +|= 1;
+            try options.log.activate(battle.active(player), .Rage);
         }
-        try options.log.singleturn(battle.active(player), move.id);
     }
+}
 
-    const MAGNITUDE_POWER = [_]u8{ 10, 30, 50, 70, 90, 110, 150 };
-};
+pub fn rageDamage(battle: anytype, player: Player, state: *State, _: anytype) !void {
+    const volatiles = battle.side(player).active.volatiles;
+    assert(volatiles.Rage);
+    state.damage *|= (volatiles.rage +| 1);
+}
 
-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);
+pub fn kingsRock(battle: anytype, player: Player, _: *State, options: anytype) !void {
+    var foe = battle.foe(player);
+    const flinch = battle.side(player).stored().item == .KingsRock and
+        !foe.active.volatiles.Substitute and
+        try Rolls.item(battle, player, options);
+    if (flinch) {
+        foe.active.volatiles.Recharging = false;
+        foe.active.volatiles.Flinch = true;
     }
 }
 
-inline fn isForced(active: anytype) bool {
-    return active.volatiles.Recharging or active.volatiles.Rage or
-        active.volatiles.Thrashing or active.volatiles.Charging or
-        active.volatiles.Rollout;
-}
+pub fn destinyBond(battle: anytype, player: Player, _: *State, options: anytype) !bool {
+    const foe = battle.foe(player);
+    if (foe.stored().hp > 0) return false;
 
-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;
+    if (foe.active.volatiles.DestinyBond) {
+        battle.side(player).stored().hp = 0;
+        try options.log.activate(battle.active(player.foe()), .DestinyBond);
+    }
+    return true;
+}
 
-        try options.chance.speedTie(p1);
-        return p1;
+pub const Effects = struct {
+    pub fn alwaysHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    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;
+    pub fn attract(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        const side = battle.side(player);
+        var foe = battle.foe(player);
 
-        try options.chance.quickClaw(player, qkc);
-        return qkc;
+        const gender: u8 = @intFromEnum(side.stored().dvs.gender);
+        const foe_gender: u8 = @intFromEnum(foe.stored().dvs.gender);
+        if (gender + foe_gender != 1) {
+            try options.log.immune(battle.active(player.foe()), .None);
+            return;
+        } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+            try options.log.lastmiss();
+            try options.log.miss(battle.active(player));
+            return;
+        }
+
+        foe.active.volatiles.Attract = true;
+        try options.log.start(battle.active(player.foe()), .Attract);
     }
 
-    inline fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) !bool {
-        const ok = if (options.calc.overridden(player, .hit)) |val|
-            val == .true
-        else if (showdown)
-            battle.rng.chance(u8, accuracy, 256)
-        else
-            battle.rng.next() < accuracy;
+    pub fn batonPass(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
 
-        try options.chance.hit(player, ok, accuracy);
-        return ok;
+    pub fn beatUp(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    inline fn criticalHit(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
-        const crit = if (options.calc.overridden(player, .critical_hit)) |val|
-            val == .true
-        else if (showdown)
-            battle.rng.chance(u8, rate, 256)
-        else
-            battle.rng.next() < rate;
+    pub fn bellyDrum(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
 
-        try options.chance.criticalHit(player, crit, rate);
-        return crit;
+    pub fn bide(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    inline fn damage(battle: anytype, player: anytype, options: anytype) !u8 {
-        const roll = if (options.calc.overridden(player, .damage)) |val|
-            val
-        else roll: {
-            if (showdown) break :roll battle.rng.range(u8, 217, 256);
-            while (true) {
-                const r = std.math.rotr(u8, battle.rng.next(), 1);
-                if (r >= 217) break :roll r;
+    pub fn binding(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn burnChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+        var foe_stored = foe.stored();
+
+        if (foe.active.volatiles.Substitute) return;
+        if (Status.any(foe_stored.status)) {
+            if (Status.is(foe_stored.status, .FRZ)) {
+                assert(Move.get(state.move).type == .Fire);
+                try options.log.curestatus(
+                    battle.active(player.foe()),
+                    foe_stored.status,
+                    .Message,
+                );
+                foe_stored.status = 0;
             }
-        };
+            return;
+        }
+        if (!state.proc) return;
+        if (foe.conditions.Safeguard) return;
+        // No need to check for immunity because nothing is immune to Fire-type
+        assert(!state.immune());
+        if (foe.active.types.includes(Move.get(state.move).type)) return;
 
-        assert(roll >= 217 and roll <= 255);
-        try options.chance.damage(player, roll);
-        return roll;
-    }
+        foe_stored.status = Status.init(.BRN);
+        foe.active.stats.atk = @max(foe.active.stats.atk / 2, 1);
+        try options.log.status(battle.active(player.foe()), foe_stored.status, .None);
 
-    inline fn confused(battle: anytype, player: Player, options: anytype) !bool {
-        const cfz = if (options.calc.overridden(player, .confused)) |val|
-            val == .true
-        else if (showdown)
-            !battle.rng.chance(u8, 128, 256)
-        else
-            battle.rng.next() >= Gen12.percent(50) + 1;
+        // TODO: check for status berry
+    }
 
-        try options.chance.confused(player, cfz);
-        return cfz;
+    pub fn confusion(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    inline fn attract(battle: anytype, player: Player, options: anytype) !bool {
-        const cant = if (options.calc.overridden(player, .attract)) |val|
-            val == .true
-        else if (showdown)
-            battle.rng.chance(u8, 1, 2)
-        else
-            battle.rng.next() > Gen12.percent(50) + 1;
+    pub fn conversion(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
 
-        try options.chance.attract(player, cant);
-        return cant;
+        var n: u3 = 0;
+        for (side.active.moves) |m| {
+            if (convertible(side.active, m.id)) n += 1;
+        }
+        if (n == 0) {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
+
+        side.active.types.type1 = try Rolls.conversion(battle, player, n, options);
+        side.active.types.type2 = side.active.types.type1;
     }
 
-    inline fn paralyzed(battle: anytype, player: Player, options: anytype) !bool {
-        const par = if (options.calc.overridden(player, .paralyzed)) |val|
-            val == .true
-        else if (showdown)
-            battle.rng.chance(u8, 63, 256)
-        else
-            battle.rng.next() < Gen12.percent(25);
+    pub fn conversion2(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
 
-        try options.chance.paralyzed(player, par);
-        return par;
-    }
+        const last = battle.foe(player).lastMove(false);
+        if (last == .None) {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
+        const move = Move.get(last);
+        if (move.type == .@"???") {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
 
-    inline fn defrost(battle: anytype, player: Player, options: anytype) !bool {
-        const thaw = if (options.calc.overridden(player, .defrost)) |val|
-            val == .true
-        else if (showdown)
-            battle.rng.chance(u8, 25, 256)
-        else
-            battle.rng.next() < Gen12.percent(10);
+        side.active.types.type1 = try Rolls.conversion2(battle, player, move.type, options);
+        side.active.types.type2 = side.active.types.type1;
+    }
 
-        try options.chance.defrost(player, thaw);
-        return thaw;
+    pub fn counter(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    inline fn secondaryChance(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
-        // GLITCH: 100% secondary chance will still fail 1/256 of the time
-        const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
-            val == .true
-        else if (showdown)
-            battle.rng.chance(u8, rate, 256)
-        else
-            battle.rng.next() < rate;
+    pub fn curse(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
 
-        try options.chance.secondaryChance(player, proc, rate);
-        return proc;
+    pub fn defenseCurl(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    inline fn focusBand(battle: anytype, player: Player, options: anytype) !bool {
-        const proc = if (options.calc.overridden(player, .focus_band)) |val|
-            val == .true
-        else if (showdown)
-            battle.rng.chance(u8, 30, 256)
-        else
-            battle.rng.next() < 30;
+    pub fn defrost(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+        assert(Status.is(side.stored().status, .FRZ));
 
-        try options.chance.focusBand(player, proc);
-        return proc;
+        try options.log.curestatus(battle.active(player), side.stored().status, .Message);
+        side.stored().status = 0;
     }
 
-    inline fn kingsRock(battle: anytype, player: Player, options: anytype) !bool {
-        const proc = if (options.calc.overridden(player, .kings_rock)) |val|
-            val == .true
-        else if (showdown)
-            battle.rng.chance(u8, 30, 256)
-        else
-            battle.rng.next() < 30;
-
-        try options.chance.kingsRock(player, proc);
-        return proc;
+    pub fn destinyBond(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        battle.side(player).active.volatiles.DestinyBond = true;
+        try options.log.singlemove(battle.active(player), Move.DestinyBond);
     }
 
-    inline fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (showdown)
-            @intCast(battle.rng.range(u8, 1, 7))
-        else duration: {
-            while (true) {
-                const r = battle.rng.next() & 7;
-                if (r != 0 and r != 7) break :duration @intCast(r);
+    pub fn disable(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+        var volatiles = &foe.active.volatiles;
+        const foe_ident = battle.active(player.foe());
+
+        if (volatiles.disable.move != 0) {
+            try options.log.fail(foe_ident, .None);
+            return;
+        }
+
+        const last = battle.foe(player).lastMove(false);
+        if (last == .None or last == .Struggle) {
+            try options.log.fail(foe_ident, .None);
+            return;
+        }
+
+        var slot: u3 = 0;
+        for (foe.active.moves) |m| {
+            assert(m.id != .None);
+            slot += 1;
+            if (m.id == last) break;
+        }
+        const move = foe.active.move(slot);
+        if (move.pp == 0) {
+            try options.log.fail(foe_ident, .None);
+            return;
+        }
+
+        volatiles.disable.move = slot;
+        volatiles.disable.duration = Rolls.disableDuration(battle, player, options);
+
+        try options.log.startEffect(foe_ident, .Disable, move.id);
+    }
+
+    pub fn doubleHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn drainHP(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var stored = battle.side(player).stored();
+
+        assert(state.damage != 0);
+
+        if (stored.hp == stored.stats.hp) return;
+        stored.hp = @min(stored.stats.hp, stored.hp + @max(state.damage / 2, 1));
+
+        try options.log.drain(battle.active(player), stored, battle.active(player.foe()));
+    }
+
+    pub fn encore(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+        var volatiles = &foe.active.volatiles;
+        const foe_ident = battle.active(player.foe());
+
+        const last = battle.foe(player).lastMove(true);
+        const failed = volatiles.Encore or
+            (last == .None or last == .Struggle or
+            last == .Encore or .last == .MirrorMove);
+        if (failed) {
+            try options.log.fail(foe_ident, .None);
+            return;
+        }
+
+        var slot: u3 = 0;
+        for (foe.active.moves) |m| {
+            assert(m.id != .None);
+            slot += 1;
+            if (m.id == last) break;
+        }
+        const move = foe.active.move(slot);
+        if (move.pp == 0) {
+            try options.log.fail(foe_ident, .None);
+            return;
+        }
+
+        volatiles.Encore = true;
+        volatiles.encore = Rolls.encoreDuration(battle, player, options);
+
+        // TODO ???
+        _ = state;
+
+        try options.log.startEffect(foe_ident, .Encore, move.id);
+    }
+
+    pub fn explode(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn falseSwipe(battle: anytype, player: Player, state: *State, _: anytype) !void {
+        const foe = battle.foe(player);
+        assert(foe.stored().hp > 0);
+        // FIXME crit?
+        if (state.damage > foe.stored().hp) state.damage = foe.stored().hp - 1;
+    }
+
+    pub fn fixedDamage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        const side = battle.side(player);
+        const foe = battle.foe(player);
+
+        state.damage = switch (Move.get(state.move).effect) {
+            .SuperFang => @max(foe.stored().hp / 2, 1),
+            .LevelDamage => side.stored().level,
+            .FixedDamage => if (state.move == .SonicBoom) 20 else 40,
+            .Psywave => try Rolls.psywave(
+                battle,
+                player,
+                @intCast(@as(u16, side.stored().level) * 3 / 2),
+                options,
+            ),
+            else => unreachable,
+        };
+    }
+
+    pub fn flameWheel(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn flinchChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn flyDig(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn focusEnergy(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+
+        if (side.active.volatiles.FocusEnergy) {
+            if (!showdown) try options.log.fail(battle.active(player), .None);
+            return;
+        }
+
+        side.active.volatiles.FocusEnergy = true;
+        try options.log.start(battle.active(player), .FocusEnergy);
+    }
+
+    var SLOTS: [5]u4 = .{ 0, 0, 0, 0, 0 };
+
+    pub fn forceSwitch(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        const foe = battle.foe(player);
+
+        var n: u4 = 0;
+        var i: u4 = 0;
+        for (foe.pokemon, 0..) |pokemon, j| {
+            if (pokemon.species == .None) break;
+            n += 1;
+            if (pokemon.position == 1) continue;
+            if (pokemon.hp > 0) {
+                SLOTS[i] = @intCast(foe.pokemon[j].position);
+                i += 1;
+            }
+        }
+
+        if (n == 0) {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
+
+        _ = try Rolls.forceSwitch(battle, player, SLOTS[0..i], n, options); // TODO
+    }
+
+    pub fn foresight(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+
+        if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+            try options.log.lastmiss();
+            try options.log.miss(battle.active(player));
+            return;
+        } else if (foe.active.volatiles.Foresight) {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
+
+        foe.active.volatiles.Foresight = true;
+        try options.log.start(battle.active(player.foe()), .FocusEnergy);
+    }
+
+    pub fn freezeChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+        var foe_stored = foe.stored();
+        const foe_ident = battle.active(player.foe());
+
+        if (foe.active.volatiles.Substitute) return;
+        if (Status.any(foe_stored.status)) return;
+
+        // No need to check for immunity because nothing is immune to Ice-type
+        assert(!state.immune());
+        if (battle.field.weather == .Sun) return;
+        if (foe.active.types.includes(Move.get(state.move).type)) return;
+        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;
+
+        foe_stored.status = Status.init(.FRZ);
+        try options.log.status(foe_ident, foe_stored.status, .None);
+
+        // TODO: check for status berry
+
+        foe.active.volatiles.Recharging = false;
+        foe.active.volatiles.frozen = true;
+    }
+
+    pub fn furyCutter(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn futureSight(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn happiness(battle: anytype, player: Player, state: *State, _: anytype) !void {
+        const val = battle.side(player).stored().happiness;
+        const frustration = Move.get(state.move).effect == .Frustration;
+        state.bp = ((if (frustration) 255 - val else val) * 10) / 25;
+    }
+
+    pub fn haze(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn heal(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn healBell(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn hiddenPower(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn hyperBeam(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn jumpKick(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn leechSeed(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn lockOn(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    const MAGNITUDE_POWER = [_]u8{ 10, 30, 50, 70, 90, 110, 150 };
+
+    pub fn magnitude(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn meanLook(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn metronome(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn mimic(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn mirrorCoat(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn mirrorMove(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn mist(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn weatherHeal(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var stored = battle.side(player).stored();
+        const ident = battle.active(player);
+
+        if (stored.hp == stored.stats.hp) return try options.log.fail(ident, .None);
+
+        stored.hp = switch (battle.field.weather) {
+            .Sun => stored.stats.hp,
+            .None => @min(stored.stats.hp, stored.hp + (stored.stats.hp / 2)),
+            else => @min(stored.stats.hp, stored.hp + (stored.stats.hp / 4)),
+        };
+
+        try options.log.heal(ident, stored, Heal.None);
+    }
+
+    pub fn multiHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn nightmare(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn ohko(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn painSplit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn paralyze(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn paralyzeChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+        var foe_stored = foe.stored();
+
+        if (foe.active.volatiles.Substitute) return;
+        if (Status.any(foe_stored.status)) return;
+        if (state.immune()) return;
+        if (!state.proc) return;
+        if (foe.conditions.Safeguard) return;
+
+        foe_stored.status = Status.init(.PAR);
+        foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
+        try options.log.status(battle.active(player.foe()), foe_stored.status, .None);
+
+        // TODO: check for status berry
+    }
+
+    pub fn payDay(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn perishSong(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn poison(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+        var foe_stored = foe.stored();
+        const foe_ident = battle.active(player.foe());
+
+        const toxic = state.move == .Toxic;
+        if (state.immune() or foe.active.types.includes(.Poison)) {
+            return options.log.immune(foe_ident, .None);
+        } else if (Status.any(foe_stored.status)) {
+            // Pokémon Showdown considers Toxic to be a status even in Generation II and so
+            // will not include a fail reason for Toxic vs. Poison or vice-versa...
+            return options.log.fail(foe_ident, if (Status.is(foe_stored.status, .PSN))
+                if (!showdown)
+                    .Poison
+                else if (toxic == (foe_stored.status == Status.TOX))
+                    if (toxic) .Toxic else .Poison
+                else
+                    .None
+            else
+                .None);
+        } else if (foe.active.volatiles.Substitute) {
+            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+        } else if (state.miss) {
+            try options.log.lastmiss();
+            try options.log.miss(battle.active(player));
+        }
+
+        foe_stored.status = Status.init(.PSN);
+        if (toxic) {
+            if (showdown) foe_stored.status = Status.TOX;
+            foe.active.volatiles.Toxic = true;
+            foe.active.volatiles.toxic = 0;
+        }
+
+        try options.log.status(foe_ident, foe_stored.status, .None);
+
+        // TODO: check for status berry
+    }
+
+    pub fn poisonChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+        var foe_stored = foe.stored();
+
+        if (foe.active.volatiles.Substitute) return;
+        if (Status.any(foe_stored.status)) return if (showdown) battle.rng.advance(1);
+        if (state.immune() or foe.active.types.includes(.Poison)) return;
+        if (!state.proc) return;
+        if (foe.conditions.Safeguard) return;
+
+        foe_stored.status = Status.init(.PSN);
+        try options.log.status(battle.active(player.foe()), foe_stored.status, .None);
+
+        // TODO: check for status berry
+    }
+
+    pub fn present(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn protect(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var side = battle.side(player);
+        var volatiles = &side.active.volatiles;
+
+        const failed = !state.first or volatiles.Substitute or
+            !try Rolls.protect(battle, player, volatiles.protect, options);
+        if (failed) {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
+
+        volatiles.protect = @max(8, volatiles.protect + 1);
+        if (state.move == .Endure) {
+            volatiles.Endure = true;
+        } else {
+            volatiles.Protect = true;
+        }
+        try options.log.singleturn(battle.active(player), state.move);
+    }
+
+    pub fn psychUp(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn pursuit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn rage(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        battle.side(player).active.volatiles.Rage = true;
+        try options.log.singlemove(battle.active(player), Move.Rage);
+    }
+
+    pub fn rainDance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn rapidSpin(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn razorWind(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn recoil(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn reversal(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        const stored = battle.side(player).stored();
+
+        // Pokémon Showdown Gen II implementation incorrectly inherits Gen IV's table instead
+        state.bp = if (showdown) power: {
+            const x = @max(1, stored.hp * 64 / stored.stats.hp);
+            if (x < 2) break :power 200;
+            if (x < 6) break :power 150;
+            if (x < 13) break :power 100;
+            if (x < 22) break :power 80;
+            if (x < 43) break :power 40;
+            break :power 20;
+        } else power: {
+            const x = @max(1, stored.hp * 48 / stored.stats.hp);
+            if (x < 1) break :power 200;
+            if (x < 4) break :power 150;
+            if (x < 9) break :power 100;
+            if (x < 16) break :power 80;
+            if (x < 32) break :power 40;
+            break :power 20;
+        };
+
+        try calcDamage(battle, player, state, options);
+    }
+
+    pub fn rollout(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn sacredFire(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn safeguard(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn sandstorm(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn screens(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn sketch(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn skullBash(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn skyAttack(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn sleep(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+        var foe_stored = foe.stored();
+        const foe_ident = battle.active(player.foe());
+
+        if (Status.any(foe_stored.status)) {
+            return options.log.fail(
+                foe_ident,
+                if (Status.is(foe_stored.status, .SLP)) .Sleep else .None,
+            );
+        }
+
+        if (foe.active.volatiles.Substitute) {
+            return options.log.activateMove(foe_ident, .SubstituteBlock, state.move);
+        }
+
+        // Sleep Clause Mod
+        if (showdown) {
+            for (foe.pokemon) |p| {
+                if (Status.is(p.status, .SLP) and !Status.is(p.status, .EXT)) return;
+            }
+        }
+
+        foe_stored.status = Status.slp(Rolls.sleepDuration(battle, player, options));
+        try options.log.statusFrom(foe_ident, foe_stored.status, state.move);
+    }
+
+    pub fn sleepTalk(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        const side = battle.side(player);
+
+        if (!Status.is(side.stored().status, .SLP)) {
+            if (!showdown) try options.log.fail(battle.active(player), .None);
+            return;
+        }
+
+        var n: u3 = 0;
+        for (side.active.moves, 0..) |m, i| {
+            if (state.mslot - 1 != i and Move.get(m.id).extra.sleep_talk) n += 1;
+        }
+        if (n == 0) {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
+
+        _ = try Rolls.sleepTalk(battle, player, n, state.mslot, options); // TODO
+    }
+
+    pub fn snore(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn solarBeam(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn spikes(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn spite(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn splash(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn stomp(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn substitute(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn sunnyDay(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn swagger(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn synthesis(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn teleport(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn thief(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn thrashing(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn transform(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn tripleKick(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    pub fn twister(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
+    }
+
+    const ALL_STAT_UP_STATS = [_][]const u8{ "atk", "def", "spe", "spa", "spd" };
+    const ALL_STAT_UP_REASONS =
+        [_]Boost{ .Attack, .Defense, .Speed, .SpecialAttack, .SpecialDefense };
+
+    pub fn boost(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var log = options.log;
+        var side = battle.side(player);
+        const ident = battle.active(player);
+
+        if (state.miss) return try log.fail(ident, .None);
+
+        var stats = &side.active.stats;
+        var boosts = &side.active.boosts;
+
+        const move = Move.get(state.move);
+        switch (move.effect) {
+            .AttackUp1, .AttackUp2, .Rage => {
+                assert(state.proc);
+                assert(boosts.atk >= -6 and boosts.atk <= 6);
+                if (boosts.atk == 6 or stats.atk == MAX_STAT_VALUE) {
+                    return try log.fail(ident, .None);
+                }
+                const n: u2 = if (move.effect == .AttackUp2) 2 else 1;
+                boosts.atk = @as(i4, @intCast(@min(6, @as(i8, boosts.atk) + n)));
+                const reason = if (showdown and move.effect == .Rage) Boost.Rage else Boost.Attack;
+                var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, boosts.atk) + 6))];
+                const stat = unmodifiedStats(battle, side).atk;
+                stats.atk = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
+                try log.boost(ident, reason, n);
+            },
+            .DefenseUp1, .DefenseUp2 => {
+                assert(state.proc);
+                assert(boosts.def >= -6 and boosts.def <= 6);
+                if (boosts.def == 6 or stats.def == MAX_STAT_VALUE) {
+                    return try log.fail(ident, .None);
+                }
+                const n: u2 = if (move.effect == .DefenseUp2) 2 else 1;
+                boosts.def = @intCast(@min(6, @as(i8, boosts.def) + n));
+                var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, boosts.def) + 6))];
+                const stat = unmodifiedStats(battle, side).def;
+                stats.def = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
+                try log.boost(ident, .Defense, n);
+            },
+            .SpeedUp2 => {
+                assert(state.proc);
+                assert(boosts.spe >= -6 and boosts.spe <= 6);
+                if (boosts.spe == 6 or stats.spe == MAX_STAT_VALUE) {
+                    return try log.fail(ident, .None);
+                }
+                boosts.spe = @intCast(@min(6, @as(i8, boosts.spe) + 2));
+                var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, boosts.spe) + 6))];
+                const stat = unmodifiedStats(battle, side).spe;
+                stats.spe = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
+                try log.boost(ident, .Speed, 2);
+            },
+            .SpAtkUp1 => {
+                assert(state.proc);
+                assert(boosts.spa >= -6 and boosts.spa <= 6);
+                if (boosts.spa == 6 or stats.spa == MAX_STAT_VALUE) {
+                    return try log.fail(ident, .None);
+                }
+                boosts.spa = @intCast(@min(6, @as(i8, boosts.spa) + 1));
+                var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, boosts.spa) + 6))];
+                const stat = unmodifiedStats(battle, side).spa;
+                stats.spa = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
+                try log.boost(ident, .SpecialAttack, 1);
+            },
+            .SpDefUp2 => {
+                assert(state.proc);
+                assert(boosts.spd >= -6 and boosts.spd <= 6);
+                if (boosts.spd == 6 or stats.spd == MAX_STAT_VALUE) {
+                    return try log.fail(ident, .None);
+                }
+                boosts.spd = @intCast(@min(6, @as(i8, boosts.spd) + 2));
+                var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, boosts.spd) + 6))];
+                const stat = unmodifiedStats(battle, side).spd;
+                stats.spd = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
+                try log.boost(ident, .SpecialDefense, 2);
+            },
+            .EvasionUp1 => {
+                assert(state.proc);
+                assert(boosts.evasion >= -6 and boosts.evasion <= 6);
+                if (boosts.evasion == 6) {
+                    return try log.fail(ident, .None);
+                }
+                boosts.evasion = @intCast(@min(6, @as(i8, boosts.evasion) + 1));
+                try log.boost(ident, .Evasion, 1);
+            },
+            .AllStatUpChance => {
+                if (!state.proc) return;
+                inline for (ALL_STAT_UP_STATS, ALL_STAT_UP_REASONS) |s, r| {
+                    assert(@field(boosts, s) >= -6 and @field(boosts, s) <= 6);
+                    if (@field(boosts, s) == 6 or @field(stats, s) == MAX_STAT_VALUE) {
+                        try log.boost(ident, r, 0);
+                    } else {
+                        @field(boosts, s) = @intCast(@min(6, @as(i8, @field(boosts, s)) + 1));
+                        var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, @field(boosts, s)) + 6))];
+                        const stat = @field(unmodifiedStats(battle, side), s);
+                        @field(stats, s) = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
+                        try log.boost(ident, r, 1);
+                    }
+                }
+            },
+            else => unreachable,
+        }
+
+        statusModify(side.stored().status, stats);
+    }
+
+    pub fn unboost(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var log = options.log;
+        var foe = battle.foe(player);
+        const foe_ident = battle.active(player.foe());
+
+        if (foe.active.volatiles.Mist) {
+            try log.activate(foe_ident, .Mist);
+            return try log.fail(foe_ident, .None);
+        }
+
+        const fail = foe.active.volatiles.Substitute or state.miss or !state.proc;
+
+        var stats = &foe.active.stats;
+        var boosts = &foe.active.boosts;
+
+        const move = Move.get(state.move);
+        switch (move.effect) {
+            .AttackDown1, .AttackDown2, .AttackDownChance => {
+                assert(boosts.atk >= -6 and boosts.atk <= 6);
+                if (fail or boosts.atk == -6) {
+                    return if (move.effect != .AttackDownChance) try log.fail(foe_ident, .None);
+                } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+                    try options.log.lastmiss();
+                    try options.log.miss(battle.active(player));
+                    return;
+                } else if (stats.atk == 1) {
+                    return if (move.effect != .AttackDownChance) try log.fail(foe_ident, .None);
+                }
+                const n: u2 = if (move.effect == .AttackDown2) 2 else 1;
+                boosts.atk = @intCast(@max(-6, @as(i8, boosts.atk) - n));
+                var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, boosts.atk) + 6))];
+                const stat = unmodifiedStats(battle, foe).atk;
+                stats.atk = @max(1, stat * mod[0] / mod[1]);
+                try log.boost(foe_ident, .Attack, -@as(i8, n));
+            },
+            .DefenseDown1, .DefenseDown2, .DefenseDownChance => {
+                assert(boosts.def >= -6 and boosts.def <= 6);
+                if (fail or boosts.def == -6) {
+                    return if (move.effect != .DefenseDownChance) try log.fail(foe_ident, .None);
+                } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+                    try options.log.lastmiss();
+                    try options.log.miss(battle.active(player));
+                    return;
+                } else if (stats.def == 1) {
+                    return if (move.effect != .DefenseDownChance) try log.fail(foe_ident, .None);
+                }
+                const n: u2 = if (move.effect == .DefenseDown2) 2 else 1;
+                boosts.def = @intCast(@max(-6, @as(i8, boosts.def) - n));
+                var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, boosts.def) + 6))];
+                const stat = unmodifiedStats(battle, foe).def;
+                stats.def = @max(1, stat * mod[0] / mod[1]);
+                try log.boost(foe_ident, .Defense, -@as(i8, n));
+            },
+            .SpeedDown1, .SpeedDown2, .SpeedDownChance => {
+                assert(boosts.spe >= -6 and boosts.spe <= 6);
+                if (fail or boosts.spe == -6) {
+                    return if (move.effect != .SpeedDownChance) try log.fail(foe_ident, .None);
+                } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+                    try options.log.lastmiss();
+                    try options.log.miss(battle.active(player));
+                    return;
+                } else if (stats.spe == 1) {
+                    return if (move.effect != .SpeedDownChance) try log.fail(foe_ident, .None);
+                }
+                const n: u2 = if (move.effect == .SpeedDown2) 2 else 1;
+                boosts.spe = @intCast(@max(-6, @as(i8, boosts.spe) - 1));
+                var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, boosts.spe) + 6))];
+                const stat = unmodifiedStats(battle, foe).spe;
+                stats.spe = @max(1, stat * mod[0] / mod[1]);
+                try log.boost(foe_ident, .Speed, -@as(i8, n));
+                assert(boosts.spe >= -6);
+            },
+            .SpDefDownChance => {
+                assert(boosts.spd >= -6 and boosts.spd <= 6);
+                if (fail or boosts.spd == -6) return;
+                if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+                    try options.log.lastmiss();
+                    try options.log.miss(battle.active(player));
+                    return;
+                } else if (stats.spd == 1) return;
+                boosts.spd = @intCast(@max(-6, @as(i8, boosts.spd) - 1));
+                var mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, boosts.spd) + 6))];
+                const stat = unmodifiedStats(battle, foe).spd;
+                stats.spd = @max(1, stat * mod[0] / mod[1]);
+                try log.boost(foe_ident, .SpecialDefense, -1);
+            },
+            .AccuracyDown1, .AccuracyDownChance => {
+                assert(boosts.accuracy >= -6 and boosts.accuracy <= 6);
+                if (fail or boosts.accuracy == -6) {
+                    return if (move.effect != .AccuracyDownChance) try log.fail(foe_ident, .None);
+                } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+                    try options.log.lastmiss();
+                    try options.log.miss(battle.active(player));
+                    return;
+                }
+                boosts.accuracy = @intCast(@max(-6, @as(i8, boosts.accuracy) - 1));
+                try log.boost(foe_ident, .Accuracy, -1);
+            },
+            else => unreachable,
+        }
+
+        statusModify(foe.stored().status, stats);
+    }
+};
+
+fn unmodifiedStats(battle: anytype, side: *Side) *Stats(u16) {
+    if (!side.active.volatiles.Transform) return &side.stored().stats;
+    const id = ID.from(side.active.volatiles.transform);
+    return &battle.side(id.player).pokemon[id.id - 1].stats;
+}
+
+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
+        active.volatiles.Rollout;
+}
+
+inline fn convertible(active: ActivePokemon, m: Move) bool {
+    if (m == .None) return false;
+    const t = Move.get(m).type;
+    return t != .@"???" and !active.types.includes(t);
+}
+
+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;
+    }
+
+    inline fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) !bool {
+        const ok = if (options.calc.overridden(player, .hit)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, accuracy, 256)
+        else
+            battle.rng.next() < accuracy;
+
+        try options.chance.hit(player, ok, accuracy);
+        return ok;
+    }
+
+    inline fn criticalHit(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
+        const crit = if (options.calc.overridden(player, .critical_hit)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, rate, 256)
+        else
+            battle.rng.next() < rate;
+
+        try options.chance.criticalHit(player, crit, rate);
+        return crit;
+    }
+
+    inline fn damage(battle: anytype, player: Player, options: anytype) !u8 {
+        const roll = if (options.calc.overridden(player, .damage)) |val|
+            val
+        else roll: {
+            if (showdown) break :roll battle.rng.range(u8, 217, 256);
+            while (true) {
+                const r = std.math.rotr(u8, battle.rng.next(), 1);
+                if (r >= 217) break :roll r;
             }
         };
 
-        assert(duration >= 1 and duration <= 6);
-        options.chance.duration(.sleep, player, player.foe(), duration);
-        return duration + 1;
+        assert(roll >= 217 and roll <= 255);
+        try options.chance.damage(player, roll);
+        return roll;
+    }
+
+    inline fn confused(battle: anytype, player: Player, options: anytype) !bool {
+        const cfz = if (options.calc.overridden(player, .confused)) |val|
+            val == .true
+        else if (showdown)
+            !battle.rng.chance(u8, 128, 256)
+        else
+            battle.rng.next() >= Gen12.percent(50) + 1;
+
+        try options.chance.confused(player, cfz);
+        return cfz;
+    }
+
+    inline fn attract(battle: anytype, player: Player, options: anytype) !bool {
+        const cant = if (options.calc.overridden(player, .attract)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, 1, 2)
+        else
+            battle.rng.next() > Gen12.percent(50) + 1;
+
+        try options.chance.attract(player, cant);
+        return cant;
+    }
+
+    inline fn paralyzed(battle: anytype, player: Player, options: anytype) !bool {
+        const par = if (options.calc.overridden(player, .paralyzed)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, 63, 256)
+        else
+            battle.rng.next() < Gen12.percent(25);
+
+        try options.chance.paralyzed(player, par);
+        return par;
+    }
+
+    inline fn defrost(battle: anytype, player: Player, options: anytype) !bool {
+        const thaw = if (options.calc.overridden(player, .defrost)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, 25, 256)
+        else
+            battle.rng.next() < Gen12.percent(10);
+
+        try options.chance.defrost(player, thaw);
+        return thaw;
+    }
+
+    inline fn secondaryChance(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
+        // GLITCH: 100% secondary chance will still fail 1/256 of the time
+        const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, rate, 256)
+        else
+            battle.rng.next() < rate;
+
+        try options.chance.secondaryChance(player, proc, rate);
+        return proc;
+    }
+
+    inline fn item(battle: anytype, player: Player, options: anytype) !bool {
+        const proc = if (options.calc.overridden(player, .item)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, 30, 256)
+        else
+            battle.rng.next() < 30;
+
+        try options.chance.item(player, proc);
+        return proc;
     }
 
     inline fn triAttack(battle: anytype, player: Player, options: anytype) !u8 {
@@ -1236,7 +2345,7 @@ pub const Rolls = struct {
         else loop: {
             while (true) {
                 const r = std.math.rotr(u8, std.battle.rng.next(), 4) & 3;
-                if (r != 0) break :loop @intCast(r - 1);
+                if (r != 0) break :loop @enumFromInt(r - 1);
             }
         };
 
@@ -1294,11 +2403,11 @@ pub const Rolls = struct {
         return num;
     }
 
-    inline fn tripleKick(battle: anytype, player: Player, options: anytype) !u8 {
+    inline fn tripleKick(battle: anytype, player: Player, options: anytype) !u2 {
         const hits = if (options.calc.overridden(player, .triple_kick)) |val|
             val
         else if (showdown)
-            battle.rng.range(u8, 1, 4)
+            battle.rng.range(u2, 1, 4)
         else power: {
             while (true) {
                 const r = battle.rng.next() & 3;
@@ -1325,7 +2434,7 @@ pub const Rolls = struct {
     }
 
     // Conversion 2 can at most choose between 7 types (vs. a Grass-type attack)
-    const CONVERSION_2: [7]Type = [_]Type{.{}} ** 7;
+    var CONVERSION_2: [7]Type = [_]Type{.@"???"} ** 7;
 
     inline fn conversion2(battle: anytype, player: Player, mtype: Type, options: anytype) !Type {
         var i: u8 = 0;
@@ -1349,7 +2458,7 @@ pub const Rolls = struct {
                 if (r > 9 and r < 20) continue; // UNUSED_TYPES
                 if (r > 27) continue; // TYPES_END
 
-                const t = Types.conversion2(r);
+                const t = Type.conversion2(r);
                 if (@intFromEnum(mtype.effectiveness(t)) < neutral) {
                     break :ty t;
                 }
@@ -1361,47 +2470,299 @@ pub const Rolls = struct {
         return ty;
     }
 
-    // TODO thrashingDuration
-    // TODO confusionDuraiton (from thrash vs. from move)
-    // TODO forceSwitch
-    // TODO bindingDuration
-    // TODO bideDuration
-    // TODO conversion moveSlot
-    // TODO disable duration
-    // TODO encore duration
-    // TODO metronome
-    // TODO protect
-    // TODO sleeptalk move slot
+    inline fn protect(battle: anytype, player: Player, count: u8, options: anytype) !bool {
+        assert(count <= 8);
+        const num = if (count == 8) 0 else @as(u8, 255) >> @intCast(count);
+
+        const ok = if (options.calc.overridden(player, .protect)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, num, 255)
+        else protected: {
+            while (true) {
+                const r = battle.rng.next();
+                if (r != 0) break :protected !(num <= r - 1);
+            }
+        };
+
+        try options.chance.protect(player, num, ok);
+        return ok;
+    }
+
+    fn conversion(battle: anytype, player: Player, n: u4, options: anytype) !Type {
+        assert(n > 0);
+
+        const active = battle.side(player).active;
+        const moves = active.moves;
+
+        // TODO: consider throwing error instead of rerolling?
+        const overridden = if (options.calc.overridden(player, .move_slot)) |val|
+            if (convertible(active, moves[val - 1].id)) val else null
+        else
+            null;
+
+        const slot: u4 = overridden orelse slot: {
+            if (showdown) {
+                var r = battle.rng.range(u4, 0, n) + 1;
+                var i: usize = 0;
+                while (i < moves.len and r > 0) : (i += 1) {
+                    if (convertible(active, moves[i].id)) {
+                        r -= 1;
+                        if (r == 0) break :slot @intCast(i + 1);
+                    }
+                }
+                break :slot @intCast(i + 1);
+            } else {
+                while (true) {
+                    const r: u4 = @intCast(battle.rng.next() & 3);
+                    if (convertible(active, moves[r].id)) break :slot @intCast(r + 1);
+                }
+            }
+        };
+
+        assert(n >= 1 and n <= 4);
+        assert(slot >= 1 and slot <= 4);
+        try options.chance.moveSlot(player, slot, n);
+        return Move.get(active.move(slot).id).type;
+    }
+
+    fn sleepTalk(battle: anytype, player: Player, n: u4, mslot: u4, options: anytype) !u4 {
+        assert(n > 0);
+
+        const active = battle.side(player).active;
+        const moves = active.moves;
+
+        // TODO: consider throwing error instead of rerolling?
+        const overridden = if (options.calc.overridden(player, .move_slot)) |val|
+            if (val != mslot and Move.get(moves[val - 1].id).extra.sleep_talk) val else null
+        else
+            null;
+
+        const slot: u4 = overridden orelse slot: {
+            if (showdown) {
+                var r = battle.rng.range(u4, 0, n) + 1;
+                var i: usize = 0;
+                while (i < moves.len and r > 0) : (i += 1) {
+                    if (i + 1 != mslot and Move.get(moves[i].id).extra.sleep_talk) {
+                        r -= 1;
+                        if (r == 0) break :slot @intCast(i + 1);
+                    }
+                }
+                break :slot @intCast(i + 1);
+            } else {
+                while (true) {
+                    const r: u4 = @intCast(battle.rng.next() & 3);
+                    if (r + 1 == mslot or !Move.get(moves[r].id).extra.sleep_talk) continue;
+                    break :slot @intCast(r + 1);
+                }
+            }
+        };
+
+        assert(n >= 1 and n <= 4);
+        assert(slot >= 1 and slot <= 4);
+        try options.chance.moveSlot(player, slot, n);
+        return slot;
+    }
+
+    inline fn forceSwitch(
+        battle: anytype,
+        player: Player,
+        slots: []u4,
+        n: u4,
+        options: anytype,
+    ) !u4 {
+        const foe = battle.foe(player);
+
+        assert(slots.len < 5);
+        assert(n > 0 and n <= 6);
+
+        // TODO: consider throwing error instead of rerolling?
+        const overridden = if (options.calc.overridden(player, .force_switch)) |val| val: {
+            for (slots) |slot| if (slot == val) break :val if (foe.get(slot).hp > 0) val else null;
+            break :val null;
+        } else null;
+
+        const slot: u4 = overridden orelse slot: {
+            if (showdown) {
+                break :slot slots[battle.rng.range(u4, 0, @as(u4, @intCast(slots.len)))];
+            } else {
+                while (true) {
+                    const r = battle.rng.next() & 7;
+                    if (r > n or r == 1) continue;
+                    if (foe.get(r).hp > 0) break :slot @intCast(r);
+                }
+            }
+        };
+
+        assert(n >= 1 and n <= 6);
+        assert(slot >= 1 and slot <= 6);
+        try options.chance.forceSwitch(player, slot, n);
+        return slot;
+    }
+
+    const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
+
+    inline fn multiHit(battle: anytype, player: Player, options: anytype) !u3 {
+        const n: u3 = if (options.calc.overridden(player, .multi_hit)) |val|
+            @intCast(val)
+        else if (showdown)
+            DISTRIBUTION[battle.rng.range(u3, 0, DISTRIBUTION.len)]
+        else n: {
+            const r = (battle.rng.next() & 3);
+            break :n @intCast((if (r < 2) r else battle.rng.next() & 3) + 2);
+        };
+
+        assert(n >= 2 and n <= 5);
+        try options.chance.multiHit(player, n);
+        return n;
+    }
 
     inline fn psywave(battle: anytype, player: Player, max: u8, options: anytype) !u8 {
         const power = if (options.calc.overridden(player, .psywave)) |val|
-            val - 1
+            val
         else if (showdown)
-            battle.rng.range(u8, 0, max)
+            battle.rng.range(u8, 1, max)
         else power: {
             while (true) {
                 const r = battle.rng.next();
-                if (r < max) break :power r;
+                if (r != 0 and r < max) break :power r;
             }
         };
 
-        assert(power < max);
+        assert(power != 0 and power < max);
         try options.chance.psywave(player, power, max);
         return power;
     }
 
-    const METRONOME = init: {
-        var num = 0;
-        var moves: [238]Move = undefined;
-        for (1..Move.size) |i| {
-            if (Move.get(@enumFromInt(i)).extra.metronome) {
-                moves[num] = @enumFromInt(i);
-                num += 1;
-            }
+    inline fn metronome(battle: anytype, player: Player, options: anytype) !Move {
+        const moves = battle.get(player).active.moves;
+
+        var n: u2 = 0;
+        for (moves) |m| {
+            if (m == .None) break;
+            if (Move.get(m).metronome) n += 1;
         }
-        assert(num == moves.len);
-        break :init moves;
-    };
+
+        // TODO: consider throwing error instead of rerolling?
+        const overridden = if (options.calc.overridden(player, .metronome)) |val| val: {
+            for (moves) |m| if (m.id == val) break :val null;
+            break :val val;
+        } else null;
+
+        const move: Move = overridden orelse move: {
+            if (showdown) {
+                var r = battle.rng.range(u8, 0, Move.METRONOME.len - n);
+                for (moves) |m| {
+                    if (m == .None or @intFromEnum(m) > @intFromEnum(Move.METRONOME[r])) break;
+                    if (Move.get(m).metronome) r -= 1;
+                }
+                break :move Move.METRONOME[r];
+            } else {
+                outer: while (true) {
+                    const r = battle.rng.next();
+                    if (r == 0 or r >= Move.size) continue;
+                    const selected: Move = @enumFromInt(r);
+                    if (!Move.get(selected).extra.metronome) continue;
+                    for (moves) |m| if (m.id == selected) continue :outer;
+                    break :move selected;
+                }
+            }
+        };
+
+        assert(Move.get(move).metronome);
+        try options.chance.metronome(player, move, n);
+        return move;
+    }
+
+    inline fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            battle.rng.range(u3, 1, 7)
+        else duration: {
+            while (true) {
+                const r = battle.rng.next() & 7;
+                if (r != 0 and r != 7) break :duration @intCast(r);
+            }
+        };
+
+        assert(duration >= 1 and duration <= 6);
+        options.chance.duration(.sleep, player, player.foe(), duration);
+        return duration + 1;
+    }
+
+    inline fn confusionDuration(battle: anytype, player: Player, self: bool, options: anytype) u3 {
+        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            // Pokémon Showdown incorrectly uses the same duration for self-confusion
+            battle.rng.range(u3, 2, 6)
+        else
+            @intCast((battle.rng.next() & if (self) 1 else 3) + 2);
+
+        assert(duration >= 2 and duration <= if (!showdown and self) 3 else 5);
+        options.chance.duration(.confusion, player, if (self) player else player.foe(), duration);
+        return duration;
+    }
+
+    inline fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
+        const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            // Pokémon Showdown incorrectly inherits Generation III's Disable duration
+            battle.rng.range(u4, 2, 6)
+        else duration: {
+            while (true) {
+                const r = battle.rng.next() & 7;
+                if (r != 0) break :duration @intCast(r + 1);
+            }
+        };
+
+        assert(duration >= 2 and duration <= (if (showdown) 5 else 7));
+        options.chance.duration(.disable, player, player.foe(), duration);
+        return duration;
+    }
+
+    inline fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            battle.rng.range(u3, 2, 4)
+        else
+            @intCast((battle.rng.next() & 1) + 2); // BUG: thrash is + 1 not +2
+
+        assert(duration >= 2 and duration <= 3);
+        options.chance.duration(.attacking, player, player, duration);
+        return duration;
+    }
+
+    inline fn bindingDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            // TODO: PS does range(3, 6) here which after subtracting 1 is actually 2-4 not 2-5!
+            battle.rng.range(u3, 2, 5)
+        else
+            @intCast(battle.rng.next() & 3 + 2));
+
+        assert(duration >= 2 and duration <= 5);
+        options.chance.duration(.binding, player, player.foe(), duration);
+        return duration + 1;
+    }
+
+    // TODO: consider sharing implementation with bindingDuration
+    inline fn encoreDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            battle.rng.range(u3, 2, 6)
+        else
+            @intCast(battle.rng.next() & 3 + 2));
+
+        assert(duration >= 2 and duration <= 5);
+        options.chance.duration(.encore, player, player.foe(), duration);
+        return duration + 1;
+    }
 };
 
 test "RNG agreement" {
@@ -1466,6 +2827,28 @@ test "Roll probabilities" {
     try expectEqualSlices(u8, &.{ 14, 26, 50, 77, 51, 25, 13 }, &magnitude);
 }
 
+test "Reasons" {
+    const moves = [_]Move{ .Bind, .Wrap, .FireSpin, .Clamp, .Whirlpool };
+    for (moves) |move| {
+        const reason = Move.get(move).extra.protocol - 1;
+
+        const activate: Activate = @enumFromInt(@intFromEnum(Activate.Bind) + reason);
+        try expectEqualStrings(@tagName(move), @tagName(activate));
+
+        const damage: Damage = @enumFromInt(@intFromEnum(Damage.Bind) + reason);
+        try expectEqualStrings(@tagName(move), @tagName(damage));
+
+        const end: End = @enumFromInt(@intFromEnum(End.Bind) + reason);
+        try expectEqualStrings(@tagName(move), @tagName(end));
+    }
+
+    const perish_song = [_]Start{ .PerishSong0, .PerishSong1, .PerishSong2, .PerishSong3 };
+    for (perish_song, 0..) |ps, i| {
+        const reason: Start = @enumFromInt(@intFromEnum(Start.PerishSong0) + i);
+        try expectEqualStrings(@tagName(ps), @tagName(reason));
+    }
+}
+
 pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Choice) u8 {
     var n: u8 = 0;
     switch (request) {
@@ -1544,7 +2927,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                     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);
+                            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 };
                         n += 1;
@@ -1559,7 +2942,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                 const m = active.moves[slot - 1];
                 if (m.id == .None) break;
                 if (m.pp == 0) continue;
-                if (active.volatiles.disabled_move == slot) continue;
+                if (active.volatiles.disable.move == slot) continue;
                 out[n] = .{ .type = .Move, .data = slot };
                 n += 1;
             }