Phaser.Polygon has been refactored to address some Pixi v2 migration issues (thanks @pnstickne for the original implementation phaserjs#1267)

Polygon.area is now only calculated when the Polygon points list is modified, rather than on every call.

Phaser.Polygon can now accept the points list in a variety of formats: Arrays of Points, numbers, objects with public x/y properties or any combination of, or as a parameter list (thanks @pnstickne for the original implementation phaserjs#1267)

Polygon.contains now correctly calculates the result  (thanks @pnstickne @BurnedToast phaserjs#1267)

Author: photonstorm

README.md

@@ -91,6 +91,9 @@ Version 2.1.4 - "Bethal" - in development
 * Game.destroy now destroys either the WebGLRenderer or CanvasRenderer, whichever Pixi was using.
 * Particle.Emitter will now automatically set `particle.body.skipQuadTree` to `true` to help with collision speeds within Arcade Physics.
 * Particle.Emitter.explode (or `Emitter.start` with the `explode` parameter set to `true`) will immediately emit the required quantity of particles and not delay until the next frame to do so. This means you can re-use a single emitter across multiple places in your game that require explode-style emissions, just by adjusting the `emitter.x` and `emitter.y` properties before calling explode (thanks Insanehero)
+* Phaser.Polygon has been refactored to address some Pixi v2 migration issues (thanks @pnstickne for the original implementation #1267)
+* Polygon.area is now only calculated when the Polygon points list is modified, rather than on every call.
+* Phaser.Polygon can now accept the points list in a variety of formats: Arrays of Points, numbers, objects with public x/y properties or any combination of, or as a parameter list (thanks @pnstickne for the original implementation #1267)
 
 ### Bug Fixes
 
@@ -100,6 +103,8 @@ Version 2.1.4 - "Bethal" - in development
 * Loader.json was using the wrong context in IE9 with XDomainRequest calls (thanks @pnstickne #1258)
 * Polygon.contains was toggling the return value on each valid hit (thanks @Singularetantum #1265 #1266)
 * Text.updateText was incorrectly increasing the size of the texture each time it was called (thanks @spayton #1261)
+* Polygon.contains now correctly calculates the result  (thanks @pnstickne @BurnedToast #1267)
+* Setting Key.enabled = false while it is down did not reset the isDown state (thanks @pnstickne #1190 #1271)
 
 
 For details about changes made in previous versions of Phaser see the full Change Log at https://github.com/photonstorm/phaser/blob/master/CHANGELOG.md

build/config.php

@@ -37,8 +37,8 @@
     echo <<<EOL
 
     <script src="$path/src/pixi/Pixi.js"></script>
-    <script src="$path/src/pixi/geom/Polygon.js"></script>
     <script src="$path/src/pixi/geom/Matrix.js"></script>
+    <script src="$path/src/pixi/geom/Polygon.js"></script>
     <script src="$path/src/pixi/display/DisplayObject.js"></script>
     <script src="$path/src/pixi/display/DisplayObjectContainer.js"></script>
     <script src="$path/src/pixi/display/Sprite.js"></script>

src/geom/Polygon.js

@@ -6,45 +6,43 @@
 */
 
 /**
-* Creates a new Polygon. You have to provide a list of points.
-* This can be an array of Points that form the polygon, a flat array of numbers that will be interpreted as [x,y, x,y, ...],
-* or the arguments passed can be all the points of the polygon e.g. `new Phaser.Polygon(new Phaser.Point(), new Phaser.Point(), ...)`, or the
-* arguments passed can be flat x,y values e.g. `new Phaser.Polygon(x,y, x,y, x,y, ...)` where `x` and `y` are numbers.
+* Creates a new Polygon.
+* 
+* The points can be set from a variety of formats:
+*
+* - An array of Point objects: `[new Phaser.Point(x1, y1), ...]`
+* - An array of objects with public x/y properties: `[obj1, obj2, ...]`
+* - An array of paired numbers that represent point coordinates: `[x1,y1, x2,y2, ...]`
+* - As separate Point arguments: `setTo(new Phaser.Point(x1, y1), ...)`
+* - As separate objects with public x/y properties arguments: `setTo(obj1, obj2, ...)`
+* - As separate arguments representing point coordinates: `setTo(x1,y1, x2,y2, ...)`
 *
 * @class Phaser.Polygon
 * @constructor
-* @param {Phaser.Point[]|number[]} points - The array of Points.
+* @param {Phaser.Point[]|number[]|...Phaser.Point|...number} points - The points to set.
 */
-Phaser.Polygon = function (points) {
+Phaser.Polygon = function () {
 
     /**
-    * @property {number} type - The base object type.
-    */
+     * @property {number} type - The base object type.
+     */
     this.type = Phaser.POLYGON;
 
-    //  If points isn't an array, use arguments as the array
-    if (!(points instanceof Array))
-    {
-        points = Array.prototype.slice.call(arguments);
-    }
-
-    //  If this is a flat array of numbers, convert it to points
-    if (points[0] instanceof Phaser.Point)
-    {
-        var p = [];
-
-        for (var i = 0, il = points.length; i < il; i++)
-        {
-            p.push(points[i].x, points[i].y);
-        }
-
-        points = p;
-    }
+    /**
+    * @property {number} area - The area of this Polygon.
+    */
+    this.area = 0;
 
     /**
-    * @property {array} points - An array of Points that make up this Polygon.
+    * @property {array} _points - An array of Points that make up this Polygon.
+    * @private
     */
-    this.points = points;
+    this._points = [];
+
+    if (arguments.length > 0)
+    {
+        this.setTo.apply(this, arguments);
+    }
 
     /**
     * @property {boolean} closed - Is the Polygon closed or not?
@@ -60,12 +58,12 @@ Phaser.Polygon.prototype = {
      * This is a deep clone, the resulting copy contains new Phaser.Point objects
      *
      * @method Phaser.Polygon#clone
-     * @param {Phaser.Polygon} [output] Optional Polygon object. If given the values will be set into this object, otherwise a brand new Polygon object will be created and returned.
-     * @return {Phaser.Polygon} The new Polygon object.
+     * @param {Phaser.Polygon} [output=(new Polygon)] - The polygon to update. If not specified a new polygon will be created.
+     * @return {Phaser.Polygon} The cloned (`output`) polygon object.
      */
     clone: function (output) {
 
-        var points = this.points.slice();
+        var points = this._points.slice();
 
         if (typeof output === "undefined" || output === null)
         {
@@ -90,155 +88,156 @@ Phaser.Polygon.prototype = {
     */
     contains: function (x, y) {
 
-        // use some raycasting to test hits https://github.com/substack/point-in-polygon/blob/master/index.js
+        //  Adapted from http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html by Jonas Raoni Soares Silva
 
-        var length = this.points.length / 2;
+        var length = this._points.length;
+        var inside = false;
 
-        for (var i = 0, j = length - 1; i < length; j = i++)
+        for (var i = -1, j = length - 1; ++i < length; j = i)
         {
-            var xi = this.points[i * 2].x;
-            var yi = this.points[i * 2 + 1].y;
-            var xj = this.points[j * 2].x;
-            var yj = this.points[j * 2 + 1].y;
+            var ix = this._points[i].x;
+            var iy = this._points[i].y;
 
-            var intersect = ((yi > y) !== (yj > y)) && (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
+            var jx = this._points[j].x;
+            var jy = this._points[j].y;
 
-            if (intersect)
-            {
-                return true;
-            }
+            ((iy <= y && y < jy) || (jy <= y && y < iy)) && (x < (jx - ix) * (y - iy) / (jy - iy) + ix) && (inside = !inside);
         }
 
-        return false;
+        return inside;
 
     },
 
     /**
-    * Sets this Polygon to the given points.
-    *
-    * @method Phaser.Polygon#setTo
-    * @param {Phaser.Point[]|number[]} points - The array of Points.
-    * @return {boolean} True if the coordinates are within this polygon, otherwise false.
-    */
+     * Sets this Polygon to the given points.
+     *
+     * The points can be set from a variety of formats:
+     *
+     * - An array of Point objects: `[new Phaser.Point(x1, y1), ...]`
+     * - An array of objects with public x/y properties: `[obj1, obj2, ...]`
+     * - An array of paired numbers that represent point coordinates: `[x1,y1, x2,y2, ...]`
+     * - As separate Point arguments: `setTo(new Phaser.Point(x1, y1), ...)`
+     * - As separate objects with public x/y properties arguments: `setTo(obj1, obj2, ...)`
+     * - As separate arguments representing point coordinates: `setTo(x1,y1, x2,y2, ...)`
+     *
+     * `setTo` may also be called without any arguments to remove all points.
+     *
+     * @method Phaser.Polygon#setTo
+     * @param {Phaser.Point[]|number[]|...Phaser.Point|...number} points - The points to set.
+     * @return {Phaser.Polygon} This Polygon object
+     */
     setTo: function (points) {
 
-        //  If points isn't an array, use arguments as the array
-        if (!(points instanceof Array))
-        {
-            points = Array.prototype.slice.call(arguments);
-        }
+        this.area = 0;
+        this._points = [];
 
-        //  If this is a flat array of numbers, convert it to points
-        if (points[0] instanceof Phaser.Point)
+        if (arguments.length > 0)
         {
-            var p = [];
+            //  If points isn't an array, use arguments as the array
+            if (!Array.isArray(points))
+            {
+                points = Array.prototype.slice.call(arguments);
+            }
+
+            var y0 = Number.MAX_VALUE;
 
-            for (var i = 0, il = points.length; i < il; i++)
+            //  Allows for mixed-type arguments
+            for (var i = 0, len = points.length; i < len; i++)
             {
-                p.push(points[i].x, points[i].y);
+                if (typeof points[i] === 'number')
+                {
+                    var p = new Phaser.Point(points[i], points[i + 1]);
+                    i++;
+                }
+                else
+                {
+                    var p = new Phaser.Point(points[i].x, points[i].y);
+                }
+
+                this._points.push(p);
+
+                //  Lowest boundary
+                if (p.y < y0)
+                {
+                    y0 = p.y;
+                }
             }
 
-            points = p;
+            this.calculateArea(y0);
         }
 
-        this.points = points;
-
         return this;
 
-    }
-
-};
-
-Phaser.Polygon.prototype.constructor = Phaser.Polygon;
-
-/*
-* Sets and modifies the points of this polygon.
-*
-* @name Phaser.Polygon#points
-* @property {array<Phaser.Point>|array<number>} points - The array of vertex points
-*/
-Object.defineProperty(Phaser.Polygon.prototype, 'points', {
-
-    get: function() {
-        return this._points;
     },
 
-    set: function(points) {
+    /**
+     * Calcuates the area of the Polygon. This is available in the property Polygon.area
+     *
+     * @method Phaser.Polygon#calculateArea
+     * @private
+     * @param {number} y0 - The lowest boundary
+     * @return {number} The area of the Polygon.
+     */
+    calculateArea: function (y0) {
 
-        //if points isn't an array, use arguments as the array
-        if (!(points instanceof Array))
-        {
-            points = Array.prototype.slice.call(arguments);
-        }
+        var p1;
+        var p2;
+        var avgHeight;
+        var width;
 
-        //if this is a flat array of numbers, convert it to points
-        if (typeof points[0] === 'number')
+        for (var i = 0, len = this._points.length; i < len; i++)
         {
-            var p = [];
+            p1 = this._points[i];
 
-            for (var i = 0, len = points.length; i < len; i += 2)
+            if (i === len - 1)
             {
-                p.push(new Phaser.Point(points[i], points[i + 1]));
+                p2 = this._points[0];
+            }
+            else
+            {
+                p2 = this._points[i + 1];
             }
 
-            points = p;
+            avgHeight = ((p1.y - y0) + (p2.y - y0)) / 2;
+            width = p1.x - p2.x;
+            this.area += avgHeight * width;
         }
 
-        this._points = points;
+        return this.area;
+
     }
 
-});
+};
+
+Phaser.Polygon.prototype.constructor = Phaser.Polygon;
 
 /**
-* Returns the area of the polygon.
+* Sets and modifies the points of this polygon.
 *
-* @name Phaser.Polygon#area
-* @readonly
+* See {@link Phaser.Polygon#setTo setTo} for the different kinds of arrays formats that can be assigned.
+*
+* @name Phaser.Polygon#points
+* @property {Phaser.Point[]} points - The array of vertex points.
+* @deprecated Use `setTo`.
 */
-Object.defineProperty(Phaser.Polygon.prototype, 'area', {
+Object.defineProperty(Phaser.Polygon.prototype, 'points', {
 
     get: function() {
+        return this._points;
+    },
 
-        var p1;
-        var p2;
-        var avgHeight;
-        var width;
-        var i;
-        var y0 = Number.MAX_VALUE;
-        var area = 0;
+    set: function(points) {
 
-        // Find lowest boundary
-        for (i = 0; i < this.points.length; i++)
+        if (points != null)
         {
-            if (this.points[i].y < y0)
-            {
-                y0 = this.points[i].y;
-            }
+            this.setTo(points);
         }
-
-        for (i = 0; i< this.points.length; i++)
+        else
         {
-            p1 = this.points[i];
-
-            if (i === this.points.length - 1)
-            {
-                p2 = this.points[0];
-            }
-            else
-            {
-                p2 = this.points[i+1];
-            }
-
-            avgHeight = ((p1.y - y0) + (p2.y - y0)) / 2;
-            width = p1.x - p2.x;
-            area += avgHeight * width;
+            //  Clear the points
+            this.setTo();
         }
 
-        return area;
-
     }
 
 });
-
-//   Because PIXI uses its own Polygon, we'll replace it with ours to avoid duplicating code or confusion.
-// PIXI.Polygon = Phaser.Polygon;