hzengine-core 0.1.2-dev

package/dist/plugins/basic_command/audio.js

@@ -0,0 +1,40 @@
+import Path from "../../utils/path.js";
+export function audio_command(core) {
+    // play command: play <channel> "<path>"
+    core.script.use((ctx, next) => {
+        if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "play" &&
+            ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "queue")
+            return next();
+        if (ctx.slicedArgs.length !== 3)
+            throw `${ctx.slicedArgs[0].str.toUpperCase()} Command: incorrect amount of args`;
+        if (!ctx.slicedArgs[2].isQuoted)
+            throw `the third arg of ${ctx.slicedArgs[0].str} command should be quoted as string path`;
+        let channel_name = ctx.slicedArgs[1].str;
+        let path = ctx.slicedArgs[2].str;
+        core.debug.log(`Play Command: play ${channel_name} ${path}`);
+        let channel = core.audio.channels[channel_name];
+        if (!channel) {
+            throw `audio channel ${channel_name} not found`;
+        }
+        if (ctx.slicedArgs[0].str !== "queue") {
+            channel.stop();
+        }
+        channel.push({ path: Path.join(core.storage.projectRoot, "audio", path) });
+        channel.play();
+    });
+    // stop command: stop <channel>
+    core.script.use((ctx, next) => {
+        if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "stop") {
+            return next();
+        }
+        if (ctx.slicedArgs.length !== 2) {
+            throw `Stop Command: incorrect amount of args`;
+        }
+        let channel_name = ctx.slicedArgs[1].str;
+        let channel = core.audio.channels[channel_name];
+        if (!channel) {
+            throw `audio channel ${channel_name} not found`;
+        }
+        channel.stop();
+    });
+}

package/dist/plugins/basic_command/basic.js

@@ -0,0 +1,124 @@
+export function basic_commands(core) {
+    // jump command
+    core.script.use((ctx, next) => {
+        let strArr = ctx.rawtext.trim().split(/ +/);
+        if (strArr.length === 0 || strArr[0].toLowerCase() !== "jump")
+            return next();
+        if (strArr.length !== 2)
+            throw "Jump Command: incorrect amount of args";
+        core.debug.log(`Jump Command: jump to label [${strArr[1]}]`);
+        core.script.jumpLabel(strArr[1]);
+    });
+    // call command
+    core.script.use((ctx, next) => {
+        let strArr = ctx.rawtext.trim().split(/ +/);
+        if (strArr.length === 0 || strArr[0].toLowerCase() !== "call")
+            return next();
+        if (strArr.length !== 2)
+            throw "Call Command: incorrect amount of args";
+        core.debug.log(`Call Command: call label [${strArr[1]}]`);
+        core.script.callLabel(strArr[1]);
+    });
+    // return command
+    core.script.use((ctx, next) => {
+        let strArr = ctx.rawtext.trim().split(/ +/);
+        if (strArr.length === 0 || strArr[0].toLowerCase() !== "return")
+            return next();
+        if (strArr.length !== 1)
+            throw "Return Command: this command can not have args";
+        core.debug.log(`Return Command: return`);
+        core.script.return();
+    });
+    // (debug) echo command
+    core.script.use((ctx, next) => {
+        let str = ctx.rawtext.trim();
+        if (!str.startsWith("echo"))
+            return next();
+        core.debug.log(`[ECHO] ${core.script.parseString(str.slice(4).trim())}`);
+    });
+    // say command
+    core.script.use((ctx, next) => {
+        if (!ctx.rawtext.trim().startsWith('"'))
+            return next();
+        function parseSayCommandArgs() {
+            if (ctx.slicedArgs.length > 0 &&
+                ctx.slicedArgs[ctx.slicedArgs.length - 1].str === "nowait") {
+                ctx.slicedArgs = ctx.slicedArgs.slice(0, ctx.slicedArgs.length - 1);
+                return {
+                    wait: false,
+                };
+            }
+            else {
+                return {
+                    wait: true,
+                };
+            }
+        }
+        let parsed = parseSayCommandArgs();
+        if (ctx.slicedArgs.length > 2 || ctx.slicedArgs.length < 1) {
+            throw `Say Command: incorrect amount of args`;
+        }
+        if (ctx.slicedArgs.length === 1) {
+            core.debug.log(`[SAY] ${ctx.slicedArgs[0].str}`);
+            sayAction(core, "", ctx.slicedArgs[0].str, parsed.wait);
+        }
+        else {
+            if (!ctx.slicedArgs[1].isQuoted)
+                throw `Say Command: second arg should be quoted`;
+            core.debug.log(`[SAY] ${ctx.slicedArgs[0].str}: ${ctx.slicedArgs[1].str}`);
+            sayAction(core, ctx.slicedArgs[0].str, ctx.slicedArgs[1].str, parsed.wait);
+        }
+        // if (parsed?.wait) core.system.pause();
+    });
+    // pause command
+    core.script.use((ctx, next) => {
+        if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "pause")
+            return next();
+        if (ctx.slicedArgs.length > 2)
+            throw `Pause Command: incorrect amount of args`;
+        if (ctx.slicedArgs.length === 2) {
+            if (ctx.slicedArgs[1].isQuoted ||
+                !isFinite(Number(ctx.slicedArgs[1].str)))
+                throw `Pause Command: the second arg must be a number`;
+            core.system.pause(Number(ctx.slicedArgs[1].str) * 1000);
+        }
+        else
+            core.system.pause();
+    });
+}
+export function sayAction(core, who, what, wait) {
+    const say_view_tag = "hzengine.say";
+    const say_view_name = "say";
+    what = core.script.parseString(what);
+    let message = {
+        who,
+        what,
+    };
+    let router = core.ui.getRouter(say_view_tag);
+    if (!router) {
+        core.ui.addRouter(say_view_tag, "ct");
+        router = core.ui.getRouter(say_view_tag);
+    }
+    if (!router.length) {
+        // @ts-ignore
+        router.push(say_view_name, message);
+    }
+    else {
+        // @ts-ignore
+        router.update(message);
+    }
+    if (wait) {
+        if (core.config.getConfig("game.autoplay.enable")) {
+            let delay = core.config.getConfig("game.autoplay.extra_delay") +
+                core.config.getConfig("game.autoplay.ms_per_char") *
+                    what.length;
+            if (isNaN(delay) || !isFinite(delay) || delay < 0) {
+                throw `Say Action: AutoPlay Delay Error: ${delay} ms`;
+            }
+            core.system.pause(delay);
+        }
+        else {
+            core.system.pause();
+        }
+    }
+}

