@pkmn/engine 0.1.0-dev.028ab165 → 0.1.0-dev.047d6e71

package/src/lib/gen1/data.zig

@@ -112,7 +112,7 @@ pub fn Battle(comptime RNG: anytype) type {
         /// make (i.e. on the cartridge a soft-lock occurs).
         ///
         /// This function will always return choices > 0 if `pkmn.options.showdown` is true.
-        pub fn choices(self: *Self, player: Player, request: Choice.Type, out: []Choice) u8 {
+        pub fn choices(self: *const Self, player: Player, request: Choice.Type, out: []Choice) u8 {
             return mechanics.choices(self, player, request, out);
         }
     };
@@ -316,12 +316,12 @@ test Status {
     try expect(Status.is(Status.slp(5), .SLP));
     try expect(!Status.is(Status.slp(5), .EXT));
     try expect(!Status.is(Status.slp(7), .PSN));
-    try expectEqual(@as(u3, 5), Status.duration(Status.slp(5)));
+    try expectEqual(5, Status.duration(Status.slp(5)));
     try expect(Status.is(Status.slf(2), .SLP));
     try expect(Status.is(Status.slf(2), .EXT));
     try expect(Status.is(Status.TOX, .PSN));
     try expect(Status.is(Status.TOX, .EXT));
-    try expectEqual(@as(u3, 1), Status.duration(Status.slp(1)));
+    try expectEqual(1, Status.duration(Status.slp(1)));
 }
 
 /// Bitfield representation of volatile statuses and associated data in Generation I.
@@ -405,13 +405,13 @@ test Volatiles {
     try expect(!volatiles.Transform);
     try expect(!volatiles.MultiHit);
 
-    try expectEqual(@as(u16, 235), volatiles.state);
-    try expectEqual(@as(u8, 42), volatiles.substitute);
-    try expectEqual(@as(u4, 2), volatiles.disable_move);
-    try expectEqual(@as(u4, 4), volatiles.disable_duration);
-    try expectEqual(@as(u4, 2), volatiles.confusion);
-    try expectEqual(@as(u5, 4), volatiles.toxic);
-    try expectEqual(@as(u4, 3), volatiles.attacks);
+    try expectEqual(235, volatiles.state);
+    try expectEqual(42, volatiles.substitute);
+    try expectEqual(2, volatiles.disable_move);
+    try expectEqual(4, volatiles.disable_duration);
+    try expectEqual(2, volatiles.confusion);
+    try expectEqual(4, volatiles.toxic);
+    try expectEqual(3, volatiles.attacks);
 }
 
 /// Representaiton of a Pokémon's stats in Generation I.
@@ -442,9 +442,9 @@ test Stats {
     try expectEqual(0, stats.def);
 
     var base = Species.get(.Gyarados).stats;
-    try expectEqual(@as(u16, 127), Stats(u16).calc("hp", base.hp, 0, 5120, 38));
+    try expectEqual(127, Stats(u16).calc("hp", base.hp, 0, 5120, 38));
     base = Species.get(.Pidgeot).stats;
-    try expectEqual(@as(u16, 279), Stats(u16).calc("spe", base.spe, 15, 63001, 100));
+    try expectEqual(279, Stats(u16).calc("spe", base.spe, 15, 63001, 100));
 }
 
 /// Representation of a Pokémon's boosts in Generation I.
@@ -537,7 +537,7 @@ pub const Species = species.Species;
 
 test Species {
     try expectEqual(2, @intFromEnum(Species.Ivysaur));
-    try expectEqual(@as(u8, 100), Species.get(.Mew).stats.def);
+    try expectEqual(100, Species.get(.Mew).stats.def);
 }
 
 /// Representation of a Generation I type in Pokémon.
@@ -576,8 +576,8 @@ test Types {
     try expectEqual(Effectiveness.Resisted, Type.effectiveness(.Fire, .Water));
     try expectEqual(Effectiveness.Neutral, Type.effectiveness(.Normal, .Grass));
 
-    try expectEqual(@as(u8, 3), Type.precedence(.Water, .Water));
-    try expectEqual(@as(u8, 26), Type.precedence(.Bug, .Ghost));
+    try expectEqual(3, Type.precedence(.Water, .Water));
+    try expectEqual(26, Type.precedence(.Bug, .Ghost));
     try expect(Type.precedence(.Poison, .Bug) > Type.precedence(.Poison, .Poison));
 
     const t: Types = .{ .type1 = .Rock, .type2 = .Ground };
@@ -617,18 +617,18 @@ pub const DVs = struct {
 
 test DVs {
     var dvs: DVs = .{ .spc = 15, .spe = 15 };
-    try expectEqual(@as(u4, 15), dvs.hp());
+    try expectEqual(15, dvs.hp());
     dvs = .{
         .atk = 5,
         .def = 15,
         .spe = 13,
         .spc = 13,
     };
-    try expectEqual(@as(u4, 15), dvs.hp());
+    try expectEqual(15, dvs.hp());
     dvs = .{
         .def = 3,
         .spe = 10,
         .spc = 11,
     };
-    try expectEqual(@as(u4, 13), dvs.hp());
+    try expectEqual(13, dvs.hp());
 }

package/src/lib/gen1/helpers.zig

@@ -478,12 +478,12 @@ test "Rolls.damage" {
 test "Rolls.coalesce" {
     var summaries =
         calc.Summaries{ .p1 = .{ .damage = .{ .base = 74, .final = 69, .capped = true } } };
-    try expectEqual(@as(u8, 0), try Rolls.coalesce(.P2, 0, &summaries, false));
-    try expectEqual(@as(u8, 241), try Rolls.coalesce(.P2, 238, &summaries, false));
-    try expectEqual(@as(u8, 255), try Rolls.coalesce(.P2, 238, &summaries, true));
+    try expectEqual(0, try Rolls.coalesce(.P2, 0, &summaries, false));
+    try expectEqual(241, try Rolls.coalesce(.P2, 238, &summaries, false));
+    try expectEqual(255, try Rolls.coalesce(.P2, 238, &summaries, true));
     summaries.p1.damage.final = 74;
-    try expectEqual(@as(u8, 217), try Rolls.coalesce(.P2, 217, &summaries, false));
-    try expectEqual(@as(u8, 255), try Rolls.coalesce(.P2, 217, &summaries, true));
+    try expectEqual(217, try Rolls.coalesce(.P2, 217, &summaries, false));
+    try expectEqual(255, try Rolls.coalesce(.P2, 217, &summaries, true));
 }
 
 test "Rolls.hit" {
@@ -771,9 +771,9 @@ test "Rolls.psywave" {
 
     try expectEqualSlices(u8, &.{0}, Rolls.psywave(actions.p1, &side, .None));
     var rolls = Rolls.psywave(actions.p2, &side, .None);
-    try expectEqual(@as(u8, 150), rolls[rolls.len - 1]);
+    try expectEqual(150, rolls[rolls.len - 1]);
     side.stored().level = 81;
     rolls = Rolls.psywave(actions.p2, &side, .None);
-    try expectEqual(@as(u8, 121), rolls[rolls.len - 1]);
+    try expectEqual(121, rolls[rolls.len - 1]);
     try expectEqualSlices(u8, &.{0}, Rolls.psywave(actions.p2, &side, .false));
 }

package/src/lib/gen1/mechanics.zig

@@ -71,8 +71,8 @@ pub fn update(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Result
     var p1 = battle.side(.P1);
     var p2 = battle.side(.P2);
 
-    var r1 = showdown and p1.active.volatiles.Binding and c2.type == .Switch;
-    var r2 = showdown and p2.active.volatiles.Binding and c1.type == .Switch;
+    const r1 = showdown and p1.active.volatiles.Binding and c2.type == .Switch;
+    const r2 = showdown and p2.active.volatiles.Binding and c1.type == .Switch;
 
     if (try turnOrder(battle, c1, c2, options) == .P1) {
         if (try doTurn(battle, .P1, c1, r1, s1, .P2, c2, r2, s2, options)) |r| return r;
@@ -90,11 +90,11 @@ fn start(battle: anytype, options: anytype) !Result {
     const p1 = battle.side(.P1);
     const p2 = battle.side(.P2);
 
-    var p1_slot = findFirstAlive(p1);
+    const p1_slot = findFirstAlive(p1);
     assert(!showdown or p1_slot == 1);
     if (p1_slot == 0) return if (findFirstAlive(p2) == 0) Result.Tie else Result.Lose;
 
-    var p2_slot = findFirstAlive(p2);
+    const p2_slot = findFirstAlive(p2);
     assert(!showdown or p2_slot == 1);
     if (p2_slot == 0) return Result.Win;
 
@@ -635,8 +635,6 @@ fn beforeMove(
             volatiles.state +%= battle.last_damage;
         }
 
-        assert(volatiles.attacks > 0);
-
         if (options.calc.modify(player, .attacking)) |extend| {
             if (!extend) volatiles.attacks = 0;
         } else {
@@ -676,8 +674,6 @@ fn beforeMove(
     }
 
     if (volatiles.Thrashing) {
-        assert(volatiles.attacks > 0);
-
         if (options.calc.modify(player, .attacking)) |extend| {
             if (!extend) volatiles.attacks = 0;
         } else {
@@ -701,8 +697,6 @@ fn beforeMove(
     }
 
     if (volatiles.Binding) {
-        assert(volatiles.attacks > 0);
-
         if (options.calc.modify(player, .binding)) |extend| {
             if (!extend) volatiles.attacks = 0;
         } else {
@@ -738,7 +732,6 @@ fn canMove(
     const player_ident = battle.active(player);
     const move = Move.get(side.last_selected_move);
 
-    var skip = skip_pp;
     if (side.active.volatiles.Charging) {
         side.active.volatiles.Charging = false;
         side.active.volatiles.Invulnerable = false;
@@ -750,7 +743,7 @@ fn canMove(
     }
 
     side.last_used_move = side.last_selected_move;
-    if (!skip) decrementPP(side, mslot, auto);
+    if (!skip_pp) decrementPP(side, mslot, auto);
 
     const target = if (move.target == .Self) player else player.foe();
     try options.log.move(.{ player_ident, side.last_selected_move, battle.active(target), from });
@@ -902,7 +895,7 @@ fn doMove(
         }
     }
 
-    var zero = battle.last_damage == 0;
+    const zero = battle.last_damage == 0;
     miss = if (showdown or skip)
         miss
     else
@@ -1060,7 +1053,7 @@ fn checkCriticalHit(battle: anytype, player: Player, move: Move.Data, options: a
     const side = battle.side(player);
 
     // Base speed is used for the critical hit calculation, even when Transform-ed
-    var rate = @as(u16, Species.chance(side.stored().species));
+    var rate: u16 = Species.chance(side.stored().species);
     // GLITCH: Focus Energy reduces critical hit rate instead of increasing it
     rate = if (side.active.volatiles.FocusEnergy) rate / 2 else @min(rate * 2, 255);
     rate = if (move.effect == .HighCritical) @min(rate * 4, 255) else rate / 2;
@@ -1117,9 +1110,9 @@ fn calcDamage(
         def = @max((def / 4) & 255, if (showdown) 1 else 0);
     }
 
-    const lvl = @as(u32, side.stored().level * @as(u2, if (crit) 2 else 1));
+    const lvl: u32 = side.stored().level * @as(u2, if (crit) 2 else 1);
 
-    def = @as(u32, if (move.effect == .Explode) @max(def / 2, 1) else def);
+    def = if (move.effect == .Explode) @max(def / 2, 1) else def;
 
     if (def == 0) return false;
 
@@ -1402,7 +1395,7 @@ fn moveHit(
         const overwritten = overwrite and state > 0;
         assert(!overwritten or (0 < state and state <= 255 and !side.active.volatiles.Bide));
 
-        var accuracy = if (overwritten) state else @as(u16, move.accuracy);
+        var accuracy: u16 = if (overwritten) state else move.accuracy;
         var boost = BOOSTS[@as(u4, @intCast(@as(i8, side.active.boosts.accuracy) + 6))];
         accuracy = accuracy * boost[0] / boost[1];
         boost = BOOSTS[@as(u4, @intCast(@as(i8, -foe.active.boosts.evasion) + 6))];
@@ -1679,7 +1672,6 @@ fn onBegin(
     residual: *bool,
     options: anytype,
 ) !void {
-    assert(move.effect.onBegin());
     return switch (move.effect) {
         .Confusion => Effects.confusion(battle, player, move, options),
         .Conversion => Effects.conversion(battle, player, options),
@@ -1702,7 +1694,6 @@ fn onBegin(
 }
 
 fn onEnd(battle: anytype, player: Player, move: Move.Data, options: anytype) !void {
-    assert(move.effect.onEnd());
     return switch (move.effect) {
         .Bide => Effects.bide(battle, player, options),
         // zig fmt: off
@@ -1724,7 +1715,6 @@ fn alwaysHappens(
     residual: *bool,
     options: anytype,
 ) !void {
-    assert(move.effect.alwaysHappens());
     return switch (move.effect) {
         .DrainHP, .DreamEater => Effects.drainHP(battle, player, options),
         .Explode => Effects.explode(battle, player),
@@ -1972,7 +1962,7 @@ pub const Effects = struct {
         var side = battle.side(player);
         var foe = battle.foe(player);
 
-        var side_stored = side.stored();
+        const side_stored = side.stored();
         var foe_stored = foe.stored();
 
         const player_ident = battle.active(player);
@@ -2441,7 +2431,7 @@ pub const Effects = struct {
                     }
                     return log.fail(.{ ident, .None });
                 }
-                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.atk) + 6))];
+                const mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.atk) + 6))];
                 const stat = unmodifiedStats(battle, side).atk;
                 stats.atk = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(.{ ident, reason, n });
@@ -2461,7 +2451,7 @@ pub const Effects = struct {
                     }
                     return log.fail(.{ ident, .None });
                 }
-                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.def) + 6))];
+                const mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.def) + 6))];
                 const stat = unmodifiedStats(battle, side).def;
                 stats.def = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(.{ ident, .Defense, n });
@@ -2478,7 +2468,7 @@ pub const Effects = struct {
                     }
                     return log.fail(.{ ident, .None });
                 }
-                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spe) + 6))];
+                const mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spe) + 6))];
                 const stat = unmodifiedStats(battle, side).spe;
                 stats.spe = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(.{ ident, .Speed, 2 });
