angry-pixel 1.1.3 → 1.1.4

package/lib/core/managers/iteration/BrowserIterationManager.d.ts

@@ -1,35 +0,0 @@
-import { GameObjectManager } from "../GameObjectManager";
-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 { TimeManager } from "../TimeManager";
-import { IIterationManager } from "./IIterationManager";
-export declare class BrowserIterationManager implements IIterationManager {
-    private readonly timeManager;
-    private readonly collisionManager;
-    private readonly physicsManager;
-    private readonly renderManager;
-    private readonly inputManager;
-    private readonly gameObjectManager;
-    private readonly sceneManager;
-    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);
-    start(): void;
-    pause(): void;
-    resume(): void;
-    stop(): void;
-    private startLoop;
-    private requestAnimationLoop;
-    private gameLogicIteration;
-    private renderIteration;
-    private physicsIteration;
-    private asyncPhysicsLoop;
-    private load;
-    private dispatchFrameEvent;
-}

package/lib/core/managers/iteration/FrameEvent.d.ts

@@ -1,13 +0,0 @@
-export declare enum FrameEvent {
-    Init = 0,
-    Start = 1,
-    Update = 2,
-    UpdateEngine = 3,
-    UpdateCollider = 4,
-    UpdatePhysics = 5,
-    UpdateTransform = 6,
-    UpdatePreRender = 7,
-    UpdateCamera = 8,
-    UpdateRender = 9,
-    Destroy = 10
-}

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

@@ -1,29 +0,0 @@
-import { GameObjectManager } from "../GameObjectManager";
-import { SceneManager } from "../SceneManager";
-import { CollisionManager } from "../../../physics/collision/CollisionManager";
-import { RigidBodyManager } from "../../../physics/rigodBody/RigidBodyManager";
-import { TimeManager } from "../TimeManager";
-import { IIterationManager } from "./IIterationManager";
-export declare class HeadlessIterationManager implements IIterationManager {
-    private readonly timeManager;
-    private readonly collisionManager;
-    private readonly physicsManager;
-    private readonly gameObjectManager;
-    private readonly sceneManager;
-    running: boolean;
-    private currentScene;
-    private gameObjects;
-    private components;
-    constructor(timeManager: TimeManager, collisionManager: CollisionManager, physicsManager: RigidBodyManager, gameObjectManager: GameObjectManager, sceneManager: SceneManager);
-    start(): void;
-    pause(): void;
-    resume(): void;
-    stop(): void;
-    private startLoop;
-    private gameLogicIteration;
-    private physicsIteration;
-    private asyncGameLoop;
-    private asyncPhysicsLoop;
-    private load;
-    private dispatchFrameEvent;
-}

package/lib/core/managers/iteration/IIterationManager.d.ts

@@ -1,7 +0,0 @@
-export interface IIterationManager {
-    running: boolean;
-    start(): void;
-    pause(): void;
-    resume(): void;
-    stop(): void;
-}

package/lib/math/Rectangle.d.ts

@@ -1,57 +0,0 @@
-import { Vector2 } from "./Vector2";
-export declare class Rectangle {
-    private _position;
-    private _center;
-    private _width;
-    private _height;
-    constructor(x: number, y: number, width: number, height: number);
-    get x(): number;
-    set x(value: number);
-    get y(): number;
-    set y(value: number);
-    get x1(): number;
-    get y1(): number;
-    get position(): Vector2;
-    set position(position: Vector2);
-    get width(): number;
-    set width(width: number);
-    get height(): number;
-    set height(height: number);
-    get center(): Vector2;
-    /**
-     * Set the rectangle
-     *
-     * @param x
-     * @param y
-     * @param width
-     * @param height
-     */
-    set(x: number, y: number, width: number, height: number): void;
-    /**
-     * Compare if two rectangles are equals
-     *
-     * @param vector The rectangle to compare
-     * @returns True if the rectangles are equals, false if not
-     */
-    equals(rectangle: Rectangle): boolean;
-    /**
-     * Set the rectangle properties from another rectangle
-     *
-     * @param rect The rectangleto to update from
-     */
-    updateFromRect(rect: Rectangle): void;
-    /**
-     * Check if the target rectangle is overlapping
-     *
-     * @param rect The rectangle to compare
-     * @returns TRUE or FALSE
-     */
-    overlapRectangle(rect: Rectangle): boolean;
-    /**
-     * Check if the target vector is overlapping
-     *
-     * @param vector The target vector
-     * @returns TRUE or FALSE
-     */
-    overlapVector(vector: Vector2): boolean;
-}

