excalibur 0.33.0-alpha.99 → 1.1.0-alpha.310

package/build/{dist → esm/src/engine}/collision/colliders/collider.d.ts

@@ -27,13 +27,19 @@ export declare abstract class Collider implements Clonable<Collider> {
      */
     composite: CompositeCollider | null;
     events: EventEmitter<any>;
+    protected _worldVersion: number;
+    /**
+     * Increments whenever this collider's world space geometry changes (owner transform, offset or shape), cheap change
+     * detection for spatial data structures
+     */
+    get worldVersion(): number;
     /**
      * Returns a boolean indicating whether this body collided with
      * or was in stationary contact with
      * the body of the other {@apilink Collider}
      */
     touching(other: Collider): boolean;
-    owner: Entity;
+    owner: Entity | null;
     /**
      * Pixel offset of the collision collider relative to the collider, by default (0, 0) meaning the collider is positioned
      * on top of the collider.

package/build/{dist/collision/colliders/shape.d.ts → esm/src/engine/collision/colliders/colliders.d.ts}

@@ -3,8 +3,53 @@ import { CircleCollider } from './circle-collider';
 import { EdgeCollider } from './edge-collider';
 import { Vector } from '../../math/vector';
 import { CompositeCollider } from './composite-collider';
+export declare class Colliders {
+    /**
+     * Creates a box collider, under the hood defines a {@apilink PolygonCollider} collider
+     * @param width Width of the box
+     * @param height Height of the box
+     * @param anchor Anchor of the box (default (.5, .5)) which positions the box relative to the center of the collider's position
+     * @param offset Optional offset relative to the collider in local coordinates
+     */
+    static Box(width: number, height: number, anchor?: Vector, offset?: Vector): PolygonCollider;
+    /**
+     * Creates a new {@apilink PolygonCollider | `arbitrary polygon`} collider
+     *
+     * PolygonColliders are useful for creating convex polygon shapes
+     * @param points Points specified in counter clockwise
+     * @param offset Optional offset relative to the collider in local coordinates
+     */
+    static Polygon(points: Vector[], offset?: Vector, suppressConvexWarning?: boolean): PolygonCollider;
+    /**
+     * Creates a new {@apilink CircleCollider | `circle`} collider
+     *
+     * Circle colliders are useful for balls, or to make collisions more forgiving on sharp edges
+     * @param radius Radius of the circle collider
+     * @param offset Optional offset relative to the collider in local coordinates
+     */
+    static Circle(radius: number, offset?: Vector): CircleCollider;
+    /**
+     * Creates a new {@apilink EdgeCollider | `edge`} collider
+     *
+     * Edge colliders are useful for  floors, walls, and other barriers
+     * @param begin Beginning of the edge in local coordinates to the collider
+     * @param end Ending of the edge in local coordinates to the collider
+     */
+    static Edge(begin: Vector, end: Vector): EdgeCollider;
+    /**
+     * Creates a new capsule shaped {@apilink CompositeCollider} using 2 circles and a box
+     *
+     * Capsule colliders are useful for platformers with incline or jagged floors to have a smooth
+     * player experience.
+     * @param width
+     * @param height
+     * @param offset Optional offset
+     */
+    static Capsule(width: number, height: number, offset?: Vector): CompositeCollider;
+}
 /**
  * Excalibur helper for defining colliders quickly
+ * @deprecated use Colliders.*
  */
 export declare class Shape {
     /**
@@ -13,6 +58,7 @@ export declare class Shape {
      * @param height Height of the box
      * @param anchor Anchor of the box (default (.5, .5)) which positions the box relative to the center of the collider's position
      * @param offset Optional offset relative to the collider in local coordinates
+     * @deprecated use Colliders.Box
      */
     static Box(width: number, height: number, anchor?: Vector, offset?: Vector): PolygonCollider;
     /**
@@ -21,6 +67,7 @@ export declare class Shape {
      * PolygonColliders are useful for creating convex polygon shapes
      * @param points Points specified in counter clockwise
      * @param offset Optional offset relative to the collider in local coordinates
+     * @deprecated Use Colliders.Polygon
      */
     static Polygon(points: Vector[], offset?: Vector, suppressConvexWarning?: boolean): PolygonCollider;
     /**
@@ -29,6 +76,7 @@ export declare class Shape {
      * Circle colliders are useful for balls, or to make collisions more forgiving on sharp edges
      * @param radius Radius of the circle collider
      * @param offset Optional offset relative to the collider in local coordinates
+     * @deprecated Use Colliders.Circle
      */
     static Circle(radius: number, offset?: Vector): CircleCollider;
     /**
@@ -37,6 +85,7 @@ export declare class Shape {
      * Edge colliders are useful for  floors, walls, and other barriers
      * @param begin Beginning of the edge in local coordinates to the collider
      * @param end Ending of the edge in local coordinates to the collider
+     * @deprecated Use Colliders.Edge
      */
     static Edge(begin: Vector, end: Vector): EdgeCollider;
     /**
@@ -47,6 +96,7 @@ export declare class Shape {
      * @param width
      * @param height
      * @param offset Optional offset
+     * @deprecated Use Colliders.Capsule
      */
     static Capsule(width: number, height: number, offset?: Vector): CompositeCollider;
 }

