Phaser

https://docs.phaser.io/api-documentation/
Admin
Phaser is an HTML5 game framework that provides a comprehensive set of tools and features for...
Tokens:1,858,581
Snippets:14,050
Trust Score:9.4
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### install(key, plugin, [start], [mapping], [data])

Source: https://docs.phaser.io/api-documentation/class/plugins-pluginmanager

Installs a new Global Plugin into the Plugin Manager and optionally starts it running. Global plugins belong to the Plugin Manager and can be accessed across all Scenes in the game.

```APIDOC
## install(key, plugin, [start], [mapping], [data])

### Description
Installs a new Global Plugin into the Plugin Manager and optionally starts it running. A global plugin belongs to the Plugin Manager, rather than a specific Scene, and can be accessed and used by all Scenes in your game.

### Parameters
- **key** (string) - Required - The unique handle given to this plugin within the Plugin Manager.
- **plugin** (function) - Required - The plugin code. This should be the non-instantiated version.
- **start** (boolean) - Optional (default: false) - Automatically start the plugin running? This is always `true` if you provide a mapping value.
- **mapping** (string) - Optional - If this plugin is injected into the Phaser.Scene class, this is the property key to use.
- **data** (any) - Optional - A value passed to the plugin's `init` method.

### Returns
- **Phaser.Plugins.BasePlugin** - The plugin that was started, or `null` if `start` was false, or game isn't yet booted.

### Example
```javascript
this.plugins.install('powerupsPlugin', pluginCode);

// and from within the scene:
this.plugins.get('powerupsPlugin');
```
```

--------------------------------

### start()

Source: https://docs.phaser.io/api-documentation/class/loader-loaderplugin

Starts the Loader running, resetting progress and totals, and emits a start event. If the queue is empty it completes immediately; otherwise, it begins loading files in batches.

```APIDOC
## start()

### Description
Starts the Loader running. This will reset the progress and totals and then emit a `start` event. If there is nothing in the queue the Loader will immediately complete, otherwise it will start loading the first batch of files. The Loader is started automatically if the queue is populated within your Scene's `preload` method. However, outside of this, you need to call this method to start it. If the Loader is already running this method will simply return.

### Signature
```javascript
start()
```

### Events Fired
- `Phaser.Loader.Events#event:START`
```

--------------------------------

### Install and access a Global Plugin using install()

Source: https://docs.phaser.io/api-documentation/class/plugins-pluginmanager

Installs a global plugin into the PluginManager with a key handle and retrieves it later from a scene.

```javascript
this.plugins.install('powerupsPlugin', pluginCode);  
  
// and from within the scene:  
this.plugins.get('powerupsPlugin');  

```

--------------------------------

### start(key, [runAs])

Source: https://docs.phaser.io/api-documentation/class/plugins-pluginmanager

Starts a global plugin running. If the plugin was previously active, it resets it to active and calls its start method; otherwise, it creates and initializes a new instance.

```APIDOC
## start(key, [runAs])

### Description
Starts a global plugin running. If the plugin was previously active then calling `start` will reset it to an active state and then call its `start` method. If the plugin has never been run before a new instance of it will be created within the Plugin Manager, its active state set and then both of its `init` and `start` methods called, in that order. If the plugin is already running under the given key then nothing happens.

### Parameters
- **key** (string) - Required - The key of the plugin to start.
- **runAs** (string) - Optional - Run the plugin under a new key. This allows you to run one plugin multiple times.

### Returns
- **Phaser.Plugins.BasePlugin** - The plugin that was started, or `null` if invalid key given or plugin is already stopped.
```

--------------------------------

### START

Source: https://docs.phaser.io/api-documentation/namespace/input-events

Dispatched by the Input Plugin when it has finished setting up, signalling to all internal systems to start.

```APIDOC
## Event: START

