Phaser

Class: P2

Phaser.Physics. P2

Physics World Constructor

new P2(game, config)

Parameters:
Name Type Argument Description
game Phaser.Game

Reference to the current game instance.
config object <optional>

Physics configuration object passed in from the game constructor.
Source:

Classes

Body
BodyDebug
CollisionGroup
ContactMaterial
DistanceConstraint
GearConstraint
InversePointProxy
LockConstraint
Material
PointProxy
PrismaticConstraint
RevoluteConstraint
Spring

Members

_toRemove

Properties:
Name Type Description
_toRemove array

Internal var used to hold references to bodies to remove from the world on the next step.
Source:

applyDamping

Properties:
Name Type Description
applyDamping boolean

Enable to automatically apply body damping each step.
Source:

applyGravity

Properties:
Name Type Description
applyGravity boolean

Enable to automatically apply gravity each step.
Source:

applySpringForces

Properties:
Name Type Description
applySpringForces boolean

Enable to automatically apply spring forces each step.
Source:

bounds

Properties:
Name Type Description
bounds p2.Body

The bounds body contains the 4 walls that border the World. Define or disable with setBounds.
Source:

collisionGroups

Properties:
Name Type Description
collisionGroups array

Internal var.
Source:

emitImpactEvent

Properties:
Name Type Description
emitImpactEvent boolean

Set to true if you want to the world to emit the "impact" event. Turning this off could improve performance.
Source:

enableBodySleeping

Properties:
Name Type Description
enableBodySleeping boolean

Enable / disable automatic body sleeping.
Source:

frameRate

Properties:
Name Type Description
frameRate number

The frame rate the world will be stepped at. Defaults to 1 / 60, but you can change here. Also see useElapsedTime property.
Source:

friction

Properties:
Name Type Description
friction number

Friction between colliding bodies. This value is used if no matching ContactMaterial is found for a Material pair.
Source:

game

Properties:
Name Type Description
game Phaser.Game

Local reference to game.
Source:

gravity

Properties:
Name Type Description
gravity Phaser.InversePointProxy

The gravity applied to all bodies each step.
Source:

impactCallback

Properties:
Name Type Description
onImpact Phaser.Signal

Dispatched when a first contact is created between two bodies. This event is fired after the step has been done.
Source:

<protected> materials

Properties:
Name Type Description
materials array.<Phaser.Physics.P2.Material>

A local array of all created Materials.
Source:

onBeginContact

Properties:
Name Type Description
onBeginContact Phaser.Signal

Dispatched when a first contact is created between two bodies. This event is fired before the step has been done.
Source:

onBodyAdded

Properties:
Name Type Description
onBodyAdded Phaser.Signal

Dispatched when a new Body is added to the World.
Source:

onBodyRemoved

Properties:
Name Type Description
onBodyRemoved Phaser.Signal

Dispatched when a Body is removed from the World.
Source:

onConstraintAdded

Properties:
Name Type Description
onConstraintAdded Phaser.Signal

Dispatched when a new Constraint is added to the World.
Source:

onConstraintRemoved

Properties:
Name Type Description
onConstraintRemoved Phaser.Signal

Dispatched when a Constraint is removed from the World.
Source:

onContactMaterialAdded

Properties:
Name Type Description
onContactMaterialAdded Phaser.Signal

Dispatched when a new ContactMaterial is added to the World.
Source:

onContactMaterialRemoved

Properties:
Name Type Description
onContactMaterialRemoved Phaser.Signal

Dispatched when a ContactMaterial is removed from the World.
Source:

onEndContact

Properties:
Name Type Description
onEndContact Phaser.Signal

Dispatched when final contact occurs between two bodies. This event is fired before the step has been done.
Source:

onSpringAdded

Properties:
Name Type Description
onSpringAdded Phaser.Signal

Dispatched when a new Spring is added to the World.
Source:

onSpringRemoved

Properties:
Name Type Description
onSpringRemoved Phaser.Signal

Dispatched when a Spring is removed from the World.
Source:

postBroadphaseCallback

Properties:
Name Type Description
onPostBroadphase Phaser.Signal

Dispatched after the Broadphase has collected collision pairs in the world.
Source:

restituion

Properties:
Name Type Description
restitution number

Default coefficient of restitution between colliding bodies. This value is used if no matching ContactMaterial is found for a Material pair.
Source:

