@pkmn/engine 0.1.0-dev.d56bdadd → 0.1.0-dev.d73cd76c

package/src/lib/common/rng.zig

@@ -1,10 +1,8 @@
+const options = @import("options.zig");
 const std = @import("std");
 
-const options = @import("./options.zig");
-
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
-
 const showdown = options.showdown;
 
 pub fn PRNG(comptime gen: comptime_int) type {
@@ -66,6 +64,10 @@ 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 {
@@ -197,7 +199,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 +208,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 +239,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

@@ -1,12 +1,64 @@
 const std = @import("std");
 
+const expect = std.testing.expect;
 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;
+    const ptr_info = @typeInfo(P).pointer;
+    const is_const = if (@hasField(@TypeOf(ptr_info), "attrs"))
+        ptr_info.attrs.@"const"
+    else
+        ptr_info.is_const;
+    return if (is_const) *const C else *C;
 }
 
 test PointerType {
     try expectEqual(*bool, PointerType(*u8, bool));
     try expectEqual(*const f64, PointerType(*const i32, f64));
 }
+
+pub fn EnumFieldsLen(comptime E: type) usize {
+    const info = @typeInfo(E).@"enum";
+    return if (@hasField(@TypeOf(info), "fields"))
+        info.fields.len
+    else
+        info.field_names.len;
+}
+
+test EnumFieldsLen {
+    const E1 = enum { A, B, C };
+    const E2 = enum(u8) { A = 0, B = 10, C = 20, D = 30 };
+    try expectEqual(3, EnumFieldsLen(E1));
+    try expectEqual(4, EnumFieldsLen(E2));
+}
+
+pub fn isPointerTo(p: anytype, comptime P: type) bool {
+    const info = @typeInfo(@TypeOf(p));
+    return switch (info) {
+        .pointer => info.pointer.child == P,
+        else => false,
+    };
+}
+
+test isPointerTo {
+    const S = struct {};
+    const s: S = .{};
+    try expect(!isPointerTo(s, S));
+    try expect(isPointerTo(&s, S));
+}
+
+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;
+
+        var i: usize = 0;
+        while (i < n) : (i += 1) {
+            for (xs, 0..) |v, j| {
+                ts[i * xs.len + j] = v;
+            }
+        }
+
+        return ts;
+    }
+}