redscript-mc 1.2.25 → 1.2.27

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

@@ -1,49 +1,302 @@
-// Integer math helpers for RedScript datapacks.
+// math.mcrs — Integer & fixed-point math helpers for RedScript datapacks.
+//
+// Fixed-point convention: scale = 1000
+//   1.0  → 1000
+//   3.14 → 3140
+//   Use `sqrt_fixed` / `lerp` for sub-integer precision.
+//
+// Phase 1: basic integer helpers (abs, sign, min, max, clamp, lerp)
+// Phase 2: iterative algorithms (isqrt, sqrt_fixed, pow_int, gcd)
+// Phase 3: trig (sin_fixed, cos_fixed) — lookup table in NBT storage
+
+// All functions in this file are library-mode: only compiled into the
+// datapack if actually called from user code.  Use via `librarySources`
+// compile option or concatenate with user code (module library; handles it).
+module library;
+// Phase 4: number theory & utilities (lcm, map, ceil_div, log2_int)
+
+// ─── Phase 1: Basic integer helpers ──────────────────────────────────────────
 
 fn abs(x: int) -> int {
     if (x < 0) {
-        return -x;
-    } else {
-        return x;
+        return 0 - x;
     }
+    return x;
+}
+
+fn sign(x: int) -> int {
+    if (x > 0) {
+        return 1;
+    }
+    if (x < 0) {
+        return -1;
+    }
+    return 0;
 }
 
 fn min(a: int, b: int) -> int {
     if (a < b) {
         return a;
-    } else {
-        return b;
     }
+    return b;
 }
 
 fn max(a: int, b: int) -> int {
     if (a > b) {
         return a;
-    } else {
-        return b;
     }
+    return b;
 }
 
 fn clamp(x: int, lo: int, hi: int) -> int {
     if (x < lo) {
         return lo;
-    } else {
-        if (x > hi) {
-            return hi;
-        } else {
-            return x;
-        }
     }
+    if (x > hi) {
+        return hi;
+    }
+    return x;
 }
 
