angry-pixel 1.0.9 → 1.1.2

package/lib/core/Scene.d.ts

@@ -1,67 +1,10 @@
 import { GameCamera } from "../gameObject/GameCamera";
 import { Game } from "./Game";
-import { GameObject } from "./GameObject";
-import { GameObjectFactory } from "../core/managers/GameObjectManager";
-export declare const GAME_CAMERA_ID = "GameCamera";
-export declare class Scene {
-    private readonly gameObjectManager;
-    game: Game;
-    name: string;
-    private started;
-    constructor();
-    private gameLoopEventHandler;
+import { GameActor } from "./GameActor";
+export declare class Scene extends GameActor {
+    readonly name: string;
+    readonly game: Game;
+    constructor(name: string, game: Game);
     get gameCamera(): GameCamera;
-    /**
-     * This method is only ever called once.
-     * Recommended for GameObject cration.
-     */
-    init(): void;
-    /**
-     * This method is only ever called once.
-     */
-    protected start(): void;
-    /**
-     * This method is called on every frame.
-     */
-    protected update(): void;
-    /**
-     * @param gameObjectFactory The factory function for the game object
-     * @param name The name of the game object, this must not be used by another game object
-     * @returns The added game object
-     */
-    protected addGameObject<T extends GameObject>(gameObjectFactory: GameObjectFactory, name: string): T;
-    /**
-     * @returns The all the loaded game objects
-     */
-    protected getGameObjects(): GameObject[];
-    /**
-     * @param name The name of the game object to find
-     * @returns The found game object
-     */
-    protected findGameObjectByName<T extends GameObject>(name: string): T;
-    /**
-     * @param tag The tag of the game objects to find
-     * @returns The found game objects
-     */
-    protected findGameObjectsByTag(tag: string): GameObject[];
-    /**
-     * @param tag The tag of the game object to find
-     * @returns The found game object
-     */
-    protected findGameObjectByTag<T extends GameObject>(tag: string): T;
-    /**
-     * Destroy one game objects by its name
-     * @param name The name of the game object
-     */
-    protected destroyGameObjectByName(name: string): void;
-    /**
-     * Destroy the game objects
-     *
-     * @param gameObject The game object to destory
-     */
-    protected destroyGameObject(gameObject: GameObject): void;
-    /**
-     * @description NOTE: do not use this method. Use SceneManager.unloadCurrentScene instead.
-     */
-    destroy(): void;
+    protected _destroy(): void;
 }

package/lib/core/facades/GameObjectManagerFacade.d.ts

@@ -1,54 +1,64 @@
-import { GameObjectManager, GameObjectFactory } from "../managers/GameObjectManager";
-import { GameObject } from "../GameObject";
+import { GameObjectManager } from "../managers/GameObjectManager";
+import { GameObject, GameObjectClass } from "../GameObject";
+import { InitOptions } from "../GameActor";
 export declare class GameObjectManagerFacade {
     private static manager;
     static initialize(manager: GameObjectManager): void;
     /**
-     * @param gameObjectFactory The factory function for the game object
-     * @param name The name of the game object, this must not be used by another game object
-     * @param parent (optional) The parent game object
+     * Adds a new game object to the scene.
+     * @param gameObjectClass The class of the game object
+     * @param options [optional] This options will be passed to the init method
+     * @param parent [optional] The parent game object
+     * @param name [optional] The name of the game object
      * @returns the added game object
      */
-    static addGameObject<T extends GameObject>(gameObjectFactory: GameObjectFactory, name: string, parent?: GameObject): T;
+    static addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, parent?: GameObject, name?: string): T;
     /**
-     * @returns All the added game objects
+     * Returns all the game objects in the scene.
+     * @returns The found game objects
+     */
+    static findGameObjects(): GameObject[];
+    /**
+     * Returns the first game object found for the given class, or undefined otherwise.
+     * @param gameObjectClass The game object class to find
+     * @returns The found game object
      */
-    static getGameObjects(): GameObject[];
+    static findGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
     /**
+     * Returns the first game object found for the given name, or undefined otherwise.
      * @param name The name of the game object to find
      * @returns The found game object
      */
-    static findGameObjectByName<T extends GameObject>(name: string): T;
+    static findGameObject<T extends GameObject>(name: string): T;
     /**
+     * Returns a collection of game objects found for the given parent
      * @param parent The parent game object
      * @returns The found game objects
      */
-    static findGameObjectsByParent(parent: GameObject): GameObject[];
+    static findGameObjectsByParent<T extends GameObject>(parent: GameObject): T[];
     /**
-     *
+     * Returns the first child found for the given parent and class, or undefined otherwise.
      * @param parent The parent game object
-     * @param name The name of the game object to find
-     * @returns The found game objects
+     * @param gameObjectClass The class of the child game object to find
+     * @returns The found child game object
      */
-    static findGameObjectByParentAndName<T extends GameObject>(parent: GameObject, name: string): T;
+    static findGameObjectByParent<T extends GameObject>(parent: GameObject, gameObjectClass: GameObjectClass<T>): T;
     /**
-     * @param tag The tag of the game objects to find
-     * @returns The found game objects
+     * Returns the first child found for the given parent and name, or undefined otherwise.
+     * @param parent The parent game object
+     * @param name The name of the child game object to find
+     * @returns The found child game object
      */
-    static findGameObjectsByTag(tag: string): GameObject[];
+    static findGameObjectByParent<T extends GameObject>(parent: GameObject, name: string): T;
     /**
-     * @param tag The tag of the game object to find
-     * @returns The found game object
+     * Returns a collection of game objects found for the given tag
+     * @param tag The tag of the game objects to find
+     * @returns The found game objects
      */
-    static findGameObjectByTag<T extends GameObject>(tag: string): T;
+    static findGameObjectsByTag<T extends GameObject>(tag: string): T[];
     /**
      * Destroy the game objects
      * @param gameObject The game object to destory
      */
     static destroyGameObject(gameObject: GameObject): void;
-    /**
-     * Destroy one game objects by its name
-     * @param name The name of the game object
-     */
-    static destroyGameObjectByName(name: string): void;
 }

