World

The Arcade Physics world. Contains Arcade Physics related collision, overlap and motion methods.

Instance Members #

The World gravity X setting. Defaults to 0 (no gravity).

The World gravity Y setting. Defaults to 0 (no gravity).

The bounds x position inside of which the physics world exists.

The bounds y position inside of which the physics world exists.

The bounds width inside of which the physics world exists.

The bounds height inside of which the physics world exists.

Which edges of the World bounds Bodies can collide against when collideWorldBounds is true. For example checkCollisionDown = false means Bodies cannot collide with the World.bounds.bottom.

Whether Bodies can collide with the World upper bounds.

Whether Bodies can collide with the World lower bounds.

Whether Bodies can collide with the World left bounds.

Whether Bodies can collide with the World right bounds.

Used by the QuadTree to set the maximum number of objects per quad.

Used by the QuadTree to set the maximum number of iteration levels.

A value added to the delta values during collision checks. Increase it to prevent sprite tunneling.

If true World.separate will always separate on the X axis before Y. Otherwise it will check gravity totals first.

Used when colliding a Body vs. a Group, or a Group vs. a Group, this defines the direction the sort is based on. Default is LEFT_RIGHT.

If true the QuadTree will not be used for any collision. QuadTrees are great if objects are well spread out in your game, otherwise they are a performance hit. If you enable this you can disable on a per body basis via Body.skipQuadTree.

If true the Body.preUpdate method will be skipped, halting all motion for all bodies. Note that other methods such as collide will still work, so be careful not to call them on paused bodies.

When colliding/overlapping with groups. Use a quad tree if we reach this threshold value

A value added to the delta values during collision with tiles. Adjust this if you get tunneling.

Elapsed time since last tick.

Get a QuadTree object configured for this world. IMPORTANT: you must release it with releaseQuadTree() when you are done using it and the items it returned.

Updates the size of this physics world.

Creates an Arcade 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.

When you add an Arcade Physics body to an object it will automatically add the object into its parent Groups hash array.

Called automatically by a Physics body, it updates all motion related values on the Body unless World.isPaused is true.

A tween-like function that takes a starting velocity and some other factors and returns an altered velocity. Based on a function in Flixel by @ADAMATOMIC

Checks for overlaps between two bodies. The objects can be Bodies or Groups. Unlike collide the objects are NOT automatically separated or have any physics applied, they merely test for overlap results.

Checks for collision between two bodies and separates them if colliding. If you don't require separation then use overlap instead.

This method will sort a Groups hash array.

If the Group has sortDirection set it will use the sort direction defined.

Otherwise if the sortDirection parameter is undefined, or Group.sortDirection is null, it will use World.sortDirection.

By changing Group.sortDirection you can customise each Group to sort in a different order.

Check for intersection against two bodies.

Given a Group and a location this will check to see which Group children overlap with the coordinates. Each child will be sent to the given callback for further processing. Note that the children are not checked for depth order, but simply if they overlap the coordinate or not.

Move the given body towards the destination body at a steady velocity. If you specify a maxTime then it will adjust the speed (overwriting what you set) so it arrives at the destination in that number of seconds. Timings are approximate due to the way browser timers work. Allow for a variance of +- 50ms. Note: The body does not continuously track the target. If the target changes location during transit the body will not modify its course. Note: The body doesn't stop moving once it reaches the destination coordinates. Note: Doesn't take into account acceleration, maxVelocity or drag (if you've set drag or acceleration too high this object may not move at all)

Move the given body towards the x/y coordinates at a steady velocity. If you specify a maxTime then it will adjust the speed (over-writing what you set) so it arrives at the destination in that number of seconds. Timings are approximate due to the way browser timers work. Allow for a variance of +- 50ms. Note: The body does not continuously track the target. If the target changes location during transit the body will not modify its course. Note: The body doesn't stop moving once it reaches the destination coordinates. Note: Doesn't take into account acceleration, maxVelocity or drag (if you've set drag or acceleration too high this object may not move at all)

Given the angle (in degrees) and speed calculate the velocity and return it as a Point object, or set it to the given point object. One way to use this is: velocityFromAngle(angle, 200, point) which will set the values directly to the point and not create a new Point object.

Given the rotation (in radians) and speed calculate the velocity and return it as a Point object, or set it to the given point object. One way to use this is: velocityFromRotation(rotation, 200, point) which will set the values directly to the point and not create a new Point object.

Given the rotation (in radians) and speed calculate the acceleration and return it as a Point object, or set it to the given point object. One way to use this is: accelerationFromRotation(rotation, 200, point) which will set the values directly to the point and not create a new Point object.

Sets the acceleration.x/y property on the body so it will move towards the target at the given speed (in pixels per second sq.) You must give a maximum speed value, beyond which the body won't go any faster. Note: The body does not continuously track the target. If the target changes location during transit the body will not modify its course. Note: The body doesn't stop moving once it reaches the destination coordinates.

Sets the acceleration.x/y property on the body so it will move towards the x/y coordinates at the given speed (in pixels per second sq.) You must give a maximum speed value, beyond which the body won't go any faster. Note: The body does not continuously track the target. If the target changes location during transit the body will not modify its course. Note: The body doesn't stop moving once it reaches the destination coordinates.

Find the distance between two bodies.

If objects aren't nested or they share a parent's offset, you can calculate the distance between their centers with the useCenter argument.

Find the distance between a body and the given x/y coordinates. The calculation is made from the body's x/y coordinate. This may be the top-left. If you need to calculate from the center of a body instead use distanceBetween with the useCenter argument.

From a set of bodies, find the one closest to a source body.

From a set of bodies, find the one farthest from a source body.

Find the angle in radians between two bodies.

Find the angle in radians between centers of two bodies.

Find the angle in radians between a body and the given x/y coordinate.

Private Members #

The world QuadTree objects.

A shared internal pool used by every QuadTree.

The core separation function to separate two physics bodies.

Checks to see if a circular Body intersects with a Rectangular Body.

The core separation function to separate two circular physics bodies.

Calculates the horizontal overlap between two Bodies and sets their properties accordingly, including: touchingLeft, touchingRight and overlapX.

Calculates the vertical overlap between two Bodies and sets their properties accordingly, including: touchingUp, touchingDown and overlapY.

The core separation function to separate two physics bodies on the x axis.

The core separation function to separate two physics bodies on the y axis.