redscript-mc 1.2.27 → 1.2.28

package/dist/optimizer/commands.js

@@ -1,12 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setOptimizerObjective = setOptimizerObjective;
 exports.createEmptyOptimizationStats = createEmptyOptimizationStats;
 exports.mergeOptimizationStats = mergeOptimizationStats;
 exports.applyLICM = applyLICM;
 exports.applyCSE = applyCSE;
 exports.batchSetblocks = batchSetblocks;
 exports.optimizeCommandFunctions = optimizeCommandFunctions;
-const SCOREBOARD_READ_RE = /^execute store result score (\$[A-Za-z0-9_]+) rs run scoreboard players get (\S+) (\S+)$/;
+// Matches scoreboard reads for LICM/CSE — objective is captured in group 2
+// so the optimizer can reconstruct the command with the same objective.
+let _OBJ_PATTERN = 'rs';
+function setOptimizerObjective(obj) { _OBJ_PATTERN = obj; }
+function scoreboardReadRe() {
+    return new RegExp(`^execute store result score (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} run scoreboard players get (\\S+) (\\S+)$`);
+}
 const SCOREBOARD_WRITE_RE = /^(?:scoreboard players (?:set|add|remove|reset)\s+(\S+)\s+(\S+)|scoreboard players operation\s+(\S+)\s+(\S+)\s+[+\-*/%]?= )/;
 const EXECUTE_STORE_SCORE_RE = /^execute store result score (\S+) (\S+) run /;
 const FUNCTION_CALL_RE = /^execute as (.+) run function ([^:]+):(.+)$/;