package/lib/math/Rotation.d.ts

@@ -1,13 +0,0 @@
-import { Vector2 } from "./Vector2";
-export declare class Rotation {
-    private _degrees;
-    private _radians;
-    private _direction;
-    constructor(radians?: number | null, degrees?: number | null);
-    set degrees(degrees: number);
-    get degrees(): number;
-    set radians(radians: number);
-    get radians(): number;
-    get direction(): Vector2;
-    private updateDirection;
-}

package/lib/math/Utils.d.ts

@@ -1,39 +0,0 @@
-/**
- * @param value number to clamp
- * @param min min value
- * @param max max value
- * @returns clamped value
- */
-export declare const clamp: (value: number, min: number, max: number) => number;
-/**
- * @param min min value
- * @param max max value
- * @returns the random int value
- */
-export declare const randomInt: (min: number, max: number) => number;
-/**
- * @param min min value
- * @param max max value
- * @returns the random float value
- */
-export declare const randomFloat: (min: number, max: number, decimals?: number) => number;
-/**
- * @param value the value to round
- * @param decimals the number of decimals
- * @returns the rounded value
- */
-export declare const fixedRound: (value: number, decimals: number) => number;
-/**
- * @param start the starting value
- * @param end the end value
- * @param steps the steps to move
- * @returns number range
- */
-export declare const range: (start: number, end: number, steps?: number) => number[];
-/**
- * @param value number to compare
- * @param min min value
- * @param max max value
- * @returns true if the number is between the min and the max, false instead
- */
-export declare const between: (value: number, min: number, max: number) => boolean;

package/lib/math/Vector2.d.ts

@@ -1,114 +0,0 @@
-export declare class Vector2 {
-    private _x;
-    private _y;
-    constructor(x?: number, y?: number);
-    get x(): number;
-    set x(x: number);
-    get y(): number;
-    set y(y: number);
-    /**
-     * Get the magnitude of the vector
-     *
-     * @returns The magnitude of the vector
-     */
-    get magnitude(): number;
-    /**
-     * Set the vector
-     *
-     * @param x
-     * @param y
-     */
-    set(x: number, y: number): void;
-    /**
-     * Copy the target vector properties
-     *
-     * @param vector
-     */
-    copy(vector: Vector2): void;
-    /**
-     * Compare if two vector are equals
-     *
-     * @param vector The vector to compare
-     * @returns True if the vectors are equals, false if not
-     */
-    equals(vector: Vector2): boolean;
-    /**
-     * Colne a vector into a new instace
-     *
-     * @returns The cloned vector
-     */
-    clone(): Vector2;
-    /**
-     * Get the distance with another vector
-     *
-     * @param vector The vector to compare
-     * @returns The magnitude of the distance
-     */
-    distance(vector: Vector2): number;
-    /**
-     * Calculates a + b
-     *
-     * @param out The output vector
-     * @param a The first operand
-     * @param b The second operand
-     * @returns The output vector
-     */
-    static add(out: Vector2, a: Vector2, b: Vector2): Vector2;
-    /**
-     * Calculates a - b
-     *
-     * @param out The output vector
-     * @param a The first operand
-     * @param b The second operand
-     * @returns The output vector
-     */
-    static subtract(out: Vector2, a: Vector2, b: Vector2): Vector2;
-    /**
-     * Returns the unit vector
-     *
-     * @param out The output vector
-     * @param a The vector to get the unit
-     * @returns The output vector
-     */
-    static unit(out: Vector2, a: Vector2): Vector2;
-    /**
-     * Normalize a vector
-     *
-     * @param out The output vector
-     * @param a The vector to normalize
-     * @returns The output vector
-     */
-    static normal(out: Vector2, a: Vector2): Vector2;
-    /**
-     * Scale a vector
-     *
-     * @param out The output vector
-     * @param a The vector to scale
-     * @param scalar The scalar value
-     * @returns The output vector
-     */
-    static scale(out: Vector2, a: Vector2, scalar: number): Vector2;
-    /**
-     * Calculates the dot product of two vectors and returns a scalar value
-     *
-     * @param a The first operand
-     * @param b The second operand
-     * @returns The dot product result
-     */
-    static dot(a: Vector2, b: Vector2): number;
-    /**
-     * Calculates the cross product of two vectors and returns a scalar value
-     *
-     * @param a The first operand
-     * @param b The second operand
-     * @returns The cross produc result
-     */
-    static cross(a: Vector2, b: Vector2): number;
-    /**
-     * Rounds a vector
-     *
-     * @param a The vector to round
-     * @returns The output vector
-     */
-    static round(out: Vector2, a: Vector2): Vector2;
-}

