redscript-mc 1.2.27 → 1.2.29

package/src/index.ts

@@ -10,7 +10,7 @@ export const version = '1.2.11'
 import { Lexer } from './lexer'
 import { Parser } from './parser'
 import { TypeChecker } from './typechecker'
-import { Lowering } from './lowering'
+import { Lowering, setScoreboardObjective } from './lowering'
 import type { Warning } from './lowering'
 import {
   constantFoldingWithStats,
@@ -36,6 +36,11 @@ export interface CompileOptions {
   filePath?: string
   dce?: boolean
   mangle?: boolean
+  /** Scoreboard objective used for all variable slots.
+   *  Defaults to '__<namespace>' (e.g. '__mathshow') to avoid collisions when
+   *  multiple RedScript datapacks are loaded simultaneously, without occupying
+   *  the user's own namespace. Override only if you need a specific name. */
+  scoreboardObjective?: string
 }
 
 export interface CompileResult {
@@ -101,12 +106,18 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
     typeErrors = checker.check(ast)
   }
 
+  // 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 to IR
   const lowering = new Lowering(namespace, preprocessed.ranges)
   const ir = lowering.lower(ast)
 
   let optimizedIR: IRModule = ir
-  let generated = generateDatapackWithStats(ir, { optimizeCommands: shouldOptimize, mangle })
+  let generated = generateDatapackWithStats(ir, { optimizeCommands: shouldOptimize, mangle, scoreboardObjective: scoreboardObj })
   let optimizationStats: OptimizationStats | undefined
 
   if (shouldOptimize) {
@@ -128,10 +139,10 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
     const copyPropagatedIR: IRModule = { ...ir, functions: copyPropagatedFunctions }
     optimizedIR = { ...ir, functions: deadCodeEliminatedFunctions }
 
-    const baselineGenerated = generateDatapackWithStats(ir, { optimizeCommands: false, mangle })
-    const beforeDceGenerated = generateDatapackWithStats(copyPropagatedIR, { optimizeCommands: false, mangle })
-    const afterDceGenerated = generateDatapackWithStats(optimizedIR, { optimizeCommands: false, mangle })
-    generated = generateDatapackWithStats(optimizedIR, { optimizeCommands: true, mangle })
+    const baselineGenerated = generateDatapackWithStats(ir, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
+    const beforeDceGenerated = generateDatapackWithStats(copyPropagatedIR, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
+    const afterDceGenerated = generateDatapackWithStats(optimizedIR, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
+    generated = generateDatapackWithStats(optimizedIR, { optimizeCommands: true, mangle, scoreboardObjective: scoreboardObj })
 
     stats.deadCodeRemoved =
       countMcfunctionCommands(beforeDceGenerated.files) - countMcfunctionCommands(afterDceGenerated.files)
@@ -147,7 +158,7 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
     optimizationStats = stats
   } else {
     optimizedIR = ir
-    generated = generateDatapackWithStats(ir, { optimizeCommands: false, mangle })
+    generated = generateDatapackWithStats(ir, { optimizeCommands: false, mangle, scoreboardObjective: scoreboardObj })
   }
 
   return {

package/src/lowering/index.ts

@@ -29,6 +29,15 @@ import { getBaseSelectorType, areCompatibleTypes, getConcreteSubtypes } from '..
 // All builtins support macro parameters - any arg that's a function param
 // will automatically use MC 1.20.2+ macro syntax when needed
 
+// ---------------------------------------------------------------------------
+// Scoreboard Objective
+// Set per-compilation via setScoreboardObjective() — defaults to 'rs'.
+// ---------------------------------------------------------------------------
+
+/** Current scoreboard objective. Set once per compile() call. */
+export let LOWERING_OBJ = 'rs'
+export function setScoreboardObjective(obj: string): void { LOWERING_OBJ = obj }
+
 // ---------------------------------------------------------------------------
 // Builtin Functions
 // ---------------------------------------------------------------------------
@@ -50,9 +59,13 @@ const BUILTINS: Record<string, (args: string[]) => string | null> = {
     const pos = [x ?? '~', y ?? '~', z ?? '~'].join(' ')
     return nbt ? `summon ${type} ${pos} ${nbt}` : `summon ${type} ${pos}`
   },
-  particle: ([name, x, y, z]) => {
+  particle: ([name, x, y, z, dx, dy, dz, speed, count]) => {
     const pos = [x ?? '~', y ?? '~', z ?? '~'].join(' ')
-    return `particle ${name} ${pos}`
+    // dx/dy/dz/speed/count are optional; omit trailing undefineds
+    const extra = [dx, dy, dz, speed, count].filter(v => v !== undefined && v !== null)
+    return extra.length > 0
+      ? `particle ${name} ${pos} ${extra.join(' ')}`
+      : `particle ${name} ${pos}`
   },
   playsound:  ([sound, source, sel, x, y, z, volume, pitch, minVolume]) =>
     ['playsound', sound, source, sel, x, y, z, volume, pitch, minVolume].filter(Boolean).join(' '),
@@ -465,6 +478,16 @@ export class Lowering {
     if (expr.kind === 'struct_lit' || expr.kind === 'array_lit') {
       return { str: this.exprToSnbt(expr) }
     }
+    // Float literals: preserve the float value for MC commands that accept floats
+    // (particle spread, playsound volume/pitch, etc.)
+    // We do NOT truncate here — that only applies to scoreboard/IR contexts.
+    if (expr.kind === 'float_lit') {
+      return { str: expr.value.toString() }
+    }
+    // Unary minus applied to a float literal (e.g. -0.5)
+    if (expr.kind === 'unary' && expr.op === '-' && expr.operand.kind === 'float_lit') {
+      return { str: (-expr.operand.value).toString() }
+    }
     return { str: this.exprToString(expr) }
   }
 
@@ -485,9 +508,9 @@ export class Lowering {
     for (let i = 0; i < loweredArgs.length; i++) {
       const operand = loweredArgs[i]
       if (operand.kind === 'const') {
-        this.builder.emitRaw(`scoreboard players set $p${i} rs ${operand.value}`)
+        this.builder.emitRaw(`scoreboard players set $p${i} ${LOWERING_OBJ} ${operand.value}`)
       } else if (operand.kind === 'var') {
-        this.builder.emitRaw(`scoreboard players operation $p${i} rs = ${operand.name} rs`)
+        this.builder.emitRaw(`scoreboard players operation $p${i} ${LOWERING_OBJ} = ${operand.name} ${LOWERING_OBJ}`)
       }
     }
 
@@ -501,7 +524,7 @@ export class Lowering {
         this.builder.emitRaw(`data modify storage rs:macro_args ${macroParam} set value ${operand.value}`)
       } else if (operand.kind === 'var') {
         this.builder.emitRaw(
-          `execute store result storage rs:macro_args ${macroParam} int 1 run scoreboard players get ${operand.name} rs`
+          `execute store result storage rs:macro_args ${macroParam} int 1 run scoreboard players get ${operand.name} ${LOWERING_OBJ}`
         )
       }
     }
@@ -511,7 +534,7 @@ export class Lowering {
 
     // Copy return value (callers may use it)
     const dst = this.builder.freshTemp()
-    this.builder.emitRaw(`scoreboard players operation ${dst} rs = $ret rs`)
+    this.builder.emitRaw(`scoreboard players operation ${dst} ${LOWERING_OBJ} = $ret ${LOWERING_OBJ}`)
     return { kind: 'var', name: dst }
   }
 
@@ -792,7 +815,7 @@ export class Lowering {
     const originalTerm = entry.term
 
     entry.instrs = [
-      { op: 'raw', cmd: `scoreboard players add ${counterVar} rs 1` },
+      { op: 'raw', cmd: `scoreboard players add ${counterVar} ${LOWERING_OBJ} 1` },
     ]
 
     // Create conditional jump
@@ -809,14 +832,14 @@ export class Lowering {
     // Add check instruction
     entry.instrs.push({
       op: 'raw',
-      cmd: `execute store success score ${counterVar}_check rs if score ${counterVar} rs matches ${rate}..`,
+      cmd: `execute store success score ${counterVar}_check ${LOWERING_OBJ} if score ${counterVar} ${LOWERING_OBJ} matches ${rate}..`,
     })
 
     // Body block (original logic + counter reset)
     fn.blocks.push({
       label: bodyLabel,
       instrs: [
-        { op: 'raw', cmd: `scoreboard players set ${counterVar} rs 0` },
+        { op: 'raw', cmd: `scoreboard players set ${counterVar} ${LOWERING_OBJ} 0` },
         ...originalInstrs,
       ],
       term: originalTerm,
@@ -943,7 +966,7 @@ export class Lowering {
           this.builder.emitRaw(`data modify storage ${path} set value ${fieldValue.value}`)
         } else if (fieldValue.kind === 'var') {
           // Copy from scoreboard to NBT
-          this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} rs`)
+          this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} ${LOWERING_OBJ}`)
         }
       }
       return
@@ -977,7 +1000,7 @@ export class Lowering {
           this.builder.emitRaw(`data modify storage rs:heap ${stmt.name} append value ${elemValue.value}`)
         } else if (elemValue.kind === 'var') {
           this.builder.emitRaw(`data modify storage rs:heap ${stmt.name} append value 0`)
-          this.builder.emitRaw(`execute store result storage rs:heap ${stmt.name}[-1] int 1 run scoreboard players get ${elemValue.name} rs`)
+          this.builder.emitRaw(`execute store result storage rs:heap ${stmt.name}[-1] int 1 run scoreboard players get ${elemValue.name} ${LOWERING_OBJ}`)
         }
       }
       return
@@ -1028,7 +1051,7 @@ export class Lowering {
           if (fieldValue.kind === 'const') {
             this.builder.emitRaw(`data modify storage ${path} set value ${fieldValue.value}`)
           } else if (fieldValue.kind === 'var') {
-            this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} rs`)
+            this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${fieldValue.name} ${LOWERING_OBJ}`)
           }
         }
         this.builder.emitReturn({ kind: 'const', value: 0 })
@@ -1247,9 +1270,9 @@ export class Lowering {
     this.varMap.set(stmt.varName, loopVar)
     const startVal = this.lowerExpr(stmt.start)
     if (startVal.kind === 'const') {
-      this.builder.emitRaw(`scoreboard players set ${loopVar} rs ${startVal.value}`)
+      this.builder.emitRaw(`scoreboard players set ${loopVar} ${LOWERING_OBJ} ${startVal.value}`)
     } else if (startVal.kind === 'var') {
-      this.builder.emitRaw(`scoreboard players operation ${loopVar} rs = ${startVal.name} rs`)
+      this.builder.emitRaw(`scoreboard players operation ${loopVar} ${LOWERING_OBJ} = ${startVal.name} ${LOWERING_OBJ}`)
     }
 
     // Call loop function
@@ -1272,12 +1295,12 @@ export class Lowering {
     this.lowerBlock(stmt.body)
 
     // Increment
-    this.builder.emitRaw(`scoreboard players add ${loopVar} rs 1`)
+    this.builder.emitRaw(`scoreboard players add ${loopVar} ${LOWERING_OBJ} 1`)
 
     // Loop condition: execute if score matches ..<end-1> run function
     const endVal = this.lowerExpr(stmt.end)
     const endNum = endVal.kind === 'const' ? endVal.value - 1 : '?'
-    this.builder.emitRaw(`execute if score ${loopVar} rs matches ..${endNum} run function ${this.namespace}:${subFnName}`)
+    this.builder.emitRaw(`execute if score ${loopVar} ${LOWERING_OBJ} matches ..${endNum} run function ${this.namespace}:${subFnName}`)
 
     if (!this.builder.isBlockSealed()) {
       this.builder.emitReturn()
@@ -1382,13 +1405,13 @@ export class Lowering {
       }
 
       const subFnName = `${this.currentFn}/match_${this.foreachCounter++}`
-      this.builder.emitRaw(`execute if score ${matchedVar} rs matches ..0 if score ${subject} rs matches ${matchCondition} run function ${this.namespace}:${subFnName}`)
+      this.builder.emitRaw(`execute if score ${matchedVar} ${LOWERING_OBJ} matches ..0 if score ${subject} ${LOWERING_OBJ} matches ${matchCondition} run function ${this.namespace}:${subFnName}`)
       this.emitMatchArmSubFunction(subFnName, matchedVar, arm.body, true)
     }
 
     if (defaultArm) {
       const subFnName = `${this.currentFn}/match_${this.foreachCounter++}`
-      this.builder.emitRaw(`execute if score ${matchedVar} rs matches ..0 run function ${this.namespace}:${subFnName}`)
+      this.builder.emitRaw(`execute if score ${matchedVar} ${LOWERING_OBJ} matches ..0 run function ${this.namespace}:${subFnName}`)
       this.emitMatchArmSubFunction(subFnName, matchedVar, defaultArm.body, false)
     }
   }
@@ -1406,7 +1429,7 @@ export class Lowering {
 
     this.builder.startBlock('entry')
     if (setMatched) {
-      this.builder.emitRaw(`scoreboard players set ${matchedVar} rs 1`)
+      this.builder.emitRaw(`scoreboard players set ${matchedVar} ${LOWERING_OBJ} 1`)
     }
     this.lowerBlock(body)
     if (!this.builder.isBlockSealed()) {
@@ -1445,7 +1468,7 @@ export class Lowering {
 
     this.builder.emitAssign(indexVar, { kind: 'const', value: 0 })
     this.builder.emitAssign(oneVar, { kind: 'const', value: 1 })
-    this.builder.emitRaw(`execute store result score ${lengthVar} rs run data get storage rs:heap ${arrayName}`)
+    this.builder.emitRaw(`execute store result score ${lengthVar} ${LOWERING_OBJ} run data get storage rs:heap ${arrayName}`)
 
     const checkLabel = this.builder.freshLabel('foreach_array_check')
     const bodyLabel = this.builder.freshLabel('foreach_array_body')
@@ -1462,7 +1485,7 @@ export class Lowering {
     this.builder.emitAssign(bindingVar, element)
     this.lowerBlock(stmt.body)
     if (!this.builder.isBlockSealed()) {
-      this.builder.emitRaw(`scoreboard players operation ${indexVar} rs += ${oneVar} rs`)
+      this.builder.emitRaw(`scoreboard players operation ${indexVar} ${LOWERING_OBJ} += ${oneVar} ${LOWERING_OBJ}`)
       this.builder.emitJump(checkLabel)
     }
 
@@ -1841,7 +1864,7 @@ export class Lowering {
       if (mapped && mapped.startsWith('@e[tag=__rs_obj_')) {
         // World object field access → scoreboard get
         const dst = this.builder.freshTemp()
-        this.builder.emitRaw(`scoreboard players operation ${dst} rs = ${mapped} rs`)
+        this.builder.emitRaw(`scoreboard players operation ${dst} ${LOWERING_OBJ} = ${mapped} ${LOWERING_OBJ}`)
         return { kind: 'var', name: dst }
       }
 
@@ -1850,14 +1873,14 @@ export class Lowering {
         const path = `rs:heap ${structName}_${expr.obj.name}.${expr.field}`
         const dst = this.builder.freshTemp()
         // Read from NBT storage into scoreboard
-        this.builder.emitRaw(`execute store result score ${dst} rs run data get storage ${path}`)
+        this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} run data get storage ${path}`)
         return { kind: 'var', name: dst }
       }
 
       // Array length property
       if (varType?.kind === 'array' && expr.field === 'len') {
         const dst = this.builder.freshTemp()
-        this.builder.emitRaw(`execute store result score ${dst} rs run data get storage rs:heap ${expr.obj.name}`)
+        this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} run data get storage rs:heap ${expr.obj.name}`)
         return { kind: 'var', name: dst }
       }
     }
@@ -1876,9 +1899,9 @@ export class Lowering {
         const value = this.lowerExpr(expr.value)
         if (expr.op === '=') {
           if (value.kind === 'const') {
-            this.builder.emitRaw(`scoreboard players set ${mapped} rs ${value.value}`)
+            this.builder.emitRaw(`scoreboard players set ${mapped} ${LOWERING_OBJ} ${value.value}`)
           } else if (value.kind === 'var') {
-            this.builder.emitRaw(`scoreboard players operation ${mapped} rs = ${value.name} rs`)
+            this.builder.emitRaw(`scoreboard players operation ${mapped} ${LOWERING_OBJ} = ${value.name} ${LOWERING_OBJ}`)
           }
         } else {
           // Compound assignment
@@ -1887,9 +1910,9 @@ export class Lowering {
           if (value.kind === 'const') {
             const constTemp = this.builder.freshTemp()
             this.builder.emitAssign(constTemp, value)
-            this.builder.emitRaw(`scoreboard players operation ${mapped} rs ${opMap[binOp]} ${constTemp} rs`)
+            this.builder.emitRaw(`scoreboard players operation ${mapped} ${LOWERING_OBJ} ${opMap[binOp]} ${constTemp} ${LOWERING_OBJ}`)
           } else if (value.kind === 'var') {
-            this.builder.emitRaw(`scoreboard players operation ${mapped} rs ${opMap[binOp]} ${value.name} rs`)
+            this.builder.emitRaw(`scoreboard players operation ${mapped} ${LOWERING_OBJ} ${opMap[binOp]} ${value.name} ${LOWERING_OBJ}`)
           }
         }
         return { kind: 'const', value: 0 }
@@ -1904,15 +1927,15 @@ export class Lowering {
           if (value.kind === 'const') {
             this.builder.emitRaw(`data modify storage ${path} set value ${value.value}`)
           } else if (value.kind === 'var') {
-            this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${value.name} rs`)
+            this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${value.name} ${LOWERING_OBJ}`)
           }
         } else {
           // Compound assignment: read, modify, write back
           const dst = this.builder.freshTemp()
-          this.builder.emitRaw(`execute store result score ${dst} rs run data get storage ${path}`)
+          this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} run data get storage ${path}`)
           const binOp = expr.op.slice(0, -1)
           this.builder.emitBinop(dst, { kind: 'var', name: dst }, binOp as any, value)
-          this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${dst} rs`)
+          this.builder.emitRaw(`execute store result storage ${path} int 1 run scoreboard players get ${dst} ${LOWERING_OBJ}`)
         }
         return { kind: 'const', value: 0 }
       }
@@ -1945,13 +1968,13 @@ export class Lowering {
         this.builder.emitAssign(dst, left)
         const rightVar = this.operandToVar(right)
         // dst = dst && right → if dst != 0 then dst = right
-        this.builder.emitRaw(`execute if score ${dst} rs matches 1.. run scoreboard players operation ${dst} rs = ${rightVar} rs`)
+        this.builder.emitRaw(`execute if score ${dst} ${LOWERING_OBJ} matches 1.. run scoreboard players operation ${dst} ${LOWERING_OBJ} = ${rightVar} ${LOWERING_OBJ}`)
       } else {
         // Short-circuit OR
         this.builder.emitAssign(dst, left)
         const rightVar = this.operandToVar(right)
         // dst = dst || right → if dst == 0 then dst = right
-        this.builder.emitRaw(`execute if score ${dst} rs matches ..0 run scoreboard players operation ${dst} rs = ${rightVar} rs`)
+        this.builder.emitRaw(`execute if score ${dst} ${LOWERING_OBJ} matches ..0 run scoreboard players operation ${dst} ${LOWERING_OBJ} = ${rightVar} ${LOWERING_OBJ}`)
       }
       return { kind: 'var', name: dst }
     }
@@ -1970,15 +1993,15 @@ export class Lowering {
           // Divide by 1000 to correct for double scaling
           const constDiv = this.builder.freshTemp()
           this.builder.emitAssign(constDiv, { kind: 'const', value: 1000 })
-          this.builder.emitRaw(`scoreboard players operation ${dst} rs /= ${constDiv} rs`)
+          this.builder.emitRaw(`scoreboard players operation ${dst} ${LOWERING_OBJ} /= ${constDiv} ${LOWERING_OBJ}`)
         } else {
           // Division: a * 1000 / b
           const constMul = this.builder.freshTemp()
           this.builder.emitAssign(constMul, { kind: 'const', value: 1000 })
           this.builder.emitAssign(dst, left)
-          this.builder.emitRaw(`scoreboard players operation ${dst} rs *= ${constMul} rs`)
+          this.builder.emitRaw(`scoreboard players operation ${dst} ${LOWERING_OBJ} *= ${constMul} ${LOWERING_OBJ}`)
           const rightVar = this.operandToVar(right)
-          this.builder.emitRaw(`scoreboard players operation ${dst} rs /= ${rightVar} rs`)
+          this.builder.emitRaw(`scoreboard players operation ${dst} ${LOWERING_OBJ} /= ${rightVar} ${LOWERING_OBJ}`)
         }
         return { kind: 'var', name: dst }
       }
@@ -2057,7 +2080,7 @@ export class Lowering {
       const storagePath = this.getStringStoragePath(expr.args[0])
       if (storagePath) {
         const dst = this.builder.freshTemp()
-        this.builder.emitRaw(`execute store result score ${dst} rs run data get storage ${storagePath}`)
+        this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} run data get storage ${storagePath}`)
         return { kind: 'var', name: dst }
       }
 
@@ -2095,7 +2118,7 @@ export class Lowering {
       const entity = this.exprToString(expr.args[0])
       const tagName = this.exprToString(expr.args[1])
       const dst = this.builder.freshTemp()
-      this.builder.emitRaw(`execute store result score ${dst} rs if entity ${entity}[tag=${tagName}]`)
+      this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} if entity ${entity}[tag=${tagName}]`)
       return { kind: 'var', name: dst }
     }
 
@@ -2110,7 +2133,7 @@ export class Lowering {
           this.builder.emitRaw(`data modify storage rs:heap ${arrName} append value ${value.value}`)
         } else if (value.kind === 'var') {
           this.builder.emitRaw(`data modify storage rs:heap ${arrName} append value 0`)
-          this.builder.emitRaw(`execute store result storage rs:heap ${arrName}[-1] int 1 run scoreboard players get ${value.name} rs`)
+          this.builder.emitRaw(`execute store result storage rs:heap ${arrName}[-1] int 1 run scoreboard players get ${value.name} ${LOWERING_OBJ}`)
         }
       }
       return { kind: 'const', value: 0 }
@@ -2120,7 +2143,7 @@ export class Lowering {
       const arrName = this.getArrayStorageName(expr.args[0])
       const dst = this.builder.freshTemp()
       if (arrName) {
-        this.builder.emitRaw(`execute store result score ${dst} rs run data get storage rs:heap ${arrName}[-1]`)
+        this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} run data get storage rs:heap ${arrName}[-1]`)
         this.builder.emitRaw(`data remove storage rs:heap ${arrName}[-1]`)
       } else {
         this.builder.emitAssign(dst, { kind: 'const', value: 0 })
@@ -2420,7 +2443,7 @@ export class Lowering {
       const dst = this.builder.freshTemp()
       const min = args[0] ? this.exprToLiteral(args[0]) : '0'
       const max = args[1] ? this.exprToLiteral(args[1]) : '100'
-      this.builder.emitRaw(`scoreboard players random ${dst} rs ${min} ${max}`)
+      this.builder.emitRaw(`scoreboard players random ${dst} ${LOWERING_OBJ} ${min} ${max}`)
       return { kind: 'var', name: dst }
     }
 
@@ -2429,7 +2452,7 @@ export class Lowering {
       const dst = this.builder.freshTemp()
       const min = args[0] ? this.exprToLiteral(args[0]) : '0'
       const max = args[1] ? this.exprToLiteral(args[1]) : '100'
-      this.builder.emitRaw(`execute store result score ${dst} rs run random value ${min} ${max}`)
+      this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} run random value ${min} ${max}`)
       return { kind: 'var', name: dst }
     }
 
