@pkmn/engine 0.1.0-dev.d716e940 → 0.1.0-dev.d952b7c9

package/src/lib/common/rational.zig

@@ -0,0 +1,447 @@
+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;
+
+const Int = if (@hasField(std.builtin.Type, "int")) .int else .Int;
+const Float = if (@hasField(std.builtin.Type, "float")) .float else .Float;
+const ComptimeInt =
+    if (@hasField(std.builtin.Type, "comptime_int")) .comptime_int else .ComptimeInt;
+const ComptimeFloat =
+    if (@hasField(std.builtin.Type, "comptime_float")) .comptime_float else .ComptimeFloat;
+
+/// 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 {
+            // std.debug.print("({d}/{d}) * ", .{ p, q }); // DEBUG
+            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 });
+        }
+
+        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);
+        }
+
+        fn addition(r: *Self, p: anytype, q: anytype) !void {
+            // (a/b) + (c/d) = (ad+bc)/(bd)
+            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;
+        }
+    };
+}
+
+fn gcd(p: anytype, q: anytype) @TypeOf(p, q) {
+    assert(p >= 1);
+    assert(q >= 1);
+
+    // convert comptime_int to a sized integer within this function so that @ctz will work
+    const T = switch (@TypeOf(p, q)) {
+        comptime_int => std.math.IntFittingRange(@min(p, q), @max(p, q)),
+        else => |U| U,
+    };
+
+    switch (@typeInfo(T)) {
+        Int => {
+            // std.math.gcd but without some checks because we have a stricter range
+            var x: T = @intCast(p);
+            var y: T = @intCast(q);
+
+            const xz = @ctz(x);
+            const yz = @ctz(y);
+            const shift = @min(xz, yz);
+            x >>= @intCast(xz);
+            y >>= @intCast(yz);
+
+            var diff = y -% x;
+            while (diff != 0) : (diff = y -% x) {
+                const zeros = @ctz(diff);
+                if (x > y) diff = -%diff;
+                y = @min(x, y);
+                x = diff >> @intCast(zeros);
+            }
+
+            const result = y << @intCast(shift);
+            assert(result > 0);
+            return result;
+        },
+        else => {
+            var a = p;
+            var b = q;
+            var c: T = undefined;
+
+            while (b != 0) {
+                c = b;
+                b = @mod(a, b);
+                a = c;
+            }
+
+            assert(a > 0);
+            return a;
+        },
+    }
+}
+
+test gcd {
+    const seed = if (@hasDecl(std.testing, "random_seed")) std.testing.random_seed else 0x12345678;
+    var prng = (if (@hasDecl(std, "Random")) std.Random else std.rand).DefaultPrng.init(seed);
+    var random = prng.random();
+
+    for (0..1000) |_| {
+        const a = random.int(u32);
+        const b = random.int(u32);
+        if (a == 0 or b == 0) continue;
+
+        try expectEqual(
+            gcd(a, b),
+            @as(u32, @intFromFloat(gcd(@as(f64, @floatFromInt(a)), @as(f64, @floatFromInt(b))))),
+        );
+    }
+
+    try expectEqual(gcd(300_000, @as(u32, 2_300_000)), 100_000); // NB: @ctz requires an @intCast
+}
+
+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;
+        _ = &c;
+
+        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 .{ .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;
+    _ = &c;
+
+    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);
+}
+
+test "minimum" {
+    // TODO: ziglang/zig#21069
+    if (builtin.mode == .ReleaseFast or builtin.mode == .ReleaseSmall) {
+        return error.SkipZigTest;
+    }
+    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();
+
+    try r.update(1, 2); // Speed Tie
+    for (0..2) |_| {
+        try r.update(1, 2); // Confusion
+        try r.update(1, 2); // Infatuation
+        try r.update(3, 4); // Paralysis
+        // Population Bomb
+        for (0..10) |_| {
+            try r.update(9, 10); // Accuracy
+            try r.update(1, 15); // Damage roll
+            try r.update(1, 24); // Critical Hit
+            try r.update(9, 10); // King's Rock non-proc
+        }
+    }
+
+    const ZEROS = std.math.pow(u310, 10, 31);
+    const n = 36472996377170786403;
+    const d: u310 = 146267071761884981524886149560653378220687632500762654519853056 * ZEROS;
+    try s.setRatio(n, d);
+    try expect((try s.order(r.val)) == .eq);
+}

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;
@@ -25,6 +25,11 @@ pub fn PRNG(comptime gen: comptime_int) type {
         pub fn next(self: *Self) Output(gen) {
             return self.src.next();
         }
+
+        pub fn advance(self: *Self, n: usize) void {
+            if (!options.advance) return;
+            for (0..n) |_| self.src.advance();
+        }
     };
 }
 
