angry-pixel 1.1.13 → 1.1.15

package/lib/core/GameConfig.d.ts

@@ -1,18 +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;
-    };
-}
+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

@@ -1,133 +1,133 @@
-import { Component, ComponentClass } from "./Component";
-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 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;
-    tag: string;
-    layer: string;
-    ui: boolean;
-    keep: boolean;
-    private _parent;
-    private _active;
-    private components;
-    private activeComponentsCache;
-    private activeChildrenCache;
-    constructor(container: Container, name?: string, parent?: GameObject);
-    get active(): boolean;
-    set active(active: boolean);
-    get parent(): GameObject | null;
-    set parent(parent: GameObject | null);
-    private updateComponentsActiveStatus;
-    private updateChildrenActiveStatus;
-    get transform(): Transform;
-    get rigidBody(): RigidBody;
-    /**
-     * This method is called when the active state changes.
-     */
-    protected onActiveChange(): void;
-    /**
-     * @returns The current loaded scene
-     */
-    protected getCurrentScene<T extends Scene>(): T;
-    /**
-     * Add a component to the game obejct
-     * @param componentClass The class of the component
-     * @returns The added component
-     */
-    addComponent<ComponentType extends Component = Component>(componentClass: ComponentClass<ComponentType>): ComponentType;
-    /**
-     * Add a component to the game obejct
-     * @param componentClass The class of the component
-     * @param options The options passed to the init method of the component
-     * @returns The added component
-     */
-    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options: OptionsType): ComponentType;
-    /**
-     * Add a component to the game obejct
-     * @param componentClass The class of the component
-     * @param name The name of the component
-     * @returns The added component
-     */
-    addComponent<ComponentType extends Component = Component>(componentClass: ComponentClass<ComponentType>, name: string): ComponentType;
-    /**
-     * Add a component to the game obejct
-     * @param componentClass The class of the component
-     * @param options The options passed to the init method of the component
-     * @param name The name of the component
-     * @returns The added component
-     */
-    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options: OptionsType, name: string): ComponentType;
-    private checkMultipleComponent;
-    /**
-     * Returns all the components in the game object.
-     * @returns The found components
-     */
-    getComponents(): Component[];
-    /**
-     * Returns all the components for the given class in the game object.
-     * @param componentClass The class of the components
-     * @returns The found components
-     */
-    getComponents<T extends Component>(componentClass: ComponentClass<T>): T[];
-    /**
-     * Returns the first component found for the given class, or undefined otherwise.
-     * @param componentClass The class of the component
-     * @returns The found component
-     */
-    getComponent<T extends Component>(componentClass: ComponentClass<T>): T;
-    /**
-     * Returns the first component found for the given name, or undefined otherwise.
-     * @param name The name of the component
-     * @returns The found component
-     */
-    getComponent<T extends Component>(name: string): T;
-    /**
-     * 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
-     */
-    hasComponent<T extends Component>(componentClass: ComponentClass<T>): boolean;
-    /**
-     * @param name The name of the component to find
-     * @returns boolean
-     */
-    hasComponent(name: string): boolean;
-    removeComponent(component: Component): void;
-    /**
-     * Add a child 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>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, name?: string): T;
-    /**
-     * @returns The children game objects
-     */
-    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
-     */
-    getChild<T extends GameObject>(name: string): T;
-    /**
-     * Destroy all the children game objects
-     */
-    destroyChildren(): void;
-    protected _destroy(): void;
-    private destroyComponents;
-    protected _stopGame(): void;
-}
+import { Component, ComponentClass } from "./Component";
+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 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;
+    tag: string;
+    layer: string;
+    ui: boolean;
+    keep: boolean;
+    private _parent;
+    private _active;
+    private components;
+    private activeComponentsCache;
+    private activeChildrenCache;
+    constructor(container: Container, name?: string, parent?: GameObject);
+    get active(): boolean;
+    set active(active: boolean);
+    get parent(): GameObject | null;
+    set parent(parent: GameObject | null);
+    private updateComponentsActiveStatus;
+    private updateChildrenActiveStatus;
+    get transform(): Transform;
+    get rigidBody(): RigidBody;
+    /**
+     * This method is called when the active state changes.
+     */
+    protected onActiveChange(): void;
+    /**
+     * @returns The current loaded scene
+     */
+    protected getCurrentScene<T extends Scene>(): T;
+    /**
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @returns The added component
+     */
+    addComponent<ComponentType extends Component = Component>(componentClass: ComponentClass<ComponentType>): ComponentType;
+    /**
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @param options The options passed to the init method of the component
+     * @returns The added component
+     */
+    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options: OptionsType): ComponentType;
+    /**
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @param name The name of the component
+     * @returns The added component
+     */
+    addComponent<ComponentType extends Component = Component>(componentClass: ComponentClass<ComponentType>, name: string): ComponentType;
+    /**
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @param options The options passed to the init method of the component
+     * @param name The name of the component
+     * @returns The added component
+     */
+    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options: OptionsType, name: string): ComponentType;
+    private checkMultipleComponent;
+    /**
+     * Returns all the components in the game object.
+     * @returns The found components
+     */
+    getComponents(): Component[];
+    /**
+     * Returns all the components for the given class in the game object.
+     * @param componentClass The class of the components
+     * @returns The found components
+     */
+    getComponents<T extends Component>(componentClass: ComponentClass<T>): T[];
+    /**
+     * Returns the first component found for the given class, or undefined otherwise.
+     * @param componentClass The class of the component
+     * @returns The found component
+     */
+    getComponent<T extends Component>(componentClass: ComponentClass<T>): T;
+    /**
+     * Returns the first component found for the given name, or undefined otherwise.
+     * @param name The name of the component
+     * @returns The found component
+     */
+    getComponent<T extends Component>(name: string): T;
+    /**
+     * 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
+     */
+    hasComponent<T extends Component>(componentClass: ComponentClass<T>): boolean;
+    /**
+     * @param name The name of the component to find
+     * @returns boolean
+     */
+    hasComponent(name: string): boolean;
+    removeComponent(component: Component): void;
+    /**
+     * Add a child 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>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, name?: string): T;
+    /**
+     * @returns The children game objects
+     */
+    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
+     */
+    getChild<T extends GameObject>(name: string): T;
+    /**
+     * Destroy all the children game objects
+     */
+    destroyChildren(): void;
+    protected _destroy(): void;
+    private destroyComponents;
+    protected _stopGame(): void;
+}

