Class: MatterPhysics

Phaser.Physics.Matter. MatterPhysics

The Phaser Matter plugin provides the ability to use the Matter JS Physics Engine within your Phaser games.

Unlike Arcade Physics, the other physics system provided with Phaser, Matter JS is a full-body physics system. It features:

  • Rigid bodies
  • Compound bodies
  • Composite bodies
  • Concave and convex hulls
  • Physical properties (mass, area, density etc.)
  • Restitution (elastic and inelastic collisions)
  • Collisions (broad-phase, mid-phase and narrow-phase)
  • Stable stacking and resting
  • Conservation of momentum
  • Friction and resistance
  • Constraints
  • Gravity
  • Sleeping and static bodies
  • Rounded corners (chamfering)
  • Views (translate, zoom)
  • Collision queries (raycasting, region tests)
  • Time scaling (slow-mo, speed-up)

Configuration of Matter is handled via the Matter World Config object, which can be passed in either the Phaser Game Config, or Phaser Scene Config. Here is a basic example:

physics: {
    default: 'matter',
    matter: {
        enableSleeping: true,
        gravity: {
            y: 0
        },
        debug: {
            showBody: true,
            showStaticBody: true
        }
    }
}

This class acts as an interface between a Phaser Scene and a single instance of the Matter Engine.

Use it to access the most common Matter features and helper functions.

You can find details, documentation and examples on the Matter JS website: https://brm.io/matter-js/

new MatterPhysics(scene)

Parameters:
Name Type Description
scene Phaser.Scene

The Phaser Scene that owns this Matter Physics instance.
Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 41)

Members

add :Phaser.Physics.Matter.Factory

An instance of the Matter Factory. This class provides lots of functions for creating a wide variety of physics objects and adds them automatically to the Matter World.

You can use this class to cut-down on the amount of code required in your game, however, use of the Factory is entirely optional and should be seen as a development aid. It's perfectly possible to create and add components to the Matter world without using it.

Type:
Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 141)

axes :MatterJS.AxesFactory

A reference to the Matter.Axes module.

The Matter.Axes module contains methods for creating and manipulating sets of axes.

Type:
  • MatterJS.AxesFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 316)

bodies :MatterJS.BodiesFactory

A reference to the Matter.Bodies module.

The Matter.Bodies module contains factory methods for creating rigid bodies with commonly used body configurations (such as rectangles, circles and other polygons).

Type:
  • MatterJS.BodiesFactory
Since: 3.18.0
Source: src/physics/matter-js/MatterPhysics.js (Line 290)

body :MatterJS.BodyFactory

A reference to the Matter.Body module.

The Matter.Body module contains methods for creating and manipulating body models. A Matter.Body is a rigid body that can be simulated by a Matter.Engine. Factories for commonly used body configurations (such as rectangles, circles and other polygons) can be found in the Bodies module.

Type:
  • MatterJS.BodyFactory
Since: 3.18.0
Source: src/physics/matter-js/MatterPhysics.js (Line 167)

bodyBounds :Phaser.Physics.Matter.BodyBounds

An instance of the Body Bounds class. This class contains functions used for getting the world position from various points around the bounds of a physics body.

Type:
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 155)

bounds :MatterJS.BoundsFactory

A reference to the Matter.Bounds module.

The Matter.Bounds module contains methods for creating and manipulating axis-aligned bounding boxes (AABB).

Type:
  • MatterJS.BoundsFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 327)

composite :MatterJS.CompositeFactory

A reference to the Matter.Composite module.

The Matter.Composite module contains methods for creating and manipulating composite bodies. A composite body is a collection of Matter.Body, Matter.Constraint and other Matter.Composite, therefore composites form a tree structure. It is important to use the functions in this module to modify composites, rather than directly modifying their properties. Note that the Matter.World object is also a type of Matter.Composite and as such all composite methods here can also operate on a Matter.World.

Type:
  • MatterJS.CompositeFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 180)

composites :MatterJS.CompositesFactory

A reference to the Matter.Composites module.

The Matter.Composites module contains factory methods for creating composite bodies with commonly used configurations (such as stacks and chains).

