redscript-mc 2.3.0 → 2.4.0

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)