hzengine-core 0.1.2-dev

package/src/plugins/basic_command/config.ts

@@ -0,0 +1,29 @@
+import { HZEngineCore } from "../../index.js";
+import Path from "../../utils/path.js";
+
+export function config_command(core: HZEngineCore) {
+  // 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: any = 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/src/plugins/basic_command/decorator.ts

@@ -0,0 +1,29 @@
+import { HZEngineCore } from "../../index.js";
+import { splitStr2Objs, splitStr2Strs } from "../../script/strtools.js";
+
+export function decorator_module(core: HZEngineCore) {
+  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 as any).realEnv = true;
+        break;
+      case "real":
+        if (!(core.storage.globalData as any).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/src/plugins/basic_command/eval.ts

@@ -0,0 +1,88 @@
+import { HZEngineCore } from "../../index.js";
+
+export function eval_module(core: HZEngineCore) {
+  // 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") as unknown as ScriptStatementData;
+    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") as unknown as ScriptStatementData;
+    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") as unknown as ScriptStatementData;
+        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] as unknown as ScriptStatementData
+        ).js_code_scope += ctx.rawtext.trim() + '\n';
+      }
+    } else return next();
+  }, true);
+}
+
+// eval a()
+// eval"a()"
+// eval "a()"
+
+interface ScriptStatementData {
+  start_position: [path: string, index: number];
+  end_position: [path: string, index: number];
+  js_code_scope: string;
+}

package/src/plugins/basic_command/img.ts