@@ -2446,7 +2469,7 @@ export class Lowering {
       const dst = this.builder.freshTemp()
       const player = this.exprToTargetString(args[0])
       const objective = this.resolveScoreboardObjective(args[0], args[1], callSpan)
-      this.builder.emitRaw(`execute store result score ${dst} rs run scoreboard players get ${player} ${objective}`)
+      this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} run scoreboard players get ${player} ${objective}`)
       return { kind: 'var', name: dst }
     }
 
@@ -2460,7 +2483,7 @@ export class Lowering {
       } else if (value.kind === 'var') {
         // Read directly from the computed scoreboard temp. Routing through a fresh
         // temp here breaks once optimization removes the apparently-dead assign.
-        this.builder.emitRaw(`execute store result score ${player} ${objective} run scoreboard players get ${value.name} rs`)
+        this.builder.emitRaw(`execute store result score ${player} ${objective} run scoreboard players get ${value.name} ${LOWERING_OBJ}`)
       }
       return { kind: 'const', value: 0 }
     }
@@ -2536,7 +2559,7 @@ export class Lowering {
 
     if (name === 'bossbar_get_value') {
       const dst = this.builder.freshTemp()
-      this.builder.emitRaw(`execute store result score ${dst} rs run bossbar get ${this.exprToString(args[0])} value`)
+      this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} run bossbar get ${this.exprToString(args[0])} value`)
       return { kind: 'var', name: dst }
     }
 
