angry-pixel 1.0.7 → 1.1.0

package/lib/component/Animation.d.ts

@@ -0,0 +1,12 @@
+import { Sprite } from "./Sprite";
+export interface AnimationConfig {
+    sprites: Sprite[];
+    loop: boolean;
+    framerate: number;
+}
+export declare class Animation {
+    sprites: Sprite[];
+    framerate: number;
+    loop: boolean;
+    constructor(config: AnimationConfig);
+}

package/lib/component/Animator.d.ts

@@ -0,0 +1,18 @@
+import { EngineComponent } from "../core/Component";
+import { SpriteRenderer } from "./rendering/SpriteRenderer";
+import { Animation } from "./Animation";
+export interface AnimatorConfig {
+    spriteRenderer: SpriteRenderer;
+}
+export declare class Animator extends EngineComponent {
+    private timeManager;
+    private spriteRenderer;
+    private animations;
+    private currentAnimation;
+    constructor(config: AnimatorConfig);
+    protected update(): void;
+    addAnimation(name: string, animation: Animation, framerate?: number): this;
+    playAnimation(name: string): void;
+    stopAnimation(): void;
+    isPlayingAnimation(name: string): boolean;
+}

package/lib/component/AudioPlayer.d.ts

@@ -0,0 +1,24 @@
+import { EngineComponent } from "../core/Component";
+export interface AudioPlayerConfig {
+    audio?: HTMLAudioElement;
+    volume?: number;
+    loop?: boolean;
+}
+export declare class AudioPlayer extends EngineComponent {
+    volume: number;
+    loop: boolean;
+    audio: HTMLAudioElement;
+    private clones;
+    private _playing;
+    private _paused;
+    constructor(config?: AudioPlayerConfig);
+    playAudio(audio: HTMLAudioElement, volume?: number | null): void;
+    private cloneAudio;
+    play(): void;
+    stop(): void;
+    pause(): void;
+    private audioEventHandler;
+    private userinputEventHandler;
+    protected activeStateChange(): void;
+    protected destroy(): void;
+}

package/lib/component/Camera.d.ts

@@ -0,0 +1,30 @@
+import { CameraComponent } from "../core/Component";
+import { Rectangle } from "../math/Rectangle";
+export declare class Camera extends CameraComponent {
+    private renderManager;
+    private domManager;
+    private _layers;
+    private _depth;
+    private _zoom;
+    private _originalViewportRect;
+    private _viewportRect;
+    private _worldSpaceRect;
+    private canvas;
+    private cameraData;
+    constructor();
+    set layers(layers: string[]);
+    get layers(): string[];
+    set depth(depth: number);
+    get depth(): number;
+    set zoom(zoom: number);
+    get zoom(): number;
+    get originalViewportRect(): Rectangle;
+    get worldSpaceRect(): Rectangle;
+    get viewportRect(): Rectangle;
+    addLayer(layer: string): void;
+    protected update(): void;
+    private updateOriginalViewportRect;
+    private updateViewportRect;
+    private updateWorldSpaceRect;
+    private updateCameraData;
+}

package/lib/component/ComponentTypes.d.ts

@@ -0,0 +1,15 @@
+export declare const ComponentTypes: {
+    Animator: string;
+    AudioPlayer: string;
+    Camera: string;
+    RigidBody: string;
+    Transform: string;
+    BoxCollider: string;
+    TilemapCollider: string;
+    PolygonCollider: string;
+    CsvTilemapRenderer: string;
+    SpriteRenderer: string;
+    TextRenderer: string;
+    TiledTilemapRenderer: string;
+    MaskRenderer: string;
+};

package/lib/component/RigidBody.d.ts

