@pkmn/engine 0.1.0-dev.15f64810 → 0.1.0-dev.18478e7d

package/src/lib/common/rng.zig

@@ -1,10 +1,8 @@
-const std = @import("std");
-
 const options = @import("options.zig");
+const std = @import("std");
 
 const assert = std.debug.assert;
 const expectEqual = std.testing.expectEqual;
-
 const showdown = options.showdown;
 
 pub fn PRNG(comptime gen: comptime_int) type {
@@ -74,7 +72,7 @@ pub const PSRNG = extern struct {
 
 test PSRNG {
     var psrng: PSRNG = .{ .src = .{ .seed = 0x0001000200030004 } };
-    try expectEqual(121, psrng.range(u8, 0, 256));
+    try expectEqual(@as(u8, 121), psrng.range(u8, 0, 256));
     try expectEqual(false, psrng.chance(u8, 128, 256)); // 226 < 128
 }
 
@@ -111,9 +109,9 @@ test Gen12 {
         try expectEqual(e, rng.next());
     }
 
-    try expectEqual(16, Gen12.percent(6) + 1);
-    try expectEqual(16, Gen12.percent(7) - 1);
-    try expectEqual(128, Gen12.percent(50) + 1);
+    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);
 }
 
 // https://pkmn.cc/pokeemerald/src/random.c

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;
+    }
+}