redscript-mc 1.2.26 → 1.2.28

package/src/__tests__/stdlib-advanced.test.ts

@@ -257,3 +257,123 @@ describe('julia_iter', () => {
     expect(scoreOf(rt, 'r')).toBe(0)
   })
 })
+
+// ─── Experiment: cross-stdlib (vec + math + advanced) ────────────────────────
+
+const VEC_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/vec.mcrs'), 'utf-8')
+
+function runAll(driver: string): MCRuntime {
+  const result = compile(driver, {
+    namespace: 'exptest',
+    librarySources: [MATH_SRC, VEC_SRC, ADV_SRC],
+  })
+  if (!result.success) throw new Error(result.error?.message ?? 'compile failed: ' + result.error?.message)
+  const rt = new MCRuntime('exptest')
+  for (const file of result.files ?? []) {
+    if (!file.path.endsWith('.mcfunction')) continue
+    const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/)
+    if (!match) continue
+    rt.loadFunction(`${match[1]}:${match[2]}`, file.content.split('\n'))
+  }
+  rt.load()
+  return rt
+}
+
+function exp(rt: MCRuntime, key: string): number {
+  return rt.getScore('out', `exptest.${key}`) ?? 0
+}
+
+describe('newton_sqrt', () => {
+  it('newton_sqrt(25) == 5', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", newton_sqrt(25)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(5)
+  })
+  it('newton_sqrt(100) == 10', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", newton_sqrt(100)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(10)
+  })
+  it('newton_sqrt(2) == 1', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", newton_sqrt(2)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(1)
+  })
+  it('newton_sqrt(0) == 0', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", newton_sqrt(0)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(0)
+  })
+})
+
+describe('digital_root', () => {
+  it('digital_root(493) == 7', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", digital_root(493)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(7)
+  })
+  it('digital_root(9) == 9', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", digital_root(9)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(9)
+  })
+  it('digital_root(0) == 0', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", digital_root(0)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(0)
+  })
+})
+
+describe('spiral_ring', () => {
+  it('spiral_ring(1) == 0', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", spiral_ring(1)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(0)
+  })
+  it('spiral_ring(9) == 1', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", spiral_ring(9)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(1)
+  })
+  it('spiral_ring(25) == 2', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", spiral_ring(25)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(2)
+  })
+})
+
+describe('clamp_circle', () => {
+  it('point inside: clamp_circle_x(3,4,10) == 3', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", clamp_circle_x(3, 4, 10)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(3)
+  })
+  it('point outside: clamp_circle_x(600,0,500) == 500', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", clamp_circle_x(600, 0, 500)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(500)
+  })
+  it('clamp_circle_y(0,600,500) == 500', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", clamp_circle_y(0, 600, 500)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(500)
+  })
+})
+
+describe('angle_between', () => {
+  it('perpendicular vectors: angle_between(1000,0,0,1000) == 90', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", angle_between(1000, 0, 0, 1000)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(90)
+  })
+  it('parallel vectors: angle_between(1000,0,1000,0) == 0', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", angle_between(1000, 0, 1000, 0)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(0)
+  })
+  it('opposite vectors: angle_between(1000,0,-1000,0) == 180', () => {
+    const rt = runAll(`fn test() { scoreboard_set("out", "r", angle_between(1000, 0, -1000, 0)); }`)
+    rt.execFunction('test')
+    expect(exp(rt, 'r')).toBe(180)
+  })
+})

package/src/__tests__/stdlib-bigint.test.ts

