redscript-mc 1.2.25 → 1.2.27

package/src/runtime/index.ts

@@ -266,6 +266,9 @@ export class MCRuntime {
   // Flag to stop function execution (for return)
   private shouldReturn: boolean = false
 
+  // Current MC macro context: key → value (set by 'function ... with storage')
+  private currentMacroContext: Record<string, any> | null = null
+
   constructor(namespace: string) {
     this.namespace = namespace
     // Initialize default objective
@@ -363,6 +366,13 @@ export class MCRuntime {
     cmd = cmd.trim()
     if (!cmd || cmd.startsWith('#')) return true
 
+    // MC macro command: line starts with '$'.
+    // Expand $(key) placeholders from currentMacroContext, then execute.
+    if (cmd.startsWith('$')) {
+      const expanded = this.expandMacro(cmd.slice(1))
+      return this.execCommand(expanded, executor)
+    }
+
     // Parse command
     if (cmd.startsWith('scoreboard ')) {
       return this.execScoreboard(cmd)
@@ -542,7 +552,10 @@ export class MCRuntime {
     // Track execute state
     let currentExecutor = executor
     let condition: boolean = true
-    let storeTarget: { player: string; objective: string; type: 'result' | 'success' } | null = null
+    let storeTarget: 
+      | { player: string; objective: string; type: 'result' | 'success' }
+      | { storagePath: string; field: string; type: 'result' }
+      | null = null
 
     while (rest.length > 0) {
       rest = rest.trimStart()
@@ -557,7 +570,11 @@ export class MCRuntime {
           const value = storeTarget.type === 'result'
             ? (this.returnValue ?? (result ? 1 : 0))
             : (result ? 1 : 0)
-          this.setScore(storeTarget.player, storeTarget.objective, value)
+          if ('storagePath' in storeTarget) {
+            this.setStorageField(storeTarget.storagePath, storeTarget.field, value)
+          } else {
+            this.setScore(storeTarget.player, storeTarget.objective, value)
+          }
         }
 
         return result
@@ -630,15 +647,34 @@ export class MCRuntime {
       // Handle 'unless score ...'
       if (rest.startsWith('unless score ')) {
         rest = rest.slice(13)
-        const scoreParts = rest.match(/^(\S+)\s+(\S+)\s+matches\s+(\S+)(.*)$/)
-        if (scoreParts) {
-          const [, player, obj, rangeStr, remaining] = scoreParts
+        // unless score <player> <obj> matches <range>
+        const matchesParts = rest.match(/^(\S+)\s+(\S+)\s+matches\s+(\S+)(.*)$/)
+        if (matchesParts) {
+          const [, player, obj, rangeStr, remaining] = matchesParts
           const range = parseRange(rangeStr)
           const score = this.getScore(player, obj)
           condition = condition && !matchesRange(score, range)
           rest = remaining.trim()
           continue
         }
+        // unless score <p1> <o1> <op> <p2> <o2>
+        const compareMatch = rest.match(/^(\S+)\s+(\S+)\s+([<>=]+)\s+(\S+)\s+(\S+)(.*)$/)
+        if (compareMatch) {
+          const [, p1, o1, op, p2, o2, remaining] = compareMatch
+          const v1 = this.getScore(p1, o1)
+          const v2 = this.getScore(p2, o2)
+          let matches = false
+          switch (op) {
+            case '=': matches = v1 === v2; break
+            case '<': matches = v1 < v2; break
+            case '<=': matches = v1 <= v2; break
+            case '>': matches = v1 > v2; break
+            case '>=': matches = v1 >= v2; break
+          }
+          condition = condition && !matches  // unless = negate
+          rest = remaining.trim()
+          continue
+        }
       }
 
       // Handle 'if entity <selector>'
@@ -661,6 +697,29 @@ export class MCRuntime {
         continue
       }
 
+      // Handle 'store result storage <ns:path> <field>[<idx>] <type> <scale>'  (array element)
+      if (rest.startsWith('store result storage ')) {
+        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>'
       if (rest.startsWith('store result score ')) {
         rest = rest.slice(19)
@@ -695,7 +754,11 @@ export class MCRuntime {
       const value = storeTarget.type === 'result'
         ? (this.returnValue ?? (condition ? 1 : 0))
         : (condition ? 1 : 0)
-      this.setScore(storeTarget.player, storeTarget.objective, value)
+      if ('storagePath' in storeTarget) {
+        this.setStorageField(storeTarget.storagePath, storeTarget.field, value)
+      } else {
+        this.setScore(storeTarget.player, storeTarget.objective, value)
+      }
     }
 
     return condition
@@ -721,13 +784,39 @@ export class MCRuntime {
   // -------------------------------------------------------------------------
 
   private execFunctionCmd(cmd: string, executor?: Entity): boolean {
-    const fnName = cmd.slice(9).trim() // remove 'function '
+    let fnRef = cmd.slice(9).trim() // remove 'function '
+
+    // Handle 'function ns:name with storage ns:path' — MC macro calling convention.
+    // The called function may have $( ) placeholders that need to be expanded
+    // using the provided storage compound. We execute the function after
+    // expanding its macro context.
+    const withStorageMatch = fnRef.match(/^(\S+)\s+with\s+storage\s+(\S+)$/)
+    if (withStorageMatch) {
+      const [, actualFnName, storagePath] = withStorageMatch
+      const macroContext = this.getStorageCompound(storagePath) ?? {}
+      const outerShouldReturn = this.shouldReturn
+      const outerMacroCtx = this.currentMacroContext
+      this.currentMacroContext = macroContext
+      this.execFunction(actualFnName, executor)
+      this.currentMacroContext = outerMacroCtx
+      this.shouldReturn = outerShouldReturn
+      return true
+    }
+
     const outerShouldReturn = this.shouldReturn
-    this.execFunction(fnName, executor)
+    this.execFunction(fnRef, executor)
     this.shouldReturn = outerShouldReturn
     return true
   }
 
+  /** Expand MC macro placeholders: $(key) → value from currentMacroContext */
+  private expandMacro(cmd: string): string {
+    return cmd.replace(/\$\(([^)]+)\)/g, (_, key) => {
+      const val = this.currentMacroContext?.[key]
+      return val !== undefined ? String(val) : `$(${key})`
+    })
+  }
+
   // -------------------------------------------------------------------------
   // Data Commands
   // -------------------------------------------------------------------------
@@ -755,8 +844,31 @@ export class MCRuntime {
       return true
     }
 
-    // data get storage <ns:path> <field>
-    const getMatch = cmd.match(/^data get storage (\S+) (\S+)$/)
+    // 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.]+)?$/)
+    if (getArrMatch) {
+      const [, storagePath, field, indexStr] = getArrMatch
+      const arr = this.getStorageField(storagePath, field)
+      const idx = parseInt(indexStr, 10)
+      const value = Array.isArray(arr) ? arr[idx] : undefined
+      this.returnValue = typeof value === 'number' ? value : 0
+      return true
+    }
+
+    // data get storage <ns:path> <field> [scale]
+    const getMatch = cmd.match(/^data get storage (\S+) (\S+)(?:\s+[\d.]+)?$/)
     if (getMatch) {
       const [, storagePath, field] = getMatch
       const value = this.getStorageField(storagePath, field)
@@ -803,6 +915,14 @@ export class MCRuntime {
     }
   }
 
+  /** Return the whole storage compound at storagePath as a flat key→value map.
+   *  Used by 'function ... with storage' to provide macro context. */
+  private getStorageCompound(storagePath: string): Record<string, any> | null {
+    const data = this.storage.get(storagePath)
+    if (!data || typeof data !== 'object' || Array.isArray(data)) return null
+    return data as Record<string, any>
+  }
+
   private getStorageField(storagePath: string, field: string): any {
     const data = this.storage.get(storagePath) ?? {}
     const segments = this.parseStoragePath(field)

package/src/stdlib/advanced.mcrs

@@ -0,0 +1,330 @@
+// advanced.mcrs — Higher-order integer math and "fun" algorithms.
+//
+// Requires: math.mcrs (for lerp, smoothstep, mulfix, abs, isqrt, sqrt_fixed)
+//
+// Category 1: Number theory  — fib, is_prime, collatz_steps, digit_sum, reverse_int, mod_pow
+// Category 2: Hashing/noise  — hash_int, noise1d
+// Category 3: Curves         — bezier_quad, bezier_cubic
+// Category 4: Fractals 🤯    — mandelbrot_iter (fixed-point complex arithmetic)
+
+module library;
+
+// ─── Category 1: Number theory ───────────────────────────────────────────────
+
+// Fibonacci number F(n) using simple iteration.
+// Overflow: F(46) = 1836311903 ≈ INT_MAX; use n ≤ 46.
+// fib(0) == 0, fib(1) == 1, fib(10) == 55
+fn fib(n: int) -> int {
+    if (n <= 0) { return 0; }
+    if (n == 1) { return 1; }
+    let a: int = 0;
+    let b: int = 1;
+    let i: int = 2;
+    while (i <= n) {
+        let c: int = a + b;
+        a = b;
+        b = c;
+        i = i + 1;
+    }
+    return b;
+}
+
+// Primality test by trial division up to √n.
+// Returns 1 if n is prime, 0 otherwise.
+// is_prime(2) == 1, is_prime(4) == 0, is_prime(97) == 1
+fn is_prime(n: int) -> int {
+    if (n < 2) { return 0; }
+    if (n == 2) { return 1; }
+    if (n % 2 == 0) { return 0; }
+    let i: int = 3;
+    while (i * i <= n) {
+        if (n % i == 0) { return 0; }
+        i = i + 2;
+    }
+    return 1;
+}
+
+// Number of steps in the Collatz sequence starting at n until reaching 1.
+// collatz_steps(1)  == 0
+// collatz_steps(6)  == 8
+// collatz_steps(27) == 111   (world record among small numbers)
+fn collatz_steps(n: int) -> int {
+    if (n <= 1) { return 0; }
+    let x: int = n;
+    let steps: int = 0;
+    while (x != 1) {
+        if (x % 2 == 0) {
+            x = x / 2;
+        } else {
+            x = 3 * x + 1;
+        }
+        steps = steps + 1;
+    }
+    return steps;
+}
+
+// Sum of decimal digits.  Negative input uses absolute value.
+// digit_sum(123) == 6, digit_sum(0) == 0
+fn digit_sum(n: int) -> int {
+    let x: int = n;
+    if (x < 0) { x = 0 - x; }
+    if (x == 0) { return 0; }
+    let sum: int = 0;
+    while (x > 0) {
+        sum = sum + x % 10;
+        x = x / 10;
+    }
+    return sum;
+}
+
+// Count decimal digits.  0 has 1 digit.  Negative: counts absolute digits.
+// count_digits(0) == 1, count_digits(100) == 3
+fn count_digits(n: int) -> int {
+    let x: int = n;
+    if (x < 0) { x = 0 - x; }
+    if (x == 0) { return 1; }
+    let cnt: int = 0;
+    while (x > 0) {
+        cnt = cnt + 1;
+        x = x / 10;
+    }
+    return cnt;
+}
+
+// Reverse the decimal digits of an integer.  Sign is preserved.
+// reverse_int(12345) == 54321, reverse_int(-42) == -24
+fn reverse_int(n: int) -> int {
+    let x: int = n;
+    let neg: int = 0;
+    if (x < 0) { x = 0 - x; neg = 1; }
+    let result: int = 0;
+    while (x > 0) {
+        result = result * 10 + x % 10;
+        x = x / 10;
+    }
+    if (neg == 1) { return 0 - result; }
+    return result;
+}
+
+// Modular exponentiation: (base ^ exp) mod m  using fast O(log exp) squaring.
+// IMPORTANT: m must be ≤ 46340 to avoid b*b overflow (46340² < INT_MAX).
+// mod_pow(2, 10, 1000) == 24   (1024 mod 1000)
+fn mod_pow(base: int, exp: int, m: int) -> int {
+    if (m == 1) { return 0; }
+    let result: int = 1;
+    let b: int = base % m;
+    if (b < 0) { b = b + m; }
+    let e: int = exp;
+    while (e > 0) {
+        if (e % 2 == 1) {
+            result = result * b % m;
+        }
+        b = b * b % m;
+        e = e / 2;
+    }
+    return result;
+}
+
+// ─── Category 2: Hashing & noise ─────────────────────────────────────────────
+
+// Integer hash function.  Output is non-negative, range [0, ~2 × 10⁹).
+// Deterministic, no randomness — same input always produces the same output.
+// Suitable as a seeded pseudo-random value for procedural generation.
+// hash_int(0) != hash_int(1), repeatable across runs.
+fn hash_int(n: int) -> int {
+    let h: int = n;
+    if (h < 0) { h = 0 - h; }
+    h = h % 46340;               // Clamp so h² fits in int32
+    h = h * 46337 + 97;          // 46337 is prime; h*46337 ≤ 46340*46337 < INT_MAX
+    if (h < 0) { h = 0 - h; }
+    h = h % 46340;
+    h = h * 46337 + 211;
+    if (h < 0) { h = 0 - h; }
+    return h;
+}
+
+// 1D value noise.  Input x in fixed-point (scale = 1000).
+// Output in [0, 999] — smoothly interpolated between hashed lattice points.
+// noise1d(0) == noise1d(0), noise1d(500) is between noise1d(0) and noise1d(1000).
+fn noise1d(x: int) -> int {
+    let ix: int = x / 1000;
+    let frac: int = x % 1000;
+    // Handle negative x so frac is always in [0, 999]
+    if (frac < 0) {
+        ix = ix - 1;
+        frac = frac + 1000;
+    }
+    let h0: int = hash_int(ix) % 1000;
+    let h1: int = hash_int(ix + 1) % 1000;
+    if (h0 < 0) { h0 = 0 - h0; }
+    if (h1 < 0) { h1 = 0 - h1; }
+    // Smoothstep for C1 continuity
+    let t: int = smoothstep(0, 1000, frac);
+    return lerp(h0, h1, t);
+}
+
+// ─── Category 3: Curves ──────────────────────────────────────────────────────
+
+// Quadratic Bezier: B(t) = lerp(lerp(p0,p1,t), lerp(p1,p2,t), t)
+// De Casteljau's algorithm — numerically stable, safe for large coordinates.
+// t in [0, 1000] (fixed-point).
+//
+// bezier_quad(0, 500, 1000, 0)    == 0     (t=0: start)
+// bezier_quad(0, 500, 1000, 500)  == 500   (t=500: midpoint of curve)
+// bezier_quad(0, 500, 1000, 1000) == 1000  (t=1000: end)
+// bezier_quad(0, 1000, 0, 500)    == 500   (arch at midpoint)
+fn bezier_quad(p0: int, p1: int, p2: int, t: int) -> int {
+    let m0: int = lerp(p0, p1, t);
+    let m1: int = lerp(p1, p2, t);
+    return lerp(m0, m1, t);
+}
+
+// Cubic Bezier: 4-point curve using De Casteljau's algorithm.
+// t in [0, 1000].
+// bezier_cubic(0, 333, 667, 1000, 0)    == 0
+// bezier_cubic(0, 333, 667, 1000, 1000) == 1000
+fn bezier_cubic(p0: int, p1: int, p2: int, p3: int, t: int) -> int {
+    let m0: int = lerp(p0, p1, t);
+    let m1: int = lerp(p1, p2, t);
+    let m2: int = lerp(p2, p3, t);
+    let n0: int = lerp(m0, m1, t);
+    let n1: int = lerp(m1, m2, t);
+    return lerp(n0, n1, t);
+}
+
+// ─── Category 4: Fractals 🤯 ─────────────────────────────────────────────────
+
+// Mandelbrot set iteration count.
+//
+// cx, cy: fixed-point coordinates of the complex number c = cx/1000 + i*cy/1000
+//   cx = -2000..1000  (i.e. real part -2.0..1.0)
+//   cy = -1000..1000  (imaginary part -1.0..1.0)
+//
+// Returns the number of iterations before |z| > 2 (escape), or max_iter if
+// the point is in the Mandelbrot set.  Use the return value to colour blocks!
+//
+// Points in the set: mandelbrot_iter(-1000, 0, 100) == 100  (c = -1+0i)
+// Points outside:   mandelbrot_iter(1000, 0, 100)  == 0   (c = 1+0i, escapes immediately)
+// Boundary region:  mandelbrot_iter(-500, 500, 50) → varies
+//
+// Algorithm: z₀ = 0, z_{n+1} = z_n² + c
+//   z_n = (zr + zi·i),  z_n² = zr²−zi² + 2·zr·zi·i
+//   Escape when |z|² = (zr²+zi²)/10⁶ > 4  ↔  mulfix(zr,zr)+mulfix(zi,zi) > 4000
+fn mandelbrot_iter(cx: int, cy: int, max_iter: int) -> int {
+    let zr: int = 0;
+    let zi: int = 0;
+    let i: int = 0;
+    while (i < max_iter) {
+        let zr2: int = mulfix(zr, zr) - mulfix(zi, zi) + cx;
+        let zi2: int = 2 * mulfix(zr, zi) + cy;
+        zr = zr2;
+        zi = zi2;
+        if (mulfix(zr, zr) + mulfix(zi, zi) > 4000) {
+            return i;
+        }
+        i = i + 1;
+    }
+    return max_iter;
+}
+
+// Julia set iteration count (generalised Mandelbrot with fixed c and variable z₀).
+// z0r, z0i: starting point (fixed-point, scale=1000)
+// cr, ci:   constant c   (fixed-point, scale=1000)
+// Same escape condition as mandelbrot_iter.
+fn julia_iter(z0r: int, z0i: int, cr: int, ci: int, max_iter: int) -> int {
+    let zr: int = z0r;
+    let zi: int = z0i;
+    let i: int = 0;
+    while (i < max_iter) {
+        let zr2: int = mulfix(zr, zr) - mulfix(zi, zi) + cr;
+        let zi2: int = 2 * mulfix(zr, zi) + ci;
+        zr = zr2;
+        zi = zi2;
+        if (mulfix(zr, zr) + mulfix(zi, zi) > 4000) {
+            return i;
+        }
+        i = i + 1;
+    }
+    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;
+}