angry-pixel 1.0.8 → 1.1.1

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

@@ -0,0 +1,25 @@
+import { Vector2 } from "../../../math/Vector2";
+import { Tile } from "./Tile";
+export interface TilesetConfig {
+    image: HTMLImageElement;
+    tileWidth: number;
+    tileHeight: number;
+    gridWidth: number;
+    gridHeight: number;
+    offset?: Vector2;
+    spacing?: Vector2;
+}
+export declare class Tileset {
+    image: HTMLImageElement;
+    tileWidth: number;
+    tileHeight: number;
+    gridWidth: number;
+    gridHeight: number;
+    offset: Vector2;
+    tileSpacing: Vector2;
+    private _tiles;
+    constructor(config: TilesetConfig);
+    private generateTiles;
+    getTile(index: number): Tile | null;
+    get tiles(): Tile[];
+}

package/lib/component/renderingComponent/MaskRenderer.d.ts

@@ -0,0 +1,29 @@
+import { RenderComponent } from "../../core/Component";
+import { Rotation } from "../../math/Rotation";
+import { Vector2 } from "../../math/Vector2";
+export interface MaskRendererConfig {
+    width: number;
+    height: number;
+    color: string;
+    offset?: Vector2;
+    rotation?: Rotation;
+    opacity?: number;
+    layer?: string;
+}
+export declare class MaskRenderer extends RenderComponent {
+    private renderManager;
+    width: number;
+    height: number;
+    color: string;
+    offset: Vector2;
+    rotation: Rotation;
+    opacity: number;
+    layer: string;
+    private renderData;
+    private innerPosition;
+    private scaledOffset;
+    constructor(config: MaskRendererConfig);
+    protected update(): void;
+    private calculateRenderPosition;
+    private translateRenderPosition;
+}

package/lib/core/Component.d.ts

@@ -1,39 +1,42 @@
-import { GameObjectFactory } from "./managers/GameObjectManager";
+import { GameObjectFactory, GameObjectManager } from "./managers/GameObjectManager";
 import { GameObject } from "./GameObject";
 import { Scene } from "./Scene";
