angry-pixel 1.2.4 → 1.2.6

package/lib/component/Sprite.d.ts

@@ -1,50 +1,22 @@
+import { Vector2 } from "angry-pixel-math";
 import { Slice } from "angry-pixel-2d-renderer";
 export { Slice };
-/**
- * Sprite configuration options
- * @public
- */
 export interface SpriteConfig {
-    /** The image element to render */
     image: HTMLImageElement;
-    /** Cut the image based on straight coordinates starting from the top left downward */
+    scale?: Vector2;
     slice?: Slice;
-    /** Smoothing pixels (not recommended for pixel art) */
     smooth?: boolean;
 }
-/**
- * The Sprite is an object that is composed of the Image element and allow to slice it and smooth its pixels.
- *
- * @public
- * @example
- * ```js
- * const sprite = new Sprite({image: this.assetManager.getImage("image.png")});
- * ```
- *
- * @example
- * ```js
- * const sprite = new Sprite({
- *   image: this.assetManager.getImage("image.png"),
- *   slice: {x: 0, y:0, width: 16, height: 16},
- *   smooth: false
- * });
- * ```
- */
 export declare class Sprite {
-    /** The image element to render */
     readonly image: HTMLImageElement;
-    /** Cut the image based on straight coordinates starting from the top left downward */
     readonly slice: Slice;
-    /** Smoothing pixels (not recommended for pixel art) */
     readonly smooth: boolean;
+    scale?: Vector2;
     private _width;
     private _height;
     private _loaded;
     constructor(config: SpriteConfig);
-    /** The image width */
     get width(): number;
-    /** The image height */
     get height(): number;
-    /** TRUE if the image is loaded */
     get loaded(): boolean;
 }

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

@@ -1,6 +1,6 @@
 import { ColliderComponent, RenderComponent } from "../../core/Component";
 import { GameObject } from "../../core/GameObject";
-import { ICollisionResolution, ICollider } from "angry-pixel-2d-physics";
+import { ICollisionResolution, ICollider, ICollision } from "angry-pixel-2d-physics";
 /**
  * Information about the collision
  * @public
@@ -17,6 +17,8 @@ export interface CollisionData {
      * @return The object on the other side of the collision.
      */
     getGameObject: <T extends GameObject>() => T;
+    /** The collider belonging to the queried component */
+    localCollider: ICollider;
 }
 /**
  * Every collider component implements this interface.
@@ -74,7 +76,7 @@ export declare abstract class BaseCollider extends ColliderComponent implements
      * @returns The collection of collision data
      */
     getCollisionsWithLayer(layer: string): CollisionData[];
-    private createCollisionData;
+    protected createCollisionData(collision: ICollision): CollisionData;
     protected onActiveChange(): void;
     protected onDestroy(): void;
 }

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

@@ -26,7 +26,8 @@ export interface TilemapColliderOptions extends InitOptions {
     debug?: boolean;
 }
 /**
- * Generates rectanble colliders for the map edge tiles (or lines if composite is TRUE).
+ * Generates rectangle colliders for the map edge tiles (or lines if composite is TRUE).
+ * **Limitations:** At the moment, it is not possible to modify the shape, position, scale and rotation of the collider once it has been generated.
  * @public
  * @category Components
  * @example

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

@@ -34,8 +34,8 @@ export interface TiledTilemapRendererOptions {
     tilemapLayer: string;
     /** The Tileset instance */
     tileset: Tileset;
-    tileWidth: number;
-    tileHeight: number;
+    tileWidth?: number;
+    tileHeight?: number;
     /** The render layer */
     layer?: string;
     /** Direction in which the tilemap will be rendered. */
