Class Bullet

If no Display List is specified, it will default to the Display List owned by the Scene to which this Game Object belongs.

A Game Object can only exist on one Display List at any given time, but may move freely between them.

If this Game Object is already on another Display List when this method is called, it will first be removed from it, before being added to the new list.

You can query which list it is on by looking at the Phaser.GameObjects.GameObject#displayList property.

If a Game Object isn't on any display list, it will not be rendered. If you just wish to temporarly disable it from rendering, consider using the setVisible method, instead.

When a Game Object is added to the Update List it will have its preUpdate method called every game frame. This method is passed two parameters: delta and time.

If you wish to run your own logic within preUpdate then you should always call super.preUpdate(delta, time) within it, or it may fail to process required operations, such as Sprite animations.

Can be overriden by custom Game Objects, but be aware of some Game Objects that will use this, such as Sprites, to add themselves into the Update List.

You can also listen for the ADDED_TO_SCENE event from this Game Object.

The current animation must enter a 'completed' state for this to happen, i.e. finish all of its repeats, delays, etc, or have the stop method called directly on it.

An animation set to repeat forever will never enter a completed state.

You can chain a new animation at any point, including before the current one starts playing, during it, or when it ends (via its animationcomplete event).

Chained animations are specific to a Game Object, meaning different Game Objects can have different chained animations without impacting the animation they're playing.

Call this method with no arguments to reset all currently chained animations.

When playing an animation on a Sprite it will first check to see if it can find a matching key locally within the Sprite. If it can, it will play the local animation. If not, it will then search the global Animation Manager and look for it there.

Immediately sets the alpha levels back to 1 (fully opaque).

If you wish to remove a single controller, use the preFX.remove(fx) or postFX.remove(fx) methods instead.

If you wish to clear a single controller, use the preFX.clear() or postFX.clear() methods instead.

Immediately sets the color values back to 0xffffff and the tint type to 'additive', which results in no visible change to the texture.

Also removes itself from the Input Manager and Physics Manager if previously enabled.

Use this to remove a Game Object from your game if you don't ever plan to use it again. As long as no reference to it exists within your own code it should become free for garbage collection by the browser.

If you just want to temporarily disable an object then look at using the Game Object Pool instead of destroying it, as destroyed objects cannot be resurrected.

An object that is disabled for input stops processing or being considered for input events, but can be turned back on again at any time by simply calling setInteractive() with no arguments provided.

If want to completely remove interaction from this Game Object then use removeInteractive instead.

If this Game Object is not on a display list or in a container, it will return null.

You should be very careful with this method, and understand that it returns a direct reference to the internal array used by the Display List. Mutating this array directly can cause all kinds of subtle and difficult to debug issues in your game.

Used internally by the InputPlugin but also useful if you wish to find out the display depth of this Game Object and all of its ancestors.

The returned Vector2 contains the translated point in its properties.

A Camera needs to be provided in order to handle modified scroll factors. If no camera is specified, it will use the main camera from the Scene to which this Game Object belongs.

The returned value is in radians and will be zero if this Game Object has no parent container.

If the Game Object has not been enabled for data (via setDataEnabled) then it will be enabled before setting the value.

If the key doesn't already exist in the Data Manager then it is created.

When the value is first set, a setdata event is emitted from this Game Object.

This should only be called during the instantiation of the Game Object. After that, use setPipeline.

It is called by default by all core Game Objects and doesn't need calling again.

After that, use setPostPipeline.

Animations in Phaser can either belong to the global Animation Manager, or specifically to this Sprite.

The benefit of a global animation is that multiple Sprites can all play the same animation, without having to duplicate the data. You can just create it once and then play it on any Sprite.

The following code shows how to create a global repeating animation. The animation will be created from all of the frames within the sprite sheet that was loaded with the key 'muybridge':

var config = {
    key: 'run',
    frames: 'muybridge',
    frameRate: 15,
    repeat: -1
};

//  This code should be run from within a Scene:
this.anims.create(config);

However, if you wish to create an animation that is unique to this Sprite, and this Sprite alone, you can call the Animation.create method instead. It accepts the exact same parameters as when creating a global animation, however the resulting data is kept locally in this Sprite.

With the animation created, either globally or locally, you can now play it on this Sprite:

this.add.sprite(x, y).play('run');

Alternatively, if you wish to run it at a different frame rate, for example, you can pass a config object instead:

this.add.sprite(x, y).play({ key: 'run', frameRate: 24 });

