angry-pixel 1.0.5 → 1.0.9

package/lib/input/GamepadController.d.ts

@@ -0,0 +1,48 @@
+import { Vector2 } from "..";
+export declare class GamepadController {
+    private readonly gamepads;
+    constructor();
+    getGamepad(index: number): GamepadData;
+    private eventHandler;
+    private gamepadConnected;
+    private gamepadDisconected;
+    update(): void;
+    private getGamepads;
+}
+export declare class GamepadData {
+    private _connected;
+    private _id;
+    private readonly buttons;
+    private readonly axes;
+    private readonly _dpadAxes;
+    private readonly _leftStickAxes;
+    private readonly _rightStickAxes;
+    updateFromGamepad(gamepad: Gamepad): void;
+    get id(): string;
+    getButtonPressed(index: number): boolean;
+    getAxis(index: number): number;
+    get dpadAxes(): Vector2;
+    get leftStickAxes(): Vector2;
+    get rightStickAxes(): Vector2;
+    get connected(): boolean;
+    get dpadUp(): boolean;
+    get dpadDown(): boolean;
+    get dpadLeft(): boolean;
+    get dpadRight(): boolean;
+    get bottomFace(): boolean;
+    get rightFace(): boolean;
+    get leftFace(): boolean;
+    get topFace(): boolean;
+    get leftShoulder(): boolean;
+    get rightShoulder(): boolean;
+    get leftTrigger(): boolean;
+    get rightTrigger(): boolean;
+    get back(): boolean;
+    get start(): boolean;
+    get leftStickButton(): boolean;
+    get rightStickButton(): boolean;
+    get leftStickHorizontal(): number;
+    get leftStickVertical(): number;
+    get rightStickHorizontal(): number;
+    get rightStickVertical(): number;
+}

package/lib/input/InputManager.d.ts

@@ -0,0 +1,12 @@
+import { MouseController } from "./MouseController";
+import { KeyboardController } from "./KeyboardController";
+import { GamepadController } from "./GamepadController";
+import { TouchController } from "./TouchController";
+export declare class InputManager {
+    mouse: MouseController;
+    keyboard: KeyboardController;
+    gamepad: GamepadController;
+    touch: TouchController;
+    constructor(mouse: MouseController, keyboard: KeyboardController, gamepad: GamepadController, touch: TouchController);
+    update(): void;
+}

package/lib/input/KeyboardController.d.ts

@@ -0,0 +1,12 @@
+export declare class KeyboardController {
+    private canvas;
+    private keyPresses;
+    constructor(canvas: HTMLCanvasElement);
+    private eventHandler;
+    isPressed(keyCode: string): boolean;
+    orPressed(keyCodes: string[]): boolean;
+    andPressed(keyCodes: string[]): boolean;
+    isPressedReturn<T>(keyCode: string, returnTrue: T, returnFalse: T): T;
+    orPressedReturn<T>(keyCodes: string[], returnTrue: T, returnFalse: T): T;
+    andPressedReturn<T>(keyCodes: string[], returnTrue: T, returnFalse: T): T;
+}

package/lib/input/MouseController.d.ts

@@ -0,0 +1,21 @@
+import { Vector2 } from "../math/Vector2";
+export declare class MouseController {
+    private _leftButtonPressed;
+    private _scrollButtonPressed;
+    private _rightButtonPressed;
+    private _positionInViewport;
+    private _hasMoved;
+    private lastPositionInViewport;
+    private canvas;
+    constructor(canvas: HTMLCanvasElement);
+    get leftButtonPressed(): boolean;
+    get scrollButtonPressed(): boolean;
+    get rightButtonPressed(): boolean;
+    get positionInViewport(): Vector2;
+    get hasMoved(): boolean;
+    update(): void;
+    private setup;
+    private updateButtonDown;
+    private updateButtonUp;
+    private updatePosition;
+}

package/lib/input/TouchController.d.ts

@@ -0,0 +1,13 @@
+import { Vector2 } from "../math/Vector2";
+export declare class TouchController {
+    private canvas;
+    private _touching;
+    private _positionInViewport;
+    private _radius;
+    constructor(canvas: HTMLCanvasElement);
+    get positionInViewport(): Vector2;
+    get touching(): boolean;
+    get radius(): Vector2;
+    private eventHandler;
+    private updatePosition;
+}

package/lib/math/Rectangle.d.ts

