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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pkmn/engine",
-  "version": "0.1.0-dev.bcb16a6c",
+  "version": "0.1.0-dev.c42deb42",
   "description": "A minimal, complete, Pokémon battle simulation engine optimized for performance",
   "repository": "github:pkmn/engine",
   "license": "MIT",

package/src/lib/common/optional.zig

@@ -15,19 +15,17 @@ pub fn Optional(comptime T: type) type {
 
     enumFields[0] = .{ .name = "None", .value = 0 };
 
-    var i: usize = 0;
-    inline for (fields) |field| {
+    inline for (fields, 1..) |field, i| {
         assert(!std.mem.eql(u8, field.name, "None"));
-        enumFields[i + 1] = .{
+        enumFields[i] = .{
             .name = field.name,
-            .value = i + 1,
+            .value = i,
         };
-        i += 1;
     }
 
     return @Type(.{
         .Enum = .{
-            .tag_type = std.math.IntFittingRange(0, i),
+            .tag_type = std.math.IntFittingRange(0, fields.len),
             .fields = &enumFields,
             .decls = &decls,
             .is_exhaustive = true,

package/src/lib/common/protocol.zig

@@ -222,6 +222,7 @@ pub const Start = enum(u8) {
     Disable,
     Mimic,
 
+    Attract,
     Nightmare,
     Curse,
     Foresight,
@@ -305,7 +306,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub const Error = Writer.Error;
 
-        pub fn move(self: Self, source: ID, m: anytype, target: ID, from: anytype) Error!void {
+        pub fn move(self: Self, source: ID, m: anytype, target: ID) Error!void {
             if (!enabled) return;
 
             assert(m != .None);
@@ -314,19 +315,24 @@ pub fn Log(comptime Writer: type) type {
                 @as(u8, @bitCast(source)),
                 @intFromEnum(m),
                 @as(u8, @bitCast(target)),
+                @intFromEnum(Move.None),
             });
-            const none = &[_]u8{@intFromEnum(Move.None)};
-            try self.writer.writeAll(switch (@typeInfo(@TypeOf(from))) {
-                .Null => none,
-                .Optional => if (from) |f| blk: {
-                    assert(@intFromEnum(f) != 0);
-                    break :blk &[_]u8{ @intFromEnum(Move.From), @intFromEnum(f) };
-                } else none,
-                else => blk: {
-                    assert(@intFromEnum(from) != 0);
-                    break :blk &[_]u8{ @intFromEnum(Move.From), @intFromEnum(from) };
-                },
+        }
+
+        pub fn moveFrom(self: Self, source: ID, m: anytype, target: ID, from: anytype) Error!void {
+            if (!enabled) return;
+
+            assert(m != .None);
+            try self.writer.writeAll(&.{
+                @intFromEnum(ArgType.Move),
+                @as(u8, @bitCast(source)),
+                @intFromEnum(m),
+                @as(u8, @bitCast(target)),
             });
+            try self.writer.writeAll(if (@intFromEnum(from) == 0)
+                &.{@intFromEnum(Move.None)}
+            else
+                &.{ @intFromEnum(Move.From), @intFromEnum(from) });
         }
 
         pub fn switched(self: Self, ident: ID, pokemon: anytype) Error!void {
@@ -1288,22 +1294,21 @@ fn formatter(comptime gen: anytype, kind: Kind, byte: u8) []const u8 {
 }
 
 test "|move|" {
-    try log.move(p2.ident(4), M1.Thunderbolt, p1.ident(5), null);
+    try log.move(p2.ident(4), M1.Thunderbolt, p1.ident(5));
     try expectLog1(
         &.{ N(ArgType.Move), 0b1100, N(M1.Thunderbolt), 0b0101, N(Move.None) },
         buf[0..5],
     );
     stream.reset();
 
-    try log.move(p2.ident(4), M1.Wrap, p1.ident(5), M1.Wrap);
-    const wrap = N(M1.Wrap);
+    try log.moveFrom(p2.ident(4), M1.Pound, p1.ident(5), M1.Metronome);
     try expectLog1(
-        &.{ N(ArgType.Move), 0b1100, wrap, 0b0101, N(Move.From), wrap },
+        &.{ N(ArgType.Move), 0b1100, N(M1.Pound), 0b0101, N(Move.From), N(M1.Metronome) },
         buf[0..6],
     );
     stream.reset();
 
-    try log.move(p2.ident(4), M1.SkullBash, .{}, null);
+    try log.move(p2.ident(4), M1.SkullBash, .{});
     try log.laststill();
     try expectLog1(
         &.{
@@ -1318,7 +1323,7 @@ test "|move|" {
     );
     stream.reset();
 
-    try log.move(p2.ident(4), M1.Tackle, p1.ident(5), null);
+    try log.move(p2.ident(4), M1.Tackle, p1.ident(5));
     try log.lastmiss();
     try expectLog1(
         &.{

package/src/lib/gen1/chance.zig

@@ -14,12 +14,14 @@ const util = @import("../common/util.zig");
 const Player = @import("../common/data.zig").Player;
 const Optional = @import("../common/optional.zig").Optional;
 
-const Move = @import("data.zig").Move;
-const MoveSlot = @import("data.zig").MoveSlot;
+const data = @import("./data.zig");
 
 const enabled = options.chance;
 const showdown = options.showdown;
 
+const Move = data.Move;
+const MoveSlot = data.MoveSlot;
+
 /// Actions taken by a hypothetical "chance player" that convey information about which RNG events
 /// were observed during a Generation I battle `update`. This can additionally be provided as input
 /// to the `update` call to override the normal behavior of the RNG in order to force specific
@@ -514,22 +516,6 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
-        pub fn disable(self: *Self, player: Player, turns: u4) Error!void {
-            if (!enabled) return;
-
-            var durations = &self.actions.get(player).durations;
-            const n = durations.disable;
-            if (turns == 0) {
-                assert(n >= 1 and n <= 8);
-                if (n != 8) try self.probability.update(1, 9 - @as(u4, n));
-                durations.disable = 0;
-            } else {
-                assert(n >= 1 and n < 8);
-                try self.probability.update(9 - @as(u4, n) - 1, 9 - @as(u4, n));
-                durations.disable += 1;
-            }
-        }
-
         pub fn confusion(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
@@ -546,6 +532,22 @@ pub fn Chance(comptime Rational: type) type {
             }
         }
 
+        pub fn disable(self: *Self, player: Player, turns: u4) Error!void {
+            if (!enabled) return;
+
+            var durations = &self.actions.get(player).durations;
+            const n = durations.disable;
+            if (turns == 0) {
+                assert(n >= 1 and n <= 8);
+                if (n != 8) try self.probability.update(1, 9 - @as(u4, n));
+                durations.disable = 0;
+            } else {
+                assert(n >= 1 and n < 8);
+                try self.probability.update(9 - @as(u4, n) - 1, 9 - @as(u4, n));
+                durations.disable += 1;
+            }
+        }
+
         pub fn attacking(self: *Self, player: Player, turns: u4) Error!void {
             if (!enabled) return;
 
@@ -593,7 +595,7 @@ pub fn Chance(comptime Rational: type) type {
         pub fn metronome(self: *Self, player: Player, move: Move) Error!void {
             if (!enabled) return;
 
-            try self.probability.update(1, Move.size - 2);
+            try self.probability.update(1, Move.METRONOME.len);
             self.actions.get(player).metronome = move;
         }
     };
@@ -832,28 +834,6 @@ test "Chance.sleep" {
     }
 }
 
-test "Chance.disable" {
-    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
-
-    for ([_]u8{ 8, 7, 6, 5, 4, 3, 2, 1 }, 1..9) |d, i| {
-        chance.actions.p1.durations.disable = @intCast(i);
-        try chance.disable(.P1, 0);
-        try expectProbability(&chance.probability, 1, d);
-        try expectValue(@as(u4, 0), chance.actions.p1.durations.disable);
-
-        chance.reset();
-
-        if (i < 8) {
-            chance.actions.p1.durations.disable = @intCast(i);
-            try chance.disable(.P1, 1);
-            try expectProbability(&chance.probability, d - 1, d);
-            try expectValue(@as(u4, @intCast(i)) + 1, chance.actions.p1.durations.disable);
-
-            chance.reset();
-        }
-    }
-}
-
 test "Chance.confusion" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
@@ -878,6 +858,28 @@ test "Chance.confusion" {
     }
 }
 
+test "Chance.disable" {
+    var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
+
+    for ([_]u8{ 8, 7, 6, 5, 4, 3, 2, 1 }, 1..9) |d, i| {
+        chance.actions.p1.durations.disable = @intCast(i);
+        try chance.disable(.P1, 0);
+        try expectProbability(&chance.probability, 1, d);
+        try expectValue(@as(u4, 0), chance.actions.p1.durations.disable);
+
+        chance.reset();
+
+        if (i < 8) {
+            chance.actions.p1.durations.disable = @intCast(i);
+            try chance.disable(.P1, 1);
+            try expectProbability(&chance.probability, d - 1, d);
+            try expectValue(@as(u4, @intCast(i)) + 1, chance.actions.p1.durations.disable);
+
+            chance.reset();
+        }
+    }
+}
+
 test "Chance.attacking" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 

package/src/lib/gen1/data/moves.zig

@@ -1838,6 +1838,20 @@ pub const Move = enum(u8) {
     /// The number of Pokémon moves in this generation.
     pub const size = 165;
 
+    /// Pokémon moves that can be called by Metronome in this generation.
+    pub const METRONOME = init: {
+        var num = 0;
+        var moves: [163]Move = undefined;
+        for (1..Move.size) |i| {
+            if (i != @intFromEnum(Move.Metronome)) {
+                moves[num] = @enumFromInt(i);
+                num += 1;
+            }
+        }
+        assert(num == moves.len);
+        break :init moves;
+    };
+
     /// Returns the `Data` corresponding to the move.
     pub inline fn get(id: Move) Data {
         assert(id != .None and id != .SKIP_TURN);

package/src/lib/gen1/helpers.zig

@@ -455,25 +455,10 @@ pub const Rolls = struct {
     }
 
     const MOVE_NONE = [_]Move{.None};
-    const MOVES = init: {
-        var moves: [Move.size - 2]Move = undefined;
-        var i: usize = 0;
-        for (@typeInfo(Move).Enum.fields) |f| {
-            if (!(std.mem.eql(u8, f.name, "None") or
-                std.mem.eql(u8, f.name, "Metronome") or
-                std.mem.eql(u8, f.name, "Struggle") or
-                std.mem.eql(u8, f.name, "SKIP_TURN")))
-            {
-                moves[i] = @field(Move, f.name);
-                i += 1;
-            }
-        }
-        break :init moves;
-    };
 
     /// Returns a slice with the correct range of values for metronome given the `action` state.
     pub inline fn metronome(action: Action) []const Move {
-        return if (@field(action, "metronome") == .None) &MOVE_NONE else &MOVES;
+        return if (@field(action, "metronome") == .None) &MOVE_NONE else &Move.METRONOME;
     }
 };
 

package/src/lib/gen1/mechanics.zig

@@ -7,8 +7,6 @@ const DEBUG = @import("../common/debug.zig").print;
 const protocol = @import("../common/protocol.zig");
 const rng = @import("../common/rng.zig");
 
-const Action = @import("chance.zig").Action;
-
 const data = @import("data.zig");
 
 const assert = std.debug.assert;
@@ -59,19 +57,15 @@ const BOOSTS = &[_][2]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);
 
     var s1 = false;
     var s2 = false;
-    var f1: ?Move = null;
-    var f2: ?Move = null;
 
-    if (selectMove(battle, .P1, c1, c2, &s1, &f1)) |r| return r;
-    if (selectMove(battle, .P2, c2, c1, &s2, &f2)) |r| return r;
+    if (selectMove(battle, .P1, c1, c2, &s1)) |r| return r;
+    if (selectMove(battle, .P2, c2, c1, &s2)) |r| return r;
 
     var p1 = battle.side(.P1);
     var p2 = battle.side(.P2);
@@ -80,9 +74,9 @@ pub fn update(battle: anytype, c1: Choice, c2: Choice, options: anytype) !Result
     var 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, f1, .P2, c2, r2, s2, f2, options)) |r| return r;
+        if (try doTurn(battle, .P1, c1, r1, s1, .P2, c2, r2, s2, options)) |r| return r;
     } else {
-        if (try doTurn(battle, .P2, c2, r2, s2, f2, .P1, c1, r1, s1, f1, options)) |r| return r;
+        if (try doTurn(battle, .P2, c2, r2, s2, .P1, c1, r1, s1, options)) |r| return r;
     }
 
     if (p1.active.volatiles.attacks == 0) p1.active.volatiles.Binding = false;
@@ -120,7 +114,6 @@ fn selectMove(
     choice: Choice,
     foe_choice: Choice,
     skip_turn: *bool,
-    from: *?Move,
 ) ?Result {
     if (choice.type == .Pass) return null;
 
@@ -137,7 +130,6 @@ fn selectMove(
         return null;
     }
     if (volatiles.Rage) {
-        from.* = side.last_used_move;
         if (showdown) {
             if (battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
             saveMove(battle, player, null);
@@ -147,7 +139,6 @@ fn selectMove(
     // Pokémon Showdown removes Flinch at the end-of-turn in its residual handler
     if (!showdown) volatiles.Flinch = false;
     if (volatiles.Thrashing or volatiles.Charging) {
-        from.* = side.last_selected_move;
         if (showdown) {
             if (battle.foe(player).active.volatiles.Binding) skip_turn.* = true;
             saveMove(battle, player, null);
@@ -168,9 +159,7 @@ fn selectMove(
         return null;
     }
     if (volatiles.Binding) {
-        from.* = side.last_used_move;
         if (showdown) {
-            if (foe_choice.type == .Switch) from.* = null;
             // Pokémon Showdown overwrites Mirror Move with whatever was selected - really this
             // should set side.last_selected_move = last.id to reuse Mirror Move and fail in order
             // to satisfy the conditions of the Desync Clause Mod. However, because Binding is still
@@ -336,12 +325,10 @@ fn doTurn(
     player_choice: Choice,
     player_rewrap: bool,
     player_skip: bool,
-    player_from: ?Move,
     foe_player: Player,
     foe_choice: Choice,
     foe_rewrap: bool,
     foe_skip: bool,
-    foe_from: ?Move,
     options: anytype,
 ) !?Result {
     assert(player_choice.type != .Pass);
@@ -354,7 +341,6 @@ fn doTurn(
         player_choice,
         player_rewrap,
         player_skip,
-        player_from,
         &residual,
         options,
     )) |r| return r;
@@ -377,7 +363,6 @@ fn doTurn(
         foe_choice,
         foe_rewrap,
         foe_skip,
-        foe_from,
         &residual,
         options,
     )) |r| return r;
@@ -405,7 +390,6 @@ fn executeMove(
     choice: Choice,
     rewrap: bool,
     skip: bool,
-    from: ?Move,
     residual: *bool,
     options: anytype,
 ) !?Result {
@@ -440,8 +424,10 @@ fn executeMove(
         mslot = @intCast(battle.lastMove(player).index);
         const stored = side.stored();
         // GLITCH: Struggle bypass PP underflow via Hyper Beam / Trapping-switch auto selection
-        auto = side.last_selected_move == .HyperBeam or side.active.volatiles.Bide or
-            from != null or Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP);
+        auto = isForced(&side.active) or
+            side.active.volatiles.Binding or side.active.volatiles.Bide or
+            side.last_selected_move == .HyperBeam or
+            Status.is(stored.status, .FRZ) or Status.is(stored.status, .SLP);
         // If it wasn't Hyper Beam or the continuation of a move effect then we must have just
         // thawed, in which case we will desync unless the last_selected_move happened to be at
         // index 1 and the current Pokémon has the same move in its first slot.
@@ -463,7 +449,7 @@ fn executeMove(
 
     var skip_can = false;
     var skip_pp = false;
-    switch (try beforeMove(battle, player, skip, from, residual, options)) {
+    switch (try beforeMove(battle, player, skip, residual, options)) {
         .done => return null,
         .skip_can => skip_can = true,
         .skip_pp => skip_pp = true,
@@ -471,9 +457,9 @@ fn executeMove(
         .err => return @as(?Result, Result.Error),
     }
 
-    if (!skip_can and !try canMove(battle, player, mslot, auto, skip_pp, from, residual, options)) {
-        return null;
-    }
+    const can = skip_can or
+        try canMove(battle, player, mslot, auto, skip_pp, .None, residual, options);
+    if (!can) return null;
 
     return doMove(battle, player, mslot, rewrap, auto, residual, options);
 }
@@ -484,7 +470,6 @@ fn beforeMove(
     battle: anytype,
     player: Player,
     skip: bool,
-    from: ?Move,
     residual: *bool,
     options: anytype,
 ) !BeforeMove {
@@ -691,7 +676,6 @@ fn beforeMove(
 
     if (volatiles.Thrashing) {
         assert(volatiles.attacks > 0);
-        assert(from != null);
 
         if (options.calc.modify(player, .attacking)) |extend| {
             if (!extend) volatiles.attacks = 0;
@@ -703,7 +687,7 @@ fn beforeMove(
         if (!showdown and handleThrashing(battle, active, player, options)) {
             try log.start(battle.active(player), .ConfusionSilent);
         }
-        try log.move(ident, side.last_selected_move, battle.active(player.foe()), from);
+        try log.move(ident, side.last_selected_move, battle.active(player.foe()));
         if (showdown) {
             // This shouldn't actually set last_used_move, but Pokémon Showdown sets last
             // used in useMove and doesn't have the notion of skipping canMove semantics
@@ -725,12 +709,7 @@ fn beforeMove(
         }
         try options.chance.binding(player, volatiles.attacks);
 
-        try log.move(
-            battle.active(player),
-            side.last_selected_move,
-            battle.active(player.foe()),
-            side.last_selected_move,
-        );
+        try log.move(battle.active(player), side.last_selected_move, battle.active(player.foe()));
         if (showdown or battle.last_damage != 0) {
             const sub = showdown and foe.active.volatiles.Substitute;
             _ = try applyDamage(battle, player.foe(), player.foe(), .None, options);
@@ -750,7 +729,7 @@ fn canMove(
     mslot: u4,
     auto: bool,
     skip_pp: bool,
-    from: ?Move,
+    from: Move,
     residual: *bool,
     options: anytype,
 ) !bool {
@@ -758,33 +737,22 @@ fn canMove(
     const player_ident = battle.active(player);
     const move = Move.get(side.last_selected_move);
 
-    const foe_last = battle.foe(player).last_used_move;
-    const special = from != null and (from.? == .Metronome and
-        (from.? == .MirrorMove and !(foe_last == .None or foe_last == .MirrorMove)));
-
     var skip = skip_pp;
     if (side.active.volatiles.Charging) {
         side.active.volatiles.Charging = false;
         side.active.volatiles.Invulnerable = false;
     } else if (move.effect == .Charge) {
-        try options.log.move(player_ident, side.last_selected_move, .{}, from);
+        try options.log.moveFrom(player_ident, side.last_selected_move, .{}, from);
         setCounterable(battle, player, side, move);
         try Effects.charge(battle, player, options);
         return false;
     }
 
-    if (!showdown or !special) side.last_used_move = side.last_selected_move;
+    side.last_used_move = side.last_selected_move;
     if (!skip) decrementPP(side, mslot, auto);
 
     const target = if (move.target == .Self) player else player.foe();
-    // Pokémon Showdown's protocol for Rage and Binding moves should come with a [from], though we
-    // don't have space to be able to track it in all circumstances and thus usually try to infer it
-    // from side.last_used_move. However, this gets reset by the opponent switching or fainting,
-    // meaning sometimes we lose this information. from is still set because it not being null is
-    // relevant for control flow, but we don't have anything useful to put in the log. This is
-    // regrettable, but this information is more "nice to have" than required
-    const f = if (from != null and from.? == .None) null else from;
-    try options.log.move(player_ident, side.last_selected_move, battle.active(target), f);
+    try options.log.moveFrom(player_ident, side.last_selected_move, battle.active(target), from);
     setCounterable(battle, player, side, move);
 
     if (move.effect.onBegin()) {
@@ -2863,11 +2831,9 @@ pub const Rolls = struct {
     inline fn metronome(battle: anytype, player: Player, options: anytype) !Move {
         const move: Move = if (options.calc.overridden(player, .metronome)) |val|
             val
-        else if (showdown) move: {
-            const r = battle.rng.range(u8, 0, @intFromEnum(Move.Struggle) - 2);
-            const mod = @as(u2, (if (r < @intFromEnum(Move.Metronome) - 1) 1 else 2));
-            break :move @enumFromInt(r + mod);
-        } else move: {
+        else if (showdown)
+            Move.METRONOME[battle.rng.range(u8, 0, Move.METRONOME.len)]
+        else move: {
             while (true) {
                 const r = battle.rng.next();
                 if (r == 0 or r == @intFromEnum(Move.Metronome)) continue;
@@ -2901,7 +2867,7 @@ pub const Rolls = struct {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
         else if (showdown)
-            @intCast(battle.rng.range(u8, 1, 8))
+            battle.rng.range(u3, 1, 8)
         else duration: {
             while (true) {
                 const r = battle.rng.next() & 7;
@@ -2918,7 +2884,7 @@ pub const Rolls = struct {
         const duration: u4 = if (options.calc.overridden(player, .duration)) |val|
             val
         else if (showdown)
-            @intCast(battle.rng.range(u8, 1, 9))
+            battle.rng.range(u4, 1, 9)
         else
             @intCast((battle.rng.next() & 7) + 1);
 
@@ -2931,7 +2897,7 @@ pub const Rolls = struct {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
         else if (showdown)
-            @intCast(battle.rng.range(u8, 2, 6))
+            battle.rng.range(u3, 2, 6)
         else
             @intCast((battle.rng.next() & 3) + 2);
 
@@ -2944,7 +2910,7 @@ pub const Rolls = struct {
         const duration: u3 = if (options.calc.overridden(player, .duration)) |val|
             @intCast(val)
         else if (showdown)
-            @intCast(battle.rng.range(u4, 2, 4))
+            battle.rng.range(u3, 2, 4)
         else
             @intCast((battle.rng.next() & 1) + 2);
 
@@ -2953,6 +2919,8 @@ pub const Rolls = struct {
         return duration;
     }
 
+    const DISTRIBUTION = [_]u3{ 2, 2, 2, 3, 3, 3, 4, 5 };
+
     inline fn distribution(
         battle: anytype,
         comptime effect: Move.Effect,
@@ -2963,7 +2931,7 @@ pub const Rolls = struct {
         const n: u3 = if (options.calc.overridden(player, roll)) |val|
             @intCast(val)
         else if (showdown)
-            DISTRIBUTION[battle.rng.range(u8, 0, DISTRIBUTION.len)]
+            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);
@@ -3010,10 +2978,9 @@ pub const Rolls = struct {
                     while (i < moves.len and r > 0) : (i += 1) {
                         if (moves[i].pp > 0) {
                             r -= 1;
-                            if (r == 0) break;
+                            if (r == 0) break :slot @intCast(i + 1);
                         }
                     }
-                    break :slot @intCast(i + 1);
                 }
             }