littlejsengine 1.18.28 → 1.19.3

package/src/engineInput.js

@@ -582,7 +582,7 @@ function inputInit()
         const rect = mainCanvas.getBoundingClientRect();
         const px = percent(mousePos.x, rect.left, rect.right);
         const py = percent(mousePos.y, rect.top, rect.bottom);
-        return vec2(px*mainCanvas.width, py*mainCanvas.height);
+        return vec2(px*mainCanvasSize.x, py*mainCanvasSize.y);
     }
 }
 

package/src/engineLogo.js

@@ -13,10 +13,11 @@ function drawEngineLogo(t)
     const showName = 1;
 
     // LittleJS Logo and Splash Screen
+    // the splash runs before the engine loop so size the canvas here too
+    engineUpdateCanvas();
     const x = mainContext;
-    const dpr = canvasPixelRatio ?? (devicePixelRatio || 1);
-    const w = mainCanvas.width = innerWidth * dpr;
-    const h = mainCanvas.height = innerHeight * dpr;
+    const w = mainCanvasSize.x;
+    const h = mainCanvasSize.y;
     {
         // background
         const p3 = percent(t, 1, .8);

package/src/engineMath.js

@@ -261,6 +261,74 @@ function isIntersecting(start, end, pos, size)
     return true;
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// Collision helpers, none of them change anything that is passed in
+// Boxes are axis aligned and centered on pos with a full size, like drawRect
+// Each returns how far to move the first shape to get it clear, or undefined when they are not touching
+// isOverlapping answers whether two boxes touch, these answer how far out
+
+/** Returns the vector to move circle A by so it no longer overlaps circle B, or undefined
+ *  @param {Vector2} posA - Center of circle A
+ *  @param {number} radiusA
+ *  @param {Vector2} posB - Center of circle B
+ *  @param {number} radiusB
+ *  @return {Vector2|undefined}
+ *  @memberof Math */
+function collideCircleCircle(posA, radiusA, posB, radiusB)
+{
+    const d = posA.subtract(posB);
+    const r = radiusA + radiusB;
+    const dist = d.length();
+    if (dist >= r)
+        return undefined;
+    return d.normalize(r - dist); // coincident centers normalize to straight up
+}
+
+/** Returns the vector to move a circle out of an axis aligned box, or undefined
+ *  @param {Vector2} pos - Center of the circle
+ *  @param {number} radius
+ *  @param {Vector2} boxPos - Center of the box
+ *  @param {Vector2} boxSize - Full size of the box
+ *  @return {Vector2|undefined}
+ *  @memberof Math */
+function collideCircleBox(pos, radius, boxPos, boxSize)
+{
+    const h = boxSize.scale(.5);
+    const closest = vec2(clamp(pos.x, boxPos.x - h.x, boxPos.x + h.x), clamp(pos.y, boxPos.y - h.y, boxPos.y + h.y));
+    const d = pos.subtract(closest), distSq = d.lengthSquared();
+    if (distSq)
+        return distSq >= radius*radius ? undefined : d.normalize(radius - distSq**.5);
+
+    // center is inside the box, push out along the axis of least penetration
+    const offset = pos.subtract(boxPos);
+    return pushOutAxis(offset, h.x - abs(offset.x), h.y - abs(offset.y), radius);
+}
+
+/** Returns the vector to move box A by so it no longer overlaps box B, the shortest way out, or undefined
+ *  - isOverlapping is the yes or no version of this
+ *  @param {Vector2} posA - Center of box A
+ *  @param {Vector2} sizeA - Full size of box A
+ *  @param {Vector2} posB - Center of box B
+ *  @param {Vector2} sizeB - Full size of box B
+ *  @return {Vector2|undefined}
+ *  @memberof Math */
+function collideBoxBox(posA, sizeA, posB, sizeB)
+{
+    const d = posA.subtract(posB);
+    const overlapX = (sizeA.x + sizeB.x)/2 - abs(d.x);
+    const overlapY = (sizeA.y + sizeB.y)/2 - abs(d.y);
+    if (overlapX <= 0 || overlapY <= 0)
+        return undefined;
+    return pushOutAxis(d, overlapX, overlapY);
+}
+
+// the axis with the smallest penetration, pointing the way d does, with extra distance added
+function pushOutAxis(d, penX, penY, extra=0)
+{
+    const s = (v)=> v >= 0 ? 1 : -1; // sign() gives 0 on a tie, which would be no push
+    return penX <= penY ? vec2(s(d.x)*(penX + extra), 0) : vec2(0, s(d.y)*(penY + extra));
+}
+
 /** Returns an oscillating wave between 0 and amplitude with frequency of 1 Hz by default
  *  @param {number} [frequency] - Frequency of the wave in Hz
  *  @param {number} [amplitude] - Amplitude (max height) of the wave
@@ -693,6 +761,7 @@ class Vector2
     distanceSquared(v) { return (this.x - v.x)**2 + (this.y - v.y)**2; }
 
     /** Returns a new vector in same direction as this one with the length passed in
+     * - A zero vector has no direction, so it normalizes to straight up
      * @param {number} [length]
      * @return {Vector2} */
     normalize(length=1)