angry-pixel 1.1.5 → 1.1.7

package/lib/component/RigidBody.d.ts

@@ -1,23 +1,23 @@
 import { EngineComponent } from "../core/Component";
 import { Vector2 } from "angry-pixel-math";
-import { RigidBodyType } from "../physics/rigodBody/RigidBodyManager";
 import { InitOptions } from "../core/GameActor";
-export { RigidBodyType } from "../physics/rigodBody/RigidBodyManager";
+import { RigidBodyType } from "angry-pixel-2d-physics";
+export { RigidBodyType } from "angry-pixel-2d-physics";
 export interface RigidBodyOptions extends InitOptions {
     rigidBodyType: RigidBodyType;
     gravity?: number;
 }
 export declare class RigidBody extends EngineComponent {
     readonly allowMultiple: boolean;
-    private rigidBodyManager;
-    private data;
-    set velocity(velocity: Vector2);
+    private physicsManager;
+    private rigidBody;
     get velocity(): Vector2;
-    set gravity(gravity: number);
+    set velocity(velocity: Vector2);
     get gravity(): number;
-    get rigidBodyType(): RigidBodyType;
+    set gravity(gravity: number);
     protected init({ rigidBodyType, gravity }: RigidBodyOptions): void;
-    protected start(): void;
     protected update(): void;
-    private getColliders;
+    private getColliderIds;
+    protected onActiveChange(): void;
+    protected onDestroy(): void;
 }

package/lib/component/Sprite.d.ts

