redscript-mc 2.1.0 → 2.1.1

package/examples/enum-demo.mcrs

@@ -0,0 +1,95 @@
+// enum-demo.mcrs — NPC AI state machine using enums and match
+//
+// An NPC cycles through Idle → Moving → Attacking states.
+// Each state has its own behaviour, driven by @tick.
+//
+// Usage:
+//   /function demo:npc_start    activate the NPC AI
+//   /function demo:npc_stop     deactivate the NPC AI
+
+enum Phase {
+    Idle,       // 0 — waiting for a player nearby
+    Moving,     // 1 — closing the distance
+    Attacking,  // 2 — striking the nearest player
+}
+
+struct NpcState {
+    phase:    int,    // current Phase value
+    ticks:    int,    // ticks in the current phase
+    active:   bool
+}
+
+let npc: NpcState = {
+    phase:  0,
+    ticks:  0,
+    active: false
+};
+
+@load
+fn npc_load() {
+    npc.phase  = Phase.Idle;
+    npc.ticks  = 0;
+    npc.active = false;
+}
+
+fn npc_start() {
+    npc.active = true;
+    npc.phase  = Phase.Idle;
+    npc.ticks  = 0;
+    actionbar(@a, "[NPC] AI activated");
+}
+
+fn npc_stop() {
+    npc.active = false;
+    actionbar(@a, "[NPC] AI deactivated");
+}
+
+// ── Phase handlers ────────────────────────────────────────────────────────
+
+fn phase_idle() {
+    actionbar(@a, "[NPC] Idle — scanning for targets...");
+    // After 40 ticks (2 seconds) transition to Moving
+    if (npc.ticks >= 40) {
+        npc.phase = Phase.Moving;
+        npc.ticks = 0;
+        title(@a, "NPC begins moving");
+    }
+}
+
+fn phase_moving() {
+    actionbar(@a, "[NPC] Moving — closing distance");
+    // Simulate movement toward nearest player
+    raw("execute as @e[type=minecraft:zombie,tag=npc_ai] at @s run tp @s @p[limit=1] 0 0 0");
+    if (npc.ticks >= 60) {
+        npc.phase = Phase.Attacking;
+        npc.ticks = 0;
+        title(@a, "NPC attacks!");
+    }
+}
+
+fn phase_attacking() {
+    actionbar(@a, "[NPC] Attacking!");
+    raw("execute as @e[type=minecraft:zombie,tag=npc_ai] at @s run effect give @p[limit=1,distance=..3] minecraft:slowness 1 1 true");
+    if (npc.ticks >= 30) {
+        npc.phase = Phase.Idle;
+        npc.ticks = 0;
+        title(@a, "NPC backs off");
+    }
+}
+
+// ── Main tick ─────────────────────────────────────────────────────────────
+
+@tick
+fn npc_tick() {
+    if (!npc.active) {
+        return;
+    }
+
+    npc.ticks = npc.ticks + 1;
+
+    match (npc.phase) {
+        Phase.Idle      => { phase_idle(); }
+        Phase.Moving    => { phase_moving(); }
+        Phase.Attacking => { phase_attacking(); }
+    }
+}

package/examples/scheduler-demo.mcrs

