redscript-mc 1.0.0 → 1.2.0

package/src/__tests__/e2e.test.ts

@@ -146,6 +146,195 @@ fn main() {
     })
   })
 
+  describe('timer builtins', () => {
+    it('generates scheduled timer helper functions', () => {
+      const files = compile(`
+fn main() {
+    let intervalId: int = setInterval(20, () => {
+        say("tick");
+    });
+    setTimeout(100, () => {
+        say("later");
+    });
+    clearInterval(intervalId);
+}
+`)
+      const mainFn = getFunction(files, 'main')
+      const intervalFn = getFunction(files, '__interval_0')
+      const intervalBodyFn = getFunction(files, '__interval_body_0')
+      const timeoutFn = getFunction(files, '__timeout_0')
+      expect(mainFn).toBeDefined()
+      expect(mainFn).toContain('schedule function test:__interval_0 20t')
+      expect(mainFn).toContain('schedule function test:__timeout_0 100t')
+      expect(mainFn).toContain('schedule clear test:__interval_0')
+      expect(intervalFn).toContain('function test:__interval_body_0')
+      expect(intervalFn).toContain('schedule function test:__interval_0 20t')
+      expect(intervalBodyFn).toContain('say tick')
+      expect(timeoutFn).toContain('say later')
+    })
+  })
+
+  describe('is type narrowing', () => {
+    it('type checks and compiles entity narrowing inside foreach blocks', () => {
+      const source = `
+fn main() {
+    foreach (e in @e) {
+        if (e is Player) {
+            kill(e);
+        }
+        if (e is Zombie) {
+            kill(e);
+        }
+    }
+}
+`
+      expect(typeCheck(source)).toEqual([])
+
+      const files = compile(source)
+      const mainFn = getFunction(files, 'main')
+      const foreachFn = getSubFunction(files, 'main', 'foreach_0')
+      const thenFiles = files.filter(file => file.path.includes('/main/then_') && file.content.includes('kill @s'))
+
+      expect(mainFn).toContain('execute as @e run function test:main/foreach_0')
+      expect(foreachFn).toContain('execute if entity @s[type=player] run function test:main/then_')
+      expect(foreachFn).toContain('execute if entity @s[type=zombie] run function test:main/then_')
+      expect(thenFiles).toHaveLength(2)
+    })
+  })
+
+  describe('impl blocks', () => {
+    it('compiles static and instance impl methods end to end', () => {
+      const source = `
+struct Point { x: int, y: int }
+
+impl Point {
+    fn new(x: int, y: int) -> Point {
+        return { x: x, y: y };
+    }
+
+    fn distance(self) -> int {
+        return self.x + self.y;
+    }
+}
+
+fn main() {
+    let p: Point = Point::new(1, 2);
+    let d: int = p.distance();
+    say("\${d}");
+}
+`
+      expect(typeCheck(source)).toEqual([])
+
+      const files = compile(source)
+      const mainFn = getFunction(files, 'main')
+      const staticFn = getFunction(files, 'Point_new')
+      const instanceFn = getFunction(files, 'Point_distance')
+
+      expect(mainFn).toContain('function test:Point_new')
+      expect(mainFn).toContain('function test:Point_distance')
+      expect(staticFn).toBeDefined()
+      expect(instanceFn).toBeDefined()
+    })
+  })
+
+  describe('namespace prefixing', () => {
+    it('prefixes user objectives but preserves mc_name and qualified objectives', () => {
+      const files = compile(`
+fn main() {
+    scoreboard_set("timer", #rs, 100);
+    scoreboard_set(@s, "timer", 100);
+    scoreboard_set(@s, #health, 20);
+    scoreboard_set(@s, "custom.timer", 1);
+}
+`, 'pack')
+      const mainFn = getFunction(files, 'main')
+      expect(mainFn).toContain('scoreboard players set timer rs 100')
+      expect(mainFn).toContain('scoreboard players set @s pack.timer 100')
+      expect(mainFn).toContain('scoreboard players set @s health 20')
+      expect(mainFn).toContain('scoreboard players set @s custom.timer 1')
+    })
+  })
+
+  describe('Timer OOP API', () => {
+    it('compiles the Timer impl API end to end', () => {
+      const source = `
+struct Timer {
+    _id: int,
+    _duration: int
+}
+
+impl Timer {
+    fn new(duration: int) -> Timer {
+        scoreboard_set("timer_ticks", #rs, 0);
+        scoreboard_set("timer_active", #rs, 0);
+        return { _id: 0, _duration: duration };
+    }
+
+    fn start(self) {
+        scoreboard_set("timer_active", #rs, 1);
+    }
+
+    fn pause(self) {
+        scoreboard_set("timer_active", #rs, 0);
+    }
+
+    fn reset(self) {
+        scoreboard_set("timer_ticks", #rs, 0);
+    }
+
+    fn done(self) -> bool {
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+        return ticks >= self._duration;
+    }
+
+    fn tick(self) {
+        let active: int = scoreboard_get("timer_active", #rs);
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+
+        if (active == 1) {
+            if (ticks < self._duration) {
+                scoreboard_set("timer_ticks", #rs, ticks + 1);
+            }
+        }
+    }
+}
+
+fn main() {
+    let t: Timer = Timer::new(100);
+    t.start();
+    t.tick();
+    let finished: bool = t.done();
+    if (finished) {
+        say("done");
+    }
+    t.pause();
+    t.reset();
+}
+`
+      expect(typeCheck(source)).toEqual([])
+
+      const files = compile(source, 'timerapi')
+      const mainFn = getFunction(files, 'main')
+      const newFn = getFunction(files, 'Timer_new')
+      const startFn = getFunction(files, 'Timer_start')
+      const tickFn = getFunction(files, 'Timer_tick')
+      const doneFn = getFunction(files, 'Timer_done')
+      const pauseFn = getFunction(files, 'Timer_pause')
+      const resetFn = getFunction(files, 'Timer_reset')
+
+      expect(mainFn).toContain('function timerapi:Timer_new')
+      expect(mainFn).toContain('function timerapi:Timer_start')
+      expect(mainFn).toContain('function timerapi:Timer_tick')
+      expect(mainFn).toContain('function timerapi:Timer_done')
+      expect(newFn).toContain('scoreboard players set timer_ticks rs 0')
+      expect(startFn).toContain('scoreboard players set timer_active rs 1')
+      expect(tickFn).toContain('scoreboard players get timer_active rs')
+      expect(doneFn).toContain('scoreboard players get timer_ticks rs')
+      expect(pauseFn).toContain('scoreboard players set timer_active rs 0')
+      expect(resetFn).toContain('scoreboard players set timer_ticks rs 0')
+    })
+  })
+
   describe('advancement event decorators', () => {
     it('generates advancement json with reward function path', () => {
       const source = `
@@ -309,12 +498,12 @@ fn test() {
 }
 `
       const fn = getFunction(compile(source), 'test')!
-      expect(fn).toContain('scoreboard objectives setdisplay sidebar kills')
-      expect(fn).toContain('scoreboard objectives setdisplay list coins')
-      expect(fn).toContain('scoreboard objectives setdisplay belowName hp')
+      expect(fn).toContain('scoreboard objectives setdisplay sidebar test.kills')
+      expect(fn).toContain('scoreboard objectives setdisplay list test.coins')
+      expect(fn).toContain('scoreboard objectives setdisplay belowName test.hp')
       expect(fn).toContain('scoreboard objectives setdisplay sidebar')
-      expect(fn).toContain('scoreboard objectives add kills playerKillCount "Kill Count"')
-      expect(fn).toContain('scoreboard objectives remove kills')
+      expect(fn).toContain('scoreboard objectives add test.kills playerKillCount "Kill Count"')
+      expect(fn).toContain('scoreboard objectives remove test.kills')
     })
 
     it('compiles bossbar builtins', () => {
@@ -340,7 +529,7 @@ fn test() {
       expect(fn).toContain('bossbar set ns:health visible true')
       expect(fn).toContain('bossbar set ns:health players @a')
       expect(fn).toContain('bossbar remove ns:health')
-      expect(fn).toMatch(/execute store result score \$t\d+ rs run bossbar get ns:health value/)
+      expect(fn).toMatch(/execute store result score \$_\d+ rs run bossbar get ns:health value/)
     })
 
     it('compiles team builtins', () => {
@@ -536,7 +725,7 @@ fn test() -> int {
       const fn = getFunction(files, 'test')
       expect(fn).toBeDefined()
       expect(fn).toContain('execute store result score')
-      expect(fn).toContain('scoreboard players get PlayerName kill_count')
+      expect(fn).toContain('scoreboard players get PlayerName test.kill_count')
     })
 
     it('compiles scoreboard_get with @s selector', () => {
@@ -549,7 +738,7 @@ fn test() -> int {
       const files = compile(source)
       const fn = getFunction(files, 'test')
       expect(fn).toBeDefined()
-      expect(fn).toContain('scoreboard players get @s kill_count')
+      expect(fn).toContain('scoreboard players get @s test.kill_count')
     })
 
     it('compiles scoreboard_set with constant value', () => {
@@ -561,7 +750,7 @@ fn test() {
       const files = compile(source)
       const fn = getFunction(files, 'test')
       expect(fn).toBeDefined()
-      expect(fn).toContain('scoreboard players set PlayerName kill_count 100')
+      expect(fn).toContain('scoreboard players set PlayerName test.kill_count 100')
     })
 
     it('compiles scoreboard_set with variable value', () => {
@@ -576,7 +765,7 @@ fn test() {
         .filter(f => f.path.includes('test'))
         .map(f => f.content)
         .join('\n')
-      expect(allContent).toContain('execute store result score @s score')
+      expect(allContent).toContain('execute store result score @s test.score')
     })
 
     it('compiles score() as expression', () => {
@@ -604,7 +793,7 @@ fn double_score() -> int {
       const files = compile(source)
       const fn = getFunction(files, 'double_score')
       expect(fn).toBeDefined()
-      expect(fn).toContain('scoreboard players get @s points')
+      expect(fn).toContain('scoreboard players get @s test.points')
     })
   })
 
@@ -651,21 +840,21 @@ fn double_score() -> int {
       const source = 'fn test() { let x: int = random(1, 10); }'
       const files = compile(source)
       const fn = getFunction(files, 'test')
-      expect(fn).toContain('scoreboard players random $t0 rs 1 10')
+      expect(fn).toContain('scoreboard players random $_0 rs 1 10')
     })
 
     it('compiles random_native()', () => {
       const source = 'fn test() { let x: int = random_native(1, 6); }'
       const files = compile(source)
       const fn = getFunction(files, 'test')
-      expect(fn).toContain('execute store result score $t0 rs run random value 1 6')
+      expect(fn).toContain('execute store result score $_0 rs run random value 1 6')
     })
 
     it('compiles random_native() with zero min', () => {
       const source = 'fn test() { let x: int = random_native(0, 100); }'
       const files = compile(source)
       const fn = getFunction(files, 'test')
-      expect(fn).toContain('execute store result score $t0 rs run random value 0 100')
+      expect(fn).toContain('execute store result score $_0 rs run random value 0 100')
     })
 
     it('compiles random_sequence()', () => {
@@ -1188,7 +1377,7 @@ fn handle_claim() {
     })
   })
 
-  describe('Real program: zombie_game.rs', () => {
+  describe('Real program: zombie_game.mcrs', () => {
     const source = `
 // A zombie survival game logic
 // Kills nearby zombies and tracks score
@@ -1481,10 +1670,10 @@ fn heal(amount: int) {
 
   describe('backward compat: string objective still works', () => {
     const source = `fn test() { let x: int = scoreboard_get(@s, "kills"); }`
-    it('compiles "kills" string to bare objective name', () => {
+    it('prefixes plain string objectives with the active namespace', () => {
       const files = compile(source, 'compat')
       const fn = getFunction(files, 'test')
-      expect(fn).toContain('scoreboard players get @s kills')
+      expect(fn).toContain('scoreboard players get @s compat.kills')
     })
   })
 
@@ -1719,3 +1908,132 @@ describe('NBT parameters', () => {
     expect(fn).toContain('{Unbreakable:1b}')
   })
 })
+
+// ---------------------------------------------------------------------------
+// Set Operations
+// ---------------------------------------------------------------------------
+
+describe('Set operations', () => {
+  it('creates a new set', () => {
+    const src = `fn test() { let s = set_new(); }`
+    const files = compile(src, 'settest')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data modify storage rs:sets __set_0 set value []')
+  })
+
+  it('adds to a set with uniqueness check', () => {
+    const src = `fn test() { let s = set_new(); set_add(s, "apple"); }`
+    const files = compile(src, 'setadd')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('execute unless data storage rs:sets __set_0[{value:apple}] run data modify storage rs:sets __set_0 append value {value:apple}')
+  })
+
+  it('checks set membership', () => {
+    const src = `fn test() { let s = set_new(); set_add(s, "x"); let has = set_contains(s, "x"); }`
+    const files = compile(src, 'setcontains')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('if data storage rs:sets __set_0[{value:x}]')
+  })
+
+  it('removes from a set', () => {
+    const src = `fn test() { let s = set_new(); set_add(s, "y"); set_remove(s, "y"); }`
+    const files = compile(src, 'setremove')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data remove storage rs:sets __set_0[{value:y}]')
+  })
+
+  it('clears a set', () => {
+    const src = `fn test() { let s = set_new(); set_clear(s); }`
+    const files = compile(src, 'setclear')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data modify storage rs:sets __set_0 set value []')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Method Syntax Sugar
+// ---------------------------------------------------------------------------
+
+describe('Method syntax sugar', () => {
+  it('transforms obj.method() to method(obj)', () => {
+    const src = `fn test() { let s = set_new(); s.clear(); }`
+    const files = compile(src, 'method1')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data modify storage rs:sets __set_0 set value []')
+  })
+
+  it('transforms obj.method(arg) to method(obj, arg)', () => {
+    const src = `fn test() { let s = set_new(); s.add("apple"); }`
+    const files = compile(src, 'method2')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data modify storage rs:sets __set_0 append value {value:apple}')
+  })
+
+  it('transforms obj.method(arg) with contains', () => {
+    const src = `fn test() { let s = set_new(); s.add("x"); let r = s.contains("x"); }`
+    const files = compile(src, 'method3')
+    const fn = getFunction(files, 'test')
+    expect(fn).toBeDefined()
+  })
+
+  it('works with multiple args', () => {
+    const src = `fn test() { let s = set_new(); s.add("a"); s.add("b"); s.remove("a"); }`
+    const files = compile(src, 'method4')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data remove storage rs:sets __set_0[{value:a}]')
+  })
+})
+
+describe('Global variables', () => {
+  it('initializes global in __load', () => {
+    const src = `let x: int = 42;\nfn test() { say("hi"); }`
+    const files = compile(src, 'globaltest')
+    const load = getFunction(files, '__load')
+    expect(load).toContain('scoreboard players set $x rs 42')
+  })
+
+  it('reads and writes global in function', () => {
+    const src = `let count: int = 0;\nfn inc() { count = count + 1; }`
+    const files = compile(src, 'globalrw')
+    const fn = getFunction(files, 'inc')
+    expect(fn).toBeDefined()
+    // Global should be initialized in __load
+    const load = getFunction(files, '__load')
+    expect(load).toContain('scoreboard players set $count rs 0')
+  })
+
+  it('const cannot be reassigned', () => {
+    const src = `const X: int = 5;\nfn bad() { X = 10; }`
+    expect(() => compile(src, 'constbad')).toThrow()
+  })
+})
+
+describe('@load decorator', () => {
+  it('calls @load function from __load.mcfunction', () => {
+    const src = `@load fn init() { say("Datapack loaded!"); }`
+    const files = compile(src, 'loadtest')
+    const load = getFunction(files, '__load')
+    expect(load).toContain('function loadtest:init')
+  })
+
+  it('calls multiple @load functions in order', () => {
+    const src = `
+      @load fn setup() { say("setup"); }
+      @load fn init() { say("init"); }
+    `
+    const files = compile(src, 'loadtest')
+    const load = getFunction(files, '__load')!
+    const setupIdx = load.indexOf('function loadtest:setup')
+    const initIdx = load.indexOf('function loadtest:init')
+    expect(setupIdx).toBeGreaterThan(-1)
+    expect(initIdx).toBeGreaterThan(-1)
+    expect(setupIdx).toBeLessThan(initIdx)
+  })
+
+  it('generates the @load function body normally', () => {
+    const src = `@load fn init() { say("hi"); }`
+    const files = compile(src, 'loadtest')
+    const fn = getFunction(files, 'init')
+    expect(fn).toContain('say hi')
+  })
+})

package/src/__tests__/fixtures/event-test.mcrs

@@ -0,0 +1,13 @@
+// Test @on(PlayerDeath) event system
+// Since we can't easily kill players in test, we manually set the tag
+
+@on(PlayerDeath)
+fn handle_death(player: Player) {
+    say("Player died event triggered!");
+    scoreboard_set("#event_test", "death_count", scoreboard_get("#event_test", "death_count") + 1);
+}
+
+fn trigger_fake_death() {
+    // Manually add the death tag to simulate event
+    tag_add(@a, "rs.just_died");
+}

package/src/__tests__/fixtures/impl-test.mcrs

@@ -0,0 +1,46 @@
+struct timer {
+    _id: int,
+    _duration: int
+}
+
+impl timer {
+    fn new(duration: int) -> timer {
+        scoreboard_set("timer_ticks", #rs, 0);
+        scoreboard_set("timer_active", #rs, 0);
+        return { _id: 0, _duration: duration };
+    }
+
+    fn start(self) {
+        scoreboard_set("timer_active", #rs, 1);
+    }
+
+    fn tick(self) {
+        let active: int = scoreboard_get("timer_active", #rs);
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+
+        if (active == 1) {
+            if (ticks < self._duration) {
+                scoreboard_set("timer_ticks", #rs, ticks + 1);
+            }
+        }
+    }
+
+    fn done(self) -> bool {
+        let ticks: int = scoreboard_get("timer_ticks", #rs);
+        return ticks >= 3;
+    }
+}
+
+fn test() {
+    let timer_value: timer = timer::new(3);
+    timer_value.start();
+    timer_value.tick();
+    timer_value.tick();
+    timer_value.tick();
+    let finished: bool = timer_value.done();
+    if (finished) {
+        scoreboard_set("#impl", #done, 1);
+        return;
+    }
+    scoreboard_set("#impl", #done, 1);
+}

package/src/__tests__/fixtures/interval-test.mcrs

@@ -0,0 +1,11 @@
+fn start() {
+    scoreboard_set("#interval", #ticks, 0);
+
+    setInterval(20, () => {
+        let count: int = scoreboard_get("#interval", #ticks);
+        if (count < 3) {
+            say("Interval tick");
+            scoreboard_set("#interval", #ticks, count + 1);
+        }
+    });
+}

package/src/__tests__/fixtures/is-check-test.mcrs

@@ -0,0 +1,20 @@
+fn check_types() {
+    scoreboard_set("#is_check", #players, 0);
+    scoreboard_set("#is_check", #zombies, 0);
+
+    foreach (e in @e[type=zombie,tag=is_check_target]) {
+        if (e is Player) {
+            let players: int = scoreboard_get("#is_check", #players);
+            scoreboard_set("#is_check", #players, players + 1);
+        }
+
+        if (e is Zombie) {
+            let players: int = scoreboard_get("#is_check", #players);
+            scoreboard_set("#is_check", #players, players);
+        }
+
+        let zombies: int = scoreboard_get("#is_check", #zombies);
+        scoreboard_set("#is_check", #zombies, zombies + 1);
+        kill(e);
+    }
+}

package/src/__tests__/fixtures/timeout-test.mcrs

@@ -0,0 +1,7 @@
+fn start() {
+    scoreboard_set("#timeout", #fired, 0);
+    setTimeout(20, () => {
+        say("Delayed message");
+        scoreboard_set("#timeout", #fired, 1);
+    });
+}

package/src/__tests__/lexer.test.ts

@@ -11,10 +11,17 @@ function kinds(tokens: Token[]): TokenKind[] {
 describe('Lexer', () => {
   describe('keywords', () => {
     it('recognizes all keywords', () => {
-      const tokens = tokenize('fn let const if else while for foreach match return as at in struct enum trigger namespace')
+      const tokens = tokenize('fn let const if else while for foreach match return as at in is struct impl enum trigger namespace')
       expect(kinds(tokens)).toEqual([
         'fn', 'let', 'const', 'if', 'else', 'while', 'for', 'foreach', 'match',
-        'return', 'as', 'at', 'in', 'struct', 'enum', 'trigger', 'namespace', 'eof'
+        'return', 'as', 'at', 'in', 'is', 'struct', 'impl', 'enum', 'trigger', 'namespace', 'eof'
+      ])
+    })
+
+    it('tokenizes is-check and impl syntax with their dedicated keywords', () => {
+      const tokens = tokenize('if (e is Player) { } impl Point { }')
+      expect(kinds(tokens)).toEqual([
+        'if', '(', 'ident', 'is', 'ident', ')', '{', '}', 'impl', 'ident', '{', '}', 'eof',
       ])
     })
 
@@ -191,6 +198,11 @@ describe('Lexer', () => {
       const tokens = tokenize('=>')
       expect(kinds(tokens)).toEqual(['=>', 'eof'])
     })
+
+    it('tokenizes static method separators for impl methods', () => {
+      const tokens = tokenize('Point::new()')
+      expect(kinds(tokens)).toEqual(['ident', '::', 'ident', '(', ')', 'eof'])
+    })
   })
 
   describe('delimiters', () => {