redscript-mc 2.5.0 → 2.6.0

package/src/mc-test/client.ts

@@ -117,7 +117,7 @@ export class MCTestClient {
     return this.post('/command', { cmd })
   }
 
-  /** Wait for N server ticks (50ms each) */
+  /** Wait for N server ticks (50ms each, real-time) */
   async ticks(count: number): Promise<void> {
     await this.post('/tick', { count })
   }
@@ -127,6 +127,37 @@ export class MCTestClient {
     await this.ticks(s * 20)
   }
 
+  /** Freeze the server tick loop (/tick freeze) */
+  async tickFreeze(): Promise<void> {
+    await this.command('tick freeze')
+  }
+
+  /** Advance exactly N frozen ticks synchronously (/tick step N) */
+  async tickStep(n = 1): Promise<void> {
+    await this.command(`tick step ${n}`)
+    // Brief real-time pause to allow the step to fully process
+    await new Promise(r => setTimeout(r, 50 * n))
+  }
+
+  /** Resume the server tick loop (/tick unfreeze) */
+  async tickUnfreeze(): Promise<void> {
+    await this.command('tick unfreeze')
+  }
+
+  /**
+   * Run a tick-precise coroutine test:
+   * freeze → run fn → step N ticks → unfreeze
+   * Returns a cleanup function that unfreezes.
+   */
+  async withTickControl<T>(fn: (step: (n?: number) => Promise<void>) => Promise<T>): Promise<T> {
+    await this.tickFreeze()
+    try {
+      return await fn((n = 1) => this.tickStep(n))
+    } finally {
+      await this.tickUnfreeze()
+    }
+  }
+
   /** Get a scoreboard value */
   async scoreboard(player: string, obj: string): Promise<number> {
     const result = await this.get<ScoreResult>('/scoreboard', { player, obj })

package/src/mir/lower.ts

@@ -138,6 +138,11 @@ class FnContext {
   readonly timerCounter: { count: number; timerId: number }
   /** Tracks temps whose values are known compile-time constants (for Timer static ID propagation) */
   readonly constTemps = new Map<Temp, number>()
+  /** Tracks temps that hold fixed (×10000 fixed-point) values — for mul/div scale correction */
+  readonly floatTemps = new Set<Temp>()
+  /** Tracks double variables: varName → NBT storage path (without "rs:d " prefix) */
+  readonly doubleVars = new Map<string, string>()
+  private doubleVarCount = 0
   /** HIR function definitions for array-arg monomorphization */
   hirFunctions: Map<string, HIRFunction> = new Map()
   /** Shared registry of already-generated specialized (monomorphized) MIR functions */
@@ -226,6 +231,13 @@ class FnContext {
   getFnName(): string {
     return this.fnName
   }
+
+  /** Allocate a unique NBT storage path for a double variable */
+  freshDoubleVar(varName: string): string {
+    const path = `${this.namespace}_${this.fnName}_${varName}_${this.doubleVarCount++}`
+    this.doubleVars.set(varName, path)
+    return path
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -266,13 +278,22 @@ function lowerFunction(
   }
 
   // Create temps for parameters, skipping array-type params that are pre-bound
+  // and double-type params (which are passed via NBT __dp<i> slots instead of scoreboard)
   const params: { name: Temp; isMacroParam: boolean }[] = []
   const scope = new Map<string, Temp>()
+  let doubleParamSlot = 0
   fn.params.forEach((p) => {
     if (p.type.kind === 'array' && arrayArgBindings?.has(p.name)) {
       // Array param already bound via arrayVars; no scoreboard slot needed
       return
     }
+    if (p.type.kind === 'named' && p.type.name === 'double') {
+      // double param: passed via NBT storage rs:d __dp<i> instead of scoreboard
+      const path = `__dp${doubleParamSlot++}`
+      ctx.doubleVars.set(p.name, path)
+      // No scoreboard param slot; callee reads from rs:d __dp<i> via doubleVars
+      return
+    }
     const t = ctx.freshTemp()
     params.push({ name: t, isMacroParam: fnMacroInfo?.macroParams.has(p.name) ?? false })
     scope.set(p.name, t)
@@ -334,18 +355,46 @@ function lowerImplMethod(
       selfFields.set(fieldName, t)
     }
     ctx.structVars.set('self', { typeName, fields: selfFields })
-    // Remaining params (after self)
+    // Remaining params (after self) — struct params get one slot per field
     for (let i = 1; i < method.params.length; i++) {
-      const t = ctx.freshTemp()
-      params.push({ name: t, isMacroParam: false })
-      scope.set(method.params[i].name, t)
+      const p = method.params[i]
+      const paramTypeName = p.type.kind === 'named' ? p.type.name
+        : p.type.kind === 'struct' ? p.type.name : null
+      const paramFields = paramTypeName ? ctx.structDefs.get(paramTypeName) : null
+      if (paramFields && paramFields.length > 0) {
+        // Struct param: one slot per field, register as structVar
+        const paramFieldTemps = new Map<string, Temp>()
+        for (const fieldName of paramFields) {
+          const t = ctx.freshTemp()
+          params.push({ name: t, isMacroParam: false })
+          paramFieldTemps.set(fieldName, t)
+        }
+        ctx.structVars.set(p.name, { typeName: paramTypeName!, fields: paramFieldTemps })
+      } else {
+        const t = ctx.freshTemp()
+        params.push({ name: t, isMacroParam: false })
+        scope.set(p.name, t)
+      }
     }
   } else {
-    // Static method — regular params
+    // Static method — regular params (struct params get one slot per field)
     for (const p of method.params) {
-      const t = ctx.freshTemp()
-      params.push({ name: t, isMacroParam: false })
-      scope.set(p.name, t)
+      const paramTypeName = p.type.kind === 'named' ? p.type.name
+        : p.type.kind === 'struct' ? p.type.name : null
+      const paramFields = paramTypeName ? ctx.structDefs.get(paramTypeName) : null
+      if (paramFields && paramFields.length > 0) {
+        const paramFieldTemps = new Map<string, Temp>()
+        for (const fieldName of paramFields) {
+          const t = ctx.freshTemp()
+          params.push({ name: t, isMacroParam: false })
+          paramFieldTemps.set(fieldName, t)
+        }
+        ctx.structVars.set(p.name, { typeName: paramTypeName!, fields: paramFieldTemps })
+      } else {
+        const t = ctx.freshTemp()
+        params.push({ name: t, isMacroParam: false })
+        scope.set(p.name, t)
+      }
     }
   }
 
@@ -506,6 +555,25 @@ function lowerStmt(
           ctx.emit({ kind: 'copy', dst: t, src: valOp })
           scope.set(stmt.name, t)
         }
+      } else if (stmt.type?.kind === 'named' && stmt.type.name === 'double') {
+        // double variable: store in NBT storage rs:d
+        const path = ctx.freshDoubleVar(stmt.name)
+        const ns = ctx.getNamespace()
+        if (stmt.init.kind === 'double_lit') {
+          // Store the double literal directly into NBT
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d ${path} set value ${stmt.init.value}d`, args: [] })
+        } else {
+          // Lower init as fixed (×10000) then convert to double in NBT
+          const initOp = lowerExpr(stmt.init, ctx, scope)
+          const initTemp = ctx.freshTemp()
+          ctx.emit({ kind: 'copy', dst: initTemp, src: initOp })
+          // execute store result storage rs:d <path> double 0.0001 run scoreboard players get $<t> __<ns>
+          ctx.emit({ kind: 'call', dst: null, fn: `__raw:execute store result storage rs:d ${path} double 0.0001 run scoreboard players get $${initTemp} __${ns}`, args: [] })
+        }
+        // Store a placeholder temp in scope (value = 0, not used directly for reads)
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: t, value: 0 })
+        scope.set(stmt.name, t)
       } else if (stmt.init.kind === 'array_lit') {
         // Array literal: write to NBT storage, track the var for index access
         const ns = `${ctx.getNamespace()}:arrays`
@@ -533,11 +601,34 @@ function lowerStmt(
         const lenTemp = ctx.freshTemp()
         ctx.emit({ kind: 'const', dst: lenTemp, value: elems.length })
         scope.set(stmt.name, lenTemp)
+      } else if (stmt.type?.kind === 'array') {
+        // int[] variable initialized from a function call (e.g. let h: int[] = heap_new())
+        // Register as arrayVar so h[i] / h.push(v) / monomorphization all work correctly.
+        // The call returns the array in the caller's own NBT path (same ns:arrays/<name>).
+        const ns = `${ctx.getNamespace()}:arrays`
+        const pathPrefix = stmt.name
+        ctx.arrayVars.set(stmt.name, { ns, pathPrefix })
+        // Evaluate the init expression (e.g. heap_new() or some function call)
+        lowerExpr(stmt.init, ctx, scope)
+        // After the call, copy the NBT array from the return path into our own path.
+        // By convention array-returning functions write into ns:arrays/<ret> or a __ret path.
+        // Here we use 'data modify ... set from storage ns:arrays __ret_array' pattern,
+        // but since we don't have a unified return convention for arrays, we rely on
+        // monomorphization: the first time heap_push(h, val) is called with h in arrayVars,
+        // it will monomorphize correctly.
+        // Store a length temp so .length() works.
+        const lenTemp = ctx.freshTemp()
+        ctx.emit({ kind: 'const', dst: lenTemp, value: 0 })
+        scope.set(stmt.name, lenTemp)
       } else {
         const valOp = lowerExpr(stmt.init, ctx, scope)
         const t = ctx.freshTemp()
         ctx.emit({ kind: 'copy', dst: t, src: valOp })
         scope.set(stmt.name, t)
+        // Track fixed-typed temps for mul/div scale correction
+        if (stmt.type?.kind === 'named' && (stmt.type.name === 'fixed' || stmt.type.name === 'float')) {
+          ctx.floatTemps.add(t)
+        }
       }
       break
     }
@@ -875,8 +966,13 @@ function lowerStmt(
 
     case 'raw': {
       // Raw commands are opaque at MIR level — emit as a call to a synthetic raw function
-      // For now, pass through as a call with no args (will be handled in LIR)
-      ctx.emit({ kind: 'call', dst: null, fn: `__raw:${stmt.cmd}`, args: [] })
+      // __NS__ is replaced with the current namespace so stdlib can reference self-functions.
+      // __OBJ__ is replaced with the scoreboard objective (__<namespace>).
+      const ns = ctx.getNamespace()
+      const rawCmd = stmt.cmd
+        .replace(/__NS__/g, ns)
+        .replace(/__OBJ__/g, `__${ns}`)
+      ctx.emit({ kind: 'call', dst: null, fn: `__raw:${rawCmd}`, args: [] })
       break
     }
 
@@ -956,15 +1052,24 @@ function lowerExpr(
       return { kind: 'const', value: expr.value }
 
     case 'float_lit':
-      // float is ×1000 fixed-point in RedScript
-      return { kind: 'const', value: expr.value }
+      // fixed is ×10000 fixed-point in RedScript
+      return { kind: 'const', value: Math.round(expr.value * 10000) }
 
     case 'byte_lit':
     case 'short_lit':
     case 'long_lit':
-    case 'double_lit':
       return { kind: 'const', value: expr.value }
 
+    case 'double_lit': {
+      // Store as NBT double, return as ×10000 fixed score
+      const path = ctx.freshDoubleVar(`dlit`)
+      ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d ${path} set value ${expr.value}d`, args: [] })
+      const t = ctx.freshTemp()
+      ctx.emit({ kind: 'nbt_read', dst: t, ns: 'rs:d', path, scale: 10000.0 })
+      ctx.floatTemps.add(t)
+      return { kind: 'temp', name: t }
+    }
+
     case 'bool_lit': {
       return { kind: 'const', value: expr.value ? 1 : 0 }
     }
@@ -1001,6 +1106,16 @@ function lowerExpr(
     }
 
     case 'ident': {
+      // If this is a double variable, load it as ×10000 fixed into a fresh temp
+      if (ctx.doubleVars.has(expr.name)) {
+        const path = ctx.doubleVars.get(expr.name)!
+        const t = ctx.freshTemp()
+        // Load double NBT as ×10000 fixed-point score via nbt_read (LIR renames dst properly)
+        ctx.emit({ kind: 'nbt_read', dst: t, ns: 'rs:d', path, scale: 10000.0 })
+        // Mark as fixed (×10000) so arithmetic scale correction applies
+        ctx.floatTemps.add(t)
+        return { kind: 'temp', name: t }
+      }
       const temp = scope.get(expr.name)
       if (temp) return { kind: 'temp', name: temp }
       // Unresolved ident — could be a global or external reference
@@ -1019,6 +1134,31 @@ function lowerExpr(
         return lowerShortCircuitOr(expr, ctx, scope)
       }
 
+      // Double arithmetic intrinsics: double op double → call math_hp:double_add/sub/mul/div
+      const doubleArithOps: Record<string, string> = {
+        '+': 'math_hp:double_add',
+        '-': 'math_hp:double_sub',
+        '*': 'math_hp:double_mul',
+        '/': 'math_hp:double_div',
+      }
+      if (expr.op in doubleArithOps && isDoubleExpr(expr.left, ctx) && isDoubleExpr(expr.right, ctx)) {
+        const ns = ctx.getNamespace()
+        const leftPath = lowerDoubleExprToPath(expr.left, ctx, scope)
+        const rightPath = lowerDoubleExprToPath(expr.right, ctx, scope)
+        // Copy operands into __dp0 and __dp1 (intrinsic calling convention)
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d __dp0 set from storage rs:d ${leftPath}`, args: [] })
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d __dp1 set from storage rs:d ${rightPath}`, args: [] })
+        // Call the intrinsic
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:function ${doubleArithOps[expr.op]}`, args: [] })
+        // Result is in rs:d __dp0 — register as a new double var and read back as ×10000 fixed
+        const resultPath = ctx.freshDoubleVar('dres')
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d ${resultPath} set from storage rs:d __dp0`, args: [] })
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'nbt_read', dst: t, ns: 'rs:d', path: resultPath, scale: 10000.0 })
+        ctx.floatTemps.add(t)
+        return { kind: 'temp', name: t }
+      }
+
       const left = lowerExpr(expr.left, ctx, scope)
       const right = lowerExpr(expr.right, ctx, scope)
       const t = ctx.freshTemp()
