@pkmn/engine 0.1.0-dev.8b83af6b → 0.1.0-dev.90d6c14c

package/src/lib/common/protocol.zig

@@ -219,8 +219,12 @@ pub const Immune = enum(u8) {
     OHKO,
 };
 
+/// Null object pattern implementation of `Log` backed by a `std.io.null_writer`.
+/// Ignores anything sent to it, though protocol logging should additionally be turned off
+/// entirely with `options.log`.
 pub const NULL = Log(@TypeOf(std.io.null_writer)){ .writer = std.io.null_writer };
 
+/// Logs protocol information to its `Writer` during a battle update when `options.log` is enabled.
 pub fn Log(comptime Writer: type) type {
     return struct {
         const Self = @This();
@@ -231,6 +235,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn move(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),
@@ -254,6 +259,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn switched(self: Self, ident: ID, pokemon: anytype) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Switch), @as(u8, @bitCast(ident)) });
             try self.writer.writeAll(&.{ @intFromEnum(pokemon.species), pokemon.level });
             try self.writer.writeIntNative(u16, pokemon.hp);
@@ -263,6 +269,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn cant(self: Self, ident: ID, reason: Cant) Error!void {
             if (!enabled) return;
+
             assert(reason != .Disable);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Cant),
@@ -273,6 +280,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn disabled(self: Self, ident: ID, m: anytype) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Cant),
                 @as(u8, @bitCast(ident)),
@@ -283,12 +291,14 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn faint(self: Self, ident: ID, done: bool) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Faint), @as(u8, @bitCast(ident)) });
             if (done) try self.writer.writeByte(@intFromEnum(ArgType.None));
         }
 
         pub fn turn(self: Self, num: u16) Error!void {
             if (!enabled) return;
+
             try self.writer.writeByte(@intFromEnum(ArgType.Turn));
             try self.writer.writeIntNative(u16, num);
             try self.writer.writeByte(@intFromEnum(ArgType.None));
@@ -296,6 +306,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn win(self: Self, player: Player) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Win),
                 @intFromEnum(player),
@@ -305,11 +316,13 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn tie(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Tie), @intFromEnum(ArgType.None) });
         }
 
         pub fn damage(self: Self, ident: ID, pokemon: anytype, reason: Damage) Error!void {
             if (!enabled) return;
+
             assert(@intFromEnum(reason) <= @intFromEnum(Damage.LeechSeed));
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Damage), @as(u8, @bitCast(ident)) });
             try self.writer.writeIntNative(u16, pokemon.hp);
@@ -325,6 +338,7 @@ pub fn Log(comptime Writer: type) type {
             source: ID,
         ) Error!void {
             if (!enabled) return;
+
             assert(@intFromEnum(reason) == @intFromEnum(Damage.RecoilOf));
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Damage), @as(u8, @bitCast(ident)) });
             try self.writer.writeIntNative(u16, pokemon.hp);
@@ -338,6 +352,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn heal(self: Self, ident: ID, pokemon: anytype, reason: Heal) Error!void {
             if (!enabled) return;
+
             assert(reason != .Drain);
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Heal), @as(u8, @bitCast(ident)) });
             try self.writer.writeIntNative(u16, pokemon.hp);
@@ -347,6 +362,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn drain(self: Self, source: ID, pokemon: anytype, target: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Heal), @as(u8, @bitCast(source)) });
             try self.writer.writeIntNative(u16, pokemon.hp);
             try self.writer.writeIntNative(u16, pokemon.stats.hp);
@@ -359,6 +375,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn status(self: Self, ident: ID, value: u8, reason: Status) Error!void {
             if (!enabled) return;
+
             assert(reason != .From);
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Status),
@@ -370,6 +387,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn statusFrom(self: Self, ident: ID, value: u8, m: anytype) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Status),
                 @as(u8, @bitCast(ident)),
@@ -381,6 +399,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn curestatus(self: Self, ident: ID, value: u8, reason: CureStatus) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.CureStatus),
                 @as(u8, @bitCast(ident)),
@@ -391,6 +410,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn boost(self: Self, ident: ID, reason: Boost, num: i8) Error!void {
             if (!enabled) return;
+
             assert(num != 0 and (reason != .Rage or num > 0));
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Boost),
@@ -402,11 +422,13 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn clearallboost(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{@intFromEnum(ArgType.ClearAllBoost)});
         }
 
         pub fn fail(self: Self, ident: ID, reason: Fail) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Fail),
                 @as(u8, @bitCast(ident)),
