angry-pixel 1.1.1 → 1.1.2

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,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,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/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;
@@ -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

@@ -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/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;

package/lib/core/Component.d.ts

@@ -1,130 +1,85 @@
-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;
+import { GameActor } from "./GameActor";
+export declare type ComponentClass<T extends Component = Component> = new (gameObject: GameObject, name?: string) => T;
+export declare abstract class Component extends GameActor {
+    private readonly sceneManager;
     readonly id: string;
-    type: string;
-    name: string;
-    gameObject: GameObject;
-    allowMultiple: boolean;
+    readonly name: string;
+    readonly gameObject: GameObject;
+    readonly allowMultiple: boolean;
     private _active;
-    private started;
-    protected get updateEvent(): FrameEvent;
+    constructor(gameObject: GameObject, name?: string);
     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;
+    set active(active: boolean);
     /**
      * This method is called when the active state changes.
      */
-    protected activeStateChange(): void;
+    protected onActiveChange(): 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
+     * @returns The GameObject to which this component is attached
      */
-    protected getComponentByType<T extends Component>(type: string): T;
+    protected getGameObject<T extends GameObject>(): T;
     /**
-     * @param type The type of the components to find
+     * Returns all the components in the game object.
      * @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;
+    getComponents(): Component[];
     /**
-     * @param tag The tag of the game objects to find
-     * @returns The found game objects
+     * Returns all the components for the given class in the game object.
+     * @param componentClass The class of the components
+     * @returns The found components
      */
-    protected findGameObjectsByTag(tag: string): GameObject[];
+    getComponents<T extends Component>(componentClass: ComponentClass<T>): T[];
     /**
-     * @param tag The tag of the game object to find
-     * @returns The found game object
+     * Returns the first component found for the given class, or undefined otherwise.
+     * @param componentClass The class of the component
+     * @returns The found component
      */
-    protected findGameObjectByTag<T extends GameObject>(tag: string): T;
+    getComponent<T extends Component>(componentClass: ComponentClass<T>): T;
     /**
-     * Destroy one game objects by its name
-     * @param name The name of the game object
+     * Returns the first component found for the given name, or undefined otherwise.
+     * @param name The name of the component
+     * @returns The found component
      */
-    protected destroyGameObjectByName(name: string): void;
+    getComponent<T extends Component>(name: string): T;
     /**
-     * Destroy the game objects
-     * @param gameObject The game object to destory
+     * Returns TRUE if the game object has a component for the given class, or FALSE otherwise
+     * @param componentClass The class of the component to find
+     * @returns boolean
      */
-    protected destroyGameObject(gameObject: GameObject): void;
+    hasComponent<T extends Component>(componentClass: ComponentClass<T>): boolean;
     /**
      * @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
+     * @returns boolean
      */
-    removeComponentByType(type: string): void;
-    private _destroy;
+    hasComponent(name: string): boolean;
+    removeComponent(component: Component): void;
+    protected _destroy(): void;
 }
 export declare abstract class EngineComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class ColliderComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class PhysicsComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class TransformComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class PreRenderComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class CameraComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }
 export declare abstract class RenderComponent extends Component {
-    protected get updateEvent(): FrameEvent;
+    protected readonly updateEvent: FrameEvent;
 }