@@ -0,0 +1,50 @@
+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 rectangle is overlapping another rectangle
+     *
+     * @param rect The rectangle to compare
+     * @returns TRUE or FALSE
+     */
+    overlappingRectangle(rect: Rectangle): boolean;
+}

package/lib/math/Rotation.d.ts

@@ -0,0 +1,16 @@
+import { Vector2 } from "./Vector2";
+export declare class Rotation {
+    private _degrees;
+    private _radians;
+    private _direction;
+    constructor(config?: {
+        radians?: number;
+        degrees?: number;
+    });
+    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

@@ -0,0 +1,33 @@
+/**
+ * @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 value
+ */
+export declare const random: (min: number, max: 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

@@ -0,0 +1,114 @@
+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/collision/CollisionData.d.ts

@@ -0,0 +1,8 @@
+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/CollisionManager.d.ts

@@ -0,0 +1,27 @@
+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/QuadTree.d.ts

@@ -0,0 +1,32 @@
+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/collider/ICollider.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,31 @@
+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/AABBResolver.d.ts

@@ -0,0 +1,14 @@
+import { CollisionData } from "../CollisionData";
+import { Shape } from "../shape/Shape";
+import { ICollisionResolver } from "./ICollisionResolver";
+export declare class AABBResolver implements ICollisionResolver {
+    private shape1Rect;
+    private shape2Rect;
+    private overlapX;
+    private overlapY;
+    private minOverlap;
+    private displaceDirection;
+    getCollisionData(shape1: Shape, shape2: Shape): CollisionData | null;
+    private setShapeRect;
+    private preventContainment;
+}

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

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

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

@@ -0,0 +1,14 @@
+import { Shape } from "../shape/Shape";
+import { CollisionData } from "../CollisionData";
+import { ICollisionResolver } from "./ICollisionResolver";
+export declare class SatResolver implements ICollisionResolver {
+    private axes;
+    private proj1;
+    private proj2;
+    private currentOverlap;
+    private minOverlap;
+    private displaceDirection;
+    getCollisionData(shape1: Shape, shape2: Shape): CollisionData | null;
+    private projectShapeOntoAxis;
+    private preventContainment;
+}

package/lib/physics/collision/shape/Rectangle.d.ts

@@ -0,0 +1,13 @@
+import { Vector2 } from "../../../math/Vector2";
+import { Shape } from "./Shape";
+export declare class Rectangle extends Shape {
+    private cacheVector;
+    private axes;
+    constructor(position: Vector2, width: number, height: number, angle?: number);
+    update(): void;
+    private updateModel;
+    private updateDirection;
+    private updateAxes;
+    clone(): Rectangle;
+    getAxes(): Vector2[];
+}

package/lib/physics/collision/shape/Shape.d.ts

@@ -0,0 +1,28 @@
+import { Vector2 } from "../../../math/Vector2";
+export declare enum ShapeType {
+    Rectangle = 0
+}
+export declare abstract class Shape {
+    protected _type: ShapeType;
+    protected _model: Vector2[];
+    protected _vertices: Vector2[];
+    protected _position: Vector2;
+    protected _direction: Vector2;
+    protected _height: number;
+    protected _width: number;
+    protected _angle: number;
+    get type(): ShapeType;
+    get position(): Vector2;
+    set position(position: Vector2);
+    get angle(): number;
+    set angle(angle: number);
+    get width(): number;
+    set width(width: number);
+    get height(): number;
+    set height(height: number);
+    get direction(): Vector2;
+    get vertices(): Vector2[];
+    abstract update(): void;
+    abstract clone(): Shape;
+    abstract getAxes(): Vector2[];
+}

package/lib/rendering/CameraData.d.ts

@@ -0,0 +1,9 @@
+import { Rectangle } from "../math/Rectangle";
+export declare class CameraData {
+    depth: number;
+    layers: string[];
+    originalViewportRect: Rectangle;
+    viewportRect: Rectangle;
+    worldSpaceRect: Rectangle;
+    zoom: number;
+}

package/lib/rendering/ContextRenderer.d.ts

@@ -0,0 +1,6 @@
+import { CameraData } from "./CameraData";
+import { RenderData } from "./renderData/RenderData";
+export interface ContextRenderer {
+    render(camera: CameraData, renderData: RenderData): void;
+    clearCanvas(color: string | null): void;
+}

package/lib/rendering/CullingService.d.ts

@@ -0,0 +1,11 @@
+import { CameraData } from "./CameraData";
+import { RenderData } from "./renderData/RenderData";
+export declare class CullingService {
+    applyCulling(camera: CameraData, renderDataCollection: RenderData[]): RenderData[];
+    private cullSprite;
+    private cullTilemap;
+    private cullCollider;
+    private cullGeometric;
+    private cullText;
+    private isTargetVisible;
+}

package/lib/rendering/FontAtlasFactory.d.ts

@@ -0,0 +1,24 @@
+export declare class FontAtlasFactory {
+    private bitmapSize;
+    private chars;
+    private fontAtlas;
+    private loading;
+    hasFontAtlas(fontFamily: string): boolean;
+    loadingFontAtlas(fontFamily: string): boolean;
+    getFontAtlas(fontFamily: string): FontAtlas;
+    asyncCreate(charRanges: number[], fontFamily: string, fontUrl?: string, bitmapSize?: number): void;
+    private loadFont;
+    private renderAtlas;
+}
+export declare class FontAtlas {
+    readonly name: string;
+    readonly canvas: HTMLCanvasElement;
+    readonly glyphsData: Map<string, GlyphData>;
+    constructor(name: string);
+}
+export interface GlyphData {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}

package/lib/rendering/RenderManager.d.ts

@@ -0,0 +1,22 @@
+import { ContextRenderer } from "./ContextRenderer";
+import { RenderData } from "./renderData/RenderData";
+import { CameraData } from "./CameraData";
+import { CullingService } from "./CullingService";
+export declare class RenderManager {
+    private renderer;
+    private cullingService;
+    private canvasColor;
+    private debug;
+    private renderData;
+    private cameraData;
+    constructor(gameRenderer: ContextRenderer, cullingService: CullingService, canvasColor: string, debug?: boolean);
+    clearCanvas(): void;
+    addRenderData(renderData: RenderData): void;
+    addCameraData(cameraData: CameraData): void;
+    render(): void;
+    clearData(): void;
+    private renderByCamera;
+    private orderRendeData;
+    private updateFromCameraViewport;
+    private setPositionInViewport;
+}

package/lib/rendering/context2D/Context2DRenderer.d.ts

@@ -0,0 +1,19 @@
+import { CameraData } from "../CameraData";
+import { ContextRenderer } from "../ContextRenderer";
+import { RenderData } from "../renderData/RenderData";
+export declare class Context2DRenderer implements ContextRenderer {
+    private canvas;
+    private canvasContext;
+    private imagePosition;
+    constructor(canvas: HTMLCanvasElement);
+    clearCanvas(color?: string | null): void;
+    render(camera: CameraData, renderData: RenderData): void;
+    private renderImage;
+    private renderTilemap;
+    private renderText;
+    private renderGeometric;
+    private renderCollider;
+    private applyZoom;
+    private updateRenderPosition;
+    private centerImage;
+}

package/lib/rendering/renderData/ColliderRenderData.d.ts

@@ -0,0 +1,7 @@
+import { Shape } from "../../physics/collision/shape/Shape";
+import { RenderData, RenderDataType } from "./RenderData";
+export declare class ColliderRenderData extends RenderData {
+    type: RenderDataType;
+    color: string;
+    shape: Shape;
+}

package/lib/rendering/renderData/GeometricRenderData.d.ts

@@ -0,0 +1,12 @@
+import { Rectangle } from "../../math/Rectangle";
+import { RenderData, RenderDataType } from "./RenderData";
+declare type Geometric = Rectangle;
+declare type GeometricType = "Rectangle";
+export declare class GeometricRenderData extends RenderData {
+    type: RenderDataType;
+    color: string;
+    geometricType: GeometricType;
+    geometric: Geometric;
+    getGeometric<T extends Geometric>(): T;
+}
+export {};

package/lib/rendering/renderData/ImageRenderData.d.ts

@@ -0,0 +1,22 @@
+import { RenderData, RenderDataType } from "./RenderData";
+export interface Slice {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class ImageRenderData extends RenderData {
+    type: RenderDataType;
+    image: HTMLImageElement;
+    width: number;
+    height: number;
+    slice: Slice;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+    rotation: number;
+    smooth: boolean;
+    alpha: number;
+    maskColor: string;
+    maskColorMix: number;
+    tintColor: string;
+}