### Description
The Input Plugin Start Event. Dispatched by the Input Plugin when it has finished setting-up, signalling to all of its internal systems to start.
```

--------------------------------

### install(target)

Source: https://docs.phaser.io/api-documentation/namespace/input-inputplugincache

Installs all of the registered Input Plugins into the given target.

```APIDOC
### install(target)

#### Description
Installs all of the registered Input Plugins into the given target.

#### Parameters
- **target** (`Phaser.Input.InputPlugin`) - Required. The target InputPlugin to install the plugins into.
```

--------------------------------

### start()

Source: https://docs.phaser.io/api-documentation/class/cameras-controls-smoothedkeycontrol

Starts the Key Control running, provided it has been bound to a camera. Returns the instance for chaining.

```APIDOC
## start()

### Description
Starts the Key Control running, providing it has been linked to a camera.

### Method
`start()`

### Returns
- `Phaser.Cameras.Controls.SmoothedKeyControl` - This Key Control instance.
```

--------------------------------

### start(key, [data])

Source: https://docs.phaser.io/api-documentation/class/scenes-scenemanager

Starts the given Scene if it is not currently starting, loading, or creating. If already active, paused, or sleeping, it will be shut down and restarted.

```APIDOC
### start(key, [data])

#### Description
Starts the given Scene, if it is not starting, loading, or creating. If the Scene is running, paused, or sleeping, it will be shutdown and then started.

#### Parameters
- **key** (`string` | `Phaser.Scene`) - Required - The Scene to start.
- **data** (`object`) - Optional - Optional data object to pass to `Scene.Settings` and `Scene.init`, and `Scene.create`.

#### Returns
- **Phaser.Scenes.SceneManager** - This Scene Manager instance.
```

--------------------------------

### play([fromStart])

Source: https://docs.phaser.io/api-documentation/class/time-timeline

Starts the timeline running. Can optionally reset all events back to the start before playback.

```APIDOC
### play([fromStart])

#### Description
Starts this Timeline running. If the Timeline is already running and the `fromStart` parameter is `true`, then calling this method will reset the Timeline events as incomplete. If you wish to resume a paused Timeline, then use the `Timeline.resume` method instead.

#### Parameters
- **fromStart** (`boolean`) - Optional. Default: `true`. Reset this Timeline back to the start before playing.

#### Returns
- `Phaser.Time.Timeline` - This Timeline instance.
```

--------------------------------

### start(callback)

Source: https://docs.phaser.io/api-documentation/class/core-timestep

Starts the Time Step running if it is not already doing so.

```APIDOC
### start(callback)

**Description:**
Starts the Time Step running, if it is not already doing so. Called automatically by the Game Boot process.

**Parameters:**
- **callback** (`Phaser.Types.Core.TimeStepCallback`) - The callback to be invoked each time the Time Step steps.

**Since:** 3.0.0
```

--------------------------------

### startFollow([config], [startAt])

Source: https://docs.phaser.io/api-documentation/namespace/gameobjects-components-pathfollower

Starts the follower along its configured path from an optional start position.

```APIDOC
## startFollow([config], [startAt])

### Description
Starts this PathFollower following its given Path.

### Syntax
```javascript
follower.startFollow([config], [startAt])
```

### Parameters
- **config** (`number` | `Phaser.Types.GameObjects.PathFollower.PathConfig` | `Phaser.Types.Tweens.NumberTweenBuilderConfig`) - Optional. Configuration object or duration for path following. Default: `{}`.
- **startAt** (`number`) - Optional. Start position of the follow, between 0 and 1. Default: `0`.

### Returns
- **Phaser.GameObjects.Components.PathFollower** - This Game Object.
```

--------------------------------

### start(zoom, [duration], [ease], [force], [callback], [context])

Source: https://docs.phaser.io/api-documentation/class/cameras-scene2d-effects-zoom

Starts zooming the Camera to the given scale over a specified duration with an easing function.

```APIDOC
### start(zoom, [duration], [ease], [force], [callback], [context])

