kippy 0.4.0 → 0.5.0

package/README.md

@@ -67,6 +67,7 @@ const entity = new Entity({
     position, // Entity's position (centered), type Vector2
     rotation, // Entity's rotation in radians, type number
     body, // Entity's physical body, type EntityBody
+    collider, // Entity's collider, type Collider
 });
 
 // Add it to a scene
@@ -84,7 +85,7 @@ entity.rotation; // Initialized from the "rotation" param above, 0 if not specif
 
 ### Create a sprite
 
-A sprite represents what an entity looks like, the "graphics part", you can create a sprite like this:
+A sprite represents what an entity looks like (the "graphics part"), and you can create a sprite like this:
 ```js
 import { Sprite } from "kippy";
 
@@ -100,7 +101,7 @@ entity.sprite = sprite;
 
 ### Add controls
 
-Game controls like mouse presses, key presses, touch, and cursor traking (in the game canvas, not the web window) can be done by using the input handler from your `game` instance:
+Game controls like mouse presses, key presses, touch, and cursor tracking (in the game canvas, not the web window) can be done by using the input handler from your `game` instance:
 ```js
 const input = game.input;
 ```
@@ -123,7 +124,7 @@ input.pointer.y; // Current Y position of mouse/touch
 
 ### Vectors
 
-To work with positions and movements in Kippy, it is best to know about `Vector2` first. Positions, velocities, forces, etc are all represented as vectors in Kippy. And here is how you can create a 2D vector and some vector math utilities that comes along with it:
+To work with positions and movements in Kippy, it is best to know about `Vector2` first. Positions, velocities, forces, etc are all represented as vectors in Kippy. And here are how you can create a 2D vector and some vector math utilities that come along with it:
 ```js
 import { Vector2 } from "kippy";
 
@@ -134,17 +135,31 @@ vect.x; // X coordinate
 vect.y; // Y coordinate
 
 // Utilities
+vect.toString(); // Returns "Vector2(x, y)"
 vect.add(otherVect); // Add another vector and return the result vector
 vect.sub(otherVect); // Subtract another vector and return the result vector
+vect.mul(otherVect); // Multiply with another vector and return the result vector
+vect.div(otherVect); // Divide by another vector and return the result vector
+vect.neg(); // Negate and return the result vector
 vect.scale(scale); // Multiply with scale and return the result vector
 vect.magnitude(); // Return the magnitude/length of vector
+vect.magnitudeSquared(); // Return the squared magnitude/length of vector
 vect.normalize(); // Return the normalized vector by magnitude
 vect.dot(otherVect); // Return dot product with another vector
+vect.cross(otherVect); // Return cross product with another vector
+vect.project(otherVect); // Return projection on another vector
+vect.min(otherVect); // Return a new vector with min coordinates
+vect.max(otherVect); // Return a new vector with max coordinates
+vect.floor(); // Floor rounding
+vect.ceil(); // Ceil rounding
+vect.round(); // Normal rounding
 vect.distance(otherVect); // Return distance to another vector
+vect.distanceSquared(otherVect); // Return squared distance to another vector
 vect.copy(); // Return a copy (same coordinates, different reference)
 vect.lerp(otherVect, scale); // Apply linear interpolation and return
 vect.clamp(maxLength); // Clamp vector to have length below maxLength
 vect.rotate(angle); // Return rotated vector by provided angle
+vect.orthogonal(); // Return orthogonal vector of this vector
 vect.angle(); // Return angle of vector.
 vect.angleTo(otherVec); // Return angle between this and another vector
 vect.reflect(otherVect); // Return reflection/bounce back vector
@@ -163,14 +178,17 @@ Vector2.RIGHT; // Vector2(1, 0);
 
 For movements, currently you can create a `RigidBody`:
 ```js
+import { RigidBody } from "kippy";
+
 // Create a rigid body
 const rigidBody = new RigidBody({
     velocity, // Entity's velocity vector, type Vector2
-    rotationVelocity, // Entity's ngular/rotation velocity, type number
+    rotationVelocity, // Entity's angular/rotation velocity, type number
     mass, // Entity's mass, type number
     inertia, // Entity's inertia, type number
     force, // Entity's force vector, type Vector2
     torque, // Entity's torque/rotational force, type number
+    restitution // Entity's restitution for collision bounce back, type number
 });
 
 // Attach body to an entity
@@ -184,11 +202,53 @@ entity.body.inertia; // Set with the matching parameter above, default is 1
 // Note that forces are reset after every frame
 entity.body.force; // Set with the matching parameter above, default is Vector2(0, 0)
 entity.body.torque; // Set with the matching parameter above, default is 0
+entity.body.restitution; // Set with the matching parameter above, default is 0
 ```
 
