@phalanx-engine/physics 0.1.0

package/dist/systems/PhysicsSystem.js

@@ -0,0 +1,316 @@
+import { GameSystem } from '@phalanx-engine/ecs';
+import { FP } from '@phalanx-engine/math';
+import { PhysicsSoASchema } from '../components/PhysicsBodyComponent';
+import { TransformSoASchema } from '../components/TransformComponent';
+import { SpatialHashGrid } from '../collision/SpatialHashGrid';
+import { NarrowPhase } from '../collision/NarrowPhase';
+import { PhysicsEvents } from '../events';
+const SEPARATION_HALF = FP.FromFloat(0.5);
+export class PhysicsSystem extends GameSystem {
+    physicsStore;
+    transformStore;
+    config;
+    spatialGrid;
+    collisionFilter = null;
+    externalTickProvider = null;
+    providerStarted = false;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.spatialGrid = new SpatialHashGrid(config.gridCellSize);
+    }
+    init(context) {
+        super.init(context);
+        this.physicsStore = this.entityManager.getOrCreateSoAStore(PhysicsSoASchema);
+        this.transformStore = this.entityManager.getOrCreateSoAStore(TransformSoASchema);
+        this.tryStartProvider();
+    }
+    tryStartProvider() {
+        if (this.providerStarted ||
+            !this.physicsStore ||
+            !this.transformStore ||
+            !this.externalTickProvider)
+            return;
+        this.providerStarted = true;
+        this.externalTickProvider.start(() => this.step());
+    }
+    setCollisionFilter(filter) {
+        this.collisionFilter = filter;
+    }
+    step() {
+        const subDt = FP.Div(this.config.tickDt, FP.FromFloat(this.config.subSteps));
+        for (let i = 0; i < this.config.subSteps; i++) {
+            this.applyVelocities(subDt);
+            this.rebuildSpatialGrid();
+            this.detectAndResolve();
+            this.applyFriction();
+        }
+    }
+    processTick(_tick) {
+        if (this.externalTickProvider)
+            return;
+        this.step();
+    }
+    setTickProvider(provider) {
+        this.externalTickProvider?.stop();
+        this.providerStarted = false;
+        this.externalTickProvider = provider;
+        this.tryStartProvider();
+    }
+    applyImpulse(entityId, vx, vz) {
+        const physIndex = this.physicsStore.indexOf(entityId);
+        if (physIndex === -1)
+            return;
+        this.physicsStore.arrays.ignorePhysics[physIndex] = 0;
+        this.physicsStore.arrays.velocityX[physIndex] = FP.ToRaw(vx);
+        this.physicsStore.arrays.velocityZ[physIndex] = FP.ToRaw(vz);
+    }
+    isSettled(threshold) {
+        const thresh = threshold ?? FP.FromFloat(0.01);
+        const threshSq = FP.Mul(thresh, thresh);
+        const velX = this.physicsStore.arrays.velocityX;
+        const velZ = this.physicsStore.arrays.velocityZ;
+        const isStatic = this.physicsStore.arrays.isStatic;
+        const ignore = this.physicsStore.arrays.ignorePhysics;
+        for (const entityId of this.physicsStore.entityIds()) {
+            const i = this.physicsStore.indexOf(entityId);
+            if (isStatic[i] === 1 || ignore[i] === 1)
+                continue;
+            const vx = FP.FromRaw(velX[i]);
+            const vz = FP.FromRaw(velZ[i]);
+            if (FP.Gt(FP.Add(FP.Mul(vx, vx), FP.Mul(vz, vz)), threshSq))
+                return false;
+        }
+        return true;
+    }
+    applyVelocities(dt) {
+        const physVelocityX = this.physicsStore.arrays.velocityX;
+        const physVelocityZ = this.physicsStore.arrays.velocityZ;
+        const physIsStatic = this.physicsStore.arrays.isStatic;
+        const physIgnorePhysics = this.physicsStore.arrays.ignorePhysics;
+        const fpPosXArr = this.transformStore.arrays.fpPositionX;
+        const fpPosZArr = this.transformStore.arrays.fpPositionZ;
+        const maxVelSq = FP.Mul(this.config.maxVelocity, this.config.maxVelocity);
+        const bounds = this.config.worldBounds;
+        const pendingBoundsExits = [];
+        for (const entityId of this.physicsStore.entityIds()) {
+            const physIndex = this.physicsStore.indexOf(entityId);
+            if (physIsStatic[physIndex] === 1)
+                continue;
+            if (physIgnorePhysics[physIndex] === 1)
+                continue;
+            const transformIndex = this.transformStore.indexOf(entityId);
+            if (transformIndex === -1)
+                continue;
+            let velX = FP.FromRaw(physVelocityX[physIndex]);
+            let velZ = FP.FromRaw(physVelocityZ[physIndex]);
+            const velMagSq = FP.Add(FP.Mul(velX, velX), FP.Mul(velZ, velZ));
+            if (FP.Gt(velMagSq, maxVelSq)) {
+                const scale = FP.Div(this.config.maxVelocity, FP.Sqrt(velMagSq));
+                velX = FP.Mul(velX, scale);
+                velZ = FP.Mul(velZ, scale);
+                physVelocityX[physIndex] = FP.ToRaw(velX);
+                physVelocityZ[physIndex] = FP.ToRaw(velZ);
+            }
+            const posX = FP.FromRaw(fpPosXArr[transformIndex]);
+            const posZ = FP.FromRaw(fpPosZArr[transformIndex]);
+            let newPosX = FP.Add(posX, FP.Mul(velX, dt));
+            let newPosZ = FP.Add(posZ, FP.Mul(velZ, dt));
+            if (bounds) {
+                const outOfBounds = FP.Lt(newPosX, bounds.minX) || FP.Gt(newPosX, bounds.maxX) ||
+                    FP.Lt(newPosZ, bounds.minZ) || FP.Gt(newPosZ, bounds.maxZ);
+                if (outOfBounds && this.config.ejectOnBoundsExit) {
+                    this.physicsStore.arrays.ignorePhysics[physIndex] = 1;
+                    this.physicsStore.arrays.velocityX[physIndex] = FP.ToRaw(FP._0);
+                    this.physicsStore.arrays.velocityZ[physIndex] = FP.ToRaw(FP._0);
+                    newPosX = FP.Clamp(newPosX, bounds.minX, bounds.maxX);
+                    newPosZ = FP.Clamp(newPosZ, bounds.minZ, bounds.maxZ);
+                    pendingBoundsExits.push({ entityId });
+                }
+                else {
+                    newPosX = FP.Clamp(newPosX, bounds.minX, bounds.maxX);
+                    newPosZ = FP.Clamp(newPosZ, bounds.minZ, bounds.maxZ);
+                }
+            }
+            fpPosXArr[transformIndex] = FP.ToRaw(newPosX);
+            fpPosZArr[transformIndex] = FP.ToRaw(newPosZ);
+        }
+        for (const evt of pendingBoundsExits) {
+            this.eventBus.emit(PhysicsEvents.BOUNDS_EXIT, evt);
+        }
+    }
+    rebuildSpatialGrid() {
+        this.spatialGrid.clear();
+        const physLastX = this.physicsStore.arrays.lastX;
+        const physLastZ = this.physicsStore.arrays.lastZ;
+        const physRadius = this.physicsStore.arrays.radius;
+        const fpPosXArr = this.transformStore.arrays.fpPositionX;
+        const fpPosZArr = this.transformStore.arrays.fpPositionZ;
+        for (const entityId of this.physicsStore.entityIds()) {
+            const physIndex = this.physicsStore.indexOf(entityId);
+            const transformIndex = this.transformStore.indexOf(entityId);
+            if (transformIndex === -1)
+                continue;
+            const posX = FP.FromRaw(fpPosXArr[transformIndex]);
+            const posZ = FP.FromRaw(fpPosZArr[transformIndex]);
+            const radius = FP.FromRaw(physRadius[physIndex]);
+            physLastX[physIndex] = FP.ToFloat(posX);
+            physLastZ[physIndex] = FP.ToFloat(posZ);
+            this.spatialGrid.insert(entityId, posX, posZ, radius);
+        }
+    }
+    detectAndResolve() {
+        const pairs = this.spatialGrid.queryPairs();
+        const physVelocityX = this.physicsStore.arrays.velocityX;
+        const physVelocityZ = this.physicsStore.arrays.velocityZ;
+        const physRadius = this.physicsStore.arrays.radius;
+        const physMass = this.physicsStore.arrays.mass;
+        const physIsStatic = this.physicsStore.arrays.isStatic;
+        const physIgnorePhysics = this.physicsStore.arrays.ignorePhysics;
+        const physRestitution = this.physicsStore.arrays.restitution;
+        const fpPosXArr = this.transformStore.arrays.fpPositionX;
+        const fpPosZArr = this.transformStore.arrays.fpPositionZ;
+        for (const [entityIdA, entityIdB] of pairs) {
+            const physIndexA = this.physicsStore.indexOf(entityIdA);
+            const physIndexB = this.physicsStore.indexOf(entityIdB);
+            if (physIndexA === -1 || physIndexB === -1)
+                continue;
+            if (physIgnorePhysics[physIndexA] === 1 || physIgnorePhysics[physIndexB] === 1) {
+                continue;
+            }
+            if (this.collisionFilter && !this.collisionFilter(entityIdA, entityIdB)) {
+                continue;
+            }
+            const transformIndexA = this.transformStore.indexOf(entityIdA);
+            const transformIndexB = this.transformStore.indexOf(entityIdB);
+            if (transformIndexA === -1 || transformIndexB === -1)
+                continue;
+            const posAX = FP.FromRaw(fpPosXArr[transformIndexA]);
+            const posAZ = FP.FromRaw(fpPosZArr[transformIndexA]);
+            const posBX = FP.FromRaw(fpPosXArr[transformIndexB]);
+            const posBZ = FP.FromRaw(fpPosZArr[transformIndexB]);
+            const radiusA = FP.FromRaw(physRadius[physIndexA]);
+            const radiusB = FP.FromRaw(physRadius[physIndexB]);
+            const manifold = NarrowPhase.circleVsCircle(posAX, posAZ, radiusA, posBX, posBZ, radiusB, entityIdA, entityIdB);
+            if (!manifold)
+                continue;
+            const restitutionA = FP.FromRaw(physRestitution[physIndexA]);
+            const restitutionB = FP.FromRaw(physRestitution[physIndexB]);
+            const restitution = (restitutionA === FP._0 && restitutionB === FP._0)
+                ? FP._1
+                : FP.Div(FP.Add(restitutionA, restitutionB), FP.FromFloat(2));
+            this.resolveCollision(manifold, restitution, physIndexA, physIndexB, transformIndexA, transformIndexB, physVelocityX, physVelocityZ, physMass, physIsStatic, fpPosXArr, fpPosZArr);
+            const event = {
+                entityA: entityIdA,
+                entityB: entityIdB,
+                manifold,
+            };
+            this.eventBus.emit(PhysicsEvents.COLLISION, event);
+        }
+    }
+    resolveCollision(manifold, restitution, physIndexA, physIndexB, transformIndexA, transformIndexB, physVelocityX, physVelocityZ, physMass, physIsStatic, fpPosXArr, fpPosZArr) {
+        const isStaticA = physIsStatic[physIndexA] === 1;
+        const isStaticB = physIsStatic[physIndexB] === 1;
+        if (isStaticA && isStaticB)
+            return;
+        const massA = FP.FromRaw(physMass[physIndexA]);
+        const massB = FP.FromRaw(physMass[physIndexB]);
+        const totalMass = FP.Add(massA, massB);
+        const nx = manifold.normalX;
+        const nz = manifold.normalZ;
+        const overlap = manifold.penetration;
+        const pushForce = FP.Mul(FP.Mul(overlap, this.config.pushStrength), restitution);
+        const ratioA = isStaticA ? FP._0 : (isStaticB ? FP._1 : FP.Div(massB, totalMass));
+        const ratioB = isStaticB ? FP._0 : (isStaticA ? FP._1 : FP.Div(massA, totalMass));
+        if (!isStaticA) {
+            const pushA = FP.Mul(pushForce, ratioA);
+            const velAx = FP.FromRaw(physVelocityX[physIndexA]);
+            const velAz = FP.FromRaw(physVelocityZ[physIndexA]);
+            physVelocityX[physIndexA] = FP.ToRaw(FP.Sub(velAx, FP.Mul(nx, pushA)));
+            physVelocityZ[physIndexA] = FP.ToRaw(FP.Sub(velAz, FP.Mul(nz, pushA)));
+        }
+        if (!isStaticB) {
+            const pushB = FP.Mul(pushForce, ratioB);
+            const velBx = FP.FromRaw(physVelocityX[physIndexB]);
+            const velBz = FP.FromRaw(physVelocityZ[physIndexB]);
+            physVelocityX[physIndexB] = FP.ToRaw(FP.Add(velBx, FP.Mul(nx, pushB)));
+            physVelocityZ[physIndexB] = FP.ToRaw(FP.Add(velBz, FP.Mul(nz, pushB)));
+        }
+        const separation = FP.Mul(overlap, SEPARATION_HALF);
+        if (!isStaticA) {
+            const sepA = FP.Mul(separation, ratioA);
+            const posAX = FP.FromRaw(fpPosXArr[transformIndexA]);
+            const posAZ = FP.FromRaw(fpPosZArr[transformIndexA]);
+            const newAX = FP.Sub(posAX, FP.Mul(nx, sepA));
+            const newAZ = FP.Sub(posAZ, FP.Mul(nz, sepA));
+            fpPosXArr[transformIndexA] = FP.ToRaw(newAX);
+            fpPosZArr[transformIndexA] = FP.ToRaw(newAZ);
+        }
+        if (!isStaticB) {
+            const sepB = FP.Mul(separation, ratioB);
+            const posBX = FP.FromRaw(fpPosXArr[transformIndexB]);
+            const posBZ = FP.FromRaw(fpPosZArr[transformIndexB]);
+            const newBX = FP.Add(posBX, FP.Mul(nx, sepB));
+            const newBZ = FP.Add(posBZ, FP.Mul(nz, sepB));
+            fpPosXArr[transformIndexB] = FP.ToRaw(newBX);
+            fpPosZArr[transformIndexB] = FP.ToRaw(newBZ);
+        }
+    }
+    applyFriction() {
+        const physVelocityX = this.physicsStore.arrays.velocityX;
+        const physVelocityZ = this.physicsStore.arrays.velocityZ;
+        const physFriction = this.physicsStore.arrays.friction;
+        const physIsStatic = this.physicsStore.arrays.isStatic;
+        const physIgnore = this.physicsStore.arrays.ignorePhysics;
+        for (const entityId of this.physicsStore.entityIds()) {
+            const physIndex = this.physicsStore.indexOf(entityId);
+            if (physIsStatic[physIndex] === 1)
+                continue;
+            if (physIgnore[physIndex] === 1)
+                continue;
+            const frictionRaw = physFriction[physIndex];
+            const friction = frictionRaw === 0n
+                ? this.config.defaultFriction
+                : FP.FromRaw(frictionRaw);
+            physVelocityX[physIndex] = FP.ToRaw(FP.Mul(FP.FromRaw(physVelocityX[physIndex]), friction));
+            physVelocityZ[physIndex] = FP.ToRaw(FP.Mul(FP.FromRaw(physVelocityZ[physIndex]), friction));
+        }
+    }
+    getPhysicsStore() {
+        return this.physicsStore;
+    }
+    getTransformStore() {
+        return this.transformStore;
+    }
+    getConfig() {
+        return this.config;
+    }
+    getEntityPosition(entityId) {
+        const transformIndex = this.transformStore.indexOf(entityId);
+        if (transformIndex === -1) {
+            return undefined;
+        }
+        const physIndex = this.physicsStore.indexOf(entityId);
+        if (physIndex === -1) {
+            return undefined;
+        }
+        const fpPosXArr = this.transformStore.arrays.fpPositionX;
+        const fpPosZArr = this.transformStore.arrays.fpPositionZ;
+        return {
+            x: FP.FromRaw(fpPosXArr[transformIndex]),
+            z: FP.FromRaw(fpPosZArr[transformIndex]),
+        };
+    }
+    getSpatialGrid() {
+        return this.spatialGrid;
+    }
+    getEventBus() {
+        return this.eventBus;
+    }
+    dispose() {
+        this.externalTickProvider?.stop();
+        this.providerStarted = false;
+        super.dispose();
+        this.spatialGrid.clear();
+    }
+}

