@pkmn/engine 0.1.0-dev.83de29ee → 0.1.0-dev.8b83af6b

package/src/lib/binding/node.zig

@@ -34,8 +34,8 @@ fn bindings(env: c.napi_env) c.napi_value {
 }
 
 fn bind(env: c.napi_env, gen: anytype) c.napi_value {
-    const choices_size = @intCast(u32, gen.CHOICES_SIZE);
-    const logs_size = @intCast(u32, gen.LOGS_SIZE);
+    const choices_size: u32 = @intCast(gen.CHOICES_SIZE);
+    const logs_size: u32 = @intCast(gen.LOGS_SIZE);
     var object = Object.init(env);
     const properties = [_]c.napi_property_descriptor{
         Property.init("CHOICES_SIZE", .{ .value = Number.init(env, choices_size) }),
@@ -61,10 +61,9 @@ fn update(gen: anytype) c.napi_callback {
             assert(len == @sizeOf(gen.Battle(gen.PRNG)));
             assert(data != null);
 
-            var aligned = @alignCast(@alignOf(*gen.Battle(gen.PRNG)), data.?);
-            var battle = @ptrCast(*gen.Battle(gen.PRNG), aligned);
-            const c1 = @bitCast(pkmn.Choice, Number.get(env, argv[1], u8));
-            const c2 = @bitCast(pkmn.Choice, Number.get(env, argv[2], u8));
+            var battle: *gen.Battle(gen.PRNG) = @alignCast(@ptrCast(data.?));
+            const c1: pkmn.Choice = @bitCast(Number.get(env, argv[1], u8));
+            const c2: pkmn.Choice = @bitCast(Number.get(env, argv[2], u8));
 
             var vtype: c.napi_valuetype = undefined;
             assert(c.napi_typeof(env, argv[3], &vtype) == c.napi_ok);
@@ -75,14 +74,14 @@ fn update(gen: anytype) c.napi_callback {
                     assert(len == gen.LOGS_SIZE);
                     assert(data != null);
 
-                    var buf = @ptrCast([*]u8, data.?)[0..gen.LOGS_SIZE];
+                    var buf = @as([*]u8, @ptrCast(data.?))[0..gen.LOGS_SIZE];
                     var stream = pkmn.protocol.ByteStream{ .buffer = buf };
                     var log = pkmn.protocol.FixedLog{ .writer = stream.writer() };
                     break :result battle.update(c1, c2, log);
                 },
             } catch unreachable;
 
-            return Number.init(env, @bitCast(u8, result));
+            return Number.init(env, @as(u8, @bitCast(result)));
         }
     }.call;
 }
@@ -101,19 +100,17 @@ fn choices(gen: anytype) c.napi_callback {
             assert(len == @sizeOf(gen.Battle(gen.PRNG)));
             assert(data != null);
 
-            var aligned = @alignCast(@alignOf(*gen.Battle(gen.PRNG)), data.?);
-            var battle = @ptrCast(*gen.Battle(gen.PRNG), aligned);
-
-            const player = @intToEnum(pkmn.Player, Number.get(env, argv[1], u8));
-            const request = @intToEnum(pkmn.Choice.Type, Number.get(env, argv[2], u8));
+            var battle: *gen.Battle(gen.PRNG) = @alignCast(@ptrCast(data.?));
+            const player: pkmn.Player = @enumFromInt(Number.get(env, argv[1], u8));
+            const request: pkmn.Choice.Type = @enumFromInt(Number.get(env, argv[2], u8));
 
             assert(c.napi_get_arraybuffer_info(env, argv[3], &data, &len) == c.napi_ok);
             assert(len == gen.CHOICES_SIZE);
             assert(data != null);
 
-            var out = @ptrCast([*]pkmn.Choice, data.?)[0..gen.CHOICES_SIZE];
+            var out = @as([*]pkmn.Choice, @ptrCast(data.?))[0..gen.CHOICES_SIZE];
             const n = battle.choices(player, request, out);
-            return Number.init(env, @bitCast(u8, n));
+            return Number.init(env, @as(u8, @bitCast(n)));
         }
     }.call;
 }
@@ -166,25 +163,25 @@ const Number = struct {
                     .signed => {
                         var result: i32 = undefined;
                         assert(c.napi_get_value_int32(env, value, &result) == c.napi_ok);
-                        return if (info.bits == 32) result else @intCast(T, result);
+                        return if (info.bits == 32) result else @intCast(result);
                     },
                     .unsigned => {
                         var result: u32 = undefined;
                         assert(c.napi_get_value_uint32(env, value, &result) == c.napi_ok);
-                        return if (info.bits == 32) result else @intCast(T, result);
+                        return if (info.bits == 32) result else @intCast(result);
                     },
                 },
                 33...63 => {
                     var result: i64 = undefined;
                     assert(c.napi_get_value_int64(env, value, &result) == c.napi_ok);
-                    return @intCast(T, result);
+                    return @intCast(result);
                 },
                 else => {
                     var result: i64 = undefined;
                     assert(c.napi_get_value_int64(env, value, &result) == c.napi_ok);
                     return switch (info.signedness) {
-                        .signed => @as(T, value),
-                        .unsigned => if (0 <= value) @intCast(T, value) else unreachable,
+                        .signed => value,
+                        .unsigned => if (0 <= value) @intCast(value) else unreachable,
                     };
                 },
             },

