/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2014 Photon Storm Ltd.
* @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
*/
/**
* @class Phaser.Physics
*/
Phaser.Physics = {};
/**
* @const
* @type {number}
*/
Phaser.Physics.LIME_CORONA_JSON = 0;
// Add an extra properties to p2 that we need
p2.Body.prototype.parent = null;
p2.Spring.prototype.parent = null;
/**
* @class Phaser.Physics.World
* @classdesc Physics World Constructor
* @constructor
* @param {Phaser.Game} game - Reference to the current game instance.
* @param {object} [config] - Physics configuration object passed in from the game constructor.
*/
Phaser.Physics.World = function (game, config) {
/**
* @property {Phaser.Game} game - Local reference to game.
*/
this.game = game;
if (typeof config === 'undefined')
{
config = { gravity: [0, 0], broadphase: new p2.SAPBroadphase() };
}
/**
* @property {p2.World} game - The p2 World in which the simulation is run.
* @protected
*/
this.world = new p2.World(config);
/**
* @property {array<Phaser.Physics.Material>} materials - A local array of all created Materials.
* @protected
*/
this.materials = [];
/**
* @property {Phaser.InversePointProxy} gravity - The gravity applied to all bodies each step.
*/
this.gravity = new Phaser.Physics.InversePointProxy(game, this.world.gravity);
/**
* @property {p2.Body} bounds - The bounds body contains the 4 walls that border the World. Define or disable with setBounds.
*/
this.bounds = null;
/**
* @property {array} _wallShapes - The wall bounds shapes.
* @private
*/
this._wallShapes = [ null, null, null, null ];
/**
* @property {Phaser.Signal} onBodyAdded - Dispatched when a new Body is added to the World.
*/
this.onBodyAdded = new Phaser.Signal();
/**
* @property {Phaser.Signal} onBodyRemoved - Dispatched when a Body is removed from the World.
*/
this.onBodyRemoved = new Phaser.Signal();
/**
* @property {Phaser.Signal} onSpringAdded - Dispatched when a new Spring is added to the World.
*/
this.onSpringAdded = new Phaser.Signal();
/**
* @property {Phaser.Signal} onSpringRemoved - Dispatched when a Spring is removed from the World.
*/
this.onSpringRemoved = new Phaser.Signal();
/**
* @property {Phaser.Signal} onConstraintAdded - Dispatched when a new Constraint is added to the World.
*/
this.onConstraintAdded = new Phaser.Signal();
/**
* @property {Phaser.Signal} onConstraintRemoved - Dispatched when a Constraint is removed from the World.
*/
this.onConstraintRemoved = new Phaser.Signal();
/**
* @property {Phaser.Signal} onContactMaterialAdded - Dispatched when a new ContactMaterial is added to the World.
*/
this.onContactMaterialAdded = new Phaser.Signal();
/**
* @property {Phaser.Signal} onContactMaterialRemoved - Dispatched when a ContactMaterial is removed from the World.
*/
this.onContactMaterialRemoved = new Phaser.Signal();
/**
* @property {Phaser.Signal} onPostStep - Dispatched after the World.step()
*/
this.onPostStep = new Phaser.Signal();
/**
* @property {Phaser.Signal} onPostBroadphase - Dispatched after the Broadphase has collected collision pairs in the world.
*/
this.onPostBroadphase = new Phaser.Signal();
/**
* @property {Phaser.Signal} onImpact - Dispatched when a first contact is created between two bodies. This event is fired after the step has been done.
*/
this.onImpact = new Phaser.Signal();
/**
* @property {Phaser.Signal} onBeginContact - Dispatched when a first contact is created between two bodies. This event is fired before the step has been done.
*/
this.onBeginContact = new Phaser.Signal();
/**
* @property {Phaser.Signal} onEndContact - Dispatched when final contact occurs between two bodies. This event is fired before the step has been done.
*/
this.onEndContact = new Phaser.Signal();
// Hook into the World events
this.world.on("postStep", this.postStepHandler, this);
this.world.on("postBroadphase", this.postBroadphaseHandler, this);
this.world.on("impact", this.impactHandler, this);
this.world.on("beginContact", this.beginContactHandler, this);
this.world.on("endContact", this.endContactHandler, this);
/**
* @property {array} collisionGroups - Internal var.
*/
this.collisionGroups = [];
/**
* @property {number} _collisionGroupID - Internal var.
* @private
*/
this._collisionGroupID = 2;
this.nothingCollisionGroup = new Phaser.Physics.CollisionGroup(1);
this.boundsCollisionGroup = new Phaser.Physics.CollisionGroup(2);
this.everythingCollisionGroup = new Phaser.Physics.CollisionGroup(2147483648);
this.boundsCollidesWith = [];
// Group vs. Group callbacks
// By default we want everything colliding with everything
this.setBoundsToWorld(true, true, true, true, false);
};
Phaser.Physics.World.prototype = {
/**
* Handles a p2 postStep event.
*
* @method Phaser.Physics.World#postStepHandler
* @private
* @param {object} event - The event data.
*/
postStepHandler: function (event) {
},
/**
* Fired after the Broadphase has collected collision pairs in the world.
* Inside the event handler, you can modify the pairs array as you like, to prevent collisions between objects that you don't want.
*
* @method Phaser.Physics.World#postBroadphaseHandler
* @private
* @param {object} event - The event data.
*/
postBroadphaseHandler: function (event) {
// Body.id 1 is always the World bounds object
for (var i = 0; i < event.pairs.length; i += 2)
{
var a = event.pairs[i];
var b = event.pairs[i+1];
if (a.id !== 1 && b.id !== 1)
{
// console.log('postBroadphaseHandler', a, b);
}
}
},
/**
* Handles a p2 impact event.
*
* @method Phaser.Physics.World#impactHandler
* @private
* @param {object} event - The event data.
*/
impactHandler: function (event) {
if (event.bodyA.parent && event.bodyB.parent)
{
// Body vs. Body callbacks
var a = event.bodyA.parent;
var b = event.bodyB.parent;
if (a._bodyCallbacks[event.bodyB.id])
{
a._bodyCallbacks[event.bodyB.id].call(a._bodyCallbackContext[event.bodyB.id], a, b, event.shapeA, event.shapeB);
}
if (b._bodyCallbacks[event.bodyA.id])
{
b._bodyCallbacks[event.bodyA.id].call(b._bodyCallbackContext[event.bodyA.id], b, a, event.shapeB, event.shapeA);
}
// Body vs. Group callbacks
if (a._groupCallbacks[event.shapeB.collisionGroup])
{
a._groupCallbacks[event.shapeB.collisionGroup].call(a._groupCallbackContext[event.shapeB.collisionGroup], a, b, event.shapeA, event.shapeB);
}
if (b._groupCallbacks[event.shapeA.collisionGroup])
{
b._groupCallbacks[event.shapeA.collisionGroup].call(b._groupCallbackContext[event.shapeA.collisionGroup], b, a, event.shapeB, event.shapeA);
}
}
},
/**
* Handles a p2 begin contact event.
*
* @method Phaser.Physics.World#beginContactHandler
* @private
* @param {object} event - The event data.
*/
beginContactHandler: function (event) {
// console.log('beginContactHandler');
// console.log(event);
if (event.bodyA.id > 1 && event.bodyB.id > 1)
{
// console.log('beginContactHandler');
// console.log(event.bodyA.parent.sprite.key);
// console.log(event.bodyB.parent.sprite.key);
}
},
/**
* Handles a p2 end contact event.
*
* @method Phaser.Physics.World#endContactHandler
* @private
* @param {object} event - The event data.
*/
endContactHandler: function (event) {
// console.log('endContactHandler');
// console.log(event);
if (event.bodyA.id > 1 && event.bodyB.id > 1)
{
// console.log('endContactHandler');
// console.log(event);
}
},
/**
* Sets the bounds of the Physics world to match the Game.World dimensions.
* You can optionally set which 'walls' to create: left, right, top or bottom.
*
* @method Phaser.Physics#setBoundsToWorld
* @param {boolean} [left=true] - If true will create the left bounds wall.
* @param {boolean} [right=true] - If true will create the right bounds wall.
* @param {boolean} [top=true] - If true will create the top bounds wall.
* @param {boolean} [bottom=true] - If true will create the bottom bounds wall.
* @param {boolean} [setCollisionGroup=true] - If true the Bounds will be set to use its own Collision Group.
*/
setBoundsToWorld: function (left, right, top, bottom, setCollisionGroup) {
this.setBounds(this.game.world.bounds.x, this.game.world.bounds.y, this.game.world.bounds.width, this.game.world.bounds.height, left, right, top, bottom, setCollisionGroup);
},
/**
* Sets the given material against the 4 bounds of this World.
*
* @method Phaser.Physics#setWorldMaterial
* @param {Phaser.Physics.Material} material - The material to set.
* @param {boolean} [left=true] - If true will set the material on the left bounds wall.
* @param {boolean} [right=true] - If true will set the material on the right bounds wall.
* @param {boolean} [top=true] - If true will set the material on the top bounds wall.
* @param {boolean} [bottom=true] - If true will set the material on the bottom bounds wall.
*/
setWorldMaterial: function (material, left, right, top, bottom) {
if (typeof left === 'undefined') { left = true; }
if (typeof right === 'undefined') { right = true; }
if (typeof top === 'undefined') { top = true; }
if (typeof bottom === 'undefined') { bottom = true; }
if (left && this._wallShapes[0])
{
this._wallShapes[0].material = material;
}
if (right && this._wallShapes[1])
{
this._wallShapes[1].material = material;
}
if (top && this._wallShapes[2])
{
this._wallShapes[2].material = material;
}
if (bottom && this._wallShapes[3])
{
this._wallShapes[3].material = material;
}
},
/**
* Sets the bounds of the Physics world to match the given world pixel dimensions.
* You can optionally set which 'walls' to create: left, right, top or bottom.
*
* @method Phaser.Physics.World#setBounds
* @param {number} x - The x coordinate of the top-left corner of the bounds.
* @param {number} y - The y coordinate of the top-left corner of the bounds.
* @param {number} width - The width of the bounds.
* @param {number} height - The height of the bounds.
* @param {boolean} [left=true] - If true will create the left bounds wall.
* @param {boolean} [right=true] - If true will create the right bounds wall.
* @param {boolean} [top=true] - If true will create the top bounds wall.
* @param {boolean} [bottom=true] - If true will create the bottom bounds wall.
* @param {boolean} [setCollisionGroup=true] - If true the Bounds will be set to use its own Collision Group.
*/
setBounds: function (x, y, width, height, left, right, top, bottom, setCollisionGroup) {
if (typeof left === 'undefined') { left = true; }
if (typeof right === 'undefined') { right = true; }
if (typeof top === 'undefined') { top = true; }
if (typeof bottom === 'undefined') { bottom = true; }
if (typeof setCollisionGroup === 'undefined') { setCollisionGroup = true; }
var hw = (width / 2);
var hh = (height / 2);
var cx = hw + x;
var cy = hh + y;
if (this.bounds !== null)
{
this.world.removeBody(this.bounds);
var i = this.bounds.shapes.length;
while (i--)
{
var shape = this.bounds.shapes[i];
this.bounds.removeShape(shape);
}
this.bounds.position[0] = this.game.math.px2pi(cx);
this.bounds.position[1] = this.game.math.px2pi(cy);
}
else
{
this.bounds = new p2.Body({ mass: 0, position:[this.game.math.px2pi(cx), this.game.math.px2pi(cy)] });
}
if (left)
{
this._wallShapes[0] = new p2.Plane();
if (setCollisionGroup)
{
this._wallShapes[0].collisionGroup = this.boundsCollisionGroup.mask;
// this._wallShapes[0].collisionGroup = this.everythingCollisionGroup.mask;
// this._wallShapes[0].collisionMask = this.everythingCollisionGroup.mask;
}
this.bounds.addShape(this._wallShapes[0], [this.game.math.px2pi(-hw), 0], 1.5707963267948966 );
}
if (right)
{
this._wallShapes[1] = new p2.Plane();
if (setCollisionGroup)
{
this._wallShapes[1].collisionGroup = this.boundsCollisionGroup.mask;
// this._wallShapes[1].collisionGroup = this.everythingCollisionGroup.mask;
// this._wallShapes[1].collisionMask = this.everythingCollisionGroup.mask;
}
this.bounds.addShape(this._wallShapes[1], [this.game.math.px2pi(hw), 0], -1.5707963267948966 );
}
if (top)
{
this._wallShapes[2] = new p2.Plane();
if (setCollisionGroup)
{
this._wallShapes[2].collisionGroup = this.boundsCollisionGroup.mask;
// this._wallShapes[2].collisionGroup = this.everythingCollisionGroup.mask;
// this._wallShapes[2].collisionMask = this.everythingCollisionGroup.mask;
}
this.bounds.addShape(this._wallShapes[2], [0, this.game.math.px2pi(-hh)], -3.141592653589793 );
}
if (bottom)
{
this._wallShapes[3] = new p2.Plane();
if (setCollisionGroup)
{
this._wallShapes[3].collisionGroup = this.boundsCollisionGroup.mask;
// this._wallShapes[3].collisionGroup = this.everythingCollisionGroup.mask;
// this._wallShapes[3].collisionMask = this.everythingCollisionGroup.mask;
}
this.bounds.addShape(this._wallShapes[3], [0, this.game.math.px2pi(hh)] );
}
this.world.addBody(this.bounds);
},
/**
* @method Phaser.Physics.World#update
*/
update: function () {
this.world.step(1 / 60);
},
/**
* @method Phaser.Physics.World#destroy
*/
destroy: function () {
this.world.clear();
this.game = null;
},
/**
* Add a body to the world.
*
* @method Phaser.Physics.World#addBody
* @param {Phaser.Physics.Body} body - The Body to add to the World.
* @return {boolean} True if the Body was added successfully, otherwise false.
*/
addBody: function (body) {
if (body.data.world)
{
return false;
}
else
{
this.world.addBody(body.data);
this.onBodyAdded.dispatch(body);
return true;
}
},
/**
* Removes a body from the world.
*
* @method Phaser.Physics.World#removeBody
* @param {Phaser.Physics.Body} body - The Body to remove from the World.
* @return {Phaser.Physics.Body} The Body that was removed.
*/
removeBody: function (body) {
this.world.removeBody(body.data);
this.onBodyRemoved.dispatch(body);
return body;
},
/**
* Adds a Spring to the world.
*
* @method Phaser.Physics.World#addSpring
* @param {Phaser.Physics.Spring} spring - The Spring to add to the World.
* @return {Phaser.Physics.Spring} The Spring that was added.
*/
addSpring: function (spring) {
this.world.addSpring(spring);
this.onSpringAdded.dispatch(spring);
return spring;
},
/**
* Removes a Spring from the world.
*
* @method Phaser.Physics.World#removeSpring
* @param {Phaser.Physics.Spring} spring - The Spring to remove from the World.
* @return {Phaser.Physics.Spring} The Spring that was removed.
*/
removeSpring: function (spring) {
this.world.removeSpring(spring);
this.onSpringRemoved.dispatch(spring);
return spring;
},
/**
* Adds a Constraint to the world.
*
* @method Phaser.Physics.World#addConstraint
* @param {Phaser.Physics.Constraint} constraint - The Constraint to add to the World.
* @return {Phaser.Physics.Constraint} The Constraint that was added.
*/
addConstraint: function (constraint) {
this.world.addConstraint(constraint);
this.onConstraintAdded.dispatch(constraint);
return constraint;
},
/**
* Removes a Constraint from the world.
*
* @method Phaser.Physics.World#removeConstraint
* @param {Phaser.Physics.Constraint} constraint - The Constraint to be removed from the World.
* @return {Phaser.Physics.Constraint} The Constraint that was removed.
*/
removeConstraint: function (constraint) {
this.world.removeConstraint(constraint);
this.onConstraintRemoved.dispatch(constraint);
return constraint;
},
/**
* Adds a Contact Material to the world.
*
* @method Phaser.Physics.World#addContactMaterial
* @param {Phaser.Physics.ContactMaterial} material - The Contact Material to be added to the World.
* @return {Phaser.Physics.ContactMaterial} The Contact Material that was added.
*/
addContactMaterial: function (material) {
this.world.addContactMaterial(material);
this.onContactMaterialAdded.dispatch(material);
return material;
},
/**
* Removes a Contact Material from the world.
*
* @method Phaser.Physics.World#removeContactMaterial
* @param {Phaser.Physics.ContactMaterial} material - The Contact Material to be removed from the World.
* @return {Phaser.Physics.ContactMaterial} The Contact Material that was removed.
*/
removeContactMaterial: function (material) {
this.world.removeContactMaterial(material);
this.onContactMaterialRemoved.dispatch(material);
return material;
},
/**
* Gets a Contact Material based on the two given Materials.
*
* @method Phaser.Physics.World#getContactMaterial
* @param {Phaser.Physics.Material} materialA - The first Material to search for.
* @param {Phaser.Physics.Material} materialB - The second Material to search for.
* @return {Phaser.Physics.ContactMaterial|boolean} The Contact Material or false if none was found matching the Materials given.
*/
getContactMaterial: function (materialA, materialB) {
return this.world.getContactMaterial(materialA, materialB);
},
/**
* Sets the given Material against all Shapes owned by all the Bodies in the given array.
*
* @method Phaser.Physics.World#setMaterial
* @param {Phaser.Physics.Material} material - The Material to be applied to the given Bodies.
* @param {array<Phaser.Physics.Body>} bodies - An Array of Body objects that the given Material will be set on.
*/
setMaterial: function (material, bodies) {
var i = bodies.length;
while (i--)
{
bodies.setMaterial(material);
}
},
/**
* Creates a Material. Materials are applied to Shapes owned by a Body and can be set with Body.setMaterial().
* Materials are a way to control what happens when Shapes collide. Combine unique Materials together to create Contact Materials.
* Contact Materials have properties such as friction and restitution that allow for fine-grained collision control between different Materials.
*
* @method Phaser.Physics.World#createMaterial
* @param {string} [name] - Optional name of the Material. Each Material has a unique ID but string names are handy for debugging.
* @param {Phaser.Physics.Body} [body] - Optional Body. If given it will assign the newly created Material to the Body shapes.
* @return {Phaser.Physics.Material} The Material that was created. This is also stored in Phaser.Physics.World.materials.
*/
createMaterial: function (name, body) {
name = name || '';
var material = new Phaser.Physics.Material(name);
this.materials.push(material);
if (typeof body !== 'undefined')
{
body.setMaterial(material);
}
return material;
},
/**
* Creates a Contact Material from the two given Materials. You can then edit the properties of the Contact Material directly.
*
* @method Phaser.Physics.World#createContactMaterial
* @param {Phaser.Physics.Material} [materialA] - The first Material to create the ContactMaterial from. If undefined it will create a new Material object first.
* @param {Phaser.Physics.Material} [materialB] - The second Material to create the ContactMaterial from. If undefined it will create a new Material object first.
* @param {object} [options] - Material options object.
* @return {Phaser.Physics.ContactMaterial} The Contact Material that was created.
*/
createContactMaterial: function (materialA, materialB, options) {
if (typeof materialA === 'undefined') { materialA = this.createMaterial(); }
if (typeof materialB === 'undefined') { materialB = this.createMaterial(); }
var contact = new Phaser.Physics.ContactMaterial(materialA, materialB, options);
return this.addContactMaterial(contact);
},
/**
* Populates and returns an array of all current Bodies in the world.
*
* @method Phaser.Physics.World#getBodies
* @return {array<Phaser.Physics.Body>} An array containing all current Bodies in the world.
*/
getBodies: function () {
var output = [];
var i = this.world.bodies.length;
while (i--)
{
output.push(this.world.bodies[i].parent);
}
return output;
},
/**
* Populates and returns an array of all current Springs in the world.
*
* @method Phaser.Physics.World#getSprings
* @return {array<Phaser.Physics.Spring>} An array containing all current Springs in the world.
*/
getSprings: function () {
var output = [];
var i = this.world.springs.length;
while (i--)
{
output.push(this.world.springs[i]);
}
return output;
},
/**
* Populates and returns an array of all current Constraints in the world.
*
* @method Phaser.Physics.World#getConstraints
* @return {array<Phaser.Physics.Constraints>} An array containing all current Constraints in the world.
*/
getConstraints: function () {
var output = [];
var i = this.world.constraints.length;
while (i--)
{
output.push(this.world.springs[i]);
}
return output;
},
/**
* Test if a world point overlaps bodies.
*
* @method Phaser.Physics.World#hitTest
* @param {Phaser.Point} worldPoint - Point to use for intersection tests.
* @param {Array} bodies - A list of objects to check for intersection.
* @param {number} precision - Used for matching against particles and lines. Adds some margin to these infinitesimal objects.
* @return {Array} Array of bodies that overlap the point.
*/
hitTest: function (worldPoint, bodies, precision) {
},
/**
* Converts the current world into a JSON object.
*
* @method Phaser.Physics.World#toJSON
* @return {object} A JSON representation of the world.
*/
toJSON: function () {
this.world.toJSON();
},
createCollisionGroup: function () {
var bitmask = Math.pow(2, this._collisionGroupID);
if (this._wallShapes[0])
{
this._wallShapes[0].collisionMask = this._wallShapes[0].collisionMask | bitmask;
}
if (this._wallShapes[1])
{
this._wallShapes[1].collisionMask = this._wallShapes[1].collisionMask | bitmask;
}
if (this._wallShapes[2])
{
this._wallShapes[2].collisionMask = this._wallShapes[2].collisionMask | bitmask;
}
if (this._wallShapes[3])
{
this._wallShapes[3].collisionMask = this._wallShapes[3].collisionMask | bitmask;
}
this._collisionGroupID++;
var group = new Phaser.Physics.CollisionGroup(bitmask);
this.collisionGroups.push(group);
return group;
},
/**
* @method Phaser.Physics.World.prototype.createBody
* @param {number} x - The x coordinate of Body.
* @param {number} y - The y coordinate of Body.
* @param {number} mass - The mass of the Body. A mass of 0 means a 'static' Body is created.
* @param {boolean} [addToWorld=false] - Automatically add this Body to the world? (usually false as it won't have any shapes on construction).
* @param {object} options - An object containing the build options:
* @param {boolean} [options.optimalDecomp=false] - Set to true if you need optimal decomposition. Warning: very slow for polygons with more than 10 vertices.
* @param {boolean} [options.skipSimpleCheck=false] - Set to true if you already know that the path is not intersecting itself.
* @param {boolean|number} [options.removeCollinearPoints=false] - Set to a number (angle threshold value) to remove collinear points, or false to keep all points.
* @param {(number[]|...number)} points - An array of 2d vectors that form the convex or concave polygon.
* Either [[0,0], [0,1],...] or a flat array of numbers that will be interpreted as [x,y, x,y, ...],
* or the arguments passed can be flat x,y values e.g. `setPolygon(options, x,y, x,y, x,y, ...)` where `x` and `y` are numbers.
*/
createBody: function (x, y, mass, addToWorld, options, data) {
if (typeof addToWorld === 'undefined') { addToWorld = false; }
var body = new Phaser.Physics.Body(this.game, null, x, y, mass);
if (data)
{
var result = body.addPolygon(options, data);
if (!result)
{
return false;
}
}
if (addToWorld)
{
this.world.addBody(body.data);
}
return body;
},
/**
* @method Phaser.Physics.World.prototype.createBody
* @param {number} x - The x coordinate of Body.
* @param {number} y - The y coordinate of Body.
* @param {number} mass - The mass of the Body. A mass of 0 means a 'static' Body is created.
* @param {boolean} [addToWorld=false] - Automatically add this Body to the world? (usually false as it won't have any shapes on construction).
* @param {object} options - An object containing the build options:
* @param {boolean} [options.optimalDecomp=false] - Set to true if you need optimal decomposition. Warning: very slow for polygons with more than 10 vertices.
* @param {boolean} [options.skipSimpleCheck=false] - Set to true if you already know that the path is not intersecting itself.
* @param {boolean|number} [options.removeCollinearPoints=false] - Set to a number (angle threshold value) to remove collinear points, or false to keep all points.
* @param {(number[]|...number)} points - An array of 2d vectors that form the convex or concave polygon.
* Either [[0,0], [0,1],...] or a flat array of numbers that will be interpreted as [x,y, x,y, ...],
* or the arguments passed can be flat x,y values e.g. `setPolygon(options, x,y, x,y, x,y, ...)` where `x` and `y` are numbers.
*/
createParticle: function (x, y, mass, addToWorld, options, data) {
if (typeof addToWorld === 'undefined') { addToWorld = false; }
var body = new Phaser.Physics.Body(this.game, null, x, y, mass);
if (data)
{
var result = body.addPolygon(options, data);
if (!result)
{
return false;
}
}
if (addToWorld)
{
this.world.addBody(body.data);
}
return body;
},
};
/**
* @name Phaser.Physics.World#friction
* @property {number} friction - Friction between colliding bodies. This value is used if no matching ContactMaterial is found for a Material pair.
*/
Object.defineProperty(Phaser.Physics.World.prototype, "friction", {
get: function () {
return this.world.defaultFriction;
},
set: function (value) {
this.world.defaultFriction = value;
}
});
/**
* @name Phaser.Physics.World#restituion
* @property {number} restitution - Default coefficient of restitution between colliding bodies. This value is used if no matching ContactMaterial is found for a Material pair.
*/
Object.defineProperty(Phaser.Physics.World.prototype, "restituion", {
get: function () {
return this.world.defaultRestitution;
},
set: function (value) {
this.world.defaultRestitution = value;
}
});
/**
* @name Phaser.Physics.World#applySpringForces
* @property {boolean} applySpringForces - Enable to automatically apply spring forces each step.
*/
Object.defineProperty(Phaser.Physics.World.prototype, "applySpringForces", {
get: function () {
return this.world.applySpringForces;
},
set: function (value) {
this.world.applySpringForces = value;
}
});
/**
* @name Phaser.Physics.World#applyDamping
* @property {boolean} applyDamping - Enable to automatically apply body damping each step.
*/
Object.defineProperty(Phaser.Physics.World.prototype, "applyDamping", {
get: function () {
return this.world.applyDamping;
},
set: function (value) {
this.world.applyDamping = value;
}
});
/**
* @name Phaser.Physics.World#applyGravity
* @property {boolean} applyGravity - Enable to automatically apply gravity each step.
*/
Object.defineProperty(Phaser.Physics.World.prototype, "applyGravity", {
get: function () {
return this.world.applyGravity;
},
set: function (value) {
this.world.applyGravity = value;
}
});
/**
* @name Phaser.Physics.World#solveConstraints
* @property {boolean} solveConstraints - Enable/disable constraint solving in each step.
*/
Object.defineProperty(Phaser.Physics.World.prototype, "solveConstraints", {
get: function () {
return this.world.solveConstraints;
},
set: function (value) {
this.world.solveConstraints = value;
}
});
/**
* @name Phaser.Physics.World#time
* @property {boolean} time - The World time.
* @readonly
*/
Object.defineProperty(Phaser.Physics.World.prototype, "time", {
get: function () {
return this.world.time;
}
});
/**
* @name Phaser.Physics.World#emitImpactEvent
* @property {boolean} emitImpactEvent - Set to true if you want to the world to emit the "impact" event. Turning this off could improve performance.
*/
Object.defineProperty(Phaser.Physics.World.prototype, "emitImpactEvent", {
get: function () {
return this.world.emitImpactEvent;
},
set: function (value) {
this.world.emitImpactEvent = value;
}
});
/**
* @name Phaser.Physics.World#enableBodySleeping
* @property {boolean} enableBodySleeping - Enable / disable automatic body sleeping.
*/
Object.defineProperty(Phaser.Physics.World.prototype, "enableBodySleeping", {
get: function () {
return this.world.enableBodySleeping;
},
set: function (value) {
this.world.enableBodySleeping = value;
}
});