angry-pixel 1.1.13 → 1.2.0

package/lib/component/rendering/TilemapRenderer.d.ts

@@ -1,55 +1,54 @@
-import { TilemapOrientation } from "angry-pixel-2d-renderer";
-import { Vector2 } from "angry-pixel-math";
-import { RenderComponent } from "../../core/Component";
-export { TilemapOrientation };
-export interface Tileset {
-    image: HTMLImageElement;
-    width: number;
-    tileWidth: number;
-    tileHeight: number;
-    margin?: Vector2;
-    spacing?: Vector2;
-}
-export interface TilemapRendererOptions {
-    tiles: string;
-    tileset: Tileset;
-    width: number;
-    tileWidth: number;
-    tileHeight: number;
-    layer?: string;
-    orientation?: TilemapOrientation;
-    alpha?: number;
-    tintColor?: string;
-    smooth?: boolean;
-}
-export interface ITilemapRenderer {
-    tiles: number[];
-    width: number;
-    height: number;
-    tileWidth: number;
-    tileHeight: number;
-    orientation: TilemapOrientation;
-    realWidth: number;
-    realHeight: number;
-}
-export declare class TilemapRenderer extends RenderComponent implements ITilemapRenderer {
-    private renderManager;
-    tiles: number[];
-    width: number;
-    height: number;
-    tileWidth: number;
-    tileHeight: number;
-    tintColor: string;
-    alpha: number;
-    orientation: TilemapOrientation;
-    private tileset;
-    private renderData;
-    private layer;
-    private scaledTileWidth;
-    private scaledTileHeight;
-    realWidth: number;
-    realHeight: number;
-    protected init({ tiles, tileset, tileWidth, tileHeight, width, layer, orientation, alpha, tintColor, smooth, }: TilemapRendererOptions): void;
-    protected update(): void;
-    private updateRenderData;
-}
+import { TilemapOrientation } from "angry-pixel-2d-renderer";
+import { Vector2 } from "angry-pixel-math";
+import { RenderComponent } from "../../core/Component";
+export { TilemapOrientation };
+export interface Tileset {
+    image: HTMLImageElement;
+    width: number;
+    tileWidth: number;
+    tileHeight: number;
+    margin?: Vector2;
+    spacing?: Vector2;
+}
+export interface TilemapRendererOptions {
+    tiles: string;
+    tileset: Tileset;
+    width: number;
+    tileWidth: number;
+    tileHeight: number;
+    layer?: string;
+    orientation?: TilemapOrientation;
+    alpha?: number;
+    tintColor?: string;
+    smooth?: boolean;
+}
+export interface ITilemapRenderer {
+    tiles: number[];
+    width: number;
+    height: number;
+    tileWidth: number;
+    tileHeight: number;
+    orientation: TilemapOrientation;
+    realWidth: number;
+    realHeight: number;
+}
+export declare class TilemapRenderer extends RenderComponent implements ITilemapRenderer {
+    tiles: number[];
+    width: number;
+    height: number;
+    tileWidth: number;
+    tileHeight: number;
+    tintColor: string;
+    alpha: number;
+    orientation: TilemapOrientation;
+    private tileset;
+    private renderData;
+    private layer;
+    private scaledTileWidth;
+    private scaledTileHeight;
+    realWidth: number;
+    realHeight: number;
+    protected init({ tiles, tileset, tileWidth, tileHeight, width, layer, orientation, alpha, tintColor, smooth, }: TilemapRendererOptions): void;
+    protected update(): void;
+    private updateRenderData;
+}

package/lib/core/Component.d.ts