#### Description
Zooms the Camera to the given scale, over the duration and with the ease specified.

#### Parameters
- **zoom** (`number`) - Required - The target Camera zoom value.
- **duration** (`number`) - Optional (default: `1000`) - The duration of the effect in milliseconds.
- **ease** (`string` | `function`) - Optional (default: `'Linear'`) - The ease to use for the Zoom. Can be any of the Phaser Easing constants or a custom function.
- **force** (`boolean`) - Optional (default: `false`) - Force the zoom effect to start immediately, even if already running.
- **callback** (`Phaser.Types.Cameras.Scene2D.CameraZoomCallback`) - Optional - Invoked every frame for the duration of the effect. Receives the camera reference, progress (0 to 1), and current zoom value.
- **context** (`any`) - Optional - The context in which the callback is invoked. Defaults to the Scene to which the Camera belongs.

#### Returns
- `Phaser.Cameras.Scene2D.Camera` - The Camera on which the effect was started.

#### Events Fired
- `Phaser.Cameras.Scene2D.Events#event:ZOOM_START`
- `Phaser.Cameras.Scene2D.Events#event:ZOOM_COMPLETE`
```

--------------------------------

### start([key], [data])

Source: https://docs.phaser.io/api-documentation/class/scenes-sceneplugin

Shuts down the current Scene and starts a specified target Scene at the next update.

```APIDOC
## start([key], [data])

### Description
Shutdown this Scene and run the given one. This will happen at the next Scene Manager update, not immediately.

### Parameters
- **key** (`string` | `Phaser.Scene`) - Optional. The Scene to start.
- **data** (`object`) - Optional. The Scene data. If no value is given it will not overwrite any previous data that may exist.

### Returns
- **Phaser.Scenes.ScenePlugin** - This Scene Plugin instance.
```

--------------------------------

### start(data)

Source: https://docs.phaser.io/api-documentation/class/scenes-systems

Start this Scene running and rendering. Usually called automatically by SceneManager.

```APIDOC
## Phaser.Scenes.Systems.start(data)

### Description
Start this Scene running and rendering. Called automatically by the SceneManager.

### Parameters
- **data** (object, required) - Optional data object that may have been passed to this Scene from another.

### Events Fired
- `Phaser.Scenes.Events#event:START`
- `Phaser.Scenes.Events#event:READY`
```

--------------------------------

### get(key)

Source: https://docs.phaser.io/api-documentation/class/sound-noaudiosoundmanager

Gets the first sound instance in the manager matching the given asset key.

```APIDOC
### Method
`get(key)`

#### Description
Gets the first sound in the manager matching the given key, if any.

#### Parameters
- **key** (`string`) - Sound asset key.

#### Returns
- `Phaser.Sound.BaseSound` - The sound instance, or null.
```

--------------------------------

### start()

Source: https://docs.phaser.io/api-documentation/class/plugins-baseplugin

Lifecycle method called by the PluginManager when the Global Plugin is started. Typically called immediately after init or when a stopped plugin is resumed.

```APIDOC
## Method: start()

### Description
The PluginManager calls this method on a Global Plugin when the plugin is started. If a plugin is stopped and started again, this method will be called again. Typically invoked immediately after `init`.

### Syntax
```javascript
start()
```
```

--------------------------------

### init()

Source: https://docs.phaser.io/api-documentation/class/renderer-canvas-canvasrenderer

Sets up the event listeners required by the renderer, including listening for the Game BOOT event and Texture Manager READY event.

```APIDOC
### init()

#### Description
Sets up the event listeners required by the renderer. Specifically, it listens for the Game BOOT event to fill the background color on the canvas, and waits for the Texture Manager's READY event before completing the boot sequence and registering the Scale Manager resize handler.
```

--------------------------------

### getStartPoint([out])

Source: https://docs.phaser.io/api-documentation/class/curves-cubicbezier

Gets the starting point coordinates on the curve.

```APIDOC
## getStartPoint([out])

