angry-pixel 1.0.8 → 1.1.1

package/lib/component/Animation.d.ts

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

package/lib/component/Animator.d.ts

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

package/lib/component/AudioPlayer.d.ts

@@ -19,9 +19,6 @@ export declare class AudioPlayer extends EngineComponent {
     pause(): void;
     private audioEventHandler;
     private userinputEventHandler;
-    setActive(active: boolean): void;
-    /**
-     * @description NOTE: Do not call this method. Use GameObject.setComponentActive instead.
-     */
-    destroy(): void;
+    protected activeStateChange(): void;
+    protected destroy(): void;
 }

package/lib/component/ComponentTypes.d.ts

@@ -6,8 +6,12 @@ export declare const ComponentTypes: {
     Transform: string;
     BoxCollider: string;
     TilemapCollider: string;
+    PolygonCollider: string;
+    BallCollider: string;
+    EdgeCollider: string;
     CsvTilemapRenderer: string;
     SpriteRenderer: string;
     TextRenderer: string;
     TiledTilemapRenderer: string;
+    MaskRenderer: string;
 };

package/lib/component/RigidBody.d.ts

@@ -1,42 +1,22 @@
-import { PhysicsComponent } from "../core/Component";
+import { EngineComponent } from "../core/Component";
 import { Vector2 } from "../math/Vector2";
-export declare enum RigidBodyType {
-    Static = 0,
-    Dynamic = 1
-}
+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 PhysicsComponent {
-    private timeManager;
-    private readonly gravityScale;
-    private readonly velocityScale;
-    private _rigidBodyType;
-    private _colliderComponents;
-    private _layersToCollide;
-    private _velocity;
-    private _gravity;
-    private deltaGravity;
-    private deltaVelocity;
-    private collisions;
-    private penetrationPerDirection;
-    private updatePosition;
-    private penetrationResolution;
-    private nextObjectPosition;
+export declare class RigidBody extends EngineComponent {
+    private rigidBodyManager;
+    readonly rigidBodyType: RigidBodyType;
+    private data;
     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;
+    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/Transform.d.ts

@@ -12,6 +12,7 @@ export declare class Transform extends TransformComponent {
     private cache;
     private lastParentRadians;
     private lastPosition;
+    private scaledInnerPosition;
     constructor();
     get position(): Vector2;
     set position(position: Vector2);
@@ -27,4 +28,5 @@ export declare class Transform extends TransformComponent {
     private updateInnerPositionFromParent;
     private setPositionFromParent;
     private translateInnerPosition;
+    private updateScaledInnerPosition;
 }

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

@@ -0,0 +1,26 @@
+import { Collider } from "./Collider";
+export interface BallColliderConfig {
+    radius: number;
+    offsetX?: number;
+    offsetY?: number;
+    layer?: string;
+    physics?: boolean;
+    debug?: boolean;
+}
+export declare class BallCollider extends Collider {
+    debug: boolean;
+    radius: number;
+    offsetX: number;
+    offsetY: number;
+    private realRadius;
+    private realOffset;
+    private realPosition;
+    private innerPosition;
+    constructor(config: BallColliderConfig);
+    protected start(): void;
+    protected update(): void;
+    private updateRealSize;
+    protected updatePosition(): void;
+    private translate;
+    private updateShape;
+}

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 { GameObject } from "../../core/GameObject";
+import { CollisionResolution } from "../../physics/collision/resolver/CollisionResolver";
+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/EdgeCollider.d.ts

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

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

@@ -0,0 +1,31 @@
+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 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/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/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;
+}

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[];
+}