redscript-mc 2.4.1 → 2.6.0

package/src/stdlib/noise.mcrs

@@ -0,0 +1,153 @@
+// noise.mcrs — Procedural noise functions for Minecraft datapacks.
+//
+// Uses fixed-point arithmetic (×10000 scale).
+// No floating point, no external dependencies.
+//
+// Functions:
+//   hash_1d, hash_2d — integer hash (pseudo-random per coordinate)
+//   value_noise_1d   — smooth 1D value noise [0, 10000]
+//   value_noise_2d   — smooth 2D value noise [0, 10000]
+//   fbm_1d           — fractal Brownian motion (octave stacking)
+//
+// Requires: import "stdlib/math" (for lerp, abs, clamp)
+
+module library;
+
+// ─── Hash functions ───────────────────────────────────────────────────────────
+
+// hash_1d(x): pseudo-random int from a 1D coordinate
+// Returns any int (use % to restrict range)
+fn hash_1d(x: int): int {
+    let h: int = x * 374761393;
+    h = h + 1013904223;
+    h = h * 1664525;
+    h = h + (h / 65536);
+    return h;
+}
+
+// hash_2d(x, z): pseudo-random int from 2D coordinates
+fn hash_2d(x: int, z: int): int {
+    return hash_1d(x + hash_1d(z));
+}
+
+// hash_1d_pos(x): hash in [0, 10000]
+fn hash_1d_pos(x: int): int {
+    let h: int = hash_1d(x);
+    if (h < 0) { h = 0 - h; }
+    return h % 10001;
+}
+
+// hash_2d_pos(x, z): hash in [0, 10000]
+fn hash_2d_pos(x: int, z: int): int {
+    let h: int = hash_2d(x, z);
+    if (h < 0) { h = 0 - h; }
+    return h % 10001;
+}
+
+// ─── Value noise ─────────────────────────────────────────────────────────────
+
+// value_noise_1d(x_fx): smooth 1D noise at position x_fx (fixed-point ×10000)
+// Returns value in [0, 10000]
+// Uses linear interpolation between random values at integer coords
+fn value_noise_1d(x_fx: int): int {
+    let xi: int = x_fx / 10000;   // integer part
+    let xf: int = x_fx % 10000;   // fractional part [0, 9999]
+    if (xf < 0) { xf = xf + 10000; xi = xi - 1; }
+
+    let v0: int = hash_1d_pos(xi);
+    let v1: int = hash_1d_pos(xi + 1);
+
+    // Smooth interpolation using smoothstep on xf
+    let t: int = 3 * xf * xf / 10000 - 2 * xf * xf / 10000 * xf / 10000;
+    return v0 + (v1 - v0) * t / 10000;
+}
+
+// value_noise_2d(x_fx, z_fx): smooth 2D noise
+// Returns value in [0, 10000]
+fn value_noise_2d(x_fx: int, z_fx: int): int {
+    let xi: int = x_fx / 10000;
+    let xf: int = x_fx % 10000;
+    if (xf < 0) { xf = xf + 10000; xi = xi - 1; }
+
+    let zi: int = z_fx / 10000;
+    let zf: int = z_fx % 10000;
+    if (zf < 0) { zf = zf + 10000; zi = zi - 1; }
+
+    // Bilinear interpolation of 4 corner values
+    let v00: int = hash_2d_pos(xi, zi);
+    let v10: int = hash_2d_pos(xi + 1, zi);
+    let v01: int = hash_2d_pos(xi, zi + 1);
+    let v11: int = hash_2d_pos(xi + 1, zi + 1);
+
+    // Smooth t values
+    let tx: int = 3 * xf * xf / 10000 - 2 * xf * xf / 10000 * xf / 10000;
+    let tz: int = 3 * zf * zf / 10000 - 2 * zf * zf / 10000 * zf / 10000;
+
+    // Bilinear interpolation
+    let vz0: int = v00 + (v10 - v00) * tx / 10000;
+    let vz1: int = v01 + (v11 - v01) * tx / 10000;
+    return vz0 + (vz1 - vz0) * tz / 10000;
+}
+
+// ─── Fractal Brownian Motion ──────────────────────────────────────────────────
+
+// fbm_1d(x_fx, octaves, persistence_fx):
+//   x_fx: position ×10000
+//   octaves: number of noise layers (1-6, more = more detail)
+//   persistence_fx: amplitude decay per octave ×10000 (typical: 5000 = 0.5)
+// Returns value in approximately [0, 10000]
+fn fbm_1d(x_fx: int, octaves: int, persistence_fx: int): int {
+    let value: int = 0;
+    let amplitude: int = 10000;
+    let frequency: int = 10000;  // ×10000 multiplier (starts at 1.0)
+    let max_val: int = 0;         // for normalization
+
+    let oct: int = 0;
+    while (oct < octaves) {
+        let sample_x: int = x_fx * frequency / 10000;
+        value = value + value_noise_1d(sample_x) * amplitude / 10000;
+        max_val = max_val + amplitude;
+        amplitude = amplitude * persistence_fx / 10000;
+        frequency = frequency * 2;
+        oct = oct + 1;
+    }
+
+    // Normalize to [0, 10000]
+    if (max_val <= 0) { return 0; }
+    return value * 10000 / max_val;
+}
+
+// fbm_2d(x_fx, z_fx, octaves, persistence_fx): 2D fractal Brownian motion
+fn fbm_2d(x_fx: int, z_fx: int, octaves: int, persistence_fx: int): int {
+    let value: int = 0;
+    let amplitude: int = 10000;
+    let frequency: int = 10000;
+    let max_val: int = 0;
+
+    let oct: int = 0;
+    while (oct < octaves) {
+        let sx: int = x_fx * frequency / 10000;
+        let sz: int = z_fx * frequency / 10000;
+        value = value + value_noise_2d(sx, sz) * amplitude / 10000;
+        max_val = max_val + amplitude;
+        amplitude = amplitude * persistence_fx / 10000;
+        frequency = frequency * 2;
+        oct = oct + 1;
+    }
+
+    if (max_val <= 0) { return 0; }
+    return value * 10000 / max_val;
+}
+
+// ─── Convenience: terrain height ─────────────────────────────────────────────
+
+// terrain_height(x, z, base_y, amplitude):
+//   Generates a terrain height using 3-octave fbm.
+//   x, z: block coordinates (integers, NOT fixed-point)
+//   base_y: baseline height in blocks
+//   amplitude: max height variation in blocks
+fn terrain_height(x: int, z: int, base_y: int, amplitude: int): int {
+    // Scale x,z by ×10000 for fixed-point, divide by 4 for wider features
+    let noise: int = fbm_2d(x * 2500, z * 2500, 3, 5000);
+    return base_y + noise * amplitude / 10000;
+}

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");
+}