When playing an animation on a Sprite it will first check to see if it can find a matching key locally within the Sprite. If it can, it will play the local animation. If not, it will then search the global Animation Manager and look for it there.

If you need a Sprite to be able to play both local and global animations, make sure they don't have conflicting keys.

See the documentation for the PlayAnimationConfig config object for more details about this.

Also, see the documentation in the Animation Manager for further details on creating animations.

If the animation also has a delay value set in its config, it will be added to the delay given here.

If an animation is already running and a new animation is given to this method, it will wait for the given delay before starting the new animation.

If no animation is currently running, the given one begins after the delay.

When playing an animation on a Sprite it will first check to see if it can find a matching key locally within the Sprite. If it can, it will play the local animation. If not, it will then search the global Animation Manager and look for it there.

Prior to Phaser 3.50 this method was called 'delayedPlay'.

You can use this to ensure there are no harsh jumps between two sets of animations, i.e. going from an idle animation to a walking animation, by making them blend smoothly into each other.

If no animation is currently running, the given one will start immediately.

When playing an animation on a Sprite it will first check to see if it can find a matching key locally within the Sprite. If it can, it will play the local animation. If not, it will then search the global Animation Manager and look for it there.

Animations in Phaser can either belong to the global Animation Manager, or specifically to this Sprite.

The benefit of a global animation is that multiple Sprites can all play the same animation, without having to duplicate the data. You can just create it once and then play it on any Sprite.

The following code shows how to create a global repeating animation. The animation will be created from all of the frames within the sprite sheet that was loaded with the key 'muybridge':

var config = {
    key: 'run',
    frames: 'muybridge',
    frameRate: 15,
    repeat: -1
};

//  This code should be run from within a Scene:
this.anims.create(config);

However, if you wish to create an animation that is unique to this Sprite, and this Sprite alone, you can call the Animation.create method instead. It accepts the exact same parameters as when creating a global animation, however the resulting data is kept locally in this Sprite.

With the animation created, either globally or locally, you can now play it on this Sprite:

this.add.sprite(x, y).playReverse('run');

Alternatively, if you wish to run it at a different frame rate, for example, you can pass a config object instead:

this.add.sprite(x, y).playReverse({ key: 'run', frameRate: 24 });

When playing an animation on a Sprite it will first check to see if it can find a matching key locally within the Sprite. If it can, it will play the local animation. If not, it will then search the global Animation Manager and look for it there.

If you need a Sprite to be able to play both local and global animations, make sure they don't have conflicting keys.

See the documentation for the PlayAnimationConfig config object for more details about this.

Also, see the documentation in the Animation Manager for further details on creating animations.

A Game Object can only exist on one Display List at any given time, but may move freely removed and added back at a later stage.

You can query which list it is on by looking at the Phaser.GameObjects.GameObject#displayList property.

If a Game Object isn't on any Display List, it will not be rendered. If you just wish to temporarly disable it from rendering, consider using the setVisible method, instead.

When a Game Object is on the Update List, it will have its preUpdate method called every game frame. Calling this method will remove it from the list, preventing this.

Removing a Game Object from the Update List will stop most internal functions working. For example, removing a Sprite from the Update List will prevent it from being able to run animations.

The Interactive Object that was assigned to this Game Object will be destroyed, removed from the Input Manager and cleared from this Game Object.

If you wish to re-enable this Game Object at a later date you will need to re-create its InteractiveObject by calling setInteractive again.

If you wish to only temporarily stop an object from receiving input then use disableInteractive instead, as that toggles the interactive state, where-as this erases it completely.

If you wish to resize a hit area, don't remove and then set it as being interactive. Instead, access the hitarea object directly and resize the shape being used. I.e.: sprite.input.hitArea.setSize(width, height) (assuming the shape is a Rectangle, which it is by default.)

If you wish to remove all Post Pipelines use the resetPostPipeline method instead.

Can be overriden by custom Game Objects, but be aware of some Game Objects that will use this, such as Sprites, to removed themselves from the Update List.

You can also listen for the REMOVED_FROM_SCENE event from this Game Object.

This means it will render immediately after the other object in the display list.

Both objects must belong to the same display list, or parent container.

This method does not change this Game Objects depth value, it simply alters its list position.

If your game is running under WebGL you can optionally specify four different alpha values, each of which correspond to the four corners of the Game Object. Under Canvas only the topLeft value given is used.

This means it will render immediately under the other object in the display list.

Both objects must belong to the same display list, or parent container.

