redscript-mc 2.4.1 → 2.6.0

package/dist/src/__tests__/double.test.js

@@ -0,0 +1,464 @@
+"use strict";
+/**
+ * Tests for double type support in RedScript.
+ *
+ * double variables are NBT-backed IEEE 754 doubles stored in rs:d storage.
+ * All arithmetic goes through fixed (×10000) as intermediate representation.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../emit/compile");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function getAllMcContent(files) {
+    return files.filter(f => f.path.endsWith('.mcfunction')).map(f => f.content).join('\n');
+}
+describe('double literal storage', () => {
+    test('double literal stores into rs:d NBT storage', () => {
+        const source = `
+      fn t() {
+        let x: double = 3.14d;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('data modify storage rs:d');
+        expect(all).toContain('3.14d');
+    });
+    test('double literal read back as ×10000 fixed (3.14d → ~31400)', () => {
+        const source = `
+      fn t(): fixed {
+        let x: double = 3.14d;
+        return x as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // Reading back uses 10000.0 scale
+        expect(all).toContain('10000.0');
+        expect(all).toContain('rs:d');
+    });
+    test('double literal 1.5d stores 1.5d in NBT', () => {
+        const source = `
+      fn t() {
+        let x: double = 1.5d;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('1.5d');
+    });
+});
+describe('double to fixed cast', () => {
+    test('x as fixed reads double as ×10000 score', () => {
+        const source = `
+      fn t(): fixed {
+        let x: double = 2.5d;
+        return x as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // The cast emits a data get with scale 10000.0
+        expect(all).toContain('data get storage rs:d');
+        expect(all).toContain('10000.0');
+    });
+});
+describe('fixed to double cast', () => {
+    test('fixed as double stores in NBT with scale 0.0001', () => {
+        const source = `
+      fn t() {
+        let x: fixed = 1.5;
+        let y: double = x as double;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // The cast emits execute store with scale 0.0001
+        expect(all).toContain('0.0001');
+        expect(all).toContain('rs:d');
+    });
+    test('round-trip: fixed → double → fixed preserves value', () => {
+        const source = `
+      fn t(): fixed {
+        let x: fixed = 1.5;
+        let y: double = x as double;
+        return y as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // Should see both directions of conversion
+        expect(all).toContain('0.0001');
+        expect(all).toContain('10000.0');
+        expect(all).toContain('rs:d');
+    });
+});
+describe('double arithmetic intrinsics', () => {
+    test('double + double lowers to math_hp:double_add call', () => {
+        const source = `
+      fn t(): double {
+        let a: double = 2.0d;
+        let b: double = 3.0d;
+        return a + b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function math_hp:double_add');
+        expect(all).toContain('rs:d __dp0');
+        expect(all).toContain('rs:d __dp1');
+    });
+    test('double / double lowers to math_hp:double_div call', () => {
+        const source = `
+      fn t(): double {
+        let a: double = 6.0d;
+        let b: double = 2.0d;
+        return a / b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function math_hp:double_div');
+        expect(all).toContain('rs:d __dp0');
+        expect(all).toContain('rs:d __dp1');
+    });
+    test('double - double lowers to math_hp:double_sub call', () => {
+        const source = `
+      fn t(): double {
+        let a: double = 5.0d;
+        let b: double = 1.0d;
+        return a - b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function math_hp:double_sub');
+    });
+    test('double * double lowers to math_hp:double_mul call', () => {
+        const source = `
+      fn t(): double {
+        let a: double = 3.0d;
+        let b: double = 4.0d;
+        return a * b;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function math_hp:double_mul');
+    });
+    test('double + double result readable as fixed (10000.0 scale back)', () => {
+        const source = `
+      fn t(): fixed {
+        let a: double = 1.5d;
+        let b: double = 2.5d;
+        return (a + b) as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('10000.0');
+        expect(all).toContain('rs:d');
+        expect(all).toContain('function math_hp:double_add');
+    });
+    test('double + double via literals lowers to math_hp:double_add', () => {
+        const source = `
+      fn t(): double {
+        return 1.5d + 2.5d;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function math_hp:double_add');
+    });
+});
+describe('double literal type system', () => {
+    test('double_lit expression emits NBT set and score read', () => {
+        const source = `
+      fn t(): fixed {
+        return 3.0d as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('3d');
+        expect(all).toContain('rs:d');
+        expect(all).toContain('10000.0');
+    });
+});
+describe('double parameter passing', () => {
+    test('passing double var to fn uses data modify (no ×10000 conversion)', () => {
+        const source = `
+      fn take_double(d: double): fixed {
+        return d as fixed;
+      }
+      fn t(): fixed {
+        let x: double = 3.14d;
+        return take_double(x);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // Caller must copy NBT path directly — no execute store with 10000 for the arg
+        expect(all).toContain('data modify storage rs:d __dp0 set from storage rs:d');
+        // Callee reads __dp0 as double
+        expect(all).toContain('data get storage rs:d __dp0');
+    });
+    test('double param returning double uses NBT round-trip', () => {
+        const source = `
+      fn identity(d: double): double {
+        return d;
+      }
+      fn t(): fixed {
+        let x: double = 2.0d;
+        let y: double = identity(x);
+        return y as fixed;
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('__dp0');
+        expect(all).toContain('data modify storage rs:d __dp0 set from storage rs:d');
+    });
+    test('mixed double and int params: double via NBT, int via scoreboard', () => {
+        const source = `
+      fn mixed(d: double, n: int): fixed {
+        return (d as fixed) + n;
+      }
+      fn t(): fixed {
+        let x: double = 1.5d;
+        return mixed(x, 42);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'doubletest' });
+        const all = getAllMcContent(result.files);
+        // Double arg passed via NBT
+        expect(all).toContain('data modify storage rs:d __dp0 set from storage rs:d');
+        // Int arg passed via scoreboard $p0 (first non-double param)
+        expect(all).toContain('$p0');
+    });
+});
+describe('double_add — entity position trick', () => {
+    const mathHpSrc = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+    test('double_add compiles: emits tp macro helpers and Pos[0] read-back', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dadd() {
+        let a: double = 1.5d;
+        let b: double = 2.5d;
+        let result: double = double_add(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'daddtest' });
+        const all = getAllMcContent(result.files);
+        // Macro helper for absolute TP must be used
+        expect(all).toContain('with storage rs:d __dadd_args');
+        // Pos[0] read-back into __dp0
+        expect(all).toContain('Pos[0]');
+        // Marker UUID used
+        expect(all).toContain('b54f1a4f-d7ac-4002-915e-3c2a3bf6f8a4');
+    });
+    test('double_add emits __dadd_tp_to and __dadd_tp_rel helper functions', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dadd() {
+        let a: double = 1.5d;
+        let b: double = 2.5d;
+        let result: double = double_add(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'daddtest' });
+        const tp_to = result.files.find(f => f.path.includes('__dadd_tp_to'));
+        const tp_rel = result.files.find(f => f.path.includes('__dadd_tp_rel'));
+        expect(tp_to).toBeDefined();
+        expect(tp_rel).toBeDefined();
+        expect(tp_to.content).toContain('$(x)');
+        expect(tp_rel.content).toContain('$(dx)');
+    });
+    test('double_add uses __NS__ correctly — helpers called in compilation namespace', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dadd() {
+        let a: double = 1.5d;
+        let b: double = 2.5d;
+        let result: double = double_add(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'mynamespace' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function mynamespace:__dadd_tp_to with storage');
+        expect(all).toContain('function mynamespace:__dadd_tp_rel with storage');
+    });
+    test('init_double_add is called on load — summons AEC marker UUID', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dadd() {
+        let a: double = 1.5d;
+        let b: double = 2.5d;
+        let result: double = double_add(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'daddtest' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('rs_math_hp_marker');
+        expect(all).toContain('area_effect_cloud');
+    });
+});
+describe('double_sub — negate-then-add', () => {
+    const mathHpSrc = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+    test('double_sub emits negation step (double -0.0001 × 10000)', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dsub() {
+        let a: double = 5.0d;
+        let b: double = 2.0d;
+        let result: double = double_sub(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'dsubtest' });
+        const all = getAllMcContent(result.files);
+        // Negation: store __dp1 as double × -0.0001
+        expect(all).toContain('double -0.0001');
+        // Then uses the add machinery
+        expect(all).toContain('with storage rs:d __dadd_args');
+        expect(all).toContain('Pos[0]');
+    });
+});
+describe('double_mul — scoreboard approximation', () => {
+    const mathHpSrc = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+    test('double_mul emits data get ×10000 for both operands', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dmul() {
+        let a: double = 3.0d;
+        let b: double = 2.0d;
+        let result: double = double_mul(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'dmultest2' });
+        const all = getAllMcContent(result.files);
+        // Both operands converted to ×10000 scores
+        expect(all).toContain('$dmul_a');
+        expect(all).toContain('$dmul_b');
+        // Result stored back as double × 0.0001
+        expect(all).toContain('double 0.0001');
+        // Scoreboard multiply
+        expect(all).toContain('$dmul_a __rs_math_hp *= $dmul_b __rs_math_hp');
+    });
+});
+describe('double_div — display entity SVD trick', () => {
+    const mathHpSrc = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+    test('double_div emits __ddiv_set_mat helper and reads transformation.scale[0]', () => {
+        const source = mathHpSrc + `
+      @keep fn test_ddiv() {
+        let a: double = 6.0d;
+        let b: double = 2.0d;
+        let result: double = double_div(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ddivtest' });
+        const all = getAllMcContent(result.files);
+        // Uses rs_div entity (block_display)
+        expect(all).toContain('rs_div');
+        // Reads scale[0] back into __dp0
+        expect(all).toContain('transformation.scale[0]');
+        // Macro helper called with storage
+        expect(all).toContain('with storage rs:math_hp __ddiv_args');
+    });
+    test('double_div emits __ddiv_set_mat helper function with $(da)/$(db) macros', () => {
+        const source = mathHpSrc + `
+      @keep fn test_ddiv() {
+        let a: double = 6.0d;
+        let b: double = 2.0d;
+        let result: double = double_div(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'ddivtest' });
+        const helper = result.files.find(f => f.path.includes('__ddiv_set_mat'));
+        expect(helper).toBeDefined();
+        expect(helper.content).toContain('$(da)');
+        expect(helper.content).toContain('$(db)');
+    });
+    test('double_div uses __NS__ correctly', () => {
+        const source = mathHpSrc + `
+      @keep fn test_ddiv() {
+        let a: double = 6.0d;
+        let b: double = 2.0d;
+        let result: double = double_div(a, b);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'mynamespace' });
+        const all = getAllMcContent(result.files);
+        expect(all).toContain('function mynamespace:__ddiv_set_mat with storage');
+    });
+});
+describe('double_mul_fixed — true double precision via function macro', () => {
+    const mathHpSrc = fs.readFileSync(path.join(__dirname, '../stdlib/math_hp.mcrs'), 'utf-8');
+    test('double_mul_fixed compiles with function macro (with storage) pattern', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dmul() {
+        let d: double = 2.5d;
+        let result: double = double_mul_fixed(d, 20000);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'dmultest' });
+        const all = getAllMcContent(result.files);
+        // Must use the macro helper function call
+        expect(all).toContain('with storage rs:math_hp __dmul_args');
+        // Helper must contain the $ macro line
+        expect(all).toContain('$execute store result storage rs:d __dp0 double $(scale)');
+        // Scale must be stored as double 0.0001 factor
+        expect(all).toContain('scale double 0.0001');
+    });
+    test('double_mul_fixed emits __dmul_apply_scale helper function', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dmul() {
+        let d: double = 2.5d;
+        let result: double = double_mul_fixed(d, 20000);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'dmultest' });
+        const helper = result.files.find(f => f.path.includes('__dmul_apply_scale'));
+        expect(helper).toBeDefined();
+        expect(helper.content).toContain('$execute store result storage rs:d __dp0 double $(scale)');
+    });
+    test('double_mul_fixed uses __NS__ correctly — helper called in same namespace', () => {
+        const source = mathHpSrc + `
+      @keep fn test_dmul() {
+        let d: double = 2.5d;
+        let result: double = double_mul_fixed(d, 20000);
+      }
+    `;
+        const result = (0, compile_1.compile)(source, { namespace: 'mynamespace' });
+        const all = getAllMcContent(result.files);
+        // The function call must use the compilation namespace, not a hardcoded one
+        expect(all).toContain('function mynamespace:__dmul_apply_scale with storage');
+    });
+});
+//# sourceMappingURL=double.test.js.map

package/dist/src/__tests__/e2e/for-in-array.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * E2E tests for the `for (let v in arr, len)` syntax sugar.
+ */
+export {};

