@pkmn/engine 0.1.0-dev.dc33f678 → 0.1.0-dev.deda8593

package/src/lib/gen2/mechanics.zig

@@ -9,6 +9,7 @@ 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;
 
@@ -24,9 +25,10 @@ const Player = common.Player;
 const Result = common.Result;
 
 const Activate = protocol.Activate;
-const Cant = protocol.Cant;
+const Boost = protocol.Boost;
 const Damage = protocol.Damage;
 const End = protocol.End;
+const Fail = protocol.Fail;
 const Heal = protocol.Heal;
 const Start = protocol.Start;
 
@@ -35,6 +37,7 @@ const Gen12 = rng.Gen12;
 const PointerType = util.PointerType;
 
 const ActivePokemon = data.ActivePokemon;
+const Boosts = data.Boosts;
 const Effectiveness = data.Effectiveness;
 const Item = data.Item;
 const Move = data.Move;
@@ -48,6 +51,7 @@ const TriAttack = data.TriAttack;
 const Type = data.Type;
 const Types = data.Types;
 const Volatiles = data.Volatiles;
+const Weather = data.Weather;
 
 // zig fmt: off
 const STAT_BOOSTS = &[_][2]u8{
@@ -93,21 +97,28 @@ const CRITICAL_HITS = &[_]u8{
 
 const MAX_STAT_VALUE = 999;
 
-const State = struct {
-    damage: u16 = 0,
-    effectiveness: u16 = Effectiveness.neutral,
-    bp: u8 = 0,
-    move: Move = .None,
-    mslot: u4 = 0,
-    first: bool = false,
-    miss: bool = false,
-    crit: bool = false,
+const STATS = [_][]const u8{ "atk", "def", "spe", "spa", "spd" };
+
+pub const State = struct {
+    damage: u16 = 0, // wCurDamage
+    effectiveness: u16 = Effectiveness.neutral, // wTypeModifier
+    bp: u8, // wPlayerMoveStructPower
+    type: Type, // BATTLE_VARS_MOVE_TYPE
+    accuracy: u8, // wEnemyMoveStruct + MOVE_ACC
+    move: Move, // wCurPlayerMove
+    from: Move = .None,
+    mslot: u4, // wCurMoveNum
+    first: bool, // wEnemyGoesFirst
+    miss: bool = false, // wAttackMissed
+    crit: bool = false, // wCriticalHit = 1
+    ohko: bool = false, // wCriticalHit = 2
+    proc: bool = true, // wEffectFailed
 
     comptime {
-        assert(@sizeOf(State) == 10);
+        assert(@sizeOf(State) == 16);
     }
 
-    inline fn immune(self: *State) bool {
+    pub fn immune(self: *State) bool {
         return self.effectiveness == 0;
     }
 };
@@ -129,16 +140,16 @@ fn start(battle: anytype, options: anytype) !Result {
     const p1 = battle.side(.P1);
     const p2 = battle.side(.P2);
 
-    var p1_slot = findFirstAlive(p1);
+    const p1_slot = findFirstAlive(p1);
     assert(!showdown or p1_slot == 1);
     if (p1_slot == 0) return if (findFirstAlive(p2) == 0) Result.Tie else Result.Lose;
 
-    var p2_slot = findFirstAlive(p2);
+    const p2_slot = findFirstAlive(p2);
     assert(!showdown or p2_slot == 1);
     if (p2_slot == 0) return Result.Win;
 
-    try switchIn(battle, .P1, p1_slot, true, options);
-    try switchIn(battle, .P2, p2_slot, true, options);
+    try switchIn(battle, .P1, p1_slot, .Initial, options);
+    try switchIn(battle, .P2, p2_slot, .Initial, options);
 
     return endTurn(battle, options);
 }
@@ -212,7 +223,9 @@ fn selectMove(battle: anytype, player: Player, choice: Choice) void {
     volatiles.protect = 0;
 }
 
-fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, options: anytype) !void {
+const SwitchIn = enum { Initial, Switch, Drag };
+
+fn switchIn(battle: anytype, player: Player, slot: u8, kind: SwitchIn, options: anytype) !void {
     var side = battle.side(player);
     var foe = battle.foe(player);
 
@@ -220,7 +233,7 @@ fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, options: a
     const incoming = side.get(slot);
 
     assert(incoming.hp != 0);
-    assert(slot != 1 or initial);
+    assert(slot != 1 or kind == .Initial);
 
     const out = side.pokemon[0].position;
     side.pokemon[0].position = side.pokemon[slot - 1].position;
@@ -238,12 +251,16 @@ fn switchIn(battle: anytype, player: Player, slot: u8, initial: bool, options: a
 
     statusModify(incoming.status, &active.stats);
 
-    try options.log.switched(battle.active(player), incoming);
+    if (kind == .Drag) {
+        try options.log.drag(.{ battle.active(player), incoming });
+    } else {
+        try options.log.switched(.{ battle.active(player), incoming });
+    }
     options.chance.switched(player, side.pokemon[0].position, out);
 
     if (side.conditions.Spikes and !active.types.includes(.Flying)) {
         incoming.hp -|= @max(incoming.stats.hp / 8, 1);
-        try options.log.damage(battle.active(player), incoming, .Spikes);
+        try options.log.damage(.{ battle.active(player), incoming, .Spikes });
     }
 }
 
@@ -257,7 +274,13 @@ fn turnOrder(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Player
     // TODO: add to pending and only commit roll on Pokémon Showdown if roll is used
     const qkc = showdown and try Rolls.quickClaw(battle, .P1, options);
 
-    if ((c1.type == .Switch) != (c2.type == .Switch)) return if (c1.type == .Switch) .P1 else .P2;
+    if ((c1.type == .Switch) != (c2.type == .Switch)) {
+        const m1 = .Pound; // TODO battle.side(.P1).last_selected_move;
+        const m2 = .Pound; // TODO battle.side(.P2).last_selected_move;
+        return if (c1.type == .Switch)
+            if (m1 == .Pursuit) .P2 else .P1
+        else if (m2 == .Pursuit) .P1 else .P2;
+    }
 
     // https://www.smogon.com/forums/threads/adv-switch-priority.3622189/
     // > In Gen 1 it's irrelevant [which player switches first] because switches happen instantly on
@@ -337,25 +360,33 @@ 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, 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, 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;
+    }
 
     // FIXME
-    try handleResidual(battle, player, options);
-
-    // FIXME
-    try betweenTurns(battle, 0, options);
-
-    return null;
+    return betweenTurns(battle, 0, options);
 }
 
 fn executeMove(
@@ -366,18 +397,30 @@ fn executeMove(
     options: anytype,
 ) !?Result {
     if (choice.type == .Switch) {
-        try switchIn(battle, player, choice.data, false, options);
+        try switchIn(battle, player, choice.data, .Switch, options);
         return null;
     }
 
     assert(choice.type == .Move);
     var mslot: u4 = @intCast(choice.data);
+    _ = &mslot;
     var move = Move.Pound; // TODO
+    _ = &move;
 
     if (!try beforeMove(battle, player, move, options)) return null;
 
-    var state: State = .{ .move = move, .mslot = mslot, .first = first };
-    return doMove(battle, player, &state, options);
+    // FIXME: need damage from doTurn
+    const m = Move.get(move);
+    var state: State = .{
+        .move = move,
+        .mslot = mslot,
+        .first = first,
+        .accuracy = m.accuracy,
+        .bp = m.bp,
+        .type = m.type,
+    };
+    try generated.runMove(battle, player, &state, options);
+    return null;
 }
 
 fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bool {
@@ -391,8 +434,8 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
 
     if (volatiles.Recharging) {
         volatiles.Recharging = false;
-        cantMove(volatiles);
-        try log.cant(ident, .Recharge);
+        resetCant(volatiles);
+        try log.cant(.{ ident, .Recharge });
         return false;
     }
 
@@ -411,21 +454,21 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
         }
 
         if (duration == 0) {
-            try log.curestatus(ident, before, .Message);
+            try log.curestatus(.{ ident, before, .Message });
             stored.status = 0; // clears EXT if present
-            cantMove(volatiles);
+            resetCant(volatiles);
             volatiles.Nightmare = false;
         } else {
-            try log.cant(ident, .Sleep);
+            try log.cant(.{ ident, .Sleep });
             if (move == .Snore or move == .SleepTalk) break :slp;
-            cantMove(volatiles);
+            resetCant(volatiles);
             return false;
         }
     }
 
     if (Status.is(stored.status, .FRZ) and !(move == .FlameWheel or move == .SacredFire)) {
-        cantMove(volatiles);
-        try log.cant(ident, .Freeze);
+        resetCant(volatiles);
+        try log.cant(.{ ident, .Freeze });
         return false;
     }
 
@@ -434,8 +477,8 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
         // Pokémon can sometimes flinch multiple times from the same original hit
         // if (!showdown) volatiles.Flinch = false;
         volatiles.Flinch = false;
-        cantMove(volatiles);
-        try log.cant(ident, .Flinch);
+        resetCant(volatiles);
+        try log.cant(.{ ident, .Flinch });
         return false;
     }
 
@@ -449,7 +492,7 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
 
         if (volatiles.disable.duration == 0) {
             volatiles.disable.move = 0;
-            try log.end(ident, .Disable);
+            try log.end(.{ ident, .Disable });
         }
     }
 
@@ -465,14 +508,14 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
 
         if (volatiles.confusion == 0) {
             volatiles.Confusion = false;
-            try log.end(ident, .Confusion);
+            try log.end(.{ ident, .Confusion });
         } else {
-            try log.activate(ident, .Confusion);
+            try log.activate(.{ ident, .Confusion });
 
             if (try Rolls.confused(battle, player, options)) {
                 volatiles.BeatUp = false;
                 volatiles.Flinch = false;
-                cantMove(volatiles);
+                resetCant(volatiles);
 
                 // TODO HitConfusion
 
@@ -482,11 +525,11 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
     }
 
     if (volatiles.Attract) {
-        try log.activate(ident, .Attract);
+        try log.activate(.{ ident, .Attract });
 
         if (try Rolls.attract(battle, player, options)) {
-            cantMove(volatiles);
-            try log.cant(ident, .Attract);
+            resetCant(volatiles);
+            try log.cant(.{ ident, .Attract });
             return false;
         }
     }
@@ -496,22 +539,22 @@ fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bo
         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);
-            try options.log.disabled(ident, move);
+            resetCant(volatiles);
+            try options.log.cant(.{ ident, .Disable, move });
             return false;
         }
     }
 
     if (Status.is(stored.status, .PAR) and try Rolls.paralyzed(battle, player, options)) {
-        cantMove(volatiles);
-        try log.cant(ident, .Paralysis);
+        resetCant(volatiles);
+        try log.cant(.{ ident, .Paralysis });
         return false;
     }
 
     return true;
 }
 
