redscript-mc 1.1.0 → 1.2.1

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "0.2.0",
+  "version": "1.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "0.2.0",
+      "version": "1.0.1",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../"

package/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "redscript-vscode",
   "displayName": "RedScript for Minecraft",
   "description": "Syntax highlighting, error diagnostics, and language support for RedScript — a compiler targeting Minecraft Java Edition",
-  "version": "0.8.2",
+  "version": "1.0.3",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",

package/editors/vscode/syntaxes/redscript.tmLanguage.json

@@ -133,11 +133,11 @@
       "patterns": [
         {
           "name": "keyword.control.redscript",
-          "match": "\\b(if|else|while|for|foreach|return|match|in|execute|as|at|unless|run)\\b"
+          "match": "\\b(if|else|while|for|foreach|return|match|in|execute|as|at|unless|run|is)\\b"
         },
         {
           "name": "keyword.declaration.redscript",
-          "match": "\\b(fn|let|struct|enum|import|namespace|trigger)\\b"
+          "match": "\\b(fn|let|struct|enum|impl|import|namespace|trigger)\\b"
         },
         {
           "name": "keyword.declaration.const.redscript",
@@ -146,6 +146,10 @@
         {
           "name": "constant.language.boolean.redscript",
           "match": "\\b(true|false)\\b"
+        },
+        {
+          "name": "variable.language.self.redscript",
+          "match": "\\bself\\b"
         }
       ]
     },

package/examples/spiral.mcrs

