hzengine-core 0.1.2-dev

package/src/async/zeppos_timer.js

@@ -0,0 +1,65 @@
+/**
+ * zeppos-timer.js
+ * @description An accurate timer for ZeppOS. 一个适用于ZeppOS的准确的计时器
+ * @version 1.0.0
+ * @date 2023/04/07
+ * @author XiaomaiTX
+ * @license MIT
+ * https://github.com/XiaomaiTX/zeppos-timer
+ *
+ * */
+import { Time } from "@zos/sensor";
+
+export class ZeppTimer {
+    constructor(callback, interval) {
+        this.callback = callback;
+        this.interval = interval;
+        this.timerId = null;
+        this.startTime = null;
+        this.nextTick = null;
+        this.time = new Time();
+        this.stopped = false
+    }
+
+    start(delay = 0) {
+        this.startTime = this.time.getTime() + delay;
+        this.nextTick = this.startTime + this.interval;
+        this.scheduleTick();
+    }
+
+    stop() {
+        this.timerId && clearTimeout(this.timerId);
+        this.stopped = true
+    }
+
+    scheduleTick() {
+        if(this.stopped) return
+        const currentTime = this.time.getTime();
+        const delay = Math.max(0, this.nextTick - currentTime);
+        this.timerId = setTimeout(() => {
+            this.timerId = null
+            this.tick();
+        }, delay);
+    }
+
+    tick() {
+        const currentTime = this.time.getTime();
+
+        // 计算误差，确保计时器的准确性
+        const error = currentTime - this.nextTick;
+
+        if (error > this.interval) {
+            // 如果误差大于一个间隔时间，则将 nextTick 更新为当前时间
+            this.nextTick = currentTime;
+        } else {
+            // 否则将 nextTick 加上一个间隔时间
+            this.nextTick += this.interval;
+        }
+
+        // 调用回调函数
+        this.callback();
+
+        // 继续调度下一个 tick
+        this.scheduleTick();
+    }
+}

package/src/audio/index.ts

