@daneren2005/shared-memory-physics 1.4.0 → 1.6.0

package/dist/math/polygons.d.ts

@@ -0,0 +1,3 @@
+import type { Vector } from './shapes';
+export declare function polygonShapesOverlap(aShape: number, aPolygon: Float32Array | undefined, aX: number, aY: number, aWidth: number, aHeight: number, aAngle: number, bShape: number, bPolygon: Float32Array | undefined, bX: number, bY: number, bWidth: number, bHeight: number, bAngle: number): boolean;
+export declare function polygonContactNormal(aShape: number, aPolygon: Float32Array | undefined, aX: number, aY: number, aWidth: number, aHeight: number, aAngle: number, bShape: number, bPolygon: Float32Array | undefined, bX: number, bY: number, bWidth: number, bHeight: number, bAngle: number, out: Vector): boolean;

package/dist/systems/bounce.d.ts

@@ -4,8 +4,9 @@ interface BounceEntity {
         velocity?: Float32Array;
         bounciness?: Float32Array;
         body?: Uint32Array;
+        polygon?: Float32Array;
     };
 }
-export declare function bouncePair(self: BounceEntity, other: BounceEntity): void;
+export declare function bouncePair(self: BounceEntity, other: BounceEntity, stopNonBouncing?: boolean): void;
 export declare function bounce(self: BounceEntity, other: BounceEntity): void;
 export default bounce;

package/dist/systems/collision.d.ts

@@ -1,9 +1,12 @@
-import type { ComponentMap, ComponentSystemCallbacks, ComponentSystemWorld, EntityQueryComponents, EntityUpdateComponents } from '@daneren2005/shared-memory-ecs';
+import type { ComponentMap, EntityWorkerSystemCallbacks, EntityWorkerSystemWorld, EntityQueryComponents, EntityUpdateComponents } from '@daneren2005/shared-memory-ecs';
 import type { PhysicsUpdateComponents } from '../components/registry';
