@pkmn/engine 0.1.0-dev.1336408 → 0.1.0-dev.14ca6108

package/src/lib/gen2/mechanics.zig

@@ -6,6 +6,7 @@ const common = @import("../common/data.zig");
 const DEBUG = @import("../common/debug.zig").print;
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
+const util = @import("../common/util.zig");
 
 const data = @import("data.zig");
 
@@ -13,14 +14,15 @@ const assert = std.debug.assert;
 
 const expectEqual = std.testing.expectEqual;
 const expectEqualSlices = std.testing.expectEqualSlices;
+const expectEqualStrings = std.testing.expectEqualStrings;
+
+const showdown = pkmn.options.showdown;
 
 const Choice = common.Choice;
 const ID = common.ID;
 const Player = common.Player;
 const Result = common.Result;
 
-const showdown = pkmn.options.showdown;
-
 const Activate = protocol.Activate;
 const Cant = protocol.Cant;
 const Damage = protocol.Damage;
@@ -30,6 +32,8 @@ const Start = protocol.Start;
 
 const Gen12 = rng.Gen12;
 
+const PointerType = util.PointerType;
+
 const ActivePokemon = data.ActivePokemon;
 const Effectiveness = data.Effectiveness;
 const Item = data.Item;
@@ -89,6 +93,25 @@ 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,
+
+    comptime {
+        assert(@sizeOf(State) == 10);
+    }
+
+    inline fn immune(self: *State) bool {
+        return self.effectiveness == 0;
+    }
+};
+
 pub fn update(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Result {
     assert(c1.type != .Pass or c2.type != .Pass or battle.turn == 0);
     if (battle.turn == 0) return start(battle, options);
@@ -167,14 +190,14 @@ fn selectMove(battle: anytype, player: Player, choice: Choice) void {
         if (choice.data == 0) {
             const struggle = ok: {
                 for (side.active.moves, 0..) |move, i| {
-                    if (move.pp > 0 and volatiles.disabled_move != i + 1) break :ok false;
+                    if (move.pp > 0 and volatiles.disable.move != i + 1) break :ok false;
                 }
                 break :ok true;
             };
             assert(struggle);
             // TODO wCurPlayerMove = .Struggle;
         } else {
-            assert(showdown or side.active.volatiles.disabled_move != choice.data);
+            assert(showdown or side.active.volatiles.disable.move != choice.data);
             const move = side.active.move(choice.data);
             // You cannot *select* a move with 0 PP
             assert(move.pp != 0);
@@ -326,6 +349,12 @@ fn doTurn(
     volatiles.Endure = false;
     volatiles.DestinyBond = false;
 
+    // FIXME
+    try handleResidual(battle, player, options);
+
+    // FIXME
+    try betweenTurns(battle, 0, options);
+
     return null;
 }
 
@@ -342,16 +371,16 @@ fn executeMove(
     }
 
     assert(choice.type == .Move);
-    var mslot: u3 = @intCast(choice.data);
-
-    // const move = Move.get(side.last_selected_move);
+    var mslot: u4 = @intCast(choice.data);
+    var move = Move.Pound; // TODO
 
-    // CheckTurn
+    if (!try beforeMove(battle, player, move, options)) return null;
 
-    return doMove(battle, player, mslot, first, options);
+    var state: State = .{ .move = move, .mslot = mslot, .first = first };
+    return doMove(battle, player, &state, options);
 }
 
-fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
+fn beforeMove(battle: anytype, player: Player, move: Move, options: anytype) !bool {
     var log = options.log;
     var side = battle.side(player);
     // const foe = battle.foe(player);
@@ -360,8 +389,6 @@ fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
     const ident = battle.active(player);
     var volatiles = &active.volatiles;
 
-    const move = Move.Pound; // TODO
-
     if (volatiles.Recharging) {
         volatiles.Recharging = false;
         cantMove(volatiles);
@@ -412,16 +439,16 @@ fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
         return false;
     }
 
-    if (volatiles.disabled_duration > 0) {
+    if (volatiles.disable.duration > 0) {
         // if (options.calc.modify(player, .disable)) |extend| {
-        //     if (!extend) volatiles.disabled_duration = 0;
+        //     if (!extend) volatiles.disable.duration = 0;
         // } else {
-        volatiles.disabled_duration -= 1;
+        volatiles.disable.duration -= 1;
         // }
-        try options.chance.disable(player, volatiles.disabled_duration);
+        try options.chance.disable(player, volatiles.disable.duration);
 
-        if (volatiles.disabled_duration == 0) {
-            volatiles.disabled_move = 0;
+        if (volatiles.disable.duration == 0) {
+            volatiles.disable.move = 0;
             try log.end(ident, .Disable);
         }
     }
@@ -455,7 +482,7 @@ fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
     }
 
     if (volatiles.Attract) {
-        try log.atrract(ident, .Attract);
+        try log.activate(ident, .Attract);
 
         if (try Rolls.attract(battle, player, options)) {
             cantMove(volatiles);
@@ -464,9 +491,9 @@ fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
         }
     }
 
-    if (side.active.volatiles.disabled_move != 0) {
-        // A Pokémon that transforms after being disabled may end up with less move slots
-        const m = side.active.moves[side.active.volatiles.disabled_move - 1].id;
+    if (side.active.volatiles.disable.move != 0) {
+        // A Pokémon that transforms after being disable may end up with less move slots
+        const m = side.active.moves[side.active.volatiles.disable.move - 1].id;
         if (m != .None and m == move) {
             side.active.volatiles.Charging = false;
             cantMove(volatiles);
@@ -484,7 +511,7 @@ fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
     return true;
 }
 
-fn cantMove(volatiles: *Volatiles) void {
+fn cantMove(volatiles: *align(8) Volatiles) void {
     volatiles.Bide = false;
     volatiles.Thrashing = false;
     volatiles.Charging = false;
@@ -495,7 +522,7 @@ fn cantMove(volatiles: *Volatiles) void {
     volatiles.fury_cutter = 0;
 }
 
-fn canMove(battle: anytype, player: Player, options: anytype) !bool {
+fn canMove(battle: anytype, player: Player, options: anytype) !void {
     _ = battle;
     _ = player;
     _ = options;
@@ -520,325 +547,56 @@ fn decrementPP(side: *Side, mslot: u3) void {
     assert(active.move(mslot).pp == side.stored().move(mslot).pp);
 }
 
-fn doMove(battle: anytype, player: Player, mslot: u3, first: bool, options: anytype) !?Result {
-    var side = battle.side(player);
-    var move = Move.get(.Teleport); // side.last_selected_move
-    _ = .{ side, mslot };
-
-    switch (move.effect) {
-        .None, .HighCritical, .AlwaysHit, .Priority, .Gust, .TriAttack, .Earthquake => {
-            // TODO Gust skips kingsrock and does double fly damage
-            // TODO triattack does own effect instead of kingsrock
-            // TODO double damage for earthquake
-        },
-        .Attract => {
-            try Effects.attract(battle, player, options); // TODO
-        },
-        .BatonPass => {
-            try Effects.batonPass(battle, player, options); // TODO
-        },
-        .BeatUp => {
-            try Effects.beatUp(battle, player, options); // TODO
-        },
-        .BellyDrum => {
-            try Effects.bellyDrum(battle, player, options); // TODO
-        },
-        .Bide => {
-            try Effects.bide(battle, player, options); // TODO
-        },
-        .Binding => {
-            try Effects.binding(battle, player, options); // TODO
-        },
-        .BurnChance => {
-            try Effects.burnChance(battle, player, move, options); // TODO
-        },
-        .Confusion, .ConfusionChance => {
-            try Effects.confusion(battle, player, move, options); // TODO
-        },
-        .Conversion => {
-            try Effects.conversion(battle, player, options); // TODO
-        },
-        .Conversion2 => {
-            try Effects.conversion2(battle, player, options); // TODO
-        },
-        .Counter => {
-            try Effects.counter(battle, player, move, options); // TODO
-        },
-        .Curse => {
-            try Effects.curse(battle, player, options); // TODO
-        },
-        .DefenseCurl => {
-            try Effects.defenseCurl(battle, player, options); // TODO
-        },
-        .DestinyBond => {
-            try Effects.destinyBond(battle, player, options); // TODO
-        },
-        .Disable => {
-            try Effects.disable(battle, player, options); // TODO
-        },
-        .DrainHP, .DreamEater => {
-            try Effects.drainHP(battle, player, options); // TODO
-        },
-        .Encore => {
-            try Effects.encore(battle, player, first, options); // TODO
-        },
-        .Endure => {
-            try Effects.protect(battle, player, Move.Endure, first, options); // TODO
-        },
-        .Explode => {
-            try Effects.explode(battle, player, options); // TODO
-        },
-        .FalseSwipe => {
-            var damage: u16 = 0; // TODO
-            damage = try Effects.falseSwipe(battle, player, damage);
-        },
-        .FixedDamage, .Psywave, .SuperFang => {
-            try Effects.fixedDamage(battle, player, move, options); // TODO
-        },
-        .FlameWheel => {
-            try Effects.flameWheel(battle, player, options); // TODO
-        },
-        .FlinchChance => {
-            try Effects.flinchChance(battle, player, move, options); // TODO
-        },
-        .FlyDig => {
-            try Effects.flyDig(battle, player, move, options); // TODO
-        },
-        .FocusEnergy => {
-            try Effects.focusEnergy(battle, player, options); // TODO
-        },
-        .ForceSwitch => {
-            try Effects.forceSwitch(battle, player, options); // TODO
-        },
-        .Foresight => {
-            try Effects.foresight(battle, player, options); // TODO
-        },
-        .FreezeChance => {
-            try Effects.freezeChance(battle, player, move, options); // TODO
-        },
-        .FuryCutter => {
-            try Effects.furyCutter(battle, player, options); // TODO
-        },
-        .FutureSight => {
-            try Effects.futureSight(battle, player, options); // TODO
-        },
-        .Return, .Frustration => {
-            const bp = try Effects.happiness(battle, player, move); // TODO
-            _ = bp;
-        },
-        .Haze => {
-            try Effects.haze(battle, player, options); // TODO
-        },
-        .Heal => {
-            try Effects.heal(battle, player, options); // TODO
-        },
-        .HealBell => {
-            try Effects.healBell(battle, player, options); // TODO
-        },
-        .HiddenPower => {
-            try Effects.hiddenPower(battle, player, options); // TODO
-        },
-        .HyperBeam => {
-            try Effects.hyperBeam(battle, player, options); // TODO
-        },
-        .JumpKick => {
-            try Effects.jumpKick(battle, player, options); // TODO
-        },
-        .LeechSeed => {
-            try Effects.leechSeed(battle, player, options); // TODO
-        },
-        .LevelDamage => {
-            try Effects.levelDamage(battle, player, options); // TODO
-        },
-        .LightScreen, .Reflect => {
-            try Effects.screens(battle, player, move, options); // TODO
-        },
-        .LockOn => {
-            try Effects.lockOn(battle, player, options); // TODO
-        },
-        .Magnitude => {
-            try Effects.magnitude(battle, player, options); // TODO
-        },
-        .MeanLook => {
-            try Effects.meanLook(battle, player, options); // TODO
-        },
-        .Metronome => {
-            try Effects.metronome(battle, player, options); // TODO
-        },
-        .Mimic => {
-            try Effects.mimic(battle, player, options); // TODO
-        },
-        .MirrorCoat => {
-            try Effects.mirrorCoat(battle, player, options); // TODO
-        },
-        .MirrorMove => {
-            try Effects.mirrorMove(battle, player, options); // TODO
-        },
-        .Mist => {
-            try Effects.mist(battle, player, options); // TODO
-        },
-        .Moonlight, .MorningSun => {
-            try Effects.weatherHeal(battle, player, options); // TODO
-        },
-        .MultiHit, .DoubleHit, .Twineedle => {
-            try Effects.multiHit(battle, player, options); // TODO
-        },
-        .Nightmare => {
-            try Effects.nightmare(battle, player, options); // TODO
-        },
-        .OHKO => {
-            try Effects.ohko(battle, player, options); // TODO
-        },
-        .PainSplit => {
-            try Effects.painSplit(battle, player, options); // TODO
-        },
-        .Paralyze => {
-            try Effects.paralyze(battle, player, options); // TODO
-        },
-        .ParalyzeChance, .Thunder => {
-            try Effects.paralyzeChance(battle, player, options); // TODO
-        },
-        .PayDay => {
-            try Effects.payDay(battle, player, options); // TODO
-        },
-        .PerishSong => {
-            try Effects.perishSong(battle, player, options); // TODO
-        },
-        .Poison, .PoisonChance, .Toxic => {
-            try Effects.poison(battle, player, move, options); // TODO
-        },
-        .Present => {
-            try Effects.present(battle, player, options); // TODO
-        },
-        .Protect => {
-            try Effects.protect(battle, player, Move.Protect, first, options); // TODO Detect?
-        },
-        .PsychUp => {
-            try Effects.psychUp(battle, player, options); // TODO
-        },
-        .Pursuit => {
-            try Effects.pursuit(battle, player, options); // TODO
-        },
-        .Rage => {
-            try Effects.rage(battle, player, options); // TODO
-        },
-        .RainDance => {
-            try Effects.rainDance(battle, player, options); // TODOq
-        },
-        .RapidSpin => {
-            try Effects.rapidSpin(battle, player, options); // TODO
-        },
-        .RazorWind => {
-            try Effects.razorWind(battle, player, options); // TODO
-        },
-        .Recoil => {
-            try Effects.recoil(battle, player, options); // TODO
-        },
-        .Reversal => {
-            try Effects.reversal(battle, player, options); // TODO
-        },
-        .Rollout => {
-            try Effects.rollout(battle, player, options); // TODO
-        },
-        .SacredFire => {
-            try Effects.sacredFire(battle, player, options); // TODO
-        },
-        .Safeguard => {
-            try Effects.safeguard(battle, player, options); // TODO
-        },
-        .Sandstorm => {
-            try Effects.sandstorm(battle, player, options); // TODO
-        },
-        .Sketch => {
-            try Effects.sketch(battle, player, options); // TODO
-        },
-        .SkullBash => {
-            try Effects.skullBash(battle, player, options); // TODO
-        },
-        .SkyAttack => {
-            try Effects.skyAttack(battle, player, options); // TODO
-        },
-        .Sleep => {
-            try Effects.sleep(battle, player, options); // TODO
-        },
-        .SleepTalk => {
-            try Effects.sleepTalk(battle, player, mslot, options); // TODO
-        },
-        .Snore => {
-            try Effects.snore(battle, player, options); // TODO
-        },
-        .Solarbeam => {
-            try Effects.solarBeam(battle, player, options); // TODO
-        },
-        .Spikes => {
-            try Effects.spikes(battle, player, options); // TODO
-        },
-        .Spite => {
-            try Effects.spite(battle, player, options); // TODO
-        },
-        .Splash => {
-            try Effects.splash(battle, player, options); // TODO
-        },
-        .Stomp => {
-            try Effects.stomp(battle, player, options); // TODO
-        },
-        .Substitute => {
-            try Effects.substitute(battle, player, options); // TODO
-        },
-        .SunnyDay => {
-            try Effects.sunnyDay(battle, player, options); // TODO
-        },
-        .Swagger => {
-            try Effects.swagger(battle, player, options); // TODO
-        },
-        .Synthesis => {
-            try Effects.synthesis(battle, player, options); // TODO
-        },
-        .Teleport => {
-            try Effects.teleport(battle, player, options); // TODO
-        },
-        .Thief => {
-            try Effects.thief(battle, player, options); // TODO
-        },
-        .Thrashing => {
-            try Effects.thrashing(battle, player, options); // TODO
-        },
-        .Transform => {
-            try Effects.transform(battle, player, options); // TODO
-        },
-        .TripleKick => {
-            try Effects.tripleKick(battle, player, options); // TODO
-        },
-        .Twister => {
-            try Effects.twister(battle, player, options); // TODO
-        },
-        // zig fmt: off
-        .AllStatUpChance,
-        .AttackUp1, .AttackUp2, .AttackUpChance,
-        .DefenseUp1, .DefenseUp2, .DefenseUpChance,
-        .EvasionUp1,
-        .SpAtkUp1,
-        .SpDefUp2,
-        .SpeedUp2 => {
-        // zig fmt: on
-            try Effects.boost(battle, player, move, options); // TODO
-        },
-        // zig fmt: off
-        .AccuracyDown1, .AccuracyDownChance,
-        .AttackDown1, .AttackDown2, .AttackDownChance,
-        .DefenseDown1, .DefenseDown2, .DefenseDownChance,
-        .EvasionDown1,
-        .SpDefDownChance,
-        .SpeedDown1, .SpeedDown2, .SpeedDownChance => {
-        // zig fmt: on
-            try Effects.unboost(battle, player, move, options); // TODO
-        },
-    }
+const Command: type =
+    fn (battle: anytype, player: Player, state: *State, options: anytype) anyerror!void;
+
+// zig fmt: off
+// const COMMANDS = [_][]Command{
+//     // None
+//     (if (showdown) &[_]Command{
+//         // checkHit, checkCriticalHit, calcDamage, adjustDamage, randomizeDamage,
+//         // applyDamage, buildRage, kingsRock,
+//     } else &[_]Command{
+//         // checkCriticalHit, calcDamage, adjustDamage, randomizeDamage,
+//         // checkHit, applyDamage, buildRage, kingsRock,
+//     }),
+// };
+// zig fmt: on
+
+fn doMove(battle: anytype, player: Player, state: *State, options: anytype) !?Result {
+    // FIXME
+    // const commands = COMMANDS[@intFromEnum(Move.get(state.move).effect)];
+    // for (commands) |command| {
+    //     if (!try command(battle, player, state, options)) return null;
+    // }
+    // return null;
+    try checkCriticalHit(battle, player, state, options);
+    try calcDamage(battle, player, state, options);
+    try adjustDamage(battle, player, state, options);
+    try randomizeDamage(battle, player, state, options);
+    try applyDamage(battle, player, state, options);
+    try buildRage(battle, player, state, options);
+    try kingsRock(battle, player, state, options);
+
+    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;
 }
 
-fn checkCriticalHit(battle: anytype, player: Player, move: Move.Data, options: anytype) !bool {
-    if (move.bp == 0) return false;
+fn checkCriticalHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    const move = Move.get(state.move);
+    if (move.bp == 0) return;
 
     const side = battle.side(player);
     const pokemon = side.stored();
@@ -853,41 +611,38 @@ fn checkCriticalHit(battle: anytype, player: Player, move: Move.Data, options: a
     }
     assert(stage <= 4);
 
-    return Rolls.criticalHit(battle, player, CRITICAL_HITS[stage], options);
+    state.crit = try Rolls.criticalHit(battle, player, CRITICAL_HITS[stage], options);
 }
 
 fn calcDamage(
     battle: anytype,
     player: Player,
-    target_player: Player,
-    m: ?Move.Data,
-    crit: bool,
-) u16 {
+    state: *State,
+    options: anytype,
+) !void {
     _ = battle;
     _ = player;
-    _ = target_player;
-    _ = m;
-    _ = crit;
-    return 0;
+    _ = state;
+    _ = options;
 }
 
 const FORESIGHT: Types = .{ .type1 = .Normal, .type2 = .Fighting };
 
-fn adjustDamage(battle: anytype, player: Player, m: Move, damage: u16, effectiveness: *u16) u16 {
-    if (m == .Struggle) return;
+fn adjustDamage(battle: anytype, player: Player, state: *State, _: anytype) !void {
+    if (state.move == .Struggle) return;
 
     const side = battle.side(player);
     const foe = battle.foe(player);
     const types = foe.active.types;
-    const move = Move.get(side.m);
+    const move = Move.get(state.move);
 
-    var d = damage;
+    var d = state.damage;
     if ((move.type == .Water and battle.field.weather == .Rain) or
         (move.type == .Fire and battle.field.weather == .Sun))
     {
         d = d *% @intFromEnum(Effectiveness.Super) / 10;
     } else if ((move.type == .Water and battle.field.weather == .Sun) or
-        ((move.type == .Fire or m == .SolarBeam) and battle.field.weather == .Rain))
+        ((move.type == .Fire or state.move == .SolarBeam) and battle.field.weather == .Rain))
     {
         d = d *% @intFromEnum(Effectiveness.Resisted) / 10;
     }
@@ -897,17 +652,17 @@ fn adjustDamage(battle: anytype, player: Player, m: Move, damage: u16, effective
     const neutral = @intFromEnum(Effectiveness.Neutral);
     const foresight = foe.active.volatiles.Foresight and FORESIGHT.includes(move.type);
     const eff1: u16 = if (foresight and types.type1 == .Ghost)
-        10
+        neutral
     else
         @intFromEnum(move.type.effectiveness(types.type1));
     const eff2: u16 = if (foresight and types.type2 == .Ghost)
-        10
+        neutral
     else
         @intFromEnum(move.type.effectiveness(types.type2));
 
     // Type effectiveness matchup precedence only matters with (NVE, SE)
     if (!showdown and (eff1 + eff2) == Effectiveness.mismatch and
-        Type.precedence(move.type, types.type1) > Type.precedence(move.type, types.type2))
+        types.type1.precedence() > types.type2.precedence())
     {
         assert(eff2 != neutral);
         d = d *% eff2 / 10;
@@ -919,65 +674,79 @@ fn adjustDamage(battle: anytype, player: Player, m: Move, damage: u16, effective
         if (types.type1 != types.type2 and eff2 != neutral) d = d *% eff2 / 10;
     }
 
-    effectiveness.* = if (types.type1 == types.type2) eff1 * neutral else eff1 * eff2;
-    return d;
+    state.effectiveness = if (types.type1 == types.type2) eff1 * neutral else eff1 * eff2;
+    state.damage = d;
 }
 
-fn randomizeDamage(battle: anytype, player: Player, damage: u16, options: anytype) !u16 {
-    if (damage <= 1) return;
+fn randomizeDamage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+    if (state.damage <= 1) return;
     const random = try Rolls.damage(battle, player, options);
-    options.calc.base(player.foe(), damage);
-    damage = @intCast(@as(u32, damage) *% random / 255);
-    options.calc.final(player.foe(), damage);
-    return damage;
+    options.calc.base(player.foe(), state.damage);
+    state.damage = @intCast(@as(u32, state.damage) *% random / 255);
+    options.calc.final(player.foe(), state.damage);
 }
 
 fn applyDamage(
     battle: anytype,
     player: Player,
+    state: *State,
     options: anytype,
-) !bool {
+) !void {
     _ = battle;
     _ = player;
+    _ = state;
     _ = options;
-    return false;
-}
-
-fn checkHit(battle: anytype, player: Player, move: Move.Data, options: anytype) !bool {
-    if (try moveHit(battle, player, move, options)) return true;
-
-    // try options.chance.commit(player, .miss);
-    // try options.log.lastmiss();
-    // try options.log.miss(battle.active(player));
-
-    return false;
 }
 
 // TODO: set damage = 0 if missed and not (High) Jump Kick
-fn moveHit(
+fn checkHit(
     battle: anytype,
     player: Player,
-    move: Move.Data,
+    state: *State,
     options: anytype,
-) !bool {
+) !void {
     const side = battle.side(player);
     const foe = battle.foe(player);
 
-    if (move.effect == .DreamEater and !Status.is(foe.stored().status, .SLP)) return false;
-    if (foe.active.volatiles.Protect) return false;
+    const move = Move.get(state.move);
+
+    if (move.effect == .DreamEater and !Status.is(foe.stored().status, .SLP)) {
+        state.miss = true;
+        return;
+    }
+    if (foe.active.volatiles.Protect) {
+        state.miss = true;
+        return;
+    }
     const drain = move.effect == .DrainHP or move.effect == .DreamEater;
-    if (drain and foe.active.volatiles.Substitute) return false;
+    if (drain and foe.active.volatiles.Substitute) {
+        state.miss = true;
+        return;
+    }
     if (side.active.volatiles.LockOn) {
-        return !(foe.active.volatiles.Flying and move.extra.undeground);
+        state.miss = !(foe.active.volatiles.Flying and move.extra.undeground);
+        return;
     }
     assert(!(foe.active.volatiles.Flying and foe.active.volatiles.Underground));
     if (foe.active.volatiles.Flying) {
-        if (!move.extra.flying) return false;
+        if (!move.extra.flying) {
+            state.miss = true;
+            return;
+        }
     } else if (foe.active.volatiles.Underground) {
-        if (!move.extra.underground) return false;
+        if (!move.extra.underground) {
+            state.miss = true;
+            return;
+        }
+    }
+    if (move.effect == .Thunder and battle.field.weather == .Rain) {
+        state.miss = false;
+        return;
+    }
+    if (move.effect == .AlwaysHit) {
+        state.miss = false;
+        return;
     }
-    if (move.effect == .Thunder and battle.field.weather == .Rain) return true;
-    if (move.effect == .AlwaysHit) return true;
 
     var accuracy: u16 = move.accuracy;
     if (foe.active.boosts.evasion <= side.active.boosts.accuracy or
@@ -995,17 +764,21 @@ fn moveHit(
     }
 
     // The accuracy roll is skipped entirely if maxed
-    if (accuracy == 255) return true;
-    return !try Rolls.hit(battle, player, @intCast(accuracy), options);
+    state.miss = if (accuracy == 255)
+        false
+    else
+        !try Rolls.hit(battle, player, @intCast(accuracy), options);
 }
 
 fn checkFaint(
     battle: anytype,
     player: Player,
+    state: *State,
     options: anytype,
 ) @TypeOf(options.log).Error!?Result {
     _ = battle;
     _ = player;
+    _ = state;
     return null;
 }
 
@@ -1067,20 +840,20 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !void {
     if (volatiles.Nightmare) {
         stored.hp -= @max(stored.stats.hp / 4, 1);
         // ibid
-        try options.log.damage(ident, stored, Damage.Nightmare);
+        try options.log.damage(ident, stored, .Nightmare);
         if (stored.hp == 0) return;
     }
 
     if (volatiles.Curse) {
         stored.hp -= @max(stored.stats.hp / 4, 1);
         // ibid
-        try options.log.damage(ident, stored, Damage.Curse);
+        try options.log.damage(ident, stored, .Curse);
         if (stored.hp == 0) return;
     }
 }
 
-fn betweenTurns(battle: anytype, mslot: u3, options: anytype) !void {
-    const players = std.enums.values(Player);
+fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
+    const players = comptime std.enums.values(Player);
 
     // TODO checkFaintThen(p1, p2);
 
@@ -1114,7 +887,7 @@ fn betweenTurns(battle: anytype, mslot: u3, options: anytype) !void {
                 inline for (players) |player| {
                     var side = battle.side(player);
                     const active = side.active;
-                    if (!(active.volatiles.underground or active.types.sandstormImmune())) {
+                    if (!(active.volatiles.Underground or active.types.sandstormImmune())) {
                         side.stored().hp -|= @max(side.stored().stats.hp / 8, 1);
                         try options.log.damage(battle.active(player), side.stored(), .Sandstorm);
                     }
@@ -1129,18 +902,18 @@ fn betweenTurns(battle: anytype, mslot: u3, options: anytype) !void {
         var side = battle.side(player);
         var volatiles = &side.active.volatiles;
 
-        if (volatiles.bind > 0 and !volatiles.Substitute) {
-            volatiles.bind -= 1;
-            if (volatiles.bind == 0) {
-                const reason = @intFromEnum(End.Bind) + volatiles.bind_reason - 1;
+        if (volatiles.bind.duration > 0 and !volatiles.Substitute) {
+            volatiles.bind.duration -= 1;
+            if (volatiles.bind.duration == 0) {
+                const reason = @intFromEnum(End.Bind) + volatiles.bind.reason - 1;
                 try options.log.end(battle.active(player), @enumFromInt(reason));
             } else {
-                var reason = @intFromEnum(Activate.Bind) + volatiles.bind_reason - 1;
+                var reason = @intFromEnum(Activate.Bind) + volatiles.bind.reason - 1;
                 try options.log.activate(battle.active(player), @enumFromInt(reason));
 
-                reason = @intFromEnum(Activate.Damage) + volatiles.bind_reason - 1;
+                reason = @intFromEnum(Damage.Bind) + volatiles.bind.reason - 1;
                 side.stored().hp -|= @max(side.stored().stats.hp / 16, 1);
-                try options.log.damage(battle.active(player), side.stored(), reason);
+                try options.log.damage(battle.active(player), side.stored(), @enumFromInt(reason));
             }
         }
     }
@@ -1157,7 +930,7 @@ fn betweenTurns(battle: anytype, mslot: u3, options: anytype) !void {
 
             assert(volatiles.perish_song < 3);
             const reason = @intFromEnum(Start.PerishSong0) + volatiles.perish_song;
-            try options.log.start(battle.active(player), reason);
+            try options.log.start(battle.active(player), @enumFromInt(reason));
 
             if (volatiles.perish_song == 0) {
                 volatiles.PerishSong = false;
@@ -1203,22 +976,21 @@ fn betweenTurns(battle: anytype, mslot: u3, options: anytype) !void {
     // Side Conditions
     if (showdown) {
         inline for (players) |player| {
-            updateSideCondition(battle, player, "Reflect", "reflect");
+            try updateSideCondition(battle, player, "Reflect", "reflect", options);
         }
         inline for (players) |player| {
-            updateSideCondition(battle, player, "LightScreen", "light_screen");
+            try updateSideCondition(battle, player, "LightScreen", "light_screen", options);
         }
         inline for (players) |player| {
-            updateSideCondition(battle, player, "Safeguard", "safeguard");
+            try updateSideCondition(battle, player, "Safeguard", "safeguard", options);
         }
     } else {
         inline for (players) |player| {
-            updateSideCondition(battle, player, "Safeguard", "safeguard");
+            try updateSideCondition(battle, player, "Safeguard", "safeguard", options);
         }
-
         inline for (players) |player| {
-            updateSideCondition(battle, player, "LightScreen", "light_screen");
-            updateSideCondition(battle, player, "Reflect", "reflect");
+            try updateSideCondition(battle, player, "LightScreen", "light_screen", options);
+            try updateSideCondition(battle, player, "Reflect", "reflect", options);
         }
     }
 
@@ -1291,7 +1063,7 @@ fn betweenTurns(battle: anytype, mslot: u3, options: anytype) !void {
             assert(volatiles.encore > 0);
             volatiles.encore -= 1;
 
-            if (volatiles.encore == 0 or side.active.moves(mslot).pp == 0) {
+            if (volatiles.encore == 0 or side.active.move(mslot).pp == 0) {
                 volatiles.Encore = false;
                 try options.log.end(battle.active(player), .Encore);
             }
@@ -1313,7 +1085,7 @@ inline fn updateSideCondition(
 
         if (@field(side.conditions, value) == 0) {
             @field(side.conditions, key) = false;
-            try options.log.sideend(battle.active(player), @field(protocol.Side, key));
+            try options.log.sideend(player, @field(protocol.Side, key));
         }
     }
 }
@@ -1333,133 +1105,150 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
     return Result.Default;
 }
 
-fn buildRage(battle: anytype, player: Player, options: anytype) !void {
+fn buildRage(battle: anytype, player: Player, state: *State, options: anytype) !void {
     var foe = battle.foe(player);
     if (foe.active.volatiles.Rage) {
         if (showdown) {
             // TODO if showdown boost
             if (foe.active.boosts.atk < 6) {
-                try Effects.boost(battle, player, Move.get(.Rage), options);
+                try Effects.boost(battle, player, state, options);
             }
         } 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, options: anytype) !void {
+fn kingsRock(battle: anytype, player: Player, _: *State, options: anytype) !void {
     var foe = battle.foe(player);
     const flinch = battle.side(player).stored().item == .KingsRock and
         !foe.active.volatiles.Substitute and
-        try options.chance.item(battle, player, options);
+        try Rolls.item(battle, player, options);
     if (flinch) {
-        foe.active.volatiles.Recharge = false;
+        foe.active.volatiles.Recharging = false;
         foe.active.volatiles.Flinch = true;
     }
 }
 
 pub const Effects = struct {
-    fn alwaysHit(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn alwaysHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn attract(battle: anytype, player: Player, options: anytype) !void {
+    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) {
-            return try options.log.immune(battle.active(player.foe()), .None);
+            try options.log.immune(battle.active(player.foe()), .None);
+            return;
         } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
             try options.log.lastmiss();
-            return try options.log.miss(battle.active(player));
+            try options.log.miss(battle.active(player));
+            return;
         }
 
         foe.active.volatiles.Attract = true;
         try options.log.start(battle.active(player.foe()), .Attract);
     }
 
-    fn batonPass(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn batonPass(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn beatUp(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn beatUp(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn bellyDrum(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn bellyDrum(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn bide(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn bide(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn binding(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn binding(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn burnChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn burnChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn confusion(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn confusion(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn conversion(battle: anytype, player: Player, options: anytype) !void {
+    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) return try options.log.fail(battle.active(player), .None);
+        if (n == 0) {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
 
         side.active.types.type1 = try Rolls.conversion(battle, player, n, options);
         side.active.types.type2 = side.active.types.type1;
     }
 
-    fn conversion2(battle: anytype, player: Player, options: anytype) !void {
+    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) return try options.log.fail(battle.active(player), .None);
+        if (last == .None) {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
         const move = Move.get(last);
-        if (move.type == .@"???") return try options.log.fail(battle.active(player), .None);
+        if (move.type == .@"???") {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
 
         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, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn counter(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn curse(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn curse(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn defenseCurl(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn defenseCurl(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn destinyBond(battle: anytype, player: Player, options: anytype) !void {
+    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);
     }
 
-    fn disable(battle: anytype, player: Player, options: anytype) !void {
+    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.disabled.move != 0) return try options.log.fail(foe_ident, .None);
+        if (volatiles.disable.move != 0) {
+            try options.log.fail(foe_ident, .None);
+            return;
+        }
 
         const last = battle.foe(player).lastMove(false);
-        if (last == .None or last == .Struggle) return try options.log.fail(foe_ident, .None);
+        if (last == .None or last == .Struggle) {
+            try options.log.fail(foe_ident, .None);
+            return;
+        }
 
         var slot: u3 = 0;
         for (foe.active.moves) |m| {
@@ -1468,23 +1257,26 @@ pub const Effects = struct {
             if (m.id == last) break;
         }
         const move = foe.active.move(slot);
-        if (move.pp == 0) return try options.log.fail(foe_ident, .None);
+        if (move.pp == 0) {
+            try options.log.fail(foe_ident, .None);
+            return;
+        }
 
-        volatiles.disabled.move = slot;
-        volatiles.disabled.duration = Rolls.disableDuration(battle, player, options);
+        volatiles.disable.move = slot;
+        volatiles.disable.duration = Rolls.disableDuration(battle, player, options);
 
         try options.log.startEffect(foe_ident, .Disable, move.id);
     }
 
-    fn doubleHit(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn doubleHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn drainHP(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn drainHP(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn encore(battle: anytype, player: Player, first: bool, options: anytype) !void {
+    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());
@@ -1493,7 +1285,10 @@ pub const Effects = struct {
         const failed = volatiles.Encore or
             (last == .None or last == .Struggle or
             last == .Encore or .last == .MirrorMove);
-        if (failed) return try options.log.fail(foe_ident, .None);
+        if (failed) {
+            try options.log.fail(foe_ident, .None);
+            return;
+        }
 
         var slot: u3 = 0;
         for (foe.active.moves) |m| {
@@ -1502,49 +1297,53 @@ pub const Effects = struct {
             if (m.id == last) break;
         }
         const move = foe.active.move(slot);
-        if (move.pp == 0) return try options.log.fail(foe_ident, .None);
+        if (move.pp == 0) {
+            try options.log.fail(foe_ident, .None);
+            return;
+        }
 
         volatiles.Encore = true;
         volatiles.encore = Rolls.encoreDuration(battle, player, options);
 
         // TODO ???
-        _ = first;
+        _ = state;
 
         try options.log.startEffect(foe_ident, .Encore, move.id);
     }
 
-    fn explode(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn explode(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn falseSwipe(battle: anytype, player: Player, damage: u16) !u16 {
+    fn falseSwipe(battle: anytype, player: Player, state: *State, _: anytype) !void {
         const foe = battle.foe(player);
         assert(foe.stored().hp > 0);
         // FIXME crit?
-        return if (damage > foe.stored().hp) foe.stored().hp - 1 else damage;
+        if (state.damage > foe.stored().hp) state.damage = foe.stored().hp - 1;
     }
 
-    fn fixedDamage(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn fixedDamage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn flameWheel(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn flameWheel(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn flinchChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn flinchChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn flyDig(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn flyDig(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn focusEnergy(battle: anytype, player: Player, options: anytype) !void {
+    fn focusEnergy(battle: anytype, player: Player, _: *State, options: anytype) !void {
         var side = battle.side(player);
 
         if (side.active.volatiles.FocusEnergy) {
-            return if (!showdown) try options.log.fail(battle.active(player), .None);
+            if (!showdown) try options.log.fail(battle.active(player), .None);
+            return;
         }
 
         side.active.volatiles.FocusEnergy = true;
@@ -1553,7 +1352,7 @@ pub const Effects = struct {
 
     var SLOTS: [5]u4 = .{ 0, 0, 0, 0, 0 };
 
-    fn forceSwitch(battle: anytype, player: Player, options: anytype) !void {
+    fn forceSwitch(battle: anytype, player: Player, _: *State, options: anytype) !void {
         const foe = battle.foe(player);
 
         var n: u4 = 0;
@@ -1568,334 +1367,341 @@ pub const Effects = struct {
             }
         }
 
-        if (n == 0) try options.log.fail(battle.active(player), .None);
+        if (n == 0) {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
 
         _ = try Rolls.forceSwitch(battle, player, SLOTS[0..i], n, options); // TODO
     }
 
-    fn foresight(battle: anytype, player: Player, options: anytype) !void {
+    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();
-            return try options.log.miss(battle.active(player));
+            try options.log.miss(battle.active(player));
+            return;
         } else if (foe.active.volatiles.Foresight) {
-            return try options.log.fail(battle.active(player), .None);
+            try options.log.fail(battle.active(player), .None);
+            return;
         }
 
         foe.active.volatiles.Foresight = true;
         try options.log.start(battle.active(player.foe()), .FocusEnergy);
     }
 
-    fn freezeChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn freezeChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn furyCutter(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn furyCutter(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn futureSight(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn futureSight(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn happiness(battle: anytype, player: Player, move: Move.Data) !u8 {
+    fn happiness(battle: anytype, player: Player, state: *State, _: anytype) !void {
         const val = battle.side(player).stored().happiness;
-        return ((if (move.effect == .Frustration) 255 - val else val) * 10) / 25;
+        const frustration = Move.get(state.move).effect == .Frustration;
+        state.bp = ((if (frustration) 255 - val else val) * 10) / 25;
     }
 
-    fn haze(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn haze(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn heal(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn heal(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn healBell(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn healBell(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn hiddenPower(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn hiddenPower(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn hyperBeam(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn hyperBeam(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn jumpKick(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn jumpKick(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn leechSeed(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn leechSeed(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn levelDamage(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn levelDamage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn lockOn(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn lockOn(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
     const MAGNITUDE_POWER = [_]u8{ 10, 30, 50, 70, 90, 110, 150 };
 
-    fn magnitude(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn magnitude(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn meanLook(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn meanLook(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn metronome(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn metronome(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn mimic(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn mimic(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn mirrorCoat(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn mirrorCoat(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn mirrorMove(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn mirrorMove(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn mist(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn mist(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn weatherHeal(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn weatherHeal(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn multiHit(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn multiHit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn nightmare(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn nightmare(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn ohko(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn ohko(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn painSplit(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn painSplit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn paralyze(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn paralyze(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn paralyzeChance(battle: anytype, player: Player, options: anytype) !void {
+    fn paralyzeChance(battle: anytype, player: Player, state: *State, options: anytype) !void {
         // TODO: Thunder does acc/checkHit/effectChance before stab + damage variation
-        _ = .{ battle, player, options }; // TODO
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn payDay(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn payDay(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn perishSong(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn perishSong(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn poison(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn poison(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn present(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn present(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn protect(
-        battle: anytype,
-        player: Player,
-        move: Move,
-        first: bool,
-        options: anytype,
-    ) !void {
+    fn protect(battle: anytype, player: Player, state: *State, options: anytype) !void {
         var side = battle.side(player);
         var volatiles = &side.active.volatiles;
 
-        const failed = !first or volatiles.Substitute or
+        const failed = !state.first or volatiles.Substitute or
             !try Rolls.protect(battle, player, volatiles.protect, options);
-        if (failed) return try options.log.fail(battle.active(player), .None);
+        if (failed) {
+            try options.log.fail(battle.active(player), .None);
+            return;
+        }
 
         volatiles.protect = @max(8, volatiles.protect + 1);
-        if (move == .Endure) {
+        if (state.move == .Endure) {
             volatiles.Endure = true;
         } else {
             volatiles.Protect = true;
         }
-        try options.log.singleturn(battle.active(player), move);
+        try options.log.singleturn(battle.active(player), state.move);
     }
 
-    fn psychUp(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn psychUp(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn pursuit(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn pursuit(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn rage(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn rage(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn rainDance(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn rainDance(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn rapidSpin(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn rapidSpin(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn razorWind(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn razorWind(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn recoil(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn recoil(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn reversal(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn reversal(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn rollout(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn rollout(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn sacredFire(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn sacredFire(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn safeguard(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn safeguard(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn sandstorm(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn sandstorm(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn screens(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn screens(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn sketch(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn sketch(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn skullBash(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn skullBash(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn skyAttack(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn skyAttack(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn sleep(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn sleep(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn sleepTalk(battle: anytype, player: Player, mslot: u3, options: anytype) !void {
+    fn sleepTalk(battle: anytype, player: Player, state: *State, options: anytype) !void {
         const side = battle.side(player);
 
         if (!Status.is(side.stored().status, .SLP)) {
-            return if (!showdown) try options.log.fail(battle.active(player), .None);
+            if (!showdown) try options.log.fail(battle.active(player), .None);
+            return;
         }
 
         var n: u3 = 0;
         for (side.active.moves, 0..) |m, i| {
-            if (mslot - 1 != i and Move.get(m.id).extra.sleep_talk) n += 1;
+            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 try options.log.fail(battle.active(player), .None);
 
-        _ = try Rolls.sleepTalk(battle, player, n, mslot, options); // TODO
+        _ = try Rolls.sleepTalk(battle, player, n, state.mslot, options); // TODO
     }
 
-    fn snore(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn snore(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn solarBeam(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn solarBeam(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn spikes(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn spikes(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn spite(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn spite(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn splash(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn splash(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn stomp(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn stomp(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn substitute(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn substitute(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn sunnyDay(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn sunnyDay(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn swagger(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn swagger(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn synthesis(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn synthesis(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn teleport(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn teleport(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn thief(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn thief(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn thrashing(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn thrashing(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn toxic(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn toxic(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn transform(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn transform(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn tripleKick(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn tripleKick(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn twister(battle: anytype, player: Player, options: anytype) !void {
-        _ = .{ battle, player, options }; // TODO
+    fn twister(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn boost(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn boost(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 
-    fn unboost(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-        _ = .{ battle, player, move, options }; // TODO
+    fn unboost(battle: anytype, player: Player, state: *State, options: anytype) !void {
+        _ = .{ battle, player, state, options }; // TODO
     }
 };
 
@@ -2547,6 +2353,28 @@ test "Roll probabilities" {
     try expectEqualSlices(u8, &.{ 14, 26, 50, 77, 51, 25, 13 }, &magnitude);
 }
 
+test "Reasons" {
+    const moves = [_]Move{ .Bind, .Wrap, .FireSpin, .Clamp, .Whirlpool };
+    for (moves) |move| {
+        const reason = Move.get(move).extra.protocol - 1;
+
+        const activate: Activate = @enumFromInt(@intFromEnum(Activate.Bind) + reason);
+        try expectEqualStrings(@tagName(move), @tagName(activate));
+
+        const damage: Damage = @enumFromInt(@intFromEnum(Damage.Bind) + reason);
+        try expectEqualStrings(@tagName(move), @tagName(damage));
+
+        const end: End = @enumFromInt(@intFromEnum(End.Bind) + reason);
+        try expectEqualStrings(@tagName(move), @tagName(end));
+    }
+
+    const perish_song = [_]Start{ .PerishSong0, .PerishSong1, .PerishSong2, .PerishSong3 };
+    for (perish_song, 0..) |ps, i| {
+        const reason: Start = @enumFromInt(@intFromEnum(Start.PerishSong0) + i);
+        try expectEqualStrings(@tagName(ps), @tagName(reason));
+    }
+}
+
 pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Choice) u8 {
     var n: u8 = 0;
     switch (request) {
@@ -2625,7 +2453,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                     if (m.id == if (active.volatiles.Bide) .Bide else side.last_selected_move) {
                         // Pokémon Showdown displays Struggle if limited to Bide but unable to pick
                         const struggle =
-                            m.id == .Bide and (m.pp == 0 or active.volatiles.disabled_move == slot);
+                            m.id == .Bide and (m.pp == 0 or active.volatiles.disable.move == slot);
                         const s = if (struggle) 0 else slot;
                         out[n] = .{ .type = .Move, .data = s };
                         n += 1;
@@ -2640,7 +2468,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
                 const m = active.moves[slot - 1];
                 if (m.id == .None) break;
                 if (m.pp == 0) continue;
-                if (active.volatiles.disabled_move == slot) continue;
+                if (active.volatiles.disable.move == slot) continue;
                 out[n] = .{ .type = .Move, .data = slot };
                 n += 1;
             }