@@ -0,0 +1,427 @@
+/**
+ * stdlib/bigint.mcrs — runtime behavioural tests
+ *
+ * Tests basic BigInt operations (base 10000, 8 limbs = 32 decimal digits).
+ * All arithmetic validated against known values.
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import { compile } from '../compile'
+import { MCRuntime } from '../runtime'
+
+const MATH_SRC   = fs.readFileSync(path.join(__dirname, '../../src/stdlib/math.mcrs'), 'utf-8')
+const BIGINT_SRC = fs.readFileSync(path.join(__dirname, '../../src/stdlib/bigint.mcrs'), 'utf-8')
+
+function run(driver: string): MCRuntime {
+  const result = compile(driver, {
+    namespace: 'bitest',
+    librarySources: [MATH_SRC, BIGINT_SRC],
+  })
+  if (!result.success) throw new Error(result.error?.message ?? 'compile failed')
+  const rt = new MCRuntime('bitest')
+  for (const file of result.files ?? []) {
+    if (!file.path.endsWith('.mcfunction')) continue
+    const match = file.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction$/)
+    if (!match) continue
+    rt.loadFunction(`${match[1]}:${match[2]}`, file.content.split('\n'))
+  }
+  rt.load()
+  return rt
+}
+
+function sc(rt: MCRuntime, key: string): number {
+  return rt.getScore('out', `bitest.${key}`) ?? 0
+}
+
+// ── storage_set_int roundtrip ─────────────────────────────────────────────────
+
+describe('storage_set_int roundtrip', () => {
+  it('static index: write 99 to arr[2], read back', () => {
+    const rt = run(`fn test() {
+      storage_set_array("rs:t", "arr", "[10,20,30,40]");
+      storage_set_int("rs:t", "arr", 2, 99);
+      scoreboard_set("out", "r", storage_get_int("rs:t", "arr", 2));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(99)
+  })
+
+  it('runtime index: write 777 to arr[idx], read back', () => {
+    const rt = run(`fn test() {
+      storage_set_array("rs:t", "arr", "[1,2,3,4,5]");
+      let idx: int = 3;
+      storage_set_int("rs:t", "arr", idx, 777);
+      scoreboard_set("out", "r", storage_get_int("rs:t", "arr", idx));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(777)
+  })
+
+  it('loop write: fill arr[0..3] with 10,20,30,40', () => {
+    const rt = run(`fn test() {
+      storage_set_array("rs:t", "arr", "[0,0,0,0]");
+      let i: int = 0;
+      while (i < 4) {
+        storage_set_int("rs:t", "arr", i, (i + 1) * 10);
+        i = i + 1;
+      }
+      scoreboard_set("out", "a", storage_get_int("rs:t", "arr", 0));
+      scoreboard_set("out", "b", storage_get_int("rs:t", "arr", 1));
+      scoreboard_set("out", "c", storage_get_int("rs:t", "arr", 2));
+      scoreboard_set("out", "d", storage_get_int("rs:t", "arr", 3));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'a')).toBe(10)
+    expect(sc(rt, 'b')).toBe(20)
+    expect(sc(rt, 'c')).toBe(30)
+    expect(sc(rt, 'd')).toBe(40)
+  })
+})
+
+// ── bigint_init + from_int ────────────────────────────────────────────────────
+
+describe('bigint init and load', () => {
+  it('bigint_init zeros registers', () => {
+    const rt = run(`fn test() {
+      bigint_init();
+      scoreboard_set("out", "r", bigint_get_a(0));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(0)
+  })
+
+  it('bigint_from_int_a(12345678): limb0=5678, limb1=1234', () => {
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(12345678);
+      scoreboard_set("out", "l0", bigint_get_a(0));
+      scoreboard_set("out", "l1", bigint_get_a(1));
+      scoreboard_set("out", "l2", bigint_get_a(2));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(5678)
+    expect(sc(rt, 'l1')).toBe(1234)
+    expect(sc(rt, 'l2')).toBe(0)
+  })
+
+  it('bigint_from_int_a(2000000000): limb0=0, limb1=0, limb2=20', () => {
+    // 2000000000 = 20 × 10000^2 (not 2000: 20 × 10^8 = 2×10^9 ✓)
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(2000000000);
+      scoreboard_set("out", "l0", bigint_get_a(0));
+      scoreboard_set("out", "l1", bigint_get_a(1));
+      scoreboard_set("out", "l2", bigint_get_a(2));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(0)
+    expect(sc(rt, 'l1')).toBe(0)
+    expect(sc(rt, 'l2')).toBe(20)
+  })
+})
+
+// ── bigint_add ────────────────────────────────────────────────────────────────
+
+describe('bigint_add', () => {
+  it('1 + 1 = 2 (simple)', () => {
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(1);
+      bigint_from_int_b(1);
+      bigint_add();
+      scoreboard_set("out", "r", bigint_get_c(0));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(2)
+  })
+
+  it('9999 + 1 = 10000: carry across limb boundary', () => {
+    // a=[9999,0,...] + b=[1,0,...] = c=[0,1,0,...] (carry to limb1)
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(9999);
+      bigint_from_int_b(1);
+      bigint_add();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(0)
+    expect(sc(rt, 'l1')).toBe(1)
+  })
+
+  it('99990000 + 10000 = 100000000: multi-limb carry', () => {
+    // a=[0,9999,...] + b=[0,1,...] = c=[0,0,1,...] (carry to limb2)
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(99990000);
+      bigint_from_int_b(10000);
+      bigint_add();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+      scoreboard_set("out", "l2", bigint_get_c(2));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(0)
+    expect(sc(rt, 'l1')).toBe(0)
+    expect(sc(rt, 'l2')).toBe(1)
+  })
+
+  it('large add: 999999999 + 999999999', () => {
+    // 999999999 = [9999, 9999, 9, 0, ...]
+    // + same = [9998, 9999, 18, 0, ...] after carry
+    // = 1999999998: l0=9998, l1=9999, l2=19 (carry: 9+9=18, no carry from l2)
+    // Wait: l0=9999+9999=19998, carry=1, l0=9998
+    //       l1=9999+9999+1=19999, carry=1, l1=9999
+    //       l2=9+9+1=19, carry=0, l2=19
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(999999999);
+      bigint_from_int_b(999999999);
+      bigint_add();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+      scoreboard_set("out", "l2", bigint_get_c(2));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(9998)  // 1999999998 % 10000 = 9998
+    expect(sc(rt, 'l1')).toBe(9999)  // floor(1999999998 / 10000) % 10000 = 9999
+    expect(sc(rt, 'l2')).toBe(19)    // floor(1999999998 / 100000000) = 19
+  })
+})
+
+// ── bigint_sub ────────────────────────────────────────────────────────────────
+
+describe('bigint_sub', () => {
+  it('10 - 3 = 7', () => {
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(10);
+      bigint_from_int_b(3);
+      bigint_sub();
+      scoreboard_set("out", "r", bigint_get_c(0));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(7)
+  })
+
+  it('10000 - 1 = 9999: borrow across limb boundary', () => {
+    // a=[0,1,...] - b=[1,0,...] = c=[9999,0,...] (borrow from limb1)
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(10000);
+      bigint_from_int_b(1);
+      bigint_sub();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(9999)
+    expect(sc(rt, 'l1')).toBe(0)
+  })
+})
+
+// ── bigint_compare ────────────────────────────────────────────────────────────
+
+describe('bigint_compare', () => {
+  it('1 == 1 → 0', () => {
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(1);
+      bigint_from_int_b(1);
+      scoreboard_set("out", "r", bigint_compare());
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(0)
+  })
+
+  it('2 > 1 → 1', () => {
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(2);
+      bigint_from_int_b(1);
+      scoreboard_set("out", "r", bigint_compare());
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(1)
+  })
+
+  it('1 < 2 → -1', () => {
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(1);
+      bigint_from_int_b(2);
+      scoreboard_set("out", "r", bigint_compare());
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(-1)
+  })
+})
+
+// ── bigint_mul_small ──────────────────────────────────────────────────────────
+
+describe('bigint_mul_small', () => {
+  it('12345 * 2 = 24690', () => {
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(12345);
+      bigint_mul_small(2);
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(4690)
+    expect(sc(rt, 'l1')).toBe(2)
+  })
+
+  it('9999 * 9999 = 99980001: carry', () => {
+    // c[0] = 99980001 % 10000 = 1
+    // c[1] = floor(99980001 / 10000) = 9998
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(9999);
+      bigint_mul_small(9999);
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(1)      // 99980001 % 10000 = 1  (actually 0001)
+    expect(sc(rt, 'l1')).toBe(9998)   // 9998
+  })
+})
+
+// ── bigint_mul ────────────────────────────────────────────────────────────────
+
+describe('bigint_mul', () => {
+  it('3 * 4 = 12', () => {
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(3);
+      bigint_from_int_b(4);
+      bigint_mul();
+      scoreboard_set("out", "r", bigint_get_c(0));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(12)
+  })
+
+  it('9999 * 9999 = 99980001', () => {
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(9999);
+      bigint_from_int_b(9999);
+      bigint_mul();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(1)
+    expect(sc(rt, 'l1')).toBe(9998)
+  })
+
+  it('100000 * 100000 = 10^10: spans 3 limbs', () => {
+    // 10^10 = [0, 0, 0, 1, 0, ...] in base 10000 (1 * 10000^3 = 10^12? no)
+    // 10^10 / 10000^0 % 10000 = 0
+    // 10^10 / 10000^1 % 10000 = 0
+    // 10^10 / 10000^2 % 10000 = 10000 → wait: 10^10 / 10^8 = 100, 100 % 10000 = 100
+    // Actually: 10^10 = 100 * 10^8 = 100 * (10^4)^2
+    //   l0 = 10^10 % 10^4 = 0
+    //   l1 = floor(10^10 / 10^4) % 10^4 = floor(10^6) % 10000 = 0
+    //   l2 = floor(10^10 / 10^8) % 10^4 = 100 % 10000 = 100
+    const rt = run(`fn test() {
+      bigint_init();
+      bigint_from_int_a(100000);
+      bigint_from_int_b(100000);
+      bigint_mul();
+      scoreboard_set("out", "l0", bigint_get_c(0));
+      scoreboard_set("out", "l1", bigint_get_c(1));
+      scoreboard_set("out", "l2", bigint_get_c(2));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(0)
+    expect(sc(rt, 'l1')).toBe(0)
+    expect(sc(rt, 'l2')).toBe(100)
+  })
+})
+
+// ── bigint_fib ────────────────────────────────────────────────────────────────
+
+describe('bigint_fib', () => {
+  it('F(0) = 0', () => {
+    const rt = run(`fn test() {
+      bigint_fib(0);
+      scoreboard_set("out", "r", bigint_get_a(0));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(0)
+  })
+
+  it('F(1) = 1', () => {
+    const rt = run(`fn test() {
+      bigint_fib(1);
+      scoreboard_set("out", "r", bigint_get_a(0));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(1)
+  })
+
+  it('F(10) = 55', () => {
+    const rt = run(`fn test() {
+      bigint_fib(10);
+      scoreboard_set("out", "r", bigint_get_a(0));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(55)
+  })
+
+  it('F(20) = 6765', () => {
+    const rt = run(`fn test() {
+      bigint_fib(20);
+      scoreboard_set("out", "r", bigint_get_a(0));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'r')).toBe(6765)
+  })
+
+  it('F(50) = 12586269025: limb0=9025, limb1=8626, limb2=125', () => {
+    // F(50) = 12,586,269,025
+    // 12586269025 % 10000 = 9025
+    // floor(12586269025 / 10000) % 10000 = 1258626 % 10000 = 8626
+    // floor(12586269025 / 10^8) = 125
+    const rt = run(`fn test() {
+      bigint_fib(50);
+      scoreboard_set("out", "l0", bigint_get_a(0));
+      scoreboard_set("out", "l1", bigint_get_a(1));
+      scoreboard_set("out", "l2", bigint_get_a(2));
+    }`)
+    rt.execFunction('test')
+    expect(sc(rt, 'l0')).toBe(9025)
+    expect(sc(rt, 'l1')).toBe(8626)
+    expect(sc(rt, 'l2')).toBe(125)
+  })
+
+  it('F(100) low limbs check', () => {
+    // F(100) = 354224848179261915075
+    // % 10000 = 5075
+    // floor / 10000 % 10000 = floor(35422484817926191.5075) % 10000 = ...
+    // Let's compute:
+    // 354224848179261915075 % 10000 = 5075
+    // floor(354224848179261915075 / 10000) = 35422484817926191507 (JS BigInt)
+    // 35422484817926191507 % 10000 = 1507
+    // floor(35422484817926191507 / 10000) = 3542248481792619 (roughly)
+    // % 10000 = 2619
+    const rt = run(`fn test() {
+      bigint_fib(100);
+      scoreboard_set("out", "l0", bigint_get_a(0));
+      scoreboard_set("out", "l1", bigint_get_a(1));
+      scoreboard_set("out", "l2", bigint_get_a(2));
+    }`)
+    rt.execFunction('test')
+    const f100 = BigInt('354224848179261915075')
+    const b = BigInt(10000)
+    expect(sc(rt, 'l0')).toBe(Number(f100 % b))
+    expect(sc(rt, 'l1')).toBe(Number((f100 / b) % b))
+    expect(sc(rt, 'l2')).toBe(Number((f100 / b / b) % b))
+  })
+})

package/src/cli.ts

@@ -29,7 +29,7 @@ function printUsage(): void {
 RedScript Compiler
 
 Usage:
-  redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--target <target>] [--no-dce]
+  redscript compile <file> [-o <out>] [--output-nbt <file>] [--namespace <ns>] [--scoreboard <obj>] [--target <target>] [--no-dce]
   redscript watch <dir> [-o <outdir>] [--namespace <ns>] [--hot-reload <url>]
   redscript check <file>
   redscript fmt <file.mcrs> [file2.mcrs ...]
@@ -54,6 +54,9 @@ Options:
   --target <target>      Output target: datapack (default), cmdblock, or structure
   --no-dce               Disable AST dead code elimination
   --no-mangle            Disable variable name mangling (use readable names)
+  --scoreboard <obj>     Scoreboard objective for variables (default: namespace).
+                         Each datapack automatically uses its namespace as the objective
+                         so multiple datapacks can coexist without collisions.
   --stats                Print optimizer statistics
   --hot-reload <url>     After each successful compile, POST to <url>/reload
                          (use with redscript-testharness; e.g. http://localhost:25561)
@@ -168,6 +171,7 @@ function parseArgs(args: string[]): {
   hotReload?: string
   dce?: boolean
   mangle?: boolean
+  scoreboardObjective?: string
 } {
   const result: ReturnType<typeof parseArgs> = { dce: true, mangle: true }
   let i = 0
@@ -199,6 +203,9 @@ function parseArgs(args: string[]): {
     } else if (arg === '--no-mangle') {
       result.mangle = false
       i++
+    } else if (arg === '--scoreboard') {
+      result.scoreboardObjective = args[++i]
+      i++
     } else if (arg === '--hot-reload') {
       result.hotReload = args[++i]
       i++
@@ -262,7 +269,8 @@ function compileCommand(
   target: string = 'datapack',
   showStats = false,
   dce = true,
-  mangle = true
+  mangle = true,
+  scoreboardObjective: string | undefined = undefined
 ): void {
   // Read source file
   if (!fs.existsSync(file)) {
@@ -274,7 +282,7 @@ function compileCommand(
 
   try {
     if (target === 'cmdblock') {
-      const result = compile(source, { namespace, filePath: file, dce, mangle })
+      const result = compile(source, { namespace, filePath: file, dce, mangle, scoreboardObjective })
       printWarnings(result.warnings)
 
       // Generate command block JSON
@@ -305,7 +313,7 @@ function compileCommand(
         printOptimizationStats(structure.stats)
       }
     } else {
-      const result = compile(source, { namespace, filePath: file, dce, mangle })
+      const result = compile(source, { namespace, filePath: file, dce, mangle, scoreboardObjective })
       printWarnings(result.warnings)
 
       // Default: generate datapack
@@ -508,7 +516,8 @@ async function main(): Promise<void> {
         target,
         parsed.stats,
         parsed.dce,
-        parsed.mangle
+        parsed.mangle,
+        parsed.scoreboardObjective  // undefined = derive from namespace in compile()
       )
       }
       break

package/src/codegen/mcfunction/index.ts

@@ -17,7 +17,7 @@
  */
 
 import type { IRBlock, IRFunction, IRInstr, IRModule, Operand, Terminator } from '../../ir/types'