+import type { Vector } from '../math/shapes';
+import type { DynamicsCommands } from './dynamics';
 export declare const COLLIDABLE_QUERY = "collidable";
 export type CollisionComponents<T extends PhysicsUpdateComponents> = Partial<T> & {
     transform: Float32Array;
     body: Uint32Array;
+    polygon?: Float32Array;
     entity?: Uint32Array;
 };
 export interface MovingEntity<T extends PhysicsUpdateComponents> {
@@ -14,7 +17,11 @@ export interface CollisionEntity<T extends PhysicsUpdateComponents> {
     entityId: number;
     components: CollisionComponents<T>;
 }
-export type CollisionFunction<C extends ComponentMap, T extends PhysicsUpdateComponents & EntityUpdateComponents<C>, W extends ComponentSystemWorld = ComponentSystemWorld> = (world: W, self: MovingEntity<T>, other: CollisionEntity<T>, queries: EntityQueryComponents<C>, callbacks: ComponentSystemCallbacks<C>) => void;
+export interface CollisionContact {
+    normalX: number;
+    normalY: number;
+}
+export type CollisionFunction<C extends ComponentMap, T extends PhysicsUpdateComponents & EntityUpdateComponents<C>, W extends EntityWorkerSystemWorld = EntityWorkerSystemWorld> = (world: W, self: MovingEntity<T>, other: CollisionEntity<T>, queries: EntityQueryComponents<C>, callbacks: EntityWorkerSystemCallbacks<C>, contact: CollisionContact) => void;
 export interface SweepResult<T extends PhysicsUpdateComponents> {
     fraction: number;
     blocking: Array<CollisionEntity<T>>;
@@ -24,6 +31,21 @@ export interface MoveResult<T extends PhysicsUpdateComponents> {
     moveY: number;
     blocking: Array<CollisionEntity<T>>;
 }
+interface ContactSource {
+    entityId: number;
+    components: {
+        transform: Float32Array;
+        body?: Uint32Array;
+        polygon?: Float32Array;
+    };
+}
+interface ContactTarget {
+    components: {
+        transform: Float32Array;
+        body: Uint32Array;
+        polygon?: Float32Array;
+    };
+}
 export default class CollisionBroadphase<T extends PhysicsUpdateComponents> {
     private buckets;
     readonly hasBounciness: boolean;
@@ -31,9 +53,14 @@ export default class CollisionBroadphase<T extends PhysicsUpdateComponents> {
     constructor(entities: Array<{
         entityId: number;
         components: EntityUpdateComponents;
-    }>, seconds: number);
+    }>, seconds: number, dynamicsCommands?: DynamicsCommands);
     claimContact(a: number, b: number): boolean;
     forEachOverlapping(self: MovingEntity<T>, handle: (other: CollisionEntity<T>) => void, moveX?: number, moveY?: number): void;
+    contactPoint(self: ContactSource, other: ContactTarget, moveX: number, moveY: number): {
+        x: number;
+        y: number;
+    };
+    contactNormal(self: ContactSource, other: ContactTarget, moveX: number, moveY: number, out: Vector): boolean;
     sweep(self: MovingEntity<T>, moveX: number, moveY: number): SweepResult<T>;
     resolveMove(self: MovingEntity<T>, moveX: number, moveY: number, slide: boolean): MoveResult<T>;
     private gatherCandidates;
@@ -45,3 +72,4 @@ export default class CollisionBroadphase<T extends PhysicsUpdateComponents> {
     private blockedAt;
     private forEachCandidate;
 }
+export {};

package/dist/systems/dynamics.d.ts

@@ -0,0 +1,43 @@
+export interface DynamicsCommand {
+    entityId: number;
+    forceX: number;
+    forceY: number;
+    impulseX: number;
+    impulseY: number;
+    velocityX?: number;
+    velocityY?: number;
+}
+export interface VelocityAssignment {
+    velocityX?: number;
+    velocityY?: number;
+}
+export interface DynamicsCommandQueue {
+    queueForce(entityId: number, forceX: number, forceY: number): void;
+    queueImpulse(entityId: number, impulseX: number, impulseY: number): void;
+    queueVelocity(entityId: number, velocity: VelocityAssignment): void;
+}
+export type PendingDynamicsCommands = Map<number, Omit<DynamicsCommand, 'entityId'>>;
+export type DynamicsCommandBuffer = Float64Array;
+export type DynamicsCommands = DynamicsCommandBuffer | ReadonlyArray<DynamicsCommand>;
+export declare const DYNAMICS_COMMAND_STRIDE = 8;
+export declare const DYNAMICS_COMMAND_ENTITY_ID_OFFSET = 0;
+export declare const DYNAMICS_COMMAND_FORCE_X_OFFSET = 1;
+export declare const DYNAMICS_COMMAND_FORCE_Y_OFFSET = 2;
+export declare const DYNAMICS_COMMAND_IMPULSE_X_OFFSET = 3;
+export declare const DYNAMICS_COMMAND_IMPULSE_Y_OFFSET = 4;
+export declare const DYNAMICS_COMMAND_VELOCITY_MASK_OFFSET = 5;
+export declare const DYNAMICS_COMMAND_VELOCITY_X_OFFSET = 6;
+export declare const DYNAMICS_COMMAND_VELOCITY_Y_OFFSET = 7;
+export declare const DYNAMICS_COMMAND_VELOCITY_X_FLAG: number;
+export declare const DYNAMICS_COMMAND_VELOCITY_Y_FLAG: number;
+export interface DynamicsWorld {
+    elapsedTime: number;
+    dynamicsCommands?: DynamicsCommands;
+}
+export declare function queueDynamicsVector(commands: PendingDynamicsCommands, entityId: number, forceX: number, forceY: number, impulseX: number, impulseY: number): void;
+export declare function queueVelocityAssignment(commands: PendingDynamicsCommands, entityId: number, velocity: VelocityAssignment): void;
+export declare function combineDynamicsCommands(queued: ReadonlyMap<number, Omit<DynamicsCommand, 'entityId'>>, incoming: DynamicsCommands | undefined): DynamicsCommands | undefined;
+export declare function integrateDynamics(world: DynamicsWorld, entityId: number, velocity: Float32Array, dynamics?: Float32Array): void;
+export declare function findDynamicsCommand(commands: ReadonlyArray<DynamicsCommand> | undefined, entityId: number): DynamicsCommand | undefined;
+export declare function findDynamicsCommandOffset(commands: DynamicsCommandBuffer, entityId: number): number;
+export default integrateDynamics;

package/dist/systems/interpolation-system.d.ts

@@ -1,10 +1,10 @@
-import { ComponentSystem } from '@daneren2005/shared-memory-ecs';
+import { EntityWorkerSystem } from '@daneren2005/shared-memory-ecs';
 import type { BaseWorld, ComponentDefinitionMap, ComponentMap, EntityUpdateComponents, SystemConfig } from '@daneren2005/shared-memory-ecs';
 import type { InterpolationComponents, InterpolationUpdateComponents } from '../components/registry';
 export interface InterpolationSystemConfig extends Partial<SystemConfig> {
     forceMainThread?: boolean;
     getWorker?: () => Worker;
 }
-export default class InterpolationSystem<C extends ComponentMap & InterpolationComponents> extends ComponentSystem<C, InterpolationUpdateComponents & EntityUpdateComponents<C>> {
+export default class InterpolationSystem<C extends ComponentMap & InterpolationComponents> extends EntityWorkerSystem<C, InterpolationUpdateComponents & EntityUpdateComponents<C>> {
     constructor(world: BaseWorld<ComponentDefinitionMap, C>, options?: InterpolationSystemConfig);
 }

package/dist/systems/physics-system.d.ts

@@ -1,9 +1,12 @@
-import { ComponentSystem } from '@daneren2005/shared-memory-ecs';
-import type { BaseEntity, BaseWorld, ComponentDefinitionMap, ComponentMap, ComponentSystemQuery, EntityUpdateComponents, EntityUpdateFunction, SystemConfig } from '@daneren2005/shared-memory-ecs';
+import { EntityWorkerSystem } from '@daneren2005/shared-memory-ecs';
+import type { BaseEntity, BaseWorld, ComponentDefinitionMap, ComponentMap, EntityWorkerSystemQuery, EntityUpdateComponents, EntityUpdateFunction, SystemConfig } from '@daneren2005/shared-memory-ecs';
 import { type SpawnableEntity } from '../components/interpolation-component';
 import type { PhysicsComponents, PhysicsUpdateComponents } from '../components/registry';
 import { type PhysicsUpdateMetadata, type PhysicsWorld } from './physics-update';
+import { type PhysicalWorldSource } from '../world';
+import type { VelocityAssignment } from './dynamics';
 export declare const DEFAULT_PHYSICS_STEP_MS = 50;
+export type { VelocityAssignment } from './dynamics';
 export interface PhysicsSystemConfig<C extends ComponentMap & PhysicsComponents, T extends PhysicsUpdateComponents & EntityUpdateComponents<C>, W extends PhysicsWorld = PhysicsWorld> extends Partial<SystemConfig> {
     getWorker?: () => Worker;
     forceMainThread?: boolean;
@@ -16,15 +19,23 @@ export interface PhysicsSystemConfig<C extends ComponentMap & PhysicsComponents,
     filter?: (entity: BaseEntity<C>) => boolean;
     scope?: (entity: BaseEntity<C>) => boolean;
     queries?: {
-        [key: string]: ComponentSystemQuery<C>;
+        [key: string]: EntityWorkerSystemQuery<C>;
     };
     skipGroup?: number;
 }
-export default class PhysicsSystem<C extends ComponentMap & PhysicsComponents, T extends PhysicsUpdateComponents & EntityUpdateComponents<C> = PhysicsUpdateComponents & EntityUpdateComponents<C>, W extends PhysicsWorld = PhysicsWorld> extends ComponentSystem<C, T, W> {
+export default class PhysicsSystem<C extends ComponentMap & PhysicsComponents, T extends PhysicsUpdateComponents & EntityUpdateComponents<C> = PhysicsUpdateComponents & EntityUpdateComponents<C>, W extends PhysicsWorld = PhysicsWorld> extends EntityWorkerSystem<C, T, W> {
+    private spatialWorld;
+    private pendingDynamicsCommands;
+    private readonly commandQueueId;
     tick: number;
     reportMoves: boolean | undefined;
     skipGroup: number | undefined;
-    constructor(world: BaseWorld<ComponentDefinitionMap, C>, options?: PhysicsSystemConfig<C, T, W>);
+    constructor(world: BaseWorld<ComponentDefinitionMap, C> & PhysicalWorldSource, options?: PhysicsSystemConfig<C, T, W>);
     startInterpolation(entity: SpawnableEntity): void;
+    queueForce(entity: BaseEntity<C> | number, forceX: number, forceY: number): void;
+    queueImpulse(entity: BaseEntity<C> | number, impulseX: number, impulseY: number): void;
+    queueVelocity(entity: BaseEntity<C> | number, velocity: VelocityAssignment): void;
     addDataToWorld(world: W): void;
+    private queueDynamics;
+    private snapshotDynamicsCommands;
 }

package/dist/systems/physics-update.d.ts

@@ -1,16 +1,33 @@
-import type { ComponentMap, ComponentSystemCallbacks, ComponentSystemWorld, EntityQueryComponents, EntityUpdateComponents, EntityUpdateFunction } from '@daneren2005/shared-memory-ecs';
+import type { ComponentMap, EntityWorkerSystemCallbacks, EntityWorkerSystemWorld, EntityQueryComponents, EntityUpdateComponents, EntityUpdateFunction } from '@daneren2005/shared-memory-ecs';
 import type { PhysicsComponents, PhysicsUpdateComponents } from '../components/registry';
 import { type CollisionFunction } from './collision';
-export interface PhysicsWorld extends ComponentSystemWorld {
+import type { DynamicsCommandQueue, DynamicsWorld } from './dynamics';
+import { type SpatialBlockComponents } from './spatial-bounds';
+import { type PhysicalSystemWorld } from '../world';
+export interface PhysicsWorld extends EntityWorkerSystemWorld, PhysicalSystemWorld, DynamicsWorld {
     tick: number;
     reportMoves?: boolean;
     skipGroup?: number;
+    commandQueueId?: number;
+    dieAtImpact?(dying: DeathInterpolationEntity, other: DeathInterpolationEntity): void;
+}
+export interface PhysicsCallbackWorld extends PhysicsWorld, DynamicsCommandQueue {
+}
+export declare function updateSpatialMap(world: PhysicalSystemWorld, entityId: number, components: SpatialBlockComponents): void;
+export interface DeathInterpolationEntity {
+    entityId: number;
+    components: {
+        transform?: Float32Array;
+        velocity?: Float32Array;
+        body?: Uint32Array;
+    };
 }
 export declare const POSITION_UPDATED_EVENT = "position-updated";
 export interface PhysicsUpdateOptions<C extends ComponentMap, T extends PhysicsUpdateComponents & EntityUpdateComponents<C>, W extends PhysicsWorld = PhysicsWorld> {
-    onCollision?: CollisionFunction<C, T, W>;
+    onCollision?: CollisionFunction<C, T, W & PhysicsCallbackWorld>;
     optional?: Array<keyof C & string>;
     group?: PhysicsGroupConfig<C>;
+    stopVelocityOnContact?: boolean;
 }
 export interface PhysicsGroupConfig<C extends ComponentMap> {
     component: keyof C & string;
@@ -18,6 +35,7 @@ export interface PhysicsGroupConfig<C extends ComponentMap> {
 }
 export interface PhysicsUpdateMetadata<C extends ComponentMap> {
     collision: boolean;
+    dynamics: boolean;
     optional: Array<keyof C & string>;
     group?: PhysicsGroupConfig<C>;
 }
@@ -25,5 +43,5 @@ export type PhysicsUpdateFunction<C extends ComponentMap, T extends PhysicsUpdat
     physics: PhysicsUpdateMetadata<C>;
 };
 export declare function createPhysicsUpdate<C extends ComponentMap & PhysicsComponents = PhysicsComponents, T extends PhysicsUpdateComponents & EntityUpdateComponents<C> = PhysicsUpdateComponents & EntityUpdateComponents<C>, W extends PhysicsWorld = PhysicsWorld>(options?: PhysicsUpdateOptions<C, T, W>): PhysicsUpdateFunction<C, T, W>;
-export declare function physicsUpdate<C extends ComponentMap & PhysicsComponents = PhysicsComponents, T extends PhysicsUpdateComponents & EntityUpdateComponents<C> = PhysicsUpdateComponents & EntityUpdateComponents<C>, W extends PhysicsWorld = PhysicsWorld>(world: W, entityId: number, components: T, queries: EntityQueryComponents<C>, callbacks: ComponentSystemCallbacks<C>): void;
+export declare function physicsUpdate<C extends ComponentMap & PhysicsComponents = PhysicsComponents, T extends PhysicsUpdateComponents & EntityUpdateComponents<C> = PhysicsUpdateComponents & EntityUpdateComponents<C>, W extends PhysicsWorld = PhysicsWorld>(world: W, entityId: number, components: T, queries: EntityQueryComponents<C>, callbacks: EntityWorkerSystemCallbacks<C>): void;
 export default physicsUpdate;

package/dist/systems/spatial-bounds.d.ts

@@ -0,0 +1,13 @@
+export interface SpatialBounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export interface SpatialBlockComponents {
+    transform: Float32Array;
+    body?: Uint32Array;
+}
+export declare function spatialBounds(components: SpatialBlockComponents): SpatialBounds;
+export declare function boundsOverlap(a: SpatialBounds, minX: number, minY: number, maxX: number, maxY: number): boolean;
+export declare function querySize(min: number, max: number): number;

package/dist/world.d.ts

@@ -0,0 +1,30 @@
+import SharedSpatialMap from '@daneren2005/shared-memory-objects/spatial/shared-spatial-map';
+import type { SharedSpatialMapConfig, SharedSpatialMapMemory } from '@daneren2005/shared-memory-objects/spatial/shared-spatial-map';
+import { BaseWorld } from '@daneren2005/shared-memory-ecs';
+import type { BaseEntity, ComponentDefinitionMap, ComponentsOf, EntityWorkerSystemWorld, EntityConfigOf, WorldOptions } from '@daneren2005/shared-memory-ecs';
+export interface PhysicalWorldData {
+    spatialMapMemory?: SharedSpatialMapMemory;
+}
+export interface PhysicalSystemWorld extends EntityWorkerSystemWorld, PhysicalWorldData {
+    spatialMap?: SharedSpatialMap;
+}
+export interface PhysicalWorldSource {
+    spatialMap: SharedSpatialMap;
+}
+export type PhysicalWorldOptions<R extends ComponentDefinitionMap> = WorldOptions<ComponentsOf<R>, EntityConfigOf<R>> & {
+    spatial?: SharedSpatialMapConfig;
+};
+export type PhysicalWorldEntity<R extends ComponentDefinitionMap> = BaseEntity<ComponentsOf<R>, EntityConfigOf<R>>;
+export type PhysicalWorldFilter<R extends ComponentDefinitionMap> = (entity: PhysicalWorldEntity<R>) => boolean;
+export declare function addPhysicalWorldData(source: PhysicalWorldSource, target: PhysicalWorldData): void;
+export declare function getSpatialMap(world: PhysicalSystemWorld): SharedSpatialMap;
+export default class PhysicalWorld<R extends ComponentDefinitionMap> extends BaseWorld<R> implements PhysicalWorldSource {
+    readonly spatialMap: SharedSpatialMap;
+    private spatialIds;
+    constructor(registry: R, options?: PhysicalWorldOptions<R>);
+    updateSpatialEntity(entityOrId: PhysicalWorldEntity<R> | number): void;
+    searchSpatial(minX: number, minY: number, maxX: number, maxY: number, filter?: PhysicalWorldFilter<R>): Array<PhysicalWorldEntity<R>>;
+    searchSpatialAround(x: number, y: number, reachX: number, reachY: number, filter?: PhysicalWorldFilter<R>): Array<PhysicalWorldEntity<R>>;
+    findNearestSpatial(x: number, y: number, maxDistance?: number, filter?: PhysicalWorldFilter<R>): PhysicalWorldEntity<R> | undefined;
+    findNearbySpatial(x: number, y: number, maxResults: number, maxDistance?: number, filter?: PhysicalWorldFilter<R>): Array<PhysicalWorldEntity<R>>;
+}

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@daneren2005/shared-memory-physics",
 	"description": "2D physics components and systems built on the shared-memory ECS.",
 	"author": "Scott Jackson",
-	"version": "1.4.0",
+	"version": "1.6.0",
 	"type": "module",
 	"sideEffects": false,
 	"repository": {
@@ -36,12 +36,13 @@
 		"lint": "cross-env NODE_ENV=production oxlint .",
 		"lint:fix": "cross-env NODE_ENV=production oxlint --fix .",
 		"test": "vitest run",
+		"benchmark": "vitest bench --run",
 		"release": "semantic-release",
 		"prepare": "husky"
 	},
 	"devDependencies": {
-		"@daneren2005/shared-memory-ecs": "^1.5.0",
-		"@daneren2005/shared-memory-objects": "^1.2.0",
+		"@daneren2005/shared-memory-ecs": "^1.6.0",
+		"@daneren2005/shared-memory-objects": "^1.5.0",
 		"@semantic-release/git": "^10.0.1",
 		"@stylistic/eslint-plugin": "^5.10.0",
 		"@types/node": "^26.1.1",
@@ -58,7 +59,7 @@
 		"vitest": "^4.1.10"
 	},
 	"peerDependencies": {
-		"@daneren2005/shared-memory-ecs": "^1.2.2",
+		"@daneren2005/shared-memory-ecs": "^1.5.1",
 		"@daneren2005/shared-memory-objects": "^1.1.0"
 	},
 	"dependencies": {