angry-pixel 1.1.2 → 1.1.3

package/lib/component/Animator.d.ts

@@ -10,10 +10,13 @@ export declare class Animator extends EngineComponent {
     private spriteRenderer;
     private animations;
     private currentAnimation;
+    private paused;
     protected init({ spriteRenderer }: AnimatorOptions): void;
     protected update(): void;
-    addAnimation(name: string, animation: Animation, framerate?: number): this;
-    playAnimation(name: string): void;
+    addAnimation(animation: Animation, name?: string, framerate?: number): this;
+    playAnimation(name?: string): void;
+    pause(): void;
+    resume(): void;
     stopAnimation(): void;
     isPlayingAnimation(name: string): boolean;
 }

package/lib/component/Button.d.ts

@@ -0,0 +1,42 @@
+import { Component } from "../core/Component";
+import { InitOptions } from "../core/GameActor";
+import { Vector2 } from "../math/Vector2";
+export declare enum ButtonType {
+    Rectangle = 0,
+    Circumference = 1
+}
+export interface ButtonOptions extends InitOptions {
+    type: ButtonType;
+    width?: number;
+    height?: number;
+    radius?: number;
+    touchEnabled?: boolean;
+    offset?: Vector2;
+}
+export declare class Button extends Component {
+    readonly allowMultiple: boolean;
+    type: ButtonType;
+    width: number;
+    height: number;
+    radius: number;
+    touchEnabled: boolean;
+    private _offset;
+    pressed: boolean;
+    private mouse;
+    private touch;
+    private position;
+    private distance;
+    private pressedLastFrame;
+    private scaled;
+    onClick: () => void;
+    onPressed: () => void;
+    get offset(): Vector2;
+    set offset(offset: Vector2);
+    protected init({ type, height, radius, touchEnabled, width, offset }: ButtonOptions): void;
+    protected update(): void;
+    private scale;
+    protected resolveMouseAndRectangle(): void;
+    protected resolveMouseAndCircumference(): void;
+    protected resolveTouchAndRectangle(): void;
+    protected resolveTouchAndCircumference(): void;
+}

package/lib/component/Transform.d.ts