### Description
Gets the starting point on the curve.

### Scope
Instance method

### Parameters
- **out** (`Phaser.Math.Vector2`) - Optional - A Vector2 object to store the result in. If not given will be created.

### Returns
- **Phaser.Math.Vector2** - The coordinates of the point on the curve. If an `out` object was given this will be returned.
```

--------------------------------

### Phaser.Curves.Ellipse#getStartPoint

Source: https://docs.phaser.io/api-documentation/class/curves-ellipse

Gets the starting point on the curve. Returns the coordinates stored in an optional Vector2 target.

```APIDOC
## getStartPoint([out])

### Description
Gets the starting point on the curve.

### Parameters
- **out** (Phaser.Math.Vector2) [optional] - A Vector2 object to store the result in. If not given will be created.

### Returns
- **Phaser.Math.Vector2** - The coordinates of the point on the curve. If an `out` object was given this will be returned.
```

--------------------------------

### getPoint(t, [out])

Source: https://docs.phaser.io/api-documentation/class/curves-line

Gets a point at a relative position along the line, where 0 represents the start and 1 represents the end. Results can be stored in an optional output Vector2.

```APIDOC
### getPoint(t, [out])

**Description:**
Gets a point at a relative position along the line, where 0 is the start point and 1 is the end point.

**Parameters:**
- `t` (number) - Required. The position along the curve to return. Where 0 is the start and 1 is the end.
- `out` (Phaser.Math.Vector2) - Optional. A Vector2 object to store the result in. If not given will be created.

**Returns:**
- `Phaser.Math.Vector2` - The coordinates of the point on the curve. If an `out` object was given this will be returned.
```

--------------------------------

### timeline.play()

Source: https://docs.phaser.io/api-documentation/class/time-timeline

Starts running the Timeline. Timelines always start paused upon creation and must be started with this method.

```APIDOC
### Method

`play()`

### Description
Starts the Timeline running from its initial or current state.

### Returns
- Returns the Timeline instance for chaining.

### Example
```javascript
timeline.play();
```
```

--------------------------------

### start

Source: https://docs.phaser.io/api-documentation/class/gameobjects-gradient

The starting point within the quad from which the gradient emanates.

```APIDOC
### Property
`start: Phaser.Types.Math.Vector2Like`

### Description
The start location of the gradient within its quad. The gradient emanates from this point. Gradient color starts here and ends at the tip of the `shape` vector.

### Since
4.0.0
```

--------------------------------

### boot()

Source: https://docs.phaser.io/api-documentation/class/animations-animationmanager

Initializes and registers internal event listeners after the Game boots.

```APIDOC
### boot()

#### Description
Registers event listeners after the Game boots.

#### Parameters
*None*
```

--------------------------------

### startAnimation(key)

Source: https://docs.phaser.io/api-documentation/class/animations-animationstate

Loads the animation based on key or config and sets up internal values needed for playback.

```APIDOC
### startAnimation(key)

#### Description
Load the animation based on the key and set-up all of the internal values needed for playback to start. If there is no delay, it will also fire the start events.

#### Parameters
- **key** (string | Phaser.Types.Animations.PlayAnimationConfig, required) - The string-based key of the animation to play, or a `PlayAnimationConfig` object.

#### Returns
- **Phaser.GameObjects.GameObject** - The Game Object that owns this Animation Component.

#### Fires Events
- `Phaser.Animations.Events#event:ANIMATION_START`

#### Source
- Source: `src/animations/AnimationState.js#L975`
- Since: 3.50.0
```

--------------------------------

### init(config)

Source: https://docs.phaser.io/api-documentation/class/renderer-webgl-webglrenderer

Creates a new WebGLRenderingContext and initializes all internal state for the renderer. Accepts a configuration object and returns the current WebGLRenderer instance.

```APIDOC
### init(config)

#### Description
Creates a new WebGLRenderingContext and initializes all internal state.

