redscript-mc 2.6.0 → 2.6.2

package/src/runtime/index.ts

@@ -273,6 +273,11 @@ export class MCRuntime {
     this.namespace = namespace
     // Initialize default objective
     this.scoreboard.set('rs', new Map())
+    // Pre-populate math:tables with the sin LUT (same values as _math_init in math.mcrs).
+    // This avoids requiring a real MC server for unit tests that use sin_fixed/cos_fixed.
+    // Values: sin(0°..90°) × 1000, 91 entries.
+    const SIN_TABLE = [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]
+    this.setStorageField('math:tables', 'sin', SIN_TABLE)
   }
 
   // -------------------------------------------------------------------------
@@ -786,6 +791,27 @@ export class MCRuntime {
   private execFunctionCmd(cmd: string, executor?: Entity): boolean {
     let fnRef = cmd.slice(9).trim() // remove 'function '
 
+    // Handle storage_get_int builtin — compiled as `function ns:storage_get_int`
+    // Parameters: $p0=0 (storagePath, lost as string), $p1=0 (fieldName, lost),
+    // $p2=index. Since string params are lost, we use a hardcoded lookup against
+    // the pre-populated math:tables.sin (the only stdlib user of this builtin).
+    // The result is written to $ret.
+    if (fnRef.endsWith(':storage_get_int')) {
+      const ns = this.namespace
+      const obj = `__${ns}`
+      const idx = this.getScore('$p2', obj)
+      const arr = this.getStorageField('math:tables', 'sin') as number[] | undefined
+      const value = Array.isArray(arr) ? (arr[idx] ?? 0) : 0
+      this.setScore('$ret', obj, value)
+      return true
+    }
+
+    // Handle storage_set_array builtin — compiled as `function ns:storage_set_array`
+    // The sin LUT is already pre-populated in the constructor; this is a no-op.
+    if (fnRef.endsWith(':storage_set_array')) {
+      return true
+    }
+
     // Handle 'function ns:name with storage ns:path' — MC macro calling convention.
     // The called function may have $( ) placeholders that need to be expanded
     // using the provided storage compound. We execute the function after

package/src/stdlib/bigint.mcrs

@@ -318,3 +318,130 @@ fn bigint_sq(a: int[], result: int[], len: int) {
         k = k - 1;
     }
 }
+
+// ─── Full bigint ÷ bigint (Long Division) ────────────────────────────────────
+//
+// bigint_div(a, b, quotient, remainder, la, lb):
+//   Compute a / b → quotient, a % b → remainder
+//   a has la chunks, b has lb chunks (most-significant first, base 10000)
+//   quotient must have la chunks (pre-zeroed)
+//   remainder must have lb chunks (pre-zeroed)
+//
+//   Algorithm: Binary-search trial subtraction per digit position.
+//   For each position i in quotient (0..la-lb):
+//     trial_subtract(a_window, b, lb) to find max digit q such that q*b ≤ window.
+//
+// Prerequisite helpers: bigint_cmp, bigint_mul_small, bigint_sub (all in bigint.mcrs)
+
+// bigint_shl1(a, len): shift bigint left by 1 chunk (multiply by base 10000)
+// Modifies a in-place, drops most-significant chunk.
+fn bigint_shl1(a: int[], len: int): void {
+    let i: int = 0;
+    while (i < len - 1) {
+        a[i] = a[i + 1];
+        i = i + 1;
+    }
+    a[len - 1] = 0;
+}
+
+// bigint_cmp_window(a, aoff, b, len): compare a[aoff..aoff+len] with b[0..len]
+// Returns 1 if a_window > b, -1 if a_window < b, 0 if equal
+fn bigint_cmp_window(a: int[], aoff: int, b: int[], len: int): int {
+    let i: int = 0;
+    while (i < len) {
+        let ai: int = a[aoff + i];
+        let bi: int = b[i];
+        if (ai > bi) { return 1; }
+        if (ai < bi) { return -1; }
+        i = i + 1;
+    }
+    return 0;
+}
+
+// bigint_sub_window(a, aoff, b, len): a[aoff..aoff+len] -= b[0..len]  (in-place)
+fn bigint_sub_window(a: int[], aoff: int, b: int[], len: int): void {
+    let borrow: int = 0;
+    let i: int = len - 1;
+    while (i >= 0) {
+        let diff: int = a[aoff + i] - b[i] - borrow;
+        if (diff < 0) {
+            diff = diff + 10000;
+            borrow = 1;
+        } else {
+            borrow = 0;
+        }
+        a[aoff + i] = diff;
+        i = i - 1;
+    }
+}
+
+// bigint_mul_small_into(b, factor, out, len): out = b * factor (small int)
+fn bigint_mul_small_into(b: int[], factor: int, out: int[], len: int): void {
+    let carry: int = 0;
+    let i: int = len - 1;
+    while (i >= 0) {
+        let prod: int = b[i] * factor + carry;
+        out[i] = prod % 10000;
+        carry = prod / 10000;
+        i = i - 1;
+    }
+}
+
+// bigint_div(a, b, quotient, remainder, la, lb):
+// Full arbitrary-precision integer division.
+// quotient[0..la-1] is written, remainder[0..lb-1] is written.
+// a and b must not alias quotient or remainder.
+// NOTE: la >= lb required; both arrays most-significant first, base 10000.
+fn bigint_div(a: int[], b: int[], quotient: int[], remainder: int[], la: int, lb: int): void {
+    // Work on a copy of a (dividend) to allow in-place subtraction
+    let work: int[] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    let wi: int = 0;
+    while (wi < la) {
+        work[wi] = a[wi];
+        wi = wi + 1;
+    }
+
+    // Temp buffer for trial product: b * q_digit
+    let trial: int[] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+    // Zero quotient
+    let qi: int = 0;
+    while (qi < la) {
+        quotient[qi] = 0;
+        qi = qi + 1;
+    }
+
+    // Process each quotient digit position (la - lb + 1 digits)
+    let pos: int = 0;
+    while (pos <= la - lb) {
+        // Binary search for largest q in [0, 9999] s.t. b * q ≤ work[pos..pos+lb]
+        let lo: int = 0;
+        let hi: int = 9999;
+        let q: int = 0;
+        while (lo <= hi) {
+            let mid: int = (lo + hi) / 2;
+            bigint_mul_small_into(b, mid, trial, lb);
+            let cmp: int = bigint_cmp_window(work, pos, trial, lb);
+            if (cmp >= 0) {
+                q = mid;
+                lo = mid + 1;
+            } else {
+                hi = mid - 1;
+            }
+        }
+        quotient[pos] = q;
+        // Subtract b * q from work window
+        if (q > 0) {
+            bigint_mul_small_into(b, q, trial, lb);
+            bigint_sub_window(work, pos, trial, lb);
+        }
+        pos = pos + 1;
+    }
+
+    // Remainder is work[la-lb .. la-1]
+    let ri: int = 0;
+    while (ri < lb) {
+        remainder[ri] = work[la - lb + ri];
+        ri = ri + 1;
+    }
+}

package/src/stdlib/combat.mcrs

@@ -1,20 +1,26 @@
+// module library
 // Combat helpers for simple RPG-style datapacks.
 
-fn weapon_damage(base: int, bonus: int) -> int {
-    return base + bonus;
+// Returns base + bonus damage.
+fn weapon_damage(base: int, bonus: int): int {
+    return base + bonus
 }
 
-fn enemy_health(name: string) -> int {
-    return scoreboard_get(name, #health);
+// Applies damage to a health value, clamping to 0.
+// Usage: let new_hp: int = take_damage(current_hp, amount)
+// Then: scoreboard_set(player, objective, new_hp)
+fn take_damage(health: int, amount: int): int {
+    let next: int = health - amount
+    if (next < 0) {
+        next = 0
+    }
+    return next
 }
 
-fn apply_damage(name: string, amount: int) {
-    let health: int = enemy_health(name);
-    let next: int = health - amount;
-
-    if (next < 0) {
-        scoreboard_set(name, #health, 0);
-    } else {
-        scoreboard_set(name, #health, next);
+// Returns 1 if health <= 0 (dead), else 0.
+fn is_dead(health: int): int {
+    if (health <= 0) {
+        return 1
     }
+    return 0
 }

package/src/stdlib/dialog.mcrs

@@ -0,0 +1,55 @@
+// MC tellraw dialog system — high-level wrapper for player messaging.
+// Usage: import "stdlib/dialog.mcrs"
+//
+// Provides tellraw-based chat messages, title/subtitle display, and
+// actionbar notifications. All text is sent as raw JSON chat components.
+
+module library
+
+/// Send a plain white message to a player.
+fn dialog_say(p: selector, msg: string) {
+    raw("tellraw {p} {\"text\":\"{msg}\"}");
+}
+
+/// Broadcast a plain white message to all players.
+fn dialog_broadcast(msg: string) {
+    raw("tellraw @a {\"text\":\"{msg}\"}");
+}
+
+/// Send a colored message to a player.
+/// color: 0=white, 1=red, 2=green, 3=gold, 4=aqua
+fn dialog_say_color(p: selector, msg: string, color: int) {
+    if (color == 1) {
+        raw("tellraw {p} {\"text\":\"{msg}\",\"color\":\"red\"}");
+    } else {
+        if (color == 2) {
+            raw("tellraw {p} {\"text\":\"{msg}\",\"color\":\"green\"}");
+        } else {
+            if (color == 3) {
+                raw("tellraw {p} {\"text\":\"{msg}\",\"color\":\"gold\"}");
+            } else {
+                if (color == 4) {
+                    raw("tellraw {p} {\"text\":\"{msg}\",\"color\":\"aqua\"}");
+                } else {
+                    raw("tellraw {p} {\"text\":\"{msg}\",\"color\":\"white\"}");
+                }
+            }
+        }
+    }
+}
+
+/// Display a large title and subtitle on a player's screen.
+fn dialog_title(p: selector, title: string, subtitle: string) {
+    raw("title {p} title {\"text\":\"{title}\"}");
+    raw("title {p} subtitle {\"text\":\"{subtitle}\"}");
+}
+
+/// Clear the title from a player's screen.
+fn dialog_title_clear(p: selector) {
+    raw("title {p} clear");
+}
+
+/// Display a message on the player's actionbar (above hotbar).
+fn dialog_actionbar(p: selector, msg: string) {
+    raw("title {p} actionbar {\"text\":\"{msg}\"}");
+}

package/src/stdlib/ecs.mcrs

@@ -0,0 +1,238 @@
+// ecs.mcrs — Entity Component System for Minecraft Java datapacks.
+//
+// ─── What is ECS? ────────────────────────────────────────────────────────────
+//
+// Entity Component System (ECS) is a data-driven pattern for attaching typed
+// "components" (structured data) to game entities. In Minecraft Java Edition,
+// datapacks have no built-in component system (unlike Bedrock). ECS fills this
+// gap by using:
+//
+//   - Scoreboard objectives  → integer fields (HP, velocity, etc.)
+//   - Entity tags            → component presence flags
+//   - NBT storage            → complex/string data (via raw())
+//
+// Without ECS you'd write 100+ lines of raw NBT per component type, hard-coded
+// per entity. With ecs.mcrs, component state is captured in an int[] "state
+// array" that can be passed around, modified, and read with typed helpers.
+//
+// ─── Usage example ───────────────────────────────────────────────────────────
+//
+//   // Initialise health for entity with score-ID 42, max HP 100
+//   let hp_state: int[] = ecs_health_init(42, 100)
+//
+//   // Take damage
+//   hp_state = ecs_health_damage(hp_state, 30)
+//
+//   // Initialise velocity (×1000 fixed-point)
+//   let vel_state: int[] = ecs_vel_init(1000, 0, 500)  // 1.0, 0.0, 0.5
+//
+//   // Apply gravity each tick
+//   vel_state = ecs_vel_apply_gravity(vel_state, 980)
+//
+//   // Tag the entity in MC (run via raw() or a separate mcfunction):
+//   //   tag @e[scores={ecs_entity=42}] add ecs_has_health
+//   //   tag @e[scores={ecs_entity=42}] add ecs_has_velocity
+//
+// ─── Tag naming convention ───────────────────────────────────────────────────
+//
+//   Entities should carry tag: ecs_has_<comp_name>
+//   e.g.  ecs_has_health, ecs_has_velocity, ecs_has_damage
+//
+//   This lets selectors filter: @e[tag=ecs_has_health]
+//
+// ─── Component type IDs ──────────────────────────────────────────────────────
+
+module library
+
+// Pre-defined component type IDs (used with ecs_register / ecs_is_registered)
+let ECS_COMP_HEALTH: int = 1
+let ECS_COMP_VELOCITY: int = 2
+let ECS_COMP_DAMAGE: int = 3
+
+// ─────────────────────────────────────────────────────────────────────────────
+// ECS Registry
+// Tracks which component types are active in this datapack.
+// Registry is a 16-element int[] where registry[comp_id] == 1 means registered.
+// ─────────────────────────────────────────────────────────────────────────────
+
+// ecs_registry_new(): allocate a blank 16-slot registry
+fn ecs_registry_new(): int[] {
+    let reg: int[] = []
+    let i: int = 0
+    while (i < 16) {
+        reg.push(0)
+        i = i + 1
+    }
+    return reg
+}
+
+// ecs_register(reg, comp_id): mark comp_id as registered; returns updated reg
+fn ecs_register(reg: int[], comp_id: int): int[] {
+    if (comp_id >= 0) {
+        if (comp_id < 16) {
+            reg[comp_id] = 1
+        }
+    }
+    return reg
+}
+
+// ecs_is_registered(reg, comp_id): 1 if registered, 0 otherwise
+fn ecs_is_registered(reg: int[], comp_id: int): int {
+    if (comp_id >= 0) {
+        if (comp_id < 16) {
+            return reg[comp_id]
+        }
+    }
+    return 0
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Health Component
+//
+// State layout (int[], 8 elements):
+//   [0] entity_score  — scoreboard score used as entity identifier
+//   [1] current_hp    — current hit points
+//   [2] max_hp        — maximum hit points
+//   [3..7] reserved   — 0
+// ─────────────────────────────────────────────────────────────────────────────
+
+// ecs_health_init(entity_score, max_hp): create a health component state
+// Sets current_hp = max_hp (full health at spawn)
+fn ecs_health_init(entity_score: int, max_hp: int): int[] {
+    let s: int[] = []
+    s.push(entity_score)
+    s.push(max_hp)
+    s.push(max_hp)
+    s.push(0)
+    s.push(0)
+    s.push(0)
+    s.push(0)
+    s.push(0)
+    return s
+}
+
+// ecs_health_get(state): return current HP
+fn ecs_health_get(state: int[]): int {
+    return state[1]
+}
+
+// ecs_health_max(state): return maximum HP
+fn ecs_health_max(state: int[]): int {
+    return state[2]
+}
+
+// ecs_health_set(state, hp): set current HP (clamped to [0, max]), return state
+fn ecs_health_set(state: int[], hp: int): int[] {
+    let clamped: int = hp
+    if (clamped < 0) { clamped = 0 }
+    if (clamped > state[2]) { clamped = state[2] }
+    state[1] = clamped
+    return state
+}
+
+// ecs_health_damage(state, amount): subtract amount from HP, clamp to 0
+fn ecs_health_damage(state: int[], amount: int): int[] {
+    let next: int = state[1] - amount
+    if (next < 0) { next = 0 }
+    state[1] = next
+    return state
+}
+
+// ecs_health_heal(state, amount): add amount to HP, clamp to max
+fn ecs_health_heal(state: int[], amount: int): int[] {
+    let next: int = state[1] + amount
+    if (next > state[2]) { next = state[2] }
+    state[1] = next
+    return state
+}
+
+// ecs_health_is_dead(state): 1 if HP <= 0, else 0
+fn ecs_health_is_dead(state: int[]): int {
+    if (state[1] <= 0) { return 1 }
+    return 0
+}
+
+// ecs_health_pct(state): HP percentage as fixed-point ×10000
+// e.g. 50 HP out of 100 max → 5000  (= 50.00%)
+fn ecs_health_pct(state: int[]): int {
+    if (state[2] <= 0) { return 0 }
+    return state[1] * 10000 / state[2]
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Velocity Component
+//
+// State layout (int[], 8 elements):
+//   [0] vx  — x velocity ×1000 fixed-point
+//   [1] vy  — y velocity ×1000 fixed-point
+//   [2] vz  — z velocity ×1000 fixed-point
+//   [3..7] reserved — 0
+//
+// Fixed-point convention: 1000 = 1.0 block/tick
+// ─────────────────────────────────────────────────────────────────────────────
+
+// ecs_vel_init(vx, vy, vz): create a velocity component state
+fn ecs_vel_init(vx: int, vy: int, vz: int): int[] {
+    let s: int[] = []
+    s.push(vx)
+    s.push(vy)
+    s.push(vz)
+    s.push(0)
+    s.push(0)
+    s.push(0)
+    s.push(0)
+    s.push(0)
+    return s
+}
+
+// ecs_vel_get_x(state): return vx
+fn ecs_vel_get_x(state: int[]): int {
+    return state[0]
+}
+
+// ecs_vel_get_y(state): return vy
+fn ecs_vel_get_y(state: int[]): int {
+    return state[1]
+}
+
+// ecs_vel_get_z(state): return vz
+fn ecs_vel_get_z(state: int[]): int {
+    return state[2]
+}
+
+// ecs_vel_set(state, vx, vy, vz): set all velocity components, return state
+fn ecs_vel_set(state: int[], vx: int, vy: int, vz: int): int[] {
+    state[0] = vx
+    state[1] = vy
+    state[2] = vz
+    return state
+}
+
+// ecs_vel_speed(state): magnitude of velocity vector ×1000
+// Uses sqrt_fixed: speed = sqrt(vx² + vy² + vz²) in fixed-point units
+// e.g. ecs_vel_speed([3000, 4000, 0, ...]) == 5000
+fn ecs_vel_speed(state: int[]): int {
+    let vx: int = state[0]
+    let vy: int = state[1]
+    let vz: int = state[2]
+    // mag_sq in units of ×1000² = ×1000000
+    // sqrt_fixed expects value in same ×1000 scale, so divide by 1000 first
+    let mag_sq: int = vx * vx / 1000 + vy * vy / 1000 + vz * vz / 1000
+    return sqrt_fixed(mag_sq)
+}
+
+// ecs_vel_apply_gravity(state, gravity_fx): subtract gravity from vy
+// gravity_fx is fixed-point ×1000 (e.g. 980 ≈ 0.980 blocks/tick², roughly 0.08g per tick)
+fn ecs_vel_apply_gravity(state: int[], gravity_fx: int): int[] {
+    state[1] = state[1] - gravity_fx
+    return state
+}
+
+// ecs_vel_damp(state, factor_fx): multiply each velocity component by factor_fx/10000
+// factor_fx: friction factor ×10000 (e.g. 8000 = 0.80 damping)
+fn ecs_vel_damp(state: int[], factor_fx: int): int[] {
+    state[0] = state[0] * factor_fx / 10000
+    state[1] = state[1] * factor_fx / 10000
+    state[2] = state[2] * factor_fx / 10000
+    return state
+}

package/src/stdlib/events.mcrs

@@ -0,0 +1,29 @@
+module events
+// RedScript event dispatcher — detects MC events and dispatches to function tags.
+// Handlers register via @on(EventType) decorator (compiler-generated tag JSON).
+
+@load fn __events_load() {
+    raw("scoreboard objectives add rs.deaths deathCount")
+    raw("scoreboard objectives add rs.kills totalKillCount")
+    raw("scoreboard objectives add rs.item_use minecraft.used:minecraft.carrot_on_a_stick")
+}
+
+@tick fn __events_tick() {
+    // PlayerJoin: players without rs.joined tag
+    raw("execute as @a[tag=!rs.joined] run function #rs:on_player_join")
+    raw("tag @a[tag=!rs.joined] add rs.joined")
+
+    // PlayerDeath
+    raw("execute as @a[scores={rs.deaths=1..}] run function #rs:on_player_death")
+    raw("scoreboard players set @a rs.deaths 0")
+
+    // EntityKill
+    raw("execute as @a[scores={rs.kills=1..}] run function #rs:on_entity_kill")
+    raw("scoreboard players set @a rs.kills 0")
+
+    // ItemUse (carrot_on_a_stick by default)
+    raw("execute as @a[scores={rs.item_use=1..}] run function #rs:on_item_use")
+    raw("scoreboard players set @a rs.item_use 0")
+
+    // BlockBreak requires advancement JSON (not yet implemented)
+}