@@ -2498,7 +2488,7 @@ pub const Effects = struct {
                     }
                     return log.fail(.{ ident, .None });
                 }
-                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spc) + 6))];
+                const mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spc) + 6))];
                 const stat = unmodifiedStats(battle, side).spc;
                 stats.spc = @min(MAX_STAT_VALUE, stat * mod[0] / mod[1]);
                 try log.boost(.{ ident, .SpecialAttack, n });
@@ -2551,7 +2541,7 @@ pub const Effects = struct {
                     }
                     return log.fail(.{ foe_ident, .None });
                 }
-                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.atk) + 6))];
+                const mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.atk) + 6))];
                 const stat = unmodifiedStats(battle, foe).atk;
                 stats.atk = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(.{ foe_ident, .Attack, -1 });
@@ -2569,7 +2559,7 @@ pub const Effects = struct {
                     }
                     return log.fail(.{ foe_ident, .None });
                 }
-                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.def) + 6))];
+                const mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.def) + 6))];
                 const stat = unmodifiedStats(battle, foe).def;
                 stats.def = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(.{ foe_ident, .Defense, -@as(i8, n) });
@@ -2586,7 +2576,7 @@ pub const Effects = struct {
                     }
                     return log.fail(.{ foe_ident, .None });
                 }
-                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spe) + 6))];
+                const mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spe) + 6))];
                 const stat = unmodifiedStats(battle, foe).spe;
                 stats.spe = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(.{ foe_ident, .Speed, -1 });
