@kradle/challenges-sdk 0.25.0 → 0.26.1

package/dist/runtime/reducer.js

@@ -6,6 +6,7 @@ exports.parseBlockState = parseBlockState;
 exports.blockSpecString = blockSpecString;
 exports.splitBatches = splitBatches;
 exports.createReducer = createReducer;
+const commands_js_1 = require("./commands.js");
 const dimensions_js_1 = require("./dimensions.js");
 // The reducer: one locked definition, one `init()` per run, one `reduce(state,
 // event)` per engine event. Everything a rule sees comes through a context
@@ -375,6 +376,7 @@ function createReducer(def) {
         every: {},
         timers: {},
         nextGen: 0,
+        commandAccess: {},
         players: {},
         game: {},
         votes: Object.fromEntries(voteIds.map((id) => [id, { open: false, round: 0, cast: {} }])),
@@ -1887,6 +1889,10 @@ function createReducer(def) {
                     return;
                 }
                 const missing = missingCapabilities(e.capabilities);
+                if (def.customCommands.length)
+                    for (const c of ["custom_commands_v1", "agent_commands_v1"])
+                        if (!e.capabilities.includes(c))
+                            missing.push(c);
                 if (dimensions.length > 1 && !e.capabilities.includes("dimensions"))
                     missing.push("dimensions");
                 if (def.setup && !e.capabilities.includes("batch"))
@@ -2349,6 +2355,9 @@ function createReducer(def) {
                 });
                 break;
             }
+            case "challenge_command":
+                customCommand(r, e);
+                break;
             case "custom": {
                 if (!playing())
                     return;
@@ -2357,6 +2366,67 @@ function createReducer(def) {
             }
         }
     }
+    function commandAvailable(r, command, player) {
+        return (r.s.status === "PLAYING" &&
+            player.connected &&
+            (!command.available ||
+                run(r, "pure", command.available, ctxOf(r, "read"), playerView(r, player, false)) === true));
+    }
+    function publishCommandAccess(r) {
+        if (!def.customCommands.length)
+            return;
+        const access = {};
+        if (r.s.status === "PLAYING")
+            for (const p of Object.values(r.s.players)) {
+                if (p.connected)
+                    access[p.name] = def.customCommands.filter((c) => commandAvailable(r, c, p)).map((c) => c.schema.name);
+            }
+        if (JSON.stringify(access) !== JSON.stringify(r.s.commandAccess)) {
+            r.s.commandAccess = access;
+            r.actions.push({ type: "command_access", players: snapshot(access) });
+        }
+    }
+    function customCommand(r, e) {
+        const reject = (reason) => r.actions.push({ type: "command_decision", requestId: e.requestId, origin: e.origin, accepted: false, reason });
+        const p = r.s.players[e.player];
+        const command = def.customCommands.find((c) => c.schema.name === e.command);
+        if (!p || (e.uuid !== undefined && e.uuid !== p.uuid) || !command || !commandAvailable(r, command, p)) {
+            reject("The command is not available.");
+            return;
+        }
+        if (!e.args ||
+            typeof e.args !== "object" ||
+            Array.isArray(e.args) ||
+            Object.keys(e.args).some((k) => !command.schema.args.some((a) => a.name === k))) {
+            reject("Invalid command arguments.");
+            return;
+        }
+        const args = {};
+        for (const a of command.schema.args) {
+            const value = Object.hasOwn(e.args, a.name) ? e.args[a.name] : a.default;
+            if (value === undefined && a.optional) {
+                args[a.name] = undefined;
+                continue;
+            }
+            if (!(0, commands_js_1.validCommandValue)(a, value)) {
+                reject("Invalid command arguments.");
+                return;
+            }
+            if (a.type === "player") {
+                const target = r.s.players[value];
+                if (!target?.connected) {
+                    reject("Select a connected participant.");
+                    return;
+                }
+                args[a.name] = viewOf(r, target);
+            }
+            else
+                args[a.name] = value;
+        }
+        run(r, "handler", command.run, ctxOf(r, "full"), { player: viewOf(r, p), args: Object.freeze(args) });
+        resolvePhaseRequest(r);
+        r.actions.push({ type: "command_decision", requestId: e.requestId, origin: e.origin, accepted: true });
+    }
     function voteAttempt(r, e) {
         const s = r.s;
         const p = s.players[e.name];
@@ -2450,6 +2520,7 @@ function createReducer(def) {
                 checkpoint(r);
             if (r.req.end)
                 finalize(r);
+            publishCommandAccess(r);
             assertJson({ game: r.s.game, players: Object.fromEntries(Object.values(r.s.players).map((p) => [p.name, p.state])) }, "state");
         }
         catch (err) {
@@ -2459,6 +2530,10 @@ function createReducer(def) {
             r = { ...r, s: clone(input), actions: [], batch: null, req: { phase: null, end: null, budget: 0 } };
             if (event.type === "tick")
                 r.s.tick = event.serverTick;
+            if (def.customCommands.length) {
+                r.s.commandAccess = {};
+                r.actions.push({ type: "command_access", players: {} });
+            }
             const detail = err instanceof errors_js_1.ChallengeError ? err.toJSON() : { message: String(err?.message ?? err) };
             failRun(r.s, r.actions, "error_challenge", `challenge error on ${event.type}: ${err.message}`, {
                 event: event,