@pkmn/engine 0.1.0-dev.207fa86a → 0.1.0-dev.2c13d3ec

package/src/lib/common/debug.zig

@@ -0,0 +1,74 @@
+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;
+        if (@TypeOf(@src()) == @TypeOf(value)) {
+            stderr.print("{s} ({s}:{d}:{d})", .{
+                value.fn_name,
+                value.file,
+                value.line,
+                value.column,
+            }) catch return;
+        } else {
+            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);
+                },
+            },
+            .Optional => stderr.print("{?}", .{value}) catch return,
+            else => stderr.print("{}", .{value}) catch return,
+        }
+    }
+}

package/src/lib/common/options.zig

@@ -1,21 +1,30 @@
 const build_options = @import("build_options");
 const root = @import("root");
 
+/// Configures the behavior of the pkmn package.
 pub const Options = struct {
     showdown: ?bool = null,
-    trace: ?bool = null,
+    log: ?bool = null,
+    chance: ?bool = null,
+    calc: ?bool = null,
     advance: ?bool = null,
     ebc: ?bool = null,
+    key: ?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);
+/// Whether or not protocol message logging is enabled.
+pub const log = get("log", false);
+/// Whether or not update probability tracking is enabled.
+pub const chance = get("chance", false);
+/// Whether or not damage calculator support is enabled.
+pub const calc = get("calc", false);
 
 pub const advance = get("advance", true);
 pub const ebc = get("ebc", true);
+pub const key = get("key", false);
 pub const internal = get("internal", false);
 
 fn get(comptime name: []const u8, default: bool) bool {