package/lib/core/Scene.d.ts

@@ -1,13 +1,13 @@
-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(container: Container, name: string, game: Game);
-    get gameCamera(): GameCamera;
-    protected _destroy(): void;
-    protected _stopGame(): void;
-}
+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(container: Container, name: string, game: Game);
+    get gameCamera(): GameCamera;
+    protected _destroy(): void;
+    protected _stopGame(): void;
+}

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

@@ -1,41 +1,51 @@
-import { AssetManager } from "../managers/AssetManager";
-export declare class AssetManagerFacade {
-    private static assetManager;
-    static initialize(assetManager: AssetManager): void;
-    /**
-     * @returns TRUE if all the assets are loaded, FALSE instead
-     */
-    static getAssetsLoaded(): boolean;
-    /**
-     * @param url The url of the image
-     * @param preloadTexture [optional] preload the texture for this image
-     * @returns The created image element
-     */
-    static loadImage(url: string, preloadTexture?: boolean): HTMLImageElement;
-    /**
-     * @param url The url of the audio file
-     * @returns The created audio element
-     */
-    static loadAudio(url: string): HTMLAudioElement;
-    /**
-     * @param family The family name of the font
-     * @param url The url of the font
-     * @returns The created fontFace element
-     */
-    static loadFont(family: string, url: string): FontFace;
-    /**
-     * @param url The url of the image element to find
-     * @returns the found image element
-     */
-    static getImage(url: string): HTMLImageElement;
-    /**
-     * @param url The url of the audio element to find
-     * @returns The found audio element
-     */
-    static getAudio(url: string): HTMLAudioElement;
-    /**
-     * @param family The family of the font
-     * @returns The found audio element
-     */
-    static getFont(family: string): FontFace;
-}
+import { AssetManager } from "../managers/AssetManager";
+export declare class AssetManagerFacade {
+    private static assetManager;
+    static initialize(assetManager: AssetManager): void;
+    /**
+     * @returns TRUE if all the assets are loaded, FALSE instead
+     */
+    static getAssetsLoaded(): boolean;
+    /**
+     * @param url The url of the image
+     * @param preloadTexture [optional] preload the texture for this image
+     * @returns The created image element
+     */
+    static loadImage(url: string, preloadTexture?: boolean): HTMLImageElement;
+    /**
+     * @param url The url of the audio file
+     * @returns The created audio element
+     */
+    static loadAudio(url: string): HTMLAudioElement;
+    /**
+     * @param family The family name of the font
+     * @param url The url of the font
+     * @returns The created fontFace element
+     */
+    static loadFont(family: string, url: string): FontFace;
+    /**
+     * @param url The url of the video file
+     * @returns The created video element
+     */
+    static loadVideo(url: string): HTMLVideoElement;
+    /**
+     * @param url The url of the image element to find
+     * @returns the found image element
+     */
+    static getImage(url: string): HTMLImageElement;
+    /**
+     * @param url The url of the audio element to find
+     * @returns The found audio element
+     */
+    static getAudio(url: string): HTMLAudioElement;
+    /**
+     * @param family The family of the font
+     * @returns The found audio element
+     */
+    static getFont(family: string): FontFace;
+    /**
+     * @param url The url of the video element to find
+     * @returns The found video element
+     */
+    static getVideo(url: string): HTMLVideoElement;
+}

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