package/dist/systems/index.d.ts

@@ -0,0 +1,5 @@
+export { PhysicsSystem } from './PhysicsSystem';
+export { CollisionSystem } from './CollisionSystem';
+export { InterpolationSystem } from './InterpolationSystem';
+export type { InterpolatedTransformSample } from './InterpolationSystem';
+//# sourceMappingURL=index.d.ts.map

package/dist/systems/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/systems/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,YAAY,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/systems/index.js

@@ -0,0 +1,3 @@
+export { PhysicsSystem } from './PhysicsSystem';
+export { CollisionSystem } from './CollisionSystem';
+export { InterpolationSystem } from './InterpolationSystem';

package/dist/tick/AutonomousPhysicsTickProvider.d.ts

@@ -0,0 +1,18 @@
+import type { IPhysicsTickProvider } from './IPhysicsTickProvider';
+export interface AutonomousProviderOptions {
+    maxSteps?: number;
+    isSettled: () => boolean;
+    onSettled: () => void;
+}
+export declare class AutonomousPhysicsTickProvider implements IPhysicsTickProvider {
+    private running;
+    private steps;
+    private onStepFn;
+    private readonly options;
+    constructor(options: AutonomousProviderOptions);
+    start(onStep: () => void): void;
+    stop(): void;
+    private schedule;
+    private tick;
+}
+//# sourceMappingURL=AutonomousPhysicsTickProvider.d.ts.map

package/dist/tick/AutonomousPhysicsTickProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutonomousPhysicsTickProvider.d.ts","sourceRoot":"","sources":["../../src/tick/AutonomousPhysicsTickProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,MAAM,WAAW,yBAAyB;IAExC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,MAAM,OAAO,CAAC;IAEzB,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,qBAAa,6BAA8B,YAAW,oBAAoB;IACxE,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;gBAElD,OAAO,EAAE,yBAAyB;IAI9C,KAAK,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI;IAQ/B,IAAI,IAAI,IAAI;IAMZ,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,IAAI;CAWb"}

package/dist/tick/AutonomousPhysicsTickProvider.js

@@ -0,0 +1,39 @@
+export class AutonomousPhysicsTickProvider {
+    running = false;
+    steps = 0;
+    onStepFn = null;
+    options;
+    constructor(options) {
+        this.options = { maxSteps: 10_000, ...options };
+    }
+    start(onStep) {
+        this.stop();
+        this.running = true;
+        this.steps = 0;
+        this.onStepFn = onStep;
+        this.schedule();
+    }
+    stop() {
+        this.running = false;
+        this.onStepFn = null;
+        this.steps = 0;
+    }
+    schedule() {
+        const next = typeof setImmediate !== 'undefined'
+            ? (fn) => setImmediate(fn)
+            : (fn) => setTimeout(fn, 0);
+        next(() => this.tick());
+    }
+    tick() {
+        if (!this.running)
+            return;
+        this.onStepFn();
+        this.steps++;
+        if (this.options.isSettled() || this.steps >= this.options.maxSteps) {
+            this.running = false;
+            this.options.onSettled();
+            return;
+        }
+        this.schedule();
+    }
+}

