angry-pixel 1.0.9 → 1.1.2

package/lib/component/Animator.d.ts

@@ -1,7 +1,8 @@
 import { EngineComponent } from "../core/Component";
-import { SpriteRenderer } from "./renderingComponent/SpriteRenderer";
+import { SpriteRenderer } from "./rendering/SpriteRenderer";
 import { Animation } from "./Animation";
-export interface AnimatorConfig {
+import { InitOptions } from "../core/GameActor";
+export interface AnimatorOptions extends InitOptions {
     spriteRenderer: SpriteRenderer;
 }
 export declare class Animator extends EngineComponent {
@@ -9,7 +10,7 @@ export declare class Animator extends EngineComponent {
     private spriteRenderer;
     private animations;
     private currentAnimation;
-    constructor(config: AnimatorConfig);
+    protected init({ spriteRenderer }: AnimatorOptions): void;
     protected update(): void;
     addAnimation(name: string, animation: Animation, framerate?: number): this;
     playAnimation(name: string): void;

package/lib/component/AudioPlayer.d.ts

@@ -1,17 +1,19 @@
 import { EngineComponent } from "../core/Component";
-export interface AudioPlayerConfig {
+import { InitOptions } from "../core/GameActor";
+export interface AudioPlayerOptions extends InitOptions {
     audio?: HTMLAudioElement;
     volume?: number;
     loop?: boolean;
 }
 export declare class AudioPlayer extends EngineComponent {
+    readonly allowMultiple: boolean;
     volume: number;
     loop: boolean;
     audio: HTMLAudioElement;
     private clones;
     private _playing;
     private _paused;
-    constructor(config?: AudioPlayerConfig);
+    protected init(options?: AudioPlayerOptions): void;
     playAudio(audio: HTMLAudioElement, volume?: number | null): void;
     private cloneAudio;
     play(): void;
@@ -19,9 +21,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 onActiveChange(): void;
+    protected onDestroy(): void;
 }

package/lib/component/Camera.d.ts

@@ -1,8 +1,8 @@
 import { CameraComponent } from "../core/Component";
 import { Rectangle } from "../math/Rectangle";
 export declare class Camera extends CameraComponent {
+    readonly allowMultiple: boolean;
     private renderManager;
-    private domManager;
     private _layers;
     private _depth;
     private _zoom;
@@ -11,7 +11,6 @@ export declare class Camera extends CameraComponent {
     private _worldSpaceRect;
     private canvas;
     private cameraData;
-    constructor();
     set layers(layers: string[]);
     get layers(): string[];
     set depth(depth: number);

package/lib/component/ComponentTypes.d.ts

@@ -6,6 +6,9 @@ export declare const ComponentTypes: {
     Transform: string;
     BoxCollider: string;
     TilemapCollider: string;
+    PolygonCollider: string;
+    BallCollider: string;
+    EdgeCollider: string;
     CsvTilemapRenderer: string;
     SpriteRenderer: string;
     TextRenderer: string;

package/lib/component/RigidBody.d.ts

@@ -1,39 +1,23 @@
-import { PhysicsComponent } from "../core/Component";
+import { EngineComponent } from "../core/Component";
 import { Vector2 } from "../math/Vector2";
-export declare enum RigidBodyType {
-    Static = 0,
-    Dynamic = 1
-}
-export interface RigidBodyConfig {
+import { RigidBodyType } from "../physics/rigodBody/RigidBodyManager";
+import { InitOptions } from "../core/GameActor";
+export { RigidBodyType } from "../physics/rigodBody/RigidBodyManager";
+export interface RigidBodyOptions extends InitOptions {
     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;
+export declare class RigidBody extends EngineComponent {
+    readonly allowMultiple: boolean;
+    private rigidBodyManager;
+    private data;
     set velocity(velocity: Vector2);
     get velocity(): Vector2;
     set gravity(gravity: number);
     get gravity(): number;
+    get rigidBodyType(): RigidBodyType;
+    protected init({ rigidBodyType, gravity }: RigidBodyOptions): void;
     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

@@ -2,18 +2,18 @@ import { TransformComponent } from "../core/Component";
 import { Rotation } from "../math/Rotation";
 import { Vector2 } from "../math/Vector2";
 export declare class Transform extends TransformComponent {
+    readonly allowMultiple: boolean;
+    parentScale: boolean;
+    parentRotation: boolean;
     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;
@@ -23,9 +23,8 @@ export declare class Transform extends TransformComponent {
     get innerPosition(): Vector2;
     set innerPosition(innerPosition: Vector2);
     get parent(): Transform | null;
-    set parent(parent: Transform | null);
     protected update(): void;
-    private updateInnerPositionFromParent;
+    private setParent;
     private setPositionFromParent;
     private translateInnerPosition;
     private updateScaledInnerPosition;

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

@@ -0,0 +1,27 @@
+import { Collider } from "./Collider";
+import { InitOptions } from "../../core/GameActor";
+export interface BallColliderOptions extends InitOptions {
+    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;
+    protected init(config: BallColliderOptions): void;
+    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,35 @@
+import { Collider } from "./Collider";
+import { Rotation } from "../../math/Rotation";
+import { InitOptions } from "../../core/GameActor";
+export interface BoxColliderOptions extends InitOptions {
+    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;
+    protected init(config: BoxColliderOptions): void;
+    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,27 @@
+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;
+    /**
+     * @return The GameObject to which this component belongs
+     */
+    getGameObject: <T extends GameObject>() => T;
+}
+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[];
+    private createCollisionData;
+    protected onActiveChange(): void;
+}

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

@@ -0,0 +1,34 @@
+import { Collider } from "./Collider";
+import { Vector2 } from "../../math/Vector2";
+import { Rotation } from "../../math/Rotation";
+import { GameObject } from "../../core/GameObject";
+import { InitOptions } from "../../core/GameActor";
+export interface EdgeColliderOptions extends InitOptions {
+    vertexModel: Vector2[];
+    offsetX?: number;
+    offsetY?: number;
+    rotation?: Rotation;
+    layer?: string;
+    physics?: boolean;
+    debug?: boolean;
+}
+export declare class EdgeCollider extends Collider {
+    debug: boolean;
+    vertexModel: Vector2[];
+    offsetX: number;
+    offsetY: number;
+    rotation: Rotation;
+    private scaledVertexModel;
+    private scaledOffset;
+    private scaledPosition;
+    private finalRotation;
+    private innerPosition;
+    constructor(gameObject: GameObject, name?: string);
+    protected config(config: EdgeColliderOptions): void;
+    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,34 @@
+import { Collider } from "./Collider";
+import { Vector2 } from "../../math/Vector2";
+import { Rotation } from "../../math/Rotation";
+import { InitOptions } from "../../core/GameActor";
+import { GameObject } from "../../core/GameObject";
+export interface PolygonColliderOptions extends InitOptions {
+    vertexModel: Vector2[];
+    offsetX?: number;
+    offsetY?: number;
+    rotation?: Rotation;
+    layer?: string;
+    physics?: boolean;
+    debug?: boolean;
+}
+export declare class PolygonCollider extends Collider {
+    debug: boolean;
+    vertexModel: Vector2[];
+    offsetX: number;
+    offsetY: number;
+    rotation: Rotation;
+    private scaledVertexModel;
+    private scaledOffset;
+    private scaledPosition;
+    private finalRotation;
+    private innerPosition;
+    constructor(gameObject: GameObject, name?: string);
+    protected init(config: PolygonColliderOptions): void;
+    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,17 @@
+import { TilemapRenderer } from "../rendering/tilemap/TilemapRenderer";
+import { Collider } from "./Collider";
+import { InitOptions } from "../../core/GameActor";
+export interface TilemapColliderOptions extends InitOptions {
+    tilemapRenderer: TilemapRenderer;
+    layer?: string;
+    debug?: boolean;
+}
+export declare class TilemapCollider extends Collider {
+    private tilemapRenderer;
+    private debug;
+    private cacheVertex;
+    protected init(config: TilemapColliderOptions): void;
+    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,30 @@
+import { RenderComponent } from "../../core/Component";
+import { Rotation } from "../../math/Rotation";
+import { Vector2 } from "../../math/Vector2";
+import { InitOptions } from "../../core/GameActor";
+export interface MaskRendererOptions extends InitOptions {
+    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;
+    protected init(config: MaskRendererOptions): void;
+    protected update(): void;
+    private calculateRenderPosition;
+    private translateRenderPosition;
+}

package/lib/component/rendering/SpriteRenderer.d.ts

@@ -0,0 +1,47 @@
+import { RenderComponent } from "../../core/Component";
+import { Rotation } from "../../math/Rotation";
+import { Vector2 } from "../../math/Vector2";
+import { Sprite } from "../Sprite";
+import { InitOptions } from "../../core/GameActor";
+export interface SpriteRendererOptions extends InitOptions {
+    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 | null;
+    offset: Vector2;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+    rotation: Rotation;
+    smooth: boolean;
+    opacity: number;
+    private _tiled;
+    maskColor: string | null;
+    maskColorMix: number;
+    tintColor: string | null;
+    layer: string;
+    private renderData;
+    private innerPosition;
+    private cachePosition;
+    private cacheRenderPosition;
+    private scaledOffset;
+    protected init(config?: SpriteRendererOptions): void;
+    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,50 @@
+import { RenderComponent } from "../../core/Component";
+import { Orientation } from "../../rendering/renderData/TextRenderData";
+import { Rotation } from "../../math/Rotation";
+import { Vector2 } from "../../math/Vector2";
+import { InitOptions } from "../../core/GameActor";
+export interface TextRendererOptions extends InitOptions {
+    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;
+    protected init(config: TextRendererOptions): void;
+    protected start(): void;
+    protected update(): void;
+    private crop;
+}

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

@@ -0,0 +1,13 @@
+import { TilemapRenderer, TilemapRendererOptions } from "./TilemapRenderer";
+export interface CsvTilemapOptions extends TilemapRendererOptions {
+    tilemapData: string;
+    alpha?: number;
+    tintColor?: string;
+}
+export declare class CsvTilemapRenderer extends TilemapRenderer {
+    tilemapData: string;
+    alpha: number;
+    tintColor: string;
+    protected init(config: CsvTilemapOptions): void;
+    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,48 @@
+import { TilemapRenderer, TilemapRendererOptions } from "./TilemapRenderer";
+export interface TiledTilemapOptions extends TilemapRendererOptions {
+    tilemapData: TiledTilemap;
+    layerName?: string;
+}
+export declare class TiledTilemapRenderer extends TilemapRenderer {
+    tiledTilemap: TiledTilemap;
+    layerName: string;
+    private tilesetTileIds;
+    protected init(config: TiledTilemapOptions): void;
+    protected processTilemap(): void;
+    private processChunk;
+    private getTilesetTileId;
+}
+export interface TiledTilemap {
+    width: number;
+    height: number;
+    infinite: boolean;
+    layers: TiledLayer[];
+    renderorder: string;
+    tilesets: {
+        firstgid: number;
+    }[];
+}
+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;
+}