@kradle/challenges-sdk 0.23.0 → 0.24.0

package/dist/runtime/reducer.js

@@ -1,4 +1,12 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_ACHIEVEMENTS = exports.MAX_TRANSITIONS_PER_EVENT = exports.MAX_FILL_VOLUME = exports.MAX_BATCH_EFFECTS = void 0;
+exports.assertJson = assertJson;
+exports.parseBlockState = parseBlockState;
+exports.blockSpecString = blockSpecString;
+exports.splitBatches = splitBatches;
+exports.createReducer = createReducer;
+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
 // built for the reduction; everything a rule asks for leaves as actions.
@@ -15,15 +23,8 @@
 //   the game-over hook, the judge data, `game_over`.
 // - An author error rolls the reduction back and ends the run as
 //   `error_challenge` without another author callback.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_ACHIEVEMENTS = exports.MAX_TRANSITIONS_PER_EVENT = exports.MAX_FILL_VOLUME = exports.MAX_BATCH_EFFECTS = void 0;
-exports.assertJson = assertJson;
-exports.parseBlockState = parseBlockState;
-exports.blockSpecString = blockSpecString;
-exports.splitBatches = splitBatches;
-exports.createReducer = createReducer;
-const dialog_js_1 = require("./dialog.js");
 const chat_js_1 = require("./chat.js");
+const dialog_js_1 = require("./dialog.js");
 const errors_js_1 = require("./errors.js");
 const time_js_1 = require("./time.js");
 const types_js_1 = require("./types.js");
@@ -103,7 +104,7 @@ function deepFreeze(value, seen = new WeakSet()) {
     for (const x of Object.values(value))
         deepFreeze(x, seen);
 }
