Body

Instance Constructors

new Body(sprite: Phaser.Sprite)

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
var acceleration: Phaser.Point

The acceleration is the rate of change of the velocity.
The acceleration is the rate of change of the velocity. Measured in pixels per second squared.
var allowGravity: Boolean

Allow this Body to be influenced by gravity? Either world or local.
var allowRotation: Boolean

Allow this Body to be rotated? (via angularVelocity, etc)
def angle: Double

The angle of the Body's velocity in radians.
var angularAcceleration: Double

The angular acceleration is the rate of change of the angular velocity.
The angular acceleration is the rate of change of the angular velocity. Measured in degrees per second squared.
var angularDrag: Double

The drag applied during the rotation of the Body.
The drag applied during the rotation of the Body. Measured in degrees per second squared.
var angularVelocity: Double

The angular velocity controls the rotation speed of the Body.
The angular velocity controls the rotation speed of the Body. It is measured in degrees per second.
final def asInstanceOf[T0]: T0

Definition Classes
Any
var blocked: Any

This object is populated with boolean values when the Body collides with the World bounds or a Tile.
This object is populated with boolean values when the Body collides with the World bounds or a Tile. For example if blocked.up is true then the Body cannot move up. An object containing on which faces this Body is blocked from moving, if any.
def bottom: Double

The bottom value of this Body (same as Body.y + Body.height)
var bounce: Phaser.Point

The elasticity of the Body when colliding.
The elasticity of the Body when colliding. bounce.x/y = 1 means full rebound, bounce.x/y = 0.5 means 50% rebound velocity.
def center: Phaser.Point

The center coordinate of the Physics Body.
var checkCollision: Any

Set the checkCollision properties to control which directions collision is processed for this Body.
Set the checkCollision properties to control which directions collision is processed for this Body. For example checkCollision.up = false means it won't collide when the collision happened while moving up. If you need to disable a Body entirely, use body.enable = false, this will also disable motion. If you need to disable just collision and/or overlap checks, but retain motion, set checkCollision.none = true. An object containing allowed collision.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
var collideWorldBounds: Boolean

A Body can be set to collide against the World bounds automatically and rebound back into the World if this is set to true.
A Body can be set to collide against the World bounds automatically and rebound back into the World if this is set to true. Otherwise it will leave the World. Should the Body collide with the World bounds?
var customSeparateX: Boolean

This flag allows you to disable the custom x separation that takes place by Physics.Arcade.separate.
This flag allows you to disable the custom x separation that takes place by Physics.Arcade.separate. Used in combination with your own collision processHandler you can create whatever type of collision response you need. Use a custom separation system or the built-in one?
var customSeparateY: Boolean

This flag allows you to disable the custom y separation that takes place by Physics.Arcade.separate.
This flag allows you to disable the custom y separation that takes place by Physics.Arcade.separate. Used in combination with your own collision processHandler you can create whatever type of collision response you need. Use a custom separation system or the built-in one?
var deltaMax: Phaser.Point

The Sprite position is updated based on the delta x/y values.
The Sprite position is updated based on the delta x/y values. You can set a cap on those (both +-) using deltaMax.
var dirty: Boolean

If this Body in a preUpdate (true) or postUpdate (false) state?
var drag: Phaser.Point

The drag applied to the motion of the Body.
var embedded: Boolean

If a body is overlapping with another body, but neither of them are moving (maybe they spawned on-top of each other?) this is set to true.
If a body is overlapping with another body, but neither of them are moving (maybe they spawned on-top of each other?) this is set to true. Body embed value.
var enable: Boolean

A disabled body won't be checked for any form of collision or overlap or have its pre/post updates run.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
var facing: Int

A const reference to the direction the Body is traveling or facing.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
var friction: Phaser.Point

The amount of movement that will occur if another object 'rides' this one.
var game: Phaser.Game

Local reference to game.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
var gravity: Phaser.Point

A local gravity applied to this Body.
A local gravity applied to this Body. If non-zero this over rides any world gravity, unless Body.allowGravity is set to false.
def halfHeight: Double

The calculated height / 2 of the physics body.
def halfWidth: Double

The calculated width / 2 of the physics body.
def hasOwnProperty(v: String): Boolean

Definition Classes
Object
def hashCode(): Int

Definition Classes
AnyRef → Any
def height: Double

The calculated height of the physics body.
def immovable: Boolean

An immovable Body will not receive any impacts from other bodies.
def isCircle: Boolean

If true this Body is using circular collision detection.
If true this Body is using circular collision detection. If false it is using rectangular. Use Body.setCircle to control the collision shape this Body uses.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
var isMoving: Boolean

Set by the moveTo and moveFrom methods.
def isPrototypeOf(v: Object): Boolean

Definition Classes
Object
var left: Double