@@ -0,0 +1,317 @@
+// / <reference types="@zeppos/device-types" />
+// import hmUI from "@zos/ui";
+import { Async, HZEngineCore, Script, TransformPlugin, UI } from "../../index.js";
+
+export function img(core: HZEngineCore) {
+  let transform_plugin: TransformPlugin.InstanceType = core.plugins.get(
+    "transform"
+  ) as any;
+  if (!transform_plugin)
+    core.debug.log("[IMG Plugin] Info: Transform plugin not set up");
+  // show command
+  core.script.use((ctx, next) => {
+    if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "show")
+      return next();
+    if (ctx.slicedArgs.length === 1)
+      throw `Show Command: incorrect amount of args`;
+    if (ctx.slicedArgs.length === 2)
+      throw `Show Command: incorrect amount of args`;
+    let parsedRes = parseImgCommandFields(ctx);
+
+    // update args to no fields
+    ctx.slicedArgs = parsedRes.leftedArgs;
+    let tag = ctx.slicedArgs[1].str;
+    let name_key = "";
+    for (let i = 1; i < ctx.slicedArgs.length; ++i) {
+      name_key += ctx.slicedArgs[i].str + " ";
+    }
+    name_key = name_key.trim().toLowerCase();
+    let path = core.storage.preloadedData.image.nameMap[name_key]?.[0];
+    if (!path)
+      throw `Show Command: image with name_key [${name_key}] not found `;
+    // let size = (hmUI as any).getImageInfo(path);
+    let size = core.platform.getImageInfo(path);
+    console.log(`IMG: path: ${path}, size: ${JSON.stringify(size)}`);
+    
+    if (!size) throw `Show Command: read size of [${path}] failed`;
+    showAction(tag, path, size, parsedRes.strategy);
+  });
+
+  function showAction(
+    tag: string,
+    path: string,
+    size: UI.Size,
+    routerStrategy: UI.Router.RouteStrategy | null
+  ) {
+    const show_view_tag_prefix = "hzengine.img";
+    const show_view_name = "fg_img";
+    let prop: UI.FgImgViewProp = {
+      imgPath: path,
+      offset: {
+        x: 0,
+        y: 0,
+      },
+      size: {
+        width: size.width,
+        height: size.height,
+      },
+    };
+
+    let tag_prefixed = `${show_view_tag_prefix}.${tag}`;
+    let router = core.ui.getRouter(tag_prefixed);
+    if (!router) {
+      core.ui.addRouter(tag_prefixed, "fg");
+      router = core.ui.getRouter(tag_prefixed)!;
+    }
+    Async.nextTick(() => {
+    // @ts-ignore
+      router.replace<UI.FgImgViewProp>(
+        show_view_name,
+        prop,
+        routerStrategy ?? undefined
+      );
+    });
+  }
+
+  // hide command
+  core.script.use((ctx, next) => {
+    if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "hide")
+      return next();
+    let parsedRes = parseImgCommandFields(ctx);
+    ctx.slicedArgs = parsedRes.leftedArgs;
+    if (ctx.slicedArgs.length !== 2) {
+      throw `Hide Command: incorrect amount of args`;
+    }
+    let tag = ctx.slicedArgs[1].str;
+
+    hideAction(tag, parsedRes.strategy);
+  });
+
+  function hideAction(
+    tag: string,
+    routerStrategy: UI.Router.RouteStrategy | null
+  ) {
+    const show_view_tag_prefix = "hzengine.img";
+
+    let tag_prefixed = `${show_view_tag_prefix}.${tag}`;
+    let router = core.ui.getRouter(tag_prefixed);
+    if (!router) {
+      throw `Hide Command: router with tag [${tag}] not found `;
+    }
+    Async.nextTick(() => {
+      router.clear(routerStrategy ?? undefined);
+    });
+  }
+
+  // scene command
+  core.script.use((ctx, next) => {
+    if (ctx.rawtext.trim().split(" ")[0].toLowerCase() !== "scene")
+      return next();
+    if (ctx.slicedArgs.length === 1)
+      throw `Scene Command: incorrect amount of args`;
+    if (ctx.slicedArgs.length === 2)
+      throw `Scene Command: incorrect amount of args`;
+    let parsedRes = parseImgCommandFields(ctx);
+
+    // update args to no fields
+    ctx.slicedArgs = parsedRes.leftedArgs;
+
+    let tag = ctx.slicedArgs[1].str;
+    let name_key = "";
+    for (let i = 1; i < ctx.slicedArgs.length; ++i) {
+      name_key += ctx.slicedArgs[i].str + " ";
+    }
+    name_key = name_key.trim().toLowerCase();
+    let path = core.storage.preloadedData.image.nameMap[name_key]?.[0];
+    if (!path)
+      throw `Scene Command: image with name_key [${name_key}] not found `;
+    // let size = (hmUI as any).getImageInfo(path);
+    let size = core.platform.getImageInfo(path);
+    if (!size) throw `Scene Command: read size of [${path}] failed`;
+
+    sceneAction(tag, path, size, parsedRes.strategy);
+  });
+
+  function sceneAction(
+    tag: string,
+    path: string,
+    size: UI.Size,
+    routerStrategy: UI.Router.RouteStrategy | null
+  ) {
+    const scene_view_tag_prefix = "hzengine.img";
+    const scene_view_name = "bg_img";
+    let prop: UI.BgImgViewProp = {
+      imgPath: path,
+      offset: {
+        x: 0,
+        y: 0,
+      },
+      size: {
+        width: size.width,
+        height: size.height,
+      },
+    };
+
+    let tag_prefixed = `${scene_view_tag_prefix}.${tag}`;
+    let router = core.ui.getRouter(tag_prefixed);
+    if (!router) {
+      core.ui.addRouter(tag_prefixed, "bg");
+      router = core.ui.getRouter(tag_prefixed)!;
+    }
+    if (!router.length) {
+    // @ts-ignore
+      Async.nextTick(() => {
+    // @ts-ignore
+        router.push<UI.BgImgViewProp>(
+          scene_view_name,
+          prop,
+          routerStrategy ?? undefined
+        );
+      });
+    } else {
+    // @ts-ignore
+      Async.nextTick(() => {
+    // @ts-ignore
+    router.update<UI.BgImgViewProp>(prop, routerStrategy ?? undefined);
+      });
+    }
+  }
+
+  // with
+  // at
+  // wait
+  // nowait
+
+  function parseImgCommandFields(ctx: Script.Context): ParsedImgCommandFields {
+    let slicedArgs: typeof ctx.slicedArgs = JSON.parse(
+      JSON.stringify(ctx.slicedArgs)
+    ); // TODO 深拷贝 性能
+
+    // TODO 注意这里的代码超级高耦合
+    let res: ReturnType<typeof parseImgCommandFields> = {
+      strategy: null,
+      wait: false,
+      leftedArgs: slicedArgs,
+    };
+
+    // wait/nowait
+    if (slicedArgs[slicedArgs.length - 1].str === "wait") {
+      res.wait = true;
+      slicedArgs.pop();
+    } else if (slicedArgs[slicedArgs.length - 1].str === "nowait") {
+      res.wait = false;
+      slicedArgs.pop();
+    }
+
+    // parse long fields
+    let keywords = ["with", "at"];
+    let inTransforms: string[] = [];
+    let outTransforms: string[] = [];
+    while (true) {
+      // console.log(`slicedArgs: ${JSON.stringify(slicedArgs)}`);
+
+      let keyword_index = findLastIndex(
+        slicedArgs,
+        (slicedArg) =>
+          !slicedArg.isQuoted &&
+          !slicedArg.isSquared &&
+          keywords.includes(slicedArg.str)
+      );
+      if (keyword_index === -1) break;
+      let keyword = slicedArgs[keyword_index].str;
+      let currentFieldArgs = slicedArgs.splice(
+        keyword_index,
+        slicedArgs.length - keyword_index
+      );
+      currentFieldArgs.shift();
+
+      if (keyword === "at") {
+        inTransforms.push(
+          ...Script.Utils.splitCommas(
+            Script.Utils.joinSlicedArgs(currentFieldArgs)
+          )
+        );
+      } else if (keyword === "with") {
+        let args = Script.Utils.parseHzsArgs(
+          Script.Utils.joinSlicedArgs(currentFieldArgs)
+        );
+        // console.log(`with args: ${JSON.stringify(args)}`);
+
+        for (let i = 0; i < args.length; i++) {
+          if (Array.isArray(args[i])) {
+            // Annoymous Transition Tuple
+            if (args[i].length > 2)
+              throw `Invalid Annoymous Transition Tuple: ${JSON.stringify(
+                args[i]
+              )}`;
+            console.log(
+              `Annoymous Transition Tuple: ${JSON.stringify(args[i])}`
+            );
+
+            if (args[i].length >= 1) {
+              if (Array.isArray(args[i][0])) {
+                outTransforms.push(...(args[i][0] as string[]));
+              } else {
+                outTransforms.push(args[i][0] as string);
+              }
+            }
+
+            if (args[i].length >= 2) {
+              if (Array.isArray(args[i][1])) {
+                inTransforms.push(...(args[i][1] as string[]));
+              } else {
+                inTransforms.push(args[i][1] as string);
+              }
+            }
+          } else {
+            // Named Transition
+            let transition = transform_plugin.getTransition(args[i] as string);
+            if (!transition) {
+              core.debug.log(`Transition ${args[i]} not found`);
+              continue;
+            } else {
+              core.debug.log(
+                `Transition ${args[i]} = ${JSON.stringify(transition)}`
+              );
+              inTransforms.push(...transition.inTransforms);
+              outTransforms.push(...transition.outTransforms);
+            }
+          }
+        }
+      }
+    }
+    // let withField: WithField = {
+    //   outTransform: ctx.slicedArgs[withIndex + 1]?.str ?? null,
+    //   inTransform: ctx.slicedArgs[withIndex + 2]?.str ?? null,
+    // };
+    res.strategy = transform_plugin.createStrategy(
+      outTransforms.length ? outTransforms : null,
+      inTransforms.length ? inTransforms : null
+    );
+    return res;
+  }
+
+  function findLastIndex<T>(array: T[], predicator: (value: T) => boolean) {
+    for (let i = array.length - 1; i >= 0; i--) {
+      if (predicator(array[i])) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  const slicedArgsToTransforms = (slicedArgs: Script.Context.SlicedArg[]) =>
+    Script.Utils.joinSlicedArgs(slicedArgs)
+      .split(",")
+      .map((str) => str.trim())
+      .filter((str) => str.length > 0);
+
+  type ParsedImgCommandFields = {
+    strategy: UI.Router.RouteStrategy | null;
+    wait: boolean;
+    leftedArgs: Script.Context.SlicedArg[];
+  };
+  //   type WithField = {
+  //     inTransform: string | null;
+  //     outTransform: string | null;
+  //   };
+}

package/src/plugins/basic_command/index.ts

@@ -0,0 +1,24 @@
+import { HZEngineCore, UI } from "../../index.js";
+import { $_command } from "./$.js";
+import { audio_command } from "./audio.js";
+import { basic_commands } from "./basic.js";
+import { character_command } from "./character.js";
+import { conditional } from "./conditional.js";
+import { config_command } from "./config.js";
+import { decorator_module } from "./decorator.js";
+import { eval_module } from "./eval.js";
+import { img } from "./img.js";
+import { menu_statement } from "./menu.js";
+
+export function basic_command(core: HZEngineCore) {
+  basic_commands(core);
+  character_command(core);
+  menu_statement(core);
+  decorator_module(core);
+  $_command(core);
+  eval_module(core);
+  conditional(core);
+  img(core);
+  audio_command(core);
+  config_command(core);
+}

package/src/plugins/basic_command/menu.ts

@@ -0,0 +1,178 @@
+import { HZEngineCore, UI } from "../../index.js";
+
+export function menu_statement(core: HZEngineCore) {
+  // menu statement start
+  core.script.use((ctx, next) => {
+    if (ctx.rawtext.trim().split(" ")[0] !== "menu") return next();
+    let menu_data = ctx.startStatement("menu") as unknown as MenuStatementData;
+
+    // Block the game
+    core.system.block();
+
+    let router = core.ui.getRouter("menu");
+
+    if (!router) {
+      core.ui.addRouter("menu", "ct");
+      router = core.ui.getRouter("menu")!;
+    }
+
+    let menu_view_prop = buildMenuViewProp(menu_data);
+    if (!router.length) {
+      router.push("menu", menu_view_prop);
+    } else {
+      router.update(menu_view_prop);
+    }
+    // the view contains many buttons, when the button is clicked,
+    // it will call core.script.jump() to jump to the next line of the @label statement
+    // then hide the menu
+    // so the script will continue to execute the next line of the @label statement
+    // when a @label is appended again, it represents the command between the @label and the next @label
+    // is executed completely, so jump to the next line of "end menu"
+  });
+
+  // menu statement close
+  core.script.use((ctx, next) => {
+    if (ctx.rawtext.trim().split(/ +/).join(" ") !== "end menu") return next();
+
+    ctx.endStatement("menu");
+  });
+
+  // menu internal label (start with @)
+  // syntax: @"{label_name}" [enable={js_expression}]
+  core.script.use((ctx, next) => {
+    if (!ctx.rawtext.trim().split(" ")[0].startsWith("@")) return next();
+    let label_name = ctx.slicedArgs[1].str;
+    if (
+      ctx.statementStack.length === 0 ||
+      ctx.statementStack[ctx.statementStack.length - 1][0] !== "menu"
+    ) {
+      throw `@${label_name} must in menu statement`;
+    }
+    let menu_item = ctx.statementStack[ctx.statementStack.length - 1];
+
+    let menu_data = menu_item[2] as unknown as MenuStatementData;
+
+    for (let i = 0; i < menu_data.item_list.length; i++) {
+      if (
+        menu_data.item_list[i].position[0] === ctx.currentPath &&
+        menu_data.item_list[i].position[1] === ctx.currentLineIndex
+      ) {
+        // the label belongs to this menu statement
+        // so jump to the "end menu" statement
+        // the script will continue from the "end menu" statement
+
+        // get the end menu statement position
+        let end_menu_position: [path: string, index: number] = [
+          ...menu_data.end_position,
+        ];
+
+        // jump to "end menu"
+        core.script.jump(end_menu_position[0], end_menu_position[1]);
+        return;
+      }
+    }
+
+    // the label does not belong to this menu statement, so throw error
+    throw `@${label_name} does not belong to closest menu statement, at file [${
+      ctx.currentPath
+    }] line [${ctx.currentLineIndex + 1}], but belong to [${
+      menu_item[1][0]
+    }] line [${menu_item[1][1] + 1}]`;
+  });
+
+  // analyse menu start statement
+  core.script.useAnalyseStatement((ctx, next) => {
+    if (ctx.rawtext.trim().split(" ")[0] !== "menu") return next();
+    let data = ctx.startStatement("menu");
+
+    // console.log("[HZEngine] Menu start");
+
+    // the data here is {} at first, so dont read its properties, because the properties are not defined yet
+    // we will define the properties here
+    (data as unknown as MenuStatementData).start_position = [
+      ctx.currentPath,
+      ctx.currentLineIndex,
+    ];
+    (data as unknown as MenuStatementData).item_list = [];
+  });
+
+  // analyse menu label (start with @)
+  core.script.useAnalyseStatement((ctx, next) => {
+    if (!ctx.rawtext.trim().split(" ")[0].startsWith("@")) return next();
+    if (
+      ctx.statementStack.length === 0 ||
+      ctx.statementStack[ctx.statementStack.length - 1][0] !== "menu"
+    ) {
+      throw `@${ctx.slicedArgs[1]} must in menu statement`;
+    }
+
+    // console.log("[HZEngine] Menu label: " + ctx.slicedArgs[1].str);
+
+    let menu_stack_item = ctx.statementStack[ctx.statementStack.length - 1];
+
+    // parse the enable js expression (syntax: enable={js_expression})
+    // get the js_expression and put it in the menu data
+    let enable_js_expression: string | undefined = undefined;
+    if (ctx.slicedArgs.length > 2) {
+      enable_js_expression = ctx.slicedArgs[2].str!;
+
+      if (!enable_js_expression.startsWith("enable=")) {
+        throw `enable js expression must start with "enable="`;
+      }
+      enable_js_expression = enable_js_expression.slice(7);
+      if (
+        enable_js_expression.startsWith("{") &&
+        enable_js_expression.endsWith("}")
+      ) {
+        enable_js_expression = enable_js_expression.slice(1, -1);
+      } else {
+        enable_js_expression = enable_js_expression.trim();
+      }
+
+      if (enable_js_expression.length > 0) {
+        enable_js_expression = `(${enable_js_expression})`;
+      } else {
+        throw `enable js expression must not be empty`;
+      }
+    }
+
+    (menu_stack_item[2] as unknown as MenuStatementData).item_list.push({
+      text: ctx.slicedArgs[1].str,
+      position: [ctx.currentPath, ctx.currentLineIndex],
+      enable_js_expression,
+    });
+  });
+
+  // analyse menu end statement
+  core.script.useAnalyseStatement((ctx, next) => {
+    if (ctx.rawtext.trim().split(/ +/).join(" ") !== "end menu") return next();
+    // console.log("[HZEngine] Menu analyse end");
+
+    let data: MenuStatementData = ctx.endStatement(
+      "menu"
+    ) as unknown as MenuStatementData;
+    // the data here is {} at first, so dont read its properties, because the properties are not defined yet
+    // we will define the properties here
+    data.end_position = [ctx.currentPath, ctx.currentLineIndex];
+    // set and save the menu data
+    ctx.setStatementData(data, [
+      data.start_position[0],
+      data.start_position[1],
+    ]);
+  });
+
+  function buildMenuViewProp(menu_data: MenuStatementData): UI.MenuViewProp {
+    // parse menu item string
+    let parsed_item_list: UI.MenuItemData[] = [];
+    for (let item of menu_data.item_list) {
+      parsed_item_list.push({ ...item, text: core.script.parseString(item.text) });
+    }
+    return { itemList: parsed_item_list };
+  }
+}
+
+interface MenuStatementData {
+  start_position: [path: string, index: number];
+  end_position: [path: string, index: number];
+  item_list: UI.MenuItemData[];
+}

package/src/plugins/global_gesture/index.ts

@@ -0,0 +1,29 @@
+// import hmUI from "@zos/ui";
+import { HZEngineCore, UI } from "../../index.js";
+import { System } from "../../system/index.js";
+
+export function global_gesture(core: HZEngineCore) {
+  function addTouchPad(layerInstance: UI.Layer<any>) {
+    // TODO touch pad
+    core.debug.log("[TouchPad] Not implemented");
+    // let touchPad = layerInstance.widgetFactory.createWidget(hmUI.widget.TEXT, {
+    //   x: 0,
+    //   y: 0,
+    //   w: 600,
+    //   h: 600,
+    //   text: "",
+    // });
+
+    // touchPad.addEventListener(hmUI.event.SELECT, (info: any) => {
+    //   console.log("按下了屏幕");
+    //   if (core.system.condition === System.Condition.Pause) {
+    //     core.system.continue();
+    //   }
+    // });
+  }
+  addTouchPad(core.ui.getLayer("ct")!);
+  core.on("afterAddLayer", (layerInstance: UI.Layer<any>) => {
+    if (layerInstance.name !== "ct") return;
+    addTouchPad(layerInstance);
+  });
+}