@@ -1,8 +1,8 @@
-import { DomManager } from "../managers/DomManager";
-export declare class DomManagerFacade {
-    private static domManager;
-    static initialize(domManager: DomManager): void;
-    static get gameWidth(): number;
-    static get gameHeight(): number;
-    static get canvas(): HTMLCanvasElement;
-}
+import { DomManager } from "../managers/DomManager";
+export declare class DomManagerFacade {
+    private static domManager;
+    static initialize(domManager: DomManager): void;
+    static get gameWidth(): number;
+    static get gameHeight(): number;
+    static get canvas(): HTMLCanvasElement;
+}

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

@@ -1,70 +1,70 @@
-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;
-    /**
-     * 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>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, parent?: GameObject, name?: string): T;
-    /**
-     * Returns all the game objects in the scene.
-     * @returns The found game objects
-     */
-    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 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<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 gameObjectClass The class of the child game object to find
-     * @returns The found child game object
-     */
-    static findGameObjectByParent<T extends GameObject>(parent: GameObject, gameObjectClass: GameObjectClass<T>): T;
-    /**
-     * 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 findGameObjectByParent<T extends GameObject>(parent: 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
-     */
-    static findGameObjectsByTag<T extends GameObject>(tag: string): T[];
-    /**
-     * Destroy the game objects
-     * @param gameObject The game object to destory
-     */
-    static destroyGameObject(gameObject: GameObject): void;
-}
+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;
+    /**
+     * 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>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, parent?: GameObject, name?: string): T;
+    /**
+     * Returns all the game objects in the scene.
+     * @returns The found game objects
+     */
+    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 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<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 gameObjectClass The class of the child game object to find
+     * @returns The found child game object
+     */
+    static findGameObjectByParent<T extends GameObject>(parent: GameObject, gameObjectClass: GameObjectClass<T>): T;
+    /**
+     * 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 findGameObjectByParent<T extends GameObject>(parent: 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
+     */
+    static findGameObjectsByTag<T extends GameObject>(tag: string): T[];
+    /**
+     * Destroy the game objects
+     * @param gameObject The game object to destory
+     */
+    static destroyGameObject(gameObject: GameObject): void;
+}

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

@@ -1,13 +1,13 @@
-import { GamepadController } from "../../input/GamepadController";
-import { InputManager } from "../../input/InputManager";
-import { KeyboardController } from "../../input/KeyboardController";
-import { MouseController } from "../../input/MouseController";
-import { TouchController } from "../../input/TouchController";
-export declare class InputManagerFacade {
-    private static inputManager;
-    static initialize(inputManager: InputManager): void;
-    static get mouse(): MouseController;
-    static get keyboard(): KeyboardController;
-    static get gamepad(): GamepadController;
-    static get touch(): TouchController;
-}
+import { GamepadController } from "../../input/GamepadController";
+import { InputManager } from "../../input/InputManager";
+import { KeyboardController } from "../../input/KeyboardController";
+import { MouseController } from "../../input/MouseController";
+import { TouchController } from "../../input/TouchController";
+export declare class InputManagerFacade {
+    private static inputManager;
+    static initialize(inputManager: InputManager): void;
+    static get mouse(): MouseController;
+    static get keyboard(): KeyboardController;
+    static get gamepad(): GamepadController;
+    static get touch(): TouchController;
+}

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

@@ -1,18 +1,18 @@
-import { SceneManager } from "../managers/SceneManager";
-export declare class SceneManagerFacade {
-    private static sceneManager;
-    static initialize(sceneManager: SceneManager): void;
-    /**
-     * Unload the current scene and load the new scene
-     * @param name The scene name to load
-     */
-    static loadScene(name: string): void;
-    /**
-     * @returns The name of the current scene
-     */
-    static getCurrentSceneName(): string;
-    /**
-     * Load the opening scene
-     */
-    static loadOpeningScene(): void;
-}
+import { SceneManager } from "../managers/SceneManager";
+export declare class SceneManagerFacade {
+    private static sceneManager;
+    static initialize(sceneManager: SceneManager): void;
+    /**
+     * Unload the current scene and load the new scene
+     * @param name The scene name to load
+     */
+    static loadScene(name: string): void;
+    /**
+     * @returns The name of the current scene
+     */
+    static getCurrentSceneName(): string;
+    /**
+     * Load the opening scene
+     */
+    static loadOpeningScene(): void;
+}