@@ -2583,7 +2606,7 @@ export class Lowering {
         : this.exprToString(args[1])
       const path = this.exprToString(args[2])
       const scale = args[3] ? this.exprToString(args[3]) : '1'
-      this.builder.emitRaw(`execute store result score ${dst} rs run data get ${targetType} ${target} ${path} ${scale}`)
+      this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} run data get ${targetType} ${target} ${path} ${scale}`)
       return { kind: 'var', name: dst }
     }
 
@@ -2593,7 +2616,7 @@ export class Lowering {
     //   array_key  : e.g. "sin"
     //   index      : integer index (const or runtime)
     //
-    // Const index: execute store result score $dst rs run data get storage math:tables sin[N] 1
+    // Const index: execute store result score $dst ${LOWERING_OBJ} run data get storage math:tables sin[N] 1
     // Runtime index: macro sub-function via rs:heap, mirrors readArrayElement.
     if (name === 'storage_get_int') {
       const storageNs  = this.exprToString(args[0])  // "math:tables"
@@ -2603,7 +2626,7 @@ export class Lowering {
 
       if (indexOperand.kind === 'const') {
         this.builder.emitRaw(
-          `execute store result score ${dst} rs run data get storage ${storageNs} ${arrayKey}[${indexOperand.value}] 1`
+          `execute store result score ${dst} ${LOWERING_OBJ} run data get storage ${storageNs} ${arrayKey}[${indexOperand.value}] 1`
         )
       } else {
         // Runtime index: store the index into rs:heap under a unique key,
@@ -2614,7 +2637,7 @@ export class Lowering {
           ? indexOperand.name
           : this.operandToVar(indexOperand)
         this.builder.emitRaw(
-          `execute store result storage rs:heap ${macroKey} int 1 run scoreboard players get ${indexVar} rs`
+          `execute store result storage rs:heap ${macroKey} int 1 run scoreboard players get ${indexVar} ${LOWERING_OBJ}`
         )
         this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`)
         // Prefix \x01 is a sentinel for the MC macro '$' line-start marker.
