pma-locals 1.0.8 → 1.0.10

package/README.md

@@ -1,19 +1,13 @@
-# pma-locals
-
-Modern TypeScript library for managing RedM ped spawning and animations.
-
-## Installation
-
 ```bash
 npm install pma-locals
 # or
 pnpm add pma-locals
 ```
 
-## Usage
+## Quick Start
 
 ```typescript
-import { registerPed, processSpawning } from "pma-locals";
+import { registerPed, processSpawning, cleanupPeds } from "pma-locals";
 import { Vector3, Delay } from "@nativewrappers/redm";
 
 // Register a ped with animation
@@ -22,6 +16,7 @@ registerPed(
 	new Vector3(-297.74, 791.1, 118.4), // spawn coords
 	180.0, // heading
 	50.0, // spawn distance (optional, default: 100.0)
+	true, // disable collisions
 	{
 		dict: "amb_wander@world_human_smoke@male@male_a@idle_a",
 		anim: "idle_a",
@@ -31,47 +26,86 @@ registerPed(
 
 // In your game loop
 setTick(async () => {
-	const playerPed = PlayerPedId();
-	if (!playerPed) return;
+	const playerPed = Game.PlayerPed;
 
-	const coords = GetEntityCoords(playerPed, true, true);
-	const playerPos = new Vector3(coords[0], coords[1], coords[2]);
-
-	await processSpawning(playerPos);
+	await processSpawning(playerPed.Position);
 	await Delay(500);
 });
+
+// Cleanup on resource stop
+on("onResourceStop", (resourceName: string) => {
+	if (resourceName === GetCurrentResourceName()) {
+		cleanupPeds();
+	}
+});
 ```
 
-## API
+## API Reference
 
 ### `registerPed(modelName, coords, heading, spawnDistance?, animation?, propData?)`
 
-Register a ped to spawn when players approach.
+Register a ped to spawn when players are within range.
 
 **Parameters:**
 
 -   `modelName` (number): Model hash
 -   `coords` (Vector3): Spawn coordinates
--   `heading` (number): Ped heading direction
--   `spawnDistance` (number): Distance threshold (default: 100.0)
--   `animation` (Animation): Optional animation data
--   `propData` (Props): Optional prop attachment
+-   `heading` (number): Ped heading direction (0-360)
+-   `spawnDistance?` (number): Distance threshold (default: 100.0)
+-   `collisions?` (boolean): Optional collision handler
+-   `animation?` (Animation): Optional animation config
+    -   `dict` (string): Animation dictionary
+    -   `anim` (string): Animation name
+-   `propData?` (Props): Optional prop attachment
+    -   `model` (string): Prop model hash
+    -   `boneId` (number): Bone to attach to
+    -   `offset` (number[]): Position offset [x, y, z]
+    -   `rotation` (number[]): Rotation [x, y, z]
 
 ### `processSpawning(playerPos: Vector3)`
 
-Update ped spawning based on player position. Call this in your game loop.
+Process ped spawning/despawning based on player position. Call this regularly in your game loop (e.g., every 500ms).
 
 ### `cleanupPeds()`
 
-Delete all spawned peds (useful for resource cleanup).
+Delete all spawned peds. Use this when your resource stops to clean up entities.
+
+## TypeScript Support
+
+Full type definitions are included. Import types as needed:
 
