redscript-mc 1.0.0 → 1.2.0

package/dist/__tests__/cli.test.js

@@ -43,10 +43,10 @@ describe('CLI API', () => {
     describe('imports', () => {
         it('compiles a file with imported helpers', () => {
             const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-imports-'));
-            const libPath = path.join(tempDir, 'lib.rs');
-            const mainPath = path.join(tempDir, 'main.rs');
+            const libPath = path.join(tempDir, 'lib.mcrs');
+            const mainPath = path.join(tempDir, 'main.mcrs');
             fs.writeFileSync(libPath, 'fn double(x: int) -> int { return x + x; }\n');
-            fs.writeFileSync(mainPath, 'import "./lib.rs"\n\nfn main() { let value: int = double(2); }\n');
+            fs.writeFileSync(mainPath, 'import "./lib.mcrs"\n\nfn main() { let value: int = double(2); }\n');
             const source = fs.readFileSync(mainPath, 'utf-8');
             const result = (0, index_1.compile)(source, { namespace: 'imports', filePath: mainPath });
             expect(result.files.length).toBeGreaterThan(0);
@@ -55,17 +55,155 @@ describe('CLI API', () => {
         });
         it('deduplicates circular imports', () => {
             const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-circular-'));
-            const aPath = path.join(tempDir, 'a.rs');
-            const bPath = path.join(tempDir, 'b.rs');
-            const mainPath = path.join(tempDir, 'main.rs');
-            fs.writeFileSync(aPath, 'import "./b.rs"\n\nfn from_a() -> int { return 1; }\n');
-            fs.writeFileSync(bPath, 'import "./a.rs"\n\nfn from_b() -> int { return from_a(); }\n');
-            fs.writeFileSync(mainPath, 'import "./a.rs"\n\nfn main() { let value: int = from_b(); }\n');
+            const aPath = path.join(tempDir, 'a.mcrs');
+            const bPath = path.join(tempDir, 'b.mcrs');
+            const mainPath = path.join(tempDir, 'main.mcrs');
+            fs.writeFileSync(aPath, 'import "./b.mcrs"\n\nfn from_a() -> int { return 1; }\n');
+            fs.writeFileSync(bPath, 'import "./a.mcrs"\n\nfn from_b() -> int { return from_a(); }\n');
+            fs.writeFileSync(mainPath, 'import "./a.mcrs"\n\nfn main() { let value: int = from_b(); }\n');
             const source = fs.readFileSync(mainPath, 'utf-8');
             const result = (0, index_1.compile)(source, { namespace: 'circular', filePath: mainPath });
             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 = (0, index_1.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 = (0, index_1.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 = (0, index_1.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 = (0, index_1.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 = (0, index_1.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 = (0, index_1.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()', () => {
         it('compiles simple source', () => {
@@ -110,7 +248,7 @@ fn build() {
     describe('--stats flag', () => {
         it('prints optimizer statistics', () => {
             const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stats-'));
-            const inputPath = path.join(tempDir, 'input.rs');
+            const inputPath = path.join(tempDir, 'input.mcrs');
             const outputDir = path.join(tempDir, 'out');
             fs.writeFileSync(inputPath, 'fn build() { setblock((0, 64, 0), "minecraft:stone"); setblock((1, 64, 0), "minecraft:stone"); }');
             const stdout = (0, child_process_1.execFileSync)(process.execPath, ['-r', 'ts-node/register', path.join(process.cwd(), 'src/cli.ts'), 'compile', inputPath, '-o', outputDir, '--stats'], { cwd: process.cwd(), encoding: 'utf-8' });

package/dist/__tests__/codegen.test.js

@@ -10,7 +10,7 @@ describe('generateDatapack', () => {
         expect(JSON.parse(meta.content).pack.pack_format).toBe(26);
     });
     it('generates __load.mcfunction with objective setup', () => {
-        const mod = { namespace: 'mypack', functions: [], globals: ['counter'] };
+        const mod = { namespace: 'mypack', functions: [], globals: [{ name: 'counter', init: 0 }] };
         const files = (0, mcfunction_1.generateDatapack)(mod);
         const load = files.find(f => f.path.includes('__load.mcfunction'));
         expect(load?.content).toContain('scoreboard objectives add rs dummy');
@@ -117,5 +117,30 @@ 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 = {
+            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 = (0, mcfunction_1.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');
+    });
 });
 //# sourceMappingURL=codegen.test.js.map

package/dist/__tests__/diagnostics.test.js

@@ -23,8 +23,8 @@ describe('DiagnosticError', () => {
         });
         it('includes file path when available', () => {
             const source = 'let x = foo();';
-            const error = new diagnostics_1.DiagnosticError('TypeError', 'Unknown function: foo', { file: 'test.rs', line: 1, col: 9 }, source.split('\n'));
-            expect((0, diagnostics_1.formatError)(error, source)).toContain('Error in test.rs at line 1, col 9:');
+            const error = new diagnostics_1.DiagnosticError('TypeError', 'Unknown function: foo', { file: 'test.mcrs', line: 1, col: 9 }, source.split('\n'));
+            expect((0, diagnostics_1.formatError)(error, source)).toContain('Error in test.mcrs at line 1, col 9:');
         });
     });
     describe('format', () => {
@@ -43,9 +43,9 @@ describe('DiagnosticError', () => {
             expect(formatted).toContain('^');
         });
         it('formats error with file path', () => {
-            const error = new diagnostics_1.DiagnosticError('LexError', 'Unexpected character', { file: 'test.rs', line: 1, col: 1 }, ['@@@']);
+            const error = new diagnostics_1.DiagnosticError('LexError', 'Unexpected character', { file: 'test.mcrs', line: 1, col: 1 }, ['@@@']);
             const formatted = error.format();
-            expect(formatted).toContain('test.rs:');
+            expect(formatted).toContain('test.mcrs:');
             expect(formatted).toContain('[LexError]');
         });
         it('handles missing source lines gracefully', () => {
@@ -110,7 +110,7 @@ describe('compile function', () => {
         expect(result.error?.message).toContain("Expected ';'");
     });
     it('includes file path in error', () => {
-        const result = (0, compile_1.compile)('fn main() { }', { filePath: 'test.rs' });
+        const result = (0, compile_1.compile)('fn main() { }', { filePath: 'test.mcrs' });
         // This is valid, but test that filePath is passed through
         expect(result.success).toBe(true);
     });