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

package/src/lib/common/protocol.zig

@@ -3,8 +3,8 @@ const builtin = @import("builtin");
 
 const pkmn = @import("../pkmn.zig");
 
-const data = @import("./data.zig");
-const options = @import("./options.zig");
+const data = @import("data.zig");
+const options = @import("options.zig");
 
 const assert = std.debug.assert;
 const print = std.debug.print;
@@ -14,6 +14,8 @@ const enabled = options.log;
 const Player = data.Player;
 const ID = data.ID;
 
+const endian = builtin.cpu.arch.endian();
+
 pub const ArgType = enum(u8) {
     None,
 
@@ -71,7 +73,7 @@ pub const ArgType = enum(u8) {
     EndAbility,
     ClearNegativeBoost,
     FormeChange,
-    NoTarget,
+    LastNoTarget, // FIXME
 
     // Gen 4
     SwapBoost,
@@ -218,6 +220,7 @@ pub const Activate = enum(u8) {
     BeatUp, // FIXME of
 
     Magnitude,
+    Spite,
 };
 
 pub const Start = enum(u8) {
@@ -359,8 +362,8 @@ pub fn Log(comptime Writer: type) type {
             } else {
                 try self.writer.writeAll(&.{ @intFromEnum(args[1].species), args[1].level });
             }
-            try self.writer.writeIntNative(u16, args[1].hp);
-            try self.writer.writeIntNative(u16, args[1].stats.hp);
+            try self.writer.writeInt(u16, args[1].hp, endian);
+            try self.writer.writeInt(u16, args[1].stats.hp, endian);
             try self.writer.writeAll(&.{args[1].status});
         }
 
@@ -391,7 +394,7 @@ pub fn Log(comptime Writer: type) type {
             if (!enabled) return;
 
             try self.writer.writeByte(@intFromEnum(ArgType.Turn));
-            try self.writer.writeIntNative(u16, args[0]);
+            try self.writer.writeInt(u16, args[0], endian);
             try self.writer.writeByte(@intFromEnum(ArgType.None));
         }
 
@@ -423,8 +426,8 @@ pub fn Log(comptime Writer: type) type {
                 @intFromEnum(ArgType.Damage),
                 @as(u8, @bitCast(args[0])),
             });
-            try self.writer.writeIntNative(u16, args[1].hp);
-            try self.writer.writeIntNative(u16, args[1].stats.hp);
+            try self.writer.writeInt(u16, args[1].hp, endian);
+            try self.writer.writeInt(u16, args[1].stats.hp, endian);
             try self.writer.writeAll(&.{ args[1].status, @intFromEnum(@as(Damage, args[2])) });
             if (args.len == 4) try self.writer.writeByte(@as(u8, @bitCast(args[3])));
         }
@@ -436,8 +439,8 @@ pub fn Log(comptime Writer: type) type {
 
             assert(args[2] != .Drain or args.len == 4);
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Heal), @as(u8, @bitCast(args[0])) });
-            try self.writer.writeIntNative(u16, args[1].hp);
-            try self.writer.writeIntNative(u16, args[1].stats.hp);
+            try self.writer.writeInt(u16, args[1].hp, endian);
+            try self.writer.writeInt(u16, args[1].stats.hp, endian);
             try self.writer.writeAll(&.{ args[1].status, @intFromEnum(@as(Heal, args[2])) });
             if (args.len == 4) try self.writer.writeByte(@as(u8, @bitCast(args[3])));
         }
@@ -542,6 +545,7 @@ pub fn Log(comptime Writer: type) type {
         // ident: ID, reason: Activate
         // ident: ID, reason: .SubstituteBlock, m: <Move>
         // ident: ID, reason: .Magnitude, num: u8
+        // ident: ID, reason: .Spite, m: <Move>, num: u8
         pub fn activate(self: Self, args: anytype) Error!void {
             if (!enabled) return;
 
@@ -559,6 +563,9 @@ pub fn Log(comptime Writer: type) type {
                     assert(reason == .Magnitude);
                     try self.writer.writeByte(args[2]);
                 }
+            } else if (args.len == 4) {
+                assert(reason == .Spite);
+                try self.writer.writeAll(&.{ @intFromEnum(args[2]), args[3] });
             }
         }
 