-fn sign(x: int) -> int {
-    if (x > 0) {
+// Linear interpolation (fixed-point t, t in [0, 1000])
+// lerp(0, 1000, 500) == 500
+// lerp(100, 200, 750) == 175
+fn lerp(a: int, b: int, t: int) -> int {
+    return a + (b - a) * t / 1000;
+}
+
+// ─── Phase 2: Iterative algorithms ───────────────────────────────────────────
+
+// Integer square root: floor(sqrt(n))
+// 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 == 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;
+    }
+    // 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; }
+        x = next;
+        i = i + 1;
+    }
+    return x;
+}
+
+// Fixed-point sqrt (scale = 1000)
+// sqrt_fixed(2000) ≈ 1414  (√2 × 1000)
+// sqrt_fixed(1000) == 1000 (√1 × 1000)
+fn sqrt_fixed(x: int) -> int {
+    return isqrt(x * 1000);
+}
+
+// Integer power: base^exp  (exp ≥ 0)
+// Fast exponentiation by squaring: O(log exp)
+// pow_int(2, 10) == 1024, pow_int(3, 0) == 1
+fn pow_int(base: int, exp: int) -> int {
+    if (exp <= 0) {
         return 1;
-    } else {
-        if (x < 0) {
-            return -1;
-        } else {
-            return 0;
+    }
+    let result: int = 1;
+    let b: int = base;
+    let e: int = exp;
+    while (e > 0) {
+        if (e % 2 == 1) {
+            result = result * b;
         }
+        b = b * b;
+        e = e / 2;
+    }
+    return result;
+}
+
+// Greatest common divisor (Euclidean algorithm)
+// gcd(12, 8) == 4, gcd(0, 5) == 5
+fn gcd(a: int, b: int) -> int {
+    // Inline abs to avoid cross-function scoreboard variable collision.
+    let x: int = a;
+    if (x < 0) { x = 0 - x; }
+    let y: int = b;
+    if (y < 0) { y = 0 - y; }
+    while (y > 0) {
+        let r: int = x % y;
+        x = y;
+        y = r;
+    }
+    return x;
+}
+
+// ─── Phase 3: Trigonometry ────────────────────────────────────────────────────
+//
+// sin/cos lookup table stored in NBT storage (math:tables).
+// 91 entries covering 0-90°; other quadrants derived by symmetry.
+// All values are sin(i°) × 1000, rounded to nearest integer.
+//
+// Accuracy: ≤ 1 unit error (≤0.1% relative) for all integer degrees.
+// Cost: ~4 MC commands per call + 1 NBT read per call (O(1)).
+
+// Initialize the sin lookup table.
+// This function has NO @load — it is called from __load only when sin_fixed
+// or cos_fixed are compiled into the project (via @requires).  If you only
+// use Phase 1/2/4 functions, this never runs and adds zero overhead.
+fn _math_init() {
+    storage_set_array("math:tables", "sin",
+        "[0, 17, 35, 52, 70, 87, 105, 122, 139, 156, 174, 191, 208, 225, 242, 259, 276, 292, 309, 326, 342, 358, 375, 391, 407, 423, 438, 454, 469, 485, 500, 515, 530, 545, 559, 574, 588, 602, 616, 629, 643, 656, 669, 682, 695, 707, 719, 731, 743, 755, 766, 777, 788, 799, 809, 819, 829, 839, 848, 857, 866, 875, 883, 891, 899, 906, 914, 921, 927, 934, 940, 946, 951, 956, 961, 966, 970, 974, 978, 982, 985, 988, 990, 993, 995, 996, 998, 999, 999, 1000, 1000]"
+    );
+}
+
+// sin_fixed(deg) → sin(deg°) × 1000   (integer degrees, any value)
+// sin_fixed(30)  == 500
+// sin_fixed(90)  == 1000
+// sin_fixed(180) == 0
+// sin_fixed(270) == -1000
+//
+// @require_on_load(_math_init): the sin lookup table is written to NBT storage at
+// world load automatically when this function is included in a project.
+@require_on_load(_math_init)
+fn sin_fixed(deg: int) -> int {
+    // Normalise to [0, 359]
+    let d: int = deg % 360;
+    if (d < 0) { d = d + 360; }
+
+    // Quadrant reduction to first quadrant index [0, 90]
+    if (d <= 90) {
+        return storage_get_int("math:tables", "sin", d);
+    }
+    if (d <= 180) {
+        return storage_get_int("math:tables", "sin", 180 - d);
+    }
+    if (d <= 270) {
+        let idx: int = d - 180;
+        return 0 - storage_get_int("math:tables", "sin", idx);
     }
+    // d in (270, 360)
+    let idx: int = 360 - d;
+    return 0 - storage_get_int("math:tables", "sin", idx);
+}
+
+// cos_fixed(deg) → cos(deg°) × 1000   (integer degrees, any value)
+// cos_fixed(0)   == 1000
+// cos_fixed(90)  == 0
+// cos_fixed(180) == -1000
+@require_on_load(_math_init)
+fn cos_fixed(deg: int) -> int {
+    return sin_fixed(deg + 90);
+}
+
+// ─── Phase 4: Number theory & utilities ──────────────────────────────────────
+
+// Least common multiple
+// lcm(4, 6) == 12, lcm(0, 5) == 0
+fn lcm(a: int, b: int) -> int {
+    let g: int = gcd(a, b);
+    if (g == 0) { return 0; }
+    return a / g * b;
+}
+
+// Range map: scale x from [in_lo, in_hi] onto [out_lo, out_hi].
+// Uses integer arithmetic — multiply before dividing to preserve precision.
+// map(5, 0, 10, 0, 100) == 50
+// map(1, 0, 10, 100, 200) == 110
+fn map(x: int, in_lo: int, in_hi: int, out_lo: int, out_hi: int) -> int {
+    let in_range: int = in_hi - in_lo;
+    if (in_range == 0) { return out_lo; }
+    return out_lo + (x - in_lo) * (out_hi - out_lo) / in_range;
+}
+
+// Ceiling division: ⌈a / b⌉  (b > 0 required)
+// ceil_div(7, 3) == 3, ceil_div(6, 3) == 2
+fn ceil_div(a: int, b: int) -> int {
+    return (a + b - 1) / b;
+}
+
+// Integer log base 2: ⌊log₂(n)⌋
+// log2_int(1) == 0, log2_int(8) == 3, log2_int(7) == 2
+// Returns -1 for n ≤ 0 (error sentinel).
+fn log2_int(n: int) -> int {
+    if (n <= 0) { return -1; }
+    let result: int = 0;
+    let v: int = n;
+    while (v > 1) {
+        v = v / 2;
+        result = result + 1;
+    }
+    return result;
+}
+
+// ─── Phase 5: Fixed-point arithmetic & easing ────────────────────────────────
+// Vector functions (dot2d, cross2d, length2d_fixed, manhattan, chebyshev,
+// atan2_fixed, rotate2d, normalize2d, etc.) have moved to vec.mcrs.
+
+// Fixed-point multiply: (a × b) / 1000
+// Use instead of a*b when both operands are fixed-point (scale=1000),
+// e.g. mulfix(sin_fixed(30), cos_fixed(45)) instead of sin*cos which overflows.
+// mulfix(500, 707) == 353   (≈ 0.5 × 0.707)
+fn mulfix(a: int, b: int) -> int {
+    return a * b / 1000;
+}
+
+// Fixed-point divide: (a × 1000) / b
+// Inverse of mulfix; produces a fixed-point result from two integers.
+// divfix(1, 3) == 333   (≈ 0.333)
+fn divfix(a: int, b: int) -> int {
+    if (b == 0) { return 0; }
+    return a * 1000 / b;
+}
+
+// Smooth Hermite interpolation (Ken Perlin's smoothstep).
+// Returns a value in [0, 1000] (fixed-point scale = 1000).
+// Eases in AND out — useful for animations and value transitions.
+//
+// smoothstep(0, 100, 0)   == 0
+// smoothstep(0, 100, 50)  == 500
+// smoothstep(0, 100, 100) == 1000
+// smoothstep(0, 100, 25)  == 156   (≈ 3×0.25² − 2×0.25³ = 0.15625)
+fn smoothstep(lo: int, hi: int, x: int) -> int {
+    let range: int = hi - lo;
+    if (range == 0) { return 0; }
+    // t in [0, 1000]
+    let t: int = (x - lo) * 1000 / range;
+    if (t < 0) { t = 0; }
+    if (t > 1000) { t = 1000; }
+    // f(t) = t² × (3 − 2t) / 1000   (all in scale=1000)
+    // Rewrite to avoid int32 overflow: use t/10 as intermediate
+    let t10: int = t / 10;   // [0, 100], avoids 1000² = 10⁶ overflow
+    return t10 * t10 * (3000 - 2 * t) / 10000;
+}
+
+// Smoother step (Perlin's order-5): 6t⁵ − 15t⁴ + 10t³
+// Higher-order derivative at edges → smoother acceleration curve.
+// smootherstep(0, 100, 25) ≈ 103
+fn smootherstep(lo: int, hi: int, x: int) -> int {
+    let range: int = hi - lo;
+    if (range == 0) { return 0; }
+    let t: int = (x - lo) * 1000 / range;
+    if (t < 0) { t = 0; }
+    if (t > 1000) { t = 1000; }
+    // f(t) = t³ × (10 − t × (15 − 6t) / 1000) / 1000000
+    // Compute in stages to stay within int32
+    let t10: int = t / 10;          // [0, 100]
+    let t2: int = t10 * t10;        // [0, 10000]
+    let t3: int = t2 * t10 / 100;  // [0, 10000]
+    // 10t³ − 15t⁴ + 6t⁵ = t³(10 − 15t + 6t²)  at scale=1000
+    let inner: int = 10000 - 15 * t10 + 6 * t2 / 100;
+    return t3 * inner / 100000;
 }