angry-pixel 1.0.9 → 1.1.2

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

@@ -0,0 +1,74 @@
+import { RenderComponent } from "../../../core/Component";
+import { RenderManager } from "../../../rendering/RenderManager";
+import { Vector2 } from "../../../math/Vector2";
+import { Tileset } from "./Tileset";
+import { TileData } from "./TileData";
+import { Tile } from "./Tile";
+import { TilemapRenderData, TileRenderData } from "../../../rendering/renderData/TilemapRenderData";
+import { InitOptions } from "../../../core/GameActor";
+export declare type Flip = {
+    h: boolean;
+    v: boolean;
+};
+export declare type Offset = {
+    x: number;
+    y: number;
+};
+export declare type RenderOrder = "center" | "right-down" | "right-up" | "left-down" | "left-right";
+export declare type LayerToProcess = {
+    layer: string;
+    alpha: number;
+    tintColor: string;
+};
+export declare type TileToProcess = {
+    layer: string;
+    tile: Tile;
+    col: number;
+    row: number;
+    flip: Flip;
+    offset: Offset;
+};
+export interface TilemapRendererOptions extends InitOptions {
+    tileset: Tileset;
+    renderOrder?: RenderOrder;
+    smooth?: boolean;
+    textureCorrection?: number;
+    tileScale?: Vector2;
+}
+export declare abstract class TilemapRenderer extends RenderComponent {
+    readonly allowMultiple: boolean;
+    tileset: Tileset;
+    renderOrder: RenderOrder;
+    smooth: boolean;
+    textureCorrection: number;
+    tileScale: Vector2;
+    protected tileWidth: number;
+    protected tileHeight: number;
+    protected orientation: Vector2;
+    protected renderManager: RenderManager;
+    protected tilemapProcessed: boolean;
+    protected renderData: Map<string, TilemapRenderData>;
+    private cols;
+    private rows;
+    protected _width: number;
+    protected _height: number;
+    protected tiles: TileData[];
+    protected _realWidth: number;
+    protected _realHeight: number;
+    private cacheV2;
+    protected init(config: TilemapRendererOptions): void;
+    protected start(): void;
+    protected update(): void;
+    protected abstract processTilemap(): void;
+    protected processLayer(data: LayerToProcess): void;
+    protected processTile(data: TileToProcess): void;
+    private addTileToRenderData;
+    private updateSizeInfo;
+    private updatePosition;
+    protected addTileData(tileRenderData: TileRenderData): void;
+    get width(): number;
+    get height(): number;
+    get realWidth(): number;
+    get realHeight(): number;
+    get tilesData(): TileData[];
+}

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/core/Component.d.ts

@@ -1,130 +1,85 @@
-import { GameObjectFactory } from "./managers/GameObjectManager";
 import { GameObject } from "./GameObject";
 import { Scene } from "./Scene";
