redscript-mc 1.2.25 → 1.2.27

package/dist/codegen/mcfunction/index.js

@@ -32,6 +32,8 @@ function operandToScore(op, alloc) {
         return `${alloc.alloc(op.name)} ${OBJ}`;
     if (op.kind === 'const')
         return `${alloc.constant(op.value)} ${OBJ}`;
+    if (op.kind === 'param')
+        return `${alloc.internal(`p${op.index}`)} ${OBJ}`;
     throw new Error(`Cannot convert storage operand to score: ${op.path}`);
 }
 // Collect all constants used in a function for pre-setup
@@ -79,6 +81,9 @@ function emitInstr(instr, ns, alloc) {
             else if (src.kind === 'var') {
                 lines.push(`scoreboard players operation ${dst} ${OBJ} = ${alloc.alloc(src.name)} ${OBJ}`);
             }
+            else if (src.kind === 'param') {
+                lines.push(`scoreboard players operation ${dst} ${OBJ} = ${alloc.internal(`p${src.index}`)} ${OBJ}`);
+            }
             else {
                 lines.push(`execute store result score ${dst} ${OBJ} run data get storage ${src.path}`);
             }
@@ -121,21 +126,42 @@ function emitInstr(instr, ns, alloc) {
             break;
         }
         case 'call': {
-            // Push args as param fake players
+            // Push args into the internal parameter slots ($p0, $p1, ...).
+            // We emit the copy commands directly (not via emitInstr/alloc.alloc) to
+            // ensure the destination resolves to alloc.internal('p{i}') rather than
+            // alloc.alloc('p{i}') which would create a *different* user-var slot.
             for (let i = 0; i < instr.args.length; i++) {
-                const paramName = alloc.internal(`p${i}`);
-                lines.push(...emitInstr({ op: 'assign', dst: paramName, src: instr.args[i] }, ns, alloc));
+                const paramSlot = alloc.internal(`p${i}`);
+                const arg = instr.args[i];
+                if (arg.kind === 'const') {
+                    lines.push(`scoreboard players set ${paramSlot} ${OBJ} ${arg.value}`);
+                }
+                else if (arg.kind === 'var') {
+                    lines.push(`scoreboard players operation ${paramSlot} ${OBJ} = ${alloc.alloc(arg.name)} ${OBJ}`);
+                }
+                else if (arg.kind === 'param') {
+                    lines.push(`scoreboard players operation ${paramSlot} ${OBJ} = ${alloc.internal(`p${arg.index}`)} ${OBJ}`);
+                }
+                // storage args are rare for call sites; fall through to no-op
             }
             lines.push(`function ${ns}:${instr.fn}`);
             if (instr.dst) {
-                const retName = alloc.internal('ret');
-                lines.push(`scoreboard players operation ${alloc.alloc(instr.dst)} ${OBJ} = ${retName} ${OBJ}`);
+                const retSlot = alloc.internal('ret');
+                lines.push(`scoreboard players operation ${alloc.alloc(instr.dst)} ${OBJ} = ${retSlot} ${OBJ}`);
             }
             break;
         }
-        case 'raw':
-            lines.push(instr.cmd);
+        case 'raw': {
+            // resolveRaw rewrites $var tokens that are registered in the allocator
+            // so that mangle=true mode produces correct mangled names instead of
+            // the raw IR names embedded by the lowering phase.
+            // \x01 is a sentinel for the MC macro line-start '$' (used by
+            // storage_get_int sub-functions). Replace it last, after resolveRaw,
+            // so '$execute' is never treated as a variable reference.
+            const rawResolved = alloc.resolveRaw(instr.cmd).replace(/^\x01/, '$');
+            lines.push(rawResolved);
             break;
+        }
     }
     return lines;
 }
