angry-pixel 1.0.5 → 1.0.9

package/lib/component/RigidBody.d.ts

@@ -0,0 +1,39 @@
+import { PhysicsComponent } from "../core/Component";
+import { Vector2 } from "../math/Vector2";
+export declare enum RigidBodyType {
+    Static = 0,
+    Dynamic = 1
+}
+export interface RigidBodyConfig {
+    rigidBodyType: RigidBodyType;
+    layersToCollide?: string[];
+    gravity?: number;
+}
+export declare class RigidBody extends PhysicsComponent {
+    private timeManager;
+    private _rigidBodyType;
+    private _colliderComponents;
+    private _layersToCollide;
+    private _velocity;
+    private _gravity;
+    private deltaGravity;
+    private deltaVelocity;
+    private collisions;
+    private penetrationPerDirection;
+    private updatePosition;
+    private penetrationResolution;
+    constructor(config: RigidBodyConfig);
+    get rigidBodyType(): RigidBodyType;
+    set velocity(velocity: Vector2);
+    get velocity(): Vector2;
+    set gravity(gravity: number);
+    get gravity(): number;
+    protected start(): void;
+    protected update(): void;
+    private applyGravity;
+    private applyVelocity;
+    private applyReposition;
+    private setPenetrationPerDirectionPerAxis;
+    private setPenetrationResolution;
+    private updateCollisions;
+}

package/lib/component/Sprite.d.ts