-import { optimizeCommandFunctions, type OptimizationStats, createEmptyOptimizationStats, mergeOptimizationStats } from '../../optimizer/commands'
+import { optimizeCommandFunctions, setOptimizerObjective, type OptimizationStats, createEmptyOptimizationStats, mergeOptimizationStats } from '../../optimizer/commands'
 import { EVENT_TYPES, isEventTypeName, type EventTypeName } from '../../events/types'
 import { VarAllocator } from '../var-allocator'
 
@@ -25,7 +25,8 @@ import { VarAllocator } from '../var-allocator'
 // Utilities
 // ---------------------------------------------------------------------------
 
-const OBJ = 'rs'  // scoreboard objective name
+// Default scoreboard objective — overridden per-compilation via DatapackGenerationOptions.scoreboardObjective
+let OBJ = 'rs'
 
 function operandToScore(op: Operand, alloc: VarAllocator): string {
   if (op.kind === 'var')   return `${alloc.alloc(op.name)} ${OBJ}`
@@ -284,6 +285,10 @@ export interface DatapackGenerationResult {
 export interface DatapackGenerationOptions {
   optimizeCommands?: boolean
   mangle?: boolean
+  /** Scoreboard objective used for all scoreboard variables.
+   *  Defaults to 'rs'. Override per-datapack to avoid collisions
+   *  when multiple RedScript datapacks are loaded simultaneously. */
+  scoreboardObjective?: string
 }
 
 export function countMcfunctionCommands(files: DatapackFile[]): number {
@@ -354,7 +359,11 @@ export function generateDatapackWithStats(
   module: IRModule,
   options: DatapackGenerationOptions = {},
 ): DatapackGenerationResult {
-  const { optimizeCommands = true, mangle = false } = options
+  const { optimizeCommands = true, mangle = false, scoreboardObjective = 'rs' } = options
+  // Set module-level OBJ so all helper functions in this module use the correct objective.
+  // This is safe because compilation is synchronous.
+  OBJ = scoreboardObjective
+  setOptimizerObjective(scoreboardObjective)
   const alloc = new VarAllocator(mangle)
   const files: DatapackFile[] = []
   const advancements: DatapackFile[] = []
@@ -402,9 +411,9 @@ export function generateDatapackWithStats(
   for (const eventType of eventTypes) {
     const detection = EVENT_TYPES[eventType].detection
     if (eventType === 'PlayerDeath') {
-      loadLines.push('scoreboard objectives add rs.deaths deathCount')
+      loadLines.push(`scoreboard objectives add ${OBJ}.deaths deathCount`)
     } else if (eventType === 'EntityKill') {
-      loadLines.push('scoreboard objectives add rs.kills totalKillCount')
+      loadLines.push(`scoreboard objectives add ${OBJ}.kills totalKillCount`)
     } else if (eventType === 'ItemUse') {
       loadLines.push('# ItemUse detection requires a project-specific objective/tag setup')
     } else if (detection === 'tag' || detection === 'advancement') {