@@ -1032,7 +1172,31 @@ function lowerExpr(
       }
 
       if (expr.op in arithmeticOps) {
-        ctx.emit({ kind: arithmeticOps[expr.op] as any, dst: t, a: left, b: right })
+        const isFloatLeft = left.kind === 'temp' && ctx.floatTemps.has(left.name)
+        const isFloatRight = right.kind === 'temp' && ctx.floatTemps.has(right.name)
+        if (expr.op === '*' && isFloatLeft && isFloatRight) {
+          // fixed * fixed: result is ×100000000, divide by 10000 to restore ×10000 scale
+          ctx.emit({ kind: 'mul', dst: t, a: left, b: right })
+          const scaleTemp = ctx.freshTemp()
+          ctx.emit({ kind: 'const', dst: scaleTemp, value: 10000 })
+          const corrected = ctx.freshTemp()
+          ctx.emit({ kind: 'div', dst: corrected, a: { kind: 'temp', name: t }, b: { kind: 'temp', name: scaleTemp } })
+          ctx.floatTemps.add(corrected)
+          return { kind: 'temp', name: corrected }
+        } else if (expr.op === '/' && isFloatLeft && isFloatRight) {
+          // fixed / fixed: pre-multiply dividend by 10000 to restore ×10000 scale
+          const scaleTemp = ctx.freshTemp()
+          ctx.emit({ kind: 'const', dst: scaleTemp, value: 10000 })
+          const scaled = ctx.freshTemp()
+          ctx.emit({ kind: 'mul', dst: scaled, a: left, b: { kind: 'temp', name: scaleTemp } })
+          ctx.emit({ kind: 'div', dst: t, a: { kind: 'temp', name: scaled }, b: right })
+          ctx.floatTemps.add(t)
+        } else {
+          ctx.emit({ kind: arithmeticOps[expr.op] as any, dst: t, a: left, b: right })
+          if (isFloatLeft || isFloatRight) {
+            ctx.floatTemps.add(t)
+          }
+        }
       } else if (expr.op in cmpOps) {
         ctx.emit({ kind: 'cmp', dst: t, op: cmpOps[expr.op], a: left, b: right })
       } else {
@@ -1174,6 +1338,79 @@ function lowerExpr(
         return { kind: 'temp', name: t }
       }
 
+      // Handle __entity_tag / __entity_untag — entity.tag("name") / entity.untag("name") sugar
+      if (expr.fn === '__entity_tag' || expr.fn === '__entity_untag') {
+        const selArg = expr.args[0]
+        const tagArg = expr.args[1]
+        const tagStr = tagArg.kind === 'str_lit' ? tagArg.value : 'unknown'
+        const selStr = selArg.kind === 'selector'
+          ? selectorToString((selArg as any).sel ?? selArg)
+          : '@s'
+        const op = expr.fn === '__entity_tag' ? 'add' : 'remove'
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:tag ${selStr} ${op} ${tagStr}`, args: [] })
+        ctx.emit({ kind: 'const', dst: t, value: 0 })
+        return { kind: 'temp', name: t }
+      }
+
+      // Handle __entity_has_tag(entity, tag) — entity.has_tag("vip") sugar
+      // Compiles to: execute store success score $ret __ns if entity <sel>[tag=<name>]
+      // We use $ret as the store target so LIR's dst-copy mechanism picks it up.
+      if (expr.fn === '__entity_has_tag') {
+        const tagArg = expr.args[1]
+        const tagStr = tagArg.kind === 'str_lit' ? tagArg.value : 'unknown'
+        const selArg = expr.args[0]
+        const selStr = selArg.kind === 'selector'
+          ? selectorToString((selArg as any).sel ?? selArg)
+          : '@s'
+        const t = ctx.freshTemp()
+        const ns = ctx.getNamespace()
+        // Store result in $ret — LIR will copy $ret → $t when dst=t
+        ctx.emit({ kind: 'call', dst: t, fn: `__raw:execute store success score $ret __${ns} if entity ${selStr}[tag=${tagStr}]`, args: [] })
+        return { kind: 'temp', name: t }
+      }
+
+      // Handle __array_push(arr, val) — h.push(val) sugar (parser desugars arr.push → __array_push)
+      // Equivalent to list_push but uses the array's known NBT path directly.
+      if (expr.fn === '__array_push') {
+        if (expr.args[0].kind === 'ident') {
+          const arrInfo = ctx.arrayVars.get((expr.args[0] as { kind: 'ident'; name: string }).name)
+          if (arrInfo) {
+            const valOp = lowerExpr(expr.args[1], ctx, scope)
+            ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage ${arrInfo.ns} ${arrInfo.pathPrefix} append value 0`, args: [] })
+            ctx.emit({ kind: 'nbt_write', ns: arrInfo.ns, path: `${arrInfo.pathPrefix}[-1]`, type: 'int', scale: 1, src: valOp })
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'const', dst: t, value: 0 })
+            return { kind: 'temp', name: t }
+          }
+        }
+      }
+
+      // Handle __array_pop(arr) — h.pop() sugar
+      if (expr.fn === '__array_pop') {
+        if (expr.args[0].kind === 'ident') {
+          const arrInfo = ctx.arrayVars.get((expr.args[0] as { kind: 'ident'; name: string }).name)
+          if (arrInfo) {
+            ctx.emit({ kind: 'call', dst: null, fn: `__raw:data remove storage ${arrInfo.ns} ${arrInfo.pathPrefix}[-1]`, args: [] })
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'const', dst: t, value: 0 })
+            return { kind: 'temp', name: t }
+          }
+        }
+      }
+
+      // Handle __array_length(arr) — h.length sugar → get array length via data get
+      if (expr.fn === '__array_length') {
+        if (expr.args[0].kind === 'ident') {
+          const arrInfo = ctx.arrayVars.get((expr.args[0] as { kind: 'ident'; name: string }).name)
+          if (arrInfo) {
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'nbt_read', dst: t, ns: arrInfo.ns, path: `${arrInfo.pathPrefix}`, scale: 1 })
+            return { kind: 'temp', name: t }
+          }
+        }
+      }
+
       // Handle list_push(arr_name, val) — append an int to an NBT int array
       // list_push("rs:lists", "mylist", val) or simpler: uses the array's storage path
       if (expr.fn === 'list_push') {
@@ -1322,7 +1559,25 @@ function lowerExpr(
               const temp = sv.fields.get(f)
               return temp ? { kind: 'temp' as const, name: temp } : { kind: 'const' as const, value: 0 }
             })