#### Parameters
- **config** (object) - Required. The configuration object for the renderer.

#### Returns
- **Phaser.Renderer.WebGL.WebGLRenderer** - This WebGLRenderer instance.

#### Since
3.0.0
```

--------------------------------

### ParticleEmitter.on('start', listener)

Source: https://docs.phaser.io/api-documentation/event/gameobjects-particles-events

Dispatched when a Particle Emitter starts emission of particles.

```APIDOC
### START

**Event:** `'start'` / `Phaser.GameObjects.Particles.Events.START`

#### Description
The Particle Emitter Start Event. This event is dispatched when a Particle Emitter starts emission of particles.

#### Usage
```javascript
ParticleEmitter.on('start', listener);
```

#### Event Parameters
- **emitter** (`Phaser.GameObjects.Particles.ParticleEmitter`) - Required - A reference to the Particle Emitter that just completed.
```

--------------------------------

### boot()

Source: https://docs.phaser.io/api-documentation/class/plugins-sceneplugin

Called once when the Scene boots. Override this method to configure event listeners and scene-specific resources.

```APIDOC
### Method Signature

```javascript
boot()
```

### Description
This method is called once when the Scene boots. By this point, `scene` and `systems` properties are set. Used to register listeners for Scene lifecycle events.

### Usage Example
```javascript
var eventEmitter = this.systems.events;
eventEmitter.once('destroy', this.sceneDestroy, this);
```
```

--------------------------------

### start(angle, [shortestPath], [duration], [ease], [force], [callback], [context])

Source: https://docs.phaser.io/api-documentation/class/cameras-scene2d-effects-rotateto

Rotate the Camera to the given angle over the duration and with the ease specified.

```APIDOC
### start(angle, [shortestPath], [duration], [ease], [force], [callback], [context])

#### Description
Rotate the Camera to the given angle over the duration and with the ease specified.

#### Parameters
- **angle** (number) - Required - The destination angle in radians to rotate the Camera view to.
- **shortestPath** (boolean) - Optional (default: `false`) - If true, take the shortest distance to the destination. This adjusts the destination angle to be within one half turn of the start angle.
- **duration** (number) - Optional (default: `1000`) - The duration of the effect in milliseconds.
- **ease** (string | function) - Optional (default: `'Linear'`) - The ease to use. Can be any of the Phaser Easing constants or a custom function.
- **force** (boolean) - Optional (default: `false`) - Force the rotation effect to start immediately, even if already running.
- **callback** (Phaser.Types.Cameras.Scene2D.CameraRotateCallback) - Optional - This callback will be invoked every frame for the duration of the effect. Sent arguments: camera reference, progress (0 to 1), and current camera rotation.
- **context** (any) - Optional - The context in which the callback is invoked. Defaults to the Scene to which the Camera belongs.

#### Returns
- **Phaser.Cameras.Scene2D.Camera** - The Camera on which the effect was started.

#### Fires
- `Phaser.Cameras.Scene2D.Events#event:ROTATE_START`
- `Phaser.Cameras.Scene2D.Events#event:ROTATE_COMPLETE`
```

--------------------------------

### init(game)

Source: https://docs.phaser.io/api-documentation/class/textures-texturesource

Creates a WebGL Texture, if required, and sets the Texture filter mode. Requires a Phaser.Game instance.

```APIDOC
### init(game)

#### Description
Creates a WebGL Texture, if required, and sets the Texture filter mode.

#### Syntax
```javascript
init(game)
```

#### Parameters
- **game** (`Phaser.Game`) - Required. A reference to the Phaser Game instance.
```

--------------------------------

### Example matrix for CheckMatrix

Source: https://docs.phaser.io/api-documentation/function/utils

Example 2D array matrix structure evaluated by CheckMatrix.

```javascript
[  
   [ 1, 1, 1, 1, 1, 1 ],  
   [ 2, 0, 0, 0, 0, 4 ],  
   [ 2, 0, 1, 2, 0, 4 ],  
   [ 2, 0, 3, 4, 0, 4 ],  
   [ 2, 0, 0, 0, 0, 4 ],  
   [ 3, 3, 3, 3, 3, 3 ]  
]  