-fn cantMove(volatiles: *align(8) Volatiles) void {
+fn resetCant(volatiles: *align(8) Volatiles) void {
     volatiles.Bide = false;
     volatiles.Thrashing = false;
     volatiles.Charging = false;
@@ -522,14 +565,32 @@ fn cantMove(volatiles: *align(8) Volatiles) void {
     volatiles.fury_cutter = 0;
 }
 
-fn canMove(battle: anytype, player: Player, options: anytype) !void {
+pub fn canMove(battle: anytype, player: Player, state: *State, options: anytype) !bool {
+    var side = battle.side(player);
+    const volatiles = &side.active.volatiles;
+
+    // FIXME: pass in target to avoid lookup?
+    const target = if (Move.get(state.move).target == .Self) player else player.foe();
+    try options.log.move(.{ battle.active(player), state.move, battle.active(target), state.from });
+
+    const charging = false; // TODO charging uses doUse
+    const skip_pp = charging or state.move == .Struggle or
+        (volatiles.BeatUp or volatiles.Thrashing or volatiles.Bide);
+    if (!skip_pp) _ = decrementPP(side, state.move, state.mslot); // TODO if no pp return
+
+    return true;
+}
+
+pub fn canCharge(battle: anytype, player: Player, state: *State, options: anytype) !bool {
     _ = battle;
     _ = player;
+    _ = state;
     _ = options;
-    return false;
+    // TODO skipsuncharge account for SolarBeam
+    return true;
 }
 
-fn decrementPP(side: *Side, move: Move, mslot: u4) bool {
+pub fn decrementPP(side: *Side, move: Move, mslot: u4) bool {
     var active = &side.active;
     const volatiles = &active.volatiles;
 
@@ -553,34 +614,43 @@ fn decrementPP(side: *Side, move: Move, mslot: u4) bool {
     return true;
 }
 
-fn doMove(battle: anytype, player: Player, state: *State, options: anytype) !?Result {
+pub fn doMove(
+    comptime secondary: bool,
+    battle: anytype,
+    player: Player,
+    state: *State,
+    options: anytype,
+) !bool {
     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 checkHit(battle, player, state, options);
+    if (secondary) try effectChance(battle, player, state, options);
     try applyDamage(battle, player, state, options);
+    try reportOutcome(battle, player, state, options);
+    if (try destinyBond(battle, player, state, options)) return false;
     try buildRage(battle, player, state, options);
     try kingsRock(battle, player, state, options);
+    return true;
+}
 
-    try Effects.attract(battle, player, state, options);
-    try Effects.conversion(battle, player, state, options);
-    try Effects.conversion2(battle, player, state, options);
-    try Effects.destinyBond(battle, player, state, options);
-    try Effects.disable(battle, player, state, options);
-    try Effects.encore(battle, player, state, options);
-    try Effects.falseSwipe(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.happiness(battle, player, state, options);
-    try Effects.protect(battle, player, state, options);
-
-    return null;
+pub fn afterMove(
+    comptime kings: bool,
+    battle: anytype,
+    player: Player,
+    state: *State,
+    options: anytype,
+) !bool {
+    if (try destinyBond(battle, player, state, options)) return false;
+    try buildRage(battle, player, state, options);
+    if (kings) try kingsRock(battle, player, state, options);
+    return true;
 }
 
-fn checkCriticalHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+pub fn checkCriticalHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
     const move = Move.get(state.move);
-    if (move.bp == 0) return;
+    if (state.bp == 0) return;
 
     const side = battle.side(player);
     const pokemon = side.stored();
@@ -598,7 +668,7 @@ fn checkCriticalHit(battle: anytype, player: Player, state: *State, options: any
     state.crit = try Rolls.criticalHit(battle, player, CRITICAL_HITS[stage], options);
 }
 
-fn calcDamage(
+pub fn calcDamage(
     battle: anytype,
     player: Player,
     state: *State,
@@ -612,37 +682,36 @@ fn calcDamage(
 
 const FORESIGHT: Types = .{ .type1 = .Normal, .type2 = .Fighting };
 
-fn adjustDamage(battle: anytype, player: Player, state: *State, _: anytype) !void {
+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(state.move);
 
     var d = state.damage;
-    if ((move.type == .Water and battle.field.weather == .Rain) or
-        (move.type == .Fire and battle.field.weather == .Sun))
+    if ((state.type == .Water and battle.field.weather == .Rain) or
+        (state.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 state.move == .SolarBeam) and battle.field.weather == .Rain))
+    } else if ((state.type == .Water and battle.field.weather == .Sun) or
+        ((state.type == .Fire or state.move == .SolarBeam) and battle.field.weather == .Rain))
     {
         d = d *% @intFromEnum(Effectiveness.Resisted) / 10;
     }
 
-    if (side.active.types.includes(move.type)) d +%= d / 2;
+    if (side.active.types.includes(state.type)) d +%= d / 2;
 
     const neutral = @intFromEnum(Effectiveness.Neutral);
-    const foresight = foe.active.volatiles.Foresight and FORESIGHT.includes(move.type);
+    const foresight = foe.active.volatiles.Foresight and FORESIGHT.includes(state.type);
     const eff1: u16 = if (foresight and types.type1 == .Ghost)
         neutral
     else
-        @intFromEnum(move.type.effectiveness(types.type1));
+        @intFromEnum(state.type.effectiveness(types.type1));
     const eff2: u16 = if (foresight and types.type2 == .Ghost)
         neutral
     else
-        @intFromEnum(move.type.effectiveness(types.type2));
+        @intFromEnum(state.type.effectiveness(types.type2));
 
     // Type effectiveness matchup precedence only matters with (NVE, SE)
     if (!showdown and (eff1 + eff2) == Effectiveness.mismatch and
@@ -662,7 +731,7 @@ fn adjustDamage(battle: anytype, player: Player, state: *State, _: anytype) !voi
     state.damage = d;
 }
 
-fn randomizeDamage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+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(), state.damage);
@@ -670,12 +739,13 @@ fn randomizeDamage(battle: anytype, player: Player, state: *State, options: anyt
     options.calc.final(player.foe(), state.damage);
 }
 
-fn applyDamage(
+pub fn applyDamage(
     battle: anytype,
     player: Player,
     state: *State,
     options: anytype,
 ) !void {
+    // TODO failuretext (if not Bide) + applydamage
     _ = battle;
     _ = player;
     _ = state;
@@ -683,7 +753,7 @@ fn applyDamage(
 }
 
 // TODO: set damage = 0 if missed and not (High) Jump Kick
-fn checkHit(
+pub fn checkHit(
     battle: anytype,
     player: Player,
     state: *State,
@@ -708,7 +778,7 @@ fn checkHit(
         return;
     }
     if (side.active.volatiles.LockOn) {
-        state.miss = !(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));
@@ -723,16 +793,23 @@ fn checkHit(
             return;
         }
     }
-    if (move.effect == .Thunder and battle.field.weather == .Rain) {
-        state.miss = false;
-        return;
+    if (move.effect == .Thunder) {
+        if (battle.field.weather == .Rain) {
+            state.miss = false;
+            return;
+        } else if (battle.field.weather == .Sun) {
+            // This latter part gets applied in a separate Thunder accuracy handler
+            // on the cartridge but it makes more sense to just do it here
+            state.accuracy = Gen12.percent(50) + 1;
+        }
     }
     if (move.effect == .AlwaysHit) {
         state.miss = false;
         return;
     }
 
-    var accuracy: u16 = move.accuracy;
+    var accuracy: u16 = state.accuracy;
+    assert(accuracy > 0);
     if (foe.active.boosts.evasion <= side.active.boosts.accuracy or
         !foe.active.volatiles.Foresight)
     {
@@ -757,24 +834,85 @@ fn checkHit(
 fn checkFaint(
     battle: anytype,
     player: Player,
-    state: *State,
     options: anytype,
 ) @TypeOf(options.log).Error!?Result {
-    _ = battle;
-    _ = player;
-    _ = state;
-    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);
+}
+
+// TODO: see if we can move *before* applyDamage and include failuretext logic
+pub fn reportOutcome(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    const foe_ident = battle.active(player.foe());
+    if (state.crit) try options.log.crit(.{foe_ident});
+    if (!state.immune()) {
+        if (state.effectiveness > Effectiveness.neutral) {
+            try options.log.supereffective(.{foe_ident});
+        } else if (state.effectiveness < Effectiveness.neutral) {
+            try options.log.resisted(.{foe_ident});
+        }
+    }
+}
+
+pub fn effectChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    const rate = Move.get(state.move).chance;
+    assert(rate > 0);
+    // FIXME: only commit secondary chance roll if effect actually is successful (doesn't fail)
+    state.proc = !battle.foe(player).active.volatiles.Substitute and
+        try Rolls.secondaryChance(battle, player, rate, options);
 }
 
-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);
@@ -794,9 +932,9 @@ 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;
+        // Pokémon Showdown uses damage [of] 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 true;
     }
 
     if (volatiles.LeechSeed) {
@@ -811,35 +949,37 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !void {
 
         const damage = @max(stored.stats.hp / 8, 1);
         stored.hp -|= damage;
-        // As above, Pokémon Showdown uses damageOf but its not relevant
-        try options.log.damage(ident, stored, .LeechSeed);
+        // As above, Pokémon Showdown uses damage [of] but its not relevant
+        try options.log.damage(.{ ident, stored, .LeechSeed });
 
         const before = foe_stored.hp;
         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 (foe_stored.hp > before) try options.log.heal(.{ foe_ident, foe_stored, .Silent });
+        if (stored.hp == 0) return true;
     }
 
     if (volatiles.Nightmare) {
         stored.hp -= @max(stored.stats.hp / 4, 1);
         // ibid
-        try options.log.damage(ident, stored, .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, .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 {
+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| {
@@ -850,33 +990,36 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
             future_sight.count -= 1;
             assert(future_sight.count != 0);
             if (future_sight.count == 1) {
-                try options.log.end(battle.active(player), .FutureSight);
+                try options.log.end(.{ battle.active(player), .FutureSight });
                 // TODO doMove
             }
         }
     }
-    // TODO checkFaintThen(p1, p2);
+    if (try checkFaint(battle, .P1, options)) |r| return r;
 
     // Weather
     if (battle.field.weather != .None) {
-        assert(battle.field.weather_duration > 0);
         battle.field.weather_duration -= 1;
 
         if (battle.field.weather_duration == 0) {
             battle.field.weather = .None;
-            try options.log.weather(battle.field.weather, .None);
+            try options.log.weather(.{ battle.field.weather, protocol.Weather.None });
         } else {
-            try options.log.weather(battle.field.weather, .Upkeep);
+            try options.log.weather(.{ battle.field.weather, protocol.Weather.Upkeep });
             if (battle.field.weather == .Sandstorm) {
                 inline for (players) |player| {
                     var side = battle.side(player);
                     const active = side.active;
                     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);
+                        try options.log.damage(.{
+                            battle.active(player),
+                            side.stored(),
+                            .Sandstorm,
+                        });
                     }
                 }
-                // TODO checkFaintThen(p1, p2);
+                if (try checkFaint(battle, .P1, options)) |r| return r;
             }
         }
     }
@@ -885,23 +1028,28 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
     inline for (players) |player| {
         var side = battle.side(player);
         var volatiles = &side.active.volatiles;
+        const ident = battle.active(player);
 
         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));
+                try options.log.end(.{ ident, @as(End, @enumFromInt(reason)) });
             } else {
                 var reason = @intFromEnum(Activate.Bind) + volatiles.bind.reason - 1;
-                try options.log.activate(battle.active(player), @enumFromInt(reason));
+                try options.log.activate(.{ ident, @as(Activate, @enumFromInt(reason)) });
 
                 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(), @enumFromInt(reason));
+                try options.log.damage(.{
+                    ident,
+                    side.stored(),
+                    @as(Damage, @enumFromInt(reason)),
+                });
             }
         }
     }
-    // TODO checkFaintThen(p1, p2);
+    if (try checkFaint(battle, .P1, options)) |r| return r;
 
     // Perish Song
     inline for (players) |player| {
@@ -909,12 +1057,11 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
         var volatiles = &side.active.volatiles;
 
         if (volatiles.PerishSong) {
-            assert(volatiles.perish_song > 0);
             volatiles.perish_song -= 1;
 
             assert(volatiles.perish_song < 3);
             const reason = @intFromEnum(Start.PerishSong0) + volatiles.perish_song;
-            try options.log.start(battle.active(player), @enumFromInt(reason));
+            try options.log.start(.{ battle.active(player), @as(Start, @enumFromInt(reason)) });
 
             if (volatiles.perish_song == 0) {
                 volatiles.PerishSong = false;
@@ -922,7 +1069,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| {
@@ -931,13 +1078,15 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
         if (stored.item == .Leftovers) {
             const before = stored.hp;
             stored.hp = @min(stored.hp + @max(stored.stats.hp / 16, 1), stored.stats.hp);
-            if (stored.hp > before) try options.log.heal(battle.active(player), stored, .Leftovers);
+            if (stored.hp > before) {
+                try options.log.heal(.{ battle.active(player), stored, .Leftovers });
+            }
         }
     }
 
     // Mystery Berry
     inline for (players) |player| {
-        var stored = battle.side(player).stored();
+        const stored = battle.side(player).stored();
 
         if (stored.item == .MysteryBerry) {
             // TODO stored and active moves, transform, etc
@@ -952,7 +1101,7 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
             !side.active.volatiles.frozen and
             try Rolls.defrost(battle, player, options))
         {
-            try options.log.curestatus(battle.active(player), side.stored().status, .Message);
+            try options.log.curestatus(.{ battle.active(player), side.stored().status, .Message });
             side.stored().status = 0;
         }
     }
@@ -993,14 +1142,14 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
                     stored.hp < stored.stats.hp;
                 if (proc) {
                     assert(stored.hp != 0);
-                    try options.log.enditem(ident, stored.item, .Eat);
+                    try options.log.enditem(.{ ident, stored.item, .Eat });
                     stored.item = .None;
 
                     const offset = num - @intFromEnum(Item.Berry);
                     assert(offset < 3);
                     stored.hp = @min(stored.hp + ((offset + 1) * 10), stored.stats.hp);
                     const reason: Heal = @enumFromInt(@intFromEnum(Heal.Berry) + offset);
-                    try options.log.heal(ident, stored, reason);
+                    try options.log.heal(.{ ident, stored, reason });
                 }
             } else if (num < @intFromEnum(Item.BitterBerry)) {
                 const proc = if (stored.item == .MiracleBerry)
@@ -1010,29 +1159,29 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
 
                 if (proc) {
                     assert(Status.any(stored.status));
-                    try options.log.enditem(ident, stored.item, .Eat);
+                    try options.log.enditem(.{ ident, stored.item, .Eat });
                     stored.item = .None;
 
                     // FIXME wtf?
                     // side.active.volatiles.Toxic = false;
-                    // side.active.volatiles.NightMare = false;
+                    // side.active.volatiles.Nightmare = false;
                     if (stored.item == .MiracleBerry) {
                         side.active.volatiles.Confusion = false;
-                        try options.log.end(ident, .Confusion);
+                        try options.log.end(.{ ident, .Confusion });
                     }
                     stored.status = 0;
 
                     // FIXME recalc stats
 
-                    try options.log.curestatus(ident, stored.status, .Message);
+                    try options.log.curestatus(.{ ident, stored.status, .Message });
                 }
             } else if (num == @intFromEnum(Item.BitterBerry)) {
                 if (side.active.volatiles.Confusion) {
-                    try options.log.enditem(ident, stored.item, .Eat);
+                    try options.log.enditem(.{ ident, stored.item, .Eat });
                     stored.item = .None;
 
                     side.active.volatiles.Confusion = false;
-                    try options.log.end(ident, .Confusion);
+                    try options.log.end(.{ ident, .Confusion });
                 }
             }
         }
@@ -1044,18 +1193,19 @@ fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
         var volatiles = &side.active.volatiles;
 
         if (volatiles.Encore) {
-            assert(volatiles.encore > 0);
             volatiles.encore -= 1;
 
             if (volatiles.encore == 0 or side.active.move(mslot).pp == 0) {
                 volatiles.Encore = false;
-                try options.log.end(battle.active(player), .Encore);
+                try options.log.end(.{ battle.active(player), .Encore });
             }
         }
     }
+
+    return null;
 }
 
-inline fn updateSideCondition(
+fn updateSideCondition(
     battle: anytype,
     player: Player,
     comptime key: []const u8,
@@ -1064,12 +1214,11 @@ inline fn updateSideCondition(
 ) !void {
     var side = battle.side(player);
     if (@field(side.conditions, key)) {
-        assert(@field(side.conditions, value) > 0);
         @field(side.conditions, value) -= 1;
 
         if (@field(side.conditions, value) == 0) {
             @field(side.conditions, key) = false;
-            try options.log.sideend(player, @field(protocol.Side, key));
+            try options.log.sideend(.{ player, @field(protocol.Side, key) });
         }
     }
 }
@@ -1078,18 +1227,19 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
     battle.turn += 1;
 
     if (showdown and battle.turn >= 1000) {
-        try options.log.tie();
+        try options.log.tie(.{});
         return Result.Tie;
     } else if (battle.turn >= 65535) {
         return Result.Error;
     }
 
-    try options.log.turn(battle.turn);
+    try options.log.turn(.{battle.turn});
 
     return Result.Default;
 }
 
-fn buildRage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+pub fn buildRage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    assert(!state.miss); // TODO
     var foe = battle.foe(player);
     if (foe.active.volatiles.Rage) {
         if (showdown) {
@@ -1099,12 +1249,13 @@ fn buildRage(battle: anytype, player: Player, state: *State, options: anytype) !
             }
         } else {
             foe.active.volatiles.rage +|= 1;
-            try options.log.activate(battle.active(player), .Rage);
+            try options.log.activate(.{ battle.active(player), .Rage });
         }
     }
 }
 
-fn kingsRock(battle: anytype, player: Player, _: *State, options: anytype) !void {
+pub fn kingsRock(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    assert(!state.miss); // TODO
     var foe = battle.foe(player);
     const flinch = battle.side(player).stored().item == .KingsRock and
         !foe.active.volatiles.Substitute and
@@ -1115,124 +1266,283 @@ fn kingsRock(battle: anytype, player: Player, _: *State, options: anytype) !void
     }
 }
 
-pub const Effects = struct {
-    fn alwaysHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+pub fn destinyBond(battle: anytype, player: Player, _: *State, options: anytype) !bool {
+    const foe = battle.foe(player);
+    if (foe.stored().hp > 0) return false;
+
+    if (foe.active.volatiles.DestinyBond) {
+        battle.side(player).stored().hp = 0;
+        try options.log.activate(.{ battle.active(player.foe()), .DestinyBond });
     }
+    return true;
+}
 
-    fn attract(battle: anytype, player: Player, _: *State, options: anytype) !void {
+pub const Effects = struct {
+    pub fn attract(battle: anytype, player: Player, _: *State, options: anytype) !void {
         const side = battle.side(player);
         var foe = battle.foe(player);
 
         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;
+            return options.log.immune(.{ battle.active(player.foe()), .None });
         } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
-            try options.log.lastmiss();
-            try options.log.miss(battle.active(player));
-            return;
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
         }
 
         foe.active.volatiles.Attract = true;
-        try options.log.start(battle.active(player.foe()), .Attract);
+        try options.log.start(.{ battle.active(player.foe()), .Attract });
     }
 
-    fn batonPass(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    pub fn batonPass(battle: anytype, player: Player, state: *State, options: anytype) !void {
         _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn beatUp(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    pub fn beatUp(battle: anytype, player: Player, state: *State, options: anytype) !void {
         _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn bellyDrum(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn bellyDrum(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        assert(!state.miss);
+        var side = battle.side(player);
+
+        const ident = battle.active(player);
+
+        assert(side.active.boosts.atk >= -6 and side.active.boosts.atk <= 6);
+        if (side.active.boosts.atk == 6 or side.active.boosts.atk == MAX_STAT_VALUE) {
+            return options.log.fail(.{ ident, .None });
+        }
+
+        const hp = @max(side.stored().stats.hp / 2, 1);
+        if (side.stored().hp <= hp) {
+            try boostStat(battle, side, &side.active.stats, &side.active.boosts, "atk", 2);
+            try options.log.boost(.{ ident, .Attack, @as(i8, 2), .Silent });
+            return options.log.fail(.{ ident, .None });
+        } else {
+            side.stored().hp -= hp;
+            try options.log.damage(.{ ident, side.stored(), .None });
+
+            const before = side.active.boosts.atk;
+            var i: usize = 0;
+            while (i < 6 and side.active.stats.atk < MAX_STAT_VALUE) : (i += 1) {
+                try boostStat(battle, side, &side.active.stats, &side.active.boosts, "atk", 2);
+            }
+            try options.log.boost(.{ ident, .Attack, @as(i8, side.active.boosts.atk - before) });
+        }
     }
 
-    fn bide(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub const bide = struct {
+        pub fn store(battle: anytype, player: Player, state: *State, options: anytype) !void {
+            var side = battle.side(player);
+            var volatiles = &side.active.volatiles;
+
+            const ident = battle.active(player);
+
+            if (!volatiles.Bide) return;
+
+            // if (options.calc.modify(player, .attacking)) |extend| {
+            //     if (!extend) volatiles.attacks = 0;
+            // } else {
+            volatiles.attacks -= 1;
+            // }
+            try options.chance.attacking(player, volatiles.attacks);
+
+            if (volatiles.attacks != 0) return options.log.activate(.{ ident, .Bide });
+
+            volatiles.Bide = false;
+            try options.log.end(.{ ident, .Bide });
+
+            state.damage = volatiles.bide *% 2;
+            volatiles.bide = 0;
+
+            if (state.damage == 0) state.miss = true;
+        }
+
+        pub fn unleash(battle: anytype, player: Player, state: *State, options: anytype) !void {
+            _ = .{ battle, player, state, options }; // TODO
+        }
+    };
+
+    pub fn binding(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+
+        if (state.miss) return;
+        if (foe.active.volatiles.bind.duration > 0) return;
+        if (foe.active.volatiles.Substitute) return;
+
+        foe.active.volatiles.bind = .{
+            .duration = Rolls.bindingDuration(battle, player, options),
+            .reason = Move.get(state.move).extra.protocol,
+        };
     }
 
-    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 or state.move == .TriAttack);
+                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;
+        // Nothing is immune to Fire-type, but Ghosts are immune to burnChance called by Tri Attack
+        if (state.immune()) return;
+        if (foe.active.types.includes(Move.get(state.move).type) and state.move != .TriAttack) {
+            return;
+        }
+
+        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 });
+
+        // TODO: check for status berry
     }
 
-    fn burnChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    pub fn confusion(battle: anytype, player: Player, state: *State, options: anytype) !void {
         _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn confusion(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    pub fn confusionChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
         _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn conversion(battle: anytype, player: Player, _: *State, options: anytype) !void {
+    pub fn conversion(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var side = battle.side(player);
 
         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;
-        }
+        if (n == 0) return options.log.fail(.{ battle.active(player), .None });
 
         side.active.types.type1 = try Rolls.conversion(battle, player, n, options);
         side.active.types.type2 = side.active.types.type1;
     }
 
-    fn conversion2(battle: anytype, player: Player, _: *State, options: anytype) !void {
+    pub fn conversion2(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var side = battle.side(player);
 
         const last = battle.foe(player).lastMove(false);
-        if (last == .None) {
-            try options.log.fail(battle.active(player), .None);
-            return;
-        }
+        if (last == .None) return options.log.fail(.{ battle.active(player), .None });
         const move = Move.get(last);
-        if (move.type == .@"???") {
-            try options.log.fail(battle.active(player), .None);
-            return;
-        }
+        if (move.type == .@"???") return options.log.fail(.{ battle.active(player), .None });
 
         side.active.types.type1 = try Rolls.conversion2(battle, player, move.type, options);
         side.active.types.type2 = side.active.types.type1;
     }
 
-    fn counter(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn counter(battle: anytype, player: Player, state: *State, _: anytype) !void {
+        assert(state.move == .Counter or state.move == .MirrorCoat);
+
+        const foe = battle.foe(player);
+
+        state.miss = true;
+        const last = foe.lastMove(false);
+
+        if (last == .None) return;
+        if (last == state.move) return;
+
+        const immune = state.immune();
+        state.effectiveness = Effectiveness.neutral;
+        if (immune) {
+            state.damage = 0;
+            return;
+        }
+
+        const move = Move.get(last);
+        if (state.bp == 0) return;
+        if (move.type.special() != (last == .MirrorCoat)) return;
+        if (state.damage == 0) return;
+
+        state.damage *|= 2;
+        state.miss = false;
     }
 
-    fn curse(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn curse(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var side = battle.side(player);
+        var foe = battle.foe(player);
+
+        const ident = battle.active(player);
+        const foe_ident = battle.active(player.foe());
+
+        if (side.active.types.includes(.Ghost)) {
+            if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+                try options.log.lastmiss(.{});
+                return options.log.miss(.{battle.active(player)});
+            } else if (foe.active.volatiles.Substitute) {
+                return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
+            } else if (foe.active.volatiles.Curse) {
+                return options.log.fail(.{ foe_ident, .None });
+            }
+
+            foe.active.volatiles.Curse = true;
+            try options.log.start(.{ foe_ident, .Curse });
+
+            side.stored().hp -= @max(side.stored().stats.hp / 2, 1);
+            try options.log.damage(.{ ident, side.stored(), .Curse });
+        } else {
+            const stats = &side.active.stats;
+            const boosts = &side.active.boosts;
+
+            const max_atk = boosts.atk == 6 or stats.atk == MAX_STAT_VALUE;
+            const max_def = boosts.def == 6 or stats.def == MAX_STAT_VALUE;
+            if (max_atk and max_def) return options.log.fail(.{ ident, .None });
+
+            if (!(boosts.spe == -6 or stats.spe == 1)) {
+                assert(boosts.spe >= -6 and boosts.spe <= 6);
+                try unboostStat(battle, side, stats, boosts, "spe", 1);
+                try options.log.boost(.{ ident, .Speed, @as(i8, -1) });
+            }
+            if (!max_atk) {
+                assert(boosts.atk >= -6 and boosts.atk <= 6);
+                try boostStat(battle, side, stats, boosts, "atk", 1);
+                try options.log.boost(.{ ident, .Attack, @as(i8, 1) });
+            }
+            if (!max_def) {
+                assert(boosts.def >= -6 and boosts.def <= 6);
+                try boostStat(battle, side, stats, boosts, "def", 1);
+                try options.log.boost(.{ ident, .Defense, @as(i8, 1) });
+            }
+        }
     }
 
-    fn defenseCurl(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn defenseCurl(battle: anytype, player: Player, _: *State, _: anytype) !void {
+        battle.side(player).active.volatiles.DefenseCurl = true;
     }
 
-    fn destinyBond(battle: anytype, player: Player, _: *State, options: anytype) !void {
+    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.log.curestatus(.{ battle.active(player), side.stored().status, .Message });
+        side.stored().status = 0;
+    }
+
+    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);
+        try options.log.singlemove(.{ battle.active(player), Move.DestinyBond });
     }
 
-    fn disable(battle: anytype, player: Player, _: *State, options: anytype) !void {
+    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;
-        }
+        if (volatiles.disable.move != 0) return options.log.fail(.{ foe_ident, .None });
 
         const last = battle.foe(player).lastMove(false);
-        if (last == .None or last == .Struggle) {
-            try options.log.fail(foe_ident, .None);
-            return;
-        }
+        if (last == .None or last == .Struggle) return options.log.fail(.{ foe_ident, .None });
 
         var slot: u3 = 0;
         for (foe.active.moves) |m| {
@@ -1241,26 +1551,41 @@ pub const Effects = struct {
             if (m.id == last) break;
         }
         const move = foe.active.move(slot);
-        if (move.pp == 0) {
-            try options.log.fail(foe_ident, .None);
-            return;
-        }
+        if (move.pp == 0) return options.log.fail(.{ foe_ident, .None });
 
         volatiles.disable.move = slot;
         volatiles.disable.duration = Rolls.disableDuration(battle, player, options);
 
-        try options.log.startEffect(foe_ident, .Disable, move.id);
+        try options.log.start(.{ foe_ident, .Disable, move.id });
     }
 
-    fn doubleHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-    }
+    pub const double = struct {
+        pub fn flying(battle: anytype, player: Player, state: *State, _: anytype) !void {
+            if (battle.foe(player).active.volatiles.Flying) state.damage *|= 2;
+        }
 
-    fn drainHP(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+        pub fn underground(battle: anytype, player: Player, state: *State, _: anytype) !void {
+            if (battle.foe(player).active.volatiles.Underground) state.damage *|= 2;
+        }
+
+        pub fn minimize(battle: anytype, player: Player, state: *State, _: anytype) !void {
+            if (battle.foe(player).active.volatiles.minimized) state.damage *|= 2;
+        }
+    };
+
+    pub fn drainHP(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var stored = battle.side(player).stored();
+        const ident = battle.active(player);
+
+        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.heal(.{ ident, stored, .Drain, battle.active(player.foe()) });
     }
 
-    fn encore(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    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());
@@ -1269,10 +1594,7 @@ pub const Effects = struct {
         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;
-        }
+        if (failed) return options.log.fail(.{ foe_ident, .None });
 
         var slot: u3 = 0;
         for (foe.active.moves) |m| {
@@ -1281,10 +1603,7 @@ pub const Effects = struct {
             if (m.id == last) break;
         }
         const move = foe.active.move(slot);
-        if (move.pp == 0) {
-            try options.log.fail(foe_ident, .None);
-            return;
-        }
+        if (move.pp == 0) return options.log.fail(.{ foe_ident, .None });
 
         volatiles.Encore = true;
         volatiles.encore = Rolls.encoreDuration(battle, player, options);
@@ -1292,53 +1611,84 @@ pub const Effects = struct {
         // TODO ???
         _ = state;
 
-        try options.log.startEffect(foe_ident, .Encore, move.id);
+        try options.log.start(.{ foe_ident, .Encore, move.id });
     }
 
-    fn explode(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn explode(battle: anytype, player: Player, _: *State, _: anytype) !void {
+        var side = battle.side(player);
+        var stored = side.stored();
+
+        stored.hp = 0;
+        // Pokémon Showdown sets the status to 0 on faint(), and we need to do the same to be able
+        // to correctly implement Pokémon Showdown's dumb speed-based switch mechanics
+        if (!showdown) stored.status = 0;
+        side.active.volatiles.LeechSeed = false;
+        side.active.volatiles.DestinyBond = false;
     }
 
-    fn falseSwipe(battle: anytype, player: Player, state: *State, _: anytype) !void {
+    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;
     }
 
-    fn fixedDamage(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-    }
+    pub fn fixedDamage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        const side = battle.side(player);
+        const foe = battle.foe(player);
 
-    fn flameWheel(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+        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,
+        };
     }
 
-    fn flinchChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn flinchChance(battle: anytype, player: Player, state: *State, _: anytype) !void {
+        const foe = battle.foe(player);
+        const status = foe.stored().status;
+        var volatiles = &foe.active.volatiles;
+
+        if (volatiles.Substitute) return;
+        if (Status.is(status, .FRZ) or Status.is(status, .SLP)) return;
+        if (!state.first) return;
+        if (!state.proc) return;
+
+        volatiles.Flinch = true;
+        volatiles.Recharging = false;
     }
 
-    fn flyDig(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    pub fn flyDig(battle: anytype, player: Player, state: *State, options: anytype) !void {
         _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn focusEnergy(battle: anytype, player: Player, _: *State, options: anytype) !void {
+    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;
+            return if (!showdown) try options.log.fail(.{ battle.active(player), .None });
         }
 
         side.active.volatiles.FocusEnergy = true;
-        try options.log.start(battle.active(player), .FocusEnergy);
+        try options.log.start(.{ battle.active(player), .FocusEnergy });
     }
 
     var SLOTS: [5]u4 = .{ 0, 0, 0, 0, 0 };
 
-    fn forceSwitch(battle: anytype, player: Player, _: *State, options: anytype) !void {
+    pub fn forceSwitch(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        assert(!state.miss); // FIXME ensure checkHit handles fail message
+
         const foe = battle.foe(player);
 
+        if (state.first) return options.log.fail(.{ battle.active(player), .None });
+
         var n: u4 = 0;
         var i: u4 = 0;
         for (foe.pokemon, 0..) |pokemon, j| {
@@ -1351,169 +1701,518 @@ pub const Effects = struct {
             }
         }
 
-        if (n == 0) {
-            try options.log.fail(battle.active(player), .None);
-            return;
-        }
+        if (n == 0) return options.log.fail(.{ battle.active(player), .None });
 
-        _ = try Rolls.forceSwitch(battle, player, SLOTS[0..i], n, options); // TODO
+        const slot = try Rolls.forceSwitch(battle, player, SLOTS[0..i], n, options);
+        try switchIn(battle, player.foe(), slot, .Drag, options);
     }
 
-    fn foresight(battle: anytype, player: Player, _: *State, options: anytype) !void {
+    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;
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
         } else if (foe.active.volatiles.Foresight) {
-            try options.log.fail(battle.active(player), .None);
-            return;
+            return options.log.fail(.{ battle.active(player), .None });
         }
 
         foe.active.volatiles.Foresight = true;
-        try options.log.start(battle.active(player.foe()), .FocusEnergy);
+        try options.log.start(.{ battle.active(player.foe()), .FocusEnergy });
     }
 
-    fn freezeChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    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;
+
+        // Nothing is immune to Ice-type, but Ghosts are immune to freezeChance called by Tri Attack
+        if (state.immune()) return;
+        if (battle.field.weather == .Sun) return;
+        if (foe.active.types.includes(Move.get(state.move).type) and state.move != .TriAttack) {
+            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;
     }
 
-    fn furyCutter(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    // TODO FIXME showdown calls this before calcDamage (after checkHit) and modifies state.bp!
+    pub fn furyCutter(battle: anytype, player: Player, state: *State, _: anytype) !void {
+        var side = battle.side(player);
+        var volatiles = &side.active.volatiles;
+
+        if (state.miss) {
+            volatiles.fury_cutter = 0;
+            return;
+        }
+
+        assert(volatiles.fury_cutter >= 0 and volatiles.fury_cutter <= 5);
+        if (volatiles.fury_cutter == 5) return;
+        volatiles.fury_cutter += 1;
+
+        if (showdown) {
+            state.bp *= 2;
+            assert(state.bp <= 160);
+        } else {
+            state.damage *|= 2;
+        }
     }
 
-    fn futureSight(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    pub fn futureSight(battle: anytype, player: Player, state: *State, options: anytype) !void {
         _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn happiness(battle: anytype, player: Player, state: *State, _: anytype) !void {
+    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;
     }
 
-    fn haze(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-    }
+    pub fn haze(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+        var stats = unmodifiedStats(battle, side);
+        side.active.boosts = .{};
+        inline for (STATS) |s| @field(side.active.stats, s) = @field(stats, s);
+        statusModify(side.stored().status, &side.active.stats);
 
-    fn heal(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-    }
+        var foe = battle.foe(player);
+        stats = unmodifiedStats(battle, foe);
+        foe.active.boosts = .{};
+        inline for (STATS) |s| @field(foe.active.stats, s) = @field(stats, s);
+        statusModify(foe.stored().status, &foe.active.stats);
 
-    fn healBell(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+        try options.log.clearallboost(.{});
     }
 
-    fn hiddenPower(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 {
+        var side = battle.side(player);
+        var stored = side.stored();
+        const ident = battle.active(player);
 
-    fn hyperBeam(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+        if (stored.stats.hp == stored.hp) return options.log.fail(.{ ident, .None });
+
+        const rest = state.move == .Rest;
+        if (rest) {
+            // Adding the sleep status runs the sleep condition handler to roll duration
+            if (showdown) battle.rng.advance(1);
+            side.active.volatiles.Toxic = false;
+            stored.status = Status.slf(2);
+            recomputeStats(battle, side);
+            try options.log.status(.{ ident, stored.status, .From, Move.Rest });
+            stored.hp = stored.stats.hp;
+        } else {
+            stored.hp = @min(stored.stats.hp, stored.hp + (stored.stats.hp / 2));
+        }
+        try options.log.heal(.{ ident, stored, if (rest) Heal.Silent else Heal.None });
     }
 
-    fn jumpKick(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn healBell(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+        side.active.volatiles.Nightmare = false;
+
+        try options.log.cureteam(.{battle.active(player)});
+        for (&side.pokemon) |*p| p.status = 0;
+
+        // We technically only need to recompute stats if the active Pokémon was burned/paralyzed,
+        // but adding a branch to check for that is probably more expensive than just recomputing
+        recomputeStats(battle, side);
     }
 
-    fn leechSeed(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn hiddenPower(battle: anytype, player: Player, state: *State, _: anytype) !void {
+        const side = battle.side(player);
+        state.bp = side.stored().dvs.power();
+        state.type = side.stored().dvs.type;
     }
 
-    fn levelDamage(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn hyperBeam(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        battle.side(player).active.volatiles.Recharging = true;
+        try options.log.mustrecharge(.{battle.active(player)});
     }
 
-    fn lockOn(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 {
+        var foe = battle.foe(player);
+
+        if (showdown) {
+            // Invulnerability trumps type immunity on Pokémon Showdown
+            const invulnerable = foe.active.volatiles.Underground or foe.active.volatiles.Flying;
+            if (!invulnerable and foe.active.types.includes(.Grass)) {
+                return options.log.immune(.{ battle.active(player.foe()), .None });
+            }
+            try checkHit(battle, player, state, options);
+            if (state.miss) {
+                try options.log.lastmiss(.{});
+                return options.log.miss(.{battle.active(player)});
+            }
+            if (foe.active.volatiles.LeechSeed) return;
+        } else {
+            try checkHit(battle, player, state, options);
+            const miss =
+                state.miss or foe.active.types.includes(.Grass) or foe.active.volatiles.LeechSeed;
+            if (miss) {
+                try options.log.lastmiss(.{});
+                return options.log.miss(.{battle.active(player)});
+            }
+        }
+
+        foe.active.volatiles.LeechSeed = true;
+
+        try options.log.start(.{ battle.active(player.foe()), .LeechSeed });
     }
 
-    const MAGNITUDE_POWER = [_]u8{ 10, 30, 50, 70, 90, 110, 150 };
+    pub fn lockOn(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+        const foe_ident = battle.active(player.foe());
 
-    fn magnitude(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+        if (foe.active.volatiles.Substitute) {
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
+        } else if (state.miss) {
+            return options.log.fail(.{ foe_ident, .None });
+        }
+
+        foe.active.volatiles.LockOn = true;
+        try options.log.activate(.{ battle.active(player), .LockOn });
     }
 
-    fn meanLook(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 {
+        const num = try Rolls.magnitude(battle, player, options);
+        try options.log.activate(.{ battle.active(player), .Magnitude, num });
+        state.bp = MAGNITUDE_POWER[num - 4];
     }
 
-    fn metronome(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn meanLook(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+
+        if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+            if (!showdown) return options.log.fail(.{ battle.active(player.foe()), .None });
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
+        } else if (foe.active.volatiles.Trapped) {
+            return options.log.fail(.{ battle.active(player.foe()), .None });
+        }
+
+        foe.active.volatiles.Trapped = true;
     }
 
-    fn mimic(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,
+    ) anyerror!void {
+        var side = battle.side(player);
+
+        side.last_used_move = .None;
+        side.active.volatiles.dirty = false;
+
+        // if (wPlayerCharging) ???
+        // wPlayerCharging = 1
+
+        // FIXME
+        state.move = try Rolls.metronome(battle, player, options);
+        state.from = .Metronome;
+        return generated.runMove(battle, player, state, options);
     }
 
-    fn mirrorCoat(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 {
+        var side = battle.side(player);
+
+        if (state.miss) {
+            if (!showdown) return options.log.fail(.{ battle.active(player.foe()), .None });
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
+        }
+
+        const move = battle.foe(player).lastMove(false);
+        if (move == .None or move == .Struggle) {
+            return options.log.fail(.{ battle.active(player.foe()), .None });
+        }
+
+        var slot: u4 = 0;
+        for (side.active.moves, 0..) |m, i| {
+            if (m.id == move) return options.log.fail(.{ battle.active(player.foe()), .None });
+            if (m.id == .Mimic) slot = @intCast(i + 1);
+        }
+        assert(slot != 0 and slot == state.mslot);
+
+        side.active.move(slot).id = move;
+        side.active.move(slot).pp = 5;
+        try options.log.start(.{ battle.active(player), .Mimic, move });
     }
 
-    fn mirrorMove(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,
+    ) anyerror!void {
+        var side = battle.side(player);
+        const foe = battle.foe(player);
+
+        side.last_used_move = .None;
+        side.active.volatiles.dirty = false;
+
+        const last = foe.lastMove(false);
+
+        if (last == .None) return options.log.fail(.{ battle.active(player), .None });
+        const knows = knows: for (side.active.moves) |m| {
+            if (last == m.id) break :knows true;
+        } else false;
+        if (knows) return options.log.fail(.{ battle.active(player), .None });
+
+        // if (wPlayerCharging) ???
+        // wPlayerCharging = 1
+
+        // FIXME
+        state.move = last;
+        state.from = .MirrorMove;
+        return generated.runMove(battle, player, state, options);
     }
 
-    fn mist(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn mist(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+
+        if (side.active.volatiles.Mist) return options.log.fail(.{ battle.active(player), .None });
+        side.active.volatiles.Mist = true;
+
+        try options.log.start(.{ battle.active(player), .Mist });
     }
 
-    fn weatherHeal(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 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, .None });
     }
 
-    fn multiHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    pub fn multiHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
         _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn nightmare(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 {
+        var foe = battle.foe(player);
+        var foe_volatiles = &foe.active.volatiles;
+        const foe_ident = battle.active(player.foe());
+
+        if (foe_volatiles.Flying or foe_volatiles.Underground) {
+            if (!showdown) return options.log.fail(.{ battle.active(player.foe()), .None });
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
+        } else if (foe_volatiles.Substitute) {
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
+        } else if (!Status.is(foe.stored().status, .SLP) or foe_volatiles.Nightmare) {
+            return options.log.fail(.{ foe_ident, .None });
+        }
+
+        foe_volatiles.Nightmare = true;
+        try options.log.start(.{ battle.active(player.foe()), .Nightmare });
     }
 
-    fn ohko(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub const ohko = struct {
+        // OHKO calls adjustDamage but only actually cares about immunity
+        pub fn immune(battle: anytype, player: Player, state: *State, _: anytype) !void {
+            const move = Move.get(state.move);
+
+            assert(move.type == .Normal or move.type == .Ground);
+            const foe = battle.foe(player);
+            const zero = if (move.type == .Normal)
+                foe.active.types.includes(.Ghost) and !foe.active.volatiles.Foresight
+            else
+                foe.active.types.includes(.Flying);
+            state.effectiveness = if (zero) 0 else Effectiveness.neutral;
+        }
+
+        pub fn damage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+            const side = battle.side(player);
+            const foe = battle.foe(player);
+
+            const foe_ident = battle.active(player.foe());
+
+            state.damage = 0;
+            if (state.immune()) return options.log.immune(.{ foe_ident, .None });
+            const delta = side.stored().level -| foe.stored().level;
+            if (delta == 0) return options.log.immune(.{ foe_ident, .OHKO });
+
+            state.accuracy = 2 * delta +| Gen12.percent(30);
+            try checkHit(battle, player, state, options);
+            if (!state.miss) state.damage = 65535;
+            state.ohko = true;
+        }
+    };
+
+    pub fn painSplit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var side = battle.side(player);
+        var foe = battle.foe(player);
+
+        const ident = battle.active(player);
+        const foe_ident = battle.active(player.foe());
+
+        if (state.miss) return options.log.fail(.{ foe_ident, .None });
+        if (foe.active.volatiles.Substitute) {
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
+        }
+
+        const avg = @max((foe.stored().hp + side.stored().hp) / 2, 1);
+        foe.stored().hp -= avg;
+        side.stored().hp = avg;
+
+        try options.log.sethp(.{ foe_ident, foe.stored(), .Silent });
+        try options.log.sethp(.{ ident, side.stored(), .None });
     }
 
-    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 {
+        var foe = battle.foe(player);
+        const foe_ident = battle.active(player.foe());
+
+        if (Status.is(foe.stored().status, .PAR)) {
+            return options.log.fail(.{ foe_ident, .Paralysis });
+        }
+        if (state.immune()) return options.log.immune(.{ foe_ident, .None });
+        if (Status.any(foe.stored().status)) return options.log.fail(.{ foe_ident, .None });
+        if (state.miss) {
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
+        } else if (foe.active.volatiles.Substitute) {
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
+        }
+
+        foe.stored().status = Status.init(.PAR);
+        foe.active.stats.spe = @max(foe.active.stats.spe / 4, 1);
+
+        try options.log.status(.{ foe_ident, foe.stored().status, .None });
     }
 
-    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
     }
 
-    fn paralyzeChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        // TODO: Thunder does acc/checkHit/effectChance before stab + damage variation
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn payDay(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        if (!showdown or !battle.foe(player).active.volatiles.Substitute) {
+            try options.log.fieldactivate(.{}); // FIXME .PayDay
+        }
     }
 
-    fn payDay(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn perishSong(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+        var foe = battle.foe(player);
+
+        if (foe.active.volatiles.PerishSong) {
+            return options.log.fail(.{ battle.active(player.foe()), .None });
+        } else if (!side.active.volatiles.PerishSong) {
+            side.active.volatiles.PerishSong = true;
+            side.active.volatiles.perish_song = 4;
+            try options.log.start(.{ battle.active(player), .PerishSong3Silent });
+        }
+        foe.active.volatiles.PerishSong = true;
+        foe.active.volatiles.perish_song = 4;
+        try options.log.start(.{ battle.active(player.foe()), .PerishSong3Silent });
+
+        try options.log.fieldactivate(.{}); // FIXME .PerishSong
     }
 
-    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)
+                    Fail.Poison
+                else if (toxic == (foe_stored.status == Status.TOX))
+                    if (toxic) Fail.Toxic else Fail.Poison
+                else
+                    Fail.None
+            else
+                Fail.None });
+        } else if (foe.active.volatiles.Substitute) {
+            return options.log.activate(.{ foe_ident, .SubstituteBlock, state.move });
+        } else if (state.miss) {
+            try options.log.lastmiss(.{});
+            return 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
     }
 
-    fn poison(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    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
     }
 
-    fn present(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    pub fn present(battle: anytype, player: Player, state: *State, options: anytype) !void {
         _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn protect(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    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;
-        }
+        if (failed) return options.log.fail(.{ battle.active(player), .None });
 
         volatiles.protect = @max(8, volatiles.protect + 1);
         if (state.move == .Endure) {
@@ -1521,174 +2220,594 @@ pub const Effects = struct {
         } else {
             volatiles.Protect = true;
         }
-        try options.log.singleturn(battle.active(player), state.move);
+        try options.log.singleturn(.{ battle.active(player), state.move });
     }
 
-    fn psychUp(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-    }
+    pub fn psychUp(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+        const foe = battle.foe(player);
 
-    fn pursuit(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-    }
+        // Pokémon Showdown should fail when the enemy has no boosts/unboosts but doesn't
+        if (!showdown and @as(u32, @bitCast(foe.active.boosts)) == 0) {
+            return options.log.fail(.{ battle.active(player), .None });
+        }
 
-    fn rage(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+        side.active.boosts = foe.active.boosts;
+        try options.log.copyboost(.{ battle.active(player), battle.active(player.foe()) });
     }
 
-    fn rainDance(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn pursuit(battle: anytype, player: Player, state: *State, _: anytype) !void {
+        // TODO: remove switching variable and just look at Choice saved in Battle struct?
+        if (battle.foe(player).active.volatiles.switching) state.damage *|= 2;
     }
 
-    fn rapidSpin(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-    }
+    pub const rage = struct {
+        pub fn start(battle: anytype, player: Player, _: *State, options: anytype) !void {
+            battle.side(player).active.volatiles.Rage = true;
+            try options.log.singlemove(.{ battle.active(player), Move.Rage });
+        }
 
-    fn razorWind(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-    }
+        pub fn damage(battle: anytype, player: Player, state: *State, _: anytype) !void {
+            const side = battle.side(player);
 
-    fn recoil(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+            assert(side.active.volatiles.Rage);
+            state.damage *|= (side.active.volatiles.rage +| 1);
+        }
+    };
+
+    pub fn rainDance(battle: anytype, _: Player, _: *State, options: anytype) !void {
+        return weather(battle, .Rain, options);
     }
 
-    fn reversal(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn rapidSpin(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+
+        if (side.active.volatiles.LeechSeed) {
+            try options.log.end(.{ battle.active(player), .LeechSeedFrom });
+            side.active.volatiles.LeechSeed = false;
+        }
+
+        if (side.conditions.Spikes) {
+            try options.log.sideend(.{ player, protocol.Side.Spikes, battle.active(player) });
+            side.conditions.Spikes = false;
+        }
+
+        if (side.active.volatiles.bind.duration > 0) {
+            const reason = @intFromEnum(End.Bind) + side.active.volatiles.bind.reason - 1;
+            try options.log.end(.{ battle.active(player), @as(End, @enumFromInt(reason)) });
+            side.active.volatiles.bind = .{};
+        }
     }
 
-    fn rollout(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 {
+        var side = battle.side(player);
+        var stored = side.stored();
+        const ident = battle.active(player);
+
+        assert(state.damage > 0);
+
+        const damage: i16 = @intCast(@max(state.damage / 4, 1));
+        stored.hp = @intCast(@max(@as(i16, @intCast(stored.hp)) - damage, 0));
+
+        try options.log.damage(.{ ident, stored, .RecoilOf, battle.active(player.foe()) });
     }
 
-    fn sacredFire(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);
     }
 
-    fn safeguard(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub const rollout = struct {
+        pub fn check(battle: anytype, player: Player, _: *State, _: anytype) !void {
+            var side = battle.side(player);
+
+            if (!side.active.volatiles.Rollout) {
+                side.active.volatiles.attacks = 0;
+            } else {
+                // TODO SkipToBattleCommand(doturn_command)
+            }
+        }
+
+        pub fn power(battle: anytype, player: Player, state: *State, _: anytype) !void {
+            var side = battle.side(player);
+
+            if (Status.is(side.stored().status, .SLP)) return;
+
+            if (side.active.volatiles.attacks > 0) {
+                // TODO set wSomeoneIsRampaging
+            }
+
+            if (state.miss) {
+                side.active.volatiles.Rollout = false;
+                return;
+            }
+
+            assert(side.active.volatiles.attacks < 5);
+            side.active.volatiles.attacks += 1;
+            side.active.volatiles.Rollout = side.active.volatiles.attacks != 5;
+
+            if (side.active.volatiles.DefenseCurl) state.damage *|= 2;
+        }
+    };
+
+    pub fn sandstorm(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        if (battle.field.weather != .Sandstorm) return weather(battle, .Sandstorm, options);
+        return options.log.fail(.{ battle.active(player), .None });
     }
 
-    fn sandstorm(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn safeguard(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        return screens(battle, player, "Safeguard", "safeguard", options);
     }
 
-    fn screens(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn reflect(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        return screens(battle, player, "Reflect", "reflect", options);
     }
 
-    fn sketch(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn lightScreen(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        return screens(battle, player, "LightScreen", "light_screen", options);
     }
 
-    fn skullBash(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    fn screens(
+        battle: anytype,
+        player: Player,
+        comptime key: []const u8,
+        comptime value: []const u8,
+        options: anytype,
+    ) !void {
+        var side = battle.side(player);
+
+        if (@field(side.conditions, key)) {
+            return options.log.fail(.{ battle.active(player), .None });
+        }
+
+        @field(side.conditions, key) = true;
+        @field(side.conditions, value) = 5;
+        try options.log.sidestart(.{ player, @field(protocol.Side, key) });
     }
 
-    fn skyAttack(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn sketch(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+
+        side.last_used_move = .None;
+        side.active.volatiles.dirty = false;
+
+        if (showdown) {
+            // yes, actually "Splash". '|nothing' gets blindly mapped to  '|-activate||move:Splash'
+            try options.log.activate(.{ battle.active(player), .Splash });
+        } else {
+            try options.log.fail(.{ battle.active(player), .None });
+        }
     }
 
-    fn sleep(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)) Fail.Sleep else Fail.None,
+            });
+        }
+
+        if (foe.active.volatiles.Substitute) {
+            return options.log.activate(.{ 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.status(.{ foe_ident, foe_stored.status, .From, state.move });
     }
 
-    fn sleepTalk(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    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;
+            return if (!showdown) try options.log.fail(.{ battle.active(player), .None });
         }
 
         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;
-        }
+        if (n == 0) return options.log.fail(.{ battle.active(player), .None });
 
         _ = try Rolls.sleepTalk(battle, player, n, state.mslot, options); // TODO
     }
 
-    fn snore(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn snore(battle: anytype, player: Player, state: *State, options: anytype) !bool {
+        if (Status.is(battle.side(player).stored().status, .SLP)) return true;
+        state.damage = 0;
+        state.miss = true; // TODO is this necessary?
+        if (!showdown) try options.log.fail(.{ battle.active(player), .None });
+        return false;
     }
 
-    fn solarBeam(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-    }
+    pub fn spikes(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var foe = battle.foe(player);
+        if (foe.conditions.Spikes) return options.log.fail(.{ battle.active(player), .None });
 
-    fn spikes(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+        foe.conditions.Spikes = true;
+        try options.log.sidestart(.{ player.foe(), protocol.Side.Spikes });
     }
 
-    fn spite(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 {
+        var foe = battle.foe(player);
 
-    fn splash(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
-    }
+        const last = foe.lastMove(false);
+        if (state.miss or last == .None or last == .Struggle) {
+            return options.log.fail(.{ battle.active(player.foe()), .None });
+        }
 
-    fn stomp(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+        var slot: u4 = 0;
+        for (foe.active.moves, 0..) |m, i| {
+            if (m.id == last) slot = @intCast(i + 1);
+        }
+        // If the move was called via Metronome it might not exist
+        if (slot == 0 or foe.active.move(slot).pp == 0) {
+            return options.log.fail(.{ battle.active(player.foe()), .None });
+        }
+
+        // Pokémon Showdown always deducts 4 instead of randomizing
+        const pp = @min(
+            foe.active.move(slot).pp,
+            if (showdown) 4 else try Rolls.spite(battle, player, options),
+        );
+        foe.active.move(slot).pp -= pp;
+        if (!foe.active.volatiles.Transform) {
+            var move_slot = foe.stored().move(slot);
+            assert(move_slot.pp > 0);
+
+            move_slot.pp = @as(u6, @intCast(move_slot.pp)) -% 1;
+            assert(foe.active.move(slot).pp == foe.stored().move(slot).pp);
+        }
+
+        try options.log.activate(.{ battle.active(player.foe()), .Spite, last, pp });
     }
 
-    fn substitute(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn splash(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        try options.log.activate(.{ battle.active(player), .Splash });
     }
 
-    fn sunnyDay(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn substitute(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+        if (side.active.volatiles.Substitute) {
+            return options.log.fail(.{ battle.active(player), .Substitute });
+        }
+
+        assert(side.stored().stats.hp <= 1023);
+        const hp: u8 = @intCast(side.stored().stats.hp / 4);
+
+        if (hp == 0 or side.stored().hp <= hp) {
+            return options.log.fail(.{ battle.active(player), .Weak });
+        }
+
+        side.stored().hp -= hp;
+        side.active.volatiles.substitute = hp;
+        side.active.volatiles.Substitute = true;
+        side.active.volatiles.bind = .{};
+        try options.log.start(.{ battle.active(player), .Substitute });
+        try options.log.damage(.{ battle.active(player), side.stored(), .None });
     }
 
-    fn swagger(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn sunnyDay(battle: anytype, _: Player, _: *State, options: anytype) !void {
+        return weather(battle, .Sun, options);
     }
 
-    fn synthesis(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    fn weather(battle: anytype, w: Weather, options: anytype) !void {
+        battle.field.weather = w;
+        battle.field.weather_duration = 5;
+        try options.log.weather(.{ w, protocol.Weather.None });
     }
 
-    fn teleport(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn teleport(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        if (showdown) return;
+
+        try options.log.fail(.{ battle.active(player), .None });
+        try options.log.laststill(.{});
     }
 
-    fn thief(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 {
+        const side = battle.side(player);
+        const foe = battle.foe(player);
+
+        if (side.stored().item != .None or foe.stored().item == .None) return;
+        // Pokémon Showdown incorrectly allows you steal Mail
+        if (!showdown and foe.stored().item.isMail()) return;
+        if (!state.proc) return;
+
+        side.stored().item = foe.stored().item;
+        foe.stored().item = .None;
+
+        try options.log.item(.{
+            battle.active(player),
+            side.stored().item,
+            battle.active(player.foe()),
+        });
     }
 
-    fn thrashing(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn thrashing(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+        if (Status.is(side.stored().status, .SLP)) return;
+
+        assert(!side.active.volatiles.Thrashing);
+        side.active.volatiles.Thrashing = true;
+        side.active.volatiles.attacks = Rolls.attackingDuration(battle, player, options);
+        // TODO wSomeoneIsRampaging = true;
     }
 
-    fn toxic(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn transform(battle: anytype, player: Player, _: *State, options: anytype) !void {
+        var side = battle.side(player);
+        const foe = battle.foe(player);
+        const foe_ident = battle.active(player.foe());
+
+        side.last_used_move = .None;
+        side.active.volatiles.dirty = false;
+
+        if (foe.active.volatiles.Transform) {
+            return options.log.fail(.{ battle.active(player), .None });
+        } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+            if (!showdown) return options.log.fail(.{ battle.active(player), .None });
+            try options.log.lastmiss(.{});
+            return options.log.miss(.{battle.active(player)});
+        }
+
+        side.active.volatiles.Transform = true;
+        side.active.volatiles.transform = foe_ident.int();
+        side.active.volatiles.disable = .{};
+
+        // HP is not copied by Transform
+        side.active.stats.atk = foe.active.stats.atk;
+        side.active.stats.def = foe.active.stats.def;
+        side.active.stats.spe = foe.active.stats.spe;
+        side.active.stats.spa = foe.active.stats.spa;
+        side.active.stats.spd = foe.active.stats.spd;
+
+        side.active.species = foe.active.species;
+        side.active.types = foe.active.types;
+        side.active.boosts = foe.active.boosts;
+        for (foe.active.moves, 0..) |m, i| {
+            side.active.moves[i].id = m.id;
+            side.active.moves[i].pp = if (m.id != .None) if (m.id == .Sketch) 1 else 5 else 0;
+        }
+
+        try options.log.transform(.{ battle.active(player), foe_ident });
     }
 
-    fn transform(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    pub fn triAttack(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        // FIXME only commit effectchance and triattack rolls if actually does something...
+        try effectChance(battle, player, state, options);
+        if (state.proc) {
+            try switch (try Rolls.triAttack(battle, player, options)) {
+                .PAR => paralyzeChance(battle, player, state, options),
+                .FRZ => freezeChance(battle, player, state, options),
+                .BRN => burnChance(battle, player, state, options),
+            };
+        } else if (!showdown) battle.rng.advance(1);
     }
 
-    fn tripleKick(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    pub fn tripleKick(battle: anytype, player: Player, state: *State, options: anytype) !void {
         _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn twister(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    const STAT_UP_REASONS =
+        [_]Boost{ .Attack, .Defense, .Speed, .SpecialAttack, .SpecialDefense };
+
+    pub fn allStatUpChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        var side = battle.side(player);
+
+        const stats = &side.active.stats;
+        const boosts = &side.active.boosts;
+
+        if (!state.proc) return;
+        inline for (STATS, 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 options.log.boost(.{ battle.active(player), r, 0 });
+            } else {
+                try boostStat(battle, side, stats, boosts, s, 1);
+                try options.log.boost(.{ battle.active(player), r, 1 });
+            }
+        }
     }
 
-    fn boost(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    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 log.fail(.{ ident, .None });
+
+        const stats = &side.active.stats;
+        var boosts = &side.active.boosts;
+
+        const move = Move.get(state.move);
+        switch (move.effect) {
+            .AttackUp1, .AttackUp2, .Rage, .Swagger => {
+                assert(boosts.atk >= -6 and boosts.atk <= 6);
+                if (boosts.atk == 6 or stats.atk == MAX_STAT_VALUE) {
+                    return log.fail(.{ ident, .None });
+                }
+                const n: u2 = if (move.effect == .AttackUp2 or move.effect == .Swagger) 2 else 1;
+                try boostStat(battle, side, stats, boosts, "atk", n);
+                const reason = if (showdown and move.effect == .Rage) Boost.Rage else Boost.Attack;
+                try log.boost(.{ ident, reason, n });
+            },
+            .DefenseUp1, .DefenseUp2, .SkullBash => {
+                assert(boosts.def >= -6 and boosts.def <= 6);
+                if (boosts.def == 6 or stats.def == MAX_STAT_VALUE) {
+                    return log.fail(.{ ident, .None });
+                }
+                const n: u2 = if (move.effect == .DefenseUp2) 2 else 1;
+                try boostStat(battle, side, stats, boosts, "def", n);
+                try log.boost(.{ ident, .Defense, n });
+            },
+            .SpeedUp2 => {
+                assert(boosts.spe >= -6 and boosts.spe <= 6);
+                if (boosts.spe == 6 or stats.spe == MAX_STAT_VALUE) {
+                    return log.fail(.{ ident, .None });
+                }
+                try boostStat(battle, side, stats, boosts, "spe", 2);
+                try log.boost(.{ ident, .Speed, 2 });
+            },
+            .SpAtkUp1 => {
+                assert(boosts.spa >= -6 and boosts.spa <= 6);
+                if (boosts.spa == 6 or stats.spa == MAX_STAT_VALUE) {
+                    return log.fail(.{ ident, .None });
+                }
+                try boostStat(battle, side, stats, boosts, "spa", 1);
+                try log.boost(.{ ident, .SpecialAttack, 1 });
+            },
+            .SpDefUp2 => {
+                assert(boosts.spd >= -6 and boosts.spd <= 6);
+                if (boosts.spd == 6 or stats.spd == MAX_STAT_VALUE) {
+                    return log.fail(.{ ident, .None });
+                }
+                try boostStat(battle, side, stats, boosts, "spd", 2);
+                try log.boost(.{ ident, .SpecialDefense, 2 });
+            },
+            .EvasionUp1 => {
+                assert(boosts.evasion >= -6 and boosts.evasion <= 6);
+                if (boosts.evasion == 6) return log.fail(.{ ident, .None });
+                boosts.evasion = @intCast(@min(6, @as(i8, boosts.evasion) + 1));
+                try log.boost(.{ ident, .Evasion, 1 });
+                if (state.move == .Minimize) side.active.volatiles.minimized = true;
+            },
+            else => unreachable,
+        }
     }
 
-    fn unboost(battle: anytype, player: Player, state: *State, options: anytype) !void {
-        _ = .{ battle, player, state, options }; // TODO
+    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 log.fail(.{ foe_ident, .None });
+        }
+
+        const fail = foe.active.volatiles.Substitute or state.miss or !state.proc;
+
+        const stats = &foe.active.stats;
+        var boosts = &foe.active.boosts;
+
+        const move = Move.get(state.move);
+        const none: Fail = .None;
+        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(.{});
+                    return options.log.miss(.{battle.active(player)});
+                } 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;
+                try unboostStat(battle, foe, stats, boosts, "atk", n);
+                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) {
+                    if (move.effect != .DefenseDownChance) try log.fail(.{ foe_ident, none });
+                    return;
+                } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+                    try options.log.lastmiss(.{});
+                    return options.log.miss(.{battle.active(player)});
+                } else if (stats.def == 1) {
+                    if (move.effect != .DefenseDownChance) try log.fail(.{ foe_ident, none });
+                    return;
+                }
+                const n: u2 = if (move.effect == .DefenseDown2) 2 else 1;
+                try unboostStat(battle, foe, stats, boosts, "def", n);
+                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(.{});
+                    return options.log.miss(.{battle.active(player)});
+                } 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;
+                try unboostStat(battle, foe, stats, boosts, "spe", n);
+                try log.boost(.{ foe_ident, .Speed, -@as(i8, n) });
+            },
+            .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(.{});
+                    return options.log.miss(.{battle.active(player)});
+                } else if (stats.spd == 1) return;
+                try unboostStat(battle, foe, stats, boosts, "spd", 1);
+                try log.boost(.{ foe_ident, .SpecialDefense, -1 });
+            },
+            .AccuracyDown1, .AccuracyDownChance => {
+                assert(boosts.accuracy >= -6 and boosts.accuracy <= 6);
+                if (fail or boosts.accuracy == -6) {
+                    if (move.effect != .AccuracyDownChance) try log.fail(.{ foe_ident, none });
+                    return;
+                } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+                    try options.log.lastmiss(.{});
+                    return options.log.miss(.{battle.active(player)});
+                }
+                boosts.accuracy = @intCast(@max(-6, @as(i8, boosts.accuracy) - 1));
+                try log.boost(.{ foe_ident, .Accuracy, -1 });
+            },
+            else => unreachable,
+        }
     }
 };
 
+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 recomputeStats(battle: anytype, side: *Side) void {
+    const stats = unmodifiedStats(battle, side);
+    inline for (STATS) |s| {
+        const mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, @field(side.active.boosts, s)) + 6))];
+        const val = @field(stats, s) * mod[0] / mod[1];
+        @field(side.active.stats, s) = @max(1, @min(MAX_STAT_VALUE, val));
+    }
+}
+
 fn statusModify(status: u8, stats: *Stats(u16)) void {
     if (Status.is(status, .PAR)) {
         stats.spe = @max(stats.spe / 4, 1);
@@ -1697,20 +2816,66 @@ fn statusModify(status: u8, stats: *Stats(u16)) void {
     }
 }
 
-inline fn isForced(active: anytype) bool {
+fn boostStat(
+    battle: anytype,
+    side: *Side,
+    stats: *Stats(u16),
+    boosts: *Boosts,
+    comptime s: []const u8,
+    n: u2,
+) !void {
+    @field(boosts, s) = @intCast(@min(6, @as(i8, @field(boosts, s)) + n));
+    const 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]);
+    if (comptime std.mem.eql(u8, s, "atk")) {
+        if (Status.is(side.stored().status, .BRN)) {
+            @field(stats, s) = @max(@field(stats, s) / 2, 1);
+        }
+    } else if (comptime std.mem.eql(u8, s, "spe")) {
+        if (Status.is(side.stored().status, .PAR)) {
+            @field(stats, s) = @max(@field(stats, s) / 4, 1);
+        }
+    }
+}
+
+fn unboostStat(
+    battle: anytype,
+    side: *Side,
+    stats: *Stats(u16),
+    boosts: *Boosts,
+    comptime s: []const u8,
+    n: u2,
+) !void {
+    @field(boosts, s) = @intCast(@max(-6, @as(i8, @field(boosts, s)) - n));
+    const mod = STAT_BOOSTS[@as(u4, @intCast(@as(i8, @field(boosts, s)) + 6))];
+    const stat = @field(unmodifiedStats(battle, side), s);
+    @field(stats, s) = @max(1, stat * mod[0] / mod[1]);
+    if (comptime std.mem.eql(u8, s, "atk")) {
+        if (Status.is(side.stored().status, .BRN)) {
+            @field(stats, s) = @max(@field(stats, s) / 2, 1);
+        }
+    } else if (comptime std.mem.eql(u8, s, "spe")) {
+        if (Status.is(side.stored().status, .PAR)) {
+            @field(stats, s) = @max(@field(stats, s) / 4, 1);
+        }
+    }
+}
+
+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 {
+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 {
+    fn speedTie(battle: anytype, options: anytype) !bool {
         const p1 = if (options.calc.overridden(.P1, .speed_tie)) |player|
             player == .P1
         else if (showdown)
@@ -1722,7 +2887,7 @@ pub const Rolls = struct {
         return p1;
     }
 
-    inline fn quickClaw(battle: anytype, player: Player, options: anytype) !bool {
+    fn quickClaw(battle: anytype, player: Player, options: anytype) !bool {
         const qkc = if (options.calc.overridden(player, .quick_claw)) |val|
             val == .true
         else if (showdown)
@@ -1734,7 +2899,7 @@ pub const Rolls = struct {
         return qkc;
     }
 
-    inline fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) !bool {
+    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)
@@ -1746,7 +2911,7 @@ pub const Rolls = struct {
         return ok;
     }
 
-    inline fn criticalHit(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
+    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)
@@ -1758,7 +2923,7 @@ pub const Rolls = struct {
         return crit;
     }
 
-    inline fn damage(battle: anytype, player: anytype, options: anytype) !u8 {
+    fn damage(battle: anytype, player: Player, options: anytype) !u8 {
         const roll = if (options.calc.overridden(player, .damage)) |val|
             val
         else roll: {
@@ -1774,7 +2939,7 @@ pub const Rolls = struct {
         return roll;
     }
 
-    inline fn confused(battle: anytype, player: Player, options: anytype) !bool {
+    fn confused(battle: anytype, player: Player, options: anytype) !bool {
         const cfz = if (options.calc.overridden(player, .confused)) |val|
             val == .true
         else if (showdown)
@@ -1786,7 +2951,7 @@ pub const Rolls = struct {
         return cfz;
     }
 
-    inline fn attract(battle: anytype, player: Player, options: anytype) !bool {
+    fn attract(battle: anytype, player: Player, options: anytype) !bool {
         const cant = if (options.calc.overridden(player, .attract)) |val|
             val == .true
         else if (showdown)
@@ -1798,7 +2963,7 @@ pub const Rolls = struct {
         return cant;
     }
 
-    inline fn paralyzed(battle: anytype, player: Player, options: anytype) !bool {
+    fn paralyzed(battle: anytype, player: Player, options: anytype) !bool {
         const par = if (options.calc.overridden(player, .paralyzed)) |val|
             val == .true
         else if (showdown)
@@ -1810,7 +2975,7 @@ pub const Rolls = struct {
         return par;
     }
 
-    inline fn defrost(battle: anytype, player: Player, options: anytype) !bool {
+    fn defrost(battle: anytype, player: Player, options: anytype) !bool {
         const thaw = if (options.calc.overridden(player, .defrost)) |val|
             val == .true
         else if (showdown)
@@ -1822,7 +2987,7 @@ pub const Rolls = struct {
         return thaw;
     }
 
-    inline fn secondaryChance(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
+    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
@@ -1835,7 +3000,7 @@ pub const Rolls = struct {
         return proc;
     }
 
-    inline fn item(battle: anytype, player: Player, options: anytype) !bool {
+    fn item(battle: anytype, player: Player, options: anytype) !bool {
         const proc = if (options.calc.overridden(player, .item)) |val|
             val == .true
         else if (showdown)
@@ -1847,23 +3012,23 @@ pub const Rolls = struct {
         return proc;
     }
 
-    inline fn triAttack(battle: anytype, player: Player, options: anytype) !u8 {
+    fn triAttack(battle: anytype, player: Player, options: anytype) !TriAttack {
         const status: TriAttack = if (options.calc.overridden(player, .tri_attack)) |val|
-            val
+            @enumFromInt(@intFromEnum(val) - 1)
         else if (showdown)
-            @enumFromInt(battle.rng.range(u8, 0, 2))
+            @enumFromInt(battle.rng.range(u2, 0, 2))
         else loop: {
             while (true) {
-                const r = std.math.rotr(u8, std.battle.rng.next(), 4) & 3;
+                const r = std.math.rotr(u8, battle.rng.next(), 4) & 3;
                 if (r != 0) break :loop @enumFromInt(r - 1);
             }
         };
 
         try options.chance.triAttack(player, status);
-        return status.status();
+        return status;
     }
 
-    inline fn present(battle: anytype, player: Player, options: anytype) !u8 {
+    fn present(battle: anytype, player: Player, options: anytype) !u8 {
         const power = if (options.calc.overridden(player, .present)) |val|
             (val - 1) * 40
         else if (showdown) power: {
@@ -1885,8 +3050,8 @@ pub const Rolls = struct {
         return power;
     }
 
-    inline fn magnitude(battle: anytype, player: Player, options: anytype) !u8 {
-        const num = if (options.calc.overridden(player, .magnitude)) |val|
+    fn magnitude(battle: anytype, player: Player, options: anytype) !u8 {
+        const num: u8 = if (options.calc.overridden(player, .magnitude)) |val|
             val + 3
         else if (showdown) num: {
             const r = battle.rng.range(u8, 0, 100);
@@ -1913,7 +3078,7 @@ pub const Rolls = struct {
         return num;
     }
 
-    inline fn tripleKick(battle: anytype, player: Player, options: anytype) !u2 {
+    fn tripleKick(battle: anytype, player: Player, options: anytype) !u2 {
         const hits = if (options.calc.overridden(player, .triple_kick)) |val|
             val
         else if (showdown)
@@ -1930,13 +3095,12 @@ pub const Rolls = struct {
         return hits;
     }
 
-    inline fn spite(battle: anytype, player: Player, options: anytype) !u8 {
-        const pp = if (options.calc.overridden(player, .spite)) |val|
+    fn spite(battle: anytype, player: Player, options: anytype) !u3 {
+        assert(!showdown);
+        const pp: u3 = if (options.calc.overridden(player, .spite)) |val|
             val + 1
-        else if (showdown)
-            battle.rng.range(u8, 2, 6)
         else
-            (battle.rng.next() & 3) + 2;
+            @intCast((battle.rng.next() & 3) + 2);
 
         assert(pp >= 2 and pp <= 5);
         try options.chance.spite(player, pp);
@@ -1946,7 +3110,7 @@ pub const Rolls = struct {
     // Conversion 2 can at most choose between 7 types (vs. a Grass-type attack)
     var CONVERSION_2: [7]Type = [_]Type{.@"???"} ** 7;
 
-    inline fn conversion2(battle: anytype, player: Player, mtype: Type, options: anytype) !Type {
+    fn conversion2(battle: anytype, player: Player, mtype: Type, options: anytype) !Type {
         var i: u8 = 0;
         const neutral = @intFromEnum(Effectiveness.Neutral);
         assert(mtype != .@"???");
@@ -1980,7 +3144,7 @@ pub const Rolls = struct {
         return ty;
     }
 
-    inline fn protect(battle: anytype, player: Player, count: u8, options: anytype) !bool {
+    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);
 
@@ -2074,7 +3238,7 @@ pub const Rolls = struct {
         return slot;
     }
 
-    inline fn forceSwitch(
+    fn forceSwitch(
         battle: anytype,
         player: Player,
         slots: []u4,
@@ -2112,7 +3276,7 @@ pub const Rolls = struct {
 
     const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
 
-    inline fn multiHit(battle: anytype, player: Player, options: anytype) !u3 {
+    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)
@@ -2127,30 +3291,30 @@ pub const Rolls = struct {
         return n;
     }
 
-    inline fn psywave(battle: anytype, player: Player, max: u8, options: anytype) !u8 {
+    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;
     }
 
-    inline fn metronome(battle: anytype, player: Player, options: anytype) !Move {
-        const moves = battle.get(player).active.moves;
+    fn metronome(battle: anytype, player: Player, options: anytype) !Move {
+        const moves = battle.side(player).active.moves;
 
         var n: u2 = 0;
         for (moves) |m| {
-            if (m == .None) break;
-            if (Move.get(m).metronome) n += 1;
+            if (m.id == .None) break;
+            if (Move.get(m.id).extra.metronome) n += 1;
         }
 
         // TODO: consider throwing error instead of rerolling?
@@ -2161,10 +3325,11 @@ pub const Rolls = struct {
 
         const move: Move = overridden orelse move: {
             if (showdown) {
-                var r = battle.rng.range(u8, 0, Move.METRONOME.len - n);
+                var r = battle.rng.range(u8, 0, @as(u8, @intCast(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;
+                    if (m.id == .None) break;
+                    if (@intFromEnum(m.id) > @intFromEnum(Move.METRONOME[r])) break;
+                    if (Move.get(m.id).extra.metronome) r -= 1;
                 }
                 break :move Move.METRONOME[r];
             } else {
@@ -2179,12 +3344,12 @@ pub const Rolls = struct {
             }
         };
 
-        assert(Move.get(move).metronome);
+        assert(Move.get(move).extra.metronome);
         try options.chance.metronome(player, move, n);
         return move;
     }
 
-    inline fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
+    fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
         else if (showdown)
@@ -2201,7 +3366,7 @@ pub const Rolls = struct {
         return duration + 1;
     }
 
-    inline fn confusionDuration(battle: anytype, player: Player, self: bool, options: anytype) u3 {
+    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)
@@ -2215,7 +3380,7 @@ pub const Rolls = struct {
         return duration;
     }
 
-    inline fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
+    fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
         const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
         else if (showdown)
@@ -2233,7 +3398,7 @@ pub const Rolls = struct {
         return duration;
     }
 
-    inline fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
+    fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
         else if (showdown)
@@ -2246,7 +3411,7 @@ pub const Rolls = struct {
         return duration;
     }
 
-    inline fn bindingDuration(battle: anytype, player: Player, options: anytype) u3 {
+    fn bindingDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
         else if (showdown)
@@ -2261,7 +3426,7 @@ pub const Rolls = struct {
     }
 
     // TODO: consider sharing implementation with bindingDuration
-    inline fn encoreDuration(battle: anytype, player: Player, options: anytype) u3 {
+    fn encoreDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
         else if (showdown)
@@ -2383,7 +3548,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
         .Move => {
             const side = battle.side(player);
 
-            var active = &side.active;
+            const active = &side.active;
             const stored = side.stored();
 
             // While players are not given any input options on the cartridge in these cases,
@@ -2403,7 +3568,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             }
 
             var slot: u4 = 2;
-            while (!active.volatiles.trapped and slot <= 6) : (slot += 1) {
+            while (!active.volatiles.Trapped and slot <= 6) : (slot += 1) {
                 const id = side.order[slot - 1];
                 if (id == 0 or side.pokemon[id - 1].hp == 0) continue;
                 out[n] = .{ .type = .Switch, .data = slot };