Lots of new examples and updates.

src/math/Math.js

@@ -687,13 +687,20 @@ Phaser.Math = {
 	* @return {number} The new angle value, returns the same as the input angle if it was within bounds
 	*/
     angleLimit: function (angle, min, max) {
+
         var result = angle;
-        if (angle > max) {
+
+        if (angle > max)
+        {
             result = max;
-        } else if (angle < min) {
+        }
+        else if (angle < min)
+        {
             result = min;
         }
+
         return result;
+
     },
 
 	/**
@@ -704,16 +711,23 @@ Phaser.Math = {
 	* @return {number} 
 	*/
     linearInterpolation: function (v, k) {
+
         var m = v.length - 1;
         var f = m * k;
         var i = Math.floor(f);
-        if (k < 0) {
+
+        if (k < 0)
+        {
             return this.linear(v[0], v[1], f);
         }
-        if (k > 1) {
+
+        if (k > 1)
+        {
             return this.linear(v[m], v[m - 1], m - f);
         }
+
         return this.linear(v[i], v[i + 1 > m ? m : i + 1], f - i);
+
     },
 
 	/**
@@ -724,12 +738,17 @@ Phaser.Math = {
 	* @return {number}
 	*/
     bezierInterpolation: function (v, k) {
+
         var b = 0;
         var n = v.length - 1;
-        for (var i = 0; i <= n; i++) {
+
+        for (var i = 0; i <= n; i++)
+        {
             b += Math.pow(1 - k, n - i) * Math.pow(k, i) * v[i] * this.bernstein(n, i);
         }
+
         return b;
+
     },
 
 	/**
@@ -745,20 +764,31 @@ Phaser.Math = {
         var f = m * k;
         var i = Math.floor(f);
 
-        if (v[0] === v[m]) {
-            if (k < 0) {
+        if (v[0] === v[m])
+        {
+            if (k < 0)
+            {
                 i = Math.floor(f = m * (1 + k));
             }
+
             return this.catmullRom(v[(i - 1 + m) % m], v[i], v[(i + 1) % m], v[(i + 2) % m], f - i);
-        } else {
-            if (k < 0) {
+
+        }
+        else
+        {
+            if (k < 0)
+            {
                 return v[0] - (this.catmullRom(v[0], v[0], v[1], v[1], -f) - v[0]);
             }
-            if (k > 1) {
+
+            if (k > 1)
+            {
                 return v[m] - (this.catmullRom(v[m], v[m], v[m - 1], v[m - 1], f - m) - v[m]);
             }
+
             return this.catmullRom(v[i ? i - 1 : 0], v[i], v[m < i + 1 ? m : i + 1], v[m < i + 2 ? m : i + 2], f - i);
         }
+
     },
 
 	/**
@@ -794,8 +824,11 @@ Phaser.Math = {
 	* @return {number} 
 	*/
     catmullRom: function (p0, p1, p2, p3, t) {
+
         var v0 = (p2 - p0) * 0.5, v1 = (p3 - p1) * 0.5, t2 = t * t, t3 = t * t2;
+
         return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+
     },
 
     /**
@@ -1010,6 +1043,21 @@ Phaser.Math = {
 		return x < a ? a : x;
 
 	},
+
+    /**
+    * 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.
+    */
+    within: function ( a, b, tolerance ) {
+
+        return (Math.abs(a - b) <= tolerance);
+
+    },
  
 	/**
 	* Linear mapping from range <a1, a2> to range <b1, b2>