@@ -416,11 +438,13 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn miss(self: Self, source: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Miss), @as(u8, @bitCast(source)) });
         }
 
         pub fn hitcount(self: Self, ident: ID, num: u8) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.HitCount),
                 @as(u8, @bitCast(ident)),
@@ -430,6 +454,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn prepare(self: Self, source: ID, m: anytype) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Prepare),
                 @as(u8, @bitCast(source)),
@@ -439,6 +464,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn mustrecharge(self: Self, ident: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.MustRecharge),
                 @as(u8, @bitCast(ident)),
@@ -447,6 +473,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn activate(self: Self, ident: ID, reason: Activate) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Activate),
                 @as(u8, @bitCast(ident)),
@@ -456,11 +483,13 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn fieldactivate(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{@intFromEnum(ArgType.FieldActivate)});
         }
 
         pub fn start(self: Self, ident: ID, reason: Start) Error!void {
             if (!enabled) return;
+
             assert(@intFromEnum(reason) < @intFromEnum(Start.TypeChange));
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Start),
@@ -471,6 +500,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn typechange(self: Self, source: ID, types: anytype, target: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Start),
                 @as(u8, @bitCast(source)),
@@ -482,6 +512,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn startEffect(self: Self, ident: ID, reason: Start, m: anytype) Error!void {
             if (!enabled) return;
+
             assert(@intFromEnum(reason) > @intFromEnum(Start.TypeChange));
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Start),
@@ -493,6 +524,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn end(self: Self, ident: ID, reason: End) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.End),
                 @as(u8, @bitCast(ident)),
@@ -502,16 +534,19 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn ohko(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{@intFromEnum(ArgType.OHKO)});
         }
 
         pub fn crit(self: Self, ident: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{ @intFromEnum(ArgType.Crit), @as(u8, @bitCast(ident)) });
         }
 
         pub fn supereffective(self: Self, ident: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.SuperEffective),
                 @as(u8, @bitCast(ident)),
@@ -520,6 +555,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn resisted(self: Self, ident: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Resisted),
                 @as(u8, @bitCast(ident)),
@@ -528,6 +564,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn immune(self: Self, ident: ID, reason: Immune) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Immune),
                 @as(u8, @bitCast(ident)),
@@ -537,6 +574,7 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn transform(self: Self, source: ID, target: ID) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{
                 @intFromEnum(ArgType.Transform),
                 @as(u8, @bitCast(source)),
@@ -546,18 +584,24 @@ pub fn Log(comptime Writer: type) type {
 
         pub fn laststill(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{@intFromEnum(ArgType.LastStill)});
         }
 
         pub fn lastmiss(self: Self) Error!void {
             if (!enabled) return;
+
             try self.writer.writeAll(&.{@intFromEnum(ArgType.LastMiss)});
         }
     };
 }
 
+/// `Log` type backed by the optimized `ByteStream.Writer`.
 pub const FixedLog = Log(ByteStream.Writer);
 