@@ -95,7 +102,7 @@ function applyLICMInternal(functions) {
             const readInfo = new Map();
             const scoreboardWrites = new Set();
             for (const inner of loopFn.commands) {
-                const readMatch = inner.cmd.match(SCOREBOARD_READ_RE);
+                const readMatch = inner.cmd.match(scoreboardReadRe());
                 if (readMatch) {
                     const [, temp, player, objective] = readMatch;
                     const key = `${player} ${objective}`;
@@ -110,7 +117,7 @@ function applyLICMInternal(functions) {
                 for (const info of readInfo.values()) {
                     const matches = inner.cmd.match(TEMP_RE) ?? [];
                     const usageCount = matches.filter(name => name === info.temp).length;
-                    const isDef = inner.cmd.startsWith(`execute store result score ${info.temp} rs run scoreboard players get `);
+                    const isDef = inner.cmd.startsWith(`execute store result score ${info.temp} ${_OBJ_PATTERN} run scoreboard players get `);
                     if (!isDef) {
                         info.uses += usageCount;
                     }
@@ -134,7 +141,7 @@ function applyLICMInternal(functions) {
             const hoistedTemps = new Set(hoistable.map(item => item.temp));
             const rewrittenLoopCommands = [];
             for (const inner of loopFn.commands) {
-                const readMatch = inner.cmd.match(SCOREBOARD_READ_RE);
+                const readMatch = inner.cmd.match(scoreboardReadRe());
                 if (readMatch && hoistedTemps.has(readMatch[1])) {
                     continue;
                 }
@@ -142,7 +149,7 @@ function applyLICMInternal(functions) {
             }
             loopFn.commands = rewrittenLoopCommands;
             nextCommands.push(...hoistable.map(item => ({
-                cmd: `execute store result score ${item.temp} rs run scoreboard players get ${item.player} ${item.objective}`,
+                cmd: `execute store result score ${item.temp} ${_OBJ_PATTERN} run scoreboard players get ${item.player} ${item.objective}`,
             })), command);
             stats.licmHoists = (stats.licmHoists ?? 0) + hoistable.length;
             stats.licmLoopBodies = (stats.licmLoopBodies ?? 0) + 1;
@@ -152,9 +159,9 @@ function applyLICMInternal(functions) {
     return stats;
 }
 function extractArithmeticExpression(commands, index) {
-    const assign = commands[index]?.cmd.match(/^scoreboard players operation (\$[A-Za-z0-9_]+) rs = (\$[A-Za-z0-9_]+|\$const_-?\d+) rs$/) ??
-        commands[index]?.cmd.match(/^scoreboard players set (\$[A-Za-z0-9_]+) rs (-?\d+)$/);
-    const op = commands[index + 1]?.cmd.match(/^scoreboard players operation (\$[A-Za-z0-9_]+) rs ([+\-*/%]=) (\$[A-Za-z0-9_]+|\$const_-?\d+) rs$/);
+    const assign = commands[index]?.cmd.match(new RegExp(`^scoreboard players operation (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} = (\\$[A-Za-z0-9_]+|\\$const_-?\\d+) ${_OBJ_PATTERN}$`)) ??
+        commands[index]?.cmd.match(new RegExp(`^scoreboard players set (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} (-?\\d+)$`));
+    const op = commands[index + 1]?.cmd.match(new RegExp(`^scoreboard players operation (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} ([+\\-*/%]=) (\\$[A-Za-z0-9_]+|\\$const_-?\\d+) ${_OBJ_PATTERN}$`));
     if (!assign || !op || assign[1] !== op[1]) {
         return null;
     }
@@ -184,14 +191,14 @@ function applyCSEInternal(functions) {
         }
         for (let i = 0; i < commands.length; i++) {
             const command = commands[i];
-            const readMatch = command.cmd.match(SCOREBOARD_READ_RE);
+            const readMatch = command.cmd.match(scoreboardReadRe());
             if (readMatch) {
                 const [, dst, player, objective] = readMatch;
                 const key = `${player} ${objective}`;
                 const cached = readCache.get(key);
                 if (cached) {
                     stats.cseRedundantReads = (stats.cseRedundantReads ?? 0) + 1;
-                    rewritten.push({ ...command, cmd: `scoreboard players operation ${dst} rs = ${cached} rs` });
+                    rewritten.push({ ...command, cmd: `scoreboard players operation ${dst} ${_OBJ_PATTERN} = ${cached} ${_OBJ_PATTERN}` });
                 }
                 else {
                     readCache.set(key, dst);
@@ -205,7 +212,7 @@ function applyCSEInternal(functions) {
             if (expr) {
                 const cached = exprCache.get(expr.key);
                 if (cached) {
-                    rewritten.push({ ...commands[i], cmd: `scoreboard players operation ${expr.dst} rs = ${cached} rs` });
+                    rewritten.push({ ...commands[i], cmd: `scoreboard players operation ${expr.dst} ${_OBJ_PATTERN} = ${cached} ${_OBJ_PATTERN}` });
                     stats.cseArithmetic = (stats.cseArithmetic ?? 0) + 1;
                     i += 1;
                 }

package/dist/optimizer/structure.d.ts

@@ -1,5 +1,6 @@
 import type { IRCommand, IRFunction } from '../ir/types';
 import { type OptimizationStats } from './commands';
+export declare function setStructureObjective(obj: string): void;
 export declare function optimizeFunctionForStructure(fn: IRFunction, functions: Map<string, IRFunction>, namespace: string): IRCommand[];
 export declare function optimizeForStructure(functions: IRFunction[], namespace?: string): IRFunction[];
 export declare function optimizeForStructureWithStats(functions: IRFunction[], namespace?: string): {

package/dist/optimizer/structure.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setStructureObjective = setStructureObjective;
 exports.optimizeFunctionForStructure = optimizeFunctionForStructure;
 exports.optimizeForStructure = optimizeForStructure;
 exports.optimizeForStructureWithStats = optimizeForStructureWithStats;
 const commands_1 = require("./commands");
-const OBJ = 'rs';
+let OBJ = 'rs';
+function setStructureObjective(obj) {
+    OBJ = obj;
+    (0, commands_1.setOptimizerObjective)(obj);
+}
 const INLINE_THRESHOLD = 8;
 const BOP_OP = {
     '+': '+=',

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.0.31",
+  "version": "1.0.35",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.0.31",
+      "version": "1.0.35",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../"
@@ -23,7 +23,7 @@
     },
     "../..": {
       "name": "redscript-mc",
-      "version": "1.2.26",
+      "version": "1.2.27",
       "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.31",
+  "version": "1.0.35",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",

package/examples/math-showcase.mcrs

@@ -0,0 +1,146 @@
+// math-showcase.mcrs — Fancy math examples for README / demo
+// Run each fn individually:  /function mathshow:<name>
+//
+// Compile:  node dist/cli.js compile examples/math-showcase.mcrs -o <dp> --namespace mathshow
+
+import "../src/stdlib/math.mcrs"
+import "../src/stdlib/vec.mcrs"
+import "../src/stdlib/advanced.mcrs"
+import "../src/stdlib/bigint.mcrs"
+
+// ─── 1. Trig table — print sin & cos for 0°, 15°, 30° … 90° ────────────────
+// NOTE: sin_fixed/cos_fixed return values in ×1000 space (sin(30°) = 500, not 0.5).
+//       s*s + c*c ≈ 1000000 because (sin×1000)²+(cos×1000)² = 10⁶×(sin²+cos²) = 10⁶.
+//       Requires __load to have run (initializes the sin table).
+fn trig_table() {
+    say("§e=== Trig Table (×1000 fixed-point, needs __load) ===");
+    let deg: int = 0;
+    while (deg <= 90) {
+        let s: int = sin_fixed(deg);
+        let c: int = cos_fixed(deg);
+        say(f"  {deg}°  sin={s}  cos={c}  s²+c²={s*s + c*c}  (expect ~1000000)");
+        deg = deg + 15;
+    }
+}
+
+// ─── 2. Newton–Raphson sqrt — compare isqrt vs sqrt_fixed ──────────────────
+// isqrt(n)      → floor(sqrt(n)), raw integer
+// sqrt_fixed(x) → sqrt of x/1000 expressed in ×1000 format
+//                 e.g. sqrt_fixed(2000) = sqrt(2.0)×1000 = 1414
+//                 Input must be in ×1000 space. Max input ≈ 2147000 (before overflow).
+// NOTE: Each isqrt call runs a convergence loop (bits+guess+Newton).
+//       Large values = more loop iterations = more MC commands.
+//       Keep inputs moderate to stay under Paper's maxCommandChainLength (65536).
+fn sqrt_showcase() {
+    say("§e=== Integer Square Root (isqrt) ===");
+    say(f"  isqrt(2)       = {isqrt(2)}    (exact: 1)");
+    say(f"  isqrt(144)     = {isqrt(144)}  (exact: 12)");
+    say(f"  isqrt(10000)   = {isqrt(10000)} (exact: 100)");
+    say(f"  isqrt(1000000) = {isqrt(1000000)} (exact: 1000)");
+
+    say("§e=== Fixed-Point sqrt (input&output in ×1000) ===");
+    say(f"  sqrt_fixed(1000) = {sqrt_fixed(1000)} (sqrt(1.0) = 1.000)");
+    say(f"  sqrt_fixed(2000) = {sqrt_fixed(2000)} (sqrt(2.0) ≈ 1.414)");
+    say(f"  sqrt_fixed(4000) = {sqrt_fixed(4000)} (sqrt(4.0) = 2.000)");
+    say(f"  sqrt_fixed(9000) = {sqrt_fixed(9000)} (sqrt(9.0) = 3.000)");
+}
+
+// ─── 3. 2D vector geometry ──────────────────────────────────────────────────
+fn vector_showcase() {
+    say("§e=== 2D Vector Geometry ===");
+    // 3-4-5 right triangle
+    let d345: int = distance2d_fixed(0, 0, 300, 400);
+    say(f"  dist((0,0)→(300,400))  = {d345}  (expect 500)");
+    // unit circle
+    let d_unit: int = length2d_fixed(1000, 0);
+    say(f"  length(1000, 0)        = {d_unit}  (expect 1000)");
+    // atan2
+    say(f"  atan2(1000, 0)         = {atan2_fixed(1000, 0)}°  (expect 90)");
+    say(f"  atan2(1000, 1000)      = {atan2_fixed(1000, 1000)}°  (expect 45)");
+    say(f"  atan2(-1, 0)           = {atan2_fixed(-1, 0)}°  (expect 270)");
+    // dot product: orthogonal vectors → 0
+    say(f"  dot2d(1000,0, 0,1000)  = {dot2d(1000, 0, 0, 1000)}  (expect 0, orthogonal)");
+    say(f"  dot2d(1000,0, 1000,0)  = {dot2d(1000, 0, 1000, 0)}  (expect 1000000, parallel)");
+}
+
+// ─── 4. Number theory ───────────────────────────────────────────────────────
+fn number_theory() {
+    say("§e=== Number Theory ===");
+    say(f"  gcd(360, 252)         = {gcd(360, 252)}      (expect 36)");
+    say(f"  lcm(12, 18)           = {lcm(12, 18)}        (expect 36)");
+    say(f"  is_prime(97)          = {is_prime(97)}       (expect 1)");
+    say(f"  is_prime(100)         = {is_prime(100)}      (expect 0)");
+    say(f"  fib(20)               = {fib(20)}            (expect 6765)");
+    say(f"  collatz_steps(27)     = {collatz_steps(27)}  (expect 111)");
+    say(f"  digit_sum(123456789)  = {digit_sum(123456789)} (expect 45)");
+    say(f"  mod_pow(2, 10, 1000)  = {mod_pow(2, 10, 1000)} (expect 24)");
+    say(f"  mod_pow(7, 5, 13)     = {mod_pow(7, 5, 13)}    (expect 11)");
+}
+
+// ─── 5. Fixed-point interpolation & easing ──────────────────────────────────
+fn easing_showcase() {
+    say("§e=== Easing & Interpolation (t = 0..1000) ===");
+    let t: int = 0;
+    while (t <= 1000) {
+        let lin: int = lerp(0, 1000, t);
+        let sm:  int = smoothstep(0, 1000, t);
+        let smr: int = smootherstep(0, 1000, t);
+        say(f"  t={t}  lerp={lin}  smooth={sm}  smoother={smr}");
+        t = t + 250;
+    }
+}
+
+// ─── 6. Hash & noise ────────────────────────────────────────────────────────
+fn hash_showcase() {
+    say("§e=== Hash & Procedural Noise ===");
+    say(f"  hash_int(0)           = {hash_int(0)}");
+    say(f"  hash_int(1)           = {hash_int(1)}");
+    say(f"  hash_int(42)          = {hash_int(42)}");
+    say(f"  noise1d(0)            = {noise1d(0)}   (0..1000)");
+    say(f"  noise1d(100)          = {noise1d(100)}");
+    say(f"  noise1d(200)          = {noise1d(200)}");
+    say(f"  noise1d(300)          = {noise1d(300)}");
+}
+
+// ─── 7. BigInt Fibonacci — numbers beyond INT32 ─────────────────────────────
+fn bigint_showcase() {
+    say("§e=== BigInt — Arbitrary Precision (base 10000, 8 limbs) ===");
+    bigint_fib(50);
+    let l0: int = bigint_get_a(0);
+    let l1: int = bigint_get_a(1);
+    let l2: int = bigint_get_a(2);
+    say(f"  fib(50)  limbs: [{l2}][{l1}][{l0}]");
+    say(f"           = {l2}×10⁸ + {l1}×10⁴ + {l0}");
+    say(f"           = 12,586,269,025  (verify: l0=9025 l1=8626 l2=125)");
+
+    bigint_fib(70);
+    let m0: int = bigint_get_a(0);
+    let m1: int = bigint_get_a(1);
+    let m2: int = bigint_get_a(2);
+    let m3: int = bigint_get_a(3);
+    say(f"  fib(70)  limbs: [{m3}][{m2}][{m1}][{m0}]");
+    say(f"           = 190,392,490,709,135");
+}
+
+// ─── 8. Mandelbrot / Julia — fractals in integer arithmetic ─────────────────
+fn fractal_showcase() {
+    say("§e=== Mandelbrot & Julia (fixed-point, scale=1000) ===");
+    // Mandelbrot: does (cr, ci) escape in <max_iter> steps?
+    say(f"  mandelbrot_iter(0, 0, 64)         = {mandelbrot_iter(0, 0, 64)}  (inside, expect 64)");
+    say(f"  mandelbrot_iter(2000, 0, 64)      = {mandelbrot_iter(2000, 0, 64)}  (outside, < 64)");
+    say(f"  mandelbrot_iter(-500, 500, 64)    = {mandelbrot_iter(-500, 500, 64)}");
+    say(f"  julia_iter(0, 0, -500, 250, 64)  = {julia_iter(0, 0, -500, 250, 64)}");
+    say(f"  julia_iter(500, 0, -500, 250, 64)= {julia_iter(500, 0, -500, 250, 64)}");
+}
+
+// ─── 9. Run everything ──────────────────────────────────────────────────────
+fn run_all() {
+    trig_table();
+    sqrt_showcase();
+    vector_showcase();
+    number_theory();
+    easing_showcase();
+    hash_showcase();
+    bigint_showcase();
+    fractal_showcase();
+}

package/examples/readme-demo.mcrs

@@ -0,0 +1,92 @@
+// readme-demo.mcrs — RedScript v1.2.27 README visual showcase
+// What 55 lines of RedScript can do on a vanilla Minecraft server.
+//
+// Compile:  node dist/cli.js compile examples/readme-demo.mcrs -o <datapack> --namespace rsdemo
+// In-game:  /function rsdemo:start   (then record your gif)
+//           /function rsdemo:stop
+
+import "../src/stdlib/math.mcrs"
+
+let t:     int = 0;     // 0..359 degrees, 4° per tick = full cycle every 1.5 s
+let frame: int = 0;
+let on:    bool = false;
+
+@load fn _init() {
+    t = 0;
+    frame = 0;
+}
+
+@tick fn _wave_tick() {
+    if (!on) { return; }
+
+    t = (t + 4) % 360;
+    frame = frame + 1;
+
+    let s:   int = sin_fixed(t);        // -1000 .. 1000
+    let c:   int = cos_fixed(t);        // -1000 .. 1000
+    let mag: int = abs(s);              // 0 .. 1000
+
+    // ── Particle rings: spread values scale with sin(t) ─────────────────
+    // Inner ring — always visible, small tight shimmer
+    foreach (p in @a) at @s {
+        particle("minecraft:end_rod", ~0, ~1, ~0, 0.25, 0.08, 0.25, 0.02, 6);
+    }
+
+    // Mid ring — appears when sin > 0 (upper half of cycle)
+    if (s > 0) {
+        foreach (p in @a) at @s {
+            particle("minecraft:end_rod", ~0, ~1, ~0, 0.9, 0.25, 0.9, 0.02, 12);
+        }
+    }
+
+    // Outer ring + soul fire — sin > 600
+    if (s > 600) {
+        foreach (p in @a) at @s {
+            particle("minecraft:end_rod", ~0, ~1, ~0, 1.8, 0.4, 1.8, 0.02, 18);
+            particle("minecraft:soul_fire_flame", ~0, ~2, ~0, 0.9, 0.3, 0.9, 0.03, 8);
+        }
+    }
+
+    // Peak flash — fires ~4 ticks per cycle
+    if (s > 940) {
+        foreach (p in @a) at @s {
+            particle("minecraft:flash", ~0, ~3, ~0, 0.4, 0.3, 0.4, 0.1, 3);
+        }
+    }
+
+    // Negative trough — ground portal swirl
+    if (s < -700) {
+        foreach (p in @a) at @s {
+            particle("minecraft:portal", ~0, ~0.5, ~0, 1.2, 0.4, 1.2, 0.05, 12);
+        }
+    }
+
+    // ── Actionbar: live math rotating every 3 s ──────────────────────────
+    let seg: int = (frame / 45) % 4;
+    if (seg == 0) {
+        actionbar(@a, f"§3⚡ §bsin({t}°) = §e{s}‰   cos({t}°) = §e{c}‰");
+    }
+    if (seg == 1) {
+        actionbar(@a, f"§3⚡ §bsmoothstep(|sin|) = §e{smoothstep(0, 1000, mag)}‰   isqrt({frame}) = §e{isqrt(frame)}");
+    }
+    if (seg == 2) {
+        actionbar(@a, f"§3⚡ §bgcd(360, {t + 1}) = §e{gcd(360, t + 1)}   log2({mag + 1}) = §e{log2_int(mag + 1)}");
+    }
+    if (seg == 3) {
+        actionbar(@a, f"§3⚡ §bpow(2, {(frame / 30) % 10 + 1}) = §e{pow_int(2, (frame / 30) % 10 + 1)}   clamp(sin) = §e{clamp(s, -500, 500)}");
+    }
+}
+
+fn start() {
+    on = true;
+    t = 0;
+    frame = 0;
+    title(@a, f"§e✦ §bRedScript§e ✦", f"§7trig-driven particle rings");
+    say("§a▶ readme-demo started  — /function rsdemo:stop to end");
+}
+
+fn stop() {
+    on = false;
+    actionbar(@a, f"§7[ demo stopped ]");
+    say("§c■ readme-demo stopped");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.2.27",
+  "version": "1.2.28",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/__tests__/cli.test.ts

@@ -55,7 +55,7 @@ describe('CLI API', () => {
       const result = compile(source, { namespace: 'mygame', filePath: mainPath })
       const tickTimer = result.files.find(file => file.path.endsWith('/tick_timer.mcfunction'))
 
-      expect(tickTimer?.content).toContain('scoreboard players set #rs rs.timer_ticks 1')
+      expect(tickTimer?.content).toContain('scoreboard players set #rs mygame.timer_ticks 1')
     })
 
     it('adds a call-site hash for stdlib internal scoreboard objectives', () => {
@@ -89,7 +89,7 @@ describe('CLI API', () => {
       expect(timerFns).toHaveLength(2)
 
       const objectives = timerFns
-        .flatMap(file => [...file.content.matchAll(/rs\._timer_([0-9a-f]{4})/g)].map(match => match[0]))
+        .flatMap(file => [...file.content.matchAll(/mygame\._timer_([0-9a-f]{4})/g)].map(match => match[0]))
 
       expect(new Set(objectives).size).toBe(2)
     })
@@ -113,8 +113,8 @@ describe('CLI API', () => {
 
       expect(result.typeErrors).toEqual([])
       const newFn = result.files.find(file => file.path.endsWith('/Timer_new.mcfunction'))
-      expect(newFn?.content).toContain('scoreboard players set timer_ticks rs 0')
-      expect(newFn?.content).toContain('scoreboard players set timer_active rs 0')
+      expect(newFn?.content).toContain('scoreboard players set timer_ticks timernew 0')
+      expect(newFn?.content).toContain('scoreboard players set timer_active timernew 0')
     })
 
     it('Timer.start/pause/reset', () => {
@@ -142,9 +142,9 @@ describe('CLI API', () => {
       const pauseFn = result.files.find(file => file.path.endsWith('/Timer_pause.mcfunction'))
       const resetFn = result.files.find(file => file.path.endsWith('/Timer_reset.mcfunction'))
 
-      expect(startFn?.content).toContain('scoreboard players set timer_active rs 1')
-      expect(pauseFn?.content).toContain('scoreboard players set timer_active rs 0')
-      expect(resetFn?.content).toContain('scoreboard players set timer_ticks rs 0')
+      expect(startFn?.content).toContain('scoreboard players set timer_active timerstate 1')
+      expect(pauseFn?.content).toContain('scoreboard players set timer_active timerstate 0')
+      expect(resetFn?.content).toContain('scoreboard players set timer_ticks timerstate 0')
     })
 
     it('Timer.done returns bool', () => {
@@ -171,9 +171,9 @@ describe('CLI API', () => {
       expect(result.typeErrors).toEqual([])
       const doneFn = result.files.find(file => file.path.endsWith('/Timer_done.mcfunction'))
       const mainFn = result.files.find(file => file.path.endsWith('/main.mcfunction'))
-      expect(doneFn?.content).toContain('scoreboard players get timer_ticks rs')
+      expect(doneFn?.content).toContain('scoreboard players get timer_ticks timerdone')
       expect(doneFn?.content).toContain('return run scoreboard players get')
-      expect(mainFn?.content).toContain('execute if score $main_finished rs matches 1..')
+      expect(mainFn?.content).toContain('execute if score $main_finished timerdone matches 1..')
     })
 
     it('Timer.tick increments', () => {
@@ -201,10 +201,10 @@ describe('CLI API', () => {
         .map(file => file.content)
         .join('\n')
 
-      expect(tickOutput).toContain('scoreboard players get timer_active rs')
-      expect(tickOutput).toContain('scoreboard players get timer_ticks rs')
-      expect(tickOutput).toContain(' += $const_1 rs')
-      expect(tickOutput).toContain('execute store result score timer_ticks rs run scoreboard players get $_')
+      expect(tickOutput).toContain('scoreboard players get timer_active timertick')
+      expect(tickOutput).toContain('scoreboard players get timer_ticks timertick')
+      expect(tickOutput).toContain(' += $const_1 timertick')
+      expect(tickOutput).toContain('execute store result score timer_ticks timertick run scoreboard players get $_')
     })
   })
 

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

@@ -28,7 +28,7 @@ fn turret_tick() {
     const parent = getFileContent(result.files, 'data/test/function/turret_tick.mcfunction')
     const loopBody = getFileContent(result.files, 'data/test/function/turret_tick/foreach_0.mcfunction')
 
-    const hoistedRead = 'execute store result score $_0 rs run scoreboard players get config test.turret_range'
+    const hoistedRead = 'execute store result score $_0 test run scoreboard players get config test.turret_range'
     const executeCall = 'execute as @e[tag=turret] run function test:turret_tick/foreach_0'
 
     expect(parent).toContain(hoistedRead)
@@ -54,7 +54,7 @@ fn read_twice() {
     const readMatches = fn.match(/scoreboard players get @s test\.coins/g) ?? []
 
     expect(readMatches).toHaveLength(1)
-    expect(fn).toContain('scoreboard players operation $_1 rs = $_0 rs')
+    expect(fn).toContain('scoreboard players operation $_1 test = $_0 test')
   })
 
   test('reuses duplicate arithmetic sequences', () => {
@@ -71,10 +71,10 @@ fn math() {
 
     const result = compile(source, { namespace: 'test' })
     const fn = getFileContent(result.files, 'data/test/function/math.mcfunction')
-    const addMatches = fn.match(/\+= \$const_2 rs/g) ?? []
+    const addMatches = fn.match(/\+= \$const_2 test/g) ?? []
 
     expect(addMatches).toHaveLength(1)
-    expect(fn).toContain('scoreboard players operation $_1 rs = $_0 rs')
+    expect(fn).toContain('scoreboard players operation $_1 test = $_0 test')
   })
 })
 

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') {