```

--------------------------------

### boot()

Source: https://docs.phaser.io/api-documentation/class/gameobjects-lightsplugin

Handles the boot event from the Scene's Event Emitter. Sets up subscriptions to shutdown and destroy events for automatic resource cleanup.

```APIDOC
## boot()

### Description
Handles the boot event from the Scene's Event Emitter, subscribing to the Scene's `shutdown` and `destroy` events so the plugin can clean up its resources when the Scene is stopped or destroyed.

### Parameters
None.
```

--------------------------------

### START

Source: https://docs.phaser.io/api-documentation/namespace/loader-events

Dispatched when the Loader starts running its queue. Dispatched even when there are no files in the load queue.

```APIDOC
## Event: START

### Description
The Loader Plugin Start Event. This event is dispatched when the Loader starts running. At this point load progress is zero.

### Usage
```javascript
this.load.on('start', listener);
```

### Event Listener Parameters
- **loader** (Phaser.Loader.LoaderPlugin) - Required - A reference to the Loader Plugin that dispatched this event.
```

--------------------------------

### Phaser.Scenes.Settings.create(config)

Source: https://docs.phaser.io/api-documentation/function/scenes

Takes a Scene configuration object and returns a fully formed System Settings object.

```APIDOC
### Phaser.Scenes.Settings.create(config)

#### Description
Takes a Scene configuration object and returns a fully formed System Settings object.

#### Parameters
- **config** (`string` | `Phaser.Types.Scenes.SettingsConfig`) - Required - The Scene configuration object used to create this Scene Settings.

#### Returns
- **Phaser.Types.Scenes.SettingsObject** - The Scene Settings object created as a result of the config and default settings.
```

--------------------------------

### Phaser.Cameras.Scene2D.Events.SHAKE_START

Source: https://docs.phaser.io/api-documentation/event/cameras-scene2d-events

The Camera Shake Start Event. Dispatched by a Camera instance when the Shake Effect starts.

```APIDOC
## Phaser.Cameras.Scene2D.Events.SHAKE_START

### Description
The Camera Shake Start Event. Dispatched by a Camera instance when the Shake Effect starts.

### Event String
- `'camerashakestart'`
- `Phaser.Cameras.Scene2D.Events.SHAKE_START`

### Usage Example
```javascript
this.cameras.main.on('camerashakestart', (camera, effect, duration, intensity) => {});
// or
this.cameras.main.on(Phaser.Cameras.Scene2D.Events.SHAKE_START, (camera, effect, duration, intensity) => {});
```

### Parameters
- **camera** (`Phaser.Cameras.Scene2D.Camera`) - Required - The camera that the effect began on.
- **effect** (`Phaser.Cameras.Scene2D.Effects.Shake`) - Required - A reference to the effect instance.
- **duration** (`number`) - Required - The duration of the effect.
- **intensity** (`number`) - Required - The intensity of the effect.
```

--------------------------------

### Phaser.Cameras.Scene2D.Events.FLASH_START

Source: https://docs.phaser.io/api-documentation/event/cameras-scene2d-events

The Camera Flash Start Event. Dispatched by a Camera instance when the Flash Effect starts.

```APIDOC
## Event: Phaser.Cameras.Scene2D.Events.FLASH_START

### Description
The Camera Flash Start Event. This event is dispatched by a Camera instance when the Flash Effect starts.

### Event String
`'cameraflashstart'` or `Phaser.Cameras.Scene2D.Events.FLASH_START`

### Member Of
`Phaser.Cameras.Scene2D.Events`

