redscript-mc 2.5.0 → 2.6.0

package/src/stdlib/geometry.mcrs

@@ -122,3 +122,92 @@ fn mc_day_angle(daytime: int): int {
     // Sun angle = (daytime * 360 / 24000 + 90) mod 360
     return ((daytime * 360 / 24000 + 90) % 360) * 10000;
 }
+
+// ─── Selector helpers ─────────────────────────────────────────────────────────
+//
+// All coordinates in ×10000 fixed-point units (1.0 block = 10000 units).
+// Angles for in_sector_2d in ×10000 radians (2π ≈ 628318).
+
+// in_cylinder(px,py,pz, cx,cz, radius, y_lo,y_hi):
+// Returns 1 if (px,py,pz) is inside a vertical cylinder centred at (cx,*,cz).
+// Condition: dx²+dz² <= r²  AND  y_lo <= py <= y_hi
+// Note: radius up to ~46340 (×10000 units ≈ 4.6 blocks) avoids overflow.
+// For larger radii, divide all coords by 10 first.
+fn in_cylinder(px: int, py: int, pz: int,
+               cx: int, cz: int,
+               radius: int,
+               y_lo: int, y_hi: int): int {
+    if (py < y_lo) { return 0; }
+    if (py > y_hi) { return 0; }
+    let dx: int = px - cx;
+    let dz: int = pz - cz;
+    if (dx * dx + dz * dz <= radius * radius) { return 1; }
+    return 0;
+}
+
+// in_cone(px,py,pz, apex_x,apex_y,apex_z, dir_y, half_angle_tan, height):
+// Returns 1 if point is inside an upright cone (axis along +Y from apex).
+// half_angle_tan = tan(half-angle) × 10000  (e.g. 45° → 10000, 30° → 5773).
+// Condition: 0 <= dy <= height  AND  horiz_dist <= dy * half_angle_tan / 10000
+// Both sides are compared squared to avoid sqrt:
+//   (dx²+dz²) * 10000² <= (dy * half_angle_tan)²
+fn in_cone(px: int, py: int, pz: int,
+           apex_x: int, apex_y: int, apex_z: int,
+           dir_y: int, half_angle_tan: int, height: int): int {
+    let dy: int = py - apex_y;
+    if (dir_y > 0) {
+        if (dy < 0) { return 0; }
+        if (dy > height) { return 0; }
+    } else {
+        if (dy > 0) { return 0; }
+        if (dy < 0 - height) { return 0; }
+        dy = 0 - dy;
+    }
+    let dx: int = px - apex_x;
+    let dz: int = pz - apex_z;
+    // Compare horiz_dist² <= (dy * half_angle_tan / 10000)²
+    // i.e. (dx²+dz²) * 100000000 <= dy² * half_angle_tan²
+    // To avoid overflow, divide both sides by 10000:
+    //   (dx²+dz²) * 10000 <= (dy * half_angle_tan / 10000)² * 10000 / ...
+    // Use: lhs = (dx*dx + dz*dz), rhs_numerator = dy * half_angle_tan
+    // lhs * 10000 * 10000 <= rhs_numerator * rhs_numerator
+    // Both sides can overflow for large values. Clamp inputs to safe range:
+    let lhs: int = dx * dx + dz * dz;
+    let rhs: int = dy * half_angle_tan / 10000;
+    if (lhs <= rhs * rhs) { return 1; }
+    return 0;
+}
+
+// in_sector_2d(px,pz, cx,cz, dir_angle, half_angle, radius):
+// Returns 1 if (px,pz) is inside a 2D fan (sector) in the XZ plane.
+// dir_angle: centre direction in ×10000 radians (0 = +X axis, 628318 = 2π).
+// half_angle: half-width of sector in ×10000 radians.
+// radius: maximum distance in same units as px/pz/cx/cz.
+// Uses atan2_fixed (returns integer degrees) converted to ×10000 radians.
+fn in_sector_2d(px: int, pz: int,
+                cx: int, cz: int,
+                dir_angle: int, half_angle: int,
+                radius: int): int {
+    let dx: int = px - cx;
+    let dz: int = pz - cz;
+    // Distance check (squared, avoids sqrt)
+    if (dx * dx + dz * dz > radius * radius) { return 0; }
+    if (dx == 0) {
+        if (dz == 0) { return 1; }
+    }
+    // atan2_fixed(y, x) where XZ maps to (y=dz, x=dx) → degrees [0, 359]
+    let deg: int = atan2_fixed(dz, dx);
+    // Convert degrees to ×10000 radians: deg * 628318 / 360
+    let point_angle: int = deg * 628318 / 360;
+    // Normalise dir_angle to [0, 628318)
+    let dir: int = dir_angle;
+    while (dir < 0) { dir = dir + 628318; }
+    while (dir >= 628318) { dir = dir - 628318; }
+    // Signed angular difference, shortest path
+    let diff: int = point_angle - dir;
+    if (diff > 314159) { diff = diff - 628318; }
+    if (diff < 0 - 314159) { diff = diff + 628318; }
+    if (diff < 0) { diff = 0 - diff; }
+    if (diff <= half_angle) { return 1; }
+    return 0;
+}

