angry-pixel 1.0.5 → 1.0.9

package/lib/core/GameObject.d.ts

@@ -0,0 +1,158 @@
+import { Component } from "./Component";
+import { Transform } from "../component/Transform";
+import { GameObjectFactory } from "../core/managers/GameObjectManager";
+import { Scene } from "./Scene";
+export declare const LAYER_DEFAULT = "Default";
+export declare type ComponentFactory = () => Component;
+export declare class GameObject {
+    readonly id: string;
+    name: string;
+    tag: string;
+    layer: string;
+    ui: boolean;
+    keep: boolean;
+    private _active;
+    private _parent;
+    private started;
+    private sceneManager;
+    private gameObjectManager;
+    private components;
+    private inactiveComponents;
+    private inactiveChildren;
+    constructor();
+    get transform(): Transform;
+    get active(): boolean;
+    get parent(): GameObject;
+    set parent(parent: GameObject | null);
+    private gameLoopEventHandler;
+    /**
+     * This method is only ever called once.
+     * Recommended for GameObject cration.
+     */
+    init(): void;
+    /**
+     * This method is only ever called once.
+     */
+    protected start(): void;
+    /**
+     * This method is called on every frame.
+     */
+    protected update(): void;
+    /**
+     * @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
+     * @returns The added component
+     */
+    addComponent<T extends Component>(componentFactory: ComponentFactory, name?: string | null): T;
+    private checkMultipleComponent;
+    /**
+     * @returns All the added 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 The found components
+     */
+    getComponentsByType<T extends Component>(type: string): T[];
+    /**
+     * @param name The name of the component to find
+     * @returns TRUE or FALSE
+     */
+    hasComponentOfName(name: string): boolean;
+    /**
+     * @param type The type of the component to find
+     * @returns TRUE or FALSE
+     */
+    hasComponentOfType(type: string): boolean;
+    /**
+     * @param name The name of the component to remove
+     */
+    removeComponentByName(name: string): void;
+    /**
+     * @param type The tyepe of the component to remove
+     */
+    removeComponentByType(type: string): void;
+    /**
+     * Remove all added components
+     */
+    removeComponents(): 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
+     * @returns The added child game object
+     */
+    addChild<T extends GameObject>(gameObjectFactory: GameObjectFactory, name: string): T;
+    /**
+     * @returns The children game objects
+     */
+    getChildren(): GameObject[];
+    /**
+     * @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;
+    /**
+     * If the object become inactive, every component and child game object will stop their execution.
+     *
+     * @param active TRUE or FALE
+     */
+    setActive(active: boolean): void;
+    private updateInactiveCache;
+    /**
+     * 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;
+    /**
+     * @description NOTE: do not use this method. Use GameObject.destroyGameObject or Scene.destroyGameObject instead.
+     */
+    destroy(): void;
+}

package/lib/core/Scene.d.ts

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

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

