angry-pixel 1.2.6 → 1.2.7

package/lib/component/Camera.d.ts

@@ -1,47 +0,0 @@
-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;
-    private updateViewportRect;
-    private updateWorldSpaceRect;
-    private updateCameraData;
-}

package/lib/component/RigidBody.d.ts

@@ -1,97 +0,0 @@
-import { EngineComponent } from "../core/Component";
-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;
-    protected onActiveChange(): void;
-    protected onDestroy(): void;
-}

package/lib/component/Sprite.d.ts

@@ -1,22 +0,0 @@
-import { Vector2 } from "angry-pixel-math";
-import { Slice } from "angry-pixel-2d-renderer";
-export { Slice };
-export interface SpriteConfig {
-    image: HTMLImageElement;
-    scale?: Vector2;
-    slice?: Slice;
-    smooth?: boolean;
-}
-export declare class Sprite {
-    readonly image: HTMLImageElement;
-    readonly slice: Slice;
-    readonly smooth: boolean;
-    scale?: Vector2;
-    private _width;
-    private _height;
-    private _loaded;
-    constructor(config: SpriteConfig);
-    get width(): number;
-    get height(): number;
-    get loaded(): boolean;
-}

package/lib/component/Transform.d.ts

@@ -1,65 +0,0 @@
-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;
-    private _rotation;
-    private _innerPosition;
-    private _parent;
-    private cache;
-    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;
-    private translateInnerPosition;
-    private updateScaledInnerPosition;
-}

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

@@ -1,73 +0,0 @@
-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;
-    private realPosition;
-    private innerPosition;
-    protected init(config: BallColliderOptions): void;
-    protected updateRealSize(): void;
-    protected updatePosition(): void;
-    private translate;
-    protected updateColliders(): void;
-}

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

@@ -1,90 +0,0 @@
-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;
-    private realOffset;
-    private realPosition;
-    private realRotation;
-    private applyRotation;
-    private innerPosition;
-    protected init(config: BoxColliderOptions): void;
-    protected updateRealSize(): void;
-    protected updatePosition(): void;
-    private translate;
-    protected updateColliders(): void;
-}

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

@@ -1,82 +0,0 @@
-import { ColliderComponent, RenderComponent } from "../../core/Component";
-import { GameObject } from "../../core/GameObject";
-import { ICollisionResolution, ICollider, ICollision } 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 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.
- * @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[];
-    protected createCollisionData(collision: ICollision): CollisionData;
-    protected onActiveChange(): void;
-    protected onDestroy(): void;
-}

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

@@ -1,81 +0,0 @@
-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;
-    private scaledPosition;
-    private finalRotation;
-    private innerPosition;
-    protected init(config: EdgeColliderOptions): void;
-    protected updateRealSize(): void;
-    protected updatePosition(): void;
-    private translate;
-    protected updateColliders(): void;
-}

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

@@ -1,92 +0,0 @@
-import { BaseCollider } from "./Collider";
-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;
-    private scaledPosition;
-    private finalRotation;
-    private innerPosition;
-    protected init(config: PolygonColliderOptions): void;
-    protected updateRealSize(): void;
-    protected updatePosition(): void;
-    private translate;
-    protected updateColliders(): void;
-}
-/** @private */
-export declare class PolygonColliderRenderer extends RenderComponent {
-    private renderData;
-    private collider;
-    protected init({ collider }: {
-        collider: ICollider;
-    }): void;
-    protected update(): void;
-}