redscript-mc 2.3.0 → 2.4.1

package/src/optimizer/unroll.ts

@@ -334,6 +334,8 @@ function substituteInstr(instr: MIRInstr, sub: Map<Temp, Operand>): MIRInstr {
       return { ...instr, a: substituteOp(instr.a, sub), b: substituteOp(instr.b, sub) }
     case 'nbt_write':
       return { ...instr, src: substituteOp(instr.src, sub) }
+    case 'nbt_write_dynamic':
+      return { ...instr, indexSrc: substituteOp(instr.indexSrc, sub), valueSrc: substituteOp(instr.valueSrc, sub) }
     case 'call':
       return { ...instr, args: instr.args.map(a => substituteOp(a, sub)) }
     case 'call_macro':
@@ -357,6 +359,7 @@ function getInstrDst(instr: MIRInstr): Temp | null {
     case 'add': case 'sub': case 'mul': case 'div': case 'mod':
     case 'neg': case 'cmp': case 'and': case 'or': case 'not':
     case 'nbt_read':
+    case 'nbt_read_dynamic':
       return instr.dst
     case 'call': case 'call_macro':
       return instr.dst

package/src/parser/index.ts

@@ -1162,6 +1162,15 @@ export class Parser {
           this.getLocToken(left) ?? token
         )
       }
+
+      // Index assignment: arr[0] = val, arr[i] = val
+      if (left.kind === 'index') {
+        const value = this.parseAssignment()
+        return this.withLoc(
+          { kind: 'index_assign', obj: left.obj, index: left.index, op, value },
+          this.getLocToken(left) ?? token
+        )
+      }
     }
 
     return left

package/src/stdlib/list.mcrs

@@ -1,45 +1,29 @@
-// list.mcrs — Dynamic NBT-backed integer list operations.
+// list.mcrs — List and array utilities for RedScript datapacks.
 //
-// Lists are stored in NBT storage as int arrays.
-// The storage namespace is "rs:lists" and path is the variable name.
+// NOTE: Array parameters cannot be passed to functions by reference in
+// the current RedScript implementation. Functions that operate on arrays
+// must be inlined by the user, OR use fixed-size static helpers below.
 //
-// IMPORTANT: These functions use raw() to emit NBT commands.
-// They operate on a NAMED list stored at a specific NBT path.
-// The caller must pass the list path as a namespace:path string.
+// For dynamic array operations (sort, search, sum over variable-length arrays),
+// write the loop directly in your code:
 //
-// Example usage:
-//   // Create a list (declare as int[])
-//   let mylist: int[] = [1, 2, 3];
+//   let nums: int[] = [30, 10, 20];
+//   // Manual bubble sort (2 elements):
+//   if (nums[0] > nums[1]) {
+//       let tmp: int = nums[0];
+//       nums[0] = nums[1];
+//       nums[1] = tmp;
+//   }
 //
-//   // Use list_* functions with raw() for dynamic operations.
-//   // Note: push/pop/len use raw() NBT commands directly.
-//
-// For fixed-size arrays, use int[] literals directly.
-// For dynamic lists, use the functions below.
-//
-// Storage convention: lists live at storage rs:lists <varname>
+// The static helpers below work on up to 5 discrete values passed as arguments.
 
 module library;
 
-// list_len_of(ns, path): count elements in an NBT int list.
-// Returns the count stored in a scoreboard temp.
-// Use: raw("execute store result score $len __ns run data get storage ns:name path")
-// This is a convenience wrapper — in practice use raw() directly.
+// ─── Static min/max/avg ──────────────────────────────────────────────────────
 
-// list_sum(a, b, c, d, e): sum of up to 5 int values (utility)
-fn list_sum5(a: int, b: int, c: int, d: int, e: int): int {
-    return a + b + c + d + e;
-}
-
-fn list_sum4(a: int, b: int, c: int, d: int): int {
-    return a + b + c + d;
-}
+fn sort2_min(a: int, b: int): int { if (a <= b) { return a; } return b; }
+fn sort2_max(a: int, b: int): int { if (a >= b) { return a; } return b; }
 