package/dist/src/__tests__/e2e/for-in-array.test.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * E2E tests for the `for (let v in arr, len)` syntax sugar.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const compile_1 = require("../../emit/compile");
+function getFiles(files) {
+    return files.map(f => f.content).join('\n');
+}
+describe('e2e: for-in-array syntax sugar', () => {
+    test('for in array basic compiles without error', () => {
+        const src = `
+      @keep fn test() {
+        let nums: int[] = [10, 20, 30];
+        let len: int = 3;
+        for (let v in nums, len) {
+          scoreboard_add("#sum", "test", v);
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('for in array generates dynamic index access (with storage)', () => {
+        const src = `
+      @keep fn test() {
+        let nums: int[] = [10, 20, 30];
+        let len: int = 3;
+        for (let v in nums, len) {
+          scoreboard_add("#sum", "test", v);
+        }
+      }
+    `;
+        const result = (0, compile_1.compile)(src, { namespace: 'test' });
+        const allContent = getFiles(result.files);
+        expect(allContent).toContain('with storage');
+    });
+    test('for in array with len variable compiles', () => {
+        const src = `
+      @keep fn loop_sum(arr: int[], n: int): void {
+        for (let item in arr, n) {
+          scoreboard_add("#total", "obj", item);
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+    test('for in array with literal len compiles', () => {
+        const src = `
+      @keep fn test() {
+        let data: int[] = [1, 2, 3, 4, 5];
+        for (let x in data, 5) {
+          scoreboard_add("#res", "test", x);
+        }
+      }
+    `;
+        expect(() => (0, compile_1.compile)(src, { namespace: 'test' })).not.toThrow();
+    });
+});
+//# sourceMappingURL=for-in-array.test.js.map

package/dist/src/__tests__/e2e/macros.test.js

@@ -118,10 +118,10 @@ describe('e2e: macro call site generation', () => {
 // ---------------------------------------------------------------------------
 // Float macro params (local coords)
 // ---------------------------------------------------------------------------
-describe('e2e: float macro params with local coords', () => {
-    test('float params in ^coord positions produce macro function', () => {
+describe('e2e: fixed macro params with local coords', () => {
+    test('fixed params in ^coord positions produce macro function', () => {
         const source = `
-      fn draw_pt(px: float, py: float) {
+      fn draw_pt(px: fixed, py: fixed) {
         particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
       }
     `;
@@ -131,9 +131,9 @@ describe('e2e: float macro params with local coords', () => {
         // Should have $particle with ^$(px) and ^$(py)
         expect(fn).toContain('$particle minecraft:end_rod ^$(px) ^$(py) ^5');
     });
-    test('float macro call site uses double 0.01 scale for NBT storage', () => {
+    test('fixed macro call site uses double 0.0001 scale for NBT storage', () => {
         const source = `
-      fn draw_pt(px: float, py: float) {
+      fn draw_pt(px: fixed, py: fixed) {
         particle("minecraft:end_rod", ^px, ^py, ^5, 0.02, 0.02, 0.02, 0.0, 10);
       }
 
@@ -144,9 +144,9 @@ describe('e2e: float macro params with local coords', () => {
         const result = (0, compile_1.compile)(source, { namespace: 'test' });
         const callerFn = getFile(result.files, 'caller.mcfunction');
         expect(callerFn).toBeDefined();
-        // Should store to NBT with double type and 0.01 scale
+        // Should store to NBT with double type and 0.0001 scale
         expect(callerFn).toContain('rs:macro_args');
-        expect(callerFn).toContain('double 0.01');
+        expect(callerFn).toContain('double 0.0001');
         expect(callerFn).toContain('with storage rs:macro_args');
     });
 });