redscript-mc 1.1.0 → 1.2.1

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', () => {
@@ -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')
     })
   })
 
@@ -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')
     })
   })
 

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',
       ])
     })
 
@@ -81,6 +88,14 @@ describe('Lexer', () => {
       ])
     })
 
+    it('tokenizes f-strings as a dedicated token', () => {
+      const tokens = tokenize('f"Hello {name}!"')
+      expect(tokens.map(t => [t.kind, t.value])).toEqual([
+        ['f_string', 'Hello {name}!'],
+        ['eof', ''],
+      ])
+    })
+
     it('tokenizes byte literals (b suffix)', () => {
       const tokens = tokenize('20b 0B 127b')
       expect(tokens.map(t => [t.kind, t.value])).toEqual([
@@ -163,8 +178,19 @@ describe('Lexer', () => {
 
   describe('operators', () => {
     it('tokenizes arithmetic operators', () => {
-      const tokens = tokenize('+ - * / % ~ ^')
-      expect(kinds(tokens)).toEqual(['+', '-', '*', '/', '%', '~', '^', 'eof'])
+      const tokens = tokenize('+ - * / %')
+      expect(kinds(tokens)).toEqual(['+', '-', '*', '/', '%', 'eof'])
+    })
+
+    it('tokenizes relative and local coordinates', () => {
+      const tokens = tokenize('~ ~5 ~-3 ^ ^10 ^-2')
+      expect(kinds(tokens)).toEqual(['rel_coord', 'rel_coord', 'rel_coord', 'local_coord', 'local_coord', 'local_coord', 'eof'])
+      expect(tokens[0].value).toBe('~')
+      expect(tokens[1].value).toBe('~5')
+      expect(tokens[2].value).toBe('~-3')
+      expect(tokens[3].value).toBe('^')
+      expect(tokens[4].value).toBe('^10')
+      expect(tokens[5].value).toBe('^-2')
     })
 
     it('tokenizes comparison operators', () => {
@@ -191,6 +217,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', () => {