redscript-mc 2.4.1 → 2.6.0

package/src/examples/tutorial_09_precision.mcrs

@@ -0,0 +1,154 @@
+// ============================================
+// Tutorial 09: Precision Arithmetic — fixed & double
+// ============================================
+// Demonstrates:
+// 1. fixed-point (×10000) for 4-decimal precision
+// 2. double type (NBT-backed IEEE 754) for 8+ decimal precision
+// 3. Compound interest: A = P * (1.05)^t
+// 4. Casting between types
+// ============================================
+
+namespace tutorial09
+
+import math::*
+import math_hp::*
+
+// ─── Setup ──────────────────────────────────────────────────────────────────
+
+@load
+fn on_load() {
+    scoreboard_add_objective("precision_data", "dummy")
+    scoreboard_add_objective("result_display", "dummy")
+    scoreboard_display("sidebar", "result_display")
+    say("Precision arithmetic tutorial! /trigger compound_interest  /trigger fixed_demo")
+}
+
+// ─── Fixed-point demo ────────────────────────────────────────────────────────
+
+@on_trigger("fixed_demo")
+fn fixed_demo() {
+    tell(@s, "=== Fixed-Point Arithmetic (×10000 scale) ===")
+
+    // fixed stores values as integer × 10000
+    // 1.5 → 15000,  3.14 → 31400,  0.001 → 10
+    let a: fixed = 15000 as fixed   // 1.5
+    let b: fixed = 25000 as fixed   // 2.5
+
+    // Arithmetic on fixed values works like int arithmetic
+    // BUT remember: adding two fixed values is fine (15000+25000=40000 = 4.0)
+    // Multiplying needs manual rescaling: a*b/10000
+
+    let sum: int = (a as int) + (b as int)   // 40000 = 4.0
+    tell(@s, "1.5 + 2.5 = " + sum + " (×10000, real value = 4.0)")
+
+    // Multiply: must divide by 10000 to stay in scale
+    let product: int = mulfix(a as int, b as int)   // 15000*25000/1000 ≈ 375000? No!
+    // mulfix uses scale=1000, but our fixed uses scale=10000
+    // For ×10000 scale: use (a * b) / 10000
+    let product_fx: int = (a as int) * (b as int) / 10000
+    tell(@s, "1.5 * 2.5 = " + product_fx + " (×10000, real value = 3.75)")
+
+    // Percentage calculation
+    let score: int = 750    // raw score
+    let max_score: int = 1000
+    let pct_fx: fixed = (score * 10000 / max_score) as fixed  // 7500 = 75.00%
+    tell(@s, "Score " + score + "/" + max_score + " = " + (pct_fx as int) + " (×10000 = 75.00%)")
+
+    // sqrt_fx: fixed-point square root (×10000 scale)
+    // sqrt_fx(20000) ≈ 14142 means sqrt(2.0) ≈ 1.4142
+    let sqrt2: int = sqrt_fx(20000)
+    tell(@s, "sqrt(2.0) ≈ " + sqrt2 + " (×10000)")
+
+    // sin_fixed: degrees, result ×1000 (note: math lib uses scale=1000 not 10000)
+    let sin45: int = sin_fixed(45)   // ≈ 707
+    tell(@s, "sin(45°) ≈ " + sin45 + " (×1000 = 0.707)")
+}
+
+// ─── Compound interest with fixed-point ─────────────────────────────────────
+// A = P * (1 + r)^t
+// Using fixed-point: rate = 500 (0.05 = 5%)
+
+@on_trigger("compound_interest")
+fn compound_interest() {
+    tell(@s, "=== Compound Interest Demo ===")
+    tell(@s, "P = 1000, rate = 5%, t = 10 years")
+
+    // Fixed-point approach
+    let principal: int = 1000
+    let rate_fx: int = 500   // 0.05 * 10000 = 500
+    let base_fx: int = 10000 + rate_fx   // 1.05 × 10000 = 10500
+
+    let amount: int = principal
+    let t: int = 0
+    while (t < 10) {
+        // A = A * 1.05  in fixed-point: A = A * base_fx / 10000
+        amount = amount * base_fx / 10000
+        t = t + 1
+    }
+
+    tell(@s, "Fixed-point result: " + amount + " (expected ~1629)")
+    scoreboard_set("#result_fx", "result_display", amount)
+    scoreboard_set("#result_fx", "precision_data", amount)
+
+    // Show step-by-step for first 3 years
+    let a: int = principal
+    tell(@s, "Year-by-year (fixed):")
+    let yr: int = 1
+    while (yr <= 5) {
+        a = a * base_fx / 10000
+        tell(@s, "Year " + yr + ": " + a)
+        yr = yr + 1
+    }
+}
+
+// ─── Double precision compound interest ─────────────────────────────────────
+// Uses NBT-backed IEEE 754 doubles for higher precision
+
+@on_trigger("compound_double")
+fn compound_double() {
+    tell(@s, "=== Compound Interest (double precision) ===")
+    tell(@s, "P = 1000.0, rate = 5%, t = 10 years")
+
+    // pow_real(base, exp) computes base^exp using ln/exp
+    // base = 1.05d, exp = 10.0d
+    let base: double = 1.05d
+    let exp_val: double = 10.0d
+
+    let result: double = pow_real(base, exp_val) as double
+
+    // Convert result to int (×10000) to display
+    let result_int: int = result as int
+    scoreboard_set("#result_dbl", "result_display", result_int)
+    tell(@s, "Double result (×10000): " + result_int + " (expected ~16289 = 1.6289)")
+
+    // Compare precision
+    // Fixed:  1000 * 10500^10 / 10000^10  (integer truncation each step)
+    // Double: exact IEEE 754 floating point computation
+    tell(@s, "Fixed gave: check sidebar 'result_fx' vs 'result_dbl'")
+}
+
+// ─── Casting between types ───────────────────────────────────────────────────
+
+@on_trigger("cast_demo")
+fn cast_demo() {
+    tell(@s, "=== Type Casting Demo ===")
+
+    let i: int = 42
+    let f: fixed = i as fixed       // int → fixed: just stores as-is (42 as fixed)
+    tell(@s, "int 42 as fixed = " + (f as int) + " (note: fixed stores the raw int)")
+
+    // To represent 4.2 as fixed: store 42000 (4.2 × 10000)
+    let four_two: fixed = 42000 as fixed
+    tell(@s, "4.2 as fixed = " + (four_two as int) + " (×10000)")
+
+    // fixed → int: drops the scale factor, use / 10000 for real value
+    let raw: int = four_two as int
+    let real: int = raw / 10000   // integer part
+    let decimal: int = raw % 10000   // decimal part (×10000)
+    tell(@s, "4.2 in fixed: integer=" + real + " decimal=" + decimal)
+
+    // double → int: reads the double as a ×10000 fixed integer
+    let d: double = 3.14d
+    let d_int: int = d as int
+    tell(@s, "3.14d as int = " + d_int + " (×10000 = 31400)")
+}

