@vpmedia/phaser 1.0.1 → 1.0.2

package/src/phaser/geom/util/circle.js

@@ -0,0 +1,115 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+import Circle from '../circle';
+import Point from '../point';
+import { degToRad, distance } from '../../util/math';
+
+/**
+ *
+ * @param input
+ * @param output
+ */
+export function clone(input, output = null) {
+  const result = output || new Circle();
+  result.x = input.x;
+  result.y = input.y;
+  result.diameter = input.diameter;
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param x
+ * @param y
+ */
+export function contains(a, x, y) {
+  if (a.radius > 0 && x >= a.left && x <= a.right && y >= a.top && y <= a.bottom) {
+    const dx = (a.x - x) * (a.x - x);
+    const dy = (a.y - y) * (a.y - y);
+    return (dx + dy) <= (a.radius * a.radius);
+  }
+  return false;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ */
+export function equals(a, b) {
+  return (a.x === b.x && a.y === b.y && a.diameter === b.diameter);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ */
+export function intersects(a, b) {
+  return distance(a.x, a.y, b.x, b.y) <= (a.radius + b.radius);
+}
+
+/**
+ *
+ * @param a
+ * @param angle
+ * @param asDegrees
+ * @param output
+ */
+export function circumferencePoint(a, angle, asDegrees = false, output = null) {
+  const result = output || new Point();
+  if (asDegrees === true) {
+    angle = degToRad(angle);
+  }
+  result.x = a.x + a.radius * Math.cos(angle);
+  result.y = a.y + a.radius * Math.sin(angle);
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param angle
+ * @param asDegrees
+ * @param output
+ */
+export function intersectsPoint(a, angle, asDegrees = false, output = null) {
+  const result = output || new Point();
+  if (asDegrees === true) {
+    angle = degToRad(angle);
+  }
+  result.x = a.x + a.radius * Math.cos(angle);
+  result.y = a.y + a.radius * Math.sin(angle);
+  return result;
+}
+
+/**
+ *
+ * @param c
+ * @param r
+ */
+export function intersectsRectangle(c, r) {
+  const cx = Math.abs(c.x - r.x - r.halfWidth);
+  const xDist = r.halfWidth + c.radius;
+  if (cx > xDist) {
+    return false;
+  }
+  const cy = Math.abs(c.y - r.y - r.halfHeight);
+  const yDist = r.halfHeight + c.radius;
+  if (cy > yDist) {
+    return false;
+  }
+  if (cx <= r.halfWidth || cy <= r.halfHeight) {
+    return true;
+  }
+  const xCornerDist = cx - r.halfWidth;
+  const yCornerDist = cy - r.halfHeight;
+  const xCornerDistSq = xCornerDist * xCornerDist;
+  const yCornerDistSq = yCornerDist * yCornerDist;
+  const maxCornerDistSq = c.radius * c.radius;
+  return xCornerDistSq + yCornerDistSq <= maxCornerDistSq;
+}

package/src/phaser/geom/util/ellipse.js

@@ -0,0 +1,30 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+
+/**
+ *
+ */
+export default function () {
+  return true;
+}
+
+/**
+ *
+ * @param a
+ * @param x
+ * @param y
+ */
+export function contains(a, x, y) {
+  if (a.width <= 0 || a.height <= 0) {
+    return false;
+  }
+  //  Normalize the coords to an ellipse with center 0,0 and a radius of 0.5
+  let normx = ((x - a.x) / a.width) - 0.5;
+  let normy = ((y - a.y) / a.height) - 0.5;
+  normx *= normx;
+  normy *= normy;
+  return (normx + normy < 0.25);
+}

package/src/phaser/geom/util/line.js

@@ -0,0 +1,130 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+import Point from '../point';
+import Line from '../line';
+import { intersects as intersectsRect } from './rectangle';
+
+/**
+ *
+ * @param input
+ * @param output
+ */
+export function clone(input, output = null) {
+  const result = output || new Line();
+  result.start.x = input.start.x;
+  result.start.y = input.start.y;
+  result.end.x = input.end.x;
+  result.end.y = input.end.y;
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param e
+ * @param f
+ * @param asSegment
+ * @param output
+ */
+export function intersectsPoints(a, b, e, f, asSegment = true, output = null) {
+  const result = output || new Point();
+  const a1 = b.y - a.y;
+  const a2 = f.y - e.y;
+  const b1 = a.x - b.x;
+  const b2 = e.x - f.x;
+  const c1 = (b.x * a.y) - (a.x * b.y);
+  const c2 = (f.x * e.y) - (e.x * f.y);
+  const denom = (a1 * b2) - (a2 * b1);
+  if (denom === 0) {
+    return null;
+  }
+  result.x = ((b1 * c2) - (b2 * c1)) / denom;
+  result.y = ((a2 * c1) - (a1 * c2)) / denom;
+  if (asSegment) {
+    const uc = ((f.y - e.y) * (b.x - a.x) - (f.x - e.x) * (b.y - a.y));
+    const ua = (((f.x - e.x) * (a.y - e.y)) - (f.y - e.y) * (a.x - e.x)) / uc;
+    const ub = (((b.x - a.x) * (a.y - e.y)) - ((b.y - a.y) * (a.x - e.x))) / uc;
+    if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {
+      return result;
+    }
+    return null;
+  }
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param asSegment
+ * @param result
+ */
+export function intersects(a, b, asSegment, result) {
+  return intersectsPoints(a.start, a.end, b.start, b.end, asSegment, result);
+}
+
+/**
+ *
+ * @param line
+ * @param rect
+ */
+export function intersectsRectangle(line, rect) {
+  //  Quick bail out of the Line and Rect bounds don't intersect
+  if (intersectsRect(line, rect)) {
+    return false;
+  }
+  const x1 = line.start.x;
+  const y1 = line.start.y;
+  const x2 = line.end.x;
+  const y2 = line.end.y;
+  const bx1 = rect.x;
+  const by1 = rect.y;
+  const bx2 = rect.right;
+  const by2 = rect.bottom;
+  let t = 0;
+  //  If the start or end of the line is inside the rect then we assume
+  //  collision, as rects are solid for our use-case.
+  if ((x1 >= bx1 && x1 <= bx2 && y1 >= by1 && y1 <= by2) || (x2 >= bx1 && x2 <= bx2 && y2 >= by1 && y2 <= by2)) {
+    return true;
+  }
+  if (x1 < bx1 && x2 >= bx1) {
+    //  Left edge
+    t = y1 + (y2 - y1) * (bx1 - x1) / (x2 - x1);
+    if (t > by1 && t <= by2) {
+      return true;
+    }
+  } else if (x1 > bx2 && x2 <= bx2) {
+    //  Right edge
+    t = y1 + (y2 - y1) * (bx2 - x1) / (x2 - x1);
+    if (t >= by1 && t <= by2) {
+      return true;
+    }
+  }
+  if (y1 < by1 && y2 >= by1) {
+    //  Top edge
+    t = x1 + (x2 - x1) * (by1 - y1) / (y2 - y1);
+    if (t >= bx1 && t <= bx2) {
+      return true;
+    }
+  } else if (y1 > by2 && y2 <= by2) {
+    //  Bottom edge
+    t = x1 + (x2 - x1) * (by2 - y1) / (y2 - y1);
+    if (t >= bx1 && t <= bx2) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ */
+export function reflect(a, b) {
+  return 2 * b.normalAngle - 3.141592653589793 - a.angle;
+}

package/src/phaser/geom/util/matrix.js

@@ -0,0 +1,48 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+import Matrix from '../matrix';
+
+/**
+ *
+ * @param input
+ * @param output
+ */
+export function clone(input, output = null) {
+  const result = output || new Matrix();
+  result.a = input.a;
+  result.b = input.b;
+  result.c = input.c;
+  result.d = input.d;
+  result.tx = input.tx;
+  result.ty = input.ty;
+  return result;
+}
+
+/**
+ *
+ */
+export function getIdentityMatrix() {
+  if (!window.PhaserRegistry) {
+    window.PhaserRegistry = {};
+  }
+  if (!window.PhaserRegistry.IDENTITY_MATRIX) {
+    window.PhaserRegistry.IDENTITY_MATRIX = new Matrix();
+  }
+  return window.PhaserRegistry.IDENTITY_MATRIX;
+}
+
+/**
+ *
+ */
+export function getTempMatrix() {
+  if (!window.PhaserRegistry) {
+    window.PhaserRegistry = {};
+  }
+  if (!window.PhaserRegistry.TEMP_MATRIX) {
+    window.PhaserRegistry.TEMP_MATRIX = new Matrix();
+  }
+  return window.PhaserRegistry.TEMP_MATRIX;
+}

package/src/phaser/geom/util/point.js

@@ -0,0 +1,276 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+import Point from '../point';
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param output
+ */
+export function add(a, b, output = null) {
+  const result = output || new Point();
+  result.x = a.x + b.x;
+  result.y = a.y + b.y;
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param output
+ */
+export function subtract(a, b, output = null) {
+  const result = output || new Point();
+  result.x = a.x - b.x;
+  result.y = a.y - b.y;
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param output
+ */
+export function multiply(a, b, output = null) {
+  const result = output || new Point();
+  result.x = a.x * b.x;
+  result.y = a.y * b.y;
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param output
+ */
+export function divide(a, b, output = null) {
+  const result = output || new Point();
+  result.x = a.x / b.x;
+  result.y = a.y / b.y;
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ */
+export function equals(a, b) {
+  return (a.x === b.x && a.y === b.y);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ */
+export function angle(a, b) {
+  return Math.atan2(a.y - b.y, a.x - b.x);
+}
+
+/**
+ *
+ * @param a
+ * @param output
+ */
+export function negative(a, output = null) {
+  const result = output || new Point();
+  return result.setTo(-a.x, -a.y);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param s
+ * @param output
+ */
+export function multiplyAdd(a, b, s, output = null) {
+  const result = output || new Point();
+  return result.setTo(a.x + b.x * s, a.y + b.y * s);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param f
+ * @param output
+ */
+export function interpolate(a, b, f, output = null) {
+  const result = output || new Point();
+  return result.setTo(a.x + (b.x - a.x) * f, a.y + (b.y - a.y) * f);
+}
+
+/**
+ *
+ * @param a
+ * @param output
+ */
+export function perp(a, output = null) {
+  const result = output || new Point();
+  return result.setTo(-a.y, a.x);
+}
+
+/**
+ *
+ * @param a
+ * @param output
+ */
+export function rperp(a, output = null) {
+  const result = output || new Point();
+  return result.setTo(a.y, -a.x);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param round
+ */
+export function distance(a, b, round = false) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  const abDistance = Math.sqrt(dx * dx + dy * dy);
+  return round ? Math.round(abDistance) : abDistance;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param output
+ */
+export function project(a, b, output = null) {
+  const result = output || new Point();
+  const amt = a.dot(b) / b.getMagnitudeSq();
+  if (amt !== 0) {
+    result.setTo(amt * b.x, amt * b.y);
+  }
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param output
+ */
+export function projectUnit(a, b, output = null) {
+  const result = output || new Point();
+  const amt = a.dot(b);
+  if (amt !== 0) {
+    result.setTo(amt * b.x, amt * b.y);
+  }
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param output
+ */
+export function normalRightHand(a, output = null) {
+  const result = output || new Point();
+  return result.setTo(a.y * -1, a.x);
+}
+
+/**
+ *
+ * @param a
+ * @param output
+ */
+export function normalize(a, output = null) {
+  const result = output || new Point();
+  const m = a.getMagnitude();
+  if (m !== 0) {
+    result.setTo(a.x / m, a.y / m);
+  }
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param x
+ * @param y
+ * @param ang
+ * @param asDegrees
+ * @param dist
+ */
+export function rotate(a, x, y, ang, asDegrees, dist) {
+  if (asDegrees) {
+    ang *= Math.PI / 180;
+  }
+  if (dist === undefined) {
+    a.subtract(x, y);
+    const s = Math.sin(ang);
+    const c = Math.cos(ang);
+    const tx = c * a.x - s * a.y;
+    const ty = s * a.x + c * a.y;
+    a.x = tx + x;
+    a.y = ty + y;
+  } else {
+    const t = ang + Math.atan2(a.y - y, a.x - x);
+    a.x = x + dist * Math.cos(t);
+    a.y = y + dist * Math.sin(t);
+  }
+  return a;
+}
+
+/**
+ *
+ * @param points
+ * @param output
+ */
+export function centroid(points, output = null) {
+  const result = output || new Point();
+  const pointsLen = points.length;
+  if (pointsLen < 1) {
+    throw new Error('Point(points) array must not be empty.');
+  }
+  if (pointsLen === 1) {
+    result.copyFrom(points[0]);
+    return result;
+  }
+  for (let i = 0; i < pointsLen; i += 1) {
+    add(result, points[i], result);
+  }
+  result.divide(pointsLen, pointsLen);
+  return result;
+}
+
+/**
+ *
+ * @param obj
+ * @param xProp
+ * @param yProp
+ */
+export function parse(obj, xProp = 'x', yProp = 'y') {
+  const point = new Point();
+  if (obj[xProp]) {
+    point.x = parseInt(obj[xProp], 10);
+  }
+  if (obj[yProp]) {
+    point.y = parseInt(obj[yProp], 10);
+  }
+  return point;
+}
+
+/**
+ *
+ * @param input
+ * @param output
+ */
+export function clone(input, output = null) {
+  const result = output || new Point();
+  result.setTo(input.x, input.y);
+  return result;
+}

package/src/phaser/geom/util/polygon.js

@@ -0,0 +1,24 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+import Polygon from '../polygon';
+
+/**
+ *
+ */
+export default function () {
+  return true;
+}
+
+/**
+ *
+ * @param input
+ * @param output
+ */
+export function clone(input, output = null) {
+  const result = output || new Polygon();
+  result.setTo(input._points.slice());
+  return result;
+}