redscript-mc 1.0.0 → 1.2.0

package/dist/codegen/structure/index.js

@@ -10,6 +10,7 @@ const commands_1 = require("../../optimizer/commands");
 const passes_1 = require("../../optimizer/passes");
 const structure_1 = require("../../optimizer/structure");
 const compile_1 = require("../../compile");
+const types_1 = require("../../events/types");
 const DATA_VERSION = 3953;
 const MAX_WIDTH = 16;
 const OBJ = 'rs';
@@ -62,15 +63,31 @@ function collectCommandEntriesFromModule(module) {
     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(globalName => `scoreboard players set ${varRef(globalName)} ${OBJ} 0`),
+        ...module.globals.map(g => `scoreboard players set ${varRef(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(constSetup),
     ];
+    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({
@@ -108,6 +125,20 @@ function collectCommandEntriesFromModule(module) {
             });
         }
     }
+    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',

package/dist/compile.d.ts

@@ -20,10 +20,20 @@ export interface CompileResult {
     ir?: IRModule;
     error?: DiagnosticError;
 }
+export interface SourceRange {
+    startLine: number;
+    endLine: number;
+    filePath: string;
+}
+export interface PreprocessedSource {
+    source: string;
+    ranges: SourceRange[];
+}
 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;

package/dist/compile.js

@@ -38,6 +38,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessSourceWithMetadata = preprocessSourceWithMetadata;
 exports.preprocessSource = preprocessSource;
 exports.compile = compile;
 exports.formatCompileError = formatCompileError;
@@ -50,7 +51,17 @@ const passes_1 = require("./optimizer/passes");
 const mcfunction_1 = require("./codegen/mcfunction");
 const diagnostics_1 = require("./diagnostics");
 const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/;
-function preprocessSource(source, options = {}) {
+function countLines(source) {
+    return source === '' ? 0 : source.split('\n').length;
+}
+function offsetRanges(ranges, lineOffset) {
+    return ranges.map(range => ({
+        startLine: range.startLine + lineOffset,
+        endLine: range.endLine + lineOffset,
+        filePath: range.filePath,
+    }));
+}
+function preprocessSourceWithMetadata(source, options = {}) {
     const { filePath } = options;
     const seen = options.seen ?? new Set();
     if (filePath) {
@@ -78,7 +89,7 @@ function preprocessSource(source, options = {}) {
                 catch {
                     throw new diagnostics_1.DiagnosticError('ParseError', `Cannot import '${match[1]}'`, { file: filePath, line: i + 1, col: 1 }, lines);
                 }
-                imports.push(preprocessSource(importedSource, { filePath: importPath, seen }));
+                imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }));
             }
             continue;
         }
@@ -89,7 +100,26 @@ function preprocessSource(source, options = {}) {
         parsingHeader = false;
         bodyLines.push(line);
     }
-    return [...imports, bodyLines.join('\n')].filter(Boolean).join('\n');
+    const body = bodyLines.join('\n');
+    const parts = [...imports.map(entry => entry.source), body].filter(Boolean);
+    const combined = parts.join('\n');
+    const ranges = [];
+    let lineOffset = 0;
+    for (const entry of imports) {
+        ranges.push(...offsetRanges(entry.ranges, lineOffset));
+        lineOffset += countLines(entry.source);
+    }
+    if (filePath && body) {
+        ranges.push({
+            startLine: lineOffset + 1,
+            endLine: lineOffset + countLines(body),
+            filePath: path.resolve(filePath),
+        });
+    }
+    return { source: combined, ranges };
+}
+function preprocessSource(source, options = {}) {
+    return preprocessSourceWithMetadata(source, options).source;
 }
 // ---------------------------------------------------------------------------
 // Main Compile Function
@@ -98,14 +128,15 @@ function compile(source, options = {}) {
     const { namespace = 'redscript', filePath, optimize: shouldOptimize = true } = options;
     let sourceLines = source.split('\n');
     try {
-        const preprocessedSource = preprocessSource(source, { filePath });
+        const preprocessed = preprocessSourceWithMetadata(source, { filePath });
+        const preprocessedSource = preprocessed.source;
         sourceLines = preprocessedSource.split('\n');
         // Lexing
         const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
         // Parsing
         const ast = new parser_1.Parser(tokens, preprocessedSource, filePath).parse(namespace);
         // Lowering
-        const ir = new lowering_1.Lowering(namespace).lower(ast);
+        const ir = new lowering_1.Lowering(namespace, preprocessed.ranges).lower(ast);
         // Optimization
         const optimized = shouldOptimize
             ? { ...ir, functions: ir.functions.map(fn => (0, passes_1.optimize)(fn)) }

package/dist/events/types.d.ts

@@ -0,0 +1,35 @@
+import type { TypeNode } from '../ast/types';
+export declare const EVENT_TYPES: {
+    readonly PlayerDeath: {
+        readonly tag: "rs.just_died";
+        readonly params: readonly ["player: Player"];
+        readonly detection: "scoreboard";
+    };
+    readonly PlayerJoin: {
+        readonly tag: "rs.just_joined";
+        readonly params: readonly ["player: Player"];
+        readonly detection: "tag";
+    };
+    readonly BlockBreak: {
+        readonly tag: "rs.just_broke_block";
+        readonly params: readonly ["player: Player", "block: string"];
+        readonly detection: "advancement";
+    };
+    readonly EntityKill: {
+        readonly tag: "rs.just_killed";
+        readonly params: readonly ["player: Player"];
+        readonly detection: "scoreboard";
+    };
+    readonly ItemUse: {
+        readonly tag: "rs.just_used_item";
+        readonly params: readonly ["player: Player"];
+        readonly detection: "scoreboard";
+    };
+};
+export type EventTypeName = keyof typeof EVENT_TYPES;
+export interface EventParamSpec {
+    name: string;
+    type: TypeNode;
+}
+export declare function isEventTypeName(value: string): value is EventTypeName;
+export declare function getEventParamSpecs(eventType: EventTypeName): EventParamSpec[];

package/dist/events/types.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_TYPES = void 0;
+exports.isEventTypeName = isEventTypeName;
+exports.getEventParamSpecs = getEventParamSpecs;
+exports.EVENT_TYPES = {
+    PlayerDeath: {
+        tag: 'rs.just_died',
+        params: ['player: Player'],
+        detection: 'scoreboard',
+    },
+    PlayerJoin: {
+        tag: 'rs.just_joined',
+        params: ['player: Player'],
+        detection: 'tag',
+    },
+    BlockBreak: {
+        tag: 'rs.just_broke_block',
+        params: ['player: Player', 'block: string'],
+        detection: 'advancement',
+    },
+    EntityKill: {
+        tag: 'rs.just_killed',
+        params: ['player: Player'],
+        detection: 'scoreboard',
+    },
+    ItemUse: {
+        tag: 'rs.just_used_item',
+        params: ['player: Player'],
+        detection: 'scoreboard',
+    },
+};
+function isEventTypeName(value) {
+    return value in exports.EVENT_TYPES;
+}
+function getEventParamSpecs(eventType) {
+    return exports.EVENT_TYPES[eventType].params.map(parseEventParam);
+}
+function parseEventParam(spec) {
+    const match = spec.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([A-Za-z_][A-Za-z0-9_]*)$/);
+    if (!match) {
+        throw new Error(`Invalid event parameter spec: ${spec}`);
+    }
+    const [, name, typeName] = match;
+    return {
+        name,
+        type: toTypeNode(typeName),
+    };
+}
+function toTypeNode(typeName) {
+    if (typeName === 'Player') {
+        return { kind: 'entity', entityType: 'Player' };
+    }
+    if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
+        return { kind: 'named', name: typeName };
+    }
+    return { kind: 'struct', name: typeName };
+}
+//# sourceMappingURL=types.js.map

package/dist/formatter/index.d.ts

@@ -0,0 +1 @@
+export declare function format(source: string): string;

package/dist/formatter/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = format;
+function format(source) {
+    const lines = source.split("\n");
+    let indent = 0;
+    const result = [];
+    for (let line of lines) {
+        line = line.trim();
+        if (!line) {
+            result.push("");
+            continue;
+        }
+        // Decrease indent before }
+        if (line.startsWith("}"))
+            indent = Math.max(0, indent - 1);
+        // Add indentation
+        result.push("    ".repeat(indent) + line);
+        // Increase indent after {
+        if (line.endsWith("{"))
+            indent++;
+    }
+    // Ensure single newline at end
+    return result.join("\n").trimEnd() + "\n";
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js

@@ -28,7 +28,8 @@ function compile(source, options = {}) {
     const shouldOptimize = options.optimize ?? true;
     const shouldTypeCheck = options.typeCheck ?? true;
     const filePath = options.filePath;
-    const preprocessedSource = (0, compile_1.preprocessSource)(source, { filePath });
+    const preprocessed = (0, compile_1.preprocessSourceWithMetadata)(source, { filePath });
+    const preprocessedSource = preprocessed.source;
     // Lexing
     const tokens = new lexer_1.Lexer(preprocessedSource, filePath).tokenize();
     // Parsing
@@ -40,7 +41,7 @@ function compile(source, options = {}) {
         typeErrors = checker.check(ast);
     }
     // Lowering to IR
-    const lowering = new lowering_1.Lowering(namespace);
+    const lowering = new lowering_1.Lowering(namespace, preprocessed.ranges);
     const ir = lowering.lower(ast);
     let optimizedIR = ir;
     let generated = (0, mcfunction_1.generateDatapackWithStats)(ir, { optimizeCommands: shouldOptimize });

package/dist/ir/builder.d.ts

@@ -29,4 +29,5 @@ export declare class IRBuilder {
     emitTickYield(continuation: string): void;
     build(name: string, params: string[], isTickLoop?: boolean): IRFunction;
 }
-export declare function buildModule(namespace: string, fns: IRFunction[], globals?: string[]): IRModule;
+import type { GlobalVar } from './types';
+export declare function buildModule(namespace: string, fns: IRFunction[], globals?: GlobalVar[]): IRModule;

package/dist/ir/types.d.ts

@@ -8,7 +8,7 @@
  *   - Integer vars  → scoreboard fake player  ($name on objective "rs_vars")
  *   - Complex data  → NBT storage             (redscript:stack / redscript:heap)
  *   - Return value  → fake player $ret
- *   - Temporaries   → $t0, $t1, ...
+ *   - Temporaries   → $_0, $_1, ...
  */
 export type Operand = {
     kind: 'var';
@@ -103,15 +103,24 @@ export interface IRFunction {
     blocks: IRBlock[];
     commands?: IRCommand[];
     isTickLoop?: boolean;
+    isLoadInit?: boolean;
     isTriggerHandler?: boolean;
     triggerName?: string;
     eventTrigger?: {
         kind: 'advancement' | 'craft' | 'death' | 'login' | 'join_team';
         value?: string;
     };
+    eventHandler?: {
+        eventType: string;
+        tag: string;
+    };
+}
+export interface GlobalVar {
+    name: string;
+    init: number;
 }
 export interface IRModule {
     namespace: string;
     functions: IRFunction[];
-    globals: string[];
+    globals: GlobalVar[];
 }

package/dist/ir/types.js

@@ -9,7 +9,7 @@
  *   - Integer vars  → scoreboard fake player  ($name on objective "rs_vars")
  *   - Complex data  → NBT storage             (redscript:stack / redscript:heap)
  *   - Return value  → fake player $ret
- *   - Temporaries   → $t0, $t1, ...
+ *   - Temporaries   → $_0, $_1, ...
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=types.js.map

package/dist/lexer/index.d.ts

@@ -5,7 +5,7 @@
  * Handles special cases like entity selectors vs decorators,
  * range literals, and raw commands.
  */
-export type TokenKind = 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match' | 'return' | 'as' | 'at' | 'in' | 'struct' | 'enum' | 'trigger' | 'namespace' | 'execute' | 'run' | 'unless' | 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'true' | 'false' | 'selector' | 'decorator' | 'int_lit' | 'float_lit' | 'byte_lit' | 'short_lit' | 'long_lit' | 'double_lit' | 'string_lit' | 'range_lit' | '+' | '-' | '*' | '/' | '%' | '~' | '^' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||' | '!' | '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '{' | '}' | '(' | ')' | '[' | ']' | ',' | ';' | ':' | '::' | '->' | '=>' | '.' | 'ident' | 'mc_name' | 'raw_cmd' | 'eof';
+export type TokenKind = 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match' | 'return' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace' | 'execute' | 'run' | 'unless' | 'int' | 'bool' | 'float' | 'string' | 'void' | 'BlockPos' | 'true' | 'false' | 'selector' | 'decorator' | 'int_lit' | 'float_lit' | 'byte_lit' | 'short_lit' | 'long_lit' | 'double_lit' | 'string_lit' | 'range_lit' | '+' | '-' | '*' | '/' | '%' | '~' | '^' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||' | '!' | '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '{' | '}' | '(' | ')' | '[' | ']' | ',' | ';' | ':' | '::' | '->' | '=>' | '.' | 'ident' | 'mc_name' | 'raw_cmd' | 'eof';
 export interface Token {
     kind: TokenKind;
     value: string;

package/dist/lexer/index.js

@@ -26,7 +26,9 @@ const KEYWORDS = {
     as: 'as',
     at: 'at',
     in: 'in',
+    is: 'is',
     struct: 'struct',
+    impl: 'impl',
     enum: 'enum',
     trigger: 'trigger',
     namespace: 'namespace',

package/dist/lowering/index.d.ts

@@ -5,6 +5,7 @@
  * Handles control flow, function extraction for foreach, and builtin calls.
  */
 import type { IRModule } from '../ir/types';
+import type { SourceRange } from '../compile';
 import type { Program } from '../ast/types';
 export interface Warning {
     message: string;
@@ -14,17 +15,25 @@ export interface Warning {
 }
 export declare class Lowering {
     private namespace;
+    private readonly sourceRanges;
     private functions;
     private globals;
+    private globalNames;
     private fnDecls;
+    private implMethods;
     private specializedFunctions;
     private currentFn;
+    private currentStdlibCallSite?;
     private foreachCounter;
     private lambdaCounter;
+    private timeoutCounter;
+    private intervalCounter;
     readonly warnings: Warning[];
     private builder;
     private varMap;
     private lambdaBindings;
+    private intervalBindings;
+    private intervalFunctions;
     private currentCallbackBindings;
     private currentContext;
     private blockPosVars;
@@ -36,7 +45,7 @@ export declare class Lowering {
     private varTypes;
     private floatVars;
     private worldObjCounter;
-    constructor(namespace: string);
+    constructor(namespace: string, sourceRanges?: SourceRange[]);
     lower(program: Program): IRModule;
     private lowerFn;
     private getTickRate;
@@ -46,6 +55,7 @@ export declare class Lowering {
     private lowerLetStmt;
     private lowerReturnStmt;
     private lowerIfStmt;
+    private lowerIsCheckIfStmt;
     private lowerWhileStmt;
     private lowerForStmt;
     private lowerForRangeStmt;
@@ -66,32 +76,55 @@ export declare class Lowering {
     private lowerUnaryExpr;
     private lowerAssignExpr;
     private lowerCallExpr;
+    private lowerStaticCallExpr;
     private lowerInvokeExpr;
     private inlineLambdaInvoke;
     private emitDirectFunctionCall;
+    private emitMethodCall;
     private resolveFunctionRefExpr;
     private resolveFunctionRefByName;
     private ensureSpecializedFunction;
+    private ensureSpecializedFunctionWithContext;
     private lowerLambdaExpr;
     private withSavedFunctionState;
     private lowerBuiltinCall;
+    private lowerSetTimeout;
+    private lowerSetInterval;
+    private lowerClearInterval;
+    private lowerNamedLambdaFunction;
+    private lowerIntervalWrapperFunction;
+    private resolveIntervalFunctionName;
     private lowerRichTextBuiltin;
     private getRichTextArgIndex;
     private buildRichTextJson;
     private appendRichTextExpr;
     private exprToString;
+    private exprToEntitySelector;
+    private appendTypeFilter;
+    private exprToSnbt;
     private exprToTargetString;
     private exprToLiteral;
     private exprToQuotedString;
     private exprToTextComponent;
     private exprToBoolString;
     private isTeamTextOption;
+    private exprToScoreboardObjective;
+    private resolveScoreboardObjective;
+    private getObjectiveNamespace;
+    private tryGetStdlibInternalObjective;
+    private getStdlibInternalResourceBase;
+    private getStdlibCallSiteContext;
+    private serializeCallSite;
+    private shortHash;
+    private isStdlibFile;
+    private filePathForSpan;
     private lowerCoordinateBuiltin;
     private lowerTpCommand;
     private resolveBlockPosExpr;
     private getArrayStorageName;
     private inferLambdaReturnType;
     private inferExprType;
+    private resolveInstanceMethod;
     private normalizeType;
     private readArrayElement;
     private emitRawSubFunction;