package/lib/physics/PhysicsManager.d.ts

@@ -1,24 +0,0 @@
-import { CollisionManager } from "./collision/CollisionManager";
-import { RigidBodyData } from "./rigodBody/RigidBodyData";
-export declare enum RigidBodyType {
-    Static = 0,
-    Dynamic = 1
-}
-export declare class RigidBodyManager {
-    private readonly collisionManager;
-    private rigidBodyData;
-    private cachePosition;
-    private cacheVelocity;
-    private cacheGravity;
-    private cacheDisplacement;
-    private cacheNewDisplacement;
-    private cacheCollisions;
-    constructor(collisionManager: CollisionManager);
-    addRigidBodyData(data: RigidBodyData): void;
-    update(deltaTime: number): void;
-    private applyGravity;
-    private applyVelocity;
-    private applyReposition;
-    private getCollisions;
-    clear(): void;
-}

package/lib/physics/PhysicsManagerOld2.d.ts

@@ -1,34 +0,0 @@
-import { CollisionManager } from "./collision/CollisionManager";
-import { GameObject } from "../core/GameObject";
-import { Vector2 } from "../math/Vector2";
-import { ICollider } from "./collision/collider/ICollider";
-import { TimeManager } from "../core/managers/TimeManager";
-export declare enum RigidBodyType {
-    Static = 0,
-    Dynamic = 1
-}
-export interface RigidBodyData {
-    gameObject: GameObject;
-    gravity: Vector2;
-    velocity: Vector2;
-    layersToCollider: string[];
-    colliders: ICollider[];
-}
-export declare class PhysicsManager {
-    private readonly timeManager;
-    private readonly collisionManager;
-    private rigidBodyData;
-    private cachePosition;
-    private cacheVelocity;
-    private cacheGravity;
-    private cacheDisplacement;
-    private cacheNewDisplacement;
-    constructor(timeManager: TimeManager, collisionManager: CollisionManager);
-    addRigidBodyData(data: RigidBodyData): void;
-    updatePositions(): void;
-    private applyGravityAndVelocity;
-    applyReposition(): void;
-    private applyRepositionToGameObject;
-    private getCollisions;
-    clear(): void;
-}

package/lib/physics/collision/CollisionData.d.ts

@@ -1,8 +0,0 @@
-import { Vector2 } from "../../math/Vector2";
-export declare class CollisionData {
-    private _penetration;
-    private _displacementDirection;
-    constructor(penetration: number, displacementDirection: Vector2);
-    get penetration(): number;
-    get displacementDirection(): Vector2;
-}