package/dist/tick/ExternalPhysicsTickProvider.d.ts

@@ -0,0 +1,8 @@
+import type { IPhysicsTickProvider } from './IPhysicsTickProvider';
+export declare class ExternalPhysicsTickProvider implements IPhysicsTickProvider {
+    private onStepFn;
+    start(onStep: () => void): void;
+    stop(): void;
+    tick(): void;
+}
+//# sourceMappingURL=ExternalPhysicsTickProvider.d.ts.map

package/dist/tick/ExternalPhysicsTickProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExternalPhysicsTickProvider.d.ts","sourceRoot":"","sources":["../../src/tick/ExternalPhysicsTickProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,qBAAa,2BAA4B,YAAW,oBAAoB;IACtE,OAAO,CAAC,QAAQ,CAA6B;IAC7C,KAAK,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI;IAC/B,IAAI,IAAI,IAAI;IAEZ,IAAI,IAAI,IAAI;CACb"}

package/dist/tick/ExternalPhysicsTickProvider.js

@@ -0,0 +1,6 @@
+export class ExternalPhysicsTickProvider {
+    onStepFn = null;
+    start(onStep) { this.onStepFn = onStep; }
+    stop() { this.onStepFn = null; }
+    tick() { this.onStepFn?.(); }
+}