solveConstraints

Properties:
Name Type Description
solveConstraints boolean

Enable/disable constraint solving in each step.
Source:

<readonly> time

Properties:
Name Type Description
time boolean

The World time.
Source:

<readonly> total

Properties:
Name Type Description
total number

The total number of bodies in the world.
Source:

useElapsedTime

Properties:
Name Type Description
useElapsedTime boolean

If true the frameRate value will be ignored and instead p2 will step with the value of Game.Time.physicsElapsed, which is a delta time value.
Default Value:
  • false
Source:

<protected> world

Properties:
Name Type Description
game p2.World

The p2 World in which the simulation is run.
Source:

<static, constant> LIME_CORONA_JSON :number

Type:
  • number
Source:

Methods

addBody(body) → {boolean}

Add a body to the world.

Parameters:
Name Type Description
body Phaser.Physics.P2.Body

The Body to add to the World.
Source:
Returns:

True if the Body was added successfully, otherwise false.

Type
boolean

addConstraint(constraint) → {Phaser.Physics.P2.Constraint}

Adds a Constraint to the world.

Parameters:
Name Type Description
constraint Phaser.Physics.P2.Constraint

The Constraint to add to the World.
Source:
Returns:

The Constraint that was added.

Type
Phaser.Physics.P2.Constraint

addContactMaterial(material) → {Phaser.Physics.P2.ContactMaterial}

Adds a Contact Material to the world.

Parameters:
Name Type Description
material Phaser.Physics.P2.ContactMaterial

The Contact Material to be added to the World.
Source:
Returns:

The Contact Material that was added.

Type
Phaser.Physics.P2.ContactMaterial

addSpring(spring) → {Phaser.Physics.P2.Spring}

Adds a Spring to the world.

Parameters:
Name Type Description
spring Phaser.Physics.P2.Spring

The Spring to add to the World.
Source:
Returns:

The Spring that was added.

Type
Phaser.Physics.P2.Spring

beginContactHandler(event)

Handles a p2 begin contact event.

Parameters:
Name Type Description
event object

The event data.
Source:

clear()

Clears all bodies from the simulation.

Source:

clearTilemapLayerBodies(map, layer)

Clears all physics bodies from the given TilemapLayer that were created with World.convertTilemap.

Parameters:
Name Type Argument Description
map Phaser.Tilemap

The Tilemap to get the map data from.
layer number | string | Phaser.TilemapLayer <optional>

The layer to operate on. If not given will default to map.currentLayer.
Source:

convertCollisionObjects(map, layer, addToWorld) → {array}

Converts all of the polylines objects inside a Tiled ObjectGroup into physics bodies that are added to the world. Note that the polylines must be created in such a way that they can withstand polygon decomposition.

Parameters:
Name Type Argument Default Description
map Phaser.Tilemap

The Tilemap to get the map data from.
layer number | string | Phaser.TilemapLayer <optional>

The layer to operate on. If not given will default to map.currentLayer.
addToWorld boolean <optional>
 true

If true it will automatically add each body to the world.
Source:
Returns:

An array of the Phaser.Physics.Body objects that have been created.

Type
array

convertTilemap(map, layer, addToWorld, optimize) → {array}

Goes through all tiles in the given Tilemap and TilemapLayer and converts those set to collide into physics bodies. Only call this after you have specified all of the tiles you wish to collide with calls like Tilemap.setCollisionBetween, etc. Every time you call this method it will destroy any previously created bodies and remove them from the world. Therefore understand it's a very expensive operation and not to be done in a core game update loop.

Parameters:
Name Type Argument Default Description
map Phaser.Tilemap

The Tilemap to get the map data from.
layer number | string | Phaser.TilemapLayer <optional>

The layer to operate on. If not given will default to map.currentLayer.
addToWorld boolean <optional>
 true

If true it will automatically add each body to the world, otherwise it's up to you to do so.
optimize boolean <optional>
 true

If true adjacent colliding tiles will be combined into a single body to save processing. However it means you cannot perform specific Tile to Body collision responses.
Source:
Returns:

An array of the Phaser.Physics.P2.Body objects that were created.

Type
array

createBody(x, y, mass, addToWorld, options, points) → {Phaser.Physics.P2.Body}

Creates a new Body and adds it to the World.

Parameters:
Name Type Argument Default Description
x number

The x coordinate of Body.
y number

