redscript-mc 1.0.0 → 1.2.0

package/src/codegen/structure/index.ts

@@ -8,6 +8,7 @@ import { optimizeForStructure, optimizeForStructureWithStats } from '../../optim
 import { preprocessSource } from '../../compile'
 import type { IRCommand, IRFunction, IRModule } from '../../ir/types'
 import type { DatapackFile } from '../mcfunction'
+import { EVENT_TYPES, isEventTypeName, type EventTypeName } from '../../events/types'
 
 const DATA_VERSION = 3953
 const MAX_WIDTH = 16
@@ -87,9 +88,13 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
   const entries: CommandEntry[] = []
   const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName)
   const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName!))
+  const eventHandlers = module.functions.filter((fn): fn is IRFunction & { eventHandler: { eventType: EventTypeName; tag: string } } =>
+    !!fn.eventHandler && isEventTypeName(fn.eventHandler.eventType)
+  )
+  const eventTypes = new Set<EventTypeName>(eventHandlers.map(fn => fn.eventHandler.eventType))
   const loadCommands = [
     `scoreboard objectives add ${OBJ} dummy`,
-    ...module.globals.map(globalName => `scoreboard players set ${varRef(globalName)} ${OBJ} 0`),
+    ...module.globals.map(g => `scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`),
     ...Array.from(triggerNames).flatMap(triggerName => [
       `scoreboard objectives add ${triggerName} trigger`,
       `scoreboard players enable @a ${triggerName}`,
@@ -99,6 +104,21 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
     ).map(constSetup),
   ]
 
+  for (const eventType of eventTypes) {
+    if (eventType === 'PlayerDeath') {
+      loadCommands.push('scoreboard objectives add rs.deaths deathCount')
+    } else if (eventType === 'EntityKill') {
+      loadCommands.push('scoreboard objectives add rs.kills totalKillCount')
+    }
+  }
+
+  // Call @load functions from __load
+  for (const fn of module.functions) {
+    if (fn.isLoadInit) {
+      loadCommands.push(`function ${module.namespace}:${fn.name}`)
+    }
+  }
+
   const sections: Array<{ name: string; commands: IRCommand[]; repeat?: boolean }> = []
 
   if (loadCommands.length > 0) {
@@ -139,6 +159,20 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
       })
     }
   }
+  if (eventHandlers.length > 0) {
+    for (const eventType of eventTypes) {
+      const tag = EVENT_TYPES[eventType].tag
+      const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType)
+      for (const handler of handlers) {
+        tickCommands.push({
+          cmd: `execute as @a[tag=${tag}] run function ${module.namespace}:${handler.name}`,
+        })
+      }
+      tickCommands.push({
+        cmd: `tag @a[tag=${tag}] remove ${tag}`,
+      })
+    }
+  }
   if (tickCommands.length > 0) {
     sections.push({
       name: '__tick',

package/src/compile.ts

@@ -39,6 +39,17 @@ export interface CompileResult {
   error?: DiagnosticError
 }
 
+export interface SourceRange {
+  startLine: number
+  endLine: number
+  filePath: string
+}
+
+export interface PreprocessedSource {
+  source: string
+  ranges: SourceRange[]
+}
+
 const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/
 
 interface PreprocessOptions {
@@ -46,7 +57,19 @@ interface PreprocessOptions {
   seen?: Set<string>
 }
 
-export function preprocessSource(source: string, options: PreprocessOptions = {}): string {
+function countLines(source: string): number {
+  return source === '' ? 0 : source.split('\n').length
+}
+
+function offsetRanges(ranges: SourceRange[], lineOffset: number): SourceRange[] {
+  return ranges.map(range => ({
+    startLine: range.startLine + lineOffset,
+    endLine: range.endLine + lineOffset,
+    filePath: range.filePath,
+  }))
+}
+
+export function preprocessSourceWithMetadata(source: string, options: PreprocessOptions = {}): PreprocessedSource {
   const { filePath } = options
   const seen = options.seen ?? new Set<string>()
 
@@ -55,7 +78,7 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
   }
 
   const lines = source.split('\n')
-  const imports: string[] = []
+  const imports: PreprocessedSource[] = []
   const bodyLines: string[] = []
   let parsingHeader = true
 
@@ -90,7 +113,7 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
           )
         }
 
-        imports.push(preprocessSource(importedSource, { filePath: importPath, seen }))
+        imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }))
       }
       continue
     }
