GameObject overlaps another.
- * Can be called with one object and one group, or two groups, or two objects,
- * whatever floats your boat! For maximum performance try bundling a lot of objects
- * together using a Group (or even bundling groups together!).
- *
- * NOTE: does NOT take objects' scrollfactor into account, all overlaps are checked in world space.
- * - * @param ObjectOrGroup1 The first object or group you want to check. - * @param ObjectOrGroup2 The second object or group you want to check. If it is the same as the first it knows to just do a comparison within that group. - * @param NotifyCallback A function with twoGameObject parameters - e.g. myOverlapFunction(Object1:GameObject,Object2:GameObject) - that is called if those two objects overlap.
- * @param ProcessCallback A function with two GameObject parameters - e.g. myOverlapFunction(Object1:GameObject,Object2:GameObject) - that is called if those two objects overlap. If a ProcessCallback is provided, then NotifyCallback will only be called if ProcessCallback returns true for those objects!
- *
- * @return Whether any overlaps were detected.
- */
- public overlap(ObjectOrGroup1: Basic = null, ObjectOrGroup2: Basic = null, NotifyCallback = null, ProcessCallback = null): bool {
-
- if (ObjectOrGroup1 == null)
+ if (object1 == null)
{
- ObjectOrGroup1 = this._game.world.group;
+ object1 = this._game.world.group;
}
- if (ObjectOrGroup2 == ObjectOrGroup1)
+ if (object2 == object1)
{
- ObjectOrGroup2 = null;
+ object2 = null;
}
QuadTree.divisions = this._game.world.worldDivisions;
var quadTree: QuadTree = new QuadTree(this._game.world.bounds.x, this._game.world.bounds.y, this._game.world.bounds.width, this._game.world.bounds.height);
- quadTree.load(ObjectOrGroup1, ObjectOrGroup2, NotifyCallback, ProcessCallback);
+ quadTree.load(object1, object2, notifyCallback, processCallback);
var result: bool = quadTree.execute();
@@ -604,98 +614,91 @@ module Phaser {
}
/**
- * The main collision resolution in flixel.
- *
- * @param Object1 Any Sprite.
- * @param Object2 Any other Sprite.
- *
- * @return Whether the objects in fact touched and were separated.
+ * The core Collision separation function used by Collision.overlap.
+ * @param object1 The first GameObject to separate
+ * @param object2 The second GameObject to separate
+ * @returns {boolean} Returns true if the objects were separated, otherwise false.
*/
- public static separate(Object1, Object2): bool {
+ public static separate(object1, object2): bool {
- var separatedX: bool = Collision.separateX(Object1, Object2);
- var separatedY: bool = Collision.separateY(Object1, Object2);
+ var separatedX: bool = Collision.separateX(object1, object2);
+ var separatedY: bool = Collision.separateY(object1, object2);
return separatedX || separatedY;
}
/**
- * The X-axis component of the object separation process.
- *
- * @param Object1 Any Sprite.
- * @param Object2 Any other Sprite.
- *
- * @return Whether the objects in fact touched and were separated along the X axis.
+ * Collision resolution specifically for GameObjects vs. Tiles.
+ * @param object The GameObject to separate
+ * @param tile The Tile to separate
+ * @returns {boolean} Whether the objects in fact touched and were separated
*/
- public static separateX(Object1, Object2): bool {
+ public static separateTile(object:GameObject, tile): bool {
- //can't separate two immovable objects
- var obj1immovable: bool = Object1.immovable;
- var obj2immovable: bool = Object2.immovable;
+ var separatedX: bool = Collision.separateTileX(object, tile);
+ var separatedY: bool = Collision.separateTileY(object, tile);
- if (obj1immovable && obj2immovable)
+ return separatedX || separatedY;
+
+ }
+
+ /**
+ * Separates the two objects on their x axis
+ * @param object The GameObject to separate
+ * @param tile The Tile to separate
+ * @returns {boolean} Whether the objects in fact touched and were separated along the X axis.
+ */
+ public static separateTileX(object, tile): bool {
+
+ // Can't separate two immovable objects
+ if (object.immovable && tile.immovable)
{
return false;
}
- //If one of the objects is a tilemap, just pass it off.
- /*
- if (typeof Object1 === 'Tilemap')
- {
- return Object1.overlapsWithCallback(Object2, separateX);
- }
-
- if (typeof Object2 === 'Tilemap')
- {
- return Object2.overlapsWithCallback(Object1, separateX, true);
- }
- */
-
- //First, get the two object deltas
+ // First, get the two object deltas
var overlap: number = 0;
- var obj1delta: number = Object1.x - Object1.last.x;
- var obj2delta: number = Object2.x - Object2.last.x;
+ var objDelta: number = object.x - object.last.x;
+ var tileDelta: number = 0;
- if (obj1delta != obj2delta)
+ if (objDelta != tileDelta)
{
- //Check if the X hulls actually overlap
- var obj1deltaAbs: number = (obj1delta > 0) ? obj1delta : -obj1delta;
- var obj2deltaAbs: number = (obj2delta > 0) ? obj2delta : -obj2delta;
- var obj1rect: Rectangle = new Rectangle(Object1.x - ((obj1delta > 0) ? obj1delta : 0), Object1.last.y, Object1.width + ((obj1delta > 0) ? obj1delta : -obj1delta), Object1.height);
- var obj2rect: Rectangle = new Rectangle(Object2.x - ((obj2delta > 0) ? obj2delta : 0), Object2.last.y, Object2.width + ((obj2delta > 0) ? obj2delta : -obj2delta), Object2.height);
+ // Check if the X hulls actually overlap
+ var objDeltaAbs: number = (objDelta > 0) ? objDelta : -objDelta;
+ var tileDeltaAbs: number = (tileDelta > 0) ? tileDelta : -tileDelta;
+ var objBounds: Quad = new Quad(object.x - ((objDelta > 0) ? objDelta : 0), object.last.y, object.width + ((objDelta > 0) ? objDelta : -objDelta), object.height);
+ var tileBounds: Quad = new Quad(tile.x - ((tileDelta > 0) ? tileDelta : 0), tile.y, tile.width + ((tileDelta > 0) ? tileDelta : -tileDelta), tile.height);
- if ((obj1rect.x + obj1rect.width > obj2rect.x) && (obj1rect.x < obj2rect.x + obj2rect.width) && (obj1rect.y + obj1rect.height > obj2rect.y) && (obj1rect.y < obj2rect.y + obj2rect.height))
+ if ((objBounds.x + objBounds.width > tileBounds.x) && (objBounds.x < tileBounds.x + tileBounds.width) && (objBounds.y + objBounds.height > tileBounds.y) && (objBounds.y < tileBounds.y + tileBounds.height))
{
- var maxOverlap: number = obj1deltaAbs + obj2deltaAbs + Collision.OVERLAP_BIAS;
+ var maxOverlap: number = objDeltaAbs + tileDeltaAbs + Collision.OVERLAP_BIAS;
- //If they did overlap (and can), figure out by how much and flip the corresponding flags
- if (obj1delta > obj2delta)
+ // If they did overlap (and can), figure out by how much and flip the corresponding flags
+ if (objDelta > tileDelta)
{
- overlap = Object1.x + Object1.width - Object2.x;
+ overlap = object.x + object.width - tile.x;
- if ((overlap > maxOverlap) || !(Object1.allowCollisions & Collision.RIGHT) || !(Object2.allowCollisions & Collision.LEFT))
+ if ((overlap > maxOverlap) || !(object.allowCollisions & Collision.RIGHT) || !(tile.allowCollisions & Collision.LEFT))
{
overlap = 0;
}
else
{
- Object1.touching |= Collision.RIGHT;
- Object2.touching |= Collision.LEFT;
+ object.touching |= Collision.RIGHT;
}
}
- else if (obj1delta < obj2delta)
- {
- overlap = Object1.x - Object2.width - Object2.x;
+ else if (objDelta < tileDelta)
+ {
+ overlap = object.x - tile.width - tile.x;
- if ((-overlap > maxOverlap) || !(Object1.allowCollisions & Collision.LEFT) || !(Object2.allowCollisions & Collision.RIGHT))
+ if ((-overlap > maxOverlap) || !(object.allowCollisions & Collision.LEFT) || !(tile.allowCollisions & Collision.RIGHT))
{
overlap = 0;
}
else
{
- Object1.touching |= Collision.LEFT;
- Object2.touching |= Collision.RIGHT;
+ object.touching |= Collision.LEFT;
}
}
@@ -703,35 +706,27 @@ module Phaser {
}
}
- //Then adjust their positions and velocities accordingly (if there was any overlap)
+ // Then adjust their positions and velocities accordingly (if there was any overlap)
if (overlap != 0)
{
- var obj1v: number = Object1.velocity.x;
- var obj2v: number = Object2.velocity.x;
+ var objVelocity: number = object.velocity.x;
+ var tileVelocity: number = 0;
- if (!obj1immovable && !obj2immovable)
+ if (!object.immovable && !tile.immovable)
{
overlap *= 0.5;
- Object1.x = Object1.x - overlap;
- Object2.x += overlap;
+ object.x = object.x - overlap;
- var obj1velocity: number = Math.sqrt((obj2v * obj2v * Object2.mass) / Object1.mass) * ((obj2v > 0) ? 1 : -1);
- var obj2velocity: number = Math.sqrt((obj1v * obj1v * Object1.mass) / Object2.mass) * ((obj1v > 0) ? 1 : -1);
- var average: number = (obj1velocity + obj2velocity) * 0.5;
- obj1velocity -= average;
- obj2velocity -= average;
- Object1.velocity.x = average + obj1velocity * Object1.elasticity;
- Object2.velocity.x = average + obj2velocity * Object2.elasticity;
+ var objNewVelocity: number = Math.sqrt((tileVelocity * tileVelocity * tile.mass) / object.mass) * ((tileVelocity > 0) ? 1 : -1);
+ var tileNewVelocity: number = Math.sqrt((objVelocity * objVelocity * object.mass) / tile.mass) * ((objVelocity > 0) ? 1 : -1);
+ var average: number = (objNewVelocity + tileNewVelocity) * 0.5;
+ objNewVelocity -= average;
+ object.velocity.x = average + objNewVelocity * object.elasticity;
}
- else if (!obj1immovable)
- {
- Object1.x = Object1.x - overlap;
- Object1.velocity.x = obj2v - obj1v * Object1.elasticity;
- }
- else if (!obj2immovable)
- {
- Object2.x += overlap;
- Object2.velocity.x = obj1v - obj2v * Object2.elasticity;
+ else if (!object.immovable)
+ {
+ object.x = object.x - overlap;
+ object.velocity.x = tileVelocity - objVelocity * object.elasticity;
}
return true;
@@ -744,123 +739,98 @@ module Phaser {
}
/**
- * The Y-axis component of the object separation process.
- *
- * @param Object1 Any Sprite.
- * @param Object2 Any other Sprite.
- *
- * @return Whether the objects in fact touched and were separated along the Y axis.
+ * Separates the two objects on their y axis
+ * @param object The first GameObject to separate
+ * @param tile The second GameObject to separate
+ * @returns {boolean} Whether the objects in fact touched and were separated along the Y axis.
*/
- public static separateY(Object1, Object2): bool {
+ public static separateTileY(object, tile): bool {
- //can't separate two immovable objects
-
- var obj1immovable: bool = Object1.immovable;
- var obj2immovable: bool = Object2.immovable;
-
- if (obj1immovable && obj2immovable)
+ // Can't separate two immovable objects
+ if (object.immovable && tile.immovable) {
return false;
-
- //If one of the objects is a tilemap, just pass it off.
- /*
- if (typeof Object1 === 'Tilemap')
- {
- return Object1.overlapsWithCallback(Object2, separateY);
}
-
- if (typeof Object2 === 'Tilemap')
- {
- return Object2.overlapsWithCallback(Object1, separateY, true);
- }
- */
- //First, get the two object deltas
+ // First, get the two object deltas
var overlap: number = 0;
- var obj1delta: number = Object1.y - Object1.last.y;
- var obj2delta: number = Object2.y - Object2.last.y;
+ var objDelta: number = object.y - object.last.y;
+ var tileDelta: number = 0;
- if (obj1delta != obj2delta)
+ if (objDelta != tileDelta)
{
- //Check if the Y hulls actually overlap
- var obj1deltaAbs: number = (obj1delta > 0) ? obj1delta : -obj1delta;
- var obj2deltaAbs: number = (obj2delta > 0) ? obj2delta : -obj2delta;
- var obj1rect: Rectangle = new Rectangle(Object1.x, Object1.y - ((obj1delta > 0) ? obj1delta : 0), Object1.width, Object1.height + obj1deltaAbs);
- var obj2rect: Rectangle = new Rectangle(Object2.x, Object2.y - ((obj2delta > 0) ? obj2delta : 0), Object2.width, Object2.height + obj2deltaAbs);
+ // Check if the Y hulls actually overlap
+ var objDeltaAbs: number = (objDelta > 0) ? objDelta : -objDelta;
+ var tileDeltaAbs: number = (tileDelta > 0) ? tileDelta : -tileDelta;
+ var objBounds: Quad = new Quad(object.x, object.y - ((objDelta > 0) ? objDelta : 0), object.width, object.height + objDeltaAbs);
+ var tileBounds: Quad = new Quad(tile.x, tile.y - ((tileDelta > 0) ? tileDelta : 0), tile.width, tile.height + tileDeltaAbs);
- if ((obj1rect.x + obj1rect.width > obj2rect.x) && (obj1rect.x < obj2rect.x + obj2rect.width) && (obj1rect.y + obj1rect.height > obj2rect.y) && (obj1rect.y < obj2rect.y + obj2rect.height))
+ if ((objBounds.x + objBounds.width > tileBounds.x) && (objBounds.x < tileBounds.x + tileBounds.width) && (objBounds.y + objBounds.height > tileBounds.y) && (objBounds.y < tileBounds.y + tileBounds.height))
{
- var maxOverlap: number = obj1deltaAbs + obj2deltaAbs + Collision.OVERLAP_BIAS;
+ var maxOverlap: number = objDeltaAbs + tileDeltaAbs + Collision.OVERLAP_BIAS;
- //If they did overlap (and can), figure out by how much and flip the corresponding flags
- if (obj1delta > obj2delta)
+ // If they did overlap (and can), figure out by how much and flip the corresponding flags
+ if (objDelta > tileDelta)
{
- overlap = Object1.y + Object1.height - Object2.y;
+ overlap = object.y + object.height - tile.y;
- if ((overlap > maxOverlap) || !(Object1.allowCollisions & Collision.DOWN) || !(Object2.allowCollisions & Collision.UP))
+ if ((overlap > maxOverlap) || !(object.allowCollisions & Collision.DOWN) || !(tile.allowCollisions & Collision.UP))
{
overlap = 0;
}
else
{
- Object1.touching |= Collision.DOWN;
- Object2.touching |= Collision.UP;
+ object.touching |= Collision.DOWN;
+ //tile.touching |= Collision.UP;
}
}
- else if (obj1delta < obj2delta)
- {
- overlap = Object1.y - Object2.height - Object2.y;
+ else if (objDelta < tileDelta)
+ {
+ overlap = object.y - tile.height - tile.y;
- if ((-overlap > maxOverlap) || !(Object1.allowCollisions & Collision.UP) || !(Object2.allowCollisions & Collision.DOWN))
+ if ((-overlap > maxOverlap) || !(object.allowCollisions & Collision.UP) || !(tile.allowCollisions & Collision.DOWN))
{
overlap = 0;
}
else
{
- Object1.touching |= Collision.UP;
- Object2.touching |= Collision.DOWN;
+ object.touching |= Collision.UP;
+ //tile.touching |= Collision.DOWN;
}
}
}
}
- //Then adjust their positions and velocities accordingly (if there was any overlap)
+ // TODO - with super low velocities you get lots of stuttering, set some kind of base minimum here
+
+ // Then adjust their positions and velocities accordingly (if there was any overlap)
if (overlap != 0)
{
- var obj1v: number = Object1.velocity.y;
- var obj2v: number = Object2.velocity.y;
+ var objVelocity: number = object.velocity.y;
+ var tileVelocity: number = 0;
- if (!obj1immovable && !obj2immovable)
+ if (!object.immovable && !tile.immovable)
{
overlap *= 0.5;
- Object1.y = Object1.y - overlap;
- Object2.y += overlap;
+ object.y = object.y - overlap;
+ //tile.y += overlap;
- var obj1velocity: number = Math.sqrt((obj2v * obj2v * Object2.mass) / Object1.mass) * ((obj2v > 0) ? 1 : -1);
- var obj2velocity: number = Math.sqrt((obj1v * obj1v * Object1.mass) / Object2.mass) * ((obj1v > 0) ? 1 : -1);
- var average: number = (obj1velocity + obj2velocity) * 0.5;
- obj1velocity -= average;
- obj2velocity -= average;
- Object1.velocity.y = average + obj1velocity * Object1.elasticity;
- Object2.velocity.y = average + obj2velocity * Object2.elasticity;
+ var objNewVelocity: number = Math.sqrt((tileVelocity * tileVelocity * tile.mass) / object.mass) * ((tileVelocity > 0) ? 1 : -1);
+ var tileNewVelocity: number = Math.sqrt((objVelocity * objVelocity * object.mass) / tile.mass) * ((objVelocity > 0) ? 1 : -1);
+ var average: number = (objNewVelocity + tileNewVelocity) * 0.5;
+ objNewVelocity -= average;
+ //tileNewVelocity -= average;
+ object.velocity.y = average + objNewVelocity * object.elasticity;
+ //tile.velocity.y = average + tileNewVelocity * tile.elasticity;
}
- else if (!obj1immovable)
+ else if (!object.immovable)
+ {
+ //console.log('y sep', overlap, object.y);
+ object.y = object.y - overlap;
+ object.velocity.y = tileVelocity - objVelocity * object.elasticity;
+ // This is special case code that handles things like horizontal moving platforms you can ride
+ if (tile.active && tile.moves && (objDelta > tileDelta))
{
- Object1.y = Object1.y - overlap;
- Object1.velocity.y = obj2v - obj1v * Object1.elasticity;
- //This is special case code that handles cases like horizontal moving platforms you can ride
- if (Object2.active && Object2.moves && (obj1delta > obj2delta))
- {
- Object1.x += Object2.x - Object2.last.x;
- }
- }
- else if (!obj2immovable)
- {
- Object2.y += overlap;
- Object2.velocity.y = obj1v - obj2v * Object2.elasticity;
- //This is special case code that handles cases like horizontal moving platforms you can ride
- if (Object1.active && Object1.moves && (obj1delta < obj2delta))
- {
- Object2.x += Object1.x - Object1.last.x;
+ //object.x += tile.x - tile.x;
}
}
@@ -872,22 +842,246 @@ module Phaser {
}
}
+ /**
+ * Separates the two objects on their x axis
+ * @param object1 The first GameObject to separate
+ * @param object2 The second GameObject to separate
+ * @returns {boolean} Whether the objects in fact touched and were separated along the X axis.
+ */
+ public static separateX(object1, object2): bool {
+
+ // Can't separate two immovable objects
+ if (object1.immovable && object2.immovable)
+ {
+ return false;
+ }
+
+ // First, get the two object deltas
+ var overlap: number = 0;
+ var obj1Delta: number = object1.x - object1.last.x;
+ var obj2Delta: number = object2.x - object2.last.x;
+
+ if (obj1Delta != obj2Delta)
+ {
+ // Check if the X hulls actually overlap
+ var obj1DeltaAbs: number = (obj1Delta > 0) ? obj1Delta : -obj1Delta;
+ var obj2DeltaAbs: number = (obj2Delta > 0) ? obj2Delta : -obj2Delta;
+ var obj1Bounds: Quad = new Quad(object1.x - ((obj1Delta > 0) ? obj1Delta : 0), object1.last.y, object1.width + ((obj1Delta > 0) ? obj1Delta : -obj1Delta), object1.height);
+ var obj2Bounds: Quad = new Quad(object2.x - ((obj2Delta > 0) ? obj2Delta : 0), object2.last.y, object2.width + ((obj2Delta > 0) ? obj2Delta : -obj2Delta), object2.height);
+
+ if ((obj1Bounds.x + obj1Bounds.width > obj2Bounds.x) && (obj1Bounds.x < obj2Bounds.x + obj2Bounds.width) && (obj1Bounds.y + obj1Bounds.height > obj2Bounds.y) && (obj1Bounds.y < obj2Bounds.y + obj2Bounds.height))
+ {
+ var maxOverlap: number = obj1DeltaAbs + obj2DeltaAbs + Collision.OVERLAP_BIAS;
+
+ // If they did overlap (and can), figure out by how much and flip the corresponding flags
+ if (obj1Delta > obj2Delta)
+ {
+ overlap = object1.x + object1.width - object2.x;
+
+ if ((overlap > maxOverlap) || !(object1.allowCollisions & Collision.RIGHT) || !(object2.allowCollisions & Collision.LEFT))
+ {
+ overlap = 0;
+ }
+ else
+ {
+ object1.touching |= Collision.RIGHT;
+ object2.touching |= Collision.LEFT;
+ }
+ }
+ else if (obj1Delta < obj2Delta)
+ {
+ overlap = object1.x - object2.width - object2.x;
+
+ if ((-overlap > maxOverlap) || !(object1.allowCollisions & Collision.LEFT) || !(object2.allowCollisions & Collision.RIGHT))
+ {
+ overlap = 0;
+ }
+ else
+ {
+ object1.touching |= Collision.LEFT;
+ object2.touching |= Collision.RIGHT;
+ }
+
+ }
+
+ }
+ }
+
+ // Then adjust their positions and velocities accordingly (if there was any overlap)
+ if (overlap != 0)
+ {
+ var obj1Velocity: number = object1.velocity.x;
+ var obj2Velocity: number = object2.velocity.x;
+
+ if (!object1.immovable && !object2.immovable)
+ {
+ overlap *= 0.5;
+ object1.x = object1.x - overlap;
+ object2.x += overlap;
+
+ var obj1NewVelocity: number = Math.sqrt((obj2Velocity * obj2Velocity * object2.mass) / object1.mass) * ((obj2Velocity > 0) ? 1 : -1);
+ var obj2NewVelocity: number = Math.sqrt((obj1Velocity * obj1Velocity * object1.mass) / object2.mass) * ((obj1Velocity > 0) ? 1 : -1);
+ var average: number = (obj1NewVelocity + obj2NewVelocity) * 0.5;
+ obj1NewVelocity -= average;
+ obj2NewVelocity -= average;
+ object1.velocity.x = average + obj1NewVelocity * object1.elasticity;
+ object2.velocity.x = average + obj2NewVelocity * object2.elasticity;
+ }
+ else if (!object1.immovable)
+ {
+ object1.x = object1.x - overlap;
+ object1.velocity.x = obj2Velocity - obj1Velocity * object1.elasticity;
+ }
+ else if (!object2.immovable)
+ {
+ object2.x += overlap;
+ object2.velocity.x = obj1Velocity - obj2Velocity * object2.elasticity;
+ }
+
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+
+ }
/**
- * -------------------------------------------------------------------------------------------
- * Distance
- * -------------------------------------------------------------------------------------------
- **/
+ * Separates the two objects on their y axis
+ * @param object1 The first GameObject to separate
+ * @param object2 The second GameObject to separate
+ * @returns {boolean} Whether the objects in fact touched and were separated along the Y axis.
+ */
+ public static separateY(object1, object2): bool {
+ // Can't separate two immovable objects
+ if (object1.immovable && object2.immovable) {
+ return false;
+ }
+
+ // First, get the two object deltas
+ var overlap: number = 0;
+ var obj1Delta: number = object1.y - object1.last.y;
+ var obj2Delta: number = object2.y - object2.last.y;
+
+ if (obj1Delta != obj2Delta)
+ {
+ // Check if the Y hulls actually overlap
+ var obj1DeltaAbs: number = (obj1Delta > 0) ? obj1Delta : -obj1Delta;
+ var obj2DeltaAbs: number = (obj2Delta > 0) ? obj2Delta : -obj2Delta;
+ var obj1Bounds: Quad = new Quad(object1.x, object1.y - ((obj1Delta > 0) ? obj1Delta : 0), object1.width, object1.height + obj1DeltaAbs);
+ var obj2Bounds: Quad = new Quad(object2.x, object2.y - ((obj2Delta > 0) ? obj2Delta : 0), object2.width, object2.height + obj2DeltaAbs);
+
+ if ((obj1Bounds.x + obj1Bounds.width > obj2Bounds.x) && (obj1Bounds.x < obj2Bounds.x + obj2Bounds.width) && (obj1Bounds.y + obj1Bounds.height > obj2Bounds.y) && (obj1Bounds.y < obj2Bounds.y + obj2Bounds.height))
+ {
+ var maxOverlap: number = obj1DeltaAbs + obj2DeltaAbs + Collision.OVERLAP_BIAS;
+
+ // If they did overlap (and can), figure out by how much and flip the corresponding flags
+ if (obj1Delta > obj2Delta)
+ {
+ overlap = object1.y + object1.height - object2.y;
+
+ if ((overlap > maxOverlap) || !(object1.allowCollisions & Collision.DOWN) || !(object2.allowCollisions & Collision.UP))
+ {
+ overlap = 0;
+ }
+ else
+ {
+ object1.touching |= Collision.DOWN;
+ object2.touching |= Collision.UP;
+ }
+ }
+ else if (obj1Delta < obj2Delta)
+ {
+ overlap = object1.y - object2.height - object2.y;
+
+ if ((-overlap > maxOverlap) || !(object1.allowCollisions & Collision.UP) || !(object2.allowCollisions & Collision.DOWN))
+ {
+ overlap = 0;
+ }
+ else
+ {
+ object1.touching |= Collision.UP;
+ object2.touching |= Collision.DOWN;
+ }
+ }
+ }
+ }
+
+ // Then adjust their positions and velocities accordingly (if there was any overlap)
+ if (overlap != 0)
+ {
+ var obj1Velocity: number = object1.velocity.y;
+ var obj2Velocity: number = object2.velocity.y;
+
+ if (!object1.immovable && !object2.immovable)
+ {
+ overlap *= 0.5;
+ object1.y = object1.y - overlap;
+ object2.y += overlap;
+
+ var obj1NewVelocity: number = Math.sqrt((obj2Velocity * obj2Velocity * object2.mass) / object1.mass) * ((obj2Velocity > 0) ? 1 : -1);
+ var obj2NewVelocity: number = Math.sqrt((obj1Velocity * obj1Velocity * object1.mass) / object2.mass) * ((obj1Velocity > 0) ? 1 : -1);
+ var average: number = (obj1NewVelocity + obj2NewVelocity) * 0.5;
+ obj1NewVelocity -= average;
+ obj2NewVelocity -= average;
+ object1.velocity.y = average + obj1NewVelocity * object1.elasticity;
+ object2.velocity.y = average + obj2NewVelocity * object2.elasticity;
+ }
+ else if (!object1.immovable)
+ {
+ object1.y = object1.y - overlap;
+ object1.velocity.y = obj2Velocity - obj1Velocity * object1.elasticity;
+ // This is special case code that handles things like horizontal moving platforms you can ride
+ if (object2.active && object2.moves && (obj1Delta > obj2Delta))
+ {
+ object1.x += object2.x - object2.last.x;
+ }
+ }
+ else if (!object2.immovable)
+ {
+ object2.y += overlap;
+ object2.velocity.y = obj1Velocity - obj2Velocity * object2.elasticity;
+ // This is special case code that handles things like horizontal moving platforms you can ride
+ if (object1.active && object1.moves && (obj1Delta < obj2Delta))
+ {
+ object2.x += object1.x - object1.last.x;
+ }
+ }
+
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ /**
+ * Returns the distance between the two given coordinates.
+ * @param x1 The X value of the first coordinate
+ * @param y1 The Y value of the first coordinate
+ * @param x2 The X value of the second coordinate
+ * @param y2 The Y value of the second coordinate
+ * @returns {number} The distance between the two coordinates
+ */
public static distance(x1: number, y1: number, x2: number, y2: number) {
return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}
+ /**
+ * Returns the distanced squared between the two given coordinates.
+ * @param x1 The X value of the first coordinate
+ * @param y1 The Y value of the first coordinate
+ * @param x2 The X value of the second coordinate
+ * @param y2 The Y value of the second coordinate
+ * @returns {number} The distance between the two coordinates
+ */
public static distanceSquared(x1: number, y1: number, x2: number, y2: number) {
return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
}
-
}
}
\ No newline at end of file
diff --git a/Phaser/Game.ts b/Phaser/Game.ts
index ef780a4f..3c60d426 100644
--- a/Phaser/Game.ts
+++ b/Phaser/Game.ts
@@ -35,6 +35,9 @@
*
* This is where the magic happens. The Game object is the heart of your game,
* providing quick access to common functions and handling the boot process.
+*
+* "Hell, there are no rules here - we're trying to accomplish something."
+* Thomas A. Edison
*/
module Phaser {
@@ -313,8 +316,7 @@ module Phaser {
}
else
{
- throw Error("Invalid State object given. Must contain at least a create or update function.");
- return;
+ throw new Error("Invalid State object given. Must contain at least a create or update function.");
}
}
@@ -416,8 +418,8 @@ module Phaser {
return this.tweens.create(obj);
}
- public collide(ObjectOrGroup1: Basic = null, ObjectOrGroup2: Basic = null, NotifyCallback = null): bool {
- return this.collision.overlap(ObjectOrGroup1, ObjectOrGroup2, NotifyCallback, Collision.separate);
+ public collide(objectOrGroup1: Basic = null, objectOrGroup2: Basic = null, notifyCallback = null): bool {
+ return this.collision.overlap(objectOrGroup1, objectOrGroup2, notifyCallback, Collision.separate);
}
}
diff --git a/Phaser/Group.ts b/Phaser/Group.ts
index a436baa8..81459a62 100644
--- a/Phaser/Group.ts
+++ b/Phaser/Group.ts
@@ -450,7 +450,7 @@ module Phaser {
}
}
- public forEach(callback, Recurse: bool = false) {
+ public forEach(callback, recursive: bool = false) {
var basic;
var i: number = 0;
@@ -461,7 +461,7 @@ module Phaser {
if (basic != null)
{
- if (Recurse && (basic.isGroup == true))
+ if (recursive && (basic.isGroup == true))
{
basic.forEach(callback, true);
}
@@ -474,6 +474,30 @@ module Phaser {
}
+ public forEachAlive(callback, recursive: bool = false) {
+
+ var basic;
+ var i: number = 0;
+
+ while (i < this.length)
+ {
+ basic = this.members[i++];
+
+ if (basic != null && basic.alive)
+ {
+ if (recursive && (basic.isGroup == true))
+ {
+ basic.forEachAlive(callback, true);
+ }
+ else
+ {
+ callback.call(this, basic);
+ }
+ }
+ }
+
+ }
+
/**
* Call this function to retrieve the first object with exists == false in the group.
* This is handy for recycling in general, e.g. respawning enemies.
diff --git a/Phaser/Phaser.ts b/Phaser/Phaser.ts
index 8fca2aee..7434f78c 100644
--- a/Phaser/Phaser.ts
+++ b/Phaser/Phaser.ts
@@ -1,7 +1,7 @@
/**
* Phaser
*
-* v0.9.3 - April 24th 2013
+* v0.9.4 - April 24th 2013
*
* A small and feature-packed 2D canvas game framework born from the firey pits of Flixel and Kiwi.
*
@@ -16,6 +16,6 @@
module Phaser {
- export var VERSION: string = 'Phaser version 0.9.3';
+ export var VERSION: string = 'Phaser version 0.9.4';
}
diff --git a/Phaser/Stage.ts b/Phaser/Stage.ts
index 6b85f1ef..5606b144 100644
--- a/Phaser/Stage.ts
+++ b/Phaser/Stage.ts
@@ -43,8 +43,8 @@ module Phaser {
this.scaleMode = StageScaleMode.NO_SCALE;
this.scale = new StageScaleMode(this._game);
- //document.addEventListener('visibilitychange', (event) => this.visibilityChange(event), false);
- //document.addEventListener('webkitvisibilitychange', (event) => this.visibilityChange(event), false);
+ document.addEventListener('visibilitychange', (event) => this.visibilityChange(event), false);
+ document.addEventListener('webkitvisibilitychange', (event) => this.visibilityChange(event), false);
window.onblur = (event) => this.visibilityChange(event);
window.onfocus = (event) => this.visibilityChange(event);
@@ -96,6 +96,8 @@ module Phaser {
//if (document['hidden'] === true || document['webkitHidden'] === true)
private visibilityChange(event) {
+ //console.log(event);
+
if (this.disablePauseScreen)
{
return;
diff --git a/Phaser/gameobjects/GameObject.ts b/Phaser/gameobjects/GameObject.ts
index 5b578181..e942cf72 100644
--- a/Phaser/gameobjects/GameObject.ts
+++ b/Phaser/gameobjects/GameObject.ts
@@ -89,6 +89,8 @@ module Phaser {
// rotationOffset to 90 and it would correspond correctly with Phasers rotation system
public rotationOffset: number = 0;
+ public renderRotation: bool = true;
+
// Physics properties
public immovable: bool;
diff --git a/Phaser/gameobjects/Sprite.ts b/Phaser/gameobjects/Sprite.ts
index ba849c3a..106226b4 100644
--- a/Phaser/gameobjects/Sprite.ts
+++ b/Phaser/gameobjects/Sprite.ts
@@ -229,7 +229,7 @@ module Phaser {
this._game.stage.context.save();
this._game.stage.context.translate(this._dx + (this._dw / 2), this._dy + (this._dh / 2));
- if (this.angle !== 0 || this.rotationOffset !== 0)
+ if (this.renderRotation == true && (this.angle !== 0 || this.rotationOffset !== 0))
{
this._game.stage.context.rotate((this.rotationOffset + this.angle) * (Math.PI / 180));
}
diff --git a/Phaser/gameobjects/Tilemap.ts b/Phaser/gameobjects/Tilemap.ts
index 526d1aea..9fc3ae3f 100644
--- a/Phaser/gameobjects/Tilemap.ts
+++ b/Phaser/gameobjects/Tilemap.ts
@@ -1,6 +1,7 @@
/// 
+
+
+## Installation
+
+ npm install colors
+
+## colors and styles!
+
+- bold
+- italic
+- underline
+- inverse
+- yellow
+- cyan
+- white
+- magenta
+- green
+- red
+- grey
+- blue
+- rainbow
+- zebra
+- random
+
+## Usage
+
+``` js
+var colors = require('./colors');
+
+console.log('hello'.green); // outputs green text
+console.log('i like cake and pies'.underline.red) // outputs red underlined text
+console.log('inverse the color'.inverse); // inverses the color
+console.log('OMG Rainbows!'.rainbow); // rainbow (ignores spaces)
+```
+
+# Creating Custom themes
+
+```js
+
+var require('colors');
+
+colors.setTheme({
+ silly: 'rainbow',
+ input: 'grey',
+ verbose: 'cyan',
+ prompt: 'grey',
+ info: 'green',
+ data: 'grey',
+ help: 'cyan',
+ warn: 'yellow',
+ debug: 'blue',
+ error: 'red'
+});
+
+// outputs red text
+console.log("this is an error".error);
+
+// outputs yellow text
+console.log("this is a warning".warn);
+```
+
+
+### Contributors
+
+Marak (Marak Squires)
+Alexis Sellier (cloudhead)
+mmalecki (Maciej Małecki)
+nicoreed (Nico Reed)
+morganrallen (Morgan Allen)
+JustinCampbell (Justin Campbell)
+ded (Dustin Diaz)
+
+
+#### , Marak Squires , Justin Campbell, Dustin Diaz (@ded)
diff --git a/Phaser/node_modules/grunt/node_modules/colors/example.html b/Phaser/node_modules/grunt/node_modules/colors/example.html
new file mode 100644
index 00000000..ab956494
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/colors/example.html
@@ -0,0 +1,74 @@
+
+
+
+
+ ![](\"http://i.imgur.com/goJdO.png\")
\n\n\n## Installation\n\n npm install colors\n\n## colors and styles!\n\n- bold\n- italic\n- underline\n- inverse\n- yellow\n- cyan\n- white\n- magenta\n- green\n- red\n- grey\n- blue\n- rainbow\n- zebra\n- random\n\n## Usage\n\n``` js\nvar colors = require('./colors');\n\nconsole.log('hello'.green); // outputs green text\nconsole.log('i like cake and pies'.underline.red) // outputs red underlined text\nconsole.log('inverse the color'.inverse); // inverses the color\nconsole.log('OMG Rainbows!'.rainbow); // rainbow (ignores spaces)\n```\n\n# Creating Custom themes\n\n```js\n\nvar require('colors');\n\ncolors.setTheme({\n silly: 'rainbow',\n input: 'grey',\n verbose: 'cyan',\n prompt: 'grey',\n info: 'green',\n data: 'grey',\n help: 'cyan',\n warn: 'yellow',\n debug: 'blue',\n error: 'red'\n});\n\n// outputs red text\nconsole.log(\"this is an error\".error);\n\n// outputs yellow text\nconsole.log(\"this is a warning\".warn);\n```\n\n\n### Contributors \n\nMarak (Marak Squires)\nAlexis Sellier (cloudhead)\nmmalecki (Maciej Małecki)\nnicoreed (Nico Reed)\nmorganrallen (Morgan Allen)\nJustinCampbell (Justin Campbell)\nded (Dustin Diaz)\n\n\n#### , Marak Squires , Justin Campbell, Dustin Diaz (@ded)\n",
+ "readmeFilename": "ReadMe.md",
+ "_id": "colors@0.6.0-1",
+ "dist": {
+ "shasum": "322d52c6f629babb21b1713e6365d1b6ec1937bd"
+ },
+ "_from": "colors@~0.6.0-1",
+ "_resolved": "https://registry.npmjs.org/colors/-/colors-0.6.0-1.tgz"
+}
diff --git a/Phaser/node_modules/grunt/node_modules/dateformat/Readme.md b/Phaser/node_modules/grunt/node_modules/dateformat/Readme.md
new file mode 100644
index 00000000..d469e6d7
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/dateformat/Readme.md
@@ -0,0 +1,67 @@
+# node-dateformat
+
+A node.js package for Steven Levithan's excellent [dateFormat()][dateformat] function.
+
+## Modifications
+
+* Removed the `Date.prototype.format` method. Sorry folks, but extending native prototypes is for suckers.
+* Added a `module.exports = dateFormat;` statement at the bottom
+
+## Usage
+
+As taken from Steven's post, modified to match the Modifications listed above:
+
+ var dateFormat = require('dateformat');
+ var now = new Date();
+
+ // Basic usage
+ dateFormat(now, "dddd, mmmm dS, yyyy, h:MM:ss TT");
+ // Saturday, June 9th, 2007, 5:46:21 PM
+
+ // You can use one of several named masks
+ dateFormat(now, "isoDateTime");
+ // 2007-06-09T17:46:21
+
+ // ...Or add your own
+ dateFormat.masks.hammerTime = 'HH:MM! "Can\'t touch this!"';
+ dateFormat(now, "hammerTime");
+ // 17:46! Can't touch this!
+
+ // When using the standalone dateFormat function,
+ // you can also provide the date as a string
+ dateFormat("Jun 9 2007", "fullDate");
+ // Saturday, June 9, 2007
+
+ // Note that if you don't include the mask argument,
+ // dateFormat.masks.default is used
+ dateFormat(now);
+ // Sat Jun 09 2007 17:46:21
+
+ // And if you don't include the date argument,
+ // the current date and time is used
+ dateFormat();
+ // Sat Jun 09 2007 17:46:22
+
+ // You can also skip the date argument (as long as your mask doesn't
+ // contain any numbers), in which case the current date/time is used
+ dateFormat("longTime");
+ // 5:46:22 PM EST
+
+ // And finally, you can convert local time to UTC time. Simply pass in
+ // true as an additional argument (no argument skipping allowed in this case):
+ dateFormat(now, "longTime", true);
+ // 10:46:21 PM UTC
+
+ // ...Or add the prefix "UTC:" to your mask.
+ dateFormat(now, "UTC:h:MM:ss TT Z");
+ // 10:46:21 PM UTC
+
+ // You can also get the ISO 8601 week of the year:
+ dateFormat(now, "W");
+ // 42
+## License
+
+(c) 2007-2009 Steven Levithan [stevenlevithan.com][stevenlevithan], MIT license.
+
+[dateformat]: http://blog.stevenlevithan.com/archives/date-time-format
+[stevenlevithan]: http://stevenlevithan.com/
diff --git a/Phaser/node_modules/grunt/node_modules/dateformat/package.json b/Phaser/node_modules/grunt/node_modules/dateformat/package.json
new file mode 100644
index 00000000..91a795a0
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/dateformat/package.json
@@ -0,0 +1,24 @@
+{
+ "name": "dateformat",
+ "description": "A node.js package for Steven Levithan's excellent dateFormat() function.",
+ "maintainers": "Felix Geisendörfer +[Development](https://raw.github.com/bestiejs/lodash/v1.0.1/dist/lodash.js) and +[Production](https://raw.github.com/bestiejs/lodash/v1.0.1/dist/lodash.min.js) + +* Lo-Dash compatibility builds (for legacy and modern environments):
+[Development](https://raw.github.com/bestiejs/lodash/v1.0.1/dist/lodash.compat.js) and +[Production](https://raw.github.com/bestiejs/lodash/v1.0.1/dist/lodash.compat.min.js) + +* Underscore compatibility builds:
+[Development](https://raw.github.com/bestiejs/lodash/v1.0.1/dist/lodash.underscore.js) and +[Production](https://raw.github.com/bestiejs/lodash/v1.0.1/dist/lodash.underscore.min.js) + +* CDN copies of ≤ v1.0.1’s builds are available on [cdnjs](http://cdnjs.com/) thanks to [CloudFlare](http://www.cloudflare.com/):
+[Lo-Dash dev](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.0.1/lodash.js), +[Lo-Dash prod](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.0.1/lodash.min.js),
+[Lo-Dash compat-dev](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.0.1/lodash.compat.js), +[Lo-Dash compat-prod](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.0.1/lodash.compat.min.js),
+[Underscore compat-dev](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.0.1/lodash.underscore.js), and +[Underscore compat-prod](http://cdnjs.cloudflare.com/ajax/libs/lodash.js/1.0.1/lodash.underscore.min.js) + +* For optimal file size, [create a custom build](https://github.com/bestiejs/lodash#custom-builds) with only the features you need + +## Dive in + +We’ve got [API docs](http://lodash.com/docs), [benchmarks](http://lodash.com/benchmarks), and [unit tests](http://lodash.com/tests). + +For a list of upcoming features, check out our [roadmap](https://github.com/bestiejs/lodash/wiki/Roadmap). + +## Resources + +For more information check out these articles, screencasts, and other videos over Lo-Dash: + + * Posts + - [Say “Hello†to Lo-Dash](http://kitcambridge.be/blog/say-hello-to-lo-dash/) + + * Videos + - [Introducing Lo-Dash](https://vimeo.com/44154599) + - [Lo-Dash optimizations and custom builds](https://vimeo.com/44154601) + - [Lo-Dash’s origin and why it’s a better utility belt](https://vimeo.com/44154600) + - [Unit testing in Lo-Dash](https://vimeo.com/45865290) + - [Lo-Dash’s approach to native method use](https://vimeo.com/48576012) + - [CascadiaJS: Lo-Dash for a better utility belt](http://www.youtube.com/watch?v=dpPy4f_SeEk) + +## Features + + * AMD loader support ([RequireJS](http://requirejs.org/), [curl.js](https://github.com/cujojs/curl), etc.) + * [_(…)](http://lodash.com/docs#_) supports intuitive chaining + * [_.at](http://lodash.com/docs#at) for cherry-picking collection values + * [_.bindKey](http://lodash.com/docs#bindKey) for binding [*“lazyâ€* defined](http://michaux.ca/articles/lazy-function-definition-pattern) methods + * [_.cloneDeep](http://lodash.com/docs#cloneDeep) for deep cloning arrays and objects + * [_.contains](http://lodash.com/docs#contains) accepts a `fromIndex` argument + * [_.forEach](http://lodash.com/docs#forEach) is chainable and supports exiting iteration early + * [_.forIn](http://lodash.com/docs#forIn) for iterating over an object’s own and inherited properties + * [_.forOwn](http://lodash.com/docs#forOwn) for iterating over an object’s own properties + * [_.isPlainObject](http://lodash.com/docs#isPlainObject) checks if values are created by the `Object` constructor + * [_.merge](http://lodash.com/docs#merge) for a deep [_.extend](http://lodash.com/docs#extend) + * [_.partial](http://lodash.com/docs#partial) and [_.partialRight](http://lodash.com/docs#partialRight) for partial application without `this` binding + * [_.template](http://lodash.com/docs#template) supports [*“importsâ€* options](http://lodash.com/docs#templateSettings_imports), [ES6 template delimiters](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6), and [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) + * [_.where](http://lodash.com/docs#where) supports deep object comparisons + * [_.clone](http://lodash.com/docs#clone), [_.omit](http://lodash.com/docs#omit), [_.pick](http://lodash.com/docs#pick), + [and more…](http://lodash.com/docs "_.assign, _.cloneDeep, _.first, _.initial, _.isEqual, _.last, _.merge, _.rest") accept `callback` and `thisArg` arguments + * [_.contains](http://lodash.com/docs#contains), [_.size](http://lodash.com/docs#size), [_.toArray](http://lodash.com/docs#toArray), + [and more…](http://lodash.com/docs "_.at, _.countBy, _.every, _.filter, _.find, _.forEach, _.groupBy, _.invoke, _.map, _.max, _.min, _.pluck, _.reduce, _.reduceRight, _.reject, _.shuffle, _.some, _.sortBy, _.where") accept strings + * [_.filter](http://lodash.com/docs#filter), [_.find](http://lodash.com/docs#find), [_.map](http://lodash.com/docs#map), + [and more…](http://lodash.com/docs "_.countBy, _.every, _.first, _.groupBy, _.initial, _.last, _.max, _.min, _.reject, _.rest, _.some, _.sortBy, _.sortedIndex, _.uniq") support *“_.pluckâ€* and *“_.whereâ€* `callback` shorthands + +## Support + +Lo-Dash has been tested in at least Chrome 5~24, Firefox 1~18, IE 6-10, Opera 9.25-12, Safari 3-6, Node.js 0.4.8-0.8.20, Narwhal 0.3.2, PhantomJS 1.8.1, RingoJS 0.9, and Rhino 1.7RC5. + +## Custom builds + +Custom builds make it easy to create lightweight versions of Lo-Dash containing only the methods you need. +To top it off, we handle all method dependency and alias mapping for you. + + * Backbone builds, with only methods required by Backbone, may be created using the `backbone` modifier argument. +```bash +lodash backbone +``` + + * CSP builds, supporting default [Content Security Policy](https://dvcs.w3.org/hg/content-security-policy/raw-file/tip/csp-specification.dev.html) restrictions, may be created using the `csp` modifier argument. + The `csp` modifier is an alais of the `mobile` modifier. Lo-Dash may be used in Chrome extensions by using either the `csp`, `mobile`, or `underscore` build and using precompiled templates, or loading Lo-Dash in a [sandbox](http://developer.chrome.com/stable/extensions/sandboxingEval.html). +```bash +lodash csp +``` + + * Legacy builds, tailored for older environments without [ES5 support](http://es5.github.com/), may be created using the `legacy` modifier argument. +```bash +lodash legacy +``` + + * Modern builds, tailored for newer environments with ES5 support, may be created using the `modern` modifier argument. +```bash +lodash modern +``` + + * Mobile builds, without method compilation and most bug fixes for old browsers, may be created using the `mobile` modifier argument. +```bash +lodash mobile +``` + + * Strict builds, with `_.bindAll`, `_.defaults`, and `_.extend` in [strict mode](http://es5.github.com/#C), may be created using the `strict` modifier argument. +```bash +lodash strict +``` + + * Underscore builds, tailored for projects already using Underscore, may be created using the `underscore` modifier argument. +```bash +lodash underscore +``` + +Custom builds may be created using the following commands: + + * Use the `category` argument to pass comma separated categories of methods to include in the build.
+ Valid categories (case-insensitive) are *“arraysâ€*, *“chainingâ€*, *“collectionsâ€*, *“functionsâ€*, *“objectsâ€*, and *“utilitiesâ€*. +```bash +lodash category=collections,functions +lodash category="collections, functions" +``` + + * Use the `exports` argument to pass comma separated names of ways to export the `LoDash` function.
+ Valid exports are *“amdâ€*, *“commonjsâ€*, *“globalâ€*, *“nodeâ€*, and *“noneâ€*. +```bash +lodash exports=amd,commonjs,node +lodash exports="amd, commonjs, node" +``` + + * Use the `iife` argument to specify code to replace the immediately-invoked function expression that wraps Lo-Dash. +```bash +lodash iife="!function(window,undefined){%output%}(this)" +``` + + * Use the `include` argument to pass comma separated method/category names to include in the build. +```bash +lodash include=each,filter,map +lodash include="each, filter, map" +``` + + * Use the `minus` argument to pass comma separated method/category names to remove from those included in the build. +```bash +lodash underscore minus=result,shuffle +lodash underscore minus="result, shuffle" +``` + + * Use the `plus` argument to pass comma separated method/category names to add to those included in the build. +```bash +lodash backbone plus=random,template +lodash backbone plus="random, template" +``` + + * Use the `template` argument to pass the file path pattern used to match template files to precompile. +```bash +lodash template="./*.jst" +``` + + * Use the `settings` argument to pass the template settings used when precompiling templates. +```bash +lodash settings="{interpolate:/\{\{([\s\S]+?)\}\}/g}" +``` + + * Use the `moduleId` argument to specify the AMD module ID of Lo-Dash, which defaults to “lodashâ€, used by precompiled templates. +```bash +lodash moduleId="underscore" +``` + +All arguments, except `legacy` with `csp`, `mobile`, `modern`, or `underscore`, may be combined.
+Unless specified by `-o` or `--output`, all files created are saved to the current working directory. + +The following options are also supported: + + * `-c`, `--stdout` ......... Write output to standard output + * `-d`, `--debug` ........... Write only the non-minified development output + * `-h`, `--help` ............. Display help information + * `-m`, `--minify` ......... Write only the minified production output + * `-o`, `--output` ......... Write output to a given path/filename + * `-p`, `--source-map` .. Generate a source map for the minified output, using an optional source map URL + * `-s`, `--silent` ......... Skip status updates normally logged to the console + * `-V`, `--version` ....... Output current version of Lo-Dash + +The `lodash` command-line utility is available when Lo-Dash is installed as a global package (i.e. `npm install -g lodash`). + +## Installation and usage + +In browsers: + +```html + +``` + +Using [`npm`](http://npmjs.org/): + +```bash +npm install lodash + +npm install -g lodash +npm link lodash +``` + +To avoid potential issues, update `npm` before installing Lo-Dash: + +```bash +npm install npm -g +``` + +In [Node.js](http://nodejs.org/) and [RingoJS v0.8.0+](http://ringojs.org/): + +```js +var _ = require('lodash'); + +// or as a drop-in replacement for Underscore +var _ = require('lodash/lodash.underscore'); +``` + +**Note:** If Lo-Dash is installed globally, run [`npm link lodash`](http://blog.nodejs.org/2011/03/23/npm-1-0-global-vs-local-installation/) in your project’s root directory before requiring it. + +In [RingoJS v0.7.0-](http://ringojs.org/): + +```js +var _ = require('lodash')._; +``` + +In [Rhino](http://www.mozilla.org/rhino/): + +```js +load('lodash.js'); +``` + +In an AMD loader like [RequireJS](http://requirejs.org/): + +```js +require({ + 'paths': { + 'underscore': 'path/to/lodash' + } +}, +['underscore'], function(_) { + console.log(_.VERSION); +}); +``` + +## Release Notes + +### v1.0.1 + + * Add support for specifying source map URLs in `-p`/`--source-map` build options + * Ensured the second argument passed to `_.assign` is not treated as a `callback` + * Ensured `-p`/`--source-map` build options correctly set the `sourceMappingURL` + * Made `-p`/`--source-map` build options set source map *“sourcesâ€* keys based on the builds performed + * Made `_.defer` use `setImmediate`, in Node.js, when available + * Made `_.where` search arrays for values regardless of their index position + * Removed dead code from `_.template` + +The full changelog is available [here](https://github.com/bestiejs/lodash/wiki/Changelog). + +## BestieJS + +Lo-Dash is part of the BestieJS *“Best in Classâ€* module collection. This means we promote solid browser/environment support, ES5 precedents, unit testing, and plenty of documentation. + +## Author + +* [John-David Dalton](http://allyoucanleet.com/) + [](https://twitter.com/jdalton "Follow @jdalton on Twitter") + +## Contributors + +* [Kit Cambridge](http://kitcambridge.github.com/) + [](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") +* [Mathias Bynens](http://mathiasbynens.be/) + [](https://twitter.com/mathias "Follow @mathias on Twitter") diff --git a/Phaser/node_modules/grunt/node_modules/findup-sync/node_modules/lodash/doc/README.md b/Phaser/node_modules/grunt/node_modules/findup-sync/node_modules/lodash/doc/README.md new file mode 100644 index 00000000..8e22b33a --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/findup-sync/node_modules/lodash/doc/README.md @@ -0,0 +1,3590 @@ +# Lo-Dash v1.0.1 + + + + + + +## `Arrays` +* [`_.compact`](#_compactarray) +* [`_.difference`](#_differencearray--array1-array2-) +* [`_.drop`](#_restarray--callbackn1-thisarg) +* [`_.first`](#_firstarray--callbackn-thisarg) +* [`_.flatten`](#_flattenarray-shallow) +* [`_.head`](#_firstarray--callbackn-thisarg) +* [`_.indexOf`](#_indexofarray-value--fromindex0) +* [`_.initial`](#_initialarray--callbackn1-thisarg) +* [`_.intersection`](#_intersectionarray1-array2-) +* [`_.last`](#_lastarray--callbackn-thisarg) +* [`_.lastIndexOf`](#_lastindexofarray-value--fromindexarraylength-1) +* [`_.object`](#_objectkeys--values) +* [`_.range`](#_rangestart0-end--step1) +* [`_.rest`](#_restarray--callbackn1-thisarg) +* [`_.sortedIndex`](#_sortedindexarray-value--callbackidentity-thisarg) +* [`_.tail`](#_restarray--callbackn1-thisarg) +* [`_.take`](#_firstarray--callbackn-thisarg) +* [`_.union`](#_unionarray1-array2-) +* [`_.uniq`](#_uniqarray--issortedfalse-callbackidentity-thisarg) +* [`_.unique`](#_uniqarray--issortedfalse-callbackidentity-thisarg) +* [`_.without`](#_withoutarray--value1-value2-) +* [`_.zip`](#_ziparray1-array2-) + + + + + + +## `Chaining` +* [`_`](#_value) +* [`_.tap`](#_tapvalue-interceptor) +* [`_.prototype.toString`](#_prototypetostring) +* [`_.prototype.value`](#_prototypevalueof) +* [`_.prototype.valueOf`](#_prototypevalueof) + + + + + + +## `Collections` +* [`_.all`](#_everycollection--callbackidentity-thisarg) +* [`_.any`](#_somecollection--callbackidentity-thisarg) +* [`_.at`](#_atcollection--index1-index2-) +* [`_.collect`](#_mapcollection--callbackidentity-thisarg) +* [`_.contains`](#_containscollection-target--fromindex0) +* [`_.countBy`](#_countbycollection--callbackidentity-thisarg) +* [`_.detect`](#_findcollection--callbackidentity-thisarg) +* [`_.each`](#_foreachcollection--callbackidentity-thisarg) +* [`_.every`](#_everycollection--callbackidentity-thisarg) +* [`_.filter`](#_filtercollection--callbackidentity-thisarg) +* [`_.find`](#_findcollection--callbackidentity-thisarg) +* [`_.foldl`](#_reducecollection--callbackidentity-accumulator-thisarg) +* [`_.foldr`](#_reducerightcollection--callbackidentity-accumulator-thisarg) +* [`_.forEach`](#_foreachcollection--callbackidentity-thisarg) +* [`_.groupBy`](#_groupbycollection--callbackidentity-thisarg) +* [`_.include`](#_containscollection-target--fromindex0) +* [`_.inject`](#_reducecollection--callbackidentity-accumulator-thisarg) +* [`_.invoke`](#_invokecollection-methodname--arg1-arg2-) +* [`_.map`](#_mapcollection--callbackidentity-thisarg) +* [`_.max`](#_maxcollection--callbackidentity-thisarg) +* [`_.min`](#_mincollection--callbackidentity-thisarg) +* [`_.pluck`](#_pluckcollection-property) +* [`_.reduce`](#_reducecollection--callbackidentity-accumulator-thisarg) +* [`_.reduceRight`](#_reducerightcollection--callbackidentity-accumulator-thisarg) +* [`_.reject`](#_rejectcollection--callbackidentity-thisarg) +* [`_.select`](#_filtercollection--callbackidentity-thisarg) +* [`_.shuffle`](#_shufflecollection) +* [`_.size`](#_sizecollection) +* [`_.some`](#_somecollection--callbackidentity-thisarg) +* [`_.sortBy`](#_sortbycollection--callbackidentity-thisarg) +* [`_.toArray`](#_toarraycollection) +* [`_.where`](#_wherecollection-properties) + + + + + + +## `Functions` +* [`_.after`](#_aftern-func) +* [`_.bind`](#_bindfunc--thisarg-arg1-arg2-) +* [`_.bindAll`](#_bindallobject--methodname1-methodname2-) +* [`_.bindKey`](#_bindkeyobject-key--arg1-arg2-) +* [`_.compose`](#_composefunc1-func2-) +* [`_.debounce`](#_debouncefunc-wait-immediate) +* [`_.defer`](#_deferfunc--arg1-arg2-) +* [`_.delay`](#_delayfunc-wait--arg1-arg2-) +* [`_.memoize`](#_memoizefunc--resolver) +* [`_.once`](#_oncefunc) +* [`_.partial`](#_partialfunc--arg1-arg2-) +* [`_.partialRight`](#_partialrightfunc--arg1-arg2-) +* [`_.throttle`](#_throttlefunc-wait) +* [`_.wrap`](#_wrapvalue-wrapper) + + + + + + +## `Objects` +* [`_.assign`](#_assignobject--source1-source2--callback-thisarg) +* [`_.clone`](#_clonevalue--deepfalse-callback-thisarg) +* [`_.cloneDeep`](#_clonedeepvalue--callback-thisarg) +* [`_.defaults`](#_defaultsobject--source1-source2-) +* [`_.extend`](#_assignobject--source1-source2--callback-thisarg) +* [`_.forIn`](#_forinobject--callbackidentity-thisarg) +* [`_.forOwn`](#_forownobject--callbackidentity-thisarg) +* [`_.functions`](#_functionsobject) +* [`_.has`](#_hasobject-property) +* [`_.invert`](#_invertobject) +* [`_.isArguments`](#_isargumentsvalue) +* [`_.isArray`](#_isarrayvalue) +* [`_.isBoolean`](#_isbooleanvalue) +* [`_.isDate`](#_isdatevalue) +* [`_.isElement`](#_iselementvalue) +* [`_.isEmpty`](#_isemptyvalue) +* [`_.isEqual`](#_isequala-b--callback-thisarg) +* [`_.isFinite`](#_isfinitevalue) +* [`_.isFunction`](#_isfunctionvalue) +* [`_.isNaN`](#_isnanvalue) +* [`_.isNull`](#_isnullvalue) +* [`_.isNumber`](#_isnumbervalue) +* [`_.isObject`](#_isobjectvalue) +* [`_.isPlainObject`](#_isplainobjectvalue) +* [`_.isRegExp`](#_isregexpvalue) +* [`_.isString`](#_isstringvalue) +* [`_.isUndefined`](#_isundefinedvalue) +* [`_.keys`](#_keysobject) +* [`_.merge`](#_mergeobject--source1-source2--callback-thisarg) +* [`_.methods`](#_functionsobject) +* [`_.omit`](#_omitobject-callback-prop1-prop2--thisarg) +* [`_.pairs`](#_pairsobject) +* [`_.pick`](#_pickobject-callback-prop1-prop2--thisarg) +* [`_.values`](#_valuesobject) + + + + + + +## `Utilities` +* [`_.escape`](#_escapestring) +* [`_.identity`](#_identityvalue) +* [`_.mixin`](#_mixinobject) +* [`_.noConflict`](#_noconflict) +* [`_.random`](#_randommin0-max1) +* [`_.result`](#_resultobject-property) +* [`_.template`](#_templatetext-data-options) +* [`_.times`](#_timesn-callback--thisarg) +* [`_.unescape`](#_unescapestring) +* [`_.uniqueId`](#_uniqueidprefix) + + + + + + +## `Methods` +* [`_.templateSettings.imports._`](#_templatesettingsimports_) + + + + + + +## `Properties` +* [`_.VERSION`](#_version) +* [`_.templateSettings`](#_templatesettings) +* [`_.templateSettings.escape`](#_templatesettingsescape) +* [`_.templateSettings.evaluate`](#_templatesettingsevaluate) +* [`_.templateSettings.interpolate`](#_templatesettingsinterpolate) +* [`_.templateSettings.variable`](#_templatesettingsvariable) +* [`_.templateSettings.imports`](#_templatesettingsimports) + + + + + + + + + + + + +## `“Arrays†Methods` + + + +### `_.compact(array)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3166 "View in source") [Ⓣ][1] + +Creates an array with all falsey values of `array` removed. The values `false`, `null`, `0`, `""`, `undefined` and `NaN` are all falsey. + +#### Arguments +1. `array` *(Array)*: The array to compact. + +#### Returns +*(Array)*: Returns a new filtered array. + +#### Example +```js +_.compact([0, 1, false, 2, '', 3]); +// => [1, 2, 3] +``` + +* * * + + + + + + +### `_.difference(array [, array1, array2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3196 "View in source") [Ⓣ][1] + +Creates an array of `array` elements not present in the other arrays using strict equality for comparisons, i.e. `===`. + +#### Arguments +1. `array` *(Array)*: The array to process. +2. `[array1, array2, ...]` *(Array)*: Arrays to check. + +#### Returns +*(Array)*: Returns a new array of `array` elements not present in the other arrays. + +#### Example +```js +_.difference([1, 2, 3, 4, 5], [5, 2, 10]); +// => [1, 3, 4] +``` + +* * * + + + + + + +### `_.first(array [, callback|n, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3268 "View in source") [Ⓣ][1] + +Gets the first element of the `array`. If a number `n` is passed, the first `n` elements of the `array` are returned. If a `callback` function is passed, the first elements the `callback` returns truthy for are returned. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index, array)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Aliases +*head, take* + +#### Arguments +1. `array` *(Array)*: The array to query. +2. `[callback|n]` *(Function|Object|Number|String)*: The function called per element or the number of elements to return. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the first element(s) of `array`. + +#### Example +```js +_.first([1, 2, 3]); +// => 1 + +_.first([1, 2, 3], 2); +// => [1, 2] + +_.first([1, 2, 3], function(num) { + return num < 3; +}); +// => [1, 2] + +var food = [ + { 'name': 'banana', 'organic': true }, + { 'name': 'beet', 'organic': false }, +]; + +// using "_.pluck" callback shorthand +_.first(food, 'organic'); +// => [{ 'name': 'banana', 'organic': true }] + +var food = [ + { 'name': 'apple', 'type': 'fruit' }, + { 'name': 'banana', 'type': 'fruit' }, + { 'name': 'beet', 'type': 'vegetable' } +]; + +// using "_.where" callback shorthand +_.first(food, { 'type': 'fruit' }); +// => [{ 'name': 'apple', 'type': 'fruit' }, { 'name': 'banana', 'type': 'fruit' }] +``` + +* * * + + + + + + +### `_.flatten(array, shallow)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3307 "View in source") [Ⓣ][1] + +Flattens a nested array *(the nesting can be to any depth)*. If `shallow` is truthy, `array` will only be flattened a single level. + +#### Arguments +1. `array` *(Array)*: The array to compact. +2. `shallow` *(Boolean)*: A flag to indicate only flattening a single level. + +#### Returns +*(Array)*: Returns a new flattened array. + +#### Example +```js +_.flatten([1, [2], [3, [[4]]]]); +// => [1, 2, 3, 4]; + +_.flatten([1, [2], [3, [[4]]]], true); +// => [1, 2, 3, [[4]]]; +``` + +* * * + + + + + + +### `_.indexOf(array, value [, fromIndex=0])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3349 "View in source") [Ⓣ][1] + +Gets the index at which the first occurrence of `value` is found using strict equality for comparisons, i.e. `===`. If the `array` is already sorted, passing `true` for `fromIndex` will run a faster binary search. + +#### Arguments +1. `array` *(Array)*: The array to search. +2. `value` *(Mixed)*: The value to search for. +3. `[fromIndex=0]` *(Boolean|Number)*: The index to search from or `true` to perform a binary search on a sorted `array`. + +#### Returns +*(Number)*: Returns the index of the matched value or `-1`. + +#### Example +```js +_.indexOf([1, 2, 3, 1, 2, 3], 2); +// => 1 + +_.indexOf([1, 2, 3, 1, 2, 3], 2, 3); +// => 4 + +_.indexOf([1, 1, 2, 2, 3, 3], 2, true); +// => 2 +``` + +* * * + + + + + + +### `_.initial(array [, callback|n=1, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3423 "View in source") [Ⓣ][1] + +Gets all but the last element of `array`. If a number `n` is passed, the last `n` elements are excluded from the result. If a `callback` function is passed, the last elements the `callback` returns truthy for are excluded from the result. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index, array)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Arguments +1. `array` *(Array)*: The array to query. +2. `[callback|n=1]` *(Function|Object|Number|String)*: The function called per element or the number of elements to exclude. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a slice of `array`. + +#### Example +```js +_.initial([1, 2, 3]); +// => [1, 2] + +_.initial([1, 2, 3], 2); +// => [1] + +_.initial([1, 2, 3], function(num) { + return num > 1; +}); +// => [1] + +var food = [ + { 'name': 'beet', 'organic': false }, + { 'name': 'carrot', 'organic': true } +]; + +// using "_.pluck" callback shorthand +_.initial(food, 'organic'); +// => [{ 'name': 'beet', 'organic': false }] + +var food = [ + { 'name': 'banana', 'type': 'fruit' }, + { 'name': 'beet', 'type': 'vegetable' }, + { 'name': 'carrot', 'type': 'vegetable' } +]; + +// using "_.where" callback shorthand +_.initial(food, { 'type': 'vegetable' }); +// => [{ 'name': 'banana', 'type': 'fruit' }] +``` + +* * * + + + + + + +### `_.intersection([array1, array2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3457 "View in source") [Ⓣ][1] + +Computes the intersection of all the passed-in arrays using strict equality for comparisons, i.e. `===`. + +#### Arguments +1. `[array1, array2, ...]` *(Array)*: Arrays to process. + +#### Returns +*(Array)*: Returns a new array of unique elements that are present in **all** of the arrays. + +#### Example +```js +_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]); +// => [1, 2] +``` + +* * * + + + + + + +### `_.last(array [, callback|n, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3548 "View in source") [Ⓣ][1] + +Gets the last element of the `array`. If a number `n` is passed, the last `n` elements of the `array` are returned. If a `callback` function is passed, the last elements the `callback` returns truthy for are returned. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index, array)*. + + If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Arguments +1. `array` *(Array)*: The array to query. +2. `[callback|n]` *(Function|Object|Number|String)*: The function called per element or the number of elements to return. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the last element(s) of `array`. + +#### Example +```js +_.last([1, 2, 3]); +// => 3 + +_.last([1, 2, 3], 2); +// => [2, 3] + +_.last([1, 2, 3], function(num) { + return num > 1; +}); +// => [2, 3] + +var food = [ + { 'name': 'beet', 'organic': false }, + { 'name': 'carrot', 'organic': true } +]; + +// using "_.pluck" callback shorthand +_.last(food, 'organic'); +// => [{ 'name': 'carrot', 'organic': true }] + +var food = [ + { 'name': 'banana', 'type': 'fruit' }, + { 'name': 'beet', 'type': 'vegetable' }, + { 'name': 'carrot', 'type': 'vegetable' } +]; + +// using "_.where" callback shorthand +_.last(food, { 'type': 'vegetable' }); +// => [{ 'name': 'beet', 'type': 'vegetable' }, { 'name': 'carrot', 'type': 'vegetable' }] +``` + +* * * + + + + + + +### `_.lastIndexOf(array, value [, fromIndex=array.length-1])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3589 "View in source") [Ⓣ][1] + +Gets the index at which the last occurrence of `value` is found using strict equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the offset from the end of the collection. + +#### Arguments +1. `array` *(Array)*: The array to search. +2. `value` *(Mixed)*: The value to search for. +3. `[fromIndex=array.length-1]` *(Number)*: The index to search from. + +#### Returns +*(Number)*: Returns the index of the matched value or `-1`. + +#### Example +```js +_.lastIndexOf([1, 2, 3, 1, 2, 3], 2); +// => 4 + +_.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3); +// => 1 +``` + +* * * + + + + + + +### `_.object(keys [, values=[]])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3619 "View in source") [Ⓣ][1] + +Creates an object composed from arrays of `keys` and `values`. Pass either a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`, or two arrays, one of `keys` and one of corresponding `values`. + +#### Arguments +1. `keys` *(Array)*: The array of keys. +2. `[values=[]]` *(Array)*: The array of values. + +#### Returns +*(Object)*: Returns an object composed of the given keys and corresponding values. + +#### Example +```js +_.object(['moe', 'larry'], [30, 40]); +// => { 'moe': 30, 'larry': 40 } +``` + +* * * + + + + + + +### `_.range([start=0], end [, step=1])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3663 "View in source") [Ⓣ][1] + +Creates an array of numbers *(positive and/or negative)* progressing from `start` up to but not including `end`. + +#### Arguments +1. `[start=0]` *(Number)*: The start of the range. +2. `end` *(Number)*: The end of the range. +3. `[step=1]` *(Number)*: The value to increment or descrement by. + +#### Returns +*(Array)*: Returns a new range array. + +#### Example +```js +_.range(10); +// => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + +_.range(1, 11); +// => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + +_.range(0, 30, 5); +// => [0, 5, 10, 15, 20, 25] + +_.range(0, -10, -1); +// => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] + +_.range(0); +// => [] +``` + +* * * + + + + + + +### `_.rest(array [, callback|n=1, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3741 "View in source") [Ⓣ][1] + +The opposite of `_.initial`, this method gets all but the first value of `array`. If a number `n` is passed, the first `n` values are excluded from the result. If a `callback` function is passed, the first elements the `callback` returns truthy for are excluded from the result. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index, array)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Aliases +*drop, tail* + +#### Arguments +1. `array` *(Array)*: The array to query. +2. `[callback|n=1]` *(Function|Object|Number|String)*: The function called per element or the number of elements to exclude. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a slice of `array`. + +#### Example +```js +_.rest([1, 2, 3]); +// => [2, 3] + +_.rest([1, 2, 3], 2); +// => [3] + +_.rest([1, 2, 3], function(num) { + return num < 3; +}); +// => [3] + +var food = [ + { 'name': 'banana', 'organic': true }, + { 'name': 'beet', 'organic': false }, +]; + +// using "_.pluck" callback shorthand +_.rest(food, 'organic'); +// => [{ 'name': 'beet', 'organic': false }] + +var food = [ + { 'name': 'apple', 'type': 'fruit' }, + { 'name': 'banana', 'type': 'fruit' }, + { 'name': 'beet', 'type': 'vegetable' } +]; + +// using "_.where" callback shorthand +_.rest(food, { 'type': 'fruit' }); +// => [{ 'name': 'beet', 'type': 'vegetable' }] +``` + +* * * + + + + + + +### `_.sortedIndex(array, value [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3805 "View in source") [Ⓣ][1] + +Uses a binary search to determine the smallest index at which the `value` should be inserted into `array` in order to maintain the sort order of the sorted `array`. If `callback` is passed, it will be executed for `value` and each element in `array` to compute their sort ranking. The `callback` is bound to `thisArg` and invoked with one argument; *(value)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Arguments +1. `array` *(Array)*: The array to iterate over. +2. `value` *(Mixed)*: The value to evaluate. +3. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Number)*: Returns the index at which the value should be inserted into `array`. + +#### Example +```js +_.sortedIndex([20, 30, 50], 40); +// => 2 + +// using "_.pluck" callback shorthand +_.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x'); +// => 2 + +var dict = { + 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 } +}; + +_.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { + return dict.wordToNumber[word]; +}); +// => 2 + +_.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { + return this.wordToNumber[word]; +}, dict); +// => 2 +``` + +* * * + + + + + + +### `_.union([array1, array2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3837 "View in source") [Ⓣ][1] + +Computes the union of the passed-in arrays using strict equality for comparisons, i.e. `===`. + +#### Arguments +1. `[array1, array2, ...]` *(Array)*: Arrays to process. + +#### Returns +*(Array)*: Returns a new array of unique values, in order, that are present in one or more of the arrays. + +#### Example +```js +_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]); +// => [1, 2, 3, 101, 10] +``` + +* * * + + + + + + +### `_.uniq(array [, isSorted=false, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3884 "View in source") [Ⓣ][1] + +Creates a duplicate-value-free version of the `array` using strict equality for comparisons, i.e. `===`. If the `array` is already sorted, passing `true` for `isSorted` will run a faster algorithm. If `callback` is passed, each element of `array` is passed through a callback` before uniqueness is computed. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index, array)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Aliases +*unique* + +#### Arguments +1. `array` *(Array)*: The array to process. +2. `[isSorted=false]` *(Boolean)*: A flag to indicate that the `array` is already sorted. +3. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a duplicate-value-free array. + +#### Example +```js +_.uniq([1, 2, 1, 3, 1]); +// => [1, 2, 3] + +_.uniq([1, 1, 2, 2, 3], true); +// => [1, 2, 3] + +_.uniq([1, 2, 1.5, 3, 2.5], function(num) { return Math.floor(num); }); +// => [1, 2, 3] + +_.uniq([1, 2, 1.5, 3, 2.5], function(num) { return this.floor(num); }, Math); +// => [1, 2, 3] + +// using "_.pluck" callback shorthand +_.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); +// => [{ 'x': 1 }, { 'x': 2 }] +``` + +* * * + + + + + + +### `_.without(array [, value1, value2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3943 "View in source") [Ⓣ][1] + +Creates an array with all occurrences of the passed values removed using strict equality for comparisons, i.e. `===`. + +#### Arguments +1. `array` *(Array)*: The array to filter. +2. `[value1, value2, ...]` *(Mixed)*: Values to remove. + +#### Returns +*(Array)*: Returns a new filtered array. + +#### Example +```js +_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); +// => [2, 3, 4] +``` + +* * * + + + + + + +### `_.zip([array1, array2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3974 "View in source") [Ⓣ][1] + +Groups the elements of each array at their corresponding indexes. Useful for separate data sources that are coordinated through matching array indexes. For a matrix of nested arrays, `_.zip.apply(...)` can transpose the matrix in a similar fashion. + +#### Arguments +1. `[array1, array2, ...]` *(Array)*: Arrays to process. + +#### Returns +*(Array)*: Returns a new array of grouped elements. + +#### Example +```js +_.zip(['moe', 'larry'], [30, 40], [true, false]); +// => [['moe', 30, true], ['larry', 40, false]] +``` + +* * * + + + + + + + + + +## `“Chaining†Methods` + + + +### `_(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L272 "View in source") [Ⓣ][1] + +Creates a `lodash` object, that wraps the given `value`, to enable method chaining. + +In addition to Lo-Dash methods, wrappers also have the following `Array` methods:
+`concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`, and `unshift` + +The chainable wrapper functions are:
+`after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`, `compose`, `concat`, `countBy`, `debounce`, `defaults`, `defer`, `delay`, `difference`, `filter`, `flatten`, `forEach`, `forIn`, `forOwn`, `functions`, `groupBy`, `initial`, `intersection`, `invert`, `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`, `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `push`, `range`, `reject`, `rest`, `reverse`, `shuffle`, `slice`, `sort`, `sortBy`, `splice`, `tap`, `throttle`, `times`, `toArray`, `union`, `uniq`, `unshift`, `values`, `where`, `without`, `wrap`, and `zip` + +The non-chainable wrapper functions are:
+`clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `has`, `identity`, `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`, `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`, `isNull`, `isNumber`, `isObject`, `isPlainObject`, `isRegExp`, `isString`, `isUndefined`, `join`, `lastIndexOf`, `mixin`, `noConflict`, `pop`, `random`, `reduce`, `reduceRight`, `result`, `shift`, `size`, `some`, `sortedIndex`, `template`, `unescape`, and `uniqueId` + +The wrapper functions `first` and `last` return wrapped values when `n` is passed, otherwise they return unwrapped values. + +#### Arguments +1. `value` *(Mixed)*: The value to wrap in a `lodash` instance. + +#### Returns +*(Object)*: Returns a `lodash` instance. + +* * * + + + + + + +### `_.tap(value, interceptor)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4874 "View in source") [Ⓣ][1] + +Invokes `interceptor` with the `value` as the first argument, and then returns `value`. The purpose of this method is to "tap into" a method chain, in order to perform operations on intermediate results within the chain. + +#### Arguments +1. `value` *(Mixed)*: The value to pass to `interceptor`. +2. `interceptor` *(Function)*: The function to invoke. + +#### Returns +*(Mixed)*: Returns `value`. + +#### Example +```js +_([1, 2, 3, 4]) + .filter(function(num) { return num % 2 == 0; }) + .tap(alert) + .map(function(num) { return num * num; }) + .value(); +// => // [2, 4] (alerted) +// => [4, 16] +``` + +* * * + + + + + + +### `_.prototype.toString()` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4891 "View in source") [Ⓣ][1] + +Produces the `toString` result of the wrapped value. + +#### Returns +*(String)*: Returns the string result. + +#### Example +```js +_([1, 2, 3]).toString(); +// => '1,2,3' +``` + +* * * + + + + + + +### `_.prototype.valueOf()` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4908 "View in source") [Ⓣ][1] + +Extracts the wrapped value. + +#### Aliases +*value* + +#### Returns +*(Mixed)*: Returns the wrapped value. + +#### Example +```js +_([1, 2, 3]).valueOf(); +// => [1, 2, 3] +``` + +* * * + + + + + + + + + +## `“Collections†Methods` + + + +### `_.at(collection [, index1, index2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2167 "View in source") [Ⓣ][1] + +Creates an array of elements from the specified indexes, or keys, of the `collection`. Indexes may be specified as individual arguments or as arrays of indexes. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[index1, index2, ...]` *(Array|Number|String)*: The indexes of `collection` to retrieve, either as individual arguments or arrays. + +#### Returns +*(Array)*: Returns a new array of elements corresponding to the provided indexes. + +#### Example +```js +_.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]); +// => ['a', 'c', 'e'] + +_.at(['moe', 'larry', 'curly'], 0, 2); +// => ['moe', 'curly'] +``` + +* * * + + + + + + +### `_.contains(collection, target [, fromIndex=0])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2209 "View in source") [Ⓣ][1] + +Checks if a given `target` element is present in a `collection` using strict equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the offset from the end of the collection. + +#### Aliases +*include* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `target` *(Mixed)*: The value to check for. +3. `[fromIndex=0]` *(Number)*: The index to search from. + +#### Returns +*(Boolean)*: Returns `true` if the `target` element is found, else `false`. + +#### Example +```js +_.contains([1, 2, 3], 1); +// => true + +_.contains([1, 2, 3], 1, 2); +// => false + +_.contains({ 'name': 'moe', 'age': 40 }, 'moe'); +// => true + +_.contains('curly', 'ur'); +// => true +``` + +* * * + + + + + + +### `_.countBy(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2263 "View in source") [Ⓣ][1] + +Creates an object composed of keys returned from running each element of the `collection` through the given `callback`. The corresponding value of each key is the number of times the key was returned by the `callback`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns the composed aggregate object. + +#### Example +```js +_.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); }); +// => { '4': 1, '6': 2 } + +_.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math); +// => { '4': 1, '6': 2 } + +_.countBy(['one', 'two', 'three'], 'length'); +// => { '3': 2, '5': 1 } +``` + +* * * + + + + + + +### `_.every(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2315 "View in source") [Ⓣ][1] + +Checks if the `callback` returns a truthy value for **all** elements of a `collection`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Aliases +*all* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Boolean)*: Returns `true` if all elements pass the callback check, else `false`. + +#### Example +```js +_.every([true, 1, null, 'yes'], Boolean); +// => false + +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 } +]; + +// using "_.pluck" callback shorthand +_.every(stooges, 'age'); +// => true + +// using "_.where" callback shorthand +_.every(stooges, { 'age': 50 }); +// => false +``` + +* * * + + + + + + +### `_.filter(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2376 "View in source") [Ⓣ][1] + +Examines each element in a `collection`, returning an array of all elements the `callback` returns truthy for. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Aliases +*select* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a new array of elements that passed the callback check. + +#### Example +```js +var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); +// => [2, 4, 6] + +var food = [ + { 'name': 'apple', 'organic': false, 'type': 'fruit' }, + { 'name': 'carrot', 'organic': true, 'type': 'vegetable' } +]; + +// using "_.pluck" callback shorthand +_.filter(food, 'organic'); +// => [{ 'name': 'carrot', 'organic': true, 'type': 'vegetable' }] + +// using "_.where" callback shorthand +_.filter(food, { 'type': 'fruit' }); +// => [{ 'name': 'apple', 'organic': false, 'type': 'fruit' }] +``` + +* * * + + + + + + +### `_.find(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2443 "View in source") [Ⓣ][1] + +Examines each element in a `collection`, returning the first that the `callback` returns truthy for. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Aliases +*detect* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the element that passed the callback check, else `undefined`. + +#### Example +```js +var even = _.find([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); +// => 2 + +var food = [ + { 'name': 'apple', 'organic': false, 'type': 'fruit' }, + { 'name': 'banana', 'organic': true, 'type': 'fruit' }, + { 'name': 'beet', 'organic': false, 'type': 'vegetable' }, + { 'name': 'carrot', 'organic': true, 'type': 'vegetable' } +]; + +// using "_.where" callback shorthand +var veggie = _.find(food, { 'type': 'vegetable' }); +// => { 'name': 'beet', 'organic': false, 'type': 'vegetable' } + +// using "_.pluck" callback shorthand +var healthy = _.find(food, 'organic'); +// => { 'name': 'banana', 'organic': true, 'type': 'fruit' } +``` + +* * * + + + + + + +### `_.forEach(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2478 "View in source") [Ⓣ][1] + +Iterates over a `collection`, executing the `callback` for each element in the `collection`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. Callbacks may exit iteration early by explicitly returning `false`. + +#### Aliases +*each* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array, Object, String)*: Returns `collection`. + +#### Example +```js +_([1, 2, 3]).forEach(alert).join(','); +// => alerts each number and returns '1,2,3' + +_.forEach({ 'one': 1, 'two': 2, 'three': 3 }, alert); +// => alerts each number value (order is not guaranteed) +``` + +* * * + + + + + + +### `_.groupBy(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2528 "View in source") [Ⓣ][1] + +Creates an object composed of keys returned from running each element of the `collection` through the `callback`. The corresponding value of each key is an array of elements passed to `callback` that returned the key. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false` + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns the composed aggregate object. + +#### Example +```js +_.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); }); +// => { '4': [4.2], '6': [6.1, 6.4] } + +_.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math); +// => { '4': [4.2], '6': [6.1, 6.4] } + +// using "_.pluck" callback shorthand +_.groupBy(['one', 'two', 'three'], 'length'); +// => { '3': ['one', 'two'], '5': ['three'] } +``` + +* * * + + + + + + +### `_.invoke(collection, methodName [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2561 "View in source") [Ⓣ][1] + +Invokes the method named by `methodName` on each element in the `collection`, returning an array of the results of each invoked method. Additional arguments will be passed to each invoked method. If `methodName` is a function, it will be invoked for, and `this` bound to, each element in the `collection`. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `methodName` *(Function|String)*: The name of the method to invoke or the function invoked per iteration. +3. `[arg1, arg2, ...]` *(Mixed)*: Arguments to invoke the method with. + +#### Returns +*(Array)*: Returns a new array of the results of each invoked method. + +#### Example +```js +_.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); +// => [[1, 5, 7], [1, 2, 3]] + +_.invoke([123, 456], String.prototype.split, ''); +// => [['1', '2', '3'], ['4', '5', '6']] +``` + +* * * + + + + + + +### `_.map(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2613 "View in source") [Ⓣ][1] + +Creates an array of values by running each element in the `collection` through the `callback`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Aliases +*collect* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a new array of the results of each `callback` execution. + +#### Example +```js +_.map([1, 2, 3], function(num) { return num * 3; }); +// => [3, 6, 9] + +_.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; }); +// => [3, 6, 9] (order is not guaranteed) + +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 } +]; + +// using "_.pluck" callback shorthand +_.map(stooges, 'name'); +// => ['moe', 'larry'] +``` + +* * * + + + + + + +### `_.max(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2670 "View in source") [Ⓣ][1] + +Retrieves the maximum value of an `array`. If `callback` is passed, it will be executed for each value in the `array` to generate the criterion by which the value is ranked. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index, collection)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the maximum value. + +#### Example +```js +_.max([4, 2, 8, 6]); +// => 8 + +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 } +]; + +_.max(stooges, function(stooge) { return stooge.age; }); +// => { 'name': 'larry', 'age': 50 }; + +// using "_.pluck" callback shorthand +_.max(stooges, 'age'); +// => { 'name': 'larry', 'age': 50 }; +``` + +* * * + + + + + + +### `_.min(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2739 "View in source") [Ⓣ][1] + +Retrieves the minimum value of an `array`. If `callback` is passed, it will be executed for each value in the `array` to generate the criterion by which the value is ranked. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index, collection)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the minimum value. + +#### Example +```js +_.min([4, 2, 8, 6]); +// => 2 + +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 } +]; + +_.min(stooges, function(stooge) { return stooge.age; }); +// => { 'name': 'moe', 'age': 40 }; + +// using "_.pluck" callback shorthand +_.min(stooges, 'age'); +// => { 'name': 'moe', 'age': 40 }; +``` + +* * * + + + + + + +### `_.pluck(collection, property)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2789 "View in source") [Ⓣ][1] + +Retrieves the value of a specified property from all elements in the `collection`. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `property` *(String)*: The property to pluck. + +#### Returns +*(Array)*: Returns a new array of property values. + +#### Example +```js +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 } +]; + +_.pluck(stooges, 'name'); +// => ['moe', 'larry'] +``` + +* * * + + + + + + +### `_.reduce(collection [, callback=identity, accumulator, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2821 "View in source") [Ⓣ][1] + +Reduces a `collection` to a value that is the accumulated result of running each element in the `collection` through the `callback`, where each successive `callback` execution consumes the return value of the previous execution. If `accumulator` is not passed, the first element of the `collection` will be used as the initial `accumulator` value. The `callback` is bound to `thisArg` and invoked with four arguments; *(accumulator, value, index|key, collection)*. + +#### Aliases +*foldl, inject* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function)*: The function called per iteration. +3. `[accumulator]` *(Mixed)*: Initial value of the accumulator. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the accumulated value. + +#### Example +```js +var sum = _.reduce([1, 2, 3], function(sum, num) { + return sum + num; +}); +// => 6 + +var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) { + result[key] = num * 3; + return result; +}, {}); +// => { 'a': 3, 'b': 6, 'c': 9 } +``` + +* * * + + + + + + +### `_.reduceRight(collection [, callback=identity, accumulator, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2864 "View in source") [Ⓣ][1] + +This method is similar to `_.reduce`, except that it iterates over a `collection` from right to left. + +#### Aliases +*foldr* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function)*: The function called per iteration. +3. `[accumulator]` *(Mixed)*: Initial value of the accumulator. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the accumulated value. + +#### Example +```js +var list = [[0, 1], [2, 3], [4, 5]]; +var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []); +// => [4, 5, 2, 3, 0, 1] +``` + +* * * + + + + + + +### `_.reject(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2924 "View in source") [Ⓣ][1] + +The opposite of `_.filter`, this method returns the elements of a `collection` that `callback` does **not** return truthy for. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a new array of elements that did **not** pass the callback check. + +#### Example +```js +var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); +// => [1, 3, 5] + +var food = [ + { 'name': 'apple', 'organic': false, 'type': 'fruit' }, + { 'name': 'carrot', 'organic': true, 'type': 'vegetable' } +]; + +// using "_.pluck" callback shorthand +_.reject(food, 'organic'); +// => [{ 'name': 'apple', 'organic': false, 'type': 'fruit' }] + +// using "_.where" callback shorthand +_.reject(food, { 'type': 'fruit' }); +// => [{ 'name': 'carrot', 'organic': true, 'type': 'vegetable' }] +``` + +* * * + + + + + + +### `_.shuffle(collection)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2945 "View in source") [Ⓣ][1] + +Creates an array of shuffled `array` values, using a version of the Fisher-Yates shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to shuffle. + +#### Returns +*(Array)*: Returns a new shuffled collection. + +#### Example +```js +_.shuffle([1, 2, 3, 4, 5, 6]); +// => [4, 1, 6, 3, 5, 2] +``` + +* * * + + + + + + +### `_.size(collection)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2978 "View in source") [Ⓣ][1] + +Gets the size of the `collection` by returning `collection.length` for arrays and array-like objects or the number of own enumerable properties for objects. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to inspect. + +#### Returns +*(Number)*: Returns `collection.length` or number of own enumerable properties. + +#### Example +```js +_.size([1, 2]); +// => 2 + +_.size({ 'one': 1, 'two': 2, 'three': 3 }); +// => 3 + +_.size('curly'); +// => 5 +``` + +* * * + + + + + + +### `_.some(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3025 "View in source") [Ⓣ][1] + +Checks if the `callback` returns a truthy value for **any** element of a `collection`. The function returns as soon as it finds passing value, and does not iterate over the entire `collection`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Aliases +*any* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Boolean)*: Returns `true` if any element passes the callback check, else `false`. + +#### Example +```js +_.some([null, 0, 'yes', false], Boolean); +// => true + +var food = [ + { 'name': 'apple', 'organic': false, 'type': 'fruit' }, + { 'name': 'carrot', 'organic': true, 'type': 'vegetable' } +]; + +// using "_.pluck" callback shorthand +_.some(food, 'organic'); +// => true + +// using "_.where" callback shorthand +_.some(food, { 'type': 'meat' }); +// => false +``` + +* * * + + + + + + +### `_.sortBy(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3081 "View in source") [Ⓣ][1] + +Creates an array of elements, sorted in ascending order by the results of running each element in the `collection` through the `callback`. This method performs a stable sort, that is, it will preserve the original sort order of equal elements. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +If a property name is passed for `callback`, the created "_.pluck" style callback will return the property value of the given element. + +If an object is passed for `callback`, the created "_.where" style callback will return `true` for elements that have the propeties of the given object, else `false`. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function|Object|String)*: The function called per iteration. If a property name or object is passed, it will be used to create a "_.pluck" or "_.where" style callback, respectively. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a new array of sorted elements. + +#### Example +```js +_.sortBy([1, 2, 3], function(num) { return Math.sin(num); }); +// => [3, 1, 2] + +_.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math); +// => [3, 1, 2] + +// using "_.pluck" callback shorthand +_.sortBy(['banana', 'strawberry', 'apple'], 'length'); +// => ['apple', 'banana', 'strawberry'] +``` + +* * * + + + + + + +### `_.toArray(collection)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3116 "View in source") [Ⓣ][1] + +Converts the `collection` to an array. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to convert. + +#### Returns +*(Array)*: Returns the new converted array. + +#### Example +```js +(function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4); +// => [2, 3, 4] +``` + +* * * + + + + + + +### `_.where(collection, properties)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3148 "View in source") [Ⓣ][1] + +Examines each element in a `collection`, returning an array of all elements that have the given `properties`. When checking `properties`, this method performs a deep comparison between values to determine if they are equivalent to each other. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `properties` *(Object)*: The object of property values to filter by. + +#### Returns +*(Array)*: Returns a new array of elements that have the given `properties`. + +#### Example +```js +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 } +]; + +_.where(stooges, { 'age': 40 }); +// => [{ 'name': 'moe', 'age': 40 }] +``` + +* * * + + + + + + + + + +## `“Functions†Methods` + + + +### `_.after(n, func)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4007 "View in source") [Ⓣ][1] + +Creates a function that is restricted to executing `func` only after it is called `n` times. The `func` is executed with the `this` binding of the created function. + +#### Arguments +1. `n` *(Number)*: The number of times the function must be called before it is executed. +2. `func` *(Function)*: The function to restrict. + +#### Returns +*(Function)*: Returns the new restricted function. + +#### Example +```js +var renderNotes = _.after(notes.length, render); +_.forEach(notes, function(note) { + note.asyncSave({ 'success': renderNotes }); +}); +// `renderNotes` is run once, after all notes have saved +``` + +* * * + + + + + + +### `_.bind(func [, thisArg, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4040 "View in source") [Ⓣ][1] + +Creates a function that, when called, invokes `func` with the `this` binding of `thisArg` and prepends any additional `bind` arguments to those passed to the bound function. + +#### Arguments +1. `func` *(Function)*: The function to bind. +2. `[thisArg]` *(Mixed)*: The `this` binding of `func`. +3. `[arg1, arg2, ...]` *(Mixed)*: Arguments to be partially applied. + +#### Returns +*(Function)*: Returns the new bound function. + +#### Example +```js +var func = function(greeting) { + return greeting + ' ' + this.name; +}; + +func = _.bind(func, { 'name': 'moe' }, 'hi'); +func(); +// => 'hi moe' +``` + +* * * + + + + + + +### `_.bindAll(object [, methodName1, methodName2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4071 "View in source") [Ⓣ][1] + +Binds methods on `object` to `object`, overwriting the existing method. Method names may be specified as individual arguments or as arrays of method names. If no method names are provided, all the function properties of `object` will be bound. + +#### Arguments +1. `object` *(Object)*: The object to bind and assign the bound methods to. +2. `[methodName1, methodName2, ...]` *(String)*: Method names on the object to bind. + +#### Returns +*(Object)*: Returns `object`. + +#### Example +```js +var view = { + 'label': 'docs', + 'onClick': function() { alert('clicked ' + this.label); } +}; + +_.bindAll(view); +jQuery('#docs').on('click', view.onClick); +// => alerts 'clicked docs', when the button is clicked +``` + +* * * + + + + + + +### `_.bindKey(object, key [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4117 "View in source") [Ⓣ][1] + +Creates a function that, when called, invokes the method at `object[key]` and prepends any additional `bindKey` arguments to those passed to the bound function. This method differs from `_.bind` by allowing bound functions to reference methods that will be redefined or don't yet exist. See http://michaux.ca/articles/lazy-function-definition-pattern. + +#### Arguments +1. `object` *(Object)*: The object the method belongs to. +2. `key` *(String)*: The key of the method. +3. `[arg1, arg2, ...]` *(Mixed)*: Arguments to be partially applied. + +#### Returns +*(Function)*: Returns the new bound function. + +#### Example +```js +var object = { + 'name': 'moe', + 'greet': function(greeting) { + return greeting + ' ' + this.name; + } +}; + +var func = _.bindKey(object, 'greet', 'hi'); +func(); +// => 'hi moe' + +object.greet = function(greeting) { + return greeting + ', ' + this.name + '!'; +}; + +func(); +// => 'hi, moe!' +``` + +* * * + + + + + + +### `_.compose([func1, func2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4140 "View in source") [Ⓣ][1] + +Creates a function that is the composition of the passed functions, where each function consumes the return value of the function that follows. For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`. Each function is executed with the `this` binding of the composed function. + +#### Arguments +1. `[func1, func2, ...]` *(Function)*: Functions to compose. + +#### Returns +*(Function)*: Returns the new composed function. + +#### Example +```js +var greet = function(name) { return 'hi ' + name; }; +var exclaim = function(statement) { return statement + '!'; }; +var welcome = _.compose(exclaim, greet); +welcome('moe'); +// => 'hi moe!' +``` + +* * * + + + + + + +### `_.debounce(func, wait, immediate)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4173 "View in source") [Ⓣ][1] + +Creates a function that will delay the execution of `func` until after `wait` milliseconds have elapsed since the last time it was invoked. Pass `true` for `immediate` to cause debounce to invoke `func` on the leading, instead of the trailing, edge of the `wait` timeout. Subsequent calls to the debounced function will return the result of the last `func` call. + +#### Arguments +1. `func` *(Function)*: The function to debounce. +2. `wait` *(Number)*: The number of milliseconds to delay. +3. `immediate` *(Boolean)*: A flag to indicate execution is on the leading edge of the timeout. + +#### Returns +*(Function)*: Returns the new debounced function. + +#### Example +```js +var lazyLayout = _.debounce(calculateLayout, 300); +jQuery(window).on('resize', lazyLayout); +``` + +* * * + + + + + + +### `_.defer(func [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4237 "View in source") [Ⓣ][1] + +Defers executing the `func` function until the current call stack has cleared. Additional arguments will be passed to `func` when it is invoked. + +#### Arguments +1. `func` *(Function)*: The function to defer. +2. `[arg1, arg2, ...]` *(Mixed)*: Arguments to invoke the function with. + +#### Returns +*(Number)*: Returns the `setTimeout` timeout id. + +#### Example +```js +_.defer(function() { alert('deferred'); }); +// returns from the function before `alert` is called +``` + +* * * + + + + + + +### `_.delay(func, wait [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4217 "View in source") [Ⓣ][1] + +Executes the `func` function after `wait` milliseconds. Additional arguments will be passed to `func` when it is invoked. + +#### Arguments +1. `func` *(Function)*: The function to delay. +2. `wait` *(Number)*: The number of milliseconds to delay execution. +3. `[arg1, arg2, ...]` *(Mixed)*: Arguments to invoke the function with. + +#### Returns +*(Number)*: Returns the `setTimeout` timeout id. + +#### Example +```js +var log = _.bind(console.log, console); +_.delay(log, 1000, 'logged later'); +// => 'logged later' (Appears after one second.) +``` + +* * * + + + + + + +### `_.memoize(func [, resolver])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4265 "View in source") [Ⓣ][1] + +Creates a function that memoizes the result of `func`. If `resolver` is passed, it will be used to determine the cache key for storing the result based on the arguments passed to the memoized function. By default, the first argument passed to the memoized function is used as the cache key. The `func` is executed with the `this` binding of the memoized function. + +#### Arguments +1. `func` *(Function)*: The function to have its output memoized. +2. `[resolver]` *(Function)*: A function used to resolve the cache key. + +#### Returns +*(Function)*: Returns the new memoizing function. + +#### Example +```js +var fibonacci = _.memoize(function(n) { + return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2); +}); +``` + +* * * + + + + + + +### `_.once(func)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4292 "View in source") [Ⓣ][1] + +Creates a function that is restricted to execute `func` once. Repeat calls to the function will return the value of the first call. The `func` is executed with the `this` binding of the created function. + +#### Arguments +1. `func` *(Function)*: The function to restrict. + +#### Returns +*(Function)*: Returns the new restricted function. + +#### Example +```js +var initialize = _.once(createApplication); +initialize(); +initialize(); +// `initialize` executes `createApplication` once +``` + +* * * + + + + + + +### `_.partial(func [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4327 "View in source") [Ⓣ][1] + +Creates a function that, when called, invokes `func` with any additional `partial` arguments prepended to those passed to the new function. This method is similar to `_.bind`, except it does **not** alter the `this` binding. + +#### Arguments +1. `func` *(Function)*: The function to partially apply arguments to. +2. `[arg1, arg2, ...]` *(Mixed)*: Arguments to be partially applied. + +#### Returns +*(Function)*: Returns the new partially applied function. + +#### Example +```js +var greet = function(greeting, name) { return greeting + ' ' + name; }; +var hi = _.partial(greet, 'hi'); +hi('moe'); +// => 'hi moe' +``` + +* * * + + + + + + +### `_.partialRight(func [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4358 "View in source") [Ⓣ][1] + +This method is similar to `_.partial`, except that `partial` arguments are appended to those passed to the new function. + +#### Arguments +1. `func` *(Function)*: The function to partially apply arguments to. +2. `[arg1, arg2, ...]` *(Mixed)*: Arguments to be partially applied. + +#### Returns +*(Function)*: Returns the new partially applied function. + +#### Example +```js +var defaultsDeep = _.partialRight(_.merge, _.defaults); + +var options = { + 'variable': 'data', + 'imports': { 'jq': $ } +}; + +defaultsDeep(options, _.templateSettings); + +options.variable +// => 'data' + +options.imports +// => { '_': _, 'jq': $ } +``` + +* * * + + + + + + +### `_.throttle(func, wait)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4380 "View in source") [Ⓣ][1] + +Creates a function that, when executed, will only call the `func` function at most once per every `wait` milliseconds. If the throttled function is invoked more than once during the `wait` timeout, `func` will also be called on the trailing edge of the timeout. Subsequent calls to the throttled function will return the result of the last `func` call. + +#### Arguments +1. `func` *(Function)*: The function to throttle. +2. `wait` *(Number)*: The number of milliseconds to throttle executions to. + +#### Returns +*(Function)*: Returns the new throttled function. + +#### Example +```js +var throttled = _.throttle(updatePosition, 100); +jQuery(window).on('scroll', throttled); +``` + +* * * + + + + + + +### `_.wrap(value, wrapper)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4433 "View in source") [Ⓣ][1] + +Creates a function that passes `value` to the `wrapper` function as its first argument. Additional arguments passed to the function are appended to those passed to the `wrapper` function. The `wrapper` is executed with the `this` binding of the created function. + +#### Arguments +1. `value` *(Mixed)*: The value to wrap. +2. `wrapper` *(Function)*: The wrapper function. + +#### Returns +*(Function)*: Returns the new function. + +#### Example +```js +var hello = function(name) { return 'hello ' + name; }; +hello = _.wrap(hello, function(func) { + return 'before, ' + func('moe') + ', after'; +}); +hello(); +// => 'before, hello moe, after' +``` + +* * * + + + + + + + + + +## `“Objects†Methods` + + + +### `_.assign(object [, source1, source2, ..., callback, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1062 "View in source") [Ⓣ][1] + +Assigns own enumerable properties of source object(s) to the destination object. Subsequent sources will overwrite propery assignments of previous sources. If a `callback` function is passed, it will be executed to produce the assigned values. The `callback` is bound to `thisArg` and invoked with two arguments; *(objectValue, sourceValue)*. + +#### Aliases +*extend* + +#### Arguments +1. `object` *(Object)*: The destination object. +2. `[source1, source2, ...]` *(Object)*: The source objects. +3. `[callback]` *(Function)*: The function to customize assigning values. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns the destination object. + +#### Example +```js +_.assign({ 'name': 'moe' }, { 'age': 40 }); +// => { 'name': 'moe', 'age': 40 } + +var defaults = _.partialRight(_.assign, function(a, b) { + return typeof a == 'undefined' ? b : a; +}); + +var food = { 'name': 'apple' }; +defaults(food, { 'name': 'banana', 'type': 'fruit' }); +// => { 'name': 'apple', 'type': 'fruit' } +``` + +* * * + + + + + + +### `_.clone(value [, deep=false, callback, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1117 "View in source") [Ⓣ][1] + +Creates a clone of `value`. If `deep` is `true`, nested objects will also be cloned, otherwise they will be assigned by reference. If a `callback` function is passed, it will be executed to produce the cloned values. If `callback` returns `undefined`, cloning will be handled by the method instead. The `callback` is bound to `thisArg` and invoked with one argument; *(value)*. + +#### Arguments +1. `value` *(Mixed)*: The value to clone. +2. `[deep=false]` *(Boolean)*: A flag to indicate a deep clone. +3. `[callback]` *(Function)*: The function to customize cloning values. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the cloned `value`. + +#### Example +```js +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 } +]; + +var shallow = _.clone(stooges); +shallow[0] === stooges[0]; +// => true + +var deep = _.clone(stooges, true); +deep[0] === stooges[0]; +// => false + +_.mixin({ + 'clone': _.partialRight(_.clone, function(value) { + return _.isElement(value) ? value.cloneNode(false) : undefined; + }) +}); + +var clone = _.clone(document.body); +clone.childNodes.length; +// => 0 +``` + +* * * + + + + + + +### `_.cloneDeep(value [, callback, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1242 "View in source") [Ⓣ][1] + +Creates a deep clone of `value`. If a `callback` function is passed, it will be executed to produce the cloned values. If `callback` returns the value it was passed, cloning will be handled by the method instead. The `callback` is bound to `thisArg` and invoked with one argument; *(value)*. + +Note: This function is loosely based on the structured clone algorithm. Functions and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and objects created by constructors other than `Object` are cloned to plain `Object` objects. See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm. + +#### Arguments +1. `value` *(Mixed)*: The value to deep clone. +2. `[callback]` *(Function)*: The function to customize cloning values. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the deep cloned `value`. + +#### Example +```js +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 } +]; + +var deep = _.cloneDeep(stooges); +deep[0] === stooges[0]; +// => false + +var view = { + 'label': 'docs', + 'node': element +}; + +var clone = _.cloneDeep(view, function(value) { + return _.isElement(value) ? value.cloneNode(true) : value; +}); + +clone.node == view.node; +// => false +``` + +* * * + + + + + + +### `_.defaults(object [, source1, source2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1266 "View in source") [Ⓣ][1] + +Assigns own enumerable properties of source object(s) to the destination object for all destination properties that resolve to `undefined`. Once a property is set, additional defaults of the same property will be ignored. + +#### Arguments +1. `object` *(Object)*: The destination object. +2. `[source1, source2, ...]` *(Object)*: The source objects. + +#### Returns +*(Object)*: Returns the destination object. + +#### Example +```js +var food = { 'name': 'apple' }; +_.defaults(food, { 'name': 'banana', 'type': 'fruit' }); +// => { 'name': 'apple', 'type': 'fruit' } +``` + +* * * + + + + + + +### `_.forIn(object [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L882 "View in source") [Ⓣ][1] + +Iterates over `object`'s own and inherited enumerable properties, executing the `callback` for each property. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, key, object)*. Callbacks may exit iteration early by explicitly returning `false`. + +#### Arguments +1. `object` *(Object)*: The object to iterate over. +2. `[callback=identity]` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns `object`. + +#### Example +```js +function Dog(name) { + this.name = name; +} + +Dog.prototype.bark = function() { + alert('Woof, woof!'); +}; + +_.forIn(new Dog('Dagny'), function(value, key) { + alert(key); +}); +// => alerts 'name' and 'bark' (order is not guaranteed) +``` + +* * * + + + + + + +### `_.forOwn(object [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L907 "View in source") [Ⓣ][1] + +Iterates over an object's own enumerable properties, executing the `callback` for each property. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, key, object)*. Callbacks may exit iteration early by explicitly returning `false`. + +#### Arguments +1. `object` *(Object)*: The object to iterate over. +2. `[callback=identity]` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns `object`. + +#### Example +```js +_.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) { + alert(key); +}); +// => alerts '0', '1', and 'length' (order is not guaranteed) +``` + +* * * + + + + + + +### `_.functions(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1283 "View in source") [Ⓣ][1] + +Creates a sorted array of all enumerable properties, own and inherited, of `object` that have function values. + +#### Aliases +*methods* + +#### Arguments +1. `object` *(Object)*: The object to inspect. + +#### Returns +*(Array)*: Returns a new array of property names that have function values. + +#### Example +```js +_.functions(_); +// => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...] +``` + +* * * + + + + + + +### `_.has(object, property)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1308 "View in source") [Ⓣ][1] + +Checks if the specified object `property` exists and is a direct property, instead of an inherited property. + +#### Arguments +1. `object` *(Object)*: The object to check. +2. `property` *(String)*: The property to check for. + +#### Returns +*(Boolean)*: Returns `true` if key is a direct property, else `false`. + +#### Example +```js +_.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b'); +// => true +``` + +* * * + + + + + + +### `_.invert(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1325 "View in source") [Ⓣ][1] + +Creates an object composed of the inverted keys and values of the given `object`. + +#### Arguments +1. `object` *(Object)*: The object to invert. + +#### Returns +*(Object)*: Returns the created inverted object. + +#### Example +```js +_.invert({ 'first': 'moe', 'second': 'larry' }); +// => { 'moe': 'first', 'larry': 'second' } (order is not guaranteed) +``` + +* * * + + + + + + +### `_.isArguments(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L843 "View in source") [Ⓣ][1] + +Checks if `value` is an `arguments` object. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is an `arguments` object, else `false`. + +#### Example +```js +(function() { return _.isArguments(arguments); })(1, 2, 3); +// => true + +_.isArguments([1, 2, 3]); +// => false +``` + +* * * + + + + + + +### `_.isArray(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L925 "View in source") [Ⓣ][1] + +Checks if `value` is an array. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is an array, else `false`. + +#### Example +```js +(function() { return _.isArray(arguments); })(); +// => false + +_.isArray([1, 2, 3]); +// => true +``` + +* * * + + + + + + +### `_.isBoolean(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1351 "View in source") [Ⓣ][1] + +Checks if `value` is a boolean value. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is a boolean value, else `false`. + +#### Example +```js +_.isBoolean(null); +// => false +``` + +* * * + + + + + + +### `_.isDate(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1368 "View in source") [Ⓣ][1] + +Checks if `value` is a date. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is a date, else `false`. + +#### Example +```js +_.isDate(new Date); +// => true +``` + +* * * + + + + + + +### `_.isElement(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1385 "View in source") [Ⓣ][1] + +Checks if `value` is a DOM element. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is a DOM element, else `false`. + +#### Example +```js +_.isElement(document.body); +// => true +``` + +* * * + + + + + + +### `_.isEmpty(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1410 "View in source") [Ⓣ][1] + +Checks if `value` is empty. Arrays, strings, or `arguments` objects with a length of `0` and objects with no own enumerable properties are considered "empty". + +#### Arguments +1. `value` *(Array|Object|String)*: The value to inspect. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is empty, else `false`. + +#### Example +```js +_.isEmpty([1, 2, 3]); +// => false + +_.isEmpty({}); +// => true + +_.isEmpty(''); +// => true +``` + +* * * + + + + + + +### `_.isEqual(a, b [, callback, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1469 "View in source") [Ⓣ][1] + +Performs a deep comparison between two values to determine if they are equivalent to each other. If `callback` is passed, it will be executed to compare values. If `callback` returns `undefined`, comparisons will be handled by the method instead. The `callback` is bound to `thisArg` and invoked with two arguments; *(a, b)*. + +#### Arguments +1. `a` *(Mixed)*: The value to compare. +2. `b` *(Mixed)*: The other value to compare. +3. `[callback]` *(Function)*: The function to customize comparing values. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Boolean)*: Returns `true`, if the values are equvalent, else `false`. + +#### Example +```js +var moe = { 'name': 'moe', 'age': 40 }; +var copy = { 'name': 'moe', 'age': 40 }; + +moe == copy; +// => false + +_.isEqual(moe, copy); +// => true + +var words = ['hello', 'goodbye']; +var otherWords = ['hi', 'goodbye']; + +_.isEqual(words, otherWords, function(a, b) { + var reGreet = /^(?:hello|hi)$/i, + aGreet = _.isString(a) && reGreet.test(a), + bGreet = _.isString(b) && reGreet.test(b); + + return (aGreet || bGreet) ? (aGreet == bGreet) : undefined; +}); +// => true +``` + +* * * + + + + + + +### `_.isFinite(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1650 "View in source") [Ⓣ][1] + +Checks if `value` is, or can be coerced to, a finite number. + +Note: This is not the same as native `isFinite`, which will return true for booleans and empty strings. See http://es5.github.com/#x15.1.2.5. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is finite, else `false`. + +#### Example +```js +_.isFinite(-101); +// => true + +_.isFinite('10'); +// => true + +_.isFinite(true); +// => false + +_.isFinite(''); +// => false + +_.isFinite(Infinity); +// => false +``` + +* * * + + + + + + +### `_.isFunction(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1667 "View in source") [Ⓣ][1] + +Checks if `value` is a function. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is a function, else `false`. + +#### Example +```js +_.isFunction(_); +// => true +``` + +* * * + + + + + + +### `_.isNaN(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1730 "View in source") [Ⓣ][1] + +Checks if `value` is `NaN`. + +Note: This is not the same as native `isNaN`, which will return `true` for `undefined` and other values. See http://es5.github.com/#x15.1.2.4. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is `NaN`, else `false`. + +#### Example +```js +_.isNaN(NaN); +// => true + +_.isNaN(new Number(NaN)); +// => true + +isNaN(undefined); +// => true + +_.isNaN(undefined); +// => false +``` + +* * * + + + + + + +### `_.isNull(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1752 "View in source") [Ⓣ][1] + +Checks if `value` is `null`. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is `null`, else `false`. + +#### Example +```js +_.isNull(null); +// => true + +_.isNull(undefined); +// => false +``` + +* * * + + + + + + +### `_.isNumber(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1769 "View in source") [Ⓣ][1] + +Checks if `value` is a number. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is a number, else `false`. + +#### Example +```js +_.isNumber(8.4 * 5); +// => true +``` + +* * * + + + + + + +### `_.isObject(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1697 "View in source") [Ⓣ][1] + +Checks if `value` is the language type of Object. *(e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)* + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is an object, else `false`. + +#### Example +```js +_.isObject({}); +// => true + +_.isObject([1, 2, 3]); +// => true + +_.isObject(1); +// => false +``` + +* * * + + + + + + +### `_.isPlainObject(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1797 "View in source") [Ⓣ][1] + +Checks if a given `value` is an object created by the `Object` constructor. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if `value` is a plain object, else `false`. + +#### Example +```js +function Stooge(name, age) { + this.name = name; + this.age = age; +} + +_.isPlainObject(new Stooge('moe', 40)); +// => false + +_.isPlainObject([1, 2, 3]); +// => false + +_.isPlainObject({ 'name': 'moe', 'age': 40 }); +// => true +``` + +* * * + + + + + + +### `_.isRegExp(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1822 "View in source") [Ⓣ][1] + +Checks if `value` is a regular expression. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is a regular expression, else `false`. + +#### Example +```js +_.isRegExp(/moe/); +// => true +``` + +* * * + + + + + + +### `_.isString(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1839 "View in source") [Ⓣ][1] + +Checks if `value` is a string. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is a string, else `false`. + +#### Example +```js +_.isString('moe'); +// => true +``` + +* * * + + + + + + +### `_.isUndefined(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1856 "View in source") [Ⓣ][1] + +Checks if `value` is `undefined`. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true`, if the `value` is `undefined`, else `false`. + +#### Example +```js +_.isUndefined(void 0); +// => true +``` + +* * * + + + + + + +### `_.keys(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L944 "View in source") [Ⓣ][1] + +Creates an array composed of the own enumerable property names of `object`. + +#### Arguments +1. `object` *(Object)*: The object to inspect. + +#### Returns +*(Array)*: Returns a new array of property names. + +#### Example +```js +_.keys({ 'one': 1, 'two': 2, 'three': 3 }); +// => ['one', 'two', 'three'] (order is not guaranteed) +``` + +* * * + + + + + + +### `_.merge(object [, source1, source2, ..., callback, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1916 "View in source") [Ⓣ][1] + +Recursively merges own enumerable properties of the source object(s), that don't resolve to `undefined`, into the destination object. Subsequent sources will overwrite propery assignments of previous sources. If a `callback` function is passed, it will be executed to produce the merged values of the destination and source properties. If `callback` returns `undefined`, merging will be handled by the method instead. The `callback` is bound to `thisArg` and invoked with two arguments; *(objectValue, sourceValue)*. + +#### Arguments +1. `object` *(Object)*: The destination object. +2. `[source1, source2, ...]` *(Object)*: The source objects. +3. `[callback]` *(Function)*: The function to customize merging properties. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns the destination object. + +#### Example +```js +var names = { + 'stooges': [ + { 'name': 'moe' }, + { 'name': 'larry' } + ] +}; + +var ages = { + 'stooges': [ + { 'age': 40 }, + { 'age': 50 } + ] +}; + +_.merge(names, ages); +// => { 'stooges': [{ 'name': 'moe', 'age': 40 }, { 'name': 'larry', 'age': 50 }] } + +var food = { + 'fruits': ['apple'], + 'vegetables': ['beet'] +}; + +var otherFood = { + 'fruits': ['banana'], + 'vegetables': ['carrot'] +}; + +_.merge(food, otherFood, function(a, b) { + return _.isArray(a) ? a.concat(b) : undefined; +}); +// => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] } +``` + +* * * + + + + + + +### `_.omit(object, callback|[prop1, prop2, ..., thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2023 "View in source") [Ⓣ][1] + +Creates a shallow clone of `object` excluding the specified properties. Property names may be specified as individual arguments or as arrays of property names. If a `callback` function is passed, it will be executed for each property in the `object`, omitting the properties `callback` returns truthy for. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, key, object)*. + +#### Arguments +1. `object` *(Object)*: The source object. +2. `callback|[prop1, prop2, ...]` *(Function|String)*: The properties to omit or the function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns an object without the omitted properties. + +#### Example +```js +_.omit({ 'name': 'moe', 'age': 40 }, 'age'); +// => { 'name': 'moe' } + +_.omit({ 'name': 'moe', 'age': 40 }, function(value) { + return typeof value == 'number'; +}); +// => { 'name': 'moe' } +``` + +* * * + + + + + + +### `_.pairs(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2057 "View in source") [Ⓣ][1] + +Creates a two dimensional array of the given object's key-value pairs, i.e. `[[key1, value1], [key2, value2]]`. + +#### Arguments +1. `object` *(Object)*: The object to inspect. + +#### Returns +*(Array)*: Returns new array of key-value pairs. + +#### Example +```js +_.pairs({ 'moe': 30, 'larry': 40 }); +// => [['moe', 30], ['larry', 40]] (order is not guaranteed) +``` + +* * * + + + + + + +### `_.pick(object, callback|[prop1, prop2, ..., thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2095 "View in source") [Ⓣ][1] + +Creates a shallow clone of `object` composed of the specified properties. Property names may be specified as individual arguments or as arrays of property names. If `callback` is passed, it will be executed for each property in the `object`, picking the properties `callback` returns truthy for. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, key, object)*. + +#### Arguments +1. `object` *(Object)*: The source object. +2. `callback|[prop1, prop2, ...]` *(Array|Function|String)*: The function called per iteration or properties to pick, either as individual arguments or arrays. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns an object composed of the picked properties. + +#### Example +```js +_.pick({ 'name': 'moe', '_userid': 'moe1' }, 'name'); +// => { 'name': 'moe' } + +_.pick({ 'name': 'moe', '_userid': 'moe1' }, function(value, key) { + return key.charAt(0) != '_'; +}); +// => { 'name': 'moe' } +``` + +* * * + + + + + + +### `_.values(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2132 "View in source") [Ⓣ][1] + +Creates an array composed of the own enumerable property values of `object`. + +#### Arguments +1. `object` *(Object)*: The object to inspect. + +#### Returns +*(Array)*: Returns a new array of property values. + +#### Example +```js +_.values({ 'one': 1, 'two': 2, 'three': 3 }); +// => [1, 2, 3] +``` + +* * * + + + + + + + + + +## `“Utilities†Methods` + + + +### `_.escape(string)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4457 "View in source") [Ⓣ][1] + +Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their corresponding HTML entities. + +#### Arguments +1. `string` *(String)*: The string to escape. + +#### Returns +*(String)*: Returns the escaped string. + +#### Example +```js +_.escape('Moe, Larry & Curly'); +// => 'Moe, Larry & Curly' +``` + +* * * + + + + + + +### `_.identity(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4475 "View in source") [Ⓣ][1] + +This function returns the first argument passed to it. + +#### Arguments +1. `value` *(Mixed)*: Any value. + +#### Returns +*(Mixed)*: Returns `value`. + +#### Example +```js +var moe = { 'name': 'moe' }; +moe === _.identity(moe); +// => true +``` + +* * * + + + + + + +### `_.mixin(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4501 "View in source") [Ⓣ][1] + +Adds functions properties of `object` to the `lodash` function and chainable wrapper. + +#### Arguments +1. `object` *(Object)*: The object of function properties to add to `lodash`. + +#### Example +```js +_.mixin({ + 'capitalize': function(string) { + return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase(); + } +}); + +_.capitalize('moe'); +// => 'Moe' + +_('moe').capitalize(); +// => 'Moe' +``` + +* * * + + + + + + +### `_.noConflict()` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4525 "View in source") [Ⓣ][1] + +Reverts the '_' variable to its previous value and returns a reference to the `lodash` function. + +#### Returns +*(Function)*: Returns the `lodash` function. + +#### Example +```js +var lodash = _.noConflict(); +``` + +* * * + + + + + + +### `_.random([min=0, max=1])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4548 "View in source") [Ⓣ][1] + +Produces a random number between `min` and `max` *(inclusive)*. If only one argument is passed, a number between `0` and the given number will be returned. + +#### Arguments +1. `[min=0]` *(Number)*: The minimum possible value. +2. `[max=1]` *(Number)*: The maximum possible value. + +#### Returns +*(Number)*: Returns a random number. + +#### Example +```js +_.random(0, 5); +// => a number between 0 and 5 + +_.random(5); +// => also a number between 0 and 5 +``` + +* * * + + + + + + +### `_.result(object, property)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4586 "View in source") [Ⓣ][1] + +Resolves the value of `property` on `object`. If `property` is a function, it will be invoked and its result returned, else the property value is returned. If `object` is falsey, then `null` is returned. + +#### Arguments +1. `object` *(Object)*: The object to inspect. +2. `property` *(String)*: The property to get the value of. + +#### Returns +*(Mixed)*: Returns the resolved value. + +#### Example +```js +var object = { + 'cheese': 'crumpets', + 'stuff': function() { + return 'nonsense'; + } +}; + +_.result(object, 'cheese'); +// => 'crumpets' + +_.result(object, 'stuff'); +// => 'nonsense' +``` + +* * * + + + + + + +### `_.template(text, data, options)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4674 "View in source") [Ⓣ][1] + +A micro-templating method that handles arbitrary delimiters, preserves whitespace, and correctly escapes quotes within interpolated code. + +Note: In the development build, `_.template` utilizes sourceURLs for easier debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl + +Note: Lo-Dash may be used in Chrome extensions by either creating a `lodash csp` build and using precompiled templates, or loading Lo-Dash in a sandbox. + +For more information on precompiling templates see:
+http://lodash.com/#custom-builds + +For more information on Chrome extension sandboxes see:
+http://developer.chrome.com/stable/extensions/sandboxingEval.html + +#### Arguments +1. `text` *(String)*: The template text. +2. `data` *(Obect)*: The data object used to populate the text. +3. `options` *(Object)*: The options object. escape - The "escape" delimiter regexp. evaluate - The "evaluate" delimiter regexp. interpolate - The "interpolate" delimiter regexp. sourceURL - The sourceURL of the template's compiled source. variable - The data object variable name. + +#### Returns +*(Function, String)*: Returns a compiled function when no `data` object is given, else it returns the interpolated text. + +#### Example +```js +// using a compiled template +var compiled = _.template('hello <%= name %>'); +compiled({ 'name': 'moe' }); +// => 'hello moe' + +var list = '<% _.forEach(people, function(name) { %>
-
+<% _.forEach(people, function(name) { %>
- <%- name %> <% }); %> +
+(This page uses big5 character set.)
+charset=big5 + + + \ No newline at end of file diff --git a/Phaser/node_modules/grunt/node_modules/iconv-lite/test/gbkFile.txt b/Phaser/node_modules/grunt/node_modules/iconv-lite/test/gbkFile.txt new file mode 100644 index 00000000..345b5d09 --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/iconv-lite/test/gbkFile.txt @@ -0,0 +1,14 @@ +
РÎÅ¡¡Íø Ò³¡¡Ìù °É¡¡Öª µÀ¡¡MP3¡¡Í¼ Ƭ¡¡ÊÓ Æµ¡¡µØ ͼ
+°Ñ°Ù¶ÈÉèΪÖ÷Ò³°Ñ°Ù¶È¼ÓÈëÊղؼÐ
+¼ÓÈë°Ù¶ÈÍƹã | ËÑË÷·çÔÆ°ñ | ¹ØÓÚ°Ù¶È | About Baidu
©2011 Baidu ʹÓðٶÈÇ°±Ø¶Á ¾©ICPÖ¤030173ºÅ 
Blah blah blah
').escapeHTML();
+=> '<div>Blah blah blah</div>'
+```
+
+**unescapeHTML** _.unescapeHTML(string)
+
+Converts entity characters to HTML equivalents.
+
+```javascript
+_('<div>Blah blah blah</div>').unescapeHTML();
+=> 'Blah blah blah
'
+```
+
+**insert** _.insert(string, index, substing)
+
+```javascript
+_('Hello ').insert(6, 'world')
+=> 'Hello world'
+```
+
+**isBlank** _.isBlank(string)
+
+```javascript
+_('').isBlank(); // => true
+_('\n').isBlank(); // => true
+_(' ').isBlank(); // => true
+_('a').isBlank(); // => false
+```
+
+**join** _.join(separator, *strings)
+
+Joins strings together with given separator
+
+```javascript
+_.join(" ", "foo", "bar")
+=> "foo bar"
+```
+
+**lines** _.lines(str)
+
+```javascript
+_.lines("Hello\nWorld")
+=> ["Hello", "World"]
+```
+
+**reverse** available only through _.str object, because Underscore has function with the same name.
+
+Return reversed string:
+
+```javascript
+_.str.reverse("foobar")
+=> 'raboof'
+```
+
+**splice** _.splice(string, index, howmany, substring)
+
+Like a array splice.
+
+```javascript
+_('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli')
+=> 'https://edtsech@bitbucket.org/epeli/underscore.strings'
+```
+
+**startsWith** _.startsWith(string, starts)
+
+This method checks whether string starts with starts.
+
+```javascript
+_("image.gif").startsWith("image")
+=> true
+```
+
+**endsWith** _.endsWith(string, ends)
+
+This method checks whether string ends with ends.
+
+```javascript
+_("image.gif").endsWith("gif")
+=> true
+```
+
+**succ** _.succ(str)
+
+Returns the successor to str.
+
+```javascript
+_('a').succ()
+=> 'b'
+
+_('A').succ()
+=> 'B'
+```
+
+**supplant**
+
+Supplant function was removed, use Underscore.js [template function][p].
+
+[p]: http://documentcloud.github.com/underscore/#template
+
+**strip** alias for *trim*
+
+**lstrip** alias for *ltrim*
+
+**rstrip** alias for *rtrim*
+
+**titleize** _.titleize(string)
+
+```javascript
+_('my name is epeli').titleize()
+=> 'My Name Is Epeli'
+```
+
+**camelize** _.camelize(string)
+
+Converts underscored or dasherized string to a camelized one
+
+```javascript
+_('-moz-transform').camelize()
+=> 'MozTransform'
+```
+
+**classify** _.classify(string)
+
+Converts string to camelized class name
+
+```javascript
+_('some_class_name').classify()
+=> 'SomeClassName'
+```
+
+**underscored** _.underscored(string)
+
+Converts a camelized or dasherized string into an underscored one
+
+```javascript
+_('MozTransform').underscored()
+=> 'moz_transform'
+```
+
+**dasherize** _.dasherize(string)
+
+Converts a underscored or camelized string into an dasherized one
+
+```javascript
+_('MozTransform').dasherize()
+=> '-moz-transform'
+```
+
+**humanize** _.humanize(string)
+
+Converts an underscored, camelized, or dasherized string into a humanized one.
+Also removes beginning and ending whitespace, and removes the postfix '_id'.
+
+```javascript
+_(' capitalize dash-CamelCase_underscore trim ').humanize()
+=> 'Capitalize dash camel case underscore trim'
+```
+
+**trim** _.trim(string, [characters])
+
+trims defined characters from begining and ending of the string.
+Defaults to whitespace characters.
+
+```javascript
+_.trim(" foobar ")
+=> "foobar"
+
+_.trim("_-foobar-_", "_-")
+=> "foobar"
+```
+
+
+**ltrim** _.ltrim(string, [characters])
+
+Left trim. Similar to trim, but only for left side.
+
+
+**rtrim** _.rtrim(string, [characters])
+
+Right trim. Similar to trim, but only for right side.
+
+**truncate** _.truncate(string, length, truncateString)
+
+```javascript
+_('Hello world').truncate(5)
+=> 'Hello...'
+
+_('Hello').truncate(10)
+=> 'Hello'
+```
+
+**prune** _.prune(string, length, pruneString)
+
+Elegant version of truncate.
+Makes sure the pruned string does not exceed the original length.
+Avoid half-chopped words when truncating.
+
+```javascript
+_('Hello, world').prune(5)
+=> 'Hello...'
+
+_('Hello, world').prune(8)
+=> 'Hello...'
+
+_('Hello, world').prune(5, ' (read a lot more)')
+=> 'Hello, world' (as adding "(read a lot more)" would be longer than the original string)
+
+_('Hello, cruel world').prune(15)
+=> 'Hello, cruel...'
+
+_('Hello').prune(10)
+=> 'Hello'
+```
+
+**words** _.words(str, delimiter=/\s+/)
+
+Split string by delimiter (String or RegExp), /\s+/ by default.
+
+```javascript
+_.words(" I love you ")
+=> ["I","love","you"]
+
+_.words("I_love_you", "_")
+=> ["I","love","you"]
+
+_.words("I-love-you", /-/)
+=> ["I","love","you"]
+
+_.words(" ")
+=> []
+```
+
+**sprintf** _.sprintf(string format, *arguments)
+
+C like string formatting.
+Credits goes to [Alexandru Marasteanu][o].
+For more detailed documentation, see the [original page][o].
+
+[o]: http://www.diveintojavascript.com/projects/sprintf-for-javascript
+
+```javascript
+_.sprintf("%.1f", 1.17)
+"1.2"
+```
+
+**pad** _.pad(str, length, [padStr, type])
+
+pads the `str` with characters until the total string length is equal to the passed `length` parameter. By default, pads on the **left** with the space char (`" "`). `padStr` is truncated to a single character if necessary.
+
+```javascript
+_.pad("1", 8)
+-> " 1";
+
+_.pad("1", 8, '0')
+-> "00000001";
+
+_.pad("1", 8, '0', 'right')
+-> "10000000";
+
+_.pad("1", 8, '0', 'both')
+-> "00001000";
+
+_.pad("1", 8, 'bleepblorp', 'both')
+-> "bbbb1bbb";
+```
+
+**lpad** _.lpad(str, length, [padStr])
+
+left-pad a string. Alias for `pad(str, length, padStr, 'left')`
+
+```javascript
+_.lpad("1", 8, '0')
+-> "00000001";
+```
+
+**rpad** _.rpad(str, length, [padStr])
+
+right-pad a string. Alias for `pad(str, length, padStr, 'right')`
+
+```javascript
+_.rpad("1", 8, '0')
+-> "10000000";
+```
+
+**lrpad** _.lrpad(str, length, [padStr])
+
+left/right-pad a string. Alias for `pad(str, length, padStr, 'both')`
+
+```javascript
+_.lrpad("1", 8, '0')
+-> "00001000";
+```
+
+**center** alias for **lrpad**
+
+**ljust** alias for *rpad*
+
+**rjust** alias for *lpad*
+
+**toNumber** _.toNumber(string, [decimals])
+
+Parse string to number. Returns NaN if string can't be parsed to number.
+
+```javascript
+_('2.556').toNumber()
+=> 3
+
+_('2.556').toNumber(1)
+=> 2.6
+```
+
+**strRight** _.strRight(string, pattern)
+
+Searches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strRight('_')
+=> "is_a_test_string";
+```
+
+**strRightBack** _.strRightBack(string, pattern)
+
+Searches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strRightBack('_')
+=> "string";
+```
+
+**strLeft** _.strLeft(string, pattern)
+
+Searches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strLeft('_')
+=> "This";
+```
+
+**strLeftBack** _.strLeftBack(string, pattern)
+
+Searches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strLeftBack('_')
+=> "This_is_a_test";
+```
+
+**stripTags**
+
+Removes all html tags from string.
+
+```javascript
+_('a link').stripTags()
+=> 'a link'
+
+_('a link').stripTags()
+=> 'a linkalert("hello world!")'
+```
+
+**toSentence** _.toSentence(array, [delimiter, lastDelimiter])
+
+Join an array into a human readable sentence.
+
+```javascript
+_.toSentence(['jQuery', 'Mootools', 'Prototype'])
+=> 'jQuery, Mootools and Prototype';
+
+_.toSentence(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ')
+=> 'jQuery, Mootools unt Prototype';
+```
+
+**toSentenceSerial** _.toSentenceSerial(array, [delimiter, lastDelimiter])
+
+The same as `toSentence`, but adjusts delimeters to use [Serial comma](http://en.wikipedia.org/wiki/Serial_comma).
+
+```javascript
+_.toSentenceSerial(['jQuery', 'Mootools'])
+=> 'jQuery and Mootools';
+
+_.toSentenceSerial(['jQuery', 'Mootools', 'Prototype'])
+=> 'jQuery, Mootools, and Prototype'
+
+_.toSentenceSerial(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ');
+=> 'jQuery, Mootools, unt Prototype';
+```
+
+**repeat** _.repeat(string, count, [separator])
+
+Repeats a string count times.
+
+```javascript
+_.repeat("foo", 3)
+=> 'foofoofoo';
+
+_.repeat("foo", 3, "bar")
+=> 'foobarfoobarfoo'
+```
+
+**surround** _.surround(string, wrap)
+
+Surround a string with another string.
+
+```javascript
+_.surround("foo", "ab")
+=> 'abfooab';
+```
+
+**quote** _.quote(string) or _.q(string)
+
+Quotes a string.
+
+```javascript
+_.quote('foo')
+=> '"foo"';
+```
+
+
+**slugify** _.slugify(string)
+
+Transform text into a URL slug. Replaces whitespaces, accentuated, and special characters with a dash.
+
+```javascript
+_.slugify("Un éléphant à l'orée du bois")
+=> 'un-elephant-a-loree-du-bois';
+```
+
+***Caution: this function is charset dependent***
+
+## Roadmap ##
+
+Any suggestions or bug reports are welcome. Just email me or more preferably open an issue.
+
+#### Problems
+
+We lose two things for `include` and `reverse` methods from `_.string`:
+
+* Calls like `_('foobar').include('bar')` aren't available;
+* Chaining isn't available too.
+
+But if you need this functionality you can create aliases for conflict functions which will be convenient for you:
+
+```javascript
+_.mixin({
+ includeString: _.str.include,
+ reverseString: _.str.reverse
+})
+
+// Now wrapper calls and chaining are available.
+_('foobar').chain().reverseString().includeString('rab').value()
+```
+
+#### Standalone Usage
+
+If you are using Underscore.string without Underscore. You also have `_.string` namespace for it and `_.str` alias
+But of course you can just reassign `_` variable with `_.string`
+
+```javascript
+_ = _.string
+```
+
+## Changelog ##
+
+### 2.3.1 ###
+
+* Changed integration logic, now trying everything in order
+* Fixed classify method to chew some unexpected input
+* Fixed toNumber method failing to recognize '0.0' as a proper number
+
+
+### 2.3.0 ###
+
+* Added `numberformat` method
+* Added `levenshtein` method (Levenshtein distance calculation)
+* Added `swapCase` method
+* Changed default behavior of `words` method
+* Added `toSentenceSerial` method
+* Added `surround` and `quote` methods
+
+### 2.2.0 ###
+
+* Capitalize method behavior changed
+* Various perfomance tweaks
+
+### 2.1.1###
+
+* Fixed words method bug
+* Added classify method
+
+### 2.1.0 ###
+
+* AMD support
+* Added toSentence method
+* Added slugify method
+* Lots of speed optimizations
+
+### 2.0.0 ###
+
+* Added prune, humanize functions
+* Added _.string (_.str) namespace for Underscore.string library
+* Removed includes function
+
+For upgrading to this version you need to mix in Underscore.string library to Underscore object:
+
+```javascript
+_.mixin(_.string.exports());
+```
+
+and all non-conflict Underscore.string functions will be available through Underscore object.
+Also function `includes` has been removed, you should replace this function by `_.str.include`
+or create alias `_.includes = _.str.include` and all your code will work fine.
+
+### 1.1.6 ###
+
+* Fixed reverse and truncate
+* Added isBlank, stripTags, inlude(alias for includes)
+* Added uglifier compression
+
+### 1.1.5 ###
+
+* Added strRight, strRightBack, strLeft, strLeftBack
+
+### 1.1.4 ###
+
+* Added pad, lpad, rpad, lrpad methods and aliases center, ljust, rjust
+* Integration with Underscore 1.1.6
+
+### 1.1.3 ###
+
+* Added methods: underscored, camelize, dasherize
+* Support newer version of npm
+
+### 1.1.2 ###
+
+* Created functions: lines, chars, words functions
+
+### 1.0.2 ###
+
+* Created integration test suite with underscore.js 1.1.4 (now it's absolutely compatible)
+* Removed 'reverse' function, because this function override underscore.js 'reverse'
+
+## Contribute ##
+
+* Fork & pull request. Don't forget about tests.
+* If you planning add some feature please create issue before.
+
+Otherwise changes will be rejected.
+
+## Contributors list ##
+[Can be found here](https://github.com/epeli/underscore.string/graphs/contributors).
+
+
+## Licence ##
+
+The MIT License
+
+Copyright (c) 2011 Esa-Matti Suuronen esa-matti@suuronen.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/Rakefile b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/Rakefile
new file mode 100644
index 00000000..587c81b7
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/Rakefile
@@ -0,0 +1,23 @@
+# encoding: utf-8
+task default: :test
+
+desc 'Use UglifyJS to compress Underscore.string'
+task :build do
+ require 'uglifier'
+ source = File.read('lib/underscore.string.js')
+ compressed = Uglifier.compile(source, copyright: false)
+ File.open('dist/underscore.string.min.js', 'w'){ |f| f.write compressed }
+ compression_rate = compressed.length.to_f/source.length
+ puts "compressed dist/underscore.string.min.js: #{compressed.length}/#{source.length} #{(compression_rate * 100).round}%"
+end
+
+desc 'Run tests'
+task :test do
+ puts "Running underscore.string test suite."
+ result1 = system %{phantomjs ./test/run-qunit.js "test/test.html"}
+
+ puts "Running Underscore test suite."
+ result2 = system %{phantomjs ./test/run-qunit.js "test/test_underscore/index.html"}
+
+ exit(result1 && result2 ? 0 : 1)
+end
\ No newline at end of file
diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/package.json b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/package.json
new file mode 100644
index 00000000..51f52829
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/package.json
@@ -0,0 +1,77 @@
+{
+ "name": "underscore.string",
+ "version": "2.3.1",
+ "description": "String manipulation extensions for Underscore.js javascript library.",
+ "homepage": "http://epeli.github.com/underscore.string/",
+ "contributors": [
+ {
+ "name": "Esa-Matti Suuronen",
+ "email": "esa-matti@suuronen.org",
+ "url": "http://esa-matti.suuronen.org/"
+ },
+ {
+ "name": "Edward Tsech",
+ "email": "edtsech@gmail.com"
+ },
+ {
+ "name": "Pavel Pravosud",
+ "email": "pavel@pravosud.com",
+ "url": "Blah blah blah
').escapeHTML();\n=> '<div>Blah blah blah</div>'\n```\n\n**unescapeHTML** _.unescapeHTML(string)\n\nConverts entity characters to HTML equivalents.\n\n```javascript\n_('<div>Blah blah blah</div>').unescapeHTML();\n=> 'Blah blah blah
'\n```\n\n**insert** _.insert(string, index, substing)\n\n```javascript\n_('Hello ').insert(6, 'world')\n=> 'Hello world'\n```\n\n**isBlank** _.isBlank(string)\n\n```javascript\n_('').isBlank(); // => true\n_('\\n').isBlank(); // => true\n_(' ').isBlank(); // => true\n_('a').isBlank(); // => false\n```\n\n**join** _.join(separator, *strings)\n\nJoins strings together with given separator\n\n```javascript\n_.join(\" \", \"foo\", \"bar\")\n=> \"foo bar\"\n```\n\n**lines** _.lines(str)\n\n```javascript\n_.lines(\"Hello\\nWorld\")\n=> [\"Hello\", \"World\"]\n```\n\n**reverse** available only through _.str object, because Underscore has function with the same name.\n\nReturn reversed string:\n\n```javascript\n_.str.reverse(\"foobar\")\n=> 'raboof'\n```\n\n**splice** _.splice(string, index, howmany, substring)\n\nLike a array splice.\n\n```javascript\n_('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli')\n=> 'https://edtsech@bitbucket.org/epeli/underscore.strings'\n```\n\n**startsWith** _.startsWith(string, starts)\n\nThis method checks whether string starts with starts.\n\n```javascript\n_(\"image.gif\").startsWith(\"image\")\n=> true\n```\n\n**endsWith** _.endsWith(string, ends)\n\nThis method checks whether string ends with ends.\n\n```javascript\n_(\"image.gif\").endsWith(\"gif\")\n=> true\n```\n\n**succ** _.succ(str)\n\nReturns the successor to str.\n\n```javascript\n_('a').succ()\n=> 'b'\n\n_('A').succ()\n=> 'B'\n```\n\n**supplant**\n\nSupplant function was removed, use Underscore.js [template function][p].\n\n[p]: http://documentcloud.github.com/underscore/#template\n\n**strip** alias for *trim*\n\n**lstrip** alias for *ltrim*\n\n**rstrip** alias for *rtrim*\n\n**titleize** _.titleize(string)\n\n```javascript\n_('my name is epeli').titleize()\n=> 'My Name Is Epeli'\n```\n\n**camelize** _.camelize(string)\n\nConverts underscored or dasherized string to a camelized one\n\n```javascript\n_('-moz-transform').camelize()\n=> 'MozTransform'\n```\n\n**classify** _.classify(string)\n\nConverts string to camelized class name\n\n```javascript\n_('some_class_name').classify()\n=> 'SomeClassName'\n```\n\n**underscored** _.underscored(string)\n\nConverts a camelized or dasherized string into an underscored one\n\n```javascript\n_('MozTransform').underscored()\n=> 'moz_transform'\n```\n\n**dasherize** _.dasherize(string)\n\nConverts a underscored or camelized string into an dasherized one\n\n```javascript\n_('MozTransform').dasherize()\n=> '-moz-transform'\n```\n\n**humanize** _.humanize(string)\n\nConverts an underscored, camelized, or dasherized string into a humanized one.\nAlso removes beginning and ending whitespace, and removes the postfix '_id'.\n\n```javascript\n_(' capitalize dash-CamelCase_underscore trim ').humanize()\n=> 'Capitalize dash camel case underscore trim'\n```\n\n**trim** _.trim(string, [characters])\n\ntrims defined characters from begining and ending of the string.\nDefaults to whitespace characters.\n\n```javascript\n_.trim(\" foobar \")\n=> \"foobar\"\n\n_.trim(\"_-foobar-_\", \"_-\")\n=> \"foobar\"\n```\n\n\n**ltrim** _.ltrim(string, [characters])\n\nLeft trim. Similar to trim, but only for left side.\n\n\n**rtrim** _.rtrim(string, [characters])\n\nRight trim. Similar to trim, but only for right side.\n\n**truncate** _.truncate(string, length, truncateString)\n\n```javascript\n_('Hello world').truncate(5)\n=> 'Hello...'\n\n_('Hello').truncate(10)\n=> 'Hello'\n```\n\n**prune** _.prune(string, length, pruneString)\n\nElegant version of truncate.\nMakes sure the pruned string does not exceed the original length.\nAvoid half-chopped words when truncating.\n\n```javascript\n_('Hello, world').prune(5)\n=> 'Hello...'\n\n_('Hello, world').prune(8)\n=> 'Hello...'\n\n_('Hello, world').prune(5, ' (read a lot more)')\n=> 'Hello, world' (as adding \"(read a lot more)\" would be longer than the original string)\n\n_('Hello, cruel world').prune(15)\n=> 'Hello, cruel...'\n\n_('Hello').prune(10)\n=> 'Hello'\n```\n\n**words** _.words(str, delimiter=/\\s+/)\n\nSplit string by delimiter (String or RegExp), /\\s+/ by default.\n\n```javascript\n_.words(\" I love you \")\n=> [\"I\",\"love\",\"you\"]\n\n_.words(\"I_love_you\", \"_\")\n=> [\"I\",\"love\",\"you\"]\n\n_.words(\"I-love-you\", /-/)\n=> [\"I\",\"love\",\"you\"]\n\n_.words(\" \")\n=> []\n```\n\n**sprintf** _.sprintf(string format, *arguments)\n\nC like string formatting.\nCredits goes to [Alexandru Marasteanu][o].\nFor more detailed documentation, see the [original page][o].\n\n[o]: http://www.diveintojavascript.com/projects/sprintf-for-javascript\n\n```javascript\n_.sprintf(\"%.1f\", 1.17)\n\"1.2\"\n```\n\n**pad** _.pad(str, length, [padStr, type])\n\npads the `str` with characters until the total string length is equal to the passed `length` parameter. By default, pads on the **left** with the space char (`\" \"`). `padStr` is truncated to a single character if necessary.\n\n```javascript\n_.pad(\"1\", 8)\n-> \" 1\";\n\n_.pad(\"1\", 8, '0')\n-> \"00000001\";\n\n_.pad(\"1\", 8, '0', 'right')\n-> \"10000000\";\n\n_.pad(\"1\", 8, '0', 'both')\n-> \"00001000\";\n\n_.pad(\"1\", 8, 'bleepblorp', 'both')\n-> \"bbbb1bbb\";\n```\n\n**lpad** _.lpad(str, length, [padStr])\n\nleft-pad a string. Alias for `pad(str, length, padStr, 'left')`\n\n```javascript\n_.lpad(\"1\", 8, '0')\n-> \"00000001\";\n```\n\n**rpad** _.rpad(str, length, [padStr])\n\nright-pad a string. Alias for `pad(str, length, padStr, 'right')`\n\n```javascript\n_.rpad(\"1\", 8, '0')\n-> \"10000000\";\n```\n\n**lrpad** _.lrpad(str, length, [padStr])\n\nleft/right-pad a string. Alias for `pad(str, length, padStr, 'both')`\n\n```javascript\n_.lrpad(\"1\", 8, '0')\n-> \"00001000\";\n```\n\n**center** alias for **lrpad**\n\n**ljust** alias for *rpad*\n\n**rjust** alias for *lpad*\n\n**toNumber** _.toNumber(string, [decimals])\n\nParse string to number. Returns NaN if string can't be parsed to number.\n\n```javascript\n_('2.556').toNumber()\n=> 3\n\n_('2.556').toNumber(1)\n=> 2.6\n```\n\n**strRight** _.strRight(string, pattern)\n\nSearches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.\n\n```javascript\n_('This_is_a_test_string').strRight('_')\n=> \"is_a_test_string\";\n```\n\n**strRightBack** _.strRightBack(string, pattern)\n\nSearches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.\n\n```javascript\n_('This_is_a_test_string').strRightBack('_')\n=> \"string\";\n```\n\n**strLeft** _.strLeft(string, pattern)\n\nSearches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.\n\n```javascript\n_('This_is_a_test_string').strLeft('_')\n=> \"This\";\n```\n\n**strLeftBack** _.strLeftBack(string, pattern)\n\nSearches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.\n\n```javascript\n_('This_is_a_test_string').strLeftBack('_')\n=> \"This_is_a_test\";\n```\n\n**stripTags**\n\nRemoves all html tags from string.\n\n```javascript\n_('a link').stripTags()\n=> 'a link'\n\n_('a link').stripTags()\n=> 'a linkalert(\"hello world!\")'\n```\n\n**toSentence** _.toSentence(array, [delimiter, lastDelimiter])\n\nJoin an array into a human readable sentence.\n\n```javascript\n_.toSentence(['jQuery', 'Mootools', 'Prototype'])\n=> 'jQuery, Mootools and Prototype';\n\n_.toSentence(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ')\n=> 'jQuery, Mootools unt Prototype';\n```\n\n**toSentenceSerial** _.toSentenceSerial(array, [delimiter, lastDelimiter])\n\nThe same as `toSentence`, but adjusts delimeters to use [Serial comma](http://en.wikipedia.org/wiki/Serial_comma).\n\n```javascript\n_.toSentenceSerial(['jQuery', 'Mootools'])\n=> 'jQuery and Mootools';\n\n_.toSentenceSerial(['jQuery', 'Mootools', 'Prototype'])\n=> 'jQuery, Mootools, and Prototype'\n\n_.toSentenceSerial(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ');\n=> 'jQuery, Mootools, unt Prototype';\n```\n\n**repeat** _.repeat(string, count, [separator])\n\nRepeats a string count times.\n\n```javascript\n_.repeat(\"foo\", 3)\n=> 'foofoofoo';\n\n_.repeat(\"foo\", 3, \"bar\")\n=> 'foobarfoobarfoo'\n```\n\n**surround** _.surround(string, wrap)\n\nSurround a string with another string.\n\n```javascript\n_.surround(\"foo\", \"ab\")\n=> 'abfooab';\n```\n\n**quote** _.quote(string) or _.q(string)\n\nQuotes a string.\n\n```javascript\n_.quote('foo')\n=> '\"foo\"';\n```\n\n\n**slugify** _.slugify(string)\n\nTransform text into a URL slug. Replaces whitespaces, accentuated, and special characters with a dash.\n\n```javascript\n_.slugify(\"Un éléphant à l'orée du bois\")\n=> 'un-elephant-a-loree-du-bois';\n```\n\n***Caution: this function is charset dependent***\n\n## Roadmap ##\n\nAny suggestions or bug reports are welcome. Just email me or more preferably open an issue.\n\n#### Problems\n\nWe lose two things for `include` and `reverse` methods from `_.string`:\n\n* Calls like `_('foobar').include('bar')` aren't available;\n* Chaining isn't available too.\n\nBut if you need this functionality you can create aliases for conflict functions which will be convenient for you:\n\n```javascript\n_.mixin({\n includeString: _.str.include,\n reverseString: _.str.reverse\n})\n\n// Now wrapper calls and chaining are available.\n_('foobar').chain().reverseString().includeString('rab').value()\n```\n\n#### Standalone Usage\n\nIf you are using Underscore.string without Underscore. You also have `_.string` namespace for it and `_.str` alias\nBut of course you can just reassign `_` variable with `_.string`\n\n```javascript\n_ = _.string\n```\n\n## Changelog ##\n\n### 2.3.1 ###\n\n* Changed integration logic, now trying everything in order\n* Fixed classify method to chew some unexpected input\n* Fixed toNumber method failing to recognize '0.0' as a proper number\n\n\n### 2.3.0 ###\n\n* Added `numberformat` method\n* Added `levenshtein` method (Levenshtein distance calculation)\n* Added `swapCase` method\n* Changed default behavior of `words` method\n* Added `toSentenceSerial` method\n* Added `surround` and `quote` methods\n\n### 2.2.0 ###\n\n* Capitalize method behavior changed\n* Various perfomance tweaks\n\n### 2.1.1###\n\n* Fixed words method bug\n* Added classify method\n\n### 2.1.0 ###\n\n* AMD support\n* Added toSentence method\n* Added slugify method\n* Lots of speed optimizations\n\n### 2.0.0 ###\n\n* Added prune, humanize functions\n* Added _.string (_.str) namespace for Underscore.string library\n* Removed includes function\n\nFor upgrading to this version you need to mix in Underscore.string library to Underscore object:\n\n```javascript\n_.mixin(_.string.exports());\n```\n\nand all non-conflict Underscore.string functions will be available through Underscore object.\nAlso function `includes` has been removed, you should replace this function by `_.str.include`\nor create alias `_.includes = _.str.include` and all your code will work fine.\n\n### 1.1.6 ###\n\n* Fixed reverse and truncate\n* Added isBlank, stripTags, inlude(alias for includes)\n* Added uglifier compression\n\n### 1.1.5 ###\n\n* Added strRight, strRightBack, strLeft, strLeftBack\n\n### 1.1.4 ###\n\n* Added pad, lpad, rpad, lrpad methods and aliases center, ljust, rjust\n* Integration with Underscore 1.1.6\n\n### 1.1.3 ###\n\n* Added methods: underscored, camelize, dasherize\n* Support newer version of npm\n\n### 1.1.2 ###\n\n* Created functions: lines, chars, words functions\n\n### 1.0.2 ###\n\n* Created integration test suite with underscore.js 1.1.4 (now it's absolutely compatible)\n* Removed 'reverse' function, because this function override underscore.js 'reverse'\n\n## Contribute ##\n\n* Fork & pull request. Don't forget about tests.\n* If you planning add some feature please create issue before.\n\nOtherwise changes will be rejected.\n\n## Contributors list ##\n[Can be found here](https://github.com/epeli/underscore.string/graphs/contributors).\n\n\n## Licence ##\n\nThe MIT License\n\nCopyright (c) 2011 Esa-Matti Suuronen esa-matti@suuronen.org\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n",
+ "readmeFilename": "README.markdown",
+ "_id": "underscore.string@2.3.1",
+ "dist": {
+ "shasum": "deb7588dfa2f252ee47e4516edafbef4ff97ec22"
+ },
+ "_from": "underscore.string@~2.3.1",
+ "_resolved": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.3.1.tgz"
+}
diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/test/test.html b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/test/test.html
new file mode 100644
index 00000000..c959a3a3
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/test/test.html
@@ -0,0 +1,31 @@
+
+
+
+
+ Underscore.string Test Suite
+ + ++
Underscore.string Speed Suite
+ ++ + diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/test/test_standalone.html b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/test/test_standalone.html new file mode 100644 index 00000000..9854c171 --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/test/test_standalone.html @@ -0,0 +1,18 @@ + + + +
Underscore.string Test Suite
+ + +
+
+
+
+
+
+ +
Underscore Speed Suite
+
+ A representative sample of the functions are benchmarked here, to provide
+ a sense of how fast they might run in different browsers.
+ Each iteration runs on an array of 1000 elements.
+ For example, the 'intersection' test measures the number of times you can
+ find the intersection of two thousand-element arrays in one second.
+
+ + + diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/test/test_underscore/vendor/qunit.css b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/test/test_underscore/vendor/qunit.css new file mode 100644 index 00000000..55970e00 --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore.string/test/test_underscore/vendor/qunit.css @@ -0,0 +1,235 @@ +/** + * QUnit v1.10.0 - A JavaScript Unit Testing Framework + * + * http://qunitjs.com + * + * Copyright 2012 jQuery Foundation and other contributors + * Released under the MIT license. + * http://jquery.org/license + */ + +/** Font Family and Sizes */ + +#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult { + font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif; +} + +#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; } +#qunit-tests { font-size: smaller; } + + +/** Resets */ + +#qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter { + margin: 0; + padding: 0; +} + + +/** Header */ + +#qunit-header { + padding: 0.5em 0 0.5em 1em; + + color: #8699a4; + background-color: #0d3349; + + font-size: 1.5em; + line-height: 1em; + font-weight: normal; + + border-radius: 5px 5px 0 0; + -moz-border-radius: 5px 5px 0 0; + -webkit-border-top-right-radius: 5px; + -webkit-border-top-left-radius: 5px; +} + +#qunit-header a { + text-decoration: none; + color: #c2ccd1; +} + +#qunit-header a:hover, +#qunit-header a:focus { + color: #fff; +} + +#qunit-testrunner-toolbar label { + display: inline-block; + padding: 0 .5em 0 .1em; +} + +#qunit-banner { + height: 5px; +} + +#qunit-testrunner-toolbar { + padding: 0.5em 0 0.5em 2em; + color: #5E740B; + background-color: #eee; + overflow: hidden; +} + +#qunit-userAgent { + padding: 0.5em 0 0.5em 2.5em; + background-color: #2b81af; + color: #fff; + text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px; +} + +#qunit-modulefilter-container { + float: right; +} + +/** Tests: Pass/Fail */ + +#qunit-tests { + list-style-position: inside; +} + +#qunit-tests li { + padding: 0.4em 0.5em 0.4em 2.5em; + border-bottom: 1px solid #fff; + list-style-position: inside; +} + +#qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running { + display: none; +} + +#qunit-tests li strong { + cursor: pointer; +} + +#qunit-tests li a { + padding: 0.5em; + color: #c2ccd1; + text-decoration: none; +} +#qunit-tests li a:hover, +#qunit-tests li a:focus { + color: #000; +} + +#qunit-tests ol { + margin-top: 0.5em; + padding: 0.5em; + + background-color: #fff; + + border-radius: 5px; + -moz-border-radius: 5px; + -webkit-border-radius: 5px; +} + +#qunit-tests table { + border-collapse: collapse; + margin-top: .2em; +} + +#qunit-tests th { + text-align: right; + vertical-align: top; + padding: 0 .5em 0 0; +} + +#qunit-tests td { + vertical-align: top; +} + +#qunit-tests pre { + margin: 0; + white-space: pre-wrap; + word-wrap: break-word; +} + +#qunit-tests del { + background-color: #e0f2be; + color: #374e0c; + text-decoration: none; +} + +#qunit-tests ins { + background-color: #ffcaca; + color: #500; + text-decoration: none; +} + +/*** Test Counts */ + +#qunit-tests b.counts { color: black; } +#qunit-tests b.passed { color: #5E740B; } +#qunit-tests b.failed { color: #710909; } + +#qunit-tests li li { + padding: 5px; + background-color: #fff; + border-bottom: none; + list-style-position: inside; +} + +/*** Passing Styles */ + +#qunit-tests li li.pass { + color: #3c510c; + background-color: #fff; + border-left: 10px solid #C6E746; +} + +#qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; } +#qunit-tests .pass .test-name { color: #366097; } + +#qunit-tests .pass .test-actual, +#qunit-tests .pass .test-expected { color: #999999; } + +#qunit-banner.qunit-pass { background-color: #C6E746; } + +/*** Failing Styles */ + +#qunit-tests li li.fail { + color: #710909; + background-color: #fff; + border-left: 10px solid #EE5757; + white-space: pre; +} + +#qunit-tests > li:last-child { + border-radius: 0 0 5px 5px; + -moz-border-radius: 0 0 5px 5px; + -webkit-border-bottom-right-radius: 5px; + -webkit-border-bottom-left-radius: 5px; +} + +#qunit-tests .fail { color: #000000; background-color: #EE5757; } +#qunit-tests .fail .test-name, +#qunit-tests .fail .module-name { color: #000000; } + +#qunit-tests .fail .test-actual { color: #EE5757; } +#qunit-tests .fail .test-expected { color: green; } + +#qunit-banner.qunit-fail { background-color: #EE5757; } + + +/** Result */ + +#qunit-testresult { + padding: 0.5em 0.5em 0.5em 2.5em; + + color: #2b81af; + background-color: #D2E0E6; + + border-bottom: 1px solid white; +} +#qunit-testresult .module-name { + font-weight: bold; +} + +/** Fixture */ + +#qunit-fixture { + position: absolute; + top: -10000px; + left: -10000px; + width: 1000px; + height: 1000px; +} diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/.npmignore b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/.npmignore new file mode 100644 index 00000000..4e5886de --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/.npmignore @@ -0,0 +1,4 @@ +test/ +Rakefile +docs/ +raw/ diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/.travis.yml b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/.travis.yml new file mode 100644 index 00000000..99dc7712 --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/.travis.yml @@ -0,0 +1,5 @@ +language: node_js +node_js: + - 0.8 +notifications: + email: false diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/CNAME b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/CNAME new file mode 100644 index 00000000..a007e65c --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/CNAME @@ -0,0 +1 @@ +underscorejs.org diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/CONTRIBUTING.md b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/CONTRIBUTING.md new file mode 100644 index 00000000..de5d5626 --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/CONTRIBUTING.md @@ -0,0 +1,9 @@ +## How to contribute to Underscore.js + +* Before you open a ticket or send a pull request, [search](https://github.com/documentcloud/underscore/issues) for previous discussions about the same feature or issue. Add to the earlier ticket if you find one. + +* Before sending a pull request for a feature, be sure to have [tests](http://underscorejs.org/test/). + +* Use the same coding style as the rest of the [codebase](https://github.com/documentcloud/underscore/blob/master/underscore.js). + +* In your pull request, do not add documentation or re-build the minified `underscore-min.js` file. We'll do those things before cutting a new release. diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/LICENSE b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/LICENSE new file mode 100644 index 00000000..0d8dbe40 --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/LICENSE @@ -0,0 +1,22 @@ +Copyright (c) 2009-2013 Jeremy Ashkenas, DocumentCloud + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/README.md b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/README.md new file mode 100644 index 00000000..b1f3e50a --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/README.md @@ -0,0 +1,19 @@ + __ + /\ \ __ + __ __ ___ \_\ \ __ _ __ ____ ___ ___ _ __ __ /\_\ ____ + /\ \/\ \ /' _ `\ /'_ \ /'__`\/\ __\/ ,__\ / ___\ / __`\/\ __\/'__`\ \/\ \ /',__\ + \ \ \_\ \/\ \/\ \/\ \ \ \/\ __/\ \ \//\__, `\/\ \__//\ \ \ \ \ \//\ __/ __ \ \ \/\__, `\ + \ \____/\ \_\ \_\ \___,_\ \____\\ \_\\/\____/\ \____\ \____/\ \_\\ \____\/\_\ _\ \ \/\____/ + \/___/ \/_/\/_/\/__,_ /\/____/ \/_/ \/___/ \/____/\/___/ \/_/ \/____/\/_//\ \_\ \/___/ + \ \____/ + \/___/ + +Underscore.js is a utility-belt library for JavaScript that provides +support for the usual functional suspects (each, map, reduce, filter...) +without extending any core JavaScript objects. + +For Docs, License, Tests, and pre-packed downloads, see: +http://underscorejs.org + +Many thanks to our contributors: +https://github.com/documentcloud/underscore/contributors diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/favicon.ico b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/favicon.ico new file mode 100644 index 00000000..03049683 Binary files /dev/null and b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/favicon.ico differ diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/index.html b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/index.html new file mode 100644 index 00000000..8c5793ab --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/index.html @@ -0,0 +1,2467 @@ + + + + + + + + +
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/package.json b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/package.json
new file mode 100644
index 00000000..8d6d7955
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/node_modules/underscore/package.json
@@ -0,0 +1,36 @@
+{
+ "name": "underscore",
+ "description": "JavaScript's functional programming helper library.",
+ "homepage": "http://underscorejs.org",
+ "keywords": [
+ "util",
+ "functional",
+ "server",
+ "client",
+ "browser"
+ ],
+ "author": {
+ "name": "Jeremy Ashkenas",
+ "email": "jeremy@documentcloud.org"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/documentcloud/underscore.git"
+ },
+ "main": "underscore.js",
+ "version": "1.4.4",
+ "devDependencies": {
+ "phantomjs": "0.2.2"
+ },
+ "scripts": {
+ "test": "phantomjs test/vendor/runner.js test/index.html?noglobals=true"
+ },
+ "readme": " __\n /\\ \\ __\n __ __ ___ \\_\\ \\ __ _ __ ____ ___ ___ _ __ __ /\\_\\ ____\n /\\ \\/\\ \\ /' _ `\\ /'_ \\ /'__`\\/\\ __\\/ ,__\\ / ___\\ / __`\\/\\ __\\/'__`\\ \\/\\ \\ /',__\\\n \\ \\ \\_\\ \\/\\ \\/\\ \\/\\ \\ \\ \\/\\ __/\\ \\ \\//\\__, `\\/\\ \\__//\\ \\ \\ \\ \\ \\//\\ __/ __ \\ \\ \\/\\__, `\\\n \\ \\____/\\ \\_\\ \\_\\ \\___,_\\ \\____\\\\ \\_\\\\/\\____/\\ \\____\\ \\____/\\ \\_\\\\ \\____\\/\\_\\ _\\ \\ \\/\\____/\n \\/___/ \\/_/\\/_/\\/__,_ /\\/____/ \\/_/ \\/___/ \\/____/\\/___/ \\/_/ \\/____/\\/_//\\ \\_\\ \\/___/\n \\ \\____/\n \\/___/\n\nUnderscore.js is a utility-belt library for JavaScript that provides\nsupport for the usual functional suspects (each, map, reduce, filter...)\nwithout extending any core JavaScript objects.\n\nFor Docs, License, Tests, and pre-packed downloads, see:\nhttp://underscorejs.org\n\nMany thanks to our contributors:\nhttps://github.com/documentcloud/underscore/contributors\n",
+ "readmeFilename": "README.md",
+ "_id": "underscore@1.4.4",
+ "dist": {
+ "shasum": "401fc6bfa46b28a658d6e3ad7593aa91b0123f14"
+ },
+ "_from": "underscore@~1.4.3",
+ "_resolved": "https://registry.npmjs.org/underscore/-/underscore-1.4.4.tgz"
+}
diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/package.json b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/package.json
new file mode 100644
index 00000000..b25fe8fc
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/js-yaml/node_modules/argparse/package.json
@@ -0,0 +1,54 @@
+{
+ "name": "argparse",
+ "description": "Very powerful CLI arguments parser. Native port of argparse - python's options parsing library",
+ "version": "0.1.13",
+ "keywords": [
+ "cli",
+ "parser",
+ "argparse",
+ "option",
+ "args"
+ ],
+ "homepage": "https://github.com/nodeca/argparse",
+ "contributors": [
+ {
+ "name": "Eugene Shkuropat"
+ },
+ {
+ "name": "Paul Jacobson"
+ }
+ ],
+ "bugs": {
+ "url": "https://github.com/nodeca/argparse/issues"
+ },
+ "license": {
+ "type": "MIT",
+ "url": "https://github.com/nodeca/argparse/blob/master/LICENSE"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/nodeca/argparse.git"
+ },
+ "main": "./index.js",
+ "scripts": {
+ "test": "make test"
+ },
+ "dependencies": {
+ "underscore": "~1.4.3",
+ "underscore.string": "~2.3.1"
+ },
+ "devDependencies": {
+ "mocha": "*"
+ },
+ "engines": {
+ "node": ">= 0.6.0"
+ },
+ "readme": "argparse\n========\n\n[](http://travis-ci.org/nodeca/argparse)\n\nCLI arguments parser for node.js. Javascript port of python's\n[argparse](http://docs.python.org/dev/library/argparse.html) module\n(original version 3.2). That's a full port, except some very rare options,\nrecorded in issue tracker.\n\n**NB.** Method names changed to camelCase. See [generated docs](http://nodeca.github.com/argparse/).\n\n\nExample\n=======\n\ntest.js file:\n\n```javascript\n#!/usr/bin/env node\n'use strict';\n\nvar ArgumentParser = require('../lib/argparse').ArgumentParser;\nvar parser = new ArgumentParser({\n version: '0.0.1',\n addHelp:true,\n description: 'Argparse example'\n});\nparser.addArgument(\n [ '-f', '--foo' ],\n {\n help: 'foo bar'\n }\n);\nparser.addArgument(\n [ '-b', '--bar' ],\n {\n help: 'bar foo'\n }\n);\nvar args = parser.parseArgs();\nconsole.dir(args);\n```\n\nDisplay help:\n\n```\n$ ./test.js -h\nusage: example.js [-h] [-v] [-f FOO] [-b BAR]\n\nArgparse example\n\nOptional arguments:\n -h, --help Show this help message and exit.\n -v, --version Show program's version number and exit.\n -f FOO, --foo FOO foo bar\n -b BAR, --bar BAR bar foo\n```\n\nParse arguments:\n\n```\n$ ./test.js -f=3 --bar=4\n{ foo: '3', bar: '4' }\n```\n\nMore [examples](https://github.com/nodeca/argparse/tree/master/examples).\n\n\nArgumentParser objects\n======================\n\n```\nnew ArgumentParser({paramters hash});\n```\n\nCreates a new ArgumentParser object.\n\n**Supported params:**\n\n- ```description``` - Text to display before the argument help.\n- ```epilog``` - Text to display after the argument help.\n- ```addHelp``` - Add a -h/–help option to the parser. (default: True)\n- ```argumentDefault``` - Set the global default value for arguments. (default: None)\n- ```parents``` - A list of ArgumentParser objects whose arguments should also be included.\n- ```prefixChars``` - The set of characters that prefix optional arguments. (default: ‘-‘)\n- ```formatterClass``` - A class for customizing the help output.\n- ```prog``` - The name of the program (default: sys.argv[0])\n- ```usage``` - The string describing the program usage (default: generated)\n- ```conflictHandler``` - Usually unnecessary, defines strategy for resolving conflicting optionals.\n\n**Not supportied yet**\n\n- ```fromfilePrefixChars``` - The set of characters that prefix files from which additional arguments should be read.\n\n\nDetails in [original ArgumentParser guide](http://docs.python.org/dev/library/argparse.html#argumentparser-objects)\n\n\naddArgument() method\n====================\n\n```\nArgumentParser.addArgument([names or flags], {options})\n```\n\nDefines how a single command-line argument should be parsed.\n\n- ```name or flags``` - Either a name or a list of option strings, e.g. foo or -f, --foo.\n\nOptions:\n\n- ```action``` - The basic type of action to be taken when this argument is encountered at the command line.\n- ```nargs```- The number of command-line arguments that should be consumed.\n- ```constant``` - A constant value required by some action and nargs selections.\n- ```defaultValue``` - The value produced if the argument is absent from the command line.\n- ```type``` - The type to which the command-line argument should be converted.\n- ```choices``` - A container of the allowable values for the argument.\n- ```required``` - Whether or not the command-line option may be omitted (optionals only).\n- ```help``` - A brief description of what the argument does.\n- ```metavar``` - A name for the argument in usage messages.\n- ```dest``` - The name of the attribute to be added to the object returned by parseArgs().\n\nDetails in [original add_argument guide](http://docs.python.org/dev/library/argparse.html#the-add-argument-method)\n\n\nAction (some details)\n================\n\nArgumentParser objects associate command-line arguments with actions.\nThese actions can do just about anything with the command-line arguments associated\nwith them, though most actions simply add an attribute to the object returned by\nparseArgs(). The action keyword argument specifies how the command-line arguments\nshould be handled. The supported actions are:\n\n- ```store``` - Just stores the argument’s value. This is the default action.\n- ```storeConst``` - Stores value, specified by the const keyword argument.\n (Note that the const keyword argument defaults to the rather unhelpful None.)\n The 'storeConst' action is most commonly used with optional arguments, that\n specify some sort of flag.\n- ```storeTrue``` and ```storeFalse``` - Stores values True and False\n respectively. These are special cases of 'storeConst'.\n- ```append``` - Stores a list, and appends each argument value to the list.\n This is useful to allow an option to be specified multiple times.\n- ```appendConst``` - Stores a list, and appends value, specified by the\n const keyword argument to the list. (Note, that the const keyword argument defaults\n is None.) The 'appendConst' action is typically used when multiple arguments need\n to store constants to the same list.\n- ```count``` - Counts the number of times a keyword argument occurs. For example,\n used for increasing verbosity levels.\n- ```help``` - Prints a complete help message for all the options in the current\n parser and then exits. By default a help action is automatically added to the parser.\n See ArgumentParser for details of how the output is created.\n- ```version``` - Prints version information and exit. Expects a `version=`\n keyword argument in the addArgument() call.\n\nDetails in [original action guide](http://docs.python.org/dev/library/argparse.html#action)\n\n\nSub-commands\n============\n\nArgumentParser.addSubparsers()\n\nMany programs split their functionality into a number of sub-commands, for\nexample, the svn program can invoke sub-commands like `svn checkout`, `svn update`,\nand `svn commit`. Splitting up functionality this way can be a particularly good\nidea when a program performs several different functions which require different\nkinds of command-line arguments. `ArgumentParser` supports creation of such\nsub-commands with `addSubparsers()` method. The `addSubparsers()` method is\nnormally called with no arguments and returns an special action object.\nThis object has a single method `addParser()`, which takes a command name and\nany `ArgumentParser` constructor arguments, and returns an `ArgumentParser` object\nthat can be modified as usual.\n\nExample:\n\nsub_commands.js\n```javascript\n#!/usr/bin/env node\n'use strict';\n\nvar ArgumentParser = require('../lib/argparse').ArgumentParser;\nvar parser = new ArgumentParser({\n version: '0.0.1',\n addHelp:true,\n description: 'Argparse examples: sub-commands',\n});\n\nvar subparsers = parser.addSubparsers({\n title:'subcommands',\n dest:\"subcommand_name\"\n});\n\nvar bar = subparsers.addParser('c1', {addHelp:true});\nbar.addArgument(\n [ '-f', '--foo' ],\n {\n action: 'store',\n help: 'foo3 bar3'\n }\n);\nvar bar = subparsers.addParser(\n 'c2',\n {aliases:['co'], addHelp:true}\n);\nbar.addArgument(\n [ '-b', '--bar' ],\n {\n action: 'store',\n type: 'int',\n help: 'foo3 bar3'\n }\n);\n\nvar args = parser.parseArgs();\nconsole.dir(args);\n\n```\n\nDetails in [original sub-commands guide](http://docs.python.org/dev/library/argparse.html#sub-commands)\n\n\nContributors\n============\n\n- [Eugene Shkuropat](https://github.com/shkuropat)\n- [Paul Jacobson](https://github.com/hpaulj)\n\n[others](https://github.com/nodeca/argparse/graphs/contributors)\n\nLicense\n=======\n\nCopyright (c) 2012 [Vitaly Puzrin](https://github.com/puzrin).\nReleased under the MIT license. See\n[LICENSE](https://github.com/nodeca/argparse/blob/master/LICENSE) for details.\n\n\n",
+ "readmeFilename": "README.md",
+ "_id": "argparse@0.1.13",
+ "dist": {
+ "shasum": "645c024a7b8ed80970450c2185c9864f79f8ada0"
+ },
+ "_from": "argparse@~ 0.1.11",
+ "_resolved": "https://registry.npmjs.org/argparse/-/argparse-0.1.13.tgz"
+}
diff --git a/Phaser/node_modules/grunt/node_modules/js-yaml/package.json b/Phaser/node_modules/grunt/node_modules/js-yaml/package.json
new file mode 100644
index 00000000..3343344c
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/js-yaml/package.json
@@ -0,0 +1,63 @@
+{
+ "name": "js-yaml",
+ "version": "2.0.4",
+ "description": "YAML 1.2 parser and serializer",
+ "keywords": [
+ "yaml",
+ "parser",
+ "serializer",
+ "pyyaml"
+ ],
+ "homepage": "https://github.com/nodeca/js-yaml",
+ "author": {
+ "name": "Dervus Grim",
+ "email": "dervus@lavabit.com"
+ },
+ "contributors": [
+ {
+ "name": "Aleksey V Zapparov",
+ "email": "ixti@member.fsf.org",
+ "url": "http://www.ixti.net/"
+ },
+ {
+ "name": "Martin Grenfell",
+ "email": "martin.grenfell@gmail.com",
+ "url": "http://got-ravings.blogspot.com"
+ }
+ ],
+ "bugs": {
+ "url": "https://github.com/nodeca/js-yaml/issues"
+ },
+ "license": {
+ "type": "MIT",
+ "url": "https://github.com/nodeca/js-yaml/blob/master/LICENSE"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/nodeca/js-yaml.git"
+ },
+ "main": "./index.js",
+ "bin": {
+ "js-yaml": "bin/js-yaml.js"
+ },
+ "scripts": {
+ "test": "make test"
+ },
+ "dependencies": {
+ "argparse": "~ 0.1.11"
+ },
+ "devDependencies": {
+ "mocha": "*"
+ },
+ "engines": {
+ "node": ">= 0.6.0"
+ },
+ "readme": "JS-YAML - YAML 1.2 parser and serializer for JavaScript\n=======================================================\n\n[](http://travis-ci.org/nodeca/js-yaml)\n\n[Online Demo](http://nodeca.github.com/js-yaml/)\n\n\nThis is an implementation of [YAML](http://yaml.org/), a human friendly data\nserialization language. Started as [PyYAML](http://pyyaml.org/) port, it was\ncompletely rewritten from scratch. Now it's very fast, and supports 1.2 spec.\n\n\nBreaking changes in 1.x.x -> 2.0.x\n----------------------------------\n\nIf your have not used __custom__ tags or loader classes - no changes needed. Just\nupgrade library and enjoy high parse speed.\n\nIn other case, you should rewrite your tag constructors and custom loader\nclasses, to conform new schema-based API. See\n[examples](https://github.com/nodeca/js-yaml/tree/master/examples) and\n[wiki](https://github.com/nodeca/js-yaml/wiki) for details.\nNote, that parser internals were completely rewritten.\n\n\nInstallation\n------------\n\n### YAML module for node.js\n\n```\nnpm install js-yaml\n```\n\n\n### CLI executable\n\nIf you want to inspect your YAML files from CLI, install js-yaml globally:\n\n```\nnpm install js-yaml -g\n```\n\n#### Usage\n\n```\nusage: js-yaml [-h] [-v] [-c] [-j] [-t] file\n\nPositional arguments:\n file File with YAML document(s)\n\nOptional arguments:\n -h, --help Show this help message and exit.\n -v, --version Show program's version number and exit.\n -c, --compact Display errors in compact mode\n -j, --to-json Output a non-funky boring JSON\n -t, --trace Show stack trace on error\n```\n\n\n### Bundled YAML library for browsers\n\n``` html\n\n\n```\n\nBrowser support was done mostly for online demo. If you find any errors - feel\nfree to send pull requests with fixes. Also note, that IE and other old browsers\nneeds [es5-shims](https://github.com/kriskowal/es5-shim) to operate.\n\n\nAPI\n---\n\nHere we cover the most 'useful' methods. If you need advanced details (creating\nyour own tags), see [wiki](https://github.com/nodeca/js-yaml/wiki) and\n[examples](https://github.com/nodeca/js-yaml/tree/master/examples) for more\ninfo.\n\nIn node.js JS-YAML automatically registers handlers for `.yml` and `.yaml`\nfiles. You can load them just with `require`. That's mostly equivalent to\ncalling `load()` on fetched content of a file. Just with one string!\n\n``` javascript\nrequire('js-yaml');\n\n// Get document, or throw exception on error\ntry {\n var doc = require('/home/ixti/example.yml');\n console.log(doc);\n} catch (e) {\n console.log(e);\n}\n```\n\n\n### load (string [ , options ])\n\nParses `string` as single YAML document. Returns a JavaScript object or throws\n`YAMLException` on error.\n\nNOTE: This function **does not** understands multi-document sources, it throws\nexception on those.\n\noptions:\n\n- `filename` _(default: null)_ - string to be used as a file path in\n error/warning messages.\n- `strict` _(default - false)_ makes the loader to throw errors instead of\n warnings.\n- `schema` _(default: `DEFAULT_SCHEMA`)_ - specifies a schema to use.\n\n\n### loadAll (string, iterator [ , options ])\n\nSame as `load()`, but understands multi-document sources and apply `iterator` to\neach document.\n\n``` javascript\nvar yaml = require('js-yaml');\n\nyaml.loadAll(data, function (doc) {\n console.log(doc);\n});\n```\n\n\n### safeLoad (string [ , options ])\n\nSame as `load()` but uses `SAFE_SCHEMA` by default - only recommended tags of\nYAML specification (no JavaScript-specific tags, e.g. `!!js/regexp`).\n\n\n### safeLoadAll (string, iterator [ , options ])\n\nSame as `loadAll()` but uses `SAFE_SCHEMA` by default - only recommended tags of\nYAML specification (no JavaScript-specific tags, e.g. `!!js/regexp`).\n\n\n### dump (object [ , options ])\n\nSerializes `object` as YAML document.\n\noptions:\n\n- `indent` _(default: 2)_ - indentation width to use (in spaces).\n- `flowLevel` (default: -1) - specifies level of nesting, when to switch from\n block to flow style for collections. -1 means block style everwhere\n- `styles` - \"tag\" => \"style\" map. Each tag may have own set of styles.\n- `schema` _(default: `DEFAULT_SCHEMA`)_ specifies a schema to use.\n\nstyles:\n\n``` none\n!!null\n \"canonical\" => \"~\"\n\n!!int\n \"binary\" => \"0b1\", \"0b101010\", \"0b1110001111010\"\n \"octal\" => \"01\", \"052\", \"016172\"\n \"decimal\" => \"1\", \"42\", \"7290\"\n \"hexadecimal\" => \"0x1\", \"0x2A\", \"0x1C7A\"\n\n!!null, !!bool, !!float\n \"lowercase\" => \"null\", \"true\", \"false\", \".nan\", '.inf'\n \"uppercase\" => \"NULL\", \"TRUE\", \"FALSE\", \".NAN\", '.INF'\n \"camelcase\" => \"Null\", \"True\", \"False\", \".NaN\", '.Inf'\n```\n\nBy default, !!int uses `decimal`, and !!null, !!bool, !!float use `lowercase`.\n\n\n### safeDump (object [ , options ])\n\nSame as `dump()` but uses `SAFE_SCHEMA` by default - only recommended tags of\nYAML specification (no JavaScript-specific tags, e.g. `!!js/regexp`).\n\n\nSupported YAML types\n--------------------\n\nThe list of standard YAML tags and corresponding JavaScipt types. See also\n[YAML tag discussion](http://pyyaml.org/wiki/YAMLTagDiscussion) and\n[YAML types repository](http://yaml.org/type/).\n\n```\n!!null '' # null\n!!bool 'yes' # bool\n!!int '3...' # number\n!!float '3.14...' # number\n!!binary '...base64...' # buffer\n!!timestamp 'YYYY-...' # date\n!!omap [ ... ] # array of key-value pairs\n!!pairs [ ... ] # array or array pairs\n!!set { ... } # array of objects with given keys and null values\n!!str '...' # string\n!!seq [ ... ] # array\n!!map { ... } # object\n```\n\n**JavaScript-specific tags**\n\n```\n!!js/regexp /pattern/gim # RegExp\n!!js/undefined '' # Undefined\n!!js/function 'function () {...}' # Function\n```\n\n\n\n\n## Caveats\n\nNote, that you use arrays or objects as key in JS-YAML. JS do not allows objects\nor array as keys, and stringifies (by calling .toString method) them at the\nmoment of adding them.\n\n``` yaml\n---\n? [ foo, bar ]\n: - baz\n? { foo: bar }\n: - baz\n - baz\n```\n\n``` javascript\n{ \"foo,bar\": [\"baz\"], \"[object Object]\": [\"baz\", \"baz\"] }\n```\n\nAlso, reading of properties on implicit block mapping keys is not supported yet.\nSo, the following YAML document cannot be loaded.\n\n``` yaml\n&anchor foo:\n foo: bar\n *anchor: duplicate key\n baz: bat\n *anchor: duplicate key\n```\n\n## License\n\nView the [LICENSE](https://github.com/nodeca/js-yaml/blob/master/LICENSE) file\n(MIT).\n",
+ "readmeFilename": "README.md",
+ "_id": "js-yaml@2.0.4",
+ "dist": {
+ "shasum": "791f932f9c2267b6038d84784d3b8760e0120329"
+ },
+ "_from": "js-yaml@~2.0.2",
+ "_resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-2.0.4.tgz"
+}
diff --git a/Phaser/node_modules/grunt/node_modules/lodash/LICENSE.txt b/Phaser/node_modules/grunt/node_modules/lodash/LICENSE.txt
new file mode 100644
index 00000000..b194ad1d
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/lodash/LICENSE.txt
@@ -0,0 +1,22 @@
+Copyright 2012 John-David Dalton
+ 
+
+ Underscore is a + utility-belt library for JavaScript that provides a lot of the + functional programming support that you would expect in + Prototype.js + (or Ruby), + but without extending any of the built-in JavaScript objects. It's the + tie to go along with jQuery's tux, + and Backbone.js's suspenders. +
+ ++ Underscore provides 80-odd functions that support both the usual + functional suspects: map, select, invoke — + as well as more specialized helpers: function binding, javascript + templating, deep equality testing, and so on. It delegates to built-in + functions, if present, so modern browsers will use the + native implementations of forEach, map, reduce, + filter, every, some and indexOf. +
+ ++ A complete Test & Benchmark Suite + is included for your perusal. +
+ ++ You may also read through the annotated source code. +
+ ++ The project is + hosted on GitHub. + You can report bugs and discuss features on the + issues page, + on Freenode in the #documentcloud channel, + or send tweets to @documentcloud. +
+ ++ Underscore is an open-source component of DocumentCloud. +
+ +Downloads (Right-click, and use "Save As")
+ +| Development Version (1.4.4) | +40kb, Uncompressed with Plentiful Comments | +
| Production Version (1.4.4) | +4kb, Minified and Gzipped | +
| + | |
| Edge Version | +Unreleased, current master, use at your own risk | +
+
+
+
+ Collection Functions (Arrays or Objects)
+ +
+ each_.each(list, iterator, [context])
+ Alias: forEach
+
+ Iterates over a list of elements, yielding each in turn to an iterator
+ function. The iterator is bound to the context object, if one is
+ passed. Each invocation of iterator is called with three arguments:
+ (element, index, list). If list is a JavaScript object, iterator's
+ arguments will be (value, key, list). Delegates to the native
+ forEach function if it exists.
+
+_.each([1, 2, 3], alert);
+=> alerts each number in turn...
+_.each({one : 1, two : 2, three : 3}, alert);
+=> alerts each number value in turn...
+
+
+ map_.map(list, iterator, [context])
+ Alias: collect
+
+ Produces a new array of values by mapping each value in list
+ through a transformation function (iterator). If the native map method
+ exists, it will be used instead. If list is a JavaScript object,
+ iterator's arguments will be (value, key, list).
+
+_.map([1, 2, 3], function(num){ return num * 3; });
+=> [3, 6, 9]
+_.map({one : 1, two : 2, three : 3}, function(num, key){ return num * 3; });
+=> [3, 6, 9]
+
+
+ reduce_.reduce(list, iterator, memo, [context])
+ Aliases: inject, foldl
+
+ Also known as inject and foldl, reduce boils down a
+ list of values into a single value. Memo is the initial state
+ of the reduction, and each successive step of it should be returned by
+ iterator. The iterator is passed four arguments: the memo,
+ then the value and index (or key) of the iteration,
+ and finally a reference to the entire list.
+
+var sum = _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0);
+=> 6
+
+
+
+ reduceRight_.reduceRight(list, iterator, memo, [context])
+ Alias: foldr
+
+ The right-associative version of reduce. Delegates to the
+ JavaScript 1.8 version of reduceRight, if it exists. Foldr
+ is not as useful in JavaScript as it would be in a language with lazy
+ evaluation.
+
+var list = [[0, 1], [2, 3], [4, 5]];
+var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
+=> [4, 5, 2, 3, 0, 1]
+
+
+
+ find_.find(list, iterator, [context])
+ Alias: detect
+
+ Looks through each value in the list, returning the first one that
+ passes a truth test (iterator). The function returns as
+ soon as it finds an acceptable element, and doesn't traverse the
+ entire list.
+
+var even = _.find([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+=> 2
+
+
+
+ filter_.filter(list, iterator, [context])
+ Alias: select
+
+ Looks through each value in the list, returning an array of all
+ the values that pass a truth test (iterator). Delegates to the
+ native filter method, if it exists.
+
+var evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+=> [2, 4, 6]
+
+
+
+ where_.where(list, properties)
+
+ Looks through each value in the list, returning an array of all
+ the values that contain all of the key-value pairs listed in properties.
+
+_.where(listOfPlays, {author: "Shakespeare", year: 1611});
+=> [{title: "Cymbeline", author: "Shakespeare", year: 1611},
+ {title: "The Tempest", author: "Shakespeare", year: 1611}]
+
+
+
+ findWhere_.findWhere(list, properties)
+
+ Looks through the list and returns the first value that matches
+ all of the key-value pairs listed in properties.
+
+_.findWhere(publicServicePulitzers, {newsroom: "The New York Times"});
+=> {year: 1918, newsroom: "The New York Times",
+ reason: "For its public service in publishing in full so many official reports,
+ documents and speeches by European statesmen relating to the progress and
+ conduct of the war."}
+
+
+
+ reject_.reject(list, iterator, [context])
+
+ Returns the values in list without the elements that the truth
+ test (iterator) passes. The opposite of filter.
+
+var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+=> [1, 3, 5]
+
+
+
+ every_.every(list, iterator, [context])
+ Alias: all
+
+ Returns true if all of the values in the list pass the iterator
+ truth test. Delegates to the native method every, if present.
+
+_.every([true, 1, null, 'yes'], _.identity); +=> false ++ +
+ some_.some(list, [iterator], [context])
+ Alias: any
+
+ Returns true if any of the values in the list pass the
+ iterator truth test. Short-circuits and stops traversing the list
+ if a true element is found. Delegates to the native method some,
+ if present.
+
+_.some([null, 0, 'yes', false]); +=> true ++ +
+ contains_.contains(list, value)
+ Alias: include
+
+ Returns true if the value is present in the list.
+ Uses indexOf internally, if list is an Array.
+
+_.contains([1, 2, 3], 3); +=> true ++ +
+ invoke_.invoke(list, methodName, [*arguments])
+
+ Calls the method named by methodName on each value in the list.
+ Any extra arguments passed to invoke will be forwarded on to the
+ method invocation.
+
+_.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); +=> [[1, 5, 7], [1, 2, 3]] ++ +
+ pluck_.pluck(list, propertyName)
+
+ A convenient version of what is perhaps the most common use-case for
+ map: extracting a list of property values.
+
+var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];
+_.pluck(stooges, 'name');
+=> ["moe", "larry", "curly"]
+
+
+
+ max_.max(list, [iterator], [context])
+
+ Returns the maximum value in list. If iterator is passed,
+ it will be used on each value to generate the criterion by which the
+ value is ranked.
+
+var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];
+_.max(stooges, function(stooge){ return stooge.age; });
+=> {name : 'curly', age : 60};
+
+
+
+ min_.min(list, [iterator], [context])
+
+ Returns the minimum value in list. If iterator is passed,
+ it will be used on each value to generate the criterion by which the
+ value is ranked.
+
+var numbers = [10, 5, 100, 2, 1000]; +_.min(numbers); +=> 2 ++ +
+ sortBy_.sortBy(list, iterator, [context])
+
+ Returns a sorted copy of list, ranked in ascending order by the
+ results of running each value through iterator. Iterator may
+ also be the string name of the property to sort by (eg. length).
+
+_.sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); });
+=> [5, 4, 6, 3, 1, 2]
+
+
+
+ groupBy_.groupBy(list, iterator, [context])
+
+ Splits a collection into sets, grouped by the result of running each
+ value through iterator. If iterator is a string instead of
+ a function, groups by the property named by iterator on each of
+ the values.
+
+_.groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); });
+=> {1: [1.3], 2: [2.1, 2.4]}
+
+_.groupBy(['one', 'two', 'three'], 'length');
+=> {3: ["one", "two"], 5: ["three"]}
+
+
+
+ countBy_.countBy(list, iterator, [context])
+
+ Sorts a list into groups and returns a count for the number of objects
+ in each group.
+ Similar to groupBy, but instead of returning a list of values,
+ returns a count for the number of values in that group.
+
+_.countBy([1, 2, 3, 4, 5], function(num) {
+ return num % 2 == 0 ? 'even' : 'odd';
+});
+=> {odd: 3, even: 2}
+
+
+
+ shuffle_.shuffle(list)
+
+ Returns a shuffled copy of the list, using a version of the
+ Fisher-Yates shuffle.
+
+_.shuffle([1, 2, 3, 4, 5, 6]); +=> [4, 1, 6, 3, 5, 2] ++ +
+ toArray_.toArray(list)
+
+ Converts the list (anything that can be iterated over), into a
+ real Array. Useful for transmuting the arguments object.
+
+(function(){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+=> [2, 3, 4]
+
+
+
+ size_.size(list)
+
+ Return the number of values in the list.
+
+_.size({one : 1, two : 2, three : 3});
+=> 3
+
+
+ Array Functions
+ ++ + Note: All array functions will also work on the arguments object. + However, Underscore functions are not designed to work on "sparse" arrays. + +
+ +
+ first_.first(array, [n])
+ Alias: head, take
+
+ Returns the first element of an array. Passing n will
+ return the first n elements of the array.
+
+_.first([5, 4, 3, 2, 1]); +=> 5 ++ +
+ initial_.initial(array, [n])
+
+ Returns everything but the last entry of the array. Especially useful on
+ the arguments object. Pass n to exclude the last n elements
+ from the result.
+
+_.initial([5, 4, 3, 2, 1]); +=> [5, 4, 3, 2] ++ +
+ last_.last(array, [n])
+
+ Returns the last element of an array. Passing n will return
+ the last n elements of the array.
+
+_.last([5, 4, 3, 2, 1]); +=> 1 ++ +
+ rest_.rest(array, [index])
+ Alias: tail, drop
+
+ Returns the rest of the elements in an array. Pass an index
+ to return the values of the array from that index onward.
+
+_.rest([5, 4, 3, 2, 1]); +=> [4, 3, 2, 1] ++ +
+ compact_.compact(array)
+
+ Returns a copy of the array with all falsy values removed.
+ In JavaScript, false, null, 0, "",
+ undefined and NaN are all falsy.
+
+_.compact([0, 1, false, 2, '', 3]); +=> [1, 2, 3] ++ +
+ flatten_.flatten(array, [shallow])
+
+ Flattens a nested array (the nesting can be to any depth). If you
+ pass shallow, the array will only be flattened a single level.
+
+_.flatten([1, [2], [3, [[4]]]]); +=> [1, 2, 3, 4]; + +_.flatten([1, [2], [3, [[4]]]], true); +=> [1, 2, 3, [[4]]]; ++ +
+ without_.without(array, [*values])
+
+ Returns a copy of the array with all instances of the values
+ removed.
+
+_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); +=> [2, 3, 4] ++ +
+ union_.union(*arrays)
+
+ Computes the union of the passed-in arrays: the list of unique items,
+ in order, that are present in one or more of the arrays.
+
+_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]); +=> [1, 2, 3, 101, 10] ++ +
+ intersection_.intersection(*arrays)
+
+ Computes the list of values that are the intersection of all the arrays.
+ Each value in the result is present in each of the arrays.
+
+_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]); +=> [1, 2] ++ +
+ difference_.difference(array, *others)
+
+ Similar to without, but returns the values from array that
+ are not present in the other arrays.
+
+_.difference([1, 2, 3, 4, 5], [5, 2, 10]); +=> [1, 3, 4] ++ +
+ uniq_.uniq(array, [isSorted], [iterator])
+ Alias: unique
+
+ Produces a duplicate-free version of the array, using === to test
+ object equality. If you know in advance that the array is sorted,
+ passing true for isSorted will run a much faster algorithm.
+ If you want to compute unique items based on a transformation, pass an
+ iterator function.
+
+_.uniq([1, 2, 1, 3, 1, 4]); +=> [1, 2, 3, 4] ++ +
+ zip_.zip(*arrays)
+
+ Merges together the values of each of the arrays with the
+ values at the corresponding position. Useful when you have separate
+ data sources that are coordinated through matching array indexes.
+ If you're working with a matrix of nested arrays, zip.apply
+ can transpose the matrix in a similar fashion.
+
+_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]); +=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]] ++ +
+ object_.object(list, [values])
+
+ Converts arrays into objects. Pass either a single list of
+ [key, value] pairs, or a list of keys, and a list of values.
+
+_.object(['moe', 'larry', 'curly'], [30, 40, 50]);
+=> {moe: 30, larry: 40, curly: 50}
+
+_.object([['moe', 30], ['larry', 40], ['curly', 50]]);
+=> {moe: 30, larry: 40, curly: 50}
+
+
+
+ indexOf_.indexOf(array, value, [isSorted])
+
+ Returns the index at which value can be found in the array,
+ or -1 if value is not present in the array. Uses the native
+ indexOf function unless it's missing. If you're working with a
+ large array, and you know that the array is already sorted, pass true
+ for isSorted to use a faster binary search ... or, pass a number as
+ the third argument in order to look for the first matching value in the
+ array after the given index.
+
+_.indexOf([1, 2, 3], 2); +=> 1 ++ +
+ lastIndexOf_.lastIndexOf(array, value, [fromIndex])
+
+ Returns the index of the last occurrence of value in the array,
+ or -1 if value is not present. Uses the native lastIndexOf
+ function if possible. Pass fromIndex to start your search at a
+ given index.
+
+_.lastIndexOf([1, 2, 3, 1, 2, 3], 2); +=> 4 ++ +
+ sortedIndex_.sortedIndex(list, value, [iterator], [context])
+
+ Uses a binary search to determine the index at which the value
+ should be inserted into the list in order to maintain the list's
+ sorted order. If an iterator is passed, it will be used to compute
+ the sort ranking of each value, including the value you pass.
+
+_.sortedIndex([10, 20, 30, 40, 50], 35); +=> 3 ++ +
+ range_.range([start], stop, [step])
+
+ A function to create flexibly-numbered lists of integers, handy for
+ each and map loops. start, if omitted, defaults
+ to 0; step defaults to 1. Returns a list of integers
+ from start to stop, incremented (or decremented) by step,
+ exclusive.
+
+_.range(10); +=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +_.range(1, 11); +=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +_.range(0, 30, 5); +=> [0, 5, 10, 15, 20, 25] +_.range(0, -10, -1); +=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] +_.range(0); +=> [] ++ +
Function (uh, ahem) Functions
+ +
+ bind_.bind(function, object, [*arguments])
+
+ Bind a function to an object, meaning that whenever
+ the function is called, the value of this will be the object.
+ Optionally, pass arguments to the function to pre-fill them,
+ also known as partial application.
+
+var func = function(greeting){ return greeting + ': ' + this.name };
+func = _.bind(func, {name : 'moe'}, 'hi');
+func();
+=> 'hi: moe'
+
+
+
+ bindAll_.bindAll(object, [*methodNames])
+
+ Binds a number of methods on the object, specified by
+ methodNames, to be run in the context of that object whenever they
+ are invoked. Very handy for binding functions that are going to be used
+ as event handlers, which would otherwise be invoked with a fairly useless
+ this. If no methodNames are provided, all of the object's
+ function properties will be bound to it.
+
+var buttonView = {
+ label : 'underscore',
+ onClick : function(){ alert('clicked: ' + this.label); },
+ onHover : function(){ console.log('hovering: ' + this.label); }
+};
+_.bindAll(buttonView);
+jQuery('#underscore_button').bind('click', buttonView.onClick);
+=> When the button is clicked, this.label will have the correct value...
+
+
+
+ partial_.partial(function, [*arguments])
+
+ Partially apply a function by filling in any number of its arguments,
+ without changing its dynamic this value. A close cousin
+ of bind.
+
+var add = function(a, b) { return a + b; };
+add5 = _.partial(add, 5);
+add5(10);
+=> 15
+
+
+
+ memoize_.memoize(function, [hashFunction])
+
+ Memoizes a given function by caching the computed result. Useful
+ for speeding up slow-running computations. If passed an optional
+ hashFunction, it will be used to compute the hash key for storing
+ the result, based on the arguments to the original function. The default
+ hashFunction just uses the first argument to the memoized function
+ as the key.
+
+var fibonacci = _.memoize(function(n) {
+ return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+});
+
+
+
+ delay_.delay(function, wait, [*arguments])
+
+ Much like setTimeout, invokes function after wait
+ milliseconds. If you pass the optional arguments, they will be
+ forwarded on to the function when it is invoked.
+
+var log = _.bind(console.log, console); +_.delay(log, 1000, 'logged later'); +=> 'logged later' // Appears after one second. ++ +
+ defer_.defer(function, [*arguments])
+
+ Defers invoking the function until the current call stack has cleared,
+ similar to using setTimeout with a delay of 0. Useful for performing
+ expensive computations or HTML rendering in chunks without blocking the UI thread
+ from updating. If you pass the optional arguments, they will be
+ forwarded on to the function when it is invoked.
+
+_.defer(function(){ alert('deferred'); });
+// Returns from the function before the alert runs.
+
+
+
+ throttle_.throttle(function, wait)
+
+ Creates and returns a new, throttled version of the passed function,
+ that, when invoked repeatedly, will only actually call the original function
+ at most once per every wait
+ milliseconds. Useful for rate-limiting events that occur faster than you
+ can keep up with.
+
+var throttled = _.throttle(updatePosition, 100); +$(window).scroll(throttled); ++ +
+ debounce_.debounce(function, wait, [immediate])
+
+ Creates and returns a new debounced version of the passed function that
+ will postpone its execution until after
+ wait milliseconds have elapsed since the last time it
+ was invoked. Useful for implementing behavior that should only happen
+ after the input has stopped arriving. For example: rendering a
+ preview of a Markdown comment, recalculating a layout after the window
+ has stopped being resized, and so on.
+
+ Pass true for the immediate parameter to cause + debounce to trigger the function on the leading instead of the + trailing edge of the wait interval. Useful in circumstances like + preventing accidental double-clicks on a "submit" button from firing a + second time. +
+ ++var lazyLayout = _.debounce(calculateLayout, 300); +$(window).resize(lazyLayout); ++ +
+ once_.once(function)
+
+ Creates a version of the function that can only be called one time.
+ Repeated calls to the modified function will have no effect, returning
+ the value from the original call. Useful for initialization functions,
+ instead of having to set a boolean flag and then check it later.
+
+var initialize = _.once(createApplication); +initialize(); +initialize(); +// Application is only created once. ++ +
+ after_.after(count, function)
+
+ Creates a version of the function that will only be run after first
+ being called count times. Useful for grouping asynchronous responses,
+ where you want to be sure that all the async calls have finished, before
+ proceeding.
+
+var renderNotes = _.after(notes.length, render);
+_.each(notes, function(note) {
+ note.asyncSave({success: renderNotes});
+});
+// renderNotes is run once, after all notes have saved.
+
+
+
+ wrap_.wrap(function, wrapper)
+
+ Wraps the first function inside of the wrapper function,
+ passing it as the first argument. This allows the wrapper to
+ execute code before and after the function runs, adjust the arguments,
+ and execute it conditionally.
+
+var hello = function(name) { return "hello: " + name; };
+hello = _.wrap(hello, function(func) {
+ return "before, " + func("moe") + ", after";
+});
+hello();
+=> 'before, hello: moe, after'
+
+
+
+ compose_.compose(*functions)
+
+ Returns the composition of a list of functions, where each function
+ consumes the return value of the function that follows. In math terms,
+ composing the functions f(), g(), and h() produces
+ f(g(h())).
+
+var greet = function(name){ return "hi: " + name; };
+var exclaim = function(statement){ return statement + "!"; };
+var welcome = _.compose(exclaim, greet);
+welcome('moe');
+=> 'hi: moe!'
+
+
+ Object Functions
+ +
+ keys_.keys(object)
+
+ Retrieve all the names of the object's properties.
+
+_.keys({one : 1, two : 2, three : 3});
+=> ["one", "two", "three"]
+
+
+
+ values_.values(object)
+
+ Return all of the values of the object's properties.
+
+_.values({one : 1, two : 2, three : 3});
+=> [1, 2, 3]
+
+
+
+ pairs_.pairs(object)
+
+ Convert an object into a list of [key, value] pairs.
+
+_.pairs({one: 1, two: 2, three: 3});
+=> [["one", 1], ["two", 2], ["three", 3]]
+
+
+
+ invert_.invert(object)
+
+ Returns a copy of the object where the keys have become the values
+ and the values the keys. For this to work, all of your object's values
+ should be unique and string serializable.
+
+_.invert({Moe: "Moses", Larry: "Louis", Curly: "Jerome"});
+=> {Moses: "Moe", Louis: "Larry", Jerome: "Curly"};
+
+
+
+ functions_.functions(object)
+ Alias: methods
+
+ Returns a sorted list of the names of every method in an object —
+ that is to say, the name of every function property of the object.
+
+_.functions(_); +=> ["all", "any", "bind", "bindAll", "clone", "compact", "compose" ... ++ +
+ extend_.extend(destination, *sources)
+
+ Copy all of the properties in the source objects over to the
+ destination object, and return the destination object.
+ It's in-order, so the last source will override properties of the same
+ name in previous arguments.
+
+_.extend({name : 'moe'}, {age : 50});
+=> {name : 'moe', age : 50}
+
+
+
+ pick_.pick(object, *keys)
+
+ Return a copy of the object, filtered to only have values for
+ the whitelisted keys (or array of valid keys).
+
+_.pick({name : 'moe', age: 50, userid : 'moe1'}, 'name', 'age');
+=> {name : 'moe', age : 50}
+
+
+
+ omit_.omit(object, *keys)
+
+ Return a copy of the object, filtered to omit the blacklisted
+ keys (or array of keys).
+
+_.omit({name : 'moe', age : 50, userid : 'moe1'}, 'userid');
+=> {name : 'moe', age : 50}
+
+
+
+ defaults_.defaults(object, *defaults)
+
+ Fill in null and undefined properties in object with values from the
+ defaults objects, and return the object. As soon as the
+ property is filled, further defaults will have no effect.
+
+var iceCream = {flavor : "chocolate"};
+_.defaults(iceCream, {flavor : "vanilla", sprinkles : "lots"});
+=> {flavor : "chocolate", sprinkles : "lots"}
+
+
+
+ clone_.clone(object)
+
+ Create a shallow-copied clone of the object. Any nested objects
+ or arrays will be copied by reference, not duplicated.
+
+_.clone({name : 'moe'});
+=> {name : 'moe'};
+
+
+
+ tap_.tap(object, interceptor)
+
+ Invokes interceptor with the object, and then returns object.
+ The primary purpose of this method is to "tap into" a method chain, in order to perform operations on intermediate results within the chain.
+
+_.chain([1,2,3,200])
+ .filter(function(num) { return num % 2 == 0; })
+ .tap(alert)
+ .map(function(num) { return num * num })
+ .value();
+=> // [2, 200] (alerted)
+=> [4, 40000]
+
+
+
+ has_.has(object, key)
+
+ Does the object contain the given key? Identical to
+ object.hasOwnProperty(key), but uses a safe reference to the
+ hasOwnProperty function, in case it's been
+ overridden accidentally.
+
+_.has({a: 1, b: 2, c: 3}, "b");
+=> true
+
+
+
+ isEqual_.isEqual(object, other)
+
+ Performs an optimized deep comparison between the two objects, to determine
+ if they should be considered equal.
+
+var moe = {name : 'moe', luckyNumbers : [13, 27, 34]};
+var clone = {name : 'moe', luckyNumbers : [13, 27, 34]};
+moe == clone;
+=> false
+_.isEqual(moe, clone);
+=> true
+
+
+
+ isEmpty_.isEmpty(object)
+
+ Returns true if object contains no values.
+
+_.isEmpty([1, 2, 3]);
+=> false
+_.isEmpty({});
+=> true
+
+
+
+ isElement_.isElement(object)
+
+ Returns true if object is a DOM element.
+
+_.isElement(jQuery('body')[0]);
+=> true
+
+
+
+ isArray_.isArray(object)
+
+ Returns true if object is an Array.
+
+(function(){ return _.isArray(arguments); })();
+=> false
+_.isArray([1,2,3]);
+=> true
+
+
+
+ isObject_.isObject(value)
+
+ Returns true if value is an Object. Note that JavaScript
+ arrays and functions are objects, while (normal) strings and numbers are not.
+
+_.isObject({});
+=> true
+_.isObject(1);
+=> false
+
+
+
+ isArguments_.isArguments(object)
+
+ Returns true if object is an Arguments object.
+
+(function(){ return _.isArguments(arguments); })(1, 2, 3);
+=> true
+_.isArguments([1,2,3]);
+=> false
+
+
+
+ isFunction_.isFunction(object)
+
+ Returns true if object is a Function.
+
+_.isFunction(alert); +=> true ++ +
+ isString_.isString(object)
+
+ Returns true if object is a String.
+
+_.isString("moe");
+=> true
+
+
+
+ isNumber_.isNumber(object)
+
+ Returns true if object is a Number (including NaN).
+
+_.isNumber(8.4 * 5); +=> true ++ +
+ isFinite_.isFinite(object)
+
+ Returns true if object is a finite Number.
+
+_.isFinite(-101); +=> true + +_.isFinite(-Infinity); +=> false ++ +
+ isBoolean_.isBoolean(object)
+
+ Returns true if object is either true or false.
+
+_.isBoolean(null); +=> false ++ +
+ isDate_.isDate(object)
+
+ Returns true if object is a Date.
+
+_.isDate(new Date()); +=> true ++ +
+ isRegExp_.isRegExp(object)
+
+ Returns true if object is a RegExp.
+
+_.isRegExp(/moe/); +=> true ++ +
+ isNaN_.isNaN(object)
+
+ Returns true if object is NaN.
Note: this is not
+ the same as the native isNaN function, which will also return
+ true if the variable is undefined.
+
+_.isNaN(NaN); +=> true +isNaN(undefined); +=> true +_.isNaN(undefined); +=> false ++ +
+ isNull_.isNull(object)
+
+ Returns true if the value of object is null.
+
+_.isNull(null); +=> true +_.isNull(undefined); +=> false ++ +
+ isUndefined_.isUndefined(value)
+
+ Returns true if value is undefined.
+
+_.isUndefined(window.missingVariable); +=> true ++ +
Utility Functions
+ +
+ noConflict_.noConflict()
+
+ Give control of the "_" variable back to its previous owner. Returns
+ a reference to the Underscore object.
+
+var underscore = _.noConflict();+ +
+ identity_.identity(value)
+
+ Returns the same value that is used as the argument. In math:
+ f(x) = x
+ This function looks useless, but is used throughout Underscore as
+ a default iterator.
+
+var moe = {name : 'moe'};
+moe === _.identity(moe);
+=> true
+
+
+ times_.times(n, iterator, [context])
+
+ Invokes the given iterator function n times. Each invocation of
+ iterator is called with an index argument.
+
+ Note: this example uses the chaining syntax.
+
+_(3).times(function(n){ genie.grantWishNumber(n); });
+
+
+ random_.random(min, max)
+
+ Returns a random integer between min and max, inclusive.
+ If you only pass one argument, it will return a number between 0
+ and that number.
+
+_.random(0, 100); +=> 42+ +
+ mixin_.mixin(object)
+
+ Allows you to extend Underscore with your own utility functions. Pass
+ a hash of {name: function} definitions to have your functions
+ added to the Underscore object, as well as the OOP wrapper.
+
+_.mixin({
+ capitalize : function(string) {
+ return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();
+ }
+});
+_("fabio").capitalize();
+=> "Fabio"
+
+
+
+ uniqueId_.uniqueId([prefix])
+
+ Generate a globally-unique id for client-side models or DOM elements
+ that need one. If prefix is passed, the id will be appended to it.
+
+_.uniqueId('contact_');
+=> 'contact_104'
+
+
+ escape_.escape(string)
+
+ Escapes a string for insertion into HTML, replacing
+ &, <, >, ", ', and / characters.
+
+_.escape('Curly, Larry & Moe');
+=> "Curly, Larry & Moe"
+
+
+ unescape_.unescape(string)
+
+ The opposite of escape, replaces
+ &, <, >,
+ ", ', and /
+ with their unescaped counterparts.
+
+_.unescape('Curly, Larry & Moe');
+=> "Curly, Larry & Moe"
+
+
+ result_.result(object, property)
+
+ If the value of the named property is a function then invoke it; otherwise, return it.
+
+var object = {cheese: 'crumpets', stuff: function(){ return 'nonsense'; }};
+_.result(object, 'cheese');
+=> "crumpets"
+_.result(object, 'stuff');
+=> "nonsense"
+
+
+ template_.template(templateString, [data], [settings])
+
+ Compiles JavaScript templates into functions that can be evaluated
+ for rendering. Useful for rendering complicated bits of HTML from JSON
+ data sources. Template functions can both interpolate variables, using
+ <%= … %>, as well as execute arbitrary JavaScript code, with
+ <% … %>. If you wish to interpolate a value, and have
+ it be HTML-escaped, use <%- … %> When you evaluate a template function, pass in a
+ data object that has properties corresponding to the template's free
+ variables. If you're writing a one-off, you can pass the data
+ object as the second parameter to template in order to render
+ immediately instead of returning a template function. The settings argument
+ should be a hash containing any _.templateSettings that should be overridden.
+
+var compiled = _.template("hello: <%= name %>");
+compiled({name : 'moe'});
+=> "hello: moe"
+
+var list = "<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>";
+_.template(list, {people : ['moe', 'curly', 'larry']});
+=> "<li>moe</li><li>curly</li><li>larry</li>"
+
+var template = _.template("<b><%- value %></b>");
+template({value : '<script>'});
+=> "<b><script></b>"
+
+ + You can also use print from within JavaScript code. This is + sometimes more convenient than using <%= ... %>. +
+ +
+var compiled = _.template("<% print('Hello ' + epithet); %>");
+compiled({epithet: "stooge"});
+=> "Hello stooge."
+
+ + If ERB-style delimiters aren't your cup of tea, you can change Underscore's + template settings to use different symbols to set off interpolated code. + Define an interpolate regex to match expressions that should be + interpolated verbatim, an escape regex to match expressions that should + be inserted after being HTML escaped, and an evaluate regex to match + expressions that should be evaluated without insertion into the resulting + string. You may define or omit any combination of the three. + For example, to perform + Mustache.js + style templating: +
+ +
+_.templateSettings = {
+ interpolate : /\{\{(.+?)\}\}/g
+};
+
+var template = _.template("Hello {{ name }}!");
+template({name : "Mustache"});
+=> "Hello Mustache!"
+
+ + By default, template places the values from your data in the local scope + via the with statement. However, you can specify a single variable name + with the variable setting. This can significantly improve the speed + at which a template is able to render. +
+ +
+_.template("Using 'with': <%= data.answer %>", {answer: 'no'}, {variable: 'data'});
+=> "Using 'with': no"
+
+ + Precompiling your templates can be a big help when debugging errors you can't + reproduce. This is because precompiled templates can provide line numbers and + a stack trace, something that is not possible when compiling templates on the client. + The source property is available on the compiled template + function for easy precompilation. +
+ +<script> + JST.project = <%= _.template(jstText).source %>; +</script>+ + +
Chaining
+ ++ You can use Underscore in either an object-oriented or a functional style, + depending on your preference. The following two lines of code are + identical ways to double a list of numbers. +
+ +
+_.map([1, 2, 3], function(n){ return n * 2; });
+_([1, 2, 3]).map(function(n){ return n * 2; });
+
+ + Calling chain will cause all future method calls to return + wrapped objects. When you've finished the computation, use + value to retrieve the final value. Here's an example of chaining + together a map/flatten/reduce, in order to get the word count of + every word in a song. +
+ +
+var lyrics = [
+ {line : 1, words : "I'm a lumberjack and I'm okay"},
+ {line : 2, words : "I sleep all night and I work all day"},
+ {line : 3, words : "He's a lumberjack and he's okay"},
+ {line : 4, words : "He sleeps all night and he works all day"}
+];
+
+_.chain(lyrics)
+ .map(function(line) { return line.words.split(' '); })
+ .flatten()
+ .reduce(function(counts, word) {
+ counts[word] = (counts[word] || 0) + 1;
+ return counts;
+ }, {})
+ .value();
+
+=> {lumberjack : 2, all : 4, night : 2 ... }
+
+ + In addition, the + Array prototype's methods + are proxied through the chained Underscore object, so you can slip a + reverse or a push into your chain, and continue to + modify the array. +
+ +
+ chain_.chain(obj)
+
+ Returns a wrapped object. Calling methods on this object will continue
+ to return wrapped objects until value is used.
+
+var stooges = [{name : 'curly', age : 25}, {name : 'moe', age : 21}, {name : 'larry', age : 23}];
+var youngest = _.chain(stooges)
+ .sortBy(function(stooge){ return stooge.age; })
+ .map(function(stooge){ return stooge.name + ' is ' + stooge.age; })
+ .first()
+ .value();
+=> "moe is 21"
+
+
+
+ value_(obj).value()
+
+ Extracts the value of a wrapped object.
+
+_([1, 2, 3]).value(); +=> [1, 2, 3] ++ +
Links & Suggested Reading
+ ++ The Underscore documentation is also available in + Simplified Chinese. +
+ ++ Underscore.lua, + a Lua port of the functions that are applicable in both languages. + Includes OOP-wrapping and chaining. + (source) +
+ ++ Underscore.m, an Objective-C port + of many of the Underscore.js functions, using a syntax that encourages + chaining. + (source) +
+ ++ _.m, an alternative + Objective-C port that tries to stick a little closer to the original + Underscore.js API. + (source) +
+ ++ Underscore.php, + a PHP port of the functions that are applicable in both languages. + Includes OOP-wrapping and chaining. + (source) +
+ ++ Underscore-perl, + a Perl port of many of the Underscore.js functions, + aimed at on Perl hashes and arrays. + (source) +
+ ++ Underscore.cfc, + a Coldfusion port of many of the Underscore.js functions. + (source) +
+ ++ Underscore.string, + an Underscore extension that adds functions for string-manipulation: + trim, startsWith, contains, capitalize, + reverse, sprintf, and more. +
+ ++ Ruby's Enumerable module. +
+ ++ Prototype.js, which provides + JavaScript with collection functions in the manner closest to Ruby's Enumerable. +
+ ++ Oliver Steele's + Functional JavaScript, + which includes comprehensive higher-order function support as well as string lambdas. +
+ ++ Michael Aufreiter's Data.js, + a data manipulation + persistence library for JavaScript. +
+ ++ Python's itertools. +
+ +Change Log
+ +
+ 1.4.4 — Jan. 30, 2013 — Diff
+
-
+
- + Added _.findWhere, for finding the first element in a list + that matches a particular set of keys and values. + +
- + Added _.partial, for partially applying a function without + changing its dynamic reference to this. + +
- + Simplified bind by removing some edge cases involving + constructor functions. In short: don't _.bind your + constructors. + +
- + A minor optimization to invoke. + +
- + Fix bug in the minified version due to the minifier incorrectly + optimizing-away isFunction. + +
+ 1.4.3 — Dec. 4, 2012 — Diff
+
-
+
- + Improved Underscore compatibility with Adobe's JS engine that can be + used to script Illustrator, Photoshop, and friends. + +
- + Added a default _.identity iterator to countBy and + groupBy. + +
- + The uniq function can now take array, iterator, context + as the argument list. + +
- + The times function now returns the mapped array of iterator + results. + +
- + Simplified and fixed bugs in throttle. + +
+ 1.4.2 — Oct. 1, 2012 — Diff
+
-
+
- + For backwards compatibility, returned to pre-1.4.0 behavior when + passing null to iteration functions. They now become no-ops + again. + +
+ 1.4.1 — Oct. 1, 2012 — Diff
+
-
+
- + Fixed a 1.4.0 regression in the lastIndexOf function. + +
+ 1.4.0 — Sept. 27, 2012 — Diff
+
-
+
- + Added a pairs function, for turning a JavaScript object + into [key, value] pairs ... as well as an object + function, for converting an array of [key, value] pairs + into an object. + +
- + Added a countBy function, for counting the number of objects + in a list that match a certain criteria. + +
- + Added an invert function, for performing a simple inversion + of the keys and values in an object. + +
- + Added a where function, for easy cases of filtering a list + for objects with specific values. + +
- + Added an omit function, for filtering an object to remove + certain keys. + +
- + Added a random function, to return a random number in a + given range. + +
- + _.debounce'd functions now return their last updated value, + just like _.throttle'd functions do. + +
- + The sortBy function now runs a stable sort algorithm. + +
- + Added the optional fromIndex option to indexOf and + lastIndexOf. + +
- + "Sparse" arrays are no longer supported in Underscore iteration + functions. Use a for loop instead (or better yet, an object). + +
- + The min and max functions may now be called on + very large arrays. + +
- + Interpolation in templates now represents null and + undefined as the empty string. + +
-
+
Underscore iteration functions no longer accept null values + as a no-op argument. You'll get an early error instead.+
+ - + A number of edge-cases fixes and tweaks, which you can spot in the + diff. + Depending on how you're using Underscore, 1.4.0 may be more + backwards-incompatible than usual — please test when you upgrade. + +
+ 1.3.3 — April 10, 2012
+
-
+
- + Many improvements to _.template, which now provides the + source of the template function as a property, for potentially + even more efficient pre-compilation on the server-side. You may now + also set the variable option when creating a template, + which will cause your passed-in data to be made available under the + variable you named, instead of using a with statement — + significantly improving the speed of rendering the template. + +
- + Added the pick function, which allows you to filter an + object literal with a whitelist of allowed property names. + +
- + Added the result function, for convenience when working + with APIs that allow either functions or raw properties. + +
- + Added the isFinite function, because sometimes knowing that + a value is a number just ain't quite enough. + +
- + The sortBy function may now also be passed the string name + of a property to use as the sort order on each object. + +
- + Fixed uniq to work with sparse arrays. + +
- + The difference function now performs a shallow flatten + instead of a deep one when computing array differences. + +
- + The debounce function now takes an immediate + parameter, which will cause the callback to fire on the leading + instead of the trailing edge. + +
+ 1.3.1 — Jan. 23, 2012
+
-
+
- + Added an _.has function, as a safer way to use hasOwnProperty. + +
- + Added _.collect as an alias for _.map. Smalltalkers, rejoice. + +
- + Reverted an old change so that _.extend will correctly copy + over keys with undefined values again. + +
- + Bugfix to stop escaping slashes within interpolations in _.template. + +
+ 1.3.0 — Jan. 11, 2012
+
-
+
- + Removed AMD (RequireJS) support from Underscore. If you'd like to use + Underscore with RequireJS, you can load it as a normal script, wrap + or patch your copy, or download a forked version. + +
+ 1.2.4 — Jan. 4, 2012
+
-
+
- + You now can (and probably should, as it's simpler) + write _.chain(list) + instead of _(list).chain(). + +
- + Fix for escaped characters in Underscore templates, and for supporting + customizations of _.templateSettings that only define one or + two of the required regexes. + +
- + Fix for passing an array as the first argument to an _.wrap'd function. + +
- + Improved compatibility with ClojureScript, which adds a call + function to String.prototype. + +
+ 1.2.3 — Dec. 7, 2011
+
-
+
- + Dynamic scope is now preserved for compiled _.template functions, + so you can use the value of this if you like. + +
- + Sparse array support of _.indexOf, _.lastIndexOf. + +
- + Both _.reduce and _.reduceRight can now be passed an + explicitly undefined value. (There's no reason why you'd + want to do this.) + +
+ 1.2.2 — Nov. 14, 2011
+
-
+
- + Continued tweaks to _.isEqual semantics. Now JS primitives are + considered equivalent to their wrapped versions, and arrays are compared + by their numeric properties only (#351). + +
- + _.escape no longer tries to be smart about not double-escaping + already-escaped HTML entities. Now it just escapes regardless (#350). + +
- + In _.template, you may now leave semicolons out of evaluated + statements if you wish: <% }) %> (#369). + +
- + _.after(callback, 0) will now trigger the callback immediately, + making "after" easier to use with asynchronous APIs (#366). + +
+ 1.2.1 — Oct. 24, 2011
+
-
+
- + Several important bug fixes for _.isEqual, which should now + do better on mutated Arrays, and on non-Array objects with + length properties. (#329) + +
- + jrburke contributed Underscore exporting for AMD module loaders, + and tonylukasavage for Appcelerator Titanium. + (#335, #338) + +
- + You can now _.groupBy(list, 'property') as a shortcut for + grouping values by a particular common property. + +
- + _.throttle'd functions now fire immediately upon invocation, + and are rate-limited thereafter (#170, #266). + +
- + Most of the _.is[Type] checks no longer ducktype. + +
- + The _.bind function now also works on constructors, a-la + ES5 ... but you would never want to use _.bind on a + constructor function. + +
- + _.clone no longer wraps non-object types in Objects. + +
- + _.find and _.filter are now the preferred names for + _.detect and _.select. + +
+ 1.2.0 — Oct. 5, 2011
+
-
+
- + The _.isEqual function now + supports true deep equality comparisons, with checks for cyclic structures, + thanks to Kit Cambridge. + +
- + Underscore templates now support HTML escaping interpolations, using + <%- ... %> syntax. + +
- + Ryan Tenney contributed _.shuffle, which uses a modified + Fisher-Yates to give you a shuffled copy of an array. + +
- + _.uniq can now be passed an optional iterator, to determine by + what criteria an object should be considered unique. + +
- + _.last now takes an optional argument which will return the last + N elements of the list. + +
- + A new _.initial function was added, as a mirror of _.rest, + which returns all the initial values of a list (except the last N). + +
+ 1.1.7 — July 13, 2011
+ Added _.groupBy, which aggregates a collection into groups of like items.
+ Added _.union and _.difference, to complement the
+ (re-named) _.intersection.
+ Various improvements for support of sparse arrays.
+ _.toArray now returns a clone, if directly passed an array.
+ _.functions now also returns the names of functions that are present
+ in the prototype chain.
+
+ 1.1.6 — April 18, 2011
+ Added _.after, which will return a function that only runs after
+ first being called a specified number of times.
+ _.invoke can now take a direct function reference.
+ _.every now requires an iterator function to be passed, which
+ mirrors the ECMA5 API.
+ _.extend no longer copies keys when the value is undefined.
+ _.bind now errors when trying to bind an undefined value.
+
+ 1.1.5 — Mar 20, 2011
+ Added an _.defaults function, for use merging together JS objects
+ representing default options.
+ Added an _.once function, for manufacturing functions that should
+ only ever execute a single time.
+ _.bind now delegates to the native ECMAScript 5 version,
+ where available.
+ _.keys now throws an error when used on non-Object values, as in
+ ECMAScript 5.
+ Fixed a bug with _.keys when used over sparse arrays.
+
+ 1.1.4 — Jan 9, 2011
+ Improved compliance with ES5's Array methods when passing null
+ as a value. _.wrap now correctly sets this for the
+ wrapped function. _.indexOf now takes an optional flag for
+ finding the insertion index in an array that is guaranteed to already
+ be sorted. Avoiding the use of .callee, to allow _.isArray
+ to work properly in ES5's strict mode.
+
+ 1.1.3 — Dec 1, 2010
+ In CommonJS, Underscore may now be required with just:
+ var _ = require("underscore").
+ Added _.throttle and _.debounce functions.
+ Removed _.breakLoop, in favor of an ECMA5-style un-break-able
+ each implementation — this removes the try/catch, and you'll now have
+ better stack traces for exceptions that are thrown within an Underscore iterator.
+ Improved the isType family of functions for better interoperability
+ with Internet Explorer host objects.
+ _.template now correctly escapes backslashes in templates.
+ Improved _.reduce compatibility with the ECMA5 version:
+ if you don't pass an initial value, the first item in the collection is used.
+ _.each no longer returns the iterated collection, for improved
+ consistency with ES5's forEach.
+
+ 1.1.2
+ Fixed _.contains, which was mistakenly pointing at
+ _.intersect instead of _.include, like it should
+ have been. Added _.unique as an alias for _.uniq.
+
+ 1.1.1
+ Improved the speed of _.template, and its handling of multiline
+ interpolations. Ryan Tenney contributed optimizations to many Underscore
+ functions. An annotated version of the source code is now available.
+
+ 1.1.0
+ The method signature of _.reduce has been changed to match
+ the ECMAScript 5 signature, instead of the Ruby/Prototype.js version.
+ This is a backwards-incompatible change. _.template may now be
+ called with no arguments, and preserves whitespace. _.contains
+ is a new alias for _.include.
+
+ 1.0.4
+ Andri Möll contributed the _.memoize
+ function, which can be used to speed up expensive repeated computations
+ by caching the results.
+
+ 1.0.3
+ Patch that makes _.isEqual return false if any property
+ of the compared object has a NaN value. Technically the correct
+ thing to do, but of questionable semantics. Watch out for NaN comparisons.
+
+ 1.0.2
+ Fixes _.isArguments in recent versions of Opera, which have
+ arguments objects as real Arrays.
+
+ 1.0.1
+ Bugfix for _.isEqual, when comparing two objects with the same
+ number of undefined keys, but with different names.
+
+ 1.0.0
+ Things have been stable for many months now, so Underscore is now
+ considered to be out of beta, at 1.0. Improvements since 0.6
+ include _.isBoolean, and the ability to have _.extend
+ take multiple source objects.
+
+ 0.6.0
+ Major release. Incorporates a number of
+ Mile Frawley's refactors for
+ safer duck-typing on collection functions, and cleaner internals. A new
+ _.mixin method that allows you to extend Underscore with utility
+ functions of your own. Added _.times, which works the same as in
+ Ruby or Prototype.js. Native support for ECMAScript 5's Array.isArray,
+ and Object.keys.
+
+ 0.5.8
+ Fixed Underscore's collection functions to work on
+ NodeLists and
+ HTMLCollections
+ once more, thanks to
+ Justin Tulloss.
+
+ 0.5.7
+ A safer implementation of _.isArguments, and a
+ faster _.isNumber,
thanks to
+ Jed Schmidt.
+
+ 0.5.6
+ Customizable delimiters for _.template, contributed by
+ Noah Sloan.
+
+ 0.5.5
+ Fix for a bug in MobileSafari's OOP-wrapper, with the arguments object.
+
+ 0.5.4
+ Fix for multiple single quotes within a template string for
+ _.template. See:
+ Rick Strahl's blog post.
+
+ 0.5.2
+ New implementations of isArray, isDate, isFunction,
+ isNumber, isRegExp, and isString, thanks to
+ a suggestion from
+ Robert Kieffer.
+ Instead of doing Object#toString
+ comparisons, they now check for expected properties, which is less safe,
+ but more than an order of magnitude faster. Most other Underscore
+ functions saw minor speed improvements as a result.
+ Evgeniy Dolzhenko
+ contributed _.tap,
+ similar to Ruby 1.9's,
+ which is handy for injecting side effects (like logging) into chained calls.
+
+ 0.5.1
+ Added an _.isArguments function. Lots of little safety checks
+ and optimizations contributed by
+ Noah Sloan and
+ Andri Möll.
+
+ 0.5.0
+ [API Changes] _.bindAll now takes the context object as
+ its first parameter. If no method names are passed, all of the context
+ object's methods are bound to it, enabling chaining and easier binding.
+ _.functions now takes a single argument and returns the names
+ of its Function properties. Calling _.functions(_) will get you
+ the previous behavior.
+ Added _.isRegExp so that isEqual can now test for RegExp equality.
+ All of the "is" functions have been shrunk down into a single definition.
+ Karl Guertin contributed patches.
+
+ 0.4.7
+ Added isDate, isNaN, and isNull, for completeness.
+ Optimizations for isEqual when checking equality between Arrays
+ or Dates. _.keys is now 25%–2X faster (depending on your
+ browser) which speeds up the functions that rely on it, such as _.each.
+
+ 0.4.6
+ Added the range function, a port of the
+ Python
+ function of the same name, for generating flexibly-numbered lists
+ of integers. Original patch contributed by
+ Kirill Ishanov.
+
+ 0.4.5
+ Added rest for Arrays and arguments objects, and aliased
+ first as head, and rest as tail,
+ thanks to Luke Sutton's patches.
+ Added tests ensuring that all Underscore Array functions also work on
+ arguments objects.
+
+ 0.4.4
+ Added isString, and isNumber, for consistency. Fixed
+ _.isEqual(NaN, NaN) to return true (which is debatable).
+
+ 0.4.3
+ Started using the native StopIteration object in browsers that support it.
+ Fixed Underscore setup for CommonJS environments.
+
+ 0.4.2
+ Renamed the unwrapping function to value, for clarity.
+
+ 0.4.1
+ Chained Underscore objects now support the Array prototype methods, so
+ that you can perform the full range of operations on a wrapped array
+ without having to break your chain. Added a breakLoop method
+ to break in the middle of any Underscore iteration. Added an
+ isEmpty function that works on arrays and objects.
+
+ 0.4.0
+ All Underscore functions can now be called in an object-oriented style,
+ like so: _([1, 2, 3]).map(...);. Original patch provided by
+ Marc-André Cournoyer.
+ Wrapped objects can be chained through multiple
+ method invocations. A functions method
+ was added, providing a sorted list of all the functions in Underscore.
+
+ 0.3.3
+ Added the JavaScript 1.8 function reduceRight. Aliased it
+ as foldr, and aliased reduce as foldl.
+
+ 0.3.2
+ Now runs on stock Rhino
+ interpreters with: load("underscore.js").
+ Added identity as a utility function.
+
+ 0.3.1
+ All iterators are now passed in the original collection as their third
+ argument, the same as JavaScript 1.6's forEach. Iterating over
+ objects is now called with (value, key, collection), for details
+ see _.each.
+
+ 0.3.0
+ Added Dmitry Baranovskiy's
+ comprehensive optimizations, merged in
+ Kris Kowal's patches to make Underscore
+ CommonJS and
+ Narwhal compliant.
+
+ 0.2.0
+ Added compose and lastIndexOf, renamed inject to
+ reduce, added aliases for inject, filter,
+ every, some, and forEach.
+
+ 0.1.1
+ Added noConflict, so that the "Underscore" object can be assigned to
+ other variables.
+
+ 0.1.0
+ Initial release of Underscore.js.
+
+
+ 
+
+
+ Valid categories (case-insensitive) are *“arraysâ€*, *“chainingâ€*, *“collectionsâ€*, *“functionsâ€*, *“objectsâ€*, and *“utilitiesâ€*. +```bash +lodash category=collections,functions +lodash category="collections, functions" +``` + + * Use the `exports` argument to pass comma separated names of ways to export the `LoDash` function.
+ Valid exports are *“amdâ€*, *“commonjsâ€*, *“globalâ€*, *“nodeâ€*, and *“noneâ€*. +```bash +lodash exports=amd,commonjs,node +lodash exports="amd, commonjs, node" +``` + + * Use the `iife` argument to specify code to replace the immediately-invoked function expression that wraps Lo-Dash. +```bash +lodash iife="!function(window,undefined){%output%}(this)" +``` + + * Use the `include` argument to pass comma separated method/category names to include in the build. +```bash +lodash include=each,filter,map +lodash include="each, filter, map" +``` + + * Use the `minus` argument to pass comma separated method/category names to remove from those included in the build. +```bash +lodash underscore minus=result,shuffle +lodash underscore minus="result, shuffle" +``` + + * Use the `plus` argument to pass comma separated method/category names to add to those included in the build. +```bash +lodash backbone plus=random,template +lodash backbone plus="random, template" +``` + + * Use the `template` argument to pass the file path pattern used to match template files to precompile. +```bash +lodash template="./*.jst" +``` + + * Use the `settings` argument to pass the template settings used when precompiling templates. +```bash +lodash settings="{interpolate:/\\{\\{([\\s\\S]+?)\\}\\}/g}" +``` + + * Use the `moduleId` argument to specify the AMD module ID of Lo-Dash, which defaults to “lodashâ€, used by precompiled templates. +```bash +lodash moduleId="underscore" +``` + +All arguments, except `legacy` with `csp` or `mobile`, may be combined.
+Unless specified by `-o` or `--output`, all files created are saved to the current working directory. + +The following options are also supported: + + * `-c`, `--stdout` Write output to standard output + * `-d`, `--debug` Write only the debug output + * `-h`, `--help` Display help information + * `-m`, `--minify` Write only the minified output + * `-o`, `--output` Write output to a given path/filename + * `-s`, `--silent` Skip status updates normally logged to the console + * `-V`, `--version` Output current version of Lo-Dash + +The `lodash` command-line utility is available when Lo-Dash is installed as a global package (i.e. `npm install -g lodash`). + +## Installation and usage + +In browsers: + +```html + +``` + +Using [npm](http://npmjs.org/): + +```bash +npm install lodash + +npm install -g lodash +npm link lodash +``` + +In [Node.js](http://nodejs.org/) and [RingoJS v0.8.0+](http://ringojs.org/): + +```js +var _ = require('lodash'); +``` + +**Note:** If Lo-Dash is installed globally, [run `npm link lodash`](http://blog.nodejs.org/2011/03/23/npm-1-0-global-vs-local-installation/) in your project’s root directory before requiring it. + +In [RingoJS v0.7.0-](http://ringojs.org/): + +```js +var _ = require('lodash')._; +``` + +In [Rhino](http://www.mozilla.org/rhino/): + +```js +load('lodash.js'); +``` + +In an AMD loader like [RequireJS](http://requirejs.org/): + +```js +require({ + 'paths': { + 'underscore': 'path/to/lodash' + } +}, +['underscore'], function(_) { + console.log(_.VERSION); +}); +``` + +## Resolved Underscore.js issues + + * Allow iteration of objects with a `length` property [[#799](https://github.com/documentcloud/underscore/pull/799), [test](https://github.com/bestiejs/lodash/blob/v0.9.2/test/test.js#L545-551)] + * Fix cross-browser object iteration bugs [[#60](https://github.com/documentcloud/underscore/issues/60), [#376](https://github.com/documentcloud/underscore/issues/376), [test](https://github.com/bestiejs/lodash/blob/v0.9.2/test/test.js#L558-582)] + * Methods should work on pages with incorrectly shimmed native methods [[#7](https://github.com/documentcloud/underscore/issues/7), [#742](https://github.com/documentcloud/underscore/issues/742), [test](https://github.com/bestiejs/lodash/blob/v0.9.2/test/test.js#L140-146)] + * `_.isEmpty` should support jQuery/MooTools DOM query collections [[#690](https://github.com/documentcloud/underscore/pull/690), [test](https://github.com/bestiejs/lodash/blob/v0.9.2/test/test.js#L747-752)] + * `_.isObject` should avoid V8 bug [#2291](http://code.google.com/p/v8/issues/detail?id=2291) [[#605](https://github.com/documentcloud/underscore/issues/605), [test](https://github.com/bestiejs/lodash/blob/v0.9.2/test/test.js#L828-840)] + * `_.keys` should work with `arguments` objects cross-browser [[#396](https://github.com/documentcloud/underscore/issues/396), [test](https://github.com/bestiejs/lodash/blob/v0.9.2/test/test.js#L921-923)] + * `_.range` should coerce arguments to numbers [[#634](https://github.com/documentcloud/underscore/issues/634), [#683](https://github.com/documentcloud/underscore/issues/683), [test](https://github.com/bestiejs/lodash/blob/v0.9.2/test/test.js#L1337-1340)] + +## Release Notes + +### v0.9.2 + + * Added `fromIndex` argument to `_.contains` + * Added `moduleId` build option + * Added Closure Compiler *“simpleâ€* optimizations to the build process + * Added support for strings in `_.max` and `_.min` + * Added support for ES6 template delimiters to `_.template` + * Ensured re-minification of Lo-Dash by third parties avoids Closure Compiler bugs + * Optimized `_.every`, `_.find`, `_.some`, and `_.uniq` + +The full changelog is available [here](https://github.com/bestiejs/lodash/wiki/Changelog). + +## BestieJS + +Lo-Dash is part of the BestieJS *“Best in Classâ€* module collection. This means we promote solid browser/environment support, ES5 precedents, unit testing, and plenty of documentation. + +## Author + +* [John-David Dalton](http://allyoucanleet.com/) + [](https://twitter.com/jdalton "Follow @jdalton on Twitter") + +## Contributors + +* [Kit Cambridge](http://kitcambridge.github.com/) + [](https://twitter.com/kitcambridge "Follow @kitcambridge on Twitter") +* [Mathias Bynens](http://mathiasbynens.be/) + [](https://twitter.com/mathias "Follow @mathias on Twitter") diff --git a/Phaser/node_modules/grunt/node_modules/lodash/doc/README.md b/Phaser/node_modules/grunt/node_modules/lodash/doc/README.md new file mode 100644 index 00000000..8ad38fb4 --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/lodash/doc/README.md @@ -0,0 +1,3095 @@ +# Lo-Dash v0.9.2 + + + + + + +## `Arrays` +* [`_.compact`](#_compactarray) +* [`_.difference`](#_differencearray--array1-array2-) +* [`_.drop`](#_restarray--n1) +* [`_.first`](#_firstarray--n) +* [`_.flatten`](#_flattenarray-shallow) +* [`_.head`](#_firstarray--n) +* [`_.indexOf`](#_indexofarray-value--fromindex0) +* [`_.initial`](#_initialarray--n1) +* [`_.intersection`](#_intersectionarray1-array2-) +* [`_.last`](#_lastarray--n) +* [`_.lastIndexOf`](#_lastindexofarray-value--fromindexarraylength-1) +* [`_.object`](#_objectkeys--values) +* [`_.range`](#_rangestart0-end--step1) +* [`_.rest`](#_restarray--n1) +* [`_.sortedIndex`](#_sortedindexarray-value--callbackidentityproperty-thisarg) +* [`_.tail`](#_restarray--n1) +* [`_.take`](#_firstarray--n) +* [`_.union`](#_unionarray1-array2-) +* [`_.uniq`](#_uniqarray--issortedfalse-callbackidentity-thisarg) +* [`_.unique`](#_uniqarray--issortedfalse-callbackidentity-thisarg) +* [`_.without`](#_withoutarray--value1-value2-) +* [`_.zip`](#_ziparray1-array2-) + + + + + + +## `Chaining` +* [`_`](#_value) +* [`_.chain`](#_chainvalue) +* [`_.tap`](#_tapvalue-interceptor) +* [`_.prototype.chain`](#_prototypechain) +* [`_.prototype.value`](#_prototypevalue) + + + + + + +## `Collections` +* [`_.all`](#_everycollection--callbackidentity-thisarg) +* [`_.any`](#_somecollection--callbackidentity-thisarg) +* [`_.collect`](#_mapcollection--callbackidentity-thisarg) +* [`_.contains`](#_containscollection-target--fromindex0) +* [`_.countBy`](#_countbycollection-callbackproperty--thisarg) +* [`_.detect`](#_findcollection-callback--thisarg) +* [`_.each`](#_foreachcollection-callback--thisarg) +* [`_.every`](#_everycollection--callbackidentity-thisarg) +* [`_.filter`](#_filtercollection--callbackidentity-thisarg) +* [`_.find`](#_findcollection-callback--thisarg) +* [`_.foldl`](#_reducecollection-callback--accumulator-thisarg) +* [`_.foldr`](#_reducerightcollection-callback--accumulator-thisarg) +* [`_.forEach`](#_foreachcollection-callback--thisarg) +* [`_.groupBy`](#_groupbycollection-callbackproperty--thisarg) +* [`_.include`](#_containscollection-target--fromindex0) +* [`_.inject`](#_reducecollection-callback--accumulator-thisarg) +* [`_.invoke`](#_invokecollection-methodname--arg1-arg2-) +* [`_.map`](#_mapcollection--callbackidentity-thisarg) +* [`_.max`](#_maxcollection--callback-thisarg) +* [`_.min`](#_mincollection--callback-thisarg) +* [`_.pluck`](#_pluckcollection-property) +* [`_.reduce`](#_reducecollection-callback--accumulator-thisarg) +* [`_.reduceRight`](#_reducerightcollection-callback--accumulator-thisarg) +* [`_.reject`](#_rejectcollection--callbackidentity-thisarg) +* [`_.select`](#_filtercollection--callbackidentity-thisarg) +* [`_.shuffle`](#_shufflecollection) +* [`_.size`](#_sizecollection) +* [`_.some`](#_somecollection--callbackidentity-thisarg) +* [`_.sortBy`](#_sortbycollection-callbackproperty--thisarg) +* [`_.toArray`](#_toarraycollection) +* [`_.where`](#_wherecollection-properties) + + + + + + +## `Functions` +* [`_.after`](#_aftern-func) +* [`_.bind`](#_bindfunc--thisarg-arg1-arg2-) +* [`_.bindAll`](#_bindallobject--methodname1-methodname2-) +* [`_.compose`](#_composefunc1-func2-) +* [`_.debounce`](#_debouncefunc-wait-immediate) +* [`_.defer`](#_deferfunc--arg1-arg2-) +* [`_.delay`](#_delayfunc-wait--arg1-arg2-) +* [`_.lateBind`](#_latebindobject-methodname--arg1-arg2-) +* [`_.memoize`](#_memoizefunc--resolver) +* [`_.once`](#_oncefunc) +* [`_.partial`](#_partialfunc--arg1-arg2-) +* [`_.throttle`](#_throttlefunc-wait) +* [`_.wrap`](#_wrapvalue-wrapper) + + + + + + +## `Objects` +* [`_.clone`](#_clonevalue-deep) +* [`_.defaults`](#_defaultsobject--default1-default2-) +* [`_.extend`](#_extendobject--source1-source2-) +* [`_.forIn`](#_forinobject-callback--thisarg) +* [`_.forOwn`](#_forownobject-callback--thisarg) +* [`_.functions`](#_functionsobject) +* [`_.has`](#_hasobject-property) +* [`_.invert`](#_invertobject) +* [`_.isArguments`](#_isargumentsvalue) +* [`_.isArray`](#_isarrayvalue) +* [`_.isBoolean`](#_isbooleanvalue) +* [`_.isDate`](#_isdatevalue) +* [`_.isElement`](#_iselementvalue) +* [`_.isEmpty`](#_isemptyvalue) +* [`_.isEqual`](#_isequala-b) +* [`_.isFinite`](#_isfinitevalue) +* [`_.isFunction`](#_isfunctionvalue) +* [`_.isNaN`](#_isnanvalue) +* [`_.isNull`](#_isnullvalue) +* [`_.isNumber`](#_isnumbervalue) +* [`_.isObject`](#_isobjectvalue) +* [`_.isPlainObject`](#_isplainobjectvalue) +* [`_.isRegExp`](#_isregexpvalue) +* [`_.isString`](#_isstringvalue) +* [`_.isUndefined`](#_isundefinedvalue) +* [`_.keys`](#_keysobject) +* [`_.merge`](#_mergeobject--source1-source2-) +* [`_.methods`](#_functionsobject) +* [`_.omit`](#_omitobject-callback-prop1-prop2--thisarg) +* [`_.pairs`](#_pairsobject) +* [`_.pick`](#_pickobject-callback-prop1-prop2--thisarg) +* [`_.values`](#_valuesobject) + + + + + + +## `Utilities` +* [`_.escape`](#_escapestring) +* [`_.identity`](#_identityvalue) +* [`_.mixin`](#_mixinobject) +* [`_.noConflict`](#_noconflict) +* [`_.random`](#_randommin0-max1) +* [`_.result`](#_resultobject-property) +* [`_.template`](#_templatetext-data-options) +* [`_.times`](#_timesn-callback--thisarg) +* [`_.unescape`](#_unescapestring) +* [`_.uniqueId`](#_uniqueidprefix) + + + + + + +## `Properties` +* [`_.VERSION`](#_version) +* [`_.templateSettings`](#_templatesettings) +* [`_.templateSettings.escape`](#_templatesettingsescape) +* [`_.templateSettings.evaluate`](#_templatesettingsevaluate) +* [`_.templateSettings.interpolate`](#_templatesettingsinterpolate) +* [`_.templateSettings.variable`](#_templatesettingsvariable) + + + + + + + + + + + + +## `“Arrays†Methods` + + + +### `_.compact(array)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2554 "View in source") [Ⓣ][1] + +Creates an array with all falsey values of `array` removed. The values `false`, `null`, `0`, `""`, `undefined` and `NaN` are all falsey. + +#### Arguments +1. `array` *(Array)*: The array to compact. + +#### Returns +*(Array)*: Returns a new filtered array. + +#### Example +```js +_.compact([0, 1, false, 2, '', 3]); +// => [1, 2, 3] +``` + +* * * + + + + + + +### `_.difference(array [, array1, array2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2584 "View in source") [Ⓣ][1] + +Creates an array of `array` elements not present in the other arrays using strict equality for comparisons, i.e. `===`. + +#### Arguments +1. `array` *(Array)*: The array to process. +2. `[array1, array2, ...]` *(Array)*: Arrays to check. + +#### Returns +*(Array)*: Returns a new array of `array` elements not present in the other arrays. + +#### Example +```js +_.difference([1, 2, 3, 4, 5], [5, 2, 10]); +// => [1, 3, 4] +``` + +* * * + + + + + + +### `_.first(array [, n])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2619 "View in source") [Ⓣ][1] + +Gets the first element of the `array`. Pass `n` to return the first `n` elements of the `array`. + +#### Aliases +*head, take* + +#### Arguments +1. `array` *(Array)*: The array to query. +2. `[n]` *(Number)*: The number of elements to return. + +#### Returns +*(Mixed)*: Returns the first element or an array of the first `n` elements of `array`. + +#### Example +```js +_.first([5, 4, 3, 2, 1]); +// => 5 +``` + +* * * + + + + + + +### `_.flatten(array, shallow)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2643 "View in source") [Ⓣ][1] + +Flattens a nested array *(the nesting can be to any depth)*. If `shallow` is truthy, `array` will only be flattened a single level. + +#### Arguments +1. `array` *(Array)*: The array to compact. +2. `shallow` *(Boolean)*: A flag to indicate only flattening a single level. + +#### Returns +*(Array)*: Returns a new flattened array. + +#### Example +```js +_.flatten([1, [2], [3, [[4]]]]); +// => [1, 2, 3, 4]; + +_.flatten([1, [2], [3, [[4]]]], true); +// => [1, 2, 3, [[4]]]; +``` + +* * * + + + + + + +### `_.indexOf(array, value [, fromIndex=0])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2685 "View in source") [Ⓣ][1] + +Gets the index at which the first occurrence of `value` is found using strict equality for comparisons, i.e. `===`. If the `array` is already sorted, passing `true` for `fromIndex` will run a faster binary search. + +#### Arguments +1. `array` *(Array)*: The array to search. +2. `value` *(Mixed)*: The value to search for. +3. `[fromIndex=0]` *(Boolean|Number)*: The index to search from or `true` to perform a binary search on a sorted `array`. + +#### Returns +*(Number)*: Returns the index of the matched value or `-1`. + +#### Example +```js +_.indexOf([1, 2, 3, 1, 2, 3], 2); +// => 1 + +_.indexOf([1, 2, 3, 1, 2, 3], 2, 3); +// => 4 + +_.indexOf([1, 1, 2, 2, 3, 3], 2, true); +// => 2 +``` + +* * * + + + + + + +### `_.initial(array [, n=1])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2720 "View in source") [Ⓣ][1] + +Gets all but the last element of `array`. Pass `n` to exclude the last `n` elements from the result. + +#### Arguments +1. `array` *(Array)*: The array to query. +2. `[n=1]` *(Number)*: The number of elements to exclude. + +#### Returns +*(Array)*: Returns all but the last element or `n` elements of `array`. + +#### Example +```js +_.initial([3, 2, 1]); +// => [3, 2] +``` + +* * * + + + + + + +### `_.intersection([array1, array2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2741 "View in source") [Ⓣ][1] + +Computes the intersection of all the passed-in arrays using strict equality for comparisons, i.e. `===`. + +#### Arguments +1. `[array1, array2, ...]` *(Array)*: Arrays to process. + +#### Returns +*(Array)*: Returns a new array of unique elements, in order, that are present in **all** of the arrays. + +#### Example +```js +_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]); +// => [1, 2] +``` + +* * * + + + + + + +### `_.last(array [, n])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2779 "View in source") [Ⓣ][1] + +Gets the last element of the `array`. Pass `n` to return the last `n` elements of the `array`. + +#### Arguments +1. `array` *(Array)*: The array to query. +2. `[n]` *(Number)*: The number of elements to return. + +#### Returns +*(Mixed)*: Returns the last element or an array of the last `n` elements of `array`. + +#### Example +```js +_.last([3, 2, 1]); +// => 1 +``` + +* * * + + + + + + +### `_.lastIndexOf(array, value [, fromIndex=array.length-1])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2806 "View in source") [Ⓣ][1] + +Gets the index at which the last occurrence of `value` is found using strict equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the offset from the end of the collection. + +#### Arguments +1. `array` *(Array)*: The array to search. +2. `value` *(Mixed)*: The value to search for. +3. `[fromIndex=array.length-1]` *(Number)*: The index to search from. + +#### Returns +*(Number)*: Returns the index of the matched value or `-1`. + +#### Example +```js +_.lastIndexOf([1, 2, 3, 1, 2, 3], 2); +// => 4 + +_.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3); +// => 1 +``` + +* * * + + + + + + +### `_.object(keys [, values=[]])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2836 "View in source") [Ⓣ][1] + +Creates an object composed from arrays of `keys` and `values`. Pass either a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`, or two arrays, one of `keys` and one of corresponding `values`. + +#### Arguments +1. `keys` *(Array)*: The array of keys. +2. `[values=[]]` *(Array)*: The array of values. + +#### Returns +*(Object)*: Returns an object composed of the given keys and corresponding values. + +#### Example +```js +_.object(['moe', 'larry', 'curly'], [30, 40, 50]); +// => { 'moe': 30, 'larry': 40, 'curly': 50 } +``` + +* * * + + + + + + +### `_.range([start=0], end [, step=1])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2881 "View in source") [Ⓣ][1] + +Creates an array of numbers *(positive and/or negative)* progressing from `start` up to but not including `stop`. This method is a port of Python's `range()` function. See http://docs.python.org/library/functions.html#range. + +#### Arguments +1. `[start=0]` *(Number)*: The start of the range. +2. `end` *(Number)*: The end of the range. +3. `[step=1]` *(Number)*: The value to increment or descrement by. + +#### Returns +*(Array)*: Returns a new range array. + +#### Example +```js +_.range(10); +// => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + +_.range(1, 11); +// => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + +_.range(0, 30, 5); +// => [0, 5, 10, 15, 20, 25] + +_.range(0, -10, -1); +// => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] + +_.range(0); +// => [] +``` + +* * * + + + + + + +### `_.rest(array [, n=1])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2920 "View in source") [Ⓣ][1] + +The opposite of `_.initial`, this method gets all but the first value of `array`. Pass `n` to exclude the first `n` values from the result. + +#### Aliases +*drop, tail* + +#### Arguments +1. `array` *(Array)*: The array to query. +2. `[n=1]` *(Number)*: The number of elements to exclude. + +#### Returns +*(Array)*: Returns all but the first value or `n` values of `array`. + +#### Example +```js +_.rest([3, 2, 1]); +// => [2, 1] +``` + +* * * + + + + + + +### `_.sortedIndex(array, value [, callback=identity|property, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2966 "View in source") [Ⓣ][1] + +Uses a binary search to determine the smallest index at which the `value` should be inserted into `array` in order to maintain the sort order of the sorted `array`. If `callback` is passed, it will be executed for `value` and each element in `array` to compute their sort ranking. The `callback` is bound to `thisArg` and invoked with one argument; *(value)*. The `callback` argument may also be the name of a property to order by. + +#### Arguments +1. `array` *(Array)*: The array to iterate over. +2. `value` *(Mixed)*: The value to evaluate. +3. `[callback=identity|property]` *(Function|String)*: The function called per iteration or property name to order by. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Number)*: Returns the index at which the value should be inserted into `array`. + +#### Example +```js +_.sortedIndex([20, 30, 50], 40); +// => 2 + +_.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x'); +// => 2 + +var dict = { + 'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 } +}; + +_.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { + return dict.wordToNumber[word]; +}); +// => 2 + +_.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) { + return this.wordToNumber[word]; +}, dict); +// => 2 +``` + +* * * + + + + + + +### `_.union([array1, array2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2997 "View in source") [Ⓣ][1] + +Computes the union of the passed-in arrays using strict equality for comparisons, i.e. `===`. + +#### Arguments +1. `[array1, array2, ...]` *(Array)*: Arrays to process. + +#### Returns +*(Array)*: Returns a new array of unique values, in order, that are present in one or more of the arrays. + +#### Example +```js +_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]); +// => [1, 2, 3, 101, 10] +``` + +* * * + + + + + + +### `_.uniq(array [, isSorted=false, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3031 "View in source") [Ⓣ][1] + +Creates a duplicate-value-free version of the `array` using strict equality for comparisons, i.e. `===`. If the `array` is already sorted, passing `true` for `isSorted` will run a faster algorithm. If `callback` is passed, each element of `array` is passed through a callback` before uniqueness is computed. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index, array)*. + +#### Aliases +*unique* + +#### Arguments +1. `array` *(Array)*: The array to process. +2. `[isSorted=false]` *(Boolean)*: A flag to indicate that the `array` is already sorted. +3. `[callback=identity]` *(Function)*: The function called per iteration. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a duplicate-value-free array. + +#### Example +```js +_.uniq([1, 2, 1, 3, 1]); +// => [1, 2, 3] + +_.uniq([1, 1, 2, 2, 3], true); +// => [1, 2, 3] + +_.uniq([1, 2, 1.5, 3, 2.5], function(num) { return Math.floor(num); }); +// => [1, 2, 3] + +_.uniq([1, 2, 1.5, 3, 2.5], function(num) { return this.floor(num); }, Math); +// => [1, 2, 3] +``` + +* * * + + + + + + +### `_.without(array [, value1, value2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3089 "View in source") [Ⓣ][1] + +Creates an array with all occurrences of the passed values removed using strict equality for comparisons, i.e. `===`. + +#### Arguments +1. `array` *(Array)*: The array to filter. +2. `[value1, value2, ...]` *(Mixed)*: Values to remove. + +#### Returns +*(Array)*: Returns a new filtered array. + +#### Example +```js +_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); +// => [2, 3, 4] +``` + +* * * + + + + + + +### `_.zip([array1, array2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3120 "View in source") [Ⓣ][1] + +Groups the elements of each array at their corresponding indexes. Useful for separate data sources that are coordinated through matching array indexes. For a matrix of nested arrays, `_.zip.apply(...)` can transpose the matrix in a similar fashion. + +#### Arguments +1. `[array1, array2, ...]` *(Array)*: Arrays to process. + +#### Returns +*(Array)*: Returns a new array of grouped elements. + +#### Example +```js +_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]); +// => [['moe', 30, true], ['larry', 40, false], ['curly', 50, false]] +``` + +* * * + + + + + + + + + +## `“Chaining†Methods` + + + +### `_(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L242 "View in source") [Ⓣ][1] + +The `lodash` function. + +#### Arguments +1. `value` *(Mixed)*: The value to wrap in a `lodash` instance. + +#### Returns +*(Object)*: Returns a `lodash` instance. + +* * * + + + + + + +### `_.chain(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3985 "View in source") [Ⓣ][1] + +Wraps the value in a `lodash` wrapper object. + +#### Arguments +1. `value` *(Mixed)*: The value to wrap. + +#### Returns +*(Object)*: Returns the wrapper object. + +#### Example +```js +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 }, + { 'name': 'curly', 'age': 60 } +]; + +var youngest = _.chain(stooges) + .sortBy(function(stooge) { return stooge.age; }) + .map(function(stooge) { return stooge.name + ' is ' + stooge.age; }) + .first() + .value(); +// => 'moe is 40' +``` + +* * * + + + + + + +### `_.tap(value, interceptor)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4012 "View in source") [Ⓣ][1] + +Invokes `interceptor` with the `value` as the first argument, and then returns `value`. The purpose of this method is to "tap into" a method chain, in order to perform operations on intermediate results within the chain. + +#### Arguments +1. `value` *(Mixed)*: The value to pass to `interceptor`. +2. `interceptor` *(Function)*: The function to invoke. + +#### Returns +*(Mixed)*: Returns `value`. + +#### Example +```js +_.chain([1, 2, 3, 200]) + .filter(function(num) { return num % 2 == 0; }) + .tap(alert) + .map(function(num) { return num * num }) + .value(); +// => // [2, 200] (alerted) +// => [4, 40000] +``` + +* * * + + + + + + +### `_.prototype.chain()` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4030 "View in source") [Ⓣ][1] + +Enables method chaining on the wrapper object. + +#### Returns +*(Mixed)*: Returns the wrapper object. + +#### Example +```js +_([1, 2, 3]).value(); +// => [1, 2, 3] +``` + +* * * + + + + + + +### `_.prototype.value()` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L4047 "View in source") [Ⓣ][1] + +Extracts the wrapped value. + +#### Returns +*(Mixed)*: Returns the wrapped value. + +#### Example +```js +_([1, 2, 3]).value(); +// => [1, 2, 3] +``` + +* * * + + + + + + + + + +## `“Collections†Methods` + + + +### `_.contains(collection, target [, fromIndex=0])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1837 "View in source") [Ⓣ][1] + +Checks if a given `target` element is present in a `collection` using strict equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used as the offset from the end of the collection. + +#### Aliases +*include* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `target` *(Mixed)*: The value to check for. +3. `[fromIndex=0]` *(Number)*: The index to search from. + +#### Returns +*(Boolean)*: Returns `true` if the `target` element is found, else `false`. + +#### Example +```js +_.contains([1, 2, 3], 1); +// => true + +_.contains([1, 2, 3], 1, 2); +// => false + +_.contains({ 'name': 'moe', 'age': 40 }, 'moe'); +// => true + +_.contains('curly', 'ur'); +// => true +``` + +* * * + + + + + + +### `_.countBy(collection, callback|property [, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1879 "View in source") [Ⓣ][1] + +Creates an object composed of keys returned from running each element of `collection` through a `callback`. The corresponding value of each key is the number of times the key was returned by `callback`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. The `callback` argument may also be the name of a property to count by *(e.g. 'length')*. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `callback|property` *(Function|String)*: The function called per iteration or property name to count by. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns the composed aggregate object. + +#### Example +```js +_.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); }); +// => { '4': 1, '6': 2 } + +_.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math); +// => { '4': 1, '6': 2 } + +_.countBy(['one', 'two', 'three'], 'length'); +// => { '3': 2, '5': 1 } +``` + +* * * + + + + + + +### `_.every(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1908 "View in source") [Ⓣ][1] + +Checks if the `callback` returns a truthy value for **all** elements of a `collection`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +#### Aliases +*all* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Boolean)*: Returns `true` if all elements pass the callback check, else `false`. + +#### Example +```js +_.every([true, 1, null, 'yes'], Boolean); +// => false +``` + +* * * + + + + + + +### `_.filter(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1947 "View in source") [Ⓣ][1] + +Examines each element in a `collection`, returning an array of all elements the `callback` returns truthy for. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +#### Aliases +*select* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a new array of elements that passed the callback check. + +#### Example +```js +var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); +// => [2, 4, 6] +``` + +* * * + + + + + + +### `_.find(collection, callback [, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1978 "View in source") [Ⓣ][1] + +Examines each element in a `collection`, returning the first one the `callback` returns truthy for. The function returns as soon as it finds an acceptable element, and does not iterate over the entire `collection`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +#### Aliases +*detect* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `callback` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the element that passed the callback check, else `undefined`. + +#### Example +```js +var even = _.find([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); +// => 2 +``` + +* * * + + + + + + +### `_.forEach(collection, callback [, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2012 "View in source") [Ⓣ][1] + +Iterates over a `collection`, executing the `callback` for each element in the `collection`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. Callbacks may exit iteration early by explicitly returning `false`. + +#### Aliases +*each* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `callback` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array, Object, String)*: Returns `collection`. + +#### Example +```js +_([1, 2, 3]).forEach(alert).join(','); +// => alerts each number and returns '1,2,3' + +_.forEach({ 'one': 1, 'two': 2, 'three': 3 }, alert); +// => alerts each number (order is not guaranteed) +``` + +* * * + + + + + + +### `_.groupBy(collection, callback|property [, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2040 "View in source") [Ⓣ][1] + +Creates an object composed of keys returned from running each element of `collection` through a `callback`. The corresponding value of each key is an array of elements passed to `callback` that returned the key. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. The `callback` argument may also be the name of a property to group by *(e.g. 'length')*. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `callback|property` *(Function|String)*: The function called per iteration or property name to group by. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns the composed aggregate object. + +#### Example +```js +_.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); }); +// => { '4': [4.2], '6': [6.1, 6.4] } + +_.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math); +// => { '4': [4.2], '6': [6.1, 6.4] } + +_.groupBy(['one', 'two', 'three'], 'length'); +// => { '3': ['one', 'two'], '5': ['three'] } +``` + +* * * + + + + + + +### `_.invoke(collection, methodName [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2072 "View in source") [Ⓣ][1] + +Invokes the method named by `methodName` on each element in the `collection`, returning an array of the results of each invoked method. Additional arguments will be passed to each invoked method. If `methodName` is a function it will be invoked for, and `this` bound to, each element in the `collection`. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `methodName` *(Function|String)*: The name of the method to invoke or the function invoked per iteration. +3. `[arg1, arg2, ...]` *(Mixed)*: Arguments to invoke the method with. + +#### Returns +*(Array)*: Returns a new array of the results of each invoked method. + +#### Example +```js +_.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); +// => [[1, 5, 7], [1, 2, 3]] + +_.invoke([123, 456], String.prototype.split, ''); +// => [['1', '2', '3'], ['4', '5', '6']] +``` + +* * * + + + + + + +### `_.map(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2104 "View in source") [Ⓣ][1] + +Creates an array of values by running each element in the `collection` through a `callback`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +#### Aliases +*collect* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a new array of the results of each `callback` execution. + +#### Example +```js +_.map([1, 2, 3], function(num) { return num * 3; }); +// => [3, 6, 9] + +_.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; }); +// => [3, 6, 9] (order is not guaranteed) +``` + +* * * + + + + + + +### `_.max(collection [, callback, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2146 "View in source") [Ⓣ][1] + +Retrieves the maximum value of an `array`. If `callback` is passed, it will be executed for each value in the `array` to generate the criterion by which the value is ranked. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index, collection)*. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback]` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the maximum value. + +#### Example +```js +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 }, + { 'name': 'curly', 'age': 60 } +]; + +_.max(stooges, function(stooge) { return stooge.age; }); +// => { 'name': 'curly', 'age': 60 }; +``` + +* * * + + + + + + +### `_.min(collection [, callback, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2192 "View in source") [Ⓣ][1] + +Retrieves the minimum value of an `array`. If `callback` is passed, it will be executed for each value in the `array` to generate the criterion by which the value is ranked. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index, collection)*. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback]` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the minimum value. + +#### Example +```js +_.min([10, 5, 100, 2, 1000]); +// => 2 +``` + +* * * + + + + + + +### `_.pluck(collection, property)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2241 "View in source") [Ⓣ][1] + +Retrieves the value of a specified property from all elements in the `collection`. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `property` *(String)*: The property to pluck. + +#### Returns +*(Array)*: Returns a new array of property values. + +#### Example +```js +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 }, + { 'name': 'curly', 'age': 60 } +]; + +_.pluck(stooges, 'name'); +// => ['moe', 'larry', 'curly'] +``` + +* * * + + + + + + +### `_.reduce(collection, callback [, accumulator, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2269 "View in source") [Ⓣ][1] + +Boils down a `collection` to a single value. The initial state of the reduction is `accumulator` and each successive step of it should be returned by the `callback`. The `callback` is bound to `thisArg` and invoked with `4` arguments; for arrays they are *(accumulator, value, index|key, collection)*. + +#### Aliases +*foldl, inject* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `callback` *(Function)*: The function called per iteration. +3. `[accumulator]` *(Mixed)*: Initial value of the accumulator. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the accumulated value. + +#### Example +```js +var sum = _.reduce([1, 2, 3], function(memo, num) { return memo + num; }); +// => 6 +``` + +* * * + + + + + + +### `_.reduceRight(collection, callback [, accumulator, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2298 "View in source") [Ⓣ][1] + +The right-associative version of `_.reduce`. + +#### Aliases +*foldr* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `callback` *(Function)*: The function called per iteration. +3. `[accumulator]` *(Mixed)*: Initial value of the accumulator. +4. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Mixed)*: Returns the accumulated value. + +#### Example +```js +var list = [[0, 1], [2, 3], [4, 5]]; +var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []); +// => [4, 5, 2, 3, 0, 1] +``` + +* * * + + + + + + +### `_.reject(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2335 "View in source") [Ⓣ][1] + +The opposite of `_.filter`, this method returns the values of a `collection` that `callback` does **not** return truthy for. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a new array of elements that did **not** pass the callback check. + +#### Example +```js +var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); +// => [1, 3, 5] +``` + +* * * + + + + + + +### `_.shuffle(collection)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2356 "View in source") [Ⓣ][1] + +Creates an array of shuffled `array` values, using a version of the Fisher-Yates shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to shuffle. + +#### Returns +*(Array)*: Returns a new shuffled collection. + +#### Example +```js +_.shuffle([1, 2, 3, 4, 5, 6]); +// => [4, 1, 6, 3, 5, 2] +``` + +* * * + + + + + + +### `_.size(collection)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2388 "View in source") [Ⓣ][1] + +Gets the size of the `collection` by returning `collection.length` for arrays and array-like objects or the number of own enumerable properties for objects. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to inspect. + +#### Returns +*(Number)*: Returns `collection.length` or number of own enumerable properties. + +#### Example +```js +_.size([1, 2]); +// => 2 + +_.size({ 'one': 1, 'two': 2, 'three': 3 }); +// => 3 + +_.size('curly'); +// => 5 +``` + +* * * + + + + + + +### `_.some(collection [, callback=identity, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2413 "View in source") [Ⓣ][1] + +Checks if the `callback` returns a truthy value for **any** element of a `collection`. The function returns as soon as it finds passing value, and does not iterate over the entire `collection`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. + +#### Aliases +*any* + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `[callback=identity]` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Boolean)*: Returns `true` if any element passes the callback check, else `false`. + +#### Example +```js +_.some([null, 0, 'yes', false]); +// => true +``` + +* * * + + + + + + +### `_.sortBy(collection, callback|property [, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2459 "View in source") [Ⓣ][1] + +Creates an array, stable sorted in ascending order by the results of running each element of `collection` through a `callback`. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, index|key, collection)*. The `callback` argument may also be the name of a property to sort by *(e.g. 'length')*. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `callback|property` *(Function|String)*: The function called per iteration or property name to sort by. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Array)*: Returns a new array of sorted elements. + +#### Example +```js +_.sortBy([1, 2, 3], function(num) { return Math.sin(num); }); +// => [3, 1, 2] + +_.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math); +// => [3, 1, 2] + +_.sortBy(['larry', 'brendan', 'moe'], 'length'); +// => ['moe', 'larry', 'brendan'] +``` + +* * * + + + + + + +### `_.toArray(collection)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2491 "View in source") [Ⓣ][1] + +Converts the `collection`, to an array. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to convert. + +#### Returns +*(Array)*: Returns the new converted array. + +#### Example +```js +(function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4); +// => [2, 3, 4] +``` + +* * * + + + + + + +### `_.where(collection, properties)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L2521 "View in source") [Ⓣ][1] + +Examines each element in a `collection`, returning an array of all elements that contain the given `properties`. + +#### Arguments +1. `collection` *(Array|Object|String)*: The collection to iterate over. +2. `properties` *(Object)*: The object of property values to filter by. + +#### Returns +*(Array)*: Returns a new array of elements that contain the given `properties`. + +#### Example +```js +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 }, + { 'name': 'curly', 'age': 60 } +]; + +_.where(stooges, { 'age': 40 }); +// => [{ 'name': 'moe', 'age': 40 }] +``` + +* * * + + + + + + + + + +## `“Functions†Methods` + + + +### `_.after(n, func)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3153 "View in source") [Ⓣ][1] + +Creates a function that is restricted to executing `func` only after it is called `n` times. The `func` is executed with the `this` binding of the created function. + +#### Arguments +1. `n` *(Number)*: The number of times the function must be called before it is executed. +2. `func` *(Function)*: The function to restrict. + +#### Returns +*(Function)*: Returns the new restricted function. + +#### Example +```js +var renderNotes = _.after(notes.length, render); +_.forEach(notes, function(note) { + note.asyncSave({ 'success': renderNotes }); +}); +// `renderNotes` is run once, after all notes have saved +``` + +* * * + + + + + + +### `_.bind(func [, thisArg, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3186 "View in source") [Ⓣ][1] + +Creates a function that, when called, invokes `func` with the `this` binding of `thisArg` and prepends any additional `bind` arguments to those passed to the bound function. + +#### Arguments +1. `func` *(Function)*: The function to bind. +2. `[thisArg]` *(Mixed)*: The `this` binding of `func`. +3. `[arg1, arg2, ...]` *(Mixed)*: Arguments to be partially applied. + +#### Returns +*(Function)*: Returns the new bound function. + +#### Example +```js +var func = function(greeting) { + return greeting + ' ' + this.name; +}; + +func = _.bind(func, { 'name': 'moe' }, 'hi'); +func(); +// => 'hi moe' +``` + +* * * + + + + + + +### `_.bindAll(object [, methodName1, methodName2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3216 "View in source") [Ⓣ][1] + +Binds methods on `object` to `object`, overwriting the existing method. If no method names are provided, all the function properties of `object` will be bound. + +#### Arguments +1. `object` *(Object)*: The object to bind and assign the bound methods to. +2. `[methodName1, methodName2, ...]` *(String)*: Method names on the object to bind. + +#### Returns +*(Object)*: Returns `object`. + +#### Example +```js +var buttonView = { + 'label': 'lodash', + 'onClick': function() { alert('clicked: ' + this.label); } +}; + +_.bindAll(buttonView); +jQuery('#lodash_button').on('click', buttonView.onClick); +// => When the button is clicked, `this.label` will have the correct value +``` + +* * * + + + + + + +### `_.compose([func1, func2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3247 "View in source") [Ⓣ][1] + +Creates a function that is the composition of the passed functions, where each function consumes the return value of the function that follows. In math terms, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`. Each function is executed with the `this` binding of the composed function. + +#### Arguments +1. `[func1, func2, ...]` *(Function)*: Functions to compose. + +#### Returns +*(Function)*: Returns the new composed function. + +#### Example +```js +var greet = function(name) { return 'hi: ' + name; }; +var exclaim = function(statement) { return statement + '!'; }; +var welcome = _.compose(exclaim, greet); +welcome('moe'); +// => 'hi: moe!' +``` + +* * * + + + + + + +### `_.debounce(func, wait, immediate)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3280 "View in source") [Ⓣ][1] + +Creates a function that will delay the execution of `func` until after `wait` milliseconds have elapsed since the last time it was invoked. Pass `true` for `immediate` to cause debounce to invoke `func` on the leading, instead of the trailing, edge of the `wait` timeout. Subsequent calls to the debounced function will return the result of the last `func` call. + +#### Arguments +1. `func` *(Function)*: The function to debounce. +2. `wait` *(Number)*: The number of milliseconds to delay. +3. `immediate` *(Boolean)*: A flag to indicate execution is on the leading edge of the timeout. + +#### Returns +*(Function)*: Returns the new debounced function. + +#### Example +```js +var lazyLayout = _.debounce(calculateLayout, 300); +jQuery(window).on('resize', lazyLayout); +``` + +* * * + + + + + + +### `_.defer(func [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3344 "View in source") [Ⓣ][1] + +Defers executing the `func` function until the current call stack has cleared. Additional arguments will be passed to `func` when it is invoked. + +#### Arguments +1. `func` *(Function)*: The function to defer. +2. `[arg1, arg2, ...]` *(Mixed)*: Arguments to invoke the function with. + +#### Returns +*(Number)*: Returns the `setTimeout` timeout id. + +#### Example +```js +_.defer(function() { alert('deferred'); }); +// returns from the function before `alert` is called +``` + +* * * + + + + + + +### `_.delay(func, wait [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3324 "View in source") [Ⓣ][1] + +Executes the `func` function after `wait` milliseconds. Additional arguments will be passed to `func` when it is invoked. + +#### Arguments +1. `func` *(Function)*: The function to delay. +2. `wait` *(Number)*: The number of milliseconds to delay execution. +3. `[arg1, arg2, ...]` *(Mixed)*: Arguments to invoke the function with. + +#### Returns +*(Number)*: Returns the `setTimeout` timeout id. + +#### Example +```js +var log = _.bind(console.log, console); +_.delay(log, 1000, 'logged later'); +// => 'logged later' (Appears after one second.) +``` + +* * * + + + + + + +### `_.lateBind(object, methodName [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3382 "View in source") [Ⓣ][1] + +Creates a function that, when called, invokes `object[methodName]` and prepends any additional `lateBind` arguments to those passed to the bound function. This method differs from `_.bind` by allowing bound functions to reference methods that will be redefined or don't yet exist. + +#### Arguments +1. `object` *(Object)*: The object the method belongs to. +2. `methodName` *(String)*: The method name. +3. `[arg1, arg2, ...]` *(Mixed)*: Arguments to be partially applied. + +#### Returns +*(Function)*: Returns the new bound function. + +#### Example +```js +var object = { + 'name': 'moe', + 'greet': function(greeting) { + return greeting + ' ' + this.name; + } +}; + +var func = _.lateBind(object, 'greet', 'hi'); +func(); +// => 'hi moe' + +object.greet = function(greeting) { + return greeting + ', ' + this.name + '!'; +}; + +func(); +// => 'hi, moe!' +``` + +* * * + + + + + + +### `_.memoize(func [, resolver])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3405 "View in source") [Ⓣ][1] + +Creates a function that memoizes the result of `func`. If `resolver` is passed, it will be used to determine the cache key for storing the result based on the arguments passed to the memoized function. By default, the first argument passed to the memoized function is used as the cache key. The `func` is executed with the `this` binding of the memoized function. + +#### Arguments +1. `func` *(Function)*: The function to have its output memoized. +2. `[resolver]` *(Function)*: A function used to resolve the cache key. + +#### Returns +*(Function)*: Returns the new memoizing function. + +#### Example +```js +var fibonacci = _.memoize(function(n) { + return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2); +}); +``` + +* * * + + + + + + +### `_.once(func)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3432 "View in source") [Ⓣ][1] + +Creates a function that is restricted to execute `func` once. Repeat calls to the function will return the value of the first call. The `func` is executed with the `this` binding of the created function. + +#### Arguments +1. `func` *(Function)*: The function to restrict. + +#### Returns +*(Function)*: Returns the new restricted function. + +#### Example +```js +var initialize = _.once(createApplication); +initialize(); +initialize(); +// Application is only created once. +``` + +* * * + + + + + + +### `_.partial(func [, arg1, arg2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3467 "View in source") [Ⓣ][1] + +Creates a function that, when called, invokes `func` with any additional `partial` arguments prepended to those passed to the new function. This method is similar to `bind`, except it does **not** alter the `this` binding. + +#### Arguments +1. `func` *(Function)*: The function to partially apply arguments to. +2. `[arg1, arg2, ...]` *(Mixed)*: Arguments to be partially applied. + +#### Returns +*(Function)*: Returns the new partially applied function. + +#### Example +```js +var greet = function(greeting, name) { return greeting + ': ' + name; }; +var hi = _.partial(greet, 'hi'); +hi('moe'); +// => 'hi: moe' +``` + +* * * + + + + + + +### `_.throttle(func, wait)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3489 "View in source") [Ⓣ][1] + +Creates a function that, when executed, will only call the `func` function at most once per every `wait` milliseconds. If the throttled function is invoked more than once during the `wait` timeout, `func` will also be called on the trailing edge of the timeout. Subsequent calls to the throttled function will return the result of the last `func` call. + +#### Arguments +1. `func` *(Function)*: The function to throttle. +2. `wait` *(Number)*: The number of milliseconds to throttle executions to. + +#### Returns +*(Function)*: Returns the new throttled function. + +#### Example +```js +var throttled = _.throttle(updatePosition, 100); +jQuery(window).on('scroll', throttled); +``` + +* * * + + + + + + +### `_.wrap(value, wrapper)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3541 "View in source") [Ⓣ][1] + +Creates a function that passes `value` to the `wrapper` function as its first argument. Additional arguments passed to the function are appended to those passed to the `wrapper` function. The `wrapper` is executed with the `this` binding of the created function. + +#### Arguments +1. `value` *(Mixed)*: The value to wrap. +2. `wrapper` *(Function)*: The wrapper function. + +#### Returns +*(Function)*: Returns the new function. + +#### Example +```js +var hello = function(name) { return 'hello ' + name; }; +hello = _.wrap(hello, function(func) { + return 'before, ' + func('moe') + ', after'; +}); +hello(); +// => 'before, hello moe, after' +``` + +* * * + + + + + + + + + +## `“Objects†Methods` + + + +### `_.clone(value, deep)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L896 "View in source") [Ⓣ][1] + +Creates a clone of `value`. If `deep` is `true`, all nested objects will also be cloned otherwise they will be assigned by reference. Functions, DOM nodes, `arguments` objects, and objects created by constructors other than `Object` are **not** cloned. + +#### Arguments +1. `value` *(Mixed)*: The value to clone. +2. `deep` *(Boolean)*: A flag to indicate a deep clone. + +#### Returns +*(Mixed)*: Returns the cloned `value`. + +#### Example +```js +var stooges = [ + { 'name': 'moe', 'age': 40 }, + { 'name': 'larry', 'age': 50 }, + { 'name': 'curly', 'age': 60 } +]; + +_.clone({ 'name': 'moe' }); +// => { 'name': 'moe' } + +var shallow = _.clone(stooges); +shallow[0] === stooges[0]; +// => true + +var deep = _.clone(stooges, true); +shallow[0] === stooges[0]; +// => false +``` + +* * * + + + + + + +### `_.defaults(object [, default1, default2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L979 "View in source") [Ⓣ][1] + +Assigns enumerable properties of the default object(s) to the `destination` object for all `destination` properties that resolve to `null`/`undefined`. Once a property is set, additional defaults of the same property will be ignored. + +#### Arguments +1. `object` *(Object)*: The destination object. +2. `[default1, default2, ...]` *(Object)*: The default objects. + +#### Returns +*(Object)*: Returns the destination object. + +#### Example +```js +var iceCream = { 'flavor': 'chocolate' }; +_.defaults(iceCream, { 'flavor': 'vanilla', 'sprinkles': 'rainbow' }); +// => { 'flavor': 'chocolate', 'sprinkles': 'rainbow' } +``` + +* * * + + + + + + +### `_.extend(object [, source1, source2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L999 "View in source") [Ⓣ][1] + +Assigns enumerable properties of the source object(s) to the `destination` object. Subsequent sources will overwrite propery assignments of previous sources. + +#### Arguments +1. `object` *(Object)*: The destination object. +2. `[source1, source2, ...]` *(Object)*: The source objects. + +#### Returns +*(Object)*: Returns the destination object. + +#### Example +```js +_.extend({ 'name': 'moe' }, { 'age': 40 }); +// => { 'name': 'moe', 'age': 40 } +``` + +* * * + + + + + + +### `_.forIn(object, callback [, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L754 "View in source") [Ⓣ][1] + +Iterates over `object`'s own and inherited enumerable properties, executing the `callback` for each property. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, key, object)*. Callbacks may exit iteration early by explicitly returning `false`. + +#### Arguments +1. `object` *(Object)*: The object to iterate over. +2. `callback` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns `object`. + +#### Example +```js +function Dog(name) { + this.name = name; +} + +Dog.prototype.bark = function() { + alert('Woof, woof!'); +}; + +_.forIn(new Dog('Dagny'), function(value, key) { + alert(key); +}); +// => alerts 'name' and 'bark' (order is not guaranteed) +``` + +* * * + + + + + + +### `_.forOwn(object, callback [, thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L778 "View in source") [Ⓣ][1] + +Iterates over `object`'s own enumerable properties, executing the `callback` for each property. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, key, object)*. Callbacks may exit iteration early by explicitly returning `false`. + +#### Arguments +1. `object` *(Object)*: The object to iterate over. +2. `callback` *(Function)*: The function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns `object`. + +#### Example +```js +_.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) { + alert(key); +}); +// => alerts '0', '1', and 'length' (order is not guaranteed) +``` + +* * * + + + + + + +### `_.functions(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1016 "View in source") [Ⓣ][1] + +Creates a sorted array of all enumerable properties, own and inherited, of `object` that have function values. + +#### Aliases +*methods* + +#### Arguments +1. `object` *(Object)*: The object to inspect. + +#### Returns +*(Array)*: Returns a new array of property names that have function values. + +#### Example +```js +_.functions(_); +// => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...] +``` + +* * * + + + + + + +### `_.has(object, property)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1041 "View in source") [Ⓣ][1] + +Checks if the specified object `property` exists and is a direct property, instead of an inherited property. + +#### Arguments +1. `object` *(Object)*: The object to check. +2. `property` *(String)*: The property to check for. + +#### Returns +*(Boolean)*: Returns `true` if key is a direct property, else `false`. + +#### Example +```js +_.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b'); +// => true +``` + +* * * + + + + + + +### `_.invert(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1058 "View in source") [Ⓣ][1] + +Creates an object composed of the inverted keys and values of the given `object`. + +#### Arguments +1. `object` *(Object)*: The object to invert. + +#### Returns +*(Object)*: Returns the created inverted object. + +#### Example +```js +_.invert({ 'first': 'Moe', 'second': 'Larry', 'third': 'Curly' }); +// => { 'Moe': 'first', 'Larry': 'second', 'Curly': 'third' } (order is not guaranteed) +``` + +* * * + + + + + + +### `_.isArguments(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L716 "View in source") [Ⓣ][1] + +Checks if `value` is an `arguments` object. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is an `arguments` object, else `false`. + +#### Example +```js +(function() { return _.isArguments(arguments); })(1, 2, 3); +// => true + +_.isArguments([1, 2, 3]); +// => false +``` + +* * * + + + + + + +### `_.isArray(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1082 "View in source") [Ⓣ][1] + +Checks if `value` is an array. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is an array, else `false`. + +#### Example +```js +(function() { return _.isArray(arguments); })(); +// => false + +_.isArray([1, 2, 3]); +// => true +``` + +* * * + + + + + + +### `_.isBoolean(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1099 "View in source") [Ⓣ][1] + +Checks if `value` is a boolean *(`true` or `false`)* value. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is a boolean value, else `false`. + +#### Example +```js +_.isBoolean(null); +// => false +``` + +* * * + + + + + + +### `_.isDate(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1116 "View in source") [Ⓣ][1] + +Checks if `value` is a date. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is a date, else `false`. + +#### Example +```js +_.isDate(new Date); +// => true +``` + +* * * + + + + + + +### `_.isElement(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1133 "View in source") [Ⓣ][1] + +Checks if `value` is a DOM element. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is a DOM element, else `false`. + +#### Example +```js +_.isElement(document.body); +// => true +``` + +* * * + + + + + + +### `_.isEmpty(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1158 "View in source") [Ⓣ][1] + +Checks if `value` is empty. Arrays, strings, or `arguments` objects with a length of `0` and objects with no own enumerable properties are considered "empty". + +#### Arguments +1. `value` *(Array|Object|String)*: The value to inspect. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is empty, else `false`. + +#### Example +```js +_.isEmpty([1, 2, 3]); +// => false + +_.isEmpty({}); +// => true + +_.isEmpty(''); +// => true +``` + +* * * + + + + + + +### `_.isEqual(a, b)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1200 "View in source") [Ⓣ][1] + +Performs a deep comparison between two values to determine if they are equivalent to each other. + +#### Arguments +1. `a` *(Mixed)*: The value to compare. +2. `b` *(Mixed)*: The other value to compare. + +#### Returns +*(Boolean)*: Returns `true` if the values are equvalent, else `false`. + +#### Example +```js +var moe = { 'name': 'moe', 'luckyNumbers': [13, 27, 34] }; +var clone = { 'name': 'moe', 'luckyNumbers': [13, 27, 34] }; + +moe == clone; +// => false + +_.isEqual(moe, clone); +// => true +``` + +* * * + + + + + + +### `_.isFinite(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1362 "View in source") [Ⓣ][1] + +Checks if `value` is, or can be coerced to, a finite number. Note: This is not the same as native `isFinite`, which will return true for booleans and empty strings. See http://es5.github.com/#x15.1.2.5. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is a finite number, else `false`. + +#### Example +```js +_.isFinite(-101); +// => true + +_.isFinite('10'); +// => true + +_.isFinite(true); +// => false + +_.isFinite(''); +// => false + +_.isFinite(Infinity); +// => false +``` + +* * * + + + + + + +### `_.isFunction(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1379 "View in source") [Ⓣ][1] + +Checks if `value` is a function. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is a function, else `false`. + +#### Example +```js +_.isFunction(_); +// => true +``` + +* * * + + + + + + +### `_.isNaN(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1443 "View in source") [Ⓣ][1] + +Checks if `value` is `NaN`. Note: This is not the same as native `isNaN`, which will return true for `undefined` and other values. See http://es5.github.com/#x15.1.2.4. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is `NaN`, else `false`. + +#### Example +```js +_.isNaN(NaN); +// => true + +_.isNaN(new Number(NaN)); +// => true + +isNaN(undefined); +// => true + +_.isNaN(undefined); +// => false +``` + +* * * + + + + + + +### `_.isNull(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1466 "View in source") [Ⓣ][1] + +Checks if `value` is `null`. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is `null`, else `false`. + +#### Example +```js +_.isNull(null); +// => true + +_.isNull(undefined); +// => false +``` + +* * * + + + + + + +### `_.isNumber(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1483 "View in source") [Ⓣ][1] + +Checks if `value` is a number. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is a number, else `false`. + +#### Example +```js +_.isNumber(8.4 * 5); +// => true +``` + +* * * + + + + + + +### `_.isObject(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1409 "View in source") [Ⓣ][1] + +Checks if `value` is the language type of Object. *(e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)* + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is an object, else `false`. + +#### Example +```js +_.isObject({}); +// => true + +_.isObject([1, 2, 3]); +// => true + +_.isObject(1); +// => false +``` + +* * * + + + + + + +### `_.isPlainObject(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1511 "View in source") [Ⓣ][1] + +Checks if a given `value` is an object created by the `Object` constructor. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if `value` is a plain object, else `false`. + +#### Example +```js +function Stooge(name, age) { + this.name = name; + this.age = age; +} + +_.isPlainObject(new Stooge('moe', 40)); +// => false + +_.isPlainObject([1, 2, 3]); +// => false + +_.isPlainObject({ 'name': 'moe', 'age': 40 }); +// => true +``` + +* * * + + + + + + +### `_.isRegExp(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1536 "View in source") [Ⓣ][1] + +Checks if `value` is a regular expression. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is a regular expression, else `false`. + +#### Example +```js +_.isRegExp(/moe/); +// => true +``` + +* * * + + + + + + +### `_.isString(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1553 "View in source") [Ⓣ][1] + +Checks if `value` is a string. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is a string, else `false`. + +#### Example +```js +_.isString('moe'); +// => true +``` + +* * * + + + + + + +### `_.isUndefined(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1571 "View in source") [Ⓣ][1] + +Checks if `value` is `undefined`. + +#### Arguments +1. `value` *(Mixed)*: The value to check. + +#### Returns +*(Boolean)*: Returns `true` if the `value` is `undefined`, else `false`. + +#### Example +```js +_.isUndefined(void 0); +// => true +``` + +* * * + + + + + + +### `_.keys(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1588 "View in source") [Ⓣ][1] + +Creates an array composed of the own enumerable property names of `object`. + +#### Arguments +1. `object` *(Object)*: The object to inspect. + +#### Returns +*(Array)*: Returns a new array of property names. + +#### Example +```js +_.keys({ 'one': 1, 'two': 2, 'three': 3 }); +// => ['one', 'two', 'three'] (order is not guaranteed) +``` + +* * * + + + + + + +### `_.merge(object [, source1, source2, ...])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1626 "View in source") [Ⓣ][1] + +Merges enumerable properties of the source object(s) into the `destination` object. Subsequent sources will overwrite propery assignments of previous sources. + +#### Arguments +1. `object` *(Object)*: The destination object. +2. `[source1, source2, ...]` *(Object)*: The source objects. + +#### Returns +*(Object)*: Returns the destination object. + +#### Example +```js +var stooges = [ + { 'name': 'moe' }, + { 'name': 'larry' } +]; + +var ages = [ + { 'age': 40 }, + { 'age': 50 } +]; + +_.merge(stooges, ages); +// => [{ 'name': 'moe', 'age': 40 }, { 'name': 'larry', 'age': 50 }] +``` + +* * * + + + + + + +### `_.omit(object, callback|[prop1, prop2, ..., thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1696 "View in source") [Ⓣ][1] + +Creates a shallow clone of `object` excluding the specified properties. Property names may be specified as individual arguments or as arrays of property names. If `callback` is passed, it will be executed for each property in the `object`, omitting the properties `callback` returns truthy for. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, key, object)*. + +#### Arguments +1. `object` *(Object)*: The source object. +2. `callback|[prop1, prop2, ...]` *(Function|String)*: The properties to omit or the function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns an object without the omitted properties. + +#### Example +```js +_.omit({ 'name': 'moe', 'age': 40, 'userid': 'moe1' }, 'userid'); +// => { 'name': 'moe', 'age': 40 } + +_.omit({ 'name': 'moe', '_hint': 'knucklehead', '_seed': '96c4eb' }, function(value, key) { + return key.charAt(0) == '_'; +}); +// => { 'name': 'moe' } +``` + +* * * + + + + + + +### `_.pairs(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1730 "View in source") [Ⓣ][1] + +Creates a two dimensional array of the given object's key-value pairs, i.e. `[[key1, value1], [key2, value2]]`. + +#### Arguments +1. `object` *(Object)*: The object to inspect. + +#### Returns +*(Array)*: Returns new array of key-value pairs. + +#### Example +```js +_.pairs({ 'moe': 30, 'larry': 40, 'curly': 50 }); +// => [['moe', 30], ['larry', 40], ['curly', 50]] (order is not guaranteed) +``` + +* * * + + + + + + +### `_.pick(object, callback|[prop1, prop2, ..., thisArg])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1763 "View in source") [Ⓣ][1] + +Creates a shallow clone of `object` composed of the specified properties. Property names may be specified as individual arguments or as arrays of property names. If `callback` is passed, it will be executed for each property in the `object`, picking the properties `callback` returns truthy for. The `callback` is bound to `thisArg` and invoked with three arguments; *(value, key, object)*. + +#### Arguments +1. `object` *(Object)*: The source object. +2. `callback|[prop1, prop2, ...]` *(Function|String)*: The properties to pick or the function called per iteration. +3. `[thisArg]` *(Mixed)*: The `this` binding of `callback`. + +#### Returns +*(Object)*: Returns an object composed of the picked properties. + +#### Example +```js +_.pick({ 'name': 'moe', 'age': 40, 'userid': 'moe1' }, 'name', 'age'); +// => { 'name': 'moe', 'age': 40 } + +_.pick({ 'name': 'moe', '_hint': 'knucklehead', '_seed': '96c4eb' }, function(value, key) { + return key.charAt(0) != '_'; +}); +// => { 'name': 'moe' } +``` + +* * * + + + + + + +### `_.values(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L1800 "View in source") [Ⓣ][1] + +Creates an array composed of the own enumerable property values of `object`. + +#### Arguments +1. `object` *(Object)*: The object to inspect. + +#### Returns +*(Array)*: Returns a new array of property values. + +#### Example +```js +_.values({ 'one': 1, 'two': 2, 'three': 3 }); +// => [1, 2, 3] +``` + +* * * + + + + + + + + + +## `“Utilities†Methods` + + + +### `_.escape(string)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3565 "View in source") [Ⓣ][1] + +Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their corresponding HTML entities. + +#### Arguments +1. `string` *(String)*: The string to escape. + +#### Returns +*(String)*: Returns the escaped string. + +#### Example +```js +_.escape('Moe, Larry & Curly'); +// => "Moe, Larry & Curly" +``` + +* * * + + + + + + +### `_.identity(value)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3585 "View in source") [Ⓣ][1] + +This function returns the first argument passed to it. Note: It is used throughout Lo-Dash as a default callback. + +#### Arguments +1. `value` *(Mixed)*: Any value. + +#### Returns +*(Mixed)*: Returns `value`. + +#### Example +```js +var moe = { 'name': 'moe' }; +moe === _.identity(moe); +// => true +``` + +* * * + + + + + + +### `_.mixin(object)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3611 "View in source") [Ⓣ][1] + +Adds functions properties of `object` to the `lodash` function and chainable wrapper. + +#### Arguments +1. `object` *(Object)*: The object of function properties to add to `lodash`. + +#### Example +```js +_.mixin({ + 'capitalize': function(string) { + return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase(); + } +}); + +_.capitalize('larry'); +// => 'Larry' + +_('curly').capitalize(); +// => 'Curly' +``` + +* * * + + + + + + +### `_.noConflict()` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3641 "View in source") [Ⓣ][1] + +Reverts the '_' variable to its previous value and returns a reference to the `lodash` function. + +#### Returns +*(Function)*: Returns the `lodash` function. + +#### Example +```js +var lodash = _.noConflict(); +``` + +* * * + + + + + + +### `_.random([min=0, max=1])` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3664 "View in source") [Ⓣ][1] + +Produces a random number between `min` and `max` *(inclusive)*. If only one argument is passed, a number between `0` and the given number will be returned. + +#### Arguments +1. `[min=0]` *(Number)*: The minimum possible value. +2. `[max=1]` *(Number)*: The maximum possible value. + +#### Returns +*(Number)*: Returns a random number. + +#### Example +```js +_.random(0, 5); +// => a number between 1 and 5 + +_.random(5); +// => also a number between 1 and 5 +``` + +* * * + + + + + + +### `_.result(object, property)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3703 "View in source") [Ⓣ][1] + +Resolves the value of `property` on `object`. If `property` is a function it will be invoked and its result returned, else the property value is returned. If `object` is falsey, then `null` is returned. + +#### Arguments +1. `object` *(Object)*: The object to inspect. +2. `property` *(String)*: The property to get the value of. + +#### Returns +*(Mixed)*: Returns the resolved value. + +#### Example +```js +var object = { + 'cheese': 'crumpets', + 'stuff': function() { + return 'nonsense'; + } +}; + +_.result(object, 'cheese'); +// => 'crumpets' + +_.result(object, 'stuff'); +// => 'nonsense' +``` + +* * * + + + + + + +### `_.template(text, data, options)` +# [Ⓢ](https://github.com/bestiejs/lodash/blob/master/lodash.js#L3788 "View in source") [Ⓣ][1] + +A micro-templating method that handles arbitrary delimiters, preserves whitespace, and correctly escapes quotes within interpolated code. Note: In the development build `_.template` utilizes sourceURLs for easier debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl Note: Lo-Dash may be used in Chrome extensions by either creating a `lodash csp` build and avoiding `_.template` use, or loading Lo-Dash in a sandboxed page. See http://developer.chrome.com/trunk/extensions/sandboxingEval.html + +#### Arguments +1. `text` *(String)*: The template text. +2. `data` *(Obect)*: The data object used to populate the text. +3. `options` *(Object)*: The options object. escape - The "escape" delimiter regexp. evaluate - The "evaluate" delimiter regexp. interpolate - The "interpolate" delimiter regexp. sourceURL - The sourceURL of the template's compiled source. variable - The data object variable name. + +#### Returns +*(Function, String)*: Returns a compiled function when no `data` object is given, else it returns the interpolated text. + +#### Example +```js +// using a compiled template +var compiled = _.template('hello <%= name %>'); +compiled({ 'name': 'moe' }); +// => 'hello moe' + +var list = '<% _.forEach(people, function(name) { %>
-
+<% _.forEach(people, function(name) { %>
- <%= name %> <% }); %> +
Blah blah blah
').escapeHTML();
+=> '<div>Blah blah blah</div>'
+```
+
+**unescapeHTML** _.unescapeHTML(string)
+
+Converts entity characters to HTML equivalents.
+
+```javascript
+_('<div>Blah blah blah</div>').unescapeHTML();
+=> 'Blah blah blah
'
+```
+
+**insert** _.insert(string, index, substing)
+
+```javascript
+_('Hello ').insert(6, 'world')
+=> 'Hello world'
+```
+
+**isBlank** _.isBlank(string)
+
+```javascript
+_('').isBlank(); // => true
+_('\n').isBlank(); // => true
+_(' ').isBlank(); // => true
+_('a').isBlank(); // => false
+```
+
+**join** _.join(separator, *strings)
+
+Joins strings together with given separator
+
+```javascript
+_.join(" ", "foo", "bar")
+=> "foo bar"
+```
+
+**lines** _.lines(str)
+
+```javascript
+_.lines("Hello\nWorld")
+=> ["Hello", "World"]
+```
+
+**reverse** available only through _.str object, because Underscore has function with the same name.
+
+Return reversed string:
+
+```javascript
+_.str.reverse("foobar")
+=> 'raboof'
+```
+
+**splice** _.splice(string, index, howmany, substring)
+
+Like a array splice.
+
+```javascript
+_('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli')
+=> 'https://edtsech@bitbucket.org/epeli/underscore.strings'
+```
+
+**startsWith** _.startsWith(string, starts)
+
+This method checks whether string starts with starts.
+
+```javascript
+_("image.gif").startsWith("image")
+=> true
+```
+
+**endsWith** _.endsWith(string, ends)
+
+This method checks whether string ends with ends.
+
+```javascript
+_("image.gif").endsWith("gif")
+=> true
+```
+
+**succ** _.succ(str)
+
+Returns the successor to str.
+
+```javascript
+_('a').succ()
+=> 'b'
+
+_('A').succ()
+=> 'B'
+```
+
+**supplant**
+
+Supplant function was removed, use Underscore.js [template function][p].
+
+[p]: http://documentcloud.github.com/underscore/#template
+
+**strip** alias for *trim*
+
+**lstrip** alias for *ltrim*
+
+**rstrip** alias for *rtrim*
+
+**titleize** _.titleize(string)
+
+```javascript
+_('my name is epeli').titleize()
+=> 'My Name Is Epeli'
+```
+
+**camelize** _.camelize(string)
+
+Converts underscored or dasherized string to a camelized one
+
+```javascript
+_('-moz-transform').camelize()
+=> 'MozTransform'
+```
+
+**classify** _.classify(string)
+
+Converts string to camelized class name
+
+```javascript
+_('some_class_name').classify()
+=> 'SomeClassName'
+```
+
+**underscored** _.underscored(string)
+
+Converts a camelized or dasherized string into an underscored one
+
+```javascript
+_('MozTransform').underscored()
+=> 'moz_transform'
+```
+
+**dasherize** _.dasherize(string)
+
+Converts a underscored or camelized string into an dasherized one
+
+```javascript
+_('MozTransform').dasherize()
+=> '-moz-transform'
+```
+
+**humanize** _.humanize(string)
+
+Converts an underscored, camelized, or dasherized string into a humanized one.
+Also removes beginning and ending whitespace, and removes the postfix '_id'.
+
+```javascript
+_(' capitalize dash-CamelCase_underscore trim ').humanize()
+=> 'Capitalize dash camel case underscore trim'
+```
+
+**trim** _.trim(string, [characters])
+
+trims defined characters from begining and ending of the string.
+Defaults to whitespace characters.
+
+```javascript
+_.trim(" foobar ")
+=> "foobar"
+
+_.trim("_-foobar-_", "_-")
+=> "foobar"
+```
+
+
+**ltrim** _.ltrim(string, [characters])
+
+Left trim. Similar to trim, but only for left side.
+
+
+**rtrim** _.rtrim(string, [characters])
+
+Right trim. Similar to trim, but only for right side.
+
+**truncate** _.truncate(string, length, truncateString)
+
+```javascript
+_('Hello world').truncate(5)
+=> 'Hello...'
+
+_('Hello').truncate(10)
+=> 'Hello'
+```
+
+**prune** _.prune(string, length, pruneString)
+
+Elegant version of truncate.
+Makes sure the pruned string does not exceed the original length.
+Avoid half-chopped words when truncating.
+
+```javascript
+_('Hello, world').prune(5)
+=> 'Hello...'
+
+_('Hello, world').prune(8)
+=> 'Hello...'
+
+_('Hello, world').prune(5, ' (read a lot more)')
+=> 'Hello, world' (as adding "(read a lot more)" would be longer than the original string)
+
+_('Hello, cruel world').prune(15)
+=> 'Hello, cruel...'
+
+_('Hello').prune(10)
+=> 'Hello'
+```
+
+**words** _.words(str, delimiter=" ")
+
+Split string by delimiter (String or RegExp), ' ' by default.
+
+```javascript
+_.words("I love you")
+=> ["I","love","you"]
+
+_.words("I_love_you", "_")
+=> ["I","love","you"]
+
+_.words("I-love-you", /-/)
+=> ["I","love","you"]
+```
+
+**sprintf** _.sprintf(string format, *arguments)
+
+C like string formatting.
+Credits goes to [Alexandru Marasteanu][o].
+For more detailed documentation, see the [original page][o].
+
+[o]: http://www.diveintojavascript.com/projects/sprintf-for-javascript
+
+```javascript
+_.sprintf("%.1f", 1.17)
+"1.2"
+```
+
+**pad** _.pad(str, length, [padStr, type])
+
+pads the `str` with characters until the total string length is equal to the passed `length` parameter. By default, pads on the **left** with the space char (`" "`). `padStr` is truncated to a single character if necessary.
+
+```javascript
+_.pad("1", 8)
+-> " 1";
+
+_.pad("1", 8, '0')
+-> "00000001";
+
+_.pad("1", 8, '0', 'right')
+-> "10000000";
+
+_.pad("1", 8, '0', 'both')
+-> "00001000";
+
+_.pad("1", 8, 'bleepblorp', 'both')
+-> "bbbb1bbb";
+```
+
+**lpad** _.lpad(str, length, [padStr])
+
+left-pad a string. Alias for `pad(str, length, padStr, 'left')`
+
+```javascript
+_.lpad("1", 8, '0')
+-> "00000001";
+```
+
+**rpad** _.rpad(str, length, [padStr])
+
+right-pad a string. Alias for `pad(str, length, padStr, 'right')`
+
+```javascript
+_.rpad("1", 8, '0')
+-> "10000000";
+```
+
+**lrpad** _.lrpad(str, length, [padStr])
+
+left/right-pad a string. Alias for `pad(str, length, padStr, 'both')`
+
+```javascript
+_.lrpad("1", 8, '0')
+-> "00001000";
+```
+
+**center** alias for **lrpad**
+
+**ljust** alias for *rpad*
+
+**rjust** alias for *lpad*
+
+**toNumber** _.toNumber(string, [decimals])
+
+Parse string to number. Returns NaN if string can't be parsed to number.
+
+```javascript
+_('2.556').toNumber()
+=> 3
+
+_('2.556').toNumber(1)
+=> 2.6
+```
+
+**strRight** _.strRight(string, pattern)
+
+Searches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strRight('_')
+=> "is_a_test_string";
+```
+
+**strRightBack** _.strRightBack(string, pattern)
+
+Searches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strRightBack('_')
+=> "string";
+```
+
+**strLeft** _.strLeft(string, pattern)
+
+Searches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strLeft('_')
+=> "This";
+```
+
+**strLeftBack** _.strLeftBack(string, pattern)
+
+Searches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.
+
+```javascript
+_('This_is_a_test_string').strLeftBack('_')
+=> "This_is_a_test";
+```
+
+**stripTags**
+
+Removes all html tags from string.
+
+```javascript
+_('a link').stripTags()
+=> 'a link'
+
+_('a link').stripTags()
+=> 'a linkalert("hello world!")'
+```
+
+**toSentence** _.toSentence(array, [delimiter, lastDelimiter])
+
+Join an array into a human readable sentence.
+
+```javascript
+_.toSentence(['jQuery', 'Mootools', 'Prototype'])
+=> 'jQuery, Mootools and Prototype';
+
+_.toSentence(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ')
+=> 'jQuery, Mootools unt Prototype';
+```
+
+**repeat** _.repeat(string, count, [separator])
+
+Repeats a string count times.
+
+```javascript
+_.repeat("foo", 3)
+=> 'foofoofoo';
+
+_.repeat("foo", 3, "bar")
+=> 'foobarfoobarfoo'
+```
+
+**slugify** _.slugify(string)
+
+Transform text into a URL slug. Replaces whitespaces, accentuated, and special characters with a dash.
+
+```javascript
+_.slugify("Un éléphant à l'orée du bois")
+=> 'un-elephant-a-loree-du-bois';
+```
+
+***Caution: this function is charset dependent***
+
+## Roadmap ##
+
+Any suggestions or bug reports are welcome. Just email me or more preferably open an issue.
+
+## Changelog ##
+
+### 2.0.0 ###
+
+* Added prune, humanize functions
+* Added _.string (_.str) namespace for Underscore.string library
+* Removed includes function
+
+#### Problems
+
+We lose two things for `include` and `reverse` methods from `_.string`:
+
+* Calls like `_('foobar').include('bar')` aren't available;
+* Chaining isn't available too.
+
+But if you need this functionality you can create aliases for conflict functions which will be convenient for you:
+
+```javascript
+_.mixin({
+ includeString: _.str.include,
+ reverseString: _.str.reverse
+})
+
+// Now wrapper calls and chaining are available.
+_('foobar').chain().reverseString().includeString('rab').value()
+```
+
+#### Standalone Usage
+
+If you are using Underscore.string without Underscore. You also have `_.string` namespace for it and `_.str` alias
+But of course you can just reassign `_` variable with `_.string`
+
+```javascript
+_ = _.string
+```
+### 2.2.0 ###
+
+* Capitalize method behavior changed
+* Various perfomance tweaks
+
+### 2.1.1###
+
+* Fixed words method bug
+* Added classify method
+
+### 2.1.0 ###
+
+* AMD support
+* Added toSentence method
+* Added slugify method
+* Lots of speed optimizations
+
+### 2.0.0 ###
+
+For upgrading to this version you need to mix in Underscore.string library to Underscore object:
+
+```javascript
+_.mixin(_.string.exports());
+```
+
+and all non-conflict Underscore.string functions will be available through Underscore object.
+Also function `includes` has been removed, you should replace this function by `_.str.include`
+or create alias `_.includes = _.str.include` and all your code will work fine.
+
+### 1.1.6 ###
+
+* Fixed reverse and truncate
+* Added isBlank, stripTags, inlude(alias for includes)
+* Added uglifier compression
+
+### 1.1.5 ###
+
+* Added strRight, strRightBack, strLeft, strLeftBack
+
+### 1.1.4 ###
+
+* Added pad, lpad, rpad, lrpad methods and aliases center, ljust, rjust
+* Integration with Underscore 1.1.6
+
+### 1.1.3 ###
+
+* Added methods: underscored, camelize, dasherize
+* Support newer version of npm
+
+### 1.1.2 ###
+
+* Created functions: lines, chars, words functions
+
+### 1.0.2 ###
+
+* Created integration test suite with underscore.js 1.1.4 (now it's absolutely compatible)
+* Removed 'reverse' function, because this function override underscore.js 'reverse'
+
+## Contribute ##
+
+* Fork & pull request. Don't forget about tests.
+* If you planning add some feature please create issue before.
+
+Otherwise changes will be rejected.
+
+## Contributors list ##
+
+* Esa-Matti Suuronen Blah blah blah
').escapeHTML();\n=> '<div>Blah blah blah</div>'\n```\n\n**unescapeHTML** _.unescapeHTML(string)\n\nConverts entity characters to HTML equivalents.\n\n```javascript\n_('<div>Blah blah blah</div>').unescapeHTML();\n=> 'Blah blah blah
'\n```\n\n**insert** _.insert(string, index, substing)\n\n```javascript\n_('Hello ').insert(6, 'world')\n=> 'Hello world'\n```\n\n**isBlank** _.isBlank(string)\n\n```javascript\n_('').isBlank(); // => true\n_('\\n').isBlank(); // => true\n_(' ').isBlank(); // => true\n_('a').isBlank(); // => false\n```\n\n**join** _.join(separator, *strings)\n\nJoins strings together with given separator\n\n```javascript\n_.join(\" \", \"foo\", \"bar\")\n=> \"foo bar\"\n```\n\n**lines** _.lines(str)\n\n```javascript\n_.lines(\"Hello\\nWorld\")\n=> [\"Hello\", \"World\"]\n```\n\n**reverse** available only through _.str object, because Underscore has function with the same name.\n\nReturn reversed string:\n\n```javascript\n_.str.reverse(\"foobar\")\n=> 'raboof'\n```\n\n**splice** _.splice(string, index, howmany, substring)\n\nLike a array splice.\n\n```javascript\n_('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli')\n=> 'https://edtsech@bitbucket.org/epeli/underscore.strings'\n```\n\n**startsWith** _.startsWith(string, starts)\n\nThis method checks whether string starts with starts.\n\n```javascript\n_(\"image.gif\").startsWith(\"image\")\n=> true\n```\n\n**endsWith** _.endsWith(string, ends)\n\nThis method checks whether string ends with ends.\n\n```javascript\n_(\"image.gif\").endsWith(\"gif\")\n=> true\n```\n\n**succ** _.succ(str)\n\nReturns the successor to str.\n\n```javascript\n_('a').succ()\n=> 'b'\n\n_('A').succ()\n=> 'B'\n```\n\n**supplant**\n\nSupplant function was removed, use Underscore.js [template function][p].\n\n[p]: http://documentcloud.github.com/underscore/#template\n\n**strip** alias for *trim*\n\n**lstrip** alias for *ltrim*\n\n**rstrip** alias for *rtrim*\n\n**titleize** _.titleize(string)\n\n```javascript\n_('my name is epeli').titleize()\n=> 'My Name Is Epeli'\n```\n\n**camelize** _.camelize(string)\n\nConverts underscored or dasherized string to a camelized one\n\n```javascript\n_('-moz-transform').camelize()\n=> 'MozTransform'\n```\n\n**classify** _.classify(string)\n\nConverts string to camelized class name\n\n```javascript\n_('some_class_name').classify()\n=> 'SomeClassName'\n```\n\n**underscored** _.underscored(string)\n\nConverts a camelized or dasherized string into an underscored one\n\n```javascript\n_('MozTransform').underscored()\n=> 'moz_transform'\n```\n\n**dasherize** _.dasherize(string)\n\nConverts a underscored or camelized string into an dasherized one\n\n```javascript\n_('MozTransform').dasherize()\n=> '-moz-transform'\n```\n\n**humanize** _.humanize(string)\n\nConverts an underscored, camelized, or dasherized string into a humanized one.\nAlso removes beginning and ending whitespace, and removes the postfix '_id'.\n\n```javascript\n_(' capitalize dash-CamelCase_underscore trim ').humanize()\n=> 'Capitalize dash camel case underscore trim'\n```\n\n**trim** _.trim(string, [characters])\n\ntrims defined characters from begining and ending of the string.\nDefaults to whitespace characters.\n\n```javascript\n_.trim(\" foobar \")\n=> \"foobar\"\n\n_.trim(\"_-foobar-_\", \"_-\")\n=> \"foobar\"\n```\n\n\n**ltrim** _.ltrim(string, [characters])\n\nLeft trim. Similar to trim, but only for left side.\n\n\n**rtrim** _.rtrim(string, [characters])\n\nRight trim. Similar to trim, but only for right side.\n\n**truncate** _.truncate(string, length, truncateString)\n\n```javascript\n_('Hello world').truncate(5)\n=> 'Hello...'\n\n_('Hello').truncate(10)\n=> 'Hello'\n```\n\n**prune** _.prune(string, length, pruneString)\n\nElegant version of truncate.\nMakes sure the pruned string does not exceed the original length.\nAvoid half-chopped words when truncating.\n\n```javascript\n_('Hello, world').prune(5)\n=> 'Hello...'\n\n_('Hello, world').prune(8)\n=> 'Hello...'\n\n_('Hello, world').prune(5, ' (read a lot more)')\n=> 'Hello, world' (as adding \"(read a lot more)\" would be longer than the original string)\n\n_('Hello, cruel world').prune(15)\n=> 'Hello, cruel...'\n\n_('Hello').prune(10)\n=> 'Hello'\n```\n\n**words** _.words(str, delimiter=\" \")\n\nSplit string by delimiter (String or RegExp), ' ' by default.\n\n```javascript\n_.words(\"I love you\")\n=> [\"I\",\"love\",\"you\"]\n\n_.words(\"I_love_you\", \"_\")\n=> [\"I\",\"love\",\"you\"]\n\n_.words(\"I-love-you\", /-/)\n=> [\"I\",\"love\",\"you\"]\n```\n\n**sprintf** _.sprintf(string format, *arguments)\n\nC like string formatting.\nCredits goes to [Alexandru Marasteanu][o].\nFor more detailed documentation, see the [original page][o].\n\n[o]: http://www.diveintojavascript.com/projects/sprintf-for-javascript\n\n```javascript\n_.sprintf(\"%.1f\", 1.17)\n\"1.2\"\n```\n\n**pad** _.pad(str, length, [padStr, type])\n\npads the `str` with characters until the total string length is equal to the passed `length` parameter. By default, pads on the **left** with the space char (`\" \"`). `padStr` is truncated to a single character if necessary.\n\n```javascript\n_.pad(\"1\", 8)\n-> \" 1\";\n\n_.pad(\"1\", 8, '0')\n-> \"00000001\";\n\n_.pad(\"1\", 8, '0', 'right')\n-> \"10000000\";\n\n_.pad(\"1\", 8, '0', 'both')\n-> \"00001000\";\n\n_.pad(\"1\", 8, 'bleepblorp', 'both')\n-> \"bbbb1bbb\";\n```\n\n**lpad** _.lpad(str, length, [padStr])\n\nleft-pad a string. Alias for `pad(str, length, padStr, 'left')`\n\n```javascript\n_.lpad(\"1\", 8, '0')\n-> \"00000001\";\n```\n\n**rpad** _.rpad(str, length, [padStr])\n\nright-pad a string. Alias for `pad(str, length, padStr, 'right')`\n\n```javascript\n_.rpad(\"1\", 8, '0')\n-> \"10000000\";\n```\n\n**lrpad** _.lrpad(str, length, [padStr])\n\nleft/right-pad a string. Alias for `pad(str, length, padStr, 'both')`\n\n```javascript\n_.lrpad(\"1\", 8, '0')\n-> \"00001000\";\n```\n\n**center** alias for **lrpad**\n\n**ljust** alias for *rpad*\n\n**rjust** alias for *lpad*\n\n**toNumber** _.toNumber(string, [decimals])\n\nParse string to number. Returns NaN if string can't be parsed to number.\n\n```javascript\n_('2.556').toNumber()\n=> 3\n\n_('2.556').toNumber(1)\n=> 2.6\n```\n\n**strRight** _.strRight(string, pattern)\n\nSearches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.\n\n```javascript\n_('This_is_a_test_string').strRight('_')\n=> \"is_a_test_string\";\n```\n\n**strRightBack** _.strRightBack(string, pattern)\n\nSearches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.\n\n```javascript\n_('This_is_a_test_string').strRightBack('_')\n=> \"string\";\n```\n\n**strLeft** _.strLeft(string, pattern)\n\nSearches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.\n\n```javascript\n_('This_is_a_test_string').strLeft('_')\n=> \"This\";\n```\n\n**strLeftBack** _.strLeftBack(string, pattern)\n\nSearches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.\n\n```javascript\n_('This_is_a_test_string').strLeftBack('_')\n=> \"This_is_a_test\";\n```\n\n**stripTags**\n\nRemoves all html tags from string.\n\n```javascript\n_('a link').stripTags()\n=> 'a link'\n\n_('a link').stripTags()\n=> 'a linkalert(\"hello world!\")'\n```\n\n**toSentence** _.toSentence(array, [delimiter, lastDelimiter])\n\nJoin an array into a human readable sentence.\n\n```javascript\n_.toSentence(['jQuery', 'Mootools', 'Prototype'])\n=> 'jQuery, Mootools and Prototype';\n\n_.toSentence(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ')\n=> 'jQuery, Mootools unt Prototype';\n```\n\n**repeat** _.repeat(string, count, [separator])\n\nRepeats a string count times.\n\n```javascript\n_.repeat(\"foo\", 3)\n=> 'foofoofoo';\n\n_.repeat(\"foo\", 3, \"bar\")\n=> 'foobarfoobarfoo'\n```\n\n**slugify** _.slugify(string)\n\nTransform text into a URL slug. Replaces whitespaces, accentuated, and special characters with a dash.\n\n```javascript\n_.slugify(\"Un éléphant à l'orée du bois\")\n=> 'un-elephant-a-loree-du-bois';\n```\n\n***Caution: this function is charset dependent***\n\n## Roadmap ##\n\nAny suggestions or bug reports are welcome. Just email me or more preferably open an issue.\n\n## Changelog ##\n\n### 2.0.0 ###\n\n* Added prune, humanize functions\n* Added _.string (_.str) namespace for Underscore.string library\n* Removed includes function\n\n#### Problems\n\nWe lose two things for `include` and `reverse` methods from `_.string`:\n\n* Calls like `_('foobar').include('bar')` aren't available;\n* Chaining isn't available too.\n\nBut if you need this functionality you can create aliases for conflict functions which will be convenient for you:\n\n```javascript\n_.mixin({\n includeString: _.str.include,\n reverseString: _.str.reverse\n})\n\n// Now wrapper calls and chaining are available.\n_('foobar').chain().reverseString().includeString('rab').value()\n```\n\n#### Standalone Usage\n\nIf you are using Underscore.string without Underscore. You also have `_.string` namespace for it and `_.str` alias\nBut of course you can just reassign `_` variable with `_.string`\n\n```javascript\n_ = _.string\n```\n### 2.2.0 ###\n\n* Capitalize method behavior changed\n* Various perfomance tweaks\n\n### 2.1.1###\n\n* Fixed words method bug\n* Added classify method\n\n### 2.1.0 ###\n\n* AMD support\n* Added toSentence method\n* Added slugify method\n* Lots of speed optimizations\n\n### 2.0.0 ###\n\nFor upgrading to this version you need to mix in Underscore.string library to Underscore object:\n\n```javascript\n_.mixin(_.string.exports());\n```\n\nand all non-conflict Underscore.string functions will be available through Underscore object.\nAlso function `includes` has been removed, you should replace this function by `_.str.include`\nor create alias `_.includes = _.str.include` and all your code will work fine.\n\n### 1.1.6 ###\n\n* Fixed reverse and truncate\n* Added isBlank, stripTags, inlude(alias for includes)\n* Added uglifier compression\n\n### 1.1.5 ###\n\n* Added strRight, strRightBack, strLeft, strLeftBack\n\n### 1.1.4 ###\n\n* Added pad, lpad, rpad, lrpad methods and aliases center, ljust, rjust\n* Integration with Underscore 1.1.6\n\n### 1.1.3 ###\n\n* Added methods: underscored, camelize, dasherize\n* Support newer version of npm\n\n### 1.1.2 ###\n\n* Created functions: lines, chars, words functions\n\n### 1.0.2 ###\n\n* Created integration test suite with underscore.js 1.1.4 (now it's absolutely compatible)\n* Removed 'reverse' function, because this function override underscore.js 'reverse'\n\n## Contribute ##\n\n* Fork & pull request. Don't forget about tests.\n* If you planning add some feature please create issue before.\n\nOtherwise changes will be rejected.\n\n## Contributors list ##\n\n* Esa-Matti Suuronen Underscore.string Test Suite
+ + ++
Underscore.string Speed Suite
+ ++ + diff --git a/Phaser/node_modules/grunt/node_modules/underscore.string/test/test_standalone.html b/Phaser/node_modules/grunt/node_modules/underscore.string/test/test_standalone.html new file mode 100644 index 00000000..9854c171 --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/underscore.string/test/test_standalone.html @@ -0,0 +1,18 @@ + + + +
Underscore.string Test Suite
+ + +Underscore Temporary Tests
++ A page for temporary speed tests, used for developing faster implementations + of existing Underscore methods. +
++ + diff --git a/Phaser/node_modules/grunt/node_modules/underscore.string/test/test_underscore/test.html b/Phaser/node_modules/grunt/node_modules/underscore.string/test/test_underscore/test.html new file mode 100644 index 00000000..77f2f3a2 --- /dev/null +++ b/Phaser/node_modules/grunt/node_modules/underscore.string/test/test_underscore/test.html @@ -0,0 +1,43 @@ + + + +
+
+
+ + +
+
+
diff --git a/Phaser/node_modules/grunt/node_modules/underscore.string/test/test_underscore/vendor/qunit.css b/Phaser/node_modules/grunt/node_modules/underscore.string/test/test_underscore/vendor/qunit.css
new file mode 100644
index 00000000..8d0d3a24
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/underscore.string/test/test_underscore/vendor/qunit.css
@@ -0,0 +1,196 @@
+/** Font Family and Sizes */
+
+#qunit-tests, #qunit-header, .qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
+ font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+}
+
+#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
+#qunit-tests { font-size: smaller; }
+
+
+/** Resets */
+
+#qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult {
+ margin: 0;
+ padding: 0;
+}
+
+
+/** Header */
+
+#qunit-header, .qunit-header {
+ padding: 0.5em 0 0.5em 1em;
+
+ color: #8699a4;
+ background-color: #0d3349;
+
+ font-size: 1.5em;
+ line-height: 1em;
+ font-weight: normal;
+
+ border-radius: 15px 15px 0 0;
+ -moz-border-radius: 15px 15px 0 0;
+ -webkit-border-top-right-radius: 15px;
+ -webkit-border-top-left-radius: 15px;
+}
+
+#qunit-header a {
+ text-decoration: none;
+ color: #c2ccd1;
+}
+
+#qunit-header a:hover,
+#qunit-header a:focus {
+ color: #fff;
+}
+
+#qunit-banner {
+ height: 5px;
+}
+
+#qunit-testrunner-toolbar {
+ padding: 0em 0 0.5em 2em;
+}
+
+#qunit-userAgent {
+ padding: 0.5em 0 0.5em 2.5em;
+ background-color: #2b81af;
+ color: #fff;
+ text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+
+
+/** Tests: Pass/Fail */
+
+#qunit-tests {
+ list-style-position: inside;
+}
+
+#qunit-tests li {
+ padding: 0.4em 0.5em 0.4em 2.5em;
+ border-bottom: 1px solid #fff;
+ list-style-position: inside;
+}
+
+#qunit-tests li strong {
+ cursor: pointer;
+}
+
+#qunit-tests ol {
+ margin-top: 0.5em;
+ padding: 0.5em;
+
+ background-color: #fff;
+
+ border-radius: 15px;
+ -moz-border-radius: 15px;
+ -webkit-border-radius: 15px;
+
+ box-shadow: inset 0px 2px 13px #999;
+ -moz-box-shadow: inset 0px 2px 13px #999;
+ -webkit-box-shadow: inset 0px 2px 13px #999;
+}
+
+#qunit-tests table {
+ border-collapse: collapse;
+ margin-top: .2em;
+}
+
+#qunit-tests th {
+ text-align: right;
+ vertical-align: top;
+ padding: 0 .5em 0 0;
+}
+
+#qunit-tests td {
+ vertical-align: top;
+}
+
+#qunit-tests pre {
+ margin: 0;
+ white-space: pre-wrap;
+ word-wrap: break-word;
+}
+
+#qunit-tests del {
+ background-color: #e0f2be;
+ color: #374e0c;
+ text-decoration: none;
+}
+
+#qunit-tests ins {
+ background-color: #ffcaca;
+ color: #500;
+ text-decoration: none;
+}
+
+/*** Test Counts */
+
+#qunit-tests b.counts { color: black; }
+#qunit-tests b.passed { color: #5E740B; }
+#qunit-tests b.failed { color: #710909; }
+
+#qunit-tests li li {
+ margin: 0.5em;
+ padding: 0.4em 0.5em 0.4em 0.5em;
+ background-color: #fff;
+ border-bottom: none;
+ list-style-position: inside;
+}
+
+/*** Passing Styles */
+
+#qunit-tests li li.pass {
+ color: #5E740B;
+ background-color: #fff;
+ border-left: 26px solid #C6E746;
+}
+
+#qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; }
+#qunit-tests .pass .test-name { color: #366097; }
+
+#qunit-tests .pass .test-actual,
+#qunit-tests .pass .test-expected { color: #999999; }
+
+#qunit-banner.qunit-pass { background-color: #C6E746; }
+
+/*** Failing Styles */
+
+#qunit-tests li li.fail {
+ color: #710909;
+ background-color: #fff;
+ border-left: 26px solid #EE5757;
+}
+
+#qunit-tests .fail { color: #000000; background-color: #EE5757; }
+#qunit-tests .fail .test-name,
+#qunit-tests .fail .module-name { color: #000000; }
+
+#qunit-tests .fail .test-actual { color: #EE5757; }
+#qunit-tests .fail .test-expected { color: green; }
+
+#qunit-banner.qunit-fail,
+#qunit-testrunner-toolbar { background-color: #EE5757; }
+
+
+/** Footer */
+
+#qunit-testresult {
+ padding: 0.5em 0.5em 0.5em 2.5em;
+
+ color: #2b81af;
+ background-color: #D2E0E6;
+
+ border-radius: 0 0 15px 15px;
+ -moz-border-radius: 0 0 15px 15px;
+ -webkit-border-bottom-right-radius: 15px;
+ -webkit-border-bottom-left-radius: 15px;
+}
+
+/** Fixture */
+
+#qunit-fixture {
+ position: absolute;
+ top: -10000px;
+ left: -10000px;
+}
\ No newline at end of file
diff --git a/Phaser/node_modules/grunt/node_modules/which/LICENSE b/Phaser/node_modules/grunt/node_modules/which/LICENSE
new file mode 100644
index 00000000..05a40109
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/which/LICENSE
@@ -0,0 +1,23 @@
+Copyright 2009, 2010, 2011 Isaac Z. Schlueter.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Phaser/node_modules/grunt/node_modules/which/README.md b/Phaser/node_modules/grunt/node_modules/which/README.md
new file mode 100644
index 00000000..ff1eb531
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/which/README.md
@@ -0,0 +1,5 @@
+The "which" util from npm's guts.
+
+Finds the first instance of a specified executable in the PATH
+environment variable. Does not cache the results, so `hash -r` is not
+needed when the PATH changes.
diff --git a/Phaser/node_modules/grunt/node_modules/which/package.json b/Phaser/node_modules/grunt/node_modules/which/package.json
new file mode 100644
index 00000000..4854ed2b
--- /dev/null
+++ b/Phaser/node_modules/grunt/node_modules/which/package.json
@@ -0,0 +1,31 @@
+{
+ "author": {
+ "name": "Isaac Z. Schlueter",
+ "email": "i@izs.me",
+ "url": "http://blog.izs.me"
+ },
+ "name": "which",
+ "description": "Like which(1) unix command. Find the first instance of an executable in the PATH.",
+ "version": "1.0.5",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/isaacs/node-which.git"
+ },
+ "main": "which.js",
+ "bin": {
+ "which": "./bin/which"
+ },
+ "engines": {
+ "node": "*"
+ },
+ "dependencies": {},
+ "devDependencies": {},
+ "readme": "The \"which\" util from npm's guts.\n\nFinds the first instance of a specified executable in the PATH\nenvironment variable. Does not cache the results, so `hash -r` is not\nneeded when the PATH changes.\n",
+ "readmeFilename": "README.md",
+ "_id": "which@1.0.5",
+ "dist": {
+ "shasum": "195619a6ad7e8fefd0aa76445a6d4c8d370a322c"
+ },
+ "_from": "which@~1.0.5",
+ "_resolved": "https://registry.npmjs.org/which/-/which-1.0.5.tgz"
+}
diff --git a/Phaser/node_modules/grunt/package.json b/Phaser/node_modules/grunt/package.json
new file mode 100644
index 00000000..e59635f1
--- /dev/null
+++ b/Phaser/node_modules/grunt/package.json
@@ -0,0 +1,100 @@
+{
+ "name": "grunt",
+ "description": "The JavaScript Task Runner",
+ "version": "0.4.1",
+ "author": {
+ "name": "\"Cowboy\" Ben Alman",
+ "url": "http://benalman.com/"
+ },
+ "homepage": "http://gruntjs.com/",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/gruntjs/grunt.git"
+ },
+ "bugs": {
+ "url": "http://github.com/gruntjs/grunt/issues"
+ },
+ "licenses": [
+ {
+ "type": "MIT",
+ "url": "http://github.com/gruntjs/grunt/blob/master/LICENSE-MIT"
+ }
+ ],
+ "main": "lib/grunt",
+ "scripts": {
+ "test": "grunt test"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ },
+ "keywords": [
+ "task",
+ "async",
+ "cli",
+ "minify",
+ "uglify",
+ "build",
+ "lodash",
+ "unit",
+ "test",
+ "qunit",
+ "nodeunit",
+ "server",
+ "init",
+ "scaffold",
+ "make",
+ "jake",
+ "tool"
+ ],
+ "dependencies": {
+ "async": "~0.1.22",
+ "coffee-script": "~1.3.3",
+ "colors": "~0.6.0-1",
+ "dateformat": "1.0.2-1.2.3",
+ "eventemitter2": "~0.4.9",
+ "findup-sync": "~0.1.0",
+ "glob": "~3.1.21",
+ "hooker": "~0.2.3",
+ "iconv-lite": "~0.2.5",
+ "minimatch": "~0.2.6",
+ "nopt": "~1.0.10",
+ "rimraf": "~2.0.2",
+ "lodash": "~0.9.0",
+ "underscore.string": "~2.2.0rc",
+ "which": "~1.0.5",
+ "js-yaml": "~2.0.2"
+ },
+ "devDependencies": {
+ "temporary": "~0.0.4",
+ "grunt-contrib-jshint": "~0.1.1",
+ "grunt-contrib-nodeunit": "~0.1.2",
+ "grunt-contrib-watch": "~0.2.0",
+ "difflet": "~0.2.3"
+ },
+ "contributors": [
+ {
+ "name": "\"Cowboy\" Ben Alman",
+ "url": "http://benalman.com/"
+ },
+ {
+ "name": "Kyle Robinson Young",
+ "url": "http://dontkry.com/"
+ },
+ {
+ "name": "Tyler Kellen",
+ "url": "http://goingslowly.com"
+ },
+ {
+ "name": "Sindre Sorhus",
+ "url": "http://sindresorhus.com"
+ }
+ ],
+ "readme": "# Grunt: The JavaScript Task Runner [](http://travis-ci.org/gruntjs/grunt)\n\n### Documentation\n\nVisit the [gruntjs.com](http://gruntjs.com/) website for all the things.\n\n### Support / Contributing\nBefore you make an issue, please read our [Contributing](http://gruntjs.com/contributing) guide.\n\nYou can find the grunt team in [#grunt on irc.freenode.net](irc://irc.freenode.net/#grunt).\n\n### Release History\nSee the [CHANGELOG](CHANGELOG).\n",
+ "readmeFilename": "README.md",
+ "_id": "grunt@0.4.1",
+ "dist": {
+ "shasum": "e8de3620333cbd39d1156a1d21d11d6c03b2f500"
+ },
+ "_from": "grunt@",
+ "_resolved": "https://registry.npmjs.org/grunt/-/grunt-0.4.1.tgz"
+}
diff --git a/Phaser/node_modules/grunt/test/fixtures/BOM.txt b/Phaser/node_modules/grunt/test/fixtures/BOM.txt
new file mode 100644
index 00000000..e1fde783
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/BOM.txt
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/Phaser/node_modules/grunt/test/fixtures/exec.cmd b/Phaser/node_modules/grunt/test/fixtures/exec.cmd
new file mode 100755
index 00000000..6e4a52bb
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/exec.cmd
@@ -0,0 +1 @@
+@echo done
diff --git a/Phaser/node_modules/grunt/test/fixtures/exec.sh b/Phaser/node_modules/grunt/test/fixtures/exec.sh
new file mode 100755
index 00000000..88907997
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/exec.sh
@@ -0,0 +1,2 @@
+#!/bin/bash
+echo "done"
diff --git a/Phaser/node_modules/grunt/test/fixtures/expand-mapping-ext/dir.ectory/file-no-extension b/Phaser/node_modules/grunt/test/fixtures/expand-mapping-ext/dir.ectory/file-no-extension
new file mode 100644
index 00000000..e69de29b
diff --git a/Phaser/node_modules/grunt/test/fixtures/expand-mapping-ext/dir.ectory/sub.dir.ectory/file.ext.ension b/Phaser/node_modules/grunt/test/fixtures/expand-mapping-ext/dir.ectory/sub.dir.ectory/file.ext.ension
new file mode 100644
index 00000000..e69de29b
diff --git a/Phaser/node_modules/grunt/test/fixtures/expand-mapping-ext/file.ext.ension b/Phaser/node_modules/grunt/test/fixtures/expand-mapping-ext/file.ext.ension
new file mode 100644
index 00000000..e69de29b
diff --git a/Phaser/node_modules/grunt/test/fixtures/expand/README.md b/Phaser/node_modules/grunt/test/fixtures/expand/README.md
new file mode 100644
index 00000000..e69de29b
diff --git a/Phaser/node_modules/grunt/test/fixtures/expand/css/baz.css b/Phaser/node_modules/grunt/test/fixtures/expand/css/baz.css
new file mode 100644
index 00000000..e69de29b
diff --git a/Phaser/node_modules/grunt/test/fixtures/expand/css/qux.css b/Phaser/node_modules/grunt/test/fixtures/expand/css/qux.css
new file mode 100644
index 00000000..e69de29b
diff --git a/Phaser/node_modules/grunt/test/fixtures/expand/deep/deep.txt b/Phaser/node_modules/grunt/test/fixtures/expand/deep/deep.txt
new file mode 100644
index 00000000..e69de29b
diff --git a/Phaser/node_modules/grunt/test/fixtures/expand/deep/deeper/deeper.txt b/Phaser/node_modules/grunt/test/fixtures/expand/deep/deeper/deeper.txt
new file mode 100644
index 00000000..e69de29b
diff --git a/Phaser/node_modules/grunt/test/fixtures/expand/deep/deeper/deepest/deepest.txt b/Phaser/node_modules/grunt/test/fixtures/expand/deep/deeper/deepest/deepest.txt
new file mode 100644
index 00000000..e69de29b
diff --git a/Phaser/node_modules/grunt/test/fixtures/iso-8859-1.json b/Phaser/node_modules/grunt/test/fixtures/iso-8859-1.json
new file mode 100644
index 00000000..31e1dc34
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/iso-8859-1.json
@@ -0,0 +1,4 @@
+{
+ "foo": "Ação é isso aí",
+ "bar": ["ømg", "pønies"]
+}
diff --git a/Phaser/node_modules/grunt/test/fixtures/iso-8859-1.txt b/Phaser/node_modules/grunt/test/fixtures/iso-8859-1.txt
new file mode 100644
index 00000000..c4a16844
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/iso-8859-1.txt
@@ -0,0 +1 @@
+Ação é isso aí
diff --git a/Phaser/node_modules/grunt/test/fixtures/iso-8859-1.yaml b/Phaser/node_modules/grunt/test/fixtures/iso-8859-1.yaml
new file mode 100644
index 00000000..b869cc12
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/iso-8859-1.yaml
@@ -0,0 +1,4 @@
+foo: Ação é isso aí
+bar:
+ - ømg
+ - pønies
diff --git a/Phaser/node_modules/grunt/test/fixtures/lint.txt b/Phaser/node_modules/grunt/test/fixtures/lint.txt
new file mode 100644
index 00000000..62b11566
Binary files /dev/null and b/Phaser/node_modules/grunt/test/fixtures/lint.txt differ
diff --git a/Phaser/node_modules/grunt/test/fixtures/no_BOM.txt b/Phaser/node_modules/grunt/test/fixtures/no_BOM.txt
new file mode 100644
index 00000000..19102815
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/no_BOM.txt
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/Phaser/node_modules/grunt/test/fixtures/octocat.png b/Phaser/node_modules/grunt/test/fixtures/octocat.png
new file mode 100644
index 00000000..0b68cf0d
Binary files /dev/null and b/Phaser/node_modules/grunt/test/fixtures/octocat.png differ
diff --git a/Phaser/node_modules/grunt/test/fixtures/template.txt b/Phaser/node_modules/grunt/test/fixtures/template.txt
new file mode 100644
index 00000000..99342d67
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/template.txt
@@ -0,0 +1 @@
+Version: <%= grunt.version %>, today: <%= grunt.template.today("yyyy-mm-dd") %>.
\ No newline at end of file
diff --git a/Phaser/node_modules/grunt/test/fixtures/test.json b/Phaser/node_modules/grunt/test/fixtures/test.json
new file mode 100644
index 00000000..098e7b84
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/test.json
@@ -0,0 +1,4 @@
+{
+ "foo": "bar",
+ "baz": [1, 2, 3]
+}
diff --git a/Phaser/node_modules/grunt/test/fixtures/utf8.json b/Phaser/node_modules/grunt/test/fixtures/utf8.json
new file mode 100644
index 00000000..d10e9753
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/utf8.json
@@ -0,0 +1,4 @@
+{
+ "foo": "Ação é isso aÃ",
+ "bar": ["ømg", "pønies"]
+}
diff --git a/Phaser/node_modules/grunt/test/fixtures/utf8.txt b/Phaser/node_modules/grunt/test/fixtures/utf8.txt
new file mode 100644
index 00000000..eadbdb40
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/utf8.txt
@@ -0,0 +1 @@
+Ação é isso aÃ
diff --git a/Phaser/node_modules/grunt/test/fixtures/utf8.yaml b/Phaser/node_modules/grunt/test/fixtures/utf8.yaml
new file mode 100644
index 00000000..7eb7321c
--- /dev/null
+++ b/Phaser/node_modules/grunt/test/fixtures/utf8.yaml
@@ -0,0 +1,4 @@
+foo: Ação é isso aÃ
+bar:
+ - ømg
+ - pønies
diff --git a/Phaser/phaser.js b/Phaser/phaser.js
index 2d2a57e4..b2d7ffdb 100644
--- a/Phaser/phaser.js
+++ b/Phaser/phaser.js
@@ -1,7 +1,7 @@
/**
* Phaser
*
-* v0.9.3 - April 24th 2013
+* v0.9.4 - April 24th 2013
*
* A small and feature-packed 2D canvas game framework born from the firey pits of Flixel and Kiwi.
*
@@ -15,5 +15,5 @@
*/
var Phaser;
(function (Phaser) {
- Phaser.VERSION = 'Phaser version 0.9.3';
+ Phaser.VERSION = 'Phaser version 0.9.4';
})(Phaser || (Phaser = {}));
diff --git a/Phaser/system/Camera.ts b/Phaser/system/Camera.ts
index e05e3e71..d43a3ac4 100644
--- a/Phaser/system/Camera.ts
+++ b/Phaser/system/Camera.ts
@@ -269,23 +269,21 @@ module Phaser {
/**
* Specify the boundaries of the world or where the camera is allowed to move.
*
- * @param X The smallest X value of your world (usually 0).
- * @param Y The smallest Y value of your world (usually 0).
- * @param Width The largest X value of your world (usually the world width).
- * @param Height The largest Y value of your world (usually the world height).
- * @param UpdateWorld Whether the global quad-tree's dimensions should be updated to match (default: false).
+ * @param x The smallest X value of your world (usually 0).
+ * @param y The smallest Y value of your world (usually 0).
+ * @param width The largest X value of your world (usually the world width).
+ * @param height The largest Y value of your world (usually the world height).
*/
- public setBounds(X: number = 0, Y: number = 0, Width: number = 0, Height: number = 0, UpdateWorld: bool = false) {
+ public setBounds(x: number = 0, y: number = 0, width: number = 0, height: number = 0) {
if (this.bounds == null)
{
this.bounds = new Rectangle();
}
- this.bounds.setTo(X, Y, Width, Height);
-
- //if(UpdateWorld)
- // G.worldBounds.copyFrom(bounds);
+ this.bounds.setTo(x, y, width, height);
+ this.worldView.setTo(x, y, width, height);
+ this.scroll.setTo(0, 0);
this.update();
}
@@ -345,7 +343,7 @@ module Phaser {
if (this.scroll.x > this.bounds.right - this.width)
{
- this.scroll.x = this.bounds.right - this.width;
+ this.scroll.x = (this.bounds.right - this.width) + 1;
}
if (this.scroll.y < this.bounds.top)
@@ -355,7 +353,7 @@ module Phaser {
if (this.scroll.y > this.bounds.bottom - this.height)
{
- this.scroll.y = this.bounds.bottom - this.height;
+ this.scroll.y = (this.bounds.bottom - this.height) + 1;
}
}
diff --git a/Phaser/system/QuadTree.ts b/Phaser/system/QuadTree.ts
index e157fb8c..0e799c58 100644
--- a/Phaser/system/QuadTree.ts
+++ b/Phaser/system/QuadTree.ts
@@ -704,8 +704,6 @@ module Phaser {
*/
private overlapNode(): bool {
- //console.log('overlapNode');
-
//Walk the list and check for overlaps
var overlapProcessed: bool = false;
var checkObject;
diff --git a/Phaser/system/Tile.ts b/Phaser/system/Tile.ts
index 5505a6db..ec0c7f87 100644
--- a/Phaser/system/Tile.ts
+++ b/Phaser/system/Tile.ts
@@ -3,55 +3,35 @@
/**
* Phaser - Tile
*
-* A simple helper object for Underscore Test Suite
+ + ++
Underscore Speed Suite
+
+ A representative sample of the functions are benchmarked here, to provide
+ a sense of how fast they might run in different browsers.
+ Each iteration runs on an array of 1000 elements.
+ For example, the 'intersect' test measures the number of times you can
+ find the intersection of two thousand-element arrays in one second.
+
+ + +
Tilemap that helps expand collision opportunities and control.
+* A Tile is a single representation of a tile within a Tilemap
*/
module Phaser {
- export class Tile extends GameObject {
+ export class Tile {
- /**
- * Instantiate this new tile object. This is usually called from Tilemap.loadMap().
- *
- * @param Tilemap A reference to the tilemap object creating the tile.
- * @param Index The actual core map data index for this tile type.
- * @param Width The width of the tile.
- * @param Height The height of the tile.
- * @param Visible Whether the tile is visible or not.
- * @param AllowCollisions The collision flags for the object. By default this value is ANY or NONE depending on the parameters sent to loadMap().
- */
- constructor(game: Game, Tilemap: Tilemap, Index: number, Width: number, Height: number, Visible: bool, AllowCollisions: number) {
+ constructor(game: Game, tilemap: Tilemap, index: number, width: number, height: number) {
- super(game, 0, 0, Width, Height);
+ this._game = game;
+ this.tilemap = tilemap;
+ this.index = index;
- this.immovable = true;
- this.moves = false;
- this.callback = null;
- this.filter = null;
-
- this.tilemap = Tilemap;
- this.index = Index;
- this.visible = Visible;
- this.allowCollisions = AllowCollisions;
-
- this.mapIndex = 0;
+ this.width = width;
+ this.height = height;
+ this.allowCollisions = Collision.NONE;
}
- /**
- * This function is called whenever an object hits a tile of this type.
- * This function should take the form myFunction(Tile:Tile,Object:Object).
- * Defaults to null, set through Tilemap.setTileProperties().
- */
- public callback;
+ private _game: Game;
- /**
- * Each tile can store its own filter class for their callback functions.
- * That is, the callback will only be triggered if an object with a class
- * type matching the filter touched it.
- * Defaults to null, set through Tilemap.setTileProperties().
- */
- public filter;
+ // You can give this Tile a friendly name to help with debugging. Never used internally.
+ public name: string;
+
+ public width: number;
+
+ public height: number;
+
+ public allowCollisions: number;
/**
* A reference to the tilemap this tile object belongs to.
@@ -65,24 +45,26 @@ module Phaser {
*/
public index: number;
- /**
- * The current map index of this tile object at this moment.
- * You can think of tile objects as moving around the tilemap helping with collisions.
- * This value is only reliable and useful if used from the callback function.
- */
- public mapIndex: number;
-
/**
* Clean up memory.
*/
public destroy() {
- super.destroy();
- this.callback = null;
this.tilemap = null;
}
+ /**
+ * Returns a string representation of this object.
+ * @method toString
+ * @return {string} a string representation of the object.
+ **/
+ public toString(): string {
+
+ return "[{Tiled (index=" + this.index + " collisions=" + this.allowCollisions + " width=" + this.width + " height=" + this.height + ")}]";
+
+ }
+
}
}
\ No newline at end of file
diff --git a/Phaser/system/TilemapLayer.ts b/Phaser/system/TilemapLayer.ts
index 4309d028..aa6d7453 100644
--- a/Phaser/system/TilemapLayer.ts
+++ b/Phaser/system/TilemapLayer.ts
@@ -10,9 +10,10 @@ module Phaser {
export class TilemapLayer {
- constructor(game: Game, key: string, mapFormat: number, name: string, tileWidth: number, tileHeight: number) {
+ constructor(game: Game, parent:Tilemap, key: string, mapFormat: number, name: string, tileWidth: number, tileHeight: number) {
this._game = game;
+ this._parent = parent;
this.name = name;
this.mapFormat = mapFormat;
@@ -24,11 +25,10 @@ module Phaser {
this.mapData = [];
this._texture = this._game.cache.getImage(key);
- this.parseTileOffsets();
-
}
private _game: Game;
+ private _parent: Tilemap;
private _texture;
private _tileOffsets;
private _startX: number = 0;
@@ -45,6 +45,7 @@ module Phaser {
public name: string;
public alpha: number = 1;
+ public exists: bool = true;
public visible: bool = true;
//public scrollFactor: MicroPoint;
public orientation: string;
@@ -63,6 +64,119 @@ module Phaser {
public widthInPixels: number = 0;
public heightInPixels: number = 0;
+ public tileMargin: number = 0;
+ public tileSpacing: number = 0;
+
+ public getTileFromWorldXY(x: number, y: number): number {
+
+ x = this._game.math.snapToFloor(x, this.tileWidth) / this.tileWidth;
+ y = this._game.math.snapToFloor(y, this.tileHeight) / this.tileHeight;
+
+ return this.getTileIndex(x, y);
+
+ }
+
+ public getTileOverlaps(object: GameObject) {
+
+ //var result: bool = false;
+ //var x: number = object.x;
+ //var y: number = object.y;
+
+ // What tiles do we need to check against?
+ var mapX:number = this._game.math.snapToFloor(object.bounds.x, this.tileWidth);
+ var mapY:number = this._game.math.snapToFloor(object.bounds.y, this.tileHeight);
+ var mapW:number = this._game.math.snapToCeil(object.bounds.width, this.tileWidth) + this.tileWidth;
+ var mapH:number = this._game.math.snapToCeil(object.bounds.height, this.tileHeight) + this.tileHeight;
+
+ var tileX = mapX / this.tileWidth;
+ var tileY = mapY / this.tileHeight;
+ var tileW = mapW / this.tileWidth;
+ var tileH = mapH / this.tileHeight;
+
+ if (tileX < 0)
+ {
+ tileX = 0;
+ }
+
+ if (tileY < 0)
+ {
+ tileY = 0;
+ }
+
+ if (tileW > this.widthInTiles)
+ {
+ tileW = this.widthInTiles;
+ }
+
+ if (tileH > this.heightInTiles)
+ {
+ tileH = this.heightInTiles;
+ }
+
+ // Loop through the tiles we've got and check overlaps accordingly
+ var tiles = this.getTileBlock(tileX, tileY, tileW, tileH);
+
+ var result = [];
+ var tempBounds = new Quad();
+
+ for (var r = 0; r < tiles.length; r++)
+ {
+ if (tiles[r].tile.allowCollisions != Collision.NONE)
+ {
+ tempBounds.setTo(tiles[r].x * this.tileWidth, tiles[r].y * this.tileHeight, this.tileWidth, this.tileHeight);
+
+ if (tempBounds.intersects(object.bounds))
+ {
+ result.push(Collision.separateTile(object, { x: tempBounds.x, y: tempBounds.y, width: tempBounds.width, height: tempBounds.height, mass: 1.0, immovable: true, allowCollisions: Collision.ANY }));
+ }
+ else
+ {
+ result.push(false);
+ }
+ }
+ else
+ {
+ result.push(false);
+ }
+ }
+
+ //return { x: mapX, y: mapY, w: mapW, h: mapH, collision: result };
+ return { x: tileX, y: tileY, w: tileW, h: tileH, collision: result };
+
+ }
+
+ //public checkTileOverlap(object:GameObject,
+
+ public getTileBlock(x: number, y: number, width: number, height: number) {
+
+ var output = [];
+
+ for (var ty = y; ty < y + height; ty++)
+ {
+ for (var tx = x; tx < x + width; tx++)
+ {
+ output.push({ x: tx, y: ty, tile: this._parent.tiles[this.mapData[ty][tx]] });
+ }
+ }
+
+ return output;
+
+ }
+
+ public getTileIndex(x: number, y: number): number {
+
+ if (y >= 0 && y < this.mapData.length)
+ {
+ if (x >= 0 && x < this.mapData[y].length)
+ {
+ return this.mapData[y][x];
+ }
+ }
+
+ return null;
+
+ }
+
public addColumn(column) {
var data = [];
@@ -89,9 +203,11 @@ module Phaser {
this.boundsInTiles.setTo(0, 0, this.widthInTiles, this.heightInTiles);
+ console.log('layer bounds', this.boundsInTiles);
+
}
- private parseTileOffsets() {
+ public parseTileOffsets():number {
this._tileOffsets = [];
@@ -104,15 +220,17 @@ module Phaser {
i = 1;
}
- for (var ty = 0; ty < this._texture.height; ty += this.tileHeight)
+ for (var ty = this.tileMargin; ty < this._texture.height; ty += (this.tileHeight + this.tileSpacing))
{
- for (var tx = 0; tx < this._texture.width; tx += this.tileWidth)
+ for (var tx = this.tileMargin; tx < this._texture.width; tx += (this.tileWidth + this.tileSpacing))
{
this._tileOffsets[i] = { x: tx, y: ty };
i++;
}
}
+ return this._tileOffsets.length;
+
}
public renderDebugInfo(x: number, y: number, color?: string = 'rgb(255,255,255)') {
@@ -151,6 +269,16 @@ module Phaser {
this._startY = 0;
}
+ if (this._maxX > this.widthInTiles)
+ {
+ this._maxX = this.widthInTiles;
+ }
+
+ if (this._maxY > this.heightInTiles)
+ {
+ this._maxY = this.heightInTiles;
+ }
+
if (this._startX + this._maxX > this.widthInTiles)
{
this._startX = this.widthInTiles - this._maxX;
diff --git a/Phaser/system/input/Input.ts b/Phaser/system/input/Input.ts
index f27c4719..bde9380c 100644
--- a/Phaser/system/input/Input.ts
+++ b/Phaser/system/input/Input.ts
@@ -77,6 +77,7 @@ module Phaser {
public renderDebugInfo(x: number, y: number, color?: string = 'rgb(255,255,255)') {
+ this._game.stage.context.font = '14px Courier';
this._game.stage.context.fillStyle = color;
this._game.stage.context.fillText('Input', x, y);
this._game.stage.context.fillText('Screen X: ' + this.x + ' Screen Y: ' + this.y, x, y + 14);
diff --git a/Phaser/system/input/Keyboard.ts b/Phaser/system/input/Keyboard.ts
index 332806f4..e3415304 100644
--- a/Phaser/system/input/Keyboard.ts
+++ b/Phaser/system/input/Keyboard.ts
@@ -32,11 +32,11 @@ module Phaser {
public addKeyCapture(keycode) {
- if (typeof keycode == 'array')
+ if (typeof keycode === 'object')
{
- for (var code in keycode)
+ for (var i:number = 0; i < keycode.length; i++)
{
- this._capture[code] = true;
+ this._capture[keycode[i]] = true;
}
}
else
diff --git a/README.md b/README.md
index cac21f39..80fe561c 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,7 @@
Phaser
======
-Version 0.9.3
-
-24th April 2013
+Version: 0.9.4 Released: XX April 2013
By Richard Davey, [Photon Storm](http://www.photonstorm.com)
@@ -20,23 +18,13 @@ Try out the [Phaser Test Suite](http://gametest.mobi/phaser/)
Latest Update
-------------
-V0.9.3
+V0.9.4
+
+* Fixed Tilemap bounds check if map was smaller than game dimensions
+* Added Tilemap.getTile, getTileFromWorldXY, getTileFromInputXY
+* Added Tilemap.setCollisionByIndex and setCollisionByRange
+* Added GameObject.renderRotation boolean to control if the sprite will visually rotate or not (useful when angle needs to change but graphics don't)
-* Added the new ScrollZone game object. Endlessly useful but especially for scrolling backdrops. Created 6 example tests.
-* Added GameObject.hideFromCamera(cameraID) to stop an object rendering to specific cameras (also showToCamera and clearCameraList)
-* Added GameObject.setBounds() to confine a game object to a specific area within the world (useful for stopping them going off the edges)
-* Added GameObject.outOfBoundsAction, can be either OUT OF BOUNDS STOP which stops the object moving, or OUT OF BOUNDS KILL which kills it.
-* Added GameObject.rotationOffset. Useful if your graphics need to rotate but weren't drawn facing zero degrees (to the right).
-* Added shiftSinTable and shiftCosTable to the GameMath class to allow for quick iteration through the data tables.
-* Added more robust frame checking into AnimationManager
-* Re-built Tilemap handling from scratch to allow for proper layered maps (as exported from Tiled / Mappy)
-* Tilemap no longer requires a buffer per Camera (in prep for WebGL support)
-* Fixed issues with Group not adding reference to Game to newly created objects (thanks JesseFreeman)
-* Fixed a potential race condition issue in Game.boot (thanks Hackmaniac)
-* Fixed issue with showing frame zero of a texture atlas before the animation started playing (thanks JesseFreeman)
-* Fixed a bug where Camera.visible = false would still render
-* Removed the need for DynamicTextures to require a key property and updated test cases.
-* You can now pass an array or a single value to Input.Keyboard.addKeyCapture().
Requirements
------------
@@ -171,6 +159,24 @@ Please add them to the [Issue Tracker][1] with as much info as possible.
Change Log
----------
+V0.9.3
+
+* Added the new ScrollZone game object. Endlessly useful but especially for scrolling backdrops. Created 6 example tests.
+* Added GameObject.hideFromCamera(cameraID) to stop an object rendering to specific cameras (also showToCamera and clearCameraList)
+* Added GameObject.setBounds() to confine a game object to a specific area within the world (useful for stopping them going off the edges)
+* Added GameObject.outOfBoundsAction, can be either OUT OF BOUNDS STOP which stops the object moving, or OUT OF BOUNDS KILL which kills it.
+* Added GameObject.rotationOffset. Useful if your graphics need to rotate but weren't drawn facing zero degrees (to the right).
+* Added shiftSinTable and shiftCosTable to the GameMath class to allow for quick iteration through the data tables.
+* Added more robust frame checking into AnimationManager
+* Re-built Tilemap handling from scratch to allow for proper layered maps (as exported from Tiled / Mappy)
+* Tilemap no longer requires a buffer per Camera (in prep for WebGL support)
+* Fixed issues with Group not adding reference to Game to newly created objects (thanks JesseFreeman)
+* Fixed a potential race condition issue in Game.boot (thanks Hackmaniac)
+* Fixed issue with showing frame zero of a texture atlas before the animation started playing (thanks JesseFreeman)
+* Fixed a bug where Camera.visible = false would still render
+* Removed the need for DynamicTextures to require a key property and updated test cases.
+* You can now pass an array or a single value to Input.Keyboard.addKeyCapture().
+
V0.9.2
* Fixed issue with create not being called if there was an empty init method.
diff --git a/Tests/Tests.csproj b/Tests/Tests.csproj
index fdceaa9e..700bd89b 100644
--- a/Tests/Tests.csproj
+++ b/Tests/Tests.csproj
@@ -133,6 +133,14 @@
destroy() on class members if necessary.
- * Don't forget to call super.destroy()!
- */
- function () {
+ Basic.prototype.destroy = function () {
};
- Basic.prototype.preUpdate = /**
- * Pre-update is called right before update() on each object in the game loop.
- */
- function () {
+ Basic.prototype.preUpdate = function () {
};
- Basic.prototype.update = /**
- * Override this to update your class's position and appearance.
- * This is where most of your game rules and behavioral code will go.
- */
- function () {
+ Basic.prototype.update = function () {
};
- Basic.prototype.postUpdate = /**
- * Post-update is called right after update() on each object in the game loop.
- */
- function () {
+ Basic.prototype.postUpdate = function () {
};
Basic.prototype.render = function (camera, cameraOffsetX, cameraOffsetY) {
};
- Basic.prototype.kill = /**
- * Handy for "killing" game objects.
- * Default behavior is to flag them as nonexistent AND dead.
- * However, if you want the "corpse" to remain in the game,
- * like to animate an effect or whatever, you should override this,
- * setting only alive to false, and leaving exists true.
- */
- function () {
+ Basic.prototype.kill = function () {
this.alive = false;
this.exists = false;
};
- Basic.prototype.revive = /**
- * Handy for bringing game objects "back to life". Just sets alive and exists back to true.
- * In practice, this is most often called by Object.reset().
- */
- function () {
+ Basic.prototype.revive = function () {
this.alive = true;
this.exists = true;
};
- Basic.prototype.toString = /**
- * Convert object to readable string name. Useful for debugging, save games, etc.
- */
- function () {
+ Basic.prototype.toString = function () {
return "";
};
return Basic;
})();
Phaser.Basic = Basic;
})(Phaser || (Phaser = {}));
-/// - This is an internal constructor and shouldn't be called by regular users. - *
- inspired by Joa Ebert AS3 SignalBinding and Robert Penner's Slot classes. - * @author Miller Medeiros - * @constructor - * @internal - * @name SignalBinding - * @param {Signal} signal Reference to Signal object that listener is currently bound to. - * @param {Function} listener Handler function bound to the signal. - * @param {boolean} isOnce If binding should be executed just once. - * @param {Object} [listenerContext] Context on which listener will be executed (object that should represent the `this` variable inside listener function). - * @param {Number} [priority] The priority level of the event listener. (default = 0). - */ - function SignalBinding(signal, listener, isOnce, listenerContext, priority) { - if (typeof priority === "undefined") { priority = 0; } - /** - * If binding is active and should be executed. - * @type boolean - */ - this.active = true; - /** - * Default parameters passed to listener during `Signal.dispatch` and `SignalBinding.execute`. (curried parameters) - * @type Array|null - */ - this.params = null; - this._listener = listener; - this._isOnce = isOnce; - this.context = listenerContext; - this._signal = signal; - this.priority = priority || 0; - } - SignalBinding.prototype.execute = /** - * Call listener passing arbitrary parameters. - *
If binding was added using `Signal.addOnce()` it will be automatically removed from signal dispatch queue, this method is used internally for the signal dispatch.
- * @param {Array} [paramsArr] Array of parameters that should be passed to the listener - * @return {*} Value returned by the listener. - */ - function (paramsArr) { - var handlerReturn; - var params; - if(this.active && !!this._listener) { - params = this.params ? this.params.concat(paramsArr) : paramsArr; - handlerReturn = this._listener.apply(this.context, params); - if(this._isOnce) { - this.detach(); - } - } - return handlerReturn; - }; - SignalBinding.prototype.detach = /** - * Detach binding from signal. - * - alias to: mySignal.remove(myBinding.getListener()); - * @return {Function|null} Handler function bound to the signal or `null` if binding was previously detached. - */ - function () { - return this.isBound() ? this._signal.remove(this._listener, this.context) : null; - }; - SignalBinding.prototype.isBound = /** - * @return {Boolean} `true` if binding is still bound to the signal and have a listener. - */ - function () { - return (!!this._signal && !!this._listener); - }; - SignalBinding.prototype.isOnce = /** - * @return {boolean} If SignalBinding will only be executed once. - */ - function () { - return this._isOnce; - }; - SignalBinding.prototype.getListener = /** - * @return {Function} Handler function bound to the signal. - */ - function () { - return this._listener; - }; - SignalBinding.prototype.getSignal = /** - * @return {Signal} Signal that listener is currently bound to. - */ - function () { - return this._signal; - }; - SignalBinding.prototype._destroy = /** - * Delete instance properties - * @private - */ - function () { - delete this._signal; - delete this._listener; - delete this.context; - }; - SignalBinding.prototype.toString = /** - * @return {string} String representation of the object. - */ - function () { - return '[SignalBinding isOnce:' + this._isOnce + ', isBound:' + this.isBound() + ', active:' + this.active + ']'; - }; - return SignalBinding; - })(); - Phaser.SignalBinding = SignalBinding; -})(Phaser || (Phaser = {})); -///IMPORTANT: Setting this property during a dispatch will only affect the next dispatch, if you want to stop the propagation of a signal use `halt()` instead.
- * @type boolean - */ - this.active = true; - } - Signal.VERSION = '1.0.0'; - Signal.prototype.validateListener = /** - * - * @method validateListener - * @param {Any} listener - * @param {Any} fnName - */ - function (listener, fnName) { - if(typeof listener !== 'function') { - throw new Error('listener is a required param of {fn}() and should be a Function.'.replace('{fn}', fnName)); - } - }; - Signal.prototype._registerListener = /** - * @param {Function} listener - * @param {boolean} isOnce - * @param {Object} [listenerContext] - * @param {Number} [priority] - * @return {SignalBinding} - * @private - */ - function (listener, isOnce, listenerContext, priority) { - var prevIndex = this._indexOfListener(listener, listenerContext); - var binding; - if(prevIndex !== -1) { - binding = this._bindings[prevIndex]; - if(binding.isOnce() !== isOnce) { - throw new Error('You cannot add' + (isOnce ? '' : 'Once') + '() then add' + (!isOnce ? '' : 'Once') + '() the same listener without removing the relationship first.'); - } - } else { - binding = new Phaser.SignalBinding(this, listener, isOnce, listenerContext, priority); - this._addBinding(binding); - } - if(this.memorize && this._prevParams) { - binding.execute(this._prevParams); - } - return binding; - }; - Signal.prototype._addBinding = /** - * - * @method _addBinding - * @param {SignalBinding} binding - * @private - */ - function (binding) { - //simplified insertion sort - var n = this._bindings.length; - do { - --n; - }while(this._bindings[n] && binding.priority <= this._bindings[n].priority); - this._bindings.splice(n + 1, 0, binding); - }; - Signal.prototype._indexOfListener = /** - * - * @method _indexOfListener - * @param {Function} listener - * @return {number} - * @private - */ - function (listener, context) { - var n = this._bindings.length; - var cur; - while(n--) { - cur = this._bindings[n]; - if(cur.getListener() === listener && cur.context === context) { - return n; - } - } - return -1; - }; - Signal.prototype.has = /** - * Check if listener was attached to Signal. - * @param {Function} listener - * @param {Object} [context] - * @return {boolean} if Signal has the specified listener. - */ - function (listener, context) { - if (typeof context === "undefined") { context = null; } - return this._indexOfListener(listener, context) !== -1; - }; - Signal.prototype.add = /** - * Add a listener to the signal. - * @param {Function} listener Signal handler function. - * @param {Object} [listenerContext] Context on which listener will be executed (object that should represent the `this` variable inside listener function). - * @param {Number} [priority] The priority level of the event listener. Listeners with higher priority will be executed before listeners with lower priority. Listeners with same priority level will be executed at the same order as they were added. (default = 0) - * @return {SignalBinding} An Object representing the binding between the Signal and listener. - */ - function (listener, listenerContext, priority) { - if (typeof listenerContext === "undefined") { listenerContext = null; } - if (typeof priority === "undefined") { priority = 0; } - this.validateListener(listener, 'add'); - return this._registerListener(listener, false, listenerContext, priority); - }; - Signal.prototype.addOnce = /** - * Add listener to the signal that should be removed after first execution (will be executed only once). - * @param {Function} listener Signal handler function. - * @param {Object} [listenerContext] Context on which listener will be executed (object that should represent the `this` variable inside listener function). - * @param {Number} [priority] The priority level of the event listener. Listeners with higher priority will be executed before listeners with lower priority. Listeners with same priority level will be executed at the same order as they were added. (default = 0) - * @return {SignalBinding} An Object representing the binding between the Signal and listener. - */ - function (listener, listenerContext, priority) { - if (typeof listenerContext === "undefined") { listenerContext = null; } - if (typeof priority === "undefined") { priority = 0; } - this.validateListener(listener, 'addOnce'); - return this._registerListener(listener, true, listenerContext, priority); - }; - Signal.prototype.remove = /** - * Remove a single listener from the dispatch queue. - * @param {Function} listener Handler function that should be removed. - * @param {Object} [context] Execution context (since you can add the same handler multiple times if executing in a different context). - * @return {Function} Listener handler function. - */ - function (listener, context) { - if (typeof context === "undefined") { context = null; } - this.validateListener(listener, 'remove'); - var i = this._indexOfListener(listener, context); - if(i !== -1) { - this._bindings[i]._destroy()//no reason to a SignalBinding exist if it isn't attached to a signal - ; - this._bindings.splice(i, 1); - } - return listener; - }; - Signal.prototype.removeAll = /** - * Remove all listeners from the Signal. - */ - function () { - var n = this._bindings.length; - while(n--) { - this._bindings[n]._destroy(); - } - this._bindings.length = 0; - }; - Signal.prototype.getNumListeners = /** - * @return {number} Number of listeners attached to the Signal. - */ - function () { - return this._bindings.length; - }; - Signal.prototype.halt = /** - * Stop propagation of the event, blocking the dispatch to next listeners on the queue. - *IMPORTANT: should be called only during signal dispatch, calling it before/after dispatch won't affect signal broadcast.
- * @see Signal.prototype.disable - */ - function () { - this._shouldPropagate = false; - }; - Signal.prototype.dispatch = /** - * Dispatch/Broadcast Signal to all listeners added to the queue. - * @param {...*} [params] Parameters that should be passed to each handler. - */ - function () { - var paramsArr = []; - for (var _i = 0; _i < (arguments.length - 0); _i++) { - paramsArr[_i] = arguments[_i + 0]; - } - if(!this.active) { - return; - } - var n = this._bindings.length; - var bindings; - if(this.memorize) { - this._prevParams = paramsArr; - } - if(!n) { - //should come after memorize - return; - } - bindings = this._bindings.slice(0)//clone array in case add/remove items during dispatch - ; - this._shouldPropagate = true//in case `halt` was called before dispatch or during the previous dispatch. - ; - //execute all callbacks until end of the list or until a callback returns `false` or stops propagation - //reverse loop since listeners with higher priority will be added at the end of the list - do { - n--; - }while(bindings[n] && this._shouldPropagate && bindings[n].execute(paramsArr) !== false); - }; - Signal.prototype.forget = /** - * Forget memorized arguments. - * @see Signal.memorize - */ - function () { - this._prevParams = null; - }; - Signal.prototype.dispose = /** - * Remove all bindings from signal and destroy any reference to external objects (destroy Signal object). - *IMPORTANT: calling any method on the signal instance after calling dispose will throw errors.
- */ - function () { - this.removeAll(); - delete this._bindings; - delete this._prevParams; - }; - Signal.prototype.toString = /** - * @return {string} String representation of the object. - */ - function () { - return '[Signal active:' + this.active + ' numListeners:' + this.getNumListeners() + ']'; - }; - return Signal; - })(); - Phaser.Signal = Signal; -})(Phaser || (Phaser = {})); -var __extends = this.__extends || function (d, b) { - function __() { this.constructor = d; } - __.prototype = b.prototype; - d.prototype = new __(); -}; -///GameObject overlaps this GameObject or Group.
- * If the group has a LOT of things in it, it might be faster to use Collision.overlaps().
- * WARNING: Currently tilemaps do NOT support screen space overlap checks!
- *
- * @param ObjectOrGroup The object or group being tested.
- * @param InScreenSpace Whether to take scroll factors numbero account when checking for overlap. Default is false, or "only compare in world space."
- * @param Camera Specify which game camera you want. If null getScreenXY() will just grab the first global camera.
- *
- * @return Whether or not the two objects overlap.
- */
- function (ObjectOrGroup, InScreenSpace, Camera) {
- if (typeof InScreenSpace === "undefined") { InScreenSpace = false; }
- if (typeof Camera === "undefined") { Camera = null; }
- if(ObjectOrGroup.isGroup) {
- var results = false;
- var i = 0;
- var members = ObjectOrGroup.members;
- while(i < length) {
- if(this.overlaps(members[i++], InScreenSpace, Camera)) {
- results = true;
- }
- }
- return results;
- }
- /*
- if (typeof ObjectOrGroup === 'Tilemap')
- {
- //Since tilemap's have to be the caller, not the target, to do proper tile-based collisions,
- // we redirect the call to the tilemap overlap here.
- return ObjectOrGroup.overlaps(this, InScreenSpace, Camera);
- }
- */
- //var object: GameObject = ObjectOrGroup;
- if(!InScreenSpace) {
- return (ObjectOrGroup.x + ObjectOrGroup.width > this.x) && (ObjectOrGroup.x < this.x + this.width) && (ObjectOrGroup.y + ObjectOrGroup.height > this.y) && (ObjectOrGroup.y < this.y + this.height);
- }
- if(Camera == null) {
- Camera = this._game.camera;
- }
- var objectScreenPos = ObjectOrGroup.getScreenXY(null, Camera);
- this.getScreenXY(this._point, Camera);
- return (objectScreenPos.x + ObjectOrGroup.width > this._point.x) && (objectScreenPos.x < this._point.x + this.width) && (objectScreenPos.y + ObjectOrGroup.height > this._point.y) && (objectScreenPos.y < this._point.y + this.height);
- };
- GameObject.prototype.overlapsAt = /**
- * Checks to see if this GameObject were located at the given position, would it overlap the GameObject or Group?
- * This is distinct from overlapsPoint(), which just checks that point, rather than taking the object's size numbero account.
- * WARNING: Currently tilemaps do NOT support screen space overlap checks!
- *
- * @param X The X position you want to check. Pretends this object (the caller, not the parameter) is located here.
- * @param Y The Y position you want to check. Pretends this object (the caller, not the parameter) is located here.
- * @param ObjectOrGroup The object or group being tested.
- * @param InScreenSpace Whether to take scroll factors numbero account when checking for overlap. Default is false, or "only compare in world space."
- * @param Camera Specify which game camera you want. If null getScreenXY() will just grab the first global camera.
- *
- * @return Whether or not the two objects overlap.
- */
- function (X, Y, ObjectOrGroup, InScreenSpace, Camera) {
- if (typeof InScreenSpace === "undefined") { InScreenSpace = false; }
- if (typeof Camera === "undefined") { Camera = null; }
- if(ObjectOrGroup.isGroup) {
- var results = false;
- var basic;
- var i = 0;
- var members = ObjectOrGroup.members;
- while(i < length) {
- if(this.overlapsAt(X, Y, members[i++], InScreenSpace, Camera)) {
- results = true;
- }
- }
- return results;
- }
- /*
- if (typeof ObjectOrGroup === 'Tilemap')
- {
- //Since tilemap's have to be the caller, not the target, to do proper tile-based collisions,
- // we redirect the call to the tilemap overlap here.
- //However, since this is overlapsAt(), we also have to invent the appropriate position for the tilemap.
- //So we calculate the offset between the player and the requested position, and subtract that from the tilemap.
- var tilemap: Tilemap = ObjectOrGroup;
- return tilemap.overlapsAt(tilemap.x - (X - this.x), tilemap.y - (Y - this.y), this, InScreenSpace, Camera);
- }
- */
- //var object: GameObject = ObjectOrGroup;
- if(!InScreenSpace) {
- return (ObjectOrGroup.x + ObjectOrGroup.width > X) && (ObjectOrGroup.x < X + this.width) && (ObjectOrGroup.y + ObjectOrGroup.height > Y) && (ObjectOrGroup.y < Y + this.height);
- }
- if(Camera == null) {
- Camera = this._game.camera;
- }
- var objectScreenPos = ObjectOrGroup.getScreenXY(null, Camera);
- this._point.x = X - Camera.scroll.x * this.scrollFactor.x//copied from getScreenXY()
- ;
- this._point.y = Y - Camera.scroll.y * this.scrollFactor.y;
- this._point.x += (this._point.x > 0) ? 0.0000001 : -0.0000001;
- this._point.y += (this._point.y > 0) ? 0.0000001 : -0.0000001;
- return (objectScreenPos.x + ObjectOrGroup.width > this._point.x) && (objectScreenPos.x < this._point.x + this.width) && (objectScreenPos.y + ObjectOrGroup.height > this._point.y) && (objectScreenPos.y < this._point.y + this.height);
- };
- GameObject.prototype.overlapsPoint = /**
- * Checks to see if a point in 2D world space overlaps this GameObject.
- *
- * @param Point The point in world space you want to check.
- * @param InScreenSpace Whether to take scroll factors numbero account when checking for overlap.
- * @param Camera Specify which game camera you want. If null getScreenXY() will just grab the first global camera.
- *
- * @return Whether or not the point overlaps this object.
- */
- function (point, InScreenSpace, Camera) {
- if (typeof InScreenSpace === "undefined") { InScreenSpace = false; }
- if (typeof Camera === "undefined") { Camera = null; }
- if(!InScreenSpace) {
- return (point.x > this.x) && (point.x < this.x + this.width) && (point.y > this.y) && (point.y < this.y + this.height);
- }
- if(Camera == null) {
- Camera = this._game.camera;
- }
- var X = point.x - Camera.scroll.x;
- var Y = point.y - Camera.scroll.y;
- this.getScreenXY(this._point, Camera);
- return (X > this._point.x) && (X < this._point.x + this.width) && (Y > this._point.y) && (Y < this._point.y + this.height);
- };
- GameObject.prototype.onScreen = /**
- * Check and see if this object is currently on screen.
- *
- * @param Camera Specify which game camera you want. If null getScreenXY() will just grab the first global camera.
- *
- * @return Whether the object is on screen or not.
- */
- function (Camera) {
- if (typeof Camera === "undefined") { Camera = null; }
- if(Camera == null) {
- Camera = this._game.camera;
- }
- this.getScreenXY(this._point, Camera);
- return (this._point.x + this.width > 0) && (this._point.x < Camera.width) && (this._point.y + this.height > 0) && (this._point.y < Camera.height);
- };
- GameObject.prototype.getScreenXY = /**
- * Call this to figure out the on-screen position of the object.
- *
- * @param Camera Specify which game camera you want. If null getScreenXY() will just grab the first global camera.
- * @param Point Takes a MicroPoint object and assigns the post-scrolled X and Y values of this object to it.
- *
- * @return The MicroPoint you passed in, or a new Point if you didn't pass one, containing the screen X and Y position of this object.
- */
- function (point, Camera) {
- if (typeof point === "undefined") { point = null; }
- if (typeof Camera === "undefined") { Camera = null; }
- if(point == null) {
- point = new Phaser.MicroPoint();
- }
- if(Camera == null) {
- Camera = this._game.camera;
- }
- point.x = this.x - Camera.scroll.x * this.scrollFactor.x;
- point.y = this.y - Camera.scroll.y * this.scrollFactor.y;
- point.x += (point.x > 0) ? 0.0000001 : -0.0000001;
- point.y += (point.y > 0) ? 0.0000001 : -0.0000001;
- return point;
- };
- Object.defineProperty(GameObject.prototype, "solid", {
- get: /**
- * Whether the object collides or not. For more control over what directions
- * the object will collide from, use collision constants (like LEFT, FLOOR, etc)
- * to set the value of allowCollisions directly.
- */
- function () {
- return (this.allowCollisions & Phaser.Collision.ANY) > Phaser.Collision.NONE;
- },
- set: /**
- * @private
- */
- function (Solid) {
- if(Solid) {
- this.allowCollisions = Phaser.Collision.ANY;
- } else {
- this.allowCollisions = Phaser.Collision.NONE;
- }
- },
- enumerable: true,
- configurable: true
- });
- GameObject.prototype.getMidpoint = /**
- * Retrieve the midpoint of this object in world coordinates.
- *
- * @Point Allows you to pass in an existing Point object if you're so inclined. Otherwise a new one is created.
- *
- * @return A Point object containing the midpoint of this object in world coordinates.
- */
- function (point) {
- if (typeof point === "undefined") { point = null; }
- if(point == null) {
- point = new Phaser.MicroPoint();
- }
- point.copyFrom(this.bounds.center);
- return point;
- };
- GameObject.prototype.reset = /**
- * Handy for reviving game objects.
- * Resets their existence flags and position.
- *
- * @param X The new X position of this object.
- * @param Y The new Y position of this object.
- */
- function (X, Y) {
- this.revive();
- this.touching = Phaser.Collision.NONE;
- this.wasTouching = Phaser.Collision.NONE;
- this.x = X;
- this.y = Y;
- this.last.x = X;
- this.last.y = Y;
- this.velocity.x = 0;
- this.velocity.y = 0;
- };
- GameObject.prototype.isTouching = /**
- * Handy for checking if this object is touching a particular surface.
- * For slightly better performance you can just & the value directly numbero touching.
- * However, this method is good for readability and accessibility.
- *
- * @param Direction Any of the collision flags (e.g. LEFT, FLOOR, etc).
- *
- * @return Whether the object is touching an object in (any of) the specified direction(s) this frame.
- */
- function (Direction) {
- return (this.touching & Direction) > Phaser.Collision.NONE;
- };
- GameObject.prototype.justTouched = /**
- * Handy for checking if this object is just landed on a particular surface.
- *
- * @param Direction Any of the collision flags (e.g. LEFT, FLOOR, etc).
- *
- * @return Whether the object just landed on (any of) the specified surface(s) this frame.
- */
- function (Direction) {
- return ((this.touching & Direction) > Phaser.Collision.NONE) && ((this.wasTouching & Direction) <= Phaser.Collision.NONE);
- };
- GameObject.prototype.hurt = /**
- * Reduces the "health" variable of this sprite by the amount specified in Damage.
- * Calls kill() if health drops to or below zero.
- *
- * @param Damage How much health to take away (use a negative number to give a health bonus).
- */
- function (Damage) {
- this.health = this.health - Damage;
- if(this.health <= 0) {
- this.kill();
- }
- };
- GameObject.prototype.setBounds = /**
- * Set the world bounds that this GameObject can exist within. By default a GameObject can exist anywhere
- * in the world. But by setting the bounds (which are given in world dimensions, not screen dimensions)
- * it can be stopped from leaving the world, or a section of it.
- */
- function (x, y, width, height) {
- this.worldBounds = new Phaser.Quad(x, y, width, height);
- };
- GameObject.prototype.hideFromCamera = /**
- * If you do not wish this object to be visible to a specific camera, pass the camera here.
- */
- function (camera) {
- if(this.cameraBlacklist.indexOf(camera.ID) == -1) {
- this.cameraBlacklist.push(camera.ID);
- }
- };
- GameObject.prototype.showToCamera = function (camera) {
- if(this.cameraBlacklist.indexOf(camera.ID) !== -1) {
- this.cameraBlacklist.slice(this.cameraBlacklist.indexOf(camera.ID), 1);
- }
- };
- GameObject.prototype.clearCameraList = function () {
- this.cameraBlacklist.length = 0;
- };
- GameObject.prototype.destroy = function () {
- };
- Object.defineProperty(GameObject.prototype, "x", {
- get: function () {
- return this.bounds.x;
- },
- set: function (value) {
- this.bounds.x = value;
- },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(GameObject.prototype, "y", {
- get: function () {
- return this.bounds.y;
- },
- set: function (value) {
- this.bounds.y = value;
- },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(GameObject.prototype, "rotation", {
- get: function () {
- return this._angle;
- },
- set: function (value) {
- this._angle = this._game.math.wrap(value, 360, 0);
- },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(GameObject.prototype, "angle", {
- get: function () {
- return this._angle;
- },
- set: function (value) {
- this._angle = this._game.math.wrap(value, 360, 0);
- },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(GameObject.prototype, "width", {
- get: function () {
- return this.bounds.width;
- },
- set: function (value) {
- this.bounds.width = value;
- },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(GameObject.prototype, "height", {
- get: function () {
- return this.bounds.height;
- },
- set: function (value) {
- this.bounds.height = value;
- },
- enumerable: true,
- configurable: true
- });
- return GameObject;
- })(Phaser.Basic);
- Phaser.GameObject = GameObject;
-})(Phaser || (Phaser = {}));
-/// object and next to null.
- */
function LinkedList() {
this.object = null;
this.next = null;
}
- LinkedList.prototype.destroy = /**
- * Clean up memory.
- */
- function () {
+ LinkedList.prototype.destroy = function () {
this.object = null;
if(this.next != null) {
this.next.destroy();
@@ -4062,42 +2305,20 @@ var Phaser;
})();
Phaser.LinkedList = LinkedList;
})(Phaser || (Phaser = {}));
-/// myFunction(Object1:GameObject,Object2:GameObject) that is called whenever two objects are found to overlap in world space, and either no ProcessCallback is specified, or the ProcessCallback returns true.
- * @param ProcessCallback A function with the form myFunction(Object1:GameObject,Object2:GameObject):bool that is called whenever two objects are found to overlap in world space. The NotifyCallback is only called if this function returns true. See GameObject.separate().
- */
- function (ObjectOrGroup1, ObjectOrGroup2, NotifyCallback, ProcessCallback) {
+ QuadTree.prototype.load = function (ObjectOrGroup1, ObjectOrGroup2, NotifyCallback, ProcessCallback) {
if (typeof ObjectOrGroup2 === "undefined") { ObjectOrGroup2 = null; }
if (typeof NotifyCallback === "undefined") { NotifyCallback = null; }
if (typeof ProcessCallback === "undefined") { ProcessCallback = null; }
- //console.log('quadtree load', QuadTree.divisions, ObjectOrGroup1, ObjectOrGroup2);
this.add(ObjectOrGroup1, QuadTree.A_LIST);
if(ObjectOrGroup2 != null) {
this.add(ObjectOrGroup2, QuadTree.B_LIST);
@@ -4196,18 +2402,8 @@ var Phaser;
}
QuadTree._notifyCallback = NotifyCallback;
QuadTree._processingCallback = ProcessCallback;
- //console.log('use both', QuadTree._useBothLists);
- //console.log('------------ end of load');
- };
- QuadTree.prototype.add = /**
- * Call this function to add an object to the root of the tree.
- * This function will recursively add all group members, but
- * not the groups themselves.
- *
- * @param ObjectOrGroup GameObjects are just added, Groups are recursed and their applicable members added accordingly.
- * @param List A uint flag indicating the list to which you want to add the objects. Options are QuadTree.A_LIST and QuadTree.B_LIST.
- */
- function (ObjectOrGroup, List) {
+ };
+ QuadTree.prototype.add = function (ObjectOrGroup, List) {
QuadTree._list = List;
if(ObjectOrGroup.isGroup == true) {
var i = 0;
@@ -4233,33 +2429,22 @@ var Phaser;
}
} else {
QuadTree._object = ObjectOrGroup;
- //console.log('add - not group:', ObjectOrGroup.name);
if(QuadTree._object.exists && QuadTree._object.allowCollisions) {
QuadTree._objectLeftEdge = QuadTree._object.x;
QuadTree._objectTopEdge = QuadTree._object.y;
QuadTree._objectRightEdge = QuadTree._object.x + QuadTree._object.width;
QuadTree._objectBottomEdge = QuadTree._object.y + QuadTree._object.height;
- //console.log('object properties', QuadTree._objectLeftEdge, QuadTree._objectTopEdge, QuadTree._objectRightEdge, QuadTree._objectBottomEdge);
this.addObject();
}
}
};
- QuadTree.prototype.addObject = /**
- * Internal function for recursively navigating and creating the tree
- * while adding objects to the appropriate nodes.
- */
- function () {
- //console.log('addObject');
- //If this quad (not its children) lies entirely inside this object, add it here
+ QuadTree.prototype.addObject = function () {
if(!this._canSubdivide || ((this._leftEdge >= QuadTree._objectLeftEdge) && (this._rightEdge <= QuadTree._objectRightEdge) && (this._topEdge >= QuadTree._objectTopEdge) && (this._bottomEdge <= QuadTree._objectBottomEdge))) {
- //console.log('add To List');
this.addToList();
return;
}
- //See if the selected object fits completely inside any of the quadrants
if((QuadTree._objectLeftEdge > this._leftEdge) && (QuadTree._objectRightEdge < this._midpointX)) {
if((QuadTree._objectTopEdge > this._topEdge) && (QuadTree._objectBottomEdge < this._midpointY)) {
- //console.log('Adding NW tree');
if(this._northWestTree == null) {
this._northWestTree = new QuadTree(this._leftEdge, this._topEdge, this._halfWidth, this._halfHeight, this);
}
@@ -4267,7 +2452,6 @@ var Phaser;
return;
}
if((QuadTree._objectTopEdge > this._midpointY) && (QuadTree._objectBottomEdge < this._bottomEdge)) {
- //console.log('Adding SW tree');
if(this._southWestTree == null) {
this._southWestTree = new QuadTree(this._leftEdge, this._midpointY, this._halfWidth, this._halfHeight, this);
}
@@ -4277,7 +2461,6 @@ var Phaser;
}
if((QuadTree._objectLeftEdge > this._midpointX) && (QuadTree._objectRightEdge < this._rightEdge)) {
if((QuadTree._objectTopEdge > this._topEdge) && (QuadTree._objectBottomEdge < this._midpointY)) {
- //console.log('Adding NE tree');
if(this._northEastTree == null) {
this._northEastTree = new QuadTree(this._midpointX, this._topEdge, this._halfWidth, this._halfHeight, this);
}
@@ -4285,7 +2468,6 @@ var Phaser;
return;
}
if((QuadTree._objectTopEdge > this._midpointY) && (QuadTree._objectBottomEdge < this._bottomEdge)) {
- //console.log('Adding SE tree');
if(this._southEastTree == null) {
this._southEastTree = new QuadTree(this._midpointX, this._midpointY, this._halfWidth, this._halfHeight, this);
}
@@ -4293,44 +2475,34 @@ var Phaser;
return;
}
}
- //If it wasn't completely contained we have to check out the partial overlaps
if((QuadTree._objectRightEdge > this._leftEdge) && (QuadTree._objectLeftEdge < this._midpointX) && (QuadTree._objectBottomEdge > this._topEdge) && (QuadTree._objectTopEdge < this._midpointY)) {
if(this._northWestTree == null) {
this._northWestTree = new QuadTree(this._leftEdge, this._topEdge, this._halfWidth, this._halfHeight, this);
}
- //console.log('added to north west partial tree');
this._northWestTree.addObject();
}
if((QuadTree._objectRightEdge > this._midpointX) && (QuadTree._objectLeftEdge < this._rightEdge) && (QuadTree._objectBottomEdge > this._topEdge) && (QuadTree._objectTopEdge < this._midpointY)) {
if(this._northEastTree == null) {
this._northEastTree = new QuadTree(this._midpointX, this._topEdge, this._halfWidth, this._halfHeight, this);
}
- //console.log('added to north east partial tree');
this._northEastTree.addObject();
}
if((QuadTree._objectRightEdge > this._midpointX) && (QuadTree._objectLeftEdge < this._rightEdge) && (QuadTree._objectBottomEdge > this._midpointY) && (QuadTree._objectTopEdge < this._bottomEdge)) {
if(this._southEastTree == null) {
this._southEastTree = new QuadTree(this._midpointX, this._midpointY, this._halfWidth, this._halfHeight, this);
}
- //console.log('added to south east partial tree');
this._southEastTree.addObject();
}
if((QuadTree._objectRightEdge > this._leftEdge) && (QuadTree._objectLeftEdge < this._midpointX) && (QuadTree._objectBottomEdge > this._midpointY) && (QuadTree._objectTopEdge < this._bottomEdge)) {
if(this._southWestTree == null) {
this._southWestTree = new QuadTree(this._leftEdge, this._midpointY, this._halfWidth, this._halfHeight, this);
}
- //console.log('added to south west partial tree');
this._southWestTree.addObject();
}
};
- QuadTree.prototype.addToList = /**
- * Internal function for recursively adding objects to leaf lists.
- */
- function () {
- //console.log('Adding to List');
+ QuadTree.prototype.addToList = function () {
var ot;
if(QuadTree._list == QuadTree.A_LIST) {
- //console.log('A LIST');
if(this._tailA.object != null) {
ot = this._tailA;
this._tailA = new Phaser.LinkedList();
@@ -4338,7 +2510,6 @@ var Phaser;
}
this._tailA.object = QuadTree._object;
} else {
- //console.log('B LIST');
if(this._tailB.object != null) {
ot = this._tailB;
this._tailB = new Phaser.LinkedList();
@@ -4362,19 +2533,10 @@ var Phaser;
this._southWestTree.addToList();
}
};
- QuadTree.prototype.execute = /**
- * QuadTree's other main function. Call this after adding objects
- * using QuadTree.load() to compare the objects that you loaded.
- *
- * @return Whether or not any overlaps were found.
- */
- function () {
- //console.log('quadtree execute');
+ QuadTree.prototype.execute = function () {
var overlapProcessed = false;
var iterator;
if(this._headA.object != null) {
- //console.log('---------------------------------------------------');
- //console.log('headA iterator');
iterator = this._headA;
while(iterator != null) {
QuadTree._object = iterator.object;
@@ -4384,70 +2546,50 @@ var Phaser;
QuadTree._iterator = iterator.next;
}
if(QuadTree._object.exists && (QuadTree._object.allowCollisions > 0) && (QuadTree._iterator != null) && (QuadTree._iterator.object != null) && QuadTree._iterator.object.exists && this.overlapNode()) {
- //console.log('headA iterator overlapped true');
overlapProcessed = true;
}
iterator = iterator.next;
}
}
- //Advance through the tree by calling overlap on each child
if((this._northWestTree != null) && this._northWestTree.execute()) {
- //console.log('NW quadtree execute');
overlapProcessed = true;
}
if((this._northEastTree != null) && this._northEastTree.execute()) {
- //console.log('NE quadtree execute');
overlapProcessed = true;
}
if((this._southEastTree != null) && this._southEastTree.execute()) {
- //console.log('SE quadtree execute');
overlapProcessed = true;
}
if((this._southWestTree != null) && this._southWestTree.execute()) {
- //console.log('SW quadtree execute');
overlapProcessed = true;
}
return overlapProcessed;
};
- QuadTree.prototype.overlapNode = /**
- * An private for comparing an object against the contents of a node.
- *
- * @return Whether or not any overlaps were found.
- */
- function () {
- //console.log('overlapNode');
- //Walk the list and check for overlaps
+ QuadTree.prototype.overlapNode = function () {
var overlapProcessed = false;
var checkObject;
while(QuadTree._iterator != null) {
if(!QuadTree._object.exists || (QuadTree._object.allowCollisions <= 0)) {
- //console.log('break 1');
break;
}
checkObject = QuadTree._iterator.object;
if((QuadTree._object === checkObject) || !checkObject.exists || (checkObject.allowCollisions <= 0)) {
- //console.log('break 2');
QuadTree._iterator = QuadTree._iterator.next;
continue;
}
- //calculate bulk hull for QuadTree._object
QuadTree._objectHullX = (QuadTree._object.x < QuadTree._object.last.x) ? QuadTree._object.x : QuadTree._object.last.x;
QuadTree._objectHullY = (QuadTree._object.y < QuadTree._object.last.y) ? QuadTree._object.y : QuadTree._object.last.y;
QuadTree._objectHullWidth = QuadTree._object.x - QuadTree._object.last.x;
QuadTree._objectHullWidth = QuadTree._object.width + ((QuadTree._objectHullWidth > 0) ? QuadTree._objectHullWidth : -QuadTree._objectHullWidth);
QuadTree._objectHullHeight = QuadTree._object.y - QuadTree._object.last.y;
QuadTree._objectHullHeight = QuadTree._object.height + ((QuadTree._objectHullHeight > 0) ? QuadTree._objectHullHeight : -QuadTree._objectHullHeight);
- //calculate bulk hull for checkObject
QuadTree._checkObjectHullX = (checkObject.x < checkObject.last.x) ? checkObject.x : checkObject.last.x;
QuadTree._checkObjectHullY = (checkObject.y < checkObject.last.y) ? checkObject.y : checkObject.last.y;
QuadTree._checkObjectHullWidth = checkObject.x - checkObject.last.x;
QuadTree._checkObjectHullWidth = checkObject.width + ((QuadTree._checkObjectHullWidth > 0) ? QuadTree._checkObjectHullWidth : -QuadTree._checkObjectHullWidth);
QuadTree._checkObjectHullHeight = checkObject.y - checkObject.last.y;
QuadTree._checkObjectHullHeight = checkObject.height + ((QuadTree._checkObjectHullHeight > 0) ? QuadTree._checkObjectHullHeight : -QuadTree._checkObjectHullHeight);
- //check for intersection of the two hulls
if((QuadTree._objectHullX + QuadTree._objectHullWidth > QuadTree._checkObjectHullX) && (QuadTree._objectHullX < QuadTree._checkObjectHullX + QuadTree._checkObjectHullWidth) && (QuadTree._objectHullY + QuadTree._objectHullHeight > QuadTree._checkObjectHullY) && (QuadTree._objectHullY < QuadTree._checkObjectHullY + QuadTree._checkObjectHullHeight)) {
- //console.log('intersection!');
- //Execute callback functions if they exist
if((QuadTree._processingCallback == null) || QuadTree._processingCallback(QuadTree._object, checkObject)) {
overlapProcessed = true;
}
@@ -4463,18 +2605,6 @@ var Phaser;
})(Phaser.Rectangle);
Phaser.QuadTree = QuadTree;
})(Phaser || (Phaser = {}));
-/// GameObject overlaps another.
- * Can be called with one object and one group, or two groups, or two objects,
- * whatever floats your boat! For maximum performance try bundling a lot of objects
- * together using a Group (or even bundling groups together!).
- *
- * NOTE: does NOT take objects' scrollfactor into account, all overlaps are checked in world space.
- * - * @param ObjectOrGroup1 The first object or group you want to check. - * @param ObjectOrGroup2 The second object or group you want to check. If it is the same as the first it knows to just do a comparison within that group. - * @param NotifyCallback A function with twoGameObject parameters - e.g. myOverlapFunction(Object1:GameObject,Object2:GameObject) - that is called if those two objects overlap.
- * @param ProcessCallback A function with two GameObject parameters - e.g. myOverlapFunction(Object1:GameObject,Object2:GameObject) - that is called if those two objects overlap. If a ProcessCallback is provided, then NotifyCallback will only be called if ProcessCallback returns true for those objects!
- *
- * @return Whether any overlaps were detected.
- */
- function (ObjectOrGroup1, ObjectOrGroup2, NotifyCallback, ProcessCallback) {
- if (typeof ObjectOrGroup1 === "undefined") { ObjectOrGroup1 = null; }
- if (typeof ObjectOrGroup2 === "undefined") { ObjectOrGroup2 = null; }
- if (typeof NotifyCallback === "undefined") { NotifyCallback = null; }
- if (typeof ProcessCallback === "undefined") { ProcessCallback = null; }
- if(ObjectOrGroup1 == null) {
- ObjectOrGroup1 = this._game.world.group;
+ Collision.prototype.overlap = function (object1, object2, notifyCallback, processCallback) {
+ if (typeof object1 === "undefined") { object1 = null; }
+ if (typeof object2 === "undefined") { object2 = null; }
+ if (typeof notifyCallback === "undefined") { notifyCallback = null; }
+ if (typeof processCallback === "undefined") { processCallback = null; }
+ if(object1 == null) {
+ object1 = this._game.world.group;
}
- if(ObjectOrGroup2 == ObjectOrGroup1) {
- ObjectOrGroup2 = null;
+ if(object2 == object1) {
+ object2 = null;
}
Phaser.QuadTree.divisions = this._game.world.worldDivisions;
var quadTree = new Phaser.QuadTree(this._game.world.bounds.x, this._game.world.bounds.y, this._game.world.bounds.width, this._game.world.bounds.height);
- quadTree.load(ObjectOrGroup1, ObjectOrGroup2, NotifyCallback, ProcessCallback);
+ quadTree.load(object1, object2, notifyCallback, processCallback);
var result = quadTree.execute();
quadTree.destroy();
quadTree = null;
return result;
};
- Collision.separate = /**
- * The main collision resolution in flixel.
- *
- * @param Object1 Any Sprite.
- * @param Object2 Any other Sprite.
- *
- * @return Whether the objects in fact touched and were separated.
- */
- function separate(Object1, Object2) {
- var separatedX = Collision.separateX(Object1, Object2);
- var separatedY = Collision.separateY(Object1, Object2);
+ Collision.separate = function separate(object1, object2) {
+ var separatedX = Collision.separateX(object1, object2);
+ var separatedY = Collision.separateY(object1, object2);
return separatedX || separatedY;
};
- Collision.separateX = /**
- * The X-axis component of the object separation process.
- *
- * @param Object1 Any Sprite.
- * @param Object2 Any other Sprite.
- *
- * @return Whether the objects in fact touched and were separated along the X axis.
- */
- function separateX(Object1, Object2) {
- //can't separate two immovable objects
- var obj1immovable = Object1.immovable;
- var obj2immovable = Object2.immovable;
- if(obj1immovable && obj2immovable) {
+ Collision.separateTile = function separateTile(object, tile) {
+ var separatedX = Collision.separateTileX(object, tile);
+ var separatedY = Collision.separateTileY(object, tile);
+ return separatedX || separatedY;
+ };
+ Collision.separateTileX = function separateTileX(object, tile) {
+ if(object.immovable && tile.immovable) {
return false;
}
- //If one of the objects is a tilemap, just pass it off.
- /*
- if (typeof Object1 === 'Tilemap')
- {
- return Object1.overlapsWithCallback(Object2, separateX);
- }
-
- if (typeof Object2 === 'Tilemap')
- {
- return Object2.overlapsWithCallback(Object1, separateX, true);
- }
- */
- //First, get the two object deltas
var overlap = 0;
- var obj1delta = Object1.x - Object1.last.x;
- var obj2delta = Object2.x - Object2.last.x;
- if(obj1delta != obj2delta) {
- //Check if the X hulls actually overlap
- var obj1deltaAbs = (obj1delta > 0) ? obj1delta : -obj1delta;
- var obj2deltaAbs = (obj2delta > 0) ? obj2delta : -obj2delta;
- var obj1rect = new Phaser.Rectangle(Object1.x - ((obj1delta > 0) ? obj1delta : 0), Object1.last.y, Object1.width + ((obj1delta > 0) ? obj1delta : -obj1delta), Object1.height);
- var obj2rect = new Phaser.Rectangle(Object2.x - ((obj2delta > 0) ? obj2delta : 0), Object2.last.y, Object2.width + ((obj2delta > 0) ? obj2delta : -obj2delta), Object2.height);
- if((obj1rect.x + obj1rect.width > obj2rect.x) && (obj1rect.x < obj2rect.x + obj2rect.width) && (obj1rect.y + obj1rect.height > obj2rect.y) && (obj1rect.y < obj2rect.y + obj2rect.height)) {
- var maxOverlap = obj1deltaAbs + obj2deltaAbs + Collision.OVERLAP_BIAS;
- //If they did overlap (and can), figure out by how much and flip the corresponding flags
- if(obj1delta > obj2delta) {
- overlap = Object1.x + Object1.width - Object2.x;
- if((overlap > maxOverlap) || !(Object1.allowCollisions & Collision.RIGHT) || !(Object2.allowCollisions & Collision.LEFT)) {
+ var objDelta = object.x - object.last.x;
+ var tileDelta = 0;
+ if(objDelta != tileDelta) {
+ var objDeltaAbs = (objDelta > 0) ? objDelta : -objDelta;
+ var tileDeltaAbs = (tileDelta > 0) ? tileDelta : -tileDelta;
+ var objBounds = new Phaser.Quad(object.x - ((objDelta > 0) ? objDelta : 0), object.last.y, object.width + ((objDelta > 0) ? objDelta : -objDelta), object.height);
+ var tileBounds = new Phaser.Quad(tile.x - ((tileDelta > 0) ? tileDelta : 0), tile.y, tile.width + ((tileDelta > 0) ? tileDelta : -tileDelta), tile.height);
+ if((objBounds.x + objBounds.width > tileBounds.x) && (objBounds.x < tileBounds.x + tileBounds.width) && (objBounds.y + objBounds.height > tileBounds.y) && (objBounds.y < tileBounds.y + tileBounds.height)) {
+ var maxOverlap = objDeltaAbs + tileDeltaAbs + Collision.OVERLAP_BIAS;
+ if(objDelta > tileDelta) {
+ overlap = object.x + object.width - tile.x;
+ if((overlap > maxOverlap) || !(object.allowCollisions & Collision.RIGHT) || !(tile.allowCollisions & Collision.LEFT)) {
overlap = 0;
} else {
- Object1.touching |= Collision.RIGHT;
- Object2.touching |= Collision.LEFT;
+ object.touching |= Collision.RIGHT;
}
- } else if(obj1delta < obj2delta) {
- overlap = Object1.x - Object2.width - Object2.x;
- if((-overlap > maxOverlap) || !(Object1.allowCollisions & Collision.LEFT) || !(Object2.allowCollisions & Collision.RIGHT)) {
+ } else if(objDelta < tileDelta) {
+ overlap = object.x - tile.width - tile.x;
+ if((-overlap > maxOverlap) || !(object.allowCollisions & Collision.LEFT) || !(tile.allowCollisions & Collision.RIGHT)) {
overlap = 0;
} else {
- Object1.touching |= Collision.LEFT;
- Object2.touching |= Collision.RIGHT;
+ object.touching |= Collision.LEFT;
}
}
}
}
- //Then adjust their positions and velocities accordingly (if there was any overlap)
if(overlap != 0) {
- var obj1v = Object1.velocity.x;
- var obj2v = Object2.velocity.x;
- if(!obj1immovable && !obj2immovable) {
+ var objVelocity = object.velocity.x;
+ var tileVelocity = 0;
+ if(!object.immovable && !tile.immovable) {
overlap *= 0.5;
- Object1.x = Object1.x - overlap;
- Object2.x += overlap;
- var obj1velocity = Math.sqrt((obj2v * obj2v * Object2.mass) / Object1.mass) * ((obj2v > 0) ? 1 : -1);
- var obj2velocity = Math.sqrt((obj1v * obj1v * Object1.mass) / Object2.mass) * ((obj1v > 0) ? 1 : -1);
- var average = (obj1velocity + obj2velocity) * 0.5;
- obj1velocity -= average;
- obj2velocity -= average;
- Object1.velocity.x = average + obj1velocity * Object1.elasticity;
- Object2.velocity.x = average + obj2velocity * Object2.elasticity;
- } else if(!obj1immovable) {
- Object1.x = Object1.x - overlap;
- Object1.velocity.x = obj2v - obj1v * Object1.elasticity;
- } else if(!obj2immovable) {
- Object2.x += overlap;
- Object2.velocity.x = obj1v - obj2v * Object2.elasticity;
+ object.x = object.x - overlap;
+ var objNewVelocity = Math.sqrt((tileVelocity * tileVelocity * tile.mass) / object.mass) * ((tileVelocity > 0) ? 1 : -1);
+ var tileNewVelocity = Math.sqrt((objVelocity * objVelocity * object.mass) / tile.mass) * ((objVelocity > 0) ? 1 : -1);
+ var average = (objNewVelocity + tileNewVelocity) * 0.5;
+ objNewVelocity -= average;
+ object.velocity.x = average + objNewVelocity * object.elasticity;
+ } else if(!object.immovable) {
+ object.x = object.x - overlap;
+ object.velocity.x = tileVelocity - objVelocity * object.elasticity;
}
return true;
} else {
return false;
}
};
- Collision.separateY = /**
- * The Y-axis component of the object separation process.
- *
- * @param Object1 Any Sprite.
- * @param Object2 Any other Sprite.
- *
- * @return Whether the objects in fact touched and were separated along the Y axis.
- */
- function separateY(Object1, Object2) {
- //can't separate two immovable objects
- var obj1immovable = Object1.immovable;
- var obj2immovable = Object2.immovable;
- if(obj1immovable && obj2immovable) {
+ Collision.separateTileY = function separateTileY(object, tile) {
+ if(object.immovable && tile.immovable) {
return false;
}
- //If one of the objects is a tilemap, just pass it off.
- /*
- if (typeof Object1 === 'Tilemap')
- {
- return Object1.overlapsWithCallback(Object2, separateY);
- }
-
- if (typeof Object2 === 'Tilemap')
- {
- return Object2.overlapsWithCallback(Object1, separateY, true);
- }
- */
- //First, get the two object deltas
var overlap = 0;
- var obj1delta = Object1.y - Object1.last.y;
- var obj2delta = Object2.y - Object2.last.y;
- if(obj1delta != obj2delta) {
- //Check if the Y hulls actually overlap
- var obj1deltaAbs = (obj1delta > 0) ? obj1delta : -obj1delta;
- var obj2deltaAbs = (obj2delta > 0) ? obj2delta : -obj2delta;
- var obj1rect = new Phaser.Rectangle(Object1.x, Object1.y - ((obj1delta > 0) ? obj1delta : 0), Object1.width, Object1.height + obj1deltaAbs);
- var obj2rect = new Phaser.Rectangle(Object2.x, Object2.y - ((obj2delta > 0) ? obj2delta : 0), Object2.width, Object2.height + obj2deltaAbs);
- if((obj1rect.x + obj1rect.width > obj2rect.x) && (obj1rect.x < obj2rect.x + obj2rect.width) && (obj1rect.y + obj1rect.height > obj2rect.y) && (obj1rect.y < obj2rect.y + obj2rect.height)) {
- var maxOverlap = obj1deltaAbs + obj2deltaAbs + Collision.OVERLAP_BIAS;
- //If they did overlap (and can), figure out by how much and flip the corresponding flags
- if(obj1delta > obj2delta) {
- overlap = Object1.y + Object1.height - Object2.y;
- if((overlap > maxOverlap) || !(Object1.allowCollisions & Collision.DOWN) || !(Object2.allowCollisions & Collision.UP)) {
+ var objDelta = object.y - object.last.y;
+ var tileDelta = 0;
+ if(objDelta != tileDelta) {
+ var objDeltaAbs = (objDelta > 0) ? objDelta : -objDelta;
+ var tileDeltaAbs = (tileDelta > 0) ? tileDelta : -tileDelta;
+ var objBounds = new Phaser.Quad(object.x, object.y - ((objDelta > 0) ? objDelta : 0), object.width, object.height + objDeltaAbs);
+ var tileBounds = new Phaser.Quad(tile.x, tile.y - ((tileDelta > 0) ? tileDelta : 0), tile.width, tile.height + tileDeltaAbs);
+ if((objBounds.x + objBounds.width > tileBounds.x) && (objBounds.x < tileBounds.x + tileBounds.width) && (objBounds.y + objBounds.height > tileBounds.y) && (objBounds.y < tileBounds.y + tileBounds.height)) {
+ var maxOverlap = objDeltaAbs + tileDeltaAbs + Collision.OVERLAP_BIAS;
+ if(objDelta > tileDelta) {
+ overlap = object.y + object.height - tile.y;
+ if((overlap > maxOverlap) || !(object.allowCollisions & Collision.DOWN) || !(tile.allowCollisions & Collision.UP)) {
overlap = 0;
} else {
- Object1.touching |= Collision.DOWN;
- Object2.touching |= Collision.UP;
+ object.touching |= Collision.DOWN;
}
- } else if(obj1delta < obj2delta) {
- overlap = Object1.y - Object2.height - Object2.y;
- if((-overlap > maxOverlap) || !(Object1.allowCollisions & Collision.UP) || !(Object2.allowCollisions & Collision.DOWN)) {
+ } else if(objDelta < tileDelta) {
+ overlap = object.y - tile.height - tile.y;
+ if((-overlap > maxOverlap) || !(object.allowCollisions & Collision.UP) || !(tile.allowCollisions & Collision.DOWN)) {
overlap = 0;
} else {
- Object1.touching |= Collision.UP;
- Object2.touching |= Collision.DOWN;
+ object.touching |= Collision.UP;
}
}
}
}
- //Then adjust their positions and velocities accordingly (if there was any overlap)
if(overlap != 0) {
- var obj1v = Object1.velocity.y;
- var obj2v = Object2.velocity.y;
- if(!obj1immovable && !obj2immovable) {
+ var objVelocity = object.velocity.y;
+ var tileVelocity = 0;
+ if(!object.immovable && !tile.immovable) {
overlap *= 0.5;
- Object1.y = Object1.y - overlap;
- Object2.y += overlap;
- var obj1velocity = Math.sqrt((obj2v * obj2v * Object2.mass) / Object1.mass) * ((obj2v > 0) ? 1 : -1);
- var obj2velocity = Math.sqrt((obj1v * obj1v * Object1.mass) / Object2.mass) * ((obj1v > 0) ? 1 : -1);
- var average = (obj1velocity + obj2velocity) * 0.5;
- obj1velocity -= average;
- obj2velocity -= average;
- Object1.velocity.y = average + obj1velocity * Object1.elasticity;
- Object2.velocity.y = average + obj2velocity * Object2.elasticity;
- } else if(!obj1immovable) {
- Object1.y = Object1.y - overlap;
- Object1.velocity.y = obj2v - obj1v * Object1.elasticity;
- //This is special case code that handles cases like horizontal moving platforms you can ride
- if(Object2.active && Object2.moves && (obj1delta > obj2delta)) {
- Object1.x += Object2.x - Object2.last.x;
- }
- } else if(!obj2immovable) {
- Object2.y += overlap;
- Object2.velocity.y = obj1v - obj2v * Object2.elasticity;
- //This is special case code that handles cases like horizontal moving platforms you can ride
- if(Object1.active && Object1.moves && (obj1delta < obj2delta)) {
- Object2.x += Object1.x - Object1.last.x;
+ object.y = object.y - overlap;
+ var objNewVelocity = Math.sqrt((tileVelocity * tileVelocity * tile.mass) / object.mass) * ((tileVelocity > 0) ? 1 : -1);
+ var tileNewVelocity = Math.sqrt((objVelocity * objVelocity * object.mass) / tile.mass) * ((objVelocity > 0) ? 1 : -1);
+ var average = (objNewVelocity + tileNewVelocity) * 0.5;
+ objNewVelocity -= average;
+ object.velocity.y = average + objNewVelocity * object.elasticity;
+ } else if(!object.immovable) {
+ object.y = object.y - overlap;
+ object.velocity.y = tileVelocity - objVelocity * object.elasticity;
+ if(tile.active && tile.moves && (objDelta > tileDelta)) {
}
}
return true;
@@ -5120,12 +2969,131 @@ var Phaser;
return false;
}
};
- Collision.distance = /**
- * -------------------------------------------------------------------------------------------
- * Distance
- * -------------------------------------------------------------------------------------------
- **/
- function distance(x1, y1, x2, y2) {
+ Collision.separateX = function separateX(object1, object2) {
+ if(object1.immovable && object2.immovable) {
+ return false;
+ }
+ var overlap = 0;
+ var obj1Delta = object1.x - object1.last.x;
+ var obj2Delta = object2.x - object2.last.x;
+ if(obj1Delta != obj2Delta) {
+ var obj1DeltaAbs = (obj1Delta > 0) ? obj1Delta : -obj1Delta;
+ var obj2DeltaAbs = (obj2Delta > 0) ? obj2Delta : -obj2Delta;
+ var obj1Bounds = new Phaser.Quad(object1.x - ((obj1Delta > 0) ? obj1Delta : 0), object1.last.y, object1.width + ((obj1Delta > 0) ? obj1Delta : -obj1Delta), object1.height);
+ var obj2Bounds = new Phaser.Quad(object2.x - ((obj2Delta > 0) ? obj2Delta : 0), object2.last.y, object2.width + ((obj2Delta > 0) ? obj2Delta : -obj2Delta), object2.height);
+ if((obj1Bounds.x + obj1Bounds.width > obj2Bounds.x) && (obj1Bounds.x < obj2Bounds.x + obj2Bounds.width) && (obj1Bounds.y + obj1Bounds.height > obj2Bounds.y) && (obj1Bounds.y < obj2Bounds.y + obj2Bounds.height)) {
+ var maxOverlap = obj1DeltaAbs + obj2DeltaAbs + Collision.OVERLAP_BIAS;
+ if(obj1Delta > obj2Delta) {
+ overlap = object1.x + object1.width - object2.x;
+ if((overlap > maxOverlap) || !(object1.allowCollisions & Collision.RIGHT) || !(object2.allowCollisions & Collision.LEFT)) {
+ overlap = 0;
+ } else {
+ object1.touching |= Collision.RIGHT;
+ object2.touching |= Collision.LEFT;
+ }
+ } else if(obj1Delta < obj2Delta) {
+ overlap = object1.x - object2.width - object2.x;
+ if((-overlap > maxOverlap) || !(object1.allowCollisions & Collision.LEFT) || !(object2.allowCollisions & Collision.RIGHT)) {
+ overlap = 0;
+ } else {
+ object1.touching |= Collision.LEFT;
+ object2.touching |= Collision.RIGHT;
+ }
+ }
+ }
+ }
+ if(overlap != 0) {
+ var obj1Velocity = object1.velocity.x;
+ var obj2Velocity = object2.velocity.x;
+ if(!object1.immovable && !object2.immovable) {
+ overlap *= 0.5;
+ object1.x = object1.x - overlap;
+ object2.x += overlap;
+ var obj1NewVelocity = Math.sqrt((obj2Velocity * obj2Velocity * object2.mass) / object1.mass) * ((obj2Velocity > 0) ? 1 : -1);
+ var obj2NewVelocity = Math.sqrt((obj1Velocity * obj1Velocity * object1.mass) / object2.mass) * ((obj1Velocity > 0) ? 1 : -1);
+ var average = (obj1NewVelocity + obj2NewVelocity) * 0.5;
+ obj1NewVelocity -= average;
+ obj2NewVelocity -= average;
+ object1.velocity.x = average + obj1NewVelocity * object1.elasticity;
+ object2.velocity.x = average + obj2NewVelocity * object2.elasticity;
+ } else if(!object1.immovable) {
+ object1.x = object1.x - overlap;
+ object1.velocity.x = obj2Velocity - obj1Velocity * object1.elasticity;
+ } else if(!object2.immovable) {
+ object2.x += overlap;
+ object2.velocity.x = obj1Velocity - obj2Velocity * object2.elasticity;
+ }
+ return true;
+ } else {
+ return false;
+ }
+ };
+ Collision.separateY = function separateY(object1, object2) {
+ if(object1.immovable && object2.immovable) {
+ return false;
+ }
+ var overlap = 0;
+ var obj1Delta = object1.y - object1.last.y;
+ var obj2Delta = object2.y - object2.last.y;
+ if(obj1Delta != obj2Delta) {
+ var obj1DeltaAbs = (obj1Delta > 0) ? obj1Delta : -obj1Delta;
+ var obj2DeltaAbs = (obj2Delta > 0) ? obj2Delta : -obj2Delta;
+ var obj1Bounds = new Phaser.Quad(object1.x, object1.y - ((obj1Delta > 0) ? obj1Delta : 0), object1.width, object1.height + obj1DeltaAbs);
+ var obj2Bounds = new Phaser.Quad(object2.x, object2.y - ((obj2Delta > 0) ? obj2Delta : 0), object2.width, object2.height + obj2DeltaAbs);
+ if((obj1Bounds.x + obj1Bounds.width > obj2Bounds.x) && (obj1Bounds.x < obj2Bounds.x + obj2Bounds.width) && (obj1Bounds.y + obj1Bounds.height > obj2Bounds.y) && (obj1Bounds.y < obj2Bounds.y + obj2Bounds.height)) {
+ var maxOverlap = obj1DeltaAbs + obj2DeltaAbs + Collision.OVERLAP_BIAS;
+ if(obj1Delta > obj2Delta) {
+ overlap = object1.y + object1.height - object2.y;
+ if((overlap > maxOverlap) || !(object1.allowCollisions & Collision.DOWN) || !(object2.allowCollisions & Collision.UP)) {
+ overlap = 0;
+ } else {
+ object1.touching |= Collision.DOWN;
+ object2.touching |= Collision.UP;
+ }
+ } else if(obj1Delta < obj2Delta) {
+ overlap = object1.y - object2.height - object2.y;
+ if((-overlap > maxOverlap) || !(object1.allowCollisions & Collision.UP) || !(object2.allowCollisions & Collision.DOWN)) {
+ overlap = 0;
+ } else {
+ object1.touching |= Collision.UP;
+ object2.touching |= Collision.DOWN;
+ }
+ }
+ }
+ }
+ if(overlap != 0) {
+ var obj1Velocity = object1.velocity.y;
+ var obj2Velocity = object2.velocity.y;
+ if(!object1.immovable && !object2.immovable) {
+ overlap *= 0.5;
+ object1.y = object1.y - overlap;
+ object2.y += overlap;
+ var obj1NewVelocity = Math.sqrt((obj2Velocity * obj2Velocity * object2.mass) / object1.mass) * ((obj2Velocity > 0) ? 1 : -1);
+ var obj2NewVelocity = Math.sqrt((obj1Velocity * obj1Velocity * object1.mass) / object2.mass) * ((obj1Velocity > 0) ? 1 : -1);
+ var average = (obj1NewVelocity + obj2NewVelocity) * 0.5;
+ obj1NewVelocity -= average;
+ obj2NewVelocity -= average;
+ object1.velocity.y = average + obj1NewVelocity * object1.elasticity;
+ object2.velocity.y = average + obj2NewVelocity * object2.elasticity;
+ } else if(!object1.immovable) {
+ object1.y = object1.y - overlap;
+ object1.velocity.y = obj2Velocity - obj1Velocity * object1.elasticity;
+ if(object2.active && object2.moves && (obj1Delta > obj2Delta)) {
+ object1.x += object2.x - object2.last.x;
+ }
+ } else if(!object2.immovable) {
+ object2.y += overlap;
+ object2.velocity.y = obj1Velocity - obj2Velocity * object2.elasticity;
+ if(object1.active && object1.moves && (obj1Delta < obj2Delta)) {
+ object2.x += object1.x - object1.last.x;
+ }
+ }
+ return true;
+ } else {
+ return false;
+ }
+ };
+ Collision.distance = function distance(x1, y1, x2, y2) {
return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
};
Collision.distanceSquared = function distanceSquared(x1, y1, x2, y2) {
@@ -5135,15 +3103,6 @@ var Phaser;
})();
Phaser.Collision = Collision;
})(Phaser || (Phaser = {}));
-/// - * 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. - *
- * @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 - */ - function (chance) { + GameMath.prototype.chanceRoll = function (chance) { if (typeof chance === "undefined") { chance = 50; } if(chance <= 0) { return false; @@ -5804,46 +3515,21 @@ var Phaser; } } }; - GameMath.prototype.maxAdd = /** - * 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 - */ - function (value, amount, max) { + GameMath.prototype.maxAdd = function (value, amount, max) { value += amount; if(value > max) { value = max; } return value; }; - GameMath.prototype.minSub = /** - * 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 - */ - function (value, amount, min) { + GameMath.prototype.minSub = function (value, amount, min) { value -= amount; if(value < min) { value = min; } return value; }; - GameMath.prototype.wrapValue = /** - * Adds value to amount and ensures that the result always stays between 0 and max, by wrapping the value around. - *Values must be positive integers, and are passed through Math.abs
- * - * @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 - */ - function (value, amount, max) { + GameMath.prototype.wrapValue = function (value, amount, max) { var diff; value = Math.abs(value); amount = Math.abs(amount); @@ -5851,73 +3537,35 @@ var Phaser; diff = (value + amount) % max; return diff; }; - GameMath.prototype.randomSign = /** - * Randomly returns either a 1 or -1 - * - * @return 1 or -1 - */ - function () { + GameMath.prototype.randomSign = function () { return (Math.random() > 0.5) ? 1 : -1; }; - GameMath.prototype.isOdd = /** - * 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. - */ - function (n) { + GameMath.prototype.isOdd = function (n) { if(n & 1) { return true; } else { return false; } }; - GameMath.prototype.isEven = /** - * 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. - */ - function (n) { + GameMath.prototype.isEven = function (n) { if(n & 1) { return false; } else { return true; } }; - GameMath.prototype.wrapAngle = /** - * Keeps an angle value between -180 and +180- * 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 - */ - function (angle) { + GameMath.prototype.wrapAngle = function (angle) { var result = angle; - // Nothing needs to change 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; }; - GameMath.prototype.angleLimit = /** - * 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 - */ - function (angle, min, max) { + GameMath.prototype.angleLimit = function (angle, min, max) { var result = angle; if(angle > max) { result = max; @@ -5926,13 +3574,7 @@ var Phaser; } return result; }; - GameMath.prototype.linearInterpolation = /** - * @method linear - * @param {Any} v - * @param {Any} k - * @static - */ - function (v, k) { + GameMath.prototype.linearInterpolation = function (v, k) { var m = v.length - 1; var f = m * k; var i = Math.floor(f); @@ -5944,13 +3586,7 @@ var Phaser; } return this.linear(v[i], v[i + 1 > m ? m : i + 1], f - i); }; - GameMath.prototype.bezierInterpolation = /** - * @method Bezier - * @param {Any} v - * @param {Any} k - * @static - */ - function (v, k) { + GameMath.prototype.bezierInterpolation = function (v, k) { var b = 0; var n = v.length - 1; for(var i = 0; i <= n; i++) { @@ -5958,13 +3594,7 @@ var Phaser; } return b; }; - GameMath.prototype.catmullRomInterpolation = /** - * @method CatmullRom - * @param {Any} v - * @param {Any} k - * @static - */ - function (v, k) { + GameMath.prototype.catmullRomInterpolation = function (v, k) { var m = v.length - 1; var f = m * k; var i = Math.floor(f); @@ -5983,73 +3613,26 @@ var Phaser; 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); } }; - GameMath.prototype.linear = /** - * @method Linear - * @param {Any} p0 - * @param {Any} p1 - * @param {Any} t - * @static - */ - function (p0, p1, t) { + GameMath.prototype.linear = function (p0, p1, t) { return (p1 - p0) * t + p0; }; - GameMath.prototype.bernstein = /** - * @method Bernstein - * @param {Any} n - * @param {Any} i - * @static - */ - function (n, i) { + GameMath.prototype.bernstein = function (n, i) { return this.factorial(n) / this.factorial(i) / this.factorial(n - i); }; - GameMath.prototype.catmullRom = /** - * @method CatmullRom - * @param {Any} p0 - * @param {Any} p1 - * @param {Any} p2 - * @param {Any} p3 - * @param {Any} t - * @static - */ - function (p0, p1, p2, p3, t) { + 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); }; - GameMath.prototype.random = /** - * Generates a random number. Deterministic, meaning safe - * to use if you want to record replays in random environments. - * - * @return A
Number between 0 and 1.
- */
- function () {
+ GameMath.prototype.random = function () {
return this.globalSeed = this.srand(this.globalSeed);
};
- GameMath.prototype.srand = /**
- * Generates a random number based on the seed provided.
- *
- * @param Seed A number between 0 and 1, used to generate a predictable random number (very optional).
- *
- * @return A Number between 0 and 1.
- */
- function (Seed) {
+ GameMath.prototype.srand = function (Seed) {
return ((69621 * (Seed * 0x7FFFFFFF)) % 0x7FFFFFFF) / 0x7FFFFFFF;
};
- GameMath.prototype.getRandom = /**
- * Fetch a random entry from the given array.
- * Will return null if random selection is missing, or array has no entries.
- * G.getRandom() is deterministic and safe for use with replays/recordings.
- * HOWEVER, U.getRandom() is NOT deterministic and unsafe for use with replays/recordings.
- *
- * @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.
- */
- function (Objects, StartIndex, Length) {
+ GameMath.prototype.getRandom = function (Objects, StartIndex, Length) {
if (typeof StartIndex === "undefined") { StartIndex = 0; }
if (typeof Length === "undefined") { Length = 0; }
if(Objects != null) {
@@ -6063,43 +3646,15 @@ var Phaser;
}
return null;
};
- GameMath.prototype.floor = /**
- * 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.
- */
- function (Value) {
+ GameMath.prototype.floor = function (Value) {
var n = Value | 0;
return (Value > 0) ? (n) : ((n != Value) ? (n - 1) : (n));
};
- GameMath.prototype.ceil = /**
- * 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.
- */
- function (Value) {
+ GameMath.prototype.ceil = function (Value) {
var n = Value | 0;
return (Value > 0) ? ((n != Value) ? (n + 1) : (n)) : (n);
};
- GameMath.prototype.sinCosGenerator = /**
- * Generate a sine and cosine table simultaneously and extremely quickly. Based on research by Franky of scene.at
- * - * 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. - *
- * @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 - */ - function (length, sinAmplitude, cosAmplitude, frequency) { + 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; } @@ -6116,66 +3671,30 @@ var Phaser; } return this.sinTable; }; - GameMath.prototype.shiftSinTable = /** - * 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. - */ - function () { + GameMath.prototype.shiftSinTable = function () { if(this.sinTable) { var s = this.sinTable.shift(); this.sinTable.push(s); return s; } }; - GameMath.prototype.shiftCosTable = /** - * 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. - */ - function () { + GameMath.prototype.shiftCosTable = function () { if(this.cosTable) { var s = this.cosTable.shift(); this.cosTable.push(s); return s; } }; - GameMath.prototype.vectorLength = /** - * Finds the length of the given vector - * - * @param dx - * @param dy - * - * @return - */ - function (dx, dy) { + GameMath.prototype.vectorLength = function (dx, dy) { return Math.sqrt(dx * dx + dy * dy); }; - GameMath.prototype.dotProduct = /** - * Finds the dot product value of two vectors - * - * @param ax Vector X - * @param ay Vector Y - * @param bx Vector X - * @param by Vector Y - * - * @return Dot product - */ - function (ax, ay, bx, by) { + GameMath.prototype.dotProduct = function (ax, ay, bx, by) { return ax * bx + ay * by; }; return GameMath; })(); Phaser.GameMath = GameMath; })(Phaser || (Phaser = {})); -///Basic subclass (Basic, Basic, Enemy, etc) to the group.
- * Group will try to replace a null member of the array first.
- * Failing that, Group will add it to the end of the member array,
- * assuming there is room for it, and doubling the size of the array if necessary.
- *
- * WARNING: If the group has a maxSize that has already been met, - * the object will NOT be added to the group!
- * - * @param Object The object you want to add to the group. - * - * @return The sameBasic object that was passed in.
- */
- function (Object) {
- //Don't bother adding an object twice.
+ Group.prototype.add = function (Object) {
if(this.members.indexOf(Object) >= 0) {
return Object;
}
- //First, look for a null entry where we can add the object.
var i = 0;
var l = this.members.length;
while(i < l) {
@@ -6302,7 +3789,6 @@ var Phaser;
}
i++;
}
- //Failing that, expand the array (if we can) and add the object.
if(this._maxSize > 0) {
if(this.members.length >= this._maxSize) {
return Object;
@@ -6314,36 +3800,11 @@ var Phaser;
} else {
this.members.length *= 2;
}
- //If we made it this far, then we successfully grew the group,
- //and we can go ahead and add the object at the first open slot.
this.members[i] = Object;
this.length = i + 1;
return Object;
};
- Group.prototype.recycle = /**
- * Recycling is designed to help you reuse game objects without always re-allocating or "newing" them.
- *
- * If you specified a maximum size for this group (like in Emitter), - * then recycle will employ what we're calling "rotating" recycling. - * Recycle() will first check to see if the group is at capacity yet. - * If group is not yet at capacity, recycle() returns a new object. - * If the group IS at capacity, then recycle() just returns the next object in line.
- * - *If you did NOT specify a maximum size for this group, - * then recycle() will employ what we're calling "grow-style" recycling. - * Recycle() will return either the first object with exists == false, - * or, finding none, add a new object to the array, - * doubling the size of the array if necessary.
- * - *WARNING: If this function needs to create a new object, - * and no object class was provided, it will return null - * instead of a valid object!
- * - * @param ObjectClass The class type you want to recycle (e.g. Basic, EvilRobot, etc). Do NOT "new" the class in the parameter! - * - * @return A reference to the object that was created. Don't forget to cast it back to the Class you want (e.g. myObject = myGroup.recycle(myObjectClass) as myObjectClass;). - */ - function (ObjectClass) { + Group.prototype.recycle = function (ObjectClass) { if (typeof ObjectClass === "undefined") { ObjectClass = null; } var basic; if(this._maxSize > 0) { @@ -6370,15 +3831,7 @@ var Phaser; return this.add(new ObjectClass(this._game)); } }; - Group.prototype.remove = /** - * Removes an object from the group. - * - * @param Object TheBasic you want to remove.
- * @param Splice Whether the object should be cut from the array entirely or not.
- *
- * @return The removed object.
- */
- function (Object, Splice) {
+ Group.prototype.remove = function (Object, Splice) {
if (typeof Splice === "undefined") { Splice = false; }
var index = this.members.indexOf(Object);
if((index < 0) || (index >= this.members.length)) {
@@ -6392,15 +3845,7 @@ var Phaser;
}
return Object;
};
- Group.prototype.replace = /**
- * Replaces an existing Basic with a new one.
- *
- * @param OldObject The object you want to replace.
- * @param NewObject The new object you want to use instead.
- *
- * @return The new object.
- */
- function (OldObject, NewObject) {
+ Group.prototype.replace = function (OldObject, NewObject) {
var index = this.members.indexOf(OldObject);
if((index < 0) || (index >= this.members.length)) {
return null;
@@ -6408,31 +3853,14 @@ var Phaser;
this.members[index] = NewObject;
return NewObject;
};
- Group.prototype.sort = /**
- * Call this function to sort the group according to a particular value and order.
- * For example, to sort game objects for Zelda-style overlaps you might call
- * myGroup.sort("y",Group.ASCENDING) at the bottom of your
- * State.update() override. To sort all existing objects after
- * a big explosion or bomb attack, you might call myGroup.sort("exists",Group.DESCENDING).
- *
- * @param Index The string name of the member variable you want to sort on. Default value is "y".
- * @param Order A Group constant that defines the sort order. Possible values are Group.ASCENDING and Group.DESCENDING. Default value is Group.ASCENDING.
- */
- function (Index, Order) {
+ Group.prototype.sort = function (Index, Order) {
if (typeof Index === "undefined") { Index = "y"; }
if (typeof Order === "undefined") { Order = Group.ASCENDING; }
this._sortIndex = Index;
this._sortOrder = Order;
this.members.sort(this.sortHandler);
};
- Group.prototype.setAll = /**
- * Go through and set the specified variable to the specified value on all members of the group.
- *
- * @param VariableName The string representation of the variable name you want to modify, for example "visible" or "scrollFactor".
- * @param Value The value you want to assign to that variable.
- * @param Recurse Default value is true, meaning if setAll() encounters a member that is a group, it will call setAll() on that group rather than modifying its variable.
- */
- function (VariableName, Value, Recurse) {
+ Group.prototype.setAll = function (VariableName, Value, Recurse) {
if (typeof Recurse === "undefined") { Recurse = true; }
var basic;
var i = 0;
@@ -6447,14 +3875,7 @@ var Phaser;
}
}
};
- Group.prototype.callAll = /**
- * Go through and call the specified function on all members of the group.
- * Currently only works on functions that have no required parameters.
- *
- * @param FunctionName The string representation of the function you want to call on each object, for example "kill()" or "init()".
- * @param Recurse Default value is true, meaning if callAll() encounters a member that is a group, it will call callAll() on that group rather than calling the group's function.
- */
- function (FunctionName, Recurse) {
+ Group.prototype.callAll = function (FunctionName, Recurse) {
if (typeof Recurse === "undefined") { Recurse = true; }
var basic;
var i = 0;
@@ -6469,14 +3890,14 @@ var Phaser;
}
}
};
- Group.prototype.forEach = function (callback, Recurse) {
- if (typeof Recurse === "undefined") { Recurse = false; }
+ Group.prototype.forEach = function (callback, recursive) {
+ if (typeof recursive === "undefined") { recursive = false; }
var basic;
var i = 0;
while(i < this.length) {
basic = this.members[i++];
if(basic != null) {
- if(Recurse && (basic.isGroup == true)) {
+ if(recursive && (basic.isGroup == true)) {
basic.forEach(callback, true);
} else {
callback.call(this, basic);
@@ -6484,15 +3905,22 @@ var Phaser;
}
}
};
- Group.prototype.getFirstAvailable = /**
- * Call this function to retrieve the first object with exists == false in the group.
- * This is handy for recycling in general, e.g. respawning enemies.
- *
- * @param ObjectClass An optional parameter that lets you narrow the results to instances of this particular class.
- *
- * @return A Basic currently flagged as not existing.
- */
- function (ObjectClass) {
+ Group.prototype.forEachAlive = function (callback, recursive) {
+ if (typeof recursive === "undefined") { recursive = false; }
+ var basic;
+ var i = 0;
+ while(i < this.length) {
+ basic = this.members[i++];
+ if(basic != null && basic.alive) {
+ if(recursive && (basic.isGroup == true)) {
+ basic.forEachAlive(callback, true);
+ } else {
+ callback.call(this, basic);
+ }
+ }
+ }
+ };
+ Group.prototype.getFirstAvailable = function (ObjectClass) {
if (typeof ObjectClass === "undefined") { ObjectClass = null; }
var basic;
var i = 0;
@@ -6504,13 +3932,7 @@ var Phaser;
}
return null;
};
- Group.prototype.getFirstNull = /**
- * Call this function to retrieve the first index set to 'null'.
- * Returns -1 if no index stores a null object.
- *
- * @return An int indicating the first null slot in the group.
- */
- function () {
+ Group.prototype.getFirstNull = function () {
var basic;
var i = 0;
var l = this.members.length;
@@ -6523,13 +3945,7 @@ var Phaser;
}
return -1;
};
- Group.prototype.getFirstExtant = /**
- * Call this function to retrieve the first object with exists == true in the group.
- * This is handy for checking if everything's wiped out, or choosing a squad leader, etc.
- *
- * @return A Basic currently flagged as existing.
- */
- function () {
+ Group.prototype.getFirstExtant = function () {
var basic;
var i = 0;
while(i < length) {
@@ -6540,13 +3956,7 @@ var Phaser;
}
return null;
};
- Group.prototype.getFirstAlive = /**
- * Call this function to retrieve the first object with dead == false in the group.
- * This is handy for checking if everything's wiped out, or choosing a squad leader, etc.
- *
- * @return A Basic currently flagged as not dead.
- */
- function () {
+ Group.prototype.getFirstAlive = function () {
var basic;
var i = 0;
while(i < this.length) {
@@ -6557,13 +3967,7 @@ var Phaser;
}
return null;
};
- Group.prototype.getFirstDead = /**
- * Call this function to retrieve the first object with dead == true in the group.
- * This is handy for checking if everything's wiped out, or choosing a squad leader, etc.
- *
- * @return A Basic currently flagged as dead.
- */
- function () {
+ Group.prototype.getFirstDead = function () {
var basic;
var i = 0;
while(i < this.length) {
@@ -6574,12 +3978,7 @@ var Phaser;
}
return null;
};
- Group.prototype.countLiving = /**
- * Call this function to find out how many members of the group are not dead.
- *
- * @return The number of Basics flagged as not dead. Returns -1 if group is empty.
- */
- function () {
+ Group.prototype.countLiving = function () {
var count = -1;
var basic;
var i = 0;
@@ -6596,12 +3995,7 @@ var Phaser;
}
return count;
};
- Group.prototype.countDead = /**
- * Call this function to find out how many members of the group are dead.
- *
- * @return The number of Basics flagged as dead. Returns -1 if group is empty.
- */
- function () {
+ Group.prototype.countDead = function () {
var count = -1;
var basic;
var i = 0;
@@ -6618,15 +4012,7 @@ var Phaser;
}
return count;
};
- Group.prototype.getRandom = /**
- * Returns a member at random from the group.
- *
- * @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 A Basic from the members list.
- */
- function (StartIndex, Length) {
+ Group.prototype.getRandom = function (StartIndex, Length) {
if (typeof StartIndex === "undefined") { StartIndex = 0; }
if (typeof Length === "undefined") { Length = 0; }
if(Length == 0) {
@@ -6634,17 +4020,10 @@ var Phaser;
}
return this._game.math.getRandom(this.members, StartIndex, Length);
};
- Group.prototype.clear = /**
- * Remove all instances of Basic subclass (Basic, Block, etc) from the list.
- * WARNING: does not destroy() or kill() any of these objects!
- */
- function () {
+ Group.prototype.clear = function () {
this.length = this.members.length = 0;
};
- Group.prototype.kill = /**
- * Calls kill on the group's members and then on the group itself.
- */
- function () {
+ Group.prototype.kill = function () {
var basic;
var i = 0;
while(i < this.length) {
@@ -6654,15 +4033,7 @@ var Phaser;
}
}
};
- Group.prototype.sortHandler = /**
- * Helper function for the sort process.
- *
- * @param Obj1 The first object being sorted.
- * @param Obj2 The second object being sorted.
- *
- * @return An integer value: -1 (Obj1 before Obj2), 0 (same), or 1 (Obj1 after Obj2).
- */
- function (Obj1, Obj2) {
+ Group.prototype.sortHandler = function (Obj1, Obj2) {
if(Obj1[this._sortIndex] < Obj2[this._sortIndex]) {
return this._sortOrder;
} else if(Obj1[this._sortIndex] > Obj2[this._sortIndex]) {
@@ -6674,13 +4045,6 @@ var Phaser;
})(Phaser.Basic);
Phaser.Group = Group;
})(Phaser || (Phaser = {}));
-/// - * If you specify a maxTime then it will adjust the speed (over-writing what you set) so it arrives at the destination in that number of seconds.
- * Timings are approximate due to the way Flash timers work, and irrespective of SWF frame rate. Allow for a variance of +- 50ms.
- * The source object doesn't stop moving automatically should it ever reach the destination coordinates.
- * If you need the object to accelerate, see accelerateTowardsObject() instead - * Note: Doesn't take into account acceleration, maxVelocity or drag (if you set drag or acceleration too high this object may not move at all) - * - * @param source The Sprite on which the velocity will be set - * @param dest The Sprite where the source object will move to - * @param speed The speed it will move, in pixels per second (default is 60 pixels/sec) - * @param maxTime Time given in milliseconds (1000 = 1 sec). If set the speed is adjusted so the source will arrive at destination in the given number of ms - */ - function (source, dest, speed, maxTime) { + Motion.prototype.moveTowardsObject = function (source, dest, speed, maxTime) { if (typeof speed === "undefined") { speed = 60; } if (typeof maxTime === "undefined") { maxTime = 0; } var a = this.angleBetween(source, dest); if(maxTime > 0) { var d = this.distanceBetween(source, dest); - // We know how many pixels we need to move, but how fast? speed = d / (maxTime / 1000); } source.velocity.x = Math.cos(a) * speed; source.velocity.y = Math.sin(a) * speed; }; - Motion.prototype.accelerateTowardsObject = /** - * Sets the x/y acceleration on the source Sprite so it will move towards the destination Sprite at the speed given (in pixels per second)
- * You must give a maximum speed value, beyond which the Sprite won't go any faster.
- * If you don't need acceleration look at moveTowardsObject() instead. - * - * @param source The Sprite on which the acceleration will be set - * @param dest The Sprite where the source object will move towards - * @param speed The speed it will accelerate in pixels per second - * @param xSpeedMax The maximum speed in pixels per second in which the sprite can move horizontally - * @param ySpeedMax The maximum speed in pixels per second in which the sprite can move vertically - */ - function (source, dest, speed, xSpeedMax, ySpeedMax) { + Motion.prototype.accelerateTowardsObject = function (source, dest, speed, xSpeedMax, ySpeedMax) { var a = this.angleBetween(source, dest); source.velocity.x = 0; source.velocity.y = 0; @@ -7091,39 +4398,18 @@ var Phaser; source.maxVelocity.x = xSpeedMax; source.maxVelocity.y = ySpeedMax; }; - Motion.prototype.moveTowardsMouse = /** - * Move the given Sprite towards the mouse pointer coordinates at a steady velocity - * If you specify a maxTime then it will adjust the speed (over-writing what you set) so it arrives at the destination in that number of seconds.
- * Timings are approximate due to the way Flash timers work, and irrespective of SWF frame rate. Allow for a variance of +- 50ms.
- * The source object doesn't stop moving automatically should it ever reach the destination coordinates.
- * - * @param source The Sprite to move - * @param speed The speed it will move, in pixels per second (default is 60 pixels/sec) - * @param maxTime Time given in milliseconds (1000 = 1 sec). If set the speed is adjusted so the source will arrive at destination in the given number of ms - */ - function (source, speed, maxTime) { + Motion.prototype.moveTowardsMouse = function (source, speed, maxTime) { if (typeof speed === "undefined") { speed = 60; } if (typeof maxTime === "undefined") { maxTime = 0; } var a = this.angleBetweenMouse(source); if(maxTime > 0) { var d = this.distanceToMouse(source); - // We know how many pixels we need to move, but how fast? speed = d / (maxTime / 1000); } source.velocity.x = Math.cos(a) * speed; source.velocity.y = Math.sin(a) * speed; }; - Motion.prototype.accelerateTowardsMouse = /** - * Sets the x/y acceleration on the source Sprite so it will move towards the mouse coordinates at the speed given (in pixels per second)
- * You must give a maximum speed value, beyond which the Sprite won't go any faster.
- * If you don't need acceleration look at moveTowardsMouse() instead. - * - * @param source The Sprite on which the acceleration will be set - * @param speed The speed it will accelerate in pixels per second - * @param xSpeedMax The maximum speed in pixels per second in which the sprite can move horizontally - * @param ySpeedMax The maximum speed in pixels per second in which the sprite can move vertically - */ - function (source, speed, xSpeedMax, ySpeedMax) { + Motion.prototype.accelerateTowardsMouse = function (source, speed, xSpeedMax, ySpeedMax) { var a = this.angleBetweenMouse(source); source.velocity.x = 0; source.velocity.y = 0; @@ -7132,41 +4418,18 @@ var Phaser; source.maxVelocity.x = xSpeedMax; source.maxVelocity.y = ySpeedMax; }; - Motion.prototype.moveTowardsPoint = /** - * Sets the x/y velocity on the source Sprite so it will move towards the target coordinates at the speed given (in pixels per second)
- * If you specify a maxTime then it will adjust the speed (over-writing what you set) so it arrives at the destination in that number of seconds.
- * Timings are approximate due to the way Flash timers work, and irrespective of SWF frame rate. Allow for a variance of +- 50ms.
- * The source object doesn't stop moving automatically should it ever reach the destination coordinates.
- * - * @param source The Sprite to move - * @param target The Point coordinates to move the source Sprite towards - * @param speed The speed it will move, in pixels per second (default is 60 pixels/sec) - * @param maxTime Time given in milliseconds (1000 = 1 sec). If set the speed is adjusted so the source will arrive at destination in the given number of ms - */ - function (source, target, speed, maxTime) { + Motion.prototype.moveTowardsPoint = function (source, target, speed, maxTime) { if (typeof speed === "undefined") { speed = 60; } if (typeof maxTime === "undefined") { maxTime = 0; } var a = this.angleBetweenPoint(source, target); if(maxTime > 0) { var d = this.distanceToPoint(source, target); - // We know how many pixels we need to move, but how fast? speed = d / (maxTime / 1000); } source.velocity.x = Math.cos(a) * speed; source.velocity.y = Math.sin(a) * speed; }; - Motion.prototype.accelerateTowardsPoint = /** - * Sets the x/y acceleration on the source Sprite so it will move towards the target coordinates at the speed given (in pixels per second)
- * You must give a maximum speed value, beyond which the Sprite won't go any faster.
- * If you don't need acceleration look at moveTowardsPoint() instead. - * - * @param source The Sprite on which the acceleration will be set - * @param target The Point coordinates to move the source Sprite towards - * @param speed The speed it will accelerate in pixels per second - * @param xSpeedMax The maximum speed in pixels per second in which the sprite can move horizontally - * @param ySpeedMax The maximum speed in pixels per second in which the sprite can move vertically - */ - function (source, target, speed, xSpeedMax, ySpeedMax) { + Motion.prototype.accelerateTowardsPoint = function (source, target, speed, xSpeedMax, ySpeedMax) { var a = this.angleBetweenPoint(source, target); source.velocity.x = 0; source.velocity.y = 0; @@ -7175,52 +4438,22 @@ var Phaser; source.maxVelocity.x = xSpeedMax; source.maxVelocity.y = ySpeedMax; }; - Motion.prototype.distanceBetween = /** - * Find the distance (in pixels, rounded) between two Sprites, taking their origin into account - * - * @param a The first Sprite - * @param b The second Sprite - * @return int Distance (in pixels) - */ - function (a, b) { + Motion.prototype.distanceBetween = function (a, b) { var dx = (a.x + a.origin.x) - (b.x + b.origin.x); var dy = (a.y + a.origin.y) - (b.y + b.origin.y); return this._game.math.vectorLength(dx, dy); }; - Motion.prototype.distanceToPoint = /** - * Find the distance (in pixels, rounded) from an Sprite to the given Point, taking the source origin into account - * - * @param a The Sprite - * @param target The Point - * @return int Distance (in pixels) - */ - function (a, target) { + Motion.prototype.distanceToPoint = function (a, target) { var dx = (a.x + a.origin.x) - (target.x); var dy = (a.y + a.origin.y) - (target.y); return this._game.math.vectorLength(dx, dy); }; - Motion.prototype.distanceToMouse = /** - * Find the distance (in pixels, rounded) from the object x/y and the mouse x/y - * - * @param a The Sprite to test against - * @return int The distance between the given sprite and the mouse coordinates - */ - function (a) { + Motion.prototype.distanceToMouse = function (a) { var dx = (a.x + a.origin.x) - this._game.input.x; var dy = (a.y + a.origin.y) - this._game.input.y; return this._game.math.vectorLength(dx, dy); }; - Motion.prototype.angleBetweenPoint = /** - * Find the angle (in radians) between an Sprite and an Point. The source sprite takes its x/y and origin into account. - * The angle is calculated in clockwise positive direction (down = 90 degrees positive, right = 0 degrees positive, up = 90 degrees negative) - * - * @param a The Sprite to test from - * @param target The Point to angle the Sprite towards - * @param asDegrees If you need the value in degrees instead of radians, set to true - * - * @return Number The angle (in radians unless asDegrees is true) - */ - function (a, target, asDegrees) { + Motion.prototype.angleBetweenPoint = function (a, target, asDegrees) { if (typeof asDegrees === "undefined") { asDegrees = false; } var dx = (target.x) - (a.x + a.origin.x); var dy = (target.y) - (a.y + a.origin.y); @@ -7230,17 +4463,7 @@ var Phaser; return Math.atan2(dy, dx); } }; - Motion.prototype.angleBetween = /** - * Find the angle (in radians) between the two Sprite, taking their x/y and origin into account. - * The angle is calculated in clockwise positive direction (down = 90 degrees positive, right = 0 degrees positive, up = 90 degrees negative) - * - * @param a The Sprite to test from - * @param b The Sprite to test to - * @param asDegrees If you need the value in degrees instead of radians, set to true - * - * @return Number The angle (in radians unless asDegrees is true) - */ - function (a, b, asDegrees) { + Motion.prototype.angleBetween = function (a, b, asDegrees) { if (typeof asDegrees === "undefined") { asDegrees = false; } var dx = (b.x + b.origin.x) - (a.x + a.origin.x); var dy = (b.y + b.origin.y) - (a.y + a.origin.y); @@ -7250,15 +4473,7 @@ var Phaser; return Math.atan2(dy, dx); } }; - Motion.prototype.velocityFromFacing = /** - * Given the GameObject and speed calculate the velocity and return it as an Point based on the direction the sprite is facing - * - * @param parent The Sprite to get the facing value from - * @param speed The speed it will move, in pixels per second sq - * - * @return An Point where Point.x contains the velocity x value and Point.y contains the velocity y value - */ - function (parent, speed) { + Motion.prototype.velocityFromFacing = function (parent, speed) { var a; if(parent.facing == Phaser.Collision.LEFT) { a = this._game.math.degreesToRadians(180); @@ -7271,18 +4486,8 @@ var Phaser; } return new Phaser.Point(Math.cos(a) * speed, Math.sin(a) * speed); }; - Motion.prototype.angleBetweenMouse = /** - * Find the angle (in radians) between an Sprite and the mouse, taking their x/y and origin into account. - * The angle is calculated in clockwise positive direction (down = 90 degrees positive, right = 0 degrees positive, up = 90 degrees negative) - * - * @param a The Object to test from - * @param asDegrees If you need the value in degrees instead of radians, set to true - * - * @return Number The angle (in radians unless asDegrees is true) - */ - function (a, asDegrees) { + Motion.prototype.angleBetweenMouse = function (a, asDegrees) { if (typeof asDegrees === "undefined") { asDegrees = false; } - // In order to get the angle between the object and mouse, we need the objects screen coordinates (rather than world coordinates) var p = a.getScreenXY(); var dx = a._game.input.x - p.x; var dy = a._game.input.y - p.y; @@ -7296,13 +4501,6 @@ var Phaser; })(); Phaser.Motion = Motion; })(Phaser || (Phaser = {})); -///
Emitter object at a specific position.
- * Does NOT automatically generate or attach particles!
- *
- * @param X The X position of the emitter.
- * @param Y The Y position of the emitter.
- * @param Size Optional, specifies a maximum capacity for this emitter.
- */
function Emitter(game, X, Y, Size) {
if (typeof X === "undefined") { X = 0; }
if (typeof Y === "undefined") { Y = 0; }
@@ -10365,10 +6639,7 @@ var Phaser;
this.on = false;
this._point = new Phaser.Point();
}
- Emitter.prototype.destroy = /**
- * Clean up memory.
- */
- function () {
+ Emitter.prototype.destroy = function () {
this.minParticleSpeed = null;
this.maxParticleSpeed = null;
this.particleDrag = null;
@@ -10376,33 +6647,13 @@ var Phaser;
this._point = null;
_super.prototype.destroy.call(this);
};
- Emitter.prototype.makeParticles = /**
- * This function generates a new array of particle sprites to attach to the emitter.
- *
- * @param Graphics If you opted to not pre-configure an array of Sprite objects, you can simply pass in a particle image or sprite sheet.
- * @param Quantity The number of particles to generate when using the "create from image" option.
- * @param BakedRotations How many frames of baked rotation to use (boosts performance). Set to zero to not use baked rotations.
- * @param Multiple Whether the image in the Graphics param is a single particle or a bunch of particles (if it's a bunch, they need to be square!).
- * @param Collide Whether the particles should be flagged as not 'dead' (non-colliding particles are higher performance). 0 means no collisions, 0-1 controls scale of particle's bounding box.
- *
- * @return This Emitter instance (nice for chaining stuff together, if you're into that).
- */
- function (Graphics, Quantity, BakedRotations, Multiple, Collide) {
+ Emitter.prototype.makeParticles = function (Graphics, Quantity, BakedRotations, Multiple, Collide) {
if (typeof Quantity === "undefined") { Quantity = 50; }
if (typeof BakedRotations === "undefined") { BakedRotations = 16; }
if (typeof Multiple === "undefined") { Multiple = false; }
if (typeof Collide === "undefined") { Collide = 0.8; }
this.maxSize = Quantity;
var totalFrames = 1;
- /*
- if(Multiple)
- {
- var sprite:Sprite = new Sprite(this._game);
- sprite.loadGraphic(Graphics,true);
- totalFrames = sprite.frames;
- sprite.destroy();
- }
- */
var randomFrame;
var particle;
var i = 0;
@@ -10413,23 +6664,7 @@ var Phaser;
particle = new this.particleClass(this._game);
}
if(Multiple) {
- /*
- randomFrame = this._game.math.random()*totalFrames;
- if(BakedRotations > 0)
- particle.loadRotatedGraphic(Graphics,BakedRotations,randomFrame);
- else
- {
- particle.loadGraphic(Graphics,true);
- particle.frame = randomFrame;
- }
- */
- } else {
- /*
- if (BakedRotations > 0)
- particle.loadRotatedGraphic(Graphics,BakedRotations);
- else
- particle.loadGraphic(Graphics);
- */
+ } else {
if(Graphics) {
particle.loadGraphic(Graphics);
}
@@ -10437,8 +6672,7 @@ var Phaser;
if(Collide > 0) {
particle.width *= Collide;
particle.height *= Collide;
- //particle.centerOffsets();
- } else {
+ } else {
particle.allowCollisions = Phaser.Collision.NONE;
}
particle.exists = false;
@@ -10447,10 +6681,7 @@ var Phaser;
}
return this;
};
- Emitter.prototype.update = /**
- * Called automatically by the game loop, decides when to launch particles and when to "die".
- */
- function () {
+ Emitter.prototype.update = function () {
if(this.on) {
if(this._explode) {
this.on = false;
@@ -10478,22 +6709,11 @@ var Phaser;
}
_super.prototype.update.call(this);
};
- Emitter.prototype.kill = /**
- * Call this function to turn off all the particles and the emitter.
- */
- function () {
+ Emitter.prototype.kill = function () {
this.on = false;
_super.prototype.kill.call(this);
};
- Emitter.prototype.start = /**
- * Call this function to start emitting particles.
- *
- * @param Explode Whether the particles should all burst out at once.
- * @param Lifespan How long each particle lives once emitted. 0 = forever.
- * @param Frequency Ignored if Explode is set to true. Frequency is how often to emit a particle. 0 = never emit, 0.1 = 1 particle every 0.1 seconds, 5 = 1 particle every 5 seconds.
- * @param Quantity How many particles to launch. 0 = "all of the particles".
- */
- function (Explode, Lifespan, Frequency, Quantity) {
+ Emitter.prototype.start = function (Explode, Lifespan, Frequency, Quantity) {
if (typeof Explode === "undefined") { Explode = true; }
if (typeof Lifespan === "undefined") { Lifespan = 0; }
if (typeof Frequency === "undefined") { Frequency = 0.1; }
@@ -10508,10 +6728,7 @@ var Phaser;
this._counter = 0;
this._timer = 0;
};
- Emitter.prototype.emitParticle = /**
- * This function can be used both internally and externally to emit the next particle.
- */
- function () {
+ Emitter.prototype.emitParticle = function () {
var particle = this.recycle(Phaser.Particle);
particle.lifespan = this.lifespan;
particle.elasticity = this.bounce;
@@ -10540,58 +6757,29 @@ var Phaser;
particle.drag.y = this.particleDrag.y;
particle.onEmit();
};
- Emitter.prototype.setSize = /**
- * A more compact way of setting the width and height of the emitter.
- *
- * @param Width The desired width of the emitter (particles are spawned randomly within these dimensions).
- * @param Height The desired height of the emitter.
- */
- function (Width, Height) {
+ Emitter.prototype.setSize = function (Width, Height) {
this.width = Width;
this.height = Height;
};
- Emitter.prototype.setXSpeed = /**
- * A more compact way of setting the X velocity range of the emitter.
- *
- * @param Min The minimum value for this range.
- * @param Max The maximum value for this range.
- */
- function (Min, Max) {
+ Emitter.prototype.setXSpeed = function (Min, Max) {
if (typeof Min === "undefined") { Min = 0; }
if (typeof Max === "undefined") { Max = 0; }
this.minParticleSpeed.x = Min;
this.maxParticleSpeed.x = Max;
};
- Emitter.prototype.setYSpeed = /**
- * A more compact way of setting the Y velocity range of the emitter.
- *
- * @param Min The minimum value for this range.
- * @param Max The maximum value for this range.
- */
- function (Min, Max) {
+ Emitter.prototype.setYSpeed = function (Min, Max) {
if (typeof Min === "undefined") { Min = 0; }
if (typeof Max === "undefined") { Max = 0; }
this.minParticleSpeed.y = Min;
this.maxParticleSpeed.y = Max;
};
- Emitter.prototype.setRotation = /**
- * A more compact way of setting the angular velocity constraints of the emitter.
- *
- * @param Min The minimum value for this range.
- * @param Max The maximum value for this range.
- */
- function (Min, Max) {
+ Emitter.prototype.setRotation = function (Min, Max) {
if (typeof Min === "undefined") { Min = 0; }
if (typeof Max === "undefined") { Max = 0; }
this.minRotation = Min;
this.maxRotation = Max;
};
- Emitter.prototype.at = /**
- * Change the emitter's midpoint to match the midpoint of a Object.
- *
- * @param Object The Object that you want to sync up with.
- */
- function (Object) {
+ Emitter.prototype.at = function (Object) {
Object.getMidpoint(this._point);
this.x = this._point.x - (this.width >> 1);
this.y = this._point.y - (this.height >> 1);
@@ -10600,14 +6788,6 @@ var Phaser;
})(Phaser.Group);
Phaser.Emitter = Emitter;
})(Phaser || (Phaser = {}));
-/// Sprite, all meaningful creation
- * happens during loadGraphic() or makeGraphic() or whatever.
- */
function Particle(game) {
_super.call(this, game);
this.lifespan = 0;
this.friction = 500;
}
- Particle.prototype.update = /**
- * The particle's main update logic. Basically it checks to see if it should
- * be dead yet, and then has some special bounce behavior if there is some gravity on it.
- */
- function () {
- //lifespan behavior
+ Particle.prototype.update = function () {
if(this.lifespan <= 0) {
return;
}
@@ -10947,14 +7064,12 @@ var Phaser;
if(this.lifespan <= 0) {
this.kill();
}
- //simpler bounce/spin behavior for now
if(this.touching) {
if(this.angularVelocity != 0) {
this.angularVelocity = -this.angularVelocity;
}
}
- if(this.acceleration.y > 0)//special behavior for particles with gravity
- {
+ if(this.acceleration.y > 0) {
if(this.touching & Phaser.Collision.FLOOR) {
this.drag.x = this.friction;
if(!(this.wasTouching & Phaser.Collision.FLOOR)) {
@@ -10972,26 +7087,16 @@ var Phaser;
}
}
};
- Particle.prototype.onEmit = /**
- * Triggered whenever this object is launched by a Emitter.
- * You can override this to add custom behavior like a sound or AI or something.
- */
- function () {
+ Particle.prototype.onEmit = function () {
};
return Particle;
})(Phaser.Sprite);
Phaser.Particle = Particle;
})(Phaser || (Phaser = {}));
-/// Tilemap that helps expand collision opportunities and control.
-*/
-var Phaser;
-(function (Phaser) {
- var Tile = (function (_super) {
- __extends(Tile, _super);
- /**
- * Instantiate this new tile object. This is usually called from Tilemap.loadMap().
- *
- * @param Tilemap A reference to the tilemap object creating the tile.
- * @param Index The actual core map data index for this tile type.
- * @param Width The width of the tile.
- * @param Height The height of the tile.
- * @param Visible Whether the tile is visible or not.
- * @param AllowCollisions The collision flags for the object. By default this value is ANY or NONE depending on the parameters sent to loadMap().
- */
- function Tile(game, Tilemap, Index, Width, Height, Visible, AllowCollisions) {
- _super.call(this, game, 0, 0, Width, Height);
- this.immovable = true;
- this.moves = false;
- this.callback = null;
- this.filter = null;
- this.tilemap = Tilemap;
- this.index = Index;
- this.visible = Visible;
- this.allowCollisions = AllowCollisions;
- this.mapIndex = 0;
- }
- Tile.prototype.destroy = /**
- * Clean up memory.
- */
- function () {
- _super.prototype.destroy.call(this);
- this.callback = null;
- this.tilemap = null;
+ AnimationManager.prototype.stop = function (name) {
+ if(this._anims[name]) {
+ this.currentAnim = this._anims[name];
+ this.currentAnim.stop();
+ }
};
- return Tile;
- })(Phaser.GameObject);
- Phaser.Tile = Tile;
+ AnimationManager.prototype.update = function () {
+ if(this.currentAnim && this.currentAnim.update() == true) {
+ this.currentFrame = this.currentAnim.currentFrame;
+ this._parent.bounds.width = this.currentFrame.width;
+ this._parent.bounds.height = this.currentFrame.height;
+ }
+ };
+ Object.defineProperty(AnimationManager.prototype, "frameData", {
+ get: function () {
+ return this._frameData;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(AnimationManager.prototype, "frameTotal", {
+ get: function () {
+ return this._frameData.total;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(AnimationManager.prototype, "frame", {
+ get: function () {
+ return this._frameIndex;
+ },
+ set: function (value) {
+ if(this._frameData.getFrame(value) !== null) {
+ this.currentFrame = this._frameData.getFrame(value);
+ this._parent.bounds.width = this.currentFrame.width;
+ this._parent.bounds.height = this.currentFrame.height;
+ this._frameIndex = value;
+ }
+ },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(AnimationManager.prototype, "frameName", {
+ get: function () {
+ return this.currentFrame.name;
+ },
+ set: function (value) {
+ if(this._frameData.getFrameByName(value) !== null) {
+ this.currentFrame = this._frameData.getFrameByName(value);
+ this._parent.bounds.width = this.currentFrame.width;
+ this._parent.bounds.height = this.currentFrame.height;
+ this._frameIndex = this.currentFrame.index;
+ }
+ },
+ enumerable: true,
+ configurable: true
+ });
+ return AnimationManager;
+ })();
+ Phaser.AnimationManager = AnimationManager;
})(Phaser || (Phaser = {}));
-///