Type:
  • MatterJS.CompositesFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 302)

config :Phaser.Types.Physics.Matter.MatterWorldConfig

The parsed Matter Configuration object.

Type:
Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 122)

constraint :MatterJS.ConstraintFactory

A reference to the Matter.Constraint module.

The Matter.Constraint module contains methods for creating and manipulating constraints. Constraints are used for specifying that a fixed distance must be maintained between two bodies (or a body and a fixed world-space position). The stiffness of constraints can be modified to create springs or elastic.

Type:
  • MatterJS.ConstraintFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 275)

detector :MatterJS.DetectorFactory

A reference to the Matter.Detector module.

The Matter.Detector module contains methods for detecting collisions given a set of pairs.

Type:
  • MatterJS.DetectorFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 196)

grid :MatterJS.GridFactory

A reference to the Matter.Grid module.

The Matter.Grid module contains methods for creating and manipulating collision broadphase grid structures.

Type:
  • MatterJS.GridFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 207)

pair :MatterJS.PairFactory

A reference to the Matter.Pair module.

The Matter.Pair module contains methods for creating and manipulating collision pairs.

Type:
  • MatterJS.PairFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 218)

pairs :MatterJS.PairsFactory

A reference to the Matter.Pairs module.

The Matter.Pairs module contains methods for creating and manipulating collision pair sets.

Type:
  • MatterJS.PairsFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 229)

query :MatterJS.QueryFactory

A reference to the Matter.Query module.

The Matter.Query module contains methods for performing collision queries.

Type:
  • MatterJS.QueryFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 240)

resolver :MatterJS.ResolverFactory

A reference to the Matter.Resolver module.

The Matter.Resolver module contains methods for resolving collision pairs.

Type:
  • MatterJS.ResolverFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 251)

sat :MatterJS.SATFactory

A reference to the Matter.SAT module.

The Matter.SAT module contains methods for detecting collisions using the Separating Axis Theorem.

Type:
  • MatterJS.SATFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 262)

scene :Phaser.Scene

The Phaser Scene that owns this Matter Physics instance

Type:
Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 104)

svg :MatterJS.SvgFactory

A reference to the Matter.Svg module.

The Matter.Svg module contains methods for converting SVG images into an array of vector points.

To use this module you also need the SVGPathSeg polyfill: https://github.com/progers/pathseg

Type:
  • MatterJS.SvgFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 338)

systems :Phaser.Scenes.Systems

A reference to the Scene Systems that belong to the Scene owning this Matter Physics instance.

Type:
Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 113)

vector :MatterJS.VectorFactory

A reference to the Matter.Vector module.

The Matter.Vector module contains methods for creating and manipulating vectors. Vectors are the basis of all the geometry related operations in the engine. A Matter.Vector object is of the form { x: 0, y: 0 }.

Type:
  • MatterJS.VectorFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 351)

vertices :MatterJS.VerticesFactory

A reference to the Matter.Vertices module.

The Matter.Vertices module contains methods for creating and manipulating sets of vertices. A set of vertices is an array of Matter.Vector with additional indexing properties inserted by Vertices.create. A Matter.Body maintains a set of vertices to represent the shape of the object (its convex hull).

Type:
  • MatterJS.VerticesFactory
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 364)

verts :MatterJS.VerticesFactory

A reference to the Matter.Vertices module.

The Matter.Vertices module contains methods for creating and manipulating sets of vertices. A set of vertices is an array of Matter.Vector with additional indexing properties inserted by Vertices.create. A Matter.Body maintains a set of vertices to represent the shape of the object (its convex hull).

Type:
  • MatterJS.VerticesFactory
Since: 3.14.0
Source: src/physics/matter-js/MatterPhysics.js (Line 377)

world :Phaser.Physics.Matter.World

An instance of the Matter World class. This class is responsible for the updating of the Matter Physics world, as well as handling debug drawing functions.

Type:
Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 131)

Methods

alignBody(body, x, y, align)

Aligns a Body, or Matter Game Object, against the given coordinates.

The alignment takes place using the body bounds, which take into consideration things like body scale and rotation.

