angry-pixel 1.2.6 → 1.2.8

package/lib/core/GameActor.d.ts

@@ -1,131 +0,0 @@
-import { IPhysicsManager } from "angry-pixel-2d-physics";
-import { IInputManager } from "../input/InputManager";
-import { Container } from "../utils/Container";
-import { GameConfig } from "./GameConfig";
-import { GameObject, GameObjectClass } from "./GameObject";
-import { IAssetManager } from "./managers/AssetManager";
-import { IDomManager } from "./managers/DomManager";
-import { IGameObjectManager } from "./managers/GameObjectManager";
-import { FrameEvent } from "./managers/IterationManager";
-import { ISceneManager } from "./managers/SceneManager";
-import { ITimeManager } from "./managers/TimeManager";
-import { IRenderManager } from "angry-pixel-2d-renderer";
-/** @private */
-export interface InitOptions {
-    [key: string]: any;
-}
-/**
- * Base class from which Scene, GameObjects and Component are extended.
- * @private
- */
-export declare abstract class GameActor {
-    /** @private */
-    protected readonly updateEvent: FrameEvent;
-    /** @private */
-    protected readonly container: Container;
-    /** Used to load and retrieve assets. */
-    protected readonly assetManager: IAssetManager;
-    /** Used to access the canvas element. */
-    protected readonly domManager: IDomManager;
-    /** Used to obtain information about the input. */
-    protected readonly inputManager: IInputManager;
-    /** Used to create, retrieve and destroy GameObject instances. */
-    protected readonly gameObjectManager: IGameObjectManager;
-    /** Used to manage colliders and rigidBodies. */
-    protected readonly physicsManager: IPhysicsManager;
-    /** Used to manage the render and camera data. */
-    protected readonly renderManager: IRenderManager;
-    /** Used to load scenes. */
-    protected readonly sceneManager: ISceneManager;
-    /** Used to manage and obtain information about the time in the game. */
-    protected readonly timeManager: ITimeManager;
-    /** Object containing the game configuration. */
-    protected readonly gameConfig: GameConfig;
-    private started;
-    /** @private */
-    constructor(container: Container);
-    /** @private */
-    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
-     * @returns The added game object
-     */
-    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
-    /**
-     * Adds a new game object to the scene.
-     * @param gameObjectClass The game object class
-     * @param name The name of the game object
-     * @returns The added game object
-     */
-    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, name: string): T;
-    /**
-     * Adds a new game object to the scene.
-     * @param gameObjectClass The game object class
-     * @param options This options will be passed to the init method
-     * @returns The added game object
-     */
-    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options: InitOptions): T;
-    /**
-     * 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
-     */
-    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions | string, name?: string): T;
-    /**
-     * Returns all the game objects in the scene.
-     * @returns The found game objects
-     */
-    protected findGameObjects(): GameObject[];
-    /**
-     * Returns a collection of found game objects for the given class
-     * @param gameObjectClass The game object class to find
-     * @returns The found game objects
-     */
-    protected 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
-     */
-    protected 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
-     */
-    protected 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;
-    /** @private */
-    protected abstract _destroy(): void;
-    /** @private */
-    protected abstract _stopGame(): void;
-}

package/lib/core/GameConfig.d.ts

@@ -1,61 +0,0 @@
-import { BroadPhaseMethods, CollisionMatrix, CollisionMethods } from "angry-pixel-2d-physics";
-import { Rectangle, Vector2 } from "angry-pixel-math";
-/**
- * Game configuration options
- * @public
- * @category Core
- *  @example
- * ```js
- * const gameConfig = {
- *   containerNode: document.getElementById("app"),
- *   gameWidth: 1920,
- *   gameHeight: 1080,
- *   debugEnabled: false,
- *   canvasColor: "#000000",
- *   physicsFramerate: 180,
- *   headless: false,
- *   spriteDefaultScale: new Vector2(1, 1),
- *   collisions: {
- *     collisionMatrix: [
- *       ["layer1", "layer2"],
- *       ["layer1", "layer3"],
- *     ],
- *     collisionMethod: CollisionMethods.SAT,
- *     collisionBroadPhaseMethod: BroadPhaseMethods.SpartialGrid,
- *     collisionArea: new Rectangle(-960, -540, 1920, 1080),
- *   }
- * };
- * ```
- */
-export interface GameConfig {
-    /** HTML element where the game will be created */
-    containerNode?: HTMLElement;
-    /** Game width */
-    gameWidth?: number;
-    /** Game height */
-    gameHeight?: number;
-    /** Enables the debug mode */
-    debugEnabled?: boolean;
-    /** Background color of canvas */
-    canvasColor?: string;
-    /** Framerate for physics execution. The allowed values are 60, 120, 180, 240.
-     * The higher the framerate, the more accurate the physics will be, but it will consume more processor resources.
-     * Default value is 180.
-     */
-    physicsFramerate?: number;
-    /** Define a general scaling for all sprites. It can be overwritten individually on each sprite */
-    spriteDefaultScale?: Vector2;
-    /** Enable Headless mode. The input and rendering functions are turned off. Ideal for game server development */
-    headless?: boolean;
-    /** Collision configuration options */
-    collisions?: {
-        /** Collision detection method: CollisionMethods.SAT or CollisionMethods.ABB. Default value is CollisionMethods.SAT */
-        collisionMethod?: CollisionMethods;
-        /** Define a fixed area  */
-        collisionArea?: Rectangle;
-        /** Define a fixed rectangular area for collision detection */
-        collisionMatrix?: CollisionMatrix;
-        /** Collision broad phase method: BroadPhaseMethods.QuadTree or BroadPhaseMethods.SpartialGrid. Default values is BroadPhaseMethods.SpartialGrid */
-        collisionBroadPhaseMethod?: BroadPhaseMethods;
-    };
-}

