@vpmedia/phaser 1.0.1 → 1.0.2

package/src/phaser/geom/point.js

@@ -0,0 +1,164 @@
+/**
+ * @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 { distance, rotate, clone } from './util/point';
+import { GEOM_POINT } from '../core/const';
+
+export default class {
+
+  constructor(x = 0, y = 0) {
+    this.x = x;
+    this.y = y;
+    this.type = GEOM_POINT;
+  }
+
+  copyFrom(source) {
+    return this.setTo(source.x, source.y);
+  }
+
+  invert() {
+    return this.setTo(this.y, this.x);
+  }
+
+  setTo(x, y) {
+    this.x = x || 0;
+    this.y = y || ((y !== 0) ? this.x : 0);
+    return this;
+  }
+
+  set(x, y) {
+    // deprecated, use setTo(x, y)
+    this.x = x || 0;
+    this.y = y || ((y !== 0) ? this.x : 0);
+    return this;
+  }
+
+  add(x, y) {
+    this.x += x;
+    this.y += y;
+    return this;
+  }
+
+  subtract(x, y) {
+    this.x -= x;
+    this.y -= y;
+    return this;
+  }
+
+  multiply(x, y) {
+    this.x *= x;
+    this.y *= y;
+    return this;
+  }
+
+  divide(x, y) {
+    this.x /= x;
+    this.y /= y;
+    return this;
+  }
+
+  clampX(min, max) {
+    this.x = Math.max(min, Math.min(max, this.x));
+    return this;
+  }
+
+  clampY(min, max) {
+    this.y = Math.max(min, Math.min(max, this.y));
+    return this;
+  }
+
+  clamp(min, max) {
+    this.x = Math.max(min, Math.min(max, this.x));
+    this.y = Math.max(min, Math.min(max, this.y));
+    return this;
+  }
+
+  clone() {
+    return clone(this);
+  }
+
+  copyTo(dest) {
+    dest.x = this.x;
+    dest.y = this.y;
+    return dest;
+  }
+
+  distance(b) {
+    return distance(this, b);
+  }
+
+  equals(a) {
+    return (a.x === this.x && a.y === this.y);
+  }
+
+  angle(a, asDegrees = false) {
+    if (asDegrees) {
+      return (180 / Math.PI) * (Math.atan2(a.y - this.y, a.x - this.x));
+    }
+    return Math.atan2(a.y - this.y, a.x - this.x);
+  }
+
+  rotate(x, y, angle, asDegrees, dist) {
+    return rotate(this, x, y, angle, asDegrees, dist);
+  }
+
+  getMagnitude() {
+    return Math.sqrt((this.x * this.x) + (this.y * this.y));
+  }
+
+  getMagnitudeSq() {
+    return (this.x * this.x) + (this.y * this.y);
+  }
+
+  setMagnitude(magnitude) {
+    return this.normalize().multiply(magnitude, magnitude);
+  }
+
+  normalize() {
+    if (!this.isZero()) {
+      const m = this.getMagnitude();
+      this.x /= m;
+      this.y /= m;
+    }
+    return this;
+  }
+
+  isZero() {
+    return (this.x === 0 && this.y === 0);
+  }
+
+  dot(a) {
+    return ((this.x * a.x) + (this.y * a.y));
+  }
+
+  cross(a) {
+    return ((this.x * a.y) - (this.y * a.x));
+  }
+
+  perp() {
+    return this.setTo(-this.y, this.x);
+  }
+
+  rperp() {
+    return this.setTo(this.y, -this.x);
+  }
+
+  normalRightHand() {
+    return this.setTo(this.y * -1, this.x);
+  }
+
+  floor() {
+    return this.setTo(Math.floor(this.x), Math.floor(this.y));
+  }
+
+  ceil() {
+    return this.setTo(Math.ceil(this.x), Math.ceil(this.y));
+  }
+
+  toString() {
+    return '[{Point (x=' + this.x + ' y=' + this.y + ')}]';
+  }
+
+}

package/src/phaser/geom/polygon.js

@@ -0,0 +1,141 @@
+/**
+ * @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)
+ */
+/* eslint-disable no-cond-assign, no-plusplus */
+import Point from './point';
+import { clone } from './util/polygon';
+import { GEOM_POLYGON } from '../core/const';
+
+export default class {
+
+  constructor(points = null) {
+    this.area = 0;
+    this._points = [];
+    this.closed = true;
+    this.flattened = false;
+    this.type = GEOM_POLYGON;
+    if (points) {
+      this.setTo(points);
+    }
+  }
+
+  toNumberArray(output = []) {
+    for (let i = 0; i < this._points.length; i += 1) {
+      if (typeof this._points[i] === 'number') {
+        output.push(this._points[i]);
+        output.push(this._points[i + 1]);
+        i += 1;
+      } else {
+        output.push(this._points[i].x);
+        output.push(this._points[i].y);
+      }
+    }
+    return output;
+  }
+
+  flatten() {
+    this._points = this.toNumberArray();
+    this.flattened = true;
+    return this;
+  }
+
+  clone() {
+    return clone(this);
+  }
+
+  contains(x, y) {
+    //  Adapted from http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html by Jonas Raoni Soares Silva
+    let inside = false;
+    if (this.flattened) {
+      for (let i = -2, j = this._points.length - 2; (i += 2) < this._points.length; j = i) {
+        const ix = this._points[i];
+        const iy = this._points[i + 1];
+        const jx = this._points[j];
+        const jy = this._points[j + 1];
+        if (((iy <= y && y < jy) || (jy <= y && y < iy)) && (x < (jx - ix) * (y - iy) / (jy - iy) + ix)) {
+          inside = !inside;
+        }
+      }
+    } else {
+      for (let i = -1, j = this._points.length - 1; ++i < this._points.length; j = i) {
+        const ix = this._points[i].x;
+        const iy = this._points[i].y;
+        const jx = this._points[j].x;
+        const jy = this._points[j].y;
+        if (((iy <= y && y < jy) || (jy <= y && y < iy)) && (x < (jx - ix) * (y - iy) / (jy - iy) + ix)) {
+          inside = !inside;
+        }
+      }
+    }
+    return inside;
+  }
+
+  setTo(points) {
+    this.area = 0;
+    this._points = [];
+    if (points) {
+      //  If points isn't an array, use arguments as the array
+      if (!Array.isArray(points)) {
+        console.error('[Polygon] setTo() error, input parameter is not an array', points);
+      }
+      /* if (!Array.isArray(points)) {
+        points = Array.prototype.slice.call(arguments);
+      } */
+      let y0 = Number.MAX_VALUE;
+      //  Allows for mixed-type arguments
+      for (let i = 0, len = points.length; i < len; i += 1) {
+        let p;
+        if (typeof points[i] === 'number') {
+          p = new Point(points[i], points[i + 1]);
+          i += 1;
+        } else if (Array.isArray(points[i])) {
+          p = new Point(points[i][0], points[i][1]);
+        } else {
+          p = new Point(points[i].x, points[i].y);
+        }
+        this._points.push(p);
+        //  Lowest boundary
+        if (p.y < y0) {
+          y0 = p.y;
+        }
+      }
+      this.calculateArea(y0);
+    }
+    return this;
+  }
+
+  calculateArea(y0) {
+    let p1;
+    let p2;
+    let avgHeight;
+    let width;
+    for (let i = 0, len = this._points.length; i < len; i += 1) {
+      p1 = this._points[i];
+      if (i === len - 1) {
+        p2 = this._points[0];
+      } else {
+        p2 = this._points[i + 1];
+      }
+      avgHeight = ((p1.y - y0) + (p2.y - y0)) / 2;
+      width = p1.x - p2.x;
+      this.area += avgHeight * width;
+    }
+    return this.area;
+  }
+
+  get points() {
+    return this._points;
+  }
+
+  set points(value) {
+    if (value !== null) {
+      this.setTo(value);
+    } else {
+      this.area = 0;
+      this._points = [];
+    }
+  }
+
+}