This method does not change this Game Objects depth value, it simply alters its list position.

This can be a const, such as Phaser.BlendModes.SCREEN, or an integer, such as 4 (for Overlay)

Under WebGL only the following Blend Modes are available:

• NORMAL
• ADD
• MULTIPLY
• SCREEN
• ERASE (only works when rendering to a framebuffer, like a Render Texture)

Canvas has more available depending on browser support.

You can also create your own custom Blend Modes in WebGL.

Blend modes have different effects under Canvas and WebGL, and from browser to browser, depending on support. Blend Modes also cause a WebGL batch flush should it encounter a new blend mode. For these reasons try to be careful about the construction of your Scene and the frequency in which blend modes are used.

The crop is a rectangle that limits the area of the texture frame that is visible during rendering.

Cropping a Game Object does not change its size, dimensions, physics body or hit area, it just changes what is shown when rendered.

The crop size as well as coordinates can not exceed the the size of the texture frame.

The crop coordinates are relative to the texture frame, not the Game Object, meaning 0 x 0 is the top-left.

Therefore, if you had a Game Object that had an 800x600 sized texture, and you wanted to show only the left half of it, you could call setCrop(0, 0, 400, 600).

It is also scaled to match the Game Object scale automatically. Therefore a crop rectangle of 100x50 would crop an area of 200x100 when applied to a Game Object that had a scale factor of 2.

You can either pass in numeric values directly, or you can provide a single Rectangle object as the first argument.

Call this method with no arguments at all to reset the crop, or toggle the property isCropped to false.

You should do this if the crop rectangle becomes the same size as the frame itself, as it will allow the renderer to skip several internal calculations.

The depth is also known as the 'z-index' in some environments, and allows you to change the rendering order of Game Objects, without actually moving their position in the display list.

The default depth is zero. A Game Object with a higher depth value will always render in front of one with a lower value.

Setting the depth will queue a depth sort event within the Scene.

Calling this will adjust the scale.

A Game Object that is flipped will render inversed on the flipped axis. Flipping always takes place from the middle of the texture and does not impact the scale value. If this Game Object has a physics body, it will not change the body. This is a rendering toggle only.

A Game Object that is flipped horizontally will render inversed on the horizontal axis. Flipping always takes place from the middle of the texture and does not impact the scale value. If this Game Object has a physics body, it will not change the body. This is a rendering toggle only.

If you pass a string or index then the Frame has to belong to the current Texture being used by this Game Object.

If you pass a Frame instance, then the Texture being used by this Game Object will also be updated.

Calling setFrame will modify the width and height properties of your Game Object.

It will also change the origin if the Frame has a custom pivot point, as exported from packages like Texture Packer.

Input works by using hit areas, these are nearly always geometric shapes, such as rectangles or circles, that act as the hit area for the Game Object. However, you can provide your own hit area shape and callback, should you wish to handle some more advanced input detection.

If no arguments are provided it will try and create a rectangle hit area based on the texture frame the Game Object is using. If this isn't a texture-bound object, such as a Graphics or BitmapText object, this will fail, and you'll need to provide a specific shape for it to use.

You can also provide an Input Configuration Object as the only argument to this method.

The mask must have been previously created and can be either a GeometryMask or a BitmapMask. Note: Bitmap Masks only work on WebGL. Geometry Masks work on both WebGL and Canvas.

If a mask is already set on this Game Object it will be immediately replaced.

Masks are positioned in global space and are not relative to the Game Object to which they are applied. The reason for this is that multiple Game Objects can all share the same mask.

Masks have no impact on physics or input detection. They are purely a rendering component that allows you to limit what is visible during the render pass.

The values are given in the range 0 to 1.

Also sets the pipelineData property, if the parameter is given.

If the 'key' already exists, its value is updated. If it doesn't exist, it is created.

If value is undefined, and key exists, key is removed from the data object.

Post Pipelines are invoked after this Game Object has rendered to its target and are commonly used for post-fx.

The post pipelines are appended to the postPipelines array belonging to this Game Object. When the renderer processes this Game Object, it iterates through the post pipelines in the order in which they appear in the array. If you are stacking together multiple effects, be aware that the order is important.

If you call this method multiple times, the new pipelines will be appended to any existing post pipelines already set. Use the resetPostPipeline method to clear them first, if required.

You can optionally also set the postPipelineData property, if the parameter is given.

If the 'key' already exists, its value is updated. If it doesn't exist, it is created.

If value is undefined, and key exists, key is removed from the data object.