@@ -157,17 +183,32 @@ function emitTerm(term, ns, fnName, alloc) {
             lines.push(`execute if score ${alloc.alloc(term.cond)} ${OBJ} matches 1.. run function ${ns}:${fnName}/${term.else_}`);
             break;
         case 'return': {
-            const retName = alloc.internal('ret');
+            // Emit the copy to the shared return slot directly — do NOT go through
+            // emitInstr/alloc.alloc(retSlot) which would allocate a *user* var slot
+            // (different from the internal slot) and break mangle mode.
+            const retSlot = alloc.internal('ret');
             if (term.value) {
-                lines.push(...emitInstr({ op: 'assign', dst: retName, src: term.value }, ns, alloc));
+                if (term.value.kind === 'const') {
+                    lines.push(`scoreboard players set ${retSlot} ${OBJ} ${term.value.value}`);
+                }
+                else if (term.value.kind === 'var') {
+                    lines.push(`scoreboard players operation ${retSlot} ${OBJ} = ${alloc.alloc(term.value.name)} ${OBJ}`);
+                }
+                else if (term.value.kind === 'param') {
+                    lines.push(`scoreboard players operation ${retSlot} ${OBJ} = ${alloc.internal(`p${term.value.index}`)} ${OBJ}`);
+                }
             }
-            // In MC 1.20+, use `return` command
+            // MC 1.20+: use `return` to propagate the value back to the caller's
+            // `execute store result … run function …` without an extra scoreboard read.
             if (term.value?.kind === 'const') {
                 lines.push(`return ${term.value.value}`);
             }
             else if (term.value?.kind === 'var') {
                 lines.push(`return run scoreboard players get ${alloc.alloc(term.value.name)} ${OBJ}`);
             }
+            else if (term.value?.kind === 'param') {
+                lines.push(`return run scoreboard players get ${alloc.internal(`p${term.value.index}`)} ${OBJ}`);
+            }
             break;
         }
         case 'tick_yield':
@@ -237,6 +278,62 @@ function countMcfunctionCommands(files) {
             .length;
     }, 0);
 }
