angry-pixel 1.2.2 → 1.2.4

package/lib/component/Camera.d.ts

@@ -1,16 +1,43 @@
 import { CameraComponent } from "../core/Component";
 import { Rectangle } from "angry-pixel-math";
+/**
+ * The Camera component is used to organize the rendering order by layers and to manage the general zooming of these layers.
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * const camera = this.addComponent(Camera);
+ * camera.zoom = 1;
+ * camera.depth = 0;
+ * camera.layers = ["Background", "Foreground"];
+ * camera.addLayer("UI");
+ * ```
+ */
 export declare class Camera extends CameraComponent {
+    /** @private */
     readonly allowMultiple: boolean;
+    /**
+     * Rectangle representing the field of view of the camera from the perspective of the screen
+     * @readonly
+     */
     readonly viewportRect: Rectangle;
+    /**
+     * Rectangle representing the field of view of the camera in the game world
+     * @readonly
+     */
     readonly worldSpaceRect: Rectangle;
+    /** In case you have more than one camera, the depth value determines which camera is rendered first */
     depth: number;
+    /** Layers to be rendered by this camera */
     layers: string[];
     private _zoom;
     private cameraData;
     private canvas;
+    /** Camera zoom. Default value is 1 */
     set zoom(zoom: number);
+    /** Camera zoom. Default value is 1 */
     get zoom(): number;
+    /** Adds a new layer to the end of the stack */
     addLayer(layer: string): void;
     protected init(): void;
     protected update(): void;

package/lib/component/RigidBody.d.ts

@@ -3,17 +3,92 @@ import { Vector2 } from "angry-pixel-math";
 import { InitOptions } from "../core/GameActor";
 import { RigidBodyType } from "angry-pixel-2d-physics";
 export { RigidBodyType } from "angry-pixel-2d-physics";
+/**
+ * RigidBody configuration options
+ * @public
+ * @category Components
+ * @example
+ * ```js
+  const body = this.addComponent(RigidBody, {
+    rigidBodyType: RigidBodyType.Dynamic,
+    gravity: 10
+  });
+ * ```
+ * @example
+ * ```js
+  const body = this.addComponent(RigidBody, {
+    rigidBodyType: RigidBodyType.Kinematic,
+  });
+ * ```
+ * @example
+ * ```js
+  const body = this.addComponent(RigidBody, {
+    rigidBodyType: RigidBodyType.Static,
+  });
+ * ```
+ */
 export interface RigidBodyOptions extends InitOptions {
+    /**
+     * The type determines how it will respond to physics and collisions.
+       - Dynamic = This type of body is affected by gravity, can be velocity-applied and collides with all types of bodies.
+       - Kinematic = This body type is not affected by gravity but can have velocity applied to it. Dynamic bodies can collide with it.
+       - Static = This type of body is immovable, no velocity can be applied to it and it is not affected by gravity. It is the body type that consumes the least processing resources.
+     */
     rigidBodyType: RigidBodyType;
+    /** Gravity expressed in pixels per second squared. Only applies fot Dynamic bodies */
     gravity?: number;
 }
+/**
+ * The RigidBody component puts the object under simulation of the physics engine, where it will interact with other objects that have a RigidBody.
+ * The RigidBody component requires the object to have at least one collider.
+ *
+ * There are three types of bodies:
+ * - Dynamic = This type of body is affected by gravity, can be velocity-applied and collides with all types of bodies.
+ * - Kinematic = This body type is not affected by gravity but can have velocity applied to it. Dynamic bodies can collide with it.
+ * - Static = This type of body is immovable, no velocity can be applied to it and it is not affected by gravity. It is the body type that consumes the least processing resources.
+ * @public
+ * @category Components
+ * @example
+ * ```js
+  const body = this.addComponent(RigidBody, {
+    rigidBodyType: RigidBodyType.Dynamic,
+    gravity: 10
+  });
+  body.velocity = 200;
+ * ```
+ * @example
+ * ```js
+  const body = this.addComponent(RigidBody, {
+    rigidBodyType: RigidBodyType.Kinematic,
+  });
+  body.velocity = 200;
+ * ```
+ * @example
+ * ```js
+  const body = this.addComponent(RigidBody, {
+    rigidBodyType: RigidBodyType.Static,
+  });
+ * ```
+ */
 export declare class RigidBody extends EngineComponent {
+    /** @private */
     readonly allowMultiple: boolean;
     private rigidBody;
+    /** Velocity applied to the x-axis and y-axis expressed in pixels per second. */
     get velocity(): Vector2;
+    /** Velocity applied to the x-axis and y-axis expressed in pixels per second. */
     set velocity(velocity: Vector2);
+    /** Gravity expressed in pixels per second squared. Only applies fot Dynamic bodies */
     get gravity(): number;
+    /** Gravity expressed in pixels per second squared. Only applies fot Dynamic bodies */
     set gravity(gravity: number);
+    /**
+     * The type determines how it will respond to physics and collisions.
+       - Dynamic = This type of body is affected by gravity, can be velocity-applied and collides with all types of bodies.
+       - Kinematic = This body type is not affected by gravity but can have velocity applied to it. Dynamic bodies can collide with it.
+       - Static = This type of body is immovable, no velocity can be applied to it and it is not affected by gravity. It is the body type that consumes the least processing resources.
+     */
+    get rigidBodyType(): RigidBodyType;
     protected init({ rigidBodyType, gravity }: RigidBodyOptions): void;
     protected update(): void;
     private getColliderIds;

package/lib/component/Sprite.d.ts

@@ -1,22 +1,50 @@
-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;
-    scale?: Vector2;
+    /** Cut the image based on straight coordinates starting from the top left downward */
     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/Transform.d.ts

@@ -1,8 +1,33 @@
 import { TransformComponent } from "../core/Component";
 import { Rotation, Vector2 } from "angry-pixel-math";
+/**
+ * All GameObject have a Transform natively, so it cannot be added manually.
+ * It is used to handle the position, rotation and scale of the object. If the object has a parent,
+ * it can be scaled, rotated and translated hierarchically.
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * this.transform.position = new Vector2(0, 0);
+ * this.transform.position.set(0, 0);
+ *
+ * this.transform.scale = new Vector2(0, 0);
+ * this.transform.scale.set(0, 0);
+ *
+ * this.transform.rotation.radians = 0;
+ * this.transform.rotation.degrees = 0;
+ *
+ * // used to set position relative to the parent
+ * this.transform.innerPosition = new Vector2(0, 0);
+ * this.transform.innerPosition.set(0, 0);
+ * ```
+ */
 export declare class Transform extends TransformComponent {
+    /** @private */
     readonly allowMultiple: boolean;
+    /** Apply scale relative to the parent. Default value is TRUE */
     parentScale: boolean;
+    /** Apply rotation relative to the parent. Default value is TRUE */
     parentRotation: boolean;
     private _position;
     private _scale;
@@ -13,15 +38,25 @@ export declare class Transform extends TransformComponent {
     private lastParentRadians;
     private lastPosition;
     private scaledInnerPosition;
+    /** Position on x-axis and y-axis in pixels */
     get position(): Vector2;
+    /** Position on x-axis and y-axis in pixels */
     set position(position: Vector2);
+    /** Scale on x-axis and y-axis in pixels */
     get scale(): Vector2;
+    /** Scale on x-axis and y-axis in pixels */
     set scale(scale: Vector2);
+    /** Rotation expressed in radians or degrees  */
     get rotation(): Rotation;
+    /** Direction vector based on the Rotation */
     get direction(): Vector2;
+    /** Position vector relative to the parent */
     get innerPosition(): Vector2;
+    /** Position vector relative to the parent */
     set innerPosition(innerPosition: Vector2);
+    /** Parent transform */
     get parent(): Transform | null;
+    /** Parent transform */
     set parent(parent: Transform | null);
     protected update(): void;
     private setPositionFromParent;

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

@@ -1,17 +1,65 @@
 import { BaseCollider } from "./Collider";
 import { InitOptions } from "../../core/GameActor";
+/**
+ * BallCollider configuration options
+ * @public
+ * @category Components
+ *  @example
+ * ```js
+ * this.addComponent(BallCollider, {
+ *   radius: 32,
+ *   offsetX: 0,
+ *   offsetY: 0,
+ *   layer: "PlayerHitbox",
+ *   debug: false,
+ *   physics: true,
+ * });
+ * ```
+ */
 export interface BallColliderOptions extends InitOptions {
+    /** Radius in pixels */
     radius: number;
+    /** x-axis offset */
     offsetX?: number;
+    /** y-axis offset */
     offsetY?: number;
+    /** Collision layer, if it's not setted, it uses the game object layer */
     layer?: string;
+    /** TRUE if this collider interact with rigid bodies */
     physics?: boolean;
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     debug?: boolean;
 }
+/**
+ * Circumference shaped collider for 2d collisions.
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * this.addComponent(BallCollider, {
+ *   radius: 32
+ * });
+ * ```
+ * @example
+ * ```js
+ * this.addComponent(BallCollider, {
+ *   radius: 32,
+ *   offsetX: 0,
+ *   offsetY: 0,
+ *   layer: "PlayerHitbox",
+ *   debug: false,
+ *   physics: true,
+ * });
+ * ```
+ */
 export declare class BallCollider extends BaseCollider {
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     debug: boolean;
+    /** Radius in pixels */
     radius: number;
+    /** x-axis offset */
     offsetX: number;
+    /** y-axis offset */
     offsetY: number;
     private realRadius;
     private realOffset;

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

@@ -1,22 +1,79 @@
 import { BaseCollider } from "./Collider";
 import { InitOptions } from "../../core/GameActor";
 import { Rotation } from "angry-pixel-math";
+/**
+ * BoxCollider configuration options
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * this.addComponent(BoxCollider, {
+ *   width: 32,
+ *   height: 32,
+ *   rotation: new Rotation(0),
+ *   offsetX: 0,
+ *   offsetY: 0,
+ *   layer: "PlayerHitbox",
+ *   debug: false,
+ *   physics: true,
+ * });
+ * ```
+ */
 export interface BoxColliderOptions extends InitOptions {
+    /** Width of the rectangle in pixels */
     width: number;
+    /** Height of the rectangle in pixels */
     height: number;
+    /** x-axis offset */
     offsetX?: number;
+    /** y-axis offset */
     offsetY?: number;
+    /** Rectangle rotation (degrees or radians) */
     rotation?: Rotation;
+    /** Collision layer, if it's not setted, it uses the game object layer */
     layer?: string;
+    /** TRUE if this collider interact with rigid bodies */
     physics?: boolean;
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     debug?: boolean;
 }
+/**
+ * Rectangle shaped collider for 2d collisions.
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * this.addComponent(BoxCollider, {
+ *   width: 32,
+ *   height: 32,
+ * });
+ * ```
+ * @example
+ * ```js
+ * this.addComponent(BoxCollider, {
+ *   width: 32,
+ *   height: 32,
+ *   rotation: new Rotation(0),
+ *   offsetX: 0,
+ *   offsetY: 0,
+ *   layer: "PlayerHitbox",
+ *   debug: false,
+ *   physics: true,
+ * });
+ * ```
+ */
 export declare class BoxCollider extends BaseCollider {
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     debug: boolean;
+    /** Width of the rectangle in pixels */
     width: number;
+    /** Height of the rectangle in pixels */
     height: number;
+    /** x-axis offset */
     offsetX: number;
+    /** y-axis offset */
     offsetY: number;
+    /** Rectangle rotation (degrees or radians) */
     rotation: Rotation;
     private realWidth;
     private realHeight;

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

@@ -1,32 +1,78 @@
 import { ColliderComponent, RenderComponent } from "../../core/Component";
 import { GameObject } from "../../core/GameObject";
 import { ICollisionResolution, ICollider } from "angry-pixel-2d-physics";
+/**
+ * Information about the collision
+ * @public
+ * @category Components
+ */
 export interface CollisionData {
+    /** Contains information about the penetration and direction of the collision. */
     resolution: ICollisionResolution;
+    /** The collider on the other side of the collision. */
     collider: ICollider;
+    /** The object on the other side of the collision. */
     gameObject: GameObject;
     /**
-     * @return The GameObject to which this component belongs
+     * @return The object on the other side of the collision.
      */
     getGameObject: <T extends GameObject>() => T;
 }
+/**
+ * Every collider component implements this interface.
+ * @public
+ * @category Components
+ */
 export interface IColliderComponent {
+    /**
+     * Check if the collider is in contact with any collider of the given layer.
+     * @param layer The layer to check
+     * @returns TRUE if is colliding, FALSE instead
+     */
     collidesWithLayer(layer: string): boolean;
+    /**
+     * If there is a collision with the given layer, it returns information about it, or null if there is none.
+     * @param layer The layer to check
+     * @returns The collision data object, or NULL instead
+     */
     getCollisionWithLayer(layer: string): CollisionData | null;
+    /**
+     * If there are collisions with the given layer, it returns information about every collision.
+     * @param layer The layer to check
+     * @returns The collection of collision data
+     */
     getCollisionsWithLayer(layer: string): CollisionData[];
 }
+/** @private */
 export declare abstract class BaseCollider extends ColliderComponent implements IColliderComponent {
     protected renderer: RenderComponent;
     readonly colliders: ICollider[];
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     layer: string;
+    /** TRUE if this collider interact with rigid bodies */
     physics: boolean;
     private activateColliders;
     protected abstract updateRealSize(): void;
     protected abstract updatePosition(): void;
     protected abstract updateColliders(): void;
     protected update(): void;
+    /**
+     * Check if the collider is in contact with any collider of the given layer.
+     * @param layer The layer to check
+     * @returns TRUE if is colliding, FALSE instead
+     */
     collidesWithLayer(layer: string): boolean;
+    /**
+     * If there is a collision with the given layer, it returns information about it, or null if there is none.
+     * @param layer The layer to check
+     * @returns The collision data object, or NULL instead
+     */
     getCollisionWithLayer(layer: string): CollisionData | null;
+    /**
+     * If there are collisions with the given layer, it returns information about every collision.
+     * @param layer The layer to check
+     * @returns The collection of collision data
+     */
     getCollisionsWithLayer(layer: string): CollisionData[];
     private createCollisionData;
     protected onActiveChange(): void;

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

@@ -1,20 +1,72 @@
 import { BaseCollider } from "./Collider";
 import { InitOptions } from "../../core/GameActor";
 import { Vector2, Rotation } from "angry-pixel-math";
+/**
+ * EdgeCollider configuration options
+ * @public
+ * @category Components
+ *  @example
+ * ```js
+ * this.addComponent(EdgeCollider, {
+ *   vertexModel: [new Vector2(0,0), new Vector2(32, 32)],
+ *   rotation: new Rotation(0),
+ *   offsetX: 0,
+ *   offsetY: 0,
+ *   layer: "Hills",
+ *   debug: false,
+ *   physics: true,
+ * });
+ * ```
+ */
 export interface EdgeColliderOptions extends InitOptions {
+    /** Collection of 2d vectors representing the vertices of the collider */
     vertexModel: Vector2[];
+    /** x-axis offset */
     offsetX?: number;
+    /** y-axis offset */
     offsetY?: number;
+    /** Edges rotation (degrees or radians) */
     rotation?: Rotation;
+    /** Collision layer, if it's not setted, it uses the game object layer */
     layer?: string;
+    /** TRUE if this collider interact with rigid bodies */
     physics?: boolean;
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     debug?: boolean;
 }
+/**
+ * Collider composed of lines defined by its vertices, for 2d collisions.
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * this.addComponent(EdgeCollider, {
+ *   vertexModel: [new Vector2(0,0), new Vector2(32, 32)],
+ * });
+ * ```
+ * @example
+ * ```js
+ * this.addComponent(EdgeCollider, {
+ *   vertexModel: [new Vector2(0,0), new Vector2(32, 32)],
+ *   rotation: new Rotation(0),
+ *   offsetX: 0,
+ *   offsetY: 0,
+ *   layer: "Hills",
+ *   debug: false,
+ *   physics: true,
+ * });
+ * ```
+ */
 export declare class EdgeCollider extends BaseCollider {
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     debug: boolean;
+    /** Collection of 2d vectors representing the vertices of the collider */
     vertexModel: Vector2[];
+    /** x-axis offset */
     offsetX: number;
+    /** y-axis offset */
     offsetY: number;
+    /** Rectangle rotation (degrees or radians) */
     rotation: Rotation;
     private scaledVertexModel;
     private scaledOffset;

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

@@ -3,20 +3,72 @@ import { RenderComponent } from "../../core/Component";
 import { InitOptions } from "../../core/GameActor";
 import { Vector2, Rotation } from "angry-pixel-math";
 import { ICollider } from "angry-pixel-2d-physics";
+/**
+ * PolygonCollider configuration options
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * this.addComponent(PolygonCollider, {
+ *   vertexModel: [new Vector2(0,0), new Vector2(32, 32), new Vector2(64, 0)],
+ *   rotation: new Rotation(0),
+ *   offsetX: 0,
+ *   offsetY: 0,
+ *   layer: "Hills",
+ *   debug: false,
+ *   physics: true,
+ * });
+ * ```
+ */
 export interface PolygonColliderOptions extends InitOptions {
+    /** Collection of 2d vectors representing the vertices of the collider */
     vertexModel: Vector2[];
+    /** x-axis offset */
     offsetX?: number;
+    /** y-axis offset */
     offsetY?: number;
+    /** Edges rotation (degrees or radians) */
     rotation?: Rotation;
+    /** Collision layer, if it's not setted, it uses the game object layer */
     layer?: string;
+    /** TRUE if this collider interact with rigid bodies */
     physics?: boolean;
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     debug?: boolean;
 }
+/**
+ * Polygon shaped Collider for 2d collisions. Only convex polygons are allowed.
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * this.addComponent(PolygonCollider, {
+ *   vertexModel: [new Vector2(0,0), new Vector2(32, 32), new Vector2(64, 0)],
+ * });
+ * ```
+ * @example
+ * ```js
+ * this.addComponent(PolygonCollider, {
+ *   vertexModel: [new Vector2(0,0), new Vector2(32, 32), new Vector2(64, 0)],
+ *   rotation: new Rotation(0),
+ *   offsetX: 0,
+ *   offsetY: 0,
+ *   layer: "Hills",
+ *   debug: false,
+ *   physics: true,
+ * });
+ * ```
+ */
 export declare class PolygonCollider extends BaseCollider {
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     debug: boolean;
+    /** Collection of 2d vectors representing the vertices of the collider */
     vertexModel: Vector2[];
+    /** x-axis offset */
     offsetX: number;
+    /** y-axis offset */
     offsetY: number;
+    /** Rectangle rotation (degrees or radians) */
     rotation: Rotation;
     private scaledVertexModel;
     private scaledOffset;
@@ -29,6 +81,7 @@ export declare class PolygonCollider extends BaseCollider {
     private translate;
     protected updateColliders(): void;
 }
+/** @private */
 export declare class PolygonColliderRenderer extends RenderComponent {
     private renderData;
     private collider;

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

@@ -1,15 +1,56 @@
 import { ITilemapRenderer } from "../rendering/TilemapRenderer";
 import { BaseCollider } from "./Collider";
 import { InitOptions } from "../../core/GameActor";
+/**
+ * TilemapCollider configuration options
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * this.addComponent(TilemapCollider, {
+ *   tilemapRenderer: this.getComponent(TilemapRenderer),
+ *   layer: "Foreground",
+ *   debug: false,
+ *   composite: true,
+ * });
+ * ```
+ */
 export interface TilemapColliderOptions extends InitOptions {
+    /** TilemapRenderer from which the tiles information will be obtained to generate the colliders */
     tilemapRenderer: ITilemapRenderer;
+    /** Generate colliders that represent the outer lines of the tile map */
     composite?: boolean;
+    /** Collision layer, if it's not setted, it uses the game object layer */
     layer?: string;
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     debug?: boolean;
 }
+/**
+ * Generates rectanble colliders for the map edge tiles (or lines if composite is TRUE).
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * this.addComponent(TilemapCollider, {
+ *   tilemapRenderer: this.getComponent(TilemapRenderer),
+ * });
+ * ```
+ * @example
+ * ```js
+ * this.addComponent(TilemapCollider, {
+ *   tilemapRenderer: this.getComponent(TilemapRenderer),
+ *   layer: "Foreground",
+ *   debug: false,
+ *   composite: true,
+ * });
+ * ```
+ */
 export declare class TilemapCollider extends BaseCollider {
+    /** TilemapRenderer from which the tiles information will be obtained to generate the colliders */
     private tilemapRenderer;
+    /** If debug mode is enabled, the collider shape is rendered using the object's render layer */
     private debug;
+    /** Generate colliders that represent the outer lines of the tile map */
     private composite;
     private scaledWidth;
     private scaledHeight;