package/lib/physics/collision/CollisionManagerOld.d.ts

@@ -1,27 +0,0 @@
-import { Rectangle } from "../../math/Rectangle";
-import { ICollider } from "./collider/ICollider";
-import { CollisionData } from "./CollisionData";
-import { ICollisionResolver } from "./resolver/ICollisionResolver";
-export interface Collision {
-    localCollider: ICollider;
-    remoteCollider: ICollider;
-    collisionData: CollisionData;
-}
-export declare class CollisionManager {
-    private colliders;
-    private quadTree;
-    private bounds;
-    private fixedQuadTree;
-    private resolver;
-    private minBounds;
-    private maxBounds;
-    private newBounds;
-    constructor(resolver: ICollisionResolver, quadTreeBounds: Rectangle | null, quadMaxLevel: number, collidersPerQuad: number);
-    addCollider(collider: ICollider): void;
-    removeCollider(collider: ICollider): void;
-    getCollisionsForCollider(collider: ICollider): Collision[];
-    private broadPhase;
-    private narrowPhase;
-    update(): void;
-    private updateNewBounds;
-}

package/lib/physics/collision/collider/ICollider.d.ts

@@ -1,13 +0,0 @@
-import { GameObject } from "../../../core/GameObject";
-import { Vector2 } from "../../../math/Vector2";
-import { Shape } from "../shape/Shape";
-export interface ICollider {
-    position: Vector2;
-    readonly shape: Shape;
-    readonly gameObject: GameObject;
-    readonly physics: boolean;
-    readonly bottomLeftQuadVertex: Vector2;
-    readonly bottomRightQuadVertex: Vector2;
-    readonly topLeftQuadVertex: Vector2;
-    readonly topRightQuadVertex: Vector2;
-}

package/lib/physics/collision/collider/RectangleCollider.d.ts

@@ -1,31 +0,0 @@
-import { GameObject } from "../../../core/GameObject";
-import { Vector2 } from "../../../math/Vector2";
-import { Rectangle } from "../shape/Rectangle";
-import { ICollider } from "./ICollider";
-export declare class RectangleCollider implements ICollider {
-    readonly gameObject: GameObject;
-    readonly shape: Rectangle;
-    readonly physics: boolean;
-    private _position;
-    private _width;
-    private _height;
-    private _angle;
-    private _quadVertices;
-    private _quadMaxBounds;
-    private _quadMinBounds;
-    constructor(position: Vector2, width: number, height: number, physics: boolean, gameObject: GameObject, angle?: number);
-    set position(coordinates: Vector2);
-    get position(): Vector2;
-    set width(width: number);
-    get width(): number;
-    set height(height: number);
-    get height(): number;
-    get angle(): number;
-    set angle(angle: number);
-    get bottomLeftQuadVertex(): Vector2;
-    get bottomRightQuadVertex(): Vector2;
-    get topLeftQuadVertex(): Vector2;
-    get topRightQuadVertex(): Vector2;
-    private updateShape;
-    private updateQuadVertices;
-}

package/lib/physics/collision/resolver/CircumferenceCircumferenceResolver.d.ts

@@ -1,7 +0,0 @@
-import { Circumference } from "../shape/Circumference";
-import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
-export declare class CircumferenceCircumferenceResolver implements CollisionResolver {
-    private distance;
-    private direction;
-    resolve(shapeA: Circumference, shapeB: Circumference): CollisionResolution;
-}

package/lib/physics/collision/resolver/CircumferencePolygonResolver.d.ts

