@infernus/core 0.8.7 → 0.9.1

package/src/controllers/player/index.ts

@@ -1,3 +0,0 @@
-import "./pauseChecker";
-export * from "./basePlayer";
-export * from "./playerEvent";

package/src/controllers/player/pauseChecker.ts

@@ -1,39 +0,0 @@
-import { PlayerStateEnum } from "@/enums";
-import {
-  OnPlayerConnect,
-  OnPlayerDisconnect,
-} from "@/wrapper/native/callbacks";
-import { Player } from "./basePlayer";
-import { playerBus, playerHooks } from "./playerBus";
-
-let timer: null | NodeJS.Timer = null;
-
-let pausePlayers: Map<number, Player> | null = null;
-
-playerBus.on(playerHooks.create, (players: Map<number, Player>) => {
-  if (pausePlayers === null) pausePlayers = players;
-});
-
-OnPlayerConnect(() => {
-  if (!timer && pausePlayers && Player.getPoolSize() > -1) {
-    timer = setInterval(() => {
-      for (const item of pausePlayers as Map<number, Player>) {
-        const p = item[1];
-        if (
-          !p.isNpc() &&
-          !p.isPaused &&
-          p.getState() !== PlayerStateEnum.NONE &&
-          Date.now() - p.lastUpdateTick > 1000
-        ) {
-          playerBus.emit(playerHooks.pause, p);
-        }
-      }
-    }, 500);
-  }
-  return 1;
-});
-
-OnPlayerDisconnect(() => {
-  if (timer && Player.getPoolSize() <= 0) clearInterval(timer);
-  return 1;
-});

package/src/controllers/player/playerBus.ts

@@ -1,9 +0,0 @@
-import { EventBus } from "@/utils/eventBus";
-
-export enum playerHooks {
-  pause = "OnPlayerPause",
-  create = "OnPlayerEventCreate",
-  setCommonProp = "OnPlayerSetCommonProp",
-}
-
-export const playerBus = new EventBus();

package/src/controllers/player/playerEvent.ts

