angry-pixel 1.0.7 → 1.1.0

package/lib/component/rendering/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/rendering/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/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/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, GameObjectManager } from "./managers/GameObjectManager";
+import { GameObject } from "./GameObject";
+import { Scene } from "./Scene";
+import { FrameEvent } from "./managers/IterationManager";
+export declare abstract class Component {
+    private sceneManager;
+    protected gameObjectManager: GameObjectManager;
+    readonly id: string;
+    type: string;
+    name: string;
+    gameObject: GameObject;
+    allowMultiple: boolean;
+    private _active;
+    private started;
+    protected get updateEvent(): FrameEvent;
+    get active(): boolean;
+    setActive(active: boolean): void;
+    dispatch(event: FrameEvent): void;
+    /**
+     * This method is called only once.
+     * Recommended for GameObject cration.
+     */
+    protected init(): void;
+    /**
+     * 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
+     */
+    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;
+    private _destroy;
+}
+export declare abstract class EngineComponent extends Component {
+    protected get updateEvent(): FrameEvent;
+}
+export declare abstract class ColliderComponent extends Component {
+    protected get updateEvent(): FrameEvent;
+}
+export declare abstract class PhysicsComponent extends Component {
+    protected get updateEvent(): FrameEvent;
+}
+export declare abstract class TransformComponent extends Component {
+    protected get updateEvent(): FrameEvent;
+}
+export declare abstract class PreRenderComponent extends Component {
+    protected get updateEvent(): FrameEvent;
+}
+export declare abstract class CameraComponent extends Component {
+    protected get updateEvent(): FrameEvent;
+}
+export declare abstract class RenderComponent extends Component {
+    protected get updateEvent(): FrameEvent;
+}

package/lib/core/Game.d.ts

@@ -0,0 +1,69 @@
+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;
+    physicsFramerate?: number;
+    spriteDefaultScale?: Vector2 | null;
+    collisions?: {
+        method?: CollisionMethodConfig;
+        quadTreeBounds?: Rectangle | null;
+        quadMaxLevel?: number;
+        collidersPerQuad?: number;
+    };
+}
+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 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;
+}