+// ---------------------------------------------------------------------------
+// Pre-allocation helpers for the two-pass mangle strategy
+// ---------------------------------------------------------------------------
+/** Register every variable referenced in an instruction with the allocator. */
+function preAllocInstr(instr, alloc) {
+    switch (instr.op) {
+        case 'assign':
+            alloc.alloc(instr.dst);
+            if (instr.src.kind === 'var')
+                alloc.alloc(instr.src.name);
+            break;
+        case 'binop':
+            alloc.alloc(instr.dst);
+            if (instr.lhs.kind === 'var')
+                alloc.alloc(instr.lhs.name);
+            if (instr.rhs.kind === 'var')
+                alloc.alloc(instr.rhs.name);
+            break;
+        case 'cmp':
+            alloc.alloc(instr.dst);
+            if (instr.lhs.kind === 'var')
+                alloc.alloc(instr.lhs.name);
+            if (instr.rhs.kind === 'var')
+                alloc.alloc(instr.rhs.name);
+            break;
+        case 'call':
+            for (const arg of instr.args) {
+                if (arg.kind === 'var')
+                    alloc.alloc(arg.name);
+            }
+            if (instr.dst)
+                alloc.alloc(instr.dst);
+            break;
+        case 'raw':
+            // Scan for $varname tokens and pre-register each one
+            ;
+            instr.cmd.replace(/\$[A-Za-z_][A-Za-z0-9_]*/g, (tok) => {
+                alloc.alloc(tok);
+                return tok;
+            });
+            break;
+    }
+}
+/** Register every variable referenced in a terminator with the allocator. */
+function preAllocTerm(term, alloc) {
+    switch (term.op) {
+        case 'jump_if':
+        case 'jump_unless':
+            alloc.alloc(term.cond);
+            break;
+        case 'return':
+            if (term.value?.kind === 'var')
+                alloc.alloc(term.value.name);
+            break;
+    }
+}
 function generateDatapackWithStats(module, options = {}) {
     const { optimizeCommands = true, mangle = false } = options;
     const alloc = new var_allocator_1.VarAllocator(mangle);
@@ -316,6 +413,39 @@ function generateDatapackWithStats(module, options = {}) {
     if (allConsts.size > 0) {
         loadLines.push(...Array.from(allConsts).sort((a, b) => a - b).map(value => `scoreboard players set ${alloc.constant(value)} ${OBJ} ${value}`));
     }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Pre-allocation pass (mangle mode only)
+    //
+    // When mangle=true, the codegen assigns sequential names ($a, $b, …) the
+    // FIRST time alloc.alloc() is called for a given variable.  Raw IR commands
+    // embed variable names (e.g. "$_0") as plain strings; resolveRaw() can only
+    // substitute them if the name was already registered in the allocator.
+    //
+    // Problem: a freshTemp ($\_0) used in a `raw` instruction and then in the
+    // immediately following `assign` gets registered by the `assign` AFTER the
+    // `raw` has already been emitted — so resolveRaw sees an unknown name and
+    // passes it through verbatim ($\_0), while the assign emits a different
+    // mangled slot ($e).  The two slots never meet and the value is lost.
+    //
+    // Fix: walk every instruction (and terminator) of every function in order
+    // and call alloc.alloc() for each variable reference.  This registers all
+    // names — with the same sequential order the main emit pass will encounter
+    // them — so that resolveRaw() can always find the correct mangled name.
+    // ─────────────────────────────────────────────────────────────────────────
+    if (mangle) {
+        for (const fn of module.functions) {
+            // Register internals used by the calling convention
+            for (let i = 0; i < fn.params.length; i++)
+                alloc.internal(`p${i}`);
+            alloc.internal('ret');
+            for (const block of fn.blocks) {
+                for (const instr of block.instrs) {
+                    preAllocInstr(instr, alloc);
+                }
+                preAllocTerm(block.term, alloc);
+            }
+        }
+    }
     // Generate each function
     for (const fn of module.functions) {
         // Entry block → <fn_name>.mcfunction
@@ -323,12 +453,9 @@ function generateDatapackWithStats(module, options = {}) {
         for (let i = 0; i < fn.blocks.length; i++) {
             const block = fn.blocks[i];
             const lines = [`# block: ${block.label}`];
-            // Param setup in entry block
-            if (i === 0) {
-                for (let j = 0; j < fn.params.length; j++) {
-                    lines.push(`scoreboard players operation ${alloc.alloc(fn.params[j])} ${OBJ} = ${alloc.internal(`p${j}`)} ${OBJ}`);
-                }
-            }
+            // Param setup is now handled by the lowering IR itself via { kind: 'param' }
+            // operands, so we no longer need a separate codegen param-copy loop here.
+            // (Removing it prevents the double-assignment that caused mangle-mode collisions.)
             for (const instr of block.instrs) {
                 lines.push(...emitInstr(instr, ns, alloc));
             }
@@ -344,11 +471,20 @@ function generateDatapackWithStats(module, options = {}) {
             files.push({ path: filePath, content: lines.join('\n') });
         }
     }
-    // Call @load functions from __load
+    // Call @load functions and @requires-referenced load helpers from __load.
+    // We collect them in a set to deduplicate (multiple fns might @requires the same dep).
+    const loadCalls = new Set();
     for (const fn of module.functions) {
         if (fn.isLoadInit) {
-            loadLines.push(`function ${ns}:${fn.name}`);
+            loadCalls.add(fn.name);
         }
+        // @requires: if this fn is compiled in, its required load-helpers must also run
+        for (const dep of fn.requiredLoads ?? []) {
+            loadCalls.add(dep);
+        }
+    }
+    for (const name of loadCalls) {
+        loadLines.push(`function ${ns}:${name}`);
     }
     // Write __load.mcfunction
     files.push({

package/dist/codegen/var-allocator.d.ts

@@ -15,6 +15,23 @@ export declare class VarAllocator {
     alloc(originalName: string): string;
     /** Allocate a name for a constant value (content-addressed). */
     constant(value: number): string;
+    /**
+     * Look up the allocated name for a raw scoreboard fake-player name such as
+     * "$_2", "$x", "$p0", or "$ret".  Returns the mangled name when mangle=true,
+     * or the original name when mangle=false or the name is not yet known.
+     *
+     * Unlike alloc/internal/constant this does NOT create a new slot — it only
+     * resolves names that were already registered.  Used by the codegen to
+     * rewrite variable references inside `raw` IR instructions.
+     */
+    resolve(rawName: string): string;
+    /**
+     * Rewrite all $varname tokens in a raw mcfunction command string so that
+     * IR variable names are replaced by their allocated (possibly mangled) names.
+     * Tokens that are not registered in the allocator are left untouched (they
+     * are literal scoreboard fake-player names like "out" or "#rs").
+     */
+    resolveRaw(cmd: string): string;
     /** Allocate a name for a compiler internal (e.g. "ret", "p0"). */
     internal(suffix: string): string;
     /** Generate the next sequential name: a, b, ..., z, aa, ab, ..., az, ba, ... */

package/dist/codegen/var-allocator.js

@@ -34,6 +34,32 @@ class VarAllocator {
         this.constCache.set(value, name);
         return name;
     }
+    /**
+     * Look up the allocated name for a raw scoreboard fake-player name such as
+     * "$_2", "$x", "$p0", or "$ret".  Returns the mangled name when mangle=true,
+     * or the original name when mangle=false or the name is not yet known.
+     *
+     * Unlike alloc/internal/constant this does NOT create a new slot — it only
+     * resolves names that were already registered.  Used by the codegen to
+     * rewrite variable references inside `raw` IR instructions.
+     */
+    resolve(rawName) {
+        const clean = rawName.startsWith('$') ? rawName.slice(1) : rawName;
+        // Check every cache in priority order: vars, internals, consts
+        return (this.varCache.get(clean) ??
+            this.internalCache.get(clean) ??
+            rawName // not registered → return as-is (literal fake player, not a var)
+        );
+    }
+    /**
+     * Rewrite all $varname tokens in a raw mcfunction command string so that
+     * IR variable names are replaced by their allocated (possibly mangled) names.
+     * Tokens that are not registered in the allocator are left untouched (they
+     * are literal scoreboard fake-player names like "out" or "#rs").
+     */
+    resolveRaw(cmd) {
+        return cmd.replace(/\$[A-Za-z_][A-Za-z0-9_]*/g, (tok) => this.resolve(tok));
+    }
     /** Allocate a name for a compiler internal (e.g. "ret", "p0"). */
     internal(suffix) {
         const cached = this.internalCache.get(suffix);

package/dist/compile.d.ts

@@ -12,6 +12,13 @@ export interface CompileOptions {
     filePath?: string;
     optimize?: boolean;
     dce?: boolean;
+    mangle?: boolean;
+    /** Additional source files that should be treated as *library* code.
+     *  Functions in these files are DCE-eligible: they are only compiled into
+     *  the datapack when actually called from user code.  Each string is parsed
+     *  independently (as if it had `module library;` at the top), so library
+     *  mode never bleeds into the main `source`. */
+    librarySources?: string[];
 }
 export interface CompileResult {
     success: boolean;
@@ -29,6 +36,13 @@ export interface SourceRange {
 export interface PreprocessedSource {
     source: string;
     ranges: SourceRange[];
+    /** Imported files that declared `module library;` — parsed separately
+     *  in library mode so their functions are DCE-eligible.  Never concatenated
+     *  into `source`. */
+    libraryImports?: Array<{
+        source: string;
+        filePath: string;
+    }>;
 }
 /**
  * Resolve a combined-source line number back to the original file and line.

package/dist/compile.js

@@ -66,6 +66,17 @@ function resolveSourceLine(combinedLine, ranges, fallbackFile) {
     return { filePath: fallbackFile, line: combinedLine };
 }
 const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/;
+/** Returns true if the source file declares `module library;` at its top
+ *  (before any non-comment/non-blank lines). */
+function isLibrarySource(source) {
+    for (const line of source.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('//'))
+            continue;
+        return /^module\s+library\s*;/.test(trimmed);
+    }
+    return false;
+}
 function countLines(source) {
     return source === '' ? 0 : source.split('\n').length;
 }
@@ -84,6 +95,8 @@ function preprocessSourceWithMetadata(source, options = {}) {
     }
     const lines = source.split('\n');
     const imports = [];
+    /** Library imports: `module library;` files routed here instead of concatenated. */
+    const libraryImports = [];
     const bodyLines = [];
     let parsingHeader = true;
     for (let i = 0; i < lines.length; i++) {
@@ -104,7 +117,18 @@ function preprocessSourceWithMetadata(source, options = {}) {
                 catch {
                     throw new diagnostics_1.DiagnosticError('ParseError', `Cannot import '${match[1]}'`, { file: filePath, line: i + 1, col: 1 }, lines);
                 }
-                imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }));
+                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 });
+                    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 }));
+                }
             }
             continue;
         }