@@ -89,6 +89,7 @@ export interface TiledTilemapRendererOptions {
  * ```
  */
 export declare class TiledTilemapRenderer extends RenderComponent implements ITilemapRenderer {
+    private readonly spriteDefaultScale;
     /**
      * Id of tiles separated by commas. The ids start at 1, and increment from left to right,
      * from top to bottom. ID 0 (zero) represents a space with no tile.
@@ -126,7 +127,7 @@ export declare class TiledTilemapRenderer extends RenderComponent implements ITi
      */
     realHeight: number;
     private tiledData;
-    private tilemapLayer;
+    private tiledLayer;
     private tileset;
     private layer;
     private smooth?;

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

@@ -61,8 +61,8 @@ export interface TilemapRendererOptions {
     /** The Tileset instance */
     tileset: Tileset;
     width: number;
-    tileWidth: number;
-    tileHeight: number;
+    tileWidth?: number;
+    tileHeight?: number;
     /** The render layer */
     layer?: string;
     /** Direction in which the tilemap will be rendered. */
@@ -128,6 +128,7 @@ export interface ITilemapRenderer {
  * ```
  */
 export declare class TilemapRenderer extends RenderComponent implements ITilemapRenderer {
+    private readonly spriteDefaultScale;
     /** Id of tiles separated by commas. The ids start at 1, and increment from left to right,
      * from top to bottom. ID 0 (zero) represents a space with no tile.  */
     tiles: number[];

package/lib/core/Game.d.ts

@@ -66,10 +66,33 @@ 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, options?: InitOptions, openingScene?: boolean): void;
+    addScene(sceneClass: SceneClass, name: string): void;
+    /**
+     * Add a scene to the game
+     *
+     * @param sceneClass the class of the scene
+     * @param name The name of the scene
+     * @param options This options will be passed to the init method
+     */
+    addScene(sceneClass: SceneClass, name: string, options: InitOptions): void;
+    /**
+     * Add a scene to the game
+     *
+     * @param sceneClass the class of the scene
+     * @param name The name of the scene
+     * @param openingScene If this is the opening scene, set TRUE, FALSE instead
+     */
+    addScene(sceneClass: SceneClass, name: string, openingScene: boolean): void;
+    /**
+     * Add a scene to the game
+     *
+     * @param sceneClass the class of the scene
+     * @param name The name of the scene
+     * @param options This options will be passed to the init method
+     * @param openingScene If this is the opening scene, set TRUE, FALSE instead
+     */
+    addScene(sceneClass: SceneClass, name: string, options: InitOptions, openingScene: boolean): void;
     /**
      * Run the game
      */

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

@@ -100,6 +100,7 @@ export interface IGameObjectManager {
 export declare class GameObjectManager implements IGameObjectManager {
     private readonly container;
     private gameObjects;
+    private lastId;
     constructor(container: Container);
     addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, parent?: GameObject, name?: string): T;
     findGameObjects<T extends GameObject>(gameObjectClass?: GameObjectClass<T>): T[];

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

@@ -10,11 +10,14 @@ export declare class HeadlessIterationManager implements IIterationManager {
     private readonly gameObjectManager;
     private readonly sceneManager;
     running: boolean;
-    private currentScene;
+    private loadedScene;
     private gameObjects;
     private components;
     private gameInterval;
     private physicsInterval;
+    private changingScene;
+    private readonly sceneEvents;
+    private readonly gameObjectEvents;
     constructor(timeManager: ITimeManager, physicsManager: IPhysicsManager, gameObjectManager: IGameObjectManager, sceneManager: ISceneManager);
     start(): void;
     pause(): void;

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

@@ -40,10 +40,13 @@ export declare class IterationManager implements IIterationManager {
     private readonly canvasColor;
     running: boolean;
     private gameLoopAccumulator;
-    private currentScene;
+    private loadedScene;
     private gameObjects;
     private components;
     private physicsIntervalId;
+    private changingScene;
+    private readonly sceneEvents;
+    private readonly gameObjectEvents;
     constructor(timeManager: ITimeManager, physicsManager: IPhysicsManager, renderManager: IRenderManager, inputManager: IInputManager, gameObjectManager: IGameObjectManager, sceneManager: ISceneManager, canvasColor: string);
     start(): void;
     pause(): void;

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

@@ -9,14 +9,10 @@ import { Container } from "../../utils/Container";
  * @example
  * ```js
  * this.sceneManager.loadScene("MainScene");
+ * const loadedScene = this.sceneManager.getLoadedScene();
  * ```
  */
 export interface ISceneManager {
-    /**
-     * Retrieves the current loaded scene.
-     * @returns The scene instance.
-     */
-    getCurrentScene<T extends Scene>(): T;
     /**
      * Adds a new scene.
      * @param sceneClass The scene class .
@@ -25,19 +21,37 @@ export interface ISceneManager {
      * @param openingScene [optional] TRUE if it's the first scene to load.
      */
     addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
-    /** Loads the scene flagged as the opening scene. */
-    loadOpeningScene(): void;
     /**
      * Loads a Scene by the given name.
      * @param name The name of the Scene.
      */
     loadScene(name: string): void;
-    /** @private */
-    update(): void;
-    /** @private */
+    /**
+     * Retrieves the current loaded scene.
+     * @returns The scene instance.
+     */
+    getLoadedScene<T extends Scene>(): T;
+    /**
+     * Loads the scene flagged as the opening scene.
+     * @private
+     */
+    loadOpeningScene(): void;
+    /**
+     * Check if there is a pending scene change.
+     * @return TRUE if there is a pending scene to load, FALSE instead
+     * @private
+     */
+    pendingSceneToload(): boolean;
+    /**
+     * Loads the next pending scene.
+     * @private
+     */
+    loadPendingScene(): void;
+    /**
+     * Unloads the current loaded scene.
+     * @private
+     */
     unloadCurrentScene(): void;
-    /** @private */
-    stopGame(): void;
 }
 /** @private */
 export declare class SceneManager implements ISceneManager {
@@ -46,14 +60,34 @@ export declare class SceneManager implements ISceneManager {
     private scenes;
     private currentScene;
     private openingSceneName;
-    private sceneToLoad;
+    private sceneNamePendingToLoad;
     constructor(container: Container, renderManager?: IRenderManager);
-    getCurrentScene<T extends Scene>(): T;
+    /**
+     * @inheritdoc
+     */
     addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;
-    loadOpeningScene(): void;
+    /**
+     * @inheritdoc
+     */
     loadScene(name: string): void;
-    update(): void;
-    private _loadScene;
+    /**
+     * @inheritdoc
+     */
+    getLoadedScene<T extends Scene>(): T;
+    /**
+     * @inheritdoc
+     */
+    loadOpeningScene(): void;
+    /**
+     * @inheritdoc
+     */
+    pendingSceneToload(): boolean;
+    /**
+     * @inheritdoc
+     */
+    loadPendingScene(): void;
+    /**
+     * @inheritdoc
+     */
     unloadCurrentScene(): void;
-    stopGame(): void;
 }