-Collisions to be added.
+For collisions, you can create a `CircleCollider` for now:
+```js
+import { CircleCollider } from "kippy";
+
+const collider = new CircleCollider({
+    radius, // Circle collider's radius, type number
+    offset, // Offset from entity's position, type Vector2
+    isTrigger, // If true, trigger callbacks are called and collision physics like bouncing 
+               // will not apply. Otherwise, collision callbacks are called and physics apply
+    layer, // A bit mask to determine what collision layer this collider is at
+    mask, // A bit mask to check what colliders to collide
+});
+
+// Attach collider to an entity
+entity.collider = collider;
+
+// You can mutate these props to configure the collider
+collider.radius; // Set with the matching parameter above, required
+collider.offset; // Set with the matching parameter above, default is Vector2(0, 0)
+collider.isTrigger; // Set with the matching parameter above, default is false
+collider.layer; // Set with the matching parameter above, default is (1 << 0)
+collider.mask; // Set with the matching parameter above, default is 0xFFFFFFFF
+```
 
-## Camera
+And you can handle when two objects collide:
+```js
+collider.onCollisionEnter = (other, info) => {};
+collider.onCollisionStay = (other, info) => {};
+collider.onCollisionExit = (other, info) => {};
+collider.onTriggerEnter = (other) => {};
+collider.onTriggerStay = (other) => {};
+collider.onTriggerExit = (other) => {};
+```
+
+`info` has the structure of:
+```js
+{
+    normal, // Vector2
+    penetration, // number
+    contact, // Vector2
+}
+```
+
+### Camera
 
 The camera decides what part of your game world gets rendered. Note that unlike most camera implementations of which positions are centered, Kippy's camera position is at the top-left of the camera. For example, camera at (0,0) and entity at (0,0) in Godot would show the entity at the center, while the same setup in Kippy would show the entity at the top-left. This is to be more aligned with how web and canvas positioning works.
 
@@ -214,9 +274,25 @@ To be added, for now mutate `entity.sprite` to swap sprites and create animation
 
 To be added, for now use web's built-in `Audio` class.
 
-### Asset management
+### Sleep system
 
-To be added.
+When a body's velocity is too low for too long, the body will enter sleep state, which means its position will not be affected by the physics engine until a force is applied or a collision happens, this is to prevent jittering and optimize performance.
+
+You can configure it inside `RigidBody`:
+```js
+const rigidBody = new RigidBody({
+    sleepThreshold, // The low threshold velocity to enter sleep state, type number
+    sleepTimeThreshold, // The duration of sustained low velocity to enter sleep state, type number
+    isSleeping, // Flag to set sleep state, type boolean
+    sleepTimer // Current sleep timer, you probably don't need this
+});
+
+// You can mutate these to change sleep configuration:
+rigidBody.sleepThreshold; // Set with the param above, default is 0.1
+rigidBody.sleepTimeThreshold; // Set with the param above, default is 0.5
+rigidBody.isSleeping; // Set with the param above, default is false
+rigidBody.sleepTimer; // Set with the param above, default is 0
+```
 
 ## Copyrights and License
 

package/dist/entity.d.ts