@@ -706,8 +713,8 @@ pub fn Log(comptime Writer: type) type {
             if (!enabled) return;
 
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.SetHP), @as(u8, @bitCast(args[0])) });
-            try self.writer.writeIntNative(u16, args[1].hp);
-            try self.writer.writeIntNative(u16, args[1].stats.hp);
+            try self.writer.writeInt(u16, args[1].hp, endian);
+            try self.writer.writeInt(u16, args[1].stats.hp, endian);
             try self.writer.writeAll(&.{args[1].status});
             try self.writer.writeByte(@intFromEnum(@as(SetHP, args[2])));
         }
@@ -831,10 +838,10 @@ pub const ByteStream = struct {
             try self.stream.writeByte(byte);
         }
 
-        pub fn writeIntNative(self: Writer, comptime T: type, value: T) Error!void {
+        pub fn writeInt(self: Writer, comptime T: type, v: T, end: std.builtin.Endian) Error!void {
             // TODO: rework this to write directly to the buffer?
-            var bytes: [(@typeInfo(T).Int.bits + 7) / 8]u8 = undefined;
-            std.mem.writeIntNative(T, &bytes, value);
+            var bytes: [@divExact(@typeInfo(T).Int.bits, 8)]u8 = undefined;
+            std.mem.writeInt(std.math.ByteAlignedInt(@TypeOf(v)), &bytes, v, end);
             return self.writeAll(&bytes);
         }
     };
