redscript-mc 2.4.0 → 2.4.1

package/dist/codegen/structure/index.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStructure = generateStructure;
+exports.compileToStructure = compileToStructure;
+const lexer_1 = require("../../lexer");
+const parser_1 = require("../../parser");
+const lowering_1 = require("../../lowering");
+const nbt_1 = require("../../nbt");
+const commands_1 = require("../../optimizer/commands");
+const passes_1 = require("../../optimizer/passes");
+const structure_1 = require("../../optimizer/structure");
+const dce_1 = require("../../optimizer/dce");
+const compile_1 = require("../../compile");
+const types_1 = require("../../events/types");
+const var_allocator_1 = require("../var-allocator");
+const DATA_VERSION = 3953;
+const MAX_WIDTH = 16;
+const OBJ = 'rs';
+const PALETTE_IMPULSE = 0;
+const PALETTE_CHAIN_UNCONDITIONAL = 1;
+const PALETTE_CHAIN_CONDITIONAL = 2;
+const PALETTE_REPEAT = 3;
+const palette = [
+    { Name: 'minecraft:command_block', Properties: { conditional: 'false', facing: 'east' } },
+    { Name: 'minecraft:chain_command_block', Properties: { conditional: 'false', facing: 'east' } },
+    { Name: 'minecraft:chain_command_block', Properties: { conditional: 'true', facing: 'east' } },
+    { Name: 'minecraft:repeating_command_block', Properties: { conditional: 'false', facing: 'east' } },
+    { Name: 'minecraft:air', Properties: {} },
+];
+function escapeJsonString(value) {
+    return JSON.stringify(value).slice(1, -1);
+}
+function collectConsts(fn) {
+    const consts = new Set();
+    for (const block of fn.blocks) {
+        for (const instr of block.instrs) {
+            if (instr.op === 'assign' && instr.src.kind === 'const')
+                consts.add(instr.src.value);
+            if (instr.op === 'binop') {
+                if (instr.lhs.kind === 'const')
+                    consts.add(instr.lhs.value);
+                if (instr.rhs.kind === 'const')
+                    consts.add(instr.rhs.value);
+            }
+            if (instr.op === 'cmp') {
+                if (instr.lhs.kind === 'const')
+                    consts.add(instr.lhs.value);
+                if (instr.rhs.kind === 'const')
+                    consts.add(instr.rhs.value);
+            }
+        }
+        if (block.term.op === 'return' && block.term.value?.kind === 'const') {
+            consts.add(block.term.value.value);
+        }
+    }
+    return consts;
+}
+function collectCommandEntriesFromModule(module, mangle = false) {
+    const alloc = new var_allocator_1.VarAllocator(mangle);
+    const entries = [];
+    const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName);
+    const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName));
+    const eventHandlers = module.functions.filter((fn) => !!fn.eventHandler && (0, types_1.isEventTypeName)(fn.eventHandler.eventType));
+    const eventTypes = new Set(eventHandlers.map(fn => fn.eventHandler.eventType));
+    const loadCommands = [
+        `scoreboard objectives add ${OBJ} dummy`,
+        ...module.globals.map(g => `scoreboard players set ${alloc.alloc(g.name)} ${OBJ} ${g.init}`),
+        ...Array.from(triggerNames).flatMap(triggerName => [
+            `scoreboard objectives add ${triggerName} trigger`,
+            `scoreboard players enable @a ${triggerName}`,
+        ]),
+        ...Array.from(new Set(module.functions.flatMap(fn => Array.from(collectConsts(fn))))).map(value => `scoreboard players set ${alloc.constant(value)} ${OBJ} ${value}`),
+    ];
+    for (const eventType of eventTypes) {
+        if (eventType === 'PlayerDeath') {
+            loadCommands.push('scoreboard objectives add rs.deaths deathCount');
+        }
+        else if (eventType === 'EntityKill') {
+            loadCommands.push('scoreboard objectives add rs.kills totalKillCount');
+        }
+    }
+    // Call @load functions from __load
+    for (const fn of module.functions) {
+        if (fn.isLoadInit) {
+            loadCommands.push(`function ${module.namespace}:${fn.name}`);
+        }
+    }
+    const sections = [];
+    if (loadCommands.length > 0) {
+        sections.push({
+            name: '__load',
+            commands: loadCommands.map(cmd => ({ cmd })),
+        });
+    }
+    for (const triggerName of triggerNames) {
+        const handlers = triggerHandlers.filter(fn => fn.triggerName === triggerName);
+        sections.push({
+            name: `__trigger_${triggerName}_dispatch`,
+            commands: [
+                ...handlers.map(handler => ({ cmd: `function ${module.namespace}:${handler.name}` })),
+                { cmd: `scoreboard players set @s ${triggerName} 0` },
+                { cmd: `scoreboard players enable @s ${triggerName}` },
+            ],
+        });
+    }
+    for (const fn of module.functions) {
+        if (!fn.commands || fn.commands.length === 0)
+            continue;
+        sections.push({
+            name: fn.name,
+            commands: fn.commands,
+        });
+    }
+    const tickCommands = [];
+    for (const fn of module.functions.filter(candidate => candidate.isTickLoop)) {
+        tickCommands.push({ cmd: `function ${module.namespace}:${fn.name}` });
+    }
+    if (triggerNames.size > 0) {
+        for (const triggerName of triggerNames) {
+            tickCommands.push({
+                cmd: `execute as @a[scores={${triggerName}=1..}] run function ${module.namespace}:__trigger_${triggerName}_dispatch`,
+            });
+        }
+    }
+    if (eventHandlers.length > 0) {
+        for (const eventType of eventTypes) {
+            const tag = types_1.EVENT_TYPES[eventType].tag;
+            const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType);
+            for (const handler of handlers) {
+                tickCommands.push({
+                    cmd: `execute as @a[tag=${tag}] run function ${module.namespace}:${handler.name}`,
+                });
+            }
+            tickCommands.push({
+                cmd: `tag @a[tag=${tag}] remove ${tag}`,
+            });
+        }
+    }
+    if (tickCommands.length > 0) {
+        sections.push({
+            name: '__tick',
+            commands: tickCommands,
+            repeat: true,
+        });
+    }
+    for (const section of sections) {
+        for (let i = 0; i < section.commands.length; i++) {
+            const command = section.commands[i];
+            const state = i === 0
+                ? (section.repeat ? PALETTE_REPEAT : PALETTE_IMPULSE)
+                : (command.conditional ? PALETTE_CHAIN_CONDITIONAL : PALETTE_CHAIN_UNCONDITIONAL);
+            entries.push({
+                functionName: section.name,
+                lineNumber: i + 1,
+                command: command.cmd,
+                conditional: Boolean(command.conditional),
+                state,
+                isRepeat: Boolean(section.repeat && i === 0),
+            });
+        }
+    }
+    return entries;
+}
+function toFunctionName(file) {
+    const match = file.path.match(/^data\/[^/]+\/function\/(.+)\.mcfunction$/);
+    return match?.[1] ?? null;
+}
+function collectCommandEntriesFromFiles(files) {
+    const entries = [];
+    for (const file of files) {
+        const functionName = toFunctionName(file);
+        if (!functionName)
+            continue;
+        const lines = file.content.split('\n');
+        let isFirstCommand = true;
+        const isTickFunction = functionName === '__tick';
+        for (let i = 0; i < lines.length; i++) {
+            const command = lines[i].trim();
+            if (command === '' || command.startsWith('#'))
+                continue;
+            const state = isFirstCommand
+                ? (isTickFunction ? PALETTE_REPEAT : PALETTE_IMPULSE)
+                : PALETTE_CHAIN_UNCONDITIONAL;
+            entries.push({
+                functionName,
+                lineNumber: i + 1,
+                command,
+                conditional: false,
+                state,
+                isRepeat: isTickFunction && isFirstCommand,
+            });
+            isFirstCommand = false;
+        }
+    }
+    return entries;
+}
+function createPaletteTag() {
+    return palette.map(entry => nbt_1.nbt.compound({
+        Name: nbt_1.nbt.string(entry.Name),
+        Properties: nbt_1.nbt.compound(Object.fromEntries(Object.entries(entry.Properties).map(([key, value]) => [key, nbt_1.nbt.string(value)]))),
+    }));
+}
+function createBlockEntityTag(entry) {
+    return nbt_1.nbt.compound({
+        id: nbt_1.nbt.string('minecraft:command_block'),
+        Command: nbt_1.nbt.string(entry.command),
+        auto: nbt_1.nbt.byte(entry.isRepeat ? 1 : 0),
+        powered: nbt_1.nbt.byte(0),
+        conditionMet: nbt_1.nbt.byte(0),
+        UpdateLastExecution: nbt_1.nbt.byte(1),
+        LastExecution: nbt_1.nbt.long(0n),
+        TrackOutput: nbt_1.nbt.byte(1),
+        SuccessCount: nbt_1.nbt.int(0),
+        LastOutput: nbt_1.nbt.string(''),
+        CustomName: nbt_1.nbt.string(`{"text":"${escapeJsonString(`${entry.functionName}:${entry.lineNumber}`)}"}`),
+    });
+}
+function createBlockTag(entry, index) {
+    const x = index % MAX_WIDTH;
+    const z = Math.floor(index / MAX_WIDTH) % MAX_WIDTH;
+    const y = Math.floor(index / (MAX_WIDTH * MAX_WIDTH));
+    return nbt_1.nbt.compound({
+        pos: nbt_1.nbt.list(3 /* TagType.Int */, [nbt_1.nbt.int(x), nbt_1.nbt.int(y), nbt_1.nbt.int(z)]),
+        state: nbt_1.nbt.int(entry.state),
+        nbt: createBlockEntityTag(entry),
+    });
+}
+function generateStructure(input, options) {
+    const entries = Array.isArray(input)
+        ? collectCommandEntriesFromFiles(input)
+        : collectCommandEntriesFromModule(input, options?.mangle);
+    const blockTags = entries.map(createBlockTag);
+    const sizeX = Math.max(1, Math.min(MAX_WIDTH, entries.length || 1));
+    const sizeZ = Math.max(1, Math.min(MAX_WIDTH, Math.ceil(entries.length / MAX_WIDTH) || 1));
+    const sizeY = Math.max(1, Math.ceil(entries.length / (MAX_WIDTH * MAX_WIDTH)) || 1);
+    const root = nbt_1.nbt.compound({
+        DataVersion: nbt_1.nbt.int(DATA_VERSION),
+        size: nbt_1.nbt.list(3 /* TagType.Int */, [nbt_1.nbt.int(sizeX), nbt_1.nbt.int(sizeY), nbt_1.nbt.int(sizeZ)]),
+        palette: nbt_1.nbt.list(10 /* TagType.Compound */, createPaletteTag()),
+        blocks: nbt_1.nbt.list(10 /* TagType.Compound */, blockTags),
+        entities: nbt_1.nbt.list(10 /* TagType.Compound */, []),
+    });
+    return {
+        buffer: (0, nbt_1.writeNbt)(root, ''),
+        blockCount: entries.length,
+        blocks: entries.map(entry => ({
+            command: entry.command,
+            conditional: entry.conditional,
+            state: entry.state,
+            functionName: entry.functionName,
+            lineNumber: entry.lineNumber,
+        })),
+    };
+}
+function compileToStructure(source, namespace, filePath, options = {}) {
+    const preprocessedSource = (0, compile_1.preprocessSource)(source, { filePath });
+    const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
+    const parsedAst = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
+    const dceResult = options.dce ?? true ? (0, dce_1.eliminateDeadCode)(parsedAst) : { program: parsedAst, warnings: [] };
+    const ast = dceResult.program;
+    const ir = new lowering_1.Lowering(namespace).lower(ast);
+    const stats = (0, commands_1.createEmptyOptimizationStats)();
+    const optimizedIRFunctions = ir.functions.map(fn => {
+        const optimized = (0, passes_1.optimizeWithStats)(fn);
+        (0, commands_1.mergeOptimizationStats)(stats, optimized.stats);
+        return optimized.fn;
+    });
+    const structureOptimized = (0, structure_1.optimizeForStructureWithStats)(optimizedIRFunctions, namespace);
+    (0, commands_1.mergeOptimizationStats)(stats, structureOptimized.stats);
+    const optimizedModule = {
+        ...ir,
+        functions: structureOptimized.functions,
+    };
+    return {
+        ...generateStructure(optimizedModule, { mangle: options.mangle }),
+        stats,
+    };
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,45 @@
+/**
+ * VarAllocator — assigns scoreboard fake-player names to variables.
+ *
+ * mangle=true:  sequential short names ($a, $b, ..., $z, $aa, $ab, ...)
+ * mangle=false: legacy names ($<name> for vars, $const_<v> for consts, $p0/$ret for internals)
+ */
+export declare class VarAllocator {
+    private readonly mangle;
+    private seq;
+    private readonly varCache;
+    private readonly constCache;
+    private readonly internalCache;
+    constructor(mangle?: boolean);
+    /** Allocate a name for a user variable. Strips leading '$' if present. */
+    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, ... */
+    private nextSeqName;
+    /**
+     * Returns a sourcemap object mapping allocated name → original name.
+     * Useful for debugging: write to <output>.map.json alongside the datapack.
+     * Only meaningful when mangle=true.
+     */
+    toSourceMap(): Record<string, string>;
+}

package/dist/codegen/var-allocator.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * VarAllocator — assigns scoreboard fake-player names to variables.
+ *
+ * mangle=true:  sequential short names ($a, $b, ..., $z, $aa, $ab, ...)
+ * mangle=false: legacy names ($<name> for vars, $const_<v> for consts, $p0/$ret for internals)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VarAllocator = void 0;
+class VarAllocator {
+    constructor(mangle = true) {
+        this.seq = 0;
+        this.varCache = new Map();
+        this.constCache = new Map();
+        this.internalCache = new Map();
+        this.mangle = mangle;
+    }
+    /** Allocate a name for a user variable. Strips leading '$' if present. */
+    alloc(originalName) {
+        const clean = originalName.startsWith('$') ? originalName.slice(1) : originalName;
+        const cached = this.varCache.get(clean);
+        if (cached)
+            return cached;
+        const name = this.mangle ? `$${this.nextSeqName()}` : `$${clean}`;
+        this.varCache.set(clean, name);
+        return name;
+    }
+    /** Allocate a name for a constant value (content-addressed). */
+    constant(value) {
+        const cached = this.constCache.get(value);
+        if (cached)
+            return cached;
+        const name = this.mangle ? `$${this.nextSeqName()}` : `$const_${value}`;
+        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);
+        if (cached)
+            return cached;
+        const name = this.mangle ? `$${this.nextSeqName()}` : `$${suffix}`;
+        this.internalCache.set(suffix, name);
+        return name;
+    }
+    /** Generate the next sequential name: a, b, ..., z, aa, ab, ..., az, ba, ... */
+    nextSeqName() {
+        const n = this.seq++;
+        let result = '';
+        let remaining = n;
+        do {
+            result = String.fromCharCode(97 + (remaining % 26)) + result;
+            remaining = Math.floor(remaining / 26) - 1;
+        } while (remaining >= 0);
+        return result;
+    }
+    /**
+     * Returns a sourcemap object mapping allocated name → original name.
+     * Useful for debugging: write to <output>.map.json alongside the datapack.
+     * Only meaningful when mangle=true.
+     */
+    toSourceMap() {
+        const map = {};
+        for (const [orig, alloc] of this.varCache) {
+            // Skip compiler-generated temporaries (start with _ followed by digits)
+            if (/^_\d+$/.test(orig))
+                continue;
+            map[alloc] = orig;
+        }
+        for (const [val, alloc] of this.constCache)
+            map[alloc] = `const:${val}`;
+        for (const [suf, alloc] of this.internalCache)
+            map[alloc] = `internal:${suf}`;
+        return map;
+    }
+}
+exports.VarAllocator = VarAllocator;
+//# sourceMappingURL=var-allocator.js.map

