angry-pixel 1.1.1 → 1.1.3

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

@@ -1,54 +1,70 @@
-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 getGameObjects(): GameObject[];
+    static findAllGameObjects(): GameObject[];
     /**
+     * Returns a collection of game objects found for the given class
+     * @param gameObjectClass The game object class to find
+     * @returns The found game objects
+     */
+    static findGameObjects<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T[];
+    /**
+     * 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 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/AssetManager.d.ts

@@ -3,13 +3,16 @@ export declare enum AssetType {
     Audio = "Audio",
     Video = "Video"
 }
+export interface IAssetManager {
+    getAssetsLoaded(): boolean;
+    loadImage(url: string): HTMLImageElement;
+}
 export declare class AssetManager {
     private assets;
     getAssetsLoaded(): boolean;
-    laadImage(url: string): HTMLImageElement;
+    loadImage(url: string): HTMLImageElement;
     loadAudio(url: string): HTMLAudioElement;
     getImage(url: string): HTMLImageElement;
-    getVideo(url: string): HTMLVideoElement;
     getAudio(url: string): HTMLAudioElement;
     getAsset<EType extends HTMLImageElement | HTMLVideoElement | HTMLAudioElement>(url: string, type?: AssetType | null): EType;
     private createAsset;

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

@@ -1,15 +1,16 @@
-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<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;
+    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 destroy;

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

@@ -0,0 +1,29 @@
+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";
+export declare class HeadlessIterationManager implements IIterationManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private readonly physicsManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
+    running: boolean;
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private startLoop;
+    private gameLogicIteration;
+    private physicsIteration;
+    private asyncGameLoop;
+    private asyncPhysicsLoop;
+    private load;
+    private dispatchFrameEvent;
+}

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

@@ -18,7 +18,14 @@ export declare enum FrameEvent {
     UpdateRender = 9,
     Destroy = 10
 }
-export declare class IterationManager {
+export interface IIterationManager {
+    running: boolean;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+}
+export declare class IterationManager implements IIterationManager {
     private readonly timeManager;
     private readonly collisionManager;
     private readonly physicsManager;
@@ -26,17 +33,22 @@ export declare class IterationManager {
     private readonly inputManager;
     private readonly gameObjectManager;
     private readonly sceneManager;
+    running: boolean;
     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;
+    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,19 @@
 import { Game } from "../Game";
 import { Scene } from "../Scene";
 import { RenderManager } from "../../rendering/RenderManager";
-export declare type SceneConstructor = () => Scene;
+import { InitOptions } from "../GameActor";
+export declare type SceneClass = new (name: string, game: Game) => Scene;
 export declare class SceneManager {
     private game;
-    private renderManager;
+    private renderManager?;
     private scenes;
     private currentScene;
     private openingSceneName;
     private sceneToLoad;
     currentSceneName: string;
-    constructor(game: Game, renderManager: RenderManager);
+    constructor(game: Game, renderManager?: RenderManager);
     getCurrentScene<T extends Scene>(): T;
-    addScene(name: string, sceneConstructor: SceneConstructor, openingScene?: boolean): void;
+    addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
     loadOpeningScene(): void;
     loadScene(name: string): void;
     update(): void;

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

@@ -1,7 +1,6 @@
-export declare const MIN_BROWSER_FRAMERATE = 15;
+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 minGameDeltatime: number;
     readonly minPhysicsDeltaTime: number;
@@ -9,12 +8,17 @@ export declare class TimeManager {
     readonly physicsFramerate: number;
     timeScale: number;
     browserDeltaTime: number;
+    gameDeltaTime: number;
     unscaledGameDeltaTime: number;
     unscaledPhysicsDeltaTime: number;
-    private readonly max;
-    private then;
+    private readonly maxDeltaTime;
+    private thenForGame;
+    private thenForPhysics;
+    private thenForBrowser;
     constructor(physicsFramerate: number);
-    update(time: number): void;
+    updateForGame(time: number): void;
+    updateForBrowser(time: number): void;
+    updateForPhysics(time: number): void;
     get deltaTime(): number;
     get physicsDeltaTime(): number;
 }

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

@@ -0,0 +1,29 @@
+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";
+export declare class HeadlessIterationManager implements IIterationManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private readonly physicsManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
+    running: boolean;
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private startLoop;
+    private gameLogicIteration;
+    private physicsIteration;
+    private asyncGameLoop;
+    private asyncPhysicsLoop;
+    private load;
+    private dispatchFrameEvent;
+}

package/lib/core/managers/headless/HeadlessRenderManager.d.ts

@@ -0,0 +1,10 @@
+import { CameraData } from "../../../rendering/CameraData";
+import { RenderData } from "../../../rendering/renderData/RenderData";
+import { IRenderManager } from "../../../rendering/RenderManager";
+export declare class HeadlessRenderManager implements IRenderManager {
+    clearCanvas(): void;
+    addRenderData(renderData: RenderData): void;
+    addCameraData(cameraData: CameraData): void;
+    render(): void;
+    clearData(): void;
+}

package/lib/core/managers/iteration/BrowserIterationManager.d.ts

@@ -0,0 +1,35 @@
+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";
+import { IIterationManager } from "./IIterationManager";
+export declare class BrowserIterationManager implements IIterationManager {
+    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 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/iteration/FrameEvent.d.ts

@@ -0,0 +1,13 @@
+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
+}

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

@@ -0,0 +1,29 @@
+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 "./IIterationManager";
+export declare class HeadlessIterationManager implements IIterationManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private readonly physicsManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
+    running: boolean;
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private startLoop;
+    private gameLogicIteration;
+    private physicsIteration;
+    private asyncGameLoop;
+    private asyncPhysicsLoop;
+    private load;
+    private dispatchFrameEvent;
+}

package/lib/core/managers/iteration/IIterationManager.d.ts

@@ -0,0 +1,7 @@
+export interface IIterationManager {
+    running: boolean;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+}

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);