package/src/examples/tutorial_10_kill_race.mcrs

@@ -0,0 +1,289 @@
+// ============================================
+// Tutorial 10: Full Game — Kill Race
+// ============================================
+// Players compete to get the most kills in 3 minutes.
+// Phase machine: LOBBY → COUNTDOWN (10s) → PLAYING (180s) → ENDED
+// ============================================
+
+namespace tutorial10
+
+import effects::*
+import bossbar::*
+import teams::*
+import random::*
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+// Phases
+let PHASE_LOBBY: int = 0
+let PHASE_COUNTDOWN: int = 1
+let PHASE_PLAYING: int = 2
+let PHASE_ENDED: int = 3
+
+// Timer durations in seconds
+let COUNTDOWN_SECS: int = 10
+let GAME_SECS: int = 180   // 3 minutes
+
+// ─── Game State ──────────────────────────────────────────────────────────────
+
+struct GameState {
+    phase: int,
+    timer: int,     // seconds remaining in current phase
+    active: int     // 1 if a game is running
+}
+
+let game: GameState = {
+    phase: 0,
+    timer: 0,
+    active: 0
+}
+
+// ─── Setup ───────────────────────────────────────────────────────────────────
+
+@load
+fn setup() {
+    // Kills objective tracks player kills automatically
+    scoreboard_add_objective("kr_kills", "playerKillCount")
+    scoreboard_add_objective("kr_streak", "dummy")
+    scoreboard_add_objective("kr_seed", "dummy")
+
+    scoreboard_display("sidebar", "kr_kills")
+
+    // Seed for RNG
+    scoreboard_set("#seed", "kr_seed", 123456789)
+
+    say("Kill Race loaded! /trigger join_game  /trigger start_game")
+}
+
+// ─── 1-second timer (rate=20 ticks) ─────────────────────────────────────────
+
+@tick(rate=20)
+fn game_timer() {
+    if (game.active == 0) {
+        return
+    }
+
+    if (game.phase == PHASE_COUNTDOWN) {
+        countdown_tick()
+    } else {
+        if (game.phase == PHASE_PLAYING) {
+            playing_tick()
+        }
+    }
+}
+
+fn countdown_tick() {
+    game.timer = game.timer - 1
+    actionbar(@a, "Game starting in " + game.timer + "...")
+
+    if (game.timer <= 0) {
+        begin_game()
+    }
+}
+
+fn playing_tick() {
+    game.timer = game.timer - 1
+
+    // Update bossbar
+    update_bar("kr:timer", game.timer)
+    update_bar_color("kr:timer", game.timer * 100 / GAME_SECS)
+
+    // Actionbar with time remaining
+    let mins: int = game.timer / 60
+    let secs: int = game.timer % 60
+    actionbar(@a, "⏱ " + mins + "m " + secs + "s remaining — get kills!")
+
+    if (game.timer <= 10) {
+        // Warning sound region
+        actionbar(@a, "⚠ FINAL " + game.timer + " SECONDS!")
+    }
+
+    if (game.timer <= 0) {
+        end_game()
+    }
+}
+
+// ─── Kill tracking ────────────────────────────────────────────────────────────
+
+// Every tick: check for players who got kills during PLAYING phase
+@tick(rate=20)
+fn check_kill_streaks() {
+    if (game.phase != PHASE_PLAYING) {
+        return
+    }
+
+    foreach (p in @a) {
+        let kills: int = scoreboard_get(p, "kr_kills")
+        let streak: int = scoreboard_get(p, "kr_streak")
+
+        // Reward kill streaks
+        if (kills > 0) {
+            if (kills % 5 == 0) {
+                // Every 5 kills: speed boost
+                speed(p, 5, 1)
+                tell(p, "Kill streak! Speed boost!")
+            }
+            if (kills % 10 == 0) {
+                // Every 10 kills: strength
+                strength(p, 10, 0)
+                tell(p, "10-kill streak! Strength boost!")
+                // Random bonus loot
+                drop_bonus_loot(p)
+            }
+        }
+    }
+}
+
+fn drop_bonus_loot(p: selector) {
+    let seed: int = scoreboard_get("#seed", "kr_seed")
+    seed = next_lcg(seed)
+    scoreboard_set("#seed", "kr_seed", seed)
+
+    let roll: int = random_range(seed, 0, 3)
+    if (roll == 0) {
+        give(p, "minecraft:golden_apple", 1)
+        tell(p, "Bonus: Golden Apple!")
+    } else {
+        if (roll == 1) {
+            give(p, "minecraft:arrow", 16)
+            tell(p, "Bonus: 16 Arrows!")
+        } else {
+            give(p, "minecraft:cooked_beef", 8)
+            tell(p, "Bonus: 8 Steaks!")
+        }
+    }
+}
+
+// ─── Triggers ────────────────────────────────────────────────────────────────
+
+@on_trigger("join_game")
+fn join_game() {
+    if (game.phase == PHASE_PLAYING) {
+        tell(@s, "A game is already in progress!")
+        return
+    }
+
+    tag_add(@s, "kr_joined")
+    tell(@s, "You joined Kill Race! Wait for the game to start.")
+    announce("A player joined Kill Race! /trigger join_game to join!")
+}
+
+@on_trigger("start_game")
+fn start_game() {
+    if (game.active == 1) {
+        tell(@s, "A game is already running!")
+        return
+    }
+
+    let joined: int = 0
+    foreach (p in @a[tag=kr_joined]) {
+        joined = joined + 1
+    }
+    if (joined < 1) {
+        tell(@s, "At least 1 player must join first!")
+        return
+    }
+
+    game.active = 1
+    game.phase = PHASE_COUNTDOWN
+    game.timer = COUNTDOWN_SECS
+
+    // Reset kill counts
+    foreach (p in @a[tag=kr_joined]) {
+        scoreboard_set(p, "kr_kills", 0)
+        scoreboard_set(p, "kr_streak", 0)
+        clear(p)
+        give(p, "minecraft:iron_sword", 1)
+        give(p, "minecraft:bow", 1)
+        give(p, "minecraft:arrow", 32)
+        give(p, "minecraft:cooked_beef", 8)
+    }
+
+    say("Kill Race countdown started!")
+    title(@a, "Kill Race")
+    subtitle(@a, "Get the most kills in 3 minutes!")
+}
+
+fn begin_game() {
+    game.phase = PHASE_PLAYING
+    game.timer = GAME_SECS
+
+    // Create timer bossbar
+    create_timer_bar("kr:timer", "Kill Race", GAME_SECS)
+
+    title(@a, "FIGHT!")
+    subtitle(@a, "Kill Race — 3 minutes")
+    say("Kill Race has begun!")
+
+    // Set gamemode to survival
+    foreach (p in @a[tag=kr_joined]) {
+        effect(p, "minecraft:speed", 3, 1)
+    }
+}
+
+fn end_game() {
+    game.phase = PHASE_ENDED
+    game.active = 0
+
+    hide_bar("kr:timer")
+    say("Kill Race ended!")
+
+    // Find winner
+    announce_winner()
+
+    // Schedule cleanup in 10 seconds
+    cleanup_game()
+}
+
+fn announce_winner() {
+    let top_kills: int = 0
+
+    // Find max kills
+    foreach (p in @a[tag=kr_joined]) {
+        let k: int = scoreboard_get(p, "kr_kills")
+        if (k > top_kills) {
+            top_kills = k
+        }
+    }
+
+    if (top_kills == 0) {
+        say("No kills scored! It's a draw.")
+        title(@a, "Draw!")
+        return
+    }
+
+    // Award winners (everyone tied at top)
+    foreach (p in @a[tag=kr_joined]) {
+        let k: int = scoreboard_get(p, "kr_kills")
+        if (k == top_kills) {
+            title(p, "You Win!")
+            subtitle(p, "Top score: " + top_kills + " kills!")
+            buff_all(p, 60)
+            give(p, "minecraft:diamond", top_kills)
+            tell(p, "Winner's prize: " + top_kills + " diamonds!")
+        } else {
+            title(p, "Game Over")
+            subtitle(p, "Your kills: " + k)
+        }
+    }
+
+    announce("Kill Race winner had " + top_kills + " kills!")
+}
+
+@schedule(200)
+fn cleanup_game() {
+    // Remove tags
+    foreach (p in @a[tag=kr_joined]) {
+        tag_remove(p, "kr_joined")
+        effect_clear(p)
+    }
+
+    // Reset phase
+    game.phase = PHASE_LOBBY
+    game.active = 0
+
+    // Remove bossbar
+    remove_bar("kr:timer")
+
+    say("Kill Race lobby reset. /trigger join_game to play again!")
+}