### Event Parameters
- **camera** (`Phaser.Cameras.Scene2D.Camera`) - Required - The camera that the effect began on.
- **effect** (`Phaser.Cameras.Scene2D.Effects.Flash`) - Required - A reference to the effect instance.
- **duration** (`number`) - Required - The duration of the effect.
- **red** (`number`) - Required - The red color channel value.
- **green** (`number`) - Required - The green color channel value.
- **blue** (`number`) - Required - The blue color channel value.

### Usage Example
```javascript
this.cameras.main.on(Phaser.Cameras.Scene2D.Events.FLASH_START, (camera, effect, duration, red, green, blue) => {
  // Handle flash start
});
```
```

--------------------------------

### init()

Source: https://docs.phaser.io/api-documentation/class/tweens-tweenchain

Prepares this TweenChain for playback. Called automatically by the TweenManager.

```APIDOC
### init()

**Description:**
Prepares this TweenChain for playback. Called automatically by the TweenManager. Should not be called directly.

**Returns:**
- `Phaser.Tweens.TweenChain` - This TweenChain instance.
```

--------------------------------

### new AudioFile(loader, key, [urlConfig], [xhrSettings], [audioContext])

Source: https://docs.phaser.io/api-documentation/class/loader-filetypes-audiofile

Initializes a single AudioFile instance for loading audio data as an ArrayBuffer over XHR and decoding it via Web Audio API.

```APIDOC
## Constructor: new AudioFile(loader, key, [urlConfig], [xhrSettings], [audioContext])

### Description
A single Audio File suitable for loading by the Loader via the Web Audio API. This file type loads audio data as an ArrayBuffer over XHR and decodes it into an AudioBuffer using the Web Audio API's decodeAudioData method, storing the result in the Phaser Audio Cache.

### Parameters
- **loader** (`Phaser.Loader.LoaderPlugin`) - Required - A reference to the Loader that is responsible for this file.
- **key** (`string` | `Phaser.Types.Loader.FileTypes.AudioFileConfig`) - Required - The key to use for this file, or a file configuration object.
- **urlConfig** (`Phaser.Types.Loader.FileTypes.AudioFileURLConfig`) - Optional - The absolute or relative URL to load this file from in a config object.
- **xhrSettings** (`Phaser.Types.Loader.XHRSettingsObject`) - Optional - Extra XHR Settings specifically for this file.
- **audioContext** (`AudioContext`) - Optional - The AudioContext this file will use to process itself.
```

--------------------------------

### startFullscreen([fullscreenOptions])

Source: https://docs.phaser.io/api-documentation/class/scale-scalemanager

Requests the browser to enter full screen mode using the Fullscreen API. Must be invoked from a user-input gesture such as pointerup.

```APIDOC
### startFullscreen([fullscreenOptions])

**Description**
Sends a request to the browser to ask it to go into full screen mode, using the Fullscreen API. If the browser does not support this, a `FULLSCREEN_UNSUPPORTED` event will be emitted. This method must be called from a `pointerup` user-input gesture (not `pointerdown`).

**Parameters**
- `fullscreenOptions` (object, optional) - The FullscreenOptions dictionary is used to provide configuration options when entering full screen.

**Fires**
- `Phaser.Scale.Events#event:ENTER_FULLSCREEN`
- `Phaser.Scale.Events#event:FULLSCREEN_FAILED`
- `Phaser.Scale.Events#event:FULLSCREEN_UNSUPPORTED`
- `Phaser.Scale.Events#event:RESIZE`
```

--------------------------------

### DRAG_START

Source: https://docs.phaser.io/api-documentation/event/input-events

The Pointer Drag Start Input Event dispatched when a pointer starts dragging any Game Object.

```APIDOC
## Event: DRAG_START ('dragstart')

### Description
The Pointer Drag Start Input Event. This event is dispatched by the Input Plugin belonging to a Scene if a pointer starts to drag any Game Object.

### Usage
```javascript
this.input.on('dragstart', listener);
```