+/// Stripped down version of `std.io.FixedBufferStream` optimized for efficiently writing the
+/// individual protocol bytes. Note that the `ByteStream.Writer` is **not** a `std.io.Writer` and
+/// should not be used for general purpose writing.
 pub const ByteStream = struct {
     buffer: []u8,
     pos: usize = 0,
@@ -855,6 +899,7 @@ pub fn expectLog(
     offset: usize,
 ) !void {
     if (!enabled) return;
+
     const color = color: {
         if (std.process.hasEnvVarConstant("ZIG_DEBUG_COLOR")) {
             break :color true;

package/src/lib/common/rational.zig

@@ -0,0 +1,353 @@
+const builtin = @import("builtin");
+const std = @import("std");
+
+const assert = std.debug.assert;
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const expectError = std.testing.expectError;
+
+/// Specialization of a rational number used by the engine to compute probabilties.
+/// For performance reasons the rational is only reduced lazily and thus `reduce` must be
+/// invoked explicitly before reading.
+pub fn Rational(comptime T: type) type {
+    return extern struct {
+        const Self = @This();
+
+        /// Numerator. Must always be >= 1. Not guaranteed to be reduced in all cases.
+        p: T = 1,
+        /// Denominator. Must always be >= 1. Not guaranteed to be reduced in all cases.
+        q: T = 1,
+
+        // With floats we can't rely on an overflow bit to let us know when to reduce, so we instead
+        // start reducing when we get sufficiently close to the limit of the mantissa (in our domain
+        // we expect updates to involve numbers < 2**10, so we should be safe not reducing before we
+        // are 2**10 away from "overflowing" the mantissa)
+        const REDUCE = if (@typeInfo(T) == .Float)
+            std.math.pow(T, 2, std.math.floatMantissaBits(T) - 10)
+        else
+            0;
+
+        /// Possible error returned by operations on the Rational.
+        pub const Error = switch (@typeInfo(T)) {
+            .Int => error{Overflow},
+            .Float => error{},
+            else => unreachable,
+        };
+
+        /// Resets the rational back to 1.
+        pub fn reset(r: *Self) void {
+            r.p = 1;
+            r.q = 1;
+        }
+
+        /// Update the rational by multiplying its numerator by p and its denominator by q.
+        /// Both p and q must be >= 1, and if computable at comptime must have no common factors.
+        pub fn update(r: *Self, p: anytype, q: anytype) Error!void {
+            // FIXME
+            // std.debug.print("({d}/{d}) * ", .{p, q});
+            assert(p >= 1);
+            assert(q >= 1);
+
+            // If our parameters are not fully reduced they may prematurely
+            // cause overflow/loss of precision after the multiplication below
+            assert(switch (@typeInfo(@TypeOf(p, q))) {
+                .ComptimeInt, .ComptimeFloat => comptime gcd(p, q),
+                else => 1,
+            } == 1);
+
+            switch (@typeInfo(T)) {
+                .Int => {
+                    // Greedily attempt to multiply and if it fails, reduce and try again
+                    r.multiplication(p, q) catch |err| switch (err) {
+                        error.Overflow => {
+                            r.reduce();
+                            try r.multiplication(p, q);
+                        },
+                        else => unreachable,
+                    };
+                },
+                .Float => {
+                    // Reduce in situations where we're likely to start losing precision
+                    if (r.q > REDUCE or r.p > REDUCE) r.reduce();
+
+                    r.p *= switch (@typeInfo(@TypeOf(p))) {
+                        .Float, .ComptimeFloat => p,
+                        else => @floatFromInt(p),
+                    };
+                    r.q *= switch (@typeInfo(@TypeOf(q))) {
+                        .Float, .ComptimeFloat => q,
+                        else => @floatFromInt(q),
+                    };
+
+                    // We should always be dealing with whole numbers
+                    assert(std.math.modf(r.p).fpart == 0);
+                    assert(std.math.modf(r.q).fpart == 0);
+                },
+                else => unreachable,
+            }
+        }
+
+        /// Add two rationals using the identity (a/b) + (c/d) = (ad+bc)/(bd).
+        pub fn add(r: *Self, s: *Self) Error!void {
+            switch (@typeInfo(T)) {
+                .Int => {
+                    if (r.q == s.q) {
+                        r.p = std.math.add(T, r.p, s.p) catch |err| switch (err) {
+                            error.Overflow => val: {
+                                r.reduce();
+                                s.reduce();
+                                break :val try std.math.add(T, r.p, s.p);
+                            },
+                            else => unreachable,
+                        };
+                    } else {
+                        r.addition(s.p, s.q) catch |err| switch (err) {
+                            error.Overflow => {
+                                r.reduce();
+                                s.reduce();
+                                try r.addition(s.p, s.q);
+                            },
+                            else => unreachable,
+                        };
+                    }
+                },
+                .Float => {
+                    if (r.q == s.q) {
+                        if (r.p > REDUCE) r.reduce();
+                        if (s.p > REDUCE) s.reduce();
+
+                        r.p += s.p;
+                    } else {
+                        // Always reduce to minimize loss of precision from the multiplications
+                        r.reduce();
+                        s.reduce();
+
+                        r.p = (r.p * s.q) + (r.q * s.p);
+                        r.q *= s.q;
+                    }
+
+                    assert(std.math.modf(r.p).fpart == 0);
+                    assert(std.math.modf(r.q).fpart == 0);
+                },
+                else => unreachable,
+            }
+        }
+
+        /// Multiplies two rationals.
+        pub fn mul(r: *Self, s: *Self) Error!void {
+            switch (@typeInfo(T)) {
+                .Int => {
+                    r.multiplication(s.p, s.q) catch |err| switch (err) {
+                        error.Overflow => {
+                            r.reduce();
+                            s.reduce();
+                            try r.multiplication(s.p, s.q);
+                        },
+                        else => unreachable,
+                    };
+                },
+                .Float => {
+                    if (r.q > REDUCE or r.p > REDUCE) r.reduce();
+                    if (s.q > REDUCE or s.p > REDUCE) s.reduce();
+
+                    r.p *= s.p;
+                    r.q *= s.q;
+
+                    assert(std.math.modf(r.p).fpart == 0);
+                    assert(std.math.modf(r.q).fpart == 0);
+                },
+                else => unreachable,
+            }
+        }
+
+        /// Normalize the rational by reducing by the greatest common divisor.
+        pub fn reduce(r: *Self) void {
+            const d = gcd(r.p, r.q);
+            if (d == 1) return;
+
+            assert(@mod(r.p, d) == 0);
+            assert(@mod(r.q, d) == 0);
+
+            r.p /= d;
+            r.q /= d;
+
+            assert(r.p >= 1);
+            assert(r.q >= 1);
+        }
+
+        pub fn format(
+            self: Self,
+            comptime fmt: []const u8,
+            opts: std.fmt.FormatOptions,
+            writer: anytype,
+        ) !void {
+            _ = .{ fmt, opts };
+            try writer.print("{d}/{d}", .{ self.p, self.q });
+        }
+
+        inline fn multiplication(r: *Self, p: anytype, q: anytype) !void {
+            r.p = try std.math.mul(T, r.p, p);
+            r.q = try std.math.mul(T, r.q, q);
+        }
+
+        inline 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);
+
+            r.p = try std.math.add(T, n1, n2);
+            r.q = d;
+        }
+    };
+}
+
+// https://en.wikipedia.org/wiki/Euclidean_algorithm
+inline fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
+    assert(p >= 1);
+    assert(q >= 1);
+
+    var a = p;
+    var b = q;
+    var c: @TypeOf(p, q) = undefined;
+
+    while (b != 0) {
+        c = b;
+        b = @mod(a, b);
+        a = c;
+    }
+
+    assert(a > 0);
+    return a;
+}
+
+fn doTurn(r: anytype) !void {
+    try r.update(1, 163); // Metronome
+    try r.update(33, 256); // Critical Hit (67 Speed)
+    try r.update(1, 39); // Damage roll
+    try r.update(89, 128); // Thunder accuracy (178/256)
+    try r.update(77, 256); // Thunder secondary proc
+}
+
+test Rational {
+    inline for (.{ u64, u128, f64 }) |t| {
+        var r: Rational(t) = .{};
+
+        var c: t = 128;
+        try r.update(c, 256);
+        try doTurn(&r);
+
+        r.reduce();
+        try expectEqual(Rational(t){ .p = 75383, .q = 35550920704 }, r);
+
+        try r.update(1, 4);
+        if (t == u64) {
+            try expectError(error.Overflow, doTurn(&r));
+        } else {
+            try doTurn(&r);
+            r.reduce();
+            try expectEqual(Rational(t){ .p = 5682596689, .q = 2527735925804191711232 }, r);
+        }
+
+        r.reset();
+
+        var s = Rational(t){ .p = 10, .q = 13 };
+        try r.mul(&s);
+        s = Rational(t){ .p = 3, .q = 4 };
+        try r.mul(&s);
+        try expectEqual(Rational(t){ .p = 30, .q = 52 }, r);
+
+        s = Rational(t){ .p = 1, .q = 3 };
+        try r.add(&s);
+        r.reduce();
+        try expectEqual(Rational(t){ .p = 71, .q = 78 }, r);
+    }
+}
+
+/// Adapter of std.math.big.Rational to the engines Rational interface.
+pub const BigRational = struct {
+    /// The underlying rational number.
+    val: std.math.big.Rational,
+
+    /// Possible error returned by operations on the rational.
+    pub const Error = error{OutOfMemory};
+
+    /// Create a new BigRational wrapper.  A small amount of memory will be allocated on
+    /// initialization. Not default initialized to 1 - you must explicitly `reset` first.
+    pub fn init(alloc: std.mem.Allocator) !BigRational {
+        return BigRational{ .val = try std.math.big.Rational.init(alloc) };
+    }
+
+    /// Frees all memory associated with a rational.
+    pub fn deinit(r: *BigRational) void {
+        r.val.deinit();
+    }
+
+    /// Resets the rational back to 1.
+    pub fn reset(r: *BigRational) !void {
+        try r.val.setInt(1);
+    }
+
+    /// Update the rational by multiplying its numerator by p and its denominator by q.
+    /// Both p and q must be >= 1.
+    pub fn update(r: *BigRational, p: anytype, q: anytype) !void {
+        assert(p >= 1);
+        assert(q >= 1);
+
+        var s = try std.math.big.Rational.init(r.val.p.allocator);
+        defer s.deinit();
+        try s.setRatio(p, q);
+        try r.val.mul(r.val, s);
+    }
+
+    /// Adds two rationals.
+    pub fn add(r: *BigRational, s: *const BigRational) !void {
+        try r.val.add(r.val, s.val);
+    }
+
+    /// Multiplies two rationals.
+    pub fn mul(r: *BigRational, s: *const BigRational) !void {
+        try r.val.mul(r.val, s.val);
+    }
+};
+
+test BigRational {
+    var r = try BigRational.init(std.testing.allocator);
+    defer r.deinit();
+    var s = try std.math.big.Rational.init(std.testing.allocator);
+    defer s.deinit();
+
+    try r.reset();
+
+    var c: u8 = 128;
+    try r.update(c, 256);
+    try doTurn(&r);
+
+    try s.setRatio(75383, 35550920704);
+    try expect((try s.order(r.val)) == .eq);
+
+    try r.update(1, 4);
+    try doTurn(&r);
+
+    try s.setRatio(5682596689, 2527735925804191711232);
+    try expect((try s.order(r.val)) == .eq);
+
+    try r.reset();
+
+    var t = try BigRational.init(std.testing.allocator);
+    defer t.deinit();
+
+    try t.val.setRatio(10, 13);
+    try r.mul(&t);
+    try t.val.setRatio(3, 4);
+    try r.mul(&t);
+
+    try s.setRatio(15, 26);
+    try expect((try s.order(r.val)) == .eq);
+
+    try t.val.setRatio(1, 3);
+    try r.add(&t);
+
+    try s.setRatio(71, 78);
+    try expect((try s.order(r.val)) == .eq);
+}

package/src/lib/common/rng.zig

@@ -72,11 +72,11 @@ test PSRNG {
 // https://pkmn.cc/pokered/engine/battle/core.asm#L6644-L6693
 // https://pkmn.cc/pokecrystal/engine/battle/core.asm#L6922-L6938
 pub const Gen12 = extern struct {
-    seed: [10]u8,
+    seed: [9]u8,
     index: u8 = 0,
 
     comptime {
-        assert(@sizeOf(Gen12) == 11);
+        assert(@sizeOf(Gen12) == 10);
     }
 
     pub fn percent(p: u8) u8 {
@@ -86,14 +86,14 @@ pub const Gen12 = extern struct {
     pub fn next(self: *Gen12) u8 {
         const val = 5 *% self.seed[self.index] +% 1;
         self.seed[self.index] = val;
-        self.index = (self.index + 1) % 10;
+        self.index = (self.index + 1) % 9;
         return val;
     }
 };
 
 test Gen12 {
-    const expected = [_]u8{ 6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 31, 56, 81 };
-    var rng = Gen12{ .seed = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } };
+    const expected = [_]u8{ 6, 11, 16, 21, 26, 31, 36, 41, 46, 31, 56, 81 };
+    var rng = Gen12{ .seed = .{ 1, 2, 3, 4, 5, 6, 7, 8, 9 } };
     for (expected) |e| {
         try expectEqual(e, rng.next());
     }

package/src/lib/common/util.zig

@@ -0,0 +1,12 @@
+const std = @import("std");
+
+const expectEqual = std.testing.expectEqual;
+
+pub fn PointerType(comptime P: type, comptime C: type) type {
+    return if (@typeInfo(P).Pointer.is_const) *const C else *C;
+}
+
+test PointerType {
+    try expectEqual(*bool, PointerType(*u8, bool));
+    try expectEqual(*const f64, PointerType(*const i32, f64));
+}