package/src/stdlib/heap.mcrs

@@ -0,0 +1,175 @@
+// heap.mcrs — Min-heap and Max-heap priority queues for RedScript datapacks.
+//
+// Heap layout in int[]:
+//   h[0]       = current size (number of elements stored)
+//   h[1..size] = heap elements (1-indexed, root at h[1])
+//
+// Parent of node i  = i / 2
+// Left child of i   = i * 2
+// Right child of i  = i * 2 + 1
+//
+// Capacity: up to 64 elements (indices 1–64, so array length 65).
+//
+// Usage:
+//   let h: int[] = heap_new()
+//   h = heap_push(h, 42)
+//   let top: int = heap_peek(h)   // min element without removing
+//   h = heap_pop(h)               // remove min
+//   let sz: int = heap_size(h)
+//
+// MaxHeap variants use reversed comparisons:
+//   h = max_heap_push(h, 42)
+//   h = max_heap_pop(h)
+
+module library
+
+// ─── Construction ─────────────────────────────────────────────────────────────
+
+// heap_new(): allocate a heap array with size=0 and 64 pre-filled slots
+fn heap_new(): int[] {
+    let h: int[] = []
+    h.push(0)
+    let i: int = 0
+    while (i < 64) {
+        h.push(0)
+        i = i + 1
+    }
+    return h
+}
+
+// ─── Common helpers ───────────────────────────────────────────────────────────
+
+// heap_size(h): number of elements currently in the heap
+fn heap_size(h: int[]): int {
+    return h[0]
+}
+
+// heap_peek(h): return the root (minimum for MinHeap, maximum for MaxHeap)
+// Precondition: heap_size(h) > 0
+fn heap_peek(h: int[]): int {
+    return h[1]
+}
+
+// ─── MinHeap ──────────────────────────────────────────────────────────────────
+
+// heap_push(h, val): insert val into MinHeap; returns updated heap
+fn heap_push(h: int[], val: int): int[] {
+    let sz: int = h[0] + 1
+    h[0] = sz
+    h[sz] = val
+    // sift up: while i > 1 and h[i] < h[parent]
+    let i: int = sz
+    let going: int = 1
+    while (going == 1) {
+        if (i > 1) {
+            let parent: int = i / 2
+            if (h[i] < h[parent]) {
+                let tmp: int = h[i]
+                h[i] = h[parent]
+                h[parent] = tmp
+                i = parent
+            } else {
+                going = 0
+            }
+        } else {
+            going = 0
+        }
+    }
+    return h
+}
+
+// heap_pop(h): remove and discard the minimum element; returns updated heap
+fn heap_pop(h: int[]): int[] {
+    let sz: int = h[0]
+    h[1] = h[sz]
+    h[0] = sz - 1
+    // sift down
+    let i: int = 1
+    let cont: int = 1
+    while (cont == 1) {
+        let left: int = i * 2
+        let right: int = i * 2 + 1
+        let smallest: int = i
+        if (left <= h[0]) {
+            if (h[left] < h[smallest]) {
+                smallest = left
+            }
+        }
+        if (right <= h[0]) {
+            if (h[right] < h[smallest]) {
+                smallest = right
+            }
+        }
+        if (smallest != i) {
+            let tmp: int = h[i]
+            h[i] = h[smallest]
+            h[smallest] = tmp
+            i = smallest
+        } else {
+            cont = 0
+        }
+    }
+    return h
+}
+
+// ─── MaxHeap ──────────────────────────────────────────────────────────────────
+
+// max_heap_push(h, val): insert val into MaxHeap; returns updated heap
+fn max_heap_push(h: int[], val: int): int[] {
+    let sz: int = h[0] + 1
+    h[0] = sz
+    h[sz] = val
+    // sift up: while i > 1 and h[i] > h[parent]
+    let i: int = sz
+    let going: int = 1
+    while (going == 1) {
+        if (i > 1) {
+            let parent: int = i / 2
+            if (h[i] > h[parent]) {
+                let tmp: int = h[i]
+                h[i] = h[parent]
+                h[parent] = tmp
+                i = parent
+            } else {
+                going = 0
+            }
+        } else {
+            going = 0
+        }
+    }
+    return h
+}
+
+// max_heap_pop(h): remove and discard the maximum element; returns updated heap
+fn max_heap_pop(h: int[]): int[] {
+    let sz: int = h[0]
+    h[1] = h[sz]
+    h[0] = sz - 1
+    // sift down
+    let i: int = 1
+    let cont: int = 1
+    while (cont == 1) {
+        let left: int = i * 2
+        let right: int = i * 2 + 1
+        let largest: int = i
+        if (left <= h[0]) {
+            if (h[left] > h[largest]) {
+                largest = left
+            }
+        }
+        if (right <= h[0]) {
+            if (h[right] > h[largest]) {
+                largest = right
+            }
+        }
+        if (largest != i) {
+            let tmp: int = h[i]
+            h[i] = h[largest]
+            h[largest] = tmp
+            i = largest
+        } else {
+            cont = 0
+        }
+    }
+    return h
+}

