pma-locals 1.0.0

package/client/main.ts

@@ -0,0 +1,33 @@
+import { Delay, Vector3 } from "@nativewrappers/redm";
+import { cleanupPeds, processSpawning } from "./ped-handler";
+
+// Example: Register peds with their spawn coordinates
+// registerPed(
+// 	0x12345678, // model hash
+// 	new Vector3(-297.74, 791.1, 118.4), // spawn coords
+// 	180.0, // heading
+// 	50.0, // spawn distance
+// 	{ dict: "amb_wander@world_human_smoke@male@male_a@idle_a", anim: "idle_a" }, // optional animation
+// 	undefined // optional prop data
+// );
+
+setTick(async () => {
+	const playerPed = PlayerPedId();
+	if (!playerPed) {
+		await Delay(500);
+		return;
+	}
+
+	const coords = GetEntityCoords(playerPed, true, true);
+	const playerPos = new Vector3(coords[0], coords[1], coords[2]);
+
+	await processSpawning(playerPos);
+
+	await Delay(500);
+});
+
+on("onResourceStop", (resourceName: string) => {
+	if (resourceName !== GetCurrentResourceName()) return;
+	console.log(`Restarting ${resourceName}`);
+	cleanupPeds();
+});

package/client/ped-handler.ts

@@ -0,0 +1,151 @@
+import { Animation, Props } from "$types/index";
+import {
+    AnimationFlags,
+    createPed,
+    createProp,
+    IkControlFlags,
+    Model,
+    Prop,
+    Vector3,
+} from "@nativewrappers/redm";
+
+export interface PedConfig {
+    modelName: number;
+    coords: Vector3;
+    heading: number;
+    spawnDistance: number;
+    animation?: Animation;
+    propData?: Props;
+}
+
+interface ActivePedData {
+    ped: any;
+    config: PedConfig;
+    prop: Prop | null;
+}
+
+// Module-level state
+const pedConfigs: PedConfig[] = [];
+const activePeds: Map<string, ActivePedData> = new Map();
+
+export function registerPed(
+    modelName: number,
+    coords: Vector3,
+    heading: number,
+    spawnDistance: number = 100.0,
+    animation?: Animation,
+    propData?: Props
+) {
+    pedConfigs.push({
+        modelName,
+        coords,
+        heading,
+        spawnDistance,
+        animation,
+        propData,
+    });
+}
+
+function getConfigKey(config: PedConfig): string {
+    return `${config.coords.x}_${config.coords.y}_${config.coords.z}`;
+}
+
+function isPlayerNearCoords(playerPos: Vector3, targetPos: Vector3, distance: number): boolean {
+    const dx = playerPos.x - targetPos.x;
+    const dy = playerPos.y - targetPos.y;
+    const dz = playerPos.z - targetPos.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz) <= distance;
+}
+
+export async function processSpawning(playerPos: Vector3) {
+    for (const config of pedConfigs) {
+        const key = getConfigKey(config);
+        const isNear = isPlayerNearCoords(playerPos, config.coords, config.spawnDistance);
+        const isSpawned = activePeds.has(key);
+
+        if (isNear && !isSpawned) {
+            // Player is within range and ped is not spawned -> spawn it
+            await spawnPed(config, key);
+        } else if (!isNear && isSpawned) {
+            // Player is outside range and ped is spawned -> delete it
+            despawnPed(key);
+        }
+    }
+}
+
+async function spawnPed(config: PedConfig, key: string) {
+    const ped = await createPed(new Model(config.modelName), config.coords, 0.0, false, true);
+    if (!ped) return;
+    SetRandomOutfitVariation(ped.Handle, true);
+    if (config.heading) {
+        ped.Heading = config.heading;
+    }
+
+    if (config.animation) {
+        await ped.Tasks.playAnimation(
+            config.animation.dict,
+            config.animation.anim,
+            8.0,
+            8.0,
+            -1,
+            1,
+            AnimationFlags.Looping,
+            IkControlFlags.UpperBody
+        );
+    }
+
+    let prop: Prop | null = null;
+    if (config.propData) {
+        prop = await createProp(new Model(config.propData.model), ped.Position, 0, true, true);
+        if (prop) {
+            AttachEntityToEntity(
+                prop.Handle,
+                ped.Handle,
+                config.propData.boneId,
+                config.propData.offset[0],
+                config.propData.offset[1],
+                config.propData.offset[2],
+                config.propData.rotation[0],
+                config.propData.rotation[1],
+                config.propData.rotation[2],
+                true,
+                false,
+                false,
+                true,
+                1,
+                true
+            );
+        }
+    }
+
+    activePeds.set(key, { ped, config, prop });
+}
+
+function despawnPed(key: string) {
+    const activePed = activePeds.get(key);
+    if (!activePed) return;
+
+    if (activePed.prop) {
+        activePed.prop.delete();
+    }
+
+    if (activePed.ped) {
+        activePed.ped.delete();
+    }
+
+    activePeds.delete(key);
+}
+
+export function cleanupPeds() {
+    for (const [key, activePed] of activePeds) {
+        if (activePed.prop) {
+            activePed.prop.delete();
+        }
+
+        if (activePed.ped) {
+            activePed.ped.delete();
+        }
+
+        activePeds.delete(key);
+    }
+}