package/dist/tick/IPhysicsTickProvider.d.ts

@@ -0,0 +1,5 @@
+export interface IPhysicsTickProvider {
+    start(onStep: () => void): void;
+    stop(): void;
+}
+//# sourceMappingURL=IPhysicsTickProvider.d.ts.map

package/dist/tick/IPhysicsTickProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IPhysicsTickProvider.d.ts","sourceRoot":"","sources":["../../src/tick/IPhysicsTickProvider.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,oBAAoB;IAKnC,KAAK,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAGhC,IAAI,IAAI,IAAI,CAAC;CACd"}

package/dist/tick/IPhysicsTickProvider.js

@@ -0,0 +1 @@
+export {};

package/dist/tick/index.d.ts

@@ -0,0 +1,5 @@
+export type { IPhysicsTickProvider } from './IPhysicsTickProvider';
+export { AutonomousPhysicsTickProvider } from './AutonomousPhysicsTickProvider';
+export type { AutonomousProviderOptions } from './AutonomousPhysicsTickProvider';
+export { ExternalPhysicsTickProvider } from './ExternalPhysicsTickProvider';
+//# sourceMappingURL=index.d.ts.map

package/dist/tick/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tick/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAChF,YAAY,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/tick/index.js

@@ -0,0 +1,2 @@
+export { AutonomousPhysicsTickProvider } from './AutonomousPhysicsTickProvider';
+export { ExternalPhysicsTickProvider } from './ExternalPhysicsTickProvider';

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+import type { FixedPoint } from '@phalanx-engine/math';
+import type { CollisionManifold } from './collision/CollisionManifold';
+export interface CollisionFilter {
+    category: number;
+    mask: number;
+}
+export interface CollisionEvent {
+    entityA: number;
+    entityB: number;
+    manifold: CollisionManifold;
+}
+export interface BoundsExitEvent {
+    entityId: number;
+}
+export interface PhysicsConfig {
+    tickDt: FixedPoint;
+    subSteps: number;
+    maxVelocity: FixedPoint;
+    defaultFriction: FixedPoint;
+    pushStrength: FixedPoint;
+    gridCellSize: FixedPoint;
+    worldBounds?: {
+        minX: FixedPoint;
+        minZ: FixedPoint;
+        maxX: FixedPoint;
+        maxZ: FixedPoint;
+    };
+    ejectOnBoundsExit?: boolean;
+}
+export interface PhysicsBodyConfig {
+    radius: FixedPoint;
+    mass?: FixedPoint;
+    isStatic?: boolean;
+    restitution?: FixedPoint;
+    friction?: FixedPoint;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAQvE,MAAM,WAAW,eAAe;IAE9B,QAAQ,EAAE,MAAM,CAAC;IAEjB,IAAI,EAAE,MAAM,CAAC;CACd;AAKD,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,iBAAiB,CAAC;CAC7B;AAKD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAKD,MAAM,WAAW,aAAa;IAE5B,MAAM,EAAE,UAAU,CAAC;IAEnB,QAAQ,EAAE,MAAM,CAAC;IAEjB,WAAW,EAAE,UAAU,CAAC;IAExB,eAAe,EAAE,UAAU,CAAC;IAE5B,YAAY,EAAE,UAAU,CAAC;IAEzB,YAAY,EAAE,UAAU,CAAC;IAEzB,WAAW,CAAC,EAAE;QACZ,IAAI,EAAE,UAAU,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;QACjB,IAAI,EAAE,UAAU,CAAC;KAClB,CAAC;IAMF,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAKD,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,QAAQ,CAAC,EAAE,UAAU,CAAC;CACvB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@phalanx-engine/physics",
+  "version": "0.1.0",
+  "description": "Deterministic fixed-point physics engine for Phalanx Engine - spatial hashing, collision detection, and resolution",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "@phalanx-engine/ecs": "^0.1.0",
+    "@phalanx-engine/math": "^0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "~5.9.3",
+    "vitest": "^1.0.0",
+    "@phalanx-engine/ecs": "0.1.0",
+    "@phalanx-engine/math": "0.1.0"
+  },
+  "keywords": [
+    "physics",
+    "deterministic",
+    "fixed-point",
+    "collision-detection",
+    "spatial-hash",
+    "ecs",
+    "phalanx"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/phaeton-forge/phalanx-engine.git",
+    "directory": "phalanx-physics"
+  },
+  "bugs": "https://github.com/phaeton-forge/phalanx-engine/issues",
+  "homepage": "https://github.com/phaeton-forge/phalanx-engine/tree/main/phalanx-physics#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "rebuild": "npm run clean && npm run build",
+    "test": "vitest run"
+  }
+}