@@ -1,23 +0,0 @@
-import { Circumference } from "../shape/Circumference";
-import { Line } from "../shape/Line";
-import { Polygon } from "../shape/Polygon";
-import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
-export declare class CircumferencePolygonResolver implements CollisionResolver {
-    private axes;
-    private projA;
-    private projB;
-    private currentOverlap;
-    private minOverlap;
-    private displaceDirection;
-    private direction;
-    private closestVertex;
-    private distance;
-    private newDistance;
-    private circumferenceAxis;
-    private cache;
-    resolve(shapeA: Circumference, shapeB: Polygon | Line, invert?: boolean): CollisionResolution;
-    private findClosestVertex;
-    private setCircumferenceVertices;
-    private projectShapeOntoAxis;
-    private preventContainment;
-}

package/lib/physics/collision/resolver/CircumferenceRectangleResolver.d.ts

@@ -1,9 +0,0 @@
-import { Circumference } from "../shape/Circumference";
-import { Rectangle } from "../shape/Rectangle";
-import { CollisionResolver, CollisionResolution } from "./CollisionResolver";
-export declare class CircumferenceRectangleResolver implements CollisionResolver {
-    private closestPoint;
-    private distance;
-    private direction;
-    resolve(shapeA: Circumference, shapeB: Rectangle, invert?: boolean): CollisionResolution;
-}

package/lib/physics/collision/resolver/CollisionResolution.d.ts

@@ -1,6 +0,0 @@
-import { Vector2 } from "../../../math/Vector2";
-export interface CollisionResolution {
-    penetration: number;
-    direction: Vector2;
-    displacementDirection: Vector2;
-}

package/lib/physics/collision/resolver/ICollisionResolver.d.ts

@@ -1,5 +0,0 @@
-import { CollisionData } from "../CollisionData";
-import { Shape } from "../shape/Shape";
-export interface ICollisionResolver {
-    getCollisionData(shape1: Shape, shape2: Shape): CollisionData | null;
-}

package/lib/physics/collision/resolver/PolygonPolygonResolver.d.ts

@@ -1,15 +0,0 @@
-import { Line } from "../shape/Line";
-import { Polygon } from "../shape/Polygon";
-import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
-export declare class PolygonPolygonResolver implements CollisionResolver {
-    private axes;
-    private projA;
-    private projB;
-    private currentOverlap;
-    private minOverlap;
-    private displaceDirection;
-    private direction;
-    resolve(shapeA: Polygon | Line, shapeB: Polygon | Line): CollisionResolution | null;
-    private projectShapeOntoAxis;
-    private preventContainment;
-}

package/lib/physics/collision/resolver/RectangleRectangleResolver.d.ts

@@ -1,11 +0,0 @@
-import { Rectangle } from "../shape/Rectangle";
-import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
-export declare class RectangleRectangleResolver implements CollisionResolver {
-    private overlapX;
-    private overlapY;
-    private minOverlap;
-    private direction;
-    private displacementDirection;
-    resolve(shapeA: Rectangle, shapeB: Rectangle): CollisionResolution | null;
-    private preventContainment;
-}

package/lib/physics/collision-old/CollisionData.d.ts

@@ -1,8 +0,0 @@
-import { Vector2 } from "../../math/Vector2";
-export declare class CollisionData {
-    private _penetration;
-    private _displacementDirection;
-    constructor(penetration: number, displacementDirection: Vector2);
-    get penetration(): number;
-    get displacementDirection(): Vector2;
-}

package/lib/physics/collision-old/CollisionManager.d.ts

@@ -1,30 +0,0 @@
-import { Rectangle } from "../../math/Rectangle";
-import { ICollider } from "./collider/ICollider";
-import { CollisionData } from "./CollisionData";
-import { ICollisionResolver } from "./resolver/ICollisionResolver";
-export interface Collision {
-    localCollider: ICollider;
-    remoteCollider: ICollider;
-    collisionData: CollisionData;
-}
-export declare class CollisionManager {
-    private colliders;
-    private quadTree;
-    private bounds;
-    private fixedQuadTree;
-    private resolver;
-    private collisions;
-    private minBounds;
-    private maxBounds;
-    private newBounds;
-    constructor(resolver: ICollisionResolver, quadTreeBounds: Rectangle | null, quadMaxLevel: number, collidersPerQuad: number);
-    addCollider(collider: ICollider): void;
-    removeCollider(collider: ICollider): void;
-    getFrameCollisionsForCollider(collider: ICollider): Collision[];
-    refreshCollisionsForCollider(collider: ICollider): Collision[];
-    update(): void;
-    private updateNewBounds;
-    private updateCollisions;
-    private broadPhase;
-    private narrowPhase;
-}

