redscript-mc 1.2.26 → 1.2.28

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(' '),
@@ -108,6 +121,7 @@ const BUILTINS: Record<string, (args: string[]) => string | null> = {
   clearInterval: () => null, // Special handling
   storage_get_int: () => null, // Special handling (dynamic NBT array read via macro)
   storage_set_array: () => null, // Special handling (write literal NBT array to storage)
+  storage_set_int: () => null, // Special handling (dynamic NBT array write via macro)
 }
 
 export interface Warning {
@@ -364,12 +378,24 @@ export class Lowering {
 
   private preScanExpr(expr: Expr, paramNames: Set<string>, macroParams: Set<string>): void {
     if (expr.kind === 'call' && BUILTINS[expr.fn] !== undefined) {
-      // All ident args to macro-aware builtins that are params → macro params
-      for (const arg of expr.args) {
-        if (arg.kind === 'ident' && paramNames.has(arg.name)) {
-          macroParams.add(arg.name)
+      // Only trigger macro param detection for builtins that actually emit
+      // MC commands with $(param) inline in the current function body.
+      // Special-handled builtins (storage_get_int / storage_set_int / etc.) are
+      // declared as `() => null` — they create their own sub-functions for macro
+      // indirection and do NOT require the surrounding function to be a macro.
+      const handler = BUILTINS[expr.fn]!
+      const isSpecialHandled: boolean = (() => {
+        try { return (handler as () => string | null)() === null } catch { return false }
+      })()
+      if (!isSpecialHandled) {
+        for (const arg of expr.args) {
+          if (arg.kind === 'ident' && paramNames.has(arg.name)) {
+            macroParams.add(arg.name)
+          }
         }
       }
+      // Always recurse into args for nested calls/expressions
+      for (const arg of expr.args) this.preScanExpr(arg, paramNames, macroParams)
       return
     }
     // Recurse into sub-expressions for other call types
@@ -452,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) }
   }
 
@@ -472,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}`)
       }
     }
 
@@ -488,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}`
         )
       }
     }
@@ -498,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 }
   }
 
@@ -779,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
@@ -796,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,
@@ -930,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
@@ -964,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
@@ -1015,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 })
@@ -1234,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
@@ -1259,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()
@@ -1369,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)
     }
   }
@@ -1393,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()) {
@@ -1432,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')
@@ -1449,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)
     }
 
@@ -1828,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 }
       }
 
@@ -1837,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 }
       }
     }
@@ -1863,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
@@ -1874,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 }
@@ -1891,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 }
       }
@@ -1932,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 }
     }
@@ -1957,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 }
       }
@@ -2044,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 }
       }
 
@@ -2082,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 }
     }
 
@@ -2097,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 }
@@ -2107,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 })
@@ -2407,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 }
     }
 
@@ -2416,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 }
     }
 
@@ -2433,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 }
     }
 
@@ -2447,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 }
     }
@@ -2523,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 }
     }
 
@@ -2570,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 }
     }
 
@@ -2580,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"
@@ -2590,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,
@@ -2601,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.
@@ -2610,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 }
@@ -2629,6 +2665,64 @@ export class Lowering {
       return { kind: 'const', value: 0 }
     }
 
+    // storage_set_int(storage_ns, array_key, index, value) -> void
+    // Writes one integer element into an NBT int-array stored in data storage.
+    //   storage_ns : e.g. "rs:bigint"
+    //   array_key  : e.g. "a"
+    //   index      : element index (const or runtime)
+    //   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 ${LOWERING_OBJ} V
+    // Runtime index or value: macro sub-function via rs:heap
+    if (name === 'storage_set_int') {
+      const storageNs    = this.exprToString(args[0])
+      const arrayKey     = this.exprToString(args[1])
+      const indexOperand = this.lowerExpr(args[2])
+      const valueOperand = this.lowerExpr(args[3])
+
+      if (indexOperand.kind === 'const') {
+        // Static index — use execute store result to write to the fixed slot
+        const valVar = valueOperand.kind === 'var'
+          ? valueOperand.name
+          : this.operandToVar(valueOperand)
+        this.builder.emitRaw(
+          `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.
+        // Store index + value into rs:heap, call macro that does:
+        //   $data modify storage <ns> <key>[$(idx_key)] set value $(val_key)
+        const macroIdxKey = `__ssi_i_${this.foreachCounter++}`
+        const macroValKey = `__ssi_v_${this.foreachCounter++}`  // kept to pin valVar in optimizer
+        const subFnName   = `${this.currentFn}/__ssi_${this.foreachCounter++}`
+        const indexVar = indexOperand.kind === 'var'
+          ? indexOperand.name
+          : this.operandToVar(indexOperand)
+        const valVar = valueOperand.kind === 'var'
+          ? valueOperand.name
+          : this.operandToVar(valueOperand)
+        this.builder.emitRaw(
+          `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} ${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
+        // substitution bugs with numeric values. The scoreboard slot ${valVar} is hardcoded
+        // 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} ${LOWERING_OBJ}`
+        )
+      }
+      return { kind: 'const', value: 0 }
+    }
+
     // data_merge(target, nbt) — merge NBT into entity/block/storage
     // data_merge(@s, { Invisible: 1b, Silent: 1b })
     if (name === 'data_merge') {
@@ -2673,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 }
     }
 
@@ -2990,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 {
@@ -3156,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}`
@@ -3181,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 {
@@ -3200,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 {
@@ -3522,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 }
   }