Phaser.Math = { 
PI2: Math.PI * 2,
fuzzyEqual: function (a, b, epsilon){ 
if (typeof epsilon === "undefined") { 
epsilon = 0.0001; 
} 
return Math.abs(a - b) < epsilon; 
} 
,
fuzzyLessThan: function (a, b, epsilon){ 
if (typeof epsilon === "undefined") { 
epsilon = 0.0001; 
} 
return a < b + epsilon; 
} 
,
fuzzyGreaterThan: function (a, b, epsilon){ 
if (typeof epsilon === "undefined") { 
epsilon = 0.0001; 
} 
return a > b - epsilon; 
} 
,
fuzzyCeil: function (val, epsilon){ 
if (typeof epsilon === "undefined") { 
epsilon = 0.0001; 
} 
return Math.ceil(val - epsilon); 
} 
,
fuzzyFloor: function (val, epsilon){ 
if (typeof epsilon === "undefined") { 
epsilon = 0.0001; 
} 
return Math.floor(val + epsilon); 
} 
,
average: function (){ 
var args = [] ; 
for (var _i = 0; 
_i < (_AN_Read_length("length", arguments) - 0); _i++ ){ 
args[_i] = arguments[_i + 0]; 
} 
var avg = 0; 
for (var i = 0; 
i < _AN_Read_length("length", args); i++ ){ 
avg += args[i]; 
} 
return avg / _AN_Read_length("length", args); 
} 
,
truncate: function (n){ 
return (n > 0)? Math.floor(n): Math.ceil(n); 
} 
,
shear: function (n){ 
return n % 1; 
} 
,
snapTo: function (input, gap, start){ 
if (typeof start === "undefined") { 
start = 0; 
} 
if (gap === 0) { 
return input; 
} 
input -= start; 
input = gap * Math.round(input / gap); 
return start + input; 
} 
,
snapToFloor: function (input, gap, start){ 
if (typeof start === "undefined") { 
start = 0; 
} 
if (gap === 0) { 
return input; 
} 
input -= start; 
input = gap * Math.floor(input / gap); 
return start + input; 
} 
,
snapToCeil: function (input, gap, start){ 
if (typeof start === "undefined") { 
start = 0; 
} 
if (gap === 0) { 
return input; 
} 
input -= start; 
input = gap * Math.ceil(input / gap); 
return start + input; 
} 
,
snapToInArray: function (input, arr, sort){ 
if (typeof sort === "undefined") { 
sort = true ; 
} 
if (sort) { 
arr.sort(); 
} 
if (input < arr[0]) { 
return arr[0]; 
} 
var i = 1; 
while (arr[i] < input){ 
i++ ; 
} 
var low = arr[i - 1]; 
var high = (i < _AN_Read_length("length", arr))? arr[i]: Number.POSITIVE_INFINITY; 
return ((high - input) <= (input - low))? high: low; 
} 
,
roundTo: function (value, place, base){ 
if (typeof place === "undefined") { 
place = 0; 
} 
if (typeof base === "undefined") { 
base = 10; 
} 
var p = Math.pow(base, - place); 
return Math.round(value * p) / p; 
} 
,
floorTo: function (value, place, base){ 
if (typeof place === "undefined") { 
place = 0; 
} 
if (typeof base === "undefined") { 
base = 10; 
} 
var p = Math.pow(base, - place); 
return Math.floor(value * p) / p; 
} 
,
ceilTo: function (value, place, base){ 
if (typeof place === "undefined") { 
place = 0; 
} 
if (typeof base === "undefined") { 
base = 10; 
} 
var p = Math.pow(base, - place); 
return Math.ceil(value * p) / p; 
} 
,
interpolateFloat: function (a, b, weight){ 
return (b - a) * weight + a; 
} 
,
angleBetween: function (x1, y1, x2, y2){ 
return Math.atan2(y2 - y1, x2 - x1); 
} 
,
angleBetweenY: function (x1, y1, x2, y2){ 
return Math.atan2(x2 - x1, y2 - y1); 
} 
,
angleBetweenPoints: function (point1, point2){ 
return Math.atan2(point2.y - point1.y, point2.x - point1.x); 
} 
,
angleBetweenPointsY: function (point1, point2){ 
return Math.atan2(point2.x - point1.x, point2.y - point1.y); 
} 
,
reverseAngle: function (angleRad){ 
return this.normalizeAngle(angleRad + Math.PI, true ); 
} 
,
normalizeAngle: function (angleRad){ 
angleRad = angleRad % (2 * Math.PI); 
return angleRad >= 0? angleRad: angleRad + 2 * Math.PI; 
} 
,
normalizeLatitude: function (lat){ 
return Math.max(-90, Math.min(90, lat)); 
} 
,
normalizeLongitude: function (lng){ 
if (lng % 360 == 180) { 
return 180; 
} 
lng = lng % 360; 
return lng < -180? lng + 360: lng > 180? lng - 360: lng; 
} 
,
chanceRoll: function (chance){ 
if (typeof chance === "undefined") { 
chance = 50; 
} 
if (chance <= 0) { 
return false ; 
} 
 else if (chance >= 100) { 
return true ; 
} 
 else { 
if (Math.random() * 100 >= chance) { 
return false ; 
} 
 else { 
return true ; 
} 
} 
} 
,
numberArray: function (min, max){ 
var result = [] ; 
for (var i = min; 
i <= max; i++ ){ 
result.push(i); 
} 
return result; 
} 
,
numberArrayStep: function (start, end, step){ 
start = + start || 0; 
var type = typeof end; 
if ((type === 'number' || type === 'string') && step && step[end] === start) { 
end = step = null ; 
} 
step = step == null ? 1: (+ step || 0); 
if (end === null ) { 
end = start; 
start = 0; 
} 
 else { 
end = + end || 0; 
} 
var index = -1; 
var length = Phaser.Math.max(Phaser.Math.ceil((end - start) / (step || 1)), 0); 
var result = new Array(length); 
while (++index < length){ 
result[index] = start; 
start += step; 
} 
return result; 
} 
,
maxAdd: function (value, amount, max){ 
value += amount; 
if (value > max) { 
value = max; 
} 
return value; 
} 
,
minSub: function (value, amount, min){ 
value -= amount; 
if (value < min) { 
value = min; 
} 
return value; 
} 
,
wrap: function (value, min, max){ 
var range = max - min; 
if (range <= 0) { 
return 0; 
} 
var result = (value - min) % range; 
if (result < 0) { 
result += range; 
} 
return result + min; 
} 
,
wrapValue: function (value, amount, max){ 
var diff; 
value = Math.abs(value); 
amount = Math.abs(amount); 
max = Math.abs(max); 
diff = (value + amount) % max; 
return diff; 
} 
,
limitValue: function (value, min, max){ 
return value < min? min: value > max? max: value; 
} 
,
randomSign: function (){ 
return (Math.random() > 0.5)? 1: -1; 
} 
,
isOdd: function (n){ 
return (n & 1); 
} 
,
isEven: function (n){ 
if (n & 1) { 
return false ; 
} 
 else { 
return true ; 
} 
} 
,
min: function (){ 
if (_AN_Read_length('length', arguments) === 1 && typeof arguments[0] === 'object') { 
var data = arguments[0]; 
} 
 else { 
var data = arguments; 
} 
for (var i = 1, min = 0, len = _AN_Read_length('length', data); 
i < len; i++ ){ 
if (data[i] < data[min]) { 
min = i; 
} 
} 
return data[min]; 
} 
,
max: function (){ 
if (_AN_Read_length('length', arguments) === 1 && typeof arguments[0] === 'object') { 
var data = arguments[0]; 
} 
 else { 
var data = arguments; 
} 
for (var i = 1, max = 0, len = _AN_Read_length('length', data); 
i < len; i++ ){ 
if (data[i] > data[max]) { 
max = i; 
} 
} 
return data[max]; 
} 
,
minProperty: function (property){ 
if (_AN_Read_length('length', arguments) === 2 && typeof arguments[1] === 'object') { 
var data = arguments[1]; 
} 
 else { 
var data = arguments.slice(1); 
} 
for (var i = 1, min = 0, len = _AN_Read_length('length', data); 
i < len; i++ ){ 
if (data[i][property] < data[min][property]) { 
min = i; 
} 
} 
return data[min][property]; 
} 
,
maxProperty: function (property){ 
if (_AN_Read_length('length', arguments) === 2 && typeof arguments[1] === 'object') { 
var data = arguments[1]; 
} 
 else { 
var data = arguments.slice(1); 
} 
for (var i = 1, max = 0, len = _AN_Read_length('length', data); 
i < len; i++ ){ 
if (data[i][property] > data[max][property]) { 
max = i; 
} 
} 
return data[max][property]; 
} 
,
wrapAngle: function (angle, radians){ 
var radianFactor = (radians)? Math.PI / 180: 1; 
return this.wrap(angle, -180 * radianFactor, 180 * radianFactor); 
} 
,
angleLimit: function (angle, min, max){ 
var result = angle; 
if (angle > max) { 
result = max; 
} 
 else if (angle < min) { 
result = min; 
} 
return result; 
} 
,
linearInterpolation: function (v, k){ 
var m = _AN_Read_length('length', v) - 1; 
var f = m * k; 
var i = Math.floor(f); 
if (k < 0) { 
return this.linear(v[0], v[1], f); 
} 
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); 
} 
,
bezierInterpolation: function (v, k){ 
var b = 0; 
var n = _AN_Read_length('length', v) - 1; 
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; 
} 
,
catmullRomInterpolation: function (v, k){ 
var m = _AN_Read_length('length', v) - 1; 
var f = m * k; 
var i = Math.floor(f); 
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) { 
return v[0] - (this.catmullRom(v[0], v[0], v[1], v[1], - f) - v[0]); 
} 
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); 
} 
} 
,
linear: function (p0, p1, t){ 
return (p1 - p0) * t + p0; 
} 
,
bernstein: function (n, i){ 
return this.factorial(n) / this.factorial(i) / this.factorial(n - i); 
} 
,
factorial: function (value){ 
if (value === 0) { 
return 1; 
} 
var res = value; 
while (--value){ 
res *= value; 
} 
return res; 
} 
,
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; 
} 
,
difference: function (a, b){ 
return Math.abs(a - b); 
} 
,
getRandom: function (objects, startIndex, length){ 
if (typeof startIndex === "undefined") { 
startIndex = 0; 
} 
if (typeof length === "undefined") { 
length = 0; 
} 
if (objects != null ) { 
var l = length; 
if ((l === 0) || (l > _AN_Read_length("length", objects) - startIndex)) { 
l = _AN_Read_length("length", objects) - startIndex; 
} 
if (l > 0) { 
return objects[startIndex + Math.floor(Math.random() * l)]; 
} 
} 
return null ; 
} 
,
removeRandom: function (objects, startIndex, length){ 
if (typeof startIndex === "undefined") { 
startIndex = 0; 
} 
if (typeof length === "undefined") { 
length = 0; 
} 
if (objects != null ) { 
var l = length; 
if ((l === 0) || (l > _AN_Read_length("length", objects) - startIndex)) { 
l = _AN_Read_length("length", objects) - startIndex; 
} 
if (l > 0) { 
var idx = startIndex + Math.floor(Math.random() * l); 
var removed = objects.splice(idx, 1); 
return removed[0]; 
} 
} 
return null ; 
} 
,
floor: function (value){ 
var n = value | 0; 
return (value > 0)? (n): ((n != value)? (n - 1): (n)); 
} 
,
ceil: function (value){ 
var n = value | 0; 
return (value > 0)? ((n != value)? (n + 1): (n)): (n); 
} 
,
sinCosGenerator: function (length, sinAmplitude, cosAmplitude, frequency){ 
if (typeof sinAmplitude === "undefined") { 
sinAmplitude = 1; 
} 
if (typeof cosAmplitude === "undefined") { 
cosAmplitude = 1; 
} 
if (typeof frequency === "undefined") { 
frequency = 1; 
} 
var sin = sinAmplitude; 
var cos = cosAmplitude; 
var frq = frequency * Math.PI / length; 
var cosTable = [] ; 
var sinTable = [] ; 
for (var c = 0; 
c < length; c++ ){ 
cos -= sin * frq; 
sin += cos * frq; 
cosTable[c] = cos; 
sinTable[c] = sin; 
} 
return { 
sin: sinTable,
cos: cosTable,
length: length}
; 
} 
,
shift: function (stack){ 
var s = stack.shift(); 
stack.push(s); 
return s; 
} 
,
shuffleArray: function (array){ 
for (var i = _AN_Read_length("length", array) - 1; 
i > 0; i-- ){ 
var j = Math.floor(Math.random() * (i + 1)); 
var temp = array[i]; 
array[i] = array[j]; 
array[j] = temp; 
} 
return array; 
} 
,
distance: function (x1, y1, x2, y2){ 
var dx = x1 - x2; 
var dy = y1 - y2; 
return Math.sqrt(dx * dx + dy * dy); 
} 
,
distancePow: function (x1, y1, x2, y2, pow){ 
if (typeof pow === 'undefined') { 
pow = 2; 
} 
return Math.sqrt(Math.pow(x2 - x1, pow) + Math.pow(y2 - y1, pow)); 
} 
,
distanceRounded: function (x1, y1, x2, y2){ 
return Math.round(Phaser.Math.distance(x1, y1, x2, y2)); 
} 
,
clamp: function (x, a, b){ 
return (x < a)? a: ((x > b)? b: x); 
} 
,
clampBottom: function (x, a){ 
return x < a? a: x; 
} 
,
within: function (a, b, tolerance){ 
return (Math.abs(a - b) <= tolerance); 
} 
,
mapLinear: function (x, a1, a2, b1, b2){ 
return b1 + (x - a1) * (b2 - b1) / (a2 - a1); 
} 
,
smoothstep: function (x, min, max){ 
x = Math.max(0, Math.min(1, (x - min) / (max - min))); 
return x * x * (3 - 2 * x); 
} 
,
smootherstep: function (x, min, max){ 
x = Math.max(0, Math.min(1, (x - min) / (max - min))); 
return x * x * x * (x * (x * 6 - 15) + 10); 
} 
,
sign: function (x){ 
return (x < 0)? -1: ((x > 0)? 1: 0); 
} 
,
percent: function (a, b, base){ 
if (typeof base === 'undefined') { 
base = 0; 
} 
if (a > b || base > b) { 
return 1; 
} 
 else if (a < base || base > a) { 
return 0; 
} 
 else { 
return (a - base) / b; 
} 
} 
,
degToRad: (function (){ 
var degreeToRadiansFactor = Math.PI / 180; 
return function (degrees){ 
return degrees * degreeToRadiansFactor; 
} 
; 
} 
()),
radToDeg: (function (){ 
var radianToDegreesFactor = 180 / Math.PI; 
return function (radians){ 
return radians * radianToDegreesFactor; 
} 
; 
} 
())}
;