angry-pixel 1.2.2 → 1.2.4

package/lib/core/GameObject.d.ts

@@ -4,28 +4,87 @@ import { RigidBody } from "../component/RigidBody";
 import { Scene } from "./Scene";
 import { GameActor, InitOptions } from "./GameActor";
 import { Container } from "../utils/Container";
+/** @private */
 export declare const LAYER_DEFAULT = "Default";
+/** @private */
 export type GameObjectClass<T extends GameObject = GameObject> = new (container: Container, id: number, name?: string, parent?: GameObject) => T;
+/**
+ * Base class for all objects in the scene.
+ * @public
+ * @category Core
+ * @example
+ * ```js
+ * class Player extends GameObject {
+ *   init(options) {
+ *     this.tag = "Tag";
+ *     this.layer = "Default";
+ *   }
+ *   start() {
+ *     // executed in the first available frame
+ *   }
+ *   update() {
+ *     // executed on every frame
+ *   }
+ * }
+ * ```
+ * @example
+ * ```ts
+ * class Player extends GameObject {
+ *   protected init(options?: InitOptions): void {
+ *     this.tag = "Tag";
+ *     this.layer = "Default";
+ *   }
+ *   protected start(): void {
+ *     // executed in the first available frame
+ *   }
+ *   protected update(): void {
+ *     // executed on every frame
+ *   }
+ * }
+ * ```
+ */
 export declare class GameObject extends GameActor {
+    /** Id automatically assigned at the time of instantiation. */
     readonly id: number;
+    /** Name given manually at the time of instantiation. */
     readonly name: string;
+    /** Tag used to group objects and optimize their retrieval. */
     tag: string;
+    /** Layer used for rendering and physics. Default value is "Default". */
     layer: string;
+    /** TRUE for UI objects. Default value is FALSE. Renders the object outside the game world coordinates. */
     ui: boolean;
+    /** TRUE to prevent the object from being automatically destroyed when changing the scene. Default value is FALSE. */
     keep: boolean;
+    /** @private */
     private _parent;
+    /** @private */
     private _active;
+    /** @private */
     private components;
+    /** @private */
     private activeComponentsCache;
+    /** @private */
     private activeChildrenCache;
+    /** @private */
     constructor(container: Container, id: number, name?: string, parent?: GameObject);
+    /** TRUE for enabled object, FALSE for disabled object. */
     get active(): boolean;
+    /** TRUE for enabled object, FALSE for disabled object. */
     set active(active: boolean);
+    /** Parent game object. A child object depends on the parent's Transform. */
     get parent(): GameObject | null;
+    /** Parent game object. A child object depends on the parent's Transform. */
     set parent(parent: GameObject | null);
+    /** @private */
     private updateComponentsActiveStatus;
+    /** @private */
     private updateChildrenActiveStatus;
+    /**
+     * Transform component added natively in the object
+     */
     get transform(): Transform;
+    /** RigidBody Component (if any) */
     get rigidBody(): RigidBody;
     /**
      * This method is called when the active state changes.
@@ -63,6 +122,7 @@ export declare class GameObject extends GameActor {
      * @returns The added component
      */
     addComponent<ComponentType extends Component = Component, OptionsType extends InitOptions = InitOptions>(componentClass: ComponentClass<ComponentType>, options: OptionsType, name: string): ComponentType;
+    /** @private */
     private checkMultipleComponent;
     /**
      * Returns all the components in the game object.
@@ -127,7 +187,10 @@ export declare class GameObject extends GameActor {
      * Destroy all the children game objects
      */
     destroyChildren(): void;
+    /** @private */
     protected _destroy(): void;
+    /** @private */
     private destroyComponents;
+    /** @private */
     protected _stopGame(): void;
 }

package/lib/core/Scene.d.ts

@@ -2,12 +2,44 @@ import { GameCamera } from "../gameObject/GameCamera";
 import { Container } from "../utils/Container";
 import { Game } from "./Game";
 import { GameActor } from "./GameActor";
+/** @private */
 export type SceneClass = new (container: Container, name: string, game: Game) => Scene;
+/**
+ * Base class for all game scenes
+ * @public
+ * @category Core
+ * @example
+ * ```js
+ * class GameScene extends Scene {
+ *   init(options) {
+ *     this.addGameObject(Player);
+ *   }
+ *   start() {}
+ *   update() {}
+ * }
+ * ```
+ * @example
+ * ```ts
+ * class GameScene extends Scene {
+ *   protected init(options?: InitOptions): void {
+ *     this.addGameObject(Player);
+ *   }
+ *   protected start(): void {}
+ *   protected update(): void {}
+ * }
+ * ```
+ */
 export declare class Scene extends GameActor {
     readonly name: string;
     readonly game: Game;
+    /** @private */
     constructor(container: Container, name: string, game: Game);
+    /**
+     * The main active camera
+     */
     get gameCamera(): GameCamera;
+    /** @private */
     protected _destroy(): void;
+    /** @private */
     protected _stopGame(): void;
 }