Although a Body has a position property, it is based on the center of mass for the body, not a dimension based center. This makes aligning bodies difficult, especially if they have rotated or scaled. This method will derive the correct position based on the body bounds and its center of mass offset, in order to align the body with the given coordinate.

For example, if you wanted to align a body so it sat in the bottom-center of the Scene, and the world was 800 x 600 in size:

this.matter.alignBody(body, 400, 600, Phaser.Display.Align.BOTTOM_CENTER);

You pass in 400 for the x coordinate, because that is the center of the world, and 600 for the y coordinate, as that is the base of the world.

Parameters:
Name Type Description
body Phaser.Types.Physics.Matter.MatterBody

The Body to align.
x number

The horizontal position to align the body to.
y number

The vertical position to align the body to.
align number

One of the Phaser.Display.Align constants, such as Phaser.Display.Align.TOP_LEFT.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 1319)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

applyForce(bodies, force)

Applies a force to a body, at the bodies current position, including resulting torque.

Parameters:
Name Type Description
bodies Phaser.Types.Physics.Matter.MatterBody | Array.<Phaser.Types.Physics.Matter.MatterBody>

Either a single Body, or an array of bodies to update. If falsey it will use all bodies in the world.
force Phaser.Types.Math.Vector2Like

A Vector that specifies the force to apply.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 1184)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

applyForceFromAngle(bodies, speed [, angle])

Apply a force to a body based on the given angle and speed. If no angle is given, the current body angle is used.

Use very small speed values, such as 0.1, depending on the mass and required velocity.

Parameters:
Name Type Argument Description
bodies Phaser.Types.Physics.Matter.MatterBody | Array.<Phaser.Types.Physics.Matter.MatterBody>

Either a single Body, or an array of bodies to update. If falsey it will use all bodies in the world.
speed number

A speed value to be applied to a directional force.
angle number <optional>

The angle, in radians, to apply the force from. Leave undefined to use the current body angle.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 1250)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

applyForceFromPosition(bodies, position, speed [, angle])

Applies a force to a body, from the given world position, including resulting torque. If no angle is given, the current body angle is used.

Use very small speed values, such as 0.1, depending on the mass and required velocity.

Parameters:
Name Type Argument Description
bodies Phaser.Types.Physics.Matter.MatterBody | Array.<Phaser.Types.Physics.Matter.MatterBody>

Either a single Body, or an array of bodies to update. If falsey it will use all bodies in the world.
position Phaser.Types.Math.Vector2Like

A Vector that specifies the world-space position to apply the force at.
speed number

A speed value to be applied to a directional force.
angle number <optional>

The angle, in radians, to apply the force from. Leave undefined to use the current body angle.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 1212)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

containsPoint(body, x, y)

Checks if the vertices of the given body, or an array of bodies, contains the given point, or not.

You can pass in either a single body, or an array of bodies to be checked. This method will return true if any of the bodies in the array contain the point. See the intersectPoint method if you need to get a list of intersecting bodies.

The point should be transformed into the Matter World coordinate system in advance. This happens by default with Input Pointers, but if you wish to use points from another system you may need to transform them before passing them.

Parameters:
Name Type Description
body Phaser.Types.Physics.Matter.MatterBody | Array.<Phaser.Types.Physics.Matter.MatterBody>

The body, or an array of bodies, to check against the point.
x number

The horizontal coordinate of the point.
y number

The vertical coordinate of the point.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 672)
Returns:

true if the point is within one of the bodies given, otherwise false.

Type
boolean

enableAttractorPlugin()

Enables the Matter Attractors Plugin.

The attractors plugin that makes it easy to apply continual forces on bodies. It's possible to simulate effects such as wind, gravity and magnetism.

https://github.com/liabru/matter-attractors

This method is called automatically if plugins.attractors is set in the Matter World Config. However, you can also call it directly from within your game.

Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 489)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

enableCollisionEventsPlugin()

Enables the Matter Collision Events Plugin.

Note that this plugin is enabled by default. So you should only ever need to call this method if you have specifically disabled the plugin in your Matter World Config. You can disable it by setting plugins.collisionevents: false in your Matter World Config.