package/src/lib/binding/wasm.zig

@@ -5,6 +5,6 @@ export const SHOWDOWN = pkmn.options.showdown;
 export const LOG = pkmn.options.log;
 
 export const GEN1_CHOICES_SIZE =
-    std.math.ceilPowerOfTwo(u32, @intCast(u32, pkmn.gen1.CHOICES_SIZE)) catch unreachable;
+    std.math.ceilPowerOfTwo(u32, @as(u32, @intCast(pkmn.gen1.CHOICES_SIZE))) catch unreachable;
 export const GEN1_LOGS_SIZE =
-    std.math.ceilPowerOfTwo(u32, @intCast(u32, pkmn.gen1.LOGS_SIZE)) catch unreachable;
+    std.math.ceilPowerOfTwo(u32, @as(u32, @intCast(pkmn.gen1.LOGS_SIZE))) catch unreachable;

package/src/lib/common/data.zig

@@ -10,7 +10,7 @@ pub const Player = enum(u1) {
 
     /// Returns a player's opponent.
     pub inline fn foe(self: Player) Player {
-        return @intToEnum(Player, ~@enumToInt(self));
+        return @enumFromInt(~@intFromEnum(self));
     }
 
     /// Return's an identifier for the player's Pokémon at the one-indexed `id`.
@@ -22,8 +22,8 @@ pub const Player = enum(u1) {
 
 test Player {
     try expectEqual(Player.P2, Player.P1.foe());
-    try expectEqual(@as(u8, 0b0001), @bitCast(u8, Player.P1.ident(1)));
-    try expectEqual(@as(u8, 0b1101), @bitCast(u8, Player.P2.ident(5)));
+    try expectEqual(@as(u8, 0b0001), @as(u8, @bitCast(Player.P1.ident(1))));
+    try expectEqual(@as(u8, 0b1101), @as(u8, @bitCast(Player.P2.ident(5))));
 }
 
 /// An identifier for a specific Pokémon in battle.
@@ -40,18 +40,18 @@ pub const ID = packed struct {
 
     /// Converts the identifier into a number.
     pub inline fn int(self: ID) u4 {
-        return @intCast(u4, @bitCast(u8, self));
+        return @intCast(@as(u8, @bitCast(self)));
     }
 
     /// Decodes the identifier from a number.
     pub inline fn from(id: u4) ID {
-        return @bitCast(ID, @as(u8, id));
+        return @bitCast(@as(u8, id));
     }
 };
 
 test ID {
-    try expectEqual(@as(u8, 0b0001), @bitCast(u8, ID{ .player = .P1, .id = 1 }));
-    try expectEqual(@as(u8, 0b1101), @bitCast(u8, ID{ .player = .P2, .id = 5 }));
+    try expectEqual(@as(u8, 0b0001), @as(u8, @bitCast(ID{ .player = .P1, .id = 1 })));
+    try expectEqual(@as(u8, 0b1101), @as(u8, @bitCast(ID{ .player = .P2, .id = 5 })));
     const id = ID{ .player = .P2, .id = 4 };
     try expectEqual(id, ID.from(id.int()));
 }
@@ -84,8 +84,8 @@ test Choice {
     const p2: Choice = .{ .type = .Switch, .data = 5 };
     try expectEqual(5, p2.data);
     try expectEqual(Choice.Type.Move, p1.type);
-    try expectEqual(0b0001_0001, @bitCast(u8, p1));
-    try expectEqual(0b0001_0110, @bitCast(u8, p2));
+    try expectEqual(0b0001_0001, @as(u8, @bitCast(p1)));
+    try expectEqual(0b0001_0110, @as(u8, @bitCast(p2)));
 }
 
 /// The result of the battle - all results other than 'None' should be considered terminal.
@@ -124,6 +124,6 @@ pub const Result = packed struct {
 };
 
 test Result {
-    try expectEqual(0b0101_0000, @bitCast(u8, Result.Default));
-    try expectEqual(0b1000_0000, @bitCast(u8, Result{ .p2 = .Switch }));
+    try expectEqual(0b0101_0000, @as(u8, @bitCast(Result.Default)));
+    try expectEqual(0b1000_0000, @as(u8, @bitCast(Result{ .p2 = .Switch })));
 }