@pkmn/engine 0.1.0-dev.02b7f810

package/src/lib/common/data.zig

@@ -0,0 +1,129 @@
+const std = @import("std");
+
+const assert = std.debug.assert;
+const expectEqual = std.testing.expectEqual;
+
+/// Representation of one of the battle's participants.
+pub const Player = enum(u1) {
+    P1,
+    P2,
+
+    /// Returns a player's opponent.
+    pub inline fn foe(self: Player) Player {
+        return @intToEnum(Player, ~@enumToInt(self));
+    }
+
+    /// Return's an identifier for the player's Pokémon at the one-indexed `id`.
+    pub inline fn ident(self: Player, id: u3) ID {
+        assert(id > 0 and id <= 6);
+        return .{ .id = id, .player = self };
+    }
+};
+
+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)));
+}
+
+/// An identifier for a specific Pokémon in battle.
+pub const ID = packed struct {
+    /// The one-indexed team slot of the Pokémon
+    id: u3 = 0,
+    /// The Pokémon's trainer.
+    player: Player = .P1,
+    _: u4 = 0,
+
+    comptime {
+        assert(@sizeOf(ID) == 1);
+    }
+
+    /// Converts the identifier into a number.
+    pub inline fn int(self: ID) u4 {
+        return @intCast(u4, @bitCast(u8, self));
+    }
+
+    /// Decodes the identifier from a number.
+    pub inline fn from(id: u4) ID {
+        return @bitCast(ID, @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 }));
+    const id = ID{ .player = .P2, .id = 4 };
+    try expectEqual(id, ID.from(id.int()));
+}
+
+/// A choice made by a player during battle.
+pub const Choice = packed struct {
+    /// The choice type.
+    type: Choice.Type = .Pass,
+    /// The choice data:
+    ///
+    ///  - 0 for 'pass'
+    ///  - 0-4 for 'move'
+    ///  - 2-6 for 'switch'
+    data: u6 = 0,
+
+    /// All valid choice types.
+    pub const Type = enum(u2) {
+        Pass,
+        Move,
+        Switch,
+    };
+
+    comptime {
+        assert(@sizeOf(Choice) == 1);
+    }
+};
+
+test Choice {
+    const p1: Choice = .{ .type = .Move, .data = 4 };
+    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));
+}
+
+/// The result of the battle - all results other than 'None' should be considered terminal.
+pub const Result = packed struct {
+    /// The type of result from the perspective of Player 1.
+    /// `Error` is not possible when in Pokémon Showdown compatibility mode.
+    type: Result.Type = .None,
+    /// The choice type of the result for Player 1.
+    p1: Choice.Type = .Pass,
+    /// The choice type of the result for Player 2.
+    p2: Choice.Type = .Pass,
+
+    /// All valid result types.
+    pub const Type = enum(u4) {
+        None,
+        Win,
+        Lose,
+        Tie,
+        Error, // Desync, EBC, etc.
+    };
+
+    /// The Tie result.
+    pub const Tie: Result = .{ .type = .Tie };
+    /// The Win result.
+    pub const Win: Result = .{ .type = .Win };
+    /// The Lost result.
+    pub const Lose: Result = .{ .type = .Lose };
+    /// The Error result.
+    pub const Error: Result = .{ .type = .Error };
+    /// The default result.
+    pub const Default: Result = .{ .p1 = .Move, .p2 = .Move };
+
+    comptime {
+        assert(@sizeOf(Result) == 1);
+    }
+};
+
+test Result {
+    try expectEqual(0b0101_0000, @bitCast(u8, Result.Default));
+    try expectEqual(0b1000_0000, @bitCast(u8, Result{ .p2 = .Switch }));
+}

package/src/lib/common/debug.zig

@@ -0,0 +1,64 @@
+const std = @import("std");
+
+const debug = std.debug;
+const io = std.io;
+
+pub fn print(value: anytype) void {
+    debug.getStderrMutex().lock();
+    defer debug.getStderrMutex().unlock();
+    const stderr = io.getStdErr().writer();
+
+    nosuspend {
+        stderr.writeAll("\x1b[41m") catch return;
+        switch (@typeInfo(@TypeOf(value))) {
+            .Struct => |info| {
+                if (info.is_tuple) {
+                    inline for (info.fields, 0..) |f, i| {
+                        inspect(@field(value, f.name));
+                        if (i < info.fields.len - 1) stderr.writeAll(" ") catch return;
+                    }
+                } else {
+                    inspect(value);
+                }
+            },
+            else => inspect(value),
+        }
+        stderr.writeAll("\x1b[K\x1b[0m\n") catch return;
+    }
+}
+
+fn inspect(value: anytype) void {
+    const stderr = io.getStdErr().writer();
+
+    nosuspend {
+        const err = "Unable to format type '" ++ @typeName(@TypeOf(value)) ++ "'";
+        switch (@typeInfo(@TypeOf(value))) {
+            .Array => |info| {
+                if (info.child == u8) return stderr.print("{s}", .{value}) catch return;
+                @compileError(err);
+            },
+            .Pointer => |ptr_info| switch (ptr_info.size) {
+                .One => switch (@typeInfo(ptr_info.child)) {
+                    .Array => |info| {
+                        if (info.child == u8) return stderr.print("{s}", .{value}) catch return;
+                        @compileError(err);
+                    },
+                    .Enum, .Union, .Struct => return inspect(value.*),
+                    else => @compileError(err),
+                },
+                .Many, .C => {
+                    if (ptr_info.sentinel) |_| return inspect(std.mem.span(value));
+                    if (ptr_info.child == u8) {
+                        return stderr.print("{s}", .{std.mem.span(value)}) catch return;
+                    }
+                    @compileError(err);
+                },
+                .Slice => {
+                    if (ptr_info.child == u8) return stderr.print("{s}", .{value}) catch return;
+                    @compileError(err);
+                },
+            },
+            else => stderr.print("{}", .{value}) catch return,
+        }
+    }
+}

package/src/lib/common/options.zig

@@ -0,0 +1,40 @@
+const build_options = @import("build_options");
+const root = @import("root");
+
+pub const Options = struct {
+    showdown: ?bool = null,
+    trace: ?bool = null,
+    advance: ?bool = null,
+    ebc: ?bool = null,
+    internal: ?bool = null,
+};
+
+/// Whether or not Pokémon Showdown compatibility mode is enabled.
+pub const showdown = get("showdown", false);
+/// Whether or not protocol trace logging is enabled.
+pub const trace = get("trace", false);
+
+pub const advance = get("advance", true);
+pub const ebc = get("ebc", true);
+pub const internal = get("internal", false);
+
+fn get(comptime name: []const u8, default: bool) bool {
+    var build_enable: ?bool = null;
+    var root_enable: ?bool = null;
+
+    if (@hasDecl(root, "pkmn_options")) {
+        root_enable = @field(@as(Options, root.pkmn_options), name);
+    }
+    if (@hasDecl(build_options, name)) {
+        build_enable = @as(?bool, @field(build_options, name));
+    }
+    if (build_enable != null and root_enable != null) {
+        if (build_enable.? != root_enable.?) {
+            const r = name ++ " (" ++ (if (root_enable.?) "false" else "true") ++ ")";
+            const b = name ++ " (" ++ (if (build_enable.?) "false" else "true") ++ ")";
+            @compileError("root decl pkmn_options." ++ r ++ " != build option " ++ b ++ ".");
+        }
+    }
+
+    return root_enable orelse (build_enable orelse default);
+}