angry-pixel 1.1.1 → 1.1.3

package/lib/component/Animator.d.ts

@@ -1,7 +1,8 @@
 import { EngineComponent } from "../core/Component";
 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,10 +10,13 @@ export declare class Animator extends EngineComponent {
     private spriteRenderer;
     private animations;
     private currentAnimation;
-    constructor(config: AnimatorConfig);
+    private paused;
+    protected init({ spriteRenderer }: AnimatorOptions): void;
     protected update(): void;
-    addAnimation(name: string, animation: Animation, framerate?: number): this;
-    playAnimation(name: string): void;
+    addAnimation(animation: Animation, name?: string, framerate?: number): this;
+    playAnimation(name?: string): void;
+    pause(): void;
+    resume(): void;
     stopAnimation(): void;
     isPlayingAnimation(name: string): boolean;
 }

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,6 +21,6 @@ export declare class AudioPlayer extends EngineComponent {
     pause(): void;
     private audioEventHandler;
     private userinputEventHandler;
-    protected activeStateChange(): void;
-    protected destroy(): void;
+    protected onActiveChange(): void;
+    protected onDestroy(): void;
 }

package/lib/component/Button.d.ts

@@ -0,0 +1,42 @@
+import { Component } from "../core/Component";
+import { InitOptions } from "../core/GameActor";
+import { Vector2 } from "../math/Vector2";
+export declare enum ButtonType {
+    Rectangle = 0,
+    Circumference = 1
+}
+export interface ButtonOptions extends InitOptions {
+    type: ButtonType;
+    width?: number;
+    height?: number;
+    radius?: number;
+    touchEnabled?: boolean;
+    offset?: Vector2;
+}
+export declare class Button extends Component {
+    readonly allowMultiple: boolean;
+    type: ButtonType;
+    width: number;
+    height: number;
+    radius: number;
+    touchEnabled: boolean;
+    private _offset;
+    pressed: boolean;
+    private mouse;
+    private touch;
+    private position;
+    private distance;
+    private pressedLastFrame;
+    private scaled;
+    onClick: () => void;
+    onPressed: () => void;
+    get offset(): Vector2;
+    set offset(offset: Vector2);
+    protected init({ type, height, radius, touchEnabled, width, offset }: ButtonOptions): void;
+    protected update(): void;
+    private scale;
+    protected resolveMouseAndRectangle(): void;
+    protected resolveMouseAndCircumference(): void;
+    protected resolveTouchAndRectangle(): void;
+    protected resolveTouchAndCircumference(): 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/RigidBody.d.ts

@@ -1,21 +1,22 @@
 import { EngineComponent } from "../core/Component";
 import { Vector2 } from "../math/Vector2";
 import { RigidBodyType } from "../physics/rigodBody/RigidBodyManager";
+import { InitOptions } from "../core/GameActor";
 export { RigidBodyType } from "../physics/rigodBody/RigidBodyManager";
-export interface RigidBodyConfig {
+export interface RigidBodyOptions extends InitOptions {
     rigidBodyType: RigidBodyType;
-    layersToCollide?: string[];
     gravity?: number;
 }
 export declare class RigidBody extends EngineComponent {
+    readonly allowMultiple: boolean;
     private rigidBodyManager;
-    readonly rigidBodyType: RigidBodyType;
     private data;
-    constructor(config: RigidBodyConfig);
     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 getColliders;

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;
@@ -25,7 +25,7 @@ export declare class Transform extends TransformComponent {
     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

@@ -1,5 +1,6 @@
 import { Collider } from "./Collider";
-export interface BallColliderConfig {
+import { InitOptions } from "../../core/GameActor";
+export interface BallColliderOptions extends InitOptions {
     radius: number;
     offsetX?: number;
     offsetY?: number;
@@ -16,7 +17,7 @@ export declare class BallCollider extends Collider {
     private realOffset;
     private realPosition;
     private innerPosition;
-    constructor(config: BallColliderConfig);
+    protected init(config: BallColliderOptions): void;
     protected start(): void;
     protected update(): void;
     private updateRealSize;

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

@@ -1,6 +1,7 @@
 import { Collider } from "./Collider";
 import { Rotation } from "../../math/Rotation";
-export interface BoxColliderConfig {
+import { InitOptions } from "../../core/GameActor";
+export interface BoxColliderOptions extends InitOptions {
     width: number;
     height: number;
     offsetX?: number;
@@ -24,7 +25,7 @@ export declare class BoxCollider extends Collider {
     private realRotation;
     private applyRotation;
     private innerPosition;
-    constructor(config: BoxColliderConfig);
+    protected init(config: BoxColliderOptions): void;
     protected start(): void;
     protected update(): void;
     private updateRealSize;

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

@@ -7,6 +7,10 @@ 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;
@@ -18,5 +22,6 @@ export declare abstract class Collider extends ColliderComponent {
     collidesWithLayer(layer: string): boolean;
     getCollisionWithLayer(layer: string): CollisionData | null;
     getCollisionsWithLayer(layer: string): CollisionData[];
-    protected activeStateChange(): void;
+    private createCollisionData;
+    protected onActiveChange(): void;
 }

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

@@ -1,7 +1,9 @@
 import { Collider } from "./Collider";
 import { Vector2 } from "../../math/Vector2";
 import { Rotation } from "../../math/Rotation";
-export interface EdgeColliderConfig {
+import { GameObject } from "../../core/GameObject";
+import { InitOptions } from "../../core/GameActor";
+export interface EdgeColliderOptions extends InitOptions {
     vertexModel: Vector2[];
     offsetX?: number;
     offsetY?: number;
@@ -11,8 +13,8 @@ export interface EdgeColliderConfig {
     debug?: boolean;
 }
 export declare class EdgeCollider extends Collider {
-    readonly debug: boolean;
-    readonly vertexModel: Vector2[];
+    debug: boolean;
+    vertexModel: Vector2[];
     offsetX: number;
     offsetY: number;
     rotation: Rotation;
@@ -21,7 +23,8 @@ export declare class EdgeCollider extends Collider {
     private scaledPosition;
     private finalRotation;
     private innerPosition;
-    constructor(config: EdgeColliderConfig);
+    constructor(gameObject: GameObject, name?: string);
+    protected config(config: EdgeColliderOptions): void;
     protected start(): void;
     protected update(): void;
     private updateSize;

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

@@ -1,7 +1,9 @@
 import { Collider } from "./Collider";
 import { Vector2 } from "../../math/Vector2";
 import { Rotation } from "../../math/Rotation";
-export interface PolygonColliderConfig {
+import { InitOptions } from "../../core/GameActor";
+import { GameObject } from "../../core/GameObject";
+export interface PolygonColliderOptions extends InitOptions {
     vertexModel: Vector2[];
     offsetX?: number;
     offsetY?: number;
@@ -11,8 +13,8 @@ export interface PolygonColliderConfig {
     debug?: boolean;
 }
 export declare class PolygonCollider extends Collider {
-    readonly debug: boolean;
-    readonly vertexModel: Vector2[];
+    debug: boolean;
+    vertexModel: Vector2[];
     offsetX: number;
     offsetY: number;
     rotation: Rotation;
@@ -21,7 +23,8 @@ export declare class PolygonCollider extends Collider {
     private scaledPosition;
     private finalRotation;
     private innerPosition;
-    constructor(config: PolygonColliderConfig);
+    constructor(gameObject: GameObject, name?: string);
+    protected init(config: PolygonColliderOptions): void;
     protected start(): void;
     protected update(): void;
     private updateSize;

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

@@ -1,6 +1,7 @@
 import { TilemapRenderer } from "../rendering/tilemap/TilemapRenderer";
 import { Collider } from "./Collider";
-export interface TilemapColliderConfig {
+import { InitOptions } from "../../core/GameActor";
+export interface TilemapColliderOptions extends InitOptions {
     tilemapRenderer: TilemapRenderer;
     layer?: string;
     debug?: boolean;
@@ -9,7 +10,7 @@ export declare class TilemapCollider extends Collider {
     private tilemapRenderer;
     private debug;
     private cacheVertex;
-    constructor(config: TilemapColliderConfig);
+    protected init(config: TilemapColliderOptions): void;
     protected start(): void;
     private needsCollider;
     protected update(): void;

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

@@ -1,7 +1,8 @@
 import { RenderComponent } from "../../core/Component";
 import { Rotation } from "../../math/Rotation";
 import { Vector2 } from "../../math/Vector2";
-export interface MaskRendererConfig {
+import { InitOptions } from "../../core/GameActor";
+export interface MaskRendererOptions extends InitOptions {
     width: number;
     height: number;
     color: string;
@@ -22,7 +23,7 @@ export declare class MaskRenderer extends RenderComponent {
     private renderData;
     private innerPosition;
     private scaledOffset;
-    constructor(config: MaskRendererConfig);
+    protected init(config: MaskRendererOptions): void;
     protected update(): void;
     private calculateRenderPosition;
     private translateRenderPosition;

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

@@ -2,7 +2,8 @@ import { RenderComponent } from "../../core/Component";
 import { Rotation } from "../../math/Rotation";
 import { Vector2 } from "../../math/Vector2";
 import { Sprite } from "../Sprite";
-export interface SpriteRendererConfig {
+import { InitOptions } from "../../core/GameActor";
+export interface SpriteRendererOptions extends InitOptions {
     sprite?: Sprite;
     offset?: Vector2;
     smooth?: boolean;
@@ -18,7 +19,7 @@ export interface SpriteRendererConfig {
 }
 export declare class SpriteRenderer extends RenderComponent {
     private renderManager;
-    sprite: Sprite;
+    sprite: Sprite | null;
     offset: Vector2;
     flipHorizontal: boolean;
     flipVertical: boolean;
@@ -26,16 +27,16 @@ export declare class SpriteRenderer extends RenderComponent {
     smooth: boolean;
     opacity: number;
     private _tiled;
-    maskColor: string;
+    maskColor: string | null;
     maskColorMix: number;
-    tintColor: string;
+    tintColor: string | null;
     layer: string;
     private renderData;
     private innerPosition;
     private cachePosition;
     private cacheRenderPosition;
     private scaledOffset;
-    constructor(config?: SpriteRendererConfig);
+    protected init(config?: SpriteRendererOptions): void;
     get tiled(): Vector2;
     set tiled(tiled: Vector2);
     protected update(): void;

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

@@ -2,7 +2,8 @@ import { RenderComponent } from "../../core/Component";
 import { Orientation } from "../../rendering/renderData/TextRenderData";
 import { Rotation } from "../../math/Rotation";
 import { Vector2 } from "../../math/Vector2";
-export interface TextRendererConfig {
+import { InitOptions } from "../../core/GameActor";
+export interface TextRendererOptions extends InitOptions {
     text: string;
     fontFamily: string;
     fontUrl?: string;
@@ -42,7 +43,7 @@ export declare class TextRenderer extends RenderComponent {
     private renderManager;
     private renderData;
     private lastFrameText;
-    constructor(config: TextRendererConfig);
+    protected init(config: TextRendererOptions): void;
     protected start(): void;
     protected update(): void;
     private crop;

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

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

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

@@ -1,10 +1,13 @@
 import { Vector2 } from "../../../math/Vector2";
 export declare class TileData {
-    private _position;
-    private _width;
-    private _height;
+    readonly position: Vector2;
+    readonly width: number;
+    readonly height: number;
+    private readonly halfWidth;
+    private readonly halfHeight;
     constructor(position: Vector2, width: number, height: number);
-    get position(): Vector2;
-    get width(): number;
-    get height(): number;
+    get x(): number;
+    get x1(): number;
+    get y(): number;
+    get y1(): number;
 }

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

@@ -1,14 +1,16 @@
-import { TilemapRenderer, TilemapRendererConfig } from "./TilemapRenderer";
-export interface TiledTilemapConfig extends TilemapRendererConfig {
+import { TilemapRenderer, TilemapRendererOptions } from "./TilemapRenderer";
+export interface TiledTilemapOptions extends TilemapRendererOptions {
     tilemapData: TiledTilemap;
     layerName?: string;
 }
 export declare class TiledTilemapRenderer extends TilemapRenderer {
-    readonly tiledTilemap: TiledTilemap;
-    readonly layerName: string;
-    constructor(config: TiledTilemapConfig);
+    tiledTilemap: TiledTilemap;
+    layerName: string;
+    private tilesetTileIds;
+    protected init(config: TiledTilemapOptions): void;
     protected processTilemap(): void;
     private processChunk;
+    private getTilesetTileId;
 }
 export interface TiledTilemap {
     width: number;
@@ -16,6 +18,9 @@ export interface TiledTilemap {
     infinite: boolean;
     layers: TiledLayer[];
     renderorder: string;
+    tilesets: {
+        firstgid: number;
+    }[];
 }
 export interface TiledChunk {
     data: number[];

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

@@ -5,6 +5,7 @@ import { Tileset } from "./Tileset";
 import { TileData } from "./TileData";
 import { Tile } from "./Tile";
 import { TilemapRenderData, TileRenderData } from "../../../rendering/renderData/TilemapRenderData";
+import { InitOptions } from "../../../core/GameActor";
 export declare type Flip = {
     h: boolean;
     v: boolean;
@@ -27,7 +28,7 @@ export declare type TileToProcess = {
     flip: Flip;
     offset: Offset;
 };
-export interface TilemapRendererConfig {
+export interface TilemapRendererOptions extends InitOptions {
     tileset: Tileset;
     renderOrder?: RenderOrder;
     smooth?: boolean;
@@ -35,11 +36,12 @@ export interface TilemapRendererConfig {
     tileScale?: Vector2;
 }
 export declare abstract class TilemapRenderer extends RenderComponent {
-    readonly tileset: Tileset;
-    readonly renderOrder: RenderOrder;
-    readonly smooth: boolean;
-    readonly textureCorrection: number;
-    readonly tileScale: Vector2;
+    readonly allowMultiple: boolean;
+    tileset: Tileset;
+    renderOrder: RenderOrder;
+    smooth: boolean;
+    textureCorrection: number;
+    tileScale: Vector2;
     protected tileWidth: number;
     protected tileHeight: number;
     protected orientation: Vector2;
@@ -54,7 +56,7 @@ export declare abstract class TilemapRenderer extends RenderComponent {
     protected _realWidth: number;
     protected _realHeight: number;
     private cacheV2;
-    constructor(config: TilemapRendererConfig);
+    protected init(config: TilemapRendererOptions): void;
     protected start(): void;
     protected update(): void;
     protected abstract processTilemap(): void;