package/src/stdlib/list.mcrs

@@ -170,3 +170,102 @@ fn list_sort_desc(arr: int[], len: int) {
         i = i + 1;
     }
 }
+
+// ─── Dynamic array aggregates ─────────────────────────────────────────────────
+
+// list_sum(arr, len): sum of all elements
+fn list_sum(arr: int[], len: int): int {
+    let s: int = 0;
+    let i: int = 0;
+    while (i < len) {
+        s = s + arr[i];
+        i = i + 1;
+    }
+    return s;
+}
+
+// list_avg(arr, len): arithmetic mean ×10000 (fixed-point)
+// Returns (sum * 10000) / len; returns 0 for empty array
+fn list_avg(arr: int[], len: int): int {
+    if (len <= 0) { return 0; }
+    let s: int = list_sum(arr, len);
+    return s * 10000 / len;
+}
+
+// list_min(arr, len): minimum element in array
+fn list_min(arr: int[], len: int): int {
+    let m: int = arr[0];
+    let i: int = 1;
+    while (i < len) {
+        if (arr[i] < m) { m = arr[i]; }
+        i = i + 1;
+    }
+    return m;
+}
+
+// list_max(arr, len): maximum element in array
+fn list_max(arr: int[], len: int): int {
+    let m: int = arr[0];
+    let i: int = 1;
+    while (i < len) {
+        if (arr[i] > m) { m = arr[i]; }
+        i = i + 1;
+    }
+    return m;
+}
+
+// list_contains(arr, len, val): 1 if val is in arr, 0 otherwise
+fn list_contains(arr: int[], len: int, val: int): int {
+    let i: int = 0;
+    while (i < len) {
+        if (arr[i] == val) { return 1; }
+        i = i + 1;
+    }
+    return 0;
+}
+
+// list_index_of(arr, len, val): first index of val in arr, or -1 if not found
+fn list_index_of(arr: int[], len: int, val: int): int {
+    let i: int = 0;
+    while (i < len) {
+        if (arr[i] == val) { return i; }
+        i = i + 1;
+    }
+    return -1;
+}
+
+// list_shuffle(arr, len, seed): Fisher-Yates shuffle in-place using next_lcg RNG
+// For each i from len-1 down to 1: pick j in [0, i] using next_lcg, swap arr[i] and arr[j]
+fn list_shuffle(arr: int[], len: int, seed: int): int[] {
+    let i: int = len - 1;
+    let s: int = seed;
+    while (i > 0) {
+        s = next_lcg(s);
+        let r: int = s;
+        if (r < 0) { r = 0 - r; }
+        let j: int = r % (i + 1);
+        let tmp: int = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+        i = i - 1;
+    }
+    return arr;
+}
+
+// list_dedup_count(arr, len): count of unique values (O(n²) — fine for small arrays)
+fn list_dedup_count(arr: int[], len: int): int {
+    let count: int = 0;
+    let i: int = 0;
+    while (i < len) {
+        // Check if arr[i] appeared before index i
+        let seen: int = 0;
+        let j: int = 0;
+        while (j < i) {
+            if (arr[j] == arr[i]) { seen = 1; }
+            j = j + 1;
+        }
+        if (seen == 0) { count = count + 1; }
+        i = i + 1;
+    }
+    return count;
+}