package/lib/core/facades/TimeManagerFacade.d.ts

@@ -7,4 +7,5 @@ export declare class TimeManagerFacade {
     static setTimeScale(scale: number): void;
     static get unscaledDeltaTime(): number;
     static get physicsDeltaTime(): number;
+    static get browserDeltaTime(): number;
 }

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

@@ -1,17 +1,18 @@
-import { GameObject } from "../GameObject";
-export declare type GameObjectFactory = () => GameObject;
+import { GameObject, GameObjectClass } from "../GameObject";
+import { InitOptions } from "../GameActor";
 export declare class GameObjectManager {
     private gameObjects;
-    addGameObject<T extends GameObject>(gameObjectFactory: GameObjectFactory, name: string, parent?: GameObject): T;
-    getGameObjects(): GameObject[];
-    findGameObjectById(id: string): GameObject;
-    findGameObjectByName(name: string): GameObject;
-    findGameObjectsByParent(parent: GameObject): GameObject[];
-    findGameObjectByParentAndName(parent: GameObject, name: string): GameObject;
-    findGameObjectsByTag(tag: string): GameObject[];
-    findGameObjectByTag(tag: string): GameObject;
+    addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, parent?: GameObject, name?: string): T;
+    findGameObjects(): GameObject[];
+    findGameObjectById<T extends GameObject>(id: string): T;
+    findGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
+    findGameObject<T extends GameObject>(name: 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;
+    findGameObjectsByTag<T extends GameObject>(tag: string): T[];
     destroyAllGameObjects(): void;
     destroyGameObject(gameObject: GameObject): void;
-    private _destroyGameObject;
+    private destroy;
     private destroyChildren;
 }

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

@@ -0,0 +1,42 @@
+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 { RenderManager } from "../../rendering/RenderManager";
+import { TimeManager } from "./TimeManager";
+export declare enum FrameEvent {
+    Init = 0,
+    Start = 1,
+    Update = 2,
+    UpdateEngine = 3,
+    UpdateCollider = 4,
+    UpdatePhysics = 5,
+    UpdateTransform = 6,
+    UpdatePreRender = 7,
+    UpdateCamera = 8,
+    UpdateRender = 9,
+    Destroy = 10
+}
+export declare class IterationManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private readonly physicsManager;
+    private readonly renderManager;
+    private readonly inputManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
+    private gameLoopAccumulator;
+    private physicsLoopAccumulator;
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, renderManager: RenderManager, inputManager: InputManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    update(time: number): void;
+    private load;
+    private mainIteration;
+    private physicsIteration;
+    private preRenderIteration;
+    private renderIteration;
+    private dispatchFrameEvent;
+}

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

@@ -1,29 +1,47 @@
+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 { RenderManager } from "../../rendering/RenderManager";
 import { TimeManager } from "./TimeManager";
