angry-pixel 1.0.8 → 1.1.1

package/lib/input/GamepadController.d.ts

@@ -1,3 +1,4 @@
+import { Vector2 } from "../math/Vector2";
 export declare class GamepadController {
     private readonly gamepads;
     constructor();
@@ -6,17 +7,24 @@ export declare class GamepadController {
     private gamepadConnected;
     private gamepadDisconected;
     update(): void;
+    private getGamepads;
 }
 export declare class GamepadData {
     private _connected;
     private _id;
     private readonly buttons;
     private readonly axes;
+    private readonly _dpadAxes;
+    private readonly _leftStickAxes;
+    private readonly _rightStickAxes;
     updateFromGamepad(gamepad: Gamepad): void;
+    get id(): string;
     getButtonPressed(index: number): boolean;
     getAxis(index: number): number;
+    get dpadAxes(): Vector2;
+    get leftStickAxes(): Vector2;
+    get rightStickAxes(): Vector2;
     get connected(): boolean;
-    get id(): string;
     get dpadUp(): boolean;
     get dpadDown(): boolean;
     get dpadLeft(): boolean;

package/lib/input/KeyboardController.d.ts

@@ -4,4 +4,9 @@ export declare class KeyboardController {
     constructor(canvas: HTMLCanvasElement);
     private eventHandler;
     isPressed(keyCode: string): boolean;
+    orPressed(keyCodes: string[]): boolean;
+    andPressed(keyCodes: string[]): boolean;
+    isPressedReturn<T>(keyCode: string, returnTrue: T, returnFalse: T): T;
+    orPressedReturn<T>(keyCodes: string[], returnTrue: T, returnFalse: T): T;
+    andPressedReturn<T>(keyCodes: string[], returnTrue: T, returnFalse: T): T;
 }

package/lib/math/Rotation.d.ts

@@ -3,10 +3,7 @@ export declare class Rotation {
     private _degrees;
     private _radians;
     private _direction;
-    constructor(config?: {
-        radians?: number;
-        degrees?: number;
-    });
+    constructor(radians?: number | null, degrees?: number | null);
     set degrees(degrees: number);
     get degrees(): number;
     set radians(radians: number);

package/lib/math/Utils.d.ts

@@ -24,3 +24,10 @@ export declare const fixedRound: (value: number, decimals: number) => number;
  * @returns number range
  */
 export declare const range: (start: number, end: number, steps?: number) => number[];
+/**
+ * @param value number to compare
+ * @param min min value
+ * @param max max value
+ * @returns true if the number is between the min and the max, false instead
+ */
+export declare const between: (value: number, min: number, max: number) => boolean;

package/lib/physics/PhysicsManager.d.ts

@@ -0,0 +1,24 @@
+import { CollisionManager } from "./collision/CollisionManager";
+import { RigidBodyData } from "./rigodBody/RigidBodyData";
+export declare enum RigidBodyType {
+    Static = 0,
+    Dynamic = 1
+}
+export declare class RigidBodyManager {
+    private readonly collisionManager;
+    private rigidBodyData;
+    private cachePosition;
+    private cacheVelocity;
+    private cacheGravity;
+    private cacheDisplacement;
+    private cacheNewDisplacement;
+    private cacheCollisions;
+    constructor(collisionManager: CollisionManager);
+    addRigidBodyData(data: RigidBodyData): void;
+    update(deltaTime: number): void;
+    private applyGravity;
+    private applyVelocity;
+    private applyReposition;
+    private getCollisions;
+    clear(): void;
+}

package/lib/physics/PhysicsManagerOld2.d.ts

@@ -0,0 +1,34 @@
+import { CollisionManager } from "./collision/CollisionManager";
+import { GameObject } from "../core/GameObject";
+import { Vector2 } from "../math/Vector2";
+import { ICollider } from "./collision/collider/ICollider";
+import { TimeManager } from "../core/managers/TimeManager";
+export declare enum RigidBodyType {
+    Static = 0,
+    Dynamic = 1
+}
+export interface RigidBodyData {
+    gameObject: GameObject;
+    gravity: Vector2;
+    velocity: Vector2;
+    layersToCollider: string[];
+    colliders: ICollider[];
+}
+export declare class PhysicsManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private rigidBodyData;
+    private cachePosition;
+    private cacheVelocity;
+    private cacheGravity;
+    private cacheDisplacement;
+    private cacheNewDisplacement;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager);
+    addRigidBodyData(data: RigidBodyData): void;
+    updatePositions(): void;
+    private applyGravityAndVelocity;
+    applyReposition(): void;
+    private applyRepositionToGameObject;
+    private getCollisions;
+    clear(): void;
+}

package/lib/physics/collision/ColliderData.d.ts

@@ -0,0 +1,15 @@
+import { QuadItem } from "./QuadTree";
+import { Shape } from "./shape/Shape";
+export declare class ColliderData implements QuadItem {
+    shape: Shape;
+    layer: string;
+    id: string;
+    updateCollisions: boolean;
+    physics: boolean;
+    rigidBody: boolean;
+    constructor(shape: Shape, layer: string, id: string, updateCollisions: boolean, physics: boolean, rigidBody: boolean);
+    get x(): number;
+    get y(): number;
+    get x1(): number;
+    get y1(): number;
+}

package/lib/physics/collision/CollisionManager.d.ts

@@ -1,27 +1,31 @@
 import { Rectangle } from "../../math/Rectangle";
-import { ICollider } from "./collider/ICollider";
-import { CollisionData } from "./CollisionData";
-import { ICollisionResolver } from "./resolver/ICollisionResolver";
+import { ColliderData } from "./ColliderData";
+import { CollisionMethod } from "./method/CollisionMethod";
+import { CollisionResolution } from "./resolver/CollisionResolver";
 export interface Collision {
-    localCollider: ICollider;
-    remoteCollider: ICollider;
-    collisionData: CollisionData;
+    localCollider: ColliderData;
+    remoteCollider: ColliderData;
+    resolution: CollisionResolution;
 }
 export declare class CollisionManager {
     private colliders;
     private quadTree;
     private bounds;
     private fixedQuadTree;
-    private resolver;
+    private method;
+    private collisions;
     private minBounds;
     private maxBounds;
     private newBounds;
-    constructor(resolver: ICollisionResolver, quadTreeBounds: Rectangle | null, quadMaxLevel: number, collidersPerQuad: number);
-    addCollider(collider: ICollider): void;
-    removeCollider(collider: ICollider): void;
-    getCollisionsForCollider(collider: ICollider): Collision[];
-    private broadPhase;
-    private narrowPhase;
+    constructor(method: CollisionMethod, quadTreeBounds: Rectangle | null, quadMaxLevel: number, collidersPerQuad: number);
+    addCollider(collider: ColliderData): void;
+    removeCollider(collider: ColliderData): void;
+    getFrameCollisionsForCollider(collider: ColliderData): Collision[];
+    refreshCollisionsForCollider(collider: ColliderData): Collision[];
+    clear(): void;
     update(): void;
     private updateNewBounds;
+    private updateCollisions;
+    private broadPhase;
+    private narrowPhase;
 }

package/lib/physics/collision/CollisionManagerOld.d.ts

@@ -0,0 +1,27 @@
+import { Rectangle } from "../../math/Rectangle";
+import { ICollider } from "./collider/ICollider";
+import { CollisionData } from "./CollisionData";
+import { ICollisionResolver } from "./resolver/ICollisionResolver";
+export interface Collision {
+    localCollider: ICollider;
+    remoteCollider: ICollider;
+    collisionData: CollisionData;
+}
+export declare class CollisionManager {
+    private colliders;
+    private quadTree;
+    private bounds;
+    private fixedQuadTree;
+    private resolver;
+    private minBounds;
+    private maxBounds;
+    private newBounds;
+    constructor(resolver: ICollisionResolver, quadTreeBounds: Rectangle | null, quadMaxLevel: number, collidersPerQuad: number);
+    addCollider(collider: ICollider): void;
+    removeCollider(collider: ICollider): void;
+    getCollisionsForCollider(collider: ICollider): Collision[];
+    private broadPhase;
+    private narrowPhase;
+    update(): void;
+    private updateNewBounds;
+}

package/lib/physics/collision/QuadTree.d.ts

@@ -1,14 +1,19 @@
 import { Rectangle } from "../../math/Rectangle";
-import { ICollider } from "./collider/ICollider";
-export declare const DEFAULT_MAX_COLLIDERS: number;
+export declare const DEFAULT_MAX_ITEMS: number;
 export declare const DEFAULT_MAX_LEVELS: number;
+export interface QuadItem {
+    x: number;
+    y: number;
+    x1: number;
+    y1: number;
+}
 export declare class QuadTree {
     private _bounds;
+    private _items;
     private _quadrants;
     private readonly maxLevels;
-    private readonly maxColliders;
+    private readonly maxItems;
     private readonly level;
-    private colliders;
     private readonly sw;
     private readonly se;
     private readonly nw;
@@ -16,17 +21,17 @@ export declare class QuadTree {
     private center;
     private childrenWidth;
     private childrenHeight;
-    private quadrantsForCollider;
-    constructor(level: number, bounds: Rectangle, maxLevels?: number, maxColliders?: number);
+    private quadsForItem;
+    constructor(level: number, bounds: Rectangle, maxLevels?: number, maxItems?: number);
     get bounds(): Rectangle;
     get quadrants(): QuadTree[];
     updateBounds(bounds: Rectangle): void;
-    clearColliders(): void;
+    clearItems(): void;
     clearQuadrants(): void;
-    addCollider(collider: ICollider): void;
-    retrieve(collider: ICollider): ICollider[];
+    addItem(item: QuadItem): void;
+    retrieve<T extends QuadItem>(item: QuadItem): T[];
     private splitQuad;
-    private getChildrenQuadrantForCollider;
-    private insertColliderIntoChildrenQuads;
+    private getChildrenQuadrantForItem;
+    private insertItemIntoChildrenQuads;
     private updateCache;
 }

package/lib/physics/collision/method/AABBMethod.d.ts

@@ -0,0 +1,13 @@
+import { Shape } from "../shape/Shape";
+import { CollisionResolution } from "../resolver/CollisionResolver";
+import { CollisionMethod } from "./CollisionMethod";
+import { AABBResolver } from "../resolver/AABBResolver";
+import { CircumferenceAABBResolver } from "../resolver/CircumferenceAABBResolver";
+import { CircumferenceResolver } from "../resolver/CircumferenceResolver";
+export declare class AABBMethod implements CollisionMethod {
+    private readonly AABBResolver;
+    private readonly circumferenceAABBResolver;
+    private readonly circumferenceResolver;
+    constructor(AABBResolver: AABBResolver, circumferenceAABBResolver: CircumferenceAABBResolver, circumferenceResolver: CircumferenceResolver);
+    getCollisionResolution(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
+}

package/lib/physics/collision/method/CollisionMethod.d.ts

@@ -0,0 +1,5 @@
+import { Shape } from "../shape/Shape";
+import { CollisionResolution } from "../resolver/CollisionResolver";
+export interface CollisionMethod {
+    getCollisionResolution(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
+}

package/lib/physics/collision/method/SatMethod.d.ts

@@ -0,0 +1,11 @@
+import { Shape } from "../shape/Shape";
+import { CollisionResolution } from "../resolver/CollisionResolver";
+import { CollisionMethod } from "./CollisionMethod";
+import { CircumferenceResolver } from "../resolver/CircumferenceResolver";
+import { SatResolver } from "../resolver/SatResolver";
+export declare class SatMethod implements CollisionMethod {
+    private readonly circumferenceResolver;
+    private readonly satResolver;
+    constructor(circumferenceResolver: CircumferenceResolver, satResolver: SatResolver);
+    getCollisionResolution(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
+}

package/lib/physics/collision/resolver/AABBResolver.d.ts

@@ -1,14 +1,11 @@
-import { CollisionData } from "../CollisionData";
-import { Shape } from "../shape/Shape";
-import { ICollisionResolver } from "./ICollisionResolver";
-export declare class AABBResolver implements ICollisionResolver {
-    private shape1Rect;
-    private shape2Rect;
+import { Rectangle } from "../shape/Rectangle";
+import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
+export declare class AABBResolver implements CollisionResolver {
     private overlapX;
     private overlapY;
     private minOverlap;
-    private displaceDirection;
-    getCollisionData(shape1: Shape, shape2: Shape): CollisionData | null;
-    private setShapeRect;
+    private direction;
+    private displacementDirection;
+    resolve(shapeA: Rectangle, shapeB: Rectangle): CollisionResolution | null;
     private preventContainment;
 }

package/lib/physics/collision/resolver/CircumferenceAABBResolver.d.ts

@@ -0,0 +1,9 @@
+import { Circumference } from "../shape/Circumference";
+import { Rectangle } from "../shape/Rectangle";
+import { CollisionResolver, CollisionResolution } from "./CollisionResolver";
+export declare class CircumferenceAABBResolver implements CollisionResolver {
+    private closestPoint;
+    private distance;
+    private direction;
+    resolve(shapeA: Circumference, shapeB: Rectangle, invert?: boolean): CollisionResolution;
+}

package/lib/physics/collision/resolver/CircumferenceCircumferenceResolver.d.ts

@@ -0,0 +1,7 @@
+import { Circumference } from "../shape/Circumference";
+import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
+export declare class CircumferenceCircumferenceResolver implements CollisionResolver {
+    private distance;
+    private direction;
+    resolve(shapeA: Circumference, shapeB: Circumference): CollisionResolution;
+}

package/lib/physics/collision/resolver/CircumferencePolygonResolver.d.ts

@@ -0,0 +1,23 @@
+import { Circumference } from "../shape/Circumference";
+import { Line } from "../shape/Line";
+import { Polygon } from "../shape/Polygon";
+import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
+export declare class CircumferencePolygonResolver implements CollisionResolver {
+    private axes;
+    private projA;
+    private projB;
+    private currentOverlap;
+    private minOverlap;
+    private displaceDirection;
+    private direction;
+    private closestVertex;
+    private distance;
+    private newDistance;
+    private circumferenceAxis;
+    private cache;
+    resolve(shapeA: Circumference, shapeB: Polygon | Line, invert?: boolean): CollisionResolution;
+    private findClosestVertex;
+    private setCircumferenceVertices;
+    private projectShapeOntoAxis;
+    private preventContainment;
+}

package/lib/physics/collision/resolver/CircumferenceRectangleResolver.d.ts

@@ -0,0 +1,9 @@
+import { Circumference } from "../shape/Circumference";
+import { Rectangle } from "../shape/Rectangle";
+import { CollisionResolver, CollisionResolution } from "./CollisionResolver";
+export declare class CircumferenceRectangleResolver implements CollisionResolver {
+    private closestPoint;
+    private distance;
+    private direction;
+    resolve(shapeA: Circumference, shapeB: Rectangle, invert?: boolean): CollisionResolution;
+}

package/lib/physics/collision/resolver/CircumferenceResolver.d.ts

@@ -0,0 +1,7 @@
+import { Circumference } from "../shape/Circumference";
+import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
+export declare class CircumferenceResolver implements CollisionResolver {
+    private distance;
+    private direction;
+    resolve(shapeA: Circumference, shapeB: Circumference): CollisionResolution;
+}

package/lib/physics/collision/resolver/CollisionResolution.d.ts

@@ -0,0 +1,6 @@
+import { Vector2 } from "../../../math/Vector2";
+export interface CollisionResolution {
+    penetration: number;
+    direction: Vector2;
+    displacementDirection: Vector2;
+}

package/lib/physics/collision/resolver/CollisionResolver.d.ts

@@ -0,0 +1,10 @@
+import { Shape } from "../shape/Shape";
+import { Vector2 } from "../../../math/Vector2";
+export interface CollisionResolution {
+    penetration: number;
+    direction: Vector2;
+    displacementDirection: Vector2;
+}
+export interface CollisionResolver {
+    resolve(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
+}

package/lib/physics/collision/resolver/PolygonPolygonResolver.d.ts

@@ -0,0 +1,15 @@
+import { Line } from "../shape/Line";
+import { Polygon } from "../shape/Polygon";
+import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
+export declare class PolygonPolygonResolver implements CollisionResolver {
+    private axes;
+    private projA;
+    private projB;
+    private currentOverlap;
+    private minOverlap;
+    private displaceDirection;
+    private direction;
+    resolve(shapeA: Polygon | Line, shapeB: Polygon | Line): CollisionResolution | null;
+    private projectShapeOntoAxis;
+    private preventContainment;
+}

package/lib/physics/collision/resolver/RectangleRectangleResolver.d.ts

@@ -0,0 +1,11 @@
+import { Rectangle } from "../shape/Rectangle";
+import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
+export declare class RectangleRectangleResolver implements CollisionResolver {
+    private overlapX;
+    private overlapY;
+    private minOverlap;
+    private direction;
+    private displacementDirection;
+    resolve(shapeA: Rectangle, shapeB: Rectangle): CollisionResolution | null;
+    private preventContainment;
+}

package/lib/physics/collision/resolver/SatResolver.d.ts

@@ -1,14 +1,18 @@
 import { Shape } from "../shape/Shape";
-import { CollisionData } from "../CollisionData";
-import { ICollisionResolver } from "./ICollisionResolver";
-export declare class SatResolver implements ICollisionResolver {
+import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
+export declare class SatResolver implements CollisionResolver {
     private axes;
-    private proj1;
-    private proj2;
+    private projA;
+    private projB;
     private currentOverlap;
     private minOverlap;
     private displaceDirection;
-    getCollisionData(shape1: Shape, shape2: Shape): CollisionData | null;
+    private direction;
+    private distance;
+    private cache;
+    resolve(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
     private projectShapeOntoAxis;
     private preventContainment;
+    private setCircumferenceAxis;
+    private setCircumferenceVertices;
 }

package/lib/physics/collision/shape/Circumference.d.ts

@@ -0,0 +1,18 @@
+import { Rectangle } from "../../../math/Rectangle";
+import { Vector2 } from "../../../math/Vector2";
+import { Shape, ShapeType } from "./Shape";
+export declare class Circumference implements Shape {
+    readonly type: ShapeType;
+    readonly vertices: Vector2[];
+    readonly projectionAxes: Vector2[];
+    readonly boundingBox: Rectangle;
+    readonly angle: number;
+    readonly vertexModel: Vector2[];
+    radius: number;
+    protected _position: Vector2;
+    constructor(radius: number);
+    set position(value: Vector2);
+    get position(): Vector2;
+    update(): void;
+    protected updateBoundingBox(): void;
+}

package/lib/physics/collision/shape/Line.d.ts

@@ -0,0 +1,19 @@
+import { Rectangle } from "../../../math/Rectangle";
+import { Vector2 } from "../../../math/Vector2";
+import { Shape, ShapeType } from "./Shape";
+export declare class Line implements Shape {
+    vertexModel: [Vector2, Vector2];
+    readonly type: ShapeType;
+    readonly vertices: Vector2[];
+    readonly projectionAxes: Vector2[];
+    readonly boundingBox: Rectangle;
+    angle: number;
+    private _position;
+    constructor(vertexModel: [Vector2, Vector2]);
+    update(): void;
+    set position(value: Vector2);
+    get position(): Vector2;
+    protected updateVertices(): void;
+    protected updateBoundingBox(): void;
+    protected updateProjectionAxes(): void;
+}

package/lib/physics/collision/shape/Polygon.d.ts

@@ -0,0 +1,31 @@
+import { Rectangle } from "../../../math/Rectangle";
+import { Vector2 } from "../../../math/Vector2";
+import { Shape, ShapeType } from "./Shape";
+export declare class Polygon implements Shape {
+    protected _type: ShapeType;
+    protected _vertices: Vector2[];
+    protected _boundingBox: Rectangle;
+    protected _projectionAxes: Vector2[];
+    protected _position: Vector2;
+    protected _angle: number;
+    protected _vertexModel: Vector2[];
+    private boxMinX;
+    private boxMinY;
+    private boxMaxX;
+    private boxMaxY;
+    constructor(vertexModel: Vector2[]);
+    get type(): ShapeType;
+    get vertices(): Vector2[];
+    get boundingBox(): Rectangle;
+    get projectionAxes(): Vector2[];
+    set position(value: Vector2);
+    get position(): Vector2;
+    set angle(value: number);
+    get angle(): number;
+    get vertexModel(): Vector2[];
+    set vertexModel(value: Vector2[]);
+    update(): void;
+    protected updateVertices(): void;
+    protected updateBoundingBox(): void;
+    protected updateProjectionAxes(): void;
+}

package/lib/physics/collision/shape/Rectangle.d.ts

@@ -1,13 +1,9 @@
 import { Vector2 } from "../../../math/Vector2";
-import { Shape } from "./Shape";
-export declare class Rectangle extends Shape {
-    private cacheVector;
-    private axes;
-    constructor(position: Vector2, width: number, height: number, angle?: number);
-    update(): void;
-    private updateModel;
-    private updateDirection;
-    private updateAxes;
-    clone(): Rectangle;
-    getAxes(): Vector2[];
+import { Polygon } from "./Polygon";
+export declare class Rectangle extends Polygon {
+    width: number;
+    height: number;
+    constructor(width: number, height: number, position: Vector2);
+    updateSize(width: number, height: number): void;
+    protected updateProjectionAxes(): void;
 }

package/lib/physics/collision/shape/Shape.d.ts

@@ -1,28 +1,17 @@
+import { Rectangle } from "../../../math/Rectangle";
 import { Vector2 } from "../../../math/Vector2";
 export declare enum ShapeType {
-    Rectangle = 0
+    Polygon = 0,
+    Circumference = 1,
+    Line = 2
 }
-export declare abstract class Shape {
-    protected _type: ShapeType;
-    protected _model: Vector2[];
-    protected _vertices: Vector2[];
-    protected _position: Vector2;
-    protected _direction: Vector2;
-    protected _height: number;
-    protected _width: number;
-    protected _angle: number;
-    get type(): ShapeType;
-    get position(): Vector2;
-    set position(position: Vector2);
-    get angle(): number;
-    set angle(angle: number);
-    get width(): number;
-    set width(width: number);
-    get height(): number;
-    set height(height: number);
-    get direction(): Vector2;
-    get vertices(): Vector2[];
-    abstract update(): void;
-    abstract clone(): Shape;
-    abstract getAxes(): Vector2[];
+export interface Shape {
+    readonly vertices: Vector2[];
+    readonly type: ShapeType;
+    readonly boundingBox: Rectangle;
+    readonly projectionAxes: Vector2[];
+    vertexModel: Vector2[];
+    position: Vector2;
+    angle: number;
+    update(): void;
 }

package/lib/physics/collision-old/CollisionData.d.ts

@@ -0,0 +1,8 @@
+import { Vector2 } from "../../math/Vector2";
+export declare class CollisionData {
+    private _penetration;
+    private _displacementDirection;
+    constructor(penetration: number, displacementDirection: Vector2);
+    get penetration(): number;
+    get displacementDirection(): Vector2;
+}

package/lib/physics/collision-old/CollisionManager.d.ts

@@ -0,0 +1,30 @@
+import { Rectangle } from "../../math/Rectangle";
+import { ICollider } from "./collider/ICollider";
+import { CollisionData } from "./CollisionData";
+import { ICollisionResolver } from "./resolver/ICollisionResolver";
+export interface Collision {
+    localCollider: ICollider;
+    remoteCollider: ICollider;
+    collisionData: CollisionData;
+}
+export declare class CollisionManager {
+    private colliders;
+    private quadTree;
+    private bounds;
+    private fixedQuadTree;
+    private resolver;
+    private collisions;
+    private minBounds;
+    private maxBounds;
+    private newBounds;
+    constructor(resolver: ICollisionResolver, quadTreeBounds: Rectangle | null, quadMaxLevel: number, collidersPerQuad: number);
+    addCollider(collider: ICollider): void;
+    removeCollider(collider: ICollider): void;
+    getFrameCollisionsForCollider(collider: ICollider): Collision[];
+    refreshCollisionsForCollider(collider: ICollider): Collision[];
+    update(): void;
+    private updateNewBounds;
+    private updateCollisions;
+    private broadPhase;
+    private narrowPhase;
+}