@@ -2623,7 +2646,7 @@ export class Lowering {
         // Codegen replaces \x01 → '$' when emitting the mc function file.
         this.emitRawSubFunction(
           subFnName,
-          `\x01execute store result score ${dst} rs run data get storage ${storageNs} ${arrayKey}[$(${macroKey})] 1`
+          `\x01execute store result score ${dst} ${LOWERING_OBJ} run data get storage ${storageNs} ${arrayKey}[$(${macroKey})] 1`
         )
       }
       return { kind: 'var', name: dst }
@@ -2650,7 +2673,7 @@ export class Lowering {
     //   value      : integer value to write (const or runtime)
     //
     // Const index + const value:
-    //   execute store result storage <ns> <key>[N] int 1 run scoreboard players set $const_V rs V
+    //   execute store result storage <ns> <key>[N] int 1 run scoreboard players set $const_V ${LOWERING_OBJ} V
     // Runtime index or value: macro sub-function via rs:heap
     if (name === 'storage_set_int') {
       const storageNs    = this.exprToString(args[0])
@@ -2664,7 +2687,7 @@ export class Lowering {
           ? valueOperand.name
           : this.operandToVar(valueOperand)
         this.builder.emitRaw(
-          `execute store result storage ${storageNs} ${arrayKey}[${indexOperand.value}] int 1 run scoreboard players get ${valVar} rs`
+          `execute store result storage ${storageNs} ${arrayKey}[${indexOperand.value}] int 1 run scoreboard players get ${valVar} ${LOWERING_OBJ}`
         )
       } else {
         // Runtime index: we need a macro sub-function.
@@ -2680,13 +2703,13 @@ export class Lowering {
           ? valueOperand.name
           : this.operandToVar(valueOperand)
         this.builder.emitRaw(
-          `execute store result storage rs:heap ${macroIdxKey} int 1 run scoreboard players get ${indexVar} rs`
+          `execute store result storage rs:heap ${macroIdxKey} int 1 run scoreboard players get ${indexVar} ${LOWERING_OBJ}`
         )
         // Pin valVar in the optimizer's read-set so the assignment is not dead-code-eliminated.
         // The value is stored to rs:heap but NOT used by the macro (the macro reads the scoreboard
         // slot directly to avoid the MC 'data modify set value $(n)' macro substitution bug).
         this.builder.emitRaw(
-          `execute store result storage rs:heap ${macroValKey} int 1 run scoreboard players get ${valVar} rs`
+          `execute store result storage rs:heap ${macroValKey} int 1 run scoreboard players get ${valVar} ${LOWERING_OBJ}`
         )
         this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`)
         // Use execute store result (not 'data modify set value $(val)') to avoid MC macro
@@ -2694,7 +2717,7 @@ export class Lowering {
         // into the macro sub-function at compile time — only the array index is macro-substituted.
         this.emitRawSubFunction(
           subFnName,
-          `\x01execute store result storage ${storageNs} ${arrayKey}[$(${macroIdxKey})] int 1 run scoreboard players get ${valVar} rs`
+          `\x01execute store result storage ${storageNs} ${arrayKey}[$(${macroIdxKey})] int 1 run scoreboard players get ${valVar} ${LOWERING_OBJ}`
         )
       }
       return { kind: 'const', value: 0 }
@@ -2744,7 +2767,7 @@ export class Lowering {
       const dst = this.builder.freshTemp()
       const setId = this.exprToString(args[0])
       const value = this.exprToString(args[1])
-      this.builder.emitRaw(`execute store result score ${dst} rs if data storage rs:sets ${setId}[{value:${value}}]`)
+      this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} if data storage rs:sets ${setId}[{value:${value}}]`)
       return { kind: 'var', name: dst }
     }
 
@@ -3061,7 +3084,7 @@ export class Lowering {
       return
     }
 
-    components.push({ score: { name: this.operandToVar(operand), objective: 'rs' } })
+    components.push({ score: { name: this.operandToVar(operand), objective: LOWERING_OBJ } })
   }
 
   private exprToString(expr: Expr): string {
@@ -3227,12 +3250,20 @@ export class Lowering {
 
   private exprToScoreboardObjective(expr: Expr, span?: Span): string {
     if (expr.kind === 'mc_name') {
-      return expr.value
+      // 'rs' is the canonical token for the current RS scoreboard objective.
+      // Resolve to LOWERING_OBJ so it respects --scoreboard / namespace default.
+      return expr.value === 'rs' ? LOWERING_OBJ : expr.value
     }
 
     const objective = this.exprToString(expr)
     if (objective.startsWith('#') || objective.includes('.')) {
-      return objective.startsWith('#') ? objective.slice(1) : objective
+      if (objective.startsWith('#')) {
+        const name = objective.slice(1)
+        // '#rs' is the canonical way to reference the current RS scoreboard objective.
+        // Resolve to LOWERING_OBJ so it tracks the --scoreboard option.
+        return name === 'rs' ? LOWERING_OBJ : name
+      }
+      return objective
     }
 
     return `${this.getObjectiveNamespace(span)}.${objective}`
@@ -3252,7 +3283,7 @@ export class Lowering {
       return this.namespace
     }
 
-    return this.isStdlibFile(filePath) ? 'rs' : this.namespace
+    return this.isStdlibFile(filePath) ? LOWERING_OBJ : this.namespace
   }
 
   private tryGetStdlibInternalObjective(playerExpr: Expr | undefined, objectiveExpr: Expr, span?: Span): string | null {
@@ -3271,7 +3302,7 @@ export class Lowering {
     }
 
     const hash = this.shortHash(this.serializeCallSite(this.currentStdlibCallSite))
-    return `rs._${resourceBase}_${hash}`
+    return `${LOWERING_OBJ}._${resourceBase}_${hash}`
   }
 
   private getStdlibInternalResourceBase(playerExpr: Expr | undefined): string | null {
@@ -3593,18 +3624,18 @@ export class Lowering {
     const dst = this.builder.freshTemp()
 
     if (index.kind === 'const') {
-      this.builder.emitRaw(`execute store result score ${dst} rs run data get storage rs:heap ${arrayName}[${index.value}]`)
+      this.builder.emitRaw(`execute store result score ${dst} ${LOWERING_OBJ} run data get storage rs:heap ${arrayName}[${index.value}]`)
       return { kind: 'var', name: dst }
     }
 
     const macroKey = `__rs_index_${this.foreachCounter++}`
     const subFnName = `${this.currentFn}/array_get_${this.foreachCounter++}`
     const indexVar = index.kind === 'var' ? index.name : this.operandToVar(index)
-    this.builder.emitRaw(`execute store result storage rs:heap ${macroKey} int 1 run scoreboard players get ${indexVar} rs`)
+    this.builder.emitRaw(`execute store result storage rs:heap ${macroKey} int 1 run scoreboard players get ${indexVar} ${LOWERING_OBJ}`)
     this.builder.emitRaw(`function ${this.namespace}:${subFnName} with storage rs:heap`)
     this.emitRawSubFunction(
       subFnName,
-      `\x01execute store result score ${dst} rs run data get storage rs:heap ${arrayName}[$(${macroKey})]`
+      `\x01execute store result score ${dst} ${LOWERING_OBJ} run data get storage rs:heap ${arrayName}[$(${macroKey})]`
     )
     return { kind: 'var', name: dst }
   }