The y coordinate of Body.
mass number

The mass of the Body. A mass of 0 means a 'static' Body is created.
addToWorld boolean <optional>
 false

Automatically add this Body to the world? (usually false as it won't have any shapes on construction).
options object

An object containing the build options:

Properties
Name Type Argument Default Description
optimalDecomp boolean <optional>
 false

Set to true if you need optimal decomposition. Warning: very slow for polygons with more than 10 vertices.
skipSimpleCheck boolean <optional>
 false

Set to true if you already know that the path is not intersecting itself.
removeCollinearPoints boolean | number <optional>
 false

Set to a number (angle threshold value) to remove collinear points, or false to keep all points.
points Array.<number> | number

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.
Source:
Returns:

The body

Type
Phaser.Physics.P2.Body

<protected> createCollisionGroup(object)

Creates a new Collision Group and optionally applies it to the given object. Collision Groups are handled using bitmasks, therefore you have a fixed limit you can create before you need to re-use older groups.

Parameters:
Name Type Argument Description
object Phaser.Group | Phaser.Sprite <optional>

An optional Sprite or Group to apply the Collision Group to. If a Group is given it will be applied to all top-level children.
Source:

createContactMaterial(materialA, materialB, options) → {Phaser.Physics.P2.ContactMaterial}

Creates a Contact Material from the two given Materials. You can then edit the properties of the Contact Material directly.

Parameters:
Name Type Argument Description
materialA Phaser.Physics.P2.Material <optional>

The first Material to create the ContactMaterial from. If undefined it will create a new Material object first.
materialB Phaser.Physics.P2.Material <optional>

The second Material to create the ContactMaterial from. If undefined it will create a new Material object first.
options object <optional>

Material options object.
Source:
Returns:

The Contact Material that was created.

Type
Phaser.Physics.P2.ContactMaterial

createDistanceConstraint(bodyA, bodyB, distance, maxForce) → {Phaser.Physics.P2.DistanceConstraint}

Creates a constraint that tries to keep the distance between two bodies constant.

Parameters:
Name Type Argument Description
bodyA Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

First connected body.
bodyB Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

Second connected body.
distance number

The distance to keep between the bodies.
maxForce number <optional>

The maximum force that should be applied to constrain the bodies.
Source:
Returns:

The constraint

Type
Phaser.Physics.P2.DistanceConstraint

createGearConstraint(bodyA, bodyB, angle, ratio) → {Phaser.Physics.P2.GearConstraint}

Creates a constraint that tries to keep the distance between two bodies constant.

Parameters:
Name Type Argument Default Description
bodyA Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

First connected body.
bodyB Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

Second connected body.
angle number <optional>
 0

The relative angle
ratio number <optional>
 1

The gear ratio.
Source:
Returns:

The constraint

Type
Phaser.Physics.P2.GearConstraint

createLockConstraint(bodyA, bodyB, offset, angle, maxForce) → {Phaser.Physics.P2.LockConstraint}

Locks the relative position between two bodies.

Parameters:
Name Type Argument Default Description
bodyA Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

First connected body.
bodyB Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

Second connected body.
offset Array <optional>

The offset of bodyB in bodyA's frame. The value is an array with 2 elements matching x and y, i.e: [32, 32].
angle number <optional>
 0

The angle of bodyB in bodyA's frame.
maxForce number <optional>

The maximum force that should be applied to constrain the bodies.
Source:
Returns:

The constraint

Type
Phaser.Physics.P2.LockConstraint

createMaterial(name, body) → {Phaser.Physics.P2.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.

Parameters:
Name Type Argument Description
name string <optional>

Optional name of the Material. Each Material has a unique ID but string names are handy for debugging.
body Phaser.Physics.P2.Body <optional>

Optional Body. If given it will assign the newly created Material to the Body shapes.
Source:
Returns:

The Material that was created. This is also stored in Phaser.Physics.P2.materials.

Type
Phaser.Physics.P2.Material

createParticle(x, y, mass, addToWorld, options, points)

Creates a new Particle and adds it to the World.

Parameters:
Name Type Argument Default Description
x number

The x coordinate of Body.
y number

The y coordinate of Body.
mass number

The mass of the Body. A mass of 0 means a 'static' Body is created.
addToWorld boolean <optional>
 false

Automatically add this Body to the world? (usually false as it won't have any shapes on construction).
options object

An object containing the build options:

Properties
Name Type Argument Default Description
optimalDecomp boolean <optional>
 false

Set to true if you need optimal decomposition. Warning: very slow for polygons with more than 10 vertices.
skipSimpleCheck boolean <optional>
 false

Set to true if you already know that the path is not intersecting itself.
removeCollinearPoints boolean | number <optional>
 false

Set to a number (angle threshold value) to remove collinear points, or false to keep all points.
points Array.<number> | number

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.
Source:

createPrismaticConstraint(bodyA, bodyB, lock, anchorA, anchorB, axis, maxForce) → {Phaser.Physics.P2.PrismaticConstraint}

Constraint that only allows bodies to move along a line, relative to each other. See http://www.iforce2d.net/b2dtut/joints-prismatic

Parameters:
Name Type Argument Default Description
bodyA Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

First connected body.
bodyB Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

Second connected body.
lock boolean <optional>
 false

If set to true, bodyB will be free to rotate around its anchor point.
anchorA Array <optional>

Body A's anchor point, defined in its own local frame. The value is an array with 2 elements matching x and y, i.e: [32, 32].
anchorB Array <optional>

Body A's anchor point, defined in its own local frame. The value is an array with 2 elements matching x and y, i.e: [32, 32].
axis Array <optional>

An axis, defined in body A frame, that body B's anchor point may slide along. The value is an array with 2 elements matching x and y, i.e: [32, 32].
maxForce number <optional>

The maximum force that should be applied to constrain the bodies.
Source:
Returns:

The constraint

Type
Phaser.Physics.P2.PrismaticConstraint

createRevoluteConstraint(bodyA, pivotA, bodyB, pivotB, maxForce) → {Phaser.Physics.P2.RevoluteConstraint}

Connects two bodies at given offset points, letting them rotate relative to each other around this point. The pivot points are given in world (pixel) coordinates.

Parameters:
Name Type Argument Default Description
bodyA Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

First connected body.
pivotA Array

The point relative to the center of mass of bodyA which bodyA is constrained to. The value is an array with 2 elements matching x and y, i.e: [32, 32].
bodyB Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

Second connected body.
pivotB Array

The point relative to the center of mass of bodyB which bodyB is constrained to. The value is an array with 2 elements matching x and y, i.e: [32, 32].
maxForce number <optional>
 0

The maximum force that should be applied to constrain the bodies.
Source:
Returns:

The constraint

Type
Phaser.Physics.P2.RevoluteConstraint

createSpring(bodyA, bodyB, restLength, stiffness, damping, restLength, stiffness, damping, worldA, worldB, localA, localB) → {Phaser.Physics.P2.Spring}

Creates a spring, connecting two bodies. A spring can have a resting length, a stiffness and damping.

Parameters:
Name Type Argument Default Description
bodyA Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

First connected body.
bodyB Phaser.Sprite | Phaser.Physics.P2.Body | p2.Body

Second connected body.
restLength number <optional>
 1

Rest length of the spring. A number > 0.
stiffness number <optional>
 100

Stiffness of the spring. A number >= 0.
damping number <optional>
 1

Damping of the spring. A number >= 0.
restLength number <optional>
 1

Rest length of the spring. A number > 0.
stiffness number <optional>
 100

Stiffness of the spring. A number >= 0.
damping number <optional>
 1

Damping of the spring. A number >= 0.
worldA Array <optional>

Where to hook the spring to body A in world coordinates. This value is an array by 2 elements, x and y, i.e: [32, 32].
worldB Array <optional>

Where to hook the spring to body B in world coordinates. This value is an array by 2 elements, x and y, i.e: [32, 32].
localA Array <optional>

Where to hook the spring to body A in local body coordinates. This value is an array by 2 elements, x and y, i.e: [32, 32].
localB Array <optional>

Where to hook the spring to body B in local body coordinates. This value is an array by 2 elements, x and y, i.e: [32, 32].
Source:
Returns:

The spring

Type
Phaser.Physics.P2.Spring

destroy()

Clears all bodies from the simulation and unlinks World from Game. Should only be called on game shutdown. Call clear on a State change.

Source:

enable(object, debug, children)

This will create a P2 Physics body on the given game object or array of game objects. A game object can only have 1 physics body active at any one time, and it can't be changed until the object is destroyed.

Parameters:
Name Type Argument Default Description
object object | array | Phaser.Group

The game object to create the physics body on. Can also be an array or Group of objects, a body will be created on every child that has a body property.
debug boolean <optional>
 false

Create a debug object to go with this body?
children boolean <optional>
 true

Should a body be created on all children of this object? If true it will recurse down the display list as far as it can go.
Source:

enableBody(object, debug)

Creates a P2 Physics body on the given game object. A game object can only have 1 physics body active at any one time, and it can't be changed until the body is nulled.

Parameters:
Name Type Description
object object

The game object to create the physics body on. A body will only be created if this object has a null body property.
debug boolean

Create a debug object to go with this body?
Source:

endContactHandler(event)

Handles a p2 end contact event.

Parameters:
Name Type Description
event object

The event data.
Source:

getBodies() → {array.<Phaser.Physics.P2.Body>}

Populates and returns an array with references to of all current Bodies in the world.

Source:
Returns:

An array containing all current Bodies in the world.

Type
array.<Phaser.Physics.P2.Body>

getBody(object) → {p2.Body}

Checks the given object to see if it has a p2.Body and if so returns it.

Parameters:
Name Type Description
object object

The object to check for a p2.Body on.
Source:
Returns:

The p2.Body, or null if not found.

Type
p2.Body

getConstraints() → {array.<Phaser.Physics.P2.Constraint>}

Populates and returns an array of all current Constraints in the world.

Source:
Returns:

An array containing all current Constraints in the world.

Type
array.<Phaser.Physics.P2.Constraint>

getContactMaterial(materialA, materialB) → {Phaser.Physics.P2.ContactMaterial|boolean}

Gets a Contact Material based on the two given Materials.

Parameters:
Name Type Description
materialA Phaser.Physics.P2.Material

The first Material to search for.
materialB Phaser.Physics.P2.Material

The second Material to search for.
Source:
Returns:

The Contact Material or false if none was found matching the Materials given.

Type
Phaser.Physics.P2.ContactMaterial | boolean

getSprings() → {array.<Phaser.Physics.P2.Spring>}

Populates and returns an array of all current Springs in the world.

Source:
Returns:

An array containing all current Springs in the world.

Type
array.<Phaser.Physics.P2.Spring>

hitTest(worldPoint, bodies, precision, filterStatic) → {Array}

Test if a world point overlaps bodies. You will get an array of actual P2 bodies back. You can find out which Sprite a Body belongs to (if any) by checking the Body.parent.sprite property. Body.parent is a Phaser.Physics.P2.Body property.

Parameters:
Name Type Argument Default Description
worldPoint Phaser.Point

Point to use for intersection tests. The points values must be in world (pixel) coordinates.
bodies Array.<(Phaser.Physics.P2.Body|Phaser.Sprite|p2.Body)> <optional>

A list of objects to check for intersection. If not given it will check Phaser.Physics.P2.world.bodies (i.e. all world bodies)
precision number <optional>
 5

Used for matching against particles and lines. Adds some margin to these infinitesimal objects.
filterStatic boolean <optional>
 false

If true all Static objects will be removed from the results array.
Source:
Returns:

Array of bodies that overlap the point.

Type
Array

mpx(v) → {number}

Convert p2 physics value (meters) to pixel scale. By default Phaser uses a scale of 20px per meter. If you need to modify this you can over-ride these functions via the Physics Configuration object.

Parameters:
Name Type Description
v number

The value to convert.
Source:
Returns:

The scaled value.

Type
number

mpxi(v) → {number}

Convert p2 physics value (meters) to pixel scale and inverses it. By default Phaser uses a scale of 20px per meter. If you need to modify this you can over-ride these functions via the Physics Configuration object.

Parameters:
Name Type Description
v number

The value to convert.
Source:
Returns:

The scaled value.

Type
number

preUpdate()

Called at the start of the core update loop. Purges flagged bodies from the world.

Source:

pxm(v) → {number}

Convert pixel value to p2 physics scale (meters). By default Phaser uses a scale of 20px per meter. If you need to modify this you can over-ride these functions via the Physics Configuration object.

Parameters:
Name Type Description
v number

The value to convert.
Source:
Returns:

The scaled value.

Type
number

pxmi(v) → {number}

Convert pixel value to p2 physics scale (meters) and inverses it. By default Phaser uses a scale of 20px per meter. If you need to modify this you can over-ride these functions via the Physics Configuration object.

Parameters:
Name Type Description
v number

The value to convert.
Source:
Returns:

The scaled value.

Type
number

removeBody(body) → {Phaser.Physics.P2.Body}

Removes a body from the world.

Parameters:
Name Type Description
body Phaser.Physics.P2.Body

The Body to remove from the World.
Source:
Returns:

The Body that was removed.

Type
Phaser.Physics.P2.Body

removeBodyNextStep(body)

This will add a P2 Physics body into the removal list for the next step.

Parameters:
Name Type Description
body Phaser.Physics.P2.Body

The body to remove at the start of the next step.
Source:

removeConstraint(constraint) → {Phaser.Physics.P2.Constraint}

Removes a Constraint from the world.

Parameters:
Name Type Description
constraint Phaser.Physics.P2.Constraint

The Constraint to be removed from the World.
Source:
Returns:

The Constraint that was removed.

Type
Phaser.Physics.P2.Constraint

removeContactMaterial(material) → {Phaser.Physics.P2.ContactMaterial}

Removes a Contact Material from the world.

Parameters:
Name Type Description
material Phaser.Physics.P2.ContactMaterial

The Contact Material to be removed from the World.
Source:
Returns:

The Contact Material that was removed.

Type
Phaser.Physics.P2.ContactMaterial

removeSpring(spring) → {Phaser.Physics.P2.Spring}

Removes a Spring from the world.

Parameters:
Name Type Description
spring Phaser.Physics.P2.Spring

The Spring to remove from the World.
Source:
Returns:

The Spring that was removed.

Type
Phaser.Physics.P2.Spring

setBounds(x, y, width, height, left, right, top, bottom, setCollisionGroup)

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.

Parameters:
Name Type Argument Default Description
x number

The x coordinate of the top-left corner of the bounds.
y number

The y coordinate of the top-left corner of the bounds.
width number

The width of the bounds.
height number

The height of the bounds.
left boolean <optional>
 true

If true will create the left bounds wall.
right boolean <optional>
 true

If true will create the right bounds wall.
top boolean <optional>
 true

If true will create the top bounds wall.
bottom boolean <optional>
 true

If true will create the bottom bounds wall.
setCollisionGroup boolean <optional>
 true

If true the Bounds will be set to use its own Collision Group.
Source:

setImpactEvents(state)

Impact event handling is disabled by default. Enable it before any impact events will be dispatched. In a busy world hundreds of impact events can be generated every step, so only enable this if you cannot do what you need via beginContact or collision masks.

Parameters:
Name Type Description
state boolean

Set to true to enable impact events, or false to disable.
Source:

setMaterial(material, bodies)

Sets the given Material against all Shapes owned by all the Bodies in the given array.

Parameters:
Name Type Description
material Phaser.Physics.P2.Material

The Material to be applied to the given Bodies.
bodies array.<Phaser.Physics.P2.Body>

An Array of Body objects that the given Material will be set on.
Source:

setPostBroadphaseCallback(callback, context)

Sets a callback to be fired after the Broadphase has collected collision pairs in the world. Just because a pair exists it doesn't mean they will collide, just that they potentially could do. If your calback returns false the pair will be removed from the narrowphase. This will stop them testing for collision this step. Returning true from the callback will ensure they are checked in the narrowphase.

Parameters:
Name Type Description
callback function

The callback that will receive the postBroadphase event data. It must return a boolean. Set to null to disable an existing callback.
context object

The context under which the callback will be fired.
Source:

toJSON() → {object}

Converts the current world into a JSON object.

Source:
Returns:

A JSON representation of the world.

Type
object

update()

Source:

updateBoundsCollisionGroup(setCollisionGroup)

By default the World will be set to collide everything with everything. The bounds of the world is a Body with 4 shapes, one for each face. If you start to use your own collision groups then your objects will no longer collide with the bounds. To fix this you need to adjust the bounds to use its own collision group first BEFORE changing your Sprites collision group.

Parameters:
Name Type Argument Default Description
setCollisionGroup boolean <optional>
 true

If true the Bounds will be set to use its own Collision Group.
Source:
Phaser Copyright © 2012-2014 Photon Storm Ltd.
Documentation generated by JSDoc 3.3.0-dev on Fri Mar 14 2014 06:34:29 GMT-0000 (GMT) using the DocStrap template.