package/dist/plugins/basic_command/character.js

@@ -0,0 +1,112 @@
+import { sayAction } from "./basic.js";
+export function character_command(core) {
+    // character command
+    // Used to create a character, and save it to script field in archive storage,
+    // so that it can be used when the archive is loaded next time the game starts
+    // by loading the archive.
+    // syntax: character <short_name> <display_name>
+    // if the short name is conflict with an existing character, the script will throw an error
+    core.script.use((ctx, next) => {
+        if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "character")
+            return next();
+        if (ctx.slicedArgs.length > 3)
+            throw `Character Command: incorrect amount of args`;
+        if (ctx.slicedArgs.length === 1)
+            throw `Character Command: incorrect amount of args`;
+        if (ctx.slicedArgs.length === 2)
+            throw `Character Command: display name not specified`;
+        if (ctx.slicedArgs[1].isQuoted)
+            throw `Character Command: short name should not be quoted`;
+        // Check if the short name is conflict with an existing character
+        let short_name = ctx.slicedArgs[1].str;
+        let characterMap = getCharacterMap();
+        if (characterMap[short_name] != null) {
+            if (characterMap[short_name].declare_info.path === ctx.currentPath &&
+                characterMap[short_name].declare_info.index === ctx.currentLineIndex) {
+            }
+            else
+                throw `Character Command: short name [${short_name}] conflict, at file [${characterMap[short_name].declare_info.path}] line [${characterMap[short_name].declare_info.index + 1}] and `;
+        }
+        else {
+            let display_name = ctx.slicedArgs[2].isQuoted
+                ? core.script.parseString(ctx.slicedArgs[2].str)
+                : ctx.slicedArgs[2].str;
+            characterMap[short_name] = buildCharacterInfo(short_name, display_name);
+        }
+        function buildCharacterInfo(short_name, display_name) {
+            return {
+                short_name,
+                display_name,
+                declare_info: {
+                    path: ctx.currentPath,
+                    index: ctx.currentLineIndex,
+                },
+            };
+        }
+    });
+    function getCharacterMap() {
+        // // Check core.storage.archiveData
+        // if (typeof core.storage.archiveData == null)
+        //   throw `[HZEngine] ArchiveData is null`;
+        // if (typeof core.storage.archiveData != "object")
+        //   throw `[HZEngine] ArchiveData is not a object(Record or Array)`;
+        // if (Array.isArray(core.storage.archiveData))
+        //   throw `[HZEngine] ArchiveData is an Array`;
+        // // Check core.storage.archiveData.script
+        // if (core.storage.archiveData.script == null) {
+        //   console.log(`[HZEngine] ArchiveData.script is null, create it`);
+        //   core.storage.archiveData.script = {};
+        // }
+        // if (typeof core.storage.archiveData.script != "object")
+        //   throw `[HZEngine] ArchiveData.script is not a object(Record or Array)`;
+        // if (Array.isArray(core.storage.archiveData.script))
+        //   throw `[HZEngine] ArchiveData.script is an Array`;
+        // // Check core.storage.archiveData.script.characterMap
+        // if (core.storage.archiveData.script.characterMap == null) {
+        //   console.log(
+        //     `[HZEngine] ArchiveData.script.characterMap is null, create it`
+        //   );
+        //   core.storage.archiveData.script.characterMap = {};
+        // }
+        // if (typeof core.storage.archiveData.script.characterMap != "object")
+        //   throw `[HZEngine] ArchiveData.script.characterMap is not a object(Record or Array)`;
+        // if (Array.isArray(core.storage.archiveData.script.characterMap))
+        //   throw `[HZEngine] ArchiveData.script.characterMap is an Array`;
+        // return core.storage.archiveData.script.characterMap as any; // TODO
+        return core.storage.getSaveableData(core.storage.archiveData, true, "script", "characterMap");
+    }
+    // Gramma: %short_name% "{message}"
+    core.script.use((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted)
+            return next();
+        let characterMap = getCharacterMap();
+        let short_name = ctx.slicedArgs[0].str;
+        for (let key in characterMap) {
+            // console.log(`Character Say Command: key=${key} sn=${short_name}`);
+            function parseSayCommandArgs() {
+                if (ctx.slicedArgs.length > 0 &&
+                    ctx.slicedArgs[ctx.slicedArgs.length - 1].str === "nowait") {
+                    ctx.slicedArgs = ctx.slicedArgs.slice(0, ctx.slicedArgs.length - 1);
+                    return {
+                        wait: false,
+                    };
+                }
+                else {
+                    return {
+                        wait: true,
+                    };
+                }
+            }
+            let parsed = parseSayCommandArgs();
+            if (key === short_name) {
+                if (ctx.slicedArgs.length != 2)
+                    throw `Character Say Command: incorrect amount of args`;
+                console.log("Character Say Command:", short_name, ctx.slicedArgs[1].str);
+                sayAction(core, characterMap[key].display_name, ctx.slicedArgs[1].str, parsed.wait);
+                // if(parsed.wait) core.system.pause();
+                return;
+            }
+        }
+        return next();
+    });
+}