-export declare const EVENT_START: string;
-export declare const EVENT_UPDATE: string;
-export declare const EVENT_UPDATE_ENGINE: string;
-export declare const EVENT_UPDATE_COLLIDER: string;
-export declare const EVENT_UPDATE_PHYSICS: string;
-export declare const EVENT_UPDATE_TRANSFORM: string;
-export declare const EVENT_UPDATE_PRERENDER: string;
-export declare const EVENT_UPDATE_CAMERA: string;
-export declare const EVENT_UPDATE_RENDER: string;
+export declare enum FrameEvent {
+    Init = 0,
+    Start = 1,
+    Update = 2,
+    UpdateEngine = 3,
+    UpdateCollider = 4,
+    UpdatePhysics = 5,
+    UpdateTransform = 6,
+    UpdatePreRender = 7,
+    UpdateCamera = 8,
+    UpdateRender = 9,
+    Destroy = 10
+}
 export declare class IterationManager {
     private readonly timeManager;
     private readonly collisionManager;
+    private readonly physicsManager;
     private readonly renderManager;
     private readonly inputManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
+    running: boolean;
     private gameLoopAccumulator;
-    private physicsLoopAccumulator;
-    private deltaAux;
-    constructor(timeManager: TimeManager, collisionManager: CollisionManager, renderManager: RenderManager, inputManager: InputManager);
-    update(time: number): void;
-    private mainIteration;
-    private physicsIteration;
-    private preRenderIteration;
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, renderManager: RenderManager, inputManager: InputManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private startLoop;
+    private requestAnimationLoop;
+    private gameLogicIteration;
     private renderIteration;
+    private physicsIteration;
+    private asyncPhysicsLoop;
+    private load;
     private dispatchFrameEvent;
 }

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

@@ -0,0 +1,42 @@
+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 { RenderManager } from "../../rendering/RenderManager";
+import { TimeManager } from "./TimeManager";
+export declare enum FrameEvent {
+    Init = 0,
+    Start = 1,
+    Update = 2,
+    UpdateEngine = 3,
+    UpdateCollider = 4,
+    UpdatePhysics = 5,
+    UpdateTransform = 6,
+    UpdatePreRender = 7,
+    UpdateCamera = 8,
+    UpdateRender = 9,
+    Destroy = 10
+}
+export declare class IterationManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private readonly physicsManager;
+    private readonly renderManager;
+    private readonly inputManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
+    private gameLoopAccumulator;
+    private physicsLoopAccumulator;
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, renderManager: RenderManager, inputManager: InputManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    update(time: number): void;
+    private load;
+    private mainIteration;
+    private physicsIteration;
+    private preRenderIteration;
+    private renderIteration;
+    private dispatchFrameEvent;
+}

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

@@ -1,18 +1,21 @@
 import { Game } from "../Game";
 import { Scene } from "../Scene";
 import { RenderManager } from "../../rendering/RenderManager";
-export declare type SceneConstructor = () => Scene;
+export declare type SceneClass = new (name: string, game: Game) => Scene;
 export declare class SceneManager {
     private game;
     private renderManager;
     private scenes;
     private currentScene;
     private openingSceneName;
+    private sceneToLoad;
     currentSceneName: string;
     constructor(game: Game, renderManager: RenderManager);
     getCurrentScene<T extends Scene>(): T;
-    addScene(name: string, sceneConstructor: SceneConstructor, openingScene?: boolean): void;
+    addScene(sceneClass: SceneClass, name: string, openingScene?: boolean): void;
     loadOpeningScene(): void;
     loadScene(name: string): void;
+    update(): void;
+    private _loadScene;
     unloadCurrentScene(): void;
 }

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

@@ -1,18 +1,24 @@
 export declare const MIN_GAME_FRAMERATE = 15;
 export declare const DEFAULT_GAME_FRAMERATE = 60;
-export declare const MIN_PHYSICS_FRAMERATE = 60;
-export declare const DEFAULT_PHYSICS_FRAMERATE = 240;
+export declare const DEFAULT_PHYSICS_FRAMERATE = 180;
 export declare class TimeManager {
-    readonly maxGameDeltatime: number;
-    readonly maxPhysicsDeltaTime: number;
+    readonly minGameDeltatime: number;
+    readonly minPhysicsDeltaTime: number;
+    readonly gameFramerate: number;
+    readonly physicsFramerate: number;
     timeScale: number;
     browserDeltaTime: number;
+    gameDeltaTime: number;
     unscaledGameDeltaTime: number;
     unscaledPhysicsDeltaTime: number;
-    private readonly max;
-    private then;
-    constructor(gameFramerate: number, physicsFramerate: number);
-    update(time: number): void;
+    private readonly maxDeltaTime;
+    private thenForGame;
+    private thenForPhysics;
+    private thenForBrowser;
+    constructor(physicsFramerate: number);
+    updateForGame(time: number): void;
+    updateForBrowser(time: number): void;
+    updateForPhysics(time: number): void;
     get deltaTime(): number;
     get physicsDeltaTime(): number;
 }

package/lib/gameObject/GameCamera.d.ts

@@ -2,8 +2,8 @@ import { GameObject } from "../core/GameObject";
 import { Camera } from "../component/Camera";
 import { Rectangle } from "../math/Rectangle";
 export declare class GameCamera extends GameObject {
-    readonly camera: Camera;
-    constructor();
+    camera: Camera;
+    protected init(): void;
     set layers(layers: string[]);
     get layers(): string[];
     set depth(depth: number);