redscript-mc 2.5.0 → 2.6.2

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, f"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, f"⏱ {mins}m {secs}s remaining — get kills!")
+
+    if (game.timer <= 10) {
+        // Warning sound region
+        actionbar(@a, f"⚠ 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, f"Top score: {top_kills} kills!")
+            buff_all(p, 60)
+            give(p, "minecraft:diamond", top_kills)
+            tell(p, f"Winner's prize: {top_kills} diamonds!")
+        } else {
+            title(p, "Game Over")
+            subtitle(p, f"Your kills: {k}")
+        }
+    }
+
+    announce(f"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/examples/zombie_survival.mcrs

@@ -90,7 +90,7 @@ fn start_prep_phase() {
     state.prep_timer = WAVE_DELAY;
     state.wave = state.wave + 1;
     
-    announce("§4[Zombie Survival] §eWave " + state.wave + " incoming!");
+    announce(f"§4[Zombie Survival] §eWave {state.wave} incoming!");
     announce("§7Preparation time: 10 seconds...");
     
     // Shop hint
@@ -110,7 +110,7 @@ fn start_combat_phase() {
     bossbar_set_max("zs_wave", zombie_count);
     bossbar_set_value("zs_wave", zombie_count);
     
-    title(@a, "§cWave " + state.wave);
+    title(@a, f"§cWave {state.wave}");
     
     // Spawn zombies
     spawn_zombies(zombie_count);
@@ -138,7 +138,7 @@ fn spawn_zombies(count: int) {
         }
     }
     
-    announce("§c" + count + " zombies have appeared!");
+    announce(f"§c{count} zombies have appeared!");
 }
 
 // ===== Every Tick =====
@@ -200,7 +200,7 @@ fn combat_tick() {
 }
 
 fn wave_complete() {
-    announce("§4[Zombie Survival] §aWave " + state.wave + " complete!");
+    announce(f"§4[Zombie Survival] §aWave {state.wave} complete!");
     
     // Reward coins
     let reward: int = 50 + (state.wave * 25);
@@ -208,7 +208,7 @@ fn wave_complete() {
         scoreboard_add(p, "zs_coins", reward);
         happy(p);
     }
-    announce("§6+" + reward + " coins");
+    announce(f"§6+{reward} coins");
     
     // Check special wave
     if (state.wave == 10) {
@@ -291,8 +291,8 @@ fn game_over() {
     state.running = 0;
     
     title(@a, "§cGame Over");
-    subtitle(@a, "§7Survived " + state.wave + " waves");
-    announce("§4[Zombie Survival] §cAll players eliminated! Highest wave: " + state.wave);
+    subtitle(@a, f"§7Survived {state.wave} waves");
+    announce(f"§4[Zombie Survival] §cAll players eliminated! Highest wave: {state.wave}");
     
     // Clean up zombies
     kill(@e[type=zombie]);

package/src/hir/lower.ts

@@ -13,11 +13,11 @@
 
 import type {
   Program, Expr, Stmt, Block, FnDecl, Param,
-  AssignOp, ExecuteSubcommand,
+  AssignOp, ExecuteSubcommand, MatchPattern,
 } from '../ast/types'
 import type {
   HIRModule, HIRFunction, HIRParam, HIRExpr, HIRStmt, HIRBlock,
-  HIRExecuteSubcommand, HIRStruct, HIRImplBlock, HIREnum, HIRConst, HIRGlobal,
+  HIRExecuteSubcommand, HIRStruct, HIRImplBlock, HIREnum, HIRConst, HIRGlobal, HIRMatchPattern,
 } from './types'
 
 // ---------------------------------------------------------------------------
@@ -54,6 +54,20 @@ export function lowerToHIR(program: Program): HIRModule {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Pattern lowering
+// ---------------------------------------------------------------------------
+
+function lowerMatchPattern(pat: MatchPattern): HIRMatchPattern {
+  switch (pat.kind) {
+    case 'PatSome': return pat
+    case 'PatNone': return pat
+    case 'PatInt':  return pat
+    case 'PatWild': return pat
+    case 'PatExpr': return { kind: 'PatExpr', expr: lowerExpr(pat.expr) }
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Functions & globals
 // ---------------------------------------------------------------------------
@@ -185,7 +199,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),
         },
@@ -248,6 +262,83 @@ function lowerStmt(stmt: Stmt): HIRStmt | HIRStmt[] {
       return [initStmt, whileStmt]
     }
 
+    // --- Desugaring: for_each → let __for_len = arr.len(); let __for_i = 0; while(__for_i < __for_len) { let item = arr[__for_i]; body; __for_i = __for_i + 1 } ---
+    case 'for_each': {
+      // Use a counter suffix to avoid collisions in nested for_each
+      const id = forEachCounter++
+      const idxName = `__foreach_i_${id}`
+      const lenName = `__foreach_len_${id}`
+      const arrExpr = lowerExpr(stmt.array)
+
+      // let __foreach_len_N = arr.len()
+      const lenInitStmt: HIRStmt = {
+        kind: 'let',
+        name: lenName,
+        type: { kind: 'named', name: 'int' },
+        init: {
+          kind: 'invoke',
+          callee: { kind: 'member', obj: arrExpr, field: 'len' },
+          args: [],
+        },
+        span: stmt.span,
+      }
+
+      // let __foreach_i_N = 0
+      const idxInitStmt: HIRStmt = {
+        kind: 'let',
+        name: idxName,
+        type: { kind: 'named', name: 'int' },
+        init: { kind: 'int_lit', value: 0 },
+        span: stmt.span,
+      }
+
+      // let item = arr[__foreach_i_N]
+      const bindingInit: HIRStmt = {
+        kind: 'let',
+        name: stmt.binding,
+        type: undefined,
+        init: {
+          kind: 'index',
+          obj: arrExpr,
+          index: { kind: 'ident', name: idxName },
+        },
+        span: stmt.span,
+      }
+
+      // __foreach_i_N = __foreach_i_N + 1
+      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: { kind: 'ident', name: lenName },
+        },
+        body,
+        step,
+        span: stmt.span,
+      }
+      return [lenInitStmt, idxInitStmt, whileStmt]
+    }
+
     case 'foreach':
       return {
         kind: 'foreach',
@@ -263,7 +354,7 @@ function lowerStmt(stmt: Stmt): HIRStmt | HIRStmt[] {
         kind: 'match',
         expr: lowerExpr(stmt.expr),
         arms: stmt.arms.map(arm => ({
-          pattern: arm.pattern ? lowerExpr(arm.pattern) : null,
+          pattern: lowerMatchPattern(arm.pattern),
           body: lowerBlock(arm.body),
         })),
         span: stmt.span,
@@ -340,6 +431,9 @@ function lowerExecuteSubcommand(sub: ExecuteSubcommand): HIRExecuteSubcommand {
 // Expressions
 // ---------------------------------------------------------------------------
 
+/** Counter to generate unique variable names for for_each desugaring */
+let forEachCounter = 0
+
 /** Map compound assignment operator to its base binary op */
 const COMPOUND_TO_BINOP: Record<string, string> = {
   '+=': '+',
@@ -518,6 +612,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

@@ -21,7 +21,7 @@
 
 import type {
   HIRModule, HIRFunction, HIRParam, HIRExpr, HIRStmt, HIRBlock,
-  TypeNode,
+  TypeNode, HIRMatchPattern,
 } from './types'
 
 // ---------------------------------------------------------------------------
@@ -258,10 +258,15 @@ class Monomorphizer {
         return {
           ...stmt,
           expr: this.rewriteExpr(stmt.expr, ctx),
-          arms: stmt.arms.map(arm => ({
-            pattern: arm.pattern ? this.rewriteExpr(arm.pattern, ctx) : null,
-            body: this.rewriteBlock(arm.body, ctx),
-          })),
+          arms: stmt.arms.map(arm => {
+            let pattern: HIRMatchPattern
+            if (arm.pattern.kind === 'PatExpr') {
+              pattern = { kind: 'PatExpr', expr: this.rewriteExpr(arm.pattern.expr, ctx) }
+            } else {
+              pattern = arm.pattern
+            }
+            return { pattern, body: this.rewriteBlock(arm.body, ctx) }
+          }),
         }
       case 'execute':
         return { ...stmt, body: this.rewriteBlock(stmt.body, ctx) }
@@ -395,7 +400,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)
@@ -128,6 +130,17 @@ export type HIRExecuteSubcommand =
   | { kind: 'store_result'; target: string; targetObj: string }
   | { kind: 'store_success'; target: string; targetObj: string }
 
+// ---------------------------------------------------------------------------
+// HIR Match Patterns
+// ---------------------------------------------------------------------------
+
+export type HIRMatchPattern =
+  | { kind: 'PatSome'; binding: string }   // Some(x)
+  | { kind: 'PatNone' }                    // None
+  | { kind: 'PatInt'; value: number }      // 1, 2, 3
+  | { kind: 'PatWild' }                    // _
+  | { kind: 'PatExpr'; expr: HIRExpr }     // legacy: range_lit or other expr
+
 // ---------------------------------------------------------------------------
 // HIR Statements
 // ---------------------------------------------------------------------------
@@ -144,7 +157,7 @@ export type HIRStmt =
   // foreach preserved (entity iteration is MC-specific, not just sugar)
   | { kind: 'foreach'; binding: string; iterable: HIRExpr; body: HIRBlock; executeContext?: string; span?: Span }
   // match preserved (not trivially desugarable)
-  | { kind: 'match'; expr: HIRExpr; arms: { pattern: HIRExpr | null; body: HIRBlock }[]; span?: Span }
+  | { kind: 'match'; expr: HIRExpr; arms: { pattern: HIRMatchPattern; body: HIRBlock }[]; span?: Span }
   // Unified execute block (absorbs as_block, at_block, as_at, execute)
   | { kind: 'execute'; subcommands: HIRExecuteSubcommand[]; body: HIRBlock; span?: Span }
   | { kind: 'raw'; cmd: string; span?: Span }

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()

package/src/lir/lower.ts

@@ -397,6 +397,14 @@ function lowerInstrInner(
       break
     }
 
+    case 'nbt_list_len': {
+      // emit: execute store result score $dst_name __ns run data get storage ns path
+      const dst = ctx.slot(instr.dst)
+      const ns = ctx.namespace
+      instrs.push({ kind: 'raw', cmd: `execute store result score ${dst} __${ns} run data get storage ${instr.ns} ${instr.path}` })
+      break
+    }
+
     case 'nbt_read_dynamic': {
       // Strategy:
       // 1. Store the index value into rs:macro_args __arr_idx (int)