If no area is specified a random position between 0 x 0 and the game width x height is used instead.

The position does not factor in the size of this Game Object, meaning that only the origin is guaranteed to be within the area.

The scroll factor controls the influence of the movement of a Camera upon this Game Object.

When a camera scrolls it will change the location at which this Game Object is rendered on-screen. It does not change the Game Objects actual position values.

A value of 1 means it will move exactly in sync with a camera. A value of 0 means it will not move at all, even if the camera moves. Other values control the degree to which the camera movement is mapped to this Game Object.

Please be aware that scroll factor values other than 1 are not taken in to consideration when calculating physics collisions. Bodies always collide based on their world position, but changing the scroll factor is a visual adjustment to where the textures are rendered, which can offset them from physics bodies if not accounted for in your code.

This will not change the size that the Game Object is rendered in-game. For that you need to either set the scale of the Game Object (setScale) or call the setDisplaySize method, which is the same thing as changing the scale but allows you to do so by giving pixel values.

If you have enabled this Game Object for input, changing the size will not change the size of the hit area. To do this you should adjust the input.hitArea object directly.

This will not change the size that the Game Object is rendered in-game. For that you need to either set the scale of the Game Object (setScale) or call the setDisplaySize method, which is the same thing as changing the scale but allows you to do so by giving pixel values.

If you have enabled this Game Object for input, changing the size will not change the size of the hit area. To do this you should adjust the input.hitArea object directly.

Phaser itself will never modify the State of a Game Object, although plugins may do so.

For example, a Game Object could change from a state of 'moving', to 'attacking', to 'dead'. The state value should typically be an integer (ideally mapped to a constant in your game code), but could also be a string. It is recommended to keep it light and simple. If you need to store complex data about your Game Object, look at using the Data Component instead.

Textures are referenced by their string-based keys, as stored in the Texture Manager.

The tint works by taking the pixel color values from the Game Objects texture, and then multiplying it by the color value of the tint. You can provide either one color value, in which case the whole Game Object will be tinted in that color. Or you can provide a color per corner. The colors are blended together across the extent of the Game Object.

To modify the tint color once set, either call this method again with new values or use the tint property to set all colors at once. Or, use the properties tintTopLeft, tintTopRight, tintBottomLeftandtintBottomRight` to set the corner color values independently.

To remove a tint call clearTint.

To swap this from being an additive tint to a fill based tint set the property tintFill to true.

Unlike an additive tint, a fill-tint literally replaces the pixel colors from the texture with those in the tint. You can use this for effects such as making a player flash 'white' if hit by something. You can provide either one color value, in which case the whole Game Object will be rendered in that color. Or you can provide a color per corner. The colors are blended together across the extent of the Game Object.

To modify the tint color once set, either call this method again with new values or use the tint property to set all colors at once. Or, use the properties tintTopLeft, tintTopRight, tintBottomLeftandtintBottomRight` to set the corner color values independently.

To remove a tint call clearTint.

To swap this from being a fill-tint to an additive tint set the property tintFill to false.

Being at the back means it will render below everything else.

This method does not change this Game Objects depth value, it simply alters its list position.

Being at the top means it will render on-top of everything else.

This method does not change this Game Objects depth value, it simply alters its list position.

An invisible Game Object will skip rendering, but will still process update logic.

Note: The z position does not control the rendering order of 2D Game Objects. Use {@link Phaser.GameObjects.Components.Depth#setDepth} instead.

If no animation is playing, no event will be dispatched.

If there is another animation queued (via the chain method) then it will start playing immediately.

It then dispatches the ANIMATION_STOP event.

If no animation is running, no events will be dispatched.

If there is another animation in the queue (set via the chain method) then it will start playing, when the current one stops.

It then dispatches the ANIMATION_STOP event.

If no animation is running, no events will be dispatched.

If there is another animation in the queue (set via the chain method) then it will start playing, when the current one stops.

It then dispatches the ANIMATION_STOP event.

If no animation is running, no events will be dispatched.

If there is another animation in the queue (set via the chain method) then it will start playing, when the current one stops.

If the Game Object has not been enabled for data (via setDataEnabled) then it will be enabled before setting the value.

If the key doesn't already exist in the Data Manager then it is created.

When the value is first set, a setdata event is emitted from this Game Object.

A Game Object that is flipped horizontally will render inversed on the horizontal axis. Flipping always takes place from the middle of the texture and does not impact the scale value. If this Game Object has a physics body, it will not change the body. This is a rendering toggle only.