-const posKey = (at) => `${Math.floor(at.x)},${Math.floor(at.y)},${Math.floor(at.z)}`;
+const posKey = dimensions_js_1.positionKey;
 /** `minecraft:oak_stairs[facing=east,half=bottom]` -> `{ id, props }`. */
 function parseBlockState(state) {
     const i = state.indexOf("[");
@@ -338,6 +339,7 @@ function viewOf(r, p) {
 }
 function createReducer(def) {
     const config = def.config;
+    const dimensions = (0, dimensions_js_1.enabledDimensions)(config.challengeConfig?.dimensions);
     const roleNames = Object.keys(config.roles);
     const declaredZones = Object.keys(def.zones);
     const derivedScores = def.outcome.scores !== undefined;
@@ -488,6 +490,21 @@ function createReducer(def) {
             }
         };
         const push = (raw) => {
+            for (const value of [
+                raw,
+                ...["at", "from", "to", "dest"].map((key) => raw[key]),
+            ]) {
+                if (value &&
+                    typeof value === "object" &&
+                    "dimension" in value &&
+                    value.dimension !== undefined &&
+                    !dimensions.includes(value.dimension))
+                    throw (0, errors_js_1.apiError)("invalid_value", "The target dimension is disabled");
+            }
+            if (raw.kind === "fill" || raw.kind === "clone")
+                (0, world_js_1.bounds)({ from: raw.from, to: raw.to });
+            if (raw.kind === "clone" && (0, dimensions_js_1.dimensionOf)(raw.from) !== (0, dimensions_js_1.dimensionOf)(raw.dest))
+                throw (0, errors_js_1.apiError)("invalid_value", "A clone cannot cross dimensions");
             // A plain copy: an author's argument may be a view (`p.pos`, `g.params.box`).
             const effect = compact(snapshot(raw));
             if (r.batch)
@@ -580,6 +597,7 @@ function createReducer(def) {
                         throw (0, errors_js_1.notDeclared)("zones", zone, declaredZones);
                     return p.zones.includes(zone);
                 }
+                (0, world_js_1.bounds)(zone);
                 return p.pos !== null && (0, world_js_1.inBox)(p.pos, zone);
             },
             countItems(p, match) {
@@ -617,6 +635,7 @@ function createReducer(def) {
             get worldTime() {
                 return s.world.time;
             },
+            dimensionTime: (dimension) => (dimension === dimensions_js_1.OVERWORLD ? s.world.time : s.world.times?.[dimension]),
             entities: (filter) => (0, world_js_1.entitiesIn)(s.world, filter).map(world_js_1.freezeObservation),
             entity(id) {
                 const e = s.world.entities[id];
@@ -826,17 +845,17 @@ function createReducer(def) {
                 write("summon");
                 push({ kind: "summon", entity, at: { ...at }, nbt: opts?.nbt });
             },
-            killEntities(entities) {
+            killEntities(entities, dimension) {
                 write("killEntities");
-                push({ kind: "kill_entities", entities });
+                push({ kind: "kill_entities", entities, dimension });
             },
-            time(value) {
+            time(value, dimension) {
                 write("time");
-                push({ kind: "time", value });
+                push({ kind: "time", value, dimension });
             },
-            gamerule(rule, value) {
+            gamerule(rule, value, dimension) {
                 write("gamerule");
-                push({ kind: "gamerule", rule, value });
+                push({ kind: "gamerule", rule, value, dimension });
             },
             setSpawn(at) {
                 write("setSpawn");
@@ -846,6 +865,7 @@ function createReducer(def) {
                 write("worldBorder");
                 push({
                     kind: "worldborder",
+                    dimension: opts.dimension,
                     center: opts.center,
                     size: opts.size,
                     seconds: opts.over === undefined ? undefined : (0, time_js_1.toTicks)(opts.over) / 20,
@@ -866,11 +886,11 @@ function createReducer(def) {
                     }));
                 push({ kind: "container", at: { ...at }, items: out });
             },
-            command(cmd, name) {
+            command(cmd, name, dimension) {
                 write("command");
                 r.actions.push({ type: "log", message: `raw command: ${cmd}` });
                 if (name === undefined) {
-                    push({ kind: "command", cmd });
+                    push({ kind: "command", cmd, dimension });
                     return;
                 }
                 if (typeof name !== "string")
@@ -879,7 +899,7 @@ function createReducer(def) {
                     throw (0, errors_js_1.apiError)("lifecycle", `command("${cmd}", "${name}"): a result needs a running game, not .setup (status ${s.status})`);
                 const id = `cmd:${s.nextId++}`;
                 s.commands[id] = { name };
-                push({ kind: "command", cmd, id });
+                push({ kind: "command", cmd, id, dimension });
             },
             // ---- flow
             startPhase(name) {
@@ -1283,11 +1303,19 @@ function createReducer(def) {
         const out = [];
         if (w.spawn)
             out.push({ kind: "spawn", at: { ...w.spawn } });
-        if (w.time !== false)
-            out.push({ kind: "time", value: w.time });
-        out.push({ kind: "gamerule", rule: "minecraft:advance_time", value: w.daylightCycle });
-        out.push({ kind: "gamerule", rule: "minecraft:spawn_mobs", value: w.mobSpawning });
-        out.push({ kind: "gamerule", rule: "minecraft:natural_health_regeneration", value: w.naturalRegeneration });
+        for (const dimension of dimensions) {
+            const scope = dimension === dimensions_js_1.OVERWORLD ? {} : { dimension };
+            if (w.time !== false)
+                out.push({ kind: "time", value: w.time, ...scope });
+            out.push({ kind: "gamerule", rule: "minecraft:advance_time", value: w.daylightCycle, ...scope });
+            out.push({ kind: "gamerule", rule: "minecraft:spawn_mobs", value: w.mobSpawning, ...scope });
+            out.push({
+                kind: "gamerule",
+                rule: "minecraft:natural_health_regeneration",
+                value: w.naturalRegeneration,
+                ...scope,
+            });
+        }
         return out;
     }
     function worldPlayers(s) {
@@ -1665,6 +1693,8 @@ function createReducer(def) {
         if (r.s.status !== "PLAYING")
             return;
         for (const { m, before, after } of edges) {
+            if ((0, dimensions_js_1.dimensionOf)(m.from) !== (0, dimensions_js_1.dimensionOf)(m.to))
+                fire(r, "dimensionChanged", { player: viewOf(r, m.p), from: m.from, to: { ...m.to } });
             for (const zone of after)
                 if (!before.includes(zone))
                     fire(r, "zoneEntered", { player: viewOf(r, m.p), zone });
@@ -1789,6 +1819,8 @@ function createReducer(def) {
                     return;
                 }
                 const missing = missingCapabilities(e.capabilities);
+                if (dimensions.length > 1 && !e.capabilities.includes("dimensions"))
+                    missing.push("dimensions");
                 if (def.setup && !e.capabilities.includes("batch"))
                     missing.push("batch");
                 if (missing.length > 0) {
@@ -1849,6 +1881,8 @@ function createReducer(def) {
                     delete s.dialogs[player];
                     r.actions.push({ type: "effect", effect: { kind: "clear_dialog", player } });
                 }
+                if (e.times)
+                    s.world = { ...s.world, times: { ...s.world.times, ...e.times } };
                 if (e.entities)
                     s.world = (0, world_js_1.moveEntities)(s.world, e.entities);
                 if (e.time !== undefined && e.time !== s.world.time)
@@ -2127,11 +2161,10 @@ function createReducer(def) {
                 s.world = (0, world_js_1.applyChunk)(s.world, e);
                 break;
             case "chunk_unloaded": {
-                s.world = (0, world_js_1.removeChunk)(s.world, e.x, e.z);
+                s.world = (0, world_js_1.removeChunk)(s.world, e.x, e.z, e.dimension);
                 // The containers of the chunk are unknown now.
                 for (const key of Object.keys(s.containers)) {
-                    const [x, , z] = key.split(",").map(Number);
-                    if (x >> 4 === e.x && z >> 4 === e.z)
+                    if ((0, dimensions_js_1.keyInChunk)(key, e.x, e.z, e.dimension))
                         delete s.containers[key];
                 }
                 break;
@@ -2141,6 +2174,7 @@ function createReducer(def) {
                 if (playing()) {
                     fire(r, "blocksChanged", () => ({
                         changes: e.changes.map((c) => compact({
+                            dimension: c.dimension,
                             x: c.x,
                             y: c.y,
                             z: c.z,
@@ -2165,10 +2199,13 @@ function createReducer(def) {
                 const from = { ...e.from };
                 const to = { ...e.to };
                 const { lo, hi } = (0, world_js_1.bounds)({ from, to });
-                const dest = { x: Math.floor(e.dest.x), y: Math.floor(e.dest.y), z: Math.floor(e.dest.z) };
+                const dest = { ...e.dest, x: Math.floor(e.dest.x), y: Math.floor(e.dest.y), z: Math.floor(e.dest.z) };
                 s.world = (0, world_js_1.cloneBlocks)(s.world, { from, to }, dest, e.mode);
                 if (playing()) {
-                    const box = { from: dest, to: { x: dest.x + hi.x - lo.x, y: dest.y + hi.y - lo.y, z: dest.z + hi.z - lo.z } };
+                    const box = {
+                        from: dest,
+                        to: { ...dest, x: dest.x + hi.x - lo.x, y: dest.y + hi.y - lo.y, z: dest.z + hi.z - lo.z },
+                    };
                     // A move clears the source first: an author who applies the entries in order gets the vanilla result on an overlap.
                     fire(r, "blocksChanged", {
                         changes: e.mode === "move"