-export declare abstract class Component {
-    private sceneManager;
-    private gameObjectManager;
+import { FrameEvent } from "./managers/IterationManager";
+import { GameActor } from "./GameActor";
+export declare type ComponentClass<T extends Component = Component> = new (gameObject: GameObject, name?: string) => T;
+export declare abstract class Component extends GameActor {
+    private readonly sceneManager;
     readonly id: string;
-    allowMultiple: boolean;
-    type: string;
-    name: string;
-    gameObject: GameObject;
+    readonly name: string;
+    readonly gameObject: GameObject;
+    readonly allowMultiple: boolean;
     private _active;
-    private started;
-    constructor();
-    protected get updateEvent(): string;
+    constructor(gameObject: GameObject, name?: string);
     get active(): boolean;
+    set active(active: boolean);
     /**
-     * If the component become inactive, will stop its execution
-     *
-     * @param active TRUE or FALSE
+     * This method is called when the active state changes.
      */
-    setActive(active: boolean): void;
-    protected gameLoopEventHandler: (event: Event) => void;
-    /**
-     * 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;
+    protected onActiveChange(): 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 component to find
-     * @returns The found component
-     */
-    protected getComponentByName<T extends Component>(name: string): T;
-    /**
-     * @param type The type of the component to find
-     * @returns The found component
+     * @returns The GameObject to which this component is attached
      */
-    protected getComponentByType<T extends Component>(type: string): T;
+    protected getGameObject<T extends GameObject>(): T;
     /**
-     * @param type The type of the components to find
+     * Returns all the components in the game object.
      * @returns The found components
      */
-    protected getComponentsByType<T extends Component>(type: string): T[];
+    getComponents(): Component[];
     /**
-     * @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
+     * Returns all the components for the given class in the game object.
+     * @param componentClass The class of the components
+     * @returns The found components
      */
-    protected findGameObjectsByTag(tag: string): GameObject[];
+    getComponents<T extends Component>(componentClass: ComponentClass<T>): T[];
     /**
-     * @param tag The tag of the game object to find
-     * @returns The found game object
+     * Returns the first component found for the given class, or undefined otherwise.
+     * @param componentClass The class of the component
+     * @returns The found component
      */
-    protected findGameObjectByTag<T extends GameObject>(tag: string): T;
+    getComponent<T extends Component>(componentClass: ComponentClass<T>): T;
     /**
-     * Destroy one game objects by its name
-     * @param name The name of the game object
+     * Returns the first component found for the given name, or undefined otherwise.
+     * @param name The name of the component
+     * @returns The found component
      */
-    protected destroyGameObjectByName(name: string): void;
+    getComponent<T extends Component>(name: string): T;
     /**
-     * Destroy the game objects
-     * @param gameObject The game object to destory
+     * 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
      */
-    protected destroyGameObject(gameObject: GameObject): void;
+    hasComponent<T extends Component>(componentClass: ComponentClass<T>): boolean;
     /**
      * @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;
-    /**
-     * @description NOTE: Do not call this method. Use GameObject.setComponentActive instead.
+     * @returns boolean
      */
-    destroy(): void;
+    hasComponent(name: string): boolean;
+    removeComponent(component: Component): void;
+    protected _destroy(): void;
 }
 export declare abstract class EngineComponent extends Component {
-    protected get updateEvent(): string;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class ColliderComponent extends Component {
-    protected get updateEvent(): string;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class PhysicsComponent extends Component {
-    protected get updateEvent(): string;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class TransformComponent extends Component {
-    protected get updateEvent(): string;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class PreRenderComponent extends Component {
-    protected get updateEvent(): string;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class CameraComponent extends Component {
-    protected get updateEvent(): string;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class RenderComponent extends Component {
-    protected get updateEvent(): string;
+    protected readonly updateEvent: FrameEvent;
 }

package/lib/core/Game.d.ts

@@ -1,7 +1,8 @@
-import { SceneConstructor as SceneFactory } from "../core/managers/SceneManager";
+import { SceneClass } from "../core/managers/SceneManager";
 import { Container } from "../utils/Container";
 import { Rectangle } from "../math/Rectangle";
 import { Vector2 } from "../math/Vector2";
+import { CollisionMatrix } from "../physics/collision/CollisionManager";
 export declare const container: Container;
 export interface GameConfig {
     containerNode: HTMLElement | null;
@@ -9,8 +10,6 @@ export interface GameConfig {
     gameHeight?: number;
     debugEnabled?: boolean;
     canvasColor?: string;
-    context2d?: Context2DConfig;
-    gameFrameRate?: number;
     physicsFramerate?: number;
     spriteDefaultScale?: Vector2 | null;
     collisions?: {
@@ -18,27 +17,18 @@ export interface GameConfig {
         quadTreeBounds?: Rectangle | null;
         quadMaxLevel?: number;
         collidersPerQuad?: number;
+        collisionMatrix?: CollisionMatrix;
     };
 }
-export declare enum Context2DConfig {
-    Default = "default",
-    Disabled = "disabled",
-    Fallback = "fallback"
-}
 export declare enum CollisionMethodConfig {
     AABB = "aabb",
     SAT = "sat"
 }
 export declare class Game {
     private sceneManager;
-    private renderManager;
     private iterationManager;
     private _config;
-    private _running;
-    private _stop;
-    private frameRequestId;
     constructor(config: GameConfig);
-    private errorEventHandler;
     private setupManagers;
     /**
      * @returns GameConfig
@@ -51,11 +41,11 @@ export declare class Game {
     /**
      * Add a scene to the game
      *
+     * @param sceneClass the class of the scene
      * @param name The name of the scene
-     * @param sceneFactory The factory funciton for the escene
-     * @param openingScene If this is the opening scene, set TRUE, FALSE instead
+     * @param openingScene [default FALSE] If this is the opening scene, set TRUE, FALSE instead
      */
-    addScene(name: string, sceneFactory: SceneFactory, openingScene?: boolean): void;
+    addScene(sceneClass: SceneClass, name: string, openingScene?: boolean): void;
     /**
      * Run the game
      */
@@ -64,14 +54,12 @@ export declare class Game {
      * Stop the game
      */
     stop(): void;
-    private gameLoop;
     /**
-     * Pauses the game loop
+     * Pauses the game
      */
-    pauseLoop(): void;
+    pause(): void;
     /**
-     * Resumes the paused game loop
+     * Resumes the paused game
      */
-    resumeLoop(): void;
-    private requestAnimationFrame;
+    resume(): void;
 }

package/lib/core/GameActor.d.ts

@@ -0,0 +1,66 @@
+import { GameObject, GameObjectClass } from "./GameObject";
+import { GameObjectManager } from "./managers/GameObjectManager";
+import { FrameEvent } from "./managers/IterationManager";
+export interface InitOptions {
+    [key: string]: unknown;
+}
+export declare abstract class GameActor {
+    protected readonly gameObjectManager: GameObjectManager;
+    protected readonly updateEvent: FrameEvent;
+    private started;
+    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
+     * @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, name?: string): T;
+    /**
+     * Returns all the game objects in the scene.
+     * @returns The found game objects
+     */
+    protected findGameObjects(): GameObject[];
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}

package/lib/core/GameObject.d.ts

@@ -1,131 +1,102 @@
-import { Component } from "./Component";
+import { Component, ComponentClass } from "./Component";
 import { Transform } from "../component/Transform";
-import { GameObjectFactory } from "../core/managers/GameObjectManager";
+import { RigidBody } from "../component/RigidBody";
 import { Scene } from "./Scene";
+import { GameActor, InitOptions } from "./GameActor";
 export declare const LAYER_DEFAULT = "Default";
-export declare type ComponentFactory = () => Component;
-export declare class GameObject {
+export declare type GameObjectClass<T extends GameObject = GameObject> = new (name?: string, parent?: GameObject) => T;
+export declare class GameObject extends GameActor {
     readonly id: string;
-    name: string;
+    readonly name: string;
     tag: string;
     layer: string;
     ui: boolean;
     keep: boolean;
+    parent: GameObject | null;
     private _active;
-    private _parent;
-    private started;
     private sceneManager;
-    private gameObjectManager;
     private components;
-    private inactiveComponents;
-    private inactiveChildren;
-    constructor();
-    get transform(): Transform;
+    private activeComponentsCache;
+    private activeChildrenCache;
+    constructor(name?: string, parent?: GameObject);
     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;
+    set active(active: boolean);
+    private updateComponentsActiveStatus;
+    private updateChildrenActiveStatus;
+    get transform(): Transform;
+    get rigidBody(): RigidBody;
     /**
-     * This method is called on every frame.
+     * This method is called when the active state changes.
      */
-    protected update(): void;
+    protected onActiveChange(): 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
+     * 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<T extends Component>(componentFactory: ComponentFactory, name?: string | null): T;
+    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options?: OptionsType, name?: string): ComponentType;
     private checkMultipleComponent;
     /**
-     * @returns All the added components
+     * Returns all the components in the game object.
+     * @returns The found 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 all the components for the given class in the game object.
+     * @param componentClass The class of the components
      * @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;
+    getComponents<T extends Component>(componentClass: ComponentClass<T>): T[];
     /**
-     * @param type The type of the component to find
-     * @returns TRUE or FALSE
+     * Returns the first component found for the given class, or undefined otherwise.
+     * @param componentClass The class of the component
+     * @returns The found component
      */
-    hasComponentOfType(type: string): boolean;
+    getComponent<T extends Component>(componentClass: ComponentClass<T>): T;
     /**
-     * @param name The name of the component to remove
+     * Returns the first component found for the given name, or undefined otherwise.
+     * @param name The name of the component
+     * @returns The found component
      */
-    removeComponentByName(name: string): void;
+    getComponent<T extends Component>(name: string): T;
     /**
-     * @param type The tyepe of the component to remove
+     * 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
      */
-    removeComponentByType(type: string): void;
+    hasComponent<T extends Component>(componentClass: ComponentClass<T>): boolean;
     /**
-     * Remove all added components
+     * @param name The name of the component to find
+     * @returns boolean
      */
-    removeComponents(): void;
+    hasComponent(name: string): boolean;
+    removeComponent(component: Component): 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
+     * @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>(gameObjectFactory: GameObjectFactory, name: string): T;
+    addChild<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, name?: string): T;
     /**
      * @returns The children game objects
      */
-    getChildren(): GameObject[];
+    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
      */
@@ -134,25 +105,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
-     */
-    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;
+    protected _destroy(): void;
+    private destroyComponents;
 }