@@ -0,0 +1,31 @@
+import { Vector2 } from "../math/Vector2";
+export interface SpriteConfig {
+    image: HTMLImageElement;
+    scale?: Vector2;
+    slice?: Slice | null;
+    smooth?: boolean;
+}
+export interface Slice {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class Sprite {
+    private _image;
+    private _slice;
+    private _scale;
+    private _smooth;
+    private _width;
+    private _height;
+    private _loaded;
+    constructor(config: SpriteConfig);
+    get loaded(): boolean;
+    get image(): HTMLImageElement;
+    get slice(): Slice;
+    get scale(): Vector2;
+    get smooth(): boolean;
+    get width(): number;
+    get height(): number;
+    private onLoad;
+}

package/lib/component/Transform.d.ts

@@ -0,0 +1,32 @@
+import { TransformComponent } from "../core/Component";
+import { Rotation } from "../math/Rotation";
+import { Vector2 } from "../math/Vector2";
+export declare class Transform extends TransformComponent {
+    private _position;
+    private _scale;
+    private _rotation;
+    private _innerPosition;
+    private _parent;
+    parentScale: boolean;
+    parentRotation: boolean;
+    private cache;
+    private lastParentRadians;
+    private lastPosition;
+    private scaledInnerPosition;
+    constructor();
+    get position(): Vector2;
+    set position(position: Vector2);
+    get scale(): Vector2;
+    set scale(scale: Vector2);
+    get rotation(): Rotation;
+    get direction(): Vector2;
+    get innerPosition(): Vector2;
+    set innerPosition(innerPosition: Vector2);
+    get parent(): Transform | null;
+    set parent(parent: Transform | null);
+    protected update(): void;
+    private updateInnerPositionFromParent;
+    private setPositionFromParent;
+    private translateInnerPosition;
+    private updateScaledInnerPosition;
+}

package/lib/component/colliderComponent/AbstractColliderComponent.d.ts

@@ -0,0 +1,22 @@
+import { ColliderComponent, RenderComponent } from "../../core/Component";
+import { ICollider } from "../../physics/collision/collider/ICollider";
+import { Collision, CollisionManager } from "../../physics/collision/CollisionManager";
+export declare abstract class AbstractColliderComponent extends ColliderComponent {
+    protected collisionManager: CollisionManager;
+    protected colliders: ICollider[];
+    protected _physics: boolean;
+    protected renderer: RenderComponent;
+    private collisionsCache;
+    constructor();
+    get physics(): boolean;
+    protected abstract updatePosition(): void;
+    protected addCollider(collider: ICollider): void;
+    collidesWithLayer(layer: string): boolean;
+    getCollisionWithLayer(layer: string): Collision | null;
+    getCollisionsWithLayer(layer: string): Collision[];
+    setActive(active: boolean): void;
+    /**
+     * @description NOTE: Do not call this method. Use GameObject.setComponentActive instead.
+     */
+    destroy(): void;
+}

package/lib/component/colliderComponent/BoxCollider.d.ts

@@ -0,0 +1,32 @@
+import { AbstractColliderComponent } from "./AbstractColliderComponent";
+import { Rotation } from "../../math/Rotation";
+export interface BoxColliderConfig {
+    width: number;
+    height: number;
+    offsetX?: number;
+    offsetY?: number;
+    rotation?: Rotation;
+    physics?: boolean;
+    debug?: boolean;
+}
+export declare class BoxCollider extends AbstractColliderComponent {
+    debug: boolean;
+    width: number;
+    height: number;
+    offsetX: number;
+    offsetY: number;
+    rotation: Rotation;
+    private realWidth;
+    private realHeight;
+    private realOffset;
+    private realPosition;
+    private realRotation;
+    private applyRotation;
+    private innerPosition;
+    constructor(config: BoxColliderConfig);
+    protected start(): void;
+    protected update(): void;
+    protected updatePosition(): void;
+    private updateRealSize;
+    private translate;
+}

package/lib/component/colliderComponent/TilemapCollider.d.ts

@@ -0,0 +1,15 @@
+import { TilemapRenderer } from "../renderingComponent/tilemap/TilemapRenderer";
+import { AbstractColliderComponent } from "./AbstractColliderComponent";
+export interface TilemapColliderConfig {
+    tilemapRenderer: TilemapRenderer;
+    debug?: boolean;
+}
+export declare class TilemapCollider extends AbstractColliderComponent {
+    private tilemapRenderer;
+    private debug;
+    private cacheVertex;
+    constructor(config: TilemapColliderConfig);
+    protected start(): void;
+    private needsCollider;
+    protected updatePosition(): void;
+}

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/component/renderingComponent/SpriteRenderer.d.ts

@@ -0,0 +1,46 @@
+import { RenderComponent } from "../../core/Component";
+import { Rotation } from "../../math/Rotation";
+import { Vector2 } from "../../math/Vector2";
+import { Sprite } from "../Sprite";
+export interface SpriteRendererConfig {
+    sprite?: Sprite;
+    offset?: Vector2;
+    smooth?: boolean;
+    rotation?: Rotation;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+    opacity?: number;
+    tiled?: Vector2;
+    maskColor?: string;
+    maskColorMix?: number;
+    tintColor?: string;
+    layer?: string;
+}
+export declare class SpriteRenderer extends RenderComponent {
+    private renderManager;
+    sprite: Sprite;
+    offset: Vector2;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+    rotation: Rotation;
+    smooth: boolean;
+    opacity: number;
+    private _tiled;
+    maskColor: string;
+    maskColorMix: number;
+    tintColor: string;
+    layer: string;
+    private renderData;
+    private innerPosition;
+    private cachePosition;
+    private cacheRenderPosition;
+    private scaledOffset;
+    constructor(config?: SpriteRendererConfig);
+    get tiled(): Vector2;
+    set tiled(tiled: Vector2);
+    protected update(): void;
+    private updateRenderDataArray;
+    private updateRenderData;
+    private calculateRenderPosition;
+    private translateRenderPosition;
+}

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

@@ -0,0 +1,49 @@
+import { RenderComponent } from "../../core/Component";
+import { Orientation } from "../../rendering/renderData/TextRenderData";
+import { Rotation } from "../../math/Rotation";
+import { Vector2 } from "../../math/Vector2";
+export interface TextRendererConfig {
+    text: string;
+    fontFamily: string;
+    fontUrl?: string;
+    fontSize?: number;
+    color?: string;
+    lineSeparation?: number;
+    letterSpacing?: number;
+    width?: number;
+    height?: number;
+    offset?: Vector2;
+    smooth?: boolean;
+    charRanges?: number[];
+    bitmapSize?: number;
+    bitmapOffset?: Vector2;
+    rotation?: Rotation;
+    opacity?: number;
+    orientation?: Orientation;
+}
+export declare class TextRenderer extends RenderComponent {
+    text: string;
+    fontFamily: string;
+    fontUrl: string;
+    fontSize: number;
+    width: number;
+    height: number;
+    offset: Vector2;
+    color: string;
+    lineSeparation: number;
+    letterSpacing: number;
+    bitmapSize: number;
+    charRanges: number[];
+    smooth: boolean;
+    bitmapOffset: Vector2;
+    rotation: Rotation;
+    opacity: number;
+    orientation: Orientation;
+    private renderManager;
+    private renderData;
+    private lastFrameText;
+    constructor(config: TextRendererConfig);
+    protected start(): void;
+    protected update(): void;
+    private crop;
+}

package/lib/component/renderingComponent/tilemap/CsvTilemapRenderer.d.ts

@@ -0,0 +1,13 @@
+import { TilemapRenderer, TilemapRendererConfig } from "./TilemapRenderer";
+export interface CsvTilemapConfig extends TilemapRendererConfig {
+    tilemapData: string;
+    alpha?: number;
+    tintColor?: string;
+}
+export declare class CsvTilemapRenderer extends TilemapRenderer {
+    readonly tilemapData: string;
+    readonly alpha: number;
+    readonly tintColor: string;
+    constructor(config: CsvTilemapConfig);
+    protected processTilemap(): void;
+}

package/lib/component/renderingComponent/tilemap/Tile.d.ts

@@ -0,0 +1,7 @@
+export declare class Tile {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor(x: number, y: number, width: number, height: number);
+}

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

@@ -0,0 +1,10 @@
+import { Vector2 } from "../../../math/Vector2";
+export declare class TileData {
+    private _position;
+    private _width;
+    private _height;
+    constructor(position: Vector2, width: number, height: number);
+    get position(): Vector2;
+    get width(): number;
+    get height(): number;
+}

package/lib/component/renderingComponent/tilemap/TiledTilemapRenderer.d.ts

@@ -0,0 +1,43 @@
+import { TilemapRenderer, TilemapRendererConfig } from "./TilemapRenderer";
+export interface TiledTilemapConfig extends TilemapRendererConfig {
+    tilemapData: TiledTilemap;
+    layerName?: string;
+}
+export declare class TiledTilemapRenderer extends TilemapRenderer {
+    readonly tiledTilemap: TiledTilemap;
+    readonly layerName: string;
+    constructor(config: TiledTilemapConfig);
+    protected processTilemap(): void;
+    private processChunk;
+}
+export interface TiledTilemap {
+    width: number;
+    height: number;
+    infinite: boolean;
+    layers: TiledLayer[];
+    renderorder: string;
+}
+export interface TiledChunk {
+    data: number[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface TiledLayer {
+    name: string;
+    id: number;
+    chunks?: TiledChunk[];
+    data?: number[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    opacity: number;
+    visible: boolean;
+    startx?: number;
+    starty?: number;
+    offsetx?: number;
+    offsety?: number;
+    tintcolor?: string;
+}

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

@@ -0,0 +1,72 @@
+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";
+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 TilemapRendererConfig {
+    tileset: Tileset;
+    renderOrder?: RenderOrder;
+    smooth?: boolean;
+    textureCorrection?: number;
+    tileScale?: Vector2;
+}
+export declare abstract class TilemapRenderer extends RenderComponent {
+    readonly tileset: Tileset;
+    readonly renderOrder: RenderOrder;
+    readonly smooth: boolean;
+    readonly textureCorrection: number;
+    readonly 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;
+    constructor(config: TilemapRendererConfig);
+    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/renderingComponent/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

@@ -0,0 +1,130 @@
+import { GameObjectFactory } from "./managers/GameObjectManager";
+import { GameObject } from "./GameObject";
+import { Scene } from "./Scene";
+export declare abstract class Component {
+    private sceneManager;
+    private gameObjectManager;
+    readonly id: string;
+    allowMultiple: boolean;
+    type: string;
+    name: string;
+    gameObject: GameObject;
+    private _active;
+    private started;
+    constructor();
+    protected get updateEvent(): string;
+    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;
+    /**
+     * 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 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
+     */
+    protected getComponentByType<T extends Component>(type: string): T;
+    /**
+     * @param type The type of the components to find
+     * @returns The found components
+     */
+    protected getComponentsByType<T extends Component>(type: 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;
+    /**
+     * 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;
+    /**
+     * @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.
+     */
+    destroy(): void;
+}
+export declare abstract class EngineComponent extends Component {
+    protected get updateEvent(): string;
+}
+export declare abstract class ColliderComponent extends Component {
+    protected get updateEvent(): string;
+}
+export declare abstract class PhysicsComponent extends Component {
+    protected get updateEvent(): string;
+}
+export declare abstract class TransformComponent extends Component {
+    protected get updateEvent(): string;
+}
+export declare abstract class PreRenderComponent extends Component {
+    protected get updateEvent(): string;
+}
+export declare abstract class CameraComponent extends Component {
+    protected get updateEvent(): string;
+}
+export declare abstract class RenderComponent extends Component {
+    protected get updateEvent(): string;
+}

package/lib/core/Game.d.ts

@@ -0,0 +1,77 @@
+import { SceneConstructor as SceneFactory } from "../core/managers/SceneManager";
+import { Container } from "../utils/Container";
+import { Rectangle } from "../math/Rectangle";
+import { Vector2 } from "../math/Vector2";
+export declare const container: Container;
+export interface GameConfig {
+    containerNode: HTMLElement | null;
+    gameWidth?: number;
+    gameHeight?: number;
+    debugEnabled?: boolean;
+    canvasColor?: string;
+    context2d?: Context2DConfig;
+    gameFrameRate?: number;
+    physicsFramerate?: number;
+    spriteDefaultScale?: Vector2 | null;
+    collisions?: {
+        method?: CollisionMethodConfig;
+        quadTreeBounds?: Rectangle | null;
+        quadMaxLevel?: number;
+        collidersPerQuad?: number;
+    };
+}
+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
+     */
+    get config(): GameConfig;
+    /**
+     * @returns running
+     */
+    get running(): boolean;
+    /**
+     * Add a scene to the game
+     *
+     * @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
+     */
+    addScene(name: string, sceneFactory: SceneFactory, openingScene?: boolean): void;
+    /**
+     * Run the game
+     */
+    run(): void;
+    /**
+     * Stop the game
+     */
+    stop(): void;
+    private gameLoop;
+    /**
+     * Pauses the game loop
+     */
+    pauseLoop(): void;
+    /**
+     * Resumes the paused game loop
+     */
+    resumeLoop(): void;
+    private requestAnimationFrame;
+}