### Event Parameters
- **pointer** (Phaser.Input.Pointer) - Required - The Pointer responsible for triggering this event.
- **gameObject** (Phaser.GameObjects.GameObject) - Required - The interactive Game Object that this pointer is dragging.

### Member of
Phaser.Input.Events
```

--------------------------------

### start(x, y, [duration], [ease], [force], [callback], [context])

Source: https://docs.phaser.io/api-documentation/class/cameras-scene2d-effects-pan

Scrolls the Camera so that the center of its viewport finishes at the given destination over a specified duration and easing function. Returns a reference to the Camera and triggers pan events.

```APIDOC
## start(x, y, [duration], [ease], [force], [callback], [context])

### Description
This effect will scroll the Camera so that the center of its viewport finishes at the given destination, over the duration and with the ease specified.

### Parameters
- **x** (number) - Required - The destination x coordinate to scroll the center of the Camera viewport to.
- **y** (number) - Required - The destination y coordinate to scroll the center of the Camera viewport to.
- **duration** (number) - Optional (default: `1000`) - The duration of the effect in milliseconds.
- **ease** (string | function) - Optional (default: `'Linear'`) - The ease to use for the pan. Can be any of the Phaser Easing constants or a custom function.
- **force** (boolean) - Optional (default: `false`) - Force the pan effect to start immediately, even if already running.
- **callback** (Phaser.Types.Cameras.Scene2D.CameraPanCallback) - Optional - Callback invoked every frame for the duration of the effect with arguments: `(camera, progress, scrollX, scrollY)`.
- **context** (any) - Optional - The context in which the callback is invoked. Defaults to the Scene to which the Camera belongs.

### Returns
- **Phaser.Cameras.Scene2D.Camera** - The Camera on which the effect was started.

### Fires Events
- `Phaser.Cameras.Scene2D.Events#event:PAN_START`
- `Phaser.Cameras.Scene2D.Events#event:PAN_COMPLETE`
```

--------------------------------

### GetTileCornersFunction(orientation)

Source: https://docs.phaser.io/api-documentation/function/tilemaps

Gets the correct function to use to get tile corners based on the map orientation.

```APIDOC
## GetTileCornersFunction(orientation)

### Description
Gets the correct function to use to get the tile corners, based on the map orientation.

### Parameters
- **orientation** (number) - Required - The Tilemap orientation constant.

### Returns
- **function** - The function to use to get the tile corners for the given map orientation.
```

--------------------------------

### start([duration], [intensity], [force], [callback], [context])

Source: https://docs.phaser.io/api-documentation/class/cameras-scene2d-effects-shake

Shakes the Camera by the given intensity over the duration specified. Dispatches SHAKE_START and SHAKE_COMPLETE events.

```APIDOC
## Method: start([duration], [intensity], [force], [callback], [context])

### Description
Shakes the Camera by the given intensity over the duration specified.

### Parameters
- **duration** (`number`) - Optional - The duration of the effect in milliseconds. Default: `100`.
- **intensity** (`number` | `Phaser.Math.Vector2`) - Optional - The intensity of the shake. Default: `0.05`.
- **force** (`boolean`) - Optional - Force the shake effect to start immediately, even if already running. Default: `false`.
- **callback** (`Phaser.Types.Cameras.Scene2D.CameraShakeCallback`) - Optional - This callback will be invoked every frame for the duration of the effect. It is sent two arguments: A reference to the camera and a progress amount between 0 and 1 indicating how complete the effect is.
- **context** (`any`) - Optional - The context in which the callback is invoked. Defaults to the Scene to which the Camera belongs.

### Returns
- `Phaser.Cameras.Scene2D.Camera` - The Camera on which the effect was started.

### Fires
- `Phaser.Cameras.Scene2D.Events#event:SHAKE_START`
- `Phaser.Cameras.Scene2D.Events#event:SHAKE_COMPLETE`
```
Tokens:
Raw