@infernus/core 0.8.7

package/src/wrapper/streamer/3dtext/3dTextBus.ts

@@ -0,0 +1,8 @@
+import { EventBus } from "@/utils/eventBus";
+
+export enum _3dTextHooks {
+  created = "On3dTextCreate",
+  destroyed = "On3dTextDestroy",
+}
+
+export const _3dTextBus = new EventBus();

package/src/wrapper/streamer/3dtext/3dTextEvent.ts

@@ -0,0 +1,70 @@
+import type { Player } from "@/controllers/player";
+import type { TCommonCallback } from "@/types";
+import { StreamerItemTypes } from "@infernus/streamer";
+import { Streamer } from "../common";
+import type { Dynamic3DTextLabel } from "./base3DText";
+
+import { _3dTextBus, _3dTextHooks } from "./3dTextBus";
+import { OnGameModeExit } from "@/wrapper/native/callbacks";
+import { promisifyCallback } from "@/utils/helperUtils";
+
+export class Dynamic3dTextLabelEvent<
+  P extends Player,
+  D extends Dynamic3DTextLabel
+> {
+  private readonly _3dTexts = new Map<number, D>();
+  private readonly players;
+
+  constructor(playersMap: Map<number, P>, destroyOnExit = true) {
+    this.players = playersMap;
+    _3dTextBus.on(_3dTextHooks.created, (_3dText: D) => {
+      this._3dTexts.set(_3dText.id, _3dText);
+    });
+    _3dTextBus.on(_3dTextHooks.destroyed, (_3dText: D) => {
+      this._3dTexts.delete(_3dText.id);
+    });
+    if (destroyOnExit) {
+      OnGameModeExit(() => {
+        this._3dTexts.forEach((t) => t.destroy());
+        this._3dTexts.clear();
+      });
+    }
+    Streamer.onItemStreamIn((type, item, player) => {
+      if (type === StreamerItemTypes.TEXT_3D_LABEL) {
+        const tl = this._3dTexts.get(item);
+        const p = this.players.get(player);
+        if (tl && p)
+          return promisifyCallback(
+            this,
+            "onStreamIn",
+            "Streamer_OnItemStreamIn"
+          )(tl, p);
+      }
+      return 1;
+    });
+    Streamer.onItemStreamOut((type, item, player) => {
+      if (type === StreamerItemTypes.TEXT_3D_LABEL) {
+        const tl = this._3dTexts.get(item);
+        const p = this.players.get(player);
+        if (tl && p)
+          return promisifyCallback(
+            this,
+            "onStreamOut",
+            "Streamer_OnItemStreamOut"
+          )(tl, p);
+      }
+      return 1;
+    });
+  }
+
+  onStreamIn?(label: D, player: P): TCommonCallback;
+  onStreamOut?(label: D, player: P): TCommonCallback;
+
+  get3dTextLabelsArr(): Array<D> {
+    return [...this._3dTexts.values()];
+  }
+
+  get3dTextLabelsMap(): Map<number, D> {
+    return this._3dTexts;
+  }
+}

package/src/wrapper/streamer/3dtext/base3DText.ts

