2013-10-01 12:54:29 +00:00
/ * *
* @ author Richard Davey < rich @ photonstorm . com >
2014-02-05 05:54:25 +00:00
* @ copyright 2014 Photon Storm Ltd .
2013-10-01 12:54:29 +00:00
* @ license { @ link https : //github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
* /
/ * *
2013-11-28 15:57:09 +00:00
* @ class Phaser . Sprite
*
* @ classdesc Create a new ` Sprite ` object . Sprites are the lifeblood of your game , used for nearly everything visual .
*
2013-10-25 14:02:21 +00:00
* At its most basic a Sprite consists of a set of coordinates and a texture that is rendered to the canvas .
* They also contain additional properties allowing for physics motion ( via Sprite . body ) , input handling ( via Sprite . input ) ,
* events ( via Sprite . events ) , animation ( via Sprite . animations ) , camera culling and more . Please see the Examples for use cases .
*
2013-10-01 12:54:29 +00:00
* @ constructor
2014-02-21 13:25:08 +00:00
* @ extends PIXI . Sprite
2013-10-25 14:02:21 +00:00
* @ param { Phaser . Game } game - A reference to the currently running game .
* @ param { number } x - The x coordinate ( in world space ) to position the Sprite at .
* @ param { number } y - The y coordinate ( in world space ) to position the Sprite at .
2013-11-13 20:57:09 +00:00
* @ param { string | Phaser . RenderTexture | Phaser . BitmapData | PIXI . Texture } key - This is the image or texture used by the Sprite during rendering . It can be a string which is a reference to the Cache entry , or an instance of a RenderTexture or PIXI . Texture .
2013-10-25 14:02:21 +00:00
* @ param { string | number } frame - If this Sprite is using part of a sprite sheet or texture atlas you can specify the exact frame to use by giving a string or numeric index .
2013-10-01 12:54:29 +00:00
* /
2013-09-11 02:55:53 +00:00
Phaser . Sprite = function ( game , x , y , key , frame ) {
2013-08-30 03:20:14 +00:00
2013-08-31 20:50:34 +00:00
x = x || 0 ;
y = y || 0 ;
2013-09-11 02:55:53 +00:00
key = key || null ;
2013-08-31 20:50:34 +00:00
frame = frame || null ;
2014-03-23 07:59:28 +00:00
2013-10-01 12:54:29 +00:00
/ * *
2013-11-25 03:13:04 +00:00
* @ property { Phaser . Game } game - A reference to the currently running Game .
* /
this . game = game ;
2013-09-06 19:20:58 +00:00
2013-10-01 12:54:29 +00:00
/ * *
2013-11-25 03:13:04 +00:00
* @ property { string } name - The user defined name given to this Sprite .
* @ default
* /
2013-08-30 03:20:14 +00:00
this . name = '' ;
2013-10-01 12:54:29 +00:00
/ * *
2013-11-25 03:13:04 +00:00
* @ property { number } type - The const type of this object .
* @ readonly
* /
2014-02-07 19:44:14 +00:00
this . type = Phaser . SPRITE ;
2013-09-10 00:26:50 +00:00
2014-03-10 23:01:10 +00:00
/ * *
* @ property { number } z - The z - depth value of this object within its Group ( remember the World is a Group as well ) . No two objects in a Group can have the same z value .
* /
this . z = 0 ;
2013-09-11 15:25:46 +00:00
/ * *
2013-11-24 23:52:31 +00:00
* @ property { Phaser . Events } events - The Events you can subscribe to that are dispatched when certain things happen on this Sprite or its components .
2013-10-01 12:54:29 +00:00
* /
2013-09-11 15:25:46 +00:00
this . events = new Phaser . Events ( this ) ;
/ * *
2013-10-25 14:02:21 +00:00
* @ property { Phaser . AnimationManager } animations - This manages animations of the sprite . You can modify animations through it ( see Phaser . AnimationManager )
2013-10-01 12:54:29 +00:00
* /
2013-09-11 15:25:46 +00:00
this . animations = new Phaser . AnimationManager ( this ) ;
2013-10-01 12:54:29 +00:00
/ * *
2013-11-13 20:57:09 +00:00
* @ property { string | Phaser . RenderTexture | Phaser . BitmapData | PIXI . Texture } key - This is the image or texture used by the Sprite during rendering . It can be a string which is a reference to the Cache entry , or an instance of a RenderTexture , BitmapData or PIXI . Texture .
2013-10-01 12:54:29 +00:00
* /
2013-09-11 02:55:53 +00:00
this . key = key ;
2014-02-07 18:44:58 +00:00
PIXI . Sprite . call ( this , PIXI . TextureCache [ '__default' ] ) ;
2013-08-30 03:20:14 +00:00
2014-02-07 18:44:58 +00:00
this . position . set ( x , y ) ;
2013-08-30 03:20:14 +00:00
2013-11-01 02:07:21 +00:00
/ * *
* @ property { Phaser . Point } world - The world coordinates of this Sprite . This differs from the x / y coordinates which are relative to the Sprites container .
* /
this . world = new Phaser . Point ( x , y ) ;
2013-09-02 22:22:24 +00:00
/ * *
2013-10-01 12:54:29 +00:00
* Should this Sprite be automatically culled if out of range of the camera ?
2013-10-25 14:02:21 +00:00
* A culled sprite has its renderable property set to 'false' .
2014-02-07 18:44:58 +00:00
* Be advised this is quite an expensive operation , as it has to calculate the bounds of the object every frame , so only enable it if you really need it .
2013-10-01 12:54:29 +00:00
*
2013-10-25 15:54:40 +00:00
* @ property { boolean } autoCull - A flag indicating if the Sprite should be automatically camera culled or not .
2013-10-01 12:54:29 +00:00
* @ default
* /
2013-09-02 22:22:24 +00:00
this . autoCull = false ;
2013-10-01 12:54:29 +00:00
/ * *
2014-02-07 18:44:58 +00:00
* @ property { Phaser . InputHandler | null } input - The Input Handler for this object . Needs to be enabled with image . inputEnabled = true before you can use it .
2013-10-01 12:54:29 +00:00
* /
2014-02-07 18:44:58 +00:00
this . input = null ;
2013-10-01 12:54:29 +00:00
/ * *
2014-03-06 06:27:16 +00:00
* By default Sprites won ' t add themselves to any physics system and their physics body will be ` null ` .
2014-03-23 07:59:28 +00:00
* To enable them for physics you need to call ` game.physics.enable(sprite, system) ` where ` sprite ` is this object
2014-03-06 06:27:16 +00:00
* and ` system ` is the Physics system you want to use to manage this body . Once enabled you can access all physics related properties via ` Sprite.body ` .
*
* Important : Enabling a Sprite for P2 or Ninja physics will automatically set ` Sprite.anchor ` to 0.5 so the physics body is centered on the Sprite .
* If you need a different result then adjust or re - create the Body shape offsets manually , and / or reset the anchor after enabling physics .
*
* @ property { Phaser . Physics . Arcade . Body | Phaser . Physics . P2 . Body | Phaser . Physics . Ninja . Body | null } body
* @ default
2013-10-01 12:54:29 +00:00
* /
2014-02-10 16:01:30 +00:00
this . body = null ;
2013-09-01 05:21:39 +00:00
2014-05-21 20:48:29 +00:00
/ * *
* @ property { boolean } alive - A useful boolean to control if the Sprite is alive or dead ( in terms of your gameplay , it doesn ' t effect rendering ) . Also linked to Sprite . health and Sprite . damage .
* @ default
* /
this . alive = true ;
2013-10-10 08:03:38 +00:00
/ * *
* @ property { number } health - Health value . Used in combination with damage ( ) to allow for quick killing of Sprites .
2013-11-25 03:13:04 +00:00
* /
2013-10-10 08:03:38 +00:00
this . health = 1 ;
2013-10-01 12:54:29 +00:00
/ * *
2014-02-07 18:44:58 +00:00
* If you would like the Sprite to have a lifespan once 'born' you can set this to a positive value . Handy for particles , bullets , etc .
* The lifespan is decremented by game . time . elapsed each update , once it reaches zero the kill ( ) function is called .
* @ property { number } lifespan - The lifespan of the Sprite ( in ms ) before it will be killed .
2013-10-01 12:54:29 +00:00
* @ default
* /
2014-02-07 18:44:58 +00:00
this . lifespan = 0 ;
2013-10-08 20:09:46 +00:00
/ * *
2014-02-09 03:48:31 +00:00
* If true the Sprite checks if it is still within the world each frame , when it leaves the world it dispatches Sprite . events . onOutOfBounds
* and optionally kills the sprite ( if Sprite . outOfBoundsKill is true ) . By default this is disabled because the Sprite has to calculate its
* bounds every frame to support it , and not all games need it . Enable it by setting the value to true .
* @ property { boolean } checkWorldBounds
* @ default
* /
this . checkWorldBounds = false ;
/ * *
* @ property { boolean } outOfBoundsKill - If true Sprite . kill is called as soon as Sprite . inWorld returns false , as long as Sprite . checkWorldBounds is true .
2013-10-08 20:09:46 +00:00
* @ default
* /
this . outOfBoundsKill = false ;
2014-02-09 03:48:31 +00:00
2014-01-31 10:34:18 +00:00
/ * *
* @ property { boolean } debug - Handy flag to use with Game . enableStep
* @ default
* /
this . debug = false ;
2014-02-15 01:27:42 +00:00
/ * *
* @ property { Phaser . Point } cameraOffset - If this object is fixedToCamera then this stores the x / y offset that its drawn at , from the top - left of the camera view .
* /
this . cameraOffset = new Phaser . Point ( ) ;
2014-06-10 22:37:33 +00:00
/ * *
* @ property { Phaser . Rectangle } cropRect - The Rectangle used to crop the texture . Set this via Sprite . crop . Any time you modify this property directly you must call Sprite . updateCrop .
* @ default
* /
this . cropRect = null ;
2014-02-07 18:44:58 +00:00
/ * *
2014-02-09 03:48:31 +00:00
* A small internal cache :
2014-06-30 10:49:53 +00:00
*
2014-02-09 03:48:31 +00:00
* 0 = previous position . x
* 1 = previous position . y
* 2 = previous rotation
* 3 = renderID
* 4 = fresh ? ( 0 = no , 1 = yes )
* 5 = outOfBoundsFired ( 0 = no , 1 = yes )
2014-02-13 09:55:46 +00:00
* 6 = exists ( 0 = no , 1 = yes )
2014-02-15 01:27:42 +00:00
* 7 = fixed to camera ( 0 = no , 1 = yes )
2014-04-22 00:43:22 +00:00
* 8 = destroy phase ? ( 0 = no , 1 = yes )
2014-03-19 12:05:19 +00:00
* @ property { Array } _cache
2014-02-07 18:44:58 +00:00
* @ private
* /
2014-07-10 13:47:12 +00:00
this . _cache = [ 0 , 0 , 0 , 0 , 1 , 0 , 1 , 0 ] ;
2013-10-30 03:46:52 +00:00
2014-07-10 13:47:12 +00:00
/ * *
* @ property { Phaser . Rectangle } _crop - Internal cache var .
* @ private
* /
this . _crop = null ;
2014-07-10 09:46:12 +00:00
2014-07-10 13:47:12 +00:00
/ * *
* @ property { Phaser . Rectangle } _frame - Internal cache var .
* @ private
* /
this . _frame = null ;
2014-07-10 09:46:12 +00:00
2014-01-09 01:23:23 +00:00
/ * *
2014-02-09 03:48:31 +00:00
* @ property { Phaser . Rectangle } _bounds - Internal cache var .
2014-02-07 18:44:58 +00:00
* @ private
2014-01-09 01:23:23 +00:00
* /
2014-02-09 03:48:31 +00:00
this . _bounds = new Phaser . Rectangle ( ) ;
2014-01-09 01:23:23 +00:00
2014-06-10 22:37:33 +00:00
this . loadTexture ( key , frame ) ;
2014-06-05 01:33:13 +00:00
2013-08-30 03:20:14 +00:00
} ;
Phaser . Sprite . prototype = Object . create ( PIXI . Sprite . prototype ) ;
2014-02-07 19:44:14 +00:00
Phaser . Sprite . prototype . constructor = Phaser . Sprite ;
2013-08-30 03:20:14 +00:00
/ * *
2014-02-07 18:44:58 +00:00
* Automatically called by World . preUpdate .
2013-10-25 14:02:21 +00:00
*
2014-02-07 19:44:14 +00:00
* @ method Phaser . Sprite # preUpdate
* @ memberof Phaser . Sprite
2014-02-09 03:48:31 +00:00
* @ return { boolean } True if the Sprite was rendered , otherwise false .
2013-10-01 12:54:29 +00:00
* /
2013-09-10 23:35:21 +00:00
Phaser . Sprite . prototype . preUpdate = function ( ) {
2013-08-30 03:20:14 +00:00
2014-03-20 03:48:54 +00:00
if ( this . _cache [ 4 ] === 1 && this . exists )
2014-02-01 04:54:02 +00:00
{
2014-02-06 13:15:45 +00:00
this . world . setTo ( this . parent . position . x + this . position . x , this . parent . position . y + this . position . y ) ;
2014-02-09 03:48:31 +00:00
this . worldTransform . tx = this . world . x ;
this . worldTransform . ty = this . world . y ;
this . _cache [ 0 ] = this . world . x ;
this . _cache [ 1 ] = this . world . y ;
this . _cache [ 2 ] = this . rotation ;
2014-03-13 15:41:56 +00:00
2014-06-30 10:49:53 +00:00
if ( this . body )
2014-03-13 15:41:56 +00:00
{
this . body . preUpdate ( ) ;
}
2014-03-20 00:20:02 +00:00
this . _cache [ 4 ] = 0 ;
2014-02-09 03:48:31 +00:00
return false ;
2014-02-01 04:54:02 +00:00
}
2014-02-07 18:44:58 +00:00
this . _cache [ 0 ] = this . world . x ;
this . _cache [ 1 ] = this . world . y ;
this . _cache [ 2 ] = this . rotation ;
if ( ! this . exists || ! this . parent . exists )
2013-09-06 19:20:58 +00:00
{
2014-02-09 03:48:31 +00:00
// Reset the renderOrderID
this . _cache [ 3 ] = - 1 ;
2013-11-19 05:29:02 +00:00
return false ;
2013-09-06 19:20:58 +00:00
}
2013-09-10 00:26:50 +00:00
if ( this . lifespan > 0 )
{
this . lifespan -= this . game . time . elapsed ;
if ( this . lifespan <= 0 )
{
this . kill ( ) ;
2013-11-19 05:29:02 +00:00
return false ;
2013-09-10 00:26:50 +00:00
}
}
2014-02-09 03:48:31 +00:00
// Cache the bounds if we need it
if ( this . autoCull || this . checkWorldBounds )
2013-10-30 03:46:52 +00:00
{
2014-02-09 03:48:31 +00:00
this . _bounds . copyFrom ( this . getBounds ( ) ) ;
2013-10-30 03:46:52 +00:00
}
2014-02-09 03:48:31 +00:00
if ( this . autoCull )
2013-10-25 02:49:14 +00:00
{
2014-02-09 03:48:31 +00:00
// Won't get rendered but will still get its transform updated
this . renderable = this . game . world . camera . screenView . intersects ( this . _bounds ) ;
2013-10-25 02:49:14 +00:00
}
2013-10-25 01:19:16 +00:00
2014-02-09 03:48:31 +00:00
if ( this . checkWorldBounds )
2013-10-24 20:21:00 +00:00
{
2014-02-09 03:48:31 +00:00
// The Sprite is already out of the world bounds, so let's check to see if it has come back again
if ( this . _cache [ 5 ] === 1 && this . game . world . bounds . intersects ( this . _bounds ) )
{
this . _cache [ 5 ] = 0 ;
2014-03-19 04:16:37 +00:00
this . events . onEnterBounds . dispatch ( this ) ;
2014-02-09 03:48:31 +00:00
}
else if ( this . _cache [ 5 ] === 0 && ! this . game . world . bounds . intersects ( this . _bounds ) )
2013-10-24 20:21:00 +00:00
{
2014-02-09 03:48:31 +00:00
// The Sprite WAS in the screen, but has now left.
this . _cache [ 5 ] = 1 ;
2013-10-24 20:21:00 +00:00
this . events . onOutOfBounds . dispatch ( this ) ;
if ( this . outOfBoundsKill )
{
this . kill ( ) ;
2014-02-09 03:48:31 +00:00
return false ;
2013-10-24 20:21:00 +00:00
}
}
}
2014-02-09 03:48:31 +00:00
this . world . setTo ( this . game . camera . x + this . worldTransform . tx , this . game . camera . y + this . worldTransform . ty ) ;
2013-10-30 03:46:52 +00:00
2014-02-09 03:48:31 +00:00
if ( this . visible )
2013-10-30 03:46:52 +00:00
{
2014-02-28 19:45:15 +00:00
this . _cache [ 3 ] = this . game . stage . currentRenderOrderID ++ ;
2013-10-30 03:46:52 +00:00
}
2014-06-06 03:12:16 +00:00
this . animations . update ( ) ;
2014-02-09 03:48:31 +00:00
2014-06-30 10:49:53 +00:00
if ( this . body )
2014-03-05 02:36:08 +00:00
{
this . body . preUpdate ( ) ;
}
2014-02-28 19:45:15 +00:00
// Update any Children
2014-04-09 13:29:23 +00:00
for ( var i = 0 , len = this . children . length ; i < len ; i ++ )
{
this . children [ i ] . preUpdate ( ) ;
}
2013-10-24 03:27:28 +00:00
2014-02-07 18:44:58 +00:00
return true ;
2013-10-24 03:27:28 +00:00
2013-11-01 02:07:21 +00:00
} ;
2013-10-24 03:27:28 +00:00
2014-02-14 01:09:52 +00:00
/ * *
* Override and use this function in your own custom objects to handle any update requirements you may have .
2014-02-28 19:45:15 +00:00
* Remember if this Sprite has any children you should call update on them too .
2014-02-14 01:09:52 +00:00
*
* @ method Phaser . Sprite # update
* @ memberof Phaser . Sprite
* /
Phaser . Sprite . prototype . update = function ( ) {
} ;
2013-10-25 14:02:21 +00:00
/ * *
* Internal function called by the World postUpdate cycle .
*
2014-02-07 19:44:14 +00:00
* @ method Phaser . Sprite # postUpdate
* @ memberof Phaser . Sprite
2013-10-25 14:02:21 +00:00
* /
2013-09-20 12:55:33 +00:00
Phaser . Sprite . prototype . postUpdate = function ( ) {
2014-03-21 18:04:24 +00:00
if ( this . key instanceof Phaser . BitmapData )
2013-11-17 04:33:16 +00:00
{
this . key . render ( ) ;
}
2014-06-30 10:49:53 +00:00
if ( this . exists && this . body )
2013-09-20 12:55:33 +00:00
{
2014-03-05 02:36:08 +00:00
this . body . postUpdate ( ) ;
2014-02-15 01:27:42 +00:00
}
2013-09-23 00:06:09 +00:00
2014-02-15 01:27:42 +00:00
// Fixed to Camera?
if ( this . _cache [ 7 ] === 1 )
{
2014-03-06 17:12:00 +00:00
this . position . x = ( this . game . camera . view . x + this . cameraOffset . x ) / this . game . camera . scale . x ;
this . position . y = ( this . game . camera . view . y + this . cameraOffset . y ) / this . game . camera . scale . y ;
2013-09-20 12:55:33 +00:00
}
2014-02-28 19:45:15 +00:00
// Update any Children
for ( var i = 0 , len = this . children . length ; i < len ; i ++ )
{
this . children [ i ] . postUpdate ( ) ;
}
2013-11-01 02:07:21 +00:00
} ;
2013-09-20 12:55:33 +00:00
2013-10-25 14:02:21 +00:00
/ * *
* Changes the Texture the Sprite is using entirely . The old texture is removed and the new one is referenced or fetched from the Cache .
* This causes a WebGL texture update , so use sparingly or in low - intensity portions of your game .
*
2014-02-07 19:44:14 +00:00
* @ method Phaser . Sprite # loadTexture
* @ memberof Phaser . Sprite
2013-11-17 04:33:16 +00:00
* @ param { string | Phaser . RenderTexture | Phaser . BitmapData | PIXI . Texture } key - This is the image or texture used by the Sprite during rendering . It can be a string which is a reference to the Cache entry , or an instance of a RenderTexture , BitmapData or PIXI . Texture .
2014-06-10 22:37:33 +00:00
* @ param { string | number } [ frame ] - If this Sprite is using part of a sprite sheet or texture atlas you can specify the exact frame to use by giving a string or numeric index .
2014-07-15 23:29:43 +00:00
* @ param { boolean } [ stopAnimation = true ] - If an animation is already playing on this Sprite you can choose to stop it or let it carry on playing .
2013-10-25 14:02:21 +00:00
* /
2014-07-15 23:29:43 +00:00
Phaser . Sprite . prototype . loadTexture = function ( key , frame , stopAnimation ) {
2013-10-10 08:03:38 +00:00
2014-02-07 18:44:58 +00:00
frame = frame || 0 ;
2014-06-30 10:49:53 +00:00
2014-07-15 23:56:26 +00:00
if ( stopAnimation || typeof stopAnimation === 'undefined' )
{
this . animations . stop ( ) ;
}
2014-06-10 22:37:33 +00:00
this . key = key ;
2013-10-10 08:03:38 +00:00
2014-07-10 13:47:12 +00:00
var setFrame = true ;
2014-07-15 23:56:26 +00:00
var smoothed = this . smoothed ;
2014-07-10 13:47:12 +00:00
2013-10-10 08:03:38 +00:00
if ( key instanceof Phaser . RenderTexture )
{
2014-02-07 18:44:58 +00:00
this . key = key . key ;
this . setTexture ( key ) ;
2013-10-10 08:03:38 +00:00
}
2013-11-17 04:33:16 +00:00
else if ( key instanceof Phaser . BitmapData )
{
2014-09-02 20:03:16 +00:00
// This works from a reference, which probably isn't what we need here
2013-11-17 04:33:16 +00:00
this . setTexture ( key . texture ) ;
}
2013-10-24 20:21:00 +00:00
else if ( key instanceof PIXI . Texture )
{
2014-02-07 18:44:58 +00:00
this . setTexture ( key ) ;
2013-10-24 20:21:00 +00:00
}
2013-10-10 08:03:38 +00:00
else
{
2014-02-07 18:44:58 +00:00
if ( key === null || typeof key === 'undefined' )
2013-10-10 08:03:38 +00:00
{
2014-02-07 18:44:58 +00:00
this . key = '__default' ;
this . setTexture ( PIXI . TextureCache [ this . key ] ) ;
}
else if ( typeof key === 'string' && ! this . game . cache . checkImageKey ( key ) )
{
2014-07-10 16:49:16 +00:00
console . warn ( "Texture with key '" + key + "' not found." ) ;
2014-02-07 18:44:58 +00:00
this . key = '__missing' ;
this . setTexture ( PIXI . TextureCache [ this . key ] ) ;
2013-10-10 08:03:38 +00:00
}
else
{
2014-06-06 03:12:16 +00:00
this . setTexture ( new PIXI . Texture ( PIXI . BaseTextureCache [ key ] ) ) ;
2014-07-10 15:06:47 +00:00
2014-07-15 23:56:26 +00:00
setFrame = ! this . animations . loadFrameData ( this . game . cache . getFrameData ( key ) , frame ) ;
2013-10-10 08:03:38 +00:00
}
}
2014-07-10 13:47:12 +00:00
if ( setFrame )
2014-06-10 22:37:33 +00:00
{
2014-07-10 13:47:12 +00:00
this . _frame = Phaser . Rectangle . clone ( this . texture . frame ) ;
2014-06-10 22:37:33 +00:00
}
2014-06-06 03:12:16 +00:00
2014-07-15 23:56:26 +00:00
if ( ! smoothed )
2014-07-15 23:29:43 +00:00
{
2014-07-15 23:56:26 +00:00
this . smoothed = false ;
2014-07-15 23:29:43 +00:00
}
2014-06-10 22:37:33 +00:00
} ;
2014-06-06 03:12:16 +00:00
2014-06-10 22:37:33 +00:00
/ * *
* Sets the Texture frame the Sprite uses for rendering .
* This is primarily an internal method used by Sprite . loadTexture , although you may call it directly .
*
* @ method Phaser . Sprite # setFrame
* @ memberof Phaser . Sprite
* @ param { Phaser . Frame } frame - The Frame to be used by the Sprite texture .
* /
Phaser . Sprite . prototype . setFrame = function ( frame ) {
2014-06-06 03:12:16 +00:00
2014-07-10 13:47:12 +00:00
this . _frame = frame ;
2014-06-06 03:12:16 +00:00
2014-06-10 22:37:33 +00:00
this . texture . frame . x = frame . x ;
this . texture . frame . y = frame . y ;
this . texture . frame . width = frame . width ;
this . texture . frame . height = frame . height ;
2014-06-06 03:12:16 +00:00
2014-07-09 04:40:50 +00:00
this . texture . crop . x = frame . x ;
this . texture . crop . y = frame . y ;
this . texture . crop . width = frame . width ;
this . texture . crop . height = frame . height ;
2014-06-10 22:37:33 +00:00
if ( frame . trimmed )
{
2014-07-07 09:23:50 +00:00
if ( this . texture . trim )
{
this . texture . trim . x = frame . spriteSourceSizeX ;
this . texture . trim . y = frame . spriteSourceSizeY ;
this . texture . trim . width = frame . sourceSizeW ;
this . texture . trim . height = frame . sourceSizeH ;
}
else
{
this . texture . trim = { x : frame . spriteSourceSizeX , y : frame . spriteSourceSizeY , width : frame . sourceSizeW , height : frame . sourceSizeH } ;
}
2014-07-09 04:40:50 +00:00
this . texture . width = frame . sourceSizeW ;
this . texture . height = frame . sourceSizeH ;
this . texture . frame . width = frame . sourceSizeW ;
this . texture . frame . height = frame . sourceSizeH ;
2014-06-10 22:37:33 +00:00
}
2014-06-06 03:12:16 +00:00
2014-06-10 22:37:33 +00:00
if ( this . cropRect )
{
this . updateCrop ( ) ;
}
2014-07-08 11:59:22 +00:00
else
{
if ( this . game . renderType === Phaser . WEBGL )
{
PIXI . WebGLRenderer . updateTextureFrame ( this . texture ) ;
}
}
2014-06-06 03:12:16 +00:00
2014-06-10 22:37:33 +00:00
} ;
2014-06-06 03:12:16 +00:00
2014-06-10 22:37:33 +00:00
/ * *
2014-07-10 13:47:12 +00:00
* Resets the Texture frame dimensions that the Sprite uses for rendering .
2014-06-10 22:37:33 +00:00
*
2014-07-10 13:47:12 +00:00
* @ method Phaser . Sprite # resetFrame
2014-06-10 22:37:33 +00:00
* @ memberof Phaser . Sprite
* /
2014-07-10 13:47:12 +00:00
Phaser . Sprite . prototype . resetFrame = function ( ) {
2014-07-08 11:59:22 +00:00
2014-07-10 13:47:12 +00:00
if ( this . _frame )
2014-06-06 03:12:16 +00:00
{
2014-07-10 13:47:12 +00:00
this . setFrame ( this . _frame ) ;
2014-06-06 03:12:16 +00:00
}
} ;
2013-09-13 03:37:06 +00:00
/ * *
2014-02-15 01:27:42 +00:00
* Crop allows you to crop the texture used to display this Sprite .
2014-06-10 22:37:33 +00:00
* This modifies the core Sprite texture frame , so the Sprite width / height properties will adjust accordingly .
2014-06-30 10:49:53 +00:00
*
2014-06-10 22:37:33 +00:00
* Cropping takes place from the top - left of the Sprite and can be modified in real - time by either providing an updated rectangle object to Sprite . crop ,
* or by modifying Sprite . cropRect ( or a reference to it ) and then calling Sprite . updateCrop .
2014-06-30 10:49:53 +00:00
*
2014-05-14 01:18:18 +00:00
* The rectangle object given to this method can be either a Phaser . Rectangle or any object so long as it has public x , y , width and height properties .
2014-06-10 22:37:33 +00:00
* A reference to the rectangle is stored in Sprite . cropRect unless the ` copy ` parameter is ` true ` in which case the values are duplicated to a local object .
2014-02-07 18:44:58 +00:00
*
2014-02-07 19:44:14 +00:00
* @ method Phaser . Sprite # crop
* @ memberof Phaser . Sprite
2014-06-10 22:37:33 +00:00
* @ param { Phaser . Rectangle } rect - The Rectangle used during cropping . Pass null or no parameters to clear a previously set crop rectangle .
* @ param { boolean } [ copy = false ] - If false Sprite . cropRect will be a reference to the given rect . If true it will copy the rect values into a local Sprite . cropRect object .
2013-10-01 12:54:29 +00:00
* /
2014-06-05 01:33:13 +00:00
Phaser . Sprite . prototype . crop = function ( rect , copy ) {
2014-06-10 22:37:33 +00:00
if ( typeof copy === 'undefined' ) { copy = false ; }
2014-06-06 03:12:16 +00:00
if ( rect )
2013-12-22 03:46:08 +00:00
{
2014-06-10 22:37:33 +00:00
if ( copy && this . cropRect !== null )
{
this . cropRect . setTo ( rect . x , rect . y , rect . width , rect . height ) ;
}
else if ( copy && this . cropRect === null )
2014-02-07 18:44:58 +00:00
{
2014-06-10 22:37:33 +00:00
this . cropRect = new Phaser . Rectangle ( rect . x , rect . y , rect . width , rect . height ) ;
2014-02-07 18:44:58 +00:00
}
else
{
2014-06-10 22:37:33 +00:00
this . cropRect = rect ;
2014-02-07 18:44:58 +00:00
}
2014-06-06 03:12:16 +00:00
2014-06-10 22:37:33 +00:00
this . updateCrop ( ) ;
2014-06-06 03:12:16 +00:00
}
else
{
2014-07-10 13:47:12 +00:00
this . _crop = null ;
2014-06-10 22:37:33 +00:00
this . cropRect = null ;
2014-07-10 13:47:12 +00:00
2014-06-10 22:37:33 +00:00
this . resetFrame ( ) ;
2014-02-07 18:44:58 +00:00
}
2013-09-13 03:37:06 +00:00
2013-11-01 02:07:21 +00:00
} ;
2013-09-13 03:37:06 +00:00
2014-07-10 13:47:12 +00:00
/ * *
* If you have set a crop rectangle on this Sprite via Sprite . crop and since modified the Sprite . cropRect property ( or the rectangle it references )
* then you need to update the crop frame by calling this method .
*
* @ method Phaser . Sprite # updateCrop
* @ memberof Phaser . Sprite
* /
Phaser . Sprite . prototype . updateCrop = function ( ) {
if ( ! this . cropRect )
{
return ;
}
this . _crop = Phaser . Rectangle . clone ( this . cropRect , this . _crop ) ;
this . _crop . x += this . _frame . x ;
this . _crop . y += this . _frame . y ;
var cx = Math . max ( this . _frame . x , this . _crop . x ) ;
var cy = Math . max ( this . _frame . y , this . _crop . y ) ;
var cw = Math . min ( this . _frame . right , this . _crop . right ) - cx ;
var ch = Math . min ( this . _frame . bottom , this . _crop . bottom ) - cy ;
this . texture . crop . x = cx ;
this . texture . crop . y = cy ;
this . texture . crop . width = cw ;
this . texture . crop . height = ch ;
this . texture . frame . width = Math . min ( cw , this . cropRect . width ) ;
this . texture . frame . height = Math . min ( ch , this . cropRect . height ) ;
this . texture . width = this . texture . frame . width ;
this . texture . height = this . texture . frame . height ;
if ( this . game . renderType === Phaser . WEBGL )
{
PIXI . WebGLRenderer . updateTextureFrame ( this . texture ) ;
}
2014-07-10 15:21:50 +00:00
} ;
2014-07-10 13:47:12 +00:00
2013-10-01 12:54:29 +00:00
/ * *
2013-10-25 14:02:21 +00:00
* Brings a 'dead' Sprite back to life , optionally giving it the health value specified .
* A resurrected Sprite has its alive , exists and visible properties all set to true .
* It will dispatch the onRevived event , you can listen to Sprite . events . onRevived for the signal .
2014-03-23 07:59:28 +00:00
*
2013-10-25 14:02:21 +00:00
* @ method Phaser . Sprite # revive
* @ memberof Phaser . Sprite
* @ param { number } [ health = 1 ] - The health to give the Sprite .
* @ return ( Phaser . Sprite ) This instance .
2013-10-01 12:54:29 +00:00
* /
2013-10-10 08:03:38 +00:00
Phaser . Sprite . prototype . revive = function ( health ) {
if ( typeof health === 'undefined' ) { health = 1 ; }
2013-09-10 00:26:50 +00:00
this . alive = true ;
this . exists = true ;
this . visible = true ;
2013-10-10 08:03:38 +00:00
this . health = health ;
2013-10-25 14:02:21 +00:00
if ( this . events )
{
this . events . onRevived . dispatch ( this ) ;
}
return this ;
2013-09-10 00:26:50 +00:00
2013-11-01 02:07:21 +00:00
} ;
2013-09-10 00:26:50 +00:00
2013-10-01 12:54:29 +00:00
/ * *
2013-10-25 14:02:21 +00:00
* Kills a Sprite . A killed Sprite has its alive , exists and visible properties all set to false .
* It will dispatch the onKilled event , you can listen to Sprite . events . onKilled for the signal .
* Note that killing a Sprite is a way for you to quickly recycle it in a Sprite pool , it doesn ' t free it up from memory .
* If you don ' t need this Sprite any more you should call Sprite . destroy instead .
2014-03-23 07:59:28 +00:00
*
2013-10-25 14:02:21 +00:00
* @ method Phaser . Sprite # kill
* @ memberof Phaser . Sprite
* @ return ( Phaser . Sprite ) This instance .
2013-10-01 12:54:29 +00:00
* /
2013-09-10 00:26:50 +00:00
Phaser . Sprite . prototype . kill = function ( ) {
this . alive = false ;
this . exists = false ;
this . visible = false ;
2013-10-23 12:30:22 +00:00
if ( this . events )
{
this . events . onKilled . dispatch ( this ) ;
}
2013-09-10 00:26:50 +00:00
2013-10-25 14:02:21 +00:00
return this ;
2013-11-01 02:07:21 +00:00
} ;
2013-09-10 00:26:50 +00:00
2013-10-13 00:29:57 +00:00
/ * *
2013-10-25 14:02:21 +00:00
* Destroys the Sprite . This removes it from its parent group , destroys the input , event and animation handlers if present
* and nulls its reference to game , freeing it up for garbage collection .
2014-03-23 07:59:28 +00:00
*
2013-10-25 14:02:21 +00:00
* @ method Phaser . Sprite # destroy
* @ memberof Phaser . Sprite
2014-02-27 20:05:16 +00:00
* @ param { boolean } [ destroyChildren = true ] - Should every child of this object have its destroy method called ?
2013-10-13 00:29:57 +00:00
* /
2014-02-27 20:05:16 +00:00
Phaser . Sprite . prototype . destroy = function ( destroyChildren ) {
2014-04-22 00:43:22 +00:00
if ( this . game === null || this . _cache [ 8 ] === 1 ) { return ; }
2014-02-27 20:05:16 +00:00
if ( typeof destroyChildren === 'undefined' ) { destroyChildren = true ; }
2013-10-13 00:29:57 +00:00
2014-04-22 00:43:22 +00:00
this . _cache [ 8 ] = 1 ;
2014-08-28 01:56:06 +00:00
if ( this . events )
{
this . events . onDestroy . dispatch ( this ) ;
}
2014-02-06 13:15:45 +00:00
if ( this . parent )
2013-10-13 00:29:57 +00:00
{
2014-02-28 09:30:53 +00:00
if ( this . parent instanceof Phaser . Group )
2014-02-28 06:17:18 +00:00
{
this . parent . remove ( this ) ;
}
else
{
this . parent . removeChild ( this ) ;
}
2013-10-13 00:29:57 +00:00
}
2014-02-07 18:44:58 +00:00
if ( this . input )
2013-10-24 03:27:28 +00:00
{
2014-02-07 18:44:58 +00:00
this . input . destroy ( ) ;
2013-10-24 03:27:28 +00:00
}
if ( this . animations )
{
this . animations . destroy ( ) ;
}
2013-10-13 00:29:57 +00:00
2014-02-05 02:39:03 +00:00
if ( this . body )
{
this . body . destroy ( ) ;
}
2014-02-10 02:14:59 +00:00
if ( this . events )
{
this . events . destroy ( ) ;
}
2014-02-21 13:25:08 +00:00
var i = this . children . length ;
2014-02-27 20:05:16 +00:00
if ( destroyChildren )
2014-02-21 13:25:08 +00:00
{
2014-02-27 20:05:16 +00:00
while ( i -- )
{
this . children [ i ] . destroy ( destroyChildren ) ;
}
}
else
{
while ( i -- )
{
this . removeChild ( this . children [ i ] ) ;
}
2014-02-21 13:25:08 +00:00
}
2014-07-10 13:47:12 +00:00
if ( this . _crop )
{
this . _crop = null ;
}
if ( this . _frame )
{
this . _frame = null ;
}
2013-10-13 00:29:57 +00:00
this . alive = false ;
this . exists = false ;
this . visible = false ;
2014-02-21 12:18:23 +00:00
this . filters = null ;
this . mask = null ;
2013-10-13 00:29:57 +00:00
this . game = null ;
2014-04-22 00:43:22 +00:00
this . _cache [ 8 ] = 0 ;
2013-11-01 02:07:21 +00:00
} ;
2013-10-13 00:29:57 +00:00
2013-10-10 08:03:38 +00:00
/ * *
2013-10-25 14:02:21 +00:00
* Damages the Sprite , this removes the given amount from the Sprites health property .
2014-03-10 00:50:06 +00:00
* If health is then taken below or is equal to zero ` Sprite.kill ` is called .
2014-03-23 07:59:28 +00:00
*
2013-10-25 14:02:21 +00:00
* @ method Phaser . Sprite # damage
* @ memberof Phaser . Sprite
* @ param { number } amount - The amount to subtract from the Sprite . health value .
* @ return ( Phaser . Sprite ) This instance .
2013-10-10 08:03:38 +00:00
* /
Phaser . Sprite . prototype . damage = function ( amount ) {
if ( this . alive )
{
this . health -= amount ;
2014-03-10 00:50:06 +00:00
if ( this . health <= 0 )
2013-10-10 08:03:38 +00:00
{
this . kill ( ) ;
}
}
2013-10-25 14:02:21 +00:00
return this ;
2013-11-01 02:07:21 +00:00
} ;
2013-10-10 08:03:38 +00:00
2013-10-01 12:54:29 +00:00
/ * *
2013-10-25 14:02:21 +00:00
* Resets the Sprite . This places the Sprite at the given x / y world coordinates and then
* sets alive , exists , visible and renderable all to true . Also resets the outOfBounds state and health values .
* If the Sprite has a physics body that too is reset .
2014-03-23 07:59:28 +00:00
*
2013-10-25 14:02:21 +00:00
* @ method Phaser . Sprite # reset
* @ memberof Phaser . Sprite
* @ param { number } x - The x coordinate ( in world space ) to position the Sprite at .
* @ param { number } y - The y coordinate ( in world space ) to position the Sprite at .
* @ param { number } [ health = 1 ] - The health to give the Sprite .
* @ return ( Phaser . Sprite ) This instance .
2013-10-01 12:54:29 +00:00
* /
2013-10-10 08:03:38 +00:00
Phaser . Sprite . prototype . reset = function ( x , y , health ) {
if ( typeof health === 'undefined' ) { health = 1 ; }
2013-09-03 16:28:12 +00:00
2014-01-31 10:34:18 +00:00
this . world . setTo ( x , y ) ;
2014-02-07 18:44:58 +00:00
this . position . x = x ;
this . position . y = y ;
2013-09-09 12:29:33 +00:00
this . alive = true ;
this . exists = true ;
this . visible = true ;
2013-10-08 20:09:46 +00:00
this . renderable = true ;
2013-09-09 12:29:33 +00:00
this . _outOfBoundsFired = false ;
2013-10-10 08:03:38 +00:00
this . health = health ;
if ( this . body )
{
2014-02-13 12:26:39 +00:00
this . body . reset ( x , y , false , false ) ;
2013-10-10 08:03:38 +00:00
}
2013-10-25 14:02:21 +00:00
2014-03-20 03:48:54 +00:00
this . _cache [ 4 ] = 1 ;
2013-10-25 14:02:21 +00:00
return this ;
2014-03-23 07:59:28 +00:00
2013-11-01 02:07:21 +00:00
} ;
2013-09-03 16:28:12 +00:00
2013-10-01 12:54:29 +00:00
/ * *
2013-10-25 14:02:21 +00:00
* Brings the Sprite to the top of the display list it is a child of . Sprites that are members of a Phaser . Group are only
* bought to the top of that Group , not the entire display list .
2014-03-23 07:59:28 +00:00
*
2013-10-25 14:02:21 +00:00
* @ method Phaser . Sprite # bringToTop
* @ memberof Phaser . Sprite
* @ return ( Phaser . Sprite ) This instance .
2013-10-01 12:54:29 +00:00
* /
2014-03-05 02:36:08 +00:00
Phaser . Sprite . prototype . bringToTop = function ( ) {
2013-09-08 21:58:15 +00:00
2014-03-05 02:36:08 +00:00
if ( this . parent )
2013-09-08 21:58:15 +00:00
{
2014-03-05 02:36:08 +00:00
this . parent . bringToTop ( this ) ;
2013-09-08 21:58:15 +00:00
}
2013-10-25 14:02:21 +00:00
return this ;
2013-11-01 02:07:21 +00:00
} ;
2013-09-08 21:58:15 +00:00
2013-09-27 12:47:22 +00:00
/ * *
* Play an animation based on the given key . The animation should previously have been added via sprite . animations . add ( )
* If the requested animation is already playing this request will be ignored . If you need to reset an already running animation do so directly on the Animation object itself .
2014-03-23 07:59:28 +00:00
*
2013-10-25 14:02:21 +00:00
* @ method Phaser . Sprite # play
* @ memberof Phaser . Sprite
* @ param { string } name - The name of the animation to be played , e . g . "fire" , "walk" , "jump" .
* @ param { number } [ frameRate = null ] - The framerate to play the animation at . The speed is given in frames per second . If not provided the previously set frameRate of the Animation is used .
* @ param { boolean } [ loop = false ] - Should the animation be looped after playback . If not provided the previously set loop value of the Animation is used .
2013-10-09 12:36:57 +00:00
* @ param { boolean } [ killOnComplete = false ] - If set to true when the animation completes ( only happens if loop = false ) the parent Sprite will be killed .
2013-09-27 12:47:22 +00:00
* @ return { Phaser . Animation } A reference to playing Animation instance .
* /
2013-10-09 12:36:57 +00:00
Phaser . Sprite . prototype . play = function ( name , frameRate , loop , killOnComplete ) {
2013-09-27 12:47:22 +00:00
if ( this . animations )
{
2013-10-25 14:02:21 +00:00
return this . animations . play ( name , frameRate , loop , killOnComplete ) ;
2013-09-27 12:47:22 +00:00
}
2013-11-01 02:07:21 +00:00
} ;
2013-09-27 12:47:22 +00:00
2014-03-26 10:48:30 +00:00
/ * *
* Checks to see if the bounds of this Sprite overlaps with the bounds of the given Display Object , which can be a Sprite , Image , TileSprite or anything that extends those such as a Button .
* This check ignores the Sprites hitArea property and runs a Sprite . getBounds comparison on both objects to determine the result .
* Therefore it 's relatively expensive to use in large quantities (i.e. with lots of Sprites at a high frequency), but should be fine for low-volume testing where physics isn' t required .
2014-06-30 10:49:53 +00:00
*
2014-03-26 10:48:30 +00:00
* @ method Phaser . Sprite # overlap
* @ memberof Phaser . Sprite
* @ param { Phaser . Sprite | Phaser . Image | Phaser . TileSprite | Phaser . Button | PIXI . DisplayObject } displayObject - The display object to check against .
* @ return { boolean } True if the bounds of this Sprite intersects at any point with the bounds of the given display object .
* /
Phaser . Sprite . prototype . overlap = function ( displayObject ) {
return Phaser . Rectangle . intersects ( this . getBounds ( ) , displayObject . getBounds ( ) ) ;
} ;
2013-10-07 23:58:20 +00:00
/ * *
* Indicates the rotation of the Sprite , in degrees , from its original orientation . Values from 0 to 180 represent clockwise rotation ; values from 0 to - 180 represent counterclockwise rotation .
* Values outside this range are added to or subtracted from 360 to obtain a value within the range . For example , the statement player . angle = 450 is the same as player . angle = 90.
2014-02-07 18:44:58 +00:00
* If you wish to work in radians instead of degrees use the property Sprite . rotation instead . Working in radians is also a little faster as it doesn ' t have to convert the angle .
2014-03-23 07:59:28 +00:00
*
2014-02-07 19:44:14 +00:00
* @ name Phaser . Sprite # angle
2014-02-10 16:01:30 +00:00
* @ property { number } angle - The angle of this Sprite in degrees .
2013-10-07 23:58:20 +00:00
* /
2014-02-07 18:44:58 +00:00
Object . defineProperty ( Phaser . Sprite . prototype , "angle" , {
2013-08-30 19:05:29 +00:00
get : function ( ) {
2014-02-07 18:44:58 +00:00
2013-10-07 23:58:20 +00:00
return Phaser . Math . wrapAngle ( Phaser . Math . radToDeg ( this . rotation ) ) ;
2014-02-07 18:44:58 +00:00
2013-08-30 19:05:29 +00:00
} ,
set : function ( value ) {
2014-02-07 18:44:58 +00:00
2013-10-07 23:58:20 +00:00
this . rotation = Phaser . Math . degToRad ( Phaser . Math . wrapAngle ( value ) ) ;
2014-02-07 18:44:58 +00:00
2013-08-30 19:05:29 +00:00
}
} ) ;
2013-10-01 12:54:29 +00:00
/ * *
2014-02-07 18:44:58 +00:00
* Returns the delta x value . The difference between world . x now and in the previous step .
*
2014-02-07 19:44:14 +00:00
* @ name Phaser . Sprite # deltaX
2014-02-07 18:44:58 +00:00
* @ property { number } deltaX - The delta value . Positive if the motion was to the right , negative if to the left .
* @ readonly
2013-10-01 12:54:29 +00:00
* /
2014-02-07 18:44:58 +00:00
Object . defineProperty ( Phaser . Sprite . prototype , "deltaX" , {
get : function ( ) {
return this . world . x - this . _cache [ 0 ] ;
2013-08-30 03:20:14 +00:00
}
} ) ;
2013-10-01 12:54:29 +00:00
/ * *
2014-02-07 18:44:58 +00:00
* Returns the delta y value . The difference between world . y now and in the previous step .
*
2014-02-07 19:44:14 +00:00
* @ name Phaser . Sprite # deltaY
2014-02-07 18:44:58 +00:00
* @ property { number } deltaY - The delta value . Positive if the motion was downwards , negative if upwards .
* @ readonly
2013-10-01 12:54:29 +00:00
* /
2014-02-07 18:44:58 +00:00
Object . defineProperty ( Phaser . Sprite . prototype , "deltaY" , {
get : function ( ) {
2014-03-23 07:59:28 +00:00
2014-02-07 18:44:58 +00:00
return this . world . y - this . _cache [ 1 ] ;
2013-08-30 03:20:14 +00:00
}
} ) ;
2013-10-01 12:54:29 +00:00
/ * *
2014-02-07 18:44:58 +00:00
* Returns the delta z value . The difference between rotation now and in the previous step .
*
2014-02-07 19:44:14 +00:00
* @ name Phaser . Sprite # deltaZ
2014-02-07 18:44:58 +00:00
* @ property { number } deltaZ - The delta value .
2013-10-25 14:02:21 +00:00
* @ readonly
2013-10-01 12:54:29 +00:00
* /
2014-02-07 18:44:58 +00:00
Object . defineProperty ( Phaser . Sprite . prototype , "deltaZ" , {
get : function ( ) {
2014-03-23 07:59:28 +00:00
2014-02-07 18:44:58 +00:00
return this . rotation - this . _cache [ 2 ] ;
2013-09-02 22:22:24 +00:00
}
} ) ;
2013-09-08 12:23:21 +00:00
2014-01-29 17:10:13 +00:00
/ * *
2014-02-15 01:27:42 +00:00
* Checks if the Sprite bounds are within the game world , otherwise false if fully outside of it .
2014-02-07 18:44:58 +00:00
*
2014-02-07 19:44:14 +00:00
* @ name Phaser . Sprite # inWorld
2014-02-15 01:27:42 +00:00
* @ property { boolean } inWorld - True if the Sprite bounds is within the game world , even if only partially . Otherwise false if fully outside of it .
2014-01-29 17:10:13 +00:00
* @ readonly
* /
2014-02-07 18:44:58 +00:00
Object . defineProperty ( Phaser . Sprite . prototype , "inWorld" , {
get : function ( ) {
return this . game . world . bounds . intersects ( this . getBounds ( ) ) ;
2014-01-29 17:10:13 +00:00
}
} ) ;
/ * *
2014-02-15 01:27:42 +00:00
* Checks if the Sprite bounds are within the game camera , otherwise false if fully outside of it .
2014-02-07 18:44:58 +00:00
*
2014-02-07 19:44:14 +00:00
* @ name Phaser . Sprite # inCamera
2014-02-15 01:27:42 +00:00
* @ property { boolean } inCamera - True if the Sprite bounds is within the game camera , even if only partially . Otherwise false if fully outside of it .
2014-01-29 17:10:13 +00:00
* @ readonly
* /
2014-02-07 18:44:58 +00:00
Object . defineProperty ( Phaser . Sprite . prototype , "inCamera" , {
get : function ( ) {
2014-03-23 07:59:28 +00:00
2014-07-10 15:38:15 +00:00
return this . game . world . camera . screenView . intersects ( this . getBounds ( ) ) ;
2014-02-07 18:44:58 +00:00
2014-01-29 17:10:13 +00:00
}
} ) ;
2013-10-01 12:54:29 +00:00
/ * *
2014-02-07 18:44:58 +00:00
* @ name Phaser . Sprite # frame
* @ property { number } frame - Gets or sets the current frame index and updates the Texture Cache for display .
2013-10-25 14:02:21 +00:00
* /
2014-02-07 18:44:58 +00:00
Object . defineProperty ( Phaser . Sprite . prototype , "frame" , {
get : function ( ) {
return this . animations . frame ;
} ,
2013-09-11 02:55:53 +00:00
2014-02-07 18:44:58 +00:00
set : function ( value ) {
this . animations . frame = value ;
}
2013-09-11 02:55:53 +00:00
2014-02-07 18:44:58 +00:00
} ) ;
/ * *
* @ name Phaser . Sprite # frameName
* @ property { string } frameName - Gets or sets the current frame name and updates the Texture Cache for display .
* /
Object . defineProperty ( Phaser . Sprite . prototype , "frameName" , {
2013-10-24 20:21:00 +00:00
2014-02-07 18:44:58 +00:00
get : function ( ) {
return this . animations . frameName ;
} ,
2013-10-24 20:21:00 +00:00
2014-02-07 18:44:58 +00:00
set : function ( value ) {
this . animations . frameName = value ;
}
2013-09-11 02:55:53 +00:00
2014-02-07 18:44:58 +00:00
} ) ;
2013-09-11 02:55:53 +00:00
2013-10-24 03:27:28 +00:00
/ * *
2014-02-07 19:44:14 +00:00
* @ name Phaser . Sprite # renderOrderID
2014-02-07 18:44:58 +00:00
* @ property { number } renderOrderID - The render order ID , reset every frame .
* @ readonly
2013-10-25 14:02:21 +00:00
* /
2014-02-07 18:44:58 +00:00
Object . defineProperty ( Phaser . Sprite . prototype , "renderOrderID" , {
2013-10-24 03:27:28 +00:00
2014-02-07 18:44:58 +00:00
get : function ( ) {
2013-10-24 20:21:00 +00:00
2014-02-07 18:44:58 +00:00
return this . _cache [ 3 ] ;
2013-10-24 20:21:00 +00:00
2014-02-07 18:44:58 +00:00
}
2013-09-11 02:55:53 +00:00
2014-02-07 18:44:58 +00:00
} ) ;
2013-09-11 02:55:53 +00:00
2013-10-01 12:54:29 +00:00
/ * *
2014-02-09 22:48:35 +00:00
* By default a Sprite won ' t process any input events at all . By setting inputEnabled to true the Phaser . InputHandler is
2014-02-07 18:44:58 +00:00
* activated for this object and it will then start to process click / touch events and more .
2013-10-25 14:02:21 +00:00
*
2014-02-07 19:44:14 +00:00
* @ name Phaser . Sprite # inputEnabled
2014-02-07 18:44:58 +00:00
* @ property { boolean } inputEnabled - Set to true to allow this object to receive input events .
2013-10-01 12:54:29 +00:00
* /
2013-09-08 12:23:21 +00:00
Object . defineProperty ( Phaser . Sprite . prototype , "inputEnabled" , {
2014-03-23 07:59:28 +00:00
2013-09-08 12:23:21 +00:00
get : function ( ) {
2014-02-07 18:44:58 +00:00
return ( this . input && this . input . enabled ) ;
2013-09-08 12:23:21 +00:00
} ,
set : function ( value ) {
if ( value )
{
2014-02-07 18:44:58 +00:00
if ( this . input === null )
2013-09-08 12:23:21 +00:00
{
2014-02-07 18:44:58 +00:00
this . input = new Phaser . InputHandler ( this ) ;
2013-09-08 12:23:21 +00:00
this . input . start ( ) ;
}
2014-03-31 09:43:37 +00:00
else if ( this . input && ! this . input . enabled )
{
this . input . start ( ) ;
}
2013-09-08 12:23:21 +00:00
}
else
{
2014-02-07 18:44:58 +00:00
if ( this . input && this . input . enabled )
2013-09-08 12:23:21 +00:00
{
this . input . stop ( ) ;
}
}
2014-03-31 09:43:37 +00:00
2013-09-08 12:23:21 +00:00
}
} ) ;
2014-02-10 16:01:30 +00:00
2014-02-13 09:55:46 +00:00
/ * *
2014-02-13 12:26:39 +00:00
* Sprite . exists controls if the core game loop and physics update this Sprite or not .
* When you set Sprite . exists to false it will remove its Body from the physics world ( if it has one ) and also set Sprite . visible to false .
* Setting Sprite . exists to true will re - add the Body to the physics world ( if it has a body ) and set Sprite . visible to true .
*
2014-02-13 09:55:46 +00:00
* @ name Phaser . Sprite # exists
2014-02-13 12:26:39 +00:00
* @ property { boolean } exists - If the Sprite is processed by the core game update and physics .
2014-02-13 09:55:46 +00:00
* /
Object . defineProperty ( Phaser . Sprite . prototype , "exists" , {
2014-03-23 07:59:28 +00:00
2014-02-13 09:55:46 +00:00
get : function ( ) {
2014-02-13 16:05:19 +00:00
return ! ! this . _cache [ 6 ] ;
2014-02-13 09:55:46 +00:00
} ,
set : function ( value ) {
if ( value )
{
// exists = true
this . _cache [ 6 ] = 1 ;
2014-03-13 15:41:56 +00:00
if ( this . body && this . body . type === Phaser . Physics . P2JS )
2014-02-13 09:55:46 +00:00
{
this . body . addToWorld ( ) ;
}
2014-02-13 12:26:39 +00:00
this . visible = true ;
2014-02-13 09:55:46 +00:00
}
else
{
// exists = false
this . _cache [ 6 ] = 0 ;
2014-03-13 15:41:56 +00:00
if ( this . body && this . body . type === Phaser . Physics . P2JS )
2014-02-13 09:55:46 +00:00
{
2014-03-13 21:14:10 +00:00
this . body . removeFromWorld ( ) ;
2014-02-13 09:55:46 +00:00
}
2014-02-13 12:26:39 +00:00
this . visible = false ;
2014-02-13 09:55:46 +00:00
}
}
} ) ;
2014-02-15 01:27:42 +00:00
/ * *
* An Sprite that is fixed to the camera uses its x / y coordinates as offsets from the top left of the camera . These are stored in Sprite . cameraOffset .
* Note that the cameraOffset values are in addition to any parent in the display list .
* So if this Sprite was in a Group that has x : 200 , then this will be added to the cameraOffset . x
*
* @ name Phaser . Sprite # fixedToCamera
* @ property { boolean } fixedToCamera - Set to true to fix this Sprite to the Camera at its current world coordinates .
* /
Object . defineProperty ( Phaser . Sprite . prototype , "fixedToCamera" , {
2014-03-23 07:59:28 +00:00
2014-02-15 01:27:42 +00:00
get : function ( ) {
return ! ! this . _cache [ 7 ] ;
} ,
set : function ( value ) {
if ( value )
{
this . _cache [ 7 ] = 1 ;
this . cameraOffset . set ( this . x , this . y ) ;
}
else
{
this . _cache [ 7 ] = 0 ;
}
}
} ) ;
2014-02-25 04:40:44 +00:00
/ * *
* Enable or disable texture smoothing for this Sprite . Only works for bitmap / image textures . Smoothing is enabled by default .
*
* @ name Phaser . Sprite # smoothed
* @ property { boolean } smoothed - Set to true to smooth the texture of this Sprite , or false to disable smoothing ( great for pixel art )
* /
Object . defineProperty ( Phaser . Sprite . prototype , "smoothed" , {
2014-03-23 07:59:28 +00:00
2014-02-25 04:40:44 +00:00
get : function ( ) {
2014-02-27 21:57:57 +00:00
return ! this . texture . baseTexture . scaleMode ;
2014-02-25 04:40:44 +00:00
} ,
set : function ( value ) {
if ( value )
{
if ( this . texture )
{
this . texture . baseTexture . scaleMode = 0 ;
}
}
else
{
if ( this . texture )
{
this . texture . baseTexture . scaleMode = 1 ;
}
}
}
} ) ;
2014-03-28 01:42:49 +00:00
/ * *
* The position of the Sprite on the x axis relative to the local coordinates of the parent .
*
* @ name Phaser . Sprite # x
* @ property { number } x - The position of the Sprite on the x axis relative to the local coordinates of the parent .
* /
Object . defineProperty ( Phaser . Sprite . prototype , "x" , {
get : function ( ) {
return this . position . x ;
} ,
set : function ( value ) {
this . position . x = value ;
if ( this . body && this . body . type === Phaser . Physics . ARCADE && this . body . phase === 2 )
{
this . body . _reset = 1 ;
}
}
} ) ;
/ * *
* The position of the Sprite on the y axis relative to the local coordinates of the parent .
*
* @ name Phaser . Sprite # y
* @ property { number } y - The position of the Sprite on the y axis relative to the local coordinates of the parent .
* /
Object . defineProperty ( Phaser . Sprite . prototype , "y" , {
get : function ( ) {
return this . position . y ;
} ,
set : function ( value ) {
this . position . y = value ;
if ( this . body && this . body . type === Phaser . Physics . ARCADE && this . body . phase === 2 )
{
this . body . _reset = 1 ;
}
}
} ) ;
2014-04-22 00:43:22 +00:00
/ * *
* @ name Phaser . Sprite # destroyPhase
* @ property { boolean } destroyPhase - True if this object is currently being destroyed .
* /
Object . defineProperty ( Phaser . Sprite . prototype , "destroyPhase" , {
get : function ( ) {
return ! ! this . _cache [ 8 ] ;
}
} ) ;