pma-locals 1.0.1 → 1.0.3

package/README.md

@@ -1,55 +1,77 @@
 # pma-locals
 
-RedM ped spawning and management library with full TypeScript support.
+Modern TypeScript library for managing RedM ped spawning and animations.
 
 ## Installation
 
 ```bash
 npm install pma-locals
+# or
+pnpm add pma-locals
 ```
 
 ## Usage
 
 ```typescript
-import { registerPed } from "pma-locals";
-import { Vector3 } from "@nativewrappers/redm";
+import { registerPed, processSpawning } from "pma-locals";
+import { Vector3, Delay } from "@nativewrappers/redm";
 
 // Register a ped with animation
 registerPed(
 	0x12345678, // model hash
 	new Vector3(-297.74, 791.1, 118.4), // spawn coords
 	180.0, // heading
-	50.0, // spawn distance
+	50.0, // spawn distance (optional, default: 100.0)
 	{
 		dict: "amb_wander@world_human_smoke@male@male_a@idle_a",
 		anim: "idle_a",
 	}, // optional animation
 	undefined // optional prop data
 );
+
+// In your game loop
+setTick(async () => {
+	const playerPed = PlayerPedId();
+	if (!playerPed) return;
+
+	const coords = GetEntityCoords(playerPed, true, true);
+	const playerPos = new Vector3(coords[0], coords[1], coords[2]);
+
+	await processSpawning(playerPos);
+	await Delay(500);
+});
 ```
 
 ## API
 
 ### `registerPed(modelName, coords, heading, spawnDistance?, animation?, propData?)`
 
-Registers a ped to be spawned when players are nearby.
+Register a ped to spawn when players approach.
 
 **Parameters:**
 
--   `modelName` (number): The model hash
+-   `modelName` (number): Model hash
 -   `coords` (Vector3): Spawn coordinates
 -   `heading` (number): Ped heading direction
--   `spawnDistance` (number, optional): Distance at which to spawn (default: 100.0)
--   `animation` (Animation, optional): Animation data
--   `propData` (Props, optional): Prop attachment data
+-   `spawnDistance` (number): Distance threshold (default: 100.0)
+-   `animation` (Animation): Optional animation data
+-   `propData` (Props): Optional prop attachment
 
-### `processSpawning(playerPos)`
+### `processSpawning(playerPos: Vector3)`
 
-Process ped spawning/despawning based on player position.
+Update ped spawning based on player position. Call this in your game loop.
 
 ### `cleanupPeds()`
 
-Clean up all spawned peds.
+Delete all spawned peds (useful for resource cleanup).
+
+## Types
+
+Full TypeScript support with exported types:
+
+-   `PedConfig`
+-   `Animation`
+-   `Props`
 
 ## License
 

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { Vector3 } from '@nativewrappers/redm';
+
+interface Animation {
+    dict: string;
+    anim: string;
+}
+interface Props {
+    model: string;
+    boneId: number;
+    offset: number[];
+    rotation: number[];
+}
+
+interface PedConfig {
+    modelName: string;
+    coords: Vector3;
+    heading: number;
+    spawnDistance: number;
+    animation?: Animation;
+    propData?: Props;
+}
+declare function registerPed(modelName: string, coords: Vector3, heading: number, spawnDistance?: number, animation?: Animation, propData?: Props): void;
+declare function processSpawning(playerPos: Vector3): Promise<void>;
+declare function cleanupPeds(): void;
+
+export { type Animation, type PedConfig, type Props, cleanupPeds, processSpawning, registerPed };

package/dist/index.js

@@ -1,6 +1,104 @@
-import { registerPed, processSpawning, cleanupPeds } from "./client/ped-handler";
-export {
-  cleanupPeds,
-  processSpawning,
-  registerPed
-};
+import { createPed, Model, AnimationFlags, IkControlFlags, createProp } from '@nativewrappers/redm';
+
+// client/ped-handler.ts
+var pedConfigs = [];
+var activePeds = /* @__PURE__ */ new Map();
+function registerPed(modelName, coords, heading, spawnDistance = 100, animation, propData) {
+  pedConfigs.push({
+    modelName,
+    coords,
+    heading,
+    spawnDistance,
+    animation,
+    propData
+  });
+}
+function getConfigKey(config) {
+  return `${config.coords.x}_${config.coords.y}_${config.coords.z}`;
+}
+function isPlayerNearCoords(playerPos, targetPos, distance) {
+  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;
+}
+async function processSpawning(playerPos) {
+  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) {
+      await spawnPed(config, key);
+    } else if (!isNear && isSpawned) {
+      despawnPed(key);
+    }
+  }
+}
+async function spawnPed(config, key) {
+  const ped = await createPed(new Model(config.modelName), config.coords, 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,
+      8,
+      -1,
+      1,
+      AnimationFlags.Looping,
+      IkControlFlags.UpperBody
+    );
+  }
+  let prop = 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) {
+  const activePed = activePeds.get(key);
+  if (!activePed) return;
+  if (activePed.prop) {
+    activePed.prop.delete();
+  }
+  if (activePed.ped) {
+    activePed.ped.delete();
+  }
+  activePeds.delete(key);
+}
+function cleanupPeds() {
+  for (const [key, activePed] of activePeds) {
+    if (activePed.prop) {
+      activePed.prop.delete();
+    }
+    if (activePed.ped) {
+      activePed.ped.delete();
+    }
+    activePeds.delete(key);
+  }
+}
+
+export { cleanupPeds, processSpawning, registerPed };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pma-locals",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "RedM ped spawning and management library with TypeScript support",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -24,20 +24,21 @@
   ],
   "author": "",
   "license": "ISC",
-  "dependencies": {
-    "@nativewrappers/redm": "^0.0.141",
-    "@nativewrappers/server": "^0.0.141",
-    "esbuild": "^0.27.2"
+  "peerDependencies": {
+    "@nativewrappers/redm": "^0.0.141"
   },
   "devDependencies": {
     "@citizenfx/client": "2.0.23683-1",
     "@citizenfx/server": "2.0.23683-1",
+    "@nativewrappers/redm": "^0.0.141",
     "@types/node": "^25.0.3",
+    "esbuild": "^0.27.2",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   },
   "scripts": {
     "watch": "node ./scripts/dev.js",
     "build": "node ./scripts/prod.js",
-    "build:package": "node ./scripts/build.js"
+    "build:package": "tsup"
   }
 }