@@ -131,7 +155,11 @@ function preprocessSourceWithMetadata(source, options = {}) {
             filePath: path.resolve(filePath),
         });
     }
-    return { source: combined, ranges };
+    return {
+        source: combined,
+        ranges,
+        libraryImports: libraryImports.length > 0 ? libraryImports : undefined,
+    };
 }
 function preprocessSource(source, options = {}) {
     return preprocessSourceWithMetadata(source, options).source;
@@ -149,8 +177,36 @@ function compile(source, options = {}) {
         sourceLines = preprocessedSource.split('\n');
         // Lexing
         const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
-        // Parsing
+        // Parsing — user source
         const parsedAst = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+        // Collect all library sources: explicit `librarySources` option +
+        // auto-detected imports (files with `module library;` pulled out by the
+        // preprocessor rather than concatenated).
+        const allLibrarySources = [];
+        for (const libSrc of options.librarySources ?? []) {
+            allLibrarySources.push({ src: libSrc });
+        }
+        for (const li of preprocessed.libraryImports ?? []) {
+            allLibrarySources.push({ src: li.source, fp: li.filePath });
+        }
+        // Parse library sources independently (fresh Parser per source) so that
+        // `inLibraryMode` never bleeds into user code.  All resulting functions get
+        // isLibraryFn=true (either via `module library;` in the source, or forced below).
+        for (const { src, fp } of allLibrarySources) {
+            const libPreprocessed = preprocessSourceWithMetadata(src, fp ? { filePath: fp } : {});
+            const libTokens = new lexer_1.Lexer(libPreprocessed.source, fp).tokenize();
+            const libAst = new parser_1.Parser(libTokens, libPreprocessed.source, fp).parse(namespace);
+            // Force all functions to library mode (even if source lacks `module library;`)
+            for (const fn of libAst.declarations)
+                fn.isLibraryFn = true;
+            // Merge into main AST
+            parsedAst.declarations.push(...libAst.declarations);
+            parsedAst.structs.push(...libAst.structs);
+            parsedAst.implBlocks.push(...libAst.implBlocks);
+            parsedAst.enums.push(...libAst.enums);
+            parsedAst.consts.push(...libAst.consts);
+            parsedAst.globals.push(...libAst.globals);
+        }
         const dceResult = shouldRunDce ? (0, dce_1.eliminateDeadCode)(parsedAst) : { program: parsedAst, warnings: [] };
         const ast = dceResult.program;
         // Lowering
@@ -159,8 +215,9 @@ function compile(source, options = {}) {
         const optimized = shouldOptimize
             ? { ...ir, functions: ir.functions.map(fn => (0, passes_1.optimize)(fn)) }
             : ir;
-        // Code generation
-        const generated = (0, mcfunction_1.generateDatapackWithStats)(optimized);
+        // Code generation — mangle=true by default to prevent cross-function
+        // scoreboard variable collisions in the global MC scoreboard namespace.
+        const generated = (0, mcfunction_1.generateDatapackWithStats)(optimized, { mangle: options.mangle ?? true });
         return {
             success: true,
             files: [...generated.files, ...generated.advancements],

package/dist/data/arena/function/__load.mcfunction

@@ -0,0 +1,6 @@
+# RedScript runtime init
+scoreboard objectives add rs dummy
+scoreboard players set $const_1 rs 1
+scoreboard players set $const_200 rs 200
+scoreboard players set $const_0 rs 0
+scoreboard players set $const_0 rs 0

package/dist/data/arena/function/__tick.mcfunction

@@ -0,0 +1,2 @@
+# RedScript tick dispatcher
+function arena:arena_tick

package/dist/data/arena/function/announce_leaders/else_1.mcfunction

@@ -0,0 +1,3 @@
+# block: else_1
+say Arena update: no PvP kills yet.
+function arena:announce_leaders/merge_2

package/dist/data/arena/function/announce_leaders/foreach_0/merge_2.mcfunction

@@ -0,0 +1 @@
+# block: merge_2

package/dist/data/arena/function/announce_leaders/foreach_0/then_0.mcfunction

@@ -0,0 +1,3 @@
+# block: then_0
+scoreboard players operation $top_kills rs = $kills rs
+function arena:announce_leaders/foreach_0/merge_2

package/dist/data/arena/function/announce_leaders/foreach_0.mcfunction

@@ -0,0 +1,7 @@
+# block: entry
+execute store result score $t0 rs run scoreboard players get @s kills
+scoreboard players operation $kills rs = $t0 rs
+scoreboard players set $t1 rs 0
+execute if score $t0 rs > $top_kills rs run scoreboard players set $t1 rs 1
+execute if score $t1 rs matches 1.. run function arena:announce_leaders/foreach_0/then_0
+execute if score $t1 rs matches ..0 run function arena:announce_leaders/foreach_0/merge_2

package/dist/data/arena/function/announce_leaders/foreach_1/merge_2.mcfunction

@@ -0,0 +1 @@
+# block: merge_2

package/dist/data/arena/function/announce_leaders/foreach_1/then_0.mcfunction

@@ -0,0 +1,4 @@
+# block: then_0
+tellraw @s {"text":"You are leading the arena right now."}
+title @s title {"text":"Arena Leader"}
+function arena:announce_leaders/foreach_1/merge_2

package/dist/data/arena/function/announce_leaders/foreach_1.mcfunction

@@ -0,0 +1,6 @@
+# block: entry
+execute store result score $t0 rs run scoreboard players get @s kills
+scoreboard players set $t1 rs 0
+execute if score $t0 rs = $top_kills rs run scoreboard players set $t1 rs 1
+execute if score $t1 rs matches 1.. run function arena:announce_leaders/foreach_1/then_0
+execute if score $t1 rs matches ..0 run function arena:announce_leaders/foreach_1/merge_2

package/dist/data/arena/function/announce_leaders/merge_2.mcfunction

@@ -0,0 +1 @@
+# block: merge_2

package/dist/data/arena/function/announce_leaders/then_0.mcfunction

@@ -0,0 +1,4 @@
+# block: then_0
+say Arena update: current leader check complete.
+execute as @a run function arena:announce_leaders/foreach_1
+function arena:announce_leaders/merge_2

package/dist/data/arena/function/announce_leaders.mcfunction

@@ -0,0 +1,6 @@
+# block: entry
+execute as @a run function arena:announce_leaders/foreach_0
+scoreboard players set $t0 rs 0
+execute if score $const_0 rs > $const_0 rs run scoreboard players set $t0 rs 1
+execute if score $t0 rs matches 1.. run function arena:announce_leaders/then_0
+execute if score $t0 rs matches ..0 run function arena:announce_leaders/else_1

package/dist/data/arena/function/arena_tick/merge_2.mcfunction

@@ -0,0 +1 @@
+# block: merge_2

package/dist/data/arena/function/arena_tick/then_0.mcfunction

@@ -0,0 +1,4 @@
+# block: then_0
+function arena:announce_leaders
+scoreboard players operation $t5 rs = $ret rs
+function arena:arena_tick/merge_2

package/dist/data/arena/function/arena_tick.mcfunction

@@ -0,0 +1,11 @@
+# block: entry
+execute store result score $t0 rs run scoreboard players get arena ticks
+scoreboard players operation $t1 rs = $t0 rs
+scoreboard players operation $t1 rs += $const_1 rs
+execute store result score arena ticks run scoreboard players get $t2 rs
+scoreboard players operation $t3 rs = $t1 rs
+scoreboard players operation $t3 rs %= $const_200 rs
+scoreboard players set $t4 rs 0
+execute if score $t3 rs = $const_0 rs run scoreboard players set $t4 rs 1
+execute if score $t4 rs matches 1.. run function arena:arena_tick/then_0
+execute if score $t4 rs matches ..0 run function arena:arena_tick/merge_2

package/dist/data/counter/function/__load.mcfunction

@@ -0,0 +1,5 @@
+# RedScript runtime init
+scoreboard objectives add rs dummy
+scoreboard players set $const_1 rs 1
+scoreboard players set $const_100 rs 100
+scoreboard players set $const_0 rs 0

package/dist/data/counter/function/__tick.mcfunction

@@ -0,0 +1,2 @@
+# RedScript tick dispatcher
+function counter:counter_tick

package/dist/data/counter/function/counter_tick/merge_2.mcfunction

@@ -0,0 +1 @@
+# block: merge_2

package/dist/data/counter/function/counter_tick/then_0.mcfunction

@@ -0,0 +1,3 @@
+# block: then_0
+say Counter reached another 100 ticks
+function counter:counter_tick/merge_2

package/dist/data/counter/function/counter_tick.mcfunction

@@ -0,0 +1,11 @@
+# block: entry
+execute store result score $t0 rs run scoreboard players get counter ticks
+scoreboard players operation $t1 rs = $t0 rs
+scoreboard players operation $t1 rs += $const_1 rs
+execute store result score counter ticks run scoreboard players get $t2 rs
+scoreboard players operation $t3 rs = $t1 rs
+scoreboard players operation $t3 rs %= $const_100 rs
+scoreboard players set $t4 rs 0
+execute if score $t3 rs = $const_0 rs run scoreboard players set $t4 rs 1
+execute if score $t4 rs matches 1.. run function counter:counter_tick/then_0
+execute if score $t4 rs matches ..0 run function counter:counter_tick/merge_2

package/dist/data/gcd2/function/__load.mcfunction

@@ -0,0 +1,3 @@
+# RedScript runtime init
+scoreboard objectives add rs dummy
+scoreboard players set $a rs 0

package/dist/data/gcd2/function/abs/merge_2.mcfunction

@@ -0,0 +1,3 @@
+# block: merge_2
+scoreboard players operation $h rs = $b rs
+return run scoreboard players get $b rs

package/dist/data/gcd2/function/abs/then_0.mcfunction

@@ -0,0 +1,5 @@
+# block: then_0
+scoreboard players set $f rs 0
+scoreboard players operation $f rs -= $b rs
+scoreboard players operation $h rs = $f rs
+return run scoreboard players get $f rs

package/dist/data/gcd2/function/abs.mcfunction

@@ -0,0 +1,7 @@
+# block: entry
+scoreboard players operation $b rs = $c rs
+scoreboard players operation $b rs = $d rs
+scoreboard players set $e rs 0
+execute if score $d rs < $a rs run scoreboard players set $e rs 1
+execute if score $e rs matches 1.. run function gcd2:abs/then_0
+execute if score $e rs matches ..0 run function gcd2:abs/merge_2

package/dist/data/gcd2/function/gcd/loop_body_1.mcfunction

@@ -0,0 +1,7 @@
+# block: loop_body_1
+scoreboard players operation $r rs = $b rs
+scoreboard players operation $r rs %= $p rs
+scoreboard players operation $s rs = $r rs
+scoreboard players operation $b rs = $p rs
+scoreboard players operation $p rs = $r rs
+function gcd2:gcd/loop_check_0

package/dist/data/gcd2/function/gcd/loop_check_0.mcfunction

@@ -0,0 +1,5 @@
+# block: loop_check_0
+scoreboard players set $q rs 0
+execute if score $p rs > $a rs run scoreboard players set $q rs 1
+execute if score $q rs matches 1.. run function gcd2:gcd/loop_body_1
+execute if score $q rs matches ..0 run function gcd2:gcd/loop_exit_2

package/dist/data/gcd2/function/gcd/loop_exit_2.mcfunction

@@ -0,0 +1,3 @@
+# block: loop_exit_2
+scoreboard players operation $h rs = $b rs
+return run scoreboard players get $b rs

package/dist/data/gcd2/function/gcd.mcfunction

@@ -0,0 +1,14 @@
+# block: entry
+scoreboard players operation $i rs = $c rs
+scoreboard players operation $j rs = $k rs
+scoreboard players operation $i rs = $d rs
+scoreboard players operation $j rs = $l rs
+scoreboard players operation $m rs = $d rs
+function gcd2:abs
+scoreboard players operation $n rs = $g rs
+scoreboard players operation $b rs = $n rs
+scoreboard players operation $m rs = $l rs
+function gcd2:abs
+scoreboard players operation $o rs = $g rs
+scoreboard players operation $p rs = $o rs
+function gcd2:gcd/loop_check_0

package/dist/data/gcd3/function/__load.mcfunction

@@ -0,0 +1,3 @@
+# RedScript runtime init
+scoreboard objectives add rs dummy
+scoreboard players set $a rs 0

package/dist/data/gcd3/function/abs/merge_2.mcfunction

@@ -0,0 +1,3 @@
+# block: merge_2
+scoreboard players operation $h rs = $b rs
+return run scoreboard players get $b rs

package/dist/data/gcd3/function/abs/then_0.mcfunction

@@ -0,0 +1,5 @@
+# block: then_0
+scoreboard players set $f rs 0
+scoreboard players operation $f rs -= $b rs
+scoreboard players operation $h rs = $f rs
+return run scoreboard players get $f rs