@@ -1,468 +0,0 @@
-import {
-  NOOP,
-  OnPlayerCommandText,
-  OnPlayerText,
-  promisifyCallback,
-} from "@/utils/helperUtils";
-import * as cbs from "@/wrapper/native/callbacks";
-import { I18n } from "../i18n";
-import { Player } from "./basePlayer";
-import { CmdBus } from "../command";
-import type { ICmdErr } from "@/interfaces";
-import * as enums from "@/enums";
-import { throttle } from "lodash";
-import { Dialog } from "../promise/dialog";
-import { delCCTask } from "../promise/client";
-import { playerBus, playerHooks } from "./playerBus";
-import type { TCommonCallback, TEventFunc, TEventName } from "@/types";
-
-// Each instance can be called to callbacks, so you can split the logic.
-
-const ICmdErrInfo: Record<"format" | "notExist" | "rejected", ICmdErr> = {
-  format: { code: 0, msg: "failed to recognize command (almost never)" },
-  notExist: { code: 1, msg: "command does not exist" },
-  rejected: { code: 2, msg: "rejected because true/1 was not returned" },
-};
-
-export class PlayerEvent<P extends Player> {
-  private readonly players = new Map<number, P>();
-  private static cmdBus = new CmdBus();
-
-  constructor(newPlayerFn: (id: number) => P) {
-    cbs.OnPlayerConnect((playerid: number): number => {
-      const p = newPlayerFn(playerid);
-      this.players.set(playerid, p);
-      const pFn = promisifyCallback(this, "onConnect", "OnPlayerConnect");
-      return pFn(p);
-    });
-
-    cbs.OnPlayerDisconnect((playerid: number, reason: number): number => {
-      const p = this.findPlayerById(playerid);
-      if (!p) return 0;
-      Dialog.close(p);
-      delCCTask(playerid, true);
-      const pFn = promisifyCallback(this, "onDisconnect", "OnPlayerDisconnect");
-      const result = pFn(p, reason);
-      this.players.delete(playerid);
-      return result;
-    });
-
-    OnPlayerText((playerid: number, byteArr: number[]): number => {
-      const p = this.findPlayerById(playerid);
-      if (!p) return 1;
-      const pFn = promisifyCallback(this, "onText", "OnPlayerTextI18n", 0);
-      return pFn(p, I18n.decodeFromBuf(byteArr, p.charset));
-    });
-
-    OnPlayerCommandText((playerid: number, buf: number[]): number => {
-      const p = this.findPlayerById(playerid);
-      if (!p) return 0;
-      const cmdtext = I18n.decodeFromBuf(buf, p.charset);
-      const regCmdtext = cmdtext.match(/[^/\s]+/gi);
-      if (regCmdtext === null || regCmdtext.length === 0) {
-        this.onCommandError &&
-          this.onCommandError(p, cmdtext, ICmdErrInfo.format);
-        return 0;
-      }
-      this.promiseCommand(p, regCmdtext);
-      return 1;
-    });
-
-    cbs.OnEnterExitModShop(
-      (playerid: number, enterexit: number, interior: number): number => {
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        const pFn = promisifyCallback(this, "onEnterExitModShop");
-        return pFn(p, enterexit, interior);
-      }
-    );
-
-    cbs.OnPlayerClickMap(
-      (playerid: number, fX: number, fY: number, fZ: number): number => {
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        const pFn = promisifyCallback(this, "onClickMap", "OnPlayerClickMap");
-        return pFn(p, fX, fY, fZ);
-      }
-    );
-
-    cbs.OnPlayerClickPlayer(
-      (playerid: number, clickedplayerid: number, source: number): number => {
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        const cp = this.findPlayerById(clickedplayerid);
-        if (!cp) return 0;
-        const pFn = promisifyCallback(
-          this,
-          "onClickPlayer",
-          "OnPlayerClickPlayer"
-        );
-        return pFn(p, cp, source);
-      }
-    );
-
-    cbs.OnPlayerDeath(
-      (playerid: number, killerid: number, reason: number): number => {
-        const pFn = promisifyCallback(this, "onDeath", "OnPlayerDeath");
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        if (killerid === enums.InvalidEnum.PLAYER_ID) {
-          return pFn(p, killerid, reason);
-        }
-        const k = this.findPlayerById(killerid);
-        if (!k) return 0;
-        return pFn(p, k, reason);
-      }
-    );
-
-    cbs.OnPlayerGiveDamage(
-      (
-        playerid: number,
-        damageid: number,
-        amount: number,
-        weaponid: enums.WeaponEnum,
-        bodypart: enums.BodyPartsEnum
-      ): number => {
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        const d = this.findPlayerById(damageid);
-        if (!d) return 0;
-        const pFn = promisifyCallback(
-          this,
-          "onGiveDamage",
-          "OnPlayerGiveDamage"
-        );
-        return pFn(p, d, amount, weaponid, bodypart);
-      }
-    );
-
-    cbs.OnPlayerKeyStateChange(
-      (playerid: number, newkeys: number, oldkeys: number): number => {
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        const pFn = promisifyCallback(
-          this,
-          "onKeyStateChange",
-          "OnPlayerKeyStateChange"
-        );
-        return pFn(p, newkeys, oldkeys);
-      }
-    );
-
-    cbs.OnPlayerRequestClass((playerid: number, classid: number): number => {
-      const p = this.findPlayerById(playerid);
-      if (!p) return 0;
-      const pFn = promisifyCallback(
-        this,
-        "onRequestClass",
-        "OnPlayerRequestClass"
-      );
-      return pFn(p, classid);
-    });
-
-    cbs.OnPlayerRequestSpawn((playerid: number): number => {
-      const p = this.findPlayerById(playerid);
-      if (!p) return 0;
-      const pFn = promisifyCallback(
-        this,
-        "onRequestSpawn",
-        "OnPlayerRequestSpawn"
-      );
-      return pFn(p);
-    });
-
-    cbs.OnPlayerSpawn((playerid: number): number => {
-      const p = this.findPlayerById(playerid);
-      if (!p) return 0;
-      const pFn = promisifyCallback(this, "onSpawn", "OnPlayerSpawn");
-      return pFn(p);
-    });
-
-    cbs.OnPlayerStateChange(
-      (playerid: number, newstate: number, oldstate: number): number => {
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        if (oldstate === enums.PlayerStateEnum.NONE)
-          p.lastUpdateTick = Date.now();
-        const pFn = promisifyCallback(
-          this,
-          "onStateChange",
-          "OnPlayerStateChange"
-        );
-        return pFn(p, newstate, oldstate);
-      }
-    );
-
-    cbs.OnPlayerStreamIn((playerid: number, forplayerid: number): number => {
-      const p = this.findPlayerById(playerid);
-      if (!p) return 0;
-      const fp = this.findPlayerById(forplayerid);
-      if (!fp) return 0;
-      const pFn = promisifyCallback(this, "onStreamIn", "OnPlayerStreamIn");
-      return pFn(p, fp);
-    });
-
-    cbs.OnPlayerStreamOut((playerid: number, forplayerid: number): number => {
-      const p = this.findPlayerById(playerid);
-      if (!p) return 0;
-      const fp = this.findPlayerById(forplayerid);
-      if (!fp) return 0;
-      const pFn = promisifyCallback(this, "onStreamOut", "OnPlayerStreamOut");
-      return pFn(p, fp);
-    });
-
-    cbs.OnPlayerTakeDamage(
-      (
-        playerid: number,
-        issuerid: number,
-        amount: number,
-        weaponid: enums.WeaponEnum,
-        bodypart: enums.BodyPartsEnum
-      ): number => {
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        if (issuerid === enums.InvalidEnum.PLAYER_ID) {
-          const pFn = promisifyCallback(
-            this,
-            "onTakeDamage",
-            "OnPlayerTakeDamage"
-          );
-          return pFn(p, issuerid, amount, weaponid, bodypart);
-        }
-        const i = this.findPlayerById(issuerid);
-        if (!i) return 0;
-        const pFn = promisifyCallback(
-          this,
-          "onTakeDamage",
-          "OnPlayerTakeDamage"
-        );
-        return pFn(p, i, amount, weaponid, bodypart);
-      }
-    );
-
-    /** 30 calls per second for a single player means a peak of 30,000 calls for 1000 players.
-     * If there are 10 player event classes, that means there are 30,0000 calls per second.
-     * By throttling down to 16.67 calls per second for a single player, performance should be optimized.
-     */
-    cbs.OnPlayerUpdate((playerid: number): number => {
-      const p = this.findPlayerById(playerid);
-      if (!p) return 0;
-      if (!p.isNpc()) {
-        const now = Date.now();
-        if (p.isPaused) {
-          p.isPaused = false;
-          this.onResume && this.onResume(p, now - p.lastUpdateTick);
-        }
-        p.lastUpdateTick = now;
-        PlayerEvent.fpsHeartbeat(p);
-      }
-      const pFn = promisifyCallback(this, "throttleUpdate", "OnPlayerUpdate");
-      const res = pFn(p);
-      if (res === undefined) return 0;
-      return res;
-    });
-
-    cbs.OnPlayerInteriorChange(
-      (
-        playerid: number,
-        newinteriorid: number,
-        oldinteriorid: number
-      ): number => {
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        const pFn = promisifyCallback(
-          this,
-          "onInteriorChange",
-          "OnPlayerInteriorChange"
-        );
-        return pFn(p, newinteriorid, oldinteriorid);
-      }
-    );
-
-    cbs.OnPlayerRequestDownload(
-      (playerid: number, type: number, crc: number): number => {
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        const pFn = promisifyCallback(
-          this,
-          "onRequestDownload",
-          "OnPlayerRequestDownload"
-        );
-        return pFn(p, type, crc);
-      }
-    );
-
-    cbs.OnPlayerFinishedDownloading(
-      (playerid: number, virtualworld: number): number => {
-        const p = this.findPlayerById(playerid);
-        if (!p) return 0;
-        const pFn = promisifyCallback(
-          this,
-          "onFinishedDownloading",
-          "OnPlayerFinishedDownloading"
-        );
-        return pFn(p, virtualworld);
-      }
-    );
-    playerBus.emit(playerHooks.create, this.players);
-    playerBus.on(playerHooks.pause, (player: P) => {
-      player.isPaused = true;
-      this.onPause && this.onPause(player, player.lastUpdateTick);
-    });
-
-    playerBus.on(playerHooks.setCommonProp, ({ player, prop, value }) => {
-      Reflect.set(player, prop, value);
-      this.players.set(player.id, player);
-    });
-  }
-  findPlayerById(playerid: number) {
-    return this.players.get(playerid);
-  }
-  getPlayersArr(): Array<P> {
-    return [...this.players.values()];
-  }
-  getPlayersMap(): Map<number, P> {
-    return this.players;
-  }
-  readonly throttleUpdate = throttle(
-    (player: P) => this.onUpdate && this.onUpdate(player),
-    60
-  );
-  private static fpsHeartbeat = throttle((player: Player) => {
-    if (!Player.isConnected(player.id)) return;
-    const nowDrunkLevel = player.getDrunkLevel();
-    if (nowDrunkLevel < 100) {
-      player.setDrunkLevel(2000);
-      player.lastDrunkLevel = 2000;
-      player.lastFps = 0;
-      return;
-    }
-    player.lastFps = player.lastDrunkLevel - nowDrunkLevel - 1;
-    player.lastDrunkLevel = nowDrunkLevel;
-  }, 1000);
-
-  /**
-   * Use eventBus to observe and subscribe to level 1 instructions,
-   * support string and array pass, array used for alias.
-   */
-  readonly onCommandText = (
-    name: TEventName,
-    fn: TEventFunc<this, P> | TEventFunc<this, P>[]
-  ): (() => void) => {
-    return PlayerEvent.cmdBus.on(this, name, fn);
-  };
-
-  readonly offCommandText = (
-    name: TEventName,
-    fn: TEventFunc<this, P> | TEventFunc<this, P>[]
-  ) => {
-    PlayerEvent.cmdBus.off(this, name, fn);
-  };
-
-  private promiseCommand = async (
-    p: P,
-    cmd: RegExpMatchArray
-  ): Promise<unknown> => {
-    const fullCommand = cmd.join(" ");
-    const firstLevel = cmd[0];
-
-    const hasAnyRegistered = PlayerEvent.cmdBus.eventMap.get(firstLevel);
-    if (!hasAnyRegistered && this.onCommandError) {
-      this.onCommandError(p, fullCommand, ICmdErrInfo.notExist);
-      return;
-    }
-
-    const hasInstanceFns = hasAnyRegistered?.get(this);
-    if (!hasInstanceFns) return;
-
-    let rFnRes =
-      this.onCommandReceived && this.onCommandReceived(p, fullCommand);
-
-    if (rFnRes !== undefined) {
-      if (rFnRes instanceof Promise) rFnRes = await rFnRes;
-      if (!rFnRes) return NOOP("OnPlayerCommandTextI18n");
-    }
-
-    // deliberately let the for loop not wait
-    hasInstanceFns.forEach(async (fn) => {
-      // CmdBus emit start
-      let result = fn.call(this, p, ...cmd.slice(1));
-      if (result instanceof Promise) result = await result;
-      if (result === undefined || result === null) result = false;
-      // CmdBus emit end
-
-      if (result) {
-        let pFnRes =
-          this.onCommandPerformed && this.onCommandPerformed(p, fullCommand);
-        if (pFnRes instanceof Promise) pFnRes = await pFnRes;
-        if (!pFnRes) return NOOP("OnPlayerCommandTextI18n");
-        return;
-      }
-
-      const pFn = promisifyCallback(
-        this,
-        "onCommandError",
-        "OnPlayerCommandTextI18n"
-      );
-      pFn(p, fullCommand, ICmdErrInfo.rejected);
-    });
-  };
-
-  onConnect?(player: P): TCommonCallback;
-  onDisconnect?(player: P, reason: number): TCommonCallback;
-  onText?(player: P, text: string): TCommonCallback;
-  onCommandReceived?(player: P, command: string): TCommonCallback;
-  onCommandPerformed?(player: P, command: string): TCommonCallback;
-  onCommandError?(player: P, command: string, err: ICmdErr): TCommonCallback;
-  onEnterExitModShop?(
-    player: P,
-    enterexit: number,
-    interiorid: number
-  ): TCommonCallback;
-  onClickMap?(player: P, fX: number, fY: number, fZ: number): TCommonCallback;
-  onClickPlayer?(player: P, clickedPlayer: P, source: number): TCommonCallback;
-  onDeath?(
-    player: P,
-    killer: P | enums.InvalidEnum.PLAYER_ID,
-    reason: number
-  ): TCommonCallback;
-  onGiveDamage?(
-    player: P,
-    damage: P,
-    amount: number,
-    weaponid: enums.WeaponEnum,
-    bodypart: enums.BodyPartsEnum
-  ): TCommonCallback;
-  onKeyStateChange?(
-    player: P,
-    newkeys: enums.KeysEnum,
-    oldkeys: enums.KeysEnum
-  ): TCommonCallback;
-  onRequestClass?(player: P, classid: number): TCommonCallback;
-  onRequestSpawn?(player: P): TCommonCallback;
-  onSpawn?(player: P): TCommonCallback;
-  onStateChange?(
-    player: P,
-    newstate: enums.PlayerStateEnum,
-    oldstate: enums.PlayerStateEnum
-  ): TCommonCallback;
-  onStreamIn?(player: P, forPlayer: P): TCommonCallback;
-  onStreamOut?(player: P, forPlayer: P): TCommonCallback;
-  onTakeDamage?(
-    player: P,
-    damage: P | enums.InvalidEnum.PLAYER_ID,
-    amount: number,
-    weaponid: enums.WeaponEnum,
-    bodypart: enums.BodyPartsEnum
-  ): TCommonCallback;
-  onUpdate?(player: P): TCommonCallback;
-  onInteriorChange?(
-    player: P,
-    newinteriorid: number,
-    oldinteriorid: number
-  ): TCommonCallback;
-  onPause?(player: P, timestamp: number): TCommonCallback;
-  onResume?(player: P, pauseMs: number): TCommonCallback;
-  onRequestDownload?(player: P, type: number, crc: number): TCommonCallback;
-  onFinishedDownloading?(player: P, virtualworld: number): TCommonCallback;
-}

