Added new Angle functions.

Author: photonstorm

v3/src/math/Within.js

@@ -0,0 +1,16 @@
+/**
+* Checks if two values are within the given tolerance of each other.
+*
+* @method Phaser.Math#within
+* @param {number} a - The first number to check
+* @param {number} b - The second number to check
+* @param {number} tolerance - The tolerance. Anything equal to or less than this is considered within the range.
+* @return {boolean} True if a is <= tolerance of b.
+* @see {@link Phaser.Math.fuzzyEqual}
+*/
+var Within = function (a, b, tolerance)
+{
+    return (Math.abs(a - b) <= tolerance);
+};
+
+module.exports = Within;

v3/src/math/angle/RotateTo.js

@@ -0,0 +1,51 @@
+/**
+* Rotates currentAngle towards targetAngle, taking the shortest rotation distance.
+* The lerp argument is the amount to rotate by in this call.
+* 
+* @method Phaser.Math#rotateToAngle
+* @param {number} currentAngle - The current angle, in radians.
+* @param {number} targetAngle - The target angle to rotate to, in radians.
+* @param {number} [lerp=0.05] - The lerp value to add to the current angle.
+* @return {number} The adjusted angle.
+*/
+var RotateTo = function (currentAngle, targetAngle, lerp)
+{
+    if (lerp === undefined) { lerp = 0.05; }
+
+    if (currentAngle === targetAngle)
+    {
+        return currentAngle;
+    }
+
+    if (Math.abs(targetAngle - currentAngle) <= lerp || Math.abs(targetAngle - currentAngle) >= (Phaser.Math.PI2 - lerp))
+    {
+        currentAngle = targetAngle;
+    }
+    else
+    {
+        if (Math.abs(targetAngle - currentAngle) > Math.PI)
+        {
+            if (targetAngle < currentAngle)
+            {
+                targetAngle += Phaser.Math.PI2;
+            }
+            else
+            {
+                targetAngle -= Phaser.Math.PI2;
+            }
+        }
+
+        if (targetAngle > currentAngle)
+        {
+            currentAngle += lerp;
+        }
+        else if (targetAngle < currentAngle)
+        {
+            currentAngle -= lerp;
+        }
+    }
+
+    return currentAngle;
+};
+
+module.exports = RotateTo;

v3/src/math/angle/ShortestBetween.js

@@ -0,0 +1,31 @@
+/**
+* Gets the shortest angle between `angle1` and `angle2`.
+* Both angles must be in the range -180 to 180, which is the same clamped
+* range that `sprite.angle` uses, so you can pass in two sprite angles to
+* this method, and get the shortest angle back between the two of them.
+*
+* The angle returned will be in the same range. If the returned angle is
+* greater than 0 then it's a counter-clockwise rotation, if < 0 then it's
+* a clockwise rotation.
+* 
+* @method Phaser.Math#getShortestAngle
+* @param {number} angle1 - The first angle. In the range -180 to 180.
+* @param {number} angle2 - The second angle. In the range -180 to 180.
+* @return {number} The shortest angle, in degrees. If greater than zero it's a counter-clockwise rotation.
+*/
+var ShortestBetween = function (angle1, angle2)
+{
+    var difference = angle2 - angle1;
+
+    if (difference === 0)
+    {
+        return 0;
+    }
+
+    var times = Math.floor((difference - (-180)) / 360);
+
+    return difference - (times * 360);
+
+};
+
+module.exports = ShortestBetween;

v3/src/math/angle/Wrap.js

@@ -1,6 +1,6 @@
-var MathWrap from '../Wrap';
+var MathWrap = require('../Wrap');
 
-var Wrap (angle)
+var Wrap = function (angle)
 {
     return MathWrap(angle, -Math.PI, Math.PI);
 };

v3/src/math/angle/index.js

@@ -5,6 +5,8 @@ module.exports = {
     BetweenPoints: require('./BetweenPoints'),
     BetweenPointsY: require('./BetweenPointsY'),
     Reverse: require('./Reverse'),
+    RotateTo: require('./RotateTo'),
+    ShortestBetween: require('./ShortestBetween'),
     Normalize: require('./Normalize'),
     Wrap: require('./Wrap'),
     WrapDegrees: require('./WrapDegrees')