package/lib/physics/collision-old/QuadTree.d.ts

@@ -1,32 +0,0 @@
-import { Rectangle } from "../../math/Rectangle";
-import { ICollider } from "./collider/ICollider";
-export declare const DEFAULT_MAX_COLLIDERS: number;
-export declare const DEFAULT_MAX_LEVELS: number;
-export declare class QuadTree {
-    private _bounds;
-    private _quadrants;
-    private readonly maxLevels;
-    private readonly maxColliders;
-    private readonly level;
-    private colliders;
-    private readonly sw;
-    private readonly se;
-    private readonly nw;
-    private readonly ne;
-    private center;
-    private childrenWidth;
-    private childrenHeight;
-    private quadrantsForCollider;
-    constructor(level: number, bounds: Rectangle, maxLevels?: number, maxColliders?: number);
-    get bounds(): Rectangle;
-    get quadrants(): QuadTree[];
-    updateBounds(bounds: Rectangle): void;
-    clearColliders(): void;
-    clearQuadrants(): void;
-    addCollider(collider: ICollider): void;
-    retrieve(collider: ICollider): ICollider[];
-    private splitQuad;
-    private getChildrenQuadrantForCollider;
-    private insertColliderIntoChildrenQuads;
-    private updateCache;
-}

package/lib/physics/collision-old/collider/ICollider.d.ts

@@ -1,14 +0,0 @@
-import { GameObject } from "../../../core/GameObject";
-import { Vector2 } from "../../../math/Vector2";
-import { Shape } from "../shape/Shape";
-export interface ICollider {
-    position: Vector2;
-    readonly shape: Shape;
-    readonly gameObject: GameObject;
-    readonly physics: boolean;
-    readonly bottomLeftQuadVertex: Vector2;
-    readonly bottomRightQuadVertex: Vector2;
-    readonly topLeftQuadVertex: Vector2;
-    readonly topRightQuadVertex: Vector2;
-    readonly updateCollisions: boolean;
-}

package/lib/physics/collision-old/collider/RectangleCollider.d.ts

@@ -1,32 +0,0 @@
-import { GameObject } from "../../../core/GameObject";
-import { Vector2 } from "../../../math/Vector2";
-import { Rectangle } from "../shape/Rectangle";
-import { ICollider } from "./ICollider";
-export declare class RectangleCollider implements ICollider {
-    readonly gameObject: GameObject;
-    readonly shape: Rectangle;
-    readonly physics: boolean;
-    readonly updateCollisions: boolean;
-    private _position;
-    private _width;
-    private _height;
-    private _angle;
-    private _quadVertices;
-    private _quadMaxBounds;
-    private _quadMinBounds;
-    constructor(position: Vector2, width: number, height: number, physics: boolean, gameObject: GameObject, angle?: number, updateCollisions?: boolean);
-    set position(coordinates: Vector2);
-    get position(): Vector2;
-    set width(width: number);
-    get width(): number;
-    set height(height: number);
-    get height(): number;
-    get angle(): number;
-    set angle(angle: number);
-    get bottomLeftQuadVertex(): Vector2;
-    get bottomRightQuadVertex(): Vector2;
-    get topLeftQuadVertex(): Vector2;
-    get topRightQuadVertex(): Vector2;
-    private updateShape;
-    private updateQuadVertices;
-}