The x position of the Body.
The x position of the Body. The same as Body.x.
var mass: Double

The mass of the Body.
The mass of the Body. When two bodies collide their mass is used in the calculation to determine the exchange of velocity (default: 1).
var maxAngular: Double

The maximum angular velocity in degrees per second that the Body can reach.
var maxVelocity: Phaser.Point

The maximum velocity in pixels per second sq.
The maximum velocity in pixels per second sq. that the Body can reach.
var movementCallback: Function

Optional callback.
Optional callback. If set, invoked during the running of moveTo or moveFrom events.
var movementCallbackContext: Object

Context in which to call the movementCallback.
var moves: Boolean

If you have a Body that is being moved around the world via a tween or a Group motion, but its local x/y position never actually changes, then you should set Body.moves = false.
If you have a Body that is being moved around the world via a tween or a Group motion, but its local x/y position never actually changes, then you should set Body.moves = false. Otherwise it will most likely fly off the screen.
If you want the physics system to move the body around, then set moves to true. Set to true to allow the Physics system to move this Body, otherwise false to move it manually.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newVelocity: Phaser.Point

The new velocity.
The new velocity. Calculated during the Body.preUpdate and applied to its position.
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
var offset: Phaser.Point

The offset of the Physics Body from the Sprite x/y position.
var onCollide: Phaser.Signal

A Signal that is dispatched when this Body collides with another Body.
A Signal that is dispatched when this Body collides with another Body. * You still need to call game.physics.arcade.collide in your update method in order for this signal to be dispatched. * Usually you'd pass a callback to the collide method, but this signal provides for a different level of notification. * Due to the potentially high volume of signals this could create it is disabled by default. * To use this feature set this property to a Phaser.Signal:
```
sprite.body.onCollide = new Phaser.Signal()
```
and it will be called when a collision happens, passing two arguments: the sprites which collided. The first sprite in the argument is always the owner of this Body. * If two Bodies with this Signal set collide, both will dispatch the Signal.
var onMoveComplete: Phaser.Signal

Listen for the completion of moveTo or moveFrom events.
var onOverlap: Phaser.Signal

A Signal that is dispatched when this Body overlaps with another Body.
A Signal that is dispatched when this Body overlaps with another Body.
You still need to call game.physics.arcade.overlap in your update method in order for this signal to be dispatched.
Usually you'd pass a callback to the overlap method, but this signal provides for a different level of notification.
Due to the potentially high volume of signals this could create it is disabled by default.
To use this feature set this property to a Phaser.Signal: sprite.body.onOverlap = new Phaser.Signal() and it will be called when a collision happens, passing two arguments: the sprites which collided. The first sprite in the argument is always the owner of this Body.
If two Bodies with this Signal set collide, both will dispatch the Signal.
var onWorldBounds: Phaser.Signal

A Signal that is dispatched when this Body collides with the world bounds.
A Signal that is dispatched when this Body collides with the world bounds. Due to the potentially high volume of signals this could create it is disabled by default. To use this feature set this property to a Phaser.Signal:
```
sprite.body.onWorldBounds = new Phaser.Signal()
```
and it will be called when a collision happens, passing five arguments:
```
onWorldBounds(sprite, up, down, left, right)
```
where the Sprite is a reference to the Sprite that owns this Body, and the other arguments are booleans indicating on which side of the world the Body collided.
var overlapR: Double

If Body.isCircle is true, and this body collides with another circular body, the amount of overlap is stored here.
If Body.isCircle is true, and this body collides with another circular body, the amount of overlap is stored here. The amount of overlap during the collision.
var overlapX: Double

When this body collides with another, the amount of overlap is stored here.
When this body collides with another, the amount of overlap is stored here. The amount of horizontal overlap during the collision.
var overlapY: Double

When this body collides with another, the amount of overlap is stored here.
When this body collides with another, the amount of overlap is stored here. The amount of vertical overlap during the collision.
def position: Phaser.Point

The position of the physics body.
def preRotation: Double

The previous rotation of the physics body.
def prev: Phaser.Point

The previous position of the physics body.
def propertyIsEnumerable(v: String): Boolean

Definition Classes
Object
def radius: Double

The radius of the circular collision shape this Body is using if Body.setCircle has been enabled.
The radius of the circular collision shape this Body is using if Body.setCircle has been enabled. If you wish to change the radius then call setCircle again with the new value. If you wish to stop the Body using a circle then call setCircle with a radius of zero (or undefined).
def right: Double

The right value of this Body (same as Body.x + Body.width)
def rotation: Double

The Body's rotation in degrees, as calculated by its angularVelocity and angularAcceleration.
The Body's rotation in degrees, as calculated by its angularVelocity and angularAcceleration. Please understand that the collision Body
itself never rotates, it is always axis-aligned. However these values are passed up to the parent Sprite and updates its rotation.
var skipQuadTree: Boolean