@@ -0,0 +1,184 @@
+import { defaultCharset } from "@/controllers/gamemode/settings";
+import { InvalidEnum } from "@/enums";
+import type { IDynamic3DTextLabel } from "@/interfaces";
+import { logger } from "@/logger";
+import { rgba } from "@/utils/colorUtils";
+import {
+  CreateDynamic3DTextLabel,
+  CreateDynamic3DTextLabelEx,
+  GetDynamic3DTextLabelText,
+  UpdateDynamic3DTextLabelText,
+} from "@/utils/helperUtils";
+import {
+  DestroyDynamic3DTextLabel,
+  IsValidDynamic3DTextLabel,
+  StreamerDistances,
+  StreamerItemTypes,
+} from "@infernus/streamer";
+import { Streamer } from "../common";
+import { _3dTextBus, _3dTextHooks } from "./3dTextBus";
+
+export class Dynamic3DTextLabel {
+  private sourceInfo: IDynamic3DTextLabel;
+  private _id = -1;
+  get id(): number {
+    return this._id;
+  }
+  constructor(textLabel: IDynamic3DTextLabel) {
+    this.sourceInfo = textLabel;
+  }
+  create(): void | this {
+    if (this.id !== -1)
+      return logger.warn("[Streamer3DTextLabel]: Unable to create again");
+    let {
+      attachedplayer,
+      attachedvehicle,
+      testlos,
+      streamdistance,
+      worldid,
+      interiorid,
+      playerid,
+      areaid,
+      priority,
+    } = this.sourceInfo;
+    const { charset, text, colour, drawdistance, x, y, z, extended } =
+      this.sourceInfo;
+
+    attachedplayer ??= InvalidEnum.PLAYER_ID;
+    attachedvehicle ??= InvalidEnum.VEHICLE_ID;
+    streamdistance ??= StreamerDistances.TEXT_3D_LABEL_SD;
+    testlos ??= false;
+    priority ??= 0;
+
+    if (extended) {
+      if (typeof worldid === "number") worldid = [-1];
+      else worldid ??= [-1];
+      if (typeof interiorid === "number") interiorid = [-1];
+      else interiorid ??= [-1];
+      if (typeof playerid === "number") playerid = [-1];
+      else playerid ??= [-1];
+      if (typeof areaid === "number") areaid = [-1];
+      else areaid ??= [-1];
+
+      this._id = CreateDynamic3DTextLabelEx(
+        text,
+        rgba(colour),
+        x,
+        y,
+        z,
+        drawdistance,
+        attachedplayer,
+        attachedvehicle,
+        testlos,
+        streamdistance,
+        worldid,
+        interiorid,
+        playerid,
+        areaid,
+        priority,
+        charset || defaultCharset
+      );
+    } else {
+      if (Array.isArray(worldid)) worldid = -1;
+      else worldid ??= -1;
+      if (Array.isArray(interiorid)) interiorid = -1;
+      else interiorid ??= -1;
+      if (Array.isArray(playerid)) playerid = -1;
+      else playerid ??= -1;
+      if (Array.isArray(areaid)) areaid = -1;
+      else areaid ??= -1;
+
+      this._id = CreateDynamic3DTextLabel(
+        charset || defaultCharset,
+        text,
+        rgba(colour),
+        x,
+        y,
+        z,
+        drawdistance,
+        attachedplayer,
+        attachedvehicle,
+        testlos,
+        worldid,
+        interiorid,
+        playerid,
+        streamdistance,
+        areaid,
+        priority
+      );
+    }
+    _3dTextBus.emit(_3dTextHooks.created, this);
+    return this;
+  }
+  destroy(): void | this {
+    if (this.id === -1)
+      return logger.warn(
+        "[Streamer3DTextLabel]: Unable to destroy before create"
+      );
+    DestroyDynamic3DTextLabel(this.id);
+    _3dTextBus.emit(_3dTextHooks.destroyed, this);
+    return this;
+  }
+  isValid(): boolean {
+    return IsValidDynamic3DTextLabel(this.id);
+  }
+  getColour(): void | string | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[Streamer3DTextLabel]: Unable to get colour before create"
+      );
+    return this.sourceInfo.colour;
+  }
+  getCharset(): void | string {
+    if (this.id === -1)
+      return logger.warn(
+        "[Streamer3DTextLabel]: Unable to get charset before create"
+      );
+    return this.sourceInfo.charset;
+  }
+  getText(): void | string {
+    if (this.id === -1)
+      return logger.warn(
+        "[Streamer3DTextLabel]: Unable to get text before create"
+      );
+    return GetDynamic3DTextLabelText(
+      this.id,
+      this.sourceInfo.charset || defaultCharset
+    );
+  }
+  updateText(
+    colour: string | number,
+    text: string,
+    charset = this.sourceInfo.charset
+  ): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[Streamer3DTextLabel]: Unable to update text before create"
+      );
+    this.sourceInfo.charset = charset;
+    return UpdateDynamic3DTextLabelText(
+      this.id,
+      rgba(colour),
+      text,
+      charset || defaultCharset
+    );
+  }
+  toggleCallbacks(toggle = true): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[Streamer3DTextLabel]: Unable to toggle callbacks before create"
+      );
+    return Streamer.toggleItemCallbacks(
+      StreamerItemTypes.TEXT_3D_LABEL,
+      this.id,
+      toggle
+    );
+  }
+  isToggleCallbacks(): boolean {
+    if (this.id === -1) false;
+    return Streamer.isToggleItemCallbacks(
+      StreamerItemTypes.TEXT_3D_LABEL,
+      this.id
+    );
+  }
+}

