angry-pixel 1.1.2 → 1.1.4

package/.vscode/settings.json

@@ -0,0 +1,2 @@
+{
+}

package/lib/component/Animator.d.ts

@@ -10,10 +10,13 @@ export declare class Animator extends EngineComponent {
     private spriteRenderer;
     private animations;
     private currentAnimation;
+    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/Button.d.ts

@@ -0,0 +1,42 @@
+import { Component } from "../core/Component";
+import { InitOptions } from "../core/GameActor";
+import { Vector2 } from "angry-pixel-math";
+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,28 +1,20 @@
 import { CameraComponent } from "../core/Component";
-import { Rectangle } from "../math/Rectangle";
+import { Rectangle } from "angry-pixel-math";
 export declare class Camera extends CameraComponent {
     readonly allowMultiple: boolean;
     private renderManager;
-    private _layers;
-    private _depth;
-    private _zoom;
-    private _originalViewportRect;
-    private _viewportRect;
-    private _worldSpaceRect;
     private canvas;
+    readonly viewportRect: Rectangle;
+    readonly worldSpaceRect: Rectangle;
+    depth: number;
+    layers: string[];
+    private _zoom;
     private cameraData;
-    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 init(): void;
     protected update(): void;
-    private updateOriginalViewportRect;
     private updateViewportRect;
     private updateWorldSpaceRect;
     private updateCameraData;

package/lib/component/RigidBody.d.ts

@@ -1,5 +1,5 @@
 import { EngineComponent } from "../core/Component";
-import { Vector2 } from "../math/Vector2";
+import { Vector2 } from "angry-pixel-math";
 import { RigidBodyType } from "../physics/rigodBody/RigidBodyManager";
 import { InitOptions } from "../core/GameActor";
 export { RigidBodyType } from "../physics/rigodBody/RigidBodyManager";

package/lib/component/Sprite.d.ts

@@ -1,31 +1,22 @@
-import { Vector2 } from "../math/Vector2";
+import { Vector2 } from "angry-pixel-math";
+import { Slice } from "angry-pixel-2d-renderer";
+export { Slice };
 export interface SpriteConfig {
     image: HTMLImageElement;
     scale?: Vector2;
-    slice?: Slice | null;
+    slice?: Slice;
     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;
+    readonly image: HTMLImageElement;
+    readonly slice: Slice;
+    readonly scale: Vector2;
+    readonly smooth: boolean;
     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;
+    get loaded(): boolean;
 }

package/lib/component/Transform.d.ts

@@ -1,6 +1,5 @@
 import { TransformComponent } from "../core/Component";
-import { Rotation } from "../math/Rotation";
-import { Vector2 } from "../math/Vector2";
+import { Rotation, Vector2 } from "angry-pixel-math";
 export declare class Transform extends TransformComponent {
     readonly allowMultiple: boolean;
     parentScale: boolean;
@@ -23,8 +22,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 setParent;
     private setPositionFromParent;
     private translateInnerPosition;
     private updateScaledInnerPosition;

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

@@ -1,6 +1,6 @@
 import { Collider } from "./Collider";
-import { Rotation } from "../../math/Rotation";
 import { InitOptions } from "../../core/GameActor";
+import { Rotation } from "angry-pixel-math";
 export interface BoxColliderOptions extends InitOptions {
     width: number;
     height: number;

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

@@ -1,8 +1,7 @@
 import { Collider } from "./Collider";
-import { Vector2 } from "../../math/Vector2";
-import { Rotation } from "../../math/Rotation";
 import { GameObject } from "../../core/GameObject";
 import { InitOptions } from "../../core/GameActor";
+import { Vector2, Rotation } from "angry-pixel-math";
 export interface EdgeColliderOptions extends InitOptions {
     vertexModel: Vector2[];
     offsetX?: number;
@@ -24,7 +23,7 @@ export declare class EdgeCollider extends Collider {
     private finalRotation;
     private innerPosition;
     constructor(gameObject: GameObject, name?: string);
-    protected config(config: EdgeColliderOptions): void;
+    protected init(config: EdgeColliderOptions): void;
     protected start(): void;
     protected update(): void;
     private updateSize;

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

@@ -1,8 +1,9 @@
 import { Collider } from "./Collider";
-import { Vector2 } from "../../math/Vector2";
-import { Rotation } from "../../math/Rotation";
+import { ColliderData } from "../../physics/collision/ColliderData";
+import { RenderComponent } from "../../core/Component";
 import { InitOptions } from "../../core/GameActor";
 import { GameObject } from "../../core/GameObject";
+import { Vector2, Rotation } from "angry-pixel-math";
 export interface PolygonColliderOptions extends InitOptions {
     vertexModel: Vector2[];
     offsetX?: number;
@@ -32,3 +33,12 @@ export declare class PolygonCollider extends Collider {
     private translate;
     private updateShape;
 }
+export declare class PolygonColliderRenderer extends RenderComponent {
+    private renderManager;
+    private renderData;
+    private collider;
+    protected init({ collider }: {
+        collider: ColliderData;
+    }): void;
+    protected update(): void;
+}

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

@@ -1,17 +1,28 @@
-import { TilemapRenderer } from "../rendering/tilemap/TilemapRenderer";
+import { ITilemapRenderer } from "../rendering/TilemapRenderer";
 import { Collider } from "./Collider";
 import { InitOptions } from "../../core/GameActor";
 export interface TilemapColliderOptions extends InitOptions {
-    tilemapRenderer: TilemapRenderer;
+    tilemapRenderer: ITilemapRenderer;
+    composite?: boolean;
     layer?: string;
     debug?: boolean;
 }
 export declare class TilemapCollider extends Collider {
     private tilemapRenderer;
     private debug;
-    private cacheVertex;
+    private composite;
+    private scaledWidth;
+    private scaledHeight;
+    private scaledTileWidth;
+    private scaledTileHeight;
+    private position;
     protected init(config: TilemapColliderOptions): void;
     protected start(): void;
+    private useBoxColliders;
+    private useLineColliders;
+    private hasTile;
+    private addLineCollider;
     private needsCollider;
+    private getNeighbors;
     protected update(): void;
 }

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

@@ -1,8 +1,6 @@
 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 {
+import { Vector2, Rotation } from "angry-pixel-math";
+export interface MaskRendererOptions {
     width: number;
     height: number;
     color: string;

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

@@ -1,12 +1,9 @@
 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 {
+import { Rotation, Vector2 } from "angry-pixel-math";
+export interface SpriteRendererOptions {
     sprite?: Sprite;
     offset?: Vector2;
-    smooth?: boolean;
     rotation?: Rotation;
     flipHorizontal?: boolean;
     flipVertical?: boolean;
@@ -19,17 +16,16 @@ export interface SpriteRendererOptions extends InitOptions {
 }
 export declare class SpriteRenderer extends RenderComponent {
     private renderManager;
-    sprite: Sprite | null;
+    sprite: Sprite;
     offset: Vector2;
     flipHorizontal: boolean;
     flipVertical: boolean;
     rotation: Rotation;
-    smooth: boolean;
     opacity: number;
     private _tiled;
-    maskColor: string | null;
+    maskColor: string;
     maskColorMix: number;
-    tintColor: string | null;
+    tintColor: string;
     layer: string;
     private renderData;
     private innerPosition;

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

@@ -1,12 +1,10 @@
 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 {
+import { Rotation, Vector2 } from "angry-pixel-math";
+import { TextOrientation } from "angry-pixel-2d-renderer";
+export { TextOrientation };
+export interface TextRendererOptions {
     text: string;
-    fontFamily: string;
-    fontUrl?: string;
+    font: FontFace | string;
     fontSize?: number;
     color?: string;
     lineSeparation?: number;
@@ -14,18 +12,17 @@ export interface TextRendererOptions extends InitOptions {
     width?: number;
     height?: number;
     offset?: Vector2;
-    smooth?: boolean;
     charRanges?: number[];
-    bitmapSize?: number;
-    bitmapOffset?: Vector2;
+    smooth?: boolean;
     rotation?: Rotation;
     opacity?: number;
-    orientation?: Orientation;
+    orientation?: TextOrientation;
+    bitmapMargin?: Vector2;
+    bitmapSpacing?: Vector2;
 }
 export declare class TextRenderer extends RenderComponent {
     text: string;
-    fontFamily: string;
-    fontUrl: string;
+    font: FontFace | string;
     fontSize: number;
     width: number;
     height: number;
@@ -33,13 +30,13 @@ export declare class TextRenderer extends RenderComponent {
     color: string;
     lineSeparation: number;
     letterSpacing: number;
-    bitmapSize: number;
     charRanges: number[];
     smooth: boolean;
-    bitmapOffset: Vector2;
     rotation: Rotation;
     opacity: number;
-    orientation: Orientation;
+    orientation: TextOrientation;
+    bitmapMargin: Vector2;
+    bitmapSpacing: Vector2;
     private renderManager;
     private renderData;
     private lastFrameText;

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

@@ -0,0 +1,78 @@
+import { RenderComponent } from "../../core/Component";
+import { ITilemapRenderer, Tileset, TilemapOrientation } from "./TilemapRenderer";
+export interface TiledTilemapRendererOptions {
+    tiledData: TiledTilemap;
+    tilemapLayer: string;
+    tileset: Tileset;
+    tileWidth: number;
+    tileHeight: number;
+    layer?: string;
+    orientation?: TilemapOrientation;
+    smooth?: boolean;
+}
+export declare class TiledTilemapRenderer extends RenderComponent implements ITilemapRenderer {
+    private renderManager;
+    tiles: number[];
+    tileWidth: number;
+    tileHeight: number;
+    width: number;
+    height: number;
+    orientation: TilemapOrientation;
+    tintColor: string;
+    alpha: number;
+    private tiledData;
+    private tilemapLayer;
+    private tileset;
+    private layer;
+    private smooth?;
+    private tilesetTileIds;
+    private chunks;
+    private scaledTileWidth;
+    private scaledTileHeight;
+    realWidth: number;
+    realHeight: number;
+    private renderData;
+    protected init({ tiledData, tilemapLayer, tileset, tileWidth, tileHeight, layer, orientation, smooth, }: TiledTilemapRendererOptions): void;
+    protected update(): void;
+    private processTilemap;
+    private processChunk;
+    private getTilesetTileId;
+    private updateRenderData;
+}
+export interface TiledTilemap {
+    width: number;
+    height: number;
+    infinite: boolean;
+    layers: TiledLayer[];
+    renderorder: string;
+    tilesets: {
+        firstgid: number;
+    }[];
+    tilewidth: number;
+    tileheight: 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;
+    type: string;
+    width: number;
+    height: number;
+    opacity: number;
+    visible: boolean;
+    startx?: number;
+    starty?: number;
+    offsetx?: number;
+    offsety?: number;
+    tintcolor?: string;
+}

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

@@ -0,0 +1,55 @@
+import { TilemapOrientation } from "angry-pixel-2d-renderer";
+import { Vector2 } from "angry-pixel-math";
+import { RenderComponent } from "../../core/Component";
+export { TilemapOrientation };
+export interface Tileset {
+    image: HTMLImageElement;
+    width: number;
+    tileWidth: number;
+    tileHeight: number;
+    margin?: Vector2;
+    spacing?: Vector2;
+}
+export interface TilemapRendererOptions {
+    tiles: string;
+    tileset: Tileset;
+    width: number;
+    tileWidth: number;
+    tileHeight: number;
+    layer?: string;
+    orientation?: TilemapOrientation;
+    alpha?: number;
+    tintColor?: string;
+    smooth?: boolean;
+}
+export interface ITilemapRenderer {
+    tiles: number[];
+    width: number;
+    height: number;
+    tileWidth: number;
+    tileHeight: number;
+    orientation: TilemapOrientation;
+    realWidth: number;
+    realHeight: number;
+}
+export declare class TilemapRenderer extends RenderComponent implements ITilemapRenderer {
+    private renderManager;
+    tiles: number[];
+    width: number;
+    height: number;
+    tileWidth: number;
+    tileHeight: number;
+    tintColor: string;
+    alpha: number;
+    orientation: TilemapOrientation;
+    private tileset;
+    private renderData;
+    private layer;
+    private scaledTileWidth;
+    private scaledTileHeight;
+    realWidth: number;
+    realHeight: number;
+    protected init({ tiles, tileset, tileWidth, tileHeight, width, layer, orientation, alpha, tintColor, smooth, }: TilemapRendererOptions): void;
+    protected update(): void;
+    private updateRenderData;
+}

package/lib/core/Game.d.ts

@@ -1,17 +1,18 @@
 import { SceneClass } from "../core/managers/SceneManager";
 import { Container } from "../utils/Container";
-import { Rectangle } from "../math/Rectangle";
-import { Vector2 } from "../math/Vector2";
+import { Rectangle, Vector2 } from "angry-pixel-math";
 import { CollisionMatrix } from "../physics/collision/CollisionManager";
+import { InitOptions } from "./GameActor";
 export declare const container: Container;
 export interface GameConfig {
-    containerNode: HTMLElement | null;
+    containerNode?: HTMLElement | null;
     gameWidth?: number;
     gameHeight?: number;
     debugEnabled?: boolean;
     canvasColor?: string;
     physicsFramerate?: number;
     spriteDefaultScale?: Vector2 | null;
+    headless?: boolean;
     collisions?: {
         method?: CollisionMethodConfig;
         quadTreeBounds?: Rectangle | null;
@@ -43,9 +44,10 @@ export declare class Game {
      *
      * @param sceneClass the class of the scene
      * @param name The name of the scene
+     * @param options [optional] This options will be passed to the init method
      * @param openingScene [default FALSE] If this is the opening scene, set TRUE, FALSE instead
      */
-    addScene(sceneClass: SceneClass, name: string, openingScene?: boolean): void;
+    addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
     /**
      * Run the game
      */

package/lib/core/GameActor.d.ts

@@ -2,7 +2,7 @@ import { GameObject, GameObjectClass } from "./GameObject";
 import { GameObjectManager } from "./managers/GameObjectManager";
 import { FrameEvent } from "./managers/IterationManager";
 export interface InitOptions {
-    [key: string]: unknown;
+    [key: string]: any;
 }
 export declare abstract class GameActor {
     protected readonly gameObjectManager: GameObjectManager;
@@ -25,6 +25,29 @@ export declare abstract class GameActor {
      * This method is called before destruction.
      */
     protected onDestroy?(): void;
+    /**
+     * Adds a new game object to the scene.
+     * @param gameObjectClass The game object class
+     * @returns The added game object
+     * @returns
+     */
+    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
+    /**
+     * Adds a new game object to the scene.
+     * @param gameObjectClass The game object class
+     * @param name The name of the game object
+     * @returns The added game object
+     * @returns
+     */
+    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, name: string): T;
+    /**
+     * Adds a new game object to the scene.
+     * @param gameObjectClass The game object class
+     * @param options This options will be passed to the init method
+     * @returns The added game object
+     * @returns
+     */
+    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options: InitOptions): T;
     /**
      * Adds a new game object to the scene.
      * @param gameObjectClass The game object class
@@ -33,24 +56,30 @@ export declare abstract class GameActor {
      * @returns The added game object
      * @returns
      */
-    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, name?: string): T;
+    protected addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions | string, name?: string): T;
     /**
      * Returns all the game objects in the scene.
      * @returns The found game objects
      */
     protected findGameObjects(): GameObject[];
+    /**
+     * Returns a collection of found game objects for the given class
+     * @param gameObjectClass The game object class to find
+     * @returns The found game objects
+     */
+    protected findGameObjects<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T[];
     /**
      * Returns the first game object found for the given class, or undefined otherwise.
      * @param gameObjectClass The game object class to find
      * @returns The found game object
      */
-    findGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
+    protected findGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>): T;
     /**
      * Returns the first game object found for the given name, or undefined otherwise.
      * @param name The name of the game object to find
      * @returns The found game object
      */
-    findGameObject<T extends GameObject>(name: string): T;
+    protected findGameObject<T extends GameObject>(name: string): T;
     /**
      * Returns a collection of game objects found for the given tag
      * @param tag The tag of the game objects to find

package/lib/core/GameObject.d.ts

@@ -12,7 +12,7 @@ export declare class GameObject extends GameActor {
     layer: string;
     ui: boolean;
     keep: boolean;
-    parent: GameObject | null;
+    private _parent;
     private _active;
     private sceneManager;
     private components;
@@ -21,6 +21,8 @@ export declare class GameObject extends GameActor {
     constructor(name?: string, parent?: GameObject);
     get active(): boolean;
     set active(active: boolean);
+    get parent(): GameObject | null;
+    set parent(parent: GameObject | null);
     private updateComponentsActiveStatus;
     private updateChildrenActiveStatus;
     get transform(): Transform;
@@ -36,11 +38,31 @@ export declare class GameObject extends GameActor {
     /**
      * Add a component to the game obejct
      * @param componentClass The class of the component
-     * @param options [optional] The options passed to the init method of the component
-     * @param name [optional] The name of the component
      * @returns The added component
      */
-    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options?: OptionsType, name?: string): ComponentType;
+    addComponent<ComponentType extends Component = Component>(componentClass: ComponentClass<ComponentType>): ComponentType;
+    /**
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @param options The options passed to the init method of the component
+     * @returns The added component
+     */
+    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options: OptionsType): ComponentType;
+    /**
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @param name The name of the component
+     * @returns The added component
+     */
+    addComponent<ComponentType extends Component = Component>(componentClass: ComponentClass<ComponentType>, name: string): ComponentType;
+    /**
+     * Add a component to the game obejct
+     * @param componentClass The class of the component
+     * @param options The options passed to the init method of the component
+     * @param name The name of the component
+     * @returns The added component
+     */
+    addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options: OptionsType, name: string): ComponentType;
     private checkMultipleComponent;
     /**
      * Returns all the components in the game object.