angry-pixel 1.1.0 → 1.1.1

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

@@ -1,7 +1,7 @@
 import { Rectangle } from "../../math/Rectangle";
 import { ColliderData } from "./ColliderData";
-import { CollisionResolution } from "./resolver/CollisionResolution";
-import { CollisionResolver } from "./resolver/CollisionResolver";
+import { CollisionMethod } from "./method/CollisionMethod";
+import { CollisionResolution } from "./resolver/CollisionResolver";
 export interface Collision {
     localCollider: ColliderData;
     remoteCollider: ColliderData;
@@ -12,12 +12,12 @@ export declare class CollisionManager {
     private quadTree;
     private bounds;
     private fixedQuadTree;
-    private resolver;
+    private method;
     private collisions;
     private minBounds;
     private maxBounds;
     private newBounds;
-    constructor(resolver: CollisionResolver, quadTreeBounds: Rectangle | null, quadMaxLevel: number, collidersPerQuad: number);
+    constructor(method: CollisionMethod, quadTreeBounds: Rectangle | null, quadMaxLevel: number, collidersPerQuad: number);
     addCollider(collider: ColliderData): void;
     removeCollider(collider: ColliderData): void;
     getFrameCollisionsForCollider(collider: ColliderData): Collision[];

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

@@ -10,5 +10,4 @@ export interface ICollider {
     readonly bottomRightQuadVertex: Vector2;
     readonly topLeftQuadVertex: Vector2;
     readonly topRightQuadVertex: Vector2;
-    readonly updateCollisions: boolean;
 }

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

@@ -6,7 +6,6 @@ export declare class RectangleCollider implements ICollider {
     readonly gameObject: GameObject;
     readonly shape: Rectangle;
     readonly physics: boolean;
-    readonly updateCollisions: boolean;
     private _position;
     private _width;
     private _height;
@@ -14,7 +13,7 @@ export declare class RectangleCollider implements ICollider {
     private _quadVertices;
     private _quadMaxBounds;
     private _quadMinBounds;
-    constructor(position: Vector2, width: number, height: number, physics: boolean, gameObject: GameObject, angle?: number, updateCollisions?: boolean);
+    constructor(position: Vector2, width: number, height: number, physics: boolean, gameObject: GameObject, angle?: number);
     set position(coordinates: Vector2);
     get position(): Vector2;
     set width(width: number);

package/lib/physics/collision/method/AABBMethod.d.ts

@@ -0,0 +1,13 @@
+import { Shape } from "../shape/Shape";
+import { CollisionResolution } from "../resolver/CollisionResolver";
+import { CollisionMethod } from "./CollisionMethod";
+import { AABBResolver } from "../resolver/AABBResolver";
+import { CircumferenceAABBResolver } from "../resolver/CircumferenceAABBResolver";
+import { CircumferenceResolver } from "../resolver/CircumferenceResolver";
+export declare class AABBMethod implements CollisionMethod {
+    private readonly AABBResolver;
+    private readonly circumferenceAABBResolver;
+    private readonly circumferenceResolver;
+    constructor(AABBResolver: AABBResolver, circumferenceAABBResolver: CircumferenceAABBResolver, circumferenceResolver: CircumferenceResolver);
+    getCollisionResolution(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
+}

package/lib/physics/collision/method/CollisionMethod.d.ts

@@ -0,0 +1,5 @@
+import { Shape } from "../shape/Shape";
+import { CollisionResolution } from "../resolver/CollisionResolver";
+export interface CollisionMethod {
+    getCollisionResolution(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
+}

package/lib/physics/collision/method/SatMethod.d.ts

@@ -0,0 +1,11 @@
+import { Shape } from "../shape/Shape";
+import { CollisionResolution } from "../resolver/CollisionResolver";
+import { CollisionMethod } from "./CollisionMethod";
+import { CircumferenceResolver } from "../resolver/CircumferenceResolver";
+import { SatResolver } from "../resolver/SatResolver";
+export declare class SatMethod implements CollisionMethod {
+    private readonly circumferenceResolver;
+    private readonly satResolver;
+    constructor(circumferenceResolver: CircumferenceResolver, satResolver: SatResolver);
+    getCollisionResolution(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
+}

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,10 @@
-import { CollisionResolution } from "./CollisionResolution";
 import { Shape } from "../shape/Shape";
+import { Vector2 } from "../../../math/Vector2";
+export interface CollisionResolution {
+    penetration: number;
+    direction: Vector2;
+    displacementDirection: Vector2;
+}
 export interface CollisionResolver {
-    getCollisionResolution(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
+    resolve(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
 }

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

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

@@ -0,0 +1,11 @@
+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/resolver/SatResolver.d.ts

@@ -1,6 +1,5 @@
 import { Shape } from "../shape/Shape";
-import { CollisionResolution } from "./CollisionResolution";
-import { CollisionResolver } from "./CollisionResolver";
+import { CollisionResolution, CollisionResolver } from "./CollisionResolver";
 export declare class SatResolver implements CollisionResolver {
     private axes;
     private projA;
@@ -9,7 +8,11 @@ export declare class SatResolver implements CollisionResolver {
     private minOverlap;
     private displaceDirection;
     private direction;
-    getCollisionResolution(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
+    private distance;
+    private cache;
+    resolve(shapeA: Shape, shapeB: Shape): CollisionResolution | null;
     private projectShapeOntoAxis;
     private preventContainment;
+    private setCircumferenceAxis;
+    private setCircumferenceVertices;
 }

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

@@ -0,0 +1,18 @@
+import { Rectangle } from "../../../math/Rectangle";
+import { Vector2 } from "../../../math/Vector2";
+import { Shape, ShapeType } from "./Shape";
+export declare class Circumference implements Shape {
+    readonly type: ShapeType;
+    readonly vertices: Vector2[];
+    readonly projectionAxes: Vector2[];
+    readonly boundingBox: Rectangle;
+    readonly angle: number;
+    readonly vertexModel: Vector2[];
+    radius: number;
+    protected _position: Vector2;
+    constructor(radius: number);
+    set position(value: Vector2);
+    get position(): Vector2;
+    update(): void;
+    protected updateBoundingBox(): void;
+}

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

@@ -0,0 +1,19 @@
+import { Rectangle } from "../../../math/Rectangle";
+import { Vector2 } from "../../../math/Vector2";
+import { Shape, ShapeType } from "./Shape";
+export declare class Line implements Shape {
+    vertexModel: [Vector2, Vector2];
+    readonly type: ShapeType;
+    readonly vertices: Vector2[];
+    readonly projectionAxes: Vector2[];
+    readonly boundingBox: Rectangle;
+    angle: number;
+    private _position;
+    constructor(vertexModel: [Vector2, Vector2]);
+    update(): void;
+    set position(value: Vector2);
+    get position(): Vector2;
+    protected updateVertices(): void;
+    protected updateBoundingBox(): void;
+    protected updateProjectionAxes(): void;
+}

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

@@ -2,7 +2,7 @@ import { Rectangle } from "../../../math/Rectangle";
 import { Vector2 } from "../../../math/Vector2";
 export declare enum ShapeType {
     Polygon = 0,
-    Circle = 1,
+    Circumference = 1,
     Line = 2
 }
 export interface Shape {

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

@@ -6,4 +6,5 @@ export interface RigidBodyData {
     velocity: Vector2;
     layersToCollider: string[];
     colliders: ColliderData[];
+    cacheVelocity?: Vector2;
 }

package/lib/rendering/CullingService.d.ts

@@ -4,7 +4,7 @@ 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/context2D/Context2DRenderer.d.ts

@@ -11,6 +11,7 @@ export declare class Context2DRenderer implements ContextRenderer {
     private renderImage;
     private renderTilemap;
     private renderText;
+    private renderGeometric;
     private renderCollider;
     private applyZoom;
     private updateRenderPosition;

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

@@ -1,12 +1,17 @@
 import { Rectangle } from "../../math/Rectangle";
+import { Vector2 } from "../../math/Vector2";
 import { RenderData, RenderDataType } from "./RenderData";
-declare type Geometric = Rectangle;
-declare type GeometricType = "Rectangle";
+export declare enum GeometricShape {
+    Polygon = 0,
+    Circumference = 1,
+    Line = 2
+}
 export declare class GeometricRenderData extends RenderData {
     type: RenderDataType;
     color: string;
-    geometricType: GeometricType;
-    geometric: Geometric;
-    getGeometric<T extends Geometric>(): T;
+    shape: GeometricShape;
+    vertexModel: Vector2[];
+    angle: number;
+    radius: number;
+    boundingBox: Rectangle;
 }
-export {};

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

@@ -3,9 +3,9 @@ import { Vector2 } from "../../math/Vector2";
 export declare enum RenderDataType {
     Image = 0,
     Text = 1,
-    Collider = 2,
-    Tilemap = 3,
-    Mask = 4
+    Tilemap = 2,
+    Mask = 3,
+    Geometric = 4
 }
 export declare abstract class RenderData {
     abstract type: RenderDataType;

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

@@ -1,6 +1,11 @@
 import { Vector2 } from "../../math/Vector2";
-import { Tile } from "../../component/rendering/tilemap/Tile";
 import { RenderData, RenderDataType } from "./RenderData";
+interface Tile {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
 export declare class TileRenderData {
     tile: Tile;
     position: Vector2;
@@ -20,3 +25,4 @@ export declare class TilemapRenderData extends RenderData {
     textureCorrection: number;
     tintColor: string;
 }
+export {};

package/lib/rendering/webGL/renderer/GeometricRenderer.d.ts

@@ -1,7 +1,7 @@
 import { Rectangle } from "../../../math/Rectangle";
 import { LastRender, WebGLContextVersion } from "../WebGLRenderer";
-import { ColliderRenderData } from "../../renderData/ColliderRenderData";
 import { ProgramManager } from "../ProgramManager";
+import { GeometricRenderData } from "../../renderData/GeometricRenderData";
 export declare class GeometricRenderer {
     private gl;
     private programManager;
@@ -9,12 +9,13 @@ export declare class GeometricRenderer {
     private modelMatrix;
     private textureMatrix;
     private readonly vertices;
-    private readonly texVertices;
+    private readonly circumferenceVertices;
     private lastVertices;
     private lastRender;
     constructor(contextVersion: WebGLContextVersion, canvas: HTMLCanvasElement, programManager: ProgramManager);
-    renderCollider(viewportRect: Rectangle, renderData: ColliderRenderData, lastRender: LastRender): void;
-    private renderPolygon;
+    render(viewportRect: Rectangle, renderData: GeometricRenderData, lastRender: LastRender): void;
+    private renderLines;
     private generateVerticesKey;
     private generatePolygonVertices;
+    private renderCircumference;
 }

package/package.json

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