redscript-mc 1.2.27 → 1.2.29

package/editors/vscode/package-lock.json

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

package/editors/vscode/src/hover.ts

@@ -1009,6 +1009,24 @@ export function registerHoverProvider(context: vscode.ExtensionContext): void {
       provideHover(document, position) {
         const line = document.lineAt(position.line).text
 
+        // ── #rs — special compiler token ────────────────────────
+        const rsRange = document.getWordRangeAtPosition(position, /#rs\b/)
+        if (rsRange) {
+          const md = new vscode.MarkdownString('', true)
+          md.isTrusted = true
+          md.appendCodeblock('#rs', 'redscript')
+          md.appendMarkdown('**RS Internal Scoreboard Objective** *(compiler token)*\n\n')
+          md.appendMarkdown('Resolves to the current datapack\'s internal scoreboard objective at compile time.\n\n')
+          md.appendMarkdown('Default: `__<namespace>` (e.g. `__mygame` for namespace `mygame`).\n\n')
+          md.appendMarkdown('Use `#rs` in `scoreboard_get` / `scoreboard_set` when you need to read or write\n')
+          md.appendMarkdown('the compiler\'s own variable slots — such as in stdlib implementations.\n\n')
+          md.appendMarkdown('> ⚠️ Unlike other `#name` tokens, `#rs` does **not** compile to the literal string `rs`.\n')
+          md.appendMarkdown('> It tracks the `--scoreboard` flag or the `__<namespace>` default.\n\n')
+          md.appendMarkdown('**Example:**\n')
+          md.appendCodeblock('scoreboard_set("timer_ticks", #rs, 0);\n// compiles to: scoreboard players set timer_ticks __mygame 0', 'redscript')
+          return new vscode.Hover(md, rsRange)
+        }
+
         // ── #mc_name hover ──────────────────────────────────────
         const mcRange = document.getWordRangeAtPosition(position, /#[a-zA-Z_][a-zA-Z0-9_]*/)
         if (mcRange) {

package/editors/vscode/syntaxes/redscript.tmLanguage.json

@@ -307,9 +307,18 @@
     },
 
     "mc-name": {
-      "comment": "#objective, #tag, #team — unquoted MC identifier literal",
-      "name": "variable.other.mc-name.redscript",
-      "match": "#[a-zA-Z_][a-zA-Z0-9_]*"
+      "comment": "#objective, #tag, #team — unquoted MC identifier literal. #rs is the special RS-internal scoreboard objective token.",
+      "patterns": [
+        {
+          "comment": "#rs — special compiler token: resolves to the current datapack's internal scoreboard objective (__<namespace>)",
+          "name": "support.constant.rs-objective.redscript",
+          "match": "#rs\\b"
+        },
+        {
+          "name": "variable.other.mc-name.redscript",
+          "match": "#[a-zA-Z_][a-zA-Z0-9_]*"
+        }
+      ]
     },
 
     "operators": {

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.29",
   "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') {

package/src/compile.ts

@@ -9,7 +9,7 @@ import * as path from 'path'
 
 import { Lexer } from './lexer'
 import { Parser } from './parser'
-import { Lowering } from './lowering'
+import { Lowering, setScoreboardObjective } from './lowering'
 import { optimize } from './optimizer/passes'
 import { eliminateDeadCode } from './optimizer/dce'
 import { generateDatapackWithStats, DatapackFile } from './codegen/mcfunction'
@@ -27,6 +27,11 @@ export interface CompileOptions {
   optimize?: boolean
   dce?: boolean
   mangle?: boolean
+  /** Scoreboard objective used for all variable slots.
+   *  Defaults to '__<namespace>' (e.g. '__mathshow') — the double-underscore
+   *  prefix signals compiler-internal and avoids occupying the user's namespace.
+   *  Each datapack gets a unique objective automatically; no manual setup needed. */
+  scoreboardObjective?: string
   /** Additional source files that should be treated as *library* code.
    *  Functions in these files are DCE-eligible: they are only compiled into
    *  the datapack when actually called from user code.  Each string is parsed
@@ -262,6 +267,12 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
     const dceResult = shouldRunDce ? eliminateDeadCode(parsedAst) : { program: parsedAst, warnings: [] }
     const ast = dceResult.program
 
+    // Configure scoreboard objective for this compilation.
+    // Default: use the datapack namespace so each datapack gets its own objective
+    // automatically, preventing variable collisions when multiple datapacks coexist.
+    const scoreboardObj = options.scoreboardObjective ?? `__${namespace}`
+    setScoreboardObjective(scoreboardObj)
+
     // Lowering
     const ir = new Lowering(namespace, preprocessed.ranges).lower(ast)
 
@@ -272,7 +283,10 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
 
     // Code generation — mangle=true by default to prevent cross-function
     // scoreboard variable collisions in the global MC scoreboard namespace.
-    const generated = generateDatapackWithStats(optimized, { mangle: options.mangle ?? true })
+    const generated = generateDatapackWithStats(optimized, {
+      mangle: options.mangle ?? true,
+      scoreboardObjective: scoreboardObj,
+    })
 
     return {
       success: true,