mirror of
https://github.com/photonstorm/phaser
synced 2024-12-25 12:33:38 +00:00
968 lines
32 KiB
JavaScript
968 lines
32 KiB
JavaScript
/// <reference path="../_definitions.ts" />
|
|
/**
|
|
* Phaser - GameMath
|
|
*
|
|
* Adds a set of extra Math functions used through-out Phaser.
|
|
* Includes methods written by Dylan Engelman and Adam Saltsman.
|
|
*/
|
|
var Phaser;
|
|
(function (Phaser) {
|
|
var GameMath = (function () {
|
|
function GameMath(game) {
|
|
this.cosTable = [];
|
|
this.sinTable = [];
|
|
this.game = game;
|
|
|
|
GameMath.sinA = [];
|
|
GameMath.cosA = [];
|
|
|
|
for (var i = 0; i < 360; i++) {
|
|
GameMath.sinA.push(Math.sin(this.degreesToRadians(i)));
|
|
GameMath.cosA.push(Math.cos(this.degreesToRadians(i)));
|
|
}
|
|
}
|
|
GameMath.prototype.fuzzyEqual = function (a, b, epsilon) {
|
|
if (typeof epsilon === "undefined") { epsilon = 0.0001; }
|
|
return Math.abs(a - b) < epsilon;
|
|
};
|
|
|
|
GameMath.prototype.fuzzyLessThan = function (a, b, epsilon) {
|
|
if (typeof epsilon === "undefined") { epsilon = 0.0001; }
|
|
return a < b + epsilon;
|
|
};
|
|
|
|
GameMath.prototype.fuzzyGreaterThan = function (a, b, epsilon) {
|
|
if (typeof epsilon === "undefined") { epsilon = 0.0001; }
|
|
return a > b - epsilon;
|
|
};
|
|
|
|
GameMath.prototype.fuzzyCeil = function (val, epsilon) {
|
|
if (typeof epsilon === "undefined") { epsilon = 0.0001; }
|
|
return Math.ceil(val - epsilon);
|
|
};
|
|
|
|
GameMath.prototype.fuzzyFloor = function (val, epsilon) {
|
|
if (typeof epsilon === "undefined") { epsilon = 0.0001; }
|
|
return Math.floor(val + epsilon);
|
|
};
|
|
|
|
GameMath.prototype.average = function () {
|
|
var args = [];
|
|
for (var _i = 0; _i < (arguments.length - 0); _i++) {
|
|
args[_i] = arguments[_i + 0];
|
|
}
|
|
var avg = 0;
|
|
|
|
for (var i = 0; i < args.length; i++) {
|
|
avg += args[i];
|
|
}
|
|
|
|
return avg / args.length;
|
|
};
|
|
|
|
GameMath.prototype.slam = function (value, target, epsilon) {
|
|
if (typeof epsilon === "undefined") { epsilon = 0.0001; }
|
|
return (Math.abs(value - target) < epsilon) ? target : value;
|
|
};
|
|
|
|
/**
|
|
* ratio of value to a range
|
|
*/
|
|
GameMath.prototype.percentageMinMax = function (val, max, min) {
|
|
if (typeof min === "undefined") { min = 0; }
|
|
val -= min;
|
|
max -= min;
|
|
|
|
if (!max)
|
|
return 0;
|
|
else
|
|
return val / max;
|
|
};
|
|
|
|
/**
|
|
* a value representing the sign of the value.
|
|
* -1 for negative, +1 for positive, 0 if value is 0
|
|
*/
|
|
GameMath.prototype.sign = function (n) {
|
|
if (n)
|
|
return n / Math.abs(n);
|
|
else
|
|
return 0;
|
|
};
|
|
|
|
GameMath.prototype.truncate = function (n) {
|
|
return (n > 0) ? Math.floor(n) : Math.ceil(n);
|
|
};
|
|
|
|
GameMath.prototype.shear = function (n) {
|
|
return n % 1;
|
|
};
|
|
|
|
/**
|
|
* wrap a value around a range, similar to modulus with a floating minimum
|
|
*/
|
|
GameMath.prototype.wrap = function (val, max, min) {
|
|
if (typeof min === "undefined") { min = 0; }
|
|
val -= min;
|
|
max -= min;
|
|
if (max == 0)
|
|
return min;
|
|
val %= max;
|
|
val += min;
|
|
while (val < min)
|
|
val += max;
|
|
|
|
return val;
|
|
};
|
|
|
|
/**
|
|
* arithmetic version of wrap... need to decide which is more efficient
|
|
*/
|
|
GameMath.prototype.arithWrap = function (value, max, min) {
|
|
if (typeof min === "undefined") { min = 0; }
|
|
max -= min;
|
|
if (max == 0)
|
|
return min;
|
|
return value - max * Math.floor((value - min) / max);
|
|
};
|
|
|
|
/**
|
|
* force a value within the boundaries of two values
|
|
*
|
|
* if max < min, min is returned
|
|
*/
|
|
GameMath.prototype.clamp = function (input, max, min) {
|
|
if (typeof min === "undefined") { min = 0; }
|
|
return Math.max(min, Math.min(max, input));
|
|
};
|
|
|
|
/**
|
|
* Snap a value to nearest grid slice, using rounding.
|
|
*
|
|
* example if you have an interval gap of 5 and a position of 12... you will snap to 10. Where as 14 will snap to 15
|
|
*
|
|
* @param input - the value to snap
|
|
* @param gap - the interval gap of the grid
|
|
* @param [start] - optional starting offset for gap
|
|
*/
|
|
GameMath.prototype.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;
|
|
};
|
|
|
|
/**
|
|
* Snap a value to nearest grid slice, using floor.
|
|
*
|
|
* example if you have an interval gap of 5 and a position of 12... you will snap to 10. As will 14 snap to 10... but 16 will snap to 15
|
|
*
|
|
* @param input - the value to snap
|
|
* @param gap - the interval gap of the grid
|
|
* @param [start] - optional starting offset for gap
|
|
*/
|
|
GameMath.prototype.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;
|
|
};
|
|
|
|
/**
|
|
* Snap a value to nearest grid slice, using ceil.
|
|
*
|
|
* example if you have an interval gap of 5 and a position of 12... you will snap to 15. As will 14 will snap to 15... but 16 will snap to 20
|
|
*
|
|
* @param input - the value to snap
|
|
* @param gap - the interval gap of the grid
|
|
* @param [start] - optional starting offset for gap
|
|
*/
|
|
GameMath.prototype.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;
|
|
};
|
|
|
|
/**
|
|
* Snaps a value to the nearest value in an array.
|
|
*/
|
|
GameMath.prototype.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 < arr.length) ? arr[i] : Number.POSITIVE_INFINITY;
|
|
|
|
return ((high - input) <= (input - low)) ? high : low;
|
|
};
|
|
|
|
/**
|
|
* roundTo some place comparative to a 'base', default is 10 for decimal place
|
|
*
|
|
* 'place' is represented by the power applied to 'base' to get that place
|
|
*
|
|
* @param value - the value to round
|
|
* @param place - the place to round to
|
|
* @param base - the base to round in... default is 10 for decimal
|
|
*
|
|
* e.g.
|
|
*
|
|
* 2000/7 ~= 285.714285714285714285714 ~= (bin)100011101.1011011011011011
|
|
*
|
|
* roundTo(2000/7,3) == 0
|
|
* roundTo(2000/7,2) == 300
|
|
* roundTo(2000/7,1) == 290
|
|
* roundTo(2000/7,0) == 286
|
|
* roundTo(2000/7,-1) == 285.7
|
|
* roundTo(2000/7,-2) == 285.71
|
|
* roundTo(2000/7,-3) == 285.714
|
|
* roundTo(2000/7,-4) == 285.7143
|
|
* roundTo(2000/7,-5) == 285.71429
|
|
*
|
|
* roundTo(2000/7,3,2) == 288 -- 100100000
|
|
* roundTo(2000/7,2,2) == 284 -- 100011100
|
|
* roundTo(2000/7,1,2) == 286 -- 100011110
|
|
* roundTo(2000/7,0,2) == 286 -- 100011110
|
|
* roundTo(2000/7,-1,2) == 285.5 -- 100011101.1
|
|
* roundTo(2000/7,-2,2) == 285.75 -- 100011101.11
|
|
* roundTo(2000/7,-3,2) == 285.75 -- 100011101.11
|
|
* roundTo(2000/7,-4,2) == 285.6875 -- 100011101.1011
|
|
* roundTo(2000/7,-5,2) == 285.71875 -- 100011101.10111
|
|
*
|
|
* note what occurs when we round to the 3rd space (8ths place), 100100000, this is to be assumed
|
|
* because we are rounding 100011.1011011011011011 which rounds up.
|
|
*/
|
|
GameMath.prototype.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;
|
|
};
|
|
|
|
GameMath.prototype.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;
|
|
};
|
|
|
|
GameMath.prototype.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;
|
|
};
|
|
|
|
/**
|
|
* a one dimensional linear interpolation of a value.
|
|
*/
|
|
GameMath.prototype.interpolateFloat = function (a, b, weight) {
|
|
return (b - a) * weight + a;
|
|
};
|
|
|
|
/**
|
|
* convert radians to degrees
|
|
*/
|
|
GameMath.prototype.radiansToDegrees = function (angle) {
|
|
return angle * GameMath.RAD_TO_DEG;
|
|
};
|
|
|
|
/**
|
|
* convert degrees to radians
|
|
*/
|
|
GameMath.prototype.degreesToRadians = function (angle) {
|
|
return angle * GameMath.DEG_TO_RAD;
|
|
};
|
|
|
|
/**
|
|
* Find the angle of a segment from (x1, y1) -> (x2, y2 )
|
|
*/
|
|
GameMath.prototype.angleBetween = function (x1, y1, x2, y2) {
|
|
return Math.atan2(y2 - y1, x2 - x1);
|
|
};
|
|
|
|
/**
|
|
* set an angle within the bounds of -PI to PI
|
|
*/
|
|
GameMath.prototype.normalizeAngle = function (angle, radians) {
|
|
if (typeof radians === "undefined") { radians = true; }
|
|
var rd = (radians) ? GameMath.PI : 180;
|
|
return this.wrap(angle, rd, -rd);
|
|
};
|
|
|
|
/**
|
|
* closest angle between two angles from a1 to a2
|
|
* absolute value the return for exact angle
|
|
*/
|
|
GameMath.prototype.nearestAngleBetween = function (a1, a2, radians) {
|
|
if (typeof radians === "undefined") { radians = true; }
|
|
var rd = (radians) ? GameMath.PI : 180;
|
|
|
|
a1 = this.normalizeAngle(a1, radians);
|
|
a2 = this.normalizeAngle(a2, radians);
|
|
|
|
if (a1 < -rd / 2 && a2 > rd / 2)
|
|
a1 += rd * 2;
|
|
if (a2 < -rd / 2 && a1 > rd / 2)
|
|
a2 += rd * 2;
|
|
|
|
return a2 - a1;
|
|
};
|
|
|
|
/**
|
|
* normalizes independent and then sets dep to the nearest value respective to independent
|
|
*
|
|
* for instance if dep=-170 and ind=170 then 190 will be returned as an alternative to -170
|
|
*/
|
|
GameMath.prototype.normalizeAngleToAnother = function (dep, ind, radians) {
|
|
if (typeof radians === "undefined") { radians = true; }
|
|
return ind + this.nearestAngleBetween(ind, dep, radians);
|
|
};
|
|
|
|
/**
|
|
* normalize independent and dependent and then set dependent to an angle relative to 'after/clockwise' independent
|
|
*
|
|
* for instance dep=-170 and ind=170, then 190 will be reutrned as alternative to -170
|
|
*/
|
|
GameMath.prototype.normalizeAngleAfterAnother = function (dep, ind, radians) {
|
|
if (typeof radians === "undefined") { radians = true; }
|
|
dep = this.normalizeAngle(dep - ind, radians);
|
|
return ind + dep;
|
|
};
|
|
|
|
/**
|
|
* normalizes indendent and dependent and then sets dependent to an angle relative to 'before/counterclockwise' independent
|
|
*
|
|
* for instance dep = 190 and ind = 170, then -170 will be returned as an alternative to 190
|
|
*/
|
|
GameMath.prototype.normalizeAngleBeforeAnother = function (dep, ind, radians) {
|
|
if (typeof radians === "undefined") { radians = true; }
|
|
dep = this.normalizeAngle(ind - dep, radians);
|
|
return ind - dep;
|
|
};
|
|
|
|
/**
|
|
* interpolate across the shortest arc between two angles
|
|
*/
|
|
GameMath.prototype.interpolateAngles = function (a1, a2, weight, radians, ease) {
|
|
if (typeof radians === "undefined") { radians = true; }
|
|
if (typeof ease === "undefined") { ease = null; }
|
|
a1 = this.normalizeAngle(a1, radians);
|
|
a2 = this.normalizeAngleToAnother(a2, a1, radians);
|
|
|
|
return (typeof ease === 'function') ? ease(weight, a1, a2 - a1, 1) : this.interpolateFloat(a1, a2, weight);
|
|
};
|
|
|
|
/**
|
|
* Compute the logarithm of any value of any base
|
|
*
|
|
* a logarithm is the exponent that some constant (base) would have to be raised to
|
|
* to be equal to value.
|
|
*
|
|
* i.e.
|
|
* 4 ^ x = 16
|
|
* can be rewritten as to solve for x
|
|
* logB4(16) = x
|
|
* which with this function would be
|
|
* LoDMath.logBaseOf(16,4)
|
|
*
|
|
* which would return 2, because 4^2 = 16
|
|
*/
|
|
GameMath.prototype.logBaseOf = function (value, base) {
|
|
return Math.log(value) / Math.log(base);
|
|
};
|
|
|
|
/**
|
|
* Greatest Common Denominator using Euclid's algorithm
|
|
*/
|
|
GameMath.prototype.GCD = function (m, n) {
|
|
var r;
|
|
|
|
//make sure positive, GCD is always positive
|
|
m = Math.abs(m);
|
|
n = Math.abs(n);
|
|
|
|
if (m < n) {
|
|
r = m;
|
|
m = n;
|
|
n = r;
|
|
}
|
|
|
|
while (true) {
|
|
r = m % n;
|
|
if (!r)
|
|
return n;
|
|
m = n;
|
|
n = r;
|
|
}
|
|
|
|
return 1;
|
|
};
|
|
|
|
/**
|
|
* Lowest Common Multiple
|
|
*/
|
|
GameMath.prototype.LCM = function (m, n) {
|
|
return (m * n) / this.GCD(m, n);
|
|
};
|
|
|
|
/**
|
|
* Factorial - N!
|
|
*
|
|
* simple product series
|
|
*
|
|
* by definition:
|
|
* 0! == 1
|
|
*/
|
|
GameMath.prototype.factorial = function (value) {
|
|
if (value == 0)
|
|
return 1;
|
|
|
|
var res = value;
|
|
|
|
while (--value) {
|
|
res *= value;
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
/**
|
|
* gamma function
|
|
*
|
|
* defined: gamma(N) == (N - 1)!
|
|
*/
|
|
GameMath.prototype.gammaFunction = function (value) {
|
|
return this.factorial(value - 1);
|
|
};
|
|
|
|
/**
|
|
* falling factorial
|
|
*
|
|
* defined: (N)! / (N - x)!
|
|
*
|
|
* written subscript: (N)x OR (base)exp
|
|
*/
|
|
GameMath.prototype.fallingFactorial = function (base, exp) {
|
|
return this.factorial(base) / this.factorial(base - exp);
|
|
};
|
|
|
|
/**
|
|
* rising factorial
|
|
*
|
|
* defined: (N + x - 1)! / (N - 1)!
|
|
*
|
|
* written superscript N^(x) OR base^(exp)
|
|
*/
|
|
GameMath.prototype.risingFactorial = function (base, exp) {
|
|
//expanded from gammaFunction for speed
|
|
return this.factorial(base + exp - 1) / this.factorial(base - 1);
|
|
};
|
|
|
|
/**
|
|
* binomial coefficient
|
|
*
|
|
* defined: N! / (k!(N-k)!)
|
|
* reduced: N! / (N-k)! == (N)k (fallingfactorial)
|
|
* reduced: (N)k / k!
|
|
*/
|
|
GameMath.prototype.binCoef = function (n, k) {
|
|
return this.fallingFactorial(n, k) / this.factorial(k);
|
|
};
|
|
|
|
/**
|
|
* rising binomial coefficient
|
|
*
|
|
* as one can notice in the analysis of binCoef(...) that
|
|
* binCoef is the (N)k divided by k!. Similarly rising binCoef
|
|
* is merely N^(k) / k!
|
|
*/
|
|
GameMath.prototype.risingBinCoef = function (n, k) {
|
|
return this.risingFactorial(n, k) / this.factorial(k);
|
|
};
|
|
|
|
/**
|
|
* Generate a random boolean result based on the chance value
|
|
* <p>
|
|
* Returns true or false based on the chance value (default 50%). For example if you wanted a player to have a 30% chance
|
|
* of getting a bonus, call chanceRoll(30) - true means the chance passed, false means it failed.
|
|
* </p>
|
|
* @param chance The chance of receiving the value. A number between 0 and 100 (effectively 0% to 100%)
|
|
* @return true if the roll passed, or false
|
|
*/
|
|
GameMath.prototype.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;
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Adds the given amount to the value, but never lets the value go over the specified maximum
|
|
*
|
|
* @param value The value to add the amount to
|
|
* @param amount The amount to add to the value
|
|
* @param max The maximum the value is allowed to be
|
|
* @return The new value
|
|
*/
|
|
GameMath.prototype.maxAdd = function (value, amount, max) {
|
|
value += amount;
|
|
|
|
if (value > max) {
|
|
value = max;
|
|
}
|
|
|
|
return value;
|
|
};
|
|
|
|
/**
|
|
* Subtracts the given amount from the value, but never lets the value go below the specified minimum
|
|
*
|
|
* @param value The base value
|
|
* @param amount The amount to subtract from the base value
|
|
* @param min The minimum the value is allowed to be
|
|
* @return The new value
|
|
*/
|
|
GameMath.prototype.minSub = function (value, amount, min) {
|
|
value -= amount;
|
|
|
|
if (value < min) {
|
|
value = min;
|
|
}
|
|
|
|
return value;
|
|
};
|
|
|
|
/**
|
|
* Adds value to amount and ensures that the result always stays between 0 and max, by wrapping the value around.
|
|
* <p>Values must be positive integers, and are passed through Math.abs</p>
|
|
*
|
|
* @param value The value to add the amount to
|
|
* @param amount The amount to add to the value
|
|
* @param max The maximum the value is allowed to be
|
|
* @return The wrapped value
|
|
*/
|
|
GameMath.prototype.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;
|
|
};
|
|
|
|
/**
|
|
* Randomly returns either a 1 or -1
|
|
*
|
|
* @return 1 or -1
|
|
*/
|
|
GameMath.prototype.randomSign = function () {
|
|
return (Math.random() > 0.5) ? 1 : -1;
|
|
};
|
|
|
|
/**
|
|
* Returns true if the number given is odd.
|
|
*
|
|
* @param n The number to check
|
|
*
|
|
* @return True if the given number is odd. False if the given number is even.
|
|
*/
|
|
GameMath.prototype.isOdd = function (n) {
|
|
if (n & 1) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns true if the number given is even.
|
|
*
|
|
* @param n The number to check
|
|
*
|
|
* @return True if the given number is even. False if the given number is odd.
|
|
*/
|
|
GameMath.prototype.isEven = function (n) {
|
|
if (n & 1) {
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Keeps an angle value between -180 and +180<br>
|
|
* Should be called whenever the angle is updated on the Sprite to stop it from going insane.
|
|
*
|
|
* @param angle The angle value to check
|
|
*
|
|
* @return The new angle value, returns the same as the input angle if it was within bounds
|
|
*/
|
|
GameMath.prototype.wrapAngle = function (angle) {
|
|
var result = angle;
|
|
|
|
if (angle >= -180 && angle <= 180) {
|
|
return angle;
|
|
}
|
|
|
|
// Else normalise it to -180, 180
|
|
result = (angle + 180) % 360;
|
|
|
|
if (result < 0) {
|
|
result += 360;
|
|
}
|
|
|
|
return result - 180;
|
|
};
|
|
|
|
/**
|
|
* Keeps an angle value between the given min and max values
|
|
*
|
|
* @param angle The angle value to check. Must be between -180 and +180
|
|
* @param min The minimum angle that is allowed (must be -180 or greater)
|
|
* @param max The maximum angle that is allowed (must be 180 or less)
|
|
*
|
|
* @return The new angle value, returns the same as the input angle if it was within bounds
|
|
*/
|
|
GameMath.prototype.angleLimit = function (angle, min, max) {
|
|
var result = angle;
|
|
|
|
if (angle > max) {
|
|
result = max;
|
|
} else if (angle < min) {
|
|
result = min;
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* @method linear
|
|
* @param {Any} v
|
|
* @param {Any} k
|
|
* @public
|
|
*/
|
|
GameMath.prototype.linearInterpolation = function (v, k) {
|
|
var m = v.length - 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);
|
|
};
|
|
|
|
/**
|
|
* @method Bezier
|
|
* @param {Any} v
|
|
* @param {Any} k
|
|
* @public
|
|
*/
|
|
GameMath.prototype.bezierInterpolation = function (v, k) {
|
|
var b = 0;
|
|
var n = v.length - 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;
|
|
};
|
|
|
|
/**
|
|
* @method CatmullRom
|
|
* @param {Any} v
|
|
* @param {Any} k
|
|
* @public
|
|
*/
|
|
GameMath.prototype.catmullRomInterpolation = function (v, k) {
|
|
var m = v.length - 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);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @method Linear
|
|
* @param {Any} p0
|
|
* @param {Any} p1
|
|
* @param {Any} t
|
|
* @public
|
|
*/
|
|
GameMath.prototype.linear = function (p0, p1, t) {
|
|
return (p1 - p0) * t + p0;
|
|
};
|
|
|
|
/**
|
|
* @method Bernstein
|
|
* @param {Any} n
|
|
* @param {Any} i
|
|
* @public
|
|
*/
|
|
GameMath.prototype.bernstein = function (n, i) {
|
|
return this.factorial(n) / this.factorial(i) / this.factorial(n - i);
|
|
};
|
|
|
|
/**
|
|
* @method CatmullRom
|
|
* @param {Any} p0
|
|
* @param {Any} p1
|
|
* @param {Any} p2
|
|
* @param {Any} p3
|
|
* @param {Any} t
|
|
* @public
|
|
*/
|
|
GameMath.prototype.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;
|
|
};
|
|
|
|
GameMath.prototype.difference = function (a, b) {
|
|
return Math.abs(a - b);
|
|
};
|
|
|
|
/**
|
|
* Fetch a random entry from the given array.
|
|
* Will return null if random selection is missing, or array has no entries.
|
|
*
|
|
* @param objects An array of objects.
|
|
* @param startIndex Optional offset off the front of the array. Default value is 0, or the beginning of the array.
|
|
* @param length Optional restriction on the number of values you want to randomly select from.
|
|
*
|
|
* @return The random object that was selected.
|
|
*/
|
|
GameMath.prototype.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 > objects.length - startIndex)) {
|
|
l = objects.length - startIndex;
|
|
}
|
|
|
|
if (l > 0) {
|
|
return objects[startIndex + Math.floor(Math.random() * l)];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Round down to the next whole number. E.g. floor(1.7) == 1, and floor(-2.7) == -2.
|
|
*
|
|
* @param Value Any number.
|
|
*
|
|
* @return The rounded value of that number.
|
|
*/
|
|
GameMath.prototype.floor = function (value) {
|
|
var n = value | 0;
|
|
return (value > 0) ? (n) : ((n != value) ? (n - 1) : (n));
|
|
};
|
|
|
|
/**
|
|
* Round up to the next whole number. E.g. ceil(1.3) == 2, and ceil(-2.3) == -3.
|
|
*
|
|
* @param Value Any number.
|
|
*
|
|
* @return The rounded value of that number.
|
|
*/
|
|
GameMath.prototype.ceil = function (value) {
|
|
var n = value | 0;
|
|
return (value > 0) ? ((n != value) ? (n + 1) : (n)) : (n);
|
|
};
|
|
|
|
/**
|
|
* Generate a sine and cosine table simultaneously and extremely quickly. Based on research by Franky of scene.at
|
|
* <p>
|
|
* The parameters allow you to specify the length, amplitude and frequency of the wave. Once you have called this function
|
|
* you should get the results via getSinTable() and getCosTable(). This generator is fast enough to be used in real-time.
|
|
* </p>
|
|
* @param length The length of the wave
|
|
* @param sinAmplitude The amplitude to apply to the sine table (default 1.0) if you need values between say -+ 125 then give 125 as the value
|
|
* @param cosAmplitude The amplitude to apply to the cosine table (default 1.0) if you need values between say -+ 125 then give 125 as the value
|
|
* @param frequency The frequency of the sine and cosine table data
|
|
* @return Returns the sine table
|
|
* @see getSinTable
|
|
* @see getCosTable
|
|
*/
|
|
GameMath.prototype.sinCosGenerator = function (length, sinAmplitude, cosAmplitude, frequency) {
|
|
if (typeof sinAmplitude === "undefined") { sinAmplitude = 1.0; }
|
|
if (typeof cosAmplitude === "undefined") { cosAmplitude = 1.0; }
|
|
if (typeof frequency === "undefined") { frequency = 1.0; }
|
|
var sin = sinAmplitude;
|
|
var cos = cosAmplitude;
|
|
var frq = frequency * Math.PI / length;
|
|
|
|
this.cosTable = [];
|
|
this.sinTable = [];
|
|
|
|
for (var c = 0; c < length; c++) {
|
|
cos -= sin * frq;
|
|
sin += cos * frq;
|
|
|
|
this.cosTable[c] = cos;
|
|
this.sinTable[c] = sin;
|
|
}
|
|
|
|
return this.sinTable;
|
|
};
|
|
|
|
/**
|
|
* Shifts through the sin table data by one value and returns it.
|
|
* This effectively moves the position of the data from the start to the end of the table.
|
|
* @return The sin value.
|
|
*/
|
|
GameMath.prototype.shiftSinTable = function () {
|
|
if (this.sinTable) {
|
|
var s = this.sinTable.shift();
|
|
this.sinTable.push(s);
|
|
return s;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Shifts through the cos table data by one value and returns it.
|
|
* This effectively moves the position of the data from the start to the end of the table.
|
|
* @return The cos value.
|
|
*/
|
|
GameMath.prototype.shiftCosTable = function () {
|
|
if (this.cosTable) {
|
|
var s = this.cosTable.shift();
|
|
this.cosTable.push(s);
|
|
return s;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Shuffles the data in the given array into a new order
|
|
* @param array The array to shuffle
|
|
* @return The array
|
|
*/
|
|
GameMath.prototype.shuffleArray = function (array) {
|
|
for (var i = array.length - 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;
|
|
};
|
|
|
|
/**
|
|
* Returns the distance from this Point object to the given Point object.
|
|
* @method distanceFrom
|
|
* @param {Point} target - The destination Point object.
|
|
* @param {Boolean} round - Round the distance to the nearest integer (default false)
|
|
* @return {Number} The distance between this Point object and the destination Point object.
|
|
**/
|
|
GameMath.prototype.distanceBetween = function (x1, y1, x2, y2) {
|
|
var dx = x1 - x2;
|
|
var dy = y1 - y2;
|
|
|
|
return Math.sqrt(dx * dx + dy * dy);
|
|
};
|
|
|
|
/**
|
|
* Finds the length of the given vector
|
|
*
|
|
* @param dx
|
|
* @param dy
|
|
*
|
|
* @return
|
|
*/
|
|
GameMath.prototype.vectorLength = function (dx, dy) {
|
|
return Math.sqrt(dx * dx + dy * dy);
|
|
};
|
|
GameMath.PI = 3.141592653589793;
|
|
GameMath.PI_2 = 1.5707963267948965;
|
|
GameMath.PI_4 = 0.7853981633974483;
|
|
GameMath.PI_8 = 0.39269908169872413;
|
|
GameMath.PI_16 = 0.19634954084936206;
|
|
GameMath.TWO_PI = 6.283185307179586;
|
|
GameMath.THREE_PI_2 = 4.7123889803846895;
|
|
GameMath.E = 2.71828182845905;
|
|
GameMath.LN10 = 2.302585092994046;
|
|
GameMath.LN2 = 0.6931471805599453;
|
|
GameMath.LOG10E = 0.4342944819032518;
|
|
GameMath.LOG2E = 1.442695040888963387;
|
|
GameMath.SQRT1_2 = 0.7071067811865476;
|
|
GameMath.SQRT2 = 1.4142135623730951;
|
|
GameMath.DEG_TO_RAD = 0.017453292519943294444444444444444;
|
|
GameMath.RAD_TO_DEG = 57.295779513082325225835265587527;
|
|
|
|
GameMath.B_16 = 65536;
|
|
GameMath.B_31 = 2147483648;
|
|
GameMath.B_32 = 4294967296;
|
|
GameMath.B_48 = 281474976710656;
|
|
GameMath.B_53 = 9007199254740992;
|
|
GameMath.B_64 = 18446744073709551616;
|
|
|
|
GameMath.ONE_THIRD = 0.333333333333333333333333333333333;
|
|
GameMath.TWO_THIRDS = 0.666666666666666666666666666666666;
|
|
GameMath.ONE_SIXTH = 0.166666666666666666666666666666666;
|
|
|
|
GameMath.COS_PI_3 = 0.86602540378443864676372317075294;
|
|
GameMath.SIN_2PI_3 = 0.03654595;
|
|
|
|
GameMath.CIRCLE_ALPHA = 0.5522847498307933984022516322796;
|
|
|
|
GameMath.ON = true;
|
|
GameMath.OFF = false;
|
|
|
|
GameMath.SHORT_EPSILON = 0.1;
|
|
GameMath.PERC_EPSILON = 0.001;
|
|
GameMath.EPSILON = 0.0001;
|
|
GameMath.LONG_EPSILON = 0.00000001;
|
|
return GameMath;
|
|
})();
|
|
Phaser.GameMath = GameMath;
|
|
})(Phaser || (Phaser = {}));
|