@@ -0,0 +1,59 @@
+// scheduler-demo.mcrs — Delayed event triggering with @schedule
+//
+// @schedule(ticks=N) generates a _schedule_xxx wrapper that emits
+// `schedule function ns:xxx Nt`, deferring execution by N ticks.
+//
+// 20 ticks = 1 second in Minecraft.
+//
+// Usage:
+//   /function demo:begin_countdown   trigger the 1-second delayed reward
+//   /function demo:announce_morning  schedule a sunrise announcement
+
+// ── 1-second delayed reward ───────────────────────────────────────────────
+
+fn begin_countdown() {
+    title(@a, "Get ready...");
+    raw("function demo:_schedule_reward_players");
+}
+
+// Called automatically 1 second (20t) after _schedule_reward_players fires
+@schedule(ticks=20)
+fn reward_players(): void {
+    title(@a, "Go!");
+    raw("effect give @a minecraft:speed 5 1 true");
+    raw("effect give @a minecraft:jump_boost 5 1 true");
+    tell(@a, "Speed and Jump Boost applied for 5 seconds.");
+}
+
+// ── 5-second delayed announcement ────────────────────────────────────────
+
+fn announce_morning() {
+    tell(@a, "Sunrise in 5 seconds...");
+    raw("function demo:_schedule_sunrise_event");
+}
+
+@schedule(ticks=100)
+fn sunrise_event(): void {
+    raw("time set day");
+    raw("weather clear");
+    title(@a, "Good morning!");
+    subtitle(@a, "A new day begins");
+}
+
+// ── Chain: schedule a follow-up from inside a scheduled function ──────────
+
+fn start_chain() {
+    tell(@a, "Chain started — phase 1 runs in 1s, phase 2 in 3s total.");
+    raw("function demo:_schedule_chain_phase1");
+}
+
+@schedule(ticks=20)
+fn chain_phase1(): void {
+    actionbar(@a, "Phase 1 complete");
+    raw("function demo:_schedule_chain_phase2");
+}
+
+@schedule(ticks=40)
+fn chain_phase2(): void {
+    actionbar(@a, "Phase 2 complete — chain done!");
+}

package/package.json

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

package/src/__tests__/lsp.test.ts

@@ -10,6 +10,7 @@ import { Parser } from '../parser'
 import { TypeChecker } from '../typechecker'
 import { DiagnosticError } from '../diagnostics'
 import type { Program, FnDecl, TypeNode } from '../ast/types'
+import { BUILTIN_METADATA } from '../builtins/metadata'
 
 // ---------------------------------------------------------------------------
 // Helpers mirrored from lsp/server.ts (tested independently)
@@ -255,6 +256,94 @@ fn anotherFn(x: int): int { return x; }
   })
 })
 
