@rpgjs/server 5.0.0-beta.5 → 5.0.0-beta.6

package/dist/{module-BmvXIvlE.js → module-Dy124Jyk.js}

@@ -2461,6 +2461,24 @@ __decorate([sync(), __decorateMetadata("design:type", Object)], Skill.prototype,
 __decorate([sync(), __decorateMetadata("design:type", Object)], Skill.prototype, "icon", void 0);
 //#endregion
 //#region ../common/src/Player.ts
+var readReactiveValue = (value) => {
+	if (typeof value === "function" && value.observable) return value();
+	return value;
+};
+var toCloneableSyncValue = (value, seen = /* @__PURE__ */ new WeakSet()) => {
+	const resolved = readReactiveValue(value);
+	if (resolved == null || typeof resolved !== "object") return typeof resolved === "function" ? void 0 : resolved;
+	if (seen.has(resolved)) return;
+	seen.add(resolved);
+	if (Array.isArray(resolved)) return resolved.map((item) => toCloneableSyncValue(item, seen)).filter((item) => item !== void 0);
+	const output = {};
+	for (const [key, child] of Object.entries(resolved)) {
+		if (key.startsWith("$") || key === "_itemInstance" || key === "_subject" || key === "observable" || key === "options") continue;
+		const childValue = toCloneableSyncValue(child, seen);
+		if (childValue !== void 0) output[key.startsWith("__") ? key.slice(2) : key] = childValue;
+	}
+	return output;
+};
 var Direction = /* @__PURE__ */ function(Direction) {
 	Direction["Up"] = "up";
 	Direction["Down"] = "down";
@@ -2644,8 +2662,11 @@ __decorate([sync(), __decorateMetadata("design:type", Object)], RpgCommonPlayer.
 __decorate([sync(), __decorateMetadata("design:type", Object)], RpgCommonPlayer.prototype, "_exp", void 0);
 __decorate([sync(), __decorateMetadata("design:type", Object)], RpgCommonPlayer.prototype, "_level", void 0);
 __decorate([sync(), __decorateMetadata("design:type", Object)], RpgCommonPlayer.prototype, "_class", void 0);
-__decorate([sync(Item), __decorateMetadata("design:type", Object)], RpgCommonPlayer.prototype, "items", void 0);
-__decorate([sync(), __decorateMetadata("design:type", Object)], RpgCommonPlayer.prototype, "equipments", void 0);
+__decorate([sync({
+	classType: Item,
+	transform: toCloneableSyncValue
+}), __decorateMetadata("design:type", Object)], RpgCommonPlayer.prototype, "items", void 0);
+__decorate([sync({ transform: toCloneableSyncValue }), __decorateMetadata("design:type", Object)], RpgCommonPlayer.prototype, "equipments", void 0);
 __decorate([sync(), __decorateMetadata("design:type", Object)], RpgCommonPlayer.prototype, "states", void 0);
 __decorate([sync(Skill), __decorateMetadata("design:type", Object)], RpgCommonPlayer.prototype, "skills", void 0);
 __decorate([sync(), __decorateMetadata("design:type", Object)], RpgCommonPlayer.prototype, "_effects", void 0);
@@ -4766,6 +4787,18 @@ var CapsuleCollider = class CapsuleCollider {
 	}
 };
 //#endregion
+//#region ../physic/src/collision/collider-cache.ts
+var colliderCache = /* @__PURE__ */ new WeakMap();
+function getCachedCollider(entity) {
+	return colliderCache.get(entity);
+}
+function setCachedCollider(entity, collider) {
+	colliderCache.set(entity, collider);
+}
+function invalidateCollider(entity) {
+	colliderCache.delete(entity);
+}
+//#endregion
 //#region ../physic/src/collision/PolygonCollider.ts
 /**
 * Weak registry to attach polygon configurations to entities
@@ -4785,6 +4818,7 @@ var entityToPolygonConfig = /* @__PURE__ */ new WeakMap();
 */
 function assignPolygonCollider(entity, config) {
 	entityToPolygonConfig.set(entity, config);
+	invalidateCollider(entity);
 }
 /**
 * Polygon collider implementation (convex via SAT; concave via convex parts)
@@ -5090,7 +5124,6 @@ function polygonCentroid(poly) {
 }
 //#endregion
 //#region ../physic/src/collision/detector.ts
-var colliderCache = /* @__PURE__ */ new WeakMap();
 /**
 * Collision detector
 * 
@@ -5104,14 +5137,14 @@ var colliderCache = /* @__PURE__ */ new WeakMap();
 * @returns Appropriate collider instance
 */
 function createCollider(entity) {
-	const cached = colliderCache.get(entity);
+	const cached = getCachedCollider(entity);
 	if (cached) return cached;
 	let collider = null;
 	if (entityToPolygonConfig.has(entity)) collider = new PolygonCollider(entity);
 	else if (entity.capsule) collider = new CapsuleCollider(entity);
 	else if (entity.radius > 0) collider = new CircleCollider(entity);
 	else if (entity.width > 0 && entity.height > 0) collider = new AABBCollider(entity);
-	if (collider) colliderCache.set(entity, collider);
+	if (collider) setCachedCollider(entity, collider);
 	return collider;
 }
 /**
@@ -5127,7 +5160,24 @@ function testCollision(entityA, entityB) {
 	const colliderA = createCollider(entityA);
 	const colliderB = createCollider(entityB);
 	if (!colliderA || !colliderB) return null;
-	return colliderA.testCollision(colliderB);
+	const directCollision = colliderA.testCollision(colliderB);
+	if (directCollision) return directCollision;
+	const reverseCollision = colliderB.testCollision(colliderA);
+	if (!reverseCollision) return null;
+	return reverseCollisionInfo(reverseCollision);
+}
+function reverseCollisionInfo(collision) {
+	return {
+		entityA: collision.entityB,
+		entityB: collision.entityA,
+		contacts: collision.contacts.map((contact) => ({
+			point: contact.point,
+			normal: contact.normal.mul(-1),
+			depth: contact.depth
+		})),
+		normal: collision.normal.mul(-1),
+		depth: collision.depth
+	};
 }
 //#endregion
 //#region ../physic/src/collision/spatial-hash.ts
@@ -5476,148 +5526,6 @@ var Ray = class {
 	}
 };
 //#endregion
-//#region ../physic/src/collision/raycast.ts
-/**
-* Casts a ray in the world using the spatial partition for broad-phase, then shape-specific narrow-phase.
-* Direction will be normalized internally.
-*
-* @param partition - Spatial partition to query
-* @param origin - Ray origin
-* @param direction - Ray direction (any length)
-* @param maxDistance - Maximum distance
-* @param mask - Optional collision mask (layer)
-* @param filter - Optional filter function (return true to include entity)
-* @returns Nearest hit or null
-*
-* @example
-* ```typescript
-* const hit = raycast(worldPartition, new Vector2(0,0), new Vector2(1,0), 1000);
-* if (hit) {
-*   // handle
-* }
-* ```
-*/
-function raycast(partition, origin, direction, maxDistance, mask, filter) {
-	const dir = direction.length() > 0 ? direction.normalize() : new Vector2(1, 0);
-	const end = origin.add(dir.mul(maxDistance));
-	const candidates = partition.raycast(new Ray(origin, dir, maxDistance), mask, filter);
-	if (candidates) return candidates;
-	const bounds = new AABB(Math.min(origin.x, end.x), Math.min(origin.y, end.y), Math.max(origin.x, end.x), Math.max(origin.y, end.y));
-	const entities = partition.queryAABB(bounds);
-	let best = null;
-	for (const e of entities) {
-		if (mask !== void 0 && (e.collisionCategory & mask) === 0) continue;
-		if (filter && !filter(e)) continue;
-		const collider = createCollider(e);
-		if (!collider) continue;
-		const hit = raycastCollider(collider, origin, dir, maxDistance);
-		if (!hit) continue;
-		if (!best || hit.distance < best.distance) best = hit;
-	}
-	return best;
-}
-function raycastCollider(collider, origin, dir, maxDistance) {
-	if (collider instanceof CircleCollider) return raycastCircle(collider, origin, dir, maxDistance);
-	if (collider instanceof AABBCollider) return raycastAABB(collider, origin, dir, maxDistance);
-	if (collider instanceof PolygonCollider) return raycastPolygon(collider, origin, dir, maxDistance);
-	return null;
-}
-function raycastCircle(circle, origin, dir, maxDistance) {
-	const c = circle.getCenter();
-	const r = circle.getRadius();
-	const m = origin.sub(c);
-	const b = m.dot(dir);
-	const cval = m.dot(m) - r * r;
-	if (cval > 0 && b > 0) return null;
-	const discr = b * b - cval;
-	if (discr < 0) return null;
-	const t = -b - Math.sqrt(discr);
-	if (t < 0) return null;
-	if (t > maxDistance) return null;
-	const point = origin.add(dir.mul(t));
-	const normal = point.sub(c).normalize();
-	return {
-		entity: circle.getEntity(),
-		point,
-		normal,
-		distance: t
-	};
-}
-function raycastAABB(box, origin, dir, maxDistance) {
-	const b = box.getBounds();
-	let tmin = 0;
-	let tmax = maxDistance;
-	const invDx = 1 / (dir.x === 0 ? 1e-9 : dir.x);
-	const invDy = 1 / (dir.y === 0 ? 1e-9 : dir.y);
-	let tx1 = (b.minX - origin.x) * invDx;
-	let tx2 = (b.maxX - origin.x) * invDx;
-	let ty1 = (b.minY - origin.y) * invDy;
-	let ty2 = (b.maxY - origin.y) * invDy;
-	const tminX = Math.min(tx1, tx2);
-	const tmaxX = Math.max(tx1, tx2);
-	const tminY = Math.min(ty1, ty2);
-	const tmaxY = Math.max(ty1, ty2);
-	tmin = Math.max(tmin, Math.max(tminX, tminY));
-	tmax = Math.min(tmax, Math.min(tmaxX, tmaxY));
-	if (tmax < tmin || tmin < 0 || tmin > maxDistance) return null;
-	const point = origin.add(dir.mul(tmin));
-	let normal;
-	if (tmin === tminX) normal = new Vector2(dir.x > 0 ? -1 : 1, 0);
-	else normal = new Vector2(0, dir.y > 0 ? -1 : 1);
-	return {
-		entity: box.getEntity(),
-		point,
-		normal,
-		distance: tmin
-	};
-}
-function raycastPolygon(poly, origin, dir, maxDistance) {
-	const end = origin.add(dir.mul(maxDistance));
-	let bestT = Number.POSITIVE_INFINITY;
-	let bestPoint = null;
-	let bestNormal = null;
-	const any = poly;
-	const parts = any["getWorldParts"] ? any["getWorldParts"]() : [];
-	for (const part of parts) for (let i = 0; i < part.length; i++) {
-		const a = part[i];
-		const b = part[(i + 1) % part.length];
-		if (!a || !b) continue;
-		const hit = segmentRayIntersection(a, b, origin, end);
-		if (!hit) continue;
-		const t = hit.distance;
-		if (t >= 0 && t <= maxDistance && t < bestT) {
-			bestT = t;
-			bestPoint = hit.point;
-			const edge = b.sub(a);
-			bestNormal = new Vector2(-edge.y, edge.x).normalize();
-		}
-	}
-	if (!bestPoint || !bestNormal || bestT === Number.POSITIVE_INFINITY) return null;
-	return {
-		entity: poly.getEntity(),
-		point: bestPoint,
-		normal: bestNormal,
-		distance: bestT
-	};
-}
-function segmentRayIntersection(a, b, r0, r1) {
-	const v1 = r0.sub(a);
-	const v2 = b.sub(a);
-	const v3 = new Vector2(-(r1.y - r0.y), r1.x - r0.x);
-	const denom = v2.dot(v3);
-	if (Math.abs(denom) < 1e-9) return null;
-	const t1 = v2.cross(v1) / denom;
-	const t2 = v1.dot(v3) / denom;
-	if (t1 >= 0 && t1 <= 1 && t2 >= 0 && t2 <= 1) {
-		const hitPoint = new Vector2(r0.x + (r1.x - r0.x) * t1, r0.y + (r1.y - r0.y) * t1);
-		return {
-			point: hitPoint,
-			distance: hitPoint.sub(r0).length()
-		};
-	}
-	return null;
-}
-//#endregion
 //#region ../physic/src/collision/resolver.ts
 /**
 * Collision resolver
@@ -6077,13 +5985,41 @@ var World = class {
 	*/
 	addEntity(entity) {
 		this.entities.add(entity);
-		if (entity.isStatic()) this.staticEntities.add(entity);
-		else this.dynamicEntities.add(entity);
+		this.syncEntityCollection(entity);
 		this.spatialPartition.insert(entity);
 		this.events.emitEntityAdded(entity);
 		return entity;
 	}
 	/**
+	* Synchronizes an entity with the world's broad-phase structures.
+	*
+	* Call this after manually changing an entity position, dimensions, or state
+	* outside the normal physics step.
+	*
+	* @param entity - Entity to synchronize
+	*/
+	updateEntity(entity) {
+		if (!this.entities.has(entity)) return;
+		invalidateCollider(entity);
+		this.syncEntity(entity);
+	}
+	syncEntity(entity) {
+		this.syncEntityCollection(entity);
+		this.spatialPartition.update(entity);
+	}
+	/**
+	* Queries entities in an AABB region.
+	*
+	* The returned array comes from the broad-phase partition and may contain
+	* false positives from overlapping cells.
+	*
+	* @param bounds - AABB to query
+	* @returns Array of entities in overlapping partition cells
+	*/
+	queryAABB(bounds) {
+		return Array.from(this.spatialPartition.queryAABB(bounds));
+	}
+	/**
 	* Performs a raycast against all entities in the world.
 	* 
 	* @param origin - Starting point of the ray
@@ -6143,13 +6079,14 @@ var World = class {
 	* Updates all entities, detects and resolves collisions.
 	*/
 	step() {
-		this.refreshDynamicEntitiesInPartition();
+		this.refreshEntitiesInPartition();
 		for (const entity of this.dynamicEntities) if (!entity.isSleeping()) {
 			const startPos = entity.position.clone();
 			this.integrator.integrate(entity);
 			this.updateEntityTile(entity, startPos);
 			if (entity.continuous) this.performCCD(entity);
 		}
+		this.refreshDynamicEntitiesInPartition();
 		let firstPassCollisions = [];
 		for (let iteration = 0; iteration < this.resolverIterations; iteration++) {
 			const collisions = this.detectCollisions();
@@ -6157,9 +6094,12 @@ var World = class {
 			if (collisions.length === 0) break;
 			this.sortCollisionsForDeterminism(collisions);
 			this.resolver.resolveAll(collisions);
-			if (iteration + 1 < this.resolverIterations) this.refreshDynamicEntitiesInPartition();
+			this.refreshDynamicEntitiesInPartition();
+		}
+		if (this.positionQuantizationStep !== null || this.velocityQuantizationStep !== null) {
+			this.quantizeEntities();
+			this.refreshDynamicEntitiesInPartition();
 		}
-		if (this.positionQuantizationStep !== null || this.velocityQuantizationStep !== null) this.quantizeEntities();
 		this.handleCollisionEvents(firstPassCollisions);
 		if (this.enableSleep) this.updateSleepState();
 	}
@@ -6249,7 +6189,10 @@ var World = class {
 	clear() {
 		for (const entity of this.entities) this.events.emitEntityRemoved(entity);
 		this.entities.clear();
+		this.staticEntities.clear();
+		this.dynamicEntities.clear();
 		this.spatialPartition.clear();
+		this.queryResults.clear();
 		this.previousCollisions.clear();
 	}
 	quantizeEntities() {
@@ -6270,6 +6213,18 @@ var World = class {
 	refreshDynamicEntitiesInPartition() {
 		for (const entity of this.dynamicEntities) this.spatialPartition.update(entity);
 	}
+	refreshEntitiesInPartition() {
+		for (const entity of this.entities) this.syncEntity(entity);
+	}
+	syncEntityCollection(entity) {
+		if (entity.isStatic()) {
+			this.dynamicEntities.delete(entity);
+			this.staticEntities.add(entity);
+		} else {
+			this.staticEntities.delete(entity);
+			this.dynamicEntities.add(entity);
+		}
+	}
 	/**
 	* Gets statistics about the world
 	* 
@@ -6358,6 +6313,10 @@ var World = class {
 * 
 * Represents an independent simulation zone that can contain entities.
 * Regions can overlap to allow smooth entity transitions.
+*
+* @experimental Region simulation is not the recommended default path for
+* RPG-JS server physics yet. Prefer a single `PhysicsEngine` world until
+* region migration semantics are fully benchmarked and documented.
 * 
 * @example
 * ```typescript
@@ -6509,6 +6468,11 @@ var Region = class {
 * 
 * Manages multiple regions in a distributed physics world.
 * Handles entity migration between regions and region activation/deactivation.
+*
+* @experimental Region simulation is not the recommended default path for
+* RPG-JS server physics yet. Prefer `PhysicsEngine` without regions until
+* migration semantics, events, stats, and config propagation are fully
+* benchmarked and documented.
 * 
 * @example
 * ```typescript
@@ -6617,6 +6581,37 @@ var RegionManager = class {
 		}
 	}
 	/**
+	* Synchronizes an entity with its current region, migrating it when needed.
+	*
+	* @param entity - Entity to synchronize
+	*/
+	updateEntity(entity) {
+		const currentRegion = this.entityRegionMap.get(entity);
+		const newRegion = this.getRegionAt(entity.position);
+		if (!newRegion) {
+			if (currentRegion) {
+				currentRegion.removeEntity(entity);
+				this.entityRegionMap.delete(entity);
+			}
+			return;
+		}
+		if (!currentRegion) {
+			newRegion.addEntity(entity);
+			this.entityRegionMap.set(entity, newRegion);
+			if (this.config.autoActivate) newRegion.activate();
+			return;
+		}
+		if (newRegion !== currentRegion) {
+			currentRegion.removeEntity(entity);
+			newRegion.addEntity(entity);
+			this.entityRegionMap.set(entity, newRegion);
+			if (this.config.autoActivate) newRegion.activate();
+			if (this.config.autoActivate && currentRegion.getEntities().length === 0) currentRegion.deactivate();
+			return;
+		}
+		currentRegion.getWorld().updateEntity(entity);
+	}
+	/**
 	* Updates entity positions and migrates them between regions if needed
 	*/
 	updateEntities() {
@@ -6628,13 +6623,7 @@ var RegionManager = class {
 				newRegion
 			});
 		}
-		for (const { entity, newRegion } of entitiesToMigrate) {
-			const oldRegion = this.entityRegionMap.get(entity);
-			if (oldRegion) oldRegion.removeEntity(entity);
-			newRegion.addEntity(entity);
-			this.entityRegionMap.set(entity, newRegion);
-			if (this.config.autoActivate) newRegion.activate();
-		}
+		for (const { entity } of entitiesToMigrate) this.updateEntity(entity);
 	}
 	/**
 	* Steps all active regions
@@ -7046,7 +7035,8 @@ var ZoneManager = class {
 	* ```
 	*/
 	createZone(config, callbacks) {
-		const id = generateUUID();
+		const id = config.id ?? generateUUID();
+		if (this.zones.has(id)) throw new Error(`Zone "${id}" already exists`);
 		const radius = config.radius;
 		if (typeof radius !== "number" || radius <= 0) throw new Error("Zone radius must be a positive number");
 		const angle = config.angle ?? 360;
@@ -7370,6 +7360,7 @@ var PhysicsEngine = class {
 		this.regionManager = null;
 		this.movementManager = null;
 		this.zoneManager = null;
+		this.rpgSpeeds = /* @__PURE__ */ new Map();
 		this.tick = 0;
 		this.useRegions = config.enableRegions ?? false;
 		if (this.useRegions) {
@@ -7460,6 +7451,19 @@ var PhysicsEngine = class {
 		return this.tick;
 	}
 	/**
+	* Applies a frame of RPG movement inputs, advances the simulation, and updates sensors.
+	*
+	* @param inputs - Map of entity id to direction input
+	* @returns Current tick index after stepping
+	*/
+	stepFrame(inputs = {}) {
+		for (const [id, input] of Object.entries(inputs)) if (this.isFrameInputObject(input)) this.moveEntity(id, input.direction, input.speed);
+		else this.moveEntity(id, input);
+		this.step();
+		if (this.zoneManager) this.zoneManager.update();
+		return this.tick;
+	}
+	/**
 	* Advances the simulation by a fixed number of ticks.
 	*
 	* @param ticks - Number of ticks to simulate (>= 1)
@@ -7494,6 +7498,93 @@ var PhysicsEngine = class {
 		return entity;
 	}
 	/**
+	* Creates a dynamic RPG character with a stable id, hitbox, and default movement speed.
+	*
+	* This is the recommended creation path for players and NPCs in server-side RPG
+	* simulations because the entity is registered and ready for `moveEntity` and
+	* `stepFrame` immediately.
+	*
+	* @param id - Stable entity identifier
+	* @param options - Character configuration
+	* @returns Created entity
+	*/
+	createCharacter(id, options) {
+		const { x, y, hitbox: hitboxOption, speed, velocity, maxLinearVelocity, ...entityOptions } = options;
+		const hitbox = this.resolveHitbox(hitboxOption);
+		const config = {
+			...entityOptions,
+			...hitbox,
+			uuid: id,
+			position: {
+				x,
+				y
+			},
+			mass: options.mass ?? 1,
+			maxLinearVelocity: maxLinearVelocity ?? speed
+		};
+		if (velocity !== void 0) config.velocity = velocity;
+		const entity = this.createEntity(config);
+		this.rpgSpeeds.set(entity.uuid, speed);
+		return entity;
+	}
+	/**
+	* Creates a static rectangular obstacle for RPG maps.
+	*
+	* @param id - Stable entity identifier
+	* @param options - Obstacle configuration
+	* @returns Created static entity
+	*/
+	createStaticObstacle(id, options) {
+		return this.createEntity({
+			...options,
+			uuid: id,
+			position: {
+				x: options.x,
+				y: options.y
+			},
+			width: options.width,
+			height: options.height,
+			mass: 0
+		});
+	}
+	/**
+	* Creates a static or attached sensor zone with a stable id.
+	*
+	* Sensors detect entities through the `ZoneManager` and do not create physical
+	* collision responses.
+	*
+	* @param id - Stable sensor identifier
+	* @param options - Sensor configuration
+	* @returns Sensor identifier
+	*/
+	createSensor(id, options) {
+		const { onEnter, onExit, entity, position, x, y, ...zoneOptions } = options;
+		let callbacks;
+		if (onEnter || onExit) {
+			callbacks = {};
+			if (onEnter) callbacks.onEnter = onEnter;
+			if (onExit) callbacks.onExit = onExit;
+		}
+		if (entity) {
+			const attachedEntity = this.resolveEntity(entity);
+			if (!attachedEntity) throw new Error(`Cannot create sensor "${id}" for unknown entity`);
+			return this.getZoneManager().createZone({
+				...zoneOptions,
+				id,
+				entity: attachedEntity
+			}, callbacks);
+		}
+		const resolvedPosition = position ?? {
+			x: x ?? 0,
+			y: y ?? 0
+		};
+		return this.getZoneManager().createZone({
+			...zoneOptions,
+			id,
+			position: resolvedPosition
+		}, callbacks);
+	}
+	/**
 	* Adds an existing entity to the engine
 	* 
 	* @param entity - Entity to add
@@ -7510,6 +7601,7 @@ var PhysicsEngine = class {
 	* @param entity - Entity to remove
 	*/
 	removeEntity(entity) {
+		this.rpgSpeeds.delete(entity.uuid);
 		if (this.useRegions && this.regionManager) this.regionManager.removeEntity(entity);
 		else this.world.removeEntity(entity);
 	}
@@ -7586,7 +7678,70 @@ var PhysicsEngine = class {
 	*/
 	teleport(entity, position) {
 		entity.teleport(position);
-		if (this.useRegions && this.regionManager) this.regionManager.updateEntities();
+		this.updateEntity(entity);
+	}
+	/**
+	* Teleports an entity by id or entity reference.
+	*
+	* @param entity - Entity or UUID to teleport
+	* @param position - New position
+	* @returns True when the entity was found
+	*/
+	teleportEntity(entity, position) {
+		const target = this.resolveEntity(entity);
+		if (!target) return false;
+		this.teleport(target, position);
+		return true;
+	}
+	/**
+	* Moves an entity in a cardinal or vector direction using its configured RPG speed.
+	*
+	* Pass `'idle'` or a zero vector to stop the entity.
+	*
+	* @param entity - Entity or UUID to move
+	* @param direction - Cardinal direction or arbitrary vector
+	* @param speed - Optional speed override for this command
+	* @returns True when the entity was found
+	*/
+	moveEntity(entity, direction, speed) {
+		const target = this.resolveEntity(entity);
+		if (!target) return false;
+		const vector = this.resolveDirection(direction);
+		const magnitude = vector.length();
+		if (magnitude === 0) {
+			target.setVelocity({
+				x: 0,
+				y: 0
+			});
+			return true;
+		}
+		const resolvedSpeed = speed ?? this.rpgSpeeds.get(target.uuid) ?? target.maxLinearVelocity;
+		if (!Number.isFinite(resolvedSpeed) || resolvedSpeed <= 0) {
+			target.setVelocity({
+				x: 0,
+				y: 0
+			});
+			return true;
+		}
+		target.setVelocity({
+			x: vector.x / magnitude * resolvedSpeed,
+			y: vector.y / magnitude * resolvedSpeed
+		});
+		return true;
+	}
+	/**
+	* Synchronizes an entity after manual position, shape, or state changes.
+	*
+	* Direct mutations such as `entity.position.set(...)`, `entity.width = ...`,
+	* or `entity.freeze()` bypass the world's broad-phase structures. Call this
+	* helper after such mutations so spatial queries and collisions use the
+	* current entity state immediately.
+	*
+	* @param entity - Entity to synchronize
+	*/
+	updateEntity(entity) {
+		if (this.useRegions && this.regionManager) this.regionManager.updateEntity(entity);
+		else this.world.updateEntity(entity);
 	}
 	/**
 	* Freezes an entity (makes it static)
@@ -7595,6 +7750,7 @@ var PhysicsEngine = class {
 	*/
 	freeze(entity) {
 		entity.freeze();
+		this.updateEntity(entity);
 	}
 	/**
 	* Unfreezes an entity (makes it dynamic)
@@ -7603,6 +7759,7 @@ var PhysicsEngine = class {
 	*/
 	unfreeze(entity) {
 		entity.unfreeze();
+		this.updateEntity(entity);
 	}
 	/**
 	* Queries entities in an AABB region
@@ -7620,9 +7777,7 @@ var PhysicsEngine = class {
 			}
 			return entities;
 		}
-		const world = this.world;
-		if (world.spatialPartition) return Array.from(world.spatialPartition.queryAABB(bounds));
-		return this.world.getEntities().filter((e) => bounds.contains(e.position));
+		return this.world.queryAABB(bounds);
 	}
 	/**
 	* Clears all entities from the engine
@@ -7630,6 +7785,7 @@ var PhysicsEngine = class {
 	clear() {
 		if (this.useRegions && this.regionManager) this.regionManager.clear();
 		else this.world.clear();
+		this.rpgSpeeds.clear();
 		this.tick = 0;
 	}
 	/**
@@ -7647,6 +7803,7 @@ var PhysicsEngine = class {
 	*/
 	assignPolygonCollider(entity, config) {
 		assignPolygonCollider(entity, config);
+		this.updateEntity(entity);
 	}
 	/**
 	* Casts a ray in the physics world and returns the nearest hit, if any.
@@ -7664,9 +7821,7 @@ var PhysicsEngine = class {
 	* ```
 	*/
 	raycast(origin, direction, maxDistance, mask, filter) {
-		const partition = this.world.spatialPartition;
-		if (!partition) return null;
-		return raycast(partition, origin, direction, maxDistance, mask, filter);
+		return this.world.raycast(origin, direction, maxDistance, mask, filter);
 	}
 	/**
 	* Computes continuous collision detection (sweep test) time-of-impact between two entities
@@ -7766,6 +7921,7 @@ var PhysicsEngine = class {
 			entity.angularVelocity = state.angularVelocity;
 			if (state.sleeping) entity.sleep();
 			else entity.wakeUp();
+			this.updateEntity(entity);
 		}
 		this.tick = snapshot.tick;
 	}
@@ -7777,6 +7933,43 @@ var PhysicsEngine = class {
 	getRegionManager() {
 		return this.regionManager;
 	}
+	resolveEntity(entity) {
+		if (entity instanceof Entity) return entity;
+		return this.getEntityByUUID(entity);
+	}
+	resolveHitbox(hitbox) {
+		if (typeof hitbox === "number") return { radius: hitbox };
+		if ("type" in hitbox) {
+			if (hitbox.type === "circle") return { radius: hitbox.radius };
+			if (hitbox.type === "capsule") return { capsule: {
+				radius: hitbox.radius,
+				height: hitbox.height
+			} };
+			return {
+				width: hitbox.width,
+				height: hitbox.height
+			};
+		}
+		if ("radius" in hitbox) return { radius: hitbox.radius };
+		return {
+			width: hitbox.width,
+			height: hitbox.height
+		};
+	}
+	resolveDirection(direction) {
+		if (direction instanceof Vector2) return direction.clone();
+		if (typeof direction === "string") switch (direction) {
+			case "up": return new Vector2(0, -1);
+			case "down": return new Vector2(0, 1);
+			case "left": return new Vector2(-1, 0);
+			case "right": return new Vector2(1, 0);
+			default: return new Vector2(0, 0);
+		}
+		return new Vector2(direction.x, direction.y);
+	}
+	isFrameInputObject(input) {
+		return typeof input === "object" && !(input instanceof Vector2) && "direction" in input;
+	}
 };
 //#endregion
 //#region ../physic/src/movement/strategies/Dash.ts
@@ -8381,17 +8574,7 @@ var ProjectileMovement = class {
 			const gravity = this.options.gravity ?? 30;
 			this.verticalVelocity -= gravity * dt;
 			this.currentHeight += this.verticalVelocity * dt;
-			if (this.options.onHeightUpdate) this.options.onHeightUpdate(this.currentHeight, body);
-			else {
-				const dispatcher = globalThis;
-				if (typeof dispatcher.dispatchEvent === "function" && typeof CustomEvent !== "undefined") {
-					const event = new CustomEvent("projectile:height", { detail: {
-						id: body.id,
-						height: this.currentHeight
-					} });
-					dispatcher.dispatchEvent(event);
-				}
-			}
+			this.options.onHeightUpdate?.(this.currentHeight, body);
 			if (this.currentHeight <= 0) {
 				this.currentHeight = 0;
 				if (this.type === ProjectileType.Bounce) if (this.bounceCount < (this.options.maxBounces ?? 0)) {
@@ -8572,6 +8755,9 @@ var MovementManager = class {
 };
 //#endregion
 //#region ../common/src/rooms/Map.ts
+var COLLISION_PROXIMITY_MARGIN = 1;
+var DEFAULT_INTERACTION_RANGE = 16;
+var INTERACTION_SIDE_PADDING = 4;
 var RpgCommonMap = class {
 	constructor() {
 		this.data = signal(null);
@@ -8924,9 +9110,8 @@ var RpgCommonMap = class {
 			this.physicsAccumulatorMs -= fixedStepMs;
 			hooks?.beforeStep?.();
 			this.physic.updateMovements();
-			const tick = this.physic.stepOneTick();
+			const tick = this.physic.stepFrame();
 			executed += 1;
-			this.runPostTickUpdates();
 			hooks?.afterStep?.(tick);
 		}
 		return executed;
@@ -9006,8 +9191,7 @@ var RpgCommonMap = class {
 	forceSingleTick(hooks) {
 		hooks?.beforeStep?.();
 		this.physic.updateMovements();
-		const tick = this.physic.stepOneTick();
-		this.runPostTickUpdates();
+		const tick = this.physic.stepFrame();
 		hooks?.afterStep?.(tick);
 		const fixedMs = this.physic.getWorld().getTimeStep() * 1e3;
 		this.physicsAccumulatorMs = Math.max(0, this.physicsAccumulatorMs - fixedMs);
@@ -9023,12 +9207,10 @@ var RpgCommonMap = class {
 			return;
 		}
 		const hitbox = typeof owner.hitbox === "function" ? owner.hitbox() : owner.hitbox;
-		const width = hitbox?.w ?? 32;
-		const height = hitbox?.h ?? 32;
-		const radius = Math.max(width, height) / 2;
+		hitbox?.w;
+		hitbox?.h;
 		this.addCharacter({
 			owner,
-			radius,
 			kind,
 			maxSpeed: owner.speed(),
 			collidesWithCharacters: !this.shouldDisableCharacterCollisions(owner),
@@ -9350,19 +9532,13 @@ var RpgCommonMap = class {
 			const centerY = y + height / 2;
 			boxWidth = Math.max(width, 1);
 			boxHeight = Math.max(height, 1);
-			entity = this.physic.createEntity({
-				uuid: id,
-				position: {
-					x: centerX,
-					y: centerY
-				},
+			entity = this.physic.createStaticObstacle(id, {
+				x: centerX,
+				y: centerY,
 				width: boxWidth,
 				height: boxHeight,
-				mass: Infinity,
-				state: EntityState.Static,
 				restitution: 0
 			});
-			entity.freeze();
 		}
 		return id;
 	}
@@ -9407,25 +9583,24 @@ var RpgCommonMap = class {
 		const hitbox = typeof owner.hitbox === "function" ? owner.hitbox() : owner.hitbox;
 		const width = hitbox?.w ?? 32;
 		const height = hitbox?.h ?? 32;
-		const radius = Math.max(width, height) / 2;
 		const topLeftX = owner.x();
 		const topLeftY = owner.y();
 		const centerX = topLeftX + width / 2;
 		const centerY = topLeftY + height / 2;
 		const isStatic = !!options.isStatic;
-		const entity = this.physic.createEntity({
-			uuid: id,
-			position: {
-				x: centerX,
-				y: centerY
+		const speed = options.maxSpeed ? options.maxSpeed * this.speedScalar : 200;
+		const entity = this.physic.createCharacter(id, {
+			x: centerX,
+			y: centerY,
+			hitbox: {
+				width,
+				height
 			},
-			radius: Math.max(radius, 1),
-			width,
-			height,
+			speed,
 			mass: options.mass ?? (isStatic ? Infinity : 1),
 			friction: options.friction ?? .4,
 			linearDamping: isStatic ? 1 : .2,
-			maxLinearVelocity: options.maxSpeed ? options.maxSpeed * this.speedScalar : 200,
+			maxLinearVelocity: speed,
 			restitution: 0
 		});
 		if (isStatic) entity.freeze();
@@ -9543,7 +9718,10 @@ var RpgCommonMap = class {
 		const entityHeight = entity.height || entity.radius * 2 || 32;
 		const centerX = x + entityWidth / 2;
 		const centerY = y + entityHeight / 2;
-		entity.position.set(centerX, centerY);
+		this.physic.teleportEntity(entity, {
+			x: centerX,
+			y: centerY
+		});
 		return true;
 	}
 	/**
@@ -9579,26 +9757,8 @@ var RpgCommonMap = class {
 	moveBody(player, direction) {
 		const entity = this.physic.getEntityByUUID(player.id);
 		if (!entity) return false;
-		const speedValue = player.speed();
-		let vx = 0, vy = 0;
-		switch (direction) {
-			case Direction.Left:
-				vx = -speedValue * this.speedScalar;
-				break;
-			case Direction.Right:
-				vx = speedValue * this.speedScalar;
-				break;
-			case Direction.Up:
-				vy = -speedValue * this.speedScalar;
-				break;
-			case Direction.Down:
-				vy = speedValue * this.speedScalar;
-				break;
-		}
-		entity.setVelocity({
-			x: vx,
-			y: vy
-		});
+		const speed = player.speed() * this.speedScalar;
+		this.physic.moveEntity(entity, direction, speed);
 		entity.wakeUp();
 		return true;
 	}
@@ -9667,8 +9827,7 @@ var RpgCommonMap = class {
 		if (!entity) return [];
 		const collider = createCollider(entity);
 		if (!collider) return [];
-		const entityAABB = collider.getBounds();
-		const expandedAABB = entityAABB.expand(1);
+		const expandedAABB = collider.getBounds().expand(1);
 		const nearby = this.physic.queryAABB(expandedAABB);
 		const collisions = [];
 		for (const other of nearby) {
@@ -9676,10 +9835,46 @@ var RpgCommonMap = class {
 			const otherCollider = createCollider(other);
 			if (!otherCollider) continue;
 			const otherAABB = otherCollider.getBounds();
-			if (entityAABB.intersects(otherAABB)) collisions.push(other.uuid);
+			if (expandedAABB.intersects(otherAABB)) collisions.push(other.uuid);
+		}
+		return collisions;
+	}
+	/**
+	* Get entities inside the action area directly in front of an entity.
+	*
+	* This is intentionally separate from physical collisions: a player often
+	* presses the action key while blocked just before touching an NPC, so the
+	* physics solver may leave a tiny gap even though gameplay expects an
+	* interaction.
+	*/
+	getInteractionCollisions(id, direction, range = DEFAULT_INTERACTION_RANGE) {
+		const entity = this.physic.getEntityByUUID(id);
+		if (!entity) return [];
+		const collider = createCollider(entity);
+		if (!collider) return [];
+		const entityAABB = collider.getBounds();
+		const interactionAABB = this.getInteractionAABB(entityAABB, direction, range);
+		const nearby = this.physic.queryAABB(interactionAABB);
+		const collisions = [];
+		for (const other of nearby) {
+			if (other.uuid === id) continue;
+			const otherCollider = createCollider(other);
+			if (!otherCollider) continue;
+			if (interactionAABB.intersects(otherCollider.getBounds())) collisions.push(other.uuid);
 		}
 		return collisions;
 	}
+	getInteractionAABB(bounds, direction, range = DEFAULT_INTERACTION_RANGE) {
+		const distance = Number.isFinite(range) ? Math.max(0, range) : DEFAULT_INTERACTION_RANGE;
+		const sidePadding = distance > 0 ? Math.min(INTERACTION_SIDE_PADDING, distance / 2) : 0;
+		switch (direction) {
+			case Direction.Up: return new AABB(bounds.minX - sidePadding, bounds.minY - distance, bounds.maxX + sidePadding, bounds.minY + COLLISION_PROXIMITY_MARGIN);
+			case Direction.Down: return new AABB(bounds.minX - sidePadding, bounds.maxY - COLLISION_PROXIMITY_MARGIN, bounds.maxX + sidePadding, bounds.maxY + distance);
+			case Direction.Left: return new AABB(bounds.minX - distance, bounds.minY - sidePadding, bounds.minX + COLLISION_PROXIMITY_MARGIN, bounds.maxY + sidePadding);
+			case Direction.Right: return new AABB(bounds.maxX - COLLISION_PROXIMITY_MARGIN, bounds.minY - sidePadding, bounds.maxX + distance, bounds.maxY + sidePadding);
+			default: return bounds.expand(distance);
+		}
+	}
 	/**
 	* Get physics body (entity) for an id
 	* @protected
@@ -9739,6 +9934,7 @@ var RpgCommonMap = class {
 		}
 		entity.position.set(centerX, centerY);
 		entity.notifyPositionChange();
+		this.physic.updateEntity(entity);
 		return entity;
 	}
 	/**
@@ -9750,7 +9946,6 @@ var RpgCommonMap = class {
 	* @private
 	*/
 	addZone(id, options) {
-		const zoneManager = this.physic.getZoneManager();
 		if (this.physic.getEntityByUUID(id)) throw new Error(`Zone with id ${id} already exists as entity`);
 		const radius = options.radius;
 		if (typeof radius !== "number" || radius <= 0) throw new Error("Zone radius must be a positive number");
@@ -9759,15 +9954,13 @@ var RpgCommonMap = class {
 			attachedEntity = this.physic.getEntityByUUID(options.linkedTo);
 			if (!attachedEntity) throw new Error(`Cannot link zone to unknown entity ${options.linkedTo}`);
 		}
-		const callbacks = {};
-		callbacks._onEnterString = void 0;
-		callbacks._onExitString = void 0;
-		const zoneId = attachedEntity ? zoneManager.createAttachedZone(attachedEntity, {
+		const zoneId = this.physic.createSensor(id, attachedEntity ? {
+			entity: attachedEntity,
 			radius,
 			angle: options.angle ?? 360,
 			direction: options.direction ?? "down",
 			limitedByWalls: options.limitedByWalls ?? false
-		}, callbacks) : zoneManager.createZone({
+		} : {
 			position: {
 				x: options.x ?? 0,
 				y: options.y ?? 0
@@ -9776,7 +9969,7 @@ var RpgCommonMap = class {
 			angle: options.angle ?? 360,
 			direction: options.direction ?? "down",
 			limitedByWalls: options.limitedByWalls ?? false
-		}, callbacks);
+		});
 		this._zoneIdMap = this._zoneIdMap || /* @__PURE__ */ new Map();
 		this._zoneIdMap.set(id, zoneId);
 		return id;
@@ -11041,6 +11234,6 @@ function provideServerModules(modules) {
 	});
 }
 //#endregion
-export { RpgCommonPlayer as $, isArray as A, createErrorClass as At, ProjectileMovement as B, SDEF as C, isSignal as Ct, arrayFlat as D, finalize as Dt, PrebuiltGui as E, untracked as Et, ModulesToken as F, Knockback as G, PathFollow as H, RpgModule as I, Entity as J, IceMovement as K, WorldMapsManager as L, isInstanceOf as M, isString as N, arrayUniq as O, combineLatest as Ot, random as P, Direction as Q, RpgCommonMap as R, PDEF as S, isObjectSubject as St, PerlinNoise2D as T, signal as Tt, Oscillate as U, ProjectileType as V, LinearRepulsion as W, Vector2 as X, EntityState as Y, RpgShape as Z, ATK as _, ObjectSubject as _t, isMapUpdateAuthorized as a, createStatesSnapshot as at, MAXHP as b, isArraySubject as bt, updateMap as c, getByPath as ct, context$1 as d, persist as dt, Skill as et, inject as f, sync as ft, AGI as g, ArraySubject as gt, injector as h, users as ht, createMapUpdateHeaders as i, DELETE_TOKEN as it, isFunction as j, capitalize as k, BehaviorSubject as kt, context as l, id as lt, inject$1 as m, type as mt, MAP_UPDATE_TOKEN_ENV as n, __decorate as nt, readMapUpdateToken as o, createStatesSnapshotDeep as ot, setInject as p, syncClass as pt, Dash as q, MAP_UPDATE_TOKEN_HEADER as r, __decorateMetadata as rt, resolveMapUpdateToken as s, generateShortUUID as st, provideServerModules as t, Item as tt, clearInject as u, load as ut, DEX as v, computed as vt, STR as w, linkedSignal as wt, MAXSP as x, isComputed as xt, INT as y, effect as yt, SeekAvoid as z };
+export { Skill as $, isArray as A, ProjectileMovement as B, SDEF as C, linkedSignal as Ct, arrayFlat as D, combineLatest as Dt, PrebuiltGui as E, finalize as Et, ModulesToken as F, Knockback as G, PathFollow as H, RpgModule as I, Entity as J, IceMovement as K, WorldMapsManager as L, isInstanceOf as M, isString as N, arrayUniq as O, BehaviorSubject as Ot, random as P, RpgCommonPlayer as Q, RpgCommonMap as R, PDEF as S, isSignal as St, PerlinNoise2D as T, untracked as Tt, Oscillate as U, ProjectileType as V, LinearRepulsion as W, RpgShape as X, Vector2 as Y, Direction as Z, ATK as _, computed as _t, isMapUpdateAuthorized as a, createStatesSnapshotDeep as at, MAXHP as b, isComputed as bt, updateMap as c, id as ct, context$1 as d, sync as dt, Item as et, inject as f, syncClass as ft, AGI as g, ObjectSubject as gt, injector as h, ArraySubject as ht, createMapUpdateHeaders as i, createStatesSnapshot as it, isFunction as j, capitalize as k, createErrorClass as kt, context as l, load as lt, inject$1 as m, users as mt, MAP_UPDATE_TOKEN_ENV as n, __decorateMetadata as nt, readMapUpdateToken as o, generateShortUUID as ot, setInject as p, type as pt, Dash as q, MAP_UPDATE_TOKEN_HEADER as r, DELETE_TOKEN as rt, resolveMapUpdateToken as s, getByPath as st, provideServerModules as t, __decorate as tt, clearInject as u, persist as ut, DEX as v, effect as vt, STR as w, signal as wt, MAXSP as x, isObjectSubject as xt, INT as y, isArraySubject as yt, SeekAvoid as z };
 
-//# sourceMappingURL=module-BmvXIvlE.js.map
+//# sourceMappingURL=module-Dy124Jyk.js.map