+import { FrameEvent } from "./managers/IterationManager";
 export declare abstract class Component {
     private sceneManager;
-    private gameObjectManager;
+    protected gameObjectManager: GameObjectManager;
     readonly id: string;
-    allowMultiple: boolean;
     type: string;
     name: string;
     gameObject: GameObject;
+    allowMultiple: boolean;
     private _active;
     private started;
-    constructor();
-    protected get updateEvent(): string;
+    protected get updateEvent(): FrameEvent;
     get active(): boolean;
-    /**
-     * If the component become inactive, will stop its execution
-     *
-     * @param active TRUE or FALSE
-     */
     setActive(active: boolean): void;
-    protected gameLoopEventHandler: (event: Event) => void;
+    dispatch(event: FrameEvent): void;
     /**
-     * This method is only ever called once.
+     * This method is called only once.
      * Recommended for GameObject cration.
      */
-    init(): void;
+    protected init(): void;
     /**
-     * This method is only ever called once
+     * This method is called only once.
      */
     protected start(): void;
     /**
      * This method is called on every frame.
      */
     protected update(): void;
+    /**
+     * This method is called before the component is destroyed.
+     */
+    protected destroy(): void;
+    /**
+     * This method is called when the active state changes.
+     */
+    protected activeStateChange(): void;
     /**
      * @returns The current loaded scene
      */
@@ -102,29 +105,26 @@ export declare abstract class Component {
      * @param type The tyepe of the component to remove
      */
     removeComponentByType(type: string): void;
-    /**
-     * @description NOTE: Do not call this method. Use GameObject.setComponentActive instead.
-     */
-    destroy(): void;
+    private _destroy;
 }
 export declare abstract class EngineComponent extends Component {
-    protected get updateEvent(): string;
+    protected get updateEvent(): FrameEvent;
 }
 export declare abstract class ColliderComponent extends Component {
-    protected get updateEvent(): string;
+    protected get updateEvent(): FrameEvent;
 }
 export declare abstract class PhysicsComponent extends Component {
-    protected get updateEvent(): string;
+    protected get updateEvent(): FrameEvent;
 }
 export declare abstract class TransformComponent extends Component {
-    protected get updateEvent(): string;
+    protected get updateEvent(): FrameEvent;
 }
 export declare abstract class PreRenderComponent extends Component {
-    protected get updateEvent(): string;
+    protected get updateEvent(): FrameEvent;
 }
 export declare abstract class CameraComponent extends Component {
-    protected get updateEvent(): string;
+    protected get updateEvent(): FrameEvent;
 }
 export declare abstract class RenderComponent extends Component {
-    protected get updateEvent(): string;
+    protected get updateEvent(): FrameEvent;
 }

package/lib/core/Game.d.ts

@@ -9,8 +9,6 @@ export interface GameConfig {
     gameHeight?: number;
     debugEnabled?: boolean;
     canvasColor?: string;
-    context2d?: Context2DConfig;
-    gameFrameRate?: number;
     physicsFramerate?: number;
     spriteDefaultScale?: Vector2 | null;
     collisions?: {
@@ -20,11 +18,6 @@ export interface GameConfig {
         collidersPerQuad?: number;
     };
 }
-export declare enum Context2DConfig {
-    Default = "default",
-    Disabled = "disabled",
-    Fallback = "fallback"
-}
 export declare enum CollisionMethodConfig {
     AABB = "aabb",
     SAT = "sat"
@@ -38,7 +31,6 @@ export declare class Game {
     private _stop;
     private frameRequestId;
     constructor(config: GameConfig);
-    private errorEventHandler;
     private setupManagers;
     /**
      * @returns GameConfig

package/lib/core/GameObject.d.ts

@@ -1,7 +1,9 @@
 import { Component } from "./Component";
 import { Transform } from "../component/Transform";
+import { RigidBody } from "../component/RigidBody";
 import { GameObjectFactory } from "../core/managers/GameObjectManager";
 import { Scene } from "./Scene";
+import { FrameEvent } from "./managers/IterationManager";
 export declare const LAYER_DEFAULT = "Default";
 export declare type ComponentFactory = () => Component;
 export declare class GameObject {
@@ -10,33 +12,38 @@ export declare class GameObject {
     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;
+    setActive(active: boolean): void;
+    get transform(): Transform;
+    get rigidBody(): RigidBody;
+    get parent(): GameObject | null;
     set parent(parent: GameObject | null);
-    private gameLoopEventHandler;
+    dispatch(event: FrameEvent): void;
     /**
-     * This method is only ever called once.
+     * This method is called only once.
      * Recommended for GameObject cration.
      */
-    init(): void;
+    protected init(): void;
     /**
-     * This method is only ever called once.
+     * This method is called only once.
      */
     protected start(): void;
     /**
      * This method is called on every frame.
      */
     protected update(): void;
+    /**
+     * This method is called before the object is destroyed.
+     */
+    protected destroy(): void;
     /**
      * @returns The current loaded scene
      */
@@ -108,10 +115,6 @@ export declare class GameObject {
      * @param type The tyepe of the component to remove
      */
     removeComponentByType(type: string): void;
-    /**
-     * Remove all added components
-     */
-    removeComponents(): void;
     /**
      * Add a child game object.
      *
@@ -133,13 +136,6 @@ export declare class GameObject {
      * 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
@@ -150,8 +146,6 @@ export declare class GameObject {
      * @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;
+    private _destroy;
+    private destroyComponents;
 }

package/lib/core/Scene.d.ts

@@ -2,6 +2,7 @@ import { GameCamera } from "../gameObject/GameCamera";
 import { Game } from "./Game";
 import { GameObject } from "./GameObject";
 import { GameObjectFactory } from "../core/managers/GameObjectManager";
+import { FrameEvent } from "./managers/IterationManager";
 export declare const GAME_CAMERA_ID = "GameCamera";
 export declare class Scene {
     private readonly gameObjectManager;
@@ -9,21 +10,25 @@ export declare class Scene {
     name: string;
     private started;
     constructor();
-    private gameLoopEventHandler;
     get gameCamera(): GameCamera;
+    dispatch(event: FrameEvent): void;
     /**
-     * This method is only ever called once.
+     * This method is called only once.
      * Recommended for GameObject cration.
      */
-    init(): void;
+    protected init(): void;
     /**
-     * This method is only ever called once.
+     * This method is called only once.
      */
     protected start(): void;
     /**
      * This method is called on every frame.
      */
     protected update(): void;
+    /**
+     * This method is called before the scene is destroyed.
+     */
+    protected destroy(): 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
@@ -49,10 +54,6 @@ export declare class Scene {
      * @returns The found game object
      */
     protected findGameObjectByTag<T extends GameObject>(tag: string): T;
-    /**
-     * Desroy all the loaded game objects
-     */
-    protected destroyAllGameObjects(): void;
     /**
      * Destroy one game objects by its name
      * @param name The name of the game object
@@ -64,8 +65,5 @@ export declare class Scene {
      * @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;
+    private _destroy;
 }

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

@@ -10,12 +10,12 @@ export declare class AssetManagerFacade {
      * @param url The url of the image
      * @returns The created image element
      */
-    static createImage(url: string): HTMLImageElement;
+    static loadImage(url: string): HTMLImageElement;
     /**
      * @param url The url of the audio file
      * @returns The created audio element
      */
-    static createAudio(url: string): HTMLAudioElement;
+    static loadAudio(url: string): HTMLAudioElement;
     /**
      * @param url The url of the image element to find
      * @returns the found image element

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

@@ -41,10 +41,6 @@ export declare class GameObjectManagerFacade {
      * @returns The found game object
      */
     static findGameObjectByTag<T extends GameObject>(tag: string): T;
-    /**
-     * Destroy all the added game objects
-     */
-    static destroyAllGameObjects(): void;
     /**
      * Destroy the game objects
      * @param gameObject The game object to destory

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

@@ -6,9 +6,8 @@ export declare enum AssetType {
 export declare class AssetManager {
     private assets;
     getAssetsLoaded(): boolean;
-    createImage(url: string): HTMLImageElement;
-    createAudio(url: string): HTMLAudioElement;
-    createVideo(url: string): HTMLVideoElement;
+    laadImage(url: string): HTMLImageElement;
+    loadAudio(url: string): HTMLAudioElement;
     getImage(url: string): HTMLImageElement;
     getVideo(url: string): HTMLVideoElement;
     getAudio(url: string): HTMLAudioElement;

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

@@ -12,6 +12,6 @@ export declare class GameObjectManager {
     findGameObjectByTag(tag: string): GameObject;
     destroyAllGameObjects(): void;
     destroyGameObject(gameObject: GameObject): void;
-    private _destroyGameObject;
+    private destroy;
     private destroyChildren;
 }

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

@@ -1,26 +1,39 @@
+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";
-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 enum FrameEvent {
+    Init = 0,
+    Start = 1,
+    Update = 2,
+    UpdateEngine = 3,
+    UpdateCollider = 4,
+    UpdatePhysics = 5,
+    UpdateTransform = 6,
+    UpdatePreRender = 7,
+    UpdateCamera = 8,
+    UpdateRender = 9,
+    Destroy = 10
+}
 export declare class IterationManager {
     private readonly timeManager;
     private readonly collisionManager;
+    private readonly physicsManager;
     private readonly renderManager;
     private readonly inputManager;
+    private readonly gameObjectManager;
+    private readonly sceneManager;
     private gameLoopAccumulator;
     private physicsLoopAccumulator;
-    private deltaAux;
-    constructor(timeManager: TimeManager, collisionManager: CollisionManager, renderManager: RenderManager, inputManager: InputManager);
+    private currentScene;
+    private gameObjects;
+    private components;
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, renderManager: RenderManager, inputManager: InputManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
     update(time: number): void;
+    private load;
     private mainIteration;
     private physicsIteration;
     private preRenderIteration;

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

@@ -8,11 +8,14 @@ export declare class SceneManager {
     private scenes;
     private currentScene;
     private openingSceneName;
+    private sceneToLoad;
     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;
+    update(): void;
+    private _loadScene;
     unloadCurrentScene(): void;
 }

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

@@ -1,17 +1,19 @@
-export declare const MIN_GAME_FRAMERATE = 15;
+export declare const MIN_BROWSER_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;
+    readonly minGameDeltatime: number;
+    readonly minPhysicsDeltaTime: number;
+    readonly gameFramerate: number;
+    readonly physicsFramerate: number;
     timeScale: number;
     browserDeltaTime: number;
     unscaledGameDeltaTime: number;
     unscaledPhysicsDeltaTime: number;
     private readonly max;
     private then;
-    constructor(gameFramerate: number, physicsFramerate: number);
+    constructor(physicsFramerate: number);
     update(time: number): void;
     get deltaTime(): number;
     get physicsDeltaTime(): number;