angry-pixel 1.1.1 → 1.1.2

package/lib/core/Game.d.ts

@@ -1,7 +1,8 @@
-import { SceneConstructor as SceneFactory } from "../core/managers/SceneManager";
+import { SceneClass } from "../core/managers/SceneManager";
 import { Container } from "../utils/Container";
 import { Rectangle } from "../math/Rectangle";
 import { Vector2 } from "../math/Vector2";
+import { CollisionMatrix } from "../physics/collision/CollisionManager";
 export declare const container: Container;
 export interface GameConfig {
     containerNode: HTMLElement | null;
@@ -16,6 +17,7 @@ export interface GameConfig {
         quadTreeBounds?: Rectangle | null;
         quadMaxLevel?: number;
         collidersPerQuad?: number;
+        collisionMatrix?: CollisionMatrix;
     };
 }
 export declare enum CollisionMethodConfig {
@@ -24,12 +26,8 @@ export declare enum CollisionMethodConfig {
 }
 export declare class Game {
     private sceneManager;
-    private renderManager;
     private iterationManager;
     private _config;
-    private _running;
-    private _stop;
-    private frameRequestId;
     constructor(config: GameConfig);
     private setupManagers;
     /**
@@ -43,11 +41,11 @@ export declare class Game {
     /**
      * Add a scene to the game
      *
+     * @param sceneClass the class of the scene
      * @param name The name of the scene
-     * @param sceneFactory The factory funciton for the escene
-     * @param openingScene If this is the opening scene, set TRUE, FALSE instead
+     * @param openingScene [default FALSE] If this is the opening scene, set TRUE, FALSE instead
      */
-    addScene(name: string, sceneFactory: SceneFactory, openingScene?: boolean): void;
+    addScene(sceneClass: SceneClass, name: string, openingScene?: boolean): void;
     /**
      * Run the game
      */
@@ -56,14 +54,12 @@ export declare class Game {
      * Stop the game
      */
     stop(): void;
-    private gameLoop;
     /**
-     * Pauses the game loop
+     * Pauses the game
      */
-    pauseLoop(): void;
+    pause(): void;
     /**
-     * Resumes the paused game loop
+     * Resumes the paused game
      */
-    resumeLoop(): void;
-    private requestAnimationFrame;
+    resume(): void;
 }

package/lib/core/GameActor.d.ts

@@ -0,0 +1,66 @@
+import { GameObject, GameObjectClass } from "./GameObject";
+import { GameObjectManager } from "./managers/GameObjectManager";
+import { FrameEvent } from "./managers/IterationManager";
+export interface InitOptions {
+    [key: string]: unknown;
+}
+export declare abstract class GameActor {
+    protected readonly gameObjectManager: GameObjectManager;
+    protected readonly updateEvent: FrameEvent;
+    private started;
+    dispatch(event: FrameEvent, options?: InitOptions): void;
+    /**
+     * This method is called after instantiation (recommended for the creation of game objects).
+     */
+    protected init?(options?: InitOptions): void;
+    /**
+     * This method is called only once on the first available frame.
+     */
+    protected start?(): void;
+    /**
+     * This method is called on every frame.
+     */
+    protected update?(): void;
+    /**
+     * This method is called before destruction.
+     */
+    protected onDestroy?(): void;
+    /**
+     * Adds a new game object to the scene.
+     * @param gameObjectClass The game object class
+     * @param options [optional] This options will be passed to the init method
+     * @param name [optional] The name of the game object
+     * @returns The added game object
+     * @returns
+     */
+    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, name?: string): T;
+    /**
+     * Returns all the game objects in the scene.
+     * @returns The found game objects
+     */
+    protected 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
+     */
+    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
+     */
+    findGameObject<T extends GameObject>(name: string): T;
+    /**
+     * 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
+     */
+    protected findGameObjectsByTag<T extends GameObject>(tag: string): T[];
+    /**
+     * Destroy the given game object
+     * @param gameObject The game object to destory
+     */
+    protected destroyGameObject(gameObject: GameObject): void;
+    protected abstract _destroy(): void;
+}

package/lib/core/GameObject.d.ts

@@ -1,133 +1,102 @@
-import { Component } from "./Component";
+import { Component, ComponentClass } from "./Component";
 import { Transform } from "../component/Transform";
 import { RigidBody } from "../component/RigidBody";
-import { GameObjectFactory } from "../core/managers/GameObjectManager";
 import { Scene } from "./Scene";
-import { FrameEvent } from "./managers/IterationManager";
+import { GameActor, InitOptions } from "./GameActor";
 export declare const LAYER_DEFAULT = "Default";
-export declare type ComponentFactory = () => Component;
-export declare class GameObject {
+export declare type GameObjectClass<T extends GameObject = GameObject> = new (name?: string, parent?: GameObject) => T;
+export declare class GameObject extends GameActor {
     readonly id: string;
-    name: string;
+    readonly name: string;
     tag: string;
     layer: string;
     ui: boolean;
     keep: boolean;
+    parent: GameObject | null;
     private _active;
-    private _parent;
-    private started;
     private sceneManager;
-    private gameObjectManager;
     private components;
-    constructor();
+    private activeComponentsCache;
+    private activeChildrenCache;
+    constructor(name?: string, parent?: GameObject);
     get active(): boolean;
-    setActive(active: boolean): void;
+    set active(active: boolean);
+    private updateComponentsActiveStatus;
+    private updateChildrenActiveStatus;
     get transform(): Transform;
     get rigidBody(): RigidBody;
-    get parent(): GameObject | null;
-    set parent(parent: GameObject | null);
-    dispatch(event: FrameEvent): void;
     /**
-     * This method is called only once.
-     * Recommended for GameObject cration.
+     * This method is called when the active state changes.
      */
-    protected init(): void;
-    /**
-     * This method is called only once.
-     */
-    protected start(): void;
-    /**
-     * This method is called on every frame.
-     */
-    protected update(): void;
-    /**
-     * This method is called before the object is destroyed.
-     */
-    protected destroy(): void;
+    protected onActiveChange(): void;
     /**
      * @returns The current loaded scene
      */
     protected getCurrentScene<T extends Scene>(): T;
     /**
-     * @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;
-    /**
-     * @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;
-    /**
-     * Add a components to the game obejct
-     *
-     * @param componentFactory The factory function for the component
-     * @param name (optional) The name of the component, this must not be used by another component
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @param options [optional] The options passed to the init method of the component
+     * @param name [optional] The name of the component
      * @returns The added component
      */
-    addComponent<T extends Component>(componentFactory: ComponentFactory, name?: string | null): T;
+    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options?: OptionsType, name?: string): ComponentType;
     private checkMultipleComponent;
     /**
-     * @returns All the added components
+     * Returns all the components in the game object.
+     * @returns The found components
      */
     getComponents(): Component[];
     /**
-     * @param name The name of the component to find
-     * @returns The found component
-     */
-    getComponentByName<T extends Component>(name: string): T;
-    /**
-     * @param type The type of the component to find
-     * @returns The found component
-     */
-    getComponentByType<T extends Component>(type: string): T;
-    /**
-     * @param type The type of the components to find
+     * Returns all the components for the given class in the game object.
+     * @param componentClass The class of the components
      * @returns The found components
      */
-    getComponentsByType<T extends Component>(type: string): T[];
+    getComponents<T extends Component>(componentClass: ComponentClass<T>): T[];
     /**
-     * @param name The name of the component to find
-     * @returns TRUE or FALSE
+     * Returns the first component found for the given class, or undefined otherwise.
+     * @param componentClass The class of the component
+     * @returns The found component
      */
-    hasComponentOfName(name: string): boolean;
+    getComponent<T extends Component>(componentClass: ComponentClass<T>): T;
     /**
-     * @param type The type of the component to find
-     * @returns TRUE or FALSE
+     * Returns the first component found for the given name, or undefined otherwise.
+     * @param name The name of the component
+     * @returns The found component
      */
-    hasComponentOfType(type: string): boolean;
+    getComponent<T extends Component>(name: string): T;
     /**
-     * @param name The name of the component to remove
+     * Returns TRUE if the game object has a component for the given class, or FALSE otherwise
+     * @param componentClass The class of the component to find
+     * @returns boolean
      */
-    removeComponentByName(name: string): void;
+    hasComponent<T extends Component>(componentClass: ComponentClass<T>): boolean;
     /**
-     * @param type The tyepe of the component to remove
+     * @param name The name of the component to find
+     * @returns boolean
      */
-    removeComponentByType(type: string): void;
+    hasComponent(name: string): boolean;
+    removeComponent(component: Component): void;
     /**
      * Add a child game object.
-     *
-     * @param gameObjectFactory The factory of the child game object
-     * @param name The name of the child game object, this must not be used by another game object
+     * @param gameObjectClass The class of the child game object
+     * @param options [optional] This options will be passed to the init method
+     * @param name [optional] The name of the game object
      * @returns The added child game object
      */
-    addChild<T extends GameObject>(gameObjectFactory: GameObjectFactory, name: string): T;
+    addChild<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, name?: string): T;
     /**
      * @returns The children game objects
      */
-    getChildren(): GameObject[];
+    getChildren<T extends GameObject>(): T[];
+    /**
+     * Returns the first child found for the given class, or undefined otherwise.
+     * @param gameObjectClass The class of the child game object to find
+     * @returns The found child game object
+     */
+    getChild<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
     /**
+     * Returns the first child found for the given name, or undefined otherwise.
      * @param name The name of the child game object to find
      * @returns The found child game object
      */
@@ -136,16 +105,6 @@ export declare class GameObject {
      * Destroy all the children game objects
      */
     destroyChildren(): void;
-    /**
-     * Destroy one game objects by its name
-     * @param name The name of the game object
-     */
-    destroyGameObjectByName(name: string): void;
-    /**
-     * Destroy the game objects
-     * @param gameObject The game object to destory
-     */
-    destroyGameObject(gameObject: GameObject): void;
-    private _destroy;
+    protected _destroy(): void;
     private destroyComponents;
 }

package/lib/core/Scene.d.ts

@@ -1,69 +1,10 @@
 import { GameCamera } from "../gameObject/GameCamera";
 import { Game } from "./Game";
-import { GameObject } from "./GameObject";
-import { GameObjectFactory } from "../core/managers/GameObjectManager";
-import { FrameEvent } from "./managers/IterationManager";
-export declare const GAME_CAMERA_ID = "GameCamera";
-export declare class Scene {
-    private readonly gameObjectManager;
-    game: Game;
-    name: string;
-    private started;
-    constructor();
+import { GameActor } from "./GameActor";
+export declare class Scene extends GameActor {
+    readonly name: string;
+    readonly game: Game;
+    constructor(name: string, game: Game);
     get gameCamera(): GameCamera;
-    dispatch(event: FrameEvent): void;
-    /**
-     * This method is called only once.
-     * Recommended for GameObject cration.
-     */
-    protected init(): void;
-    /**
-     * This method is called only once.
-     */
-    protected start(): void;
-    /**
-     * This method is called on every frame.
-     */
-    protected update(): void;
-    /**
-     * This method is called before the scene is destroyed.
-     */
-    protected destroy(): 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;
-    private _destroy;
+    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,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(): 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 destroy;

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

@@ -26,17 +26,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;
+}