-            const explicitArgs = expr.args.slice(1).map(a => lowerExpr(a, ctx, scope))
+            // Flatten struct args field-by-field; primitives as single operand
+            const explicitArgs: Operand[] = []
+            for (const argExpr of expr.args.slice(1)) {
+              if (argExpr.kind === 'ident') {
+                const argSv = ctx.structVars.get(argExpr.name)
+                if (argSv) {
+                  // Struct arg: pass each field as a separate operand
+                  const argFields = ctx.structDefs.get(argSv.typeName) ?? []
+                  for (const fieldName of argFields) {
+                    const ft = argSv.fields.get(fieldName)
+                    explicitArgs.push(ft
+                      ? { kind: 'temp' as const, name: ft }
+                      : { kind: 'const' as const, value: 0 })
+                  }
+                  continue
+                }
+              }
+              explicitArgs.push(lowerExpr(argExpr, ctx, scope))
+            }
             const allArgs = [...selfArgs, ...explicitArgs]
             const t = ctx.freshTemp()
             ctx.emit({ kind: 'call', dst: t, fn: `${sv.typeName}::${expr.fn}`, args: allArgs })
@@ -1342,11 +1597,12 @@ function lowerExpr(
           if (targetMacro.macroParams.has(paramName)) {
             const paramTypeName = targetMacro.paramTypes.get(paramName) ?? 'int'
             const isFloat = paramTypeName === 'float'
+            const isFixed = paramTypeName === 'fixed'
             macroArgs.push({
               name: paramName,
               value: args[i],
-              type: isFloat ? 'double' : 'int',
-              scale: isFloat ? 0.01 : 1,
+              type: (isFloat || isFixed) ? 'double' : 'int',
+              scale: isFloat ? 0.01 : isFixed ? 0.0001 : 1,
             })
           }
         }