@@ -47,7 +52,7 @@ pub const PSRNG = extern struct {
     }
 
     pub fn range(self: *PSRNG, comptime T: type, from: T, to: Bound(T)) T {
-        return @intCast(T, @as(u64, self.src.next()) * (to - from) / divisor + from);
+        return @intCast(@as(u64, self.src.next()) * (to - from) / divisor + from);
     }
 
     pub fn chance(self: *PSRNG, comptime T: type, numerator: T, denominator: Bound(T)) bool {
@@ -61,10 +66,14 @@ 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 } };
+    var psrng: PSRNG = .{ .src = .{ .seed = 0x0001000200030004 } };
     try expectEqual(@as(u8, 121), psrng.range(u8, 0, 256));
     try expectEqual(false, psrng.chance(u8, 128, 256)); // 226 < 128
 }
@@ -72,28 +81,32 @@ 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 {
-        return @intCast(u8, (@as(u16, p) * 0xFF) / 100);
+    pub fn percent(comptime p: comptime_int) u8 {
+        return @intCast((@as(u16, p) * 0xFF) / 100);
     }
 
     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;
     }
+
+    pub fn advance(self: *Gen12) void {
+        _ = self.next();
+    }
 };
 
 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());
     }
@@ -114,7 +127,7 @@ pub const Gen34 = extern struct {
 
     pub fn next(self: *Gen34) u16 {
         self.advance();
-        return @intCast(u16, self.seed >> 16);
+        return @intCast(self.seed >> 16);
     }
 
     pub fn advance(self: *Gen34) void {
@@ -129,7 +142,7 @@ test Gen34 {
         .{ 0x80000000, 5, 0x0E425287 }, .{ 0x80000000, 10, 0x6F2CF4B2 },
     };
     for (data) |d| {
-        var rng = Gen34{ .seed = d[0] };
+        var rng: Gen34 = .{ .seed = d[0] };
         for (0..d[1]) |_| _ = rng.next();
         try expectEqual(d[2], rng.seed);
     }
@@ -144,7 +157,7 @@ pub const Gen56 = extern struct {
 
     pub fn next(self: *Gen56) u32 {
         self.advance();
-        return @intCast(u32, self.seed >> 32);
+        return @intCast(self.seed >> 32);
     }
 
     pub fn advance(self: *Gen56) void {
@@ -161,7 +174,7 @@ test Gen56 {
         .{ 0x8000000000000000, 10, 0xE7795501267F125A },
     };
     for (data) |d| {
-        var rng = Gen56{ .seed = d[0] };
+        var rng: Gen56 = .{ .seed = d[0] };
         for (0..d[1]) |_| _ = rng.next();
         try expectEqual(d[2], rng.seed);
     }
@@ -188,16 +201,16 @@ 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(T, @as(u64, self.next()) * (to - from) / divisor + from);
+            return @intCast(@as(u64, self.next()) * (to - from) / divisor + from);
         }
 
         pub fn chance(
             self: *Self,
             comptime T: type,
             numerator: T,
-            denominator: Bound(T),
+            denominator: PSRNG.Bound(T),
         ) bool {
             assert(showdown);
             assert(denominator > 0);
@@ -213,7 +226,7 @@ pub fn FixedRNG(comptime gen: comptime_int, comptime len: usize) type {
 test FixedRNG {
     const Type = if (showdown) u32 else u8;
     const expected = [_]Type{ 42, 255, 0 };
-    var rng = FixedRNG(1, expected.len){ .rolls = expected };
+    var rng: FixedRNG(1, expected.len) = .{ .rolls = expected };
     for (expected) |e| {
         try expectEqual(e, rng.next());
     }
@@ -228,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/common/util.zig

@@ -0,0 +1,61 @@
+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;
+}
+
+test PointerType {
+    try expectEqual(*bool, PointerType(*u8, bool));
+    try expectEqual(*const f64, PointerType(*const i32, f64));
+}
+
+pub fn isPointerTo(p: anytype, comptime P: type) bool {
+    const info = @typeInfo(@TypeOf(p));
+    return switch (info) {
+        Pointer => @field(info, @tagName(Pointer)).child == P,
+        else => false,
+    };
+}
+
+test isPointerTo {
+    const S = struct {};
+    const s: S = .{};
+    try expect(!isPointerTo(s, S));
+    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));
+}
+
+fn BytesAsValueReturnType(comptime T: type, comptime B: type) type {
+    return CopyPtrAttrs(B, .One, T);
+}
+
+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 = .{
+        .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 });
+}