@@ -1,4 +1,4 @@
-import { EntityBody } from "./physics.js";
+import { Collider, CollisionInfo, EntityBody } from "./physics.js";
 import { Sprite } from "./sprite.js";
 import { Vector2 } from "./vector.js";
 export interface EntityOptions {
@@ -6,12 +6,20 @@ export interface EntityOptions {
     position?: Vector2;
     rotation?: number;
     body?: EntityBody;
+    collider?: Collider;
 }
 export declare class Entity {
     sprite?: Sprite;
     position: Vector2;
     rotation: number;
     body?: EntityBody;
+    collider?: Collider;
     constructor(options?: EntityOptions);
+    onCollisionEnter?: (other: Entity, info: CollisionInfo) => void;
+    onCollisionStay?: (other: Entity, info: CollisionInfo) => void;
+    onCollisionExit?: (other: Entity, info: CollisionInfo) => void;
+    onTriggerEnter?: (other: Entity) => void;
+    onTriggerStay?: (other: Entity) => void;
+    onTriggerExit?: (other: Entity) => void;
     render(ctx: CanvasRenderingContext2D): void;
 }

package/dist/entity.js

@@ -1,21 +1,32 @@
 import { Vector2 } from "./vector.js";
 export class Entity {
+    // Basic entity structure
     sprite;
     position;
     rotation;
     body;
+    collider;
     constructor(options = {}) {
         this.sprite = options.sprite;
         this.position = options.position ?? new Vector2(0, 0);
         this.rotation = options.rotation ?? 0;
         this.body = options.body;
+        this.collider = options.collider;
     }
+    // Event handlers
+    onCollisionEnter;
+    onCollisionStay;
+    onCollisionExit;
+    onTriggerEnter;
+    onTriggerStay;
+    onTriggerExit;
+    // Render with sprite
     render(ctx) {
         if (this.sprite) {
             ctx.save();
             ctx.translate(this.position.x, this.position.y);
             ctx.rotate(this.rotation);
-            ctx.drawImage(this.sprite.texture, -this.sprite.width / 2, -this.sprite.height / 2);
+            ctx.drawImage(this.sprite.texture, -this.sprite.width / 2, -this.sprite.height / 2, this.sprite.width, this.sprite.height);
             ctx.restore();
         }
     }

package/dist/game.d.ts

@@ -13,6 +13,7 @@ export declare class Game {
     lastTime: number;
     input: Input;
     physics: Physics;
+    paused: boolean;
     constructor(options: GameOptions);
     setCanvas(canvas: HTMLCanvasElement): void;
     setScene(scene: Scene): void;

package/dist/game.js

@@ -7,6 +7,7 @@ export class Game {
     lastTime = 0;
     input;
     physics;
+    paused = false;
     constructor(options) {
         this.canvas = options.canvas;
         this.ctx = this.canvas.getContext("2d");
@@ -24,10 +25,21 @@ export class Game {
         this.scene.init();
     }
     start() {
+        window.addEventListener("blur", () => {
+            this.paused = true;
+        });
+        window.addEventListener("focus", () => {
+            this.paused = false;
+            this.lastTime = performance.now(); // Reset!
+        });
         requestAnimationFrame(this.loop.bind(this));
     }
     // Game loop
     loop(timestamp) {
+        if (this.paused) {
+            requestAnimationFrame(this.loop.bind(this));
+            return;
+        }
         const dt = (timestamp - this.lastTime) / 1000;
         this.lastTime = timestamp;
         if (this.scene) {
@@ -36,7 +48,7 @@ export class Game {
             // Update game logic
             this.scene.update(dt);
             // Update physics info
-            this.physics.update(this.scene.entities);
+            this.physics.update(this.scene.entities, dt);
             // Render
             this.ctx.clearRect(0, 0, this.ctx.canvas.width, this.ctx.canvas.height);
             this.scene.render();

package/dist/physics.d.ts

@@ -7,6 +7,11 @@ export interface RigidBodyOptions {
     inertia?: number;
     force?: Vector2;
     torque?: number;
+    restitution?: number;
+    sleepThreshold?: number;
+    sleepTimeThreshold?: number;
+    isSleeping?: boolean;
+    sleepTimer?: number;
 }
 export declare class RigidBody {
     velocity: Vector2;
@@ -15,9 +20,65 @@ export declare class RigidBody {
     inertia: number;
     force: Vector2;
     torque: number;
+    restitution: number;
+    sleepThreshold: number;
+    sleepTimeThreshold: number;
+    isSleeping: boolean;
+    sleepTimer: number;
     constructor(options?: RigidBodyOptions);
+    wake(): void;
 }
 export type EntityBody = RigidBody;
+export interface CircleColliderOptions {
+    radius: number;
+    offset?: Vector2;
+    isTrigger?: boolean;
+    layer?: number;
+    mask?: number;
+}
+export declare class CircleCollider {
+    radius: number;
+    offset: Vector2;
+    isTrigger: boolean;
+    layer: number;
+    mask: number;
+    constructor(options: CircleColliderOptions);
+}
+export type Collider = CircleCollider;
+export interface SpatialGridOptions {
+    cellSize?: number;
+    grid?: Map<string, Set<Entity>>;
+}
+export declare class SpatialGrid {
+    cellSize: number;
+    grid: Map<string, Set<Entity>>;
+    constructor(options?: SpatialGridOptions);
+    clear(): void;
+    adaptCellSize(entities: Entity[]): void;
+    insert(entity: Entity): void;
+    getNearby(entity: Entity): Entity[];
+    getEntityBounds(entity: Entity): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+}
+export interface CollisionInfo {
+    normal: Vector2;
+    penetration: number;
+    contact: Vector2;
+    accumulatedNormalImpulse: number;
+}
+export interface CollisionResult {
+    isTrigger: boolean;
+    info?: CollisionInfo;
+}
 export declare class Physics {
-    update(entities: Entity[]): void;
+    collisionPairs: Map<Entity, Map<Entity, CollisionInfo>>;
+    spatialGrid: SpatialGrid;
+    entityCount: number;
+    update(entities: Entity[], dt: number): void;
+    checkCollision(entityA: Entity, entityB: Entity): CollisionResult;
+    resolveCollision(entityA: Entity, entityB: Entity, info: CollisionInfo, dt: number): void;
 }

package/dist/physics.js

@@ -6,6 +6,11 @@ export class RigidBody {
     inertia;
     force;
     torque;
+    restitution;
+    sleepThreshold;
+    sleepTimeThreshold;
+    isSleeping;
+    sleepTimer;
     constructor(options = {}) {
         this.velocity = options.velocity ?? new Vector2(0, 0);
         this.rotationVelocity = options.rotationVelocity ?? 0;
@@ -13,25 +18,377 @@ export class RigidBody {
         this.inertia = options.inertia ?? 1;
         this.force = options.force ?? new Vector2(0, 0);
         this.torque = options.torque ?? 0;
+        this.restitution = options.restitution ?? 0;
+        this.sleepThreshold = options.sleepThreshold ?? 0.1;
+        this.sleepTimeThreshold = options.sleepTimeThreshold ?? 0.5;
+        this.isSleeping = options.isSleeping ?? false;
+        this.sleepTimer = options.sleepTimer ?? 0;
+    }
+    wake() {
+        this.isSleeping = false;
+        this.sleepTimer = 0;
+    }
+}
+export class CircleCollider {
+    radius;
+    offset;
+    isTrigger;
+    layer;
+    mask;
+    constructor(options) {
+        this.radius = options.radius;
+        this.offset = options.offset ?? new Vector2(0, 0);
+        this.isTrigger = options.isTrigger ?? false;
+        this.layer = options.layer ?? (1 << 0);
+        this.mask = options.mask ?? 0xFFFFFFFF;
     }
 }
+export class SpatialGrid {
+    cellSize;
+    grid;
+    constructor(options = {}) {
+        this.cellSize = options.cellSize || 100;
+        this.grid = options.grid || new Map();
+    }
+    clear() {
+        this.grid.clear();
+    }
+    // Auto update cell size
+    adaptCellSize(entities) {
+        // Sample entity sizes
+        const sizes = [];
+        for (const entity of entities) {
+            const bounds = this.getEntityBounds(entity);
+            const width = bounds.maxX - bounds.minX;
+            const height = bounds.maxY - bounds.minY;
+            const maxDimension = Math.max(width, height);
+            sizes.push(maxDimension);
+        }
+        // Use median or 75th percentile (ignore outliers)
+        sizes.sort((a, b) => a - b);
+        const percentile75 = sizes[Math.floor(sizes.length * 0.75)];
+        // Multiply by 2-3x (common heuristic)
+        this.cellSize = percentile75 * 2.5;
+    }
+    // Insert entity into grid
+    insert(entity) {
+        if (entity.collider) {
+            // Get bounds of entity ('s collider)
+            const bounds = this.getEntityBounds(entity);
+            // Insert into all cells it overlaps
+            const minCellX = Math.floor(bounds.minX / this.cellSize);
+            const maxCellX = Math.floor(bounds.maxX / this.cellSize);
+            const minCellY = Math.floor(bounds.minY / this.cellSize);
+            const maxCellY = Math.floor(bounds.maxY / this.cellSize);
+            for (let cx = minCellX; cx <= maxCellX; cx++) {
+                for (let cy = minCellY; cy <= maxCellY; cy++) {
+                    const key = `${cx},${cy}`;
+                    if (!this.grid.has(key)) {
+                        this.grid.set(key, new Set());
+                    }
+                    this.grid.get(key).add(entity);
+                }
+            }
+        }
+    }
+    // Get nearby entities (checks 3x3 grid around entity)
+    getNearby(entity) {
+        const centerX = Math.floor(entity.position.x / this.cellSize);
+        const centerY = Math.floor(entity.position.y / this.cellSize);
+        const nearby = new Set();
+        // Check 3x3 grid of cells
+        for (let dx = -1; dx <= 1; dx++) {
+            for (let dy = -1; dy <= 1; dy++) {
+                const key = `${centerX + dx},${centerY + dy}`;
+                const cell = this.grid.get(key);
+                if (cell) {
+                    for (const e of cell) {
+                        if (e !== entity) {
+                            nearby.add(e);
+                        }
+                    }
+                }
+            }
+        }
+        return Array.from(nearby);
+    }
+    // Helper to get entity bounds
+    getEntityBounds(entity) {
+        if (entity.collider instanceof CircleCollider) {
+            const radius = entity.collider.radius;
+            return {
+                minX: entity.position.x - radius,
+                maxX: entity.position.x + radius,
+                minY: entity.position.y - radius,
+                maxY: entity.position.y + radius
+            };
+        }
+        else {
+            throw new Error("Collider type not supported");
+        }
+    }
+}
+// Physics engine
 export class Physics {
-    update(entities) {
+    collisionPairs = new Map(); // To store past collisions
+    spatialGrid = new SpatialGrid();
+    entityCount = 0;
+    update(entities, dt) {
+        // Update velocity/apply force
         for (const entity of entities) {
             if (entity.body instanceof RigidBody) {
+                // Wake if force applied
+                if (entity.body.force.magnitudeSquared() > 0 || entity.body.torque !== 0) {
+                    entity.body.wake();
+                }
+                // Skip sleeping bodies with no forces
+                if (entity.body.isSleeping)
+                    continue;
                 // Acceleration/apply force
-                entity.body.velocity.x += entity.body.force.x / entity.body.mass;
-                entity.body.velocity.y += entity.body.force.y / entity.body.mass;
-                entity.body.rotationVelocity += entity.body.torque / entity.body.inertia;
-                // Positional update
-                entity.position.x += entity.body.velocity.x;
-                entity.position.y += entity.body.velocity.y;
-                entity.rotation += entity.body.rotationVelocity;
+                entity.body.velocity.x += entity.body.force.x / entity.body.mass * dt;
+                entity.body.velocity.y += entity.body.force.y / entity.body.mass * dt;
+                entity.body.rotationVelocity += entity.body.torque / entity.body.inertia * dt;
                 // Clear force
                 entity.body.force.x = 0;
                 entity.body.force.y = 0;
                 entity.body.torque = 0;
             }
         }
+        // Rebuild spatial grid for collision handling
+        this.spatialGrid.clear();
+        if (this.entityCount !== entities.length) {
+            this.entityCount = entities.length;
+            this.spatialGrid.adaptCellSize(entities);
+        }
+        for (const entity of entities) {
+            this.spatialGrid.insert(entity);
+        }
+        // Handle collisions - PHASE 1: Detect and collect all contacts
+        const currentCollisions = new Map(); // To update this.collisionPairs and check duplicates
+        const contacts = [];
+        for (const entity of entities) {
+            if (entity.collider) {
+                const nearby = this.spatialGrid.getNearby(entity);
+                for (const other of nearby) {
+                    if (other.collider) {
+                        // Check duplicate
+                        if ((currentCollisions.has(entity) && currentCollisions.get(entity)?.has(other)) ||
+                            (currentCollisions.has(other) && currentCollisions.get(other)?.has(entity))) {
+                            continue;
+                        }
+                        // Check collision
+                        const collisionResult = this.checkCollision(entity, other);
+                        if (collisionResult.info) {
+                            // Track collision
+                            if (!currentCollisions.has(entity)) {
+                                currentCollisions.set(entity, new Map());
+                            }
+                            currentCollisions.get(entity)?.set(other, collisionResult.info);
+                            // Check if this is a new collision
+                            const wasColliding = (this.collisionPairs.get(entity)?.has(other) ||
+                                this.collisionPairs.get(other)?.has(entity));
+                            if (!wasColliding) {
+                                // ENTER
+                                entity.body?.wake();
+                                other.body?.wake();
+                                if (collisionResult.isTrigger) {
+                                    entity.onTriggerEnter?.(other);
+                                    other.onTriggerEnter?.(entity);
+                                }
+                                else {
+                                    entity.onCollisionEnter?.(other, collisionResult.info);
+                                    other.onCollisionEnter?.(entity, {
+                                        ...collisionResult.info,
+                                        normal: new Vector2(-collisionResult.info.normal.x, -collisionResult.info.normal.y)
+                                    });
+                                }
+                            }
+                            else {
+                                // STAY
+                                if (collisionResult.isTrigger) {
+                                    entity.onTriggerStay?.(other);
+                                    other.onTriggerStay?.(entity);
+                                }
+                                else {
+                                    entity.onCollisionStay?.(other, collisionResult.info);
+                                    other.onCollisionStay?.(entity, {
+                                        ...collisionResult.info,
+                                        normal: new Vector2(-collisionResult.info.normal.x, -collisionResult.info.normal.y)
+                                    });
+                                }
+                            }
+                            // Collect contact for solving
+                            if (!collisionResult.isTrigger) {
+                                contacts.push({
+                                    entityA: entity,
+                                    entityB: other,
+                                    info: collisionResult.info
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // PHASE 2: Iteratively solve all contacts together
+        for (let iteration = 0; iteration < 6; iteration++) {
+            for (const contact of contacts) {
+                this.resolveCollision(contact.entityA, contact.entityB, contact.info, dt);
+            }
+        }
+        // EXIT
+        for (const [entity, others] of this.collisionPairs) {
+            for (const [other, lastInfo] of others) {
+                // Check if still colliding
+                const stillColliding = (currentCollisions.get(entity)?.has(other) ||
+                    currentCollisions.get(other)?.has(entity));
+                if (!stillColliding) {
+                    // Determine if was a trigger
+                    const wasTrigger = entity.collider?.isTrigger || other.collider?.isTrigger;
+                    if (wasTrigger) {
+                        entity.onTriggerExit?.(other);
+                        other.onTriggerExit?.(entity);
+                    }
+                    else {
+                        entity.onCollisionExit?.(other, lastInfo);
+                        other.onCollisionExit?.(entity, {
+                            ...lastInfo,
+                            normal: new Vector2(-lastInfo.normal.x, -lastInfo.normal.y)
+                        });
+                    }
+                }
+            }
+        }
+        // Update tracked collisions
+        this.collisionPairs = currentCollisions;
+        // Update position
+        for (const entity of entities) {
+            if (entity.body instanceof RigidBody) {
+                // Skip sleeping bodies
+                if (entity.body.isSleeping)
+                    continue;
+                // Positional update
+                entity.position.x += entity.body.velocity.x * dt;
+                entity.position.y += entity.body.velocity.y * dt;
+                entity.rotation += entity.body.rotationVelocity * dt;
+                // Sleep accumulation
+                const speed = entity.body.velocity.magnitude();
+                const angularSpeed = Math.abs(entity.body.rotationVelocity);
+                if (speed < entity.body.sleepThreshold && angularSpeed < entity.body.sleepThreshold) {
+                    entity.body.sleepTimer += dt;
+                    if (entity.body.sleepTimer >= entity.body.sleepTimeThreshold) {
+                        // Go to sleep
+                        entity.body.isSleeping = true;
+                        entity.body.velocity.x = 0;
+                        entity.body.velocity.y = 0;
+                        entity.body.rotationVelocity = 0;
+                    }
+                }
+                else {
+                    // Reset timer if moving too fast
+                    entity.body.sleepTimer = 0;
+                }
+            }
+        }
+    }
+    checkCollision(entityA, entityB) {
+        if (entityA.collider && entityB.collider) {
+            // Layer/mask filtering
+            if ((entityA.collider.mask & entityB.collider.layer) === 0 ||
+                (entityB.collider.mask & entityA.collider.layer) === 0) {
+                return {
+                    isTrigger: false
+                };
+            }
+            // Get trigger info
+            const isTrigger = entityA.collider.isTrigger || entityB.collider.isTrigger;
+            // Check collision
+            const posA = entityA.position.add(entityA.collider.offset);
+            const posB = entityB.position.add(entityB.collider.offset);
+            // Check different types of colliders, only circle collider for now
+            if (entityA.collider instanceof CircleCollider && entityB.collider instanceof CircleCollider) {
+                const distance = posA.distance(posB);
+                const radiusSum = entityA.collider.radius + entityB.collider.radius;
+                if (distance >= radiusSum) {
+                    return {
+                        isTrigger: false
+                    };
+                }
+                const penetration = radiusSum - distance;
+                const direction = posB.sub(posA);
+                let normal = distance > 0 ? direction.scale(1 / distance) : new Vector2(1, 0);
+                // Warm starting - copy accumulated impulse from last frame if contact persists
+                let accumulatedImpulse = 0;
+                const lastContactInfo = this.collisionPairs.get(entityA)?.get(entityB) ||
+                    this.collisionPairs.get(entityB)?.get(entityA);
+                if (lastContactInfo) {
+                    accumulatedImpulse = lastContactInfo.accumulatedNormalImpulse;
+                }
+                return {
+                    isTrigger,
+                    info: {
+                        normal,
+                        penetration,
+                        contact: posA.add(normal.scale(entityA.collider.radius)),
+                        accumulatedNormalImpulse: accumulatedImpulse
+                    }
+                };
+            }
+            return {
+                isTrigger: false
+            };
+        }
+        return {
+            isTrigger: false
+        };
+    }
+    resolveCollision(entityA, entityB, info, dt) {
+        if (!entityA.body || !entityB.body)
+            return;
+        const bodyA = entityA.body;
+        const bodyB = entityB.body;
+        // Check for infinite mass
+        const invMassA = isFinite(bodyA.mass) ? 1 / bodyA.mass : 0;
+        const invMassB = isFinite(bodyB.mass) ? 1 / bodyB.mass : 0;
+        const totalInvMass = invMassA + invMassB;
+        // If both infinite mass, do nothing
+        if (totalInvMass === 0)
+            return;
+        // Relative velocity
+        const relVel = bodyB.velocity.sub(bodyA.velocity);
+        // Velocity along normal
+        const velAlongNormal = relVel.dot(info.normal);
+        // Don't resolve if velocities are separating
+        if (velAlongNormal > 0)
+            return;
+        // Restitution (bounciness) with slop
+        const restitutionSlop = 0.5; // Kill bounce below 0.5 unit/sec
+        let restitution = Math.max(bodyA.restitution, bodyB.restitution);
+        // No bounce for slow collisions (helps objects settle)
+        if (Math.abs(velAlongNormal) < restitutionSlop) {
+            restitution = 0;
+        }
+        // Position correction with slop (Box2D/PhysX style)
+        const slop = 0.01; // Allow small penetration without correction
+        const baumgarte = 0.2; // Correct 20% of penetration per frame
+        // Bias velocity - only apply when no bounce (restitution = 0)
+        // When bouncing, let restitution handle it naturally
+        const biasVelocity = restitution === 0 ? (Math.max(0, info.penetration - slop) * baumgarte) / dt : 0;
+        // Calculate impulse using inverse mass
+        const jn = (-(1 + restitution) * velAlongNormal + biasVelocity) / totalInvMass;
+        // Clamp accumulated impulse
+        const oldImpulse = info.accumulatedNormalImpulse || 0;
+        info.accumulatedNormalImpulse = Math.max(0, oldImpulse + jn);
+        const actualImpulse = info.accumulatedNormalImpulse - oldImpulse;
+        // Apply actual impulse
+        bodyA.velocity = bodyA.velocity.sub(info.normal.scale(actualImpulse * invMassA));
+        bodyB.velocity = bodyB.velocity.add(info.normal.scale(actualImpulse * invMassB));
+        // Apply angular impulse (torque from contact point)
+        const rA = info.contact.sub(entityA.position);
+        const rB = info.contact.sub(entityB.position);
+        const angularImpulseA = rA.cross(info.normal.scale(-actualImpulse));
+        const angularImpulseB = rB.cross(info.normal.scale(actualImpulse));
+        bodyA.rotationVelocity += angularImpulseA * (isFinite(bodyA.inertia) ? 1 / bodyA.inertia : 0);
+        bodyB.rotationVelocity += angularImpulseB * (isFinite(bodyB.inertia) ? 1 / bodyB.inertia : 0);
     }
 }

package/dist/vector.d.ts

@@ -8,17 +8,31 @@ export declare class Vector2 {
     static LEFT: Vector2;
     static RIGHT: Vector2;
     constructor(x: number, y: number);
+    toString(): string;
     add(other: Vector2): Vector2;
     sub(other: Vector2): Vector2;
+    mul(other: Vector2): Vector2;
+    div(other: Vector2): Vector2;
+    neg(): Vector2;
     scale(scale: number): Vector2;
     magnitude(): number;
+    magnitudeSquared(): number;
     normalize(): Vector2;
     dot(other: Vector2): number;
+    cross(other: Vector2): number;
+    project(other: Vector2): Vector2;
+    min(other: Vector2): Vector2;
+    max(other: Vector2): Vector2;
+    floor(): Vector2;
+    ceil(): Vector2;
+    round(): Vector2;
     distance(other: Vector2): number;
+    distanceSquared(other: Vector2): number;
     copy(): Vector2;
     lerp(other: Vector2, scale: number): Vector2;
     clamp(maxLength: number): Vector2;
     rotate(angle: number): Vector2;
+    orthogonal(): Vector2;
     angle(): number;
     angleTo(other: Vector2): number;
     reflect(normal: Vector2): Vector2;

package/dist/vector.js

@@ -11,18 +11,33 @@ export class Vector2 {
         this.x = x;
         this.y = y;
     }
+    toString() {
+        return `Vector2(${this.x}, ${this.y})`;
+    }
     add(other) {
         return new Vector2(this.x + other.x, this.y + other.y);
     }
     sub(other) {
         return new Vector2(this.x - other.x, this.y - other.y);
     }
+    mul(other) {
+        return new Vector2(this.x * other.x, this.y * other.y);
+    }
+    div(other) {
+        return new Vector2(this.x / other.x, this.y / other.y);
+    }
+    neg() {
+        return new Vector2(-this.x, -this.y);
+    }
     scale(scale) {
         return new Vector2(this.x * scale, this.y * scale);
     }
     magnitude() {
         return Math.sqrt(this.x * this.x + this.y * this.y);
     }
+    magnitudeSquared() {
+        return this.x * this.x + this.y * this.y;
+    }
     normalize() {
         const mag = this.magnitude();
         return mag > 0 ? new Vector2(this.x / mag, this.y / mag) : new Vector2(0, 0);
@@ -30,9 +45,34 @@ export class Vector2 {
     dot(other) {
         return this.x * other.x + this.y * other.y;
     }
+    cross(other) {
+        return this.x * other.y - this.y * other.x;
+    }
+    project(other) {
+        const scalar = this.dot(other) / other.magnitudeSquared();
+        return other.scale(scalar);
+    }
+    min(other) {
+        return new Vector2(Math.min(this.x, other.x), Math.min(this.y, other.y));
+    }
+    max(other) {
+        return new Vector2(Math.max(this.x, other.x), Math.max(this.y, other.y));
+    }
+    floor() {
+        return new Vector2(Math.floor(this.x), Math.floor(this.y));
+    }
+    ceil() {
+        return new Vector2(Math.ceil(this.x), Math.ceil(this.y));
+    }
+    round() {
+        return new Vector2(Math.round(this.x), Math.round(this.y));
+    }
     distance(other) {
         return Math.sqrt((this.x - other.x) ** 2 + (this.y - other.y) ** 2);
     }
+    distanceSquared(other) {
+        return (this.x - other.x) ** 2 + (this.y - other.y) ** 2;
+    }
     copy() {
         return new Vector2(this.x, this.y);
     }
@@ -48,6 +88,9 @@ export class Vector2 {
         const sin = Math.sin(angle);
         return new Vector2(this.x * cos - this.y * sin, this.x * sin + this.y * cos);
     }
+    orthogonal() {
+        return new Vector2(-this.y, this.x);
+    }
     angle() {
         return Math.atan2(this.y, this.x);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kippy",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Kippy 2D web game engine for JS",
   "keywords": [
     "kippy",