@@ -1417,6 +1673,49 @@ function lowerExpr(
       }
       // --- end array monomorphization ---
 
+      // Check if any args are double-typed — pass via NBT __dp<i> slots
+      {
+        const targetParams = ctx.fnParamInfo.get(expr.fn)
+        if (targetParams) {
+          const hasDoubleParam = targetParams.some(
+            p => p.type.kind === 'named' && p.type.name === 'double'
+          )
+          if (hasDoubleParam) {
+            const ns = ctx.getNamespace()
+            const nonDoubleArgs: Operand[] = []
+            let doubleSlot = 0
+            for (let i = 0; i < targetParams.length && i < expr.args.length; i++) {
+              const p = targetParams[i]
+              if (p.type.kind === 'named' && p.type.name === 'double') {
+                // Caller has a double arg: copy NBT path directly to __dp<doubleSlot>
+                const arg = expr.args[i]
+                if (arg.kind === 'ident' && ctx.doubleVars.has(arg.name)) {
+                  // Arg is already a double var — copy NBT path directly
+                  const srcPath = ctx.doubleVars.get(arg.name)!
+                  ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d __dp${doubleSlot} set from storage rs:d ${srcPath}`, args: [] })
+                } else {
+                  // Arg is an expression — lower it as fixed (×10000), store as double
+                  const argOp = lowerExpr(arg, ctx, scope)
+                  const tmp = ctx.freshTemp()
+                  ctx.emit({ kind: 'copy', dst: tmp, src: argOp })
+                  ctx.emit({ kind: 'call', dst: null, fn: `__raw:execute store result storage rs:d __dp${doubleSlot} double 0.0001 run scoreboard players get $${tmp} __${ns}`, args: [] })
+                }
+                doubleSlot++
+              } else {
+                nonDoubleArgs.push(lowerExpr(expr.args[i], ctx, scope))
+              }
+            }
+            // Any extra args beyond param count
+            for (let i = targetParams.length; i < expr.args.length; i++) {
+              nonDoubleArgs.push(lowerExpr(expr.args[i], ctx, scope))
+            }
+            const t = ctx.freshTemp()
+            ctx.emit({ kind: 'call', dst: t, fn: expr.fn, args: nonDoubleArgs })
+            return { kind: 'temp', name: t }
+          }
+        }
+      }
+
       const args = expr.args.map(a => lowerExpr(a, ctx, scope))
       const t = ctx.freshTemp()
       ctx.emit({ kind: 'call', dst: t, fn: expr.fn, args })
@@ -1516,6 +1815,54 @@ function lowerExpr(
       return { kind: 'temp', name: t }
     }
 
+    case 'type_cast': {
+      const ns = ctx.getNamespace()
+      const targetName = expr.targetType.kind === 'named' ? expr.targetType.name : null
+
+      if (targetName === 'double') {
+        // expr as double: evaluate inner as fixed (×10000), store as double in NBT
+        const innerOp = lowerExpr(expr.expr, ctx, scope)
+        const innerTemp = ctx.freshTemp()
+        ctx.emit({ kind: 'copy', dst: innerTemp, src: innerOp })
+        const path = ctx.freshDoubleVar(`cast`)
+        // execute store result storage rs:d <path> double 0.0001 run scoreboard players get $<t> __<ns>
+        ctx.emit({ kind: 'call', dst: null, fn: `__raw:execute store result storage rs:d ${path} double 0.0001 run scoreboard players get $${innerTemp} __${ns}`, args: [] })
+        // Return a fresh temp that reads the stored double back as fixed ×10000 via nbt_read
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'nbt_read', dst: t, ns: 'rs:d', path, scale: 10000.0 })
+        ctx.floatTemps.add(t)
+        return { kind: 'temp', name: t }
+      }
+
+      if (targetName === 'fixed' || targetName === 'float' || targetName === 'int') {
+        // expr as fixed (or int): check if expr is a double variable
+        if (expr.expr.kind === 'ident' && ctx.doubleVars.has(expr.expr.name)) {
+          // Load double NBT as ×10000 fixed-point score via nbt_read (LIR renames dst properly)
+          const path = ctx.doubleVars.get(expr.expr.name)!
+          const t = ctx.freshTemp()
+          ctx.emit({ kind: 'nbt_read', dst: t, ns: 'rs:d', path, scale: 10000.0 })
+          if (targetName === 'fixed' || targetName === 'float') {
+            ctx.floatTemps.add(t)
+          }
+          return { kind: 'temp', name: t }
+        }
+        // Otherwise just evaluate the inner expression (numeric coercion — no-op at scoreboard level)
+        const innerOp = lowerExpr(expr.expr, ctx, scope)
+        const t = ctx.freshTemp()
+        ctx.emit({ kind: 'copy', dst: t, src: innerOp })
+        if (targetName === 'fixed' || targetName === 'float') {
+          ctx.floatTemps.add(t)
+        }
+        return { kind: 'temp', name: t }
+      }
+
+      // All other casts: pass through
+      const innerOp = lowerExpr(expr.expr, ctx, scope)
+      const t = ctx.freshTemp()
+      ctx.emit({ kind: 'copy', dst: t, src: innerOp })
+      return { kind: 'temp', name: t }
+    }
+
     default: {
       const _exhaustive: never = expr
       throw new Error(`Unknown HIR expression kind: ${(_exhaustive as any).kind}`)
@@ -1523,6 +1870,42 @@ function lowerExpr(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Double arithmetic helpers
+// ---------------------------------------------------------------------------
+
+/** Returns true if expr is a double-typed HIR expression (ident in doubleVars or double_lit). */
+function isDoubleExpr(expr: HIRExpr, ctx: FnContext): boolean {
+  if (expr.kind === 'ident' && ctx.doubleVars.has(expr.name)) return true
+  if (expr.kind === 'double_lit') return true
+  return false
+}
+
+/**
+ * Lower a double HIR expression to its NBT storage path in rs:d.
+ * For double_lit, stores the value and returns the path.
+ * For double idents, returns the existing path directly.
+ * For other expressions, lowers as fixed (×10000) and converts to double.
+ */
+function lowerDoubleExprToPath(expr: HIRExpr, ctx: FnContext, scope: Map<string, Temp>): string {
+  if (expr.kind === 'ident' && ctx.doubleVars.has(expr.name)) {
+    return ctx.doubleVars.get(expr.name)!
+  }
+  if (expr.kind === 'double_lit') {
+    const path = ctx.freshDoubleVar('dlit')
+    ctx.emit({ kind: 'call', dst: null, fn: `__raw:data modify storage rs:d ${path} set value ${expr.value}d`, args: [] })
+    return path
+  }
+  // Fallback: lower as fixed (×10000), then convert to double NBT
+  const op = lowerExpr(expr, ctx, scope)
+  const tmp = ctx.freshTemp()
+  ctx.emit({ kind: 'copy', dst: tmp, src: op })
+  const ns = ctx.getNamespace()
+  const path = ctx.freshDoubleVar('dtmp')
+  ctx.emit({ kind: 'call', dst: null, fn: `__raw:execute store result storage rs:d ${path} double 0.0001 run scoreboard players get $${tmp} __${ns}`, args: [] })
+  return path
+}
+
 // ---------------------------------------------------------------------------
 // Short-circuit lowering
 // ---------------------------------------------------------------------------
@@ -1837,8 +2220,11 @@ function formatBuiltinCall(
     case 'time_set': cmd = `time set ${strs[0]}`; break
     case 'time_add': cmd = `time add ${strs[0]}`; break
     case 'gamerule': cmd = `gamerule ${strs[0]} ${strs[1]}`; break
-    case 'tag_add': cmd = `tag ${strs[0]} add ${strs[1]}`; break
-    case 'tag_remove': cmd = `tag ${strs[0]} remove ${strs[1]}`; break
+    case 'tag_add':        cmd = `tag ${strs[0]} add ${strs[1]}`; break
+    case 'tag_remove':     cmd = `tag ${strs[0]} remove ${strs[1]}`; break
+    // entity.tag(name) / entity.untag(name) sugar — same as tag_add/tag_remove
+    case '__entity_tag':   cmd = `tag ${strs[0]} add ${strs[1]}`; break
+    case '__entity_untag': cmd = `tag ${strs[0]} remove ${strs[1]}`; break
     case 'kick': cmd = `kick ${strs[0]} ${strs[1] ?? ''}`.trim(); break
     case 'clone': cmd = `clone ${strs.join(' ')}`; break
     case 'difficulty': cmd = `difficulty ${strs[0]}`; break

package/src/optimizer/constant_fold.ts

@@ -9,6 +9,11 @@
 
 import type { MIRFunction, MIRBlock, MIRInstr, Operand } from '../mir/types'
 
+/** Wrap a JS number to Java signed int32 (MC scoreboard semantics). */
+function int32(n: number): number {
+  return (n | 0)
+}
+
 export function constantFold(fn: MIRFunction): MIRFunction {
   return {
     ...fn,
@@ -33,27 +38,27 @@ function tryFold(instr: MIRInstr): MIRInstr | null {
   switch (instr.kind) {
     case 'add':
       if (isConst(instr.a) && isConst(instr.b))
-        return { kind: 'const', dst: instr.dst, value: instr.a.value + instr.b.value }
+        return { kind: 'const', dst: instr.dst, value: int32(instr.a.value + instr.b.value) }
       break
     case 'sub':
       if (isConst(instr.a) && isConst(instr.b))
-        return { kind: 'const', dst: instr.dst, value: instr.a.value - instr.b.value }
+        return { kind: 'const', dst: instr.dst, value: int32(instr.a.value - instr.b.value) }
       break
     case 'mul':
       if (isConst(instr.a) && isConst(instr.b))
-        return { kind: 'const', dst: instr.dst, value: instr.a.value * instr.b.value }
+        return { kind: 'const', dst: instr.dst, value: int32(instr.a.value * instr.b.value) }
       break
     case 'div':
       if (isConst(instr.a) && isConst(instr.b) && instr.b.value !== 0)
-        return { kind: 'const', dst: instr.dst, value: Math.trunc(instr.a.value / instr.b.value) }
+        return { kind: 'const', dst: instr.dst, value: int32(Math.trunc(instr.a.value / instr.b.value)) }
       break
     case 'mod':
       if (isConst(instr.a) && isConst(instr.b) && instr.b.value !== 0)
-        return { kind: 'const', dst: instr.dst, value: instr.a.value % instr.b.value }
+        return { kind: 'const', dst: instr.dst, value: int32(instr.a.value % instr.b.value) }
       break
     case 'neg':
       if (isConst(instr.src))
-        return { kind: 'const', dst: instr.dst, value: -instr.src.value }
+        return { kind: 'const', dst: instr.dst, value: int32(-instr.src.value) }
       break
     case 'not':
       if (isConst(instr.src))