This plugin triggers three new events on Matter.Body:

  1. onCollide
  2. onCollideEnd
  3. onCollideActive

These events correspond to the Matter.js events collisionStart, collisionActive and collisionEnd, respectively. You can listen to these events via Matter.Events or they will also be emitted from the Matter World.

This plugin also extends Matter.Body with three convenience functions:

Matter.Body.setOnCollide(callback) Matter.Body.setOnCollideEnd(callback) Matter.Body.setOnCollideActive(callback)

You can register event callbacks by providing a function of type (pair: Matter.Pair) => void

https://github.com/dxu/matter-collision-events

Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 538)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

enableWrapPlugin()

Enables the Matter Wrap Plugin.

The coordinate wrapping plugin that automatically wraps the position of bodies such that they always stay within the given bounds. Upon crossing a boundary the body will appear on the opposite side of the bounds, while maintaining its velocity.

https://github.com/liabru/matter-wrap

This method is called automatically if plugins.wrap is set in the Matter World Config. However, you can also call it directly from within your game.

Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 513)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

getConfig()

This internal method is called when this class starts and retrieves the final Matter World Config.

Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 468)
Returns:

The Matter World Config.

Type
Phaser.Types.Physics.Matter.MatterWorldConfig

getConstraintLength(constraint)

Returns the length of the given constraint, which is the distance between the two points.

Parameters:
Name Type Description
constraint MatterJS.ConstraintType

The constraint to get the length from.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 1287)
Returns:

The length of the constraint.

Type
number

getMatterBodies( [bodies])

Takes an array and returns a new array made from all of the Matter Bodies found in the original array.

For example, passing in Matter Game Objects, such as a bunch of Matter Sprites, to this method, would return an array containing all of their native Matter Body objects.

If the bodies argument is falsey, it will return all bodies in the world.

Parameters:
Name Type Argument Description
bodies array <optional>

An array of objects to extract the bodies from. If falsey, it will return all bodies in the world.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 1034)
Returns:

An array of native Matter Body objects.

Type
Array.<MatterJS.BodyType>

intersectBody(body [, bodies])

Checks the given Matter Body to see if it intersects with any of the given bodies.

If no bodies are provided it will check against all bodies in the Matter World.

Parameters:
Name Type Argument Description
body Phaser.Types.Physics.Matter.MatterBody

The target body.
bodies Array.<Phaser.Types.Physics.Matter.MatterBody> <optional>

An array of bodies to check the target body against. If not provided it will search all bodies in the world.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 823)
Returns:

An array of bodies whos vertices intersect with target body.

Type
Array.<Phaser.Types.Physics.Matter.MatterBody>

intersectPoint(x, y [, bodies])

Checks the given coordinates to see if any vertices of the given bodies contain it.

If no bodies are provided it will search all bodies in the Matter World, including within Composites.

The coordinates should be transformed into the Matter World coordinate system in advance. This happens by default with Input Pointers, but if you wish to use coordinates from another system you may need to transform them before passing them.

Parameters:
Name Type Argument Description
x number

The horizontal coordinate of the point.
y number

The vertical coordinate of the point.
bodies Array.<Phaser.Types.Physics.Matter.MatterBody> <optional>

An array of bodies to check. If not provided it will search all bodies in the world.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 703)
Returns:

An array of bodies which contain the given point.

Type
Array.<Phaser.Types.Physics.Matter.MatterBody>

intersectRay(x1, y1, x2, y2 [, rayWidth] [, bodies])

Checks the given ray segment to see if any vertices of the given bodies intersect with it.

If no bodies are provided it will search all bodies in the Matter World.

The width of the ray can be specified via the rayWidth parameter.

Parameters:
Name Type Argument Default Description
x1 number

The horizontal coordinate of the start of the ray segment.
y1 number

The vertical coordinate of the start of the ray segment.
x2 number

The horizontal coordinate of the end of the ray segment.
y2 number

The vertical coordinate of the end of the ray segment.
rayWidth number <optional>
 1

The width of the ray segment.
bodies Array.<Phaser.Types.Physics.Matter.MatterBody> <optional>