If true and you collide this Sprite against a Group, it will disable the collision check from using a QuadTree.
def sourceHeight: Double

The un-scaled original size.
def sourceWidth: Double

The un-scaled original size.
def speed: Double

The speed of the Body as calculated by its velocity.
val sprite: Phaser.Sprite
var stopVelocityOnCollide: Boolean

Set by the moveTo and moveFrom methods.
var syncBounds: Boolean

If true the Body will check itself against the Sprite.getBounds() dimensions and adjust its width and height accordingly.
If true the Body will check itself against the Sprite.getBounds() dimensions and adjust its width and height accordingly. If false it will compare its dimensions against the Sprite scale instead, and adjust its width height if the scale has changed. Typically you would need to enable syncBounds if your sprite is the child of a responsive display object such as a FlexLayer, or in any situation where the Sprite scale doesn't change, but its parents scale is effecting the dimensions regardless.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
var tilePadding: Phaser.Point

If this is an especially small or fast moving object then it can sometimes skip over tilemap collisions if it moves through a tile in a step.
If this is an especially small or fast moving object then it can sometimes skip over tilemap collisions if it moves through a tile in a step.
Set this padding value to add extra padding to its bounds. tilePadding.x applied to its width, y to its height. Extra padding to be added to this sprite's dimensions when checking for tile collision.
def toLocaleString(): String

Definition Classes
Object
def toString(): String

Definition Classes
AnyRef → Any
var top: Double

The y position of the Body.
The y position of the Body. The same as Body.y.
var touching: Object

This object is populated with boolean values when the Body collides with another.
This object is populated with boolean values when the Body collides with another. touching.up = true means the collision happened to the top of this Body for example. An object containing touching results.
var type: Int

The type of physics system this body belongs to.
def valueOf(): Any

Definition Classes
Object
var velocity: Point

The velocity, or rate of change in speed of the Body.
The velocity, or rate of change in speed of the Body. Measured in pixels per second.
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
var wasTouching: Object

This object is populated with previous touching values from the bodies previous collision.
This object is populated with previous touching values from the bodies previous collision. An object containing previous touching results.
def width: Double

The calculated width of the physics body.
var worldBounce: Phaser.Point

The elasticity of the Body when colliding with the World bounds.
The elasticity of the Body when colliding with the World bounds. By default this property is null, in which case Body.bounce is used instead. Set this property to a Phaser.Point object in order to enable a World bounds specific bounce value.
var x: Double

The x position.
var y: Double

The y position.

Related Doc: package arcade

class Body extends Object

Instance Constructors

new Body(sprite: Phaser.Sprite)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var acceleration: Phaser.Point

var allowGravity: Boolean

var allowRotation: Boolean

def angle: Double

var angularAcceleration: Double

var angularDrag: Double

var angularVelocity: Double

final def asInstanceOf[T0]: T0

var blocked: Any

def bottom: Double

var bounce: Phaser.Point

def center: Phaser.Point

var checkCollision: Any

def clone(): AnyRef

var collideWorldBounds: Boolean

var customSeparateX: Boolean

var customSeparateY: Boolean

var deltaMax: Phaser.Point

var dirty: Boolean

var drag: Phaser.Point

var embedded: Boolean

var enable: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

var facing: Int

def finalize(): Unit

var friction: Phaser.Point

var game: Phaser.Game

final def getClass(): Class[_]

var gravity: Phaser.Point

def halfHeight: Double

def halfWidth: Double

def hasOwnProperty(v: String): Boolean

def hashCode(): Int

def height: Double

def immovable: Boolean

def isCircle: Boolean

final def isInstanceOf[T0]: Boolean

var isMoving: Boolean

def isPrototypeOf(v: Object): Boolean

var left: Double

var mass: Double

var maxAngular: Double

var maxVelocity: Phaser.Point

var movementCallback: Function

var movementCallbackContext: Object

var moves: Boolean

final def ne(arg0: AnyRef): Boolean

def newVelocity: Phaser.Point

final def notify(): Unit

final def notifyAll(): Unit

var offset: Phaser.Point

var onCollide: Phaser.Signal

var onMoveComplete: Phaser.Signal

var onOverlap: Phaser.Signal

var onWorldBounds: Phaser.Signal

var overlapR: Double

var overlapX: Double

var overlapY: Double

def position: Phaser.Point

def preRotation: Double

def prev: Phaser.Point

def propertyIsEnumerable(v: String): Boolean

def radius: Double

def right: Double

def rotation: Double

var skipQuadTree: Boolean

def sourceHeight: Double

def sourceWidth: Double

def speed: Double

val sprite: Phaser.Sprite