@infernus/core 0.8.7

package/src/wrapper/streamer/pickup/pickupBus.ts

@@ -0,0 +1,8 @@
+import { EventBus } from "@/utils/eventBus";
+
+export enum pickupHooks {
+  created = "OnPickupCreate",
+  destroyed = "OnPickupDestroy",
+}
+
+export const pickupBus = new EventBus();

package/src/wrapper/streamer/pickup/pickupEvent.ts

@@ -0,0 +1,84 @@
+import type { Player } from "@/controllers/player";
+import type { TCommonCallback } from "@/types";
+import { promisifyCallback } from "@/utils/helperUtils";
+import { OnGameModeExit } from "@/wrapper/native/callbacks";
+import {
+  OnPlayerPickUpDynamicPickup,
+  StreamerItemTypes,
+} from "@infernus/streamer";
+import { Streamer } from "../common";
+import type { DynamicPickup } from "./basePickup";
+import { pickupBus, pickupHooks } from "./pickupBus";
+
+export class DynamicPickupEvent<P extends Player, K extends DynamicPickup> {
+  private readonly pickups = new Map<number, K>();
+  private readonly players;
+
+  constructor(playersMap: Map<number, P>, destroyOnExit = true) {
+    this.players = playersMap;
+    pickupBus.on(pickupHooks.created, (pickup: K) => {
+      this.pickups.set(pickup.id, pickup);
+    });
+    pickupBus.on(pickupHooks.destroyed, (pickup: K) => {
+      this.pickups.delete(pickup.id);
+    });
+    if (destroyOnExit) {
+      OnGameModeExit(() => {
+        this.pickups.forEach((p) => p.destroy());
+        this.pickups.clear();
+      });
+    }
+    OnPlayerPickUpDynamicPickup(
+      (playerid: number, pickupid: number): number => {
+        const k = this.pickups.get(pickupid);
+        if (!k) return 0;
+        const p = this.players.get(playerid);
+        if (!p) return 0;
+        const pFn = promisifyCallback(
+          this,
+          "onPlayerPickUp",
+          "OnPlayerPickUpDynamicPickup"
+        );
+        return pFn(p, k);
+      }
+    );
+    Streamer.onItemStreamIn((type, item, player) => {
+      if (type === StreamerItemTypes.PICKUP) {
+        const pk = this.pickups.get(item);
+        const p = this.players.get(player);
+        if (pk && p)
+          return promisifyCallback(
+            this,
+            "onStreamIn",
+            "Streamer_OnItemStreamIn"
+          )(pk, p);
+      }
+      return 1;
+    });
+    Streamer.onItemStreamOut((type, item, player) => {
+      if (type === StreamerItemTypes.PICKUP) {
+        const pk = this.pickups.get(item);
+        const p = this.players.get(player);
+        if (pk && p)
+          return promisifyCallback(
+            this,
+            "onStreamOut",
+            "Streamer_OnItemStreamOut"
+          )(pk, p);
+      }
+      return 1;
+    });
+  }
+
+  onPlayerPickUp?(player: P, pickup: K): TCommonCallback;
+  onStreamIn?(pickup: K, player: P): TCommonCallback;
+  onStreamOut?(pickup: K, player: P): TCommonCallback;
+
+  getPickupsArr(): Array<K> {
+    return [...this.pickups.values()];
+  }
+
+  getPickupsMap(): Map<number, K> {
+    return this.pickups;
+  }
+}

package/src/wrapper/streamer/raceCP/baseRaceCP.ts