package/src/wrapper/streamer/3dtext/index.ts

@@ -0,0 +1,2 @@
+export * from "./base3DText";
+export * from "./3dTextEvent";

package/src/wrapper/streamer/actor/actorBus.ts

@@ -0,0 +1,8 @@
+import { EventBus } from "@/utils/eventBus";
+
+export enum actorHooks {
+  created = "OnActorCreate",
+  destroyed = "OnActorDestroy",
+}
+
+export const actorBus = new EventBus();

package/src/wrapper/streamer/actor/actorEvent.ts

@@ -0,0 +1,95 @@
+import type { Player } from "@/controllers/player";
+import type { BodyPartsEnum } from "@/enums";
+import type { TCommonCallback } from "@/types";
+import { promisifyCallback } from "@/utils/helperUtils";
+import { OnGameModeExit } from "@/wrapper/native/callbacks";
+import {
+  OnDynamicActorStreamIn,
+  OnDynamicActorStreamOut,
+  OnPlayerGiveDamageDynamicActor,
+} from "@infernus/streamer";
+import { actorBus, actorHooks } from "./actorBus";
+import type { DynamicActor } from "./baseActor";
+
+export class DynamicActorEvent<P extends Player, A extends DynamicActor> {
+  private readonly actors = new Map<number, A>();
+  private readonly players;
+
+  constructor(playersMap: Map<number, P>, destroyOnExit = true) {
+    this.players = playersMap;
+    actorBus.on(actorHooks.created, (actor: A) => {
+      this.actors.set(actor.id, actor);
+    });
+    actorBus.on(actorHooks.destroyed, (actor: A) => {
+      this.actors.delete(actor.id);
+    });
+    if (destroyOnExit) {
+      OnGameModeExit(() => {
+        this.actors.forEach((a) => a.destroy());
+        this.actors.clear();
+      });
+    }
+    OnDynamicActorStreamIn((actorid: number, forplayerid: number): number => {
+      const act = this.actors.get(actorid);
+      if (!act) return 0;
+      const p = this.players.get(forplayerid);
+      if (!p) return 0;
+      const pFn = promisifyCallback(
+        this,
+        "onStreamIn",
+        "OnDynamicActorStreamIn"
+      );
+      return pFn(act, p);
+    });
+    OnDynamicActorStreamOut((actorid: number, forplayerid: number): number => {
+      const act = this.actors.get(actorid);
+      if (!act) return 0;
+      const p = this.players.get(forplayerid);
+      if (!p) return 0;
+      const pFn = promisifyCallback(
+        this,
+        "onStreamOut",
+        "OnDynamicActorStreamOut"
+      );
+      return pFn(act, p);
+    });
+    OnPlayerGiveDamageDynamicActor(
+      (
+        playerid: number,
+        actorid: number,
+        amount: number,
+        weaponid: number,
+        bodypart: number
+      ): number => {
+        const act = this.actors.get(actorid);
+        if (!act) return 0;
+        const p = this.players.get(playerid);
+        if (!p) return 0;
+        const pFn = promisifyCallback(
+          this,
+          "onPlayerGiveDamage",
+          "OnPlayerGiveDamageDynamicActor"
+        );
+        return pFn(p, act, amount, weaponid, bodypart);
+      }
+    );
+  }
+
+  onStreamIn?(actor: A, player: P): TCommonCallback;
+  onStreamOut?(actor: A, player: P): TCommonCallback;
+  onPlayerGiveDamage?(
+    player: P,
+    actor: A,
+    amount: number,
+    weaponid: number,
+    bodypart: BodyPartsEnum
+  ): TCommonCallback;
+
+  getActorsArr(): Array<A> {
+    return [...this.actors.values()];
+  }
+
+  getActorsMap(): Map<number, A> {
+    return this.actors;
+  }
+}

package/src/wrapper/streamer/actor/baseActor.ts

