angry-pixel 1.1.3 → 1.1.4

package/.vscode/settings.json

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

package/lib/component/Button.d.ts

@@ -1,6 +1,6 @@
 import { Component } from "../core/Component";
 import { InitOptions } from "../core/GameActor";
-import { Vector2 } from "../math/Vector2";
+import { Vector2 } from "angry-pixel-math";
 export declare enum ButtonType {
     Rectangle = 0,
     Circumference = 1

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

package/lib/core/facades/AssetManagerFacade.d.ts

@@ -16,6 +16,12 @@ export declare class AssetManagerFacade {
      * @returns The created audio element
      */
     static loadAudio(url: string): HTMLAudioElement;
+    /**
+     * @param family The family name of the font
+     * @param url The url of the font
+     * @returns The created fontFace element
+     */
+    static loadFont(family: string, url: string): FontFace;
     /**
      * @param url The url of the image element to find
      * @returns the found image element
@@ -26,4 +32,9 @@ export declare class AssetManagerFacade {
      * @returns The found audio element
      */
     static getAudio(url: string): HTMLAudioElement;
+    /**
+     * @param family The family of the font
+     * @returns The found audio element
+     */
+    static getFont(family: string): FontFace;
 }

package/lib/core/managers/AssetManager.d.ts

@@ -1,7 +1,7 @@
 export declare enum AssetType {
     Image = "Image",
     Audio = "Audio",
-    Video = "Video"
+    Font = "Font"
 }
 export interface IAssetManager {
     getAssetsLoaded(): boolean;
@@ -12,8 +12,9 @@ export declare class AssetManager {
     getAssetsLoaded(): boolean;
     loadImage(url: string): HTMLImageElement;
     loadAudio(url: string): HTMLAudioElement;
+    loadFont(family: string, url: string): FontFace;
     getImage(url: string): HTMLImageElement;
     getAudio(url: string): HTMLAudioElement;
-    getAsset<EType extends HTMLImageElement | HTMLVideoElement | HTMLAudioElement>(url: string, type?: AssetType | null): EType;
+    getFont(family: string): FontFace;
     private createAsset;
 }

package/lib/core/managers/IterationManager.d.ts

@@ -3,7 +3,7 @@ import { SceneManager } from "./SceneManager";
 import { InputManager } from "../../input/InputManager";
 import { CollisionManager } from "../../physics/collision/CollisionManager";
 import { RigidBodyManager } from "../../physics/rigodBody/RigidBodyManager";
-import { RenderManager } from "../../rendering/RenderManager";
+import { IRenderManager } from "angry-pixel-2d-renderer";
 import { TimeManager } from "./TimeManager";
 export declare enum FrameEvent {
     Init = 0,
@@ -33,12 +33,13 @@ export declare class IterationManager implements IIterationManager {
     private readonly inputManager;
     private readonly gameObjectManager;
     private readonly sceneManager;
+    private readonly canvasColor;
     running: boolean;
     private gameLoopAccumulator;
     private currentScene;
     private gameObjects;
     private components;
-    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, renderManager: RenderManager, inputManager: InputManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
+    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, renderManager: IRenderManager, inputManager: InputManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager, canvasColor: string);
     start(): void;
     pause(): void;
     resume(): void;

package/lib/core/managers/SceneManager.d.ts

@@ -1,6 +1,6 @@
 import { Game } from "../Game";
 import { Scene } from "../Scene";
-import { RenderManager } from "../../rendering/RenderManager";
+import { IRenderManager } from "angry-pixel-2d-renderer";
 import { InitOptions } from "../GameActor";
 export declare type SceneClass = new (name: string, game: Game) => Scene;
 export declare class SceneManager {
@@ -11,7 +11,7 @@ export declare class SceneManager {
     private openingSceneName;
     private sceneToLoad;
     currentSceneName: string;
-    constructor(game: Game, renderManager?: RenderManager);
+    constructor(game: Game, renderManager?: IRenderManager);
     getCurrentScene<T extends Scene>(): T;
     addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
     loadOpeningScene(): void;

package/lib/gameObject/GameCamera.d.ts

@@ -1,6 +1,6 @@
 import { GameObject } from "../core/GameObject";
 import { Camera } from "../component/Camera";
-import { Rectangle } from "../math/Rectangle";
+import { Rectangle } from "angry-pixel-math";
 export declare class GameCamera extends GameObject {
     camera: Camera;
     protected init(): void;
@@ -10,7 +10,6 @@ export declare class GameCamera extends GameObject {
     get depth(): number;
     set zoom(zoom: number);
     get zoom(): number;
-    get originalViewporRect(): Rectangle;
     get worldSpaceRect(): Rectangle;
     get viewportRect(): Rectangle;
     addLayer(layer: string): void;