package/lib/core/GameObject.d.ts

@@ -1,196 +0,0 @@
-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";
-/** @private */
-export declare const LAYER_DEFAULT = "Default";
-/** @private */
-export type GameObjectClass<T extends GameObject = GameObject> = new (container: Container, id: number, name?: string, parent?: GameObject) => T;
-/**
- * Base class for all objects in the scene.
- * @public
- * @category Core
- * @example
- * ```js
- * class Player extends GameObject {
- *   init(options) {
- *     this.tag = "Tag";
- *     this.layer = "Default";
- *   }
- *   start() {
- *     // executed in the first available frame
- *   }
- *   update() {
- *     // executed on every frame
- *   }
- * }
- * ```
- * @example
- * ```ts
- * class Player extends GameObject {
- *   protected init(options?: InitOptions): void {
- *     this.tag = "Tag";
- *     this.layer = "Default";
- *   }
- *   protected start(): void {
- *     // executed in the first available frame
- *   }
- *   protected update(): void {
- *     // executed on every frame
- *   }
- * }
- * ```
- */
-export declare class GameObject extends GameActor {
-    /** Id automatically assigned at the time of instantiation. */
-    readonly id: number;
-    /** Name given manually at the time of instantiation. */
-    readonly name: string;
-    /** Tag used to group objects and optimize their retrieval. */
-    tag: string;
-    /** Layer used for rendering and physics. Default value is "Default". */
-    layer: string;
-    /** TRUE for UI objects. Default value is FALSE. Renders the object outside the game world coordinates. */
-    ui: boolean;
-    /** TRUE to prevent the object from being automatically destroyed when changing the scene. Default value is FALSE. */
-    keep: boolean;
-    /** @private */
-    private _parent;
-    /** @private */
-    private _active;
-    /** @private */
-    private components;
-    /** @private */
-    private activeComponentsCache;
-    /** @private */
-    private activeChildrenCache;
-    /** @private */
-    constructor(container: Container, id: number, name?: string, parent?: GameObject);
-    /** TRUE for enabled object, FALSE for disabled object. */
-    get active(): boolean;
-    /** TRUE for enabled object, FALSE for disabled object. */
-    set active(active: boolean);
-    /** Parent game object. A child object depends on the parent's Transform. */
-    get parent(): GameObject | null;
-    /** Parent game object. A child object depends on the parent's Transform. */
-    set parent(parent: GameObject | null);
-    /** @private */
-    private updateComponentsActiveStatus;
-    /** @private */
-    private updateChildrenActiveStatus;
-    /**
-     * Transform component added natively in the object
-     */
-    get transform(): Transform;
-    /** RigidBody Component (if any) */
-    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 */
-    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;
-    /** @private */
-    protected _destroy(): void;
-    /** @private */
-    private destroyComponents;
-    /** @private */
-    protected _stopGame(): void;
-}

package/lib/core/Scene.d.ts

@@ -1,45 +0,0 @@
-import { GameCamera } from "../gameObject/GameCamera";
-import { Container } from "../utils/Container";
-import { Game } from "./Game";
-import { GameActor } from "./GameActor";
-/** @private */
-export type SceneClass = new (container: Container, name: string, game: Game) => Scene;
-/**
- * Base class for all game scenes
- * @public
- * @category Core
- * @example
- * ```js
- * class GameScene extends Scene {
- *   init(options) {
- *     this.addGameObject(Player);
- *   }
- *   start() {}
- *   update() {}
- * }
- * ```
- * @example
- * ```ts
- * class GameScene extends Scene {
- *   protected init(options?: InitOptions): void {
- *     this.addGameObject(Player);
- *   }
- *   protected start(): void {}
- *   protected update(): void {}
- * }
- * ```
- */
-export declare class Scene extends GameActor {
-    readonly name: string;
-    readonly game: Game;
-    /** @private */
-    constructor(container: Container, name: string, game: Game);
-    /**
-     * The main active camera
-     */
-    get gameCamera(): GameCamera;
-    /** @private */
-    protected _destroy(): void;
-    /** @private */
-    protected _stopGame(): void;
-}

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

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

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

@@ -1,11 +0,0 @@
-import { TimeManager } from "../managers/TimeManager";
-export declare class TimeManagerFacade {
-    private static timeManager;
-    static initialize(timeManager: TimeManager): void;
-    static get deltaTime(): number;
-    static getTimeScale(): number;
-    static setTimeScale(scale: number): void;
-    static get unscaledDeltaTime(): number;
-    static get physicsDeltaTime(): number;
-    static get browserDeltaTime(): number;
-}

package/lib/core/ioc/Config.d.ts

@@ -1,4 +0,0 @@
-import { GameConfig } from "../GameConfig";
-import { Container } from "../../utils/Container";
-/** @private */
-export declare const loadDependencies: (container: Container, gameConfig: GameConfig) => void;