@@ -0,0 +1,79 @@
+// ===== Spiral Particle Tower =====
+// 简单但视觉效果很酷的 demo
+// 展示: @tick, impl blocks, 三角函数近似, 粒子效果
+
+// 配置
+const RADIUS: int = 5;      // 螺旋半径
+const HEIGHT: int = 20;     // 塔高度
+const SPEED: int = 3;       // 旋转速度
+
+// 状态
+let angle: int = 0;         // 当前角度 (0-360)
+let height: int = 0;        // 当前高度
+let running: bool = false;
+
+// ===== 简化的三角函数 (查表法) =====
+// sin 和 cos 的近似值 * 100 (避免浮点)
+
+fn sin100(deg: int): int {
+    let d: int = deg % 360;
+    if (d < 0) { d = d + 360; }
+    
+    // 简化: 只处理 0, 90, 180, 270
+    if (d < 45) { return d * 2; }           // ~0 到 ~90
+    if (d < 135) { return 100; }            // ~90
+    if (d < 225) { return (180 - d) * 2; }  // ~90 到 ~-90
+    if (d < 315) { return -100; }           // ~-90
+    return (d - 360) * 2;                   // ~-90 到 ~0
+}
+
+fn cos100(deg: int): int {
+    return sin100(deg + 90);
+}
+
+// ===== 粒子生成 =====
+fn spawn_particle(x: int, y: int, z: int) {
+    // x, y, z 是 *100 的值，需要转换
+    raw("particle end_rod ~${x/100} ~${y/100} ~${z/100} 0 0 0 0 1");
+}
+
+// ===== 主循环 =====
+@tick fn spiral_tick() {
+    if (!running) { return; }
+    
+    // 计算螺旋位置
+    let x: int = cos100(angle) * RADIUS;  // x * 100
+    let z: int = sin100(angle) * RADIUS;  // z * 100
+    let y: int = height * 100;
+    
+    // 生成粒子
+    spawn_particle(x, y, z);
+    
+    // 更新状态
+    angle = angle + SPEED;
+    if (angle >= 360) {
+        angle = 0;
+        height = height + 1;
+        if (height >= HEIGHT) {
+            height = 0;
+        }
+    }
+}
+
+// ===== 控制命令 =====
+fn start() {
+    running = true;
+    say(f"Spiral started!");
+}
+
+fn stop() {
+    running = false;
+    say(f"Spiral stopped.");
+}
+
+fn reset() {
+    running = false;
+    angle = 0;
+    height = 0;
+    say(f"Spiral reset.");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/index.js",
   "bin": {

package/src/__tests__/cli.test.ts

@@ -40,6 +40,172 @@ describe('CLI API', () => {
       expect(result.ir.functions.filter(fn => fn.name === 'from_a')).toHaveLength(1)
       expect(result.ir.functions.filter(fn => fn.name === 'from_b')).toHaveLength(1)
     })
+
+    it('uses rs-prefixed scoreboard objectives for imported stdlib files', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stdlib-'))
+      const stdlibDir = path.join(tempDir, 'src', 'stdlib')
+      const stdlibPath = path.join(stdlibDir, 'timer.mcrs')
+      const mainPath = path.join(tempDir, 'main.mcrs')
+
+      fs.mkdirSync(stdlibDir, { recursive: true })
+      fs.writeFileSync(stdlibPath, 'fn tick_timer() { scoreboard_set("#rs", "timer_ticks", 1); }\n')
+      fs.writeFileSync(mainPath, 'import "./src/stdlib/timer.mcrs"\n\nfn main() { tick_timer(); }\n')
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'mygame', filePath: mainPath })
+      const tickTimer = result.files.find(file => file.path.endsWith('/tick_timer.mcfunction'))
+
+      expect(tickTimer?.content).toContain('scoreboard players set #rs rs.timer_ticks 1')
+    })
+
+    it('adds a call-site hash for stdlib internal scoreboard objectives', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stdlib-hash-'))
+      const stdlibDir = path.join(tempDir, 'src', 'stdlib')
+      const stdlibPath = path.join(stdlibDir, 'timer.mcrs')
+      const mainPath = path.join(tempDir, 'main.mcrs')
+
+      fs.mkdirSync(stdlibDir, { recursive: true })
+      fs.writeFileSync(stdlibPath, [
+        'fn timer_start(name: string, duration: int) {',
+        '  scoreboard_set("timer_ticks", #rs, duration);',
+        '  scoreboard_set("timer_active", #rs, 1);',
+        '}',
+        '',
+      ].join('\n'))
+      fs.writeFileSync(mainPath, [
+        'import "./src/stdlib/timer.mcrs"',
+        '',
+        'fn main() {',
+        '  timer_start("x", 100);',
+        '  timer_start("x", 100);',
+        '}',
+        '',
+      ].join('\n'))
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'mygame', filePath: mainPath })
+      const timerFns = result.files.filter(file => /timer_start__callsite_[0-9a-f]{4}\.mcfunction$/.test(file.path))
+
+      expect(timerFns).toHaveLength(2)
+
+      const objectives = timerFns
+        .flatMap(file => [...file.content.matchAll(/rs\._timer_([0-9a-f]{4})/g)].map(match => match[0]))
+
+      expect(new Set(objectives).size).toBe(2)
+    })
+
+    it('Timer::new creates timer', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-new-'))
+      const mainPath = path.join(tempDir, 'main.mcrs')
+      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
+
+      fs.writeFileSync(mainPath, [
+        `import "${timerPath}"`,
+        '',
+        'fn main() {',
+        '  let timer: Timer = Timer::new(20);',
+        '}',
+        '',
+      ].join('\n'))
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'timernew', filePath: mainPath })
+
+      expect(result.typeErrors).toEqual([])
+      const newFn = result.files.find(file => file.path.endsWith('/Timer_new.mcfunction'))
+      expect(newFn?.content).toContain('scoreboard players set timer_ticks rs 0')
+      expect(newFn?.content).toContain('scoreboard players set timer_active rs 0')
+    })
+
+    it('Timer.start/pause/reset', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-state-'))
+      const mainPath = path.join(tempDir, 'main.mcrs')
+      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
+
+      fs.writeFileSync(mainPath, [
+        `import "${timerPath}"`,
+        '',
+        'fn main() {',
+        '  let timer: Timer = Timer::new(20);',
+        '  timer.start();',
+        '  timer.pause();',
+        '  timer.reset();',
+        '}',
+        '',
+      ].join('\n'))
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'timerstate', filePath: mainPath })
+
+      expect(result.typeErrors).toEqual([])
+      const startFn = result.files.find(file => file.path.endsWith('/Timer_start.mcfunction'))
+      const pauseFn = result.files.find(file => file.path.endsWith('/Timer_pause.mcfunction'))
+      const resetFn = result.files.find(file => file.path.endsWith('/Timer_reset.mcfunction'))
+
+      expect(startFn?.content).toContain('scoreboard players set timer_active rs 1')
+      expect(pauseFn?.content).toContain('scoreboard players set timer_active rs 0')
+      expect(resetFn?.content).toContain('scoreboard players set timer_ticks rs 0')
+    })
+
+    it('Timer.done returns bool', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-done-'))
+      const mainPath = path.join(tempDir, 'main.mcrs')
+      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
+
+      fs.writeFileSync(mainPath, [
+        `import "${timerPath}"`,
+        '',
+        'fn main() {',
+        '  let timer: Timer = Timer::new(20);',
+        '  let finished: bool = timer.done();',
+        '  if (finished) {',
+        '    say("done");',
+        '  }',
+        '}',
+        '',
+      ].join('\n'))
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'timerdone', filePath: mainPath })
+
+      expect(result.typeErrors).toEqual([])
+      const doneFn = result.files.find(file => file.path.endsWith('/Timer_done.mcfunction'))
+      const mainFn = result.files.find(file => file.path.endsWith('/main.mcfunction'))
+      expect(doneFn?.content).toContain('scoreboard players get timer_ticks rs')
+      expect(doneFn?.content).toContain('return run scoreboard players get')
+      expect(mainFn?.content).toContain('execute if score $finished rs matches 1..')
+    })
+
+    it('Timer.tick increments', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-tick-'))
+      const mainPath = path.join(tempDir, 'main.mcrs')
+      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
+
+      fs.writeFileSync(mainPath, [
+        `import "${timerPath}"`,
+        '',
+        'fn main() {',
+        '  let timer: Timer = Timer::new(20);',
+        '  timer.start();',
+        '  timer.tick();',
+        '}',
+        '',
+      ].join('\n'))
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'timertick', filePath: mainPath })
+
+      expect(result.typeErrors).toEqual([])
+      const tickOutput = result.files
+        .filter(file => file.path.includes('/Timer_tick'))
+        .map(file => file.content)
+        .join('\n')
+
+      expect(tickOutput).toContain('scoreboard players get timer_active rs')
+      expect(tickOutput).toContain('scoreboard players get timer_ticks rs')
+      expect(tickOutput).toContain(' += $const_1 rs')
+      expect(tickOutput).toContain('execute store result score timer_ticks rs run scoreboard players get $_')
+    })
   })
 
   describe('compile()', () => {

package/src/__tests__/codegen.test.ts

@@ -125,4 +125,31 @@ describe('generateDatapack', () => {
     expect(json.criteria.trigger.trigger).toBe('minecraft:story/mine_diamond')
     expect(json.rewards.function).toBe('mypack:on_mine_diamond')
   })
+
+  it('generates static event dispatcher in __tick', () => {
+    const mod: IRModule = {
+      namespace: 'mypack',
+      globals: [],
+      functions: [{
+        name: 'handle_death',
+        params: [],
+        locals: [],
+        blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+        eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
+      }, {
+        name: 'handle_death_2',
+        params: [],
+        locals: [],
+        blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+        eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
+      }],
+    }
+
+    const files = generateDatapack(mod)
+    const tickFn = files.find(f => f.path.includes('__tick.mcfunction'))
+    expect(tickFn).toBeDefined()
+    expect(tickFn!.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death')
+    expect(tickFn!.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death_2')
+    expect(tickFn!.content).toContain('tag @a[tag=rs.just_died] remove rs.just_died')
+  })
 })

package/src/__tests__/dce.test.ts

@@ -0,0 +1,129 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { execFileSync } from 'child_process'
+
+import { compile } from '../index'
+
+function getFileContent(files: ReturnType<typeof compile>['files'], suffix: string): string {
+  const file = files.find(candidate => candidate.path.endsWith(suffix))
+  if (!file) {
+    throw new Error(`Missing file: ${suffix}`)
+  }
+  return file.content
+}
+
+describe('AST dead code elimination', () => {
+  it('removes unused functions reachable from entry points', () => {
+    const source = `
+fn unused() { say("never called"); }
+fn used() { say("called"); }
+@tick fn main() { used(); }
+`
+
+    const result = compile(source, { namespace: 'test' })
+
+    expect(result.ast.declarations.map(fn => fn.name)).toEqual(['used', 'main'])
+    expect(result.ir.functions.some(fn => fn.name === 'unused')).toBe(false)
+  })
+
+  it('removes unused local variables from the AST body', () => {
+    const source = `
+fn helper() {
+  let unused: int = 10;
+  let used: int = 20;
+  say_int(used);
+}
+@tick fn main() { helper(); }
+`
+
+    const result = compile(source, { namespace: 'test' })
+    const helper = result.ast.declarations.find(fn => fn.name === 'helper')
+
+    expect(helper?.body.filter(stmt => stmt.kind === 'let')).toHaveLength(1)
+    expect(helper?.body.some(stmt => stmt.kind === 'let' && stmt.name === 'unused')).toBe(false)
+  })
+
+  it('removes unused constants', () => {
+    const source = `
+const UNUSED: int = 10;
+const USED: int = 20;
+
+@tick fn main() {
+  say_int(USED);
+}
+`
+
+    const result = compile(source, { namespace: 'test' })
+
+    expect(result.ast.consts.map(constDecl => constDecl.name)).toEqual(['USED'])
+  })
+
+  it('eliminates dead branches with constant conditions', () => {
+    const source = `
+@tick fn main() {
+  if (false) {
+    say("dead code");
+  } else {
+    say("live code");
+  }
+}
+`
+
+    const result = compile(source, { namespace: 'test' })
+    const output = getFileContent(result.files, 'data/test/function/main.mcfunction')
+
+    expect(output).not.toContain('dead code')
+    expect(output).toContain('live code')
+  })
+
+  it('keeps decorated entry points', () => {
+    const source = `
+@tick fn ticker() { }
+@load fn loader() { }
+@on(PlayerDeath) fn handler(player: Player) { say("event"); }
+`
+
+    const result = compile(source, { namespace: 'test' })
+    const names = result.ast.declarations.map(fn => fn.name)
+
+    expect(names).toContain('ticker')
+    expect(names).toContain('loader')
+    expect(names).toContain('handler')
+  })
+
+  it('can disable AST DCE through the compile API', () => {
+    const source = `
+fn unused() { say("never called"); }
+@tick fn main() { say("live"); }
+`
+
+    const result = compile(source, { namespace: 'test', dce: false })
+
+    expect(result.ast.declarations.map(fn => fn.name)).toEqual(['unused', 'main'])
+    expect(result.ir.functions.some(fn => fn.name === 'unused')).toBe(true)
+  })
+})
+
+describe('CLI --no-dce', () => {
+  it('preserves unused functions when requested', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-dce-cli-'))
+    const inputPath = path.join(tempDir, 'main.mcrs')
+    const outputDir = path.join(tempDir, 'out')
+
+    fs.writeFileSync(inputPath, [
+      'fn unused() { say("keep me"); }',
+      '@tick fn main() { say("live"); }',
+      '',
+    ].join('\n'))
+
+    execFileSync(
+      process.execPath,
+      ['-r', 'ts-node/register', 'src/cli.ts', 'compile', inputPath, '-o', outputDir, '--namespace', 'test', '--no-dce'],
+      { cwd: path.resolve(process.cwd()) }
+    )
+
+    const unusedPath = path.join(outputDir, 'data', 'test', 'function', 'unused.mcfunction')
+    expect(fs.existsSync(unusedPath)).toBe(true)
+  })
+})