@@ -0,0 +1,22 @@
+import { EngineComponent } from "../core/Component";
+import { Vector2 } from "../math/Vector2";
+import { RigidBodyType } from "../physics/rigodBody/RigidBodyManager";
+export { RigidBodyType } from "../physics/rigodBody/RigidBodyManager";
+export interface RigidBodyConfig {
+    rigidBodyType: RigidBodyType;
+    layersToCollide?: string[];
+    gravity?: number;
+}
+export declare class RigidBody extends EngineComponent {
+    private rigidBodyManager;
+    readonly rigidBodyType: RigidBodyType;
+    private data;
+    constructor(config: RigidBodyConfig);
+    set velocity(velocity: Vector2);
+    get velocity(): Vector2;
+    set gravity(gravity: number);
+    get gravity(): number;
+    protected start(): void;
+    protected update(): void;
+    private getColliders;
+}

package/lib/component/RigidBodyOld.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/collider/BoxCollider.d.ts

@@ -0,0 +1,34 @@
+import { Collider } from "./Collider";
+import { Rotation } from "../../math/Rotation";
+export interface BoxColliderConfig {
+    width: number;
+    height: number;
+    offsetX?: number;
+    offsetY?: number;
+    rotation?: Rotation;
+    layer?: string;
+    physics?: boolean;
+    debug?: boolean;
+}
+export declare class BoxCollider extends Collider {
+    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;
+    private updateRealSize;
+    protected updatePosition(): void;
+    private translate;
+    private updateShape;
+}

package/lib/component/collider/Collider.d.ts

@@ -0,0 +1,22 @@
+import { ColliderComponent, RenderComponent } from "../../core/Component";
+import { CollisionManager } from "../../physics/collision/CollisionManager";
+import { ColliderData } from "../../physics/collision/ColliderData";
+import { CollisionResolution } from "../../physics/collision/resolver/CollisionResolution";
+import { GameObject } from "../../core/GameObject";
+export interface CollisionData {
+    resolution: CollisionResolution;
+    collider: ColliderData;
+    gameObject: GameObject;
+}
+export declare abstract class Collider extends ColliderComponent {
+    protected collisionManager: CollisionManager;
+    protected renderer: RenderComponent;
+    readonly colliders: ColliderData[];
+    layer: string;
+    physics: boolean;
+    protected update(): void;
+    collidesWithLayer(layer: string): boolean;
+    getCollisionWithLayer(layer: string): CollisionData | null;
+    getCollisionsWithLayer(layer: string): CollisionData[];
+    protected activeStateChange(): void;
+}

package/lib/component/collider/PolygonCollider.d.ts

@@ -0,0 +1,32 @@
+import { Collider } from "./Collider";
+import { Vector2 } from "../../math/Vector2";
+import { Rotation } from "../../math/Rotation";
+export interface PolygonColliderConfig {
+    vertexModel: Vector2[];
+    offsetX?: number;
+    offsetY?: number;
+    rotation?: Rotation;
+    layer?: string;
+    physics?: boolean;
+    debug?: boolean;
+}
+export declare class PolygonCollider extends Collider {
+    readonly debug: boolean;
+    readonly vertexModel: Vector2[];
+    offsetX: number;
+    offsetY: number;
+    rotation: Rotation;
+    private scaledVertexModel;
+    private scaledOffset;
+    private scaledPosition;
+    private finalRotation;
+    private applyRotation;
+    private innerPosition;
+    constructor(config: PolygonColliderConfig);
+    protected start(): void;
+    protected update(): void;
+    private updateSize;
+    protected updatePosition(): void;
+    private translate;
+    private updateShape;
+}

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

@@ -0,0 +1,16 @@
+import { TilemapRenderer } from "../rendering/tilemap/TilemapRenderer";
+import { Collider } from "./Collider";
+export interface TilemapColliderConfig {
+    tilemapRenderer: TilemapRenderer;
+    layer?: string;
+    debug?: boolean;
+}
+export declare class TilemapCollider extends Collider {
+    private tilemapRenderer;
+    private debug;
+    private cacheVertex;
+    constructor(config: TilemapColliderConfig);
+    protected start(): void;
+    private needsCollider;
+    protected update(): void;
+}

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