package/build/{dist → esm/src/engine}/collision/colliders/collision-jump-table.d.ts

@@ -2,6 +2,7 @@ import { CircleCollider } from './circle-collider';
 import { CollisionContact } from '../detection/collision-contact';
 import { PolygonCollider } from './polygon-collider';
 import { EdgeCollider } from './edge-collider';
+import type { SatShape } from './sat-shape';
 import { Vector } from '../../math/vector';
 export declare const CollisionJumpTable: {
     CollideCircleCircle(circleA: CircleCollider, circleB: CircleCollider): CollisionContact[];
@@ -9,6 +10,6 @@ export declare const CollisionJumpTable: {
     CollideCircleEdge(circle: CircleCollider, edge: EdgeCollider): CollisionContact[];
     CollideEdgeEdge(): CollisionContact[];
     CollidePolygonEdge(polygon: PolygonCollider, edge: EdgeCollider): CollisionContact[];
-    CollidePolygonPolygon(polyA: PolygonCollider, polyB: PolygonCollider): CollisionContact[];
+    CollidePolygonPolygon(polyA: SatShape, polyB: SatShape): CollisionContact[];
     FindContactSeparation(contact: CollisionContact, localPoint: Vector): number;
 };

package/build/{dist → esm/src/engine}/collision/colliders/edge-collider.d.ts

@@ -7,7 +7,7 @@ import type { Ray } from '../../math/ray';
 import type { Color } from '../../color';
 import { Collider } from './collider';
 import type { ExcaliburGraphicsContext } from '../../graphics/context/excalibur-graphics-context';
-import type { Transform } from '../../math/transform';
+import { Transform } from '../../math/transform';
 import type { RayCastHit } from '../detection/ray-cast-hit';
 export interface EdgeColliderOptions {
     /**
@@ -32,6 +32,30 @@ export declare class EdgeCollider extends Collider {
     end: Vector;
     private _transform;
     private _globalMatrix;
+    private _syncedVersion;
+    private _syncedOffsetX;
+    private _syncedOffsetY;
+    /**
+     * Rebuilds the world matrix from the owner transform if it (or the offset) changed since the last sync
+     */
+    private _ensureWorld;
+    get worldVersion(): number;
+    private _satPoints;
+    private _satNormals;
+    private _satCacheKey;
+    /**
+     * The transform from local edge space to world space, offset is baked into {@apilink EdgeCollider.points}
+     */
+    get transform(): Transform;
+    private _updateSatShape;
+    /**
+     * The edge as two points in local space (offset applied), ordered begin -> end
+     */
+    get points(): readonly Vector[];
+    /**
+     * Outward normals for the two sides (begin -> end and end -> begin) of the edge in local space
+     */
+    get normals(): readonly Vector[];
     constructor(options: EdgeColliderOptions);
     /**
      * Returns a clone of this Edge, not associated with any collider

package/build/{dist → esm/src/engine}/collision/colliders/polygon-collider.d.ts

@@ -50,6 +50,9 @@ export declare class PolygonCollider extends Collider {
      */
     get points(): Vector[];
     private _transform;
+    /**
+     * The world transform snapshot, synced with the owner transform on access
+     */
     get transform(): Transform;
     private _transformedPoints;
     private _sides;
@@ -123,6 +126,17 @@ export declare class PolygonCollider extends Collider {
      * @param transform
      */
     update(transform: Transform): void;
+    private _ownerTransform;
+    private _syncedVersion;
+    private _syncedOffsetX;
+    private _syncedOffsetY;
+    private _appliedMirrorX;
+    private _appliedMirrorY;
+    /**
+     * Rebuilds the world transform snapshot from the owner transform if anything changed since the last sync
+     */
+    private _sync;
+    get worldVersion(): number;
     /**
      * Tests if a point is contained in this collider in world space
      */
@@ -151,6 +165,15 @@ export declare class PolygonCollider extends Collider {
         distance: Vector;
         face: LineSegment;
     };
+    /**
+     * Get the axis aligned bounding box for the polygon collider in world coordinates
+     */
+    private _boundsDirty;
+    private _bounds;
+    /**
+     * World space bounds cached until the collider is updated, internal so callers can't mutate the cache
+     */
+    private _getWorldBounds;
     /**
      * Get the axis aligned bounding box for the polygon collider in world coordinates
      */

package/build/esm/src/engine/collision/colliders/sat-shape.d.ts

@@ -0,0 +1,27 @@
+import type { Vector } from '../../math/vector';
+import type { Id } from '../../id';
+import type { Transform } from '../../math/transform';
+/**
+ * Minimal convex shape description the separating axis test and contact clipping operate on.
+ *
+ * {@apilink PolygonCollider} and {@apilink EdgeCollider} (as a two-sided, two point "polygon") both satisfy this.
+ */
+export interface SatShape {
+    id: Id<'collider'>;
+    /**
+     * Points in local space (relative to `transform`), in perimeter order
+     */
+    points: readonly Vector[];
+    /**
+     * Outward normal for the side starting at each point, normals[i] belongs to side points[i] -> points[(i + 1) % length]
+     */
+    normals: readonly Vector[];
+    /**
+     * Transform from local space to world space
+     */
+    transform: Transform;
+    /**
+     * Center of the shape in world space
+     */
+    center: Vector;
+}

package/build/{dist → esm/src/engine}/collision/colliders/separating-axis.d.ts

@@ -3,7 +3,14 @@ import type { Vector } from '../../math/vector';
 import type { Collider } from './collider';
 import type { CircleCollider } from './circle-collider';
 import type { PolygonCollider } from './polygon-collider';
-import { Pool } from '../../util/pool';
+import { ArenaPool } from '../../util/arena-pool';
+import type { SatShape } from './sat-shape';
+export type { SatShape } from './sat-shape';
+/**
+ * Deep copies separation info out of the per frame {@apilink SeparatingAxis.SeparationPool} so it can outlive the frame
+ * @param info
+ */
+export declare function cloneSeparationInfo(info: SeparationInfo): SeparationInfo;
 /**
  * Specific information about a contact and it's separation
  */
@@ -46,13 +53,11 @@ export declare class SeparationInfo {
     localPoint?: Vector;
 }
 export declare class SeparatingAxis {
-    static SeparationPool: Pool<SeparationInfo>;
+    static SeparationPool: ArenaPool<SeparationInfo>;
     private static _ZERO;
-    private static _SCRATCH_POINT;
-    private static _SCRATCH_SUB_POINT;
-    private static _SCRATCH_NORMAL;
     private static _SCRATCH_MATRIX;
-    static findPolygonPolygonSeparation(polyA: PolygonCollider, polyB: PolygonCollider): SeparationInfo;
+    private static _SEPARATION_CACHE;
+    static findPolygonPolygonSeparation(polyA: SatShape, polyB: SatShape): SeparationInfo;
     static findCirclePolygonSeparation(circle: CircleCollider, polygon: PolygonCollider): Vector | null;
     static findPolygonPolygonSeparationDegenerate(polyA: PolygonCollider, polyB: PolygonCollider): SeparationInfo;
 }

package/build/{dist → esm/src/engine}/collision/collision-system.d.ts

@@ -7,12 +7,11 @@ import type { ExcaliburGraphicsContext } from '../graphics/context/excalibur-gra
 import type { Scene } from '../scene';
 import type { PhysicsWorld } from './physics-world';
 import { BodyComponent } from './index';
-import { PauseComponent } from '../entity-component-system/components/pause-component';
 export declare class CollisionSystem extends System {
     private _physics;
     static priority: -5;
     systemType: SystemType;
-    query: Query<ComponentCtor<TransformComponent> | ComponentCtor<ColliderComponent> | typeof PauseComponent>;
+    query: Query<ComponentCtor<TransformComponent> | ComponentCtor<ColliderComponent>>;
     bodyQuery: Query<ComponentCtor<BodyComponent>>;
     private _engine;
     private _configDirty;
@@ -26,9 +25,14 @@ export declare class CollisionSystem extends System {
     private _trackCollider;
     private _untrackCollider;
     constructor(world: World, _physics: PhysicsWorld);
-    initialize(world: World, scene: Scene): void;
-    update(elapsed: number): void;
-    postupdate(): void;
+    onInitialize(world: World, scene: Scene): void;
+    onUpdate(elapsed: number): void;
+    onPostUpdate(): void;
+    private _recordContacts;
+    /**
+     * Binds every active collider to its owner transform (a cheap no-op once bound) and returns the flattened list
+     */
+    private _updateColliders;
     getSolver(): CollisionSolver;
     debug(ex: ExcaliburGraphicsContext): void;
     runContactStartEnd(): void;

package/build/{dist → esm/src/engine}/collision/detection/collision-contact.d.ts

@@ -46,6 +46,12 @@ export declare class CollisionContact {
     info: SeparationInfo;
     bodyA: BodyComponent | null;
     bodyB: BodyComponent | null;
+    private _persisted;
+    /**
+     * Takes ownership of the pooled narrowphase data so this contact can be carried across frames without being
+     * detected again, used for contacts between bodies that can't move (asleep, or asleep against fixed geometry)
+     */
+    persist(): void;
     constructor(colliderA: Collider, colliderB: Collider, mtv: Vector, normal: Vector, tangent: Vector, points: Vector[], localPoints: Vector[], info: SeparationInfo);
     isCanceled(): boolean;
     cancel(): void;

package/build/{dist → esm/src/engine}/collision/detection/dynamic-tree.d.ts

@@ -8,18 +8,18 @@ import type { DynamicTreeConfig } from '../physics-config';
  * Dynamic Tree Node used for tracking bounds within the tree
  */
 export declare class TreeNode<T> {
-    parent?: TreeNode<T>;
-    left: TreeNode<T>;
-    right: TreeNode<T>;
+    parent: TreeNode<T> | null;
+    left: TreeNode<T> | null;
+    right: TreeNode<T> | null;
     bounds: BoundingBox;
     height: number;
-    data: T;
-    constructor(parent?: TreeNode<T>);
+    data: T | null;
+    constructor(parent?: TreeNode<T> | null);
     isLeaf(): boolean;
 }
 export interface ColliderProxy<T> {
     id: Id<'collider'>;
-    owner: T;
+    owner: T | null;
     bounds: BoundingBox;
 }
 /**
@@ -32,10 +32,8 @@ export interface ColliderProxy<T> {
 export declare class DynamicTree<TProxy extends ColliderProxy<Entity>> {
     private _config;
     worldBounds: BoundingBox;
-    root: TreeNode<TProxy>;
-    nodes: {
-        [key: number]: TreeNode<TProxy>;
-    };
+    root: TreeNode<TProxy> | null;
+    nodes: Record<number, TreeNode<TProxy>>;
     constructor(_config: Required<DynamicTreeConfig>, worldBounds?: BoundingBox);
     /**
      * Inserts a node into the dynamic tree
@@ -81,7 +79,7 @@ export declare class DynamicTree<TProxy extends ColliderProxy<Entity>> {
      * callback indicates that your are complete with your query and do not want to continue. Return false will continue searching
      * the tree until all possible bodies that would intersect with the ray have been returned.
      */
-    rayCastQuery(ray: Ray, max: number, callback: (other: TProxy) => boolean): void;
+    rayCastQuery(ray: Ray, max: number | undefined, callback: (other: TProxy) => boolean): void;
     getNodes(): TreeNode<TProxy>[];
     debug(ex: ExcaliburGraphicsContext): void;
 }

package/build/{dist → esm/src/engine}/collision/detection/pair.d.ts

@@ -1,4 +1,5 @@
 import type { CollisionContact } from './collision-contact';
+import { BodyComponent } from '../body-component';
 import type { Id } from '../../id';
 import type { Collider } from '../colliders/collider';
 /**
@@ -15,6 +16,14 @@ export declare class Pair {
      * @param colliderB
      */
     static canCollide(colliderA: Collider, colliderB: Collider): boolean;
+    /**
+     * A pair is dormant when neither body can move: both are asleep, or one is asleep against a
+     * {@apilink CollisionType.Fixed} body. Dormant pairs need no collision detection, the collision system
+     * carries their last contact over unchanged until one of them wakes.
+     * @param bodyA
+     * @param bodyB
+     */
+    static isDormant(bodyA: BodyComponent | null | undefined, bodyB: BodyComponent | null | undefined): boolean;
     /**
      * Returns whether or not it is possible for the pairs to collide
      */

package/build/{dist → esm/src/engine}/collision/detection/quad-tree.d.ts

@@ -14,7 +14,7 @@ export interface QuadTreeOptions {
  */
 export declare class QuadTree<TItem extends QuadTreeItem> {
     bounds: BoundingBox;
-    options?: QuadTreeOptions;
+    options: QuadTreeOptions;
     private _defaultOptions;
     halfWidth: number;
     halfHeight: number;
@@ -24,7 +24,7 @@ export declare class QuadTree<TItem extends QuadTreeItem> {
     topRight: QuadTree<TItem> | null;
     bottomLeft: QuadTree<TItem> | null;
     bottomRight: QuadTree<TItem> | null;
-    constructor(bounds: BoundingBox, options?: QuadTreeOptions);
+    constructor(bounds: BoundingBox, options: QuadTreeOptions);
     /**
      * Splits the quad tree one level deeper
      */

package/build/{dist → esm/src/engine}/collision/detection/sparse-hash-grid-collision-processor.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from '../../entity-component-system';
 import type { ExcaliburGraphicsContext } from '../../graphics/context/excalibur-graphics-context';
 import type { Ray } from '../../math/ray';
 import type { Vector } from '../../math/vector';
-import { Pool } from '../../util/pool';
+import { ArenaPool } from '../../util/arena-pool';
 import { BodyComponent } from '../body-component';
 import type { BoundingBox } from '../bounding-box';
 import type { Collider } from '../colliders/collider';
@@ -49,6 +49,11 @@ export declare class HashColliderProxy extends HashGridProxy<Collider> {
      */
     readonly gridSize: number;
     constructor(collider: Collider, gridSize: number);
+    private _lastWorldVersion;
+    /**
+     * Skips the bounds refresh and cell comparison entirely when the collider's world geometry hasn't changed
+     */
+    hasChanged(): boolean;
     /**
      * Updates the hashed bounds coordinates
      */
@@ -63,7 +68,7 @@ export declare class SparseHashGridCollisionProcessor implements CollisionProces
     readonly hashGrid: SparseHashGrid<Collider, HashColliderProxy>;
     private _pairs;
     private _nonPairs;
-    _pairPool: Pool<Pair>;
+    _pairPool: ArenaPool<Pair>;
     constructor(options: {
         size: number;
     });

package/build/{dist → esm/src/engine}/collision/detection/sparse-hash-grid.d.ts

@@ -32,6 +32,9 @@ export declare class HashGridProxy<T extends {
     constructor(object: T, gridSize: number);
     /**
      * Has the hashed bounds changed
+     *
+     * Refreshes `bounds` as a side effect (via {@apilink updateBounds}) so callers that need the current
+     * bounds regardless of the result (see {@apilink SparseHashGrid.update}) don't have to recompute them
      */
     hasChanged(): boolean;
     /**
@@ -44,6 +47,8 @@ export declare class HashGridProxy<T extends {
     updateBounds(): void;
     /**
      * Updates the hashed bounds coordinates
+     *
+     * Only called after {@apilink hasChanged} returns true, which has already refreshed `bounds`
      */
     update(): void;
 }
@@ -51,17 +56,17 @@ export declare class HashGridCell<TObject extends {
     bounds: BoundingBox;
 }, TProxy extends HashGridProxy<TObject> = HashGridProxy<TObject>> {
     proxies: TProxy[];
-    key: string;
+    key: number | bigint;
     x: number;
     y: number;
     configure(x: number, y: number): void;
-    static calculateHashKey(x: number, y: number): string;
+    static calculateHashKey(x: number, y: number): number | bigint;
 }
 export declare class SparseHashGrid<TObject extends {
     bounds: BoundingBox;
 }, TProxy extends HashGridProxy<TObject> = HashGridProxy<TObject>> {
     readonly gridSize: number;
-    readonly sparseHashGrid: Map<string, HashGridCell<TObject, TProxy>>;
+    readonly sparseHashGrid: Map<number | bigint, HashGridCell<TObject, TProxy>>;
     readonly objectToProxy: Map<TObject, TProxy>;
     bounds: BoundingBox;
     private _hashGridCellPool;
@@ -75,6 +80,9 @@ export declare class SparseHashGrid<TObject extends {
     get(xCoord: number, yCoord: number): HashGridCell<TObject>;
     private _insert;
     private _remove;
+    /**
+     * **WARNING** TObjects must use the same coordPlan on their .bounds to work properly
+     */
     track(target: TObject): void;
     untrack(target: TObject): void;
     update(targets: TObject[]): number;

package/build/{dist → esm/src/engine}/collision/group/collision-group-manager.d.ts

@@ -22,7 +22,7 @@ export declare class CollisionGroupManager {
      * Get a collision group by it's name
      * @param name
      */
-    static groupByName(name: string): CollisionGroup;
+    static groupByName(name: string): CollisionGroup | undefined;
     /**
      * Resets the managers internal group management state
      */

package/build/{dist → esm/src/engine}/collision/index.d.ts

@@ -4,7 +4,7 @@ export * from './collision-type';
 export * from './solver-strategy';
 export * from './colliders/collider';
 export * from './bounding-box';
-export * from './colliders/shape';
+export * from './colliders/colliders';
 export * from './colliders/collider';
 export * from './colliders/composite-collider';
 export * from './colliders/circle-collider';
@@ -12,6 +12,7 @@ export * from './colliders/edge-collider';
 export * from './colliders/polygon-collider';
 export * from './colliders/collision-jump-table';
 export * from './colliders/closest-line-jump-table';
+export type * from './colliders/sat-shape';
 export * from './colliders/separating-axis';
 export * from './group/collision-group';
 export * from './group/collision-group-manager';

package/build/{dist → esm/src/engine}/collision/motion-system.d.ts

@@ -1,6 +1,5 @@
 import type { Entity, Query, World } from '../entity-component-system';
 import { MotionComponent } from '../entity-component-system/components/motion-component';
-import { PauseComponent } from '../entity-component-system/components/pause-component';
 import { TransformComponent } from '../entity-component-system/components/transform-component';
 import { System, SystemType } from '../entity-component-system/system';
 import type { PhysicsWorld } from './physics-world';
@@ -10,9 +9,9 @@ export declare class MotionSystem extends System {
     static priority: -5;
     systemType: SystemType;
     private _physicsConfigDirty;
-    query: Query<typeof TransformComponent | typeof MotionComponent | typeof PauseComponent>;
+    query: Query<typeof TransformComponent | typeof MotionComponent>;
     private _createPhysicsQuery;
     constructor(world: World, physics: PhysicsWorld);
-    update(elapsed: number): void;
+    onUpdate(elapsed: number): void;
     captureOldTransformWithChildren(entity: Entity): void;
 }

package/build/{dist → esm/src/engine}/collision/physics-config.d.ts

@@ -213,6 +213,13 @@ export interface PhysicsConfig {
          * Default true
          */
         warmStart?: boolean;
+        /**
+         * Largest single position correction allowed per position iteration, in pixels. Prevents large overlaps
+         * from causing a single too-large correction (popping)
+         *
+         * Default -5
+         */
+        maxPositionCorrection?: number;
     };
 }
 export type BodyConfig = DeepRequired<Pick<PhysicsConfig, 'bodies'>['bodies']>;

package/build/{dist → esm/src/engine}/collision/physics-world.d.ts

@@ -7,46 +7,47 @@ import type { Vector } from '../math/vector';
 import { SpatialPartitionStrategy } from './detection/spatial-partition-strategy';
 export declare class PhysicsWorld {
     $configUpdate: Observable<Required<{
-        enabled?: boolean;
+        enabled?: boolean | undefined;
         integration?: Required<{
-            onScreenOnly?: boolean;
-        }>;
-        gravity?: Vector;
-        solver?: import("./solver-strategy").SolverStrategy;
-        substep?: number;
+            onScreenOnly?: boolean | undefined;
+        } | undefined>;
+        gravity?: Vector | undefined;
+        solver?: import("./solver-strategy").SolverStrategy | undefined;
+        substep?: number | undefined;
         colliders?: Required<{
-            compositeStrategy?: "separate" | "together";
-        }>;
+            compositeStrategy?: "separate" | "together" | undefined;
+        } | undefined>;
         continuous?: Required<{
-            checkForFastBodies?: boolean;
-            disableMinimumSpeedForFastBody?: boolean;
-            surfaceEpsilon?: number;
-        }>;
+            checkForFastBodies?: boolean | undefined;
+            disableMinimumSpeedForFastBody?: boolean | undefined;
+            surfaceEpsilon?: number | undefined;
+        } | undefined>;
         bodies?: Required<{
-            defaultMass?: number;
-            sleepEpsilon?: number;
-            wakeThreshold?: number;
-            sleepBias?: number;
-            sleepTimeThreshold?: number;
-            canSleepByDefault?: boolean;
-        }>;
-        spatialPartition?: SpatialPartitionStrategy;
-        sparseHashGrid?: import("./physics-config").SparseHashGridConfig;
+            defaultMass?: number | undefined;
+            sleepEpsilon?: number | undefined;
+            wakeThreshold?: number | undefined;
+            sleepBias?: number | undefined;
+            sleepTimeThreshold?: number | undefined;
+            canSleepByDefault?: boolean | undefined;
+        } | undefined>;
+        spatialPartition?: SpatialPartitionStrategy | undefined;
+        sparseHashGrid?: import("./physics-config").SparseHashGridConfig | undefined;
         dynamicTree?: Required<{
-            boundsPadding?: number;
-            velocityMultiplier?: number;
-        }>;
+            boundsPadding?: number | undefined;
+            velocityMultiplier?: number | undefined;
+        } | undefined>;
         arcade?: Required<{
-            contactSolveBias?: import("./index").ContactSolveBias;
-        }>;
+            contactSolveBias?: import("./index").ContactSolveBias | undefined;
+        } | undefined>;
         realistic?: Required<{
-            contactSolveBias?: import("./index").ContactSolveBias;
-            positionIterations?: number;
-            velocityIterations?: number;
-            slop?: number;
-            steeringFactor?: number;
-            warmStart?: boolean;
-        }>;
+            contactSolveBias?: import("./index").ContactSolveBias | undefined;
+            positionIterations?: number | undefined;
+            velocityIterations?: number | undefined;
+            slop?: number | undefined;
+            steeringFactor?: number | undefined;
+            warmStart?: boolean | undefined;
+            maxPositionCorrection?: number | undefined;
+        } | undefined>;
     }>>;
     private _configDirty;
     private _config;