package/src/phaser/geom/rectangle.js

@@ -0,0 +1,306 @@
+/**
+ * @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 { inflate, size, clone, contains, containsRect, equals, intersects, intersection, intersectsRaw, union } from './util/rectangle';
+import { GEOM_RECTANGLE, TOP_LEFT, TOP_CENTER, TOP_RIGHT, LEFT_CENTER, CENTER, RIGHT_CENTER, BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT } from '../core/const';
+
+export default class {
+
+  constructor(x = 0, y = 0, width = 0, height = 0) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    this.type = GEOM_RECTANGLE;
+  }
+
+  offset(dx, dy) {
+    this.x += dx;
+    this.y += dy;
+    return this;
+  }
+
+  offsetPoint(point) {
+    return this.offset(point.x, point.y);
+  }
+
+  setTo(x, y, width, height) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    return this;
+  }
+
+  scale(x, y) {
+    if (y === undefined) { y = x; }
+    this.width *= x;
+    this.height *= y;
+    return this;
+  }
+
+  centerOn(x, y) {
+    this.centerX = x;
+    this.centerY = y;
+    return this;
+  }
+
+  floor() {
+    this.x = Math.floor(this.x);
+    this.y = Math.floor(this.y);
+  }
+
+  floorAll() {
+    this.x = Math.floor(this.x);
+    this.y = Math.floor(this.y);
+    this.width = Math.floor(this.width);
+    this.height = Math.floor(this.height);
+  }
+
+  ceil() {
+    this.x = Math.ceil(this.x);
+    this.y = Math.ceil(this.y);
+  }
+
+  ceilAll() {
+    this.x = Math.ceil(this.x);
+    this.y = Math.ceil(this.y);
+    this.width = Math.ceil(this.width);
+    this.height = Math.ceil(this.height);
+  }
+
+  copyFrom(source) {
+    return this.setTo(source.x, source.y, source.width, source.height);
+  }
+
+  copyTo(dest) {
+    dest.x = this.x;
+    dest.y = this.y;
+    dest.width = this.width;
+    dest.height = this.height;
+    return dest;
+  }
+
+  inflate(dx, dy) {
+    return inflate(this, dx, dy);
+  }
+
+  size(output) {
+    return size(this, output);
+  }
+
+  resize(width, height) {
+    this.width = width;
+    this.height = height;
+    return this;
+  }
+
+  clone(output) {
+    return clone(this, output);
+  }
+
+  contains(x, y) {
+    return contains(this, x, y);
+  }
+
+  containsRect(b) {
+    return containsRect(b, this);
+  }
+
+  equals(b) {
+    return equals(this, b);
+  }
+
+  intersection(b, out) {
+    return intersection(this, b, out);
+  }
+
+  intersects(b) {
+    return intersects(this, b);
+  }
+
+  intersectsRaw(left, right, top, bottom, tolerance) {
+    return intersectsRaw(this, left, right, top, bottom, tolerance);
+  }
+
+  union(b, out) {
+    return union(this, b, out);
+  }
+
+  random(output = null) {
+    const result = output || new Point();
+    result.x = this.randomX;
+    result.y = this.randomY;
+    return result;
+  }
+
+  getPoint(position, output = null) {
+    const result = output || new Point();
+    switch (position) {
+      case TOP_LEFT:
+        return result.set(this.x, this.y);
+      case TOP_CENTER:
+        return result.set(this.centerX, this.y);
+      case TOP_RIGHT:
+        return result.set(this.right, this.y);
+      case LEFT_CENTER:
+        return result.set(this.x, this.centerY);
+      case CENTER:
+        return result.set(this.centerX, this.centerY);
+      case RIGHT_CENTER:
+        return result.set(this.right, this.centerY);
+      case BOTTOM_LEFT:
+        return result.set(this.x, this.bottom);
+      case BOTTOM_CENTER:
+        return result.set(this.centerX, this.bottom);
+      case BOTTOM_RIGHT:
+        return result.set(this.right, this.bottom);
+      default:
+        return result.set(this.x, this.y);
+    }
+  }
+
+  toString() {
+    return '[{Rectangle (x=' + this.x + ' y=' + this.y + ' width=' + this.width + ' height=' + this.height + ' empty=' + this.empty + ')}]';
+  }
+
+  get halfWidth() {
+    return Math.round(this.width / 2);
+  }
+
+  get halfHeight() {
+    return Math.round(this.height / 2);
+  }
+
+  get top() {
+    return this.y;
+  }
+
+  set top(value) {
+    if (value >= this.bottom) {
+      this.height = 0;
+      this.y = value;
+    } else {
+      this.height = (this.bottom - value);
+    }
+  }
+
+  get topLeft() {
+    return new Point(this.x, this.y);
+  }
+
+  set topLeft(value) {
+    this.x = value.x;
+    this.y = value.y;
+  }
+
+  get topRight() {
+    return new Point(this.x + this.width, this.y);
+  }
+
+  set topRight(value) {
+    this.right = value.x;
+    this.y = value.y;
+  }
+
+  get bottom() {
+    return this.y + this.height;
+  }
+
+  set bottom(value) {
+    if (value <= this.y) {
+      this.height = 0;
+    } else {
+      this.height = value - this.y;
+    }
+  }
+
+  get bottomLeft() {
+    return new Point(this.x, this.bottom);
+  }
+
+  set bottomLeft(value) {
+    this.x = value.x;
+    this.bottom = value.y;
+  }
+
+  get bottomRight() {
+    return new Point(this.right, this.bottom);
+  }
+
+  set bottomRight(value) {
+    this.right = value.x;
+    this.bottom = value.y;
+  }
+
+  get left() {
+    return this.x;
+  }
+
+  set left(value) {
+    if (value >= this.right) {
+      this.width = 0;
+    } else {
+      this.width = this.right - value;
+    }
+    this.x = value;
+  }
+
+  get right() {
+    return this.x + this.width;
+  }
+
+  set right(value) {
+    if (value <= this.x) {
+      this.width = 0;
+    } else {
+      this.width = value - this.x;
+    }
+  }
+
+  get volume() {
+    return this.width * this.height;
+  }
+
+  get perimeter() {
+    return (this.width * 2) + (this.height * 2);
+  }
+
+  get centerX() {
+    return this.x + this.halfWidth;
+  }
+
+  set centerX(value) {
+    this.x = value - this.halfWidth;
+  }
+
+  get centerY() {
+    return this.y + this.halfHeight;
+  }
+
+  set centerY(value) {
+    this.y = value - this.halfHeight;
+  }
+
+  get randomX() {
+    return this.x + (Math.random() * this.width);
+  }
+
+  get randomY() {
+    return this.y + (Math.random() * this.height);
+  }
+
+  get empty() {
+    return !this.width || !this.height;
+  }
+
+  set empty(value) {
+    if (value === true) {
+      this.setTo(0, 0, 0, 0);
+    }
+  }
+
+}

package/src/phaser/geom/rounded_rectangle.js

@@ -0,0 +1,36 @@
+/**
+ * @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 { clone } from './util/rounded_rectangle';
+import { GEOM_ROUNDED_RECTANGLE } from '../core/const';
+
+export default class {
+
+  constructor(x = 0, y = 0, width = 0, height = 0, radius = 20) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    this.radius = radius;
+    this.type = GEOM_ROUNDED_RECTANGLE;
+  }
+
+  contains(x, y) {
+    if (this.width <= 0 || this.height <= 0) {
+      return false;
+    }
+    if (x >= this.x && x <= this.x + this.width) {
+      if (y >= this.y && y <= this.y + this.height) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  clone() {
+    return clone(this);
+  }
+
+}