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

package/src/lib/gen2/mechanics.zig

@@ -89,8 +89,6 @@ const CRITICAL_HITS = &[_]u8{
 
 const MAX_STAT_VALUE = 999;
 
-const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
-
 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);
@@ -317,13 +315,13 @@ fn doTurn(
     const foe_volatiles = &battle.foe(player).active.volatiles;
 
     volatiles.DestinyBond = false;
-    if (try executeMove(battle, player, player_choice, options)) |r| return r;
+    if (try executeMove(battle, player, player_choice, true, options)) |r| return r;
     foe_volatiles.Protect = false;
     foe_volatiles.Endure = false;
     foe_volatiles.DestinyBond = false;
 
     // foe_volatiles.DestinyBond = false;
-    if (try executeMove(battle, foe_player, foe_choice, options)) |r| return r;
+    if (try executeMove(battle, foe_player, foe_choice, false, options)) |r| return r;
     volatiles.Protect = false;
     volatiles.Endure = false;
     volatiles.DestinyBond = false;
@@ -331,20 +329,26 @@ fn doTurn(
     return null;
 }
 
-fn executeMove(battle: anytype, player: Player, choice: Choice, options: anytype) !?Result {
+fn executeMove(
+    battle: anytype,
+    player: Player,
+    choice: Choice,
+    first: bool,
+    options: anytype,
+) !?Result {
     if (choice.type == .Switch) {
         try switchIn(battle, player, choice.data, false, options);
         return null;
     }
 
     assert(choice.type == .Move);
-    var mslot: u4 = @intCast(choice.data);
+    var mslot: u3 = @intCast(choice.data);
 
     // const move = Move.get(side.last_selected_move);
 
     // CheckTurn
 
-    return doMove(battle, player, options, mslot);
+    return doMove(battle, player, mslot, first, options);
 }
 
 fn beforeMove(battle: anytype, player: Player, options: anytype) !bool {
@@ -498,7 +502,7 @@ fn canMove(battle: anytype, player: Player, options: anytype) !bool {
     return false;
 }
 
-fn decrementPP(side: *Side, mslot: u4) void {
+fn decrementPP(side: *Side, mslot: u3) void {
     var active = &side.active;
     const volatiles = &active.volatiles;
 
@@ -516,16 +520,319 @@ fn decrementPP(side: *Side, mslot: u4) void {
     assert(active.move(mslot).pp == side.stored().move(mslot).pp);
 }
 
-fn doMove(battle: anytype, player: Player, options: anytype, mslot: u4) !?Result {
-    _ = options;
+fn doMove(battle: anytype, player: Player, mslot: u3, first: bool, options: anytype) !?Result {
     var side = battle.side(player);
-    const move = Move.get(.Teleport); // side.last_selected_move
+    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 => {
-            // side.useMove();
-            decrementPP(side, mslot);
+            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
         },
-        else => @panic("TODO"),
     }
     return null;
 }
@@ -772,7 +1079,7 @@ fn handleResidual(battle: anytype, player: Player, options: anytype) !void {
     }
 }
 
-fn betweenTurns(battle: anytype, mslot: u4, options: anytype) !void {
+fn betweenTurns(battle: anytype, mslot: u3, options: anytype) !void {
     const players = std.enums.values(Player);
 
     // TODO checkFaintThen(p1, p2);
@@ -1027,24 +1334,543 @@ fn endTurn(battle: anytype, options: anytype) @TypeOf(options.log).Error!Result
 }
 
 pub const Effects = struct {
-    fn protect(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+    fn alwaysHit(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn attract(battle: anytype, player: Player, 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);
+        } else if (foe.active.volatiles.Flying or foe.active.volatiles.Underground) {
+            try options.log.lastmiss();
+            return try options.log.miss(battle.active(player));
+        }
+
+        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 beatUp(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn bellyDrum(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn bide(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn binding(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn burnChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        _ = .{ battle, player, move, options }; // TODO
+    }
+
+    fn confusion(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        _ = .{ battle, player, move, options }; // TODO
+    }
+
+    fn conversion(battle: anytype, player: Player, options: anytype) !void {
         var side = battle.side(player);
-        var volatiles = &side.active.volatiles;
 
-        // TODO or if we didn't go first
-        if (volatiles.Substitute) return try options.log.fail(battle.active(player), .None);
+        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);
+
+        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 {
+        var side = battle.side(player);
+
+        const last = battle.foe(player).lastMove(false);
+        if (last == .None) return try options.log.fail(battle.active(player), .None);
+        const move = Move.get(last);
+        if (move.type == .@"???") return try 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, move: Move.Data, options: anytype) !void {
+        _ = .{ battle, player, move, options }; // TODO
+    }
+
+    fn curse(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn defenseCurl(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn destinyBond(battle: anytype, player: Player, 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 {
+        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);
+
+        const last = battle.foe(player).lastMove(false);
+        if (last == .None or last == .Struggle) return try options.log.fail(foe_ident, .None);
+
+        var slot: u3 = 0;
+        for (foe.active.moves) |m| {
+            assert(m.id != .None);
+            slot += 1;
+            if (m.id == last) break;
+        }
+        const move = foe.active.move(slot);
+        if (move.pp == 0) return try options.log.fail(foe_ident, .None);
+
+        volatiles.disabled.move = slot;
+        volatiles.disabled.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 drainHP(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn encore(battle: anytype, player: Player, first: bool, options: anytype) !void {
+        var foe = battle.foe(player);
+        var volatiles = &foe.active.volatiles;
+        const foe_ident = battle.active(player.foe());
+
+        const last = battle.foe(player).lastMove(true);
+        const failed = volatiles.Encore or
+            (last == .None or last == .Struggle or
+            last == .Encore or .last == .MirrorMove);
+        if (failed) return try options.log.fail(foe_ident, .None);
+
+        var slot: u3 = 0;
+        for (foe.active.moves) |m| {
+            assert(m.id != .None);
+            slot += 1;
+            if (m.id == last) break;
+        }
+        const move = foe.active.move(slot);
+        if (move.pp == 0) return try options.log.fail(foe_ident, .None);
+
+        volatiles.Encore = true;
+        volatiles.encore = Rolls.encoreDuration(battle, player, options);
+
+        // TODO ???
+        _ = first;
+
+        try options.log.startEffect(foe_ident, .Encore, move.id);
+    }
+
+    fn explode(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn falseSwipe(battle: anytype, player: Player, damage: u16) !u16 {
+        const foe = battle.foe(player);
+        assert(foe.stored().hp > 0);
+        // FIXME crit?
+        return if (damage > foe.stored().hp) foe.stored().hp - 1 else damage;
+    }
+
+    fn fixedDamage(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        _ = .{ battle, player, move, options }; // TODO
+    }
+
+    fn flameWheel(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn flinchChance(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        _ = .{ battle, player, move, options }; // TODO
+    }
+
+    fn flyDig(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        _ = .{ battle, player, move, options }; // TODO
+    }
+
+    fn focusEnergy(battle: anytype, player: Player, options: anytype) !void {
+        var side = battle.side(player);
+
+        if (side.active.volatiles.FocusEnergy) {
+            return if (!showdown) try options.log.fail(battle.active(player), .None);
+        }
+
+        side.active.volatiles.FocusEnergy = true;
+        try options.log.start(battle.active(player), .FocusEnergy);
+    }
+
+    var SLOTS: [5]u3 = .{ 0, 0, 0, 0, 0 };
+
+    fn forceSwitch(battle: anytype, player: Player, options: anytype) !void {
+        const foe = battle.foe(player);
+
+        var n: u3 = 0;
+        var i: u3 = 0;
+        for (foe.pokemon, 0..) |pokemon, j| {
+            if (pokemon.species == .None) break;
+            n += 1;
+            if (pokemon.position == 1) continue;
+            if (pokemon.hp > 0) {
+                SLOTS[i] = @intCast(foe.pokemon[j].position);
+                i += 1;
+            }
+        }
+
+        if (n == 0) try options.log.fail(battle.active(player), .None);
+
+        _ = try Rolls.forceSwitch(battle, player, SLOTS[0..i], n, options); // TODO
+    }
+
+    fn foresight(battle: anytype, player: Player, 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));
+        } else if (foe.active.volatiles.Foresight) {
+            return try options.log.fail(battle.active(player), .None);
+        }
+
+        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 furyCutter(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn futureSight(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn happiness(battle: anytype, player: Player, move: Move.Data) !u8 {
+        const val = battle.side(player).stored().happiness;
+        return ((if (move.effect == .Frustration) 255 - val else val) * 10) / 25;
+    }
+
+    fn haze(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn heal(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn healBell(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn hiddenPower(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn hyperBeam(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn jumpKick(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn leechSeed(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn levelDamage(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn lockOn(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, 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 meanLook(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn metronome(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn mimic(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn mirrorCoat(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn mirrorMove(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn mist(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn weatherHeal(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn multiHit(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn nightmare(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn ohko(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn painSplit(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn paralyze(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn paralyzeChance(battle: anytype, player: Player, options: anytype) !void {
+        // TODO: Thunder does acc/checkHit/effectChance before stab + damage variation
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn payDay(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
 
-        // TODO
+    fn perishSong(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
 
-        if (move.effect == .Endure) {
+    fn poison(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        _ = .{ battle, player, move, options }; // TODO
+    }
+
+    fn present(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn protect(
+        battle: anytype,
+        player: Player,
+        move: Move,
+        first: bool,
+        options: anytype,
+    ) !void {
+        var side = battle.side(player);
+        var volatiles = &side.active.volatiles;
+
+        const failed = !first or volatiles.Substitute or
+            !try Rolls.protect(battle, player, volatiles.protect, options);
+        if (failed) return try options.log.fail(battle.active(player), .None);
+
+        volatiles.protect = @max(8, volatiles.protect + 1);
+        if (move == .Endure) {
             volatiles.Endure = true;
         } else {
             volatiles.Protect = true;
         }
-        try options.log.singleturn(battle.active(player), move.id);
+        try options.log.singleturn(battle.active(player), move);
     }
 
-    const MAGNITUDE_POWER = [_]u8{ 10, 30, 50, 70, 90, 110, 150 };
+    fn psychUp(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn pursuit(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn rage(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn rainDance(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn rapidSpin(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn razorWind(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn recoil(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn reversal(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn rollout(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn sacredFire(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn safeguard(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn sandstorm(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn screens(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        _ = .{ battle, player, move, options }; // TODO
+    }
+
+    fn sketch(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn skullBash(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn skyAttack(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn sleep(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn sleepTalk(battle: anytype, player: Player, mslot: u3, 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);
+        }
+
+        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 (n == 0) return try options.log.fail(battle.active(player), .None);
+
+        _ = try Rolls.sleepTalk(battle, player, n, mslot, options); // TODO
+    }
+
+    fn snore(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn solarBeam(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn spikes(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn spite(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn splash(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn stomp(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn substitute(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn sunnyDay(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn swagger(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn synthesis(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn teleport(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn thief(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn thrashing(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn toxic(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn transform(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn tripleKick(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn twister(battle: anytype, player: Player, options: anytype) !void {
+        _ = .{ battle, player, options }; // TODO
+    }
+
+    fn boost(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        _ = .{ battle, player, move, options }; // TODO
+    }
+
+    fn unboost(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
+        _ = .{ battle, player, move, options }; // TODO
+    }
 };
 
 fn statusModify(status: u8, stats: *Stats(u16)) void {
@@ -1061,6 +1887,12 @@ inline fn isForced(active: anytype) bool {
         active.volatiles.Rollout;
 }
 
+inline fn convertible(active: ActivePokemon, m: Move) bool {
+    if (m == .None) return false;
+    const t = Move.get(m).type;
+    return t != .@"???" and !active.types.includes(t);
+}
+
 pub const Rolls = struct {
     inline fn speedTie(battle: anytype, options: anytype) !bool {
         const p1 = if (options.calc.overridden(.P1, .speed_tie)) |player|
@@ -1187,47 +2019,25 @@ pub const Rolls = struct {
         return proc;
     }
 
-    inline fn focusBand(battle: anytype, player: Player, options: anytype) !bool {
-        const proc = if (options.calc.overridden(player, .focus_band)) |val|
-            val == .true
-        else if (showdown)
-            battle.rng.chance(u8, 30, 256)
-        else
-            battle.rng.next() < 30;
-
-        try options.chance.focusBand(player, proc);
-        return proc;
-    }
+    inline fn item(battle: anytype, player: Player, options: anytype, effect: Item) !bool {
+        assert(effect == .FocusBand or effect == .KingsRock);
+        const roll = if (effect == .FocusBand) .focus_band else .kings_rock;
 
-    inline fn kingsRock(battle: anytype, player: Player, options: anytype) !bool {
-        const proc = if (options.calc.overridden(player, .kings_rock)) |val|
+        const proc = if (options.calc.overridden(player, roll)) |val|
             val == .true
         else if (showdown)
             battle.rng.chance(u8, 30, 256)
         else
             battle.rng.next() < 30;
 
-        try options.chance.kingsRock(player, proc);
+        if (effect == .FocusBand) {
+            try options.chance.focusBand(player, proc);
+        } else {
+            try options.chance.kingsRock(player, proc);
+        }
         return proc;
     }
 
-    inline fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
-        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
-            @intCast(val)
-        else if (showdown)
-            @intCast(battle.rng.range(u8, 1, 7))
-        else duration: {
-            while (true) {
-                const r = battle.rng.next() & 7;
-                if (r != 0 and r != 7) break :duration @intCast(r);
-            }
-        };
-
-        assert(duration >= 1 and duration <= 6);
-        options.chance.duration(.sleep, player, player.foe(), duration);
-        return duration + 1;
-    }
-
     inline fn triAttack(battle: anytype, player: Player, options: anytype) !u8 {
         const status: TriAttack = if (options.calc.overridden(player, .tri_attack)) |val|
             val
@@ -1236,7 +2046,7 @@ pub const Rolls = struct {
         else loop: {
             while (true) {
                 const r = std.math.rotr(u8, std.battle.rng.next(), 4) & 3;
-                if (r != 0) break :loop @intCast(r - 1);
+                if (r != 0) break :loop @enumFromInt(r - 1);
             }
         };
 
@@ -1294,11 +2104,11 @@ pub const Rolls = struct {
         return num;
     }
 
-    inline fn tripleKick(battle: anytype, player: Player, options: anytype) !u8 {
+    inline fn tripleKick(battle: anytype, player: Player, options: anytype) !u2 {
         const hits = if (options.calc.overridden(player, .triple_kick)) |val|
             val
         else if (showdown)
-            battle.rng.range(u8, 1, 4)
+            battle.rng.range(u2, 1, 4)
         else power: {
             while (true) {
                 const r = battle.rng.next() & 3;
@@ -1325,7 +2135,7 @@ pub const Rolls = struct {
     }
 
     // Conversion 2 can at most choose between 7 types (vs. a Grass-type attack)
-    const CONVERSION_2: [7]Type = [_]Type{.{}} ** 7;
+    var CONVERSION_2: [7]Type = [_]Type{.@"???"} ** 7;
 
     inline fn conversion2(battle: anytype, player: Player, mtype: Type, options: anytype) !Type {
         var i: u8 = 0;
@@ -1349,7 +2159,7 @@ pub const Rolls = struct {
                 if (r > 9 and r < 20) continue; // UNUSED_TYPES
                 if (r > 27) continue; // TYPES_END
 
-                const t = Types.conversion2(r);
+                const t = Type.conversion2(r);
                 if (@intFromEnum(mtype.effectiveness(t)) < neutral) {
                     break :ty t;
                 }
@@ -1361,17 +2171,152 @@ pub const Rolls = struct {
         return ty;
     }
 
-    // TODO thrashingDuration
-    // TODO confusionDuraiton (from thrash vs. from move)
-    // TODO forceSwitch
-    // TODO bindingDuration
-    // TODO bideDuration
-    // TODO conversion moveSlot
-    // TODO disable duration
-    // TODO encore duration
-    // TODO metronome
-    // TODO protect
-    // TODO sleeptalk move slot
+    inline fn protect(battle: anytype, player: Player, count: u8, options: anytype) !bool {
+        assert(count <= 8);
+        const num = if (count == 8) 0 else @as(u8, 255) >> @intCast(count);
+
+        const ok = if (options.calc.overridden(player, .protect)) |val|
+            val == .true
+        else if (showdown)
+            battle.rng.chance(u8, num, 255)
+        else protected: {
+            while (true) {
+                const r = battle.rng.next();
+                if (r != 0) break :protected !(num <= r - 1);
+            }
+        };
+
+        try options.chance.protect(player, num, ok);
+        return ok;
+    }
+
+    fn conversion(battle: anytype, player: Player, n: u3, options: anytype) !Type {
+        assert(n > 0);
+
+        const active = battle.side(player).active;
+        const moves = active.moves;
+
+        // TODO: consider throwing error instead of rerolling?
+        const overridden = if (options.calc.overridden(player, .move_slot)) |val|
+            if (convertible(active, moves[val - 1].id)) val else null
+        else
+            null;
+
+        const slot: u3 = overridden orelse slot: {
+            if (showdown) {
+                var r = battle.rng.range(u3, 0, n) + 1;
+                var i: usize = 0;
+                while (i < moves.len and r > 0) : (i += 1) {
+                    if (convertible(active, moves[i].id)) {
+                        r -= 1;
+                        if (r == 0) break :slot @intCast(i + 1);
+                    }
+                }
+                break :slot @intCast(i + 1);
+            } else {
+                while (true) {
+                    const r: u3 = @intCast(battle.rng.next() & 3);
+                    if (convertible(active, moves[r].id)) break :slot @intCast(r + 1);
+                }
+            }
+        };
+
+        assert(n >= 1 and n <= 4);
+        assert(slot >= 1 and slot <= 4);
+        try options.chance.moveSlot(player, slot, n);
+        return Move.get(active.move(slot).id).type;
+    }
+
+    fn sleepTalk(battle: anytype, player: Player, n: u3, mslot: u3, options: anytype) !u3 {
+        assert(n > 0);
+
+        const active = battle.side(player).active;
+        const moves = active.moves;
+
+        // TODO: consider throwing error instead of rerolling?
+        const overridden = if (options.calc.overridden(player, .move_slot)) |val|
+            if (val != mslot and Move.get(moves[val - 1].id).extra.sleep_talk) val else null
+        else
+            null;
+
+        const slot: u3 = overridden orelse slot: {
+            if (showdown) {
+                var r = battle.rng.range(u3, 0, n) + 1;
+                var i: usize = 0;
+                while (i < moves.len and r > 0) : (i += 1) {
+                    if (i + 1 != mslot and Move.get(moves[i].id).extra.sleep_talk) {
+                        r -= 1;
+                        if (r == 0) break :slot @intCast(i + 1);
+                    }
+                }
+                break :slot @intCast(i + 1);
+            } else {
+                while (true) {
+                    const r: u3 = @intCast(battle.rng.next() & 3);
+                    if (r + 1 == mslot or !Move.get(moves[r].id).extra.sleep_talk) continue;
+                    break :slot @intCast(r + 1);
+                }
+            }
+        };
+
+        assert(n >= 1 and n <= 4);
+        assert(slot >= 1 and slot <= 4);
+        try options.chance.moveSlot(player, slot, n);
+        return slot;
+    }
+
+    inline fn forceSwitch(
+        battle: anytype,
+        player: Player,
+        slots: []u3,
+        n: u3,
+        options: anytype,
+    ) !u3 {
+        const foe = battle.foe(player);
+
+        assert(slots.len < 5);
+        assert(n > 0 and n <= 6);
+
+        // TODO: consider throwing error instead of rerolling?
+        const overridden = if (options.calc.overridden(player, .force_switch)) |val| val: {
+            for (slots) |slot| if (slot == val) break :val if (foe.get(slot).hp > 0) val else null;
+            break :val null;
+        } else null;
+
+        const slot: u3 = overridden orelse slot: {
+            if (showdown) {
+                break :slot slots[battle.rng.range(u3, 0, @as(u3, @intCast(slots.len)))];
+            } else {
+                while (true) {
+                    const r = battle.rng.next() & 7;
+                    if (r > n or r == 1) continue;
+                    if (foe.get(r).hp > 0) break :slot @intCast(r);
+                }
+            }
+        };
+
+        assert(n >= 1 and n <= 6);
+        assert(slot >= 1 and slot <= 6);
+        try options.chance.forceSwitch(player, slot, n);
+        return slot;
+    }
+
+    const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
+
+    inline fn multiHit(battle: anytype, player: Player, options: anytype) !u3 {
+        const n: u3 = if (options.calc.overridden(player, .multi_hit)) |val|
+            @intCast(val)
+        else if (showdown)
+            DISTRIBUTION[battle.rng.range(u3, 0, DISTRIBUTION.len)]
+        else n: {
+            const r = (battle.rng.next() & 3);
+            break :n @intCast((if (r < 2) r else battle.rng.next() & 3) + 2);
+        };
+
+        assert(n >= 2 and n <= 5);
+        try options.chance.multiHit(player, n);
+        return n;
+    }
 
     inline fn psywave(battle: anytype, player: Player, max: u8, options: anytype) !u8 {
         const power = if (options.calc.overridden(player, .psywave)) |val|
@@ -1390,18 +2335,135 @@ pub const Rolls = struct {
         return power;
     }
 
-    const METRONOME = init: {
-        var num = 0;
-        var moves: [238]Move = undefined;
-        for (1..Move.size) |i| {
-            if (Move.get(@enumFromInt(i)).extra.metronome) {
-                moves[num] = @enumFromInt(i);
-                num += 1;
-            }
+    inline fn metronome(battle: anytype, player: Player, options: anytype) !Move {
+        const moves = battle.get(player).active.moves;
+
+        var n: u2 = 0;
+        for (moves) |m| {
+            if (m == .None) break;
+            if (Move.get(m).metronome) n += 1;
         }
-        assert(num == moves.len);
-        break :init moves;
-    };
+
+        // TODO: consider throwing error instead of rerolling?
+        const overridden = if (options.calc.overridden(player, .metronome)) |val| val: {
+            for (moves) |m| if (m.id == val) break :val null;
+            break :val val;
+        } else null;
+
+        const move: Move = overridden orelse move: {
+            if (showdown) {
+                var r = battle.rng.range(u8, 0, Move.METRONOME.len - n);
+                for (moves) |m| {
+                    if (m == .None or @intFromEnum(m) > @intFromEnum(Move.METRONOME[r])) break;
+                    if (Move.get(m).metronome) r -= 1;
+                }
+                break :move Move.METRONOME[r];
+            } else {
+                outer: while (true) {
+                    const r = battle.rng.next();
+                    if (r == 0 or r >= Move.size) continue;
+                    const selected: Move = @enumFromInt(r);
+                    if (!Move.get(selected).extra.metronome) continue;
+                    for (moves) |m| if (m.id == selected) continue :outer;
+                    break :move selected;
+                }
+            }
+        };
+
+        assert(Move.get(move).metronome);
+        try options.chance.metronome(player, move, n);
+        return move;
+    }
+
+    inline fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            battle.rng.range(u3, 1, 7)
+        else duration: {
+            while (true) {
+                const r = battle.rng.next() & 7;
+                if (r != 0 and r != 7) break :duration @intCast(r);
+            }
+        };
+
+        assert(duration >= 1 and duration <= 6);
+        options.chance.duration(.sleep, player, player.foe(), duration);
+        return duration + 1;
+    }
+
+    inline fn confusionDuration(battle: anytype, player: Player, self: bool, options: anytype) u3 {
+        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            // Pokémon Showdown incorrectly uses the same duration for self-confusion
+            battle.rng.range(u3, 2, 6)
+        else
+            @intCast((battle.rng.next() & if (self) 1 else 3) + 2);
+
+        assert(duration >= 2 and duration <= if (!showdown and self) 3 else 5);
+        options.chance.duration(.confusion, player, if (self) player else player.foe(), duration);
+        return duration;
+    }
+
+    inline fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
+        const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            // Pokémon Showdown incorrectly inherits Generation III's Disable duration
+            battle.rng.range(u4, 2, 6)
+        else duration: {
+            while (true) {
+                const r = battle.rng.next() & 7;
+                if (r != 0) break :duration @intCast(r + 1);
+            }
+        };
+
+        assert(duration >= 2 and duration <= (if (showdown) 5 else 7));
+        options.chance.duration(.disable, player, player.foe(), duration);
+        return duration;
+    }
+
+    inline fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            battle.rng.range(u3, 2, 4)
+        else
+            @intCast((battle.rng.next() & 1) + 2); // BUG: thrash is + 1 not +2
+
+        assert(duration >= 2 and duration <= 3);
+        options.chance.duration(.attacking, player, player, duration);
+        return duration;
+    }
+
+    inline fn bindingDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            // TODO: PS does range(3, 6) here which after subtracting 1 is actually 2-4 not 2-5!
+            battle.rng.range(u3, 2, 5)
+        else
+            @intCast(battle.rng.next() & 3 + 2));
+
+        assert(duration >= 2 and duration <= 5);
+        options.chance.duration(.binding, player, player.foe(), duration);
+        return duration + 1;
+    }
+
+    // TODO: consider sharing implementation with bindingDuration
+    inline fn encoreDuration(battle: anytype, player: Player, options: anytype) u3 {
+        const duration: u3 = (if (options.calc.overridden(player, .duration)) |val|
+            @intCast(val)
+        else if (showdown)
+            battle.rng.range(u3, 2, 6)
+        else
+            @intCast(battle.rng.next() & 3 + 2));
+
+        assert(duration >= 2 and duration <= 5);
+        options.chance.duration(.encore, player, player.foe(), duration);
+        return duration + 1;
+    }
 };
 
 test "RNG agreement" {