@@ -10,8 +10,8 @@ export interface SpriteConfig {
 export declare class Sprite {
     readonly image: HTMLImageElement;
     readonly slice: Slice;
-    readonly scale: Vector2;
     readonly smooth: boolean;
+    scale?: Vector2;
     private _width;
     private _height;
     private _loaded;

package/lib/component/collider/BallCollider.d.ts

@@ -18,10 +18,9 @@ export declare class BallCollider extends Collider {
     private realPosition;
     private innerPosition;
     protected init(config: BallColliderOptions): void;
-    protected start(): void;
     protected update(): void;
     private updateRealSize;
     protected updatePosition(): void;
     private translate;
-    private updateShape;
+    private updateCollider;
 }

package/lib/component/collider/BoxCollider.d.ts

@@ -26,10 +26,9 @@ export declare class BoxCollider extends Collider {
     private applyRotation;
     private innerPosition;
     protected init(config: BoxColliderOptions): void;
-    protected start(): void;
     protected update(): void;
     private updateRealSize;
     protected updatePosition(): void;
     private translate;
-    private updateShape;
+    private updateCollider;
 }

package/lib/component/collider/Collider.d.ts

@@ -1,11 +1,9 @@
 import { ColliderComponent, RenderComponent } from "../../core/Component";
-import { CollisionManager } from "../../physics/collision/CollisionManager";
-import { ColliderData } from "../../physics/collision/ColliderData";
 import { GameObject } from "../../core/GameObject";
-import { CollisionResolution } from "../../physics/collision/resolver/CollisionResolver";
+import { ICollisionResolution, ICollider, IPhysicsManager } from "angry-pixel-2d-physics";
 export interface CollisionData {
-    resolution: CollisionResolution;
-    collider: ColliderData;
+    resolution: ICollisionResolution;
+    collider: ICollider;
     gameObject: GameObject;
     /**
      * @return The GameObject to which this component belongs
@@ -13,15 +11,15 @@ export interface CollisionData {
     getGameObject: <T extends GameObject>() => T;
 }
 export declare abstract class Collider extends ColliderComponent {
-    protected collisionManager: CollisionManager;
+    protected physicsManager: IPhysicsManager;
     protected renderer: RenderComponent;
-    readonly colliders: ColliderData[];
+    readonly colliders: ICollider[];
     layer: string;
     physics: boolean;
-    protected update(): void;
     collidesWithLayer(layer: string): boolean;
     getCollisionWithLayer(layer: string): CollisionData | null;
     getCollisionsWithLayer(layer: string): CollisionData[];
     private createCollisionData;
     protected onActiveChange(): void;
+    protected onDestroy(): void;
 }

package/lib/component/collider/EdgeCollider.d.ts

@@ -1,5 +1,4 @@
 import { Collider } from "./Collider";
-import { GameObject } from "../../core/GameObject";
 import { InitOptions } from "../../core/GameActor";
 import { Vector2, Rotation } from "angry-pixel-math";
 export interface EdgeColliderOptions extends InitOptions {
@@ -22,9 +21,7 @@ export declare class EdgeCollider extends Collider {
     private scaledPosition;
     private finalRotation;
     private innerPosition;
-    constructor(gameObject: GameObject, name?: string);
     protected init(config: EdgeColliderOptions): void;
-    protected start(): void;
     protected update(): void;
     private updateSize;
     protected updatePosition(): void;

package/lib/component/collider/PolygonCollider.d.ts

@@ -1,9 +1,8 @@
 import { Collider } from "./Collider";
-import { ColliderData } from "../../physics/collision/ColliderData";
 import { RenderComponent } from "../../core/Component";
 import { InitOptions } from "../../core/GameActor";
-import { GameObject } from "../../core/GameObject";
 import { Vector2, Rotation } from "angry-pixel-math";
+import { ICollider } from "angry-pixel-2d-physics";
 export interface PolygonColliderOptions extends InitOptions {
     vertexModel: Vector2[];
     offsetX?: number;
@@ -24,21 +23,19 @@ export declare class PolygonCollider extends Collider {
     private scaledPosition;
     private finalRotation;
     private innerPosition;
-    constructor(gameObject: GameObject, name?: string);
     protected init(config: PolygonColliderOptions): void;
-    protected start(): void;
     protected update(): void;
     private updateSize;
     protected updatePosition(): void;
     private translate;
-    private updateShape;
+    private updateCollider;
 }
 export declare class PolygonColliderRenderer extends RenderComponent {
     private renderManager;
     private renderData;
     private collider;
     protected init({ collider }: {
-        collider: ColliderData;
+        collider: ICollider;
     }): void;
     protected update(): void;
 }

package/lib/component/collider/TilemapCollider.d.ts

@@ -17,7 +17,6 @@ export declare class TilemapCollider extends Collider {
     private scaledTileHeight;
     private position;
     protected init(config: TilemapColliderOptions): void;
-    protected start(): void;
     private useBoxColliders;
     private useLineColliders;
     private hasTile;

package/lib/component/rendering/SpriteRenderer.d.ts

@@ -15,7 +15,8 @@ export interface SpriteRendererOptions {
     layer?: string;
 }
 export declare class SpriteRenderer extends RenderComponent {
-    private renderManager;
+    private readonly renderManager;
+    private readonly spriteDefaultScale;
     sprite: Sprite;
     offset: Vector2;
     flipHorizontal: boolean;

package/lib/core/Component.d.ts

@@ -2,15 +2,15 @@ import { GameObject } from "./GameObject";
 import { Scene } from "./Scene";
 import { FrameEvent } from "./managers/IterationManager";
 import { GameActor } from "./GameActor";
-export declare type ComponentClass<T extends Component = Component> = new (gameObject: GameObject, name?: string) => T;
+import { Container } from "../utils/Container";
+export type ComponentClass<T extends Component = Component> = new (container: Container, gameObject: GameObject, name?: string) => T;
 export declare abstract class Component extends GameActor {
-    private readonly sceneManager;
     readonly id: string;
     readonly name: string;
     readonly gameObject: GameObject;
     readonly allowMultiple: boolean;
     private _active;
-    constructor(gameObject: GameObject, name?: string);
+    constructor(container: Container, gameObject: GameObject, name?: string);
     get active(): boolean;
     set active(active: boolean);
     /**

package/lib/core/Game.d.ts

@@ -1,31 +1,8 @@
-import { SceneClass } from "../core/managers/SceneManager";
-import { Container } from "../utils/Container";
-import { Rectangle, Vector2 } from "angry-pixel-math";
-import { CollisionMatrix } from "../physics/collision/CollisionManager";
 import { InitOptions } from "./GameActor";
-export declare const container: Container;
-export interface GameConfig {
-    containerNode?: HTMLElement | null;
-    gameWidth?: number;
-    gameHeight?: number;
-    debugEnabled?: boolean;
-    canvasColor?: string;
-    physicsFramerate?: number;
-    spriteDefaultScale?: Vector2 | null;
-    headless?: boolean;
-    collisions?: {
-        method?: CollisionMethodConfig;
-        quadTreeBounds?: Rectangle | null;
-        quadMaxLevel?: number;
-        collidersPerQuad?: number;
-        collisionMatrix?: CollisionMatrix;
-    };
-}
-export declare enum CollisionMethodConfig {
-    AABB = "aabb",
-    SAT = "sat"
-}
+import { GameConfig } from "./GameConfig";
+import { SceneClass } from "./Scene";
 export declare class Game {
+    private readonly container;
     private sceneManager;
     private iterationManager;
     private _config;

package/lib/core/GameActor.d.ts

@@ -1,3 +1,4 @@
+import { Container } from "../utils/Container";
 import { GameObject, GameObjectClass } from "./GameObject";
 import { GameObjectManager } from "./managers/GameObjectManager";
 import { FrameEvent } from "./managers/IterationManager";
@@ -7,7 +8,9 @@ export interface InitOptions {
 export declare abstract class GameActor {
     protected readonly gameObjectManager: GameObjectManager;
     protected readonly updateEvent: FrameEvent;
+    protected readonly container: Container;
     private started;
+    constructor(container: Container);
     dispatch(event: FrameEvent, options?: InitOptions): void;
     /**
      * This method is called after instantiation (recommended for the creation of game objects).

package/lib/core/GameConfig.d.ts

@@ -0,0 +1,18 @@
+import { BroadPhaseMethods, CollisionMatrix, CollisionMethods } from "angry-pixel-2d-physics";
+import { Rectangle, Vector2 } from "angry-pixel-math";
+export interface GameConfig {
+    containerNode?: HTMLElement | null;
+    gameWidth?: number;
+    gameHeight?: number;
+    debugEnabled?: boolean;
+    canvasColor?: string;
+    physicsFramerate?: number;
+    spriteDefaultScale?: Vector2 | null;
+    headless?: boolean;
+    collisions?: {
+        collisionMethod?: CollisionMethods;
+        collisionArea?: Rectangle;
+        collisionMatrix?: CollisionMatrix;
+        collisionBroadPhaseMethod?: BroadPhaseMethods;
+    };
+}

package/lib/core/GameObject.d.ts

@@ -3,8 +3,9 @@ import { Transform } from "../component/Transform";
 import { RigidBody } from "../component/RigidBody";
 import { Scene } from "./Scene";
 import { GameActor, InitOptions } from "./GameActor";
+import { Container } from "../utils/Container";
 export declare const LAYER_DEFAULT = "Default";
-export declare type GameObjectClass<T extends GameObject = GameObject> = new (name?: string, parent?: GameObject) => T;
+export type GameObjectClass<T extends GameObject = GameObject> = new (container: Container, name?: string, parent?: GameObject) => T;
 export declare class GameObject extends GameActor {
     readonly id: string;
     readonly name: string;
@@ -14,11 +15,10 @@ export declare class GameObject extends GameActor {
     keep: boolean;
     private _parent;
     private _active;
-    private sceneManager;
     private components;
     private activeComponentsCache;
     private activeChildrenCache;
-    constructor(name?: string, parent?: GameObject);
+    constructor(container: Container, name?: string, parent?: GameObject);
     get active(): boolean;
     set active(active: boolean);
     get parent(): GameObject | null;

package/lib/core/Scene.d.ts

@@ -1,10 +1,12 @@
 import { GameCamera } from "../gameObject/GameCamera";
+import { Container } from "../utils/Container";
 import { Game } from "./Game";
 import { GameActor } from "./GameActor";
+export type SceneClass = new (container: Container, name: string, game: Game) => Scene;
 export declare class Scene extends GameActor {
     readonly name: string;
     readonly game: Game;
-    constructor(name: string, game: Game);
+    constructor(container: Container, name: string, game: Game);
     get gameCamera(): GameCamera;
     protected _destroy(): void;
 }

package/lib/core/ioc/Config.d.ts

@@ -1,3 +1,3 @@
-import { GameConfig } from "../Game";
 import { Container } from "../../utils/Container";
+import { GameConfig } from "../GameConfig";
 export declare const loadDependencies: (container: Container, gameConfig: GameConfig) => void;

package/lib/core/managers/GameObjectManager.d.ts

@@ -1,7 +1,10 @@
 import { GameObject, GameObjectClass } from "../GameObject";
 import { InitOptions } from "../GameActor";
+import { Container } from "../../utils/Container";
 export declare class GameObjectManager {
+    private readonly container;
     private gameObjects;
+    constructor(container: Container);
     addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, parent?: GameObject, name?: string): T;
     findGameObjects<T extends GameObject>(gameObjectClass?: GameObjectClass<T>): T[];
     findGameObjectById<T extends GameObject>(id: string): T;

package/lib/core/managers/HeadlessIterationManager.d.ts

@@ -1,12 +1,10 @@
 import { GameObjectManager } from "./GameObjectManager";
 import { SceneManager } from "./SceneManager";
-import { CollisionManager } from "../../physics/collision/CollisionManager";
-import { RigidBodyManager } from "../../physics/rigodBody/RigidBodyManager";
 import { TimeManager } from "./TimeManager";
 import { IIterationManager } from "./IterationManager";
+import { IPhysicsManager } from "angry-pixel-2d-physics";
 export declare class HeadlessIterationManager implements IIterationManager {
     private readonly timeManager;
-    private readonly collisionManager;
     private readonly physicsManager;
     private readonly gameObjectManager;
     private readonly sceneManager;
@@ -14,7 +12,9 @@ export declare class HeadlessIterationManager implements IIterationManager {
     private currentScene;
     private gameObjects;
     private components;
-    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    private gameInterval;
+    private physicsInterval;
+    constructor(timeManager: TimeManager, physicsManager: IPhysicsManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
     start(): void;
     pause(): void;
     resume(): void;

package/lib/core/managers/IterationManager.d.ts

@@ -1,10 +1,9 @@
 import { GameObjectManager } from "./GameObjectManager";
 import { SceneManager } from "./SceneManager";
 import { InputManager } from "../../input/InputManager";
-import { CollisionManager } from "../../physics/collision/CollisionManager";
-import { RigidBodyManager } from "../../physics/rigodBody/RigidBodyManager";
 import { IRenderManager } from "angry-pixel-2d-renderer";
 import { TimeManager } from "./TimeManager";
+import { IPhysicsManager } from "angry-pixel-2d-physics";
 export declare enum FrameEvent {
     Init = 0,
     Start = 1,
@@ -25,9 +24,9 @@ export interface IIterationManager {
     resume(): void;
     stop(): void;
 }
+export declare const now: () => number;
 export declare class IterationManager implements IIterationManager {
     private readonly timeManager;
-    private readonly collisionManager;
     private readonly physicsManager;
     private readonly renderManager;
     private readonly inputManager;
@@ -39,7 +38,8 @@ export declare class IterationManager implements IIterationManager {
     private currentScene;
     private gameObjects;
     private components;
-    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, renderManager: IRenderManager, inputManager: InputManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager, canvasColor: string);
+    private physicsIntervalId;
+    constructor(timeManager: TimeManager, physicsManager: IPhysicsManager, renderManager: IRenderManager, inputManager: InputManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager, canvasColor: string);
     start(): void;
     pause(): void;
     resume(): void;

package/lib/core/managers/SceneManager.d.ts

@@ -1,17 +1,16 @@
-import { Game } from "../Game";
-import { Scene } from "../Scene";
+import { Scene, SceneClass } from "../Scene";
 import { IRenderManager } from "angry-pixel-2d-renderer";
 import { InitOptions } from "../GameActor";
-export declare type SceneClass = new (name: string, game: Game) => Scene;
+import { Container } from "../../utils/Container";
 export declare class SceneManager {
-    private game;
+    private readonly container;
     private renderManager?;
     private scenes;
     private currentScene;
     private openingSceneName;
     private sceneToLoad;
     currentSceneName: string;
-    constructor(game: Game, renderManager?: IRenderManager);
+    constructor(container: Container, renderManager?: IRenderManager);
     getCurrentScene<T extends Scene>(): T;
     addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
     loadOpeningScene(): void;

package/lib/core/managers/TimeManager.d.ts

@@ -1,4 +1,4 @@
-export declare const MIN_GAME_FRAMERATE = 15;
+export declare const MIN_GAME_FRAMERATE = 30;
 export declare const DEFAULT_GAME_FRAMERATE = 60;
 export declare const DEFAULT_PHYSICS_FRAMERATE = 180;
 export declare class TimeManager {