@@ -0,0 +1,29 @@
+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
+     * @returns The created image element
+     */
+    static loadImage(url: string): HTMLImageElement;
+    /**
+     * @param url The url of the audio file
+     * @returns The created audio element
+     */
+    static loadAudio(url: string): HTMLAudioElement;
+    /**
+     * @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;
+}

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

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

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

@@ -0,0 +1,54 @@
+import { GameObjectManager, GameObjectFactory } from "../managers/GameObjectManager";
+import { GameObject } from "../GameObject";
+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
+     * @returns the added game object
+     */
+    static addGameObject<T extends GameObject>(gameObjectFactory: GameObjectFactory, name: string, parent?: GameObject): T;
+    /**
+     * @returns All the added game objects
+     */
+    static getGameObjects(): GameObject[];
+    /**
+     * @param name The name of the game object to find
+     * @returns The found game object
+     */
+    static findGameObjectByName<T extends GameObject>(name: string): T;
+    /**
+     * @param parent The parent game object
+     * @returns The found game objects
+     */
+    static findGameObjectsByParent(parent: GameObject): GameObject[];
+    /**
+     *
+     * @param parent The parent game object
+     * @param name The name of the game object to find
+     * @returns The found game objects
+     */
+    static findGameObjectByParentAndName<T extends GameObject>(parent: GameObject, name: string): T;
+    /**
+     * @param tag The tag of the game objects to find
+     * @returns The found game objects
+     */
+    static findGameObjectsByTag(tag: string): GameObject[];
+    /**
+     * @param tag The tag of the game object to find
+     * @returns The found game object
+     */
+    static findGameObjectByTag<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/InputManagerFacade.d.ts

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+export declare enum AssetType {
+    Image = "Image",
+    Audio = "Audio",
+    Video = "Video"
+}
+export declare class AssetManager {
+    private assets;
+    getAssetsLoaded(): boolean;
+    laadImage(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/DomManager.d.ts

@@ -0,0 +1,9 @@
+export declare class DomManager {
+    private gameWidth;
+    private gameHeight;
+    private containerNode;
+    private _canvas;
+    constructor(containerNode: HTMLElement, gameWidth: number, gameHeight: number);
+    get canvas(): HTMLCanvasElement;
+    private setupCanvas;
+}

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

@@ -0,0 +1,17 @@
+import { GameObject } from "../GameObject";
+export declare type GameObjectFactory = () => GameObject;
+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;
+    destroyAllGameObjects(): void;
+    destroyGameObject(gameObject: GameObject): void;
+    private _destroyGameObject;
+    private destroyChildren;
+}

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

@@ -0,0 +1,29 @@
+import { InputManager } from "../../input/InputManager";
+import { CollisionManager } from "../../physics/collision/CollisionManager";
+import { RenderManager } from "../../rendering/RenderManager";
+import { TimeManager } from "./TimeManager";
+export declare const EVENT_START: string;
+export declare const EVENT_UPDATE: string;
+export declare const EVENT_UPDATE_ENGINE: string;
+export declare const EVENT_UPDATE_COLLIDER: string;
+export declare const EVENT_UPDATE_PHYSICS: string;
+export declare const EVENT_UPDATE_TRANSFORM: string;
+export declare const EVENT_UPDATE_PRERENDER: string;
+export declare const EVENT_UPDATE_CAMERA: string;
+export declare const EVENT_UPDATE_RENDER: string;
+export declare class IterationManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private readonly renderManager;
+    private readonly inputManager;
+    private gameLoopAccumulator;
+    private physicsLoopAccumulator;
+    private deltaAux;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, renderManager: RenderManager, inputManager: InputManager);
+    update(time: number): void;
+    private mainIteration;
+    private physicsIteration;
+    private preRenderIteration;
+    private renderIteration;
+    private dispatchFrameEvent;
+}

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

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

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

@@ -0,0 +1,18 @@
+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 class TimeManager {
+    readonly maxGameDeltatime: number;
+    readonly maxPhysicsDeltaTime: number;
+    timeScale: number;
+    browserDeltaTime: number;
+    unscaledGameDeltaTime: number;
+    unscaledPhysicsDeltaTime: number;
+    private readonly max;
+    private then;
+    constructor(gameFramerate: number, physicsFramerate: number);
+    update(time: number): void;
+    get deltaTime(): number;
+    get physicsDeltaTime(): number;
+}

package/lib/gameObject/GameCamera.d.ts

@@ -0,0 +1,17 @@
+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();
+    set layers(layers: string[]);
+    get layers(): string[];
+    set depth(depth: number);
+    get depth(): number;
+    set zoom(zoom: number);
+    get zoom(): number;
+    get originalViewporRect(): Rectangle;
+    get worldSpaceRect(): Rectangle;
+    get viewportRect(): Rectangle;
+    addLayer(layer: string): void;
+}

package/lib/gameObject/SpacePointer.d.ts

@@ -0,0 +1,8 @@
+import { GameObject } from "../core/GameObject";
+export declare class SpacePointer extends GameObject {
+    private camera;
+    private mousePressed;
+    private position;
+    protected start(): void;
+    protected update(): void;
+}