redscript-mc 2.5.0 → 2.6.2

package/src/stdlib/ode.mcrs

@@ -0,0 +1,168 @@
+// ode.mcrs — Runge-Kutta 4th order ODE helpers for RedScript datapacks.
+//
+// Fixed-point convention in this module: scale = 10000.
+//   1.0  -> 10000
+//   0.1  -> 1000
+//
+// Usage example (exponential decay):
+//   // dy/dt = -k*y, with k = 1.0, y0 = 1.0, h = 0.1, 10 steps
+//   ode_run(ODE_SYSTEM_DECAY, 0, 10000, 1000, 10, 10000)
+//   let y1: int = ode_get_y()
+//   // Exact solution: y(t) = y0 * e^(-k*t)
+//   // At t = 1.0: y ≈ 3679 (= 0.3679 × 10000)
+//
+// State layout in storage-backed int[] (8 slots):
+//   [system_id, t_fx, y_fx, y2_fx, param_k, param_extra, step_count, reserved]
+//
+// Built-in systems:
+//   1 = exponential decay   (dy/dt = -k*y)
+//   2 = exponential growth  (dy/dt =  k*y)
+//   3 = harmonic oscillator (y' = y2, y2' = -k*y - extra*y2)
+
+module library
+
+fn ode_mul_fx(a_fx: int, b_fx: int): int {
+    return a_fx * b_fx / 10000
+}
+
+fn ode_weighted_increment(h_fx: int, deriv_sum_fx: int): int {
+    return h_fx * deriv_sum_fx / 60000
+}
+
+fn _ode_set_slot0(v: int) { raw("execute store result storage rs:ode state[0] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot1(v: int) { raw("execute store result storage rs:ode state[1] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot2(v: int) { raw("execute store result storage rs:ode state[2] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot3(v: int) { raw("execute store result storage rs:ode state[3] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot4(v: int) { raw("execute store result storage rs:ode state[4] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot5(v: int) { raw("execute store result storage rs:ode state[5] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot6(v: int) { raw("execute store result storage rs:ode state[6] int 1 run scoreboard players get $p0 __OBJ__") }
+fn _ode_set_slot7(v: int) { raw("execute store result storage rs:ode state[7] int 1 run scoreboard players get $p0 __OBJ__") }
+
+fn _ode_get_slot0(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[0]"); raw("return 1"); return 0 }
+fn _ode_get_slot1(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[1]"); raw("return 1"); return 0 }
+fn _ode_get_slot2(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[2]"); raw("return 1"); return 0 }
+fn _ode_get_slot3(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[3]"); raw("return 1"); return 0 }
+fn _ode_get_slot4(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[4]"); raw("return 1"); return 0 }
+fn _ode_get_slot5(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[5]"); raw("return 1"); return 0 }
+fn _ode_get_slot6(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[6]"); raw("return 1"); return 0 }
+fn _ode_get_slot7(): int { raw("execute store result score $ret __OBJ__ run data get storage rs:ode state[7]"); raw("return 1"); return 0 }
+
+fn ode_reset(system_id: int, t_fx: int, y_fx: int, y2_fx: int, k_fx: int, extra_fx: int) {
+    raw("data modify storage rs:ode state set value [0,0,0,0,0,0,0,0]")
+    _ode_set_slot0(system_id)
+    _ode_set_slot1(t_fx)
+    _ode_set_slot2(y_fx)
+    _ode_set_slot3(y2_fx)
+    _ode_set_slot4(k_fx)
+    _ode_set_slot5(extra_fx)
+    _ode_set_slot6(0)
+    _ode_set_slot7(0)
+}
+
+fn ode_get_system(): int { return _ode_get_slot0() }
+fn ode_get_t(): int { return _ode_get_slot1() }
+fn ode_get_y(): int { return _ode_get_slot2() }
+fn ode_get_y2(): int { return _ode_get_slot3() }
+fn ode_get_k(): int { return _ode_get_slot4() }
+fn ode_get_extra(): int { return _ode_get_slot5() }
+fn ode_get_steps(): int { return _ode_get_slot6() }
+
+// Scalar-system dispatcher helper matching the callback-free pattern.
+// Uses the module state parameter k from slot 4.
+fn ode_k1(system_id: int, t_fx: int, y_fx: int): int {
+    let k_fx: int = ode_get_k()
+    if (system_id == 1) {
+        return 0 - ode_mul_fx(k_fx, y_fx)
+    }
+    if (system_id == 2) {
+        return ode_mul_fx(k_fx, y_fx)
+    }
+    return 0
+}
+
+fn ode_eval_y(system_id: int, t_fx: int, y_fx: int, y2_fx: int, k_fx: int, extra_fx: int): int {
+    if (system_id == 1) {
+        return 0 - ode_mul_fx(k_fx, y_fx)
+    }
+    if (system_id == 2) {
+        return ode_mul_fx(k_fx, y_fx)
+    }
+    if (system_id == 3) {
+        return y2_fx
+    }
+    return 0
+}
+
+fn ode_eval_y2(system_id: int, t_fx: int, y_fx: int, y2_fx: int, k_fx: int, extra_fx: int): int {
+    if (system_id == 3) {
+        return 0 - ode_mul_fx(k_fx, y_fx) - ode_mul_fx(extra_fx, y2_fx)
+    }
+    return 0
+}
+
+fn ode_step(h_fx: int) {
+    let system_id: int = ode_get_system()
+    let t_fx: int = ode_get_t()
+    let y_fx: int = ode_get_y()
+    let y2_fx: int = ode_get_y2()
+    let k_fx: int = ode_get_k()
+    let extra_fx: int = ode_get_extra()
+    let step_count: int = ode_get_steps()
+
+    let half_h_fx: int = h_fx / 2
+
+    if (system_id == 3) {
+        let k1_y: int = ode_eval_y(system_id, t_fx, y_fx, y2_fx, k_fx, extra_fx)
+        let k1_y2: int = ode_eval_y2(system_id, t_fx, y_fx, y2_fx, k_fx, extra_fx)
+
+        let t2_fx: int = t_fx + half_h_fx
+        let y_k2_fx: int = y_fx + half_h_fx * k1_y / 10000
+        let y2_k2_fx: int = y2_fx + half_h_fx * k1_y2 / 10000
+        let k2_y: int = ode_eval_y(system_id, t2_fx, y_k2_fx, y2_k2_fx, k_fx, extra_fx)
+        let k2_y2: int = ode_eval_y2(system_id, t2_fx, y_k2_fx, y2_k2_fx, k_fx, extra_fx)
+
+        let y_k3_fx: int = y_fx + half_h_fx * k2_y / 10000
+        let y2_k3_fx: int = y2_fx + half_h_fx * k2_y2 / 10000
+        let k3_y: int = ode_eval_y(system_id, t2_fx, y_k3_fx, y2_k3_fx, k_fx, extra_fx)
+        let k3_y2: int = ode_eval_y2(system_id, t2_fx, y_k3_fx, y2_k3_fx, k_fx, extra_fx)
+
+        let t4_fx: int = t_fx + h_fx
+        let y_k4_fx: int = y_fx + h_fx * k3_y / 10000
+        let y2_k4_fx: int = y2_fx + h_fx * k3_y2 / 10000
+        let k4_y: int = ode_eval_y(system_id, t4_fx, y_k4_fx, y2_k4_fx, k_fx, extra_fx)
+        let k4_y2: int = ode_eval_y2(system_id, t4_fx, y_k4_fx, y2_k4_fx, k_fx, extra_fx)
+
+        _ode_set_slot1(t_fx + h_fx)
+        _ode_set_slot2(y_fx + ode_weighted_increment(h_fx, k1_y + 2 * k2_y + 2 * k3_y + k4_y))
+        _ode_set_slot3(y2_fx + ode_weighted_increment(h_fx, k1_y2 + 2 * k2_y2 + 2 * k3_y2 + k4_y2))
+        _ode_set_slot6(step_count + 1)
+        return
+    }
+
+    let k1: int = ode_eval_y(system_id, t_fx, y_fx, y2_fx, k_fx, extra_fx)
+    let k2: int = ode_eval_y(system_id, t_fx + half_h_fx, y_fx + half_h_fx * k1 / 10000, y2_fx, k_fx, extra_fx)
+    let k3: int = ode_eval_y(system_id, t_fx + half_h_fx, y_fx + half_h_fx * k2 / 10000, y2_fx, k_fx, extra_fx)
+    let k4: int = ode_eval_y(system_id, t_fx + h_fx, y_fx + h_fx * k3 / 10000, y2_fx, k_fx, extra_fx)
+
+    _ode_set_slot1(t_fx + h_fx)
+    _ode_set_slot2(y_fx + ode_weighted_increment(h_fx, k1 + 2 * k2 + 2 * k3 + k4))
+    _ode_set_slot6(step_count + 1)
+}
+
+fn ode_run(system_id: int, t0_fx: int, y0_fx: int, h_fx: int, steps: int, k_fx: int) {
+    ode_reset(system_id, t0_fx, y0_fx, 0, k_fx, 0)
+    let i: int = 0
+    while (i < steps) {
+        ode_step(h_fx)
+        i = i + 1
+    }
+}
+
+fn ode_run2(system_id: int, t0_fx: int, y0_fx: int, y20_fx: int, h_fx: int, steps: int, k_fx: int, extra_fx: int) {
+    ode_reset(system_id, t0_fx, y0_fx, y20_fx, k_fx, extra_fx)
+    let i: int = 0
+    while (i < steps) {
+        ode_step(h_fx)
+        i = i + 1
+    }
+}

package/src/stdlib/parabola.mcrs

@@ -0,0 +1,160 @@
+// parabola.mcrs — Projectile motion helpers for Minecraft datapacks.
+//
+// All values use Minecraft's native units:
+//   position: blocks (integer or ×10000 fixed-point)
+//   velocity: blocks/tick (×10000 fixed-point)
+//   time:     ticks (integer)
+//   gravity:  ≈ 0.08 blocks/tick² downward = -800 in ×10000 fixed-point per tick
+//
+// MC projectile physics (per tick):
+//   vy_new = (vy_old - gravity) * drag
+//   x_new = x + vx; y_new = y + vy; z_new = z + vz
+//   vx_new = vx * drag; vz_new = vz * drag
+//
+// For simplified ballistic (no drag), use drag = 10000 (1.0).
+// Standard MC arrow drag: 9900 (0.99). Thrown snowball: 9900.
+//
+// Requires: stdlib/math (for mulfix)
+
+module library;
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+// GRAVITY: MC gravity per tick ×10000 (≈ 0.08 * 10000 = 800)
+fn parabola_gravity(): int { return 800; }
+
+// GRAVITY_HALF: gravity/2 for displacement formula ×10000
+fn parabola_gravity_half(): int { return 400; }
+
+// ─── Ballistic trajectory (no drag) ──────────────────────────────────────────
+//
+// Given a target offset (dx, dy, dz) in blocks and time t in ticks:
+//   vx = dx * 10000 / t
+//   vy = (dy * 10000 + gravity_half * t * t) / t
+//   vz = dz * 10000 / t
+//
+// All velocities returned ×10000 (blocks/tick × 10000)
+
+// parabola_vx(dx, ticks): initial X velocity ×10000
+// dx: horizontal displacement in blocks
+// ticks: flight time in ticks
+fn parabola_vx(dx: int, ticks: int): int {
+    if (ticks <= 0) { return 0; }
+    return dx * 10000 / ticks;
+}
+
+// parabola_vy(dy, ticks): initial Y velocity ×10000
+// dy: vertical displacement in blocks (positive = up)
+fn parabola_vy(dy: int, ticks: int): int {
+    if (ticks <= 0) { return 0; }
+    // vy * t = dy * 10000 + gravity_half * t^2
+    // vy = (dy * 10000 + 400 * t * t) / t
+    let g_term: int = parabola_gravity_half() * ticks * ticks / 10000;
+    return (dy * 10000 + g_term) / ticks;
+}
+
+// parabola_vz(dz, ticks): initial Z velocity ×10000
+fn parabola_vz(dz: int, ticks: int): int {
+    if (ticks <= 0) { return 0; }
+    return dz * 10000 / ticks;
+}
+
+// parabola_speed_xz(dx, dz, ticks): horizontal speed ×10000 (for launch angle)
+// Returns sqrt(vx^2 + vz^2) ×10000
+fn parabola_speed_xz(dx: int, dz: int, ticks: int): int {
+    if (ticks <= 0) { return 0; }
+    let vx: int = parabola_vx(dx, ticks);
+    let vz: int = parabola_vz(dz, ticks);
+    // |vxz|^2 = (vx^2 + vz^2) / 10000 (since vx,vz are ×10000)
+    let vxz_sq: int = mulfix(vx, vx) + mulfix(vz, vz);
+    return isqrt(vxz_sq * 10000);
+}
+
+// ─── Position at time t ───────────────────────────────────────────────────────
+//
+// Given initial velocity (vx0, vy0, vz0) ×10000 and tick t:
+//   x(t) = vx0 * t / 10000
+//   y(t) = vy0 * t / 10000 - gravity_half * t^2 / 10000
+//   z(t) = vz0 * t / 10000
+
+// parabola_x(vx0, t): X position at tick t in blocks
+fn parabola_x(vx0: int, t: int): int {
+    return vx0 * t / 10000;
+}
+
+// parabola_y(vy0, t): Y position at tick t in blocks
+fn parabola_y(vy0: int, t: int): int {
+    let g_term: int = parabola_gravity_half() * t * t / 10000;
+    return vy0 * t / 10000 - g_term;
+}
+
+// parabola_z(vz0, t): Z position at tick t in blocks
+fn parabola_z(vz0: int, t: int): int {
+    return vz0 * t / 10000;
+}
+
+// ─── Flight time estimation ───────────────────────────────────────────────────
+//
+// Given initial upward velocity vy0 (×10000), find the tick when the projectile
+// returns to launch height (y=0):
+//   t = 2 * vy0 / gravity = 2 * vy0 / 800
+// Returns ticks (integer). Returns 0 if vy0 <= 0.
+
+// parabola_flight_time(vy0): ticks until returning to launch height
+fn parabola_flight_time(vy0: int): int {
+    if (vy0 <= 0) { return 0; }
+    return 2 * vy0 / parabola_gravity();
+}
+
+// parabola_max_height(vy0): maximum height above launch point in blocks
+// apex at t = vy0 / gravity
+fn parabola_max_height(vy0: int): int {
+    if (vy0 <= 0) { return 0; }
+    let t_apex: int = vy0 / parabola_gravity();
+    return parabola_y(vy0, t_apex);
+}
+
+// ─── With drag ────────────────────────────────────────────────────────────────
+//
+// One-tick physics step with drag (for animation/simulation, not aiming):
+//   vx_new = mulfix(vx, drag)
+//   vy_new = mulfix(vy - gravity, drag)  [gravity applied before drag]
+//   vz_new = mulfix(vz, drag)
+//
+// drag: ×10000 (e.g. 9900 = 0.99 for arrows, 9800 = 0.98 for fireballs)
+
+// parabola_step_vx(vx, drag): apply drag to X velocity
+fn parabola_step_vx(vx: int, drag: int): int {
+    return mulfix(vx, drag);
+}
+
+// parabola_step_vy(vy, drag): apply gravity then drag to Y velocity
+fn parabola_step_vy(vy: int, drag: int): int {
+    return mulfix(vy - parabola_gravity(), drag);
+}
+
+// parabola_step_vz(vz, drag): apply drag to Z velocity
+fn parabola_step_vz(vz: int, drag: int): int {
+    return mulfix(vz, drag);
+}
+
+// ─── Targeting helpers ────────────────────────────────────────────────────────
+
+// parabola_ticks_for_range(range): estimate ticks to reach a horizontal range
+// range: distance in blocks
+// Uses average speed heuristic: t ≈ range * 10000 / 8000 (arrow ≈ 0.8 b/t horizontal)
+// For precise aiming use parabola_vx/vy/vz with desired ticks.
+fn parabola_ticks_for_range(range: int): int {
+    if (range <= 0) { return 1; }
+    let t: int = range * 10000 / 8000;
+    if (t <= 0) { t = 1; }
+    return t;
+}
+
+// parabola_in_range(dx, dz, max_range): returns 1 if target within horizontal range
+fn parabola_in_range(dx: int, dz: int, max_range: int): int {
+    let dist_sq: int = dx * dx + dz * dz;
+    let range_sq: int = max_range * max_range;
+    if (dist_sq <= range_sq) { return 1; }
+    return 0;
+}

package/src/stdlib/particles.mcrs

@@ -50,3 +50,72 @@ fn totem_at(x: int, y: int, z: int) {
 fn end_sparkles_at(x: int, y: int, z: int) {
     particle("end_rod", x, y, z);
 }
+
+// ─── Particle graph drawing ───────────────────────────────────────────────────
+//
+// Draw 2D/3D function graphs using particles.
+// All positions: block coordinates × 100 (e.g. 100 = 1 block)
+//
+// Usage pattern (loop over samples and draw each point):
+//   let step: int = 5000;  // 0.5 block step
+//   let t: int = -100000;  // from x = -10.0
+//   while (t <= 100000) {
+//       let y: int = sin_fixed(t / 1000);  // y = sin(x) in degrees
+//       particle_at_fx(t, y, 0, "minecraft:flame");
+//       t = t + step;
+//   }
+
+// particle_at_fx(x_fx, y_fx, z_fx, particle): spawn particle at fixed-point position
+// Coordinates: ×100 (1 block = 100 units)
+fn particle_at_fx(x_fx: int, y_fx: int, z_fx: int, particle: string) {
+    let bx: int = x_fx / 100;
+    let by: int = y_fx / 100;
+    let bz: int = z_fx / 100;
+    raw("particle {particle} {bx}.{x_fx%100} {by}.{y_fx%100} {bz}.{z_fx%100} 0 0 0 0 1 force");
+}
+
+// draw_line_2d(x0, y0, x1, y1, steps, z, particle):
+// Draw a straight line from (x0,y0) to (x1,y1) with given number of steps
+// All coords ×100
+fn draw_line_2d(x0: int, y0: int, x1: int, y1: int, steps: int, z: int, particle: string) {
+    let i: int = 0;
+    while (i <= steps) {
+        let x: int = x0 + (x1 - x0) * i / steps;
+        let y: int = y0 + (y1 - y0) * i / steps;
+        particle_dot(x / 100, y / 100, z / 100, particle);
+        i = i + 1;
+    }
+}
+
+// draw_circle(cx, cy, cz, r, steps, particle):
+// Draw a circle in the XZ plane
+// cx,cy,cz: center in blocks, r: radius ×100, steps: number of particles
+fn draw_circle(cx: int, cy: int, cz: int, r: int, steps: int, particle: string) {
+    let i: int = 0;
+    while (i < steps) {
+        let angle: int = i * 360 / steps;
+        let x: int = cx + cos_fixed(angle) * r / 1000;
+        let z: int = cz + sin_fixed(angle) * r / 1000;
+        particle_dot(x, cy, z, particle);
+        i = i + 1;
+    }
+}
+
+// draw_helix(cx, cy_start, cz, r, height, rotations, steps, particle):
+// Draw a helix spiral
+fn draw_helix(cx: int, cy_start: int, cz: int, r: int, height: int, rotations: int, steps: int, particle: string) {
+    let i: int = 0;
+    while (i < steps) {
+        let angle: int = i * 360 * rotations / steps;
+        let x: int = cx + cos_fixed(angle) * r / 1000;
+        let z: int = cz + sin_fixed(angle) * r / 1000;
+        let y: int = cy_start + height * i / steps;
+        particle_dot(x, y, z, particle);
+        i = i + 1;
+    }
+}
+
+// particle_dot(x, y, z, particle): helper — single particle at integer block coords
+fn particle_dot(x: int, y: int, z: int, particle: string) {
+    raw("particle {particle} {x} {y} {z} 0 0 0 0 1 force");
+}