-fn list_sum3(a: int, b: int, c: int): int {
-    return a + b + c;
-}
-
-// list_min3 / list_max3: min/max over 3 values (useful for array-derived work)
 fn list_min3(a: int, b: int, c: int): int {
     let m: int = a;
     if (b < m) { m = b; }
@@ -72,54 +56,117 @@ fn list_max5(a: int, b: int, c: int, d: int, e: int): int {
     return m;
 }
 
-// ─── Sorting (in-register, fixed size) ───────────────────────────────────────
-
-// sort3_asc: sort 3 values ascending, returns packed as 3 separate ints via
-// side-effect scoreboard. Caller reads $sort3_a, $sort3_b, $sort3_c.
-// (This is a placeholder — proper NBT list sort requires runtime support.)
-
-// swap helper: sort2 returns the smaller value
-fn sort2_min(a: int, b: int): int {
-    if (a <= b) { return a; }
-    return b;
-}
+fn list_sum5(a: int, b: int, c: int, d: int, e: int): int { return a + b + c + d + e; }
+fn list_sum4(a: int, b: int, c: int, d: int): int { return a + b + c + d; }
+fn list_sum3(a: int, b: int, c: int): int { return a + b + c; }
+fn avg3(a: int, b: int, c: int): int { return (a + b + c) / 3; }
+fn avg5(a: int, b: int, c: int, d: int, e: int): int { return (a + b + c + d + e) / 5; }
 
-fn sort2_max(a: int, b: int): int {
-    if (a >= b) { return a; }
-    return b;
-}
+// ─── Static sort (sorting network) ───────────────────────────────────────────
 
-// bubble_sort3: returns sorted value at position pos (0=min, 1=mid, 2=max)
+// sort3(a, b, c, pos): return sorted value at position pos (0=min, 1=mid, 2=max)
 fn sort3(a: int, b: int, c: int, pos: int): int {
-    // Sorting network for 3 elements
-    let x: int = a;
-    let y: int = b;
-    let z: int = c;
-    // Step 1: compare-swap (x, y)
-    if (x > y) { let tmp: int = x; x = y; y = tmp; }
-    // Step 2: compare-swap (y, z)
-    if (y > z) { let tmp: int = y; y = z; z = tmp; }
-    // Step 3: compare-swap (x, y)
-    if (x > y) { let tmp: int = x; x = y; y = tmp; }
+    let x: int = a; let y: int = b; let z: int = c;
+    if (x > y) { let t: int = x; x = y; y = t; }
+    if (y > z) { let t: int = y; y = z; z = t; }
+    if (x > y) { let t: int = x; x = y; y = t; }
     if (pos == 0) { return x; }
     if (pos == 1) { return y; }
     return z;
 }
 
-// ─── Statistics ──────────────────────────────────────────────────────────────
+// ─── Weighted random choice ───────────────────────────────────────────────────
+
+fn weighted2(seed: int, w0: int, w1: int): int {
+    let total: int = w0 + w1;
+    let r: int = seed * 1664525 + 1013904223;
+    if (r < 0) { r = 0 - r; }
+    if (r % total < w0) { return 0; }
+    return 1;
+}
+
+fn weighted3(seed: int, w0: int, w1: int, w2: int): int {
+    let total: int = w0 + w1 + w2;
+    let r: int = seed * 1664525 + 1013904223;
+    if (r < 0) { r = 0 - r; }
+    let v: int = r % total;
+    if (v < w0) { return 0; }
+    if (v < w0 + w1) { return 1; }
+    return 2;
+}
+
+// ─── Sorting networks (fixed-size, optimal compare-swap count) ────────────────
+
+// sort4(a,b,c,d, pos): sort 4 values, return value at position pos (0=min)
+// Uses 5-comparison optimal sorting network
+fn sort4(a: int, b: int, c: int, d: int, pos: int): int {
+    let w: int = a; let x: int = b; let y: int = c; let z: int = d;
+    // Sorting network for 4 elements
+    if (w > x) { let t: int = w; w = x; x = t; }
+    if (y > z) { let t: int = y; y = z; z = t; }
+    if (w > y) { let t: int = w; w = y; y = t; }
+    if (x > z) { let t: int = x; x = z; z = t; }
+    if (x > y) { let t: int = x; x = y; y = t; }
+    if (pos == 0) { return w; }
+    if (pos == 1) { return x; }
+    if (pos == 2) { return y; }
+    return z;
+}
 
-// avg3(a, b, c): integer average (truncated)
-fn avg3(a: int, b: int, c: int): int {
-    return (a + b + c) / 3;
+// sort5(a,b,c,d,e, pos): sort 5 values, return value at position pos
+// Uses 9-comparison sorting network
+fn sort5(a: int, b: int, c: int, d: int, e: int, pos: int): int {
+    let v0: int = a; let v1: int = b; let v2: int = c; let v3: int = d; let v4: int = e;
+    // 9-comparison sorting network (Batcher odd-even merge sort)
+    if (v0 > v1) { let t: int = v0; v0 = v1; v1 = t; }
+    if (v2 > v3) { let t: int = v2; v2 = v3; v3 = t; }
+    if (v0 > v2) { let t: int = v0; v0 = v2; v2 = t; }
+    if (v1 > v4) { let t: int = v1; v1 = v4; v4 = t; }
+    if (v0 > v1) { let t: int = v0; v0 = v1; v1 = t; }
+    if (v2 > v3) { let t: int = v2; v2 = v3; v3 = t; }
+    if (v1 > v2) { let t: int = v1; v1 = v2; v2 = t; }
+    if (v3 > v4) { let t: int = v3; v3 = v4; v4 = t; }
+    if (v2 > v3) { let t: int = v2; v2 = v3; v3 = t; }
+    if (pos == 0) { return v0; }
+    if (pos == 1) { return v1; }
+    if (pos == 2) { return v2; }
+    if (pos == 3) { return v3; }
+    return v4;
 }
 
-fn avg5(a: int, b: int, c: int, d: int, e: int): int {
-    return (a + b + c + d + e) / 5;
+// ─── Dynamic sort (arbitrary-length, uses array reference passing) ─────────────
+
+// list_sort_asc(arr, len): in-place ascending bubble sort
+// Requires RedScript ≥ 2.4.0 (array parameter by reference)
+fn list_sort_asc(arr: int[], len: int) {
+    let i: int = 0;
+    while (i < len - 1) {
+        let j: int = 0;
+        while (j < len - 1 - i) {
+            if (arr[j] > arr[j + 1]) {
+                let tmp: int = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = tmp;
+            }
+            j = j + 1;
+        }
+        i = i + 1;
+    }
 }
 
-// clamp_list3(a, b, c, lo, hi): clamp all 3 values
-fn clamp3(a: int, lo: int, hi: int): int {
-    if (a < lo) { return lo; }
-    if (a > hi) { return hi; }
-    return a;
+// list_sort_desc(arr, len): in-place descending bubble sort
+fn list_sort_desc(arr: int[], len: int) {
+    let i: int = 0;
+    while (i < len - 1) {
+        let j: int = 0;
+        while (j < len - 1 - i) {
+            if (arr[j] < arr[j + 1]) {
+                let tmp: int = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = tmp;
+            }
+            j = j + 1;
+        }
+        i = i + 1;
+    }
 }

package/src/stdlib/math.mcrs

@@ -390,3 +390,140 @@ fn exp_fx(x: int): int {
     }
     return er;
 }
+
+// ─── Cubic root ──────────────────────────────────────────────────────────────
+
+// cbrt_fx(x): integer cube root, returns floor(cbrt(x)).
+// Uses Newton's method: g_next = (2*g + x/g²) / 3
+// cbrt_fx(1000) = 10 (∛1000=10), cbrt_fx(27) = 3, cbrt_fx(8) = 2
+fn cbrt_fx(x: int): int {
+    if (x <= 0) { return 0; }
+    let g: int = x / 3;
+    if (g <= 0) { g = 1; }
+    let i: int = 0;
+    while (i < 20) {
+        let g2: int = g * g;
+        if (g2 <= 0) { g2 = 1; }
+        let next: int = (2 * g + x / g2) / 3;
+        if (next == g) { i = 20; }
+        g = next;
+        if (g <= 0) { g = 1; }
+        i = i + 1;
+    }
+    return g;
+}
+
+// ─── Combinatorics ───────────────────────────────────────────────────────────
+
+// factorial(n): n! for n ∈ [0, 12] (13! exceeds int32)
+fn factorial(n: int): int {
+    if (n <= 1) { return 1; }
+    let r: int = 1;
+    let i: int = 2;
+    while (i <= n) { r = r * i; i = i + 1; }
+    return r;
+}
+
+// combinations(n, k): C(n,k) = n! / (k! * (n-k)!) for n ≤ 20, k ≤ n
+// Uses multiplicative formula to avoid overflow: C(n,k) = ∏ (n-i)/(i+1) for i=0..k-1
+fn combinations(n: int, k: int): int {
+    if (k <= 0) { return 1; }
+    if (k > n) { return 0; }
+    // Use smaller k for efficiency: C(n,k) == C(n, n-k)
+    let kk: int = k;
+    if (n - k < kk) { kk = n - k; }
+    let r: int = 1;
+    let i: int = 0;
+    while (i < kk) {
+        r = r * (n - i) / (i + 1);
+        i = i + 1;
+    }
+    return r;
+}
+
+// ─── Logarithm ───────────────────────────────────────────────────────────────
+
+// log10_fx(x): log base 10, fixed-point ×10000
+// log10(x) = ln(x) / ln(10) ≈ ln(x) / 23026
+fn log10_fx(x: int): int {
+    return ln(x) * 10000 / 23026;
+}
+
+// log2_fx(x): log base 2, fixed-point ×10000
+// log2(x) = ln(x) / ln(2) ≈ ln(x) / 6931
+fn log2_fx(x: int): int {
+    return ln(x) * 10000 / 6931;
+}
+
+// loga_fx(base_fx, x): log_base(x), fixed-point ×10000
+// base_fx and x are both ×10000
+// loga_fx(20000, 40000) ≈ 10000 (log_2(4) = 2, but ×10000 → 20000... wait)
+// Actually: log_b(x) = ln(x) / ln(b), both ×10000, so result = ln(x)/ln(b) × 10000
+fn loga_fx(base_fx: int, x: int): int {
+    let lb: int = ln(base_fx);
+    if (lb == 0) { return 0; }
+    return ln(x) * 10000 / lb;
+}
+
+// ─── Gamma function approximation ────────────────────────────────────────────
+
+// gamma_int(n): Gamma(n) = (n-1)! for positive integers
+fn gamma_int(n: int): int {
+    if (n <= 1) { return 1; }
+    return factorial(n - 1);
+}
+
+// ─── Linear equation solvers ─────────────────────────────────────────────────
+
+// solve2x2_x(a, b, e, c, d, f): solve ax + by = e, cx + dy = f → return x × 10000
+// Uses Cramer's rule. Returns 0 if determinant = 0 (singular system).
+// a, b, c, d, e, f are integers (not fixed-point); result is fixed-point ×10000.
+fn solve2x2_x(a: int, b: int, e: int, c: int, d: int, f: int): int {
+    let det: int = a * d - b * c;
+    if (det == 0) { return 0; }
+    return (e * d - b * f) * 10000 / det;
+}
+
+// solve2x2_y(a, b, e, c, d, f): same system, return y × 10000
+fn solve2x2_y(a: int, b: int, e: int, c: int, d: int, f: int): int {
+    let det: int = a * d - b * c;
+    if (det == 0) { return 0; }
+    return (a * f - e * c) * 10000 / det;
+}
+
+// ─── Quadratic equation ───────────────────────────────────────────────────────
+
+// quadratic_disc(a, b, c): discriminant b² - 4ac
+// Returns > 0 (two real roots), 0 (one root), < 0 (no real roots)
+fn quadratic_disc(a: int, b: int, c: int): int {
+    return b * b - 4 * a * c;
+}
+
+// quadratic_x1(a, b, c): larger root × 10000 using integer sqrt
+// Only valid when discriminant >= 0
+fn quadratic_x1(a: int, b: int, c: int): int {
+    if (a == 0) { return 0; }
+    let disc: int = b * b - 4 * a * c;
+    if (disc < 0) { return 0; }
+    let sq: int = isqrt(disc);
+    return (0 - b + sq) * 10000 / (2 * a);
+}
+
+// quadratic_x2(a, b, c): smaller root × 10000
+fn quadratic_x2(a: int, b: int, c: int): int {
+    if (a == 0) { return 0; }
+    let disc: int = b * b - 4 * a * c;
+    if (disc < 0) { return 0; }
+    let sq: int = isqrt(disc);
+    return (0 - b - sq) * 10000 / (2 * a);
+}
+
+// ─── Fixed-point comparison helpers ──────────────────────────────────────────
+
+// approx_eq(a, b, eps): 1 if |a - b| <= eps
+fn approx_eq(a: int, b: int, eps: int): int {
+    let d: int = a - b;
+    if (d < 0) { d = 0 - d; }
+    if (d <= eps) { return 1; }
+    return 0;
+}

package/src/stdlib/timer.mcrs

@@ -75,3 +75,35 @@ impl Timer {
         }
     }
 }
+
+// ─── Tick-based stopwatch ─────────────────────────────────────────────────────
+
+// tick_to_seconds(ticks): convert MC ticks to seconds (20 ticks = 1 second)
+fn tick_to_seconds(ticks: int): int {
+    return ticks / 20;
+}
+
+// tick_to_ms(ticks): convert ticks to milliseconds
+fn tick_to_ms(ticks: int): int {
+    return ticks * 50;
+}
+
+// seconds_to_ticks(s): convert seconds to ticks
+fn seconds_to_ticks(s: int): int {
+    return s * 20;
+}
+
+// format_time_s(ticks): ticks → seconds component (mod 60)
+fn format_time_s(ticks: int): int {
+    return (ticks / 20) % 60;
+}
+
+// format_time_m(ticks): ticks → minutes component
+fn format_time_m(ticks: int): int {
+    return (ticks / 1200) % 60;
+}
+
+// format_time_h(ticks): ticks → hours component
+fn format_time_h(ticks: int): int {
+    return ticks / 72000;
+}

package/src/typechecker/index.ts

@@ -619,6 +619,12 @@ export class TypeChecker {
         this.checkExpr(expr.value)
         break
 
+      case 'index_assign':
+        this.checkExpr(expr.obj)
+        this.checkExpr(expr.index)
+        this.checkExpr(expr.value)
+        break
+
       case 'index':
         this.checkExpr(expr.obj)
         this.checkExpr(expr.index)