An array of bodies to check. If not provided it will search all bodies in the world.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 787)
Returns:

An array of bodies whos vertices intersect with the ray segment.

Type
Array.<Phaser.Types.Physics.Matter.MatterBody>

intersectRect(x, y, width, height [, outside] [, bodies])

Checks the given rectangular area to see if any vertices of the given bodies intersect with it. Or, if the outside parameter is set to true, it checks to see which bodies do not intersect with it.

If no bodies are provided it will search all bodies in the Matter World, including within Composites.

Parameters:
Name Type Argument Default Description
x number

The horizontal coordinate of the top-left of the area.
y number

The vertical coordinate of the top-left of the area.
width number

The width of the area.
height number

The height of the area.
outside boolean <optional>
 false

If false it checks for vertices inside the area, if true it checks for vertices outside the area.
bodies Array.<Phaser.Types.Physics.Matter.MatterBody> <optional>

An array of bodies to check. If not provided it will search all bodies in the world.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 742)
Returns:

An array of bodies that intersect with the given area.

Type
Array.<Phaser.Types.Physics.Matter.MatterBody>

overlap(target [, bodies] [, overlapCallback] [, processCallback] [, callbackContext])

Checks to see if the target body, or an array of target bodies, intersects with any of the given bodies.

If intersection occurs this method will return true and, if provided, invoke the callbacks.

If no bodies are provided for the second parameter the target will check again all bodies in the Matter World.

Note that bodies can only overlap if they are in non-colliding collision groups or categories.

If you provide a processCallback then the two bodies that overlap are sent to it. This callback must return a boolean and is used to allow you to perform additional processing tests before a final outcome is decided. If it returns true then the bodies are finally passed to the overlapCallback, if set.

If you provide an overlapCallback then the matching pairs of overlapping bodies will be sent to it.

Both callbacks have the following signature: function (bodyA, bodyB, collisionInfo) where bodyA is always the target body. The collisionInfo object contains additional data, such as the angle and depth of penetration.

Parameters:
Name Type Argument Description
target Phaser.Types.Physics.Matter.MatterBody | Array.<Phaser.Types.Physics.Matter.MatterBody>

The target body, or array of target bodies, to check.
bodies Array.<Phaser.Types.Physics.Matter.MatterBody> <optional>

The second body, or array of bodies, to check. If falsey it will check against all bodies in the world.
overlapCallback ArcadePhysicsCallback <optional>

An optional callback function that is called if the bodies overlap.
processCallback ArcadePhysicsCallback <optional>

An optional callback function that lets you perform additional checks against the two bodies if they overlap. If this is set then overlapCallback will only be invoked if this callback returns true.
callbackContext * <optional>

The context, or scope, in which to run the callbacks.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 860)
Returns:

true if the target body intersects with any of the bodies given, otherwise false.

Type
boolean

pause()

Pauses the Matter World instance and sets enabled to false.

A paused world will not run any simulations for the duration it is paused.

Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 577)
Fires:
Returns:

The Matter World object.

Type
Phaser.Physics.Matter.World

resume()

Resumes this Matter World instance from a paused state and sets enabled to true.

Since: 3.0.0
Source: src/physics/matter-js/MatterPhysics.js (Line 593)
Returns:

The Matter World object.

Type
Phaser.Physics.Matter.World

set30Hz()

Sets the Matter Engine to run at fixed timestep of 30Hz and enables autoUpdate. If you have set a custom getDelta function then this will override it.

Since: 3.4.0
Source: src/physics/matter-js/MatterPhysics.js (Line 623)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

set60Hz()

Sets the Matter Engine to run at fixed timestep of 60Hz and enables autoUpdate. If you have set a custom getDelta function then this will override it.

Since: 3.4.0
Source: src/physics/matter-js/MatterPhysics.js (Line 606)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

setAngularVelocity(bodies, value)

Sets the angular velocity of the bodies instantly. Position, angle, force etc. are unchanged.

Parameters:
Name Type Description
bodies Phaser.Types.Physics.Matter.MatterBody | Array.<Phaser.Types.Physics.Matter.MatterBody>