package/client/tsconfig.json

@@ -0,0 +1,29 @@
+{
+    "extends": "../tsconfig.json",
+    "compilerOptions": {
+        "baseUrl": ".",
+        "composite": true,
+        "types": [
+            "@types/node",
+            "@citizenfx/client",
+            "@nativewrappers/redm",
+            "../definitions/index.ts"
+        ],
+        "paths": {
+            "$types/*": [
+                "../types/*",
+                "../definitions/index.ts"
+            ],
+            "$shared/*": [
+                "../shared/*"
+            ]
+        },
+        "resolveJsonModule": true,
+        "esModuleInterop": true
+    },
+    "include": [
+        "./",
+        "../types/*",
+        "../shared/*",
+    ]
+}

package/definitions/Citizen.d.ts

@@ -0,0 +1,205 @@
+/* eslint-disable */
+
+interface IntPtrInitialized {}
+interface FloatPtrInitialized {}
+interface IntPtr {}
+interface FloatPtr {}
+interface VectorPtr {}
+interface ReturnResultAnyway {}
+interface ResultAsInteger {}
+interface ResultAsFloat {}
+interface ResultAsString {}
+interface ResultAsVector {}
+interface ResultAsLong {}
+interface ResultAsObject {}
+
+type InputArgument =
+  | string
+  | number
+  | IntPtrInitialized
+  | FloatPtrInitialized
+  | IntPtr
+  | FloatPtr
+  | VectorPtr
+  | ReturnResultAnyway
+  | ResultAsInteger
+  | ResultAsFloat
+  | ResultAsString
+  | ResultAsVector
+  | ResultAsLong
+  | ResultAsObject;
+
+interface StateBagInterface {
+  [key: string]: any;
+  set(key: string, value: any, replicated: boolean): void;
+}
+
+interface EntityInterface {
+  state: StateBagInterface;
+}
+
+interface CitizenInterface {
+  trace(...args: string[]): void;
+  setTickFunction(callback: Function): void;
+  setEventFunction(callback: Function): void;
+
+  setCallRefFunction(callback: Function): void;
+  setDeleteRefFunction(callback: Function): void;
+  setDuplicateRefFunction(callback: Function): void;
+  canonicalizeRef(ref: number): string;
+  invokeFunctionReference(ref: string, args: Uint8Array): Uint8Array;
+
+  getTickCount(): number;
+  invokeNative<T = void>(hash: string, ...args: InputArgument[]): T;
+  invokeNativeByHash<T = void>(
+    hash1: number,
+    hash2: number,
+    ...args: InputArgument[]
+  ): T;
+  startProfiling(name?: string): void;
+  stopProfiling(name?: string): {};
+
+  pointerValueIntInitialized(): IntPtrInitialized;
+  pointerValueFloatInitialized(): FloatPtrInitialized;
+  pointerValueInt(): IntPtr;
+  pointerValueFloat(): FloatPtr;
+  pointerValueVector(): VectorPtr;
+  returnResultAnyway(): ReturnResultAnyway;
+  resultAsInteger(): ResultAsInteger;
+  resultAsFloat(): ResultAsFloat;
+  resultAsString(): ResultAsString;
+  resultAsVector(): ResultAsVector;
+  resultAsLong(): ResultAsLong;
+  resultAsObject(): ResultAsObject;
+
+  makeRefFunction(refFunction: Function): string;
+}
+
+interface CitizenTimer {
+  ref(): CitizenTimer;
+  unref(): CitizenTimer;
+  hasRef(): boolean;
+  refresh(): CitizenTimer;
+  [Symbol.toPrimitive](): number;
+}
+
+type CitizenImmediate = Omit<CitizenTimer, "refresh">;
+
+declare let Citizen: CitizenInterface;
+
+declare function addRawEventListener(
+  eventName: string,
+  callback: Function,
+): void;
+
+declare function addEventListener(
+  eventName: string,
+  callback: Function,
+  netSafe?: boolean,
+): void;
+declare function on(eventName: string, callback: Function): void;
+declare function AddEventHandler(eventName: string, callback: Function): void;
+
+declare function addNetEventListener(
+  eventName: string,
+  callback: Function,
+): void;
+declare function onNet(eventName: string, callback: Function): void;
+
+declare function emit(eventName: string, ...args: any[]): void;
+declare function TriggerEvent(eventName: string, ...args: any[]): void;
+
+declare function emitNet(eventName: string, ...args: any[]): void;
+declare function TriggerServerEvent(eventName: string, ...args: any[]): void;
+declare function TriggerLatentServerEvent(
+  eventName: string,
+  bps: number,
+  ...args: any[]
+): void;
+
+declare function getPlayerIdentifiers(player: number | string): string[];
+declare function getPlayerTokens(player: number | string): string[];
+declare function getPlayers(): string[];
+
+declare function SendNUIMessage(data: any): void;
+
+declare function emitNet(
+  eventName: string,
+  target: number | string,
+  ...args: any[]
+): void;
+declare function TriggerClientEvent(
+  eventName: string,
+  target: number | string,
+  ...args: any[]
+): void;
+declare function TriggerLatentClientEvent(
+  eventName: string,
+  target: number | string,
+  bps: number,
+  ...args: any[]
+): void;
+
+declare function removeEventListener(
+  eventName: string,
+  callback: Function,
+): void;
+
+declare function setTimeout<T extends any[]>(
+  callback: (...args: T) => void,
+  ms?: number,
+  ...args: T
+): CitizenTimer;
+declare function clearTimeout(timeout: CitizenTimer): void;
+
+declare function setInterval<T extends any[]>(
+  callback: (...args: T) => void,
+  ms?: number,
+  ...args: T
+): CitizenTimer;
+declare function clearInterval(interval: CitizenTimer): void;
+
+declare function setImmediate<T extends any[]>(
+  callback: (...args: T) => void,
+  ...args: T
+): CitizenImmediate;
+declare function clearImmediate(immediate: CitizenImmediate): void;
+
+declare function setTick(callback: Function): number;
+declare function clearTick(callback: number): void;
+
+declare function NewStateBag(name: string): StateBagInterface;
+declare function Entity(entity: number): EntityInterface;
+declare let GlobalState: StateBagInterface;
+declare function Player(entity: number | string): EntityInterface;
+declare let LocalPlayer: EntityInterface;
+
+declare let exports: any;
+
+declare let source: number;
+
+// Commented methods are not implemented yet
+interface Console {
+  assert(condition?: boolean, ...data: any[]): void;
+  // clear(): void;
+  count(label?: string): void;
+  countReset(label?: string): void;
+  debug(...data: any[]): void;
+  dir(item?: any, options?: any): void;
+  // dirxml(...data: any[]): void;
+  error(...data: any[]): void;
+  // group(...data: any[]): void;
+  // groupCollapsed(...data: any[]): void;
+  // groupEnd(): void;
+  info(...data: any[]): void;
+  log(...data: any[]): void;
+  // table(tabularData?: any, properties?: string[]): void;
+  time(label?: string): void;
+  timeEnd(label?: string): void;
+  // timeLog(label?: string, ...data: any[]): void;
+  // timeStamp(label?: string): void;
+  trace(...data: any[]): void;
+  warn(...data: any[]): void;
+}
+
+declare let console: Console;

package/definitions/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="./Citizen.d.ts" />
+/// <reference path="./redm.d.ts" />
+/// <reference path="./json.d.ts" />
+/// <reference path="../web/src/png.d.ts" />

package/definitions/json.d.ts

@@ -0,0 +1,4 @@
+declare module "*.json" {
+    const value: any;
+    export default value;
+  }