angry-pixel 1.1.15 → 1.2.1

package/lib/component/Animator.d.ts

@@ -17,7 +17,6 @@ export interface AnimatorOptions extends InitOptions {
     spriteRenderer: SpriteRenderer;
 }
 export declare class Animator extends EngineComponent {
-    private timeManager;
     private spriteRenderer;
     private animations;
     private currentAnimation;
@@ -30,4 +29,5 @@ export declare class Animator extends EngineComponent {
     resume(): void;
     stopAnimation(): void;
     isPlayingAnimation(name?: string): boolean;
+    isPaused(): boolean;
 }

package/lib/component/Camera.d.ts

@@ -2,14 +2,13 @@ import { CameraComponent } from "../core/Component";
 import { Rectangle } from "angry-pixel-math";
 export declare class Camera extends CameraComponent {
     readonly allowMultiple: boolean;
-    private renderManager;
-    private canvas;
     readonly viewportRect: Rectangle;
     readonly worldSpaceRect: Rectangle;
     depth: number;
     layers: string[];
     private _zoom;
     private cameraData;
+    private canvas;
     set zoom(zoom: number);
     get zoom(): number;
     addLayer(layer: string): void;

package/lib/component/RigidBody.d.ts

@@ -9,7 +9,6 @@ export interface RigidBodyOptions extends InitOptions {
 }
 export declare class RigidBody extends EngineComponent {
     readonly allowMultiple: boolean;
-    private physicsManager;
     private rigidBody;
     get velocity(): Vector2;
     set velocity(velocity: Vector2);

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

@@ -1,6 +1,6 @@
 import { ColliderComponent, RenderComponent } from "../../core/Component";
 import { GameObject } from "../../core/GameObject";
-import { ICollisionResolution, ICollider, IPhysicsManager } from "angry-pixel-2d-physics";
+import { ICollisionResolution, ICollider } from "angry-pixel-2d-physics";
 export interface CollisionData {
     resolution: ICollisionResolution;
     collider: ICollider;
@@ -10,13 +10,12 @@ export interface CollisionData {
      */
     getGameObject: <T extends GameObject>() => T;
 }
-export interface Collider {
+export interface IColliderComponent {
     collidesWithLayer(layer: string): boolean;
     getCollisionWithLayer(layer: string): CollisionData | null;
     getCollisionsWithLayer(layer: string): CollisionData[];
 }
-export declare abstract class BaseCollider extends ColliderComponent implements Collider {
-    protected physicsManager: IPhysicsManager;
+export declare abstract class BaseCollider extends ColliderComponent implements IColliderComponent {
     protected renderer: RenderComponent;
     readonly colliders: ICollider[];
     layer: string;

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

@@ -30,7 +30,6 @@ export declare class PolygonCollider extends BaseCollider {
     protected updateColliders(): void;
 }
 export declare class PolygonColliderRenderer extends RenderComponent {
-    private renderManager;
     private renderData;
     private collider;
     protected init({ collider }: {

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

@@ -10,7 +10,6 @@ export interface MaskRendererOptions {
     layer?: string;
 }
 export declare class MaskRenderer extends RenderComponent {
-    private renderManager;
     width: number;
     height: number;
     color: string;

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

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

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

@@ -37,7 +37,6 @@ export declare class TextRenderer extends RenderComponent {
     orientation: TextOrientation;
     bitmapMargin: Vector2;
     bitmapSpacing: Vector2;
-    private renderManager;
     private renderData;
     private lastFrameText;
     protected init(config: TextRendererOptions): void;

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

@@ -11,7 +11,6 @@ export interface TiledTilemapRendererOptions {
     smooth?: boolean;
 }
 export declare class TiledTilemapRenderer extends RenderComponent implements ITilemapRenderer {
-    private renderManager;
     tiles: number[];
     tileWidth: number;
     tileHeight: number;

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

@@ -33,7 +33,6 @@ export interface ITilemapRenderer {
     realHeight: number;
 }
 export declare class TilemapRenderer extends RenderComponent implements ITilemapRenderer {
-    private renderManager;
     tiles: number[];
     width: number;
     height: number;

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

@@ -19,7 +19,6 @@ export interface VideoRendererOptions {
     loop?: boolean;
 }
 export declare class VideoRenderer extends RenderComponent {
-    private readonly renderManager;
     video: HTMLVideoElement;
     width: number;
     height: number;

package/lib/core/GameActor.d.ts

@@ -1,14 +1,30 @@
+import { IPhysicsManager } from "angry-pixel-2d-physics";
+import { IInputManager } from "../input/InputManager";
 import { Container } from "../utils/Container";
+import { GameConfig } from "./GameConfig";
 import { GameObject, GameObjectClass } from "./GameObject";
-import { GameObjectManager } from "./managers/GameObjectManager";
+import { IAssetManager } from "./managers/AssetManager";
+import { IDomManager } from "./managers/DomManager";
+import { IGameObjectManager } from "./managers/GameObjectManager";
 import { FrameEvent } from "./managers/IterationManager";
+import { ISceneManager } from "./managers/SceneManager";
+import { ITimeManager } from "./managers/TimeManager";
+import { IRenderManager } from "angry-pixel-2d-renderer";
 export interface InitOptions {
     [key: string]: any;
 }
 export declare abstract class GameActor {
-    protected readonly gameObjectManager: GameObjectManager;
     protected readonly updateEvent: FrameEvent;
     protected readonly container: Container;
+    protected readonly assetManager: IAssetManager;
+    protected readonly domManager: IDomManager;
+    protected readonly inputManager: IInputManager;
+    protected readonly gameObjectManager: IGameObjectManager;
+    protected readonly physicsManager: IPhysicsManager;
+    protected readonly renderManager: IRenderManager;
+    protected readonly sceneManager: ISceneManager;
+    protected readonly timeManager: ITimeManager;
+    protected readonly gameConfig: GameConfig;
     private started;
     constructor(container: Container);
     dispatch(event: FrameEvent, options?: InitOptions): void;

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

@@ -1,4 +1,7 @@
-export declare class DomManager {
+export interface IDomManager {
+    canvas: HTMLCanvasElement;
+}
+export declare class DomManager implements IDomManager {
     private gameWidth;
     private gameHeight;
     private containerNode;

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

@@ -1,7 +1,22 @@
 import { GameObject, GameObjectClass } from "../GameObject";
 import { InitOptions } from "../GameActor";
 import { Container } from "../../utils/Container";
-export declare class GameObjectManager {
+export interface IGameObjectManager {
+    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;
+    findGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
+    findGameObject<T extends GameObject>(name: string): T;
+    findGameObject<T extends GameObject>(filter: GameObjectClass<T> | string): T;
+    findGameObjectsByParent<T extends GameObject>(parent: GameObject): T[];
+    findGameObjectByParent<T extends GameObject>(parent: GameObject, gameObjectClass: GameObjectClass<T>): T;
+    findGameObjectByParent<T extends GameObject>(parent: GameObject, name: string): T;
+    findGameObjectByParent<T extends GameObject>(parent: GameObject, filter: GameObjectClass<T> | string): T;
+    findGameObjectsByTag<T extends GameObject>(tag: string): T[];
+    destroyAllGameObjects(ignoreKeep?: boolean): void;
+    destroyGameObject(gameObject: GameObject): void;
+}
+export declare class GameObjectManager implements IGameObjectManager {
     private readonly container;
     private gameObjects;
     constructor(container: Container);

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

@@ -1,6 +1,6 @@
-import { GameObjectManager } from "./GameObjectManager";
-import { SceneManager } from "./SceneManager";
-import { TimeManager } from "./TimeManager";
+import { IGameObjectManager } from "./GameObjectManager";
+import { ISceneManager } from "./SceneManager";
+import { ITimeManager } from "./TimeManager";
 import { IIterationManager } from "./IterationManager";
 import { IPhysicsManager } from "angry-pixel-2d-physics";
 export declare class HeadlessIterationManager implements IIterationManager {
@@ -14,7 +14,7 @@ export declare class HeadlessIterationManager implements IIterationManager {
     private components;
     private gameInterval;
     private physicsInterval;
-    constructor(timeManager: TimeManager, physicsManager: IPhysicsManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    constructor(timeManager: ITimeManager, physicsManager: IPhysicsManager, gameObjectManager: IGameObjectManager, sceneManager: ISceneManager);
     start(): void;
     pause(): void;
     resume(): void;

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

@@ -1,8 +1,8 @@
-import { GameObjectManager } from "./GameObjectManager";
-import { SceneManager } from "./SceneManager";
-import { InputManager } from "../../input/InputManager";
+import { IGameObjectManager } from "./GameObjectManager";
+import { ISceneManager } from "./SceneManager";
+import { IInputManager } from "../../input/InputManager";
 import { IRenderManager } from "angry-pixel-2d-renderer";
-import { TimeManager } from "./TimeManager";
+import { ITimeManager } from "./TimeManager";
 import { IPhysicsManager } from "angry-pixel-2d-physics";
 export declare enum FrameEvent {
     Init = 0,
@@ -40,7 +40,7 @@ export declare class IterationManager implements IIterationManager {
     private gameObjects;
     private components;
     private physicsIntervalId;
-    constructor(timeManager: TimeManager, physicsManager: IPhysicsManager, renderManager: IRenderManager, inputManager: InputManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager, canvasColor: string);
+    constructor(timeManager: ITimeManager, physicsManager: IPhysicsManager, renderManager: IRenderManager, inputManager: IInputManager, gameObjectManager: IGameObjectManager, sceneManager: ISceneManager, canvasColor: string);
     start(): void;
     pause(): void;
     resume(): void;

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

@@ -2,7 +2,16 @@ import { Scene, SceneClass } from "../Scene";
 import { IRenderManager } from "angry-pixel-2d-renderer";
 import { InitOptions } from "../GameActor";
 import { Container } from "../../utils/Container";
-export declare class SceneManager {
+export interface ISceneManager {
+    getCurrentScene<T extends Scene>(): T;
+    addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
+    loadOpeningScene(): void;
+    loadScene(name: string): void;
+    update(): void;
+    unloadCurrentScene(): void;
+    stopGame(): void;
+}
+export declare class SceneManager implements ISceneManager {
     private readonly container;
     private renderManager?;
     private scenes;

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

@@ -1,24 +1,38 @@
 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 {
+export interface ITimeManager {
+    minGameDeltatime: number;
+    minPhysicsDeltaTime: number;
+    gameFramerate: number;
+    physicsFramerate: number;
+    timeScale: number;
+    unscaledDeltaTime: number;
+    unscaledPhysicsDeltaTime: number;
+    deltaTime: number;
+    physicsDeltaTime: number;
+    browserDeltaTime: number;
+    updateForGame(time: number): void;
+    updateForBrowser(time: number): void;
+    updateForPhysics(time: number): void;
+}
+export declare class TimeManager implements ITimeManager {
     readonly minGameDeltatime: number;
     readonly minPhysicsDeltaTime: number;
     readonly gameFramerate: number;
     readonly physicsFramerate: number;
     timeScale: number;
     browserDeltaTime: number;
-    gameDeltaTime: number;
-    unscaledGameDeltaTime: number;
+    unscaledDeltaTime: number;
     unscaledPhysicsDeltaTime: number;
     private readonly maxDeltaTime;
     private thenForGame;
     private thenForPhysics;
     private thenForBrowser;
+    get deltaTime(): number;
+    get physicsDeltaTime(): number;
     constructor(physicsFramerate: number);
     updateForGame(time: number): void;
     updateForBrowser(time: number): void;
     updateForPhysics(time: number): void;
-    get deltaTime(): number;
-    get physicsDeltaTime(): number;
 }