@@ -0,0 +1,278 @@
+import type { Player } from "@/controllers/player";
+import type { IDynamicActor } from "@/interfaces";
+import { logger } from "@/logger";
+import { getAnimateDurationByLibName } from "@/utils/animateUtils";
+import {
+  GetActorSkin,
+  SetActorSkin,
+  GetActorSpawnInfo,
+  GetActorAnimation,
+} from "@infernus/wrapper";
+
+import {
+  ApplyDynamicActorAnimation,
+  ClearDynamicActorAnimations,
+  CreateDynamicActor,
+  CreateDynamicActorEx,
+  DestroyDynamicActor,
+  GetDynamicActorFacingAngle,
+  GetDynamicActorHealth,
+  GetDynamicActorPos,
+  GetDynamicActorVirtualWorld,
+  GetPlayerCameraTargetDynActor,
+  GetPlayerTargetDynamicActor,
+  IsDynamicActorInvulnerable,
+  IsDynamicActorStreamedIn,
+  IsValidDynamicActor,
+  SetDynamicActorFacingAngle,
+  SetDynamicActorHealth,
+  SetDynamicActorInvulnerable,
+  SetDynamicActorPos,
+  SetDynamicActorVirtualWorld,
+  StreamerDistances,
+  StreamerItemTypes,
+} from "@infernus/streamer";
+import { Streamer } from "../common";
+import { actorBus, actorHooks } from "./actorBus";
+
+export class DynamicActor {
+  private sourceInfo: IDynamicActor;
+  private _id = -1;
+  get id(): number {
+    return this._id;
+  }
+  constructor(actor: IDynamicActor) {
+    this.sourceInfo = actor;
+  }
+  create(): void | this {
+    if (this.id !== -1)
+      return logger.warn("[StreamerActor]: Unable to create actor again");
+    let { streamdistance, worldid, interiorid, playerid, areaid, priority } =
+      this.sourceInfo;
+    const { modelid, x, y, z, r, invulnerable, health, extended } =
+      this.sourceInfo;
+
+    streamdistance ??= StreamerDistances.ACTOR_SD;
+    priority ??= 0;
+
+    if (extended) {
+      if (typeof worldid === "number") worldid = [0];
+      else worldid ??= [0];
+      if (typeof interiorid === "number") interiorid = [-1];
+      else interiorid ??= [-1];
+      if (typeof playerid === "number") playerid = [-1];
+      else playerid ??= [-1];
+      if (typeof areaid === "number") areaid = [-1];
+      else areaid ??= [-1];
+
+      this._id = CreateDynamicActorEx(
+        modelid,
+        x,
+        y,
+        z,
+        r,
+        invulnerable,
+        health,
+        streamdistance,
+        worldid,
+        interiorid,
+        playerid,
+        areaid,
+        priority
+      );
+    } else {
+      if (Array.isArray(worldid)) worldid = 0;
+      else worldid ??= 0;
+      if (Array.isArray(interiorid)) interiorid = -1;
+      else interiorid ??= -1;
+      if (Array.isArray(playerid)) playerid = -1;
+      else playerid ??= -1;
+      if (Array.isArray(areaid)) areaid = -1;
+      else areaid ??= -1;
+
+      this._id = CreateDynamicActor(
+        modelid,
+        x,
+        y,
+        z,
+        r,
+        invulnerable,
+        health,
+        worldid,
+        interiorid,
+        playerid,
+        streamdistance,
+        areaid,
+        priority
+      );
+    }
+
+    actorBus.emit(actorHooks.created, this);
+    return this;
+  }
+  destroy(): void | this {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to destroy the actor before create"
+      );
+    DestroyDynamicActor(this.id);
+    actorBus.emit(actorHooks.destroyed, this);
+    return this;
+  }
+  isValid(): boolean {
+    return IsValidDynamicActor(this.id);
+  }
+  isStreamedIn<P extends Player>(forplayer: P): boolean {
+    if (this.id === -1) return false;
+    return IsDynamicActorStreamedIn(this.id, forplayer.id);
+  }
+  getVirtualWorld(): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to get virtual world before create"
+      );
+    return GetDynamicActorVirtualWorld(this.id);
+  }
+  setVirtualWorld(vworld: number): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to set virtual world before create"
+      );
+    return SetDynamicActorVirtualWorld(this.id, vworld);
+  }
+  applyAnimation(
+    animLib: string,
+    animName: string,
+    loop = false,
+    lockX = true,
+    lockY = true,
+    freeze = false
+  ): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to apply animation before create"
+      );
+    const duration = getAnimateDurationByLibName(animLib, animName);
+    if (duration === undefined)
+      return logger.error("[StreamerActor]: Invalid anim library or name");
+    return ApplyDynamicActorAnimation(
+      this.id,
+      animLib,
+      animName,
+      4.1,
+      loop,
+      lockX,
+      lockY,
+      freeze,
+      loop ? 0 : duration
+    );
+  }
+  clearAnimations(): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to clear animation before create"
+      );
+    return ClearDynamicActorAnimations(this.id);
+  }
+  getFacingAngle(): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to get facing angle before create"
+      );
+    return GetDynamicActorFacingAngle(this.id);
+  }
+  setFacingAngle(ang: number): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to set facing angle before create"
+      );
+    return SetDynamicActorFacingAngle(this.id, ang);
+  }
+  getPos() {
+    if (this.id === -1)
+      return logger.warn("[StreamerActor]: Unable to get pos before create");
+    return GetDynamicActorPos(this.id);
+  }
+  setPos(x: number, y: number, z: number): void | number {
+    if (this.id === -1)
+      return logger.warn("[StreamerActor]: Unable to set pos before create");
+    return SetDynamicActorPos(this.id, x, y, z);
+  }
+  getHealth(): void | number {
+    if (this.id === -1)
+      return logger.warn("[StreamerActor]: Unable to get health before create");
+    return GetDynamicActorHealth(this.id);
+  }
+  setHealth(health: number): void | number {
+    if (this.id === -1)
+      return logger.warn("[StreamerActor]: Unable to set health before create");
+    return SetDynamicActorHealth(this.id, health);
+  }
+  isInvulnerable(): boolean {
+    if (this.id === -1) return false;
+    return IsDynamicActorInvulnerable(this.id);
+  }
+  setInvulnerable(invulnerable = true): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to set invulnerable before create"
+      );
+    return SetDynamicActorInvulnerable(this.id, invulnerable);
+  }
+  getPlayerTarget<P extends Player, A extends DynamicActor>(
+    player: P,
+    actors: Map<number, A>
+  ): void | A {
+    if (this.id === -1) return undefined;
+    const actorId = GetPlayerTargetDynamicActor(player.id);
+    return actors.get(actorId);
+  }
+  getPlayerCameraTarget<P extends Player, A extends DynamicActor>(
+    player: P,
+    actors: Map<number, A>
+  ): void | A {
+    if (this.id === -1) return undefined;
+    const actorId = GetPlayerCameraTargetDynActor(player.id);
+    return actors.get(actorId);
+  }
+  getSkin(): void | number {
+    if (this.id === -1)
+      return logger.warn("[StreamerActor]: Unable to get skin before create");
+    return GetActorSkin(this.id);
+  }
+  setSkin(model: number, ignoreRange = false): void | number {
+    if (this.id === -1)
+      return logger.warn("[StreamerActor]: Unable to set skin before create");
+    if (!ignoreRange && (model < 0 || model > 311 || model == 74)) return 0;
+    return SetActorSkin(this.id, model);
+  }
+  getSpawnInfo() {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to get spawn info before create"
+      );
+    return GetActorSpawnInfo(this.id);
+  }
+  getAnimation() {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to get animation before create"
+      );
+    return GetActorAnimation(this.id);
+  }
+  toggleCallbacks(toggle = true): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerActor]: Unable to toggle callbacks before create"
+      );
+    return Streamer.toggleItemCallbacks(
+      StreamerItemTypes.ACTOR,
+      this.id,
+      toggle
+    );
+  }
+  isToggleCallbacks(): boolean {
+    if (this.id === -1) false;
+    return Streamer.isToggleItemCallbacks(StreamerItemTypes.ACTOR, this.id);
+  }
+}

package/src/wrapper/streamer/actor/index.ts

@@ -0,0 +1,2 @@
+export * from "./baseActor";
+export * from "./actorEvent";

package/src/wrapper/streamer/area/areaBus.ts

@@ -0,0 +1,8 @@
+import { EventBus } from "@/utils/eventBus";
+
+export enum areaHooks {
+  created = "OnAreaCreate",
+  destroyed = "OnAreaDestroy",
+}
+
+export const areaBus = new EventBus();