/**

* @author Richard Davey <rich@photonstorm.com>

* @copyright 2018 Photon Storm Ltd.

* @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}

*/

var CircleContains = require('../../geom/circle/Contains');

var Class = require('../../utils/Class');

var CONST = require('./const');

var RadToDeg = require('../../math/RadToDeg');

var Rectangle = require('../../geom/rectangle/Rectangle');

var RectangleContains = require('../../geom/rectangle/Contains');

var TransformMatrix = require('../../gameobjects/components/TransformMatrix');

var Vector2 = require('../../math/Vector2');

/**

* @typedef {object} ArcadeBodyBounds

*

* @property {number} x - The left edge.

* @property {number} y - The upper edge.

* @property {number} right - The right edge.

* @property {number} bottom - The lower edge.

*/

/**

* @typedef {object} ArcadeBodyCollision

*

* @property {boolean} none - True if the Body is not colliding.

* @property {boolean} up - True if the Body is colliding on its upper edge.

* @property {boolean} down - True if the Body is colliding on its lower edge.

* @property {boolean} left - True if the Body is colliding on its left edge.

* @property {boolean} right - True if the Body is colliding on its right edge.

*/

/**

* @classdesc

* A Dynamic Arcade Body.

*

* @class Body

* @memberOf Phaser.Physics.Arcade

* @constructor

* @since 3.0.0

*

* @param {Phaser.Physics.Arcade.World} world - The Arcade Physics simulation this Body belongs to.

* @param {Phaser.GameObjects.GameObject} gameObject - The Game Object this Body belongs to.

*/