package/lib/core/ioc/Config.d.ts

@@ -1,3 +1,4 @@
-import { Container } from "../../utils/Container";
 import { GameConfig } from "../GameConfig";
+import { Container } from "../../utils/Container";
+/** @private */
 export declare const loadDependencies: (container: Container, gameConfig: GameConfig) => void;

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

@@ -1,21 +1,83 @@
 import { IRenderManager } from "angry-pixel-2d-renderer";
-export declare enum AssetType {
-    Image = "Image",
-    Audio = "Audio",
-    Font = "Font",
-    Video = "Video"
-}
+/**
+ * Manages the asset loading (images, fonts, audios, videos).
+ * @public
+ * @category Managers
+ * @example
+ * ```js
+ * this.assetManager.loadImage("image.png");
+ * this.assetManager.loadAudio("audio.ogg");
+ * this.assetManager.loadVideo("video.mp4");
+ * this.assetManager.loadFont("custom-font", "custom-font.ttf");
+ *
+ * const imageElement = this.assetManager.getImage("image.png");
+ * const audioElement = this.assetManager.getAudio("audio.ogg");
+ * const videoElement = this.assetManager.getVideo("video.mp4");
+ * const fontFace = this.assetManager.getFont("custom-font");
+ *
+ * if (this.assetManager.getAssetsLoaded()) {
+ *   // do something when assets are loaded
+ * }
+ * ```
+ */
 export interface IAssetManager {
+    /**
+     * Returns TRUE if the assets are loaded
+     * @returns TRUE or FALSE
+     */
     getAssetsLoaded(): boolean;
+    /**
+     * Loads an image asset
+     * @param url The asset URL
+     * @param preloadTexture Creates the texture to be rendered at load time [optional]
+     * @returns The HTML Image element created
+     */
     loadImage(url: string, preloadTexture?: boolean): HTMLImageElement;
+    /**
+     * Loads an audio asset
+     * @param url The asset URL
+     * @returns The HTML Audio element created
+     */
     loadAudio(url: string): HTMLAudioElement;
+    /**
+     * Loads a font asset
+     * @param family The font family name
+     * @param url The asset URL
+     * @returns The FontFace object created
+     */
     loadFont(family: string, url: string): FontFace;
+    /**
+     * Loads an video asset
+     * @param url The asset URL
+     * @returns The HTML Video element created
+     */
     loadVideo(url: string): HTMLVideoElement;
+    /**
+     * Retrieves an image asset
+     * @param url The asset URL
+     * @returns The HTML Image element
+     */
     getImage(url: string): HTMLImageElement;
+    /**
+     * Retrieves an audio asset
+     * @param url The asset URL
+     * @returns The HTML Audio element
+     */
     getAudio(url: string): HTMLAudioElement;
+    /**
+     * Retrieves a font asset
+     * @param url The asset URL
+     * @returns The Font element
+     */
     getFont(family: string): FontFace;
+    /**
+     * Retrieves a video asset
+     * @param url The asset URL
+     * @returns The HTML Video element
+     */
     getVideo(url: string): HTMLVideoElement;
 }