package/dist/plugins/basic_command/conditional.js

@@ -0,0 +1,260 @@
+export function conditional(core) {
+    // if ... [elif] ... [else] ... end if
+    // syntax:
+    // if <expression>
+    // <code>
+    // [elif <expression>]
+    // <code>
+    // [else]
+    // <code>
+    // end if
+    // if statement start
+    core.script.use((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted ||
+            ctx.slicedArgs[0].str.toLowerCase() !== "if") {
+            return next();
+        }
+        let data = ctx.startStatement("if");
+        // console.log(`if data=${JSON.stringify(data)}`);
+        let if_expression_res = core.script.evalExpression(data.if_expression);
+        if (typeof if_expression_res !== "boolean") {
+            throw `If statement: if expression must return boolean, at file [${data.start_position[0]}] line [${data.start_position[1]}]`;
+        }
+        if (if_expression_res) {
+            // continue to execute next line
+            return;
+        }
+        // analyse elif
+        for (let i = 0; i < data.elif_list.length; i++) {
+            let item = data.elif_list[i];
+            let elif_expression_res = core.script.evalExpression(item.expression);
+            if (typeof elif_expression_res !== "boolean") {
+                throw `If statement: elif expression must return boolean, at file [${item.position[0]}] line [${item.position[1]}]`;
+            }
+            if (elif_expression_res) {
+                // jump to next line of elif statement
+                core.script.jump(item.position[0], item.position[1] + 1);
+                return;
+            }
+        }
+        // analyse else
+        if (data.else_position) {
+            core.script.jump(data.else_position[0], data.else_position[1] + 1);
+            return;
+        }
+        // the expressions are all false
+        // jump to the end of if statement
+        core.script.jump(data.end_position[0], data.end_position[1]);
+    });
+    // elif statement
+    // when come across next elif statement, jump to "end if" statement to stop execute.
+    core.script.use((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted ||
+            ctx.slicedArgs[0].str.toLowerCase() !== "elif") {
+            return next();
+        }
+        if (ctx.statementStack.length === 0 ||
+            ctx.statementStack[ctx.statementStack.length - 1][0] !== "if") {
+            throw `If statement: elif statement must come after if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+        }
+        let data = ctx.statementStack[ctx.statementStack.length - 1][2];
+        // check if this elif statement belong to the closest if statement
+        for (let i = 0; i < data.elif_list.length; i++) {
+            let item = data.elif_list[i];
+            if (item.position[0] === ctx.currentPath &&
+                item.position[1] === ctx.currentLineIndex) {
+                // jump to the "end if" statement
+                core.script.jump(data.end_position[0], data.end_position[1]);
+                return;
+            }
+        }
+        // the elif statement is not belong to the closest if statement, so throw error
+        throw `If statement: elif statement not belong to the closest if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    });
+    // else statement
+    core.script.use((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted ||
+            ctx.slicedArgs[0].str.toLowerCase() !== "else") {
+            return next();
+        }
+        if (ctx.statementStack.length === 0 ||
+            ctx.statementStack[ctx.statementStack.length - 1][0] !== "if") {
+            throw `If statement: else statement must come after if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+        }
+        let data = ctx.statementStack[ctx.statementStack.length - 1][2];
+        // check if this else statement belong to the closest if statement
+        if (data.else_position) {
+            if (data.else_position[0] === ctx.currentPath &&
+                data.else_position[1] === ctx.currentLineIndex) {
+                // jump to the "end if" statement
+                core.script.jump(data.end_position[0], data.end_position[1]);
+                return;
+            }
+        }
+        // the else statement is not belong to the closest if statement, so throw error
+        throw `If statement: else statement not belong to the closest if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+    });
+    // end if statement
+    core.script.use((ctx, next) => {
+        if (ctx.rawtext.trim().split(/ +/).join(" ").toLowerCase() !== "end if") {
+            return next();
+        }
+        if (ctx.statementStack.length === 0 ||
+            ctx.statementStack[ctx.statementStack.length - 1][0] !== "if") {
+            throw `If statement: end if statement must come after if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+        }
+        ctx.endStatement("if");
+    });
+    // analyse statement
+    // if statement
+    core.script.useAnalyseStatement((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted ||
+            ctx.slicedArgs[0].str.toLowerCase() !== "if") {
+            return next();
+        }
+        if (ctx.slicedArgs.length < 2) {
+            throw `If statement: no expression specified, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+        }
+        ctx.startStatement("if", {
+            start_position: [ctx.currentPath, ctx.currentLineIndex],
+            if_expression: ctx.rawtext.trim().slice(2).trim(),
+            elif_list: [],
+            else_position: null,
+        });
+    });
+    // elif statement
+    core.script.useAnalyseStatement((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted ||
+            ctx.slicedArgs[0].str.toLowerCase() !== "elif") {
+            return next();
+        }
+        if (ctx.slicedArgs.length < 2) {
+            throw `If statement: no expression specified, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+        }
+        // check if the closest statement is if statement
+        if (ctx.statementStack.length === 0 ||
+            ctx.statementStack[ctx.statementStack.length - 1][0] !== "if") {
+            throw `If statement: elif statement must come after if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+        }
+        let data = ctx.statementStack[ctx.statementStack.length - 1][2];
+        data.elif_list.push({
+            position: [ctx.currentPath, ctx.currentLineIndex],
+            expression: ctx.rawtext.trim().slice(4).trim(),
+        });
+    });
+    // else statement
+    core.script.useAnalyseStatement((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted ||
+            ctx.slicedArgs[0].str.toLowerCase() !== "else") {
+            return next();
+        }
+        // check if the closest statement is if statement
+        if (ctx.statementStack.length === 0 ||
+            ctx.statementStack[ctx.statementStack.length - 1][0] !== "if") {
+            throw `If statement: else statement must come after if statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+        }
+        let data = ctx.statementStack[ctx.statementStack.length - 1][2];
+        data.else_position = [ctx.currentPath, ctx.currentLineIndex];
+    });
+    // end if statement
+    core.script.useAnalyseStatement((ctx, next) => {
+        if (ctx.rawtext.trim().split(/ +/).join(" ").toLowerCase() !== "end if") {
+            return next();
+        }
+        let data = ctx.endStatement("if");
+        data.end_position = [ctx.currentPath, ctx.currentLineIndex];
+        ctx.setStatementData(data, [...data.start_position]);
+    });
+    // while ... end while
+    // while statement start
+    core.script.use((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted ||
+            ctx.slicedArgs[0].str.toLowerCase() !== "while") {
+            return next();
+        }
+        let data = ctx.startStatement("while");
+        // test if expression return boolean
+        let expression = data.while_expression;
+        let expression_res = core.script.evalExpression(expression);
+        if (typeof expression_res !== "boolean") {
+            throw `While statement: while expression must return boolean, at file [${data.start_position[0]}] line [${data.start_position[1]}]`;
+        }
+        if (!expression_res) {
+            ctx.endStatement("while");
+            core.script.jump(...data.end_position, false);
+            core.script.incrementNextPosition();
+        }
+        else {
+            return;
+        }
+    });
+    // while statement end
+    core.script.use((ctx, next) => {
+        if (ctx.rawtext.trim().split(/ +/).join(" ").toLowerCase() !== "end while") {
+            return next();
+        }
+        // check if the closest statement is while statement
+        if (ctx.statementStack.length === 0 ||
+            ctx.statementStack[ctx.statementStack.length - 1][0] !== "while") {
+            throw `While statement: end while statement must come after while statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+        }
+        // jump to while statement start line (loop)
+        let data = ctx.statementStack[ctx.statementStack.length - 1][2];
+        ctx.endStatement("while");
+        core.script.jump(...data.start_position, false);
+    });
+    // analyse while statement start
+    core.script.useAnalyseStatement((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted ||
+            ctx.slicedArgs[0].str.toLowerCase() !== "while") {
+            return next();
+        }
+        let while_expression = ctx.rawtext.trim().slice(5).trim();
+        if (while_expression === "") {
+            throw `While statement: no expression specified, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+        }
+        ctx.startStatement("while", {
+            start_position: [ctx.currentPath, ctx.currentLineIndex],
+            while_expression,
+            end_position: [ctx.currentPath, ctx.currentLineIndex],
+        });
+    });
+    // analyse while statement end
+    core.script.useAnalyseStatement((ctx, next) => {
+        if (ctx.rawtext.trim().split(/ +/).join(" ").toLowerCase() !== "end while") {
+            return next();
+        }
+        let data = ctx.endStatement("while");
+        data.end_position = [ctx.currentPath, ctx.currentLineIndex];
+        ctx.setStatementData(data, [...data.start_position]);
+    });
+    // do ... end do until
+    // break command
+    core.script.use((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted ||
+            ctx.slicedArgs.length !== 1 ||
+            ctx.slicedArgs[0].str.toLowerCase() !== "break") {
+            return next();
+        }
+        // find the closest breakable statement
+        // (currently only while statement is breakable)
+        //(debug) output stack
+        // console.log("Stack="+JSON.stringify(ctx.statementStack));
+        let resIndex = -1;
+        for (let i = ctx.statementStack.length - 1; i >= 0; i--) {
+            if (ctx.statementStack[i][0] === "while") {
+                resIndex = i;
+                break;
+            }
+        }
+        if (resIndex === -1) {
+            throw `Break command: break statement must come after while statement, at file [${ctx.currentPath}] line [${ctx.currentLineIndex}]`;
+        }
+        let data = ctx.statementStack[resIndex][2];
+        core.debug.log(`Break command: break from ${ctx.statementStack[resIndex][0]} statement at file [${data.start_position[0]}] line [${data.start_position[1] + 1}]`);
+        core.script.jump(...data.end_position, false);
+        core.script.incrementNextPosition();
+        // clear statement stack from breakable statement
+        ctx.statementStack.splice(resIndex + 1, ctx.statementStack.length - resIndex - 1);
+    });
+}

package/dist/plugins/basic_command/config.js

@@ -0,0 +1,22 @@
+export function config_command(core) {
+    // set command: set <key> <value>
+    core.script.use((ctx, next) => {
+        if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "set")
+            return next();
+        if (ctx.slicedArgs.length !== 3)
+            throw `Set Command: incorrect amount of args`;
+        let key = ctx.slicedArgs[1].str;
+        let val = ctx.slicedArgs[2].str;
+        if (!ctx.slicedArgs[2].isQuoted) {
+            if (val === "true" || val === "false") {
+                val = val === "true";
+            }
+            else if (!isNaN(val)) {
+                val = Number(val);
+            }
+            else
+                throw `Set Command: value type not supported`;
+        }
+        core.config.setConfig(key, val);
+    });
+}

package/dist/plugins/basic_command/decorator.js

@@ -0,0 +1,24 @@
+import { splitStr2Strs } from "../../script/strtools.js";
+export function decorator_module(core) {
+    core.script.use((ctx, next) => {
+        if (!ctx.slicedArgs[0].isSquared)
+            return next();
+        let decorator = ctx.slicedArgs[0].str.toLowerCase();
+        switch (splitStr2Strs(decorator).join("").toLowerCase()) {
+            case "real=true":
+                core.storage.globalData.realEnv = true;
+                break;
+            case "real":
+                if (!core.storage.globalData.realEnv) {
+                    return;
+                }
+                break;
+            default:
+                core.debug.log(`Decorator: Unknown decorator [${decorator}]`);
+        }
+        ctx.rawtext = ctx.rawtext.trim().slice(ctx.slicedArgs[0].str.length + 2).trim();
+        if (!ctx.rawtext.length)
+            return;
+        return next();
+    }, true);
+}

package/dist/plugins/basic_command/eval.js

@@ -0,0 +1,67 @@
+export function eval_module(core) {
+    // single line eval command
+    // syntax: eval <code>
+    core.script.use((ctx, next) => {
+        if (ctx.slicedArgs[0].isQuoted ||
+            ctx.slicedArgs[0].str.toLowerCase() !== "eval") {
+            return next();
+        }
+        if (ctx.slicedArgs.length === 1) {
+            throw `Eval Command: no code specified`;
+        }
+        if (ctx.slicedArgs.length === 2) {
+            core.script.evalScope(ctx.slicedArgs[1].str);
+        }
+        else {
+            // delete "eval" prefix
+            core.script.evalScope(ctx.rawtext.trim().slice(4).trim());
+        }
+    });
+    // multi line eval statement (script ... end script)
+    // syntax:
+    // script
+    // <code>
+    // end script
+    // script statement start
+    core.script.use((ctx, next) => {
+        if (ctx.rawtext.trim().split(" ")[0] !== "script") {
+            return next();
+        }
+        let data = ctx.startStatement("script");
+        core.script.evalScope(data.js_code_scope);
+        core.script.jump(data.end_position[0], data.end_position[1]);
+    });
+    // script statement end
+    core.script.use((ctx, next) => {
+        if (ctx.rawtext.trim().split(/ +/).join(" ") !== "end script")
+            return next();
+        ctx.endStatement("script");
+    });
+    // analyze script statement start
+    core.script.useAnalyseStatement((ctx, next) => {
+        if (ctx.rawtext.trim().split(" ")[0] !== "script") {
+            return next();
+        }
+        let data = ctx.startStatement("script");
+        data.start_position = [ctx.currentPath, ctx.currentLineIndex];
+        data.js_code_scope = "";
+    });
+    // analyze script code scope/statement end
+    core.script.useAnalyseStatement((ctx, next) => {
+        if (ctx.statementStack.length &&
+            ctx.statementStack[ctx.statementStack.length - 1][0] === "script") {
+            if (ctx.rawtext.trim().split(/ +/).join(" ") === "end script") {
+                // end script
+                let data = ctx.endStatement("script");
+                data.end_position = [ctx.currentPath, ctx.currentLineIndex];
+                ctx.setStatementData(data, [...data.start_position]);
+            }
+            else {
+                // add code line to code scope
+                ctx.statementStack[ctx.statementStack.length - 1][2].js_code_scope += ctx.rawtext.trim() + '\n';
+            }
+        }
+        else
+            return next();
+    }, true);
+}