Either a single Body, or an array of bodies to update. If falsey it will use all bodies in the world.
value number

The angular velocity.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 1160)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

setCollidesWith(bodies, categories)

Sets the collision filter mask of all given Matter Bodies to the given value.

Two Matter Bodies with different collision groups will only collide if each one includes the others category in its mask based on a bitwise AND operation: (categoryA & maskB) !== 0 and (categoryB & maskA) !== 0 are both true.

Parameters:
Name Type Description
bodies Array.<Phaser.Types.Physics.Matter.MatterBody>

An array of bodies to update. If falsey it will use all bodies in the world.
categories number | Array.<number>

A unique category bitfield, or an array of them.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 993)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

setCollisionCategory(bodies, value)

Sets the collision filter category of all given Matter Bodies to the given value.

This number must be a power of two between 2^0 (= 1) and 2^31.

Bodies with different collision groups (see #setCollisionGroup) will only collide if their collision categories are included in their collision masks (see #setCollidesWith).

Parameters:
Name Type Description
bodies Array.<Phaser.Types.Physics.Matter.MatterBody>

An array of bodies to update. If falsey it will use all bodies in the world.
value number

Unique category bitfield.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 936)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

setCollisionGroup(bodies, value)

Sets the collision filter group of all given Matter Bodies to the given value.

If the group value is zero, or if two Matter Bodies have different group values, they will collide according to the usual collision filter rules (see #setCollisionCategory and #setCollisionGroup).

If two Matter Bodies have the same positive group value, they will always collide; if they have the same negative group value they will never collide.

Parameters:
Name Type Description
bodies Array.<Phaser.Types.Physics.Matter.MatterBody>

An array of bodies to update. If falsey it will use all bodies in the world.
value number

Unique group index.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 964)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

setVelocity(bodies, x, y)

Sets both the horizontal and vertical linear velocity of the physics bodies.

Parameters:
Name Type Description
bodies Phaser.Types.Physics.Matter.MatterBody | Array.<Phaser.Types.Physics.Matter.MatterBody>

Either a single Body, or an array of bodies to update. If falsey it will use all bodies in the world.
x number

The horizontal linear velocity value.
y number

The vertical linear velocity value.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 1073)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

setVelocityX(bodies, x)

Sets just the horizontal linear velocity of the physics bodies. The vertical velocity of the body is unchanged.

Parameters:
Name Type Description
bodies Phaser.Types.Physics.Matter.MatterBody | Array.<Phaser.Types.Physics.Matter.MatterBody>

Either a single Body, or an array of bodies to update. If falsey it will use all bodies in the world.
x number

The horizontal linear velocity value.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 1102)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

setVelocityY(bodies, y)

Sets just the vertical linear velocity of the physics bodies. The horizontal velocity of the body is unchanged.

Parameters:
Name Type Description
bodies Phaser.Types.Physics.Matter.MatterBody | Array.<Phaser.Types.Physics.Matter.MatterBody>

Either a single Body, or an array of bodies to update. If falsey it will use all bodies in the world.
y number

The vertical linear velocity value.
Since: 3.22.0
Source: src/physics/matter-js/MatterPhysics.js (Line 1131)
Returns:

This Matter Physics instance.

Type
Phaser.Physics.Matter.MatterPhysics

step( [delta] [, correction])

Manually advances the physics simulation by one iteration.

You can optionally pass in the delta and correction values to be used by Engine.update. If undefined they use the Matter defaults of 60Hz and no correction.

Calling step directly bypasses any checks of enabled or autoUpdate.

It also ignores any custom getDelta functions, as you should be passing the delta value in to this call.

You can adjust the number of iterations that Engine.update performs internally. Use the Scene Matter Physics config object to set the following properties:

positionIterations (defaults to 6) velocityIterations (defaults to 4) constraintIterations (defaults to 2)

Adjusting these values can help performance in certain situations, depending on the physics requirements of your game.

Parameters:
Name Type Argument Default Description
delta number <optional>
 16.666

The delta value.
correction number <optional>
 1

Optional delta correction value.
Since: 3.4.0
Source: src/physics/matter-js/MatterPhysics.js (Line 640)