@@ -23,6 +23,7 @@ export declare class Transform extends TransformComponent {
     get innerPosition(): Vector2;
     set innerPosition(innerPosition: Vector2);
     get parent(): Transform | null;
+    set parent(parent: Transform | null);
     protected update(): void;
     private setParent;
     private setPositionFromParent;

package/lib/component/rendering/tilemap/TileData.d.ts

@@ -1,10 +1,13 @@
 import { Vector2 } from "../../../math/Vector2";
 export declare class TileData {
-    private _position;
-    private _width;
-    private _height;
+    readonly position: Vector2;
+    readonly width: number;
+    readonly height: number;
+    private readonly halfWidth;
+    private readonly halfHeight;
     constructor(position: Vector2, width: number, height: number);
-    get position(): Vector2;
-    get width(): number;
-    get height(): number;
+    get x(): number;
+    get x1(): number;
+    get y(): number;
+    get y1(): number;
 }

package/lib/core/Game.d.ts

@@ -3,15 +3,17 @@ import { Container } from "../utils/Container";
 import { Rectangle } from "../math/Rectangle";
 import { Vector2 } from "../math/Vector2";
 import { CollisionMatrix } from "../physics/collision/CollisionManager";
+import { InitOptions } from "./GameActor";
 export declare const container: Container;
 export interface GameConfig {
-    containerNode: HTMLElement | null;
+    containerNode?: HTMLElement | null;
     gameWidth?: number;
     gameHeight?: number;
     debugEnabled?: boolean;
     canvasColor?: string;
     physicsFramerate?: number;
     spriteDefaultScale?: Vector2 | null;
+    headless?: boolean;
     collisions?: {
         method?: CollisionMethodConfig;
         quadTreeBounds?: Rectangle | null;
@@ -43,9 +45,10 @@ export declare class 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, openingScene?: boolean): void;
+    addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
     /**
      * Run the game
      */

package/lib/core/GameActor.d.ts

@@ -2,7 +2,7 @@ import { GameObject, GameObjectClass } from "./GameObject";
 import { GameObjectManager } from "./managers/GameObjectManager";
 import { FrameEvent } from "./managers/IterationManager";
 export interface InitOptions {
-    [key: string]: unknown;
+    [key: string]: any;
 }
 export declare abstract class GameActor {
     protected readonly gameObjectManager: GameObjectManager;
@@ -25,6 +25,29 @@ export declare abstract class GameActor {
      * 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
@@ -33,24 +56,30 @@ export declare abstract class GameActor {
      * @returns The added game object
      * @returns
      */
-    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, name?: string): T;
+    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
      */
-    findGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
+    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
      */
-    findGameObject<T extends GameObject>(name: string): T;
+    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

package/lib/core/GameObject.d.ts

@@ -12,7 +12,7 @@ export declare class GameObject extends GameActor {
     layer: string;
     ui: boolean;
     keep: boolean;
-    parent: GameObject | null;
+    private _parent;
     private _active;
     private sceneManager;
     private components;
@@ -21,6 +21,8 @@ export declare class GameObject extends GameActor {
     constructor(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;
@@ -36,11 +38,31 @@ export declare class GameObject extends GameActor {
     /**
      * Add a component to the game obejct
      * @param componentClass The class of the component
-     * @param options [optional] The options passed to the init method of the component
-     * @param name [optional] The name of the component
      * @returns The added component
      */
-    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options?: OptionsType, name?: string): ComponentType;
+    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.

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

@@ -17,7 +17,13 @@ export declare class GameObjectManagerFacade {
      * Returns all the game objects in the scene.
      * @returns The found game objects
      */
-    static findGameObjects(): GameObject[];
+    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

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

@@ -3,13 +3,16 @@ export declare enum AssetType {
     Audio = "Audio",
     Video = "Video"
 }
+export interface IAssetManager {
+    getAssetsLoaded(): boolean;
+    loadImage(url: string): HTMLImageElement;
+}
 export declare class AssetManager {
     private assets;
     getAssetsLoaded(): boolean;
-    laadImage(url: string): HTMLImageElement;
+    loadImage(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/GameObjectManager.d.ts

@@ -3,7 +3,7 @@ import { InitOptions } from "../GameActor";
 export declare class GameObjectManager {
     private gameObjects;
     addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, parent?: GameObject, name?: string): T;
-    findGameObjects(): GameObject[];
+    findGameObjects<T extends GameObject>(gameObjectClass?: GameObjectClass<T>): T[];
     findGameObjectById<T extends GameObject>(id: string): T;
     findGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
     findGameObject<T extends GameObject>(name: string): T;

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

@@ -0,0 +1,29 @@
+import { GameObjectManager } from "./GameObjectManager";
+import { SceneManager } from "./SceneManager";
+import { CollisionManager } from "../../physics/collision/CollisionManager";
+import { RigidBodyManager } from "../../physics/rigodBody/RigidBodyManager";
+import { TimeManager } from "./TimeManager";
+import { IIterationManager } from "./IterationManager";
+export declare class HeadlessIterationManager implements IIterationManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private readonly physicsManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
+    running: boolean;
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private startLoop;
+    private gameLogicIteration;
+    private physicsIteration;
+    private asyncGameLoop;
+    private asyncPhysicsLoop;
+    private load;
+    private dispatchFrameEvent;
+}

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

@@ -18,7 +18,14 @@ export declare enum FrameEvent {
     UpdateRender = 9,
     Destroy = 10
 }
-export declare class IterationManager {
+export interface IIterationManager {
+    running: boolean;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+}
+export declare class IterationManager implements IIterationManager {
     private readonly timeManager;
     private readonly collisionManager;
     private readonly physicsManager;

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

@@ -1,18 +1,19 @@
 import { Game } from "../Game";
 import { Scene } from "../Scene";
 import { RenderManager } from "../../rendering/RenderManager";
+import { InitOptions } from "../GameActor";
 export declare type SceneClass = new (name: string, game: Game) => Scene;
 export declare class SceneManager {
     private game;
-    private renderManager;
+    private renderManager?;
     private scenes;
     private currentScene;
     private openingSceneName;
     private sceneToLoad;
     currentSceneName: string;
-    constructor(game: Game, renderManager: RenderManager);
+    constructor(game: Game, renderManager?: RenderManager);
     getCurrentScene<T extends Scene>(): T;
-    addScene(sceneClass: SceneClass, name: string, openingScene?: boolean): void;
+    addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
     loadOpeningScene(): void;
     loadScene(name: string): void;
     update(): void;

package/lib/core/managers/headless/HeadlessIterationManager.d.ts

@@ -0,0 +1,29 @@
+import { GameObjectManager } from "../GameObjectManager";
+import { SceneManager } from "../SceneManager";
+import { CollisionManager } from "../../../physics/collision/CollisionManager";
+import { RigidBodyManager } from "../../../physics/rigodBody/RigidBodyManager";
+import { TimeManager } from "../TimeManager";
+import { IIterationManager } from "../IterationManager";
+export declare class HeadlessIterationManager implements IIterationManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private readonly physicsManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
+    running: boolean;
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private startLoop;
+    private gameLogicIteration;
+    private physicsIteration;
+    private asyncGameLoop;
+    private asyncPhysicsLoop;
+    private load;
+    private dispatchFrameEvent;
+}

package/lib/core/managers/headless/HeadlessRenderManager.d.ts

@@ -0,0 +1,10 @@
+import { CameraData } from "../../../rendering/CameraData";
+import { RenderData } from "../../../rendering/renderData/RenderData";
+import { IRenderManager } from "../../../rendering/RenderManager";
+export declare class HeadlessRenderManager implements IRenderManager {
+    clearCanvas(): void;
+    addRenderData(renderData: RenderData): void;
+    addCameraData(cameraData: CameraData): void;
+    render(): void;
+    clearData(): void;
+}

package/lib/core/managers/iteration/BrowserIterationManager.d.ts

@@ -0,0 +1,35 @@
+import { GameObjectManager } from "../GameObjectManager";
+import { SceneManager } from "../SceneManager";
+import { InputManager } from "../../../input/InputManager";
+import { CollisionManager } from "../../../physics/collision/CollisionManager";
+import { RigidBodyManager } from "../../../physics/rigodBody/RigidBodyManager";
+import { RenderManager } from "../../../rendering/RenderManager";
+import { TimeManager } from "../TimeManager";
+import { IIterationManager } from "./IIterationManager";
+export declare class BrowserIterationManager implements IIterationManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private readonly physicsManager;
+    private readonly renderManager;
+    private readonly inputManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
+    running: boolean;
+    private gameLoopAccumulator;
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, renderManager: RenderManager, inputManager: InputManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private startLoop;
+    private requestAnimationLoop;
+    private gameLogicIteration;
+    private renderIteration;
+    private physicsIteration;
+    private asyncPhysicsLoop;
+    private load;
+    private dispatchFrameEvent;
+}

package/lib/core/managers/iteration/FrameEvent.d.ts

@@ -0,0 +1,13 @@
+export declare enum FrameEvent {
+    Init = 0,
+    Start = 1,
+    Update = 2,
+    UpdateEngine = 3,
+    UpdateCollider = 4,
+    UpdatePhysics = 5,
+    UpdateTransform = 6,
+    UpdatePreRender = 7,
+    UpdateCamera = 8,
+    UpdateRender = 9,
+    Destroy = 10
+}

package/lib/core/managers/iteration/HeadlessIterationManager.d.ts

@@ -0,0 +1,29 @@
+import { GameObjectManager } from "../GameObjectManager";
+import { SceneManager } from "../SceneManager";
+import { CollisionManager } from "../../../physics/collision/CollisionManager";
+import { RigidBodyManager } from "../../../physics/rigodBody/RigidBodyManager";
+import { TimeManager } from "../TimeManager";
+import { IIterationManager } from "./IIterationManager";
+export declare class HeadlessIterationManager implements IIterationManager {
+    private readonly timeManager;
+    private readonly collisionManager;
+    private readonly physicsManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
+    running: boolean;
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    private startLoop;
+    private gameLogicIteration;
+    private physicsIteration;
+    private asyncGameLoop;
+    private asyncPhysicsLoop;
+    private load;
+    private dispatchFrameEvent;
+}

package/lib/core/managers/iteration/IIterationManager.d.ts

@@ -0,0 +1,7 @@
+export interface IIterationManager {
+    running: boolean;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+}