+// ---------------------------------------------------------------------------
+// Hover — builtin functions
+// ---------------------------------------------------------------------------
+
+const DECORATOR_DOCS: Record<string, string> = {
+  tick:         'Runs every MC game tick (~20 Hz). No arguments.',
+  load:         'Runs on `/reload`. Use for initialization logic.',
+  coroutine:    'Splits loops into tick-spread continuations. Arg: `batch=N` (steps per tick, default 1).',
+  schedule:     'Schedules the function to run after N ticks. Arg: `ticks=N`.',
+  on_trigger:   'Runs when a trigger scoreboard objective is set by a player. Arg: trigger name.',
+  keep:         'Prevents the compiler from dead-code-eliminating this function.',
+  on:           'Generic event handler decorator.',
+  on_advancement: 'Runs when a player earns an advancement. Arg: advancement id.',
+  on_craft:     'Runs when a player crafts an item. Arg: item id.',
+  on_death:     'Runs when a player dies.',
+  on_join_team: 'Runs when a player joins a team. Arg: team name.',
+  on_login:     'Runs when a player logs in.',
+}
+
+describe('LSP hover — builtin functions', () => {
+  it('has metadata for say', () => {
+    const b = BUILTIN_METADATA['say']
+    expect(b).toBeDefined()
+    expect(b.params.length).toBeGreaterThan(0)
+    expect(b.returns).toBe('void')
+    expect(b.doc).toBeTruthy()
+  })
+
+  it('has metadata for kill', () => {
+    const b = BUILTIN_METADATA['kill']
+    expect(b).toBeDefined()
+    expect(b.returns).toBe('void')
+  })
+
+  it('has metadata for tellraw', () => {
+    const b = BUILTIN_METADATA['tellraw']
+    expect(b).toBeDefined()
+    const paramStr = b.params.map(p => `${p.name}: ${p.type}${p.required ? '' : '?'}`).join(', ')
+    const sig = `fn ${b.name}(${paramStr}): ${b.returns}`
+    expect(sig).toMatch(/^fn tellraw/)
+    expect(sig).toContain('target')
+  })
+
+  it('formats builtin hover markdown', () => {
+    const b = BUILTIN_METADATA['particle']
+    expect(b).toBeDefined()
+    const paramStr = b.params.map(p => `${p.name}: ${p.type}${p.required ? '' : '?'}`).join(', ')
+    const sig = `fn ${b.name}(${paramStr}): ${b.returns}`
+    const markdown = `\`\`\`redscript\n${sig}\n\`\`\`\n${b.doc}`
+    expect(markdown).toContain('```redscript')
+    expect(markdown).toContain('fn particle')
+    expect(markdown).toContain(b.doc)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Hover — decorators
+// ---------------------------------------------------------------------------
+
+describe('LSP hover — decorators', () => {
+  it('has docs for @tick', () => {
+    expect(DECORATOR_DOCS['tick']).toContain('tick')
+  })
+
+  it('has docs for @load', () => {
+    expect(DECORATOR_DOCS['load']).toContain('reload')
+  })
+
+  it('has docs for @coroutine', () => {
+    expect(DECORATOR_DOCS['coroutine']).toContain('batch')
+  })
+
+  it('has docs for @schedule', () => {
+    expect(DECORATOR_DOCS['schedule']).toContain('ticks')
+  })
+
+  it('has docs for @on_trigger', () => {
+    expect(DECORATOR_DOCS['on_trigger']).toContain('trigger')
+  })
+
+  it('formats decorator hover markdown', () => {
+    const name = 'tick'
+    const doc = DECORATOR_DOCS[name]
+    const markdown = `**@${name}** — ${doc}`
+    expect(markdown).toBe(`**@tick** — ${DECORATOR_DOCS['tick']}`)
+  })
+})
+
 // ---------------------------------------------------------------------------
 // Server module import (smoke test — does not start stdio)
 // ---------------------------------------------------------------------------

package/src/__tests__/mc-syntax.test.ts

@@ -5,7 +5,7 @@ import { compile } from '../compile'
 import { MCCommandValidator } from '../mc-validator'
 
 const FIXTURE_PATH = path.join(__dirname, 'fixtures', 'mc-commands-1.21.4.json')
-const EXAMPLES = ['counter', 'arena', 'shop', 'quiz', 'turret']
+const EXAMPLES = ['shop', 'quiz', 'turret']
 
 function getCommands(source: string, namespace = 'test'): string[] {
   const result = compile(source, { namespace })
@@ -32,12 +32,6 @@ function validateSource(
 describe('MC Command Syntax Validation', () => {
   const validator = new MCCommandValidator(FIXTURE_PATH)
 
-  test('counter example generates valid MC commands', () => {
-    const src = fs.readFileSync(path.join(__dirname, '..', 'examples', 'counter.mcrs'), 'utf-8')
-    const errors = validateSource(validator, src, 'counter')
-    expect(errors).toHaveLength(0)
-  })
-
   EXAMPLES.forEach(name => {
     test(`${name}.mcrs generates valid MC commands`, () => {
       const src = fs.readFileSync(path.join(__dirname, '..', 'examples', `${name}.mcrs`), 'utf-8')

package/src/__tests__/stdlib-include.test.ts

@@ -0,0 +1,61 @@
+import * as path from 'path'
+import * as fs from 'fs'
+import * as os from 'os'
+import { compile } from '../emit/compile'
+
+describe('stdlib include path', () => {
+  it('import "stdlib/math" resolves to the stdlib math module', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rs-stdlib-'))
+    const mainPath = path.join(tempDir, 'main.mcrs')
+    fs.writeFileSync(mainPath, 'import "stdlib/math";\nfn main() { let x: int = abs(-5); }\n')
+    const source = fs.readFileSync(mainPath, 'utf-8')
+
+    const result = compile(source, { namespace: 'test', filePath: mainPath })
+    expect(result.files.some(f => f.path.includes('abs'))).toBe(true)
+  })
+
+  it('import "stdlib/math.mcrs" also resolves (explicit extension)', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rs-stdlib-'))
+    const mainPath = path.join(tempDir, 'main.mcrs')
+    fs.writeFileSync(mainPath, 'import "stdlib/math.mcrs";\nfn main() { let x: int = abs(-5); }\n')
+    const source = fs.readFileSync(mainPath, 'utf-8')
+
+    const result = compile(source, { namespace: 'test', filePath: mainPath })
+    expect(result.files.some(f => f.path.includes('abs'))).toBe(true)
+  })
+
+  it('import "stdlib/vec" resolves to the stdlib vec module', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rs-stdlib-'))
+    const mainPath = path.join(tempDir, 'main.mcrs')
+    fs.writeFileSync(mainPath, 'import "stdlib/vec";\nfn main() { let d: int = dot2d(1, 2, 3, 4); }\n')
+    const source = fs.readFileSync(mainPath, 'utf-8')
+
+    const result = compile(source, { namespace: 'test', filePath: mainPath })
+    expect(result.files.some(f => f.path.includes('dot2d'))).toBe(true)
+  })
+
+  it('non-existent stdlib module gives a clear error', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rs-stdlib-'))
+    const mainPath = path.join(tempDir, 'main.mcrs')
+    fs.writeFileSync(mainPath, 'import "stdlib/nonexistent";\nfn main() {}\n')
+    const source = fs.readFileSync(mainPath, 'utf-8')
+
+    expect(() => compile(source, { namespace: 'test', filePath: mainPath }))
+      .toThrow(/Cannot import/)
+  })
+
+  it('--include flag allows importing from custom directory', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rs-include-'))
+    const libDir = path.join(tempDir, 'mylibs')
+    fs.mkdirSync(libDir)
+    const mainPath = path.join(tempDir, 'main.mcrs')
+    const libPath = path.join(libDir, 'helpers.mcrs')
+
+    fs.writeFileSync(libPath, 'fn triple(x: int) -> int { return x + x + x; }\n')
+    fs.writeFileSync(mainPath, 'import "helpers";\nfn main() { let x: int = triple(3); }\n')
+    const source = fs.readFileSync(mainPath, 'utf-8')
+
+    const result = compile(source, { namespace: 'test', filePath: mainPath, includeDirs: [libDir] })
+    expect(result.files.some(f => f.path.includes('triple'))).toBe(true)
+  })
+})

package/src/cli.ts

@@ -57,6 +57,7 @@ Options:
   --mc-version <ver>     Target Minecraft version (default: 1.21). Affects codegen features.
                          e.g. --mc-version 1.20.2, --mc-version 1.19
   --lenient              Treat type errors as warnings instead of blocking compilation
+  --include <dir>        Add a directory to the import search path (repeatable)
   -h, --help             Show this help message
 `)
 }
@@ -161,6 +162,7 @@ function parseArgs(args: string[]): {
   sourceMap?: boolean
   mcVersionStr?: string
   lenient?: boolean
+  includeDirs?: string[]
 } {
   const result: ReturnType<typeof parseArgs> = {}
   let i = 0
@@ -189,6 +191,10 @@ function parseArgs(args: string[]): {
     } else if (arg === '--lenient') {
       result.lenient = true
       i++
+    } else if (arg === '--include') {
+      if (!result.includeDirs) result.includeDirs = []
+      result.includeDirs.push(args[++i])
+      i++
     } else if (!result.command) {
       result.command = arg
       i++
@@ -216,6 +222,7 @@ function compileCommand(
   sourceMap = false,
   mcVersionStr?: string,
   lenient = false,
+  includeDirs?: string[],
 ): void {
   // Read source file
   if (!fs.existsSync(file)) {
@@ -236,7 +243,7 @@ function compileCommand(
   const source = fs.readFileSync(file, 'utf-8')
 
   try {
-    const result = compile(source, { namespace, filePath: file, generateSourceMap: sourceMap, mcVersion, lenient })
+    const result = compile(source, { namespace, filePath: file, generateSourceMap: sourceMap, mcVersion, lenient, includeDirs })
 
     for (const w of result.warnings) {
       console.error(`Warning: ${w}`)
@@ -435,6 +442,7 @@ async function main(): Promise<void> {
         parsed.sourceMap,
         parsed.mcVersionStr,
         parsed.lenient,
+        parsed.includeDirs,
       )
       }
       break

package/src/compile.ts

@@ -69,6 +69,37 @@ function isLibrarySource(source: string): boolean {
 interface PreprocessOptions {
   filePath?: string
   seen?: Set<string>
+  includeDirs?: string[]
+}
+
+/** Resolve an import specifier to an absolute file path, trying multiple locations. */
+function resolveImportPath(
+  spec: string,
+  fromFile: string,
+  includeDirs: string[]
+): string | null {
+  const candidates = spec.endsWith('.mcrs') ? [spec] : [spec, spec + '.mcrs']
+
+  for (const candidate of candidates) {
+    // 1. Relative to the importing file
+    const rel = path.resolve(path.dirname(fromFile), candidate)
+    if (fs.existsSync(rel)) return rel
+
+    // 2. stdlib directory (package root / src / stdlib)
+    //    Strip leading 'stdlib/' prefix so `import "stdlib/math"` resolves to
+    //    <stdlibDir>/math.mcrs rather than <stdlibDir>/stdlib/math.mcrs.
+    const stdlibDir = path.resolve(__dirname, '..', 'src', 'stdlib')
+    const stdlibCandidate = candidate.replace(/^stdlib\//, '')
+    const stdlib = path.resolve(stdlibDir, stdlibCandidate)
+    if (fs.existsSync(stdlib)) return stdlib
+
+    // 3. Extra include dirs
+    for (const dir of includeDirs) {
+      const extra = path.resolve(dir, candidate)
+      if (fs.existsSync(extra)) return extra
+    }
+  }
+  return null
 }
 
 function countLines(source: string): number {
@@ -86,6 +117,7 @@ function offsetRanges(ranges: SourceRange[], lineOffset: number): SourceRange[]
 export function preprocessSourceWithMetadata(source: string, options: PreprocessOptions = {}): PreprocessedSource {
   const { filePath } = options
   const seen = options.seen ?? new Set<string>()
+  const includeDirs = options.includeDirs ?? []
 
   if (filePath) {
     seen.add(path.resolve(filePath))
@@ -113,31 +145,28 @@ export function preprocessSourceWithMetadata(source: string, options: Preprocess
         )
       }
 
-      const importPath = path.resolve(path.dirname(filePath), match[1])
+      const importPath = resolveImportPath(match[1], filePath, includeDirs)
+      if (!importPath) {
+        throw new DiagnosticError(
+          'ParseError',
+          `Cannot import '${match[1]}'`,
+          { file: filePath, line: i + 1, col: 1 },
+          lines
+        )
+      }
       if (!seen.has(importPath)) {
         seen.add(importPath)
-        let importedSource: string
-
-        try {
-          importedSource = fs.readFileSync(importPath, 'utf-8')
-        } catch {
-          throw new DiagnosticError(
-            'ParseError',
-            `Cannot import '${match[1]}'`,
-            { file: filePath, line: i + 1, col: 1 },
-            lines
-          )
-        }
+        const importedSource = fs.readFileSync(importPath, 'utf-8')
 
         if (isLibrarySource(importedSource)) {
           // Library file: parse separately so its functions are DCE-eligible.
           // Also collect any transitive library imports inside it.
-          const nested = preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen })
+          const nested = preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen, includeDirs })
           libraryImports.push({ source: importedSource, filePath: importPath })
           // Propagate transitive library imports (e.g. math.mcrs imports vec.mcrs)
           if (nested.libraryImports) libraryImports.push(...nested.libraryImports)
         } else {
-          imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }))
+          imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen, includeDirs }))
         }
       }
       continue

package/src/emit/compile.ts

@@ -34,6 +34,8 @@ export interface CompileOptions {
    * Use for gradual migration or testing with existing codebases that have type errors.
    */
   lenient?: boolean
+  /** Extra directories to search when resolving imports (in addition to relative and stdlib). */
+  includeDirs?: string[]
 }
 
 export interface CompileResult {
@@ -44,11 +46,11 @@ export interface CompileResult {
 }
 
 export function compile(source: string, options: CompileOptions = {}): CompileResult {
-  const { namespace = 'redscript', filePath, generateSourceMap = false, mcVersion = DEFAULT_MC_VERSION, lenient = false } = options
+  const { namespace = 'redscript', filePath, generateSourceMap = false, mcVersion = DEFAULT_MC_VERSION, lenient = false, includeDirs } = options
   const warnings: string[] = []
 
   // Preprocess: resolve import directives, merge imported sources
-  const preprocessed = preprocessSourceWithMetadata(source, { filePath })
+  const preprocessed = preprocessSourceWithMetadata(source, { filePath, includeDirs })
   const processedSource = preprocessed.source
 
   // Stage 1: Lex + Parse → AST

package/src/lsp/server.ts

@@ -34,6 +34,7 @@ import { Parser } from '../parser'
 import { TypeChecker } from '../typechecker'
 import { DiagnosticError } from '../diagnostics'
 import type { Program, FnDecl, Span, TypeNode } from '../ast/types'
+import { BUILTIN_METADATA } from '../builtins/metadata'
 
 // ---------------------------------------------------------------------------
 // Connection and document manager
@@ -123,6 +124,25 @@ function toDiagnostic(err: DiagnosticError): Diagnostic {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Decorator hover docs
+// ---------------------------------------------------------------------------
+
+const DECORATOR_DOCS: Record<string, string> = {
+  tick:         'Runs every MC game tick (~20 Hz). No arguments.',
+  load:         'Runs on `/reload`. Use for initialization logic.',
+  coroutine:    'Splits loops into tick-spread continuations. Arg: `batch=N` (steps per tick, default 1).',
+  schedule:     'Schedules the function to run after N ticks. Arg: `ticks=N`.',
+  on_trigger:   'Runs when a trigger scoreboard objective is set by a player. Arg: trigger name.',
+  keep:         'Prevents the compiler from dead-code-eliminating this function.',
+  on:           'Generic event handler decorator.',
+  on_advancement: 'Runs when a player earns an advancement. Arg: advancement id.',
+  on_craft:     'Runs when a player crafts an item. Arg: item id.',
+  on_death:     'Runs when a player dies.',
+  on_join_team: 'Runs when a player joins a team. Arg: team name.',
+  on_login:     'Runs when a player logs in.',
+}
+
 // ---------------------------------------------------------------------------
 // Hover helpers
 // ---------------------------------------------------------------------------
@@ -290,9 +310,44 @@ connection.onHover((params: TextDocumentPositionParams): Hover | null => {
   const program = cached?.program ?? null
   if (!program) return null
 
+  // Check if cursor is on a decorator (@tick, @load, etc.)
+  const lines = source.split('\n')
+  const lineText = lines[params.position.line] ?? ''
+  const decoratorMatch = lineText.match(/@([a-zA-Z_][a-zA-Z0-9_]*)/)
+  if (decoratorMatch) {
+    const ch = params.position.character
+    const atIdx = lineText.indexOf('@')
+    const decoratorEnd = atIdx + 1 + decoratorMatch[1].length
+    if (ch >= atIdx && ch <= decoratorEnd) {
+      const decoratorName = decoratorMatch[1]
+      const decoratorDoc = DECORATOR_DOCS[decoratorName]
+      if (decoratorDoc) {
+        const content: MarkupContent = {
+          kind: MarkupKind.Markdown,
+          value: `**@${decoratorName}** — ${decoratorDoc}`,
+        }
+        return { contents: content }
+      }
+    }
+  }
+
   const word = wordAt(source, params.position)
   if (!word) return null
 
+  // Check builtins
+  const builtin = BUILTIN_METADATA[word]
+  if (builtin) {
+    const paramStr = builtin.params
+      .map(p => `${p.name}: ${p.type}${p.required ? '' : '?'}`)
+      .join(', ')
+    const sig = `fn ${builtin.name}(${paramStr}): ${builtin.returns}`
+    const content: MarkupContent = {
+      kind: MarkupKind.Markdown,
+      value: `\`\`\`redscript\n${sig}\n\`\`\`\n${builtin.doc}`,
+    }
+    return { contents: content }
+  }
+
   // Check if it's a known function
   const fn = findFunction(program, word)
   if (fn) {

package/examples/spiral.mcrs

@@ -1,43 +0,0 @@
-// ===== Simple Particle Demo =====
-// 展示: @tick, 状态管理, f-strings, 控制命令
-
-// 状态
-let counter: int = 0;
-let running: bool = false;
-
-// ===== 主循环 =====
-@tick fn demo_tick() {
-    if (!running) { return; }
-    
-    // 每 tick 增加计数器
-    counter = counter + 1;
-    
-    // 在每个玩家位置生成粒子
-    foreach (p in @a) at @s {
-        particle("minecraft:end_rod", ~0, ~1, ~0, 0.5, 0.5, 0.5, 0.1, 5);
-    }
-    
-    // 每 20 ticks (1秒) 报告一次
-    if (counter % 20 == 0) {
-        say(f"Running for {counter} ticks");
-    }
-}
-
-// ===== 控制命令 =====
-// @keep 防止 DCE 删除
-@keep fn start() {
-    running = true;
-    counter = 0;
-    say(f"Demo started!");
-}
-
-@keep fn stop() {
-    running = false;
-    say(f"Demo stopped at {counter} ticks.");
-}
-
-@keep fn reset() {
-    running = false;
-    counter = 0;
-    say(f"Demo reset.");
-}

package/src/examples/arena.mcrs

@@ -1,44 +0,0 @@
-// PvP arena scoreboard tracker.
-// Reads the vanilla kills objective, announces the top score every 200 ticks,
-// and tells the current leader(s) directly.
-
-@tick
-fn arena_tick() {
-    let ticks: int = scoreboard_get("arena", #ticks);
-    ticks = ticks + 1;
-    scoreboard_set("arena", #ticks, ticks);
-
-    if (ticks % 200 == 0) {
-        announce_leaders();
-    }
-}
-
-fn announce_leaders() {
-    let top_kills: int = 0;
-
-    foreach (player in @a) {
-        let kills: int = scoreboard_get(player, #kills);
-        if (kills > top_kills) {
-            top_kills = kills;
-        }
-    }
-
-    if (top_kills > 0) {
-        announce("Arena update: leader check complete.");
-        title_times(@a, 10, 40, 10);
-        actionbar(@a, "Top kills updated");
-
-        foreach (player in @a) {
-            let kills: int = scoreboard_get(player, #kills);
-            if (kills == top_kills) {
-                tell(player, "You are leading the arena right now.");
-                title(player, "Arena Leader");
-                subtitle(player, "Hold the top score");
-                actionbar(player, "Stay alive to keep the lead");
-            }
-        }
-    } else {
-        announce("Arena update: no PvP kills yet.");
-        actionbar(@a, "No arena leader yet");
-    }
-}