@@ -104,7 +127,31 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
     bodyLines.push(line)
   }
 
-  return [...imports, bodyLines.join('\n')].filter(Boolean).join('\n')
+  const body = bodyLines.join('\n')
+  const parts = [...imports.map(entry => entry.source), body].filter(Boolean)
+  const combined = parts.join('\n')
+
+  const ranges: SourceRange[] = []
+  let lineOffset = 0
+
+  for (const entry of imports) {
+    ranges.push(...offsetRanges(entry.ranges, lineOffset))
+    lineOffset += countLines(entry.source)
+  }
+
+  if (filePath && body) {
+    ranges.push({
+      startLine: lineOffset + 1,
+      endLine: lineOffset + countLines(body),
+      filePath: path.resolve(filePath),
+    })
+  }
+
+  return { source: combined, ranges }
+}
+
+export function preprocessSource(source: string, options: PreprocessOptions = {}): string {
+  return preprocessSourceWithMetadata(source, options).source
 }
 
 // ---------------------------------------------------------------------------
@@ -116,7 +163,8 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
   let sourceLines = source.split('\n')
 
   try {
-    const preprocessedSource = preprocessSource(source, { filePath })
+    const preprocessed = preprocessSourceWithMetadata(source, { filePath })
+    const preprocessedSource = preprocessed.source
     sourceLines = preprocessedSource.split('\n')
 
     // Lexing
@@ -126,7 +174,7 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
     const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
 
     // Lowering
-    const ir = new Lowering(namespace).lower(ast)
+    const ir = new Lowering(namespace, preprocessed.ranges).lower(ast)
 
     // Optimization
     const optimized: IRModule = shouldOptimize

package/src/events/types.ts

@@ -0,0 +1,69 @@
+import type { TypeNode } from '../ast/types'
+
+export const EVENT_TYPES = {
+  PlayerDeath: {
+    tag: 'rs.just_died',
+    params: ['player: Player'],
+    detection: 'scoreboard',
+  },
+  PlayerJoin: {
+    tag: 'rs.just_joined',
+    params: ['player: Player'],
+    detection: 'tag',
+  },
+  BlockBreak: {
+    tag: 'rs.just_broke_block',
+    params: ['player: Player', 'block: string'],
+    detection: 'advancement',
+  },
+  EntityKill: {
+    tag: 'rs.just_killed',
+    params: ['player: Player'],
+    detection: 'scoreboard',
+  },
+  ItemUse: {
+    tag: 'rs.just_used_item',
+    params: ['player: Player'],
+    detection: 'scoreboard',
+  },
+} as const
+
+export type EventTypeName = keyof typeof EVENT_TYPES
+
+export interface EventParamSpec {
+  name: string
+  type: TypeNode
+}
+
+export function isEventTypeName(value: string): value is EventTypeName {
+  return value in EVENT_TYPES
+}
+
+export function getEventParamSpecs(eventType: EventTypeName): EventParamSpec[] {
+  return EVENT_TYPES[eventType].params.map(parseEventParam)
+}
+
+function parseEventParam(spec: string): EventParamSpec {
+  const match = spec.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([A-Za-z_][A-Za-z0-9_]*)$/)
+  if (!match) {
+    throw new Error(`Invalid event parameter spec: ${spec}`)
+  }
+
+  const [, name, typeName] = match
+  return {
+    name,
+    type: toTypeNode(typeName),
+  }
+}
+
+function toTypeNode(typeName: string): TypeNode {
+  if (typeName === 'Player') {
+    return { kind: 'entity', entityType: 'Player' }
+  }
+
+  if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
+    return { kind: 'named', name: typeName }
+  }
+
+  return { kind: 'struct', name: typeName }
+}

