Mirrors/phaser
2
0
Fork 0
mirror of https://github.com/photonstorm/phaser synced 2024-12-25 12:33:38 +00:00
Code Issues Projects Releases Packages Wiki Activity
phaser/src/scene/Systems.js
Richard Davey 7765496b19 Moved FB plugin behind build flag
2018-08-23 18:10:20 +01:00

680 lines
18 KiB
JavaScript
Raw Blame History

/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2018 Photon Storm Ltd.
* @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
*/
var Class = require('../utils/Class');
var CONST = require('./const');
var DefaultPlugins = require('../plugins/DefaultPlugins');
var GetPhysicsPlugins = require('./GetPhysicsPlugins');
var GetScenePlugins = require('./GetScenePlugins');
var NOOP = require('../utils/NOOP');
var Settings = require('./Settings');
/**
* @classdesc
* The Scene Systems class.
*
* This class is available from within a Scene under the property `sys`.
* It is responsible for managing all of the plugins a Scene has running, including the display list, and
* handling the update step and renderer. It also contains references to global systems belonging to Game.
*
* @class Systems
* @memberOf Phaser.Scenes
* @constructor
* @since 3.0.0
*
* @param {Phaser.Scene} scene - The Scene that owns this Systems instance.
* @param {(string|Phaser.Scenes.Settings.Config)} config - Scene specific configuration settings.
*/
var Systems = new Class({
initialize:
function Systems (scene, config)
{
/**
* [description]
*
* @name Phaser.Scenes.Systems#scene
* @type {Phaser.Scene}
* @since 3.0.0
*/
this.scene = scene;
/**
* [description]
*
* @name Phaser.Scenes.Systems#game
* @type {Phaser.Game}
* @since 3.0.0
*/
this.game;
if (typeof PLUGIN_FBINSTANT)
{
/**
* [description]
*
* @name Phaser.Scenes.Systems#facebook
* @type {any}
* @since 3.12.0
*/
this.facebook;
}
/**
* [description]
*
* @name Phaser.Scenes.Systems#config
* @type {(string|Phaser.Scenes.Settings.Config)}
* @since 3.0.0
*/
this.config = config;
/**
* [description]
*
* @name Phaser.Scenes.Systems#settings
* @type {Phaser.Scenes.Settings.Object}
* @since 3.0.0
*/
this.settings = Settings.create(config);
/**
* A handy reference to the Scene canvas / context.
*
* @name Phaser.Scenes.Systems#canvas
* @type {HTMLCanvasElement}
* @since 3.0.0
*/
this.canvas;
/**
* [description]
*
* @name Phaser.Scenes.Systems#context
* @type {CanvasRenderingContext2D}
* @since 3.0.0
*/
this.context;
// Global Systems - these are single-instance global managers that belong to Game
/**
* [description]
*
* @name Phaser.Scenes.Systems#anims
* @type {Phaser.Animations.AnimationManager}
* @since 3.0.0
*/
this.anims;
/**
* [description]
*
* @name Phaser.Scenes.Systems#cache
* @type {Phaser.Cache.CacheManager}
* @since 3.0.0
*/
this.cache;
/**
* [description]
*
* @name Phaser.Scenes.Systems#plugins
* @type {Phaser.Plugins.PluginManager}
* @since 3.0.0
*/
this.plugins;
/**
* [description]
*
* @name Phaser.Scenes.Systems#registry
* @type {Phaser.Data.DataManager}
* @since 3.0.0
*/
this.registry;
/**
* [description]
*
* @name Phaser.Scenes.Systems#sound
* @type {Phaser.Sound.BaseSoundManager}
* @since 3.0.0
*/
this.sound;
/**
* [description]
*
* @name Phaser.Scenes.Systems#textures
* @type {Phaser.Textures.TextureManager}
* @since 3.0.0
*/
this.textures;
// Core Plugins - these are non-optional Scene plugins, needed by lots of the other systems
/**
* [description]
*
* @name Phaser.Scenes.Systems#add
* @type {Phaser.GameObjects.GameObjectFactory}
* @since 3.0.0
*/
this.add;
/**
* [description]
*
* @name Phaser.Scenes.Systems#cameras
* @type {Phaser.Cameras.Scene2D.CameraManager}
* @since 3.0.0
*/
this.cameras;
/**
* [description]
*
* @name Phaser.Scenes.Systems#displayList
* @type {Phaser.GameObjects.DisplayList}
* @since 3.0.0
*/
this.displayList;
/**
* [description]
*
* @name Phaser.Scenes.Systems#events
* @type {Phaser.Events.EventEmitter}
* @since 3.0.0
*/
this.events;
/**
* [description]
*
* @name Phaser.Scenes.Systems#make
* @type {Phaser.GameObjects.GameObjectCreator}
* @since 3.0.0
*/
this.make;
/**
* [description]
*
* @name Phaser.Scenes.Systems#scenePlugin
* @type {Phaser.Scenes.ScenePlugin}
* @since 3.0.0
*/
this.scenePlugin;
/**
* [description]
*
* @name Phaser.Scenes.Systems#updateList
* @type {Phaser.GameObjects.UpdateList}
* @since 3.0.0
*/
this.updateList;
/**
* The Scene Update function.
*
* This starts out as NOOP during init, preload and create, and at the end of create
* it swaps to be whatever the Scene.update function is.
*
* @name Phaser.Scenes.Systems#sceneUpdate
* @type {function}
* @private
* @since 3.10.0
*/
this.sceneUpdate = NOOP;
},
/**
* This method is called only once by the Scene Manager when the Scene is instantiated.
* It is responsible for setting up all of the Scene plugins and references.
* It should never be called directly.
*
* @method Phaser.Scenes.Systems#init
* @protected
* @since 3.0.0
*
* @param {Phaser.Game} game - A reference to the Phaser Game instance.
*/
init: function (game)
{
this.settings.status = CONST.INIT;
// This will get replaced by the SceneManager with the actual update function, if it exists, once create is over.
this.sceneUpdate = NOOP;
this.game = game;
this.canvas = game.canvas;
this.context = game.context;
var pluginManager = game.plugins;
this.plugins = pluginManager;
pluginManager.addToScene(this, DefaultPlugins.Global, [ DefaultPlugins.CoreScene, GetScenePlugins(this), GetPhysicsPlugins(this) ]);
this.events.emit('boot', this);
this.settings.isBooted = true;
},
/**
* Called by a plugin, it tells the System to install the plugin locally.
*
* @method Phaser.Scenes.Systems#install
* @private
* @since 3.0.0
*
* @param {array} plugin - An array of plugins to install into this Scene.
*/
install: function (plugin)
{
if (!Array.isArray(plugin))
{
plugin = [ plugin ];
}
this.plugins.installLocal(this, plugin);
},
/**
* A single game step. Called automatically by the Scene Manager as a result of a Request Animation
* Frame or Set Timeout call to the main Game instance.
*
* @method Phaser.Scenes.Systems#step
* @since 3.0.0
*
* @param {number} time - The time value from the most recent Game step. Typically a high-resolution timer value, or Date.now().
* @param {number} delta - The delta value since the last frame. This is smoothed to avoid delta spikes by the TimeStep class.
*/
step: function (time, delta)
{
this.events.emit('preupdate', time, delta);
this.events.emit('update', time, delta);
this.sceneUpdate.call(this.scene, time, delta);
this.events.emit('postupdate', time, delta);
},
/**
* Called automatically by the Scene Manager. Instructs the Scene to render itself via
* its Camera Manager to the renderer given.
*
* @method Phaser.Scenes.Systems#render
* @since 3.0.0
*
* @param {(Phaser.Renderer.Canvas.CanvasRenderer|Phaser.Renderer.WebGL.WebGLRenderer)} renderer - [description]
*/
render: function (renderer)
{
var displayList = this.displayList;
displayList.depthSort();
this.cameras.render(renderer, displayList);
this.events.emit('render', renderer);
},
/**
* Force a sort of the display list on the next render.
*
* @method Phaser.Scenes.Systems#queueDepthSort
* @since 3.0.0
*/
queueDepthSort: function ()
{
this.displayList.queueDepthSort();
},
/**
* Immediately sorts the display list if the flag is set.
*
* @method Phaser.Scenes.Systems#depthSort
* @since 3.0.0
*/
depthSort: function ()
{
this.displayList.depthSort();
},
/**
* Pause this Scene.
* A paused Scene still renders, it just doesn't run ANY of its update handlers or systems.
*
* @method Phaser.Scenes.Systems#pause
* @since 3.0.0
*
* @param {object} [data] - A data object that will be passed in the 'pause' event.
*
* @return {Phaser.Scenes.Systems} This Systems object.
*/
pause: function (data)
{
if (this.settings.active)
{
this.settings.status = CONST.PAUSED;
this.settings.active = false;
this.events.emit('pause', this, data);
}
return this;
},
/**
* Resume this Scene from a paused state.
*
* @method Phaser.Scenes.Systems#resume
* @since 3.0.0
*
* @param {object} [data] - A data object that will be passed in the 'resume' event.
*
* @return {Phaser.Scenes.Systems} This Systems object.
*/
resume: function (data)
{
if (!this.settings.active)
{
this.settings.status = CONST.RUNNING;
this.settings.active = true;
this.events.emit('resume', this, data);
}
return this;
},
/**
* Send this Scene to sleep.
*
* A sleeping Scene doesn't run it's update step or render anything, but it also isn't shut down
* or have any of its systems or children removed, meaning it can be re-activated at any point and
* will carry on from where it left off. It also keeps everything in memory and events and callbacks
* from other Scenes may still invoke changes within it, so be careful what is left active.
*
* @method Phaser.Scenes.Systems#sleep
* @since 3.0.0
*
* @param {object} [data] - A data object that will be passed in the 'sleep' event.
*
* @return {Phaser.Scenes.Systems} This Systems object.
*/
sleep: function (data)
{
this.settings.status = CONST.SLEEPING;
this.settings.active = false;
this.settings.visible = false;
this.events.emit('sleep', this, data);
return this;
},
/**
* Wake-up this Scene if it was previously asleep.
*
* @method Phaser.Scenes.Systems#wake
* @since 3.0.0
*
* @param {object} [data] - A data object that will be passed in the 'wake' event.
*
* @return {Phaser.Scenes.Systems} This Systems object.
*/
wake: function (data)
{
var settings = this.settings;
settings.status = CONST.RUNNING;
settings.active = true;
settings.visible = true;
this.events.emit('wake', this, data);
if (settings.isTransition)
{
this.events.emit('transitionwake', settings.transitionFrom, settings.transitionDuration);
}
return this;
},
/**
* Is this Scene sleeping?
*
* @method Phaser.Scenes.Systems#isSleeping
* @since 3.0.0
*
* @return {boolean} [description]
*/
isSleeping: function ()
{
return (this.settings.status === CONST.SLEEPING);
},
/**
* Is this Scene active?
*
* @method Phaser.Scenes.Systems#isActive
* @since 3.0.0
*
* @return {boolean} [description]
*/
isActive: function ()
{
return (this.settings.status === CONST.RUNNING);
},
/**
* Is this Scene currently transitioning out to, or in from another Scene?
*
* @method Phaser.Scenes.Systems#isTransitioning
* @since 3.5.0
*
* @return {boolean} `true` if this Scene is currently transitioning, otherwise `false`.
*/
isTransitioning: function ()
{
return (this.settings.isTransition || this.scenePlugin._target !== null);
},
/**
* Is this Scene currently transitioning out from itself to another Scene?
*
* @method Phaser.Scenes.Systems#isTransitionOut
* @since 3.5.0
*
* @return {boolean} `true` if this Scene is in transition to another Scene, otherwise `false`.
*/
isTransitionOut: function ()
{
return (this.scenePlugin._target !== null && this.scenePlugin._duration > 0);
},
/**
* Is this Scene currently transitioning in from another Scene?
*
* @method Phaser.Scenes.Systems#isTransitionIn
* @since 3.5.0
*
* @return {boolean} `true` if this Scene is transitioning in from another Scene, otherwise `false`.
*/
isTransitionIn: function ()
{
return (this.settings.isTransition);
},
/**
* Is this Scene visible and rendering?
*
* @method Phaser.Scenes.Systems#isVisible
* @since 3.0.0
*
* @return {boolean} [description]
*/
isVisible: function ()
{
return this.settings.visible;
},
/**
* Sets the visible state of this Scene.
* An invisible Scene will not render, but will still process updates.
*
* @method Phaser.Scenes.Systems#setVisible
* @since 3.0.0
*
* @param {boolean} value - [description]
*
* @return {Phaser.Scenes.Systems} This Systems object.
*/
setVisible: function (value)
{
this.settings.visible = value;
return this;
},
/**
* Set the active state of this Scene.
*
* An active Scene will run its core update loop.
*
* @method Phaser.Scenes.Systems#setActive
* @since 3.0.0
*
* @param {boolean} value - If `true` the Scene will be resumed, if previously paused. If `false` it will be paused.
* @param {object} [data] - A data object that will be passed in the 'resume' or 'pause' events.
*
* @return {Phaser.Scenes.Systems} This Systems object.
*/
setActive: function (value, data)
{
if (value)
{
return this.resume(data);
}
else
{
return this.pause(data);
}
},
/**
* Start this Scene running and rendering.
* Called automatically by the SceneManager.
*
* @method Phaser.Scenes.Systems#start
* @since 3.0.0
*
* @param {object} data - Optional data object that may have been passed to this Scene from another.
*/
start: function (data)
{
if (data)
{
this.settings.data = data;
}
this.settings.status = CONST.START;
this.settings.active = true;
this.settings.visible = true;
// For plugins to listen out for
this.events.emit('start', this);
// For user-land code to listen out for
this.events.emit('ready', this, data);
},
/**
* Called automatically by the SceneManager if the Game resizes.
* Dispatches an event you can respond to in your game code.
*
* @method Phaser.Scenes.Systems#resize
* @since 3.2.0
*
* @param {number} width - The new width of the game.
* @param {number} height - The new height of the game.
*/
resize: function (width, height)
{
this.events.emit('resize', width, height);
},
/**
* Shutdown this Scene and send a shutdown event to all of its systems.
* A Scene that has been shutdown will not run its update loop or render, but it does
* not destroy any of its plugins or references. It is put into hibernation for later use.
* If you don't ever plan to use this Scene again, then it should be destroyed instead
* to free-up resources.
*
* @method Phaser.Scenes.Systems#shutdown
* @since 3.0.0
*
* @param {object} [data] - A data object that will be passed in the 'shutdown' event.
*/
shutdown: function (data)
{
this.events.off('transitioninit');
this.events.off('transitionstart');
this.events.off('transitioncomplete');
this.events.off('transitionout');
this.settings.status = CONST.SHUTDOWN;
this.settings.active = false;
this.settings.visible = false;
this.events.emit('shutdown', this, data);
},
/**
* Destroy this Scene and send a destroy event all of its systems.
* A destroyed Scene cannot be restarted.
* You should not call this directly, instead use `SceneManager.remove`.
*
* @method Phaser.Scenes.Systems#destroy
* @private
* @since 3.0.0
*/
destroy: function ()
{
this.settings.status = CONST.DESTROYED;
this.settings.active = false;
this.settings.visible = false;
this.events.emit('destroy', this);
this.events.removeAllListeners();
var props = [ 'scene', 'game', 'anims', 'cache', 'plugins', 'registry', 'sound', 'textures', 'add', 'camera', 'displayList', 'events', 'make', 'scenePlugin', 'updateList' ];
for (var i = 0; i < props.length; i++)
{
this[props[i]] = null;
}
}
});
module.exports = Systems;
Reference in a new issue View git blame Copy permalink