package/dist/compile.d.ts

@@ -0,0 +1,68 @@
+/**
+ * RedScript Compile API
+ *
+ * Main compile function with proper error handling and diagnostics.
+ */
+import { DatapackFile } from './codegen/mcfunction';
+import { DiagnosticError } from './diagnostics';
+import type { IRModule } from './ir/types';
+import type { Program } from './ast/types';
+export interface CompileOptions {
+    namespace?: string;
+    filePath?: string;
+    optimize?: boolean;
+    dce?: boolean;
+    mangle?: boolean;
+    /** Scoreboard objective used for all variable slots.
+     *  Defaults to '__<namespace>' (e.g. '__mathshow') — the double-underscore
+     *  prefix signals compiler-internal and avoids occupying the user's namespace.
+     *  Each datapack gets a unique objective automatically; no manual setup needed. */
+    scoreboardObjective?: string;
+    /** 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;
+    files?: DatapackFile[];
+    advancements?: DatapackFile[];
+    ast?: Program;
+    ir?: IRModule;
+    error?: DiagnosticError;
+}
+export interface SourceRange {
+    startLine: number;
+    endLine: number;
+    filePath: string;
+}
+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.
+ * Returns { filePath, line } if a mapping is found, otherwise returns the input unchanged.
+ */
+export declare function resolveSourceLine(combinedLine: number, ranges: SourceRange[], fallbackFile?: string): {
+    filePath?: string;
+    line: number;
+};
+interface PreprocessOptions {
+    filePath?: string;
+    seen?: Set<string>;
+}
+export declare function preprocessSourceWithMetadata(source: string, options?: PreprocessOptions): PreprocessedSource;
+export declare function preprocessSource(source: string, options?: PreprocessOptions): string;
+export declare function compile(source: string, options?: CompileOptions): CompileResult;
+export declare function formatCompileError(result: CompileResult): string;
+export {};

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/capture_the_flag/function/add_to_team.mcfunction

@@ -0,0 +1,5 @@
+scoreboard players operation $add_to_team_t0 __capture_the_flag = $p0 __capture_the_flag
+scoreboard players operation $add_to_team_t1 __capture_the_flag = $p1 __capture_the_flag
+scoreboard players operation $p0 __capture_the_flag = $add_to_team_t0 __capture_the_flag
+scoreboard players operation $p1 __capture_the_flag = $add_to_team_t1 __capture_the_flag
+function capture_the_flag:team_join

package/dist/data/capture_the_flag/function/angry_at.mcfunction

@@ -0,0 +1 @@
+$particle angry_villager $(x) $(y) $(z)

package/dist/data/capture_the_flag/function/assign_teams.mcfunction

@@ -0,0 +1 @@
+execute as @a run function capture_the_flag:assign_teams__foreach_t1

package/dist/data/capture_the_flag/function/assign_teams__foreach_t1.mcfunction

@@ -0,0 +1,8 @@
+scoreboard players operation $assign_teams__foreach_t1_t0 __capture_the_flag = $assign_teams__foreach_t1_t0 __capture_the_flag
+scoreboard players set $__const_2 __capture_the_flag 2
+scoreboard players operation $assign_teams__foreach_t1_t0 __capture_the_flag %= $__const_2 __capture_the_flag
+scoreboard players set $__const_0 __capture_the_flag 0
+scoreboard players set $assign_teams__foreach_t1_t1 __capture_the_flag 0
+execute if score $assign_teams__foreach_t1_t0 __capture_the_flag = $__const_0 __capture_the_flag run scoreboard players set $assign_teams__foreach_t1_t1 __capture_the_flag 1
+execute if score $assign_teams__foreach_t1_t1 __capture_the_flag matches 1 run return run function capture_the_flag:assign_teams__foreach_t1__then_0
+function capture_the_flag:assign_teams__foreach_t1__else_2

package/dist/data/capture_the_flag/function/assign_teams__foreach_t1__else_2.mcfunction

@@ -0,0 +1,8 @@
+scoreboard players set $p0 __capture_the_flag 0
+scoreboard players set $p1 __capture_the_flag 0
+function capture_the_flag:team_join
+scoreboard players set $p0 __capture_the_flag 0
+scoreboard players set $p1 __capture_the_flag 0
+scoreboard players set $p2 __capture_the_flag 2
+function capture_the_flag:scoreboard_set
+function capture_the_flag:assign_teams__foreach_t1__merge_1

package/dist/data/capture_the_flag/function/assign_teams__foreach_t1__merge_1.mcfunction

@@ -0,0 +1,3 @@
+scoreboard players operation $assign_teams__foreach_t1_t12 __capture_the_flag = $assign_teams__foreach_t1_t0 __capture_the_flag
+scoreboard players add $assign_teams__foreach_t1_t12 __capture_the_flag 1
+scoreboard players operation $assign_teams__foreach_t1_t0 __capture_the_flag = $assign_teams__foreach_t1_t12 __capture_the_flag

package/dist/data/capture_the_flag/function/assign_teams__foreach_t1__then_0.mcfunction

@@ -0,0 +1,8 @@
+scoreboard players set $p0 __capture_the_flag 0
+scoreboard players set $p1 __capture_the_flag 0
+function capture_the_flag:team_join
+scoreboard players set $p0 __capture_the_flag 0
+scoreboard players set $p1 __capture_the_flag 0
+scoreboard players set $p2 __capture_the_flag 1
+function capture_the_flag:scoreboard_set
+function capture_the_flag:assign_teams__foreach_t1__merge_1

package/dist/data/capture_the_flag/function/barrier_wall.mcfunction

@@ -0,0 +1 @@
+$fill $(x1) $(y1) $(z1) $(x2) $(y2) $(z2) minecraft:barrier