@@ -2606,7 +2596,7 @@ pub const Effects = struct {
                     }
                     return log.fail(.{ foe_ident, .None });
                 }
-                var mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spc) + 6))];
+                const mod = BOOSTS[@as(u4, @intCast(@as(i8, boosts.spc) + 6))];
                 const stat = unmodifiedStats(battle, foe).spc;
                 stats.spc = @max(1, stat * mod[0] / mod[1]);
                 try log.boost(.{ foe_ident, .SpecialAttack, -1 });
@@ -2699,6 +2689,8 @@ pub const Rolls = struct {
     fn speedTie(battle: anytype, options: anytype) !bool {
         const p1 = if (options.calc.overridden(.P1, .speed_tie)) |player|
             player == .P1
+        else if (@hasDecl(@TypeOf(battle.rng), "speedTie"))
+            battle.rng.speedTie()
         else if (showdown)
             battle.rng.range(u8, 0, 2) == 0
         else
@@ -2711,6 +2703,8 @@ pub const Rolls = struct {
     fn criticalHit(battle: anytype, player: Player, rate: u8, options: anytype) !bool {
         const crit = if (options.calc.overridden(player, .critical_hit)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "criticalHit"))
+            battle.rng.criticalHit(player, rate)
         else if (showdown)
             battle.rng.chance(u8, rate, 256)
         else
@@ -2723,6 +2717,8 @@ pub const Rolls = struct {
     fn damage(battle: anytype, player: Player, options: anytype) !u8 {
         const roll = if (options.calc.overridden(player, .damage)) |val|
             val
+        else if (@hasDecl(@TypeOf(battle.rng), "damage"))
+            battle.rng.damage(player)
         else roll: {
             if (showdown) break :roll battle.rng.range(u8, 217, 256);
             while (true) {
@@ -2739,6 +2735,8 @@ pub const Rolls = struct {
     fn hit(battle: anytype, player: Player, accuracy: u8, options: anytype) bool {
         const ok = if (options.calc.overridden(player, .hit)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "hit"))
+            battle.rng.hit(player, accuracy)
         else if (showdown)
             battle.rng.chance(u8, accuracy, 256)
         else
@@ -2751,6 +2749,8 @@ pub const Rolls = struct {
     fn confused(battle: anytype, player: Player, options: anytype) !bool {
         const cfz = if (options.calc.overridden(player, .confused)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "confused"))
+            battle.rng.confused(player)
         else if (showdown)
             !battle.rng.chance(u8, 128, 256)
         else
@@ -2763,6 +2763,8 @@ pub const Rolls = struct {
     fn paralyzed(battle: anytype, player: Player, options: anytype) !bool {
         const par = if (options.calc.overridden(player, .paralyzed)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "paralyzed"))
+            battle.rng.paralyzed(player)
         else if (showdown)
             battle.rng.chance(u8, 63, 256)
         else
@@ -2775,6 +2777,8 @@ pub const Rolls = struct {
     fn confusionChance(battle: anytype, player: Player, options: anytype) !bool {
         const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "secondaryChance"))
+            battle.rng.secondaryChance(player, 25)
         else if (showdown)
             battle.rng.chance(u8, 25, 256)
         else
@@ -2789,6 +2793,8 @@ pub const Rolls = struct {
 
         const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "secondaryChance"))
+            battle.rng.secondaryChance(player, rate)
         else if (showdown)
             battle.rng.chance(u8, rate, 256)
         else
@@ -2803,6 +2809,8 @@ pub const Rolls = struct {
 
         const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "secondaryChance"))
+            battle.rng.secondaryChance(player, rate)
         else if (showdown)
             battle.rng.chance(u8, rate, 256)
         else
@@ -2815,6 +2823,8 @@ pub const Rolls = struct {
     fn unboost(battle: anytype, player: Player, options: anytype) !bool {
         const proc = if (options.calc.overridden(player, .secondary_chance)) |val|
             val == .true
+        else if (@hasDecl(@TypeOf(battle.rng), "secondaryChance"))
+            battle.rng.secondaryChance(player, 85)
         else if (showdown)
             battle.rng.chance(u8, 85, 256)
         else
@@ -2827,6 +2837,8 @@ pub const Rolls = struct {
     fn metronome(battle: anytype, player: Player, options: anytype) !Move {
         const move: Move = if (options.calc.overridden(player, .metronome)) |val|
             val
+        else if (@hasDecl(@TypeOf(battle.rng), "metronome"))
+            battle.rng.metronome(player)
         else if (showdown)
             Move.METRONOME[battle.rng.range(u8, 0, Move.METRONOME.len)]
         else move: {
@@ -2845,6 +2857,8 @@ pub const Rolls = struct {
     fn psywave(battle: anytype, player: Player, max: u8, options: anytype) !u8 {
         const power = if (options.calc.overridden(player, .psywave)) |val|
             val - 1
+        else if (@hasDecl(@TypeOf(battle.rng), "psywave"))
+            battle.rng.psywave(player)
         else if (showdown)
             battle.rng.range(u8, 0, max)
         else power: {
@@ -2862,6 +2876,8 @@ pub const Rolls = struct {
     fn sleepDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
+        else if (@hasDecl(@TypeOf(battle.rng), "sleepDuration"))
+            battle.rng.sleepDuration(player)
         else if (showdown)
             battle.rng.range(u3, 1, 8)
         else duration: {
@@ -2879,6 +2895,8 @@ pub const Rolls = struct {
     fn disableDuration(battle: anytype, player: Player, options: anytype) u4 {
         const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
             val
+        else if (@hasDecl(@TypeOf(battle.rng), "disableDuration"))
+            battle.rng.disableDuration(player)
         else if (showdown)
             battle.rng.range(u4, 1, 9)
         else
@@ -2892,6 +2910,8 @@ pub const Rolls = struct {
     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 (@hasDecl(@TypeOf(battle.rng), "confusionDuration"))
+            battle.rng.confusionDuration(player, self)
         else if (showdown)
             battle.rng.range(u3, 2, 6)
         else
@@ -2905,6 +2925,8 @@ pub const Rolls = struct {
     fn attackingDuration(battle: anytype, player: Player, options: anytype) u3 {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
+        else if (@hasDecl(@TypeOf(battle.rng), "attackingDuration"))
+            battle.rng.attackingDuration(player)
         else if (showdown)
             battle.rng.range(u3, 2, 4)
         else
@@ -2926,6 +2948,8 @@ pub const Rolls = struct {
         const roll = if (effect == .Binding) .duration else .multi_hit;
         const n: u3 = if (options.calc.overridden(player, roll)) |val|
             @intCast(val)
+        else if (@hasDecl(@TypeOf(battle.rng), "distribution"))
+            battle.rng.distribution(player)
         else if (showdown)
             DISTRIBUTION[battle.rng.range(u3, 0, DISTRIBUTION.len)]
         else n: {
@@ -2958,7 +2982,9 @@ pub const Rolls = struct {
         else
             null;
 
-        const slot: u4 = overridden orelse slot: {
+        const slot: u4 = overridden orelse if (@hasDecl(@TypeOf(battle.rng), "moveSlot"))
+            battle.rng.moveSlot(player, moves, check_pp)
+        else slot: {
             if (showdown) {
                 if (check_pp == 0) {
                     var i: usize = moves.len;
@@ -3038,7 +3064,7 @@ pub fn choices(battle: anytype, player: Player, request: Choice.Type, out: []Cho
             const side = battle.side(player);
             const foe = battle.foe(player);
 
-            var active = &side.active;
+            const active = &side.active;
             const stored = side.stored();
 
             // While players are not given any input options on the cartridge in these cases,