@pkmn/engine 0.1.0-dev.6ebbd3bc → 0.1.0-dev.724afcb1

package/src/lib/common/util.zig

@@ -3,10 +3,8 @@ const std = @import("std");
 const expect = std.testing.expect;
 const expectEqual = std.testing.expectEqual;
 
-const Pointer = if (@hasField(std.builtin.Type, "pointer")) .pointer else .Pointer;
-
 pub fn PointerType(comptime P: type, comptime C: type) type {
-    return if (@field(@typeInfo(P), @tagName(Pointer)).is_const) *const C else *C;
+    return if (@typeInfo(P).pointer.is_const) *const C else *C;
 }
 
 test PointerType {
@@ -17,7 +15,7 @@ test PointerType {
 pub fn isPointerTo(p: anytype, comptime P: type) bool {
     const info = @typeInfo(@TypeOf(p));
     return switch (info) {
-        Pointer => @field(info, @tagName(Pointer)).child == P,
+        .pointer => info.pointer.child == P,
         else => false,
     };
 }
@@ -29,33 +27,18 @@ test isPointerTo {
     try expect(isPointerTo(&s, S));
 }
 
-// NOTE: std.mem.bytesAsValue backported from ziglang/zig#18061
-pub fn bytesAsValue(comptime T: type, bytes: anytype) BytesAsValueReturnType(T, @TypeOf(bytes)) {
-    return @as(BytesAsValueReturnType(T, @TypeOf(bytes)), @ptrCast(bytes));
-}
+pub fn repeat(comptime xs: anytype, comptime n: usize) [xs.len * n]@TypeOf(xs[0]) {
+    comptime {
+        const T = @TypeOf(xs[0]);
+        var ts: [xs.len * n]T = undefined;
 
-fn BytesAsValueReturnType(comptime T: type, comptime B: type) type {
-    return CopyPtrAttrs(B, .One, T);
-}
+        var i: usize = 0;
+        while (i < n) : (i += 1) {
+            for (xs, 0..) |v, j| {
+                ts[i * xs.len + j] = v;
+            }
+        }
 
-fn CopyPtrAttrs(
-    comptime source: type,
-    comptime size: std.builtin.Type.Pointer.Size,
-    comptime child: type,
-) type {
-    const info = @field(@typeInfo(source), @tagName(Pointer));
-    const args: std.builtin.Type.Pointer = .{
-        .size = size,
-        .is_const = info.is_const,
-        .is_volatile = info.is_volatile,
-        .is_allowzero = info.is_allowzero,
-        .alignment = info.alignment,
-        .address_space = info.address_space,
-        .child = child,
-        .sentinel = null,
-    };
-    return @Type(if (@hasField(std.builtin.Type, "pointer"))
-        .{ .pointer = args }
-    else
-        .{ .Pointer = args });
+        return ts;
+    }
 }

package/src/lib/gen1/calc.zig

@@ -16,7 +16,6 @@ const Actions = chance.Actions;
 const assert = std.debug.assert;
 const Chance = chance.Chance;
 const Choice = common.Choice;
-const Confusion = chance.Confusion;
 const Duration = chance.Duration;
 const Durations = chance.Durations;
 const enabled = pkmn.options.calc;
@@ -35,9 +34,6 @@ const Sleeps = chance.Sleeps;
 const tty = true; // DEBUG
 const summary = false; // DEBUG
 
-const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
-const Enum = if (@hasField(std.builtin.Type, "enum")) .@"enum" else .Enum;
-
 /// Information relevant to damage calculation that occured during a Generation I battle `update`.
 pub const Summaries = extern struct {
     /// Relevant information for Player 1.
@@ -99,13 +95,13 @@ pub const Calc = struct {
         self: Calc,
         player: Player,
         comptime field: Action.Field,
-    ) ?std.meta.FieldType(Action, field) {
+    ) ?@FieldType(Action, @tagName(field)) {
         if (!enabled) return null;
 
         const val = @field(self.overrides.get(player), @tagName(field));
         return if (switch (@typeInfo(@TypeOf(val))) {
-            Enum => val != .None,
-            Int => val != 0,
+            .@"enum" => val != .None,
+            .int => val != 0,
             else => unreachable,
         }) val else null;
     }
@@ -146,7 +142,7 @@ const Null = struct {
         self: Null,
         player: Player,
         comptime field: Action.Field,
-    ) ?std.meta.FieldType(Action, field) {
+    ) ?@FieldType(Action, @tagName(field)) {
         _ = .{ self, player };
         return null;
     }
@@ -182,24 +178,25 @@ pub const Options = struct {
     metronome: bool = false,
 };
 
-pub const MAX_FRONTIER = 81;
+pub const MAX_FRONTIER = 86;
 
 pub fn transitions(
     battle: anytype,
     c1: Choice,
     c2: Choice,
     allocator: std.mem.Allocator,
-    writer: anytype,
+    out: *std.Io.Writer,
+    err: *std.Io.Writer,
     options: Options,
 ) !?Stats {
     var stats: Stats = .{};
 
     const cap = options.cap;
 
-    var seen = std.AutoHashMap(Actions, void).init(allocator);
+    var seen: std.AutoHashMap(Actions, void) = .init(allocator);
     defer seen.deinit();
-    var frontier = std.ArrayList(Actions).init(allocator);
-    defer frontier.deinit();
+    var frontier: std.array_list.Aligned(Actions, null) = .empty;
+    defer frontier.deinit(allocator);
 
     const d = options.durations;
 
@@ -216,8 +213,8 @@ pub fn transitions(
     const p1 = b.side(.P1);
     const p2 = b.side(.P2);
 
-    var p: Rational(u128) = .{ .p = 0, .q = 1 };
-    try frontier.append(opts.chance.actions);
+    var p: Rational(u256) = .{ .p = 0, .q = 1 };
+    try frontier.append(allocator, opts.chance.actions);
 
     // zig fmt: off
     for (Rolls.metronome(frontier.items[0].p1)) |p1_move| {
@@ -231,7 +228,9 @@ pub fn transitions(
         const f = frontier.items[i];
         const saved = stats.saved;
 
-        try debug(writer, f, .{
+        var r: Rational(u256) = .{ .p = 0, .q = 1 };
+
+        try debug(out, f, .{
             .shape = true,
             .color = i,
             .bold = true,
@@ -251,8 +250,8 @@ pub fn transitions(
         for (Rolls.disable(f.p2, d.p2, p2_slp)) |p2_dis| { a.p2.disable = p2_dis;
         for (Rolls.attacking(f.p1, d.p1, p1_slp)) |p1_atk| { a.p1.attacking = p1_atk;
         for (Rolls.attacking(f.p2, d.p2, p2_slp)) |p2_atk| { a.p2.attacking = p2_atk;
-        for (Rolls.confusion(f.p1, d.p1, p1_atk, p1_slp)) |p1_cfz| { a.p1.confusion = p1_cfz;
-        for (Rolls.confusion(f.p2, d.p2, p2_atk, p2_slp)) |p2_cfz| { a.p2.confusion = p2_cfz;
+        for (Rolls.confusion(f.p1, d.p1, tie, p1_atk, p1_slp)) |p1_cfz| { a.p1.confusion = p1_cfz;
+        for (Rolls.confusion(f.p2, d.p2, tie, p2_atk, p2_slp)) |p2_cfz| { a.p2.confusion = p2_cfz;
         for (Rolls.confused(f.p1, p1_cfz)) |p1_cfzd| { a.p1.confused = p1_cfzd;
         for (Rolls.confused(f.p2, p2_cfz)) |p2_cfzd| { a.p2.confused = p2_cfzd;
         for (Rolls.paralyzed(f.p1, p1_cfzd)) |p1_par| { a.p1.paralyzed = p1_par;
@@ -278,8 +277,8 @@ pub fn transitions(
 
             var p2_dmg = Rolls.damage(f.p2, p2_hit);
 
-            const p1_min: u9 = p1_dmg.min;
-            const p2_min: u9 = p2_dmg.min;
+            const p1_min: u9 = @intCast(p1_dmg.min);
+            const p2_min: u9 = @intCast(p2_dmg.min);
 
             while (p2_dmg.min < p2_dmg.max) : (p2_dmg.min += 1) {
                 a.p2.damage = @intCast(p2_dmg.min);
@@ -296,16 +295,16 @@ pub fn transitions(
 
                 const summaries = &opts.calc.summaries;
                 const p1_max: u9 = if (p2_dmg.min != p2_min)
-                    p1_dmg.min
+                    @intCast(p1_dmg.min)
                 else
-                    try Rolls.coalesce(.P1, @as(u8, @intCast(p1_dmg.min)), summaries, cap);
+                    Rolls.coalesce(.P1, @as(u8, @intCast(p1_dmg.min)), summaries, cap);
                 const p2_max: u9 =
-                    try Rolls.coalesce(.P2, @as(u8, @intCast(p2_dmg.min)), summaries, cap);
+                    Rolls.coalesce(.P2, @as(u8, @intCast(p2_dmg.min)), summaries, cap);
 
                 if (opts.chance.actions.matches(f)) {
                     if (!opts.chance.actions.relax().eql(a)) {
                         if (!summary) {
-                            try debug(writer, opts.chance.actions, .{
+                            try debug(out, opts.chance.actions, .{
                                 .p1_max = p1_max,
                                 .p2_max = p2_max,
                                 .color = i,
@@ -319,7 +318,7 @@ pub fn transitions(
                     }
 
                     if (!summary) {
-                        try debug(writer, opts.chance.actions, .{
+                        try debug(out, opts.chance.actions, .{
                             .p1_max = p1_max,
                             .p2_max = p2_max,
                             .color = i,
@@ -332,7 +331,7 @@ pub fn transitions(
                             acts.p1.damage = @intCast(p1d);
                             acts.p2.damage = @intCast(p2d);
                             if ((try seen.getOrPut(acts)).found_existing) {
-                                err("already seen {}", .{acts}, options.seed);
+                                die(err, "already seen {f}", .{acts}, options.seed);
                                 return error.TestUnexpectedResult;
                             }
                         }
@@ -343,25 +342,27 @@ pub fn transitions(
                     q.reduce();
                     try p.add(q);
                     p.reduce();
+                    try r.add(q);
+                    r.reduce();
 
                     stats.saved += 1;
 
                     if (p.q < p.p) {
-                        err("improper fraction {}", .{p}, options.seed);
+                        die(err, "improper fraction {f}", .{p}, options.seed);
                         return error.TestUnexpectedResult;
                     }
                 } else {
                     if (!opts.chance.actions.matchesAny(frontier.items, i)) {
-                        try frontier.append(opts.chance.actions);
+                        try frontier.append(allocator, opts.chance.actions);
 
-                        try debug(writer, opts.chance.actions, .{
+                        try debug(out, opts.chance.actions, .{
                             .p1_max = p1_max,
                             .p2_max = p2_max,
                             .dim = true,
                             .newline = false,
                         });
-                        try writer.writeAll(" → ");
-                        try debug(writer, opts.chance.actions, .{
+                        try out.writeAll(" → ");
+                        try debug(out, opts.chance.actions, .{
                             .shape = true,
                             .color = frontier.items.len - 1,
                             .dim = true,
@@ -369,7 +370,7 @@ pub fn transitions(
                             .indent = false,
                         });
                     } else if (!summary) {
-                        try debug(writer, opts.chance.actions, .{
+                        try debug(out, opts.chance.actions, .{
                             .p1_max = p1_max,
                             .p2_max = p2_max,
                             .dim = true,
@@ -384,14 +385,12 @@ pub fn transitions(
         }}}}}}}}}}}}}}}}}}}}}}}}}}}}
 
         assert(stats.saved > saved);
-        const old = @hasDecl(std.fmt, "formatFloatDecimal");
-        if (!old and @TypeOf(writer) != @TypeOf(std.io.null_writer)) {
-            p.reduce();
-            try writer.print(
-                "  = {s} ({d:.2}%)\n\n",
-                .{p, 100 * @as(f128, @floatFromInt(p.p)) / @as(f128, @floatFromInt(p.q))},
-            );
-        }
+        // TODO: LLVM - float_from_int from 'u256' without intrinsics
+        // try out.print(
+        //     "    {f} ({d:.2}%)\n  = ──────────\n    {f} ({d:.2}%)\n\n",
+        //     .{r, 100 * @as(f128, @floatFromInt(r.p)) / @as(f128, @floatFromInt(r.q)),
+        //         p, 100 * @as(f128, @floatFromInt(p.p)) / @as(f128, @floatFromInt(p.q))},
+        // );
 
     }
 
@@ -406,7 +405,7 @@ pub fn transitions(
 
     p.reduce();
     if (p.p != 1 or p.q != 1) {
-        err("expected 1, found {}", .{p}, options.seed);
+        die(err, "expected 1, found {f}", .{p}, options.seed);
         return error.TestExpectedEqual;
     }
 
@@ -419,7 +418,8 @@ pub fn update(
     c2: Choice,
     options: anytype,
     allocator: std.mem.Allocator,
-    writer: anytype,
+    out: *std.Io.Writer,
+    err: *std.Io.Writer,
     transition: bool,
 ) !Result {
     const durations = options.chance.durations;
@@ -437,8 +437,8 @@ pub fn update(
     if (@TypeOf(battle.rng) == data.PRNG) {
         // Ensure we can encode the diffs in less than MAX_DIFFS bytes.
         var buf: [helpers.MAX_DIFFS]u8 = undefined;
-        var stream: protocol.ByteStream = .{ .buffer = &buf };
-        const n = try helpers.diff(&original, battle, stream.writer());
+        var pw: protocol.Writer = .{ .buffer = &buf };
+        const n = try helpers.diff(&original, battle, &pw);
 
         // Applying the diff to the battle should take us back to the original copy
         // of the battle (ignoring the RNG).
@@ -452,7 +452,7 @@ pub fn update(
         // Ensure we can generate all transitions from the same original state
         // (we must change the battle's RNG from a FixedRNG to a PRNG because
         // the transitions function relies on RNG for discovery of states)
-        if (try transitions(unfix(original), c1, c2, allocator, writer, .{
+        if (try transitions(unfix(original), c1, c2, allocator, out, err, .{
             .durations = durations,
             .cap = true,
         })) |stats| try expect(stats.frontier <= MAX_FRONTIER);
@@ -499,10 +499,9 @@ pub fn update(
 fn expectEqualActions(expected: Actions, actual: Actions) !void {
     return expectEqual(expected, actual) catch |e| switch (e) {
         error.TestExpectedEqual => {
-            std.debug.print("expected {}, found {}\n", .{ expected, actual });
+            std.debug.print("expected {f}, found {f}\n", .{ expected, actual });
             return e;
         },
-        else => return e,
     };
 }
 
@@ -521,10 +520,9 @@ fn unfix(actual: anytype) data.Battle(data.PRNG) {
     };
 }
 
-fn err(comptime fmt: []const u8, v: anytype, seed: ?u64) void {
-    const w = std.io.getStdErr().writer();
+fn die(w: *std.Io.Writer, comptime fmt: []const u8, v: anytype, seed: ?u64) void {
     w.print(fmt, v) catch return;
-    if (seed) |s| return w.print("{}\n", .{s}) catch return;
+    if (seed) |s| return w.print("{d}\n", .{s}) catch return;
     return w.writeByte('\n') catch return;
 }
 
@@ -540,7 +538,7 @@ const Style = struct {
     indent: bool = true,
 };
 
-fn debug(writer: anytype, actions: Actions, style: Style) !void {
+fn debug(writer: *std.Io.Writer, actions: Actions, style: Style) !void {
     if (style.indent) try writer.writeAll("  ");
     if (tty) {
         const mod: usize = if (style.dim) 2 else 1;
@@ -565,13 +563,13 @@ fn debug(writer: anytype, actions: Actions, style: Style) !void {
     if (style.newline) try writer.writeByte('\n');
 }
 
-fn format(writer: anytype, actions: Actions, p1: u9, p2: u9) !void {
+fn format(writer: *std.Io.Writer, actions: Actions, p1: u9, p2: u9) !void {
     var input: [1024]u8 = undefined;
     var output: [1024]u8 = undefined;
 
-    var stream = std.io.fixedBufferStream(&input);
-    try actions.fmt(&stream.writer(), false);
-    var len = stream.getWritten().len;
+    var w = std.Io.Writer.fixed(&input);
+    try actions.fmt(&w, false);
+    var len = w.buffered().len;
     @memcpy(output[0..len], input[0..len]);
 
     var find: [16]u8 = undefined;
@@ -604,78 +602,92 @@ pub const Rolls = struct {
         return if (action.speed_tie == .None) &PLAYER_NONE else &PLAYERS;
     }
 
-    const OBS_NONE = [_]Optional(Observation){.None};
-    const OBS_STARTED = [_]Optional(Observation){.started};
-    const OBS_CONTINUING = [_]Optional(Observation){.continuing};
-    const OBS_ENDED = [_]Optional(Observation){.ended};
-    const OBS_ALL = [_]Optional(Observation){ .started, .continuing, .ended };
-    const OBS = [_]Optional(Observation){ .continuing, .ended };
+    const SLP_NONE = [_]Optional(Observation(.sleep)){.None};
+    const SLP_STARTED = [_]Optional(Observation(.sleep)){.started};
+    const SLP_ENDED = [_]Optional(Observation(.sleep)){.ended};
+    const SLP_ALL = [_]Optional(Observation(.sleep)){ .started, .continuing, .ended };
+    const SLP = [_]Optional(Observation(.sleep)){ .continuing, .ended };
 
     /// Returns a slice with a range of values for sleep given the `action` state and observed
     /// `durations`.
-    pub fn sleep(action: Action, duration: Duration) []const Optional(Observation) {
-        if (action.sleep == .None) return &OBS_NONE;
+    pub fn sleep(action: Action, duration: Duration) []const Optional(Observation(.sleep)) {
+        if (action.sleep == .None) return &SLP_NONE;
         return if (Sleeps.get(duration.sleeps, 0) == 0 and action.speed_tie != .None)
-            &OBS_ALL
+            &SLP_ALL
         else switch (action.sleep) {
-            .started => &OBS_STARTED,
-            else => if (Sleeps.get(duration.sleeps, 0) >= 7) &OBS_ENDED else &OBS,
+            .started => &SLP_STARTED,
+            else => if (Sleeps.get(duration.sleeps, 0) >= 7) &SLP_ENDED else &SLP,
         };
     }
 
+    const DIS_NONE = [_]Optional(Observation(.disable)){.None};
+    const DIS_STARTED = [_]Optional(Observation(.disable)){.started};
+    const DIS_CONTINUING = [_]Optional(Observation(.disable)){.continuing};
+    const DIS_ENDED = [_]Optional(Observation(.disable)){.ended};
+    const DIS_ALL = [_]Optional(Observation(.disable)){ .started, .continuing, .ended };
+    const DIS = [_]Optional(Observation(.disable)){ .continuing, .ended };
+
     /// Returns a slice with a range of values for disable given the `action`, observed `durations`,
     /// and the state of the `parent` (observation of the player's Pokémon sleep status).
     pub fn disable(
         action: Action,
         duration: Duration,
-        parent: Optional(Observation),
-    ) []const Optional(Observation) {
-        if (action.disable == .None) return &OBS_NONE;
+        parent: Optional(Observation(.sleep)),
+    ) []const Optional(Observation(.disable)) {
+        if (action.disable == .None) return &DIS_NONE;
         return if (duration.disable == 0 and action.speed_tie != .None)
-            &OBS_ALL
+            &DIS_ALL
         else switch (action.disable) {
-            .started => &OBS_STARTED,
+            .started => &DIS_STARTED,
             else => if (duration.disable >= 8)
-                &OBS_ENDED
+                &DIS_ENDED
             else if (parent != .None and parent != .started)
-                &OBS_CONTINUING
+                &DIS_CONTINUING
             else
-                &OBS,
+                &DIS,
         };
     }
 
-    /// FIXME
+    const ATK_NONE = [_]Optional(Observation(.attacking)){.None};
+    const ATK_STARTED = [_]Optional(Observation(.attacking)){.started};
+    const ATK_CONTINUING = [_]Optional(Observation(.attacking)){.continuing};
+    const ATK_ENDED = [_]Optional(Observation(.attacking)){.ended};
+    const ATK = [_]Optional(Observation(.attacking)){ .continuing, .ended };
+
+    /// FIXME document
     pub fn attacking(
         action: Action,
         duration: Duration,
-        parent: Optional(Observation),
-    ) []const Optional(Observation) {
+        parent: Optional(Observation(.sleep)),
+    ) []const Optional(Observation(.attacking)) {
         return switch (action.attacking) {
-            .None => &OBS_NONE,
-            .started => &OBS_STARTED,
+            .None => &ATK_NONE,
+            .started => &ATK_STARTED,
             else => if (duration.attacking >= 3)
-                &OBS_ENDED
+                &ATK_ENDED
             else if ((parent == .continuing and parent == .ended) or duration.attacking < 2)
-                &OBS_CONTINUING
+                &ATK_CONTINUING
             else
-                &OBS,
+                &ATK,
         };
     }
 
-    const CFZ_NONE = [_]Optional(Confusion){.None};
-    const CFZ_STARTED = [_]Optional(Confusion){.started};
-    const CFZ_OVERWRITTEN = [_]Optional(Confusion){ .started, .overwritten };
-    const CFZ_CONTINUING = [_]Optional(Confusion){.continuing};
-    const CFZ_ENDED = [_]Optional(Confusion){.ended};
-    const CFZ = [_]Optional(Confusion){ .continuing, .ended };
+    const CFZ_NONE = [_]Optional(Observation(.confusion)){.None};
+    const CFZ_STARTED = [_]Optional(Observation(.confusion)){.started};
+    const CFZ_OVERWRITTEN = [_]Optional(Observation(.confusion)){ .started, .overwritten };
+    const CFZ_CONTINUING = [_]Optional(Observation(.confusion)){.continuing};
+    const CFZ_ENDED = [_]Optional(Observation(.confusion)){.ended};
+    const CFZ = [_]Optional(Observation(.confusion)){ .continuing, .ended };
+    const CFZ_TIE = [_]Optional(Observation(.confusion)){ .started, .continuing, .ended };
 
-    /// FIXME
+    /// FIXME document
     pub fn confusion(
         action: Action,
         duration: Duration,
-        sibling: Optional(Observation),
-        parent: Optional(Observation),
-    ) []const Optional(Confusion) {
+        tie: Optional(Player),
+        sibling: Optional(Observation(.attacking)),
+        parent: Optional(Observation(.sleep)),
+    ) []const Optional(Observation(.confusion)) {
         return switch (action.confusion) {
             .None => &CFZ_NONE,
             .started => if (pkmn.options.overwrite and sibling == .ended and duration.confusion < 5)
@@ -686,23 +698,30 @@ pub const Rolls = struct {
                 &CFZ_ENDED
             else if ((parent == .continuing and parent == .ended) or duration.confusion < 2)
                 &CFZ_CONTINUING
+            else if (tie != .None)
+                &CFZ_TIE
             else
                 &CFZ,
         };
     }
 
+    const BND_NONE = [_]Optional(Observation(.binding)){.None};
+    const BND_STARTED = [_]Optional(Observation(.binding)){.started};
+    const BND_ENDED = [_]Optional(Observation(.binding)){.ended};
+    const BND = [_]Optional(Observation(.binding)){ .continuing, .ended };
+
     /// Returns a slice with a range of values for binding given the `action`, observed `durations`,
     /// and the state of the `parent` (whether the player's Pokémon was fully paralyzed).
     pub fn binding(
         action: Action,
         duration: Duration,
         parent: Optional(bool),
-    ) []const Optional(Observation) {
-        if (parent == .true) return &OBS_NONE;
+    ) []const Optional(Observation(.binding)) {
+        if (parent == .true) return &BND_NONE;
         return switch (action.binding) {
-            .None => &OBS_NONE,
-            .started => &OBS_STARTED,
-            else => if (duration.binding >= 4) &OBS_ENDED else &OBS,
+            .None => &BND_NONE,
+            .started => &BND_STARTED,
+            else => if (duration.binding >= 4) &BND_ENDED else &BND,
         };
     }
 
@@ -731,7 +750,7 @@ pub const Rolls = struct {
     }
 
     /// The min and max bounds on iteration over damage rolls.
-    pub const Range = struct { min: u9, max: u9 };
+    pub const Range = struct { min: usize, max: usize };
 
     /// Returns the range bounding damage rolls given the `action` state and the state of
     /// the `parent` (whether the player's Pokémon's move hit).
@@ -744,7 +763,7 @@ pub const Rolls = struct {
 
     /// Returns the max damage roll which will produce the same damage as `roll`
     /// given the base damage in `summaries`.
-    pub fn coalesce(player: Player, roll: u8, summaries: *Summaries, cap: bool) !u8 {
+    pub fn coalesce(player: Player, roll: u8, summaries: *Summaries, cap: bool) u8 {
         if (roll == 0) return roll;
 
         const dmg = summaries.get(player.foe()).damage;
@@ -756,7 +775,10 @@ pub const Rolls = struct {
 
     /// Returns a slice with the correct range of values for confused given the `action` state and
     /// the state of the `parent` (observation of the player's Pokémon confusion status).
-    pub fn confused(action: Action, parent: Optional(Confusion)) []const Optional(bool) {
+    pub fn confused(
+        action: Action,
+        parent: Optional(Observation(.confusion)),
+    ) []const Optional(bool) {
         const done = parent == .None or parent == .ended;
         return if (done or action.confused == .None) &BOOL_NONE else &BOOLS;
     }
@@ -768,24 +790,24 @@ pub const Rolls = struct {
         return if (action.paralyzed == .None) &BOOL_NONE else &BOOLS;
     }
 
-    const SLOT_NONE = [_]u4{0};
-    const SLOT = [_]u4{ 1, 2, 3, 4 };
+    const SLOT_NONE = [_]u3{0};
+    const SLOT = [_]u3{ 1, 2, 3, 4 };
 
     /// Returns a slice with a range of values for move slots given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
     ///
     /// These slots may or **may not be valid** as slots may be unset / have 0 PP.
-    pub fn moveSlot(action: Action, parent: Optional(bool)) []const u4 {
+    pub fn moveSlot(action: Action, parent: Optional(bool)) []const u3 {
         if (parent == .false) return &SLOT_NONE;
         return if (action.move_slot == 0) &SLOT_NONE else &SLOT;
     }
 
-    const MULTI_NONE = [_]u4{0};
-    const MULTI = [_]u4{ 2, 3, 4, 5 };
+    const MULTI_NONE = [_]u3{0};
+    const MULTI = [_]u3{ 2, 3, 4, 5 };
 
     /// Returns a slice with the correct range of values for multi hit given the `action` state
     /// and the state of the `parent` (whether the player's Pokémon's move hit).
-    pub fn multiHit(action: Action, parent: Optional(bool)) []const u4 {
+    pub fn multiHit(action: Action, parent: Optional(bool)) []const u3 {
         if (parent == .false) return &MULTI_NONE;
         return if (action.multi_hit == 0) &MULTI_NONE else &MULTI;
     }
@@ -854,12 +876,12 @@ test "Rolls.damage" {
 
 test "Rolls.coalesce" {
     var summaries = 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(@as(u8, 0), Rolls.coalesce(.P2, 0, &summaries, false));
+    try expectEqual(@as(u8, 241), Rolls.coalesce(.P2, 238, &summaries, false));
+    try expectEqual(@as(u8, 255), 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(@as(u8, 217), Rolls.coalesce(.P2, 217, &summaries, false));
+    try expectEqual(@as(u8, 255), Rolls.coalesce(.P2, 217, &summaries, true));
 }
 
 test "Rolls.hit" {
@@ -917,16 +939,16 @@ test "Rolls.paralyzed" {
 
 test "Rolls.moveSlot" {
     const actions: Actions = .{ .p2 = .{ .move_slot = 3 } };
-    try expectEqualSlices(u4, &.{0}, Rolls.moveSlot(actions.p1, .None));
-    try expectEqualSlices(u4, &.{ 1, 2, 3, 4 }, Rolls.moveSlot(actions.p2, .None));
-    try expectEqualSlices(u4, &.{0}, Rolls.moveSlot(actions.p2, .false));
+    try expectEqualSlices(u3, &.{0}, Rolls.moveSlot(actions.p1, .None));
+    try expectEqualSlices(u3, &.{ 1, 2, 3, 4 }, Rolls.moveSlot(actions.p2, .None));
+    try expectEqualSlices(u3, &.{0}, Rolls.moveSlot(actions.p2, .false));
 }
 
 test "Rolls.multiHit" {
     const actions: Actions = .{ .p2 = .{ .multi_hit = 3 } };
-    try expectEqualSlices(u4, &.{0}, Rolls.multiHit(actions.p1, .None));
-    try expectEqualSlices(u4, &.{ 2, 3, 4, 5 }, Rolls.multiHit(actions.p2, .None));
-    try expectEqualSlices(u4, &.{0}, Rolls.multiHit(actions.p2, .false));
+    try expectEqualSlices(u3, &.{0}, Rolls.multiHit(actions.p1, .None));
+    try expectEqualSlices(u3, &.{ 2, 3, 4, 5 }, Rolls.multiHit(actions.p2, .None));
+    try expectEqualSlices(u3, &.{0}, Rolls.multiHit(actions.p2, .false));
 }
 
 test "Rolls.metronome" {