@@ -1,86 +1,86 @@
-import { GameObject } from "./GameObject";
-import { Scene } from "./Scene";
-import { FrameEvent } from "./managers/IterationManager";
-import { GameActor } from "./GameActor";
-import { Container } from "../utils/Container";
-export type ComponentClass<T extends Component = Component> = new (container: Container, gameObject: GameObject, name?: string) => T;
-export declare abstract class Component extends GameActor {
-    readonly id: string;
-    readonly name: string;
-    readonly gameObject: GameObject;
-    readonly allowMultiple: boolean;
-    private _active;
-    constructor(container: Container, gameObject: GameObject, name?: string);
-    get active(): boolean;
-    set active(active: boolean);
-    /**
-     * This method is called when the active state changes.
-     */
-    protected onActiveChange(): void;
-    /**
-     * @returns The current loaded scene
-     */
-    protected getCurrentScene<T extends Scene>(): T;
-    /**
-     * @returns The GameObject to which this component is attached
-     */
-    protected getGameObject<T extends GameObject>(): T;
-    /**
-     * 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;
-    protected _destroy(): void;
-    protected _stopGame(): void;
-}
-export declare abstract class EngineComponent extends Component {
-    protected readonly updateEvent: FrameEvent;
-}
-export declare abstract class ColliderComponent extends Component {
-    protected readonly updateEvent: FrameEvent;
-}
-export declare abstract class PhysicsComponent extends Component {
-    protected readonly updateEvent: FrameEvent;
-}
-export declare abstract class TransformComponent extends Component {
-    protected readonly updateEvent: FrameEvent;
-}
-export declare abstract class PreRenderComponent extends Component {
-    protected readonly updateEvent: FrameEvent;
-}
-export declare abstract class CameraComponent extends Component {
-    protected readonly updateEvent: FrameEvent;
-}
-export declare abstract class RenderComponent extends Component {
-    protected readonly updateEvent: FrameEvent;
-}
+import { GameObject } from "./GameObject";
+import { Scene } from "./Scene";
+import { FrameEvent } from "./managers/IterationManager";
+import { GameActor } from "./GameActor";
+import { Container } from "../utils/Container";
+export type ComponentClass<T extends Component = Component> = new (container: Container, gameObject: GameObject, name?: string) => T;
+export declare abstract class Component extends GameActor {
+    readonly id: string;
+    readonly name: string;
+    readonly gameObject: GameObject;
+    readonly allowMultiple: boolean;
+    private _active;
+    constructor(container: Container, gameObject: GameObject, name?: string);
+    get active(): boolean;
+    set active(active: boolean);
+    /**
+     * This method is called when the active state changes.
+     */
+    protected onActiveChange(): void;
+    /**
+     * @returns The current loaded scene
+     */
+    protected getCurrentScene<T extends Scene>(): T;
+    /**
+     * @returns The GameObject to which this component is attached
+     */
+    protected getGameObject<T extends GameObject>(): T;
+    /**
+     * 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;
+    protected _destroy(): void;
+    protected _stopGame(): void;
+}
+export declare abstract class EngineComponent extends Component {
+    protected readonly updateEvent: FrameEvent;
+}
+export declare abstract class ColliderComponent extends Component {
+    protected readonly updateEvent: FrameEvent;
+}
+export declare abstract class PhysicsComponent extends Component {
+    protected readonly updateEvent: FrameEvent;
+}
+export declare abstract class TransformComponent extends Component {
+    protected readonly updateEvent: FrameEvent;
+}
+export declare abstract class PreRenderComponent extends Component {
+    protected readonly updateEvent: FrameEvent;
+}
+export declare abstract class CameraComponent extends Component {
+    protected readonly updateEvent: FrameEvent;
+}
+export declare abstract class RenderComponent extends Component {
+    protected readonly updateEvent: FrameEvent;
+}

package/lib/core/Game.d.ts

@@ -1,44 +1,44 @@
-import { InitOptions } from "./GameActor";
-import { GameConfig } from "./GameConfig";
-import { SceneClass } from "./Scene";
-export declare class Game {
-    private readonly container;
-    private sceneManager;
-    private iterationManager;
-    private _config;
-    constructor(config: GameConfig);
-    private setupManagers;
-    /**
-     * @returns GameConfig
-     */
-    get config(): GameConfig;
-    /**
-     * @returns running
-     */
-    get running(): boolean;
-    /**
-     * Add a scene to the game
-     *
-     * @param sceneClass the class of the scene
-     * @param name The name of the scene
-     * @param options [optional] This options will be passed to the init method
-     * @param openingScene [default FALSE] If this is the opening scene, set TRUE, FALSE instead
-     */
-    addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
-    /**
-     * Run the game
-     */
-    run(): void;
-    /**
-     * Stop the game
-     */
-    stop(): void;
-    /**
-     * Pauses the game
-     */
-    pause(): void;
-    /**
-     * Resumes the paused game
-     */
-    resume(): void;
-}
+import { InitOptions } from "./GameActor";
+import { GameConfig } from "./GameConfig";
+import { SceneClass } from "./Scene";
+export declare class Game {
+    private readonly container;
+    private sceneManager;
+    private iterationManager;
+    private _config;
+    constructor(config: GameConfig);
+    private setupManagers;
+    /**
+     * @returns GameConfig
+     */
+    get config(): GameConfig;
+    /**
+     * @returns running
+     */
+    get running(): boolean;
+    /**
+     * Add a scene to the game
+     *
+     * @param sceneClass the class of the scene
+     * @param name The name of the scene
+     * @param options [optional] This options will be passed to the init method
+     * @param openingScene [default FALSE] If this is the opening scene, set TRUE, FALSE instead
+     */
+    addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
+    /**
+     * Run the game
+     */
+    run(): void;
+    /**
+     * Stop the game
+     */
+    stop(): void;
+    /**
+     * Pauses the game
+     */
+    pause(): void;
+    /**
+     * Resumes the paused game
+     */
+    resume(): void;
+}

package/lib/core/GameActor.d.ts

@@ -1,99 +1,115 @@
-import { Container } from "../utils/Container";
-import { GameObject, GameObjectClass } from "./GameObject";
-import { GameObjectManager } from "./managers/GameObjectManager";
-import { FrameEvent } from "./managers/IterationManager";
-export interface InitOptions {
-    [key: string]: any;
-}
-export declare abstract class GameActor {
-    protected readonly gameObjectManager: GameObjectManager;
-    protected readonly updateEvent: FrameEvent;
-    protected readonly container: Container;
-    private started;
-    constructor(container: Container);
-    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
-     * @returns
-     */
-    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
-     * @returns
-     */
-    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
-     * @returns
-     */
-    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
-     * @returns
-     */
-    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;
-    protected abstract _destroy(): void;
-    protected abstract _stopGame(): void;
-}
+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";
+export interface InitOptions {
+    [key: string]: any;
+}
+export declare abstract class GameActor {
+    protected readonly updateEvent: FrameEvent;
+    protected readonly container: Container;
+    protected readonly assetManager: IAssetManager;
+    protected readonly domManager: IDomManager;
+    protected readonly inputManager: IInputManager;
+    protected readonly gameObjectManager: IGameObjectManager;
+    protected readonly physicsManager: IPhysicsManager;
+    protected readonly renderManager: IRenderManager;
+    protected readonly sceneManager: ISceneManager;
+    protected readonly timeManager: ITimeManager;
+    protected readonly gameConfig: GameConfig;
+    private started;
+    constructor(container: Container);
+    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
+     * @returns
+     */
+    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
+     * @returns
+     */
+    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
+     * @returns
+     */
+    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
+     * @returns
+     */
+    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;
+    protected abstract _destroy(): void;
+    protected abstract _stopGame(): void;
+}

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;
+    };
+}