package/src/hir/lower.ts

@@ -185,7 +185,7 @@ function lowerStmt(stmt: Stmt): HIRStmt | HIRStmt[] {
         kind: 'while',
         cond: {
           kind: 'binary',
-          op: '<',
+          op: stmt.inclusive ? '<=' : '<',
           left: { kind: 'ident', name: varName },
           right: lowerExpr(stmt.end),
         },
@@ -196,6 +196,58 @@ function lowerStmt(stmt: Stmt): HIRStmt | HIRStmt[] {
       return [initStmt, whileStmt]
     }
 
+    // --- Desugaring: for_in_array → let idx = 0; while(idx < len) { let v = arr[idx]; body; idx = idx + 1 } ---
+    case 'for_in_array': {
+      const idxName = `__forin_idx_${stmt.binding}`
+      const initStmt: HIRStmt = {
+        kind: 'let',
+        name: idxName,
+        type: { kind: 'named', name: 'int' },
+        init: { kind: 'int_lit', value: 0 },
+        span: stmt.span,
+      }
+      const bindingInit: HIRStmt = {
+        kind: 'let',
+        name: stmt.binding,
+        type: undefined,
+        init: {
+          kind: 'index',
+          obj: { kind: 'ident', name: stmt.arrayName },
+          index: { kind: 'ident', name: idxName },
+        },
+        span: stmt.span,
+      }
+      const stepStmt: HIRStmt = {
+        kind: 'expr',
+        expr: {
+          kind: 'assign',
+          target: idxName,
+          value: {
+            kind: 'binary',
+            op: '+',
+            left: { kind: 'ident', name: idxName },
+            right: { kind: 'int_lit', value: 1 },
+          },
+        },
+        span: stmt.span,
+      }
+      const body = [bindingInit, ...lowerBlock(stmt.body)]
+      const step: HIRStmt[] = [stepStmt]
+      const whileStmt: HIRStmt = {
+        kind: 'while',
+        cond: {
+          kind: 'binary',
+          op: '<',
+          left: { kind: 'ident', name: idxName },
+          right: lowerExpr(stmt.lenExpr),
+        },
+        body,
+        step,
+        span: stmt.span,
+      }
+      return [initStmt, whileStmt]
+    }
+
     case 'foreach':
       return {
         kind: 'foreach',
@@ -466,6 +518,9 @@ function lowerExpr(expr: Expr): HIRExpr {
     case 'none_lit':
       return { kind: 'none_lit', span: expr.span }
 
+    case 'type_cast':
+      return { kind: 'type_cast', expr: lowerExpr(expr.expr), targetType: expr.targetType, span: expr.span }
+
     case 'lambda': {
       const body = Array.isArray(expr.body) ? lowerBlock(expr.body) : lowerExpr(expr.body)
       return {

package/src/hir/monomorphize.ts

@@ -395,7 +395,7 @@ class Monomorphizer {
   private inferExprType(expr: HIRExpr, ctx: RewriteCtx): TypeNode | null {
     switch (expr.kind) {
       case 'int_lit':    return { kind: 'named', name: 'int' }
-      case 'float_lit':  return { kind: 'named', name: 'float' }
+      case 'float_lit':  return { kind: 'named', name: 'fixed' }
       case 'bool_lit':   return { kind: 'named', name: 'bool' }
       case 'str_lit':    return { kind: 'named', name: 'string' }
       case 'byte_lit':   return { kind: 'named', name: 'byte' }

package/src/hir/types.ts

@@ -95,6 +95,8 @@ export type HIRExpr =
   // Option literals
   | { kind: 'some_lit'; value: HIRExpr; span?: Span }
   | { kind: 'none_lit'; span?: Span }
+  // Type cast: expr as Type
+  | { kind: 'type_cast'; expr: HIRExpr; targetType: TypeNode; span?: Span }
 
 // ---------------------------------------------------------------------------
 // Execute Subcommands (unified — absorbs as_block, at_block, as_at)

package/src/lexer/index.ts

@@ -18,7 +18,7 @@ export type TokenKind =
   | 'return' | 'break' | 'continue' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'module'
   | 'execute' | 'run' | 'unless' | 'declare' | 'export'
   // Types
-  | 'int' | 'bool' | 'float' | 'string' | 'void'
+  | 'int' | 'bool' | 'float' | 'fixed' | 'string' | 'void'
   | 'BlockPos'
   // Boolean literals
   | 'true' | 'false'
@@ -95,6 +95,7 @@ const KEYWORDS: Record<string, TokenKind> = {
   int: 'int',
   bool: 'bool',
   float: 'float',
+  fixed: 'fixed',
   string: 'string',
   void: 'void',
   BlockPos: 'BlockPos',
@@ -276,6 +277,10 @@ export class Lexer {
     if (char === '.' && this.peek() === '.') {
       this.advance() // consume second .
       let value = '..'
+      // Check for inclusive range operator ..=
+      if (this.peek() === '=') {
+        value += this.advance() // consume =
+      }
       while (/[0-9]/.test(this.peek())) {
         value += this.advance()
       }
@@ -563,10 +568,14 @@ export class Lexer {
       value += this.advance()
     }
 
-    // Check for range literal (e.g., 1.., 1..10)
+    // Check for range literal (e.g., 1.., 1..10, 1..=10)
     if (this.peek() === '.' && this.peek(1) === '.') {
       value += this.advance() // first .
       value += this.advance() // second .
+      // Check for inclusive range operator =
+      if (this.peek() === '=') {
+        value += this.advance() // consume =
+      }
       // Optional max value
       while (/[0-9]/.test(this.peek())) {
         value += this.advance()