+/** @private */
 export declare class AssetManager implements IAssetManager {
     private readonly renderManager;
     private readonly assets;

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

@@ -1,6 +1,17 @@
+/**
+ * Manages the canvas element
+ * @public
+ * @category Managers
+ * @example
+ * ```js
+ * const canvasElement = this.domManager.canvas;
+ * ```
+ */
 export interface IDomManager {
+    /** The canvas element where the game is rendered */
     canvas: HTMLCanvasElement;
 }
+/** @private */
 export declare class DomManager implements IDomManager {
     private gameWidth;
     private gameHeight;

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

@@ -1,21 +1,102 @@
 import { GameObject, GameObjectClass } from "../GameObject";
 import { InitOptions } from "../GameActor";
 import { Container } from "../../utils/Container";
+/**
+ * Used to create, retrieve and destroy GameObject instances.
+ * @public
+ * @category Managers
+ * @example
+ * ```js
+ * // create a new game object instance
+ * this.gameObjectManager.addGameObject(Player);
+ *
+ * // find a game object by its class
+ * const player = this.gameObjectManager.findGameObject(Player);
+ *
+ * // find game objects by their class
+ * const coins = this.gameObjectManager.findGameObjects(Coin);
+ *
+ * // find game objects by their tag
+ * const enemies = this.gameObjectManager.findGameObjectsByTag("Enemy");
+ *
+ * // destroy a game object
+ * this.gameObjectManager.destroyGameObject(player);
+ * ```
+ */
 export interface IGameObjectManager {
+    /**
+     * Instantiates a new game object.
+     * @param gameObjectClass The game object class.
+     * @param options [optional] Options for the Init method.
+     * @param parent [optional] The parent game object.
+     * @param name [optional] The name associated to the game object.
+     * @returns The game object instance.
+     */
     addGameObject<T extends GameObject>(gameObjectClass: GameObjectClass<T>, options?: InitOptions, parent?: GameObject, name?: string): T;
+    /**
+     * Returns a collection of found game objects for the given class, or all the game objects if there is no class.
+     * @param gameObjectClass [optional] The game object class to find.
+     * @returns The found game objects.
+     */
     findGameObjects<T extends GameObject>(gameObjectClass?: GameObjectClass<T>): T[];
+    /**
+     * Returns the first game object found for the given id, or undefined otherwise.
+     * @param id The game object id to find.
+     * @returns The found game object.
+     */
     findGameObjectById<T extends GameObject>(id: number): 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;
+    /**
+     * 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;
     findGameObject<T extends GameObject>(filter: GameObjectClass<T> | string): T;
+    /**
+     * Returns a collection of children game objects for the given parent object.
+     * @param parent The parent game object.
+     * @returns The found game objects.
+     */
     findGameObjectsByParent<T extends GameObject>(parent: GameObject): T[];
+    /**
+     * Returns the first child game object for the given parent object and filtered by the given game object class.
+     * @param parent The parent game object.
+     * @param gameObjectClass The game object class to find.
+     * @returns The found game object.
+     */
     findGameObjectByParent<T extends GameObject>(parent: GameObject, gameObjectClass: GameObjectClass<T>): T;
+    /**
+     * Returns the first child game object for the given parent object and filtered by the given name.
+     * @param parent The parent game object.
+     * @param name The name of the game object to find.
+     * @returns The found game object.
+     */
     findGameObjectByParent<T extends GameObject>(parent: GameObject, name: string): T;
     findGameObjectByParent<T extends GameObject>(parent: GameObject, filter: GameObjectClass<T> | string): T;
+    /**
+     * Returns a collection of game objects found for the given tag.
+     * @param tag The tag of the game objects to find.
+     * @returns The found game objects.
+     */
     findGameObjectsByTag<T extends GameObject>(tag: string): T[];
+    /**
+     * Destroy all game objets.
+     * @param ignoreKeep [optional] If TRUE, it also destroys objects with the "keep" property set to TRUE.
+     */
     destroyAllGameObjects(ignoreKeep?: boolean): void;
+    /**
+     * Destroy the given game object.
+     * @param gameObject The game object to destory.
+     */
     destroyGameObject(gameObject: GameObject): void;
 }
+/** @private */
 export declare class GameObjectManager implements IGameObjectManager {
     private readonly container;
     private gameObjects;

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

@@ -3,6 +3,7 @@ import { ISceneManager } from "./SceneManager";
 import { ITimeManager } from "./TimeManager";
 import { IIterationManager } from "./IterationManager";
 import { IPhysicsManager } from "angry-pixel-2d-physics";
+/** @private */
 export declare class HeadlessIterationManager implements IIterationManager {
     private readonly timeManager;
     private readonly physicsManager;

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

@@ -4,6 +4,7 @@ import { IInputManager } from "../../input/InputManager";
 import { IRenderManager } from "angry-pixel-2d-renderer";
 import { ITimeManager } from "./TimeManager";
 import { IPhysicsManager } from "angry-pixel-2d-physics";
+/** @private */
 export declare enum FrameEvent {
     Init = 0,
     Start = 1,
@@ -18,6 +19,7 @@ export declare enum FrameEvent {
     Destroy = 10,
     StopGame = 11
 }
+/** @private */
 export interface IIterationManager {
     running: boolean;
     start(): void;
@@ -25,7 +27,9 @@ export interface IIterationManager {
     resume(): void;
     stop(): void;
 }
+/** @private */
 export declare const now: () => number;
+/** @private */
 export declare class IterationManager implements IIterationManager {
     private readonly timeManager;
     private readonly physicsManager;

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

@@ -2,15 +2,44 @@ import { Scene, SceneClass } from "../Scene";
 import { IRenderManager } from "angry-pixel-2d-renderer";
 import { InitOptions } from "../GameActor";
 import { Container } from "../../utils/Container";
+/**
+ * Manges the loading of the scenes.
+ * @public
+ * @category Managers
+ * @example
+ * ```js
+ * this.sceneManager.loadScene("MainScene");
+ * ```
+ */
 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 .
+     * @param name The name to identify the scene.
+     * @param options [optional] Options for the init method.
+     * @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 */
     unloadCurrentScene(): void;
+    /** @private */
     stopGame(): void;
 }
+/** @private */
 export declare class SceneManager implements ISceneManager {
     private readonly container;
     private renderManager?;
@@ -18,7 +47,6 @@ export declare class SceneManager implements ISceneManager {
     private currentScene;
     private openingSceneName;
     private sceneToLoad;
-    currentSceneName: string;
     constructor(container: Container, renderManager?: IRenderManager);
     getCurrentScene<T extends Scene>(): T;
     addScene(sceneClass: SceneClass, name: string, options?: InitOptions, openingScene?: boolean): void;

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

@@ -1,21 +1,56 @@
 export declare const MIN_GAME_FRAMERATE = 30;
 export declare const DEFAULT_GAME_FRAMERATE = 60;
 export declare const DEFAULT_PHYSICS_FRAMERATE = 180;
+/**
+ * Manages the properties associated with time.
+ * @public
+ * @category Managers
+ * @example
+ * ```js
+ * // using deltaTime to increment a timer
+ * this.timer += this.timeManager.deltaTime;
+ *
+ * // using physicsDeltaTime within a physics component to move the object it belongs to
+ * this.transform.position.x += speed * this.timeManager.physicsDeltaTime;
+ *
+ * // stop all time-related interactions by setting the scale to zero
+ * this.timeManager.timeScale = 0;
+ * ```
+ */
 export interface ITimeManager {
+    /** @private */
     minGameDeltatime: number;
+    /** @private */
     minPhysicsDeltaTime: number;
+    /** @private */
     gameFramerate: number;
+    /** @private */
     physicsFramerate: number;
+    /** The time difference, in seconds, between the last frame and the current frame. */
+    deltaTime: number;
+    /** The time difference, in seconds, between the last physics frame and the current one. */
+    physicsDeltaTime: number;
+    /**
+     * The scale on which time passes. The default value is 1.\
+     * For example, if set to 2, the time will run at twice the speed.\
+     * If set to 0.5, it will run at half the speed.\
+     * If set to 0, everything associated with the time will stop.
+     */
     timeScale: number;
+    /** The time difference, in seconds, between the last frame and the current frame, unaffected by the scale. */
     unscaledDeltaTime: number;
+    /** The time difference, in seconds, between the last physics frame and the current one, unaffected by the scale. */
     unscaledPhysicsDeltaTime: number;
-    deltaTime: number;
-    physicsDeltaTime: number;
+    /** The time difference, in seconds, between the last frame of and the current frame recorded by the browser. */
     browserDeltaTime: number;
+    /** @private */
     updateForGame(time: number): void;
+    /** @private */
     updateForBrowser(time: number): void;
+    /** @private */
     updateForPhysics(time: number): void;
 }
+/** @private */
 export declare class TimeManager implements ITimeManager {
     readonly minGameDeltatime: number;
     readonly minPhysicsDeltaTime: number;

package/lib/gameObject/GameCamera.d.ts

@@ -1,16 +1,38 @@
 import { GameObject } from "../core/GameObject";
 import { Camera } from "../component/Camera";
 import { Rectangle } from "angry-pixel-math";
+/**
+ * This GameCamera object is automatically added to all scenes, but it also allows
+ * new instances of it to be created, for example, to generate parallax effects.
+ * @public
+ * @category Game Objects
+ */
 export declare class GameCamera extends GameObject {
+    /** The Camera component instance */
     camera: Camera;
     protected init(): void;
+    /** Layers to be rendered by this camera */
     set layers(layers: string[]);
+    /** Layers to be rendered by this camera */
     get layers(): string[];
+    /** In case you have more than one camera, the depth value determines which camera is rendered first */
     set depth(depth: number);
+    /** In case you have more than one camera, the depth value determines which camera is rendered first */
     get depth(): number;
+    /** Camera zoom. Default value is 1 */
     set zoom(zoom: number);
+    /** Camera zoom. Default value is 1 */
     get zoom(): number;
+    /**
+     * Rectangle representing the field of view of the camera in the game world
+     * @readonly
+     */
     get worldSpaceRect(): Rectangle;
+    /**
+     * Rectangle representing the field of view of the camera from the perspective of the screen
+     * @readonly
+     */
     get viewportRect(): Rectangle;
+    /** Adds a new layer to the end of the stack */
     addLayer(layer: string): void;
 }

package/lib/gameObject/SpacePointer.d.ts

@@ -1,4 +1,11 @@
 import { GameObject } from "../core/GameObject";
+/**
+ * This object can be used to click anywhere in the game and get the coordinates relative to the game world.
+ * The coordinates are expressed as an xy vector in the browser console.
+ * It is a useful tool to know where to position objects.
+ * @public
+ * @category Game Objects
+ */
 export declare class SpacePointer extends GameObject {
     private camera;
     private mousePressed;