angry-pixel 1.1.1 → 1.1.3

package/lib/input/GamepadController.d.ts

@@ -9,22 +9,32 @@ export declare class GamepadController {
     update(): void;
     private getGamepads;
 }
+interface GamepadWithVibratorActuator extends Gamepad {
+    vibrationActuator?: {
+        type: string;
+        playEffect: (type: string, config: {
+            duration: number;
+            startDelay: number;
+            weakMagnitude: number;
+            strongMagnitude: number;
+        }) => Promise<string>;
+    };
+}
 export declare class GamepadData {
-    private _connected;
-    private _id;
+    private _gamepad;
     private readonly buttons;
     private readonly axes;
     private readonly _dpadAxes;
     private readonly _leftStickAxes;
     private readonly _rightStickAxes;
-    updateFromGamepad(gamepad: Gamepad): void;
+    updateFromGamepad(gamepad: GamepadWithVibratorActuator): void;
     get id(): string;
+    get connected(): boolean;
     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;
@@ -45,4 +55,6 @@ export declare class GamepadData {
     get leftStickVertical(): number;
     get rightStickHorizontal(): number;
     get rightStickVertical(): number;
+    vibrate(duration?: number, weakMagnitude?: number, strongMagnitude?: number, startDelay?: number): void;
 }
+export {};

package/lib/math/Rectangle.d.ts

@@ -41,10 +41,17 @@ export declare class Rectangle {
      */
     updateFromRect(rect: Rectangle): void;
     /**
-     * Check if the rectangle is overlapping another rectangle
+     * Check if the target rectangle is overlapping
      *
      * @param rect The rectangle to compare
      * @returns TRUE or FALSE
      */
-    overlappingRectangle(rect: Rectangle): boolean;
+    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/Utils.d.ts

@@ -8,9 +8,15 @@ export declare const clamp: (value: number, min: number, max: number) => number;
 /**
  * @param min min value
  * @param max max value
- * @returns the random value
+ * @returns the random int value
  */
-export declare const random: (min: number, max: number) => number;
+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

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

@@ -7,6 +7,7 @@ export interface Collision {
     remoteCollider: ColliderData;
     resolution: CollisionResolution;
 }
+export declare type CollisionMatrix = [string, string][];
 export declare class CollisionManager {
     private colliders;
     private quadTree;
@@ -14,18 +15,21 @@ export declare class CollisionManager {
     private fixedQuadTree;
     private method;
     private collisions;
+    private collisionMatrix;
     private minBounds;
     private maxBounds;
     private newBounds;
-    constructor(method: CollisionMethod, quadTreeBounds: Rectangle | null, quadMaxLevel: number, collidersPerQuad: number);
+    constructor(method: CollisionMethod, quadMaxLevel: number, collidersPerQuad: number, quadTreeBounds?: Rectangle, collisionMatrix?: CollisionMatrix | null);
+    private setupQuadTree;
     addCollider(collider: ColliderData): void;
     removeCollider(collider: ColliderData): void;
-    getFrameCollisionsForCollider(collider: ColliderData): Collision[];
-    refreshCollisionsForCollider(collider: ColliderData): Collision[];
+    getCollisionsForCollider(collider: ColliderData): Collision[];
+    refreshCollisionsForCollider(collider: ColliderData): void;
     clear(): void;
     update(): void;
     private updateNewBounds;
     private updateCollisions;
     private broadPhase;
     private narrowPhase;
+    private isResolved;
 }

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

@@ -1,4 +1,4 @@
-import { Rectangle } from "../shape/Rectangle";
+import { Shape } from "../shape/Shape";
 import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
 export declare class AABBResolver implements CollisionResolver {
     private overlapX;
@@ -6,6 +6,6 @@ export declare class AABBResolver implements CollisionResolver {
     private minOverlap;
     private direction;
     private displacementDirection;
-    resolve(shapeA: Rectangle, shapeB: Rectangle): CollisionResolution | null;
+    resolve({ boundingBox: boxA }: Shape, { boundingBox: boxB }: Shape): CollisionResolution | null;
     private preventContainment;
 }

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

@@ -6,8 +6,7 @@ export declare class SatResolver implements CollisionResolver {
     private projB;
     private currentOverlap;
     private minOverlap;
-    private displaceDirection;
-    private direction;
+    private displacementDirection;
     private distance;
     private cache;
     resolve(shapeA: Shape, shapeB: Shape): CollisionResolution | null;

package/lib/physics/rigodBody/RigidBodyData.d.ts

@@ -1,10 +1,11 @@
 import { Vector2 } from "../../math/Vector2";
 import { ColliderData } from "../collision/ColliderData";
+import { RigidBodyType } from "./RigidBodyManager";
 export interface RigidBodyData {
+    type: RigidBodyType;
     position: Vector2;
     gravity: number;
     velocity: Vector2;
-    layersToCollider: string[];
     colliders: ColliderData[];
     cacheVelocity?: Vector2;
 }

package/lib/physics/rigodBody/RigidBodyManager.d.ts

@@ -2,7 +2,8 @@ import { CollisionManager } from "../collision/CollisionManager";
 import { RigidBodyData } from "./RigidBodyData";
 export declare enum RigidBodyType {
     Static = 0,
-    Dynamic = 1
+    Dynamic = 1,
+    Kinematic = 2
 }
 export declare class RigidBodyManager {
     private readonly collisionManager;
@@ -15,6 +16,8 @@ export declare class RigidBodyManager {
     addRigidBodyData(data: RigidBodyData): void;
     removeRigidBodyData(data: RigidBodyData): void;
     update(deltaTime: number): void;
+    private dynamicUpdate;
+    private kinematicUpdate;
     private applyGravity;
     private applyVelocity;
     private applyReposition;

package/lib/rendering/RenderManager.d.ts

@@ -2,7 +2,14 @@ import { ContextRenderer } from "./ContextRenderer";
 import { RenderData } from "./renderData/RenderData";
 import { CameraData } from "./CameraData";
 import { CullingService } from "./CullingService";
-export declare class RenderManager {
+export interface IRenderManager {
+    clearCanvas(): void;
+    addRenderData(renderData: RenderData): void;
+    addCameraData(cameraData: CameraData): void;
+    render(): void;
+    clearData(): void;
+}
+export declare class RenderManager implements IRenderManager {
     private renderer;
     private cullingService;
     private canvasColor;

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

@@ -1,6 +1,6 @@
 import { Vector2 } from "../../math/Vector2";
 import { RenderData, RenderDataType } from "./RenderData";
-export declare type Orientation = "rightUp" | "rightDown" | "center";
+export declare type Orientation = "rightUp" | "rightDown" | "center" | "rightCenter";
 export declare class TextRenderData extends RenderData {
     type: RenderDataType;
     color: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "angry-pixel",
-    "version": "1.1.1",
+    "version": "1.1.3",
     "description": "Lightweight 2D game engine made with TypeScript.",
     "main": "lib/index.js",
     "types": "lib/index.d.ts",