var Body = new Class({

initialize:

function Body (world, gameObject)

{

var width = (gameObject.width) ? gameObject.width : 64;

var height = (gameObject.height) ? gameObject.height : 64;

/**

* The Arcade Physics simulation this Body belongs to.

*

* @name Phaser.Physics.Arcade.Body#world

* @type {Phaser.Physics.Arcade.World}

* @since 3.0.0

*/

this.world = world;

/**

* The Game Object this Body belongs to.

*

* @name Phaser.Physics.Arcade.Body#gameObject

* @type {Phaser.GameObjects.GameObject}

* @since 3.0.0

*/

this.gameObject = gameObject;

/**

* Transformations applied to this Body.

*

* @name Phaser.Physics.Arcade.Body#transform

* @type {object}

* @since 3.4.0

*/

this.transform = {

x: gameObject.x,

y: gameObject.y,

rotation: gameObject.angle,

scaleX: gameObject.scaleX,

scaleY: gameObject.scaleY,

displayOriginX: gameObject.displayOriginX,

displayOriginY: gameObject.displayOriginY

};

/**

* Whether the Body's boundary is drawn to the debug display.

*

* @name Phaser.Physics.Arcade.Body#debugShowBody

* @type {boolean}

* @since 3.0.0

*/

this.debugShowBody = world.defaults.debugShowBody;

/**

* Whether the Body's velocity is drawn to the debug display.

*

* @name Phaser.Physics.Arcade.Body#debugShowVelocity

* @type {boolean}

* @since 3.0.0

*/

this.debugShowVelocity = world.defaults.debugShowVelocity;

/**

* The color of this Body on the debug display.

*

* @name Phaser.Physics.Arcade.Body#debugBodyColor

* @type {integer}

* @since 3.0.0

*/

this.debugBodyColor = world.defaults.bodyDebugColor;

/**

* Whether this Body is updated by the physics simulation.

*

* @name Phaser.Physics.Arcade.Body#enable

* @type {boolean}

* @default true

* @since 3.0.0

*/

this.enable = true;

/**

* Whether this Body's boundary is circular (true) or rectangular (false).

*

* @name Phaser.Physics.Arcade.Body#isCircle

* @type {boolean}

* @default false

* @since 3.0.0

* @see Phaser.Physics.Arcade.Body#setCircle

*/

this.isCircle = false;

/**

* The unscaled radius of this Body's boundary (if circular), as set by setCircle, in source pixels.

* The true radius (if circular) is equal to halfWidth.

*

* @name Phaser.Physics.Arcade.Body#radius

* @type {number}

* @default 0

* @since 3.0.0

* @see Phaser.Physics.Arcade.Body#setCircle

*/

this.radius = 0;

/**

* The offset of this Body's position from its Game Object's position, in source pixels.

*

* @name Phaser.Physics.Arcade.Body#offset

* @type {Phaser.Math.Vector2}

* @since 3.0.0

* @see Phaser.Physics.Arcade.Body#setOffset

*/

this.offset = new Vector2();

/**

* The position of this Body within the simulation.

*

* @name Phaser.Physics.Arcade.Body#position

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.position = new Vector2(gameObject.x, gameObject.y);

/**

* The position of this Body during the previous step.

*

* @name Phaser.Physics.Arcade.Body#prev

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.prev = new Vector2(gameObject.x, gameObject.y);

/**

* Whether this Body's rotation is affected by its angular acceleration and velocity.

*

* @name Phaser.Physics.Arcade.Body#allowRotation

* @type {boolean}

* @default true

* @since 3.0.0

*/

this.allowRotation = true;

/**

* This body's rotation, in degrees, based on its angular acceleration and velocity.

* The Body's rotation controls the `angle` of its Game Object.

* It doesn't rotate the Body's boundary, which is always an axis-aligned rectangle or a circle.

*

* @name Phaser.Physics.Arcade.Body#rotation

* @type {number}

* @since 3.0.0

*/

this.rotation = gameObject.angle;

/**

* The Body's rotation, in degrees, during the previous step.

*

* @name Phaser.Physics.Arcade.Body#preRotation

* @type {number}

* @since 3.0.0

*/

this.preRotation = gameObject.angle;

/**

* The width of the Body's boundary. If circular, this is also the Body's diameter.

*

* @name Phaser.Physics.Arcade.Body#width

* @type {number}

* @default 64

* @since 3.0.0

*/

this.width = width;

/**

* The height of the Body's boundary. If circular, this is also the Body's diameter.

*

* @name Phaser.Physics.Arcade.Body#height

* @type {number}

* @default 64

* @since 3.0.0

*/

this.height = height;

/**

* The unscaled width of the Body, in source pixels. The default is the width of the Body's Game Object's texture frame.

*

* @name Phaser.Physics.Arcade.Body#sourceWidth

* @type {number}

* @since 3.0.0

* @see Phaser.Physics.Arcade.Body#setSize

*/

this.sourceWidth = width;

/**

* The unscaled height of the Body, in source pixels. The default is the height of the Body's Game Object's texture frame.

*

* @name Phaser.Physics.Arcade.Body#sourceHeight

* @type {number}

* @since 3.0.0

* @see Phaser.Physics.Arcade.Body#setSize

*/

this.sourceHeight = height;

if (gameObject.frame)

{

this.sourceWidth = gameObject.frame.realWidth;

this.sourceHeight = gameObject.frame.realHeight;

}

/**

* Half the Body's width.

*

* @name Phaser.Physics.Arcade.Body#halfWidth

* @type {number}

* @since 3.0.0

*/

this.halfWidth = Math.abs(width / 2);

/**

* Half the Body's height.

*

* @name Phaser.Physics.Arcade.Body#halfHeight

* @type {number}

* @since 3.0.0

*/

this.halfHeight = Math.abs(height / 2);

/**

* The center of the Body's boundary. The midpoint of its `position` (top-left corner) and its bottom-right corner.

*

* @name Phaser.Physics.Arcade.Body#center

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.center = new Vector2(gameObject.x + this.halfWidth, gameObject.y + this.halfHeight);

/**

* The Body's change in position, in pixels per second.

*

* @name Phaser.Physics.Arcade.Body#velocity

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.velocity = new Vector2();

/**

* The Body's calculated change in position, in pixels, at the last step.

*

* @name Phaser.Physics.Arcade.Body#newVelocity

* @type {Phaser.Math.Vector2}

* @readOnly

* @since 3.0.0

*/

this.newVelocity = new Vector2();

/**

* The Body's absolute maximum change in position, in pixels per step.

*

* @name Phaser.Physics.Arcade.Body#deltaMax

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.deltaMax = new Vector2();

/**

* The Body's change in velocity, in pixels per second squared.

*

* @name Phaser.Physics.Arcade.Body#acceleration

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.acceleration = new Vector2();

/**

* Whether this Body's velocity is affected by its drag vector.

*

* @name Phaser.Physics.Arcade.Body#allowDrag

* @type {boolean}

* @default true

* @since 3.0.0

*/

this.allowDrag = true;

/**

* Absolute loss of velocity due to movement, in pixels per second squared.

*

* @name Phaser.Physics.Arcade.Body#drag

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.drag = new Vector2();

/**

* Whether this Body's position is affected by its gravity vector.

*

* @name Phaser.Physics.Arcade.Body#allowGravity

* @type {boolean}

* @default true

* @since 3.0.0

*/

this.allowGravity = true;

/**

* Acceleration due to gravity (specific to this Body), in pixels per second squared.

* Total gravity is the sum of this vector and the simulation's `gravity`.

*

* @name Phaser.Physics.Arcade.Body#gravity

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.gravity = new Vector2();

/**

* Rebound following a collision, relative to 1.

*

* @name Phaser.Physics.Arcade.Body#bounce

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.bounce = new Vector2();

/**

* Rebound following a collision with the world boundary, relative to 1.

* If empty, `bounce` is used instead.

*

* @name Phaser.Physics.Arcade.Body#worldBounce

* @type {?Phaser.Math.Vector2}

* @default null

* @since 3.0.0

*/

this.worldBounce = null;

// If true this Body will dispatch events

/**

* Whether the simulation emits a `worldbounds` event when this Body collides with the world boundary (and `collideWorldBounds` is also true).

*

* @name Phaser.Physics.Arcade.Body#onWorldBounds

* @type {boolean}

* @default false

* @since 3.0.0

* @see Phaser.Physics.Arcade.World#event:worldbounds

*/

this.onWorldBounds = false;

/**

* Whether the simulation emits a `collide` event when this Body collides with another.

*

* @name Phaser.Physics.Arcade.Body#onCollide

* @type {boolean}

* @default false

* @since 3.0.0

* @see Phaser.Physics.Arcade.World#event:collide

*/

this.onCollide = false;

/**

* Whether the simulation emits an `overlap` event when this Body overlaps with another.

*

* @name Phaser.Physics.Arcade.Body#onOverlap

* @type {boolean}

* @default false

* @since 3.0.0

* @see Phaser.Physics.Arcade.World#event:overlap

*/

this.onOverlap = false;

/**

* The Body's absolute maximum velocity.

*

* This limits the Body's rate of movement but not its `velocity` values (which can still exceed `maxVelocity`).

*

* @name Phaser.Physics.Arcade.Body#maxVelocity

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.maxVelocity = new Vector2(10000, 10000);

/**

* If this Body is `immovable` and in motion, this the proportion of this Body's movement received by the riding body on each axis, relative to 1.

* The default value (1, 0) moves the riding body horizontally in equal proportion and vertically not at all.

*

* @name Phaser.Physics.Arcade.Body#friction

* @type {Phaser.Math.Vector2}

* @since 3.0.0

*/

this.friction = new Vector2(1, 0);

/**

* If this Body is using `drag` for deceleration this property controls how the drag is applied.

* If set to `true` drag will use a damping effect rather than a linear approach. If you are

* creating a game where the Body moves freely at any angle (i.e. like the way the ship moves in

* the game Asteroids) then you will get a far smoother and more visually correct deceleration

* by using damping, avoiding the axis-drift that is prone with linear deceleration.

*

* If you enable this property then you should use far smaller `drag` values than with linear, as

* they are used as a multiplier on the velocity. Values such as 0.95 will give a nice slow

* deceleration, where-as smaller values, such as 0.5 will stop an object almost immediately.

*

* @name Phaser.Physics.Arcade.Body#useDamping

* @type {boolean}

* @default false

* @since 3.10.0

*/

this.useDamping = false;

/**

* The rate of change of this Body's rotation, in degrees per second.

*

* @name Phaser.Physics.Arcade.Body#angularVelocity

* @type {number}

* @default 0

* @since 3.0.0

*/

this.angularVelocity = 0;

/**

* The rate of change of this Body's angular velocity, in degrees per second squared.

*

* @name Phaser.Physics.Arcade.Body#angularAcceleration

* @type {number}

* @default 0

* @since 3.0.0

*/

this.angularAcceleration = 0;

/**

* Loss of angular velocity due to angular movement, in degrees per second.

*

* @name Phaser.Physics.Arcade.Body#angularDrag

* @type {number}

* @default 0

* @since 3.0.0

*/

this.angularDrag = 0;

/**

* The Body's maximum angular velocity, in degrees per second.

*

* @name Phaser.Physics.Arcade.Body#maxAngular

* @type {number}

* @default 1000

* @since 3.0.0

*/

this.maxAngular = 1000;

/**

* The Body's inertia, relative to a default unit (1).

* With `bounce`, this affects the exchange of momentum (velocities) during collisions.

*

* @name Phaser.Physics.Arcade.Body#mass

* @type {number}

* @default 1

* @since 3.0.0

*/

this.mass = 1;

/**

* The angle of this Body's velocity vector, in degrees.

*

* @name Phaser.Physics.Arcade.Body#angle

* @type {number}

* @default 0

* @since 3.0.0

*/

this.angle = 0;

/**

* The magnitude of the Body's velocity, as calculated during the last update.

*

* @name Phaser.Physics.Arcade.Body#speed

* @type {number}

* @default 0

* @since 3.0.0

*/

this.speed = 0;

/**

* The calculated direction of the Body's velocity.

*

* @name Phaser.Physics.Arcade.Body#facing

* @type {integer}

* @since 3.0.0

*/

this.facing = CONST.FACING_NONE;

/**

* Whether this object can be moved by collisions with another body.

*

* @name Phaser.Physics.Arcade.Body#immovable

* @type {boolean}

* @default false

* @since 3.0.0

*/

this.immovable = false;

/**

* Whether the Body's position and rotation are affected by its velocity, acceleration, drag, and gravity.

*

* @name Phaser.Physics.Arcade.Body#moves

* @type {boolean}

* @default true

* @since 3.0.0

*/

this.moves = true;

/**

* A flag disabling the default horizontal separation of colliding bodies. Pass your own `processHandler` to the collider.

*

* @name Phaser.Physics.Arcade.Body#customSeparateX

* @type {boolean}

* @default false

* @since 3.0.0

*/

this.customSeparateX = false;

/**

* A flag disabling the default vertical separation of colliding bodies. Pass your own `processHandler` to the collider.

*

* @name Phaser.Physics.Arcade.Body#customSeparateY

* @type {boolean}

* @default false

* @since 3.0.0

*/

this.customSeparateY = false;

/**

* The amount of horizontal overlap (before separation), if this Body is colliding with another.

*

* @name Phaser.Physics.Arcade.Body#overlapX

* @type {number}

* @default 0

* @since 3.0.0

*/

this.overlapX = 0;

/**

* The amount of vertical overlap (before separation), if this Body is colliding with another.

*

* @name Phaser.Physics.Arcade.Body#overlapY

* @type {number}

* @default 0

* @since 3.0.0

*/

this.overlapY = 0;

/**

* The amount of overlap (before separation), if this Body is circular and colliding with another circular body.

*

* @name Phaser.Physics.Arcade.Body#overlapR

* @type {number}

* @default 0

* @since 3.0.0

*/

this.overlapR = 0;

/**

* Whether this Body is overlapped with another and both have zero velocity.

*

* @name Phaser.Physics.Arcade.Body#embedded

* @type {boolean}

* @default false

* @since 3.0.0

*/

this.embedded = false;

/**

* Whether this Body interacts with the world boundary.

*

* @name Phaser.Physics.Arcade.Body#collideWorldBounds

* @type {boolean}

* @default false

* @since 3.0.0

*/

this.collideWorldBounds = false;

/**

* Whether this Body is checked for collisions and for which directions.

* You can set `checkCollision.none = false` to disable collision checks.

*

* @name Phaser.Physics.Arcade.Body#checkCollision

* @type {ArcadeBodyCollision}

* @since 3.0.0

*/

this.checkCollision = { none: false, up: true, down: true, left: true, right: true };

/**

* Whether this Body is colliding with another and in which direction.

*

* @name Phaser.Physics.Arcade.Body#touching

* @type {ArcadeBodyCollision}

* @since 3.0.0

*/

this.touching = { none: true, up: false, down: false, left: false, right: false };

/**

* Whether this Body was colliding with another during the last step, and in which direction.

*

* @name Phaser.Physics.Arcade.Body#wasTouching

* @type {ArcadeBodyCollision}

* @since 3.0.0

*/

this.wasTouching = { none: true, up: false, down: false, left: false, right: false };

/**

* Whether this Body is colliding with a tile or the world boundary.

*

* @name Phaser.Physics.Arcade.Body#blocked

* @type {ArcadeBodyCollision}

* @since 3.0.0

*/

this.blocked = { none: true, up: false, down: false, left: false, right: false };

/**

* Whether to automatically synchronize this Body's dimensions to the dimensions of its Game Object's visual bounds.

*

* @name Phaser.Physics.Arcade.Body#syncBounds

* @type {boolean}

* @default false

* @since 3.0.0

* @see Phaser.GameObjects.Components.GetBounds#getBounds

*/

this.syncBounds = false;

/**

* Whether this Body is being moved by the `moveTo` or `moveFrom` methods.

*

* @name Phaser.Physics.Arcade.Body#isMoving

* @type {boolean}

* @default false

* @since 3.0.0

*/

this.isMoving = false;

/**

* Whether this Body's movement by `moveTo` or `moveFrom` will be stopped by collisions with other bodies.

*

* @name Phaser.Physics.Arcade.Body#stopVelocityOnCollide

* @type {boolean}

* @default true

* @since 3.0.0

*/

this.stopVelocityOnCollide = true;

// read-only

/**

* The Body's physics type (dynamic or static).

*

* @name Phaser.Physics.Arcade.Body#physicsType

* @type {integer}

* @readOnly

* @since 3.0.0

*/

this.physicsType = CONST.DYNAMIC_BODY;

/**

* Whether the Body's position needs updating from its Game Object.

*

* @name Phaser.Physics.Arcade.Body#_reset

* @type {boolean}

* @private

* @default true

* @since 3.0.0

*/

this._reset = true;

/**

* Cached horizontal scale of the Body's Game Object.

*

* @name Phaser.Physics.Arcade.Body#_sx

* @type {number}

* @private

* @since 3.0.0

*/

this._sx = gameObject.scaleX;

/**

* Cached vertical scale of the Body's Game Object.

*

* @name Phaser.Physics.Arcade.Body#_sy

* @type {number}

* @private

* @since 3.0.0

*/

this._sy = gameObject.scaleY;

/**

* The calculated change in the Body's horizontal position during the current step.

*

* @name Phaser.Physics.Arcade.Body#_dx

* @type {number}

* @private

* @default 0

* @since 3.0.0

*/

this._dx = 0;

/**

* The calculated change in the Body's vertical position during the current step.

*

* @name Phaser.Physics.Arcade.Body#_dy

* @type {number}

* @private

* @default 0

* @since 3.0.0

*/

this._dy = 0;

/**

* Stores the Game Object's bounds.

*

* @name Phaser.Physics.Arcade.Body#_bounds

* @type {Phaser.Geom.Rectangle}

* @private

* @since 3.0.0

*/

this._bounds = new Rectangle();

this._tempMatrix = new TransformMatrix();

},

/**

* Updates this Body's transform, dimensions, and position from its Game Object.

*

* @method Phaser.Physics.Arcade.Body#updateBounds

* @since 3.0.0

*/

updateBounds: function ()

{

var sprite = this.gameObject;

// Container?

var transform = this.transform;

if (sprite.parentContainer)

{

var matrix = sprite.getWorldTransformMatrix(this._tempMatrix);

transform.x = matrix.tx;

transform.y = matrix.ty;

transform.rotation = RadToDeg(matrix.rotation);

transform.scaleX = matrix.scaleX;

transform.scaleY = matrix.scaleY;

}

else

{

transform.x = sprite.x;

transform.y = sprite.y;

transform.rotation = sprite.angle;

transform.scaleX = sprite.scaleX;

transform.scaleY = sprite.scaleY;

}

var recalc = false;

if (this.syncBounds)

{

var b = sprite.getBounds(this._bounds);

this.width = b.width;

this.height = b.height;

recalc = true;

}

else

{

var asx = Math.abs(transform.scaleX);

var asy = Math.abs(transform.scaleY);

if (this._sx !== asx || this._sy !== asy)

{

this.width = this.sourceWidth * asx;

this.height = this.sourceHeight * asy;

this._sx = asx;

this._sy = asy;

recalc = true;

}

}

if (recalc)

{

this.halfWidth = Math.floor(this.width / 2);

this.halfHeight = Math.floor(this.height / 2);

this.updateCenter();

}

},

/**

* Updates the Body's `center` from its `position` and dimensions.

*

* @method Phaser.Physics.Arcade.Body#updateCenter

* @since 3.0.0

*/

updateCenter: function ()

{

this.center.set(this.position.x + this.halfWidth, this.position.y + this.halfHeight);

},

/**

* Updates the Body.

*

* @method Phaser.Physics.Arcade.Body#update

* @fires Phaser.Physics.Arcade.World#worldbounds

* @since 3.0.0

*

* @param {number} delta - The delta time, in ms, elapsed since the last frame.

*/

update: function (delta)

{

// Store and reset collision flags

this.wasTouching.none = this.touching.none;

this.wasTouching.up = this.touching.up;

this.wasTouching.down = this.touching.down;

this.wasTouching.left = this.touching.left;

this.wasTouching.right = this.touching.right;

this.touching.none = true;

this.touching.up = false;

this.touching.down = false;

this.touching.left = false;

this.touching.right = false;

this.blocked.none = true;

this.blocked.up = false;

this.blocked.down = false;

this.blocked.left = false;

this.blocked.right = false;

this.overlapR = 0;

this.overlapX = 0;

this.overlapY = 0;

this.embedded = false;

// Updates the transform values

this.updateBounds();

var sprite = this.transform;

this.position.x = sprite.x + sprite.scaleX * (this.offset.x - sprite.displayOriginX);

this.position.y = sprite.y + sprite.scaleY * (this.offset.y - sprite.displayOriginY);

this.updateCenter();

this.rotation = sprite.rotation;

this.preRotation = this.rotation;

if (this._reset)

{

this.prev.x = this.position.x;

this.prev.y = this.position.y;

}

if (this.moves)

{

this.world.updateMotion(this, delta);

var vx = this.velocity.x;

var vy = this.velocity.y;

this.newVelocity.set(vx * delta, vy * delta);

this.position.add(this.newVelocity);

this.updateCenter();

this.angle = Math.atan2(vy, vx);

this.speed = Math.sqrt(vx * vx + vy * vy);

// Now the State update will throw collision checks at the Body

// And finally we'll integrate the new position back to the Sprite in postUpdate

if (this.collideWorldBounds && this.checkWorldBounds() && this.onWorldBounds)

{

this.world.emit('worldbounds', this, this.blocked.up, this.blocked.down, this.blocked.left, this.blocked.right);

}

}

this._dx = this.deltaX();

this._dy = this.deltaY();

},

/**

* Feeds the Body results back into the parent Game Object.

*

* @method Phaser.Physics.Arcade.Body#postUpdate

* @since 3.0.0

*

* @param {boolean} resetDelta - Reset the delta properties?

*/

postUpdate: function ()

{

this._dx = this.deltaX();

this._dy = this.deltaY();

if (this.moves)

{

if (this.deltaMax.x !== 0 && this._dx !== 0)

{

if (this._dx < 0 && this._dx < -this.deltaMax.x)

{

this._dx = -this.deltaMax.x;

}

else if (this._dx > 0 && this._dx > this.deltaMax.x)

{

this._dx = this.deltaMax.x;

}

}

if (this.deltaMax.y !== 0 && this._dy !== 0)

{

if (this._dy < 0 && this._dy < -this.deltaMax.y)

{

this._dy = -this.deltaMax.y;

}

else if (this._dy > 0 && this._dy > this.deltaMax.y)

{

this._dy = this.deltaMax.y;

}

}

this.gameObject.x += this._dx;

this.gameObject.y += this._dy;

this._reset = true;

}

if (this._dx < 0)

{

this.facing = CONST.FACING_LEFT;

}

else if (this._dx > 0)

{

this.facing = CONST.FACING_RIGHT;

}

if (this._dy < 0)

{

this.facing = CONST.FACING_UP;

}

else if (this._dy > 0)

{

this.facing = CONST.FACING_DOWN;

}

if (this.allowRotation)

{

this.gameObject.angle += this.deltaZ();

}

this.prev.x = this.position.x;

this.prev.y = this.position.y;

},