2018-02-12 16:01:20 +00:00
|
|
|
/**
|
|
|
|
* @author Richard Davey <rich@photonstorm.com>
|
2022-02-28 14:29:51 +00:00
|
|
|
* @copyright 2022 Photon Storm Ltd.
|
2019-05-10 15:15:04 +00:00
|
|
|
* @license {@link https://opensource.org/licenses/MIT|MIT License}
|
2018-02-12 16:01:20 +00:00
|
|
|
*/
|
|
|
|
|
2017-02-23 03:10:48 +00:00
|
|
|
var Class = require('../utils/Class');
|
2018-09-03 12:12:37 +00:00
|
|
|
var ComponentsToJSON = require('./components/ToJSON');
|
2018-01-30 00:55:27 +00:00
|
|
|
var DataManager = require('../data/DataManager');
|
2018-01-12 17:09:09 +00:00
|
|
|
var EventEmitter = require('eventemitter3');
|
2019-01-18 14:21:45 +00:00
|
|
|
var Events = require('./events');
|
2021-03-03 17:58:12 +00:00
|
|
|
var SceneEvents = require('../scene/events');
|
2016-12-07 02:28:22 +00:00
|
|
|
|
2018-01-31 13:54:44 +00:00
|
|
|
/**
|
2018-02-07 15:27:21 +00:00
|
|
|
* @classdesc
|
2018-01-31 13:54:44 +00:00
|
|
|
* The base class that all Game Objects extend.
|
|
|
|
* You don't create GameObjects directly and they cannot be added to the display list.
|
|
|
|
* Instead, use them as the base for your own custom classes.
|
|
|
|
*
|
|
|
|
* @class GameObject
|
2018-10-10 09:49:13 +00:00
|
|
|
* @memberof Phaser.GameObjects
|
2018-03-21 14:09:58 +00:00
|
|
|
* @extends Phaser.Events.EventEmitter
|
2018-01-31 13:54:44 +00:00
|
|
|
* @constructor
|
|
|
|
* @since 3.0.0
|
|
|
|
*
|
|
|
|
* @param {Phaser.Scene} scene - The Scene to which this Game Object belongs.
|
|
|
|
* @param {string} type - A textual representation of the type of Game Object, i.e. `sprite`.
|
|
|
|
*/
|
2017-02-23 03:10:48 +00:00
|
|
|
var GameObject = new Class({
|
2016-12-07 02:28:22 +00:00
|
|
|
|
2018-01-12 17:09:09 +00:00
|
|
|
Extends: EventEmitter,
|
|
|
|
|
2017-02-23 03:10:48 +00:00
|
|
|
initialize:
|
2016-12-07 02:28:22 +00:00
|
|
|
|
2017-07-14 13:30:20 +00:00
|
|
|
function GameObject (scene, type)
|
2017-02-23 03:10:48 +00:00
|
|
|
{
|
2018-01-12 17:09:09 +00:00
|
|
|
EventEmitter.call(this);
|
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
2020-09-13 14:17:07 +00:00
|
|
|
* A reference to the Scene to which this Game Object belongs.
|
|
|
|
*
|
2017-09-12 23:58:25 +00:00
|
|
|
* Game Objects can only belong to one Scene.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2020-09-13 14:17:07 +00:00
|
|
|
* You should consider this property as being read-only. You cannot move a
|
|
|
|
* Game Object to another Scene by simply changing it.
|
|
|
|
*
|
2018-02-01 00:04:45 +00:00
|
|
|
* @name Phaser.GameObjects.GameObject#scene
|
|
|
|
* @type {Phaser.Scene}
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-07-14 13:30:20 +00:00
|
|
|
this.scene = scene;
|
2016-12-07 02:28:22 +00:00
|
|
|
|
2020-11-27 11:13:59 +00:00
|
|
|
/**
|
|
|
|
* Holds a reference to the Display List that contains this Game Object.
|
|
|
|
*
|
|
|
|
* This is set automatically when this Game Object is added to a Scene or Layer.
|
|
|
|
*
|
|
|
|
* You should treat this property as being read-only.
|
|
|
|
*
|
|
|
|
* @name Phaser.GameObjects.GameObject#displayList
|
|
|
|
* @type {(Phaser.GameObjects.DisplayList|Phaser.GameObjects.Layer)}
|
|
|
|
* @default null
|
|
|
|
* @since 3.50.0
|
|
|
|
*/
|
|
|
|
this.displayList = null;
|
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
2017-09-12 23:58:25 +00:00
|
|
|
* A textual representation of this Game Object, i.e. `sprite`.
|
|
|
|
* Used internally by Phaser but is available for your own custom classes to populate.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-02-01 00:04:45 +00:00
|
|
|
* @name Phaser.GameObjects.GameObject#type
|
|
|
|
* @type {string}
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-04-12 23:05:12 +00:00
|
|
|
this.type = type;
|
2017-07-04 00:59:31 +00:00
|
|
|
|
2018-11-07 15:11:59 +00:00
|
|
|
/**
|
|
|
|
* The current state of this Game Object.
|
2020-08-24 18:18:29 +00:00
|
|
|
*
|
2018-11-07 15:11:59 +00:00
|
|
|
* Phaser itself will never modify this value, although plugins may do so.
|
2020-08-24 18:18:29 +00:00
|
|
|
*
|
2020-01-02 16:45:28 +00:00
|
|
|
* Use this property to track the state of a Game Object during its lifetime. For example, it could change from
|
2018-11-21 02:24:54 +00:00
|
|
|
* a state of 'moving', to 'attacking', to 'dead'. The state value should be an integer (ideally mapped to a constant
|
|
|
|
* in your game code), or a string. These are recommended to keep it light and simple, with fast comparisons.
|
2018-11-07 15:11:59 +00:00
|
|
|
* If you need to store complex data about your Game Object, look at using the Data Component instead.
|
|
|
|
*
|
|
|
|
* @name Phaser.GameObjects.GameObject#state
|
2020-11-23 10:32:00 +00:00
|
|
|
* @type {(number|string)}
|
2018-11-07 15:11:59 +00:00
|
|
|
* @since 3.16.0
|
|
|
|
*/
|
|
|
|
this.state = 0;
|
|
|
|
|
2018-04-05 13:56:43 +00:00
|
|
|
/**
|
|
|
|
* The parent Container of this Game Object, if it has one.
|
|
|
|
*
|
|
|
|
* @name Phaser.GameObjects.GameObject#parentContainer
|
|
|
|
* @type {Phaser.GameObjects.Container}
|
|
|
|
* @since 3.4.0
|
|
|
|
*/
|
|
|
|
this.parentContainer = null;
|
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
2017-09-12 23:58:25 +00:00
|
|
|
* The name of this Game Object.
|
|
|
|
* Empty by default and never populated by Phaser, this is left for developers to use.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-02-01 00:04:45 +00:00
|
|
|
* @name Phaser.GameObjects.GameObject#name
|
|
|
|
* @type {string}
|
|
|
|
* @default ''
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-02-23 03:10:48 +00:00
|
|
|
this.name = '';
|
2017-07-04 00:59:31 +00:00
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
2017-09-12 23:58:25 +00:00
|
|
|
* The active state of this Game Object.
|
|
|
|
* A Game Object with an active state of `true` is processed by the Scenes UpdateList, if added to it.
|
2017-09-13 01:02:49 +00:00
|
|
|
* An active object is one which is having its logic and internal systems updated.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-02-01 00:04:45 +00:00
|
|
|
* @name Phaser.GameObjects.GameObject#active
|
|
|
|
* @type {boolean}
|
|
|
|
* @default true
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-07-07 00:56:02 +00:00
|
|
|
this.active = true;
|
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
2017-09-12 23:58:25 +00:00
|
|
|
* The Tab Index of the Game Object.
|
|
|
|
* Reserved for future use by plugins and the Input Manager.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-02-01 00:04:45 +00:00
|
|
|
* @name Phaser.GameObjects.GameObject#tabIndex
|
2020-11-23 10:22:13 +00:00
|
|
|
* @type {number}
|
2018-02-01 00:04:45 +00:00
|
|
|
* @default -1
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-05-01 00:27:35 +00:00
|
|
|
this.tabIndex = -1;
|
2016-12-07 02:28:22 +00:00
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
2018-01-30 00:55:27 +00:00
|
|
|
* A Data Manager.
|
2017-09-12 23:58:25 +00:00
|
|
|
* It allows you to store, query and get key/value paired information specific to this Game Object.
|
2018-01-30 00:55:27 +00:00
|
|
|
* `null` by default. Automatically created if you use `getData` or `setData` or `setDataEnabled`.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-02-01 00:04:45 +00:00
|
|
|
* @name Phaser.GameObjects.GameObject#data
|
|
|
|
* @type {Phaser.Data.DataManager}
|
|
|
|
* @default null
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2018-01-30 00:55:27 +00:00
|
|
|
this.data = null;
|
2017-09-08 00:59:53 +00:00
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
2017-09-13 01:02:49 +00:00
|
|
|
* The flags that are compared against `RENDER_MASK` to determine if this Game Object will render or not.
|
|
|
|
* The bits are 0001 | 0010 | 0100 | 1000 set by the components Visible, Alpha, Transform and Texture respectively.
|
|
|
|
* If those components are not used by your custom class then you can use this bitmask as you wish.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-02-01 00:04:45 +00:00
|
|
|
* @name Phaser.GameObjects.GameObject#renderFlags
|
2020-11-23 10:22:13 +00:00
|
|
|
* @type {number}
|
2018-02-01 00:04:45 +00:00
|
|
|
* @default 15
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-02-23 03:10:48 +00:00
|
|
|
this.renderFlags = 15;
|
2017-09-11 23:28:53 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* A bitmask that controls if this Game Object is drawn by a Camera or not.
|
2018-06-23 11:26:39 +00:00
|
|
|
* Not usually set directly, instead call `Camera.ignore`, however you can
|
|
|
|
* set this property directly using the Camera.id property:
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-06-23 11:26:39 +00:00
|
|
|
* @example
|
|
|
|
* this.cameraFilter |= camera.id
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-02-01 00:04:45 +00:00
|
|
|
* @name Phaser.GameObjects.GameObject#cameraFilter
|
|
|
|
* @type {number}
|
|
|
|
* @default 0
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-08-15 19:42:04 +00:00
|
|
|
this.cameraFilter = 0;
|
2017-07-07 17:12:57 +00:00
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
2017-09-13 01:02:49 +00:00
|
|
|
* If this Game Object is enabled for input then this property will contain an InteractiveObject instance.
|
|
|
|
* Not usually set directly. Instead call `GameObject.setInteractive()`.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-02-01 00:04:45 +00:00
|
|
|
* @name Phaser.GameObjects.GameObject#input
|
2019-05-09 11:02:03 +00:00
|
|
|
* @type {?Phaser.Types.Input.InteractiveObject}
|
2018-02-01 00:04:45 +00:00
|
|
|
* @default null
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-07-18 12:53:34 +00:00
|
|
|
this.input = null;
|
2017-07-13 01:05:32 +00:00
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
2020-02-04 21:13:44 +00:00
|
|
|
* If this Game Object is enabled for Arcade or Matter Physics then this property will contain a reference to a Physics Body.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-02-01 00:04:45 +00:00
|
|
|
* @name Phaser.GameObjects.GameObject#body
|
2020-05-02 23:16:16 +00:00
|
|
|
* @type {?(Phaser.Physics.Arcade.Body|Phaser.Physics.Arcade.StaticBody|MatterJS.BodyType)}
|
2018-02-01 00:04:45 +00:00
|
|
|
* @default null
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-08-15 22:35:16 +00:00
|
|
|
this.body = null;
|
|
|
|
|
2018-04-13 16:20:46 +00:00
|
|
|
/**
|
|
|
|
* This Game Object will ignore all calls made to its destroy method if this flag is set to `true`.
|
|
|
|
* This includes calls that may come from a Group, Container or the Scene itself.
|
|
|
|
* While it allows you to persist a Game Object across Scenes, please understand you are entirely
|
|
|
|
* responsible for managing references to and from this Game Object.
|
|
|
|
*
|
|
|
|
* @name Phaser.GameObjects.GameObject#ignoreDestroy
|
|
|
|
* @type {boolean}
|
|
|
|
* @default false
|
2018-04-15 11:44:47 +00:00
|
|
|
* @since 3.5.0
|
2018-04-13 16:20:46 +00:00
|
|
|
*/
|
|
|
|
this.ignoreDestroy = false;
|
|
|
|
|
2020-12-11 11:44:21 +00:00
|
|
|
this.on(Events.ADDED_TO_SCENE, this.addedToScene, this);
|
|
|
|
this.on(Events.REMOVED_FROM_SCENE, this.removedFromScene, this);
|
|
|
|
|
2017-09-12 16:08:43 +00:00
|
|
|
// Tell the Scene to re-sort the children
|
2018-04-13 16:12:17 +00:00
|
|
|
scene.sys.queueDepthSort();
|
2017-02-23 03:10:48 +00:00
|
|
|
},
|
2016-12-07 02:28:22 +00:00
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
|
|
|
* Sets the `active` property of this Game Object and returns this Game Object for further chaining.
|
2017-09-13 01:02:49 +00:00
|
|
|
* A Game Object with its `active` property set to `true` will be updated by the Scenes UpdateList.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-01-31 13:54:44 +00:00
|
|
|
* @method Phaser.GameObjects.GameObject#setActive
|
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2017-09-12 23:58:25 +00:00
|
|
|
* @param {boolean} value - True if this Game Object should be set as active, false if not.
|
2018-03-19 18:35:08 +00:00
|
|
|
*
|
2018-06-17 06:54:28 +00:00
|
|
|
* @return {this} This GameObject.
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-07-07 00:56:02 +00:00
|
|
|
setActive: function (value)
|
|
|
|
{
|
|
|
|
this.active = value;
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
|
|
|
* Sets the `name` property of this Game Object and returns this Game Object for further chaining.
|
2017-09-13 01:02:49 +00:00
|
|
|
* The `name` property is not populated by Phaser and is presented for your own use.
|
|
|
|
*
|
2018-01-31 13:54:44 +00:00
|
|
|
* @method Phaser.GameObjects.GameObject#setName
|
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2017-09-12 23:58:25 +00:00
|
|
|
* @param {string} value - The name to be given to this Game Object.
|
2018-03-19 18:35:08 +00:00
|
|
|
*
|
2018-06-17 06:54:28 +00:00
|
|
|
* @return {this} This GameObject.
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-07-27 16:39:46 +00:00
|
|
|
setName: function (value)
|
2017-07-07 17:26:03 +00:00
|
|
|
{
|
2017-07-27 16:39:46 +00:00
|
|
|
this.name = value;
|
|
|
|
|
|
|
|
return this;
|
2017-07-07 17:26:03 +00:00
|
|
|
},
|
|
|
|
|
2018-11-21 02:24:54 +00:00
|
|
|
/**
|
|
|
|
* Sets the current state of this Game Object.
|
2020-08-24 18:18:29 +00:00
|
|
|
*
|
2018-11-21 02:24:54 +00:00
|
|
|
* Phaser itself will never modify the State of a Game Object, although plugins may do so.
|
2020-08-24 18:18:29 +00:00
|
|
|
*
|
2018-11-21 02:24:54 +00:00
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#setState
|
|
|
|
* @since 3.16.0
|
|
|
|
*
|
2020-11-23 10:32:00 +00:00
|
|
|
* @param {(number|string)} value - The state of the Game Object.
|
2018-11-21 02:24:54 +00:00
|
|
|
*
|
|
|
|
* @return {this} This GameObject.
|
|
|
|
*/
|
|
|
|
setState: function (value)
|
|
|
|
{
|
|
|
|
this.state = value;
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2018-01-31 13:54:44 +00:00
|
|
|
/**
|
2018-06-05 00:01:13 +00:00
|
|
|
* Adds a Data Manager component to this Game Object.
|
2018-01-31 13:54:44 +00:00
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#setDataEnabled
|
|
|
|
* @since 3.0.0
|
2018-04-08 19:13:02 +00:00
|
|
|
* @see Phaser.Data.DataManager
|
2018-01-31 13:54:44 +00:00
|
|
|
*
|
2018-06-17 06:54:28 +00:00
|
|
|
* @return {this} This GameObject.
|
2018-01-31 13:54:44 +00:00
|
|
|
*/
|
2018-01-30 00:55:27 +00:00
|
|
|
setDataEnabled: function ()
|
2017-12-15 04:08:05 +00:00
|
|
|
{
|
2018-01-30 00:55:27 +00:00
|
|
|
if (!this.data)
|
2017-12-15 04:08:05 +00:00
|
|
|
{
|
2018-01-30 00:55:27 +00:00
|
|
|
this.data = new DataManager(this);
|
2017-12-15 04:08:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-09-29 10:41:10 +00:00
|
|
|
/**
|
2018-06-05 00:01:13 +00:00
|
|
|
* Allows you to store a key value pair within this Game Objects Data Manager.
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* If the Game Object has not been enabled for data (via `setDataEnabled`) then it will be enabled
|
|
|
|
* before setting the value.
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* If the key doesn't already exist in the Data Manager then it is created.
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* ```javascript
|
|
|
|
* sprite.setData('name', 'Red Gem Stone');
|
|
|
|
* ```
|
|
|
|
*
|
|
|
|
* You can also pass in an object of key value pairs as the first argument:
|
|
|
|
*
|
|
|
|
* ```javascript
|
|
|
|
* sprite.setData({ name: 'Red Gem Stone', level: 2, owner: 'Link', gold: 50 });
|
|
|
|
* ```
|
|
|
|
*
|
|
|
|
* To get a value back again you can call `getData`:
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* ```javascript
|
|
|
|
* sprite.getData('gold');
|
|
|
|
* ```
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* Or you can access the value directly via the `values` property, where it works like any other variable:
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* ```javascript
|
|
|
|
* sprite.data.values.gold += 50;
|
|
|
|
* ```
|
|
|
|
*
|
|
|
|
* When the value is first set, a `setdata` event is emitted from this Game Object.
|
|
|
|
*
|
|
|
|
* If the key already exists, a `changedata` event is emitted instead, along an event named after the key.
|
2019-01-18 14:21:45 +00:00
|
|
|
* For example, if you updated an existing key called `PlayerLives` then it would emit the event `changedata-PlayerLives`.
|
2018-06-05 00:01:13 +00:00
|
|
|
* These events will be emitted regardless if you use this method to set the value, or the direct `values` setter.
|
|
|
|
*
|
|
|
|
* Please note that the data keys are case-sensitive and must be valid JavaScript Object property strings.
|
|
|
|
* This means the keys `gold` and `Gold` are treated as two unique values within the Data Manager.
|
2017-09-29 10:41:10 +00:00
|
|
|
*
|
2018-01-31 13:54:44 +00:00
|
|
|
* @method Phaser.GameObjects.GameObject#setData
|
|
|
|
* @since 3.0.0
|
2017-09-29 10:41:10 +00:00
|
|
|
*
|
2019-06-22 10:38:24 +00:00
|
|
|
* @param {(string|object)} key - The key to set the value for. Or an object of key value pairs. If an object the `data` argument is ignored.
|
|
|
|
* @param {*} [data] - The value to set for the given key. If an object is provided as the key this argument is ignored.
|
2018-03-19 18:35:08 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* @return {this} This GameObject.
|
2017-09-29 10:41:10 +00:00
|
|
|
*/
|
|
|
|
setData: function (key, value)
|
|
|
|
{
|
2018-01-30 00:55:27 +00:00
|
|
|
if (!this.data)
|
|
|
|
{
|
|
|
|
this.data = new DataManager(this);
|
|
|
|
}
|
|
|
|
|
2017-09-29 10:41:10 +00:00
|
|
|
this.data.set(key, value);
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2020-02-05 08:17:54 +00:00
|
|
|
/**
|
|
|
|
* Increase a value for the given key within this Game Objects Data Manager. If the key doesn't already exist in the Data Manager then it is increased from 0.
|
|
|
|
*
|
|
|
|
* 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.
|
2020-08-24 18:18:29 +00:00
|
|
|
*
|
2020-02-05 08:17:54 +00:00
|
|
|
* When the value is first set, a `setdata` event is emitted from this Game Object.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#incData
|
|
|
|
* @since 3.23.0
|
|
|
|
*
|
|
|
|
* @param {(string|object)} key - The key to increase the value for.
|
|
|
|
* @param {*} [data] - The value to increase for the given key.
|
|
|
|
*
|
|
|
|
* @return {this} This GameObject.
|
|
|
|
*/
|
|
|
|
incData: function (key, value)
|
|
|
|
{
|
|
|
|
if (!this.data)
|
|
|
|
{
|
|
|
|
this.data = new DataManager(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
this.data.inc(key, value);
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Toggle a boolean value for the given key within this Game Objects Data Manager. If the key doesn't already exist in the Data Manager then it is toggled from false.
|
|
|
|
*
|
|
|
|
* 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.
|
2020-08-24 18:18:29 +00:00
|
|
|
*
|
2020-02-05 08:17:54 +00:00
|
|
|
* When the value is first set, a `setdata` event is emitted from this Game Object.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#toggleData
|
|
|
|
* @since 3.23.0
|
|
|
|
*
|
|
|
|
* @param {(string|object)} key - The key to toggle the value for.
|
|
|
|
*
|
|
|
|
* @return {this} This GameObject.
|
|
|
|
*/
|
|
|
|
toggleData: function (key)
|
|
|
|
{
|
|
|
|
if (!this.data)
|
|
|
|
{
|
|
|
|
this.data = new DataManager(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
this.data.toggle(key);
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-09-29 10:41:10 +00:00
|
|
|
/**
|
2018-06-05 00:01:13 +00:00
|
|
|
* Retrieves the value for the given key in this Game Objects Data Manager, or undefined if it doesn't exist.
|
|
|
|
*
|
|
|
|
* You can also access values via the `values` object. For example, if you had a key called `gold` you can do either:
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* ```javascript
|
|
|
|
* sprite.getData('gold');
|
|
|
|
* ```
|
|
|
|
*
|
|
|
|
* Or access the value directly:
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* ```javascript
|
|
|
|
* sprite.data.values.gold;
|
|
|
|
* ```
|
|
|
|
*
|
|
|
|
* You can also pass in an array of keys, in which case an array of values will be returned:
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* ```javascript
|
|
|
|
* sprite.getData([ 'gold', 'armor', 'health' ]);
|
|
|
|
* ```
|
|
|
|
*
|
|
|
|
* This approach is useful for destructuring arrays in ES6.
|
2017-09-29 10:41:10 +00:00
|
|
|
*
|
2018-01-31 13:54:44 +00:00
|
|
|
* @method Phaser.GameObjects.GameObject#getData
|
|
|
|
* @since 3.0.0
|
2017-09-29 10:41:10 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* @param {(string|string[])} key - The key of the value to retrieve, or an array of keys.
|
2018-03-19 18:35:08 +00:00
|
|
|
*
|
2018-06-05 00:01:13 +00:00
|
|
|
* @return {*} The value belonging to the given key, or an array of values, the order of which will match the input array.
|
2017-09-29 10:41:10 +00:00
|
|
|
*/
|
|
|
|
getData: function (key)
|
|
|
|
{
|
2018-01-30 00:55:27 +00:00
|
|
|
if (!this.data)
|
|
|
|
{
|
|
|
|
this.data = new DataManager(this);
|
|
|
|
}
|
|
|
|
|
2017-09-29 10:41:10 +00:00
|
|
|
return this.data.get(key);
|
|
|
|
},
|
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
|
|
|
* Pass this Game Object to the Input Manager to enable it for Input.
|
|
|
|
*
|
2018-06-11 10:35:31 +00:00
|
|
|
* 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.
|
|
|
|
*
|
2020-08-03 20:33:30 +00:00
|
|
|
* @example
|
|
|
|
* sprite.setInteractive();
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* sprite.setInteractive(new Phaser.Geom.Circle(45, 46, 45), Phaser.Geom.Circle.Contains);
|
|
|
|
*
|
|
|
|
* @example
|
|
|
|
* graphics.setInteractive(new Phaser.Geom.Rectangle(0, 0, 128, 128), Phaser.Geom.Rectangle.Contains);
|
|
|
|
*
|
2018-01-31 13:54:44 +00:00
|
|
|
* @method Phaser.GameObjects.GameObject#setInteractive
|
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2020-08-03 20:33:30 +00:00
|
|
|
* @param {(Phaser.Types.Input.InputConfiguration|any)} [hitArea] - Either an input configuration object, or a geometric shape that defines the hit area for the Game Object. If not given it will try to create a Rectangle based on the texture frame.
|
|
|
|
* @param {Phaser.Types.Input.HitAreaCallback} [callback] - The callback that determines if the pointer is within the Hit Area shape or not. If you provide a shape you must also provide a callback.
|
2018-03-01 02:46:17 +00:00
|
|
|
* @param {boolean} [dropZone=false] - Should this Game Object be treated as a drop zone target?
|
2018-03-19 18:35:08 +00:00
|
|
|
*
|
2018-06-17 06:54:28 +00:00
|
|
|
* @return {this} This GameObject.
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2020-08-03 20:33:30 +00:00
|
|
|
setInteractive: function (hitArea, hitAreaCallback, dropZone)
|
2017-07-13 01:05:32 +00:00
|
|
|
{
|
2020-08-03 20:33:30 +00:00
|
|
|
this.scene.sys.input.enable(this, hitArea, hitAreaCallback, dropZone);
|
2017-07-13 01:05:32 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2018-05-08 15:15:50 +00:00
|
|
|
/**
|
|
|
|
* If this Game Object has previously been enabled for input, this will disable it.
|
2018-05-12 18:48:15 +00:00
|
|
|
*
|
2018-05-08 15:15:50 +00:00
|
|
|
* 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.
|
2018-05-12 18:48:15 +00:00
|
|
|
*
|
2018-05-08 15:15:50 +00:00
|
|
|
* If want to completely remove interaction from this Game Object then use `removeInteractive` instead.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#disableInteractive
|
|
|
|
* @since 3.7.0
|
|
|
|
*
|
2018-06-17 06:54:28 +00:00
|
|
|
* @return {this} This GameObject.
|
2018-05-08 15:15:50 +00:00
|
|
|
*/
|
|
|
|
disableInteractive: function ()
|
|
|
|
{
|
2021-09-17 07:19:39 +00:00
|
|
|
this.scene.sys.input.disable(this);
|
2018-05-08 15:15:50 +00:00
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
2018-08-21 22:48:03 +00:00
|
|
|
* If this Game Object has previously been enabled for input, this will queue it
|
|
|
|
* for removal, causing it to no longer be interactive. The removal happens on
|
|
|
|
* the next game step, it is not immediate.
|
2018-05-08 15:15:50 +00:00
|
|
|
*
|
|
|
|
* 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
|
2018-07-20 16:49:49 +00:00
|
|
|
* re-create its InteractiveObject by calling `setInteractive` again.
|
2018-05-08 15:15:50 +00:00
|
|
|
*
|
|
|
|
* 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.
|
2020-08-24 18:18:29 +00:00
|
|
|
*
|
2018-08-21 22:48:03 +00:00
|
|
|
* 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.)
|
2018-05-08 15:15:50 +00:00
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#removeInteractive
|
|
|
|
* @since 3.7.0
|
|
|
|
*
|
2018-06-17 06:54:28 +00:00
|
|
|
* @return {this} This GameObject.
|
2018-05-08 15:15:50 +00:00
|
|
|
*/
|
|
|
|
removeInteractive: function ()
|
|
|
|
{
|
|
|
|
this.scene.sys.input.clear(this);
|
|
|
|
|
|
|
|
this.input = undefined;
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2020-08-24 18:18:29 +00:00
|
|
|
/**
|
|
|
|
* This callback is invoked when this Game Object is added to a Scene.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#addedToScene
|
|
|
|
* @since 3.50.0
|
|
|
|
*/
|
|
|
|
addedToScene: function ()
|
|
|
|
{
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This callback is invoked when this Game Object is removed from a Scene.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#removedFromScene
|
|
|
|
* @since 3.50.0
|
|
|
|
*/
|
|
|
|
removedFromScene: function ()
|
|
|
|
{
|
|
|
|
},
|
|
|
|
|
2018-01-31 13:54:44 +00:00
|
|
|
/**
|
|
|
|
* To be overridden by custom GameObjects. Allows base objects to be used in a Pool.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#update
|
|
|
|
* @since 3.0.0
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
|
|
|
* @param {...*} [args] - args
|
2018-01-31 13:54:44 +00:00
|
|
|
*/
|
2017-07-27 16:39:46 +00:00
|
|
|
update: function ()
|
|
|
|
{
|
|
|
|
},
|
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
|
|
|
* Returns a JSON representation of the Game Object.
|
|
|
|
*
|
2018-01-31 13:54:44 +00:00
|
|
|
* @method Phaser.GameObjects.GameObject#toJSON
|
|
|
|
* @since 3.0.0
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2019-05-09 11:01:00 +00:00
|
|
|
* @return {Phaser.Types.GameObjects.JSONGameObject} A JSON representation of the Game Object.
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2017-04-12 23:35:27 +00:00
|
|
|
toJSON: function ()
|
|
|
|
{
|
2018-09-03 12:12:37 +00:00
|
|
|
return ComponentsToJSON(this);
|
2017-04-12 23:35:27 +00:00
|
|
|
},
|
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
|
|
|
* Compares the renderMask with the renderFlags to see if this Game Object will render or not.
|
2018-07-19 12:19:02 +00:00
|
|
|
* Also checks the Game Object against the given Cameras exclusion list.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-01-31 13:54:44 +00:00
|
|
|
* @method Phaser.GameObjects.GameObject#willRender
|
|
|
|
* @since 3.0.0
|
2018-07-29 10:19:04 +00:00
|
|
|
*
|
2018-07-19 12:19:02 +00:00
|
|
|
* @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera to check against this Game Object.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2017-09-12 23:58:25 +00:00
|
|
|
* @return {boolean} True if the Game Object should be rendered, otherwise false.
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2018-07-19 12:19:02 +00:00
|
|
|
willRender: function (camera)
|
2017-07-27 13:22:05 +00:00
|
|
|
{
|
2021-12-01 17:24:12 +00:00
|
|
|
var listWillRender = (this.displayList && this.displayList.active) ? this.displayList.willRender(camera) : true;
|
|
|
|
|
|
|
|
return !(!listWillRender || GameObject.RENDER_MASK !== this.renderFlags || (this.cameraFilter !== 0 && (this.cameraFilter & camera.id)));
|
2017-07-27 13:22:05 +00:00
|
|
|
},
|
|
|
|
|
2018-04-12 01:11:17 +00:00
|
|
|
/**
|
|
|
|
* Returns an array containing the display list index of either this Game Object, or if it has one,
|
|
|
|
* its parent Container. It then iterates up through all of the parent containers until it hits the
|
|
|
|
* root of the display list (which is index 0 in the returned array).
|
2018-05-12 18:48:15 +00:00
|
|
|
*
|
2018-04-12 01:11:17 +00:00
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#getIndexList
|
|
|
|
* @since 3.4.0
|
|
|
|
*
|
2020-11-23 10:23:10 +00:00
|
|
|
* @return {number[]} An array of display list position indexes.
|
2018-04-12 01:11:17 +00:00
|
|
|
*/
|
|
|
|
getIndexList: function ()
|
|
|
|
{
|
2018-04-12 01:18:01 +00:00
|
|
|
// eslint-disable-next-line consistent-this
|
2018-04-12 01:11:17 +00:00
|
|
|
var child = this;
|
|
|
|
var parent = this.parentContainer;
|
|
|
|
|
|
|
|
var indexes = [];
|
2018-05-12 18:48:15 +00:00
|
|
|
|
2018-04-12 01:11:17 +00:00
|
|
|
while (parent)
|
|
|
|
{
|
|
|
|
indexes.unshift(parent.getIndex(child));
|
|
|
|
|
|
|
|
child = parent;
|
|
|
|
|
|
|
|
if (!parent.parentContainer)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
parent = parent.parentContainer;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-07 12:22:09 +00:00
|
|
|
if (this.displayList)
|
|
|
|
{
|
|
|
|
indexes.unshift(this.displayList.getIndex(child));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
indexes.unshift(this.scene.sys.displayList.getIndex(child));
|
|
|
|
}
|
2018-04-12 01:11:17 +00:00
|
|
|
|
|
|
|
return indexes;
|
|
|
|
},
|
|
|
|
|
2021-03-03 17:58:12 +00:00
|
|
|
/**
|
|
|
|
* Adds this Game Object to the given Display List.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#addToDisplayList
|
|
|
|
* @fires Phaser.Scenes.Events#ADDED_TO_SCENE
|
|
|
|
* @fires Phaser.GameObjects.Events#ADDED_TO_SCENE
|
|
|
|
* @since 3.53.0
|
|
|
|
*
|
|
|
|
* @param {(Phaser.GameObjects.DisplayList|Phaser.GameObjects.Layer)} [displayList] - The Display List to add to. Defaults to the Scene Display List.
|
|
|
|
*
|
|
|
|
* @return {this} This Game Object.
|
|
|
|
*/
|
|
|
|
addToDisplayList: function (displayList)
|
|
|
|
{
|
|
|
|
if (displayList === undefined) { displayList = this.scene.sys.displayList; }
|
|
|
|
|
|
|
|
if (this.displayList && this.displayList !== displayList)
|
|
|
|
{
|
|
|
|
this.removeFromDisplayList();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Don't repeat if it's already on this list
|
|
|
|
if (!displayList.exists(this))
|
|
|
|
{
|
|
|
|
this.displayList = displayList;
|
|
|
|
|
|
|
|
displayList.add(this, true);
|
|
|
|
|
|
|
|
displayList.queueDepthSort();
|
|
|
|
|
|
|
|
this.emit(Events.ADDED_TO_SCENE, this, this.scene);
|
|
|
|
|
|
|
|
displayList.events.emit(SceneEvents.ADDED_TO_SCENE, this, this.scene);
|
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Adds this Game Object to the Update List belonging to the Scene.
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* `preUpdate.super(delta, time)` within it, or it may fail to process required operations,
|
|
|
|
* such as Sprite animations.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#addToUpdateList
|
|
|
|
* @since 3.53.0
|
|
|
|
*
|
|
|
|
* @return {this} This Game Object.
|
|
|
|
*/
|
|
|
|
addToUpdateList: function ()
|
|
|
|
{
|
|
|
|
if (this.scene && this.preUpdate)
|
|
|
|
{
|
|
|
|
this.scene.sys.updateList.add(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes this Game Object from the Display List it is currently on.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#removeFromDisplayList
|
|
|
|
* @fires Phaser.Scenes.Events#REMOVED_FROM_SCENE
|
|
|
|
* @fires Phaser.GameObjects.Events#REMOVED_FROM_SCENE
|
|
|
|
* @since 3.53.0
|
|
|
|
*
|
|
|
|
* @return {this} This Game Object.
|
|
|
|
*/
|
|
|
|
removeFromDisplayList: function ()
|
|
|
|
{
|
|
|
|
var displayList = this.displayList || this.scene.sys.displayList;
|
|
|
|
|
2022-10-10 14:31:50 +00:00
|
|
|
if (displayList && displayList.exists(this))
|
2021-03-03 17:58:12 +00:00
|
|
|
{
|
|
|
|
displayList.remove(this, true);
|
|
|
|
|
|
|
|
displayList.queueDepthSort();
|
|
|
|
|
|
|
|
this.displayList = null;
|
|
|
|
|
|
|
|
this.emit(Events.REMOVED_FROM_SCENE, this, this.scene);
|
|
|
|
|
|
|
|
displayList.events.emit(SceneEvents.REMOVED_FROM_SCENE, this, this.scene);
|
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Removes this Game Object from the Scene's Update List.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* @method Phaser.GameObjects.GameObject#removeFromUpdateList
|
|
|
|
* @since 3.53.0
|
|
|
|
*
|
|
|
|
* @return {this} This Game Object.
|
|
|
|
*/
|
|
|
|
removeFromUpdateList: function ()
|
|
|
|
{
|
|
|
|
if (this.scene && this.preUpdate)
|
|
|
|
{
|
|
|
|
this.scene.sys.updateList.remove(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
|
2017-09-11 23:28:53 +00:00
|
|
|
/**
|
2017-09-13 01:02:49 +00:00
|
|
|
* Destroys this Game Object removing it from the Display List and Update List and
|
|
|
|
* severing all ties to parent resources.
|
2018-03-19 18:35:08 +00:00
|
|
|
*
|
2017-09-13 01:02:49 +00:00
|
|
|
* Also removes itself from the Input Manager and Physics Manager if previously enabled.
|
2018-03-19 18:35:08 +00:00
|
|
|
*
|
2017-09-13 01:02:49 +00:00
|
|
|
* 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.
|
2018-03-19 18:35:08 +00:00
|
|
|
*
|
2017-09-13 01:02:49 +00:00
|
|
|
* 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.
|
2017-09-11 23:28:53 +00:00
|
|
|
*
|
2018-01-31 13:54:44 +00:00
|
|
|
* @method Phaser.GameObjects.GameObject#destroy
|
2019-01-18 14:21:45 +00:00
|
|
|
* @fires Phaser.GameObjects.Events#DESTROY
|
2018-01-31 13:54:44 +00:00
|
|
|
* @since 3.0.0
|
2021-05-26 14:49:05 +00:00
|
|
|
*
|
|
|
|
* @param {boolean} [fromScene=false] - `True` if this Game Object is being destroyed by the Scene, `false` if not.
|
2017-09-11 23:28:53 +00:00
|
|
|
*/
|
2021-05-26 08:25:12 +00:00
|
|
|
destroy: function (fromScene)
|
2016-12-07 02:28:22 +00:00
|
|
|
{
|
2018-09-13 08:28:33 +00:00
|
|
|
// This Game Object has already been destroyed
|
2018-04-13 16:20:46 +00:00
|
|
|
if (!this.scene || this.ignoreDestroy)
|
2018-03-05 22:25:55 +00:00
|
|
|
{
|
2018-03-02 02:50:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-05-26 08:25:12 +00:00
|
|
|
if (fromScene === undefined) { fromScene = false; }
|
|
|
|
|
2017-11-30 01:20:22 +00:00
|
|
|
if (this.preDestroy)
|
|
|
|
{
|
2017-12-02 04:03:06 +00:00
|
|
|
this.preDestroy.call(this);
|
2017-11-30 01:20:22 +00:00
|
|
|
}
|
|
|
|
|
2021-05-26 08:25:12 +00:00
|
|
|
this.emit(Events.DESTROY, this, fromScene);
|
2020-12-03 14:34:32 +00:00
|
|
|
|
2020-11-27 15:14:04 +00:00
|
|
|
this.removeAllListeners();
|
2020-12-02 12:23:59 +00:00
|
|
|
|
|
|
|
if (this.postPipelines)
|
|
|
|
{
|
|
|
|
this.resetPostPipeline(true);
|
|
|
|
}
|
2020-11-27 15:14:04 +00:00
|
|
|
|
2021-03-03 17:58:12 +00:00
|
|
|
this.removeFromDisplayList();
|
|
|
|
this.removeFromUpdateList();
|
2017-03-30 12:28:40 +00:00
|
|
|
|
2017-07-28 00:17:18 +00:00
|
|
|
if (this.input)
|
|
|
|
{
|
2020-11-27 11:13:59 +00:00
|
|
|
this.scene.sys.input.clear(this);
|
|
|
|
|
2017-09-25 15:06:16 +00:00
|
|
|
this.input = undefined;
|
2017-07-28 00:17:18 +00:00
|
|
|
}
|
|
|
|
|
2018-01-30 00:55:27 +00:00
|
|
|
if (this.data)
|
|
|
|
{
|
|
|
|
this.data.destroy();
|
|
|
|
|
|
|
|
this.data = undefined;
|
|
|
|
}
|
|
|
|
|
2017-08-15 22:35:16 +00:00
|
|
|
if (this.body)
|
|
|
|
{
|
2018-02-14 19:33:13 +00:00
|
|
|
this.body.destroy();
|
2020-11-27 11:13:59 +00:00
|
|
|
|
2017-09-25 15:06:16 +00:00
|
|
|
this.body = undefined;
|
2017-08-15 22:35:16 +00:00
|
|
|
}
|
|
|
|
|
2017-08-07 16:14:13 +00:00
|
|
|
this.active = false;
|
2017-12-15 04:08:05 +00:00
|
|
|
this.visible = false;
|
2017-08-07 16:14:13 +00:00
|
|
|
|
2017-07-14 13:30:20 +00:00
|
|
|
this.scene = undefined;
|
2018-04-10 14:21:04 +00:00
|
|
|
this.parentContainer = undefined;
|
2016-12-07 02:28:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
});
|
|
|
|
|
2017-09-12 23:58:25 +00:00
|
|
|
/**
|
|
|
|
* The bitmask that `GameObject.renderFlags` is compared against to determine if the Game Object will render or not.
|
|
|
|
*
|
2020-11-23 10:22:13 +00:00
|
|
|
* @constant {number} RENDER_MASK
|
2018-10-10 09:49:13 +00:00
|
|
|
* @memberof Phaser.GameObjects.GameObject
|
2017-09-13 01:02:49 +00:00
|
|
|
* @default
|
2017-09-12 23:58:25 +00:00
|
|
|
*/
|
|
|
|
GameObject.RENDER_MASK = 15;
|
|
|
|
|
2016-12-07 02:28:22 +00:00
|
|
|
module.exports = GameObject;
|