package/src/examples/capture_the_flag.mcrs

@@ -0,0 +1,208 @@
+// ============================================
+// Capture the Flag Mini-Game
+// ============================================
+// 场景：两队对抗，抢夺对方旗帜带回己方基地得分
+// Scenario: Two teams compete to capture enemy flag
+// ============================================
+
+import "../stdlib/teams.mcrs"
+import "../stdlib/effects.mcrs"
+import "../stdlib/world.mcrs"
+import "../stdlib/inventory.mcrs"
+import "../stdlib/particles.mcrs"
+
+// ===== 配置 =====
+const RED_BASE_X: int = -50;
+const RED_BASE_Z: int = 0;
+const BLUE_BASE_X: int = 50;
+const BLUE_BASE_Z: int = 0;
+const BASE_Y: int = 64;
+const WIN_SCORE: int = 3;
+
+// ===== 游戏状态 =====
+struct GameState {
+    running: int,
+    red_score: int,
+    blue_score: int,
+    red_flag_taken: int,
+    blue_flag_taken: int
+}
+
+let game: GameState = GameState {
+    running: 0,
+    red_score: 0,
+    blue_score: 0,
+    red_flag_taken: 0,
+    blue_flag_taken: 0
+};
+
+// ===== 初始化 =====
+@load
+fn init() {
+    // 创建记分板
+    scoreboard_add_objective("ctf_team", "dummy");
+    scoreboard_add_objective("ctf_flag", "dummy");
+    
+    // 创建队伍
+    setup_two_teams();
+    
+    // 世界设置
+    set_day();
+    weather_clear();
+    enable_keep_inventory();
+    
+    announce("§e[CTF] §f夺旗战已加载！使用 /trigger start 开始游戏");
+}
+
+// ===== 开始游戏 =====
+fn start_game() {
+    game.running = 1;
+    game.red_score = 0;
+    game.blue_score = 0;
+    
+    // 随机分配队伍
+    assign_teams();
+    
+    // 传送到各自基地
+    tp(@a[team=red], RED_BASE_X, BASE_Y, RED_BASE_Z);
+    tp(@a[team=blue], BLUE_BASE_X, BASE_Y, BLUE_BASE_Z);
+    
+    // 给装备
+    foreach (p in @a) {
+        clear_inventory(p);
+        give_kit_warrior(p);
+    }
+    
+    // 放置旗帜（盔甲架）
+    place_flags();
+    
+    announce("§e[CTF] §a游戏开始！抢夺敌方旗帜！");
+    title(@a, "§6夺旗战开始！");
+}
+
+fn place_flags() {
+    // 红方旗帜（红色旗帜方块）
+    setblock(RED_BASE_X, BASE_Y + 1, RED_BASE_Z, "minecraft:red_banner");
+    // 蓝方旗帜
+    setblock(BLUE_BASE_X, BASE_Y + 1, BLUE_BASE_Z, "minecraft:blue_banner");
+    
+    game.red_flag_taken = 0;
+    game.blue_flag_taken = 0;
+}
+
+fn assign_teams() {
+    let count: int = 0;
+    foreach (p in @a) {
+        if (count % 2 == 0) {
+            team_join(p, "red");
+            scoreboard_set(p, "ctf_team", 1);
+        } else {
+            team_join(p, "blue");
+            scoreboard_set(p, "ctf_team", 2);
+        }
+        count = count + 1;
+    }
+}
+
+// ===== 每 tick 检查 =====
+@tick
+fn game_tick() {
+    if (game.running == 1) {
+        check_flag_pickup();
+        check_flag_capture();
+        check_win();
+    }
+}
+
+fn check_flag_pickup() {
+    // 检查蓝队玩家是否靠近红旗
+    foreach (p in @a[team=blue]) {
+        // 如果在红方基地附近且旗帜未被拿走
+        let dist: int = distance_to(p, RED_BASE_X, BASE_Y, RED_BASE_Z);
+        if (dist < 3) {
+            if (game.red_flag_taken == 0) {
+                game.red_flag_taken = 1;
+                tag_add(p, "has_flag");
+                setblock(RED_BASE_X, BASE_Y + 1, RED_BASE_Z, "minecraft:air");
+                announce("§e[CTF] §9蓝队 §f拿到了 §c红方旗帜§f！");
+                glow(p, 9999);
+            }
+        }
+    }
+    
+    // 检查红队玩家是否靠近蓝旗
+    foreach (p in @a[team=red]) {
+        let dist: int = distance_to(p, BLUE_BASE_X, BASE_Y, BLUE_BASE_Z);
+        if (dist < 3) {
+            if (game.blue_flag_taken == 0) {
+                game.blue_flag_taken = 1;
+                tag_add(p, "has_flag");
+                setblock(BLUE_BASE_X, BASE_Y + 1, BLUE_BASE_Z, "minecraft:air");
+                announce("§e[CTF] §c红队 §f拿到了 §9蓝方旗帜§f！");
+                glow(p, 9999);
+            }
+        }
+    }
+}
+
+fn check_flag_capture() {
+    // 蓝队带红旗回蓝方基地
+    foreach (p in @a[team=blue, tag=has_flag]) {
+        let dist: int = distance_to(p, BLUE_BASE_X, BASE_Y, BLUE_BASE_Z);
+        if (dist < 5) {
+            game.blue_score = game.blue_score + 1;
+            announce("§e[CTF] §9蓝队 §a得分！§f (" + game.blue_score + "/" + WIN_SCORE + ")");
+            tag_remove(p, "has_flag");
+            effect_clear(p, "minecraft:glowing");
+            place_flags();
+            happy(p);
+        }
+    }
+    
+    // 红队带蓝旗回红方基地  
+    foreach (p in @a[team=red, tag=has_flag]) {
+        let dist: int = distance_to(p, RED_BASE_X, BASE_Y, RED_BASE_Z);
+        if (dist < 5) {
+            game.red_score = game.red_score + 1;
+            announce("§e[CTF] §c红队 §a得分！§f (" + game.red_score + "/" + WIN_SCORE + ")");
+            tag_remove(p, "has_flag");
+            effect_clear(p, "minecraft:glowing");
+            place_flags();
+            happy(p);
+        }
+    }
+}
+
+fn check_win() {
+    if (game.red_score >= WIN_SCORE) {
+        end_game("red");
+    }
+    if (game.blue_score >= WIN_SCORE) {
+        end_game("blue");
+    }
+}
+
+fn end_game(winner: string) {
+    game.running = 0;
+    
+    if (winner == "red") {
+        title(@a, "§c红队获胜！");
+        announce("§e[CTF] §c红队 §6赢得了比赛！");
+    } else {
+        title(@a, "§9蓝队获胜！");
+        announce("§e[CTF] §9蓝队 §6赢得了比赛！");
+    }
+    
+    // 清理
+    foreach (p in @a[tag=has_flag]) {
+        tag_remove(p, "has_flag");
+        effect_clear(p);
+    }
+}
+
+// ===== 辅助函数 =====
+fn distance_to(target: selector, x: int, y: int, z: int) -> int {
+    // 简化的距离计算（使用记分板）
+    let dist: int = scoreboard_get(target, "ctf_dist");
+    return dist;
+}

package/src/examples/{counter.rs → counter.mcrs}

@@ -2,7 +2,7 @@
 
 @tick
 fn counter_tick() {
-    let ticks: int = scoreboard_get("counter", #ticks);
+    let ticks = scoreboard_get("counter", #ticks);
     ticks = ticks + 1;
     scoreboard_set("counter", #ticks, ticks);