phaser/src/boot/Game.js

822 lines
26 KiB
JavaScript
Raw Normal View History

2018-02-12 16:01:20 +00:00
/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2018 Photon Storm Ltd.
* @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
*/
2018-01-25 00:48:48 +00:00
var AddToDOM = require('../dom/AddToDOM');
var AnimationManager = require('../animations/AnimationManager');
var CacheManager = require('../cache/CacheManager');
var CanvasPool = require('../display/canvas/CanvasPool');
var Class = require('../utils/Class');
var Config = require('./Config');
2018-01-25 00:48:48 +00:00
var CreateRenderer = require('./CreateRenderer');
var DataManager = require('../data/DataManager');
2016-11-22 03:32:41 +00:00
var DebugHeader = require('./DebugHeader');
var Device = require('../device');
var DOMContentLoaded = require('../dom/DOMContentLoaded');
var EventEmitter = require('eventemitter3');
2018-01-16 16:14:21 +00:00
var InputManager = require('../input/InputManager');
var PluginCache = require('../plugins/PluginCache');
2018-05-10 16:14:33 +00:00
var PluginManager = require('../plugins/PluginManager');
2018-10-08 14:23:20 +00:00
var ScaleManager = require('../dom/ScaleManager');
2018-01-16 16:33:23 +00:00
var SceneManager = require('../scene/SceneManager');
var SoundManagerCreator = require('../sound/SoundManagerCreator');
var TextureManager = require('../textures/TextureManager');
2017-06-28 16:17:31 +00:00
var TimeStep = require('./TimeStep');
2018-01-25 00:48:48 +00:00
var VisibilityHandler = require('./VisibilityHandler');
2016-11-22 03:11:33 +00:00
2018-08-23 17:10:20 +00:00
if (typeof EXPERIMENTAL)
{
var CreateDOMContainer = require('./CreateDOMContainer');
}
2018-09-20 13:14:29 +00:00
if (typeof PLUGIN_FBINSTANT)
{
var FacebookInstantGamesPlugin = require('../../plugins/fbinstant/src/FacebookInstantGamesPlugin');
}
2018-02-07 15:27:21 +00:00
/**
* @classdesc
* The Phaser.Game instance is the main controller for the entire Phaser game. It is responsible
* for handling the boot process, parsing the configuration values, creating the renderer,
* and setting-up all of the global Phaser systems, such as sound and input.
* Once that is complete it will start the Scene Manager and then begin the main game loop.
*
* You should generally avoid accessing any of the systems created by Game, and instead use those
* made available to you via the Phaser.Scene Systems class instead.
*
* @class Game
* @memberOf Phaser
* @constructor
* @since 3.0.0
*
2018-03-27 11:30:00 +00:00
* @param {GameConfig} [GameConfig] - The configuration object for your Phaser Game instance.
2018-02-07 15:27:21 +00:00
*/
var Game = new Class({
initialize:
2016-11-24 17:01:52 +00:00
function Game (config)
{
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* The parsed Game Configuration object.
*
2018-01-25 00:48:48 +00:00
* The values stored within this object are read-only and should not be changed at run-time.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#config
* @type {Phaser.Boot.Config}
2018-01-25 00:48:48 +00:00
* @readOnly
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.config = new Config(config);
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* A reference to either the Canvas or WebGL Renderer that this Game is using.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#renderer
2018-03-20 14:58:02 +00:00
* @type {(Phaser.Renderer.Canvas.CanvasRenderer|Phaser.Renderer.WebGL.WebGLRenderer)}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.renderer = null;
2017-10-04 22:48:16 +00:00
2018-08-23 17:10:20 +00:00
if (typeof EXPERIMENTAL)
{
/**
* A reference to an HTML Div Element used as a DOM Element Container.
*
* Only set if `createDOMContainer` is `true` in the game config (by default it is `false`) and
* if you provide a parent element to insert the Phaser Game inside.
*
* See the DOM Element Game Object for more details.
*
* @name Phaser.Game#domContainer
* @type {HTMLDivElement}
* @since 3.12.0
*/
this.domContainer = null;
}
2017-10-04 22:48:16 +00:00
/**
* A reference to the HTML Canvas Element that Phaser uses to render the game.
* This is created automatically by Phaser unless you provide a `canvas` property
* in your Game Config.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#canvas
* @type {HTMLCanvasElement}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.canvas = null;
2017-10-04 22:48:16 +00:00
/**
* A reference to the Rendering Context belonging to the Canvas Element this game is rendering to.
* If the game is running under Canvas it will be a 2d Canvas Rendering Context.
* If the game is running under WebGL it will be a WebGL Rendering Context.
* This context is created automatically by Phaser unless you provide a `context` property
* in your Game Config.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#context
2018-05-17 14:10:23 +00:00
* @type {(CanvasRenderingContext2D|WebGLRenderingContext)}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.context = null;
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* A flag indicating when this Game instance has finished its boot process.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#isBooted
* @type {boolean}
2018-01-25 00:48:48 +00:00
* @readOnly
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.isBooted = false;
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* A flag indicating if this Game is currently running its game step or not.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#isRunning
* @type {boolean}
2018-01-25 00:48:48 +00:00
* @readOnly
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.isRunning = false;
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* An Event Emitter which is used to broadcast game-level events from the global systems.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#events
2018-03-29 12:12:07 +00:00
* @type {Phaser.Events.EventEmitter}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.events = new EventEmitter();
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* An instance of the Animation Manager.
*
2018-01-25 00:48:48 +00:00
* The Animation Manager is a global system responsible for managing all animations used within your game.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#anims
* @type {Phaser.Animations.AnimationManager}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.anims = new AnimationManager(this);
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* An instance of the Texture Manager.
*
2018-01-25 00:48:48 +00:00
* The Texture Manager is a global system responsible for managing all textures being used by your game.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#textures
* @type {Phaser.Textures.TextureManager}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.textures = new TextureManager(this);
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* An instance of the Cache Manager.
*
2018-01-25 00:48:48 +00:00
* The Cache Manager is a global system responsible for caching, accessing and releasing external game assets.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#cache
* @type {Phaser.Cache.CacheManager}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
2018-01-16 16:30:11 +00:00
this.cache = new CacheManager(this);
2017-10-04 22:48:16 +00:00
/**
* An instance of the Data Manager
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#registry
* @type {Phaser.Data.DataManager}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.registry = new DataManager(this);
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* An instance of the Input Manager.
*
2018-01-25 00:48:48 +00:00
* The Input Manager is a global system responsible for the capture of browser-level input events.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#input
* @type {Phaser.Input.InputManager}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
2018-01-16 16:14:21 +00:00
this.input = new InputManager(this, this.config);
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* An instance of the Scene Manager.
*
2018-01-25 00:48:48 +00:00
* The Scene Manager is a global system responsible for creating, modifying and updating the Scenes in your game.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#scene
* @type {Phaser.Scenes.SceneManager}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
2018-01-16 16:33:23 +00:00
this.scene = new SceneManager(this, this.config.sceneConfig);
2017-10-04 22:48:16 +00:00
/**
* A reference to the Device inspector.
2018-01-25 00:48:48 +00:00
*
* Contains information about the device running this game, such as OS, browser vendor and feature support.
* Used by various systems to determine capabilities and code paths.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#device
2018-03-21 14:40:30 +00:00
* @type {Phaser.DeviceConf}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.device = Device;
2018-10-08 16:03:00 +00:00
/**
* An instance of the Scale Manager.
*
* The Scale Manager is a global system responsible for handling game scaling events.
*
* @name Phaser.Game#scaleManager
* @type {Phaser.Boot.ScaleManager}
* @since 3.15.0
*/
this.scaleManager = new ScaleManager(this, this.config);
/**
2018-01-25 00:48:48 +00:00
* An instance of the base Sound Manager.
*
* The Sound Manager is a global system responsible for the playback and updating of all audio in your game.
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#sound
2018-03-28 14:04:09 +00:00
* @type {Phaser.Sound.BaseSoundManager}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
*/
this.sound = SoundManagerCreator.create(this);
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* An instance of the Time Step.
*
* The Time Step is a global system responsible for setting-up and responding to the browser frame events, processing
* them and calculating delta values. It then automatically calls the game step.
2017-10-04 22:48:16 +00:00
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#loop
* @type {Phaser.Boot.TimeStep}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2017-10-04 22:48:16 +00:00
*/
this.loop = new TimeStep(this, this.config.fps);
/**
2018-01-25 00:48:48 +00:00
* An instance of the Plugin Manager.
*
* The Plugin Manager is a global system that allows plugins to register themselves with it, and can then install
* those plugins into Scenes as required.
*
2018-02-12 23:13:16 +00:00
* @name Phaser.Game#plugins
2018-05-10 16:14:33 +00:00
* @type {Phaser.Plugins.PluginManager}
2018-01-25 00:48:48 +00:00
* @since 3.0.0
*/
this.plugins = new PluginManager(this, this.config);
2018-09-20 13:14:29 +00:00
if (typeof PLUGIN_FBINSTANT)
{
/**
* An instance of the Facebook Instant Games Plugin.
*
* This will only be available if the plugin has been built into Phaser,
* or you're using the special Facebook Instant Games custom build.
*
* @name Phaser.Game#facebook
* @type {Phaser.FacebookInstantGamesPlugin}
* @since 3.13.0
*/
this.facebook = new FacebookInstantGamesPlugin(this);
}
2018-04-16 16:02:32 +00:00
/**
2018-04-16 16:14:12 +00:00
* Is this Game pending destruction at the start of the next frame?
2018-04-16 16:02:32 +00:00
*
* @name Phaser.Game#pendingDestroy
* @type {boolean}
* @private
* @since 3.5.0
*/
this.pendingDestroy = false;
/**
* Remove the Canvas once the destroy is over?
*
* @name Phaser.Game#removeCanvas
* @type {boolean}
* @private
* @since 3.5.0
*/
this.removeCanvas = false;
/**
* Remove everything when the game is destroyed.
* You cannot create a new Phaser instance on the same web page after doing this.
*
* @name Phaser.Game#noReturn
* @type {boolean}
* @private
* @since 3.12.0
*/
this.noReturn = false;
/**
* Does the window the game is running in currently have focus or not?
* This is modified by the VisibilityHandler.
*
* @name Phaser.Game#hasFocus
* @type {boolean}
* @readOnly
* @since 3.9.0
*/
this.hasFocus = false;
/**
* Is the mouse pointer currently over the game canvas or not?
* This is modified by the VisibilityHandler.
*
* @name Phaser.Game#isOver
* @type {boolean}
* @readOnly
* @since 3.10.0
*/
this.isOver = true;
// Wait for the DOM Ready event, then call boot.
DOMContentLoaded(this.boot.bind(this));
},
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* Game boot event.
*
* This is an internal event dispatched when the game has finished booting, but before it is ready to start running.
* The global systems use this event to know when to set themselves up, dispatching their own `ready` events as required.
*
* @event Phaser.Game#boot
*/
/**
* This method is called automatically when the DOM is ready. It is responsible for creating the renderer,
* displaying the Debug Header, adding the game canvas to the DOM and emitting the 'boot' event.
* It listens for a 'ready' event from the base systems and once received it will call `Game.start`.
2017-10-04 22:48:16 +00:00
*
* @method Phaser.Game#boot
2018-01-25 00:48:48 +00:00
* @protected
* @fires Phaser.Game#boot
2017-10-04 22:48:16 +00:00
* @since 3.0.0
*/
boot: function ()
{
if (!PluginCache.hasCore('EventEmitter'))
{
console.warn('Core Phaser Plugins missing. Cannot start.');
return;
}
this.isBooted = true;
this.config.preBoot(this);
2016-11-29 11:26:30 +00:00
CreateRenderer(this);
2018-08-23 17:10:20 +00:00
if (typeof EXPERIMENTAL)
{
CreateDOMContainer(this);
}
DebugHeader(this);
2016-12-07 03:42:41 +00:00
AddToDOM(this.canvas, this.config.parent);
this.events.emit('boot');
// The Texture Manager has to wait on a couple of non-blocking events before it's fully ready.
// So it will emit this internal event when done:
this.events.once('texturesready', this.texturesReady, this);
},
/**
* Called automatically when the Texture Manager has finished setting up and preparing the
* default textures.
*
* @method Phaser.Game#texturesReady
* @private
* @fires Phaser.Game#ready
* @since 3.12.0
*/
texturesReady: function ()
{
// Start all the other systems
this.events.emit('ready');
this.start();
},
/**
2018-01-25 00:48:48 +00:00
* Called automatically by Game.boot once all of the global systems have finished setting themselves up.
* By this point the Game is now ready to start the main loop running.
* It will also enable the Visibility Handler.
*
* @method Phaser.Game#start
2018-01-25 00:48:48 +00:00
* @protected
* @since 3.0.0
*/
start: function ()
{
this.isRunning = true;
this.config.postBoot(this);
if (this.renderer)
{
this.loop.start(this.step.bind(this));
}
else
{
this.loop.start(this.headlessStep.bind(this));
}
VisibilityHandler(this);
var eventEmitter = this.events;
eventEmitter.on('hidden', this.onHidden, this);
eventEmitter.on('visible', this.onVisible, this);
eventEmitter.on('blur', this.onBlur, this);
eventEmitter.on('focus', this.onFocus, this);
},
2018-05-11 17:55:44 +00:00
/**
* Game Pre-Step event.
2018-09-13 07:09:44 +00:00
*
* Listen for it using the event type `prestep`.
2018-05-11 17:55:44 +00:00
*
* This event is dispatched before the main Step starts.
* By this point none of the Scene updates have happened.
* Hook into it from plugins or systems that need to update before the Scene Manager does.
*
* @event Phaser.Game#prestepEvent
2018-09-13 07:09:44 +00:00
* @param {number} time - The current time. Either a High Resolution Timer value if it comes from Request Animation Frame, or Date.now if using SetTimeout.
* @param {number} delta - The delta time in ms since the last frame. This is a smoothed and capped value based on the FPS rate.
2018-05-11 17:55:44 +00:00
*/
/**
* Game Step event.
2018-09-13 07:09:44 +00:00
*
* Listen for it using the event type `step`.
2018-05-11 17:55:44 +00:00
*
* This event is dispatched after Pre-Step and before the Scene Manager steps.
* Hook into it from plugins or systems that need to update before the Scene Manager does, but after core Systems.
*
* @event Phaser.Game#stepEvent
2018-09-13 07:09:44 +00:00
* @param {number} time - The current time. Either a High Resolution Timer value if it comes from Request Animation Frame, or Date.now if using SetTimeout.
* @param {number} delta - The delta time in ms since the last frame. This is a smoothed and capped value based on the FPS rate.
2018-05-11 17:55:44 +00:00
*/
/**
* Game Post-Step event.
2018-09-13 07:09:44 +00:00
*
* Listen for it using the event type `poststep`.
2018-05-11 17:55:44 +00:00
*
* This event is dispatched after the Scene Manager has updated.
* Hook into it from plugins or systems that need to do things before the render starts.
*
* @event Phaser.Game#poststepEvent
2018-09-13 07:09:44 +00:00
* @param {number} time - The current time. Either a High Resolution Timer value if it comes from Request Animation Frame, or Date.now if using SetTimeout.
* @param {number} delta - The delta time in ms since the last frame. This is a smoothed and capped value based on the FPS rate.
2018-05-11 17:55:44 +00:00
*/
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* Game Pre-Render event.
2018-09-13 07:09:44 +00:00
*
* Listen for it using the event type `prerender`.
2018-01-25 00:48:48 +00:00
*
* This event is dispatched immediately before any of the Scenes have started to render.
* The renderer will already have been initialized this frame, clearing itself and preparing to receive
* the Scenes for rendering, but it won't have actually drawn anything yet.
*
2018-02-12 23:51:47 +00:00
* @event Phaser.Game#prerenderEvent
2018-03-28 14:04:09 +00:00
* @param {(Phaser.Renderer.Canvas.CanvasRenderer|Phaser.Renderer.WebGL.WebGLRenderer)} renderer - A reference to the current renderer.
2018-01-25 00:48:48 +00:00
*/
/**
* Game Post-Render event.
2018-09-13 07:09:44 +00:00
*
* Listen for it using the event type `postrender`.
2018-01-25 00:48:48 +00:00
*
* This event is dispatched right at the end of the render process.
* Every Scene will have rendered and drawn to the canvas.
*
2018-02-12 23:51:47 +00:00
* @event Phaser.Game#postrenderEvent
2018-03-28 14:04:09 +00:00
* @param {(Phaser.Renderer.Canvas.CanvasRenderer|Phaser.Renderer.WebGL.WebGLRenderer)} renderer - A reference to the current renderer.
2018-01-25 00:48:48 +00:00
*/
/**
* The main Game Step. Called automatically by the Time Step, once per browser frame (typically as a result of
* Request Animation Frame, or Set Timeout on very old browsers.)
*
* The step will update the global managers first, then proceed to update each Scene in turn, via the Scene Manager.
*
* It will then render each Scene in turn, via the Renderer. This process emits `prerender` and `postrender` events.
2017-10-04 22:48:16 +00:00
*
* @method Phaser.Game#step
2018-05-11 17:55:44 +00:00
* @fires Phaser.Game#prestepEvent
* @fires Phaser.Game#stepEvent
* @fires Phaser.Game#poststepEvent
2018-02-12 23:51:47 +00:00
* @fires Phaser.Game#prerenderEvent
* @fires Phaser.Game#postrenderEvent
2017-10-04 22:48:16 +00:00
* @since 3.0.0
*
2018-09-13 07:09:44 +00:00
* @param {number} time - The current time. Either a High Resolution Timer value if it comes from Request Animation Frame, or Date.now if using SetTimeout.
* @param {number} delta - The delta time in ms since the last frame. This is a smoothed and capped value based on the FPS rate.
2017-10-04 22:48:16 +00:00
*/
step: function (time, delta)
{
2018-04-16 16:02:32 +00:00
if (this.pendingDestroy)
{
return this.runDestroy();
}
var eventEmitter = this.events;
// Global Managers like Input and Sound update in the prestep
2018-05-10 16:14:33 +00:00
eventEmitter.emit('prestep', time, delta);
// This is mostly meant for user-land code and plugins
2017-11-26 15:45:07 +00:00
eventEmitter.emit('step', time, delta);
// Update the Scene Manager and all active Scenes
2017-07-20 10:34:01 +00:00
this.scene.update(time, delta);
// Our final event before rendering starts
eventEmitter.emit('poststep', time, delta);
var renderer = this.renderer;
// Run the Pre-render (clearing the canvas, setting background colors, etc)
renderer.preRender();
eventEmitter.emit('prerender', renderer, time, delta);
// The main render loop. Iterates all Scenes and all Cameras in those scenes, rendering to the renderer instance.
this.scene.render(renderer);
// The Post-Render call. Tidies up loose end, takes snapshots, etc.
renderer.postRender();
// The final event before the step repeats. Your last chance to do anything to the canvas before it all starts again.
eventEmitter.emit('postrender', renderer, time, delta);
},
/**
* A special version of the Game Step for the HEADLESS renderer only.
*
* The main Game Step. Called automatically by the Time Step, once per browser frame (typically as a result of
* Request Animation Frame, or Set Timeout on very old browsers.)
*
* The step will update the global managers first, then proceed to update each Scene in turn, via the Scene Manager.
*
* This process emits `prerender` and `postrender` events, even though nothing actually displays.
*
* @method Phaser.Game#headlessStep
* @fires Phaser.Game#prerenderEvent
* @fires Phaser.Game#postrenderEvent
* @since 3.2.0
*
2018-09-13 07:09:44 +00:00
* @param {number} time - The current time. Either a High Resolution Timer value if it comes from Request Animation Frame, or Date.now if using SetTimeout.
* @param {number} delta - The delta time in ms since the last frame. This is a smoothed and capped value based on the FPS rate.
*/
headlessStep: function (time, delta)
{
var eventEmitter = this.events;
// Global Managers
eventEmitter.emit('prestep', time, delta);
eventEmitter.emit('step', time, delta);
// Scenes
this.scene.update(time, delta);
eventEmitter.emit('poststep', time, delta);
// Render
eventEmitter.emit('prerender');
eventEmitter.emit('postrender');
},
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* Game Pause event.
2018-09-13 07:09:44 +00:00
*
* Listen for it using the event type `pause`.
2018-01-25 00:48:48 +00:00
*
* This event is dispatched when the game loop enters a paused state, usually as a result of the Visibility Handler.
*
2018-02-12 23:51:47 +00:00
* @event Phaser.Game#pauseEvent
2018-01-25 00:48:48 +00:00
*/
/**
* Called automatically by the Visibility Handler.
* This will pause the main loop and then emit a pause event.
2017-10-04 22:48:16 +00:00
*
* @method Phaser.Game#onHidden
* @protected
2018-02-12 23:51:47 +00:00
* @fires Phaser.Game#pauseEvent
2017-10-04 22:48:16 +00:00
* @since 3.0.0
*/
onHidden: function ()
{
this.loop.pause();
this.events.emit('pause');
},
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* Game Resume event.
2018-09-13 07:09:44 +00:00
*
* Listen for it using the event type `resume`.
2018-01-25 00:48:48 +00:00
*
* This event is dispatched when the game loop leaves a paused state and resumes running.
*
2018-02-12 23:51:47 +00:00
* @event Phaser.Game#resumeEvent
2018-01-25 00:48:48 +00:00
*/
/**
* Called automatically by the Visibility Handler.
* This will resume the main loop and then emit a resume event.
2017-10-04 22:48:16 +00:00
*
* @method Phaser.Game#onVisible
* @protected
2018-02-12 23:51:47 +00:00
* @fires Phaser.Game#resumeEvent
2017-10-04 22:48:16 +00:00
* @since 3.0.0
*/
onVisible: function ()
{
this.loop.resume();
this.events.emit('resume');
},
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* Called automatically by the Visibility Handler.
* This will set the main loop into a 'blurred' state, which pauses it.
2017-10-04 22:48:16 +00:00
*
* @method Phaser.Game#onBlur
* @protected
* @since 3.0.0
*/
onBlur: function ()
{
this.hasFocus = false;
this.loop.blur();
},
2017-10-04 22:48:16 +00:00
/**
2018-01-25 00:48:48 +00:00
* Called automatically by the Visibility Handler.
* This will set the main loop into a 'focused' state, which resumes it.
2017-10-04 22:48:16 +00:00
*
* @method Phaser.Game#onFocus
* @protected
* @since 3.0.0
*/
onFocus: function ()
{
this.hasFocus = true;
this.loop.focus();
2018-01-25 00:48:48 +00:00
},
/**
* Game Resize event.
2018-09-13 07:09:44 +00:00
*
* Listen for it using the event type `resize`.
*
* @event Phaser.Game#resizeEvent
* @param {number} width - The new width of the Game.
* @param {number} height - The new height of the Game.
*/
/**
* Updates the Game Config with the new width and height values given.
* Then resizes the Renderer and Input Manager scale.
*
* @method Phaser.Game#resize
2018-10-08 16:03:00 +00:00
* @fires Phaser.Game#resizeEvent
* @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.config.width = width;
this.config.height = height;
2018-08-23 17:10:20 +00:00
if (typeof EXPERIMENTAL)
{
2018-08-23 17:10:20 +00:00
if (this.domContainer)
{
this.domContainer.style.width = width + 'px';
this.domContainer.style.height = height + 'px';
}
}
this.renderer.resize(width, height);
this.input.resize();
this.scene.resize(width, height);
this.events.emit('resize', width, height);
},
2018-09-13 07:09:44 +00:00
/**
* Game Destroy event.
*
* Listen for it using the event type `destroy`.
*
* @event Phaser.Game#destroyEvent
*/
2018-01-25 00:48:48 +00:00
/**
2018-04-16 16:14:12 +00:00
* Flags this Game instance as needing to be destroyed on the next frame.
* It will wait until the current frame has completed and then call `runDestroy` internally.
*
* If you **do not** need to run Phaser again on the same web page you can set the `noReturn` argument to `true` and it will free-up
* memory being held by the core Phaser plugins. If you do need to create another game instance on the same page, leave this as `false`.
2018-01-25 00:48:48 +00:00
*
* @method Phaser.Game#destroy
2018-09-13 07:09:44 +00:00
* @fires Phaser.Game#destroyEvent
2018-01-25 00:48:48 +00:00
* @since 3.0.0
2018-04-16 16:14:12 +00:00
*
* @param {boolean} removeCanvas - Set to `true` if you would like the parent canvas element removed from the DOM, or `false` to leave it in place.
* @param {boolean} [noReturn=false] - If `true` all the core Phaser plugins are destroyed. You cannot create another instance of Phaser on the same web page if you do this.
2018-01-25 00:48:48 +00:00
*/
destroy: function (removeCanvas, noReturn)
2018-01-25 00:48:48 +00:00
{
if (noReturn === undefined) { noReturn = false; }
2018-04-16 16:02:32 +00:00
this.pendingDestroy = true;
2018-04-16 16:14:12 +00:00
this.removeCanvas = removeCanvas;
this.noReturn = noReturn;
2018-04-16 16:02:32 +00:00
},
/**
* Destroys this Phaser.Game instance, all global systems, all sub-systems and all Scenes.
*
* @method Phaser.Game#runDestroy
* @private
* @since 3.5.0
*/
runDestroy: function ()
{
this.events.emit('destroy');
this.events.removeAllListeners();
this.scene.destroy();
if (this.renderer)
{
this.renderer.destroy();
}
2018-04-16 16:02:32 +00:00
if (this.removeCanvas && this.canvas)
{
CanvasPool.remove(this.canvas);
2018-04-19 13:23:55 +00:00
if (this.canvas.parentNode)
{
this.canvas.parentNode.removeChild(this.canvas);
}
}
2018-04-16 16:02:32 +00:00
2018-08-23 17:10:20 +00:00
if (typeof EXPERIMENTAL)
{
2018-08-23 17:10:20 +00:00
if (this.domContainer)
{
this.domContainer.parentNode.removeChild(this.domContainer);
}
}
2018-04-16 16:02:32 +00:00
this.loop.destroy();
2018-04-16 16:02:32 +00:00
this.pendingDestroy = false;
}
2016-10-17 20:22:55 +00:00
});
2017-06-27 01:20:03 +00:00
2016-11-22 03:11:33 +00:00
module.exports = Game;