@@ -0,0 +1,224 @@
+// / <reference path="./zos_media.d.ts" />
+// import { create, id } from "@zos/media";
+import { CustomSave, Save } from "../storage/decorator.js";
+import { HZEngineCore } from "../index.js";
+
+import { Platform } from "../platform/index.js";
+
+export class Audio {
+  // static _hmPlayer = create(id.PLAYER);
+
+  constructor(public _core: HZEngineCore) {
+    this._channels["audio"] = new Audio.Channel(this);
+  }
+
+  @CustomSave(
+    "audio.channels",
+    function (channels) {
+      let res = <Record<string, Audio.Channel.Serialized>>{};
+      for (let key in channels) {
+        res[key] = channels[key].serialize();
+      }
+      return res;
+    },
+    function (serialized) {
+      // clear exist channels
+      for (let key in this._channels) {
+        this._channels[key].stop();
+        this._channels[key].onRelease();
+      }
+
+      let res = <Record<string, Audio.Channel>>{};
+      for (let key in serialized) {
+        res[key] = Audio.Channel.deserialize(this, serialized[key]);
+      }
+      return res;
+    }
+  )
+  private accessor _channels: Record<string, Audio.Channel> = {};
+  get channels() {
+    return this._channels;
+  }
+
+  createChannel(name: string): Audio.Channel {
+    // TODO support more audio channels
+    if (Object.getOwnPropertyNames(this._channels).length > 0)
+      throw "Can't create more than one audio channel on ZeppOS";
+
+    if (this._channels[name]) throw "Channel Already Exist";
+    return (this._channels[name] = new Audio.Channel(this));
+  }
+}
+
+export namespace Audio {
+  export class Channel {
+    // platform specific
+
+    // universal
+    _audioPlayer: Platform.AudioPlayer;
+    constructor(public _audio: Audio) {
+      this._audioPlayer = _audio._core.platform.createAudioPlayer();
+
+      this._audioPlayer.onPrepared = (success: boolean) => {
+        this._onPrepared(success);
+      };
+
+      this._audioPlayer.onCompleted = () => {
+        this._onCompleted();
+      };
+
+      // Audio._hmPlayer.addEventListener(Audio._hmPlayer.event.PREPARE, (res) =>
+      //   this._onPrepared(res)
+      // );
+      // Audio._hmPlayer.addEventListener(Audio._hmPlayer.event.COMPLETE, () => {
+      //   this._onCompleted();
+      // });
+    }
+
+    onRelease() {
+      this._audioPlayer.release() // TODO
+      this._audio._core.platform.releaseAudioPlayer(this._audioPlayer);
+    }
+
+    mode: Channel.Mode = Channel.Mode.PlayInOrder;
+    status: Channel.Status = Channel.Status.Stopped;
+    _playbackList: PlaybackItem[] = [];
+    _nowIndex: number | null = null;
+
+    currentInfo: AudioInfo | null = null;
+
+    push(item: PlaybackItem) {
+      this._playbackList.push(item);
+    }
+    play() {
+      if (this.status !== Channel.Status.Stopped) return;
+      this._playNext();
+    }
+    pause() {
+      if (this.status !== Channel.Status.Playing) return;
+      this._audioPlayer.stop();
+      this.status = Channel.Status.Stopped;
+    }
+    /**
+     * 停止并清空队列
+     */
+    stop() {
+      if (this.status !== Channel.Status.Playing) return;
+      this._audio._core.debug.log("audio channel stop");
+      this._audioPlayer.stop();
+      this._playbackList = [];
+      this.currentInfo = null;
+      this._nowIndex = null;
+      this.status = Channel.Status.Stopped;
+    }
+
+    serialize(): Channel.Serialized {
+      return {
+        mode: this.mode,
+        status: this.status,
+        playbackList: this._playbackList,
+        nowIndex: this._nowIndex,
+      };
+    }
+    static deserialize(audio: Audio, data: Channel.Serialized): Channel {
+      let channel = new Channel(audio);
+      channel.mode = data.mode;
+      channel.status = data.status;
+      channel._playbackList = data.playbackList;
+      channel._nowIndex = data.nowIndex;
+      if (channel.status === Channel.Status.Playing) channel._playNext();
+      return channel;
+    }
+
+    _onPrepared(result: boolean) {
+      if (result) {
+        let mediaInfo = this._audioPlayer.getMediaInfo();
+        this.currentInfo = {
+          // placeholder
+          artist: mediaInfo.artist ?? "未知",
+          title: mediaInfo.title ?? "未知",
+          duration: mediaInfo.duration,
+        };
+        console.log("=== prepare succeed ===");
+        this._audioPlayer.start();
+      } else {
+        console.log("=== prepare fail ===");
+        this.status = Channel.Status.Error;
+        this._audioPlayer.release();
+      }
+    }
+
+    _onCompleted() {
+      // update playback list
+      if (this.mode === Channel.Mode.PlayInOrder) {
+        this._playbackList.shift();
+        if (this._playbackList.length > 0) this._nowIndex = 0;
+        else this._nowIndex = null;
+      } else if (this.mode === Channel.Mode.PlayInOrderRepeat) {
+        if (this._playbackList.length > 0) {
+          if (this._nowIndex === null) this._nowIndex = 0;
+          this._nowIndex = (this._nowIndex + 1) % this._playbackList.length;
+        } else this._nowIndex = null;
+      }
+
+      this._playNext();
+    }
+
+    /**
+     * Play the next item in the playback list. If there are no items in the
+     * playback list, set the channel status to Stopped and return.
+     * @private
+     */
+    _playNext() {
+      if (this._playbackList.length === 0) {
+        this._nowIndex = null;
+        this.status = Channel.Status.Stopped;
+        return;
+      }
+
+      if (this.mode === Channel.Mode.PlayInOrder) {
+        if (this._nowIndex === null) this._nowIndex = 0;
+        // otherwise onCompleted will set _nowIndex to next index
+      } else if (this.mode === Channel.Mode.PlayInOrderRepeat) {
+        if (this._nowIndex === null) this._nowIndex = 0;
+        // otherwise onCompleted will set _nowIndex to next index
+      }
+
+      // Audio._hmPlayer.setSource(Audio._hmPlayer.source.FILE, {
+      //   file: this._playbackList[this._nowIndex!].path,
+      // });
+      this._audioPlayer.setSource({
+        path: this._playbackList[this._nowIndex!].path,
+      });
+
+      this._audioPlayer.prepare();
+
+      this.status = Channel.Status.Playing;
+    }
+  }
+  export namespace Channel {
+    export enum Mode {
+      PlayInOrder,
+      PlayInOrderRepeat,
+    }
+    export enum Status {
+      Stopped,
+      Playing,
+      Error,
+    }
+    export type Serialized = {
+      mode: Channel.Mode;
+      status: Channel.Status;
+      playbackList: PlaybackItem[];
+      nowIndex: number | null;
+    };
+  }
+  export interface PlaybackItem {
+    path: string;
+  }
+  export interface AudioInfo {
+    duration: number;
+    title: string;
+    artist: string;
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,80 @@
+import { HZEngineCore } from "../index.js";
+
+export class Config {
+  constructor(private _core: HZEngineCore) {
+    _core.on("initGlobalData", () => {
+      _core.storage.setSaveableData(
+        _core.storage.globalData,
+        true,
+        { ...defaultConfig },
+        "config"
+      );
+    });
+    _core.on("afterLoadGlobalData", () => {
+      if (!(_core.storage.globalData as any)?.config) {
+        _core.storage.setSaveableData(
+          _core.storage.globalData,
+          true,
+          { ...defaultConfig },
+          "config"
+        );
+      }
+      _core.storage.saveGlobalData();
+    });
+  }
+
+  getConfig(key: string) {
+    let keys = this.normalizeKey(key);
+    // this._core.debug.log(`getConfig keys = ${JSON.stringify(keys)}`);
+
+    if (keys == null) return;
+    try {
+      let res = this._core.storage.getSaveableData(
+        this._core.storage.globalData,
+        false,
+        "config",
+        ...keys
+      );
+    //   this._core.debug.log(`getConfig res = ${JSON.stringify(res)}`);
+      return res;
+    } catch (e) {
+        // this._core.debug.log(`getConfig error`,e);
+      return;
+    }
+  }
+
+  setConfig(key: string, value: any) {
+    let keys = this.normalizeKey(key);
+    if (keys == null) return;
+    this._core.storage.setSaveableData(
+      this._core.storage.globalData,
+      true,
+      value,
+      "config",
+      ...keys
+    );
+
+    this._core.storage.saveGlobalData();
+  }
+
+  private normalizeKey(key: string): string[] | null {
+    let keys = <string[]>[];
+    key.split(".").forEach((key) => {
+      if (key.trim().length > 0) keys.push(key);
+      else return null;
+    });
+    return keys;
+  }
+
+  resetConfig() {}
+}
+
+const defaultConfig = {
+  game: {
+    autoplay: {
+      enable: false,
+      ms_per_char: 150,
+      extra_delay: 1300,
+    },
+  },
+};

package/src/debug/index.ts

@@ -0,0 +1,11 @@
+import { HZEngineCore } from "../index.js";
+
+export class Debug {
+    constructor(private _core: HZEngineCore) {
+
+    }
+
+    log(...args: any[]) {
+        console.log("[HZEngine]", ...args);
+    }
+}

package/src/index.ts

@@ -0,0 +1,122 @@
+/**
+ * HZEngineCore
+ * @copyright Copyright (c) 2024 CuberQAQ. All rights reserved.
+ */
+
+import { Async } from "./async/index.js";
+import { Audio } from "./audio/index.js";
+import { Config } from "./config/index.js";
+import { Debug } from "./debug/index.js";
+import Platform from "./platform/index.js";
+import { basic_command } from "./plugins/basic_command/index.js";
+import { global_gesture } from "./plugins/global_gesture/index.js";
+import { registerPlugin } from "./plugins/transform/index.js";
+import { Script } from "./script/index.js";
+import { Storage } from "./storage/index.js";
+import { System } from "./system/index.js";
+import { UI } from "./ui/index.js";
+
+class HZEngineCore<PlatformType extends Platform = any> {
+  private _eventCallbacks: Map<string, Set<Function>> = new Map();
+  public storage;
+  public async;
+  public ui;
+  public script;
+  public system;
+  public config;
+  public audio;
+  public debug;
+  constructor(public platform: PlatformType) {
+    // 請不要調整這裡的初始化順序，不然會有問題（裝飾器裡有時候要用到前面初始化的東西）
+    this.storage = new Storage(this);
+    this.async = new Async(this);
+    this.ui = new UI(this);
+    this.script = new Script(this);
+    this.system = new System(this);
+    this.config = new Config(this);
+    this.audio = new Audio(this);
+    this.debug = new Debug(this);
+
+    // internal plugin
+    this.loadPlugin("global_gesture", global_gesture);
+    this.loadPlugin("transform", registerPlugin);
+    this.loadPlugin("basic_command", basic_command);
+  }
+  loadProject(options: {
+    projectPath: string;
+    cachePath: string;
+    savePath: string;
+  }) {
+    this.storage.loadProject(options);
+  }
+  start(callback?: () => unknown) {
+    // this.system.start()
+    Async.nextTick(() => {
+      this.debug.log("[HZEngine] Game Start");
+      let title = this.storage.packageData?.name;
+      if (title == null) {
+        throw `[HZEngine] project name is null, please loadProject first or check your project.json format`;
+      }
+      this.ui.getRouter("page")!.push("title", {
+        title,
+      });
+
+      // this.on("gameEnd", () => {
+      //   let router = this.ui.getRouter("page")!;
+      //   if (router.length > 0) return;
+      //   router.push("title", {
+      //     title,
+      //   });
+      // });
+      callback?.();
+    });
+  }
+
+  end() {
+    this.debug.log("[HZEngine] Game End, return to title");
+
+    let title = this.storage.packageData?.name;
+    if (title == null) {
+      throw `[HZEngine] project name is null, please loadProject first or check your project.json format`;
+    }
+
+    this.system.condition = System.Condition.Free;
+
+    this.ui.resetUI();
+
+    if (this.ui.getRouter("page")!.length > 0) return;
+    this.ui.getRouter("page")!.push("title", {
+      title,
+    });
+  }
+
+  public plugins: Map<string, unknown> = new Map();
+  // Load Plugin
+  loadPlugin(name: string, plugin: Plugin<PlatformType>) {
+    this.debug.log(`[HZEngine] load plugin [${name}]`);
+    let slot = plugin(this);
+    if (slot != undefined) this.plugins.set(name, slot);
+  }
+
+  // Event Bus
+  on(event: string, cb: Function) {
+    if (this._eventCallbacks.has(event)) {
+      this._eventCallbacks.get(event)!.add(cb);
+    } else {
+      this._eventCallbacks.set(event, new Set<Function>().add(cb));
+    }
+  }
+  off(event: string, cb: Function): boolean {
+    return !!this._eventCallbacks.get(event)?.delete(cb);
+  }
+  emit(event: string, ...args: any[]) {
+    this._eventCallbacks.get(event)?.forEach((cb) => {
+      cb(...args);
+    });
+  }
+}
+
+type Plugin<PlatformType extends Platform> = (core: HZEngineCore<PlatformType>) => any;
+
+export { HZEngineCore, UI, Storage, Script, System, Async, type Platform };
+export * as TransformPlugin from "./plugins/transform/index.js";

package/src/platform/index.ts

@@ -0,0 +1,158 @@
+export interface Platform<WidgetFactory = any> {
+  name: string;
+
+  // screen
+  getScreenSize(): [width: number, height: number];
+
+  // ui
+  createUILayer({ z_index }: { z_index: number }): WidgetFactory;
+  deleteUILayer(widgetFactory: WidgetFactory): void;
+
+  // fs
+  isFileSync({ path }: { path: string }): boolean;
+  readdirSync(option: Platform.readdirSync.Option): Platform.readdirSync.Result;
+  statSync(option: Platform.statSync.Option): Platform.statSync.Result;
+  readFileSync(option: Platform.readFileSync.Option): Platform.readFileSync.Result;
+  writeFileSync(option: Platform.writeFileSync.Option): void;
+
+  
+
+  getImageInfo(img_path: string): {
+    width: number;
+    height: number;
+  };
+
+  // timer & async
+  getTime(): number; // in Utc
+
+  // audio
+  createAudioPlayer(): Platform.AudioPlayer;
+  releaseAudioPlayer(audio_player: Platform.AudioPlayer): void;
+
+  setFrameInterval(callback: () => void): void;
+}
+
+export declare namespace Platform {
+
+
+  export interface AudioPlayer {
+    onPrepared?: (success: boolean) => void | undefined;
+    onCompleted?: () => void | undefined;
+    prepare(): void;
+    start(): void;
+    stop(): void;
+    release(): void;
+    getMediaInfo(): MediaInfo;
+    setSource({ path }: { path: string }): void;
+  }
+
+  export interface MediaInfo {
+    title: string | undefined;
+    artist: string | undefined;
+    duration: number;
+  }
+
+  export namespace readdirSync {
+    interface Option {
+      /**
+       * @zh 目录路径
+       * @en Directory path
+       */
+      path: string;
+    }
+
+    /**
+     * @zh 如果返回 `undefined` 则目录不存在，否则返回文件名数组
+     * @en If `undefined` is returned, the directory does not exist, otherwise an array of filenames is returned
+     */
+    type Result = Array<string> | undefined;
+  }
+
+  export namespace statSync {
+    interface Option {
+      /**
+       * @zh 路径
+       * @en path
+       */
+      path: string;
+    }
+
+    /**
+     * @zh 如果返回 `undefined` 则目标文件不存在，否则返回文件信息对象
+     * @en If `undefined` is returned, the target file does not exist, otherwise the file information object is returned
+     */
+    type Result = FSStat | undefined;
+
+    /**
+     * @output
+     */
+    interface FSStat {
+      /**
+       * @zh 文件大小（单位为字节）
+       * @en The size of the file in bytes
+       */
+      size: number;
+    }
+  }
+
+  export namespace readFileSync {
+    interface Option {
+      /**
+       * @zh 文件路径
+       * @en path
+       */
+      path: string;
+      /**
+       * @zh 其他选项
+       * @en Other Options
+       */
+      options?: Options;
+    }
+
+    interface Options {
+      /**
+       * @zh 当指定了编码方式之后，API 返回结果为 `string`
+       * @en When the encoding method is specified, the API returns `string` as the result
+       */
+      encoding?: string;
+    }
+
+    /**
+     * @zh 文件内容。如果返回 `undefined`，则表明读取文件失败
+     * @en File content. If `undefined` is returned, the file failed to be read
+     */
+    type Result = ArrayBuffer | string | undefined;
+  }
+
+  export namespace writeFileSync {
+    interface Option {
+      /**
+       * @zh 文件路径或者文件句柄
+       * @en File path or file descriptor
+       */
+      path: string | number;
+      /**
+       * @zh 写入目标文件的数据
+       * @en Data to be written to the target file
+       */
+      data: ArrayBuffer | string | DataView;
+      /**
+       * @zh 其他选项
+       * @en Other Options
+       */
+      options?: Options;
+    }
+
+    interface Options {
+      /**
+       * @zh 如果数据格式为 `string`，需要指定编码方式
+       * @en If the `data` format is `string`, you need to specify the encoding method
+       * @defaultValue utf8
+       */
+      encoding?: string;
+    }
+  }
+}
+
+
+export default Platform;

package/src/plugins/basic_command/$.ts

@@ -0,0 +1,11 @@
+import { HZEngineCore } from "../../index.js";
+
+export function $_command(core: HZEngineCore) {
+
+    core.script.use((ctx, next) => {
+        if(ctx.rawtext.trim().startsWith("$")) {
+            ctx.rawtext = "eval " + ctx.rawtext.trim().slice(1).trim()
+        }
+        return next()
+    })
+}