-1){b.context.globalAlpha=this._ga}if(this.game.renderType==Phaser.WEBGL){PIXI.texturesToUpdate.push(b.baseTexture)}}return true}};
\ No newline at end of file
diff --git a/build/phaser.js b/build/phaser.js
index 7a6edd3d..e48b3599 100644
--- a/build/phaser.js
+++ b/build/phaser.js
@@ -1,7 +1,7 @@
/**
* Phaser - http://www.phaser.io
*
-* v1.0.0 - Built at: Thu, 12 Sep 2013 19:55:57 +0000
+* v1.0.0 - Built at: Fri, 13 Sep 2013 03:04:56 +0000
*
* @author Richard Davey http://www.photonstorm.com @photonstorm
*
@@ -38,7 +38,20 @@ var Phaser = Phaser || {
GAMES: [],
AUTO: 0,
CANVAS: 1,
- WEBGL: 2
+ WEBGL: 2,
+
+ SPRITE: 0,
+ BUTTON: 1,
+ BULLET: 2,
+ GRAPHICS: 3,
+ TEXT: 4,
+ TILESPRITE: 5,
+ BITMAPTEXT: 6,
+ GROUP: 7,
+ RENDERTEXTURE: 8,
+ TILEMAP: 9,
+ TILEMAPLAYER: 10,
+ EMITTER: 11
};
@@ -8850,6 +8863,8 @@ Phaser.Group = function (game, parent, name, useStage) {
}
}
+ this.type = Phaser.GROUP;
+
this.exists = true;
/**
@@ -13813,6 +13828,8 @@ Phaser.Sprite = function (game, x, y, key, frame) {
this.name = '';
+ this.type = Phaser.SPRITE;
+
this.renderOrderID = -1;
// If you would like the Sprite to have a lifespan once 'born' you can set this to a positive value. Handy for particles, bullets, etc.
@@ -13961,6 +13978,9 @@ Phaser.Sprite = function (game, x, y, key, frame) {
// Set-up the physics body
this.body = new Phaser.Physics.Arcade.Body(this);
+ this.velocity = this.body.velocity;
+ this.acceleration = this.body.acceleration;
+
// World bounds check
this.inWorld = Phaser.Rectangle.intersects(this.bounds, this.game.world.bounds);
this.inWorldThreshold = 0;
@@ -14384,6 +14404,8 @@ Phaser.TileSprite = function (game, x, y, width, height, key, frame) {
PIXI.TilingSprite.call(this, this.texture, width, height);
+ this.type = Phaser.TILESPRITE;
+
/**
* The scaling of the image that is being tiled
*
@@ -14423,6 +14445,8 @@ Phaser.Text = function (game, x, y, text, style) {
Phaser.Sprite.call(this, game, x, y, canvasID);
+ this.type = Phaser.TEXT;
+
this.setText(text);
this.setStyle(style);
@@ -14459,6 +14483,8 @@ Phaser.Button = function (game, x, y, key, callback, callbackContext, overFrame,
Phaser.Sprite.call(this, game, x, y, key, outFrame);
+ this.type = Phaser.BUTTON;
+
this._onOverFrameName = null;
this._onOutFrameName = null;
this._onDownFrameName = null;
@@ -14622,6 +14648,8 @@ Phaser.Graphics = function (game, x, y) {
PIXI.DisplayObjectContainer.call(this);
+ this.type = Phaser.GRAPHICS;
+
this.position.x = x;
this.position.y = y;
@@ -14776,6 +14804,8 @@ Phaser.RenderTexture = function (game, key, width, height) {
this.frame = new PIXI.Rectangle(0, 0, this.width, this.height);
+ this.type = Phaser.RENDERTEXTURE;
+
if (PIXI.gl)
{
this.initWebGL();
@@ -24795,16 +24825,19 @@ Phaser.Physics.Arcade = function (game) {
this.quadTree = new Phaser.QuadTree(this, this.game.world.bounds.x, this.game.world.bounds.y, this.game.world.bounds.width, this.game.world.bounds.height, this.maxObjects, this.maxLevels);
this.quadTreeID = 0;
- // avoid gc spikes by caching these values for re-use
- this._obj1Bounds = new Phaser.Rectangle;
- this._obj2Bounds = new Phaser.Rectangle;
+ // Avoid gc spikes by caching these values for re-use
+ this._bounds1 = new Phaser.Rectangle;
+ this._bounds2 = new Phaser.Rectangle;
this._overlap = 0;
this._maxOverlap = 0;
- this._obj1Velocity = 0;
- this._obj2Velocity = 0;
- this._obj1NewVelocity = 0;
- this._obj2NewVelocity = 0;
+ this._velocity1 = 0;
+ this._velocity2 = 0;
+ this._newVelocity1 = 0;
+ this._newVelocity2 = 0;
this._average = 0;
+ this._mapData = [];
+ this._result = false;
+ this._total = 0;
};
@@ -24910,27 +24943,197 @@ Phaser.Physics.Arcade.prototype = {
},
- // Collides the given object with everything in the world quadtree
- collide: function (object, notifyCallback, callbackContext) {
+ /**
+ * Checks for collision between two game objects. The objects can be Sprites, Groups or Tilemaps.
+ * You can perform Sprite vs. Sprite, Sprite vs. Group, Group vs. Group, Sprite vs. Tilemap or Group vs. Tilemap collisions.
+ *
+ * @param object1 The first object to check. Can be an instance of Phaser.Sprite, Phaser.Group or Phaser.Tilemap
+ * @param object2 The second object to check. Can be an instance of Phaser.Sprite, Phaser.Group or Phaser.Tilemap
+ * @param collideCallback An optional callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you passed them to Collision.overlap.
+ * @param processCallback A callback function that lets you perform additional checks against the two objects if they overlap. If this is set then collideCallback will only be called if processCallback returns true.
+ * @param callbackContext The context in which to run the callbacks.
+ * @returns {boolean} true if any collisions were detected, otherwise false.
+ **/
+ collide: function (object1, object2, collideCallback, processCallback, callbackContext) {
- return this.overlap(object, null, notifyCallback, this.separate, callbackContext);
+ collideCallback = collideCallback || null;
+ processCallback = processCallback || null;
+ callbackContext = callbackContext || collideCallback;
+
+ this._result = false;
+ this._total = 0;
+
+ // Only collide valid objects
+ if (object1 && object2 && object1.exists && object2.exists)
+ {
+ // Can expand to support Buttons, Text, etc at a later date. For now these are the essentials.
+
+ // SPRITE vs. SPRITE
+ if (object1.type == Phaser.SPRITE && object2.type == Phaser.SPRITE)
+ {
+ this.collideSpriteVsSprite(object1, object2, collideCallback, processCallback, callbackContext);
+ }
+ // SPRITE vs. GROUP
+ else if (object1.type == Phaser.SPRITE && object2.type == Phaser.GROUP)
+ {
+ this.collideSpriteVsGroup(object1, object2, collideCallback, processCallback, callbackContext);
+ }
+ // GROUP vs. SPRITE
+ else if (object1.type == Phaser.GROUP && object2.type == Phaser.SPRITE)
+ {
+ this.collideSpriteVsGroup(object2, object1, collideCallback, processCallback, callbackContext);
+ }
+ // GROUP vs. GROUP
+ else if (object1.type == Phaser.GROUP && object2.type == Phaser.GROUP)
+ {
+ this.collideGroupVsGroup(object1, object2, collideCallback, processCallback, callbackContext);
+ }
+ // SPRITE vs. TILEMAP
+ else if (object1.type == Phaser.SPRITE && object2.type == Phaser.TILEMAP)
+ {
+ this.collideSpriteVsTilemap(object1, object2, collideCallback, processCallback, callbackContext);
+ }
+ // TILEMAP vs. SPRITE
+ else if (object1.type == Phaser.TILEMAP && object2.type == Phaser.SPRITE)
+ {
+ this.collideSpriteVsTilemap(object2, object1, collideCallback, processCallback, callbackContext);
+ }
+ // GROUP vs. TILEMAP
+ else if (object1.type == Phaser.GROUP && object2.type == Phaser.TILEMAP)
+ {
+ this.collideGroupVsTilemap(object1, object2, collideCallback, processCallback, callbackContext);
+ }
+ // TILEMAP vs. GROUP
+ else if (object1.type == Phaser.TILEMAP && object2.type == Phaser.GROUP)
+ {
+ this.collideGroupVsTilemap(object2, object1, collideCallback, processCallback, callbackContext);
+ }
+ // EMITTER vs. TILEMAP
+ else if (object1.type == Phaser.EMITTER && object2.type == Phaser.TILEMAP)
+ {
+ this.collideGroupVsTilemap(object1, object2, collideCallback, processCallback, callbackContext);
+ }
+ // TILEMAP vs. EMITTER
+ else if (object1.type == Phaser.TILEMAP && object2.type == Phaser.EMITTER)
+ {
+ this.collideGroupVsTilemap(object2, object1, collideCallback, processCallback, callbackContext);
+ }
+ }
+
+ return (this._total > 0);
},
- collideGroup: function (group, notifyCallback, callbackContext) {
+ collideSpriteVsSprite: function (sprite1, sprite2, collideCallback, processCallback, callbackContext) {
- notifyCallback = notifyCallback || null;
- callbackContext = callbackContext || notifyCallback;
+ this.separate(sprite1.body, sprite2.body);
- for (var g = 0, len = group.length; g < len; g++)
+ if (this._result)
{
- for (var i = 0, gi = group.length; i < gi; i++)
+ // They collided, is there a custom process callback?
+ if (processCallback)
{
- if (this.separate(group[g].body, group[i].body))
+ if (processCallback.call(callbackContext, sprite1, sprite2))
{
- if (notifyCallback)
+ this._total++;
+
+ if (collideCallback)
{
- notifyCallback.call(callbackContext, group[g], group[i].sprite);
+ collideCallback.call(callbackContext, sprite1, sprite2);
+ }
+ }
+ }
+ else
+ {
+ this._total++;
+
+ if (collideCallback)
+ {
+ collideCallback.call(callbackContext, sprite1, sprite2);
+ }
+ }
+ }
+
+ },
+
+ collideGroupVsTilemap: function (group, tilemap, collideCallback, processCallback, callbackContext) {
+
+ if (group._container.first._iNext)
+ {
+ var currentNode = group._container.first._iNext;
+
+ do
+ {
+ if (currentNode.exists)
+ {
+ this.collideSpriteVsTilemap(currentNode, tilemap, collideCallback, processCallback, callbackContext);
+ }
+ currentNode = currentNode._iNext;
+ }
+ while (currentNode != group._container.last._iNext);
+ }
+
+ },
+
+ collideSpriteVsTilemap: function (sprite, tilemap, collideCallback, processCallback, callbackContext) {
+
+ this._mapData = tilemap.collisionLayer.getTileOverlaps(sprite);
+
+ // If the sprite actually collided with the tilemap then _mapData contains an array of the tiles it collided with
+ var i = this._mapData.length;
+
+ while (i--)
+ {
+ if (processCallback)
+ {
+ // We've got a custom process callback to hit first
+ if (processCallback.call(callbackContext, sprite, this._mapData[i].tile))
+ {
+ this._total++;
+
+ if (collideCallback)
+ {
+ collideCallback.call(callbackContext, sprite, this._mapData[i].tile);
+ }
+ }
+ }
+ else
+ {
+ this._total++;
+
+ if (collideCallback)
+ {
+ collideCallback.call(callbackContext, sprite, this._mapData[i].tile);
+ }
+ }
+ }
+
+ },
+
+ collideSpriteVsGroup: function (sprite, group, collideCallback, processCallback, callbackContext) {
+
+ // What is the sprite colliding with in the quadtree?
+ this._potentials = this.quadTree.retrieve(sprite);
+
+ for (var i = 0, len = this._potentials.length; i < len; i++)
+ {
+ // We have our potential suspects, are they in this group?
+ if (this._potentials[i].sprite.group == group)
+ {
+ this.separate(sprite.body, this._potentials[i]);
+
+ if (this._result && processCallback)
+ {
+ this._result = processCallback.call(callbackContext, sprite, this._potentials[i].sprite);
+ }
+
+ if (this._result)
+ {
+ this._total++;
+
+ if (collideCallback)
+ {
+ collideCallback.call(callbackContext, sprite, this._potentials[i].sprite);
}
}
}
@@ -24938,111 +25141,98 @@ Phaser.Physics.Arcade.prototype = {
},
- /**
- * Checks for overlaps between two objects using the world QuadTree. Can be GameObject vs. GameObject, GameObject vs. Group or Group vs. Group.
- * Note: Does not take the objects scrollFactor into account. All overlaps are check in world space.
- * @param object1 The first GameObject or Group to check. If null the world.group is used.
- * @param object2 The second GameObject or Group to check.
- * @param notifyCallback A callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you passed them to Collision.overlap.
- * @param processCallback A callback function that lets you perform additional checks against the two objects if they overlap. If this is set then notifyCallback will only be called if processCallback returns true.
- * @returns {boolean} true if the objects overlap, otherwise false.
- */
- overlap: function (object1, object2, notifyCallback, processCallback, callbackContext) {
+ collideGroupVsGroup: function (group1, group2, collideCallback, processCallback, callbackContext) {
- object2 = object2 || null;
- notifyCallback = notifyCallback || null;
- processCallback = processCallback || this.separate;
- callbackContext = callbackContext || this;
-
- // Get the ships top-most ID. If the length of that ID is 1 then we can ignore every other result,
- // it's simply not colliding with anything :)
- var potentials = this.quadTree.retrieve(object1);
- var output = [];
-
- for (var i = 0, len = potentials.length; i < len; i++)
+ if (group1._container.first._iNext)
{
- if (processCallback.call(callbackContext, object1.body, potentials[i]))
+ var currentNode = group1._container.first._iNext;
+
+ do
{
- if (notifyCallback)
+ if (currentNode.exists)
{
- notifyCallback.call(callbackContext, object1, potentials[i].sprite);
+ this.collideSpriteVsGroup(currentNode, group2, collideCallback, processCallback, callbackContext);
}
-
- output.push(potentials[i]);
+ currentNode = currentNode._iNext;
}
+ while (currentNode != group1._container.last._iNext);
}
- return (output.length);
-
},
/**
- * 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.
+ * The core separation function to separate two physics bodies.
+ * @param body1 The first Sprite.Body to separate
+ * @param body2 The second Sprite.Body to separate
+ * @returns {boolean} Returns true if the bodies were separated, otherwise false.
*/
- separate: function (object1, object2) {
+ separate: function (body1, body2) {
- return this.separateX(object1, object2) || this.separateY(object1, object2)
+ this._result = (this.separateX(body1, body2) || this.separateY(body1, body2));
+
+ if (this._result)
+ {
+ body1.postUpdate();
+ body2.postUpdate();
+ }
},
/**
- * Separates the two objects on their x axis
- * @param object1 The first GameObject to separate
- * @param object2 The second GameObject to separate
+ * Separates the two physics bodies on their X axis
+ * @param body1 The first Sprite.Body to separate
+ * @param body2 The second Sprite.Body to separate
* @returns {boolean} Whether the objects in fact touched and were separated along the X axis.
*/
- separateX: function (object1, object2) {
+ separateX: function (body1, body2) {
- // Can't separate two immovable objects
- if (object1.immovable && object2.immovable)
+ // Can't separate two immovable or non-existing bodys
+ if (body1.immovable && body2.immovable)
{
return false;
}
- // First, get the two object deltas
+ // First, get the two body deltas
this._overlap = 0;
- if (object1.deltaX() != object2.deltaX())
+ if (body1.deltaX() != body2.deltaX())
{
// Check if the X hulls actually overlap
- this._obj1Bounds.setTo(object1.x - ((object1.deltaX() > 0) ? object1.deltaX() : 0), object1.lastY, object1.width + ((object1.deltaX() > 0) ? object1.deltaX() : -object1.deltaX()), object1.height);
- this._obj2Bounds.setTo(object2.x - ((object2.deltaX() > 0) ? object2.deltaX() : 0), object2.lastY, object2.width + ((object2.deltaX() > 0) ? object2.deltaX() : -object2.deltaX()), object2.height);
+ this._bounds1.setTo(body1.x - ((body1.deltaX() > 0) ? body1.deltaX() : 0), body1.lastY, body1.width + ((body1.deltaX() > 0) ? body1.deltaX() : -body1.deltaX()), body1.height);
+ this._bounds2.setTo(body2.x - ((body2.deltaX() > 0) ? body2.deltaX() : 0), body2.lastY, body2.width + ((body2.deltaX() > 0) ? body2.deltaX() : -body2.deltaX()), body2.height);
- if ((this._obj1Bounds.right > this._obj2Bounds.x) && (this._obj1Bounds.x < this._obj2Bounds.right) && (this._obj1Bounds.bottom > this._obj2Bounds.y) && (this._obj1Bounds.y < this._obj2Bounds.bottom))
+ if ((this._bounds1.right > this._bounds2.x) && (this._bounds1.x < this._bounds2.right) && (this._bounds1.bottom > this._bounds2.y) && (this._bounds1.y < this._bounds2.bottom))
{
- this._maxOverlap = object1.deltaAbsX() + object2.deltaAbsX() + this.OVERLAP_BIAS;
+ this._maxOverlap = body1.deltaAbsX() + body2.deltaAbsX() + this.OVERLAP_BIAS;
// If they did overlap (and can), figure out by how much and flip the corresponding flags
- if (object1.deltaX() > object2.deltaX())
+ if (body1.deltaX() > body2.deltaX())
{
- this._overlap = object1.x + object1.width - object2.x;
+ this._overlap = body1.x + body1.width - body2.x;
- if ((this._overlap > this._maxOverlap) || object1.allowCollision.right == false || object2.allowCollision.left == false)
+ if ((this._overlap > this._maxOverlap) || body1.allowCollision.right == false || body2.allowCollision.left == false)
{
this._overlap = 0;
}
else
{
- object1.touching.right = true;
- object2.touching.left = true;
+ body1.touching.right = true;
+ body2.touching.left = true;
}
}
- else if (object1.deltaX() < object2.deltaX())
+ else if (body1.deltaX() < body2.deltaX())
{
- this._overlap = object1.x - object2.width - object2.x;
+ this._overlap = body1.x - body2.width - body2.x;
- if ((-this._overlap > this._maxOverlap) || object1.allowCollision.left == false || object2.allowCollision.right == false)
+ if ((-this._overlap > this._maxOverlap) || body1.allowCollision.left == false || body2.allowCollision.right == false)
{
this._overlap = 0;
}
else
{
- object1.touching.left = true;
- object2.touching.right = true;
+ body1.touching.left = true;
+ body2.touching.right = true;
}
}
}
@@ -25051,33 +25241,44 @@ Phaser.Physics.Arcade.prototype = {
// Then adjust their positions and velocities accordingly (if there was any overlap)
if (this._overlap != 0)
{
- this._obj1Velocity = object1.velocity.x;
- this._obj2Velocity = object2.velocity.x;
+ body1.overlapX = this._overlap;
+ body2.overlapX = this._overlap;
- if (!object1.immovable && !object2.immovable)
+ if (body1.customSeparateX || body2.customSeparateX)
+ {
+ return true;
+ }
+
+ this._velocity1 = body1.velocity.x;
+ this._velocity2 = body2.velocity.x;
+
+ if (!body1.immovable && !body2.immovable)
{
this._overlap *= 0.5;
- object1.x = object1.x - this._overlap;
- object2.x += this._overlap;
- this._obj1NewVelocity = Math.sqrt((this._obj2Velocity * this._obj2Velocity * object2.mass) / object1.mass) * ((this._obj2Velocity > 0) ? 1 : -1);
- this._obj2NewVelocity = Math.sqrt((this._obj1Velocity * this._obj1Velocity * object1.mass) / object2.mass) * ((this._obj1Velocity > 0) ? 1 : -1);
- this._average = (this._obj1NewVelocity + this._obj2NewVelocity) * 0.5;
- this._obj1NewVelocity -= this._average;
- this._obj2NewVelocity -= this._average;
- object1.velocity.x = this._average + this._obj1NewVelocity * object1.bounce.x;
- object2.velocity.x = this._average + this._obj2NewVelocity * object2.bounce.x;
+ body1.x = body1.x - this._overlap;
+ body2.x += this._overlap;
+
+ this._newVelocity1 = Math.sqrt((this._velocity2 * this._velocity2 * body2.mass) / body1.mass) * ((this._velocity2 > 0) ? 1 : -1);
+ this._newVelocity2 = Math.sqrt((this._velocity1 * this._velocity1 * body1.mass) / body2.mass) * ((this._velocity1 > 0) ? 1 : -1);
+ this._average = (this._newVelocity1 + this._newVelocity2) * 0.5;
+ this._newVelocity1 -= this._average;
+ this._newVelocity2 -= this._average;
+
+ body1.velocity.x = this._average + this._newVelocity1 * body1.bounce.x;
+ body2.velocity.x = this._average + this._newVelocity2 * body2.bounce.x;
}
- else if (!object1.immovable)
+ else if (!body1.immovable)
{
- object1.x = object1.x - this._overlap;
- object1.velocity.x = this._obj2Velocity - this._obj1Velocity * object1.bounce.x;
+ body1.x = body1.x - this._overlap;
+ body1.velocity.x = this._velocity2 - this._velocity1 * body1.bounce.x;
}
- else if (!object2.immovable)
+ else if (!body2.immovable)
{
- object2.x += this._overlap;
- object2.velocity.x = this._obj1Velocity - this._obj2Velocity * object2.bounce.x;
+ body2.x += this._overlap;
+ body2.velocity.x = this._velocity1 - this._velocity2 * body2.bounce.x;
}
+
return true;
}
else
@@ -25088,59 +25289,59 @@ Phaser.Physics.Arcade.prototype = {
},
/**
- * 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.
+ * Separates the two physics bodies on their Y axis
+ * @param body1 The first Sprite.Body to separate
+ * @param body2 The second Sprite.Body to separate
+ * @returns {boolean} Whether the bodys in fact touched and were separated along the Y axis.
*/
- separateY: function (object1, object2) {
+ separateY: function (body1, body2) {
- // Can't separate two immovable objects
- if (object1.immovable && object2.immovable)
+ // Can't separate two immovable or non-existing bodys
+ if (body1.immovable && body2.immovable)
{
return false;
}
- // First, get the two object deltas
+ // First, get the two body deltas
this._overlap = 0;
- if (object1.deltaY() != object2.deltaY())
+ if (body1.deltaY() != body2.deltaY())
{
// Check if the Y hulls actually overlap
- this._obj1Bounds.setTo(object1.x, object1.y - ((object1.deltaY() > 0) ? object1.deltaY() : 0), object1.width, object1.height + object1.deltaAbsY());
- this._obj2Bounds.setTo(object2.x, object2.y - ((object2.deltaY() > 0) ? object2.deltaY() : 0), object2.width, object2.height + object2.deltaAbsY());
+ this._bounds1.setTo(body1.x, body1.y - ((body1.deltaY() > 0) ? body1.deltaY() : 0), body1.width, body1.height + body1.deltaAbsY());
+ this._bounds2.setTo(body2.x, body2.y - ((body2.deltaY() > 0) ? body2.deltaY() : 0), body2.width, body2.height + body2.deltaAbsY());
- if ((this._obj1Bounds.right > this._obj2Bounds.x) && (this._obj1Bounds.x < this._obj2Bounds.right) && (this._obj1Bounds.bottom > this._obj2Bounds.y) && (this._obj1Bounds.y < this._obj2Bounds.bottom))
+ if ((this._bounds1.right > this._bounds2.x) && (this._bounds1.x < this._bounds2.right) && (this._bounds1.bottom > this._bounds2.y) && (this._bounds1.y < this._bounds2.bottom))
{
- this._maxOverlap = object1.deltaAbsY() + object2.deltaAbsY() + this.OVERLAP_BIAS;
+ this._maxOverlap = body1.deltaAbsY() + body2.deltaAbsY() + this.OVERLAP_BIAS;
// If they did overlap (and can), figure out by how much and flip the corresponding flags
- if (object1.deltaY() > object2.deltaY())
+ if (body1.deltaY() > body2.deltaY())
{
- this._overlap = object1.y + object1.height - object2.y;
+ this._overlap = body1.y + body1.height - body2.y;
- if ((this._overlap > this._maxOverlap) || object1.allowCollision.down == false || object2.allowCollision.up == false)
+ if ((this._overlap > this._maxOverlap) || body1.allowCollision.down == false || body2.allowCollision.up == false)
{
this._overlap = 0;
}
else
{
- object1.touching.down = true;
- object2.touching.up = true;
+ body1.touching.down = true;
+ body2.touching.up = true;
}
}
- else if (object1.deltaY() < object2.deltaY())
+ else if (body1.deltaY() < body2.deltaY())
{
- this._overlap = object1.y - object2.height - object2.y;
+ this._overlap = body1.y - body2.height - body2.y;
- if ((-this._overlap > this._maxOverlap) || object1.allowCollision.up == false || object2.allowCollision.down == false)
+ if ((-this._overlap > this._maxOverlap) || body1.allowCollision.up == false || body2.allowCollision.down == false)
{
this._overlap = 0;
}
else
{
- object1.touching.up = true;
- object2.touching.down = true;
+ body1.touching.up = true;
+ body2.touching.down = true;
}
}
}
@@ -25149,43 +25350,56 @@ Phaser.Physics.Arcade.prototype = {
// Then adjust their positions and velocities accordingly (if there was any overlap)
if (this._overlap != 0)
{
- this._obj1Velocity = object1.velocity.y;
- this._obj2Velocity = object2.velocity.y;
+ body1.overlapY = this._overlap;
+ body2.overlapY = this._overlap;
- if (!object1.immovable && !object2.immovable)
+ if (body1.customSeparateY || body2.customSeparateY)
+ {
+ return true;
+ }
+
+ this._velocity1 = body1.velocity.y;
+ this._velocity2 = body2.velocity.y;
+
+ if (!body1.immovable && !body2.immovable)
{
this._overlap *= 0.5;
- object1.y = object1.y - this._overlap;
- object2.y += this._overlap;
- this._obj1NewVelocity = Math.sqrt((this._obj2Velocity * this._obj2Velocity * object2.mass) / object1.mass) * ((this._obj2Velocity > 0) ? 1 : -1);
- this._obj2NewVelocity = Math.sqrt((this._obj1Velocity * this._obj1Velocity * object1.mass) / object2.mass) * ((this._obj1Velocity > 0) ? 1 : -1);
- this._average = (this._obj1NewVelocity + this._obj2NewVelocity) * 0.5;
- this._obj1NewVelocity -= this._average;
- this._obj2NewVelocity -= this._average;
- object1.velocity.y = this._average + this._obj1NewVelocity * object1.bounce.y;
- object2.velocity.y = this._average + this._obj2NewVelocity * object2.bounce.y;
+ body1.y = body1.y - this._overlap;
+ body2.y += this._overlap;
+
+ this._newVelocity1 = Math.sqrt((this._velocity2 * this._velocity2 * body2.mass) / body1.mass) * ((this._velocity2 > 0) ? 1 : -1);
+ this._newVelocity2 = Math.sqrt((this._velocity1 * this._velocity1 * body1.mass) / body2.mass) * ((this._velocity1 > 0) ? 1 : -1);
+ this._average = (this._newVelocity1 + this._newVelocity2) * 0.5;
+ this._newVelocity1 -= this._average;
+ this._newVelocity2 -= this._average;
+
+ body1.velocity.y = this._average + this._newVelocity1 * body1.bounce.y;
+ body2.velocity.y = this._average + this._newVelocity2 * body2.bounce.y;
}
- else if (!object1.immovable)
+ else if (!body1.immovable)
{
- object1.y = object1.y - this._overlap;
- object1.velocity.y = this._obj2Velocity - this._obj1Velocity * object1.bounce.y;
+ body1.y = body1.y - this._overlap;
+ body1.velocity.y = this._velocity2 - this._velocity1 * body1.bounce.y;
+
// This is special case code that handles things like horizontal moving platforms you can ride
- if (object2.active && object2.moves && (object1.deltaY() > object2.deltaY()))
+ if (body2.active && body2.moves && (body1.deltaY() > body2.deltaY()))
{
- object1.x += object2.x - object2.lastX;
+ body1.x += body2.x - body2.lastX;
}
}
- else if (!object2.immovable)
+ else if (!body2.immovable)
{
- object2.y += this._overlap;
- object2.velocity.y = this._obj1Velocity - this._obj2Velocity * object2.bounce.y;
+ body2.y += this._overlap;
+ body2.velocity.y = this._velocity1 - this._velocity2 * body2.bounce.y;
+
// This is special case code that handles things like horizontal moving platforms you can ride
- if (object1.sprite.active && object1.moves && (object1.deltaY() < object2.deltaY()))
+ if (body1.sprite.active && body1.moves && (body1.deltaY() < body2.deltaY()))
{
- object2.x += object1.x - object1.lastX;
+ body2.x += body1.x - body1.lastX;
}
}
+
return true;
}
else
@@ -25237,9 +25451,9 @@ Phaser.Physics.Arcade.prototype = {
if (object.deltaX() != 0)
{
- this._obj1Bounds.setTo(object.x, object.y, object.width, object.height);
+ this._bounds1.setTo(object.x, object.y, object.width, object.height);
- if ((this._obj1Bounds.right > x) && (this._obj1Bounds.x < x + width) && (this._obj1Bounds.bottom > y) && (this._obj1Bounds.y < y + height))
+ if ((this._bounds1.right > x) && (this._bounds1.x < x + width) && (this._bounds1.bottom > y) && (this._bounds1.y < y + height))
{
// The hulls overlap, let's process it
this._maxOverlap = object.deltaAbsX() + this.OVERLAP_BIAS;
@@ -25324,9 +25538,9 @@ Phaser.Physics.Arcade.prototype = {
if (object.deltaY() != 0)
{
- this._obj1Bounds.setTo(object.x, object.y, object.width, object.height);
+ this._bounds1.setTo(object.x, object.y, object.width, object.height);
- if ((this._obj1Bounds.right > x) && (this._obj1Bounds.x < x + width) && (this._obj1Bounds.bottom > y) && (this._obj1Bounds.y < y + height))
+ if ((this._bounds1.right > x) && (this._bounds1.x < x + width) && (this._bounds1.bottom > y) && (this._bounds1.y < y + height))
{
// The hulls overlap, let's process it
@@ -25808,6 +26022,17 @@ Phaser.Physics.Arcade.Body = function (sprite) {
this.allowRotation = true;
this.allowGravity = true;
+ // These two flags allow you to disable the custom separation that takes place
+ // Used in combination with your own collision processHandler you can create whatever
+ // type of collision response you need.
+ this.customSeparateX = false;
+ this.customSeparateY = false;
+
+ // When this body collides with another the amount of overlap is stored in here
+ // These values are useful if you want to provide your own custom separation logic.
+ this.overlapX = 0;
+ this.overlapY = 0;
+
this.collideWorldBounds = false;
this.lastX = sprite.x;
@@ -25893,23 +26118,6 @@ Phaser.Physics.Arcade.Body.prototype = {
},
- /*
- postUpdate: function () {
-
- // this.sprite.x = this.x - this.offset.x + (this.sprite.anchor.x * this.width);
- // this.sprite.y = this.y - this.offset.y + (this.sprite.anchor.y * this.height);
-
- this.sprite.x = (this.x - this.offset.x + (this.sprite.anchor.x * this.width)) - (this.game.world.camera.x * this.sprite.scrollFactor.x);
- this.sprite.y = (this.y - this.offset.y + (this.sprite.anchor.y * this.height)) - (this.game.world.camera.y * this.sprite.scrollFactor.y);
-
- if (this.allowRotation)
- {
- this.sprite.angle = this.rotation;
- }
-
- },
- */
-
checkWorldBounds: function () {
if (this.x < this.game.world.bounds.x)
@@ -25953,18 +26161,16 @@ Phaser.Physics.Arcade.Body.prototype = {
reset: function () {
- this.velocity = new Phaser.Point;
- this.acceleration = new Phaser.Point;
- this.drag = new Phaser.Point;
- this.gravity = new Phaser.Point;
- this.bounce = new Phaser.Point;
- this.maxVelocity = new Phaser.Point(10000, 10000);
+ this.velocity.setTo(0, 0);
+ this.acceleration.setTo(0, 0);
this.angularVelocity = 0;
this.angularAcceleration = 0;
- this.angularDrag = 0;
- this.maxAngular = 1000;
- this.mass = 1;
+
+ this.x = (this.sprite.x - (this.sprite.anchor.x * this.width)) + this.offset.x;
+ this.y = (this.sprite.y - (this.sprite.anchor.y * this.height)) + this.offset.y;
+ this.lastX = this.x;
+ this.lastY = this.y;
},
@@ -26106,6 +26312,8 @@ Phaser.Particles.Arcade.Emitter = function (game, x, y, maxParticles) {
this.name = 'emitter' + this.game.particles.ID++;
+ this.type = Phaser.EMITTER;
+
/**
* The X position of the top left corner of the emitter in world space.
*/
@@ -26428,7 +26636,7 @@ Phaser.Particles.Arcade.Emitter.prototype.emitParticle = function () {
if (this.width > 1 || this.height > 1)
{
- particle.reset(this.x - this.game.rnd.integerInRange(this.left, this.right), this.y - this.game.rnd.integerInRange(this.top, this.bottom));
+ particle.reset(this.emiteX - this.game.rnd.integerInRange(this.left, this.right), this.emiteY - this.game.rnd.integerInRange(this.top, this.bottom));
}
else
{
@@ -26697,6 +26905,8 @@ Phaser.Tilemap = function (game, key, x, y, resizeWorld, tileWidth, tileHeight)
this.position.x = x;
this.position.y = y;
+ this.type = Phaser.TILEMAP;
+
this.renderer = new Phaser.TilemapRenderer(this.game);
this.mapFormat = map.format;
@@ -27145,6 +27355,7 @@ Phaser.TilemapLayer = function (parent, id, key, mapFormat, name, tileWidth, til
this.ID = id;
this.name = name;
this.key = key;
+ this.type = Phaser.TILEMAPLAYER;
this.mapFormat = mapFormat;
this.tileWidth = tileWidth;
diff --git a/examples/mariocombo/ohballs.php b/examples/mariocombo/ohballs.php
new file mode 100644
index 00000000..72da5b30
--- /dev/null
+++ b/examples/mariocombo/ohballs.php
@@ -0,0 +1,69 @@
+
+
+
+ phaser.js - oh balls
+
+
+
+
+
+
+
+
+
+Mouse to move
+Created with Phaser 1.0 by @photonstorm
+
+
+
\ No newline at end of file
diff --git a/examples/particles.php b/examples/particles.php
index e1402869..6e4efac1 100644
--- a/examples/particles.php
+++ b/examples/particles.php
@@ -19,12 +19,12 @@
function preload() {
- game.load.image('carrot', 'assets/sprites/carrot.png');
- game.load.image('star', 'assets/misc/star_particle.png');
- game.load.image('diamond', 'assets/sprites/diamond.png');
- game.load.image('dude', 'assets/sprites/phaser-dude.png');
- game.load.image('coke', 'assets/sprites/cokecan.png');
- game.load.atlasJSONHash('pixies', 'assets/sprites/pixi_monsters.png', 'assets/sprites/pixi_monsters.json');
+ // game.load.image('carrot', 'assets/sprites/carrot.png');
+ // game.load.image('star', 'assets/misc/star_particle.png');
+ // game.load.image('diamond', 'assets/sprites/diamond.png');
+ // game.load.image('dude', 'assets/sprites/phaser-dude.png');
+ // game.load.image('coke', 'assets/sprites/cokecan.png');
+ // game.load.atlasJSONHash('pixies', 'assets/sprites/pixi_monsters.png', 'assets/sprites/pixi_monsters.json');
game.load.spritesheet('balls', 'assets/sprites/balls.png', 17, 17);
}
@@ -33,18 +33,18 @@
game.stage.backgroundColor = 0x337799;
- p = game.add.emitter(200, 100, 250);
+ p = game.add.emitter(100, 100, 250);
// p.width = 200;
// p.height = 200;
// keys, frames, quantity, collide
// p.makeParticles(['diamond', 'carrot', 'star']);
- // p.makeParticles('balls', [0,1,2,3,4,5]);
- p.makeParticles('pixies', [0,1,2,3]);
+ p.makeParticles('balls', [0,1,2,3,4,5]);
+ // p.makeParticles('pixies', [0,1,2,3]);
- p.minParticleScale = 0.1;
- p.maxParticleScale = 0.5;
+ // p.minParticleScale = 0.1;
+ // p.maxParticleScale = 0.5;
// Steady constant stream at 250ms delay and 10 seconds lifespan
// p.start(false, 10000, 250, 100);
@@ -56,11 +56,14 @@
p.gravity = 10;
p.start(false, 3000, 10);
- game.add.tween(p).to({ emitX: 400 }, 1000, Phaser.Easing.Quadratic.InOut, true, 0, 1000, true);
+ game.add.tween(p).to({ x: 700 }, 1000, Phaser.Easing.Quadratic.InOut, true, 0, 1000, true);
}
function update() {
+
+ p.y = game.math.min(100, game.input.y);
+
}
function render() {
diff --git a/examples/supermario2.php b/examples/supermario2.php
index 42426f9b..e50d9701 100644
--- a/examples/supermario2.php
+++ b/examples/supermario2.php
@@ -12,7 +12,7 @@
(function () {
- var game = new Phaser.Game(800, 600, Phaser.AUTO, '', { preload: preload, create: create, update: update, render: render });
+ var game = new Phaser.Game(800, 600, Phaser.AUTO, '', { preload: preload, create: create, update: update });
function preload() {
@@ -22,10 +22,8 @@
}
- var p;
+ var balls;
var map;
- var test = [];
- var g;
function create() {
@@ -36,22 +34,21 @@
map = game.add.tilemap(0, 0, 'level1');
map.setCollisionByIndex([9,10,11,14,15,16,18,19,22,23,24,32,37,38], true, true, true, true);
- p = game.add.emitter(300, 50, 500);
- p.bounce = 0.5;
- p.makeParticles('balls', [0,1,2,3,4,5], 500, 1);
- p.minParticleSpeed.setTo(-150, 150);
- p.maxParticleSpeed.setTo(100, 100);
- p.gravity = 8;
- p.start(false, 5000, 50);
+ balls = game.add.emitter(300, 50, 500);
+ balls.bounce = 0.5;
+ balls.makeParticles('balls', [0,1,2,3,4,5], 500, 1);
+ balls.minParticleSpeed.setTo(-150, 150);
+ balls.maxParticleSpeed.setTo(100, 100);
+ balls.gravity = 8;
+ balls.start(false, 5000, 50);
- game.add.tween(p).to({ x: 4000 }, 7500, Phaser.Easing.Quadratic.InOut, true, 0, 1000, true);
+ game.add.tween(balls).to({ x: 4000 }, 7500, Phaser.Easing.Sinusoidal.InOut, true, 0, 1000, true);
}
function update() {
- map.collide(g);
- map.collide(p);
+ game.physics.collide(balls, map);
if (game.input.keyboard.isDown(Phaser.Keyboard.LEFT))
{
@@ -73,9 +70,6 @@
}
- function render() {
- }
-
})();
diff --git a/src/physics/arcade/ArcadePhysics.js b/src/physics/arcade/ArcadePhysics.js
index 9b737e96..3e7b4909 100644
--- a/src/physics/arcade/ArcadePhysics.js
+++ b/src/physics/arcade/ArcadePhysics.js
@@ -144,11 +144,11 @@ Phaser.Physics.Arcade.prototype = {
},
/**
- * Checks for collision between two game objects. The objects can be Sprites, Groups or Tilemaps.
+ * Checks for collision between two game objects. The objects can be Sprites, Groups, Emitters or Tilemaps.
* You can perform Sprite vs. Sprite, Sprite vs. Group, Group vs. Group, Sprite vs. Tilemap or Group vs. Tilemap collisions.
*
- * @param object1 The first object to check. Can be an instance of Phaser.Sprite, Phaser.Group or Phaser.Tilemap
- * @param object2 The second object to check. Can be an instance of Phaser.Sprite, Phaser.Group or Phaser.Tilemap
+ * @param object1 The first object to check. Can be an instance of Phaser.Sprite, Phaser.Group, Phaser.Particles.Emitter, or Phaser.Tilemap
+ * @param object2 The second object to check. Can be an instance of Phaser.Sprite, Phaser.Group, Phaser.Particles.Emitter or Phaser.Tilemap
* @param collideCallback An optional callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you passed them to Collision.overlap.
* @param processCallback A callback function that lets you perform additional checks against the two objects if they overlap. If this is set then collideCallback will only be called if processCallback returns true.
* @param callbackContext The context in which to run the callbacks.
@@ -168,45 +168,65 @@ Phaser.Physics.Arcade.prototype = {
{
// Can expand to support Buttons, Text, etc at a later date. For now these are the essentials.
- // SPRITE vs. SPRITE
- if (object1.type == Phaser.SPRITE && object2.type == Phaser.SPRITE)
+ // SPRITES
+ if (object1.type == Phaser.SPRITE)
{
- this.collideSpriteVsSprite(object1, object2, collideCallback, processCallback, callbackContext);
+ if (object2.type == Phaser.SPRITE)
+ {
+ this.collideSpriteVsSprite(object1, object2, collideCallback, processCallback, callbackContext);
+ }
+ else if (object2.type == Phaser.GROUP || object2.type == Phaser.EMITTER)
+ {
+ this.collideSpriteVsGroup(object1, object2, collideCallback, processCallback, callbackContext);
+ }
+ else if (object2.type == Phaser.TILEMAP)
+ {
+ this.collideSpriteVsTilemap(object1, object2, collideCallback, processCallback, callbackContext);
+ }
}
- // SPRITE vs. GROUP
- else if (object1.type == Phaser.SPRITE && object2.type == Phaser.GROUP)
+ // GROUPS
+ else if (object1.type == Phaser.GROUP)
{
- this.collideSpriteVsGroup(object1, object2, collideCallback, processCallback, callbackContext);
+ if (object2.type == Phaser.SPRITE)
+ {
+ this.collideSpriteVsGroup(object2, object1, collideCallback, processCallback, callbackContext);
+ }
+ else if (object2.type == Phaser.GROUP || object2.type == Phaser.EMITTER)
+ {
+ this.collideGroupVsGroup(object1, object2, collideCallback, processCallback, callbackContext);
+ }
+ else if (object2.type == Phaser.TILEMAP)
+ {
+ this.collideGroupVsTilemap(object1, object2, collideCallback, processCallback, callbackContext);
+ }
}
- // GROUP vs. SPRITE
- else if (object1.type == Phaser.GROUP && object2.type == Phaser.SPRITE)
+ // TILEMAPS
+ else if (object1.type == Phaser.TILEMAP)
{
- this.collideSpriteVsGroup(object2, object1, collideCallback, processCallback, callbackContext);
+ if (object2.type == Phaser.SPRITE)
+ {
+ this.collideSpriteVsTilemap(object2, object1, collideCallback, processCallback, callbackContext);
+ }
+ else if (object2.type == Phaser.GROUP || object2.type == Phaser.EMITTER)
+ {
+ this.collideGroupVsTilemap(object2, object1, collideCallback, processCallback, callbackContext);
+ }
}
- // GROUP vs. GROUP
- else if (object1.type == Phaser.GROUP && object2.type == Phaser.GROUP)
+ // EMITTER
+ else if (object1.type == Phaser.EMITTER)
{
- this.collideGroupVsGroup(object1, object2, collideCallback, processCallback, callbackContext);
- }
- // SPRITE vs. TILEMAP
- else if (object1.type == Phaser.SPRITE && object2.type == Phaser.TILEMAP)
- {
- this.collideSpriteVsTilemap(object1, object2, collideCallback, processCallback, callbackContext);
- }
- // TILEMAP vs. SPRITE
- else if (object1.type == Phaser.TILEMAP && object2.type == Phaser.SPRITE)
- {
- this.collideSpriteVsTilemap(object2, object1, collideCallback, processCallback, callbackContext);
- }
- // GROUP vs. TILEMAP
- else if (object1.type == Phaser.GROUP && object2.type == Phaser.TILEMAP)
- {
- this.collideGroupVsTilemap(object1, object2, collideCallback, processCallback, callbackContext);
- }
- // TILEMAP vs. GROUP
- else if (object1.type == Phaser.TILEMAP && object2.type == Phaser.GROUP)
- {
- this.collideGroupVsTilemap(object2, object1, collideCallback, processCallback, callbackContext);
+ if (object2.type == Phaser.SPRITE)
+ {
+ this.collideSpriteVsGroup(object2, object1, collideCallback, processCallback, callbackContext);
+ }
+ else if (object2.type == Phaser.GROUP || object2.type == Phaser.EMITTER)
+ {
+ this.collideGroupVsGroup(object1, object2, collideCallback, processCallback, callbackContext);
+ }
+ else if (object2.type == Phaser.TILEMAP)
+ {
+ this.collideGroupVsTilemap(object1, object2, collideCallback, processCallback, callbackContext);
+ }
}
}
@@ -214,8 +234,6 @@ Phaser.Physics.Arcade.prototype = {
},
- // collideSpriteVsWorld
-
collideSpriteVsSprite: function (sprite1, sprite2, collideCallback, processCallback, callbackContext) {
this.separate(sprite1.body, sprite2.body);
@@ -352,72 +370,8 @@ Phaser.Physics.Arcade.prototype = {
},
- /**
- * Checks for overlaps between two objects using the world QuadTree. Can be GameObject vs. GameObject, GameObject vs. Group or Group vs. Group.
- * Note: Does not take the objects scrollFactor into account. All overlaps are check in world space.
- * @param object1 The first GameObject or Group to check. If null the world.group is used.
- * @param object2 The second GameObject or Group to check.
- * @param notifyCallback A callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you passed them to Collision.overlap.
- * @param processCallback A callback function that lets you perform additional checks against the two objects if they overlap. If this is set then notifyCallback will only be called if processCallback returns true.
- * @returns {boolean} true if the objects overlap, otherwise false.
- overlap: function (object1, object2, notifyCallback, processCallback, callbackContext) {
-
- object2 = object2 || null;
- notifyCallback = notifyCallback || null;
- processCallback = processCallback || this.separate;
- callbackContext = callbackContext || this;
-
- // You have to give an object first
- if (object.type )
-
- // World vs. World check
- if (object1 == null)
- {
- // Scan the entire display list, comparing every object! (ouch)
- if (this.game.world._container.first._iNext)
- {
- var currentNode = this.game.world._container.first._iNext;
-
- do
- {
- if (checkExists == false || (checkExists && currentNode.exists))
- {
- callback.call(callbackContext, currentNode);
- }
-
- currentNode = currentNode._iNext;
- }
- while (currentNode != this.game.world._container.last._iNext);
- }
- }
-
-
-
- // Get the ships top-most ID. If the length of that ID is 1 then we can ignore every other result,
- // it's simply not colliding with anything :)
- var potentials = this.quadTree.retrieve(object1);
- var output = [];
-
- for (var i = 0, len = potentials.length; i < len; i++)
- {
- if (processCallback.call(callbackContext, object1.body, potentials[i]))
- {
- if (notifyCallback)
- {
- notifyCallback.call(callbackContext, object1, potentials[i].sprite);
- }
-
- output.push(potentials[i]);
- }
- }
-
- return (output.length);
-
- },
- */
-
/**
- * The core Collision separation function to separate two physics bodies.
+ * The core separation function to separate two physics bodies.
* @param body1 The first Sprite.Body to separate
* @param body2 The second Sprite.Body to separate
* @returns {boolean} Returns true if the bodies were separated, otherwise false.
diff --git a/src/physics/arcade/Body.js b/src/physics/arcade/Body.js
index 741e46c2..c46d7d75 100644
--- a/src/physics/arcade/Body.js
+++ b/src/physics/arcade/Body.js
@@ -145,23 +145,6 @@ Phaser.Physics.Arcade.Body.prototype = {
},
- /*
- postUpdate: function () {
-
- // this.sprite.x = this.x - this.offset.x + (this.sprite.anchor.x * this.width);
- // this.sprite.y = this.y - this.offset.y + (this.sprite.anchor.y * this.height);
-
- this.sprite.x = (this.x - this.offset.x + (this.sprite.anchor.x * this.width)) - (this.game.world.camera.x * this.sprite.scrollFactor.x);
- this.sprite.y = (this.y - this.offset.y + (this.sprite.anchor.y * this.height)) - (this.game.world.camera.y * this.sprite.scrollFactor.y);
-
- if (this.allowRotation)
- {
- this.sprite.angle = this.rotation;
- }
-
- },
- */
-
checkWorldBounds: function () {
if (this.x < this.game.world.bounds.x)