package/src/controllers/promise/client/index.ts

@@ -1,31 +0,0 @@
-import type { IClientFuncQueue } from "@/interfaces";
-import { OnClientCheckResponse } from "@/wrapper/native/callbacks";
-
-export const ccWaitingQueue: Map<number, IClientFuncQueue> = new Map();
-
-export const delCCTask = (playerId: number, reject = false): boolean => {
-  const task = ccWaitingQueue.get(playerId);
-  if (!task) return false;
-  if (reject)
-    task.reject(
-      "[Player]: An attempt to check the player client response timed out"
-    );
-  clearTimeout(task.timeout);
-  ccWaitingQueue.delete(playerId);
-  return true;
-};
-
-OnClientCheckResponse(
-  (
-    playerid: number,
-    actionid: number,
-    memaddr: number,
-    retndata: number
-  ): number => {
-    const task = ccWaitingQueue.get(playerid);
-    if (!task) return 0;
-    clearTimeout(task.timeout);
-    setTimeout(() => task.resolve({ actionid, memaddr, retndata }));
-    return 1;
-  }
-);

package/src/controllers/promise/dialog/index.ts

@@ -1,143 +0,0 @@
-import { DialogStylesEnum } from "@/enums";
-import { OnDialogResponse, ShowPlayerDialog } from "@/utils/helperUtils";
-import { HidePlayerDialog } from "@infernus/wrapper";
-import type { Player } from "../../player/basePlayer";
-import { I18n } from "../../i18n";
-import type {
-  IDialog,
-  IDialogFuncQueue,
-  IDialogResRaw,
-  IDialogResResult,
-} from "@/interfaces";
-import { logger } from "@/logger";
-
-/* You don't need to define the dialog id, 
-  but you need to pay attention to the fact that you shouldn't repeatedly new the dialog in the function, 
-  instead you should call the open method.
-  
-  If you need to change the value dynamically, you should do it by setter method
-*/
-
-OnDialogResponse(
-  (
-    playerid: number,
-    dialogid: number,
-    response: number,
-    listitem: number,
-    inputbuf: number[]
-  ): number => {
-    const callback = Dialog.waitingQueue.get(playerid);
-    if (!callback) return 0;
-    // bug: does not trigger resolve of promise
-    // fix: it only works if you put it in an event loop
-    setTimeout(() => callback.resolve({ response, listitem, inputbuf }));
-    return 1;
-  }
-);
-
-export class Dialog<T extends Player> {
-  private id: number;
-  private static CREATED_ID = -1;
-  private static MAX_DIALOGID = 32767;
-  private dialog: IDialog;
-  static waitingQueue: Map<number, IDialogFuncQueue> = new Map();
-
-  constructor(
-    dialog: IDialog = {
-      style: DialogStylesEnum.MSGBOX,
-      caption: "",
-      info: "",
-      button1: "",
-      button2: "",
-    }
-  ) {
-    if (Dialog.CREATED_ID < Dialog.MAX_DIALOGID) {
-      Dialog.CREATED_ID++;
-    } else {
-      logger.warn("[Dialog]: The maximum number of dialogs is reached");
-    }
-    this.dialog = dialog;
-    this.id = Dialog.CREATED_ID;
-  }
-
-  // #region
-  get style(): DialogStylesEnum | undefined {
-    return this.dialog.style;
-  }
-  set style(v: DialogStylesEnum | undefined) {
-    this.dialog.style = v;
-  }
-
-  get caption(): string | undefined {
-    return this.dialog.caption;
-  }
-  set caption(v: string | undefined) {
-    this.dialog.caption = v;
-  }
-
-  get info(): string | undefined {
-    return this.dialog.info;
-  }
-  set info(v: string | undefined) {
-    this.dialog.info = v;
-  }
-
-  get button1(): string | undefined {
-    return this.dialog.button1;
-  }
-  set button1(v: string | undefined) {
-    this.dialog.button1 = v;
-  }
-
-  get button2(): string | undefined {
-    return this.dialog.button2;
-  }
-  set button2(v: string | undefined) {
-    this.dialog.button2 = v;
-  }
-
-  //#endregion
-
-  private static delDialogTask<T extends Player>(
-    player: T,
-    reject = false
-  ): boolean {
-    // if player disconnect and still await response
-    // should stop promise waiting
-    const task = Dialog.waitingQueue.get(player.id);
-    if (!task) return false;
-    if (reject)
-      task.reject(
-        "[Dialog]: player timeout does not respond or second request show dialog"
-      );
-    Dialog.waitingQueue.delete(player.id);
-    return true;
-  }
-
-  show(player: T) {
-    return new Promise<IDialogResRaw>((resolve, reject) => {
-      Dialog.close(player);
-      Dialog.waitingQueue.set(player.id, { resolve, reject });
-      ShowPlayerDialog(player, this.id, this.dialog);
-    })
-      .then((DialogRes: IDialogResRaw) => {
-        const { response, listitem } = DialogRes;
-        const inputtext = I18n.decodeFromBuf(
-          DialogRes.inputbuf,
-          player.charset
-        );
-        return Promise.resolve({
-          response,
-          listitem,
-          inputtext,
-        } as IDialogResResult);
-      })
-      .catch((e) => Promise.reject(e))
-      .finally(() => Dialog.delDialogTask(player));
-  }
-
-  static close<T extends Player>(player: T) {
-    Dialog.delDialogTask(player, true);
-    HidePlayerDialog(player.id);
-  }
-}