-## Types
+```typescript
+import type { PedConfig, Animation, Props } from "pma-locals";
+```
+
+**Exported Types:**
+
+-   `PedConfig` - Complete ped configuration
+-   `Animation` - Animation data structure
+-   `Props` - Prop attachment configuration
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build package (creates dist/ with .js and .d.ts files)
+pnpm build:package
+
+# RedM development mode (watch)
+pnpm watch
+
+# Publish to npm
+npm version patch
+pnpm publish
+```
 
-Full TypeScript support with exported types:
+**Built with:**
 
--   `PedConfig`
--   `Animation`
--   `Props`
+-   [tsup](https://tsup.egoist.dev/) - TypeScript bundler
+-   [esbuild](https://esbuild.github.io/) - Fast JavaScript bundler
+-   [@nativewrappers/redm](https://www.npmjs.com/package/@nativewrappers/redm) - RedM type definitions
 
 ## License
 

package/dist/index.d.mts

@@ -0,0 +1,30 @@
+import { AnimationFlags, Vector3 } from "@nativewrappers/redm";
+
+//#region types/index.d.ts
+interface Animation {
+  dict: string;
+  anim: string;
+  flag: AnimationFlags;
+}
+interface Props {
+  model: string;
+  boneId: number;
+  offset: number[];
+  rotation: number[];
+}
+//#endregion
+//#region client/ped-handler.d.ts
+interface PedConfig {
+  modelName: string;
+  coords: Vector3;
+  heading: number;
+  spawnDistance: number;
+  collisions?: boolean;
+  animation?: Animation;
+  propData?: Props;
+}
+declare function registerPed(modelName: string, coords: Vector3, heading: number, spawnDistance?: number, collisions?: boolean, animation?: Animation, propData?: Props): void;
+declare function processSpawning(playerPos: Vector3): Promise<void>;
+declare function cleanupPeds(): void;
+//#endregion
+export { type Animation, type PedConfig, type Props, cleanupPeds, processSpawning, registerPed };

package/dist/index.mjs

@@ -0,0 +1,72 @@
+import { IkControlFlags, Model, createPed, createProp } from "@nativewrappers/redm";
+
+//#region client/ped-handler.ts
+const pedConfigs = [];
+const activePeds = /* @__PURE__ */ new Map();
+function registerPed(modelName, coords, heading, spawnDistance = 100, collisions, animation, propData) {
+	pedConfigs.push({
+		modelName,
+		coords,
+		heading,
+		spawnDistance,
+		collisions,
+		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);
+	ped.IsPositionFrozen = true;
+	SetEntityInvincible(ped.Handle, true);
+	if (config.collisions) SetEntityCollision(ped.Handle, false, false);
+	SetBlockingOfNonTemporaryEvents(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, config.animation.flag, IkControlFlags.BlockNonAnimSceneLooks);
+	let prop = null;
+	if (config.propData) {
+		prop = await createProp(new Model(config.propData.model), ped.Position, 0, false, 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);
+	}
+}
+
+//#endregion
+export { cleanupPeds, processSpawning, registerPed };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pma-locals",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "RedM ped spawning and management library with TypeScript support",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -33,12 +33,12 @@
     "@nativewrappers/redm": "^0.0.141",
     "@types/node": "^25.0.3",
     "esbuild": "^0.27.2",
-    "tsup": "^8.5.1",
+    "tsdown": "0.19.0-beta.3",
     "typescript": "^5.9.3"
   },
   "scripts": {
     "watch": "node ./scripts/dev.js",
     "build": "node ./scripts/prod.js",
-    "build:package": "tsup"
+    "build:package": "tsdown"
   }
 }

package/dist/index.d.ts

@@ -1,28 +0,0 @@
-import { AnimationFlags, Vector3 } from '@nativewrappers/redm';
-
-interface Animation {
-    dict: string;
-    anim: string;
-    flag: AnimationFlags;
-}
-interface Props {
-    model: string;
-    boneId: number;
-    offset: number[];
-    rotation: number[];
-}
-
-interface PedConfig {
-    modelName: string;
-    coords: Vector3;
-    heading: number;
-    spawnDistance: number;
-    collisions?: boolean;
-    animation?: Animation;
-    propData?: Props;
-}
-declare function registerPed(modelName: string, coords: Vector3, heading: number, spawnDistance?: number, collisions?: boolean, 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,111 +0,0 @@
-import { createPed, Model, IkControlFlags, createProp } from '@nativewrappers/redm';
-
-// client/ped-handler.ts
-var pedConfigs = [];
-var activePeds = /* @__PURE__ */ new Map();
-function registerPed(modelName, coords, heading, spawnDistance = 100, collisions, animation, propData) {
-  pedConfigs.push({
-    modelName,
-    coords,
-    heading,
-    spawnDistance,
-    collisions,
-    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);
-  ped.IsPositionFrozen = true;
-  SetEntityInvincible(ped.Handle, true);
-  if (config.collisions) {
-    SetEntityCollision(ped.Handle, false, false);
-  }
-  SetBlockingOfNonTemporaryEvents(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,
-      config.animation.flag,
-      IkControlFlags.BlockNonAnimSceneLooks
-    );
-  }
-  let prop = null;
-  if (config.propData) {
-    prop = await createProp(new Model(config.propData.model), ped.Position, 0, false, 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 };