@jiant/canvable 0.0.3 → 0.0.5

package/dist/main.js

@@ -24,8 +24,12 @@ __export(main_exports, {
   Camera: () => Camera,
   Circle: () => Circle,
   CircleBoundingBox: () => CircleBoundingBox,
+  KinematicBody: () => KinematicBody,
   Node: () => Node,
-  Scene: () => Scene2,
+  Scene: () => Scene,
+  Square: () => Square,
+  SquareBoundingBox: () => SquareBoundingBox,
+  StaticBody: () => StaticBody,
   TWO_PI: () => TWO_PI,
   Vector2D: () => Vector2D,
   getCanvas: () => getCanvas
@@ -289,13 +293,14 @@ var Vector2D = class _Vector2D {
   }
 };
 
-// src/nodes/Node.ts
+// src/nodes/shapes/Node.ts
 var import_uuid = require("uuid");
 var Node = class {
   pos;
   id;
   children = [];
   scene;
+  boundingBox;
   constructor(scene, config) {
     this.scene = scene;
     const { id, pos } = config || {};
@@ -322,25 +327,54 @@ var Node = class {
   }
 };
 
-// src/nodes/BoundingBox.ts
+// src/nodes/boundingBox/BoundingBox.ts
 var BoundingBox = class extends Node {
 };
 
-// src/nodes/Camera.ts
-var Camera = class extends Node {
-  zoom;
-  constructor(zoom = 1) {
-    super();
-    this.zoom = zoom;
+// src/nodes/boundingBox/SquareBoundingBox.ts
+var SquareBoundingBox = class _SquareBoundingBox extends BoundingBox {
+  size;
+  constructor(scene, size) {
+    super(scene);
+    this.size = size || new Vector2D(10, 10);
   }
-  update(deltaTime) {
+  checkCollision(other) {
+    if (other instanceof _SquareBoundingBox) {
+      const thisPoint = this.scene?.camera.transformCoordinates(new Vector2D(this.pos.x, this.pos.y));
+      const otherPoint = this.scene?.camera.transformCoordinates(new Vector2D(other.pos.x, other.pos.y));
+      if (!thisPoint || !otherPoint) return { isColliding: false };
+      const dx = Math.abs(thisPoint.x - otherPoint.x);
+      const dy = Math.abs(thisPoint.y - otherPoint.y);
+      const halfWidths = (this.size.x + other.size.x) / 2;
+      const halfHeights = (this.size.y + other.size.y) / 2;
+      if (dx < halfWidths && dy < halfHeights) {
+        const overlapX = halfWidths - dx;
+        const overlapY = halfHeights - dy;
+        if (overlapX < overlapY) {
+          const mtvX = thisPoint.x < otherPoint.x ? -overlapX : overlapX;
+          return { isColliding: true, mtv: new Vector2D(mtvX, 0) };
+        } else {
+          const mtvY = thisPoint.y < otherPoint.y ? -overlapY : overlapY;
+          return { isColliding: true, mtv: new Vector2D(0, mtvY) };
+        }
+      }
+    }
+    if (other instanceof CircleBoundingBox) {
+      const result = other.checkCollision(this);
+      if (result.isColliding && result.mtv) {
+        return { isColliding: true, mtv: new Vector2D(-result.mtv.x, -result.mtv.y) };
+      }
+    }
+    return { isColliding: false };
   }
-  transformCoordinates(position) {
-    return new Vector2D((position.x - this.pos.x) * this.zoom, (position.y - this.pos.y) * this.zoom);
+  isPointInside(_point) {
+    const x_inside = _point.x >= this.pos.x - this.size.x && _point.x <= this.pos.x + this.size.x;
+    const y_inside = _point.y >= this.pos.y - this.size.y && _point.y <= this.pos.y + this.size.y;
+    return x_inside && y_inside;
   }
 };
 
-// src/nodes/CircleBoundingBox.ts
+// src/nodes/boundingBox/CircleBoundingBox.ts
 var CircleBoundingBox = class _CircleBoundingBox extends BoundingBox {
   radius;
   constructor(scene, radius) {
@@ -349,15 +383,28 @@ var CircleBoundingBox = class _CircleBoundingBox extends BoundingBox {
   }
   checkCollision(other) {
     if (other instanceof _CircleBoundingBox) {
-      const thisPoint = this.scene?.camera.transformCoordinates(new Vector2D(this.pos.x, this.pos.y));
-      const otherPoint = this.scene?.camera.transformCoordinates(new Vector2D(other.pos.x, other.pos.y));
-      if (!thisPoint || !otherPoint) return false;
-      const dx = thisPoint.x - otherPoint.x;
-      const dy = thisPoint.y - otherPoint.y;
+      const dx = this.pos.x - other.pos.x;
+      const dy = this.pos.y - other.pos.y;
       const distance = Math.sqrt(dx * dx + dy * dy);
-      return distance < this.radius + other.radius;
+      if (distance < this.radius + other.radius) {
+        const overlap = this.radius + other.radius - distance;
+        const mtv = distance === 0 ? new Vector2D(overlap, 0) : new Vector2D(dx / distance * overlap, dy / distance * overlap);
+        return { isColliding: true, mtv };
+      }
     }
-    return false;
+    if (other instanceof SquareBoundingBox) {
+      const closestX = Math.max(other.pos.x - other.size.x / 2, Math.min(this.pos.x, other.pos.x + other.size.x / 2));
+      const closestY = Math.max(other.pos.y - other.size.y / 2, Math.min(this.pos.y, other.pos.y + other.size.y / 2));
+      const dx = this.pos.x - closestX;
+      const dy = this.pos.y - closestY;
+      const distance = Math.sqrt(dx * dx + dy * dy);
+      if (distance < this.radius) {
+        const overlap = this.radius - distance;
+        const mtv = distance === 0 ? new Vector2D(overlap, 0) : new Vector2D(dx / distance * overlap, dy / distance * overlap);
+        return { isColliding: true, mtv };
+      }
+    }
+    return { isColliding: false };
   }
   isPointInside(_point) {
     const point = this.scene?.camera.transformCoordinates(_point);
@@ -369,40 +416,104 @@ var CircleBoundingBox = class _CircleBoundingBox extends BoundingBox {
   }
 };
 
-// src/nodes/Circle.ts
-var Circle = class extends Node {
-  vel = new Vector2D();
-  size = 10;
-  friction = 0.1;
-  boundingBox = new CircleBoundingBox(this.scene, this.size);
-  constructor(scene, config) {
-    super(scene);
-    this.vel = config?.vel || new Vector2D();
-    this.size = config?.size || 10;
-    this.friction = config?.friction || 0.1;
-    if (config?.startsWithBoundingBox) {
-      this.boundingBox = new CircleBoundingBox(scene, this.size);
-      this.addObject(this.boundingBox);
+// src/nodes/Camera.ts
+var Camera = class extends Node {
+  zoom;
+  constructor(zoom = 1) {
+    super();
+    this.zoom = zoom;
+  }
+  update(deltaTime) {
+  }
+  transformCoordinates(position) {
+    return new Vector2D((position.x - this.pos.x) * this.zoom, (position.y - this.pos.y) * this.zoom);
+  }
+};
+
+// src/nodes/physics/StaticBody.ts
+var StaticBody = class extends Node {
+  shape;
+  constructor(scene, shape) {
+    super(scene, { pos: shape.pos });
+    this.shape = shape;
+    this.pos = shape.pos;
+  }
+  update(_dt) {
+    if (this.shape.update && typeof this.shape.update === "function") {
+      this.shape.update(_dt);
     }
   }
   draw(ctx, selected) {
-    const cameraPos = this.scene?.camera.pos || new Vector2D();
-    const cameraScale = this.scene?.camera.zoom || 1;
-    const relativePos = new Vector2D((this.pos.x - cameraPos.x) * cameraScale, (this.pos.y - cameraPos.y) * cameraScale);
-    if (selected) {
-      ctx.beginPath();
-      ctx.arc(relativePos.x, relativePos.y, this.size + 5, 0, Math.PI * 2);
-      ctx.fillStyle = "transparent";
-      ctx.lineWidth = 3;
-      ctx.strokeStyle = "white";
-      ctx.stroke();
-      ctx.closePath();
+    if (this.shape.draw) this.shape.draw(ctx, selected);
+  }
+};
+
+// src/nodes/physics/KinematicBody.ts
+var KinematicBody = class _KinematicBody extends Node {
+  shape;
+  velocity = new Vector2D();
+  speed = 1500;
+  friction = 0.92;
+  maxSpeed = 800;
+  isColliding = false;
+  constructor(scene, shape, config) {
+    super(scene, { pos: shape.pos });
+    this.shape = shape;
+    if (config?.speed) this.speed = config.speed;
+    if (config?.friction) this.friction = config.friction;
+    if (config?.maxSpeed) this.maxSpeed = config.maxSpeed;
+  }
+  applyForce(x, y, dt) {
+    const len = Math.sqrt(x * x + y * y);
+    if (len > 0) {
+      const scale = this.speed * dt / len;
+      this.velocity.x += x * scale;
+      this.velocity.y += y * scale;
+    }
+  }
+  update(dt) {
+    this.velocity.x *= this.friction;
+    this.velocity.y *= this.friction;
+    const currentSpeed = Math.sqrt(this.velocity.x * this.velocity.x + this.velocity.y * this.velocity.y);
+    if (currentSpeed > this.maxSpeed) {
+      const scale = this.maxSpeed / currentSpeed;
+      this.velocity.x *= scale;
+      this.velocity.y *= scale;
+    }
+    if (Math.abs(this.velocity.x) < 0.1) this.velocity.x = 0;
+    if (Math.abs(this.velocity.y) < 0.1) this.velocity.y = 0;
+    this.pos.x += this.velocity.x * dt;
+    this.pos.y += this.velocity.y * dt;
+    this.shape.pos = this.pos;
+    if (this.shape.update) this.shape.update(dt);
+    this.resolveCollisions();
+  }
+  resolveCollisions() {
+    this.isColliding = false;
+    if (!this.shape.boundingBox) return;
+    if (!this.scene) return;
+    for (const obj of this.scene.children) {
+      if (obj === this) continue;
+      let otherBBox = null;
+      if (obj instanceof StaticBody || obj instanceof _KinematicBody) {
+        if (obj.shape.boundingBox) otherBBox = obj.shape.boundingBox;
+      } else {
+        if (obj.boundingBox) otherBBox = obj.boundingBox;
+      }
+      if (otherBBox) {
+        const result = this.shape.boundingBox.checkCollision(otherBBox);
+        if (result.isColliding && result.mtv) {
+          this.isColliding = true;
+          this.pos.x += result.mtv.x;
+          this.pos.y += result.mtv.y;
+          this.shape.pos = this.pos;
+          if (this.shape.boundingBox) this.shape.boundingBox.pos = this.pos;
+        }
+      }
     }
-    ctx.beginPath();
-    ctx.arc(relativePos.x, relativePos.y, this.size, 0, Math.PI * 2);
-    ctx.fillStyle = "blue";
-    ctx.fill();
-    ctx.closePath();
+  }
+  draw(ctx, selected) {
+    if (this.shape.draw) this.shape.draw(ctx, selected);
   }
 };
 
@@ -428,14 +539,14 @@ var InputManager = class extends Node {
     this.mousePos = new Vector2D(event.clientX, event.clientY);
   }
   handleKeyDown(event) {
-    const key = event.key;
+    const key = event.code;
     if (!this.keyState.get(key)) {
       this.keyState.set(key, true);
       this.keyJustPressed.add(key);
     }
   }
   handleKeyUp(event) {
-    const key = event.key;
+    const key = event.code;
     this.keyState.set(key, false);
     this.keyJustPressed.delete(key);
   }
@@ -474,10 +585,12 @@ var InputManager = class extends Node {
 };
 
 // src/nodes/Scene.ts
-var Scene2 = class extends Node {
+var Scene = class extends Node {
   camera;
   inputManager;
   ctx;
+  animationFrameId = null;
+  running = false;
   lastTime = 0;
   totalTime = 0;
   constructor(ctx, opts) {
@@ -502,7 +615,7 @@ var Scene2 = class extends Node {
     canvas.width = width;
     canvas.height = height;
   }
-  update(deltaTime) {
+  updateFrame(deltaTime) {
     this.camera.update(deltaTime);
     this.children.forEach((child) => {
       if (isUpdatable(child)) {
@@ -510,16 +623,20 @@ var Scene2 = class extends Node {
       }
     });
   }
-  draw(ctx) {
-    ctx.fillStyle = ctx.canvas.style.backgroundColor;
+  drawFrame(ctx) {
+    ctx.fillStyle = ctx.canvas.style.backgroundColor || "black";
     ctx.fillRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+    ctx.save();
+    ctx.translate(ctx.canvas.width / 2, ctx.canvas.height / 2);
     this.children.forEach((child) => {
       if (isDrawable(child)) {
         child.draw(ctx);
       }
     });
+    ctx.restore();
   }
-  gameLoop(callback, targetFPS = 60) {
+  run(callback, targetFPS = 60) {
+    this.running = true;
     const frameInterval = 1e3 / targetFPS;
     let lastFrameTime = 0;
     const loop = (currentTime) => {
@@ -530,8 +647,8 @@ var Scene2 = class extends Node {
           this.lastTime = currentTime;
           this.totalTime += deltaTime;
           lastFrameTime = currentTime - elapsed % frameInterval;
-          this.update(deltaTime);
-          this.draw(this.ctx);
+          this.updateFrame(deltaTime);
+          this.drawFrame(this.ctx);
           if (callback) {
             callback(deltaTime, this.totalTime);
           }
@@ -543,7 +660,14 @@ var Scene2 = class extends Node {
       requestAnimationFrame(loop);
     };
     this.lastTime = performance.now();
-    requestAnimationFrame(loop);
+    this.animationFrameId = requestAnimationFrame(loop);
+  }
+  stop() {
+    if (this.animationFrameId) {
+      cancelAnimationFrame(this.animationFrameId);
+      this.animationFrameId = null;
+    }
+    this.running = false;
   }
 };
 function isUpdatable(obj) {
@@ -553,6 +677,118 @@ function isDrawable(obj) {
   return "draw" in obj;
 }
 
+// src/nodes/shapes/Circle.ts
+var Circle = class extends Node {
+  vel = new Vector2D();
+  size = 10;
+  friction = 0.1;
+  style = {
+    fillStyle: "blue"
+  };
+  constructor(scene, config) {
+    super(scene);
+    this.vel = config?.vel || new Vector2D();
+    this.size = config?.size || 10;
+    this.friction = config?.friction || 0.1;
+    this.style = { ...this.style, ...config?.style };
+    if (config?.startsWithBoundingBox) {
+      this.boundingBox = new CircleBoundingBox(scene, this.size);
+      this.addObject(this.boundingBox);
+    }
+  }
+  update(_deltaTime) {
+    if (this.boundingBox) {
+      this.boundingBox.pos = this.pos;
+    }
+  }
+  draw(ctx, selected) {
+    const cameraPos = this.scene?.camera.pos || new Vector2D();
+    const cameraScale = this.scene?.camera.zoom || 1;
+    const relativePos = new Vector2D((this.pos.x - cameraPos.x) * cameraScale, (this.pos.y - cameraPos.y) * cameraScale);
+    if (selected) {
+      ctx.beginPath();
+      ctx.arc(relativePos.x, relativePos.y, this.size + 5, 0, Math.PI * 2);
+      ctx.fillStyle = "transparent";
+      ctx.lineWidth = 3;
+      ctx.strokeStyle = "white";
+      ctx.stroke();
+      ctx.closePath();
+    }
+    ctx.beginPath();
+    ctx.arc(relativePos.x, relativePos.y, this.size, 0, Math.PI * 2);
+    ctx.fillStyle = this.style.fillStyle || "blue";
+    ctx.fill();
+    if (this.style.strokeStyle) {
+      ctx.strokeStyle = this.style.strokeStyle;
+      ctx.lineWidth = this.style.lineWidth || 1;
+      ctx.stroke();
+    }
+    ctx.closePath();
+  }
+};
+
+// src/nodes/shapes/Square.ts
+var Square = class extends Node {
+  vel = new Vector2D();
+  size;
+  friction = 0.1;
+  style = {
+    fillStyle: "orange"
+  };
+  constructor(scene, config) {
+    super(scene);
+    this.vel = config?.vel || new Vector2D();
+    this.size = config?.size || new Vector2D(10, 10);
+    this.friction = config?.friction || 0.1;
+    this.style = { ...this.style, ...config?.style };
+    if (config?.startsWithBoundingBox) {
+      this.boundingBox = new SquareBoundingBox(scene, this.size);
+      this.addObject(this.boundingBox);
+    }
+  }
+  update(_deltaTime) {
+    if (this.boundingBox) {
+      this.boundingBox.pos = this.pos;
+    }
+  }
+  draw(ctx, selected) {
+    const cameraPos = this.scene?.camera.pos || new Vector2D();
+    const cameraScale = this.scene?.camera.zoom || 1;
+    const relativePos = new Vector2D(
+      (this.pos.x - cameraPos.x) * cameraScale,
+      (this.pos.y - cameraPos.y) * cameraScale
+    );
+    const scaledSize = new Vector2D(this.size.x * cameraScale, this.size.y * cameraScale);
+    if (selected) {
+      ctx.strokeStyle = "white";
+      ctx.lineWidth = 3;
+      ctx.strokeRect(
+        relativePos.x - scaledSize.x / 2 - 5,
+        relativePos.y - scaledSize.y / 2 - 5,
+        scaledSize.x + 10,
+        scaledSize.y + 10
+      );
+    }
+    ctx.fillStyle = this.style.fillStyle || "orange";
+    ctx.fillRect(
+      relativePos.x - scaledSize.x / 2,
+      relativePos.y - scaledSize.y / 2,
+      scaledSize.x,
+      scaledSize.y
+    );
+    if (this.style.strokeStyle) {
+      ctx.strokeStyle = this.style.strokeStyle;
+      ctx.lineWidth = this.style.lineWidth || 1;
+      ctx.strokeRect(
+        relativePos.x - scaledSize.x / 2,
+        relativePos.y - scaledSize.y / 2,
+        scaledSize.x,
+        scaledSize.y
+      );
+    }
+  }
+};
+
 // src/main.ts
 function getCanvas(id) {
   const canvas = document.getElementById(id);
@@ -567,8 +803,12 @@ function getCanvas(id) {
   Camera,
   Circle,
   CircleBoundingBox,
+  KinematicBody,
   Node,
   Scene,
+  Square,
+  SquareBoundingBox,
+  StaticBody,
   TWO_PI,
   Vector2D,
   getCanvas