redscript-mc 1.2.25 → 1.2.27

package/dist/runtime/index.js

@@ -235,6 +235,8 @@ class MCRuntime {
         this.entityIdCounter = 0;
         // Flag to stop function execution (for return)
         this.shouldReturn = false;
+        // Current MC macro context: key → value (set by 'function ... with storage')
+        this.currentMacroContext = null;
         this.namespace = namespace;
         // Initialize default objective
         this.scoreboard.set('rs', new Map());
@@ -321,6 +323,12 @@ class MCRuntime {
         cmd = cmd.trim();
         if (!cmd || cmd.startsWith('#'))
             return true;
+        // MC macro command: line starts with '$'.
+        // Expand $(key) placeholders from currentMacroContext, then execute.
+        if (cmd.startsWith('$')) {
+            const expanded = this.expandMacro(cmd.slice(1));
+            return this.execCommand(expanded, executor);
+        }
         // Parse command
         if (cmd.startsWith('scoreboard ')) {
             return this.execScoreboard(cmd);
@@ -502,7 +510,12 @@ class MCRuntime {
                     const value = storeTarget.type === 'result'
                         ? (this.returnValue ?? (result ? 1 : 0))
                         : (result ? 1 : 0);
-                    this.setScore(storeTarget.player, storeTarget.objective, value);
+                    if ('storagePath' in storeTarget) {
+                        this.setStorageField(storeTarget.storagePath, storeTarget.field, value);
+                    }
+                    else {
+                        this.setScore(storeTarget.player, storeTarget.objective, value);
+                    }
                 }
                 return result;
             }
@@ -577,15 +590,44 @@ class MCRuntime {
             // Handle 'unless score ...'
             if (rest.startsWith('unless score ')) {
                 rest = rest.slice(13);
-                const scoreParts = rest.match(/^(\S+)\s+(\S+)\s+matches\s+(\S+)(.*)$/);
-                if (scoreParts) {
-                    const [, player, obj, rangeStr, remaining] = scoreParts;
+                // unless score <player> <obj> matches <range>
+                const matchesParts = rest.match(/^(\S+)\s+(\S+)\s+matches\s+(\S+)(.*)$/);
+                if (matchesParts) {
+                    const [, player, obj, rangeStr, remaining] = matchesParts;
                     const range = parseRange(rangeStr);
                     const score = this.getScore(player, obj);
                     condition = condition && !matchesRange(score, range);
                     rest = remaining.trim();
                     continue;
                 }
+                // unless score <p1> <o1> <op> <p2> <o2>
+                const compareMatch = rest.match(/^(\S+)\s+(\S+)\s+([<>=]+)\s+(\S+)\s+(\S+)(.*)$/);
+                if (compareMatch) {
+                    const [, p1, o1, op, p2, o2, remaining] = compareMatch;
+                    const v1 = this.getScore(p1, o1);
+                    const v2 = this.getScore(p2, o2);
+                    let matches = false;
+                    switch (op) {
+                        case '=':
+                            matches = v1 === v2;
+                            break;
+                        case '<':
+                            matches = v1 < v2;
+                            break;
+                        case '<=':
+                            matches = v1 <= v2;
+                            break;
+                        case '>':
+                            matches = v1 > v2;
+                            break;
+                        case '>=':
+                            matches = v1 >= v2;
+                            break;
+                    }
+                    condition = condition && !matches; // unless = negate
+                    rest = remaining.trim();
+                    continue;
+                }
             }
             // Handle 'if entity <selector>'
             if (rest.startsWith('if entity ')) {
@@ -605,6 +647,28 @@ class MCRuntime {
                 condition = condition && entities.length === 0;
                 continue;
             }
+            // Handle 'store result storage <ns:path> <field>[<idx>] <type> <scale>'  (array element)
+            if (rest.startsWith('store result storage ')) {
+                const sliced = rest.slice(21);
+                // Try array-index form first: <ns:path> <field>[<idx>] <type> <scale> <run-cmd>
+                // Use [^\[\s]+ for field (no brackets or spaces) so that \[ matches correctly.
+                const arrParts = sliced.match(/^(\S+)\s+([^\[\s]+)\[(\d+)\]\s+(\S+)\s+([\d.]+)\s+(.*)$/);
+                if (arrParts) {
+                    const [, storagePath, field, indexStr, , , remaining] = arrParts;
+                    storeTarget = { storagePath, field: `${field}[${indexStr}]`, type: 'result' };
+                    rest = remaining.trim();
+                    continue;
+                }
+                // Plain form: <ns:path> <field> <type> <scale> <run-cmd>
+                const storageParts = sliced.match(/^(\S+)\s+(\S+)\s+(\S+)\s+([\d.]+)\s+(.*)$/);
+                if (storageParts) {
+                    const [, storagePath, field, , , remaining] = storageParts;
+                    storeTarget = { storagePath, field, type: 'result' };
+                    rest = remaining.trim();
+                    continue;
+                }
+                rest = sliced;
+            }
             // Handle 'store result score <player> <obj>'
             if (rest.startsWith('store result score ')) {
                 rest = rest.slice(19);
@@ -637,7 +701,12 @@ class MCRuntime {
             const value = storeTarget.type === 'result'
                 ? (this.returnValue ?? (condition ? 1 : 0))
                 : (condition ? 1 : 0);
-            this.setScore(storeTarget.player, storeTarget.objective, value);
+            if ('storagePath' in storeTarget) {
+                this.setStorageField(storeTarget.storagePath, storeTarget.field, value);
+            }
+            else {
+                this.setScore(storeTarget.player, storeTarget.objective, value);
+            }
         }
         return condition;
     }
@@ -659,12 +728,35 @@ class MCRuntime {
     // Function Command
     // -------------------------------------------------------------------------
     execFunctionCmd(cmd, executor) {
-        const fnName = cmd.slice(9).trim(); // remove 'function '
+        let fnRef = cmd.slice(9).trim(); // remove 'function '
+        // Handle 'function ns:name with storage ns:path' — MC macro calling convention.
+        // The called function may have $( ) placeholders that need to be expanded
+        // using the provided storage compound. We execute the function after
+        // expanding its macro context.
+        const withStorageMatch = fnRef.match(/^(\S+)\s+with\s+storage\s+(\S+)$/);
+        if (withStorageMatch) {
+            const [, actualFnName, storagePath] = withStorageMatch;
+            const macroContext = this.getStorageCompound(storagePath) ?? {};
+            const outerShouldReturn = this.shouldReturn;
+            const outerMacroCtx = this.currentMacroContext;
+            this.currentMacroContext = macroContext;
+            this.execFunction(actualFnName, executor);
+            this.currentMacroContext = outerMacroCtx;
+            this.shouldReturn = outerShouldReturn;
+            return true;
+        }
         const outerShouldReturn = this.shouldReturn;
-        this.execFunction(fnName, executor);
+        this.execFunction(fnRef, executor);
         this.shouldReturn = outerShouldReturn;
         return true;
     }
+    /** Expand MC macro placeholders: $(key) → value from currentMacroContext */
+    expandMacro(cmd) {
+        return cmd.replace(/\$\(([^)]+)\)/g, (_, key) => {
+            const val = this.currentMacroContext?.[key];
+            return val !== undefined ? String(val) : `$(${key})`;
+        });
+    }
     // -------------------------------------------------------------------------
     // Data Commands
     // -------------------------------------------------------------------------
@@ -689,8 +781,29 @@ class MCRuntime {
             }
             return true;
         }
-        // data get storage <ns:path> <field>
-        const getMatch = cmd.match(/^data get storage (\S+) (\S+)$/);
+        // data modify storage <ns:path> <field>[<index>] set value <val>  (array element write)
+        const setArrMatch = cmd.match(/^data modify storage (\S+) ([^\[\s]+)\[(\d+)\] set value (.+)$/);
+        if (setArrMatch) {
+            const [, storagePath, field, indexStr, valueStr] = setArrMatch;
+            const arr = this.getStorageField(storagePath, field);
+            const idx = parseInt(indexStr, 10);
+            if (Array.isArray(arr) && idx >= 0 && idx < arr.length) {
+                arr[idx] = this.parseDataValue(valueStr);
+            }
+            return true;
+        }
+        // data get storage <ns:path> <field>[<index>] [scale]  (array element access)
+        const getArrMatch = cmd.match(/^data get storage (\S+) ([^\[\s]+)\[(\d+)\](?:\s+[\d.]+)?$/);
+        if (getArrMatch) {
+            const [, storagePath, field, indexStr] = getArrMatch;
+            const arr = this.getStorageField(storagePath, field);
+            const idx = parseInt(indexStr, 10);
+            const value = Array.isArray(arr) ? arr[idx] : undefined;
+            this.returnValue = typeof value === 'number' ? value : 0;
+            return true;
+        }
+        // data get storage <ns:path> <field> [scale]
+        const getMatch = cmd.match(/^data get storage (\S+) (\S+)(?:\s+[\d.]+)?$/);
         if (getMatch) {
             const [, storagePath, field] = getMatch;
             const value = this.getStorageField(storagePath, field);
@@ -736,6 +849,14 @@ class MCRuntime {
             return str;
         }
     }
+    /** Return the whole storage compound at storagePath as a flat key→value map.
+     *  Used by 'function ... with storage' to provide macro context. */
+    getStorageCompound(storagePath) {
+        const data = this.storage.get(storagePath);
+        if (!data || typeof data !== 'object' || Array.isArray(data))
+            return null;
+        return data;
+    }
     getStorageField(storagePath, field) {
         const data = this.storage.get(storagePath) ?? {};
         const segments = this.parseStoragePath(field);

package/dist/runtime.map.json

@@ -0,0 +1,7 @@
+{
+  "$d": "ticks",
+  "$a": "const:0",
+  "$b": "const:1",
+  "$c": "const:100",
+  "$i": "internal:ret"
+}

package/dist/swap_test.map.json

@@ -0,0 +1,14 @@
+{
+  "$b": "a",
+  "$d": "b",
+  "$f": "p0",
+  "$g": "p1",
+  "$h": "x",
+  "$i": "y",
+  "$k": "tmp",
+  "$n": "m",
+  "$a": "const:0",
+  "$c": "internal:p0",
+  "$e": "internal:p1",
+  "$m": "internal:ret"
+}

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.0.16",
+  "version": "1.0.31",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.0.16",
+      "version": "1.0.31",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../"
@@ -23,7 +23,7 @@
     },
     "../..": {
       "name": "redscript-mc",
-      "version": "1.2.25",
+      "version": "1.2.26",
       "license": "MIT",
       "bin": {
         "redscript": "dist/cli.js",

package/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "redscript-vscode",
   "displayName": "RedScript for Minecraft",
   "description": "Syntax highlighting, error diagnostics, and language support for RedScript — a compiler targeting Minecraft Java Edition",
-  "version": "1.0.16",
+  "version": "1.0.31",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",