@@ -0,0 +1,27 @@
+import { ColliderComponent, RenderComponent } from "../../core/Component";
+import { CollisionManager } from "../../physics/collision/CollisionManager";
+import { ColliderData } from "../../physics/collision/ColliderData";
+import { CollisionResolution } from "../../physics/collision/resolver/CollisionResolution";
+import { GameObject } from "../../core/GameObject";
+export interface CollisionData {
+    resolution: CollisionResolution;
+    collider: ColliderData;
+    gameObject: GameObject;
+}
+export declare abstract class AbstractColliderComponent extends ColliderComponent {
+    protected collisionManager: CollisionManager;
+    protected renderer: RenderComponent;
+    protected _physics: boolean;
+    readonly colliders: ColliderData[];
+    layer: string;
+    get physics(): boolean;
+    protected addCollider(collider: ColliderData): void;
+    collidesWithLayer(layer: string): boolean;
+    getCollisionWithLayer(layer: string): CollisionData | null;
+    getCollisionsWithLayer(layer: string): CollisionData[];
+    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,34 @@
+import { AbstractColliderComponent } from "./AbstractColliderComponent";
+import { Rotation } from "../../math/Rotation";
+export interface BoxColliderConfig {
+    width: number;
+    height: number;
+    offsetX?: number;
+    offsetY?: number;
+    rotation?: Rotation;
+    layer?: string;
+    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;
+    private updateRealSize;
+    protected updatePosition(): void;
+    private translate;
+    private updateShape;
+}

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

@@ -0,0 +1,32 @@
+import { AbstractColliderComponent } from "./AbstractColliderComponent";
+import { Vector2 } from "../../math/Vector2";
+import { Rotation } from "../../math/Rotation";
+export interface PolygonColliderConfig {
+    vertexModel: Vector2[];
+    offsetX?: number;
+    offsetY?: number;
+    rotation?: Rotation;
+    layer?: string;
+    physics?: boolean;
+    debug?: boolean;
+}
+export declare class PolygonCollider extends AbstractColliderComponent {
+    readonly debug: boolean;
+    readonly vertexModel: Vector2[];
+    offsetX: number;
+    offsetY: number;
+    rotation: Rotation;
+    private scaledVertexModel;
+    private scaledOffset;
+    private scaledPosition;
+    private finalRotation;
+    private applyRotation;
+    private innerPosition;
+    constructor(config: PolygonColliderConfig);
+    protected start(): void;
+    protected update(): void;
+    private updateSize;
+    protected updatePosition(): void;
+    private translate;
+    private updateShape;
+}

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

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

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

@@ -0,0 +1,32 @@
+import { AbstractColliderComponent } from "./AbstractColliderComponent";
+import { Vector2 } from "../../math/Vector2";
+import { Rotation } from "../../math/Rotation";
+export interface TriangleColliderConfig {
+    vertexModel: [Vector2, Vector2, Vector2];
+    offsetX?: number;
+    offsetY?: number;
+    rotation?: Rotation;
+    layer?: string;
+    physics?: boolean;
+    debug?: boolean;
+}
+export declare class TriangleCollider extends AbstractColliderComponent {
+    debug: boolean;
+    vertexModel: [Vector2, Vector2, Vector2];
+    offsetX: number;
+    offsetY: number;
+    rotation: Rotation;
+    private scaledVertexModel;
+    private scaledOffset;
+    private scaledPosition;
+    private finalRotation;
+    private applyRotation;
+    private innerPosition;
+    constructor(config: TriangleColliderConfig);
+    protected start(): void;
+    protected update(): void;
+    private updateSize;
+    protected updatePosition(): void;
+    private translate;
+    private updateShape;
+}

package/lib/component/rendering/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/rendering/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/rendering/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/rendering/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/rendering/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/rendering/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;
+}