@@ -943,19 +950,19 @@ pub fn format(
                     if (a[i] == N(gen.Gender.Unknown)) {
                         i += 1;
                     } else {
-                        var gender = if (a[i] == N(gen.Gender.Male)) "M" else "F";
+                        const gender = if (a[i] == N(gen.Gender.Male)) "M" else "F";
                         printc(", {s}", .{gender}, a, b, &i, 1, color);
                     }
                 }
                 printc(" L{d}", .{a[i]}, a, b, &i, 1, color);
                 switch (endian) {
-                    .Big => {
+                    .big => {
                         var hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
-                    .Little => {
+                    .little => {
                         var hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
@@ -986,8 +993,8 @@ pub fn format(
             },
             .Turn => {
                 const turn = switch (endian) {
-                    .Big => @as(u16, a[i]) << 8 | @as(u16, a[i + 1]),
-                    .Little => @as(u16, a[i + 1]) << 8 | @as(u16, a[i]),
+                    .big => @as(u16, a[i]) << 8 | @as(u16, a[i + 1]),
+                    .little => @as(u16, a[i + 1]) << 8 | @as(u16, a[i]),
                 };
                 printc(" {d}", .{turn}, a, b, &i, 2, color);
             },
@@ -998,13 +1005,13 @@ pub fn format(
                 var id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                 switch (endian) {
-                    .Big => {
+                    .big => {
                         var hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
-                    .Little => {
+                    .little => {
                         var hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
@@ -1126,13 +1133,13 @@ pub fn format(
                 const id = ID.from(@intCast(a[i]));
                 printc(" {s}({d})", .{ @tagName(id.player), id.id }, a, b, &i, 1, color);
                 switch (endian) {
-                    .Big => {
+                    .big => {
                         var hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i]) << 8 | @as(u16, a[i + 1]);
                         printc("/{d}", .{hp}, a, b, &i, 2, color);
                     },
-                    .Little => {
+                    .little => {
                         var hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
                         printc(" {d}", .{hp}, a, b, &i, 2, color);
                         hp = @as(u16, a[i + 1]) << 8 | @as(u16, a[i]);
@@ -1200,14 +1207,11 @@ pub fn expectLog(
 ) !void {
     if (!enabled) return;
 
-    const color = color: {
-        if (std.process.hasEnvVarConstant("ZIG_DEBUG_COLOR")) {
-            break :color true;
-        } else if (std.process.hasEnvVarConstant("NO_COLOR")) {
-            break :color false;
-        } else {
-            break :color std.io.getStdErr().supportsAnsiEscapeCodes();
-        }
+    const color = if (std.process.hasEnvVarConstant("ZIG_DEBUG_COLOR"))
+        true
+    else switch (std.io.tty.detectConfig(std.io.getStdErr())) {
+        .escape_codes => true,
+        else => false,
     };
 
     expectEqualBytes(expected, actual, offset) catch |err| switch (err) {
@@ -1239,8 +1243,6 @@ fn expectEqualBytes(expected: []const u8, actual: []const u8, offset: usize) !vo
     }
 }
 
-const endian = builtin.target.cpu.arch.endian();
-
 fn N(e: anytype) u8 {
     return @intFromEnum(e);
 }
@@ -1248,20 +1250,13 @@ fn N(e: anytype) u8 {
 const p1 = Player.P1;
 const p2 = Player.P2;
 
-const gen1 = struct {
-    pub usingnamespace @import("../gen1/data.zig");
-    pub const helpers = @import("../gen1/helpers.zig");
-};
-
-const gen2 = struct {
-    pub usingnamespace @import("../gen2/data.zig");
-    pub const helpers = @import("../gen2/helpers.zig");
-};
-
 var buf: [pkmn.LOGS_SIZE]u8 = undefined;
 var stream: ByteStream = .{ .buffer = &buf };
 var log: FixedLog = .{ .writer = stream.writer() };
 
+const gen1 = pkmn.gen1;
+const gen2 = pkmn.gen2;
+
 const M1 = gen1.Move;
 const S1 = gen1.Species;
 
@@ -1350,8 +1345,8 @@ test "|switch|" {
     try log.switched(.{ p2.ident(3), &snorlax });
     const par = 0b1000000;
     var expected: []const u8 = switch (endian) {
-        .Big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 91, 0, 200, 1, 144, par },
-        .Little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 91, 200, 0, 144, 1, par },
+        .big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 91, 0, 200, 1, 144, par },
+        .little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 91, 200, 0, 144, 1, par },
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
@@ -1361,8 +1356,8 @@ test "|switch|" {
     snorlax.status = 0;
     try log.switched(.{ p2.ident(3), &snorlax });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 0, 0, 1, 144, 0 },
-        .Little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 0, 0, 144, 1, 0 },
+        .big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 0, 0, 1, 144, 0 },
+        .little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 0, 0, 144, 1, 0 },
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
@@ -1370,8 +1365,8 @@ test "|switch|" {
     snorlax.hp = 400;
     try log.switched(.{ p2.ident(3), &snorlax });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 1, 144, 1, 144, 0 },
-        .Little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 144, 1, 144, 1, 0 },
+        .big => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 1, 144, 1, 144, 0 },
+        .little => &.{ N(ArgType.Switch), 0b1011, N(S1.Snorlax), 100, 144, 1, 144, 1, 0 },
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
@@ -1389,8 +1384,8 @@ test "|switch|" {
         N(gen2.Gender.Female),
         91,
     } ++ switch (endian) {
-        .Big => .{ 0, 200, 1, 144, par },
-        .Little => .{ 200, 0, 144, 1, par },
+        .big => .{ 0, 200, 1, 144, par },
+        .little => .{ 200, 0, 144, 1, par },
     });
     try expectLog2(expected, buf[0..10]);
     stream.reset();
@@ -1418,9 +1413,9 @@ test "|faint|" {
 
 test "|turn|" {
     try log.turn(.{42});
-    var expected = switch (endian) {
-        .Big => &.{ N(ArgType.Turn), 0, 42, N(ArgType.None) },
-        .Little => &.{ N(ArgType.Turn), 42, 0, N(ArgType.None) },
+    const expected = switch (endian) {
+        .big => &.{ N(ArgType.Turn), 0, 42, N(ArgType.None) },
+        .little => &.{ N(ArgType.Turn), 42, 0, N(ArgType.None) },
     };
     try expectLog1(expected, buf[0..4]);
     stream.reset();
@@ -1444,8 +1439,8 @@ test "|-damage|" {
     chansey.status = gen1.Status.slp(1);
     try log.damage(.{ p2.ident(2), &chansey, .None });
     var expected: []const u8 = switch (endian) {
-        .Big => &.{ N(ArgType.Damage), 0b1010, 2, 100, 2, 191, 1, N(Damage.None) },
-        .Little => &.{ N(ArgType.Damage), 0b1010, 100, 2, 191, 2, 1, N(Damage.None) },
+        .big => &.{ N(ArgType.Damage), 0b1010, 2, 100, 2, 191, 1, N(Damage.None) },
+        .little => &.{ N(ArgType.Damage), 0b1010, 100, 2, 191, 2, 1, N(Damage.None) },
     };
     try expectLog1(expected, buf[0..8]);
     stream.reset();
@@ -1455,8 +1450,8 @@ test "|-damage|" {
     chansey.status = 0;
     try log.damage(.{ p2.ident(2), &chansey, .Confusion });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Damage), 0b1010, 0, 100, 1, 0, 0, N(Damage.Confusion) },
-        .Little => &.{ N(ArgType.Damage), 0b1010, 100, 0, 0, 1, 0, N(Damage.Confusion) },
+        .big => &.{ N(ArgType.Damage), 0b1010, 0, 100, 1, 0, 0, N(Damage.Confusion) },
+        .little => &.{ N(ArgType.Damage), 0b1010, 100, 0, 0, 1, 0, N(Damage.Confusion) },
     };
     try expectLog1(expected, buf[0..8]);
     stream.reset();
@@ -1464,8 +1459,8 @@ test "|-damage|" {
     chansey.status = gen1.Status.init(.PSN);
     try log.damage(.{ p2.ident(2), &chansey, .RecoilOf, p1.ident(1) });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Damage), 0b1010, 0, 100, 1, 0, 0b1000, N(Damage.RecoilOf), 1 },
-        .Little => &.{ N(ArgType.Damage), 0b1010, 100, 0, 0, 1, 0b1000, N(Damage.RecoilOf), 1 },
+        .big => &.{ N(ArgType.Damage), 0b1010, 0, 100, 1, 0, 0b1000, N(Damage.RecoilOf), 1 },
+        .little => &.{ N(ArgType.Damage), 0b1010, 100, 0, 0, 1, 0b1000, N(Damage.RecoilOf), 1 },
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
@@ -1477,8 +1472,8 @@ test "|-heal|" {
     chansey.status = gen1.Status.slp(1);
     try log.heal(.{ p2.ident(2), &chansey, .None });
     var expected: []const u8 = switch (endian) {
-        .Big => &.{ N(ArgType.Heal), 0b1010, 2, 100, 2, 191, 1, N(Heal.None) },
-        .Little => &.{ N(ArgType.Heal), 0b1010, 100, 2, 191, 2, 1, N(Heal.None) },
+        .big => &.{ N(ArgType.Heal), 0b1010, 2, 100, 2, 191, 1, N(Heal.None) },
+        .little => &.{ N(ArgType.Heal), 0b1010, 100, 2, 191, 2, 1, N(Heal.None) },
     };
     try expectLog1(expected, buf[0..8]);
     stream.reset();
@@ -1488,16 +1483,16 @@ test "|-heal|" {
     chansey.status = 0;
     try log.heal(.{ p2.ident(2), &chansey, .Silent });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Heal), 0b1010, 0, 100, 1, 0, 0, N(Heal.Silent) },
-        .Little => &.{ N(ArgType.Heal), 0b1010, 100, 0, 0, 1, 0, N(Heal.Silent) },
+        .big => &.{ N(ArgType.Heal), 0b1010, 0, 100, 1, 0, 0, N(Heal.Silent) },
+        .little => &.{ N(ArgType.Heal), 0b1010, 100, 0, 0, 1, 0, N(Heal.Silent) },
     };
     try expectLog1(expected, buf[0..8]);
     stream.reset();
 
     try log.heal(.{ p2.ident(2), &chansey, .Drain, p1.ident(1) });
     expected = switch (endian) {
-        .Big => &.{ N(ArgType.Heal), 0b1010, 0, 100, 1, 0, 0, N(Heal.Drain), 1 },
-        .Little => &.{ N(ArgType.Heal), 0b1010, 100, 0, 0, 1, 0, N(Heal.Drain), 1 },
+        .big => &.{ N(ArgType.Heal), 0b1010, 0, 100, 1, 0, 0, N(Heal.Drain), 1 },
+        .little => &.{ N(ArgType.Heal), 0b1010, 100, 0, 0, 1, 0, N(Heal.Drain), 1 },
     };
     try expectLog1(expected, buf[0..9]);
     stream.reset();
@@ -1740,8 +1735,8 @@ test "|drag|" {
         N(gen2.Gender.Female),
         91,
     } ++ switch (endian) {
-        .Big => .{ 0, 200, 1, 144, par },
-        .Little => .{ 200, 0, 144, 1, par },
+        .big => .{ 0, 200, 1, 144, par },
+        .little => .{ 200, 0, 144, 1, par },
     });
     try expectLog2(expected, buf[0..10]);
     stream.reset();
@@ -1773,9 +1768,9 @@ test "|-sethp|" {
     var blissey = gen2.helpers.Pokemon.init(.{ .species = .Blissey, .moves = &.{.PainSplit} });
     blissey.hp = 612;
     try log.sethp(.{ p2.ident(2), &blissey, .Silent });
-    var expected: []const u8 = switch (endian) {
-        .Big => &.{ N(ArgType.SetHP), 0b1010, 2, 100, 2, 201, 0, N(SetHP.Silent) },
-        .Little => &.{ N(ArgType.SetHP), 0b1010, 100, 2, 201, 2, 0, N(SetHP.Silent) },
+    const expected: []const u8 = switch (endian) {
+        .big => &.{ N(ArgType.SetHP), 0b1010, 2, 100, 2, 201, 0, N(SetHP.Silent) },
+        .little => &.{ N(ArgType.SetHP), 0b1010, 100, 2, 201, 2, 0, N(SetHP.Silent) },
     };
     try expectLog2(expected, buf[0..8]);
     stream.reset();

package/src/lib/common/rational.zig

@@ -192,9 +192,9 @@ pub fn Rational(comptime T: type) type {
 
         fn addition(r: *Self, p: anytype, q: anytype) !void {
             // (a/b) + (c/d) = (ad+bc)/(bd)
-            var d = try std.math.mul(T, r.q, q);
-            var n1 = try std.math.mul(T, r.p, q);
-            var n2 = try std.math.mul(T, r.q, p);
+            const d = try std.math.mul(T, r.q, q);
+            const n1 = try std.math.mul(T, r.p, q);
+            const n2 = try std.math.mul(T, r.q, p);
 
             r.p = try std.math.add(T, n1, n2);
             r.q = d;
@@ -234,6 +234,8 @@ test Rational {
         var r: Rational(t) = .{};
 
         var c: t = 128;
+        _ = &c;
+
         try r.update(c, 256);
         try doTurn(&r);
 
@@ -320,6 +322,8 @@ test BigRational {
     try r.reset();
 
     var c: u8 = 128;
+    _ = &c;
+
     try r.update(c, 256);
     try doTurn(&r);
 

package/src/lib/common/rng.zig

@@ -1,6 +1,6 @@
 const std = @import("std");
 
-const options = @import("./options.zig");
+const options = @import("options.zig");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
@@ -66,11 +66,15 @@ pub const PSRNG = extern struct {
             (@as(u64, self.range(u16, 0, 0x10000)) << 16) |
             (@as(u64, self.range(u16, 0, 0x10000)));
     }
+
+    pub fn Bound(comptime T: type) type {
+        return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
+    }
 };
 
 test PSRNG {
     var psrng: PSRNG = .{ .src = .{ .seed = 0x0001000200030004 } };
-    try expectEqual(@as(u8, 121), psrng.range(u8, 0, 256));
+    try expectEqual(121, psrng.range(u8, 0, 256));
     try expectEqual(false, psrng.chance(u8, 128, 256)); // 226 < 128
 }
 
@@ -107,9 +111,9 @@ test Gen12 {
         try expectEqual(e, rng.next());
     }
 
-    try expectEqual(@as(u8, 16), Gen12.percent(6) + 1);
-    try expectEqual(@as(u8, 16), Gen12.percent(7) - 1);
-    try expectEqual(@as(u8, 128), Gen12.percent(50) + 1);
+    try expectEqual(16, Gen12.percent(6) + 1);
+    try expectEqual(16, Gen12.percent(7) - 1);
+    try expectEqual(128, Gen12.percent(50) + 1);
 }
 
 // https://pkmn.cc/pokeemerald/src/random.c
@@ -197,7 +201,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             for (0..n) |_| _ = self.next();
         }
 
-        pub fn range(self: *Self, comptime T: type, from: T, to: Bound(T)) T {
+        pub fn range(self: *Self, comptime T: type, from: T, to: PSRNG.Bound(T)) T {
             assert(showdown);
             return @intCast(@as(u64, self.next()) * (to - from) / divisor + from);
         }
@@ -206,7 +210,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
             self: *Self,
             comptime T: type,
             numerator: T,
-            denominator: Bound(T),
+            denominator: PSRNG.Bound(T),
         ) bool {
             assert(showdown);
             assert(denominator > 0);
@@ -237,7 +241,3 @@ fn Output(comptime gen: comptime_int) type {
         else => unreachable,
     };
 }
-
-fn Bound(comptime T: type) type {
-    return std.math.IntFittingRange(0, std.math.maxInt(T) + 1);
-}

package/src/lib/gen1/calc.zig

@@ -211,8 +211,8 @@ pub fn transitions(
 ) !?Stats {
     var stats: Stats = .{};
 
-    var actions = options.actions;
-    var cap = options.cap;
+    const actions = options.actions;
+    const cap = options.cap;
 
     var seen = std.AutoHashMap(Actions, void).init(allocator);
     defer seen.deinit();
@@ -232,8 +232,8 @@ pub fn transitions(
     _ = try b.update(c1, c2, &opts);
     stats.updates += 1;
 
-    var p1 = b.side(.P1);
-    var p2 = b.side(.P2);
+    const p1 = b.side(.P1);
+    const p2 = b.side(.P2);
 
     var p: Rational(u128) = .{ .p = 0, .q = 1 };
     try frontier.append(opts.chance.actions);
@@ -247,7 +247,7 @@ pub fn transitions(
     var i: usize = 0;
     assert(frontier.items.len == 1);
     while (i < frontier.items.len) : (i += 1) {
-        var template = frontier.items[i];
+        const template = frontier.items[i];
         opts.calc.overrides.durations = .{
             .p1 = template.p1.durations,
             .p2 = template.p2.durations,

package/src/lib/gen1/chance.zig

@@ -14,7 +14,7 @@ const util = @import("../common/util.zig");
 const Player = @import("../common/data.zig").Player;
 const Optional = @import("../common/optional.zig").Optional;
 
-const data = @import("./data.zig");
+const data = @import("data.zig");
 
 const enabled = options.chance;
 const showdown = options.showdown;
@@ -706,19 +706,19 @@ test "Chance.damage" {
 
     try chance.damage(.P1, 217);
     if (showdown) {
-        try expectValue(@as(u8, 217), chance.actions.p1.damage);
+        try expectValue(217, chance.actions.p1.damage);
         try expectProbability(&chance.probability, 1, 39);
     } else {
         try expectProbability(&chance.probability, 1, 1);
-        try expectValue(@as(u8, 0), chance.actions.p1.damage);
+        try expectValue(0, chance.actions.p1.damage);
 
         try chance.commit(.P1, .miss);
         try expectProbability(&chance.probability, 1, 1);
-        try expectValue(@as(u8, 0), chance.actions.p1.damage);
+        try expectValue(0, chance.actions.p1.damage);
 
         try chance.commit(.P1, .hit);
         try expectProbability(&chance.probability, 1, 39);
-        try expectValue(@as(u8, 217), chance.actions.p1.damage);
+        try expectValue(217, chance.actions.p1.damage);
     }
 }
 
@@ -770,13 +770,13 @@ test "Chance.moveSlot" {
 
     try chance.moveSlot(.P2, 2, &ms, 2);
     try expectProbability(&chance.probability, 1, 2);
-    try expectValue(@as(u4, 2), chance.actions.p2.move_slot);
+    try expectValue(2, chance.actions.p2.move_slot);
 
     chance.reset();
 
     try chance.moveSlot(.P1, 1, &ms, 0);
     try expectProbability(&chance.probability, 1, 3);
-    try expectValue(@as(u4, 1), chance.actions.p1.move_slot);
+    try expectValue(1, chance.actions.p1.move_slot);
 }
 
 test "Chance.multiHit" {
@@ -784,32 +784,32 @@ test "Chance.multiHit" {
 
     try chance.multiHit(.P1, 3);
     try expectProbability(&chance.probability, 3, 8);
-    try expectValue(@as(u4, 3), chance.actions.p1.multi_hit);
+    try expectValue(3, chance.actions.p1.multi_hit);
 
     chance.reset();
 
     try chance.multiHit(.P2, 5);
     try expectProbability(&chance.probability, 1, 8);
-    try expectValue(@as(u4, 5), chance.actions.p2.multi_hit);
+    try expectValue(5, chance.actions.p2.multi_hit);
 }
 
 test "Chance.duration" {
     var chance: Chance(rational.Rational(u64)) = .{ .probability = .{} };
 
     chance.duration(.sleep, .P1, .P2, 2);
-    try expectValue(@as(u4, 2), chance.actions.p1.duration);
-    try expectValue(@as(u3, 1), chance.actions.p2.durations.sleep);
+    try expectValue(2, chance.actions.p1.duration);
+    try expectValue(1, chance.actions.p2.durations.sleep);
 
     chance.reset();
 
     chance.duration(.binding, .P2, .P2, 4);
     if (!showdown) {
-        try expectValue(@as(u4, 0), chance.actions.p2.duration);
-        try expectValue(@as(u3, 0), chance.actions.p2.durations.binding);
+        try expectValue(0, chance.actions.p2.duration);
+        try expectValue(0, chance.actions.p2.durations.binding);
         try chance.commit(.P2, .hit);
     }
-    try expectValue(@as(u4, 4), chance.actions.p2.duration);
-    try expectValue(@as(u3, 1), chance.actions.p2.durations.binding);
+    try expectValue(4, chance.actions.p2.duration);
+    try expectValue(1, chance.actions.p2.durations.binding);
 }
 
 test "Chance.sleep" {
@@ -819,7 +819,7 @@ test "Chance.sleep" {
         chance.actions.p1.durations.sleep = @intCast(i);
         try chance.sleep(.P1, 0);
         try expectProbability(&chance.probability, 1, d);
-        try expectValue(@as(u3, 0), chance.actions.p1.durations.sleep);
+        try expectValue(0, chance.actions.p1.durations.sleep);
 
         chance.reset();
 
@@ -842,7 +842,7 @@ test "Chance.confusion" {
             chance.actions.p2.durations.confusion = @intCast(i);
             try chance.confusion(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.confusion);
+            try expectValue(0, chance.actions.p2.durations.confusion);
 
             chance.reset();
         }
@@ -865,7 +865,7 @@ test "Chance.disable" {
         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);
+        try expectValue(0, chance.actions.p1.durations.disable);
 
         chance.reset();
 
@@ -888,7 +888,7 @@ test "Chance.attacking" {
             chance.actions.p2.durations.attacking = @intCast(i);
             try chance.attacking(.P2, 0);
             try expectProbability(&chance.probability, 1, d);
-            try expectValue(@as(u3, 0), chance.actions.p2.durations.attacking);
+            try expectValue(0, chance.actions.p2.durations.attacking);
 
             chance.reset();
         }
@@ -914,7 +914,7 @@ test "Chance.binding" {
         chance.actions.p1.durations.binding = @intCast(i);
         try chance.binding(.P1, 0);
         try expectProbability(&chance.probability, p, q);
-        try expectValue(@as(u3, 0), chance.actions.p1.durations.binding);
+        try expectValue(0, chance.actions.p1.durations.binding);
 
         chance.reset();
 
@@ -934,7 +934,7 @@ test "Chance.psywave" {
 
     try chance.psywave(.P2, 100, 150);
     try expectProbability(&chance.probability, 1, 150);
-    try expectValue(@as(u8, 101), chance.actions.p2.psywave);
+    try expectValue(101, chance.actions.p2.psywave);
 }
 
 test "Chance.metronome" {

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

@@ -1091,7 +1091,7 @@ pub const Species = enum(u8) {
     /// The number of Pokémon species in this generation.
     pub const size = 151;
 
-    /// The Pokémon's critical hit rate=io out of 256.
+    /// The Pokémon's critical hit ratio out of 256.
     pub fn chance(id: Species) u8 {
         assert(id != .None);
         return CHANCES[@intFromEnum(id) - 1];