@@ -0,0 +1,151 @@
+import type { Player } from "@/controllers/player";
+import type { IDynamicRaceCp } from "@/interfaces";
+
+import { logger } from "@/logger";
+import {
+  CreateDynamicRaceCP,
+  CreateDynamicRaceCPEx,
+  DestroyDynamicCP,
+  GetPlayerVisibleDynamicRaceCP,
+  IsPlayerInDynamicRaceCP,
+  IsValidDynamicCP,
+  StreamerDistances,
+  StreamerItemTypes,
+  TogglePlayerAllDynamicRaceCPs,
+  TogglePlayerDynamicRaceCP,
+} from "@infernus/streamer";
+import { Streamer } from "../common";
+
+import { raceCPBus, raceCPHooks } from "./raceCPBus";
+
+export class DynamicRaceCP {
+  private sourceInfo: IDynamicRaceCp;
+  private _id = -1;
+  get id(): number {
+    return this._id;
+  }
+  constructor(checkPoint: IDynamicRaceCp) {
+    this.sourceInfo = checkPoint;
+  }
+  create(): void | this {
+    if (this.id !== -1)
+      return logger.warn("[StreamerRaceCP]: Unable to create checkpoint again");
+    let { streamdistance, worldid, interiorid, playerid, areaid, priority } =
+      this.sourceInfo;
+    const { type, size, x, y, z, nextx, nexty, nextz, extended } =
+      this.sourceInfo;
+
+    if (type < 0 || type > 8)
+      return logger.error("[StreamerRaceCP]: Invalid type");
+
+    if (size < 0) return logger.error("[StreamerRaceCP]: Invalid size");
+
+    streamdistance ??= StreamerDistances.RACE_CP_SD;
+    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 = CreateDynamicRaceCPEx(
+        type,
+        x,
+        y,
+        z,
+        nextx,
+        nexty,
+        nextz,
+        size,
+        streamdistance,
+        worldid,
+        interiorid,
+        playerid,
+        areaid,
+        priority
+      );
+    } 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 = CreateDynamicRaceCP(
+        type,
+        x,
+        y,
+        z,
+        nextx,
+        nexty,
+        nextz,
+        size,
+        worldid,
+        interiorid,
+        playerid,
+        streamdistance,
+        areaid,
+        priority
+      );
+    }
+
+    raceCPBus.emit(raceCPHooks.created, this);
+    return this;
+  }
+  destroy(): void | this {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerRaceCP]: Unable to destroy the checkpoint before create"
+      );
+    DestroyDynamicCP(this.id);
+    raceCPBus.emit(raceCPHooks.destroyed, this);
+    return this;
+  }
+  isValid(): boolean {
+    return IsValidDynamicCP(this.id);
+  }
+  togglePlayer<P extends Player>(player: P, toggle: boolean): void | this {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerRaceCP]: Unable to toggle the player before create"
+      );
+    TogglePlayerDynamicRaceCP(player.id, this.id, toggle);
+    return this;
+  }
+  static togglePlayerAll<P extends Player>(player: P, toggle: boolean): number {
+    return TogglePlayerAllDynamicRaceCPs(player.id, toggle);
+  }
+  isPlayerIn<P extends Player>(player: P): boolean {
+    if (this.id === -1) return false;
+    return IsPlayerInDynamicRaceCP(player.id, this.id);
+  }
+  static getPlayerVisible<P extends Player, C extends DynamicRaceCP>(
+    player: P,
+    checkpoints: Map<number, C>
+  ): C | undefined {
+    return checkpoints.get(GetPlayerVisibleDynamicRaceCP(player.id));
+  }
+  toggleCallbacks(toggle = true): void | number {
+    if (this.id === -1)
+      return logger.warn(
+        "[StreamerRaceCP]: Unable to toggle callbacks before create"
+      );
+    return Streamer.toggleItemCallbacks(
+      StreamerItemTypes.RACE_CP,
+      this.id,
+      toggle
+    );
+  }
+  isToggleCallbacks(): boolean {
+    if (this.id === -1) false;
+    return Streamer.isToggleItemCallbacks(StreamerItemTypes.RACE_CP, this.id);
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from "./baseRaceCP";
+export * from "./raceCPEvent";

package/src/wrapper/streamer/raceCP/raceCPBus.ts

@@ -0,0 +1,8 @@
+import { EventBus } from "@/utils/eventBus";
+
+export enum raceCPHooks {
+  created = "OnRaceCPCreate",
+  destroyed = "OnRaceCPDestroy",
+}
+
+export const raceCPBus = new EventBus();

package/src/wrapper/streamer/raceCP/raceCPEvent.ts

@@ -0,0 +1,100 @@
+import type { Player } from "@/controllers/player";
+import type { TCommonCallback } from "@/types";
+import { promisifyCallback } from "@/utils/helperUtils";
+import { OnGameModeExit } from "@/wrapper/native/callbacks";
+import {
+  OnPlayerEnterDynamicRaceCP,
+  OnPlayerLeaveDynamicRaceCP,
+  StreamerItemTypes,
+} from "@infernus/streamer";
+import { Streamer } from "../common";
+import type { DynamicRaceCP } from "./baseRaceCP";
+import { raceCPBus, raceCPHooks } from "./raceCPBus";
+
+export class DynamicRaceCPEvent<P extends Player, R extends DynamicRaceCP> {
+  private readonly raceCPs = new Map<number, R>();
+  private readonly players;
+
+  constructor(playersMap: Map<number, P>, destroyOnExit = true) {
+    this.players = playersMap;
+    raceCPBus.on(raceCPHooks.created, (checkpoint: R) => {
+      this.raceCPs.set(checkpoint.id, checkpoint);
+    });
+    raceCPBus.on(raceCPHooks.destroyed, (checkpoint: R) => {
+      this.raceCPs.delete(checkpoint.id);
+    });
+    if (destroyOnExit) {
+      OnGameModeExit(() => {
+        this.raceCPs.forEach((r) => r.destroy());
+        this.raceCPs.clear();
+      });
+    }
+    OnPlayerEnterDynamicRaceCP(
+      (playerid: number, checkpointid: number): number => {
+        const cp = this.raceCPs.get(checkpointid);
+        if (!cp) return 0;
+        const p = this.players.get(playerid);
+        if (!p) return 0;
+        const pFn = promisifyCallback(
+          this,
+          "onPlayerEnter",
+          "OnPlayerEnterDynamicRaceCP"
+        );
+        return pFn(p, cp);
+      }
+    );
+    OnPlayerLeaveDynamicRaceCP(
+      (playerid: number, checkpointid: number): number => {
+        const cp = this.raceCPs.get(checkpointid);
+        if (!cp) return 0;
+        const p = this.players.get(playerid);
+        if (!p) return 0;
+        const pFn = promisifyCallback(
+          this,
+          "onPlayerLeave",
+          "OnPlayerLeaveDynamicRaceCP"
+        );
+        return pFn(p, cp);
+      }
+    );
+    Streamer.onItemStreamIn((type, item, player) => {
+      if (type === StreamerItemTypes.RACE_CP) {
+        const cp = this.raceCPs.get(item);
+        const p = this.players.get(player);
+        if (cp && p)
+          return promisifyCallback(
+            this,
+            "onStreamIn",
+            "Streamer_OnItemStreamIn"
+          )(cp, p);
+      }
+      return 1;
+    });
+    Streamer.onItemStreamOut((type, item, player) => {
+      if (type === StreamerItemTypes.RACE_CP) {
+        const cp = this.raceCPs.get(item);
+        const p = this.players.get(player);
+        if (cp && p)
+          return promisifyCallback(
+            this,
+            "onStreamOut",
+            "Streamer_OnItemStreamOut"
+          )(cp, p);
+      }
+      return 1;
+    });
+  }
+
+  onPlayerEnter?(player: P, checkpoint: R): TCommonCallback;
+  onPlayerLeave?(player: P, checkpoint: R): TCommonCallback;
+  onStreamIn?(checkpoint: R, player: P): TCommonCallback;
+  onStreamOut?(checkpoint: R, player: P): TCommonCallback;
+
+  getRaceCPsArr(): Array<R> {
+    return [...this.raceCPs.values()];
+  }
+
+  getRaceCPsMap(): Map<number, R> {
+    return this.raceCPs;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "include": ["src/**/*.ts"],
+  "compilerOptions": {
+    "types": ["@sa-mp/node"],
+    "baseUrl": "./",
+    "paths": { "@/*": ["src/*"] },
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "removeComments": true
+  }
+}