package/src/stdlib/math.mcrs

@@ -314,13 +314,14 @@ fn smootherstep(lo: int, hi: int, x: int) -> int {
 fn ln(x: int): int {
     // Input x: fixed-point ×10000; returns ln(x/10000)×10000
     // Valid range: x ∈ [100, 1000000]  (0.01 ~ 100.0)
-    // max_error: 0.000557 (in ×10000 units, i.e. 0.00000006 in real units)
+    // max_error: 0.000504 (in ×10000 units, i.e. 0.00000005 in real units)
+    // Tuned 2026-03-17 via SA (30k iterations), prev: A1=20010 A3=6856 A5=2539
 
     let scale: int = 10000;
     let ln2: int = 6931;
-    let A1: int = 20010;
-    let A3: int = 6856;
-    let A5: int = 2539;
+    let A1: int = 20026;
+    let A3: int = 6394;
+    let A5: int = 5511;
 
     // Step 1: range reduction — bring x into [scale, 2*scale)
     let xr: int = x;
@@ -348,11 +349,18 @@ fn ln(x: int): int {
 }
 
 // sqrt_fx(x): fixed-point sqrt, scale ×10000
+// Input x ×10000 (e.g. 40000 = 4.0)
+// Returns √(x/10000) × 10000
 // sqrt_fx(10000) == 10000  (√1.0 = 1.0)
 // sqrt_fx(20000) ≈ 14142   (√2.0 ≈ 1.4142)
 // sqrt_fx(40000) == 20000  (√4.0 = 2.0)
 fn sqrt_fx(x: int) -> int {
-    return isqrt(x * 100) * 100;
+    // √(x/10000) × 10000 = √x × 100
+    // isqrt(x) returns ⌊√x⌋, so isqrt(x) × 100 ≈ ⌊√x⌋ × 100
+    // For x=40000: isqrt(40000)=200, ×100=20000 ✓
+    // For x=10000: isqrt(10000)=100, ×100=10000 ✓
+    // For x=20000: isqrt(20000)=141, ×100=14100 (vs exact 14142, ≈0.3% error)
+    return isqrt(x) * 100;
 }
 
 // exp_fx(x): e^(x/10000) × 10000, fixed-point ×10000
@@ -527,3 +535,111 @@ fn approx_eq(a: int, b: int, eps: int): int {
     if (d <= eps) { return 1; }
     return 0;
 }
+
+// ─── Cubic root via Cardano / Newton ─────────────────────────────────────────
+
+// cbrt_newton(x): cube root using Newton-Raphson, more iterations than cbrt_fx
+// Returns floor(cbrt(x)) with better convergence for large values
+fn cbrt_newton(x: int): int {
+    if (x <= 0) { return 0; }
+    let g: int = cbrt_fx(x);  // start from cbrt_fx estimate
+    // Two Newton refinement steps: g = (2*g + x/g²) / 3
+    let g2: int = g * g;
+    if (g2 > 0) {
+        let next: int = (2 * g + x / g2) / 3;
+        let n2: int = next * next;
+        if (n2 > 0) { g = (2 * next + x / n2) / 3; } else { g = next; }
+    }
+    return g;
+}
+
+// ─── Cubic equation x³ + px + q = 0 (depressed cubic) ───────────────────────
+// Cardano's method, integer fixed-point ×10000
+// Returns the real root × 10000
+// Only works for depressed cubic (no x² term)
+// For ax³+bx²+cx+d=0, first substitute x = t - b/(3a) to depress
+
+// cubic_one_root_fx(p_fx, q_fx): real root of t³ + p*t + q = 0
+// p_fx, q_fx: coefficients ×10000
+// Returns t ×10000
+fn cubic_disc_fx(p_fx: int, q_fx: int): int {
+    // Discriminant: D = (q/2)² + (p/3)³
+    // ×10000 scale: q_fx/2 in units, cube of p_fx/3 tricky
+    let half_q: int = q_fx / 2;
+    let third_p: int = p_fx / 3;
+    // D = half_q² + third_p³ (×10000 each → result ×10000)
+    let d: int = half_q * half_q / 10000 + third_p * third_p / 10000 * third_p / 10000;
+    return d;
+}
+
+// Newton iteration for general cubic: ax³ + bx² + cx + d = 0
+// Returns approximate root ×10000, starting from x0_fx
+fn cubic_newton(a_fx: int, b_fx: int, c_fx: int, d_fx: int, x0_fx: int): int {
+    let x: int = x0_fx;
+    let step: int = 0;
+    while (step < 20) {
+        // f(x) = ax³ + bx² + cx + d  (all ×10000)
+        let x2: int = x * x / 10000;
+        let x3: int = x2 * x / 10000;
+        let fx: int = a_fx * x3 / 10000 + b_fx * x2 / 10000 + c_fx * x / 10000 + d_fx;
+        // f'(x) = 3ax² + 2bx + c
+        let dfx: int = 3 * a_fx * x2 / 10000 + 2 * b_fx * x / 10000 + c_fx;
+        if (dfx == 0) { step = 20; }
+        if (dfx != 0) {
+            let dx: int = fx * 10000 / dfx;
+            x = x - dx;
+            if (dx < 0) { dx = 0 - dx; }
+            if (dx < 5) { step = 20; }  // converged
+        }
+        step = step + 1;
+    }
+    return x;
+}
+
+// ─── Numerical integration ────────────────────────────────────────────────────
+
+// trapezoid_step(fa, fb, h): one trapezoid integration step
+// fa, fb: function values ×10000, h: step width ×10000
+// Returns area ×10000
+fn trapezoid_step(fa: int, fb: int, h: int): int {
+    return (fa + fb) * h / 20000;  // (fa+fb)/2 * h
+}
+
+// simpson_step(fa, fm, fb, h): one Simpson's rule step
+// fa, fm, fb: function at left/mid/right, h: half-width
+// Returns area ×10000 (over 2h width)
+fn simpson_step(fa: int, fm: int, fb: int, h: int): int {
+    return (fa + 4 * fm + fb) * h / 30000;  // (fa+4fm+fb) * h/3, factor 2h total
+}
+
+// ─── Newton's method (general scalar) ────────────────────────────────────────
+
+// newton_refine(x_fx, fx, dfx): one Newton step
+// x_fx: current x ×10000, fx: f(x) ×10000, dfx: f'(x) ×10000
+// Returns new x ×10000
+fn newton_step(x_fx: int, fx: int, dfx: int): int {
+    if (dfx == 0) { return x_fx; }
+    return x_fx - fx * 10000 / dfx;
+}
+
+// ─── Arc trigonometry ─────────────────────────────────────────────────────────
+
+// asin_approx(x_fx): arcsin approximation, x_fx ×10000 in [-10000, 10000]
+// Returns degrees ×10000
+// Uses: arcsin(x) = arctan(x / √(1-x²))
+fn asin_approx(x_fx: int): int {
+    if (x_fx >= 10000) { return 900000; }
+    if (x_fx <= -10000) { return -900000; }
+    let x2: int = x_fx * x_fx / 10000;
+    let denom_sq: int = 10000 - x2;  // (1 - x²) ×10000
+    if (denom_sq <= 0) { return 900000; }
+    let denom: int = isqrt(denom_sq * 100) * 100;  // √(1-x²) ×10000
+    if (denom == 0) { return 900000; }
+    return atan2_fixed(x_fx, denom);
+}
+
+// acos_approx(x_fx): arccos approximation
+// Returns degrees ×10000
+fn acos_approx(x_fx: int): int {
+    return 900000 - asin_approx(x_fx);  // acos = 90° - asin
+}