redscript-mc 1.2.26 → 1.2.28

package/src/optimizer/commands.ts

@@ -20,8 +20,14 @@ export interface CommandFunction {
   commands: IRCommand[]
 }
 
-const SCOREBOARD_READ_RE =
-  /^execute store result score (\$[A-Za-z0-9_]+) rs run scoreboard players get (\S+) (\S+)$/
+// Matches scoreboard reads for LICM/CSE — objective is captured in group 2
+// so the optimizer can reconstruct the command with the same objective.
+let _OBJ_PATTERN = 'rs'
+export function setOptimizerObjective(obj: string): void { _OBJ_PATTERN = obj }
+
+function scoreboardReadRe(): RegExp {
+  return new RegExp(`^execute store result score (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} run scoreboard players get (\\S+) (\\S+)$`)
+}
 const SCOREBOARD_WRITE_RE =
   /^(?:scoreboard players (?:set|add|remove|reset)\s+(\S+)\s+(\S+)|scoreboard players operation\s+(\S+)\s+(\S+)\s+[+\-*/%]?= )/
 const EXECUTE_STORE_SCORE_RE =
@@ -130,7 +136,7 @@ function applyLICMInternal(functions: CommandFunction[]): Partial<OptimizationSt
       const scoreboardWrites = new Set<string>()
 
       for (const inner of loopFn.commands) {
-        const readMatch = inner.cmd.match(SCOREBOARD_READ_RE)
+        const readMatch = inner.cmd.match(scoreboardReadRe())
         if (readMatch) {
           const [, temp, player, objective] = readMatch
           const key = `${player} ${objective}`
@@ -147,7 +153,7 @@ function applyLICMInternal(functions: CommandFunction[]): Partial<OptimizationSt
         for (const info of readInfo.values()) {
           const matches = inner.cmd.match(TEMP_RE) ?? []
           const usageCount = matches.filter(name => name === info.temp).length
-          const isDef = inner.cmd.startsWith(`execute store result score ${info.temp} rs run scoreboard players get `)
+          const isDef = inner.cmd.startsWith(`execute store result score ${info.temp} ${_OBJ_PATTERN} run scoreboard players get `)
           if (!isDef) {
             info.uses += usageCount
           }
@@ -172,7 +178,7 @@ function applyLICMInternal(functions: CommandFunction[]): Partial<OptimizationSt
       const rewrittenLoopCommands: IRCommand[] = []
 
       for (const inner of loopFn.commands) {
-        const readMatch = inner.cmd.match(SCOREBOARD_READ_RE)
+        const readMatch = inner.cmd.match(scoreboardReadRe())
         if (readMatch && hoistedTemps.has(readMatch[1])) {
           continue
         }
@@ -182,7 +188,7 @@ function applyLICMInternal(functions: CommandFunction[]): Partial<OptimizationSt
       loopFn.commands = rewrittenLoopCommands
       nextCommands.push(
         ...hoistable.map(item => ({
-          cmd: `execute store result score ${item.temp} rs run scoreboard players get ${item.player} ${item.objective}`,
+          cmd: `execute store result score ${item.temp} ${_OBJ_PATTERN} run scoreboard players get ${item.player} ${item.objective}`,
         })),
         command
       )
@@ -198,9 +204,9 @@ function applyLICMInternal(functions: CommandFunction[]): Partial<OptimizationSt
 
 function extractArithmeticExpression(commands: IRCommand[], index: number): { key: string; dst: string } | null {
   const assign =
-    commands[index]?.cmd.match(/^scoreboard players operation (\$[A-Za-z0-9_]+) rs = (\$[A-Za-z0-9_]+|\$const_-?\d+) rs$/) ??
-    commands[index]?.cmd.match(/^scoreboard players set (\$[A-Za-z0-9_]+) rs (-?\d+)$/)
-  const op = commands[index + 1]?.cmd.match(/^scoreboard players operation (\$[A-Za-z0-9_]+) rs ([+\-*/%]=) (\$[A-Za-z0-9_]+|\$const_-?\d+) rs$/)
+    commands[index]?.cmd.match(new RegExp(`^scoreboard players operation (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} = (\\$[A-Za-z0-9_]+|\\$const_-?\\d+) ${_OBJ_PATTERN}$`)) ??
+    commands[index]?.cmd.match(new RegExp(`^scoreboard players set (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} (-?\\d+)$`))
+  const op = commands[index + 1]?.cmd.match(new RegExp(`^scoreboard players operation (\\$[A-Za-z0-9_]+) ${_OBJ_PATTERN} ([+\\-*/%]=) (\\$[A-Za-z0-9_]+|\\$const_-?\\d+) ${_OBJ_PATTERN}$`))
   if (!assign || !op || assign[1] !== op[1]) {
     return null
   }
@@ -234,14 +240,14 @@ function applyCSEInternal(functions: CommandFunction[]): Partial<OptimizationSta
 
     for (let i = 0; i < commands.length; i++) {
       const command = commands[i]
-      const readMatch = command.cmd.match(SCOREBOARD_READ_RE)
+      const readMatch = command.cmd.match(scoreboardReadRe())
       if (readMatch) {
         const [, dst, player, objective] = readMatch
         const key = `${player} ${objective}`
         const cached = readCache.get(key)
         if (cached) {
           stats.cseRedundantReads = (stats.cseRedundantReads ?? 0) + 1
-          rewritten.push({ ...command, cmd: `scoreboard players operation ${dst} rs = ${cached} rs` })
+          rewritten.push({ ...command, cmd: `scoreboard players operation ${dst} ${_OBJ_PATTERN} = ${cached} ${_OBJ_PATTERN}` })
         } else {
           readCache.set(key, dst)
           rewritten.push(command)
@@ -255,7 +261,7 @@ function applyCSEInternal(functions: CommandFunction[]): Partial<OptimizationSta
       if (expr) {
         const cached = exprCache.get(expr.key)
         if (cached) {
-          rewritten.push({ ...commands[i], cmd: `scoreboard players operation ${expr.dst} rs = ${cached} rs` })
+          rewritten.push({ ...commands[i], cmd: `scoreboard players operation ${expr.dst} ${_OBJ_PATTERN} = ${cached} ${_OBJ_PATTERN}` })
           stats.cseArithmetic = (stats.cseArithmetic ?? 0) + 1
           i += 1
         } else {

package/src/optimizer/structure.ts

@@ -1,7 +1,11 @@
 import type { IRBlock, IRCommand, IRFunction, IRInstr, Operand, Terminator } from '../ir/types'
-import { createEmptyOptimizationStats, mergeOptimizationStats, optimizeCommandFunctions, type OptimizationStats } from './commands'
+import { createEmptyOptimizationStats, mergeOptimizationStats, optimizeCommandFunctions, setOptimizerObjective, type OptimizationStats } from './commands'
 
-const OBJ = 'rs'
+let OBJ = 'rs'
+export function setStructureObjective(obj: string): void {
+  OBJ = obj
+  setOptimizerObjective(obj)
+}
 const INLINE_THRESHOLD = 8
 
 const BOP_OP: Record<string, string> = {

package/src/runtime/index.ts

@@ -697,17 +697,27 @@ export class MCRuntime {
         continue
       }
 
-      // Handle 'store result storage <ns:path> <field> <type> <scale>'
+      // Handle 'store result storage <ns:path> <field>[<idx>] <type> <scale>'  (array element)
       if (rest.startsWith('store result storage ')) {
-        rest = rest.slice(21)
-        // format: <ns:path> <field> <type> <scale> <run-cmd>
-        const storageParts = rest.match(/^(\S+)\s+(\S+)\s+(\S+)\s+([\d.]+)\s+(.*)$/)
+        const sliced = rest.slice(21)
+        // Try array-index form first: <ns:path> <field>[<idx>] <type> <scale> <run-cmd>
+        // Use [^\[\s]+ for field (no brackets or spaces) so that \[ matches correctly.
+        const arrParts = sliced.match(/^(\S+)\s+([^\[\s]+)\[(\d+)\]\s+(\S+)\s+([\d.]+)\s+(.*)$/)
+        if (arrParts) {
+          const [, storagePath, field, indexStr, , , remaining] = arrParts
+          storeTarget = { storagePath, field: `${field}[${indexStr}]`, type: 'result' }
+          rest = remaining.trim()
+          continue
+        }
+        // Plain form: <ns:path> <field> <type> <scale> <run-cmd>
+        const storageParts = sliced.match(/^(\S+)\s+(\S+)\s+(\S+)\s+([\d.]+)\s+(.*)$/)
         if (storageParts) {
           const [, storagePath, field, , , remaining] = storageParts
           storeTarget = { storagePath, field, type: 'result' }
           rest = remaining.trim()
           continue
         }
+        rest = sliced
       }
 
       // Handle 'store result score <player> <obj>'
@@ -834,8 +844,20 @@ export class MCRuntime {
       return true
     }
 
+    // data modify storage <ns:path> <field>[<index>] set value <val>  (array element write)
+    const setArrMatch = cmd.match(/^data modify storage (\S+) ([^\[\s]+)\[(\d+)\] set value (.+)$/)
+    if (setArrMatch) {
+      const [, storagePath, field, indexStr, valueStr] = setArrMatch
+      const arr = this.getStorageField(storagePath, field)
+      const idx = parseInt(indexStr, 10)
+      if (Array.isArray(arr) && idx >= 0 && idx < arr.length) {
+        arr[idx] = this.parseDataValue(valueStr)
+      }
+      return true
+    }
+
     // data get storage <ns:path> <field>[<index>] [scale]  (array element access)
-    const getArrMatch = cmd.match(/^data get storage (\S+) (\S+)\[(\d+)\](?:\s+[\d.]+)?$/)
+    const getArrMatch = cmd.match(/^data get storage (\S+) ([^\[\s]+)\[(\d+)\](?:\s+[\d.]+)?$/)
     if (getArrMatch) {
       const [, storagePath, field, indexStr] = getArrMatch
       const arr = this.getStorageField(storagePath, field)

package/src/stdlib/advanced.mcrs

@@ -247,3 +247,84 @@ fn julia_iter(z0r: int, z0i: int, cr: int, ci: int, max_iter: int) -> int {
     }
     return max_iter;
 }
+
+// ─── Category 5: Geometry experiments ────────────────────────────────────────
+
+// Angle between two 2D vectors in degrees (×1 = degrees, unsigned 0..180).
+// Strategy: normalize both vectors to unit (×1000 components), then
+//   angle = atan2(|cross|, dot)  where cross,dot are from the unit vectors.
+// Unit vector components are ≤ 1000, so cross/dot ≤ 10^6 (no overflow).
+// After dividing by 1000 to re-scale, pass to atan2_fixed.
+//
+// angle_between(1000, 0, 0, 1000) == 90
+// angle_between(1000, 0, 1000, 0) == 0
+// angle_between(1000, 0, -1000, 0) == 180
+fn angle_between(x1: int, y1: int, x2: int, y2: int) -> int {
+    let nx1: int = normalize2d_x(x1, y1);
+    let ny1: int = normalize2d_y(x1, y1);
+    let nx2: int = normalize2d_x(x2, y2);
+    let ny2: int = normalize2d_y(x2, y2);
+    if (nx1 == 0 && ny1 == 0) { return 0; }
+    if (nx2 == 0 && ny2 == 0) { return 0; }
+    // dot and cross of unit vectors (components ×1000 → result ×1000000)
+    let d: int = dot2d(nx1, ny1, nx2, ny2) / 1000;   // cos × 1000
+    let c: int = abs(cross2d(nx1, ny1, nx2, ny2)) / 1000; // |sin| × 1000
+    return atan2_fixed(c, d);
+}
+
+// Clamp a 2D point to lie within a circle of radius r centred at origin.
+// r is in the same units as x, y (raw block coords, NOT fixed-point).
+// Returns the clamped x component.
+// Note: keep x, y < ~2000 to avoid overflow in normalize2d_x (x * 10^6).
+//
+// clamp_circle_x(3, 4, 10) == 3   (point at dist 5, inside r=10)
+// clamp_circle_x(600, 0, 500) == 500
+fn clamp_circle_x(x: int, y: int, r: int) -> int {
+    // length2d_fixed returns dist × 1000; compare with r × 1000
+    let dist: int = length2d_fixed(x, y);
+    if (dist <= r * 1000) { return x; }
+    return normalize2d_x(x, y) * r / 1000;
+}
+
+// Y component of circle clamp.
+// clamp_circle_y(0, 600, 500) == 500
+fn clamp_circle_y(x: int, y: int, r: int) -> int {
+    let dist: int = length2d_fixed(x, y);
+    if (dist <= r * 1000) { return y; }
+    return normalize2d_y(x, y) * r / 1000;
+}
+
+// Newton's method integer square root (alternative to isqrt).
+// Converges quadratically; validates our while loop + division.
+// newton_sqrt(25) == 5, newton_sqrt(100) == 10, newton_sqrt(2) == 1
+fn newton_sqrt(n: int) -> int {
+    if (n <= 0) { return 0; }
+    if (n == 1) { return 1; }
+    let x: int = n / 2;
+    let prev: int = 0;
+    while (x != prev) {
+        prev = x;
+        x = (x + n / x) / 2;
+    }
+    return x;
+}
+
+// Digital root: repeatedly sum digits until single digit.
+// digital_root(493) == 7  (4+9+3=16 → 1+6=7)
+// digital_root(9) == 9
+// digital_root(0) == 0
+fn digital_root(n: int) -> int {
+    if (n == 0) { return 0; }
+    let r: int = n % 9;
+    if (r == 0) { return 9; }
+    return r;
+}
+
+// Ulam spiral ring number: which concentric square ring is n on?
+// Ring 0: n=1; Ring 1: n=2..9 (3×3 square); Ring 2: n=10..25 (5×5); etc.
+// Formula: floor((isqrt(n-1) + 1) / 2)
+// spiral_ring(1) == 0, spiral_ring(9) == 1, spiral_ring(25) == 2
+fn spiral_ring(n: int) -> int {
+    if (n <= 1) { return 0; }
+    return (isqrt(n - 1) + 1) / 2;
+}

package/src/stdlib/bigint.mcrs

@@ -0,0 +1,205 @@
+// bigint.mcrs — Arbitrary precision integer arithmetic for RedScript.
+//
+// Representation:
+//   8 limbs, base B = 10000 (10^4) per limb.
+//   Limb[0] = least significant (ones place in base 10000).
+//   Maximum value: 10^32 - 1  (32 decimal digits).
+//   Stored in NBT int arrays inside data storage ("rs:bigint").
+//
+// Registers: "a", "b", "c"  (three independent BigInt values).
+//
+// Usage example:
+//   bigint_init();
+//   bigint_from_int_a(12345678);   // a = 12345678
+//   bigint_from_int_b(87654321);   // b = 87654321
+//   bigint_add();                  // c = a + b = 99999999
+//   let limb0: int = bigint_get_c(0);  // → 9999 (c[0])
+//   let limb1: int = bigint_get_c(1);  // → 9999 (c[1])
+//
+// Multiply overflow note:
+//   bigint_mul uses grade-school O(n^2) algorithm.
+//   Per-product max: 9999 * 9999 + 9999 + 9999 = 99,999,999 < INT32 ✓
+
+module library;
+
+// ── Initialization ────────────────────────────────────────────────────────────
+
+// Initialize (or reset) all BigInt registers to zero.
+// Must be called once before using any bigint operation.
+fn bigint_init() {
+    storage_set_array("rs:bigint", "a",   "[0,0,0,0,0,0,0,0]");
+    storage_set_array("rs:bigint", "b",   "[0,0,0,0,0,0,0,0]");
+    storage_set_array("rs:bigint", "c",   "[0,0,0,0,0,0,0,0]");
+}
+
+// ── Load from int32 ───────────────────────────────────────────────────────────
+
+// Set register a from a 32-bit integer (splits into up to 3 limbs).
+// Supports any n in [0, 999999999999] (12-digit safe limit).
+fn bigint_from_int_a(n: int) {
+    storage_set_array("rs:bigint", "a", "[0,0,0,0,0,0,0,0]");
+    storage_set_int("rs:bigint", "a", 0, n % 10000);
+    storage_set_int("rs:bigint", "a", 1, n / 10000 % 10000);
+    storage_set_int("rs:bigint", "a", 2, n / 10000 / 10000);
+}
+
+// Set register b from a 32-bit integer.
+fn bigint_from_int_b(n: int) {
+    storage_set_array("rs:bigint", "b", "[0,0,0,0,0,0,0,0]");
+    storage_set_int("rs:bigint", "b", 0, n % 10000);
+    storage_set_int("rs:bigint", "b", 1, n / 10000 % 10000);
+    storage_set_int("rs:bigint", "b", 2, n / 10000 / 10000);
+}
+
+// ── Read limb ─────────────────────────────────────────────────────────────────
+
+fn bigint_get_a(i: int) -> int { return storage_get_int("rs:bigint", "a", i); }
+fn bigint_get_b(i: int) -> int { return storage_get_int("rs:bigint", "b", i); }
+fn bigint_get_c(i: int) -> int { return storage_get_int("rs:bigint", "c", i); }
+
+// ── Copy between registers ────────────────────────────────────────────────────
+
+fn bigint_copy_a_to_b() {
+    let i: int = 0;
+    while (i < 8) {
+        storage_set_int("rs:bigint", "b", i, storage_get_int("rs:bigint", "a", i));
+        i = i + 1;
+    }
+}
+
+fn bigint_copy_b_to_a() {
+    let i: int = 0;
+    while (i < 8) {
+        storage_set_int("rs:bigint", "a", i, storage_get_int("rs:bigint", "b", i));
+        i = i + 1;
+    }
+}
+
+fn bigint_copy_c_to_a() {
+    let i: int = 0;
+    while (i < 8) {
+        storage_set_int("rs:bigint", "a", i, storage_get_int("rs:bigint", "c", i));
+        i = i + 1;
+    }
+}
+
+fn bigint_copy_c_to_b() {
+    let i: int = 0;
+    while (i < 8) {
+        storage_set_int("rs:bigint", "b", i, storage_get_int("rs:bigint", "c", i));
+        i = i + 1;
+    }
+}
+
+// ── Addition: c = a + b ───────────────────────────────────────────────────────
+
+// c = a + b  (carry propagated across all 8 limbs)
+fn bigint_add() {
+    let carry: int = 0;
+    let i: int = 0;
+    while (i < 8) {
+        let s: int = storage_get_int("rs:bigint", "a", i)
+                   + storage_get_int("rs:bigint", "b", i)
+                   + carry;
+        carry = s / 10000;
+        storage_set_int("rs:bigint", "c", i, s % 10000);
+        i = i + 1;
+    }
+}
+
+// ── Subtraction: c = a - b  (assumes a ≥ b) ──────────────────────────────────
+
+fn bigint_sub() {
+    let borrow: int = 0;
+    let i: int = 0;
+    while (i < 8) {
+        let d: int = storage_get_int("rs:bigint", "a", i)
+                   - storage_get_int("rs:bigint", "b", i)
+                   - borrow;
+        if (d < 0) {
+            d = d + 10000;
+            borrow = 1;
+        } else {
+            borrow = 0;
+        }
+        storage_set_int("rs:bigint", "c", i, d);
+        i = i + 1;
+    }
+}
+
+// ── Comparison: returns 1 (a>b), 0 (a==b), -1 (a<b) ─────────────────────────
+
+fn bigint_compare() -> int {
+    let i: int = 7;
+    while (i >= 0) {
+        let ai: int = storage_get_int("rs:bigint", "a", i);
+        let bi: int = storage_get_int("rs:bigint", "b", i);
+        if (ai > bi) { return 1; }
+        if (ai < bi) { return -1; }
+        i = i - 1;
+    }
+    return 0;
+}
+
+// ── Multiply by small constant: c = a × k  (k < 10000) ───────────────────────
+// Max per-limb: 9999 × 9999 + 9999 = 99,989,999 < INT32 ✓
+
+fn bigint_mul_small(k: int) {
+    let carry: int = 0;
+    let i: int = 0;
+    while (i < 8) {
+        let p: int = storage_get_int("rs:bigint", "a", i) * k + carry;
+        carry = p / 10000;
+        storage_set_int("rs:bigint", "c", i, p % 10000);
+        i = i + 1;
+    }
+}
+
+// ── Multiply: c = a × b  (grade-school O(n²), n=8) ───────────────────────────
+// Per-product max: 9999 × 9999 + 9999 (prev c) + 9999 (carry) = 99,999,999 < INT32 ✓
+
+fn bigint_mul() {
+    storage_set_array("rs:bigint", "c", "[0,0,0,0,0,0,0,0]");
+    let i: int = 0;
+    while (i < 8) {
+        let ai: int = storage_get_int("rs:bigint", "a", i);
+        if (ai != 0) {
+            let j: int = 0;
+            let carry: int = 0;
+            while (j < 8) {
+                let k: int = i + j;
+                if (k < 8) {
+                    let p: int = ai * storage_get_int("rs:bigint", "b", j)
+                               + storage_get_int("rs:bigint", "c", k)
+                               + carry;
+                    carry = p / 10000;
+                    storage_set_int("rs:bigint", "c", k, p % 10000);
+                }
+                j = j + 1;
+            }
+        }
+        i = i + 1;
+    }
+}
+
+// ── Fibonacci: F(n) → register a  (n ≤ 150 before 32-digit overflow) ─────────
+//
+// Invariant: a=F(k), b=F(k+1).  After n iterations: a=F(n).
+//
+// F(50)  = 12,586,269,025           → a[0]=9025, a[1]=8626, a[2]=125
+// F(100) = 354,224,848,179,261,915,075  → 21 digits, fits in 6 limbs
+
+fn bigint_fib(n: int) {
+    bigint_init();               // a=0=F(0), b=0
+    bigint_from_int_b(1);        // b=1=F(1)
+    let i: int = 0;
+    while (i < n) {
+        // Invariant entering iteration: a=F(i), b=F(i+1)
+        bigint_add();            // c = F(i) + F(i+1) = F(i+2)
+        bigint_copy_b_to_a();    // a = F(i+1)
+        bigint_copy_c_to_b();    // b = F(i+2)
+        // Invariant restored: a=F(i+1), b=F(i+2)
+        i = i + 1;
+    }
+    // result: a = F(n)
+}

package/src/stdlib/math.mcrs

@@ -71,16 +71,29 @@ fn lerp(a: int, b: int, t: int) -> int {
 // Uses Newton's method, converges in ≤16 iterations for all int32.
 // isqrt(9) == 3, isqrt(10) == 3, isqrt(0) == 0
 fn isqrt(n: int) -> int {
-    if (n <= 0) {
-        return 0;
+    if (n <= 0) { return 0; }
+    if (n == 1) { return 1; }
+    // Bit-length of n: how many bits needed to represent n.
+    let bits: int = 0;
+    let tmp: int = n;
+    while (tmp > 0) {
+        tmp = tmp / 2;
+        bits = bits + 1;
     }
-    let x: int = n;
+    // Initial guess: 2^((bits+1)/2).  Always ≥ sqrt(n), so Newton converges
+    // monotonically from above — the standard floor-sqrt Newton iteration.
+    let half: int = (bits + 1) / 2;
+    let x: int = 1;
+    let j: int = 0;
+    while (j < half) {
+        x = x * 2;
+        j = j + 1;
+    }
+    // Newton–Raphson floor-sqrt: converges in ≤ 8 iterations from a 2× overestimate.
     let i: int = 0;
     while (i < 16) {
         let next: int = (x + n / x) / 2;
-        if (next >= x) {
-            return x;
-        }
+        if (next >= x) { return x; }
         x = next;
         i = i + 1;
     }