diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5cbde73cc..c1f9b6a62 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,49 +1,87 @@
# Change Log
-## Version 3.22 - Senku - in development
+## Version 3.23 - Ginro - in development
-### Matter Physics Updates
+### New Features
+### Updates
+
+### Bug Fixes
+
+* The conditional checking if the `PathFollower` was at the end of the path or not was incorrect (thanks @samme)
+
+### Examples, Documentation and TypeScript
+
+My thanks to the following for helping with the Phaser 3 Examples, Docs and TypeScript definitions, either by reporting errors, fixing them or helping author the docs:
+
+
+
+## Version 3.22 - Kohaku - January 15th 2020
+
+### Matter Physics
+
+All of the following are specific to the Matter Physics implementation used by Phaser:
+
+#### Matter Physics New Features
+
+* Matter Physics now has 100% JSDoc coverage! Woohoo :)
+* Matter Physics now has brand new TypeScript defs included in the `types` folder :)
* `MatterDebugConfig` is a new configuration object that contains all of the following new Matter debug settings:
-* `showBody` - Render the dynamic bodies in the world to the Graphics object?
-* `showStaticBody` - Render the static bodies in the world to the Graphics object?
-* `showSleeping` - Render any sleeping bodies (dynamic or static) in the world to the Graphics object?
-* `showJoint` - Render all world constraints to the Graphics object?
-* `showInternalEdges` - When rendering bodies, render the internal edges as well?
-* `showConvexHulls` - When rendering polygon bodies, render the convex hull as well?
-* `renderFill` - Render the bodies using a fill color.
+* `showAxes`- Render all of the body axes?
+* `showAngleIndicator`- Render just a single body axis?
+* `angleColor`- The color of the body angle / axes lines.
+* `showBroadphase`- Render the broadphase grid?
+* `broadphaseColor`- The color of the broadphase grid.
+* `showBounds`- Render the bounds of the bodies in the world?
+* `boundsColor`- The color of the body bounds.
+* `showVelocity`- Render the velocity of the bodies in the world?
+* `velocityColor`- The color of the body velocity line.
+* `showCollisions`- Render the collision points and normals for colliding pairs.
+* `collisionColor`- The color of the collision points.
+* `showSeparation`- Render lines showing the separation between bodies.
+* `separationColor`- The color of the body separation line.
+* `showBody`- Render the dynamic bodies in the world to the Graphics object?
+* `showStaticBody`- Render the static bodies in the world to the Graphics object?
+* `showInternalEdges`- When rendering bodies, render the internal edges as well?
+* `renderFill`- Render the bodies using a fill color.
* `renderLine`- Render the bodies using a line stroke.
-* `fillColor` - The color value of the fill when rendering dynamic bodies.
-* `fillOpacity` - The opacity of the fill when rendering dynamic bodies, a value between 0 and 1.
-* `lineColor` - The color value of the line stroke when rendering dynamic bodies.
-* `lineOpacity` - The opacity of the line when rendering dynamic bodies, a value between 0 and 1.
-* `lineThickness` - If rendering lines, the thickness of the line.
-* `staticFillColor` - The color value of the fill when rendering static bodies.
-* `staticLineColor` - The color value of the line stroke when rendering static bodies.
-* `staticBodySleepOpacity` - The amount to multiply the opacity of sleeping static bodies by.
-* `sleepFillColor` - The color value of the fill when rendering sleeping dynamic bodies.
-* `sleepLineColor` - The color value of the line stroke when rendering sleeping dynamic bodies.
-* `jointColor` - The color value of joints when `showJoint` is set.
-* `jointLineOpacity` - The line opacity when rendering joints, a value between 0 and 1.
-* `jointLineThickness` - The line thickness when rendering joints.
-* `pinSize` - The size of the circles drawn when rendering pin constraints.
-* `pinColor` - The color value of the circles drawn when rendering pin constraints.
-* `springColor` - The color value of spring constraints.
-* `anchorColor` - The color value of constraint anchors.
-* `anchorSize` - The size of the circles drawn as the constraint anchors.
-* `hullColor` - The color value of hulls when `showConvexHulls` is set.
-* The `debug` property in the Matter World Config is now a `MatterDebugConfig` option instead of a boolean. However, if a boolean is given, it will use the default debug config values.
-* The following `MatterWorldConfig` options have now been removed: `debugShowBody`, `debugShowStaticBody`, `debugBodyColor`, `debugBodyFillColor`, `debugStaticBodyColor`, `debugShowJoint`, `debugJointColor`, `debugWireframes`, `debugShowInternalEdges`, `debugShowConvexHulls`, `debugConvexHullColor` and `debugShowSleeping`. These can all be set via the new `MatterDebugConfig` object instead.
-* The object `World.defaults` has been removed. Defaults are now access via `World.debugDefaults`.
+* `fillColor`- The color value of the fill when rendering dynamic bodies.
+* `fillOpacity`- The opacity of the fill when rendering dynamic bodies, a value between 0 and 1.
+* `lineColor`- The color value of the line stroke when rendering dynamic bodies.
+* `lineOpacity`- The opacity of the line when rendering dynamic bodies, a value between 0 and 1.
+* `lineThickness`- If rendering lines, the thickness of the line.
+* `staticFillColor`- The color value of the fill when rendering static bodies.
+* `staticLineColor`- The color value of the line stroke when rendering static bodies.
+* `showSleeping`- Render any sleeping bodies (dynamic or static) in the world to the Graphics object?
+* `staticBodySleepOpacity`] - The amount to multiply the opacity of sleeping static bodies by.
+* `sleepFillColor`- The color value of the fill when rendering sleeping dynamic bodies.
+* `sleepLineColor`- The color value of the line stroke when rendering sleeping dynamic bodies.
+* `showSensors`- Render bodies or body parts that are flagged as being a sensor?
+* `sensorFillColor`- The fill color when rendering body sensors.
+* `sensorLineColor`- The line color when rendering body sensors.
+* `showPositions`- Render the position of non-static bodies?
+* `positionSize`- The size of the rectangle drawn when rendering the body position.
+* `positionColor`- The color value of the rectangle drawn when rendering the body position.
+* `showJoint`- Render all world constraints to the Graphics object?
+* `jointColor`- The color value of joints when `showJoint` is set.
+* `jointLineOpacity`- The line opacity when rendering joints, a value between 0 and 1.
+* `jointLineThickness`- The line thickness when rendering joints.
+* `pinSize`- The size of the circles drawn when rendering pin constraints.
+* `pinColor`- The color value of the circles drawn when rendering pin constraints.
+* `springColor`- The color value of spring constraints.
+* `anchorColor`- The color value of constraint anchors.
+* `anchorSize`- The size of the circles drawn as the constraint anchors.
+* `showConvexHulls`- When rendering polygon bodies, render the convex hull as well?
+* `hullColor`- The color value of hulls when `showConvexHulls` is set.
* `World.renderBody` is a new method that will render a single Matter Body to the given Graphics object. This is used internally during debug rendering but is also public. This allows you to control which bodies are rendered and to which Graphics object, should you wish to use them in-game and not just during debugging.
* `World.renderConstraint` is a new method that will render a single Matter Constraint, such as a pin or a spring, to the given Graphics object. This is used internally during debug rendering but is also public. This allows you to control which constraints are rendered and to which Graphics object, should you wish to use them in-game and not just during debugging.
* `World.renderConvexHull` is a new method that will render the convex hull of a single Matter Body, to the given Graphics object. This is used internally during debug rendering but is also public. This allows you to control which hulls are rendered and to which Graphics object, should you wish to use them in-game and not just during debugging.
-* `World.renderBodies` has been rewritten to cache commonly-used values and avoid a situation when a single body would be rendered twice.
-* The private method `World.renderConvexHulls` has been removed as it's no longer used internally.
-* The private method `World.renderWireframes` has been removed as it's no longer used internally.
-* Due to the rewrite of the debug rendering, it is now possible to render _just_ constraints, where-as before this was only possible if bodies were being rendered as well. Fix #4880 (thanks @roberto257)
-* The method `World.fromPath` has been removed. This was never used internally and you can get the same results by calling `Vertices.fromPath`.
-* The `World.setBounds` argument `thickness` now defaults to 64, not 128, to keep it matching the Matter World Config.
+* `World.renderGrid` is a new method that will render the broadphase Grid to the given graphics instance.
+* `World.renderBodyBounds` is a new method that will render the bounds of all the given bodies to the given graphics instance.
+* `World.renderBodyAxes` is a new method that will render the axes of all the given bodies to the given graphics instance.
+* `World.renderBodyVelocity` is a new method that will render a velocity line for all the given bodies to the given graphics instance.
+* `World.renderSeparations` is a new method that will render the separations in the current pairs list to the given graphics instance.
+* `World.renderCollisions` is a new method that will render the collision points and normals in the current pairs list to the given graphics instance.
* `World.getAllBodies` is a new method that will return all bodies in the Matter World.
* `World.getAllConstraints` is a new method that will return all constraints in the Matter World.
* `World.getAllComposites` is a new method that will return all composites in the Matter World.
@@ -66,8 +104,6 @@
* `AFTER_ADD` is a new Event dispatched by `Matter.World` when a Body or Constraint has been added to the World.
* `BEFORE_REMOVE` is a new Event dispatched by `Matter.World` when a Body or Constraint is about to be removed from the World.
* `AFTER_REMOVE` is a new Event dispatched by `Matter.World` when a Body or Constraint has been removed from the World.
-* The `Body.render.fillStyle` property that existed on the Matter Body object has been removed and replaced with `fillColor`.
-* The `Body.render.strokeStyle` property that existed on the Matter Body object has been removed and replaced with `lineColor`.
* `Body.render.lineOpacity` is a new property on the Matter Body object that allows for custom debug rendering.
* `Body.render.lineThickness` is a new property on the Matter Body object that allows for custom debug rendering.
* `Body.render.fillOpacity` is a new property on the Matter Body object that allows for custom debug rendering.
@@ -88,24 +124,13 @@
* `MatterPhysics.setCollisionCategory` is a new method that will set the collision filter category to the value given, on all of the bodies given. This allows you to easily set the category on bodies that don't have a Phaser Matter Collision component.
* `MatterPhysics.setCollisionGroup` is a new method that will set the collision filter group to the value given, on all of the bodies given. This allows you to easily set the group on bodies that don't have a Phaser Matter Collision component.
* `MatterPhysics.setCollidesWith` is a new method that will set the collision filter mask to the value given, on all of the bodies given. This allows you to easily set the filter mask on bodies that don't have a Phaser Matter Collision component.
-* `Matter.Body.centerOfMass` is a new property added to the Matter Body object that retains the center of mass coordinates when the Body is first created.
-* `Matter.Body.render.sprite.xOffset` and `yOffset` are no longer set to anything when a Body is created. They are left as zero, or you can override them in the Body config, in which case the value is added to the sprite origin offset.
-* `Matter.Transform.centerOffsetX` is a new read-only property available on all Matter Game Objects that returns the horizontal offset between the center of the frame and the center of mass. This can be used to allow for accurately mapping texture centers to the body center.
-* `Matter.Transform.centerOffsetY` is a new read-only property available on all Matter Game Objects that returns the vertical offset between the center of the frame and the center of mass. This can be used to allow for accurately mapping texture centers to the body center.
-* The `Matter.Mass.centerOfMass` component property now returns the pre-calculated Body `centerOfMass` property, which is much more accurate than the previous bounds offset value.
-* `Matter.setExistingBody`, which is called interally whenever a Body is set on a Game Object, now uses the new `centerOffset` values to ensure that the texture frame is correctly centered based on the center of mass, not the Body bounds, allowing for much more accurate body to texture mapping with complex multi-part compound bodies.
-* The `Matter.PhysicsEditorParser` has been updated so it no longer needs to set the render offsets, and instead uses the center of mass values.
-* If the `Matter.Body` config doesn't contain a `position` property, it will now default to using `Vertices.centre(body.vertices)` as the position. In most cases, this is what you need, so it saves having to pass it in the config object.
+* `Matter.Body.centerOfMass` is a new vec2 property added to the Matter Body object that retains the center of mass coordinates when the Body is first created, or has parts added to it. These are float values, derived from the body position and bounds.
+* `Matter.Body.centerOffset` is a new vec2 property added to the Matter Body object that retains the center offset coordinates when the Body is first created, or has parts added to it. These are pixel values.
* `Constraint.pointAWorld` is a new method added to Matter that returns the world-space position of `constraint.pointA`, accounting for `constraint.bodyA`.
* `Constraint.pointBWorld` is a new method added to Matter that returns the world-space position of `constraint.pointB`, accounting for `constraint.bodyB`.
* `Body.setCentre` is a new method added to Matter that allows you to set the center of mass of a Body (please note the English spelling of this function.)
-* Bumped Matter Plugin versions to avoid console logs from Common.info and Common.warn.
-* `Body.scale` is a new vector that holds the most recent scale values as passed to `Body.scale`.
+* `Body.scale` is a new read-only vector that holds the most recent scale values as passed to `Body.scale`.
* `Matter.Bodies.flagCoincidentParts` is a new function that will flags all internal edges (coincident parts) on an array of body parts. This was previously part of the `fromVertices` function, but has been made external for outside use.
-* `PhysicsEditorParser.parseVertices` now uses `Bodies.flagCoincidentParts` to avoid duplicating code.
-* `MatterGameObject` has a new optional boolean parameter `addToWorld` which lets you control if the Body should be added to the world or not. Useful for toggling off should you be merging pre-existing bodies with Game Objects.
-* The `Matter.SetBody.setExistingBody` function, which all Matter Game Objects have, has a new parameter `addToWorld` which allows you to control when the body is added to the Matter world should you not require it immediately. It will also only add the body to the world if it doesn't already exist within it, or any of its composites.
-* `PointerConstraint` has been recoded so that when pressed down, it only polls the World for a body hit test during the next game update. This stops it coming out of sync with the state of the world. Useage of the constraint remains the same as before.
* `Matter.getMatterBodies` is a new function that will return an array of Matter JS Bodies from the given input array, which can be Matter Game Objects, or any class that extends them.
* `Matter.World.has` is a new method that will take a Matter Body, or Game Object, and search the world for it. If found, it will return `true`.
* Matter now has the option to use the Runner that it ships with. The Matter Runner operates in two modes: fixed and variable. In the fixed mode, the Matter Engine updates at a fixed delta value every frame (which is what Phaser has used since the first version). In variable mode, the delta will be smoothed and capped each frame to keep the simulation constant, but at the cost of determininism. You can configure the runner by setting the `runner` property in the Matter Config object, both of which are fully covered with JSDocs. As of 3.22 the runner is now used by default in variable (non-fixed) mode. If you wish to return to the previous behavior, set `runner: { isFixed: true }`.
@@ -117,10 +142,83 @@
* `MatterGameObject.setOnCollideEnd` is a new method available on any Matter Game Object, that sets a callback that is invoked when the body stops colliding.
* `MatterGameObject.setOnCollideActive` is a new method available on any Matter Game Object, that sets a callback which is invoked for the duration of the bodies collision with another.
* `MatterGameObject.setOnCollideWith` is a new method available on any Matter Game Object, that allows you to set a callback to be invoked whenever the body collides with another specific body, or array of bodies.
+* `Body.gravityScale` is a new vector property that allows you to scale the effect of world gravity on a specific Body.
+* `MatterPhysics._tempVec2` is a new private internal vector used for velocity and force calculations.
+* `MatterPhysics.setVelocity` is a new method that will set both the horizontal and vertical linear velocity of the given physics bodies. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.setVelocityX` is a new method that will set the horizontal linear velocity of the given physics bodies. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.setVelocityY` is a new method that will set the vertical linear velocity of the given physics bodies. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.setAngularVelocity` is a new method that will set the angular velocity of the given physics bodies. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.applyForce` is a new method that applies a force to a body, at the bodies current position, including resulting torque. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.applyForceFromPosition` is a new method that applies a force to a body from the given world position, including resulting torque. If no angle is given, the current body angle is used. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.fromSVG` is a new method that allows you to create a Body from the given SVG path data.
+* The `Matter.Factory.velocity` method has been removed. Please now use `MatterPhysics.setVelocity` instead.
+* The `Matter.Factory.angularVelocity` method has been removed. Please now use `MatterPhysics.setAngularVelocity` instead.
+* The `Matter.Factory.force` method has been removed. Please now use `MatterPhysics.applyForce` instead.
+* `MatterBodyConfig` is a new type def that contains all of the Body configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterBodyRenderConfig` is a new type def that contains all of the Body debug rendering configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterChamferConfig` is a new type def that contains all of the chamfer configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterCollisionFilter` is a new type def that contains all of the collision configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterConstraintConfig` is a new type def that contains all of the constraint configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterConstraintRenderConfig` is a new type def that contains all of the Constraint debug rendering configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterSetBodyConfig` is a new type def that contains all of the Constraint debug rendering configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterPhysics.getConstraintLength` is a new method that will return the length of the given constraint, as this is something you cannot get from the constraint properties directly.
+* `MatterPhysics.alignBody` is a new method that will align a Body, or Matter Game Object, against the given coordinates, using the given alignment constant. For example, this allows you to easily position a body to the `BOTTOM_LEFT`, or `TOP_CENTER`, or a coordinate. Alignment is based on the body bounds.
+* `Phaser.Types.Physics.Matter.MatterBody` is a new type def that contains all of the valid Matter Body objects. This is now used through-out the JSDocs to aid in code-completion.
+* `Matter.BodyBounds` is a new class that contains methods to help you extract world coordinates from various points around the bounds of a Matter Body. Because Matter bodies are positioned based on their center of mass, and not a dimension based center, you often need to get the bounds coordinates in order to properly align them in the world. You can access this new class via `this.matter.bodyBounds`.
+* The method signature for `Matter.PhysicsEditorParser.parseBody` has changed. It now takes `(x, y, config, options)` and no longer has `width` and `height` parameters. Please see the updated documentation for more details if you were calling this method directly.
+* `MatterPhysics.fromPhysicsEditor` is a new method that allows you to create a Matter Body based on the given PhysicsEditor shape data. Previously, you could only using PhysicsEditor data with a Matter Game Object, but now you can create a body directly using it.
+* `Matter.PhysicsJSONParser` is a new parser that will create Matter bodies from JSON physics data files. Currently onto the Phaser Physics Tracer app exports in this format, but details are published in the JSDocs, so any app can do so.
+* `Matter.Factory.fromJSON` is a new method that will create a body from a JSON physics data file.
+* The `SetBody` Matter component can now automatically use shapes created in the Phaser Physics Tracer App in the JSON data format.
+* `Matter.Components.Sleep.setToSleep` is a new method available on any Matter Game Object that will send the body to sleep, if Engine sleeping has been enabled.
+* `Matter.Components.Sleep.setAwake` is a new method available on any Matter Game Object that will awake a body from sleep, if Engine sleeping has been enabled.
+
+#### Matter Physics Updates
+
+* The `debug` property in the Matter World Config is now a `MatterDebugConfig` option instead of a boolean. However, if a boolean is given, it will use the default debug config values.
+* The following `MatterWorldConfig` options have now been removed: `debugShowBody`, `debugShowStaticBody`, `debugBodyColor`, `debugBodyFillColor`, `debugStaticBodyColor`, `debugShowJoint`, `debugJointColor`, `debugWireframes`, `debugShowInternalEdges`, `debugShowConvexHulls`, `debugConvexHullColor` and `debugShowSleeping`. These can all be set via the new `MatterDebugConfig` object instead.
+* The object `World.defaults` has been removed. Defaults are now access via `World.debugDefaults`.
+* `World.renderBodies` has been rewritten to cache commonly-used values and avoid a situation when a single body would be rendered twice.
+* The private method `World.renderConvexHulls` has been removed as it's no longer used internally.
+* The private method `World.renderWireframes` has been removed as it's no longer used internally.
+* The method `World.fromPath` has been removed. This was never used internally and you can get the same results by calling `Vertices.fromPath`.
+* The `World.setBounds` argument `thickness` now defaults to 64, not 128, to keep it matching the Matter World Config.
+* The `Body.render.fillStyle` property that existed on the Matter Body object has been removed and replaced with `fillColor`.
+* The `Body.render.strokeStyle` property that existed on the Matter Body object has been removed and replaced with `lineColor`.
+* `Matter.Body.render.sprite.xOffset` and `yOffset` are no longer set to anything when a Body is created. They are left as zero, or you can override them in the Body config, in which case the value is added to the sprite origin offset during a call to `setExistingBody`.
+* The `Matter.Mass.centerOfMass` component property now returns the pre-calculated Body `centerOfMass` property, which is much more accurate than the previous bounds offset value.
+* `Matter.setExistingBody`, which is called interally whenever a Body is set on a Game Object, now uses the new `centerOffset` values to ensure that the texture frame is correctly centered based on the center of mass, not the Body bounds, allowing for much more accurate body to texture mapping with complex multi-part compound bodies.
+* The `Matter.PhysicsEditorParser` has been updated so it no longer needs to set the render offsets, and instead uses the center of mass values.
+* If the `Matter.Body` config doesn't contain a `position` property, it will now default to using `Vertices.centre(body.vertices)` as the position. In most cases, this is what you need, so it saves having to pass it in the config object.
+* Bumped Matter Plugin versions to avoid console logs from Common.info and Common.warn.
+* `PhysicsEditorParser.parseVertices` now uses `Bodies.flagCoincidentParts` to avoid duplicating code.
+* `MatterGameObject` has a new optional boolean constructor parameter `addToWorld` which lets you control if the Body should be added to the world or not. Useful for toggling off should you be merging pre-existing bodies with Game Objects.
+* The `Matter.SetBody.setExistingBody` function, which all Matter Game Objects have, has a new parameter `addToWorld` which allows you to control when the body is added to the Matter world should you not require it immediately. It will also only add the body to the world if it doesn't already exist within it, or any of its composites.
+* `PointerConstraint` has been recoded so that when pressed down, it only polls the World for a body hit test during the next game update. This stops it coming out of sync with the state of the world. Use of the constraint remains the same as before.
+* You can now set `gravity: false` in your Matter Config and it will reset gravity from the defaults to zero.
+* The internal Matter `Composite.setModified` function will now emit a `compositeModified` event, which the Matter World listens for, if debug draw is enabled, so it can update the composite children render styles.
+* `Matter.PhysicsEditorParser.parseBody` can now accept a MatterBodyConfig file as a 4th parameter. This allows you to set Body properties when the body is created, overriding whatever values may have been set in the PhysicsEditor JSON.
+
+#### Matter Physics Bug Fixes
+
+* Due to the rewrite of the debug rendering, it is now possible to render _just_ constraints, where-as before this was only possible if bodies were being rendered as well. Fix #4880 (thanks @roberto257)
+* `Matter.PhysicsEditorParser` had a bug where it would allow fixtures with non-clockwise sorted vertices through, which would break pointer constraint interaction with these bodies. The parser now sorts the vertices properly. Fix #4261 (thanks @Sanchez3)
### New Features
* `TimeStep.smoothStep` is a new boolean property that controls if any delta smoothing takes place during the game step. Delta smoothing has been enabled in Phaser since the first version and helps avoid delta spikes and dips, especially after loss of focus. However, you can now easily toggle if this happens via this property and the corresponding `FPSConfig` property.
+* `Phaser.Math.Distance.BetweenPoints` is a new function that will return the distance between two Vector2-like objects (thanks @samme)
+* `Phaser.Math.Distance.BetweenPointsSquared` is a new function that will return the squared distance between two Vector2-like objects (thanks @samme)
+* `Phaser.Math.Distance.Chebyshev` is a new function that will return the Chebyshev (or chessboard) distance between two Vector2-like objects (thanks @samme)
+* `Phaser.Math.Distance.Snake` is a new function that will return the rectilinear distance between two Vector2-like objects (thanks @samme)
+* `ParticleEmitter.setTint` is a new method that will set the tint of emitted particles for the given Emitter only (thanks @samme)
+* `ParticleEmitter.remove` is a new method that will remove the Emitter from its Emitter Manager (thanks @samme)
+* `ParticleEmitterManager.removeEmitter` is a new method that will remove the given emitter from the manager, if the emitter belongs to it (thanks @samme)
+* `AlphaSingle` is a new Game Object Component that allows a Game Object to set its alpha values, but only as a single uniform value, not on a per-quad basis.
+* `Actions.AlignTo` (in combination with the new `Display.Align.To.QuickSet` function) allows you to align an array of Game Objects so they sit next to each other, one at a time. The first item isn't moved, the second is moved to sit next to the first, and so on. You can align them using any of the alignment constants (thanks @samme)
+* `Scene.Systems.getData` is a new method that will return any data that was sent to the Scene by another Scene, i.e. during a `run` or `launch` command. You can access it via `this.sys.getData()` from within your Scene.
+* `Group.internalCreateCallback` is a new optional callback that is invoked whenever a child is added to a Group. This is the same as `createCallback` except it's only for use by the parent class, allowing a parent to invoke a creation callback and for you to still provide one via the Group config.
+* `Group.internalRemoveCallback` is a new optional callback that is invoked whenever a child is removed from a Group. This is the same as `removeCallback` except it's only for use by the parent class, allowing a parent to invoke a callback and for you to still provide one via the Group config.
### Updates
@@ -130,6 +228,18 @@
* `Body._ty` is a new internal private var, holding the Arcade Physics Body combined total delta y value.
* `LineCurve.getUtoTmapping` has been updated to return `u` directly to avoid calculations as it's identical to `t` in a Line (thanks @rexrainbow)
* `Curve.getSpacedPoints` will now take an optional array as the 3rd parameter to store the points results in (thanks @rexrainbow)
+* Trying to play or resume an audio file with an incorrect key will now throw a runtime error, instead of a console warning (thanks @samme)
+* The `Shape` Game Object now uses the AlphaSingle component, allowing you to uniformly set the alpha of the shape, rather than a quad alpha, which never worked for Shape objects.
+* The `Container` Game Object now uses the AlphaSingle component, allowing you to uniformly set the alpha of the container, rather than a quad alpha, which never worked consistently across Container children. Fix #4916 (thanks @laineus)
+* The `DOMElement` Game Object now uses the AlphaSingle component, allowing you to uniformly set the alpha of the element, rather than a quad alpha, which never worked for these objects.
+* The `Graphics` Game Object now uses the AlphaSingle component, allowing you to uniformly set the alpha of the element, rather than a quad alpha, which never worked for these objects.
+* `TweenData` has a new property called `previous` which holds the eased property value prior to the update.
+* The `TWEEN_UPDATE` event now sends two new parameters to the handler: `current` and `previous` which contain the current and previous property values.
+* During `collideSpriteVsGroup` checks it will now skip bodies that are disabled to save doing a `contains` test (thanks @samme)
+* `Display.Align.In.QuickSet` now accepts `LEFT_BOTTOM` as `BOTTOM_LEFT`, `LEFT_TOP` as `TOP_LEFT`, `RIGHT_BOTTOM` as `BOTTOM_RIGHT` and `RIGHT_TOP` as `TOP_RIGHT`. Fix #4927 (thanks @zaniar)
+* `PhysicsGroup` now uses the new `internalCreateCallback` and `internalRemoveCallback` to handle its body creation and destruction, allowing you to use your own `createCallback` and `removeCallback` as defined in the Group config. Fix #4420 #4657 #4822 (thanks @S4n60w3n @kendistiller @scrubperson)
+* `DOMElement` has a new private method `handleSceneEvent` which will handle toggling the display setting of the element when a Scene sleeps and wakes. A DOM Element will now listen for the Scene sleep and wake events. These event listeners are removed in the `preDestroy` method.
+* A `DOMElement` will now set the display mode to 'none' during its render if the Scene in which it belongs is no longer visible.
### Bug Fixes
@@ -138,13 +248,25 @@
* When `Game.destroy` is running, Scenes are now destroyed _before_ plugins, avoiding bugs when closing down plugins and deleting Render Textures. Fix #4849 #4876 (thanks @rexrainbow @siyuanqiao)
* The `Mesh` and `Quad` Game Objects have had the `GetBounds` component removed as it cannot operate on a Mesh as they don't have origins. Fix #4902 (thanks @samme)
* Setting `lineSpacing` in the Text Game Object style config would set the value but not apply it to the Text, leaving you to call `updateText` yourself. If set, it's now applied on instantiation. Fix #4901 (thanks @FantaZZ)
+* External calls to the Fullscreen API using `element.requestFullscreen()` would be blocked by the Scale Manager. The Scale Manager will no longer call `stopFullScreen` should it be triggered outside of Phaser (thanks @AdamXA)
+* The `Tilemaps.Tile.tint` property wasn't working correctly as it expected the colors in the wrong order (BGR instead of RGB). It will now expect them in the correct RGB order (thanks @Aedalus @plissken2013es)
+* The `ScaleManager.destroy` method wasn't being called when the Game `DESTROY` event was dispatched, causing minor gc to build up. The destroy method will now be called properly on game destruction. Fix #4944 (thanks @sunshineuoow)
+* `FacebookInstantGamesPlugin.showAd` and `showVideo` will now break out of the ad iteration search once a valid ad has been found and called. Previously, it would carry on interating if the async didn't complete quickly. Fix #4888 (thanks @east62687)
+* When playing an Animation, if you were to play another, then pause it, then play another the internal `_paused` wouldn't get reset, preventing you from them pausing the animations from that point on. You can now play and pause animations at will. Fix #4835 (thanks @murteira)
+* In `Actions.GridAlign` if you set `width` to -1 it would align the items vertically, instead of horizontally. It now aligns them horizontally if `width` is set, or vertically if `height` is set. Fix #4899 (thanks @BenjaVR)
+* A `PathFollower` with a very short duration would often not end in the correct place, which is the very end of the Path, due to the tween handling the movement not running one final update when the tween was complete. It will now always end at the final point of the path, no matter how short the duration. Fix #4950 (thanks @bramp)
+* A `DOMElement` would still remain visible even if the Scene in which it belongs to was sent to sleep. A sleeping Scene shouldn't render anything. DOM Elements will now respond to sleep and wake events from their parent Scene. Fix #4870 (thanks @peonmodel)
+* If a config object was passed to `MultiAtlasFile` it expected the atlas URL to be in the `url` property, however the docs and file config expected it in `atlasURL`. You can now use either of these properties to declare the url. Fix #4815 (thanks @xense)
### Examples, Documentation and TypeScript
My thanks to the following for helping with the Phaser 3 Examples, Docs and TypeScript definitions, either by reporting errors, fixing them or helping author the docs:
-@fselcukcan Bambosh @louisth @hexus @javigaralva @samme @BeLi4L
+@fselcukcan Bambosh @louisth @hexus @javigaralva @samme @BeLi4L @jcyuan @javigaralva @T-Grave @bramp @Chnapy @dranitski @RollinSafary @xense
+The Matter TypeScript defs have been updated to include lots of missing classes, removed some redundant elements and general fixes. The Phaser TypeScript defs now reference the Matter defs directly and no longer try to parse them from the JSDocs. This allows the `MatterJS` namespace to work in TypeScript projects without any compilation warnings.
+
+The Spine Plugin now has new TypeScript defs in the `types` folder thanks to @supertommy
## Version 3.21.0 - Senku - 22nd November 2019
diff --git a/README.md b/README.md
index faa8bc484..a3597c5c0 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ Thousands of developers from indie and multi-national digital agencies, and univ
**Learn:** [API Docs](https://photonstorm.github.io/phaser3-docs/index.html), [Support Forum][forum] and [StackOverflow](https://stackoverflow.com/questions/tagged/phaser-framework)
**Code:** 1700+ [Examples](https://phaser.io/examples) (source available in this [repo][examples])
**Read:** The [Phaser World](#newsletter) Newsletter
-**Chat:** [Slack](https://phaser.io/community/slack) and [Discord](https://phaser.io/community/discord)
+**Chat:** [Discord](https://phaser.io/community/discord) and [Slack](https://phaser.io/community/slack)
**Extend:** With [Phaser Plugins](https://phaser.io/shop/plugins)
**Be awesome:** [Support](#support) the future of Phaser
@@ -22,23 +22,21 @@ Grab the source and join the fun!
-> 22nd November 2019
+> 15th January 2020
-Welcome to the release of Phaser 3.21. This version continues our efforts to keep Phaser 3 updated and enhanced, including lots of great new features, updates and bug fixes. New in 3.21 is the ability for you to directly set the mipmap filter levels the WebGL Renderer uses when creating textures. Any valid WebGL1 filter is allowed and you can set the filter in your game config, or at runtime, as needed. This gives you far more control over the quality of highly scaled textures.
+We're excited to announce the release of Phaser 3.22, the first of many in the year 2020. The main focus of 3.22 is all the work we've done on Matter Physics integration. Matter has been supported in Phaser since the first release, yet there were lots of things we wanted to do with it to make development life easier. 3.22 brings all of these to the front, including powerful new visual debugging options such as rendering contacts, velocity, the broadphase grid, sensors, joints and more. Matter also now has 100% JSDoc and TypeScripy coverage and I spent a long time rebuilding the TypeScript defs by hand, in order to make them as accurate as possible.
-Also new in 3.21 is the ability to soft-wrap BitmapText objects, based on a fixed pixel width. You can also define the wrapping character to be used. Arcade Physics has updates including `overlapCirc` which allows you to return all bodies (both dynamic and static) that intersect the given circular region. The Tilemap system has been updated to support Group Layers, which were introduced in a recent update of the Tiled Map Editor. These, along with Infinite Tilemaps, are now parsed correctly.
+As well as docs and defs there are stacks of handy new methods, including intersection tests such as `intersectPoint`, `intersectRay`, `overlap` and more. New Body level collision callbacks allow you to filter collided pairs a lot more quickly now, combined with new collision events and data type defs to give you all the information you need when resolving. There are now functions to create bodies from SVG data, JSON data or Physics Editor data directly, new Body alignment features and of course bug fixes.
-As usual, there's more: Including lots of new Group features, several new Actions for setting scroll factors, the ability to run at a fixed frame rate under setTimeout, a new method that lets you rebind the Web Audio Context (handy for PWA environments), fixes for drag distances and we even fixed a few IE9 (yes, really!) compatibility issues.
+It's not all about Matter Physics, though. Thanks to the community, there are new Math Distance functions such as Chebyshev, Snake and Squared Points. You can now tint particles as they're emitted, Physics Groups finally let you use your own creation and removal callbacks and plenty more besides. There are, of course, lots of bug fixes too and I've done my best to address some of the most important ones. The documentation has improved yet again and with every release the TypeScript defs get stronger and stronger. So, as usual, please do spend some time digging through the [Change Log](#changelog). I assure you, it's worth while :)
-As usual, it doesn't end here. There are plenty more fixes, features and updates across the API. You'll find loads more great new features, updates and fixes. So, as usual, please do spend some time digging through the [Change Log](#changelog). I assure you, it's worth while :)
-
-It was really great to receive a bunch of quality Pull Requests from the Phaser community, many of which found their way into 3.21. The past few versions have seen a lot of significant improvements, from comprehensive Spine support, to full Video playback, it's been an exciting few months. Things traditionally get a little more quiet around this time of the year but we're planning out 3.22 already and continuing to work through the issues list. During this time, we're also working hard on Phaser 4. You can follow development progress of both on the Phaser Patreon.
+With 3.22 released I will now be taking some time to carry on with Phaser 4 development, while planning out the 3.23 release as well. Even though Phaser 4 is in build I will fully support Phaser 3 for the foreseeable future. You can follow the development progress of both versions on the Phaser Patreon.
As usual, I'd like to send a massive thank-you to everyone who supports Phaser on Patreon (and now even GitHub Sponsors, too!) Your continued backing keeps allowing me to work on Phaser full-time and this great new releases is the very real result of that. If you've ever considered becoming a backer, now is the perfect time!
If you'd like to stay abreast of developments then I publish my [Developer Logs](https://phaser.io/phaser3/devlog) in the [Phaser World](https://phaser.io/community/newsletter) newsletter. Subscribe to stay in touch and get all the latest news from the core team and the wider community.
-You can also follow Phaser on [Twitter](https://twitter.com/phaser_) and chat with fellow Phaser devs in our [Slack](https://phaser.io/community/slack) and [Discord](https://phaser.io/community/discord) channels.
+You can also follow Phaser on [Twitter](https://twitter.com/phaser_) and chat with fellow Phaser devs in our [Discord](https://phaser.io/community/discord) and [Slack](https://phaser.io/community/slack) channels.
Phaser 3 wouldn't have been possible without the fantastic support of the community and Patreon. Thank you to everyone who supports our work, who shares our belief in the future of HTML5 gaming, and Phaser's role in that.
@@ -111,13 +109,13 @@ npm install phaser
[Phaser is on jsDelivr](https://www.jsdelivr.com/projects/phaser) which is a "super-fast CDN for developers". Include the following in your html:
```html
-
+
```
or the minified version:
```html
-
+
```
### API Documentation
@@ -200,13 +198,13 @@ We've 3 tutorials related to Facebook Instant Games and Phaser:
A special build of Phaser with the Facebook Instant Games Plugin ready-enabled is [available on jsDelivr](https://www.jsdelivr.com/projects/phaser). Include the following in your html:
```html
-
+
```
or the minified version:
```html
-
+
```
The build files are in the git repository in the `dist` folder, and you can also include the plugin in custom builds.
@@ -223,7 +221,7 @@ Create an `index.html` page locally and paste the following code into it:
-
+
@@ -334,96 +332,257 @@ You can then run `webpack` to create a development build in the `build` folder w
# Change Log
-## Version 3.21.0 - Senku - 22nd November 2019
+## Version 3.22 - Kohaku - January 15th 2020
+
+### Matter Physics
+
+All of the following are specific to the Matter Physics implementation used by Phaser:
+
+#### Matter Physics New Features
+
+* Matter Physics now has 100% JSDoc coverage! Woohoo :)
+* Matter Physics now has brand new TypeScript defs included in the `types` folder :)
+* `MatterDebugConfig` is a new configuration object that contains all of the following new Matter debug settings:
+* `showAxes`- Render all of the body axes?
+* `showAngleIndicator`- Render just a single body axis?
+* `angleColor`- The color of the body angle / axes lines.
+* `showBroadphase`- Render the broadphase grid?
+* `broadphaseColor`- The color of the broadphase grid.
+* `showBounds`- Render the bounds of the bodies in the world?
+* `boundsColor`- The color of the body bounds.
+* `showVelocity`- Render the velocity of the bodies in the world?
+* `velocityColor`- The color of the body velocity line.
+* `showCollisions`- Render the collision points and normals for colliding pairs.
+* `collisionColor`- The color of the collision points.
+* `showSeparation`- Render lines showing the separation between bodies.
+* `separationColor`- The color of the body separation line.
+* `showBody`- Render the dynamic bodies in the world to the Graphics object?
+* `showStaticBody`- Render the static bodies in the world to the Graphics object?
+* `showInternalEdges`- When rendering bodies, render the internal edges as well?
+* `renderFill`- Render the bodies using a fill color.
+* `renderLine`- Render the bodies using a line stroke.
+* `fillColor`- The color value of the fill when rendering dynamic bodies.
+* `fillOpacity`- The opacity of the fill when rendering dynamic bodies, a value between 0 and 1.
+* `lineColor`- The color value of the line stroke when rendering dynamic bodies.
+* `lineOpacity`- The opacity of the line when rendering dynamic bodies, a value between 0 and 1.
+* `lineThickness`- If rendering lines, the thickness of the line.
+* `staticFillColor`- The color value of the fill when rendering static bodies.
+* `staticLineColor`- The color value of the line stroke when rendering static bodies.
+* `showSleeping`- Render any sleeping bodies (dynamic or static) in the world to the Graphics object?
+* `staticBodySleepOpacity`] - The amount to multiply the opacity of sleeping static bodies by.
+* `sleepFillColor`- The color value of the fill when rendering sleeping dynamic bodies.
+* `sleepLineColor`- The color value of the line stroke when rendering sleeping dynamic bodies.
+* `showSensors`- Render bodies or body parts that are flagged as being a sensor?
+* `sensorFillColor`- The fill color when rendering body sensors.
+* `sensorLineColor`- The line color when rendering body sensors.
+* `showPositions`- Render the position of non-static bodies?
+* `positionSize`- The size of the rectangle drawn when rendering the body position.
+* `positionColor`- The color value of the rectangle drawn when rendering the body position.
+* `showJoint`- Render all world constraints to the Graphics object?
+* `jointColor`- The color value of joints when `showJoint` is set.
+* `jointLineOpacity`- The line opacity when rendering joints, a value between 0 and 1.
+* `jointLineThickness`- The line thickness when rendering joints.
+* `pinSize`- The size of the circles drawn when rendering pin constraints.
+* `pinColor`- The color value of the circles drawn when rendering pin constraints.
+* `springColor`- The color value of spring constraints.
+* `anchorColor`- The color value of constraint anchors.
+* `anchorSize`- The size of the circles drawn as the constraint anchors.
+* `showConvexHulls`- When rendering polygon bodies, render the convex hull as well?
+* `hullColor`- The color value of hulls when `showConvexHulls` is set.
+* `World.renderBody` is a new method that will render a single Matter Body to the given Graphics object. This is used internally during debug rendering but is also public. This allows you to control which bodies are rendered and to which Graphics object, should you wish to use them in-game and not just during debugging.
+* `World.renderConstraint` is a new method that will render a single Matter Constraint, such as a pin or a spring, to the given Graphics object. This is used internally during debug rendering but is also public. This allows you to control which constraints are rendered and to which Graphics object, should you wish to use them in-game and not just during debugging.
+* `World.renderConvexHull` is a new method that will render the convex hull of a single Matter Body, to the given Graphics object. This is used internally during debug rendering but is also public. This allows you to control which hulls are rendered and to which Graphics object, should you wish to use them in-game and not just during debugging.
+* `World.renderGrid` is a new method that will render the broadphase Grid to the given graphics instance.
+* `World.renderBodyBounds` is a new method that will render the bounds of all the given bodies to the given graphics instance.
+* `World.renderBodyAxes` is a new method that will render the axes of all the given bodies to the given graphics instance.
+* `World.renderBodyVelocity` is a new method that will render a velocity line for all the given bodies to the given graphics instance.
+* `World.renderSeparations` is a new method that will render the separations in the current pairs list to the given graphics instance.
+* `World.renderCollisions` is a new method that will render the collision points and normals in the current pairs list to the given graphics instance.
+* `World.getAllBodies` is a new method that will return all bodies in the Matter World.
+* `World.getAllConstraints` is a new method that will return all constraints in the Matter World.
+* `World.getAllComposites` is a new method that will return all composites in the Matter World.
+* `MatterPhysics.composite` is a new reference to the `Matter.Composite` module for easy access from within a Scene.
+* `MatterPhysics.detector` is a new reference to the `Matter.Dectector` module for easy access from within a Scene.
+* `MatterPhysics.grid` is a new reference to the `Matter.Grid` module for easy access from within a Scene.
+* `MatterPhysics.pair` is a new reference to the `Matter.Pair` module for easy access from within a Scene.
+* `MatterPhysics.pairs` is a new reference to the `Matter.Pairs` module for easy access from within a Scene.
+* `MatterPhysics.query` is a new reference to the `Matter.Query` module for easy access from within a Scene.
+* `MatterPhysics.resolver` is a new reference to the `Matter.Resolver` module for easy access from within a Scene.
+* `MatterPhysics.sat` is a new reference to the `Matter.SAT` module for easy access from within a Scene.
+* `MatterPhysics.constraint` is a new reference to the `Matter.Constraint` module for easy access from within a Scene.
+* `MatterPhysics.composites` is a new reference to the `Matter.Composites` module for easy access from within a Scene.
+* `MatterPhysics.axes` is a new reference to the `Matter.Axes` module for easy access from within a Scene.
+* `MatterPhysics.bounds` is a new reference to the `Matter.Bounds` module for easy access from within a Scene.
+* `MatterPhysics.svg` is a new reference to the `Matter.Svg` module for easy access from within a Scene.
+* `MatterPhysics.vector` is a new reference to the `Matter.Vector` module for easy access from within a Scene.
+* `MatterPhysics.vertices` is a new reference to the `Matter.Vertices` module for easy access from within a Scene.
+* `BEFORE_ADD` is a new Event dispatched by `Matter.World` when a Body or Constraint is about to be added to the World.
+* `AFTER_ADD` is a new Event dispatched by `Matter.World` when a Body or Constraint has been added to the World.
+* `BEFORE_REMOVE` is a new Event dispatched by `Matter.World` when a Body or Constraint is about to be removed from the World.
+* `AFTER_REMOVE` is a new Event dispatched by `Matter.World` when a Body or Constraint has been removed from the World.
+* `Body.render.lineOpacity` is a new property on the Matter Body object that allows for custom debug rendering.
+* `Body.render.lineThickness` is a new property on the Matter Body object that allows for custom debug rendering.
+* `Body.render.fillOpacity` is a new property on the Matter Body object that allows for custom debug rendering.
+* `World.setCompositeRenderStyle` is a new method that lets you quickly set the render style values on the children of the given compposite.
+* `World.setBodyRenderStyle` is a new method that lets you quickly set the render style values on the given Body.
+* `World.setConstraintRenderStyle` is a new method that lets you quickly set the render style values on the given Constraint.
+* You can now set `restingThresh` in the Matter Configuration file to adjust the Resolver property.
+* You can now set `restingThreshTangent` in the Matter Configuration file to adjust the Resolver property.
+* You can now set `positionDampen` in the Matter Configuration file to adjust the Resolver property.
+* You can now set `positionWarming` in the Matter Configuration file to adjust the Resolver property.
+* You can now set `frictionNormalMultiplier` in the Matter Configuration file to adjust the Resolver property.
+* `MatterPhysics.containsPoint` is a new method that returns a boolean if any of the given bodies intersect with the given point.
+* `MatterPhysics.intersectPoint` is a new method that checks which bodies intersect with the given point and returns them.
+* `MatterPhysics.intersectRect` is a new method that checks which bodies intersect with the given rectangular area, and returns them. Optionally, it can check which bodies are outside of the area.
+* `MatterPhysics.intersectRay` is a new method that checks which bodies intersect with the given ray segment and returns them. Optionally, you can set the width of the ray.
+* `MatterPhysics.intersectBody` is a new method that checks which bodies intersect with the given body and returns them. If the bodies are set to not collide this can be used as an overlaps check.
+* `MatterPhysics.overlap` is a new method that takes a target body and checks to see if it overlaps with any of the bodies given. If they do, optional `process` and `overlap` callbacks are invoked, passing the overlapping bodies to them, along with additional collision data.
+* `MatterPhysics.setCollisionCategory` is a new method that will set the collision filter category to the value given, on all of the bodies given. This allows you to easily set the category on bodies that don't have a Phaser Matter Collision component.
+* `MatterPhysics.setCollisionGroup` is a new method that will set the collision filter group to the value given, on all of the bodies given. This allows you to easily set the group on bodies that don't have a Phaser Matter Collision component.
+* `MatterPhysics.setCollidesWith` is a new method that will set the collision filter mask to the value given, on all of the bodies given. This allows you to easily set the filter mask on bodies that don't have a Phaser Matter Collision component.
+* `Matter.Body.centerOfMass` is a new vec2 property added to the Matter Body object that retains the center of mass coordinates when the Body is first created, or has parts added to it. These are float values, derived from the body position and bounds.
+* `Matter.Body.centerOffset` is a new vec2 property added to the Matter Body object that retains the center offset coordinates when the Body is first created, or has parts added to it. These are pixel values.
+* `Constraint.pointAWorld` is a new method added to Matter that returns the world-space position of `constraint.pointA`, accounting for `constraint.bodyA`.
+* `Constraint.pointBWorld` is a new method added to Matter that returns the world-space position of `constraint.pointB`, accounting for `constraint.bodyB`.
+* `Body.setCentre` is a new method added to Matter that allows you to set the center of mass of a Body (please note the English spelling of this function.)
+* `Body.scale` is a new read-only vector that holds the most recent scale values as passed to `Body.scale`.
+* `Matter.Bodies.flagCoincidentParts` is a new function that will flags all internal edges (coincident parts) on an array of body parts. This was previously part of the `fromVertices` function, but has been made external for outside use.
+* `Matter.getMatterBodies` is a new function that will return an array of Matter JS Bodies from the given input array, which can be Matter Game Objects, or any class that extends them.
+* `Matter.World.has` is a new method that will take a Matter Body, or Game Object, and search the world for it. If found, it will return `true`.
+* Matter now has the option to use the Runner that it ships with. The Matter Runner operates in two modes: fixed and variable. In the fixed mode, the Matter Engine updates at a fixed delta value every frame (which is what Phaser has used since the first version). In variable mode, the delta will be smoothed and capped each frame to keep the simulation constant, but at the cost of determininism. You can configure the runner by setting the `runner` property in the Matter Config object, both of which are fully covered with JSDocs. As of 3.22 the runner is now used by default in variable (non-fixed) mode. If you wish to return to the previous behavior, set `runner: { isFixed: true }`.
+* `Body.onCollideCallback` is a new Matter Body property that can point to a callback to invoke when the body starts colliding.
+* `Body.onCollideEndCallback` is a new Matter Body property that can point to a callback to invoke when the body stops colliding.
+* `Body.onCollideActiveCallback` is a new Matter Body property that can point to a callback to invoke for the duration the body is colliding.
+* `Body.onCollideWith` is a new Matter Body property that holds a mapping between bodies and collision callbacks.
+* `MatterGameObject.setOnCollide` is a new method available on any Matter Game Object, that sets a callback that is invoked when the body collides with another.
+* `MatterGameObject.setOnCollideEnd` is a new method available on any Matter Game Object, that sets a callback that is invoked when the body stops colliding.
+* `MatterGameObject.setOnCollideActive` is a new method available on any Matter Game Object, that sets a callback which is invoked for the duration of the bodies collision with another.
+* `MatterGameObject.setOnCollideWith` is a new method available on any Matter Game Object, that allows you to set a callback to be invoked whenever the body collides with another specific body, or array of bodies.
+* `Body.gravityScale` is a new vector property that allows you to scale the effect of world gravity on a specific Body.
+* `MatterPhysics._tempVec2` is a new private internal vector used for velocity and force calculations.
+* `MatterPhysics.setVelocity` is a new method that will set both the horizontal and vertical linear velocity of the given physics bodies. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.setVelocityX` is a new method that will set the horizontal linear velocity of the given physics bodies. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.setVelocityY` is a new method that will set the vertical linear velocity of the given physics bodies. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.setAngularVelocity` is a new method that will set the angular velocity of the given physics bodies. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.applyForce` is a new method that applies a force to a body, at the bodies current position, including resulting torque. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.applyForceFromPosition` is a new method that applies a force to a body from the given world position, including resulting torque. If no angle is given, the current body angle is used. This can be used on all Matter bodies, not just those created via the factory.
+* `MatterPhysics.fromSVG` is a new method that allows you to create a Body from the given SVG path data.
+* The `Matter.Factory.velocity` method has been removed. Please now use `MatterPhysics.setVelocity` instead.
+* The `Matter.Factory.angularVelocity` method has been removed. Please now use `MatterPhysics.setAngularVelocity` instead.
+* The `Matter.Factory.force` method has been removed. Please now use `MatterPhysics.applyForce` instead.
+* `MatterBodyConfig` is a new type def that contains all of the Body configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterBodyRenderConfig` is a new type def that contains all of the Body debug rendering configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterChamferConfig` is a new type def that contains all of the chamfer configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterCollisionFilter` is a new type def that contains all of the collision configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterConstraintConfig` is a new type def that contains all of the constraint configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterConstraintRenderConfig` is a new type def that contains all of the Constraint debug rendering configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterSetBodyConfig` is a new type def that contains all of the Constraint debug rendering configuration properties. This is now used through-out the JSDocs to aid in code-completion.
+* `MatterPhysics.getConstraintLength` is a new method that will return the length of the given constraint, as this is something you cannot get from the constraint properties directly.
+* `MatterPhysics.alignBody` is a new method that will align a Body, or Matter Game Object, against the given coordinates, using the given alignment constant. For example, this allows you to easily position a body to the `BOTTOM_LEFT`, or `TOP_CENTER`, or a coordinate. Alignment is based on the body bounds.
+* `Phaser.Types.Physics.Matter.MatterBody` is a new type def that contains all of the valid Matter Body objects. This is now used through-out the JSDocs to aid in code-completion.
+* `Matter.BodyBounds` is a new class that contains methods to help you extract world coordinates from various points around the bounds of a Matter Body. Because Matter bodies are positioned based on their center of mass, and not a dimension based center, you often need to get the bounds coordinates in order to properly align them in the world. You can access this new class via `this.matter.bodyBounds`.
+* The method signature for `Matter.PhysicsEditorParser.parseBody` has changed. It now takes `(x, y, config, options)` and no longer has `width` and `height` parameters. Please see the updated documentation for more details if you were calling this method directly.
+* `MatterPhysics.fromPhysicsEditor` is a new method that allows you to create a Matter Body based on the given PhysicsEditor shape data. Previously, you could only using PhysicsEditor data with a Matter Game Object, but now you can create a body directly using it.
+* `Matter.PhysicsJSONParser` is a new parser that will create Matter bodies from JSON physics data files. Currently onto the Phaser Physics Tracer app exports in this format, but details are published in the JSDocs, so any app can do so.
+* `Matter.Factory.fromJSON` is a new method that will create a body from a JSON physics data file.
+* The `SetBody` Matter component can now automatically use shapes created in the Phaser Physics Tracer App in the JSON data format.
+* `Matter.Components.Sleep.setToSleep` is a new method available on any Matter Game Object that will send the body to sleep, if Engine sleeping has been enabled.
+* `Matter.Components.Sleep.setAwake` is a new method available on any Matter Game Object that will awake a body from sleep, if Engine sleeping has been enabled.
+
+#### Matter Physics Updates
+
+* The `debug` property in the Matter World Config is now a `MatterDebugConfig` option instead of a boolean. However, if a boolean is given, it will use the default debug config values.
+* The following `MatterWorldConfig` options have now been removed: `debugShowBody`, `debugShowStaticBody`, `debugBodyColor`, `debugBodyFillColor`, `debugStaticBodyColor`, `debugShowJoint`, `debugJointColor`, `debugWireframes`, `debugShowInternalEdges`, `debugShowConvexHulls`, `debugConvexHullColor` and `debugShowSleeping`. These can all be set via the new `MatterDebugConfig` object instead.
+* The object `World.defaults` has been removed. Defaults are now access via `World.debugDefaults`.
+* `World.renderBodies` has been rewritten to cache commonly-used values and avoid a situation when a single body would be rendered twice.
+* The private method `World.renderConvexHulls` has been removed as it's no longer used internally.
+* The private method `World.renderWireframes` has been removed as it's no longer used internally.
+* The method `World.fromPath` has been removed. This was never used internally and you can get the same results by calling `Vertices.fromPath`.
+* The `World.setBounds` argument `thickness` now defaults to 64, not 128, to keep it matching the Matter World Config.
+* The `Body.render.fillStyle` property that existed on the Matter Body object has been removed and replaced with `fillColor`.
+* The `Body.render.strokeStyle` property that existed on the Matter Body object has been removed and replaced with `lineColor`.
+* `Matter.Body.render.sprite.xOffset` and `yOffset` are no longer set to anything when a Body is created. They are left as zero, or you can override them in the Body config, in which case the value is added to the sprite origin offset during a call to `setExistingBody`.
+* The `Matter.Mass.centerOfMass` component property now returns the pre-calculated Body `centerOfMass` property, which is much more accurate than the previous bounds offset value.
+* `Matter.setExistingBody`, which is called interally whenever a Body is set on a Game Object, now uses the new `centerOffset` values to ensure that the texture frame is correctly centered based on the center of mass, not the Body bounds, allowing for much more accurate body to texture mapping with complex multi-part compound bodies.
+* The `Matter.PhysicsEditorParser` has been updated so it no longer needs to set the render offsets, and instead uses the center of mass values.
+* If the `Matter.Body` config doesn't contain a `position` property, it will now default to using `Vertices.centre(body.vertices)` as the position. In most cases, this is what you need, so it saves having to pass it in the config object.
+* Bumped Matter Plugin versions to avoid console logs from Common.info and Common.warn.
+* `PhysicsEditorParser.parseVertices` now uses `Bodies.flagCoincidentParts` to avoid duplicating code.
+* `MatterGameObject` has a new optional boolean constructor parameter `addToWorld` which lets you control if the Body should be added to the world or not. Useful for toggling off should you be merging pre-existing bodies with Game Objects.
+* The `Matter.SetBody.setExistingBody` function, which all Matter Game Objects have, has a new parameter `addToWorld` which allows you to control when the body is added to the Matter world should you not require it immediately. It will also only add the body to the world if it doesn't already exist within it, or any of its composites.
+* `PointerConstraint` has been recoded so that when pressed down, it only polls the World for a body hit test during the next game update. This stops it coming out of sync with the state of the world. Use of the constraint remains the same as before.
+* You can now set `gravity: false` in your Matter Config and it will reset gravity from the defaults to zero.
+* The internal Matter `Composite.setModified` function will now emit a `compositeModified` event, which the Matter World listens for, if debug draw is enabled, so it can update the composite children render styles.
+* `Matter.PhysicsEditorParser.parseBody` can now accept a MatterBodyConfig file as a 4th parameter. This allows you to set Body properties when the body is created, overriding whatever values may have been set in the PhysicsEditor JSON.
+
+#### Matter Physics Bug Fixes
+
+* Due to the rewrite of the debug rendering, it is now possible to render _just_ constraints, where-as before this was only possible if bodies were being rendered as well. Fix #4880 (thanks @roberto257)
+* `Matter.PhysicsEditorParser` had a bug where it would allow fixtures with non-clockwise sorted vertices through, which would break pointer constraint interaction with these bodies. The parser now sorts the vertices properly. Fix #4261 (thanks @Sanchez3)
### New Features
-* You can now specify the mipmap filter level to be used when creating WebGL textures. This can be set in the Game Config using the new `mipmapFilter` property, which is a string, such as 'NEAREST_MIPMAP_NEAREST'. Or, you can set the new `WebGLRenderer.mipmapFilter` property to a valid GLenum. If you set it on the renderer, it will only impact any textures loaded _after_ it has been set, so do so in your Scene `init` method if you want it to be used for textures you're about to load. By changing the mipmap level you can drastically improve the quality when reducing large textures. Please note, due to WebGL1 limitations, this only works on power-of-two sized textures. It also works on textures created from Canvas, Videos or RenderTextures.
-* `BitmapText.setMaxWidth` is a new method that allows you to set a maximum width (in pixels) for the BitmapText to take up when rendering. Lines of text longer than `maxWidth` will be wrapped, based on whitespace, to the next line. This allows you to do word-wrapping on BitmapText objects, something only previously possible on Text objects.
-* `BitmapText.wordWrapCharCode` is a new property that works with `setMaxWidth` that allows you to control which character code causes a line-wrap. By default it is 32 (a space character).
-* `ArcadePhysics.closest` now has an optional `targets` argument. The targets can be any Arcade Physics Game Object, Body or Static Body and it will return only the closet target from those given (thanks @samme)
-* `ArcadePhysics.furthest` now has an optional `targets` argument. The targets can be any Arcade Physics Game Object, Body or Static Body and it will return only the furthest target from those given (thanks @samme)
-* `Tilemaps.Parsers.Tiled.CreateGroupLayer` is a new function that parses a Tiled group layer and adds in support for Tiled layer groups (introduced in Tiled 1.2.0). Feature #4099 (thanks @Babeetlebum @Olliebrown)
-* The Tilemap system now supports infinite Tilemaps from the Tiled map editor (thanks @Olliebrown)
-* `Tilemap.getImageLayerNames` is a new method that returns a list of all valid imagelayer names loaded in the Tilemap (thanks @Olliebrown)
-* `Tilemap.getObjectLayerNames` is a new method that returns a list of all valid objectgroup names loaded in the Tilemap (thanks @Olliebrown)
-* `Tilemap.getTileLayerNames` is a new method that returns a list of all valid tilelayer names loaded in the Tilemap (thanks @Olliebrown)
-* When `forceSetTimeOut` is set to `true` in the Game Config, you can now set the target frame rate by setting the `fps.target` value (thanks @pavels)
-* Videos can now be loaded from a data URI, allowing for base64 encoded videos to be used in the Loader instead of file based ones. Although, as with all base64 encoded data, we strongly recommend against this (thanks @apasov)
-* `Math.MIN_SAFE_INTEGER` is a new math const that stores the minimum safe integer for browsers that don't provide this, such as IE (thanks @jronn)
-* `Math.MAX_SAFE_INTEGER` is a new math const that stores the maximum safe integer for browsers that don't provide this, such as IE (thanks @jronn)
-* `KeyCodes.NUMPAD_ADD` has been added to the keycodes list (thanks @Martin-Antonov)
-* `KeyCodes.NUMPAD_SUBTRACT` has been added to the keycodes list (thanks @Martin-Antonov)
-* `Video.removeVideoElementOnDestroy` is a new boolean property that allows you to control if the Video element is removed from the DOM when the Video Game Object is destroyed.
-* `Actions.SetScrollFactor` is a new Action that will set the scroll factor on an array of Game Objects, including stepped incremental changes per item (thanks @rexrainbow)
-* `Actions.SetScrollFactorX` is a new Action that will set the horizontal scroll factor on an array of Game Objects, including stepped incremental changes per item (thanks @rexrainbow)
-* `Actions.SetScrollFactorY` is a new Action that will set the horizontal scroll factor on an array of Game Objects, including stepped incremental changes per item (thanks @rexrainbow)
-* The `Group` config object now supports use of the `setScrollFactor` property to set the value on each child of the Group (thanks @rexrainbow)
-* `Group.propertyValueSet` is a new method that sets a given property on each Group member (thanks @rexrainbow)
-* `Group.propertyValueInc` is a new method that adds an amount to a given property on each Group member (thanks @rexrainbow)
-* `Group.setX` is a new method that sets the x coordinate on each Group member (thanks @rexrainbow)
-* `Group.setY` is a new method that sets the y coordinate on each Group member (thanks @rexrainbow)
-* `Group.setXY` is a new method that sets the x and y coordinate on each Group member (thanks @rexrainbow)
-* `Group.incX` is a new method that increments the x coordinate on each Group member (thanks @rexrainbow)
-* `Group.incY` is a new method that increments the y coordinate on each Group member (thanks @rexrainbow)
-* `Group.incXY` is a new method that increments the x and y coordinate on each Group member (thanks @rexrainbow)
-* `Group.shiftPosition` is a new method that iterates the Group members and shifts the position of each to the previous members position (thanks @rexrainbow)
-* `Group.angle` is a new method that sets the angle property on each Group member (thanks @rexrainbow)
-* `Group.rotate` is a new method that sets the rotation property on each Group member (thanks @rexrainbow)
-* `Group.rotateAround` is a new method that rotates each Group member around the given point, by the given angle (thanks @rexrainbow)
-* `Group.rotateAroundDistance` is a new method that rotates each Group member around the given point, by the given angle and distance (thanks @rexrainbow)
-* `Group.setAlpha` is a new method that sets the alpha property on each Group member (thanks @rexrainbow)
-* `Group.setTint` is a new method that sets the tint property on each Group member (thanks @rexrainbow)
-* `Group.setOrigin` is a new method that sets the origin property on each Group member (thanks @rexrainbow)
-* `Group.scaleX` is a new method that sets the x scale on each Group member (thanks @rexrainbow)
-* `Group.scaleY` is a new method that sets the y scale on each Group member (thanks @rexrainbow)
-* `Group.scaleXY` is a new method that sets the x and y scale on each Group member (thanks @rexrainbow)
-* `Group.setBlendMode` is a new method that sets the blend mode on each Group member (thanks @rexrainbow)
-* `Group.setHitArea` is a new method that passes all Group members to the Input Plugin to enable them for input (thanks @rexrainbow)
-* `Group.shuffle` is a new method that shuffles all of the Group members in place (thanks @rexrainbow)
-* `Group.setVisible` is a new method that sets the visible state on each Group member (thanks @rexrainbow)
-* `WebAudioSoundManager.setAudioContext` is a new method that allows you to set the Sound Manager Audio Context to a different context instance. It will also disconnect and re-create the gain nodes on the new context.
-* `Group.type` is a new property that holds a string-based name of the Game Object type, as with other GO's (thanks @samme)
-* `Arade.Group.type` is a new property that holds a string-based name of the Game Object type, as with other GO's (thanks @samme)
-* `Arcade.StaticGroup.type` is a new property that holds a string-based name of the Game Object type, as with other GO's (thanks @samme)
-* `ArcadePhysics.overlapCirc` is a new method that allows you to return an array of all Arcade Physics bodies that overlap with the given circular area of the world. It can return either dynamic or static bodies, or a mixture of both (thanks @samme)
+* `TimeStep.smoothStep` is a new boolean property that controls if any delta smoothing takes place during the game step. Delta smoothing has been enabled in Phaser since the first version and helps avoid delta spikes and dips, especially after loss of focus. However, you can now easily toggle if this happens via this property and the corresponding `FPSConfig` property.
+* `Phaser.Math.Distance.BetweenPoints` is a new function that will return the distance between two Vector2-like objects (thanks @samme)
+* `Phaser.Math.Distance.BetweenPointsSquared` is a new function that will return the squared distance between two Vector2-like objects (thanks @samme)
+* `Phaser.Math.Distance.Chebyshev` is a new function that will return the Chebyshev (or chessboard) distance between two Vector2-like objects (thanks @samme)
+* `Phaser.Math.Distance.Snake` is a new function that will return the rectilinear distance between two Vector2-like objects (thanks @samme)
+* `ParticleEmitter.setTint` is a new method that will set the tint of emitted particles for the given Emitter only (thanks @samme)
+* `ParticleEmitter.remove` is a new method that will remove the Emitter from its Emitter Manager (thanks @samme)
+* `ParticleEmitterManager.removeEmitter` is a new method that will remove the given emitter from the manager, if the emitter belongs to it (thanks @samme)
+* `AlphaSingle` is a new Game Object Component that allows a Game Object to set its alpha values, but only as a single uniform value, not on a per-quad basis.
+* `Actions.AlignTo` (in combination with the new `Display.Align.To.QuickSet` function) allows you to align an array of Game Objects so they sit next to each other, one at a time. The first item isn't moved, the second is moved to sit next to the first, and so on. You can align them using any of the alignment constants (thanks @samme)
+* `Scene.Systems.getData` is a new method that will return any data that was sent to the Scene by another Scene, i.e. during a `run` or `launch` command. You can access it via `this.sys.getData()` from within your Scene.
+* `Group.internalCreateCallback` is a new optional callback that is invoked whenever a child is added to a Group. This is the same as `createCallback` except it's only for use by the parent class, allowing a parent to invoke a creation callback and for you to still provide one via the Group config.
+* `Group.internalRemoveCallback` is a new optional callback that is invoked whenever a child is removed from a Group. This is the same as `removeCallback` except it's only for use by the parent class, allowing a parent to invoke a callback and for you to still provide one via the Group config.
### Updates
-* `Curve.getPoints` can now take an optional array as the 3rd parameter in which to store the points results (thanks @rexrainbow)
-* `Line.arcLengthDivisions` now overrides the default Curve value and is set to 1 to optimize the amount of points returned for a Line curve (thanks @rexrainbow)
-* `ArcadePhysics.closest` will now no longer ever return the source in the target results (thanks @samme)
-* `ArcadePhysics.furthest` will now no longer ever return the source in the target results (thanks @samme)
-* `RequestAnimationFrame.target` is a new property that controls the fps rate (in ms) when setTimeout is used (thanks @pavels)
-* The `WebAudioSoundManager.unlock` method will now listen for `keydown` events in order to unlock the Audio Context, as well as touch and pointer events, making it more accessible (thanks Nick Tipping)
-* The `requestAnimationFrame` polyfill no longer expects a Browserify environment and uses `window` through-out, it also no longer adds in the same as performance.now does.
-* `BitmapText.getTextBounds` didn't reset the dirty flag, causing the `GetBitmapTextSize` function to be called every time the Bitmap Text was rendered. With enough text objects on-screen this could negatively impact performance. The flag is now reset every time the bounds are recalculated.
+* `Body.deltaXFinal` is a new method on Arcade Physics Bodies that will return the final change in the horizontal position of the body, as based on all the steps that took place this frame. This property is calculated during the `postUpdate` phase, so must be listened for accordingly (thanks Bambosh)
+* `Body.deltaYFinal` is a new method on Arcade Physics Bodies that will return the final change in the vertical position of the body, as based on all the steps that took place this frame. This property is calculated during the `postUpdate` phase, so must be listened for accordingly (thanks Bambosh)
+* `Body._tx` is a new internal private var, holding the Arcade Physics Body combined total delta x value.
+* `Body._ty` is a new internal private var, holding the Arcade Physics Body combined total delta y value.
+* `LineCurve.getUtoTmapping` has been updated to return `u` directly to avoid calculations as it's identical to `t` in a Line (thanks @rexrainbow)
+* `Curve.getSpacedPoints` will now take an optional array as the 3rd parameter to store the points results in (thanks @rexrainbow)
+* Trying to play or resume an audio file with an incorrect key will now throw a runtime error, instead of a console warning (thanks @samme)
+* The `Shape` Game Object now uses the AlphaSingle component, allowing you to uniformly set the alpha of the shape, rather than a quad alpha, which never worked for Shape objects.
+* The `Container` Game Object now uses the AlphaSingle component, allowing you to uniformly set the alpha of the container, rather than a quad alpha, which never worked consistently across Container children. Fix #4916 (thanks @laineus)
+* The `DOMElement` Game Object now uses the AlphaSingle component, allowing you to uniformly set the alpha of the element, rather than a quad alpha, which never worked for these objects.
+* The `Graphics` Game Object now uses the AlphaSingle component, allowing you to uniformly set the alpha of the element, rather than a quad alpha, which never worked for these objects.
+* `TweenData` has a new property called `previous` which holds the eased property value prior to the update.
+* The `TWEEN_UPDATE` event now sends two new parameters to the handler: `current` and `previous` which contain the current and previous property values.
+* During `collideSpriteVsGroup` checks it will now skip bodies that are disabled to save doing a `contains` test (thanks @samme)
+* `Display.Align.In.QuickSet` now accepts `LEFT_BOTTOM` as `BOTTOM_LEFT`, `LEFT_TOP` as `TOP_LEFT`, `RIGHT_BOTTOM` as `BOTTOM_RIGHT` and `RIGHT_TOP` as `TOP_RIGHT`. Fix #4927 (thanks @zaniar)
+* `PhysicsGroup` now uses the new `internalCreateCallback` and `internalRemoveCallback` to handle its body creation and destruction, allowing you to use your own `createCallback` and `removeCallback` as defined in the Group config. Fix #4420 #4657 #4822 (thanks @S4n60w3n @kendistiller @scrubperson)
+* `DOMElement` has a new private method `handleSceneEvent` which will handle toggling the display setting of the element when a Scene sleeps and wakes. A DOM Element will now listen for the Scene sleep and wake events. These event listeners are removed in the `preDestroy` method.
+* A `DOMElement` will now set the display mode to 'none' during its render if the Scene in which it belongs is no longer visible.
### Bug Fixes
-* The Spine Plugin was not clearing down the resize event listener in WebGL, causing it to still fire even if the Scene was closed. Fix #4808 (thanks @RollinSafary)
-* When a game is created with the HEADLESS renderer, `Game.destroy()` had no effect and the game kept on running. Now it destroys itself properly. Fix #4804 (thanks @samme)
-* `DOM.GetScreenOrientation` was returning the wrong consts from the Scale Manager (thanks @jcyuan)
-* When using `Input.enableDebug` on Game Objects it would not render the debug graphic correctly if the hit area had been offset. It now adjusts the debug correctly for all common hit-area geometry types. Fix #4722 (thanks @HaoboZ @Olliebrown)
-* Light2D was not properly working for DynamicTilemapLayers due to a change in the way tilesets were stored, throwing an Uncaught TypeError at runtime. This is now handled correctly. Fix #4167 #4079 (thanks @koljakutschera @blackjack26 @kainage)
-* `Input.dragDistanceThreshold` was not working correctly since 3.18, snapping to the wrong drag state unless the time threshold was also set. Fix #4667 (thanks @muliawanw @Olliebrown)
-* `Tilemap.convertLayerToStatic` would throw an error when used multiple times, due to an error with the layer index count. Fix #4737 (thanks @Olliebrown @Vegita2)
-* The `Tween` class now uses a cached MAX_SAFE_INTEGER making it compatible with Internet Explorer (thanks @jronn)
-* The `StaggerBuilder` class now uses a cached MAX_SAFE_INTEGER making it compatible with Internet Explorer (thanks @jronn)
-* The `Rectangle.FromPoints` function now uses a cached MIN_SAFE_INTEGER making it compatible with Internet Explorer (thanks @jronn)
-* The `Video` class now uses a cached MIN_SAFE_INTEGER making it compatible with Internet Explorer (thanks @jronn)
-* The `Path` class now uses a cached MIN_SAFE_INTEGER making it compatible with Internet Explorer (thanks @jronn)
-* `Video.destroy` has been renamed to `Video.preDestroy`, so that it now destroys properly like all other Game Objects. Fix #4821 (thanks @rexrainbow)
-* The Video Game Object will now check to see if the browser supports the `HTMLVideoElement` before creating one (thanks @jcyuan)
-* The `DOM.GetScreenOrientation` functions would return out-dated consts (thanks @jcyuan)
-* When calling `TileSprite.setTexture` or `setFrame`, if the new frame size didn't match the old one, the new fill pattern would become distorted and the `potWidth` and `potHeight` values would be incorrect.
-* Timeline callbacks with extra parameters like `onStart` would miss the first parameter when the callback was invoked. Fix #4810 (thanks @samme)
+* BitmapText with a `maxWidth` set wouldn't update the text correctly if it was modified post-creation. You can now update the text and/or width independantly and it'll update correctly. Fix #4881 (thanks @oxguy3)
+* Text objects will no longer add any white-space when word-wrapping if the last line is only one word long. Fix #4867 (thanks @gaamoo @rexrainbow)
+* When `Game.destroy` is running, Scenes are now destroyed _before_ plugins, avoiding bugs when closing down plugins and deleting Render Textures. Fix #4849 #4876 (thanks @rexrainbow @siyuanqiao)
+* The `Mesh` and `Quad` Game Objects have had the `GetBounds` component removed as it cannot operate on a Mesh as they don't have origins. Fix #4902 (thanks @samme)
+* Setting `lineSpacing` in the Text Game Object style config would set the value but not apply it to the Text, leaving you to call `updateText` yourself. If set, it's now applied on instantiation. Fix #4901 (thanks @FantaZZ)
+* External calls to the Fullscreen API using `element.requestFullscreen()` would be blocked by the Scale Manager. The Scale Manager will no longer call `stopFullScreen` should it be triggered outside of Phaser (thanks @AdamXA)
+* The `Tilemaps.Tile.tint` property wasn't working correctly as it expected the colors in the wrong order (BGR instead of RGB). It will now expect them in the correct RGB order (thanks @Aedalus @plissken2013es)
+* The `ScaleManager.destroy` method wasn't being called when the Game `DESTROY` event was dispatched, causing minor gc to build up. The destroy method will now be called properly on game destruction. Fix #4944 (thanks @sunshineuoow)
+* `FacebookInstantGamesPlugin.showAd` and `showVideo` will now break out of the ad iteration search once a valid ad has been found and called. Previously, it would carry on interating if the async didn't complete quickly. Fix #4888 (thanks @east62687)
+* When playing an Animation, if you were to play another, then pause it, then play another the internal `_paused` wouldn't get reset, preventing you from them pausing the animations from that point on. You can now play and pause animations at will. Fix #4835 (thanks @murteira)
+* In `Actions.GridAlign` if you set `width` to -1 it would align the items vertically, instead of horizontally. It now aligns them horizontally if `width` is set, or vertically if `height` is set. Fix #4899 (thanks @BenjaVR)
+* A `PathFollower` with a very short duration would often not end in the correct place, which is the very end of the Path, due to the tween handling the movement not running one final update when the tween was complete. It will now always end at the final point of the path, no matter how short the duration. Fix #4950 (thanks @bramp)
+* A `DOMElement` would still remain visible even if the Scene in which it belongs to was sent to sleep. A sleeping Scene shouldn't render anything. DOM Elements will now respond to sleep and wake events from their parent Scene. Fix #4870 (thanks @peonmodel)
+* If a config object was passed to `MultiAtlasFile` it expected the atlas URL to be in the `url` property, however the docs and file config expected it in `atlasURL`. You can now use either of these properties to declare the url. Fix #4815 (thanks @xense)
### Examples, Documentation and TypeScript
My thanks to the following for helping with the Phaser 3 Examples, Docs and TypeScript definitions, either by reporting errors, fixing them or helping author the docs:
-@samme (for contributing loads of new Arcade Physics examples) @dranitski @jcyuan @RollinSafary @ilyaryabchinski @jsoref @jcyuan @ghclark2
+@fselcukcan Bambosh @louisth @hexus @javigaralva @samme @BeLi4L @jcyuan @javigaralva @T-Grave @bramp @Chnapy @dranitski @RollinSafary @xense
+
+The Matter TypeScript defs have been updated to include lots of missing classes, removed some redundant elements and general fixes. The Phaser TypeScript defs now reference the Matter defs directly and no longer try to parse them from the JSDocs. This allows the `MatterJS` namespace to work in TypeScript projects without any compilation warnings.
+
+The Spine Plugin now has new TypeScript defs in the `types` folder thanks to @supertommy
Please see the complete [Change Log](https://github.com/photonstorm/phaser/blob/master/CHANGELOG.md) for previous releases.
@@ -454,8 +613,8 @@ All rights reserved.
"Above all, video games are meant to be just one thing: fun. Fun for everyone." - Satoru Iwata
-[get-js]: https://github.com/photonstorm/phaser/releases/download/v3.21.0/phaser.js
-[get-minjs]: https://github.com/photonstorm/phaser/releases/download/v3.21.0/phaser.min.js
+[get-js]: https://github.com/photonstorm/phaser/releases/download/v3.22.0/phaser.js
+[get-minjs]: https://github.com/photonstorm/phaser/releases/download/v3.22.0/phaser.min.js
[clone-http]: https://github.com/photonstorm/phaser.git
[clone-ssh]: git@github.com:photonstorm/phaser.git
[clone-ghwin]: github-windows://openRepo/https://github.com/photonstorm/phaser
diff --git a/dist/phaser-arcade-physics.js b/dist/phaser-arcade-physics.js
index 1328df1ed..ce25cd167 100644
--- a/dist/phaser-arcade-physics.js
+++ b/dist/phaser-arcade-physics.js
@@ -91,7 +91,7 @@ return /******/ (function(modules) { // webpackBootstrap
/******/
/******/
/******/ // Load entry module and return exports
-/******/ return __webpack_require__(__webpack_require__.s = 1439);
+/******/ return __webpack_require__(__webpack_require__.s = 1453);
/******/ })
/************************************************************************/
/******/ ([
@@ -100,7 +100,7 @@ return /******/ (function(modules) { // webpackBootstrap
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -354,7 +354,7 @@ module.exports = Class;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -381,7 +381,7 @@ module.exports = NOOP;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -424,7 +424,7 @@ module.exports = GetFastValue;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -1063,7 +1063,7 @@ module.exports = Vector2;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -1156,13 +1156,13 @@ module.exports = Point;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var PluginCache = __webpack_require__(21);
-var SceneEvents = __webpack_require__(22);
+var PluginCache = __webpack_require__(23);
+var SceneEvents = __webpack_require__(19);
/**
* @classdesc
@@ -1218,7 +1218,7 @@ var GameObjectFactory = new Class({
/**
* A reference to the Scene Update List.
*
- * @name Phaser.GameObjects.GameObjectFactory#updateList;
+ * @name Phaser.GameObjects.GameObjectFactory#updateList
* @type {Phaser.GameObjects.UpdateList}
* @protected
* @since 3.0.0
@@ -1261,14 +1261,14 @@ var GameObjectFactory = new Class({
/**
* Adds an existing Game Object to this Scene.
- *
+ *
* If the Game Object renders, it will be added to the Display List.
* If it has a `preUpdate` method, it will be added to the Update List.
*
* @method Phaser.GameObjects.GameObjectFactory#existing
* @since 3.0.0
*
- * @param {Phaser.GameObjects.GameObject} child - The child to be added to this Scene.
+ * @param {(Phaser.GameObjects.GameObject|Phaser.GameObjects.Group)} child - The child to be added to this Scene.
*
* @return {Phaser.GameObjects.GameObject} The Game Object that was added.
*/
@@ -1323,8 +1323,19 @@ var GameObjectFactory = new Class({
});
-// Static method called directly by the Game Object factory functions
-
+/**
+ * Static method called directly by the Game Object factory functions.
+ * With this method you can register a custom GameObject factory in the GameObjectFactory,
+ * providing a name (`factoryType`) and the constructor (`factoryFunction`) in order
+ * to be called when you call to Phaser.Scene.add[ factoryType ] method.
+ *
+ * @method Phaser.GameObjects.GameObjectFactory.register
+ * @static
+ * @since 3.0.0
+ *
+ * @param {string} factoryType - The key of the factory that you will use to call to Phaser.Scene.add[ factoryType ] method.
+ * @param {function} factoryFunction - The constructor function to be called when you invoke to the Phaser.Scene.add method.
+ */
GameObjectFactory.register = function (factoryType, factoryFunction)
{
if (!GameObjectFactory.prototype.hasOwnProperty(factoryType))
@@ -1333,6 +1344,17 @@ GameObjectFactory.register = function (factoryType, factoryFunction)
}
};
+/**
+ * Static method called directly by the Game Object factory functions.
+ * With this method you can remove a custom GameObject factory registered in the GameObjectFactory,
+ * providing a its `factoryType`.
+ *
+ * @method Phaser.GameObjects.GameObjectFactory.remove
+ * @static
+ * @since 3.0.0
+ *
+ * @param {string} factoryType - The key of the factory that you want to remove from the GameObjectFactory.
+ */
GameObjectFactory.remove = function (factoryType)
{
if (GameObjectFactory.prototype.hasOwnProperty(factoryType))
@@ -1352,7 +1374,7 @@ module.exports = GameObjectFactory;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -1423,7 +1445,7 @@ module.exports = GetValue;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -1479,7 +1501,7 @@ module.exports = IsPlainObject;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -1892,7 +1914,7 @@ if (true) {
/**
* @author Richard Davey
* @author Felipe Alfonso <@bitnenfer>
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -2026,17 +2048,17 @@ module.exports = {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Contains = __webpack_require__(47);
-var GetPoint = __webpack_require__(147);
-var GetPoints = __webpack_require__(257);
+var GetPoint = __webpack_require__(149);
+var GetPoints = __webpack_require__(271);
var GEOM_CONST = __webpack_require__(46);
-var Line = __webpack_require__(55);
-var Random = __webpack_require__(150);
+var Line = __webpack_require__(56);
+var Random = __webpack_require__(152);
/**
* @classdesc
@@ -2537,7 +2559,7 @@ module.exports = Rectangle;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -2547,27 +2569,28 @@ module.exports = Rectangle;
module.exports = {
- Alpha: __webpack_require__(252),
- Animation: __webpack_require__(484),
- BlendMode: __webpack_require__(255),
- ComputedSize: __webpack_require__(527),
- Crop: __webpack_require__(528),
- Depth: __webpack_require__(256),
- Flip: __webpack_require__(529),
- GetBounds: __webpack_require__(530),
- Mask: __webpack_require__(260),
- Origin: __webpack_require__(547),
- PathFollower: __webpack_require__(548),
- Pipeline: __webpack_require__(151),
- ScrollFactor: __webpack_require__(263),
- Size: __webpack_require__(549),
- Texture: __webpack_require__(550),
- TextureCrop: __webpack_require__(551),
- Tint: __webpack_require__(552),
- ToJSON: __webpack_require__(264),
- Transform: __webpack_require__(265),
+ Alpha: __webpack_require__(527),
+ AlphaSingle: __webpack_require__(266),
+ Animation: __webpack_require__(498),
+ BlendMode: __webpack_require__(269),
+ ComputedSize: __webpack_require__(546),
+ Crop: __webpack_require__(547),
+ Depth: __webpack_require__(270),
+ Flip: __webpack_require__(548),
+ GetBounds: __webpack_require__(549),
+ Mask: __webpack_require__(274),
+ Origin: __webpack_require__(566),
+ PathFollower: __webpack_require__(567),
+ Pipeline: __webpack_require__(153),
+ ScrollFactor: __webpack_require__(277),
+ Size: __webpack_require__(568),
+ Texture: __webpack_require__(569),
+ TextureCrop: __webpack_require__(570),
+ Tint: __webpack_require__(571),
+ ToJSON: __webpack_require__(278),
+ Transform: __webpack_require__(279),
TransformMatrix: __webpack_require__(32),
- Visible: __webpack_require__(266)
+ Visible: __webpack_require__(280)
};
@@ -2578,7 +2601,7 @@ module.exports = {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -2670,13 +2693,13 @@ module.exports = MATH_CONST;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var ComponentsToJSON = __webpack_require__(264);
-var DataManager = __webpack_require__(111);
+var ComponentsToJSON = __webpack_require__(278);
+var DataManager = __webpack_require__(113);
var EventEmitter = __webpack_require__(9);
var Events = __webpack_require__(90);
@@ -2731,7 +2754,7 @@ var GameObject = new Class({
*
* Phaser itself will never modify this value, although plugins may do so.
*
- * Use this property to track the state of a Game Object during its lifetime. For example, it could move from
+ * Use this property to track the state of a Game Object during its lifetime. For example, it could change from
* 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.
* If you need to store complex data about your Game Object, look at using the Data Component instead.
@@ -3311,11 +3334,11 @@ module.exports = GameObject;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var MATH = __webpack_require__(166);
+var MATH = __webpack_require__(168);
var GetValue = __webpack_require__(6);
/**
@@ -3398,13 +3421,13 @@ module.exports = GetAdvancedValue;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var PluginCache = __webpack_require__(21);
-var SceneEvents = __webpack_require__(22);
+var PluginCache = __webpack_require__(23);
+var SceneEvents = __webpack_require__(19);
/**
* @classdesc
@@ -3461,7 +3484,7 @@ var GameObjectCreator = new Class({
/**
* A reference to the Scene Update List.
*
- * @name Phaser.GameObjects.GameObjectCreator#updateList;
+ * @name Phaser.GameObjects.GameObjectCreator#updateList
* @type {Phaser.GameObjects.UpdateList}
* @protected
* @since 3.0.0
@@ -3566,7 +3589,7 @@ module.exports = GameObjectCreator;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -3665,7 +3688,7 @@ module.exports = Extend;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -3675,33 +3698,72 @@ module.exports = Extend;
module.exports = {
- BLUR: __webpack_require__(531),
- BOOT: __webpack_require__(532),
- CONTEXT_LOST: __webpack_require__(533),
- CONTEXT_RESTORED: __webpack_require__(534),
- DESTROY: __webpack_require__(535),
- FOCUS: __webpack_require__(536),
- HIDDEN: __webpack_require__(537),
- PAUSE: __webpack_require__(538),
- POST_RENDER: __webpack_require__(539),
- POST_STEP: __webpack_require__(540),
- PRE_RENDER: __webpack_require__(541),
- PRE_STEP: __webpack_require__(542),
- READY: __webpack_require__(543),
- RESUME: __webpack_require__(544),
- STEP: __webpack_require__(545),
- VISIBLE: __webpack_require__(546)
+ BLUR: __webpack_require__(550),
+ BOOT: __webpack_require__(551),
+ CONTEXT_LOST: __webpack_require__(552),
+ CONTEXT_RESTORED: __webpack_require__(553),
+ DESTROY: __webpack_require__(554),
+ FOCUS: __webpack_require__(555),
+ HIDDEN: __webpack_require__(556),
+ PAUSE: __webpack_require__(557),
+ POST_RENDER: __webpack_require__(558),
+ POST_STEP: __webpack_require__(559),
+ PRE_RENDER: __webpack_require__(560),
+ PRE_STEP: __webpack_require__(561),
+ READY: __webpack_require__(562),
+ RESUME: __webpack_require__(563),
+ STEP: __webpack_require__(564),
+ VISIBLE: __webpack_require__(565)
};
/***/ }),
/* 19 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+/**
+ * @namespace Phaser.Scenes.Events
+ */
+
+module.exports = {
+
+ BOOT: __webpack_require__(700),
+ CREATE: __webpack_require__(701),
+ DESTROY: __webpack_require__(702),
+ PAUSE: __webpack_require__(703),
+ POST_UPDATE: __webpack_require__(704),
+ PRE_UPDATE: __webpack_require__(705),
+ READY: __webpack_require__(706),
+ RENDER: __webpack_require__(707),
+ RESUME: __webpack_require__(708),
+ SHUTDOWN: __webpack_require__(709),
+ SLEEP: __webpack_require__(710),
+ START: __webpack_require__(711),
+ TRANSITION_COMPLETE: __webpack_require__(712),
+ TRANSITION_INIT: __webpack_require__(713),
+ TRANSITION_OUT: __webpack_require__(714),
+ TRANSITION_START: __webpack_require__(715),
+ TRANSITION_WAKE: __webpack_require__(716),
+ UPDATE: __webpack_require__(717),
+ WAKE: __webpack_require__(718)
+
+};
+
+
+/***/ }),
+/* 20 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -3848,23 +3910,23 @@ module.exports = FILE_CONST;
/***/ }),
-/* 20 */
+/* 21 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var CONST = __webpack_require__(19);
+var CONST = __webpack_require__(20);
var Events = __webpack_require__(81);
var GetFastValue = __webpack_require__(2);
-var GetURL = __webpack_require__(132);
-var MergeXHRSettings = __webpack_require__(211);
-var XHRLoader = __webpack_require__(433);
-var XHRSettings = __webpack_require__(133);
+var GetURL = __webpack_require__(134);
+var MergeXHRSettings = __webpack_require__(212);
+var XHRLoader = __webpack_require__(447);
+var XHRSettings = __webpack_require__(135);
/**
* @classdesc
@@ -4389,12 +4451,42 @@ module.exports = File;
/***/ }),
-/* 21 */
+/* 22 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+/**
+ * Force a value within the boundaries by clamping it to the range `min`, `max`.
+ *
+ * @function Phaser.Math.Clamp
+ * @since 3.0.0
+ *
+ * @param {number} value - The value to be clamped.
+ * @param {number} min - The minimum bounds.
+ * @param {number} max - The maximum bounds.
+ *
+ * @return {number} The clamped value.
+ */
+var Clamp = function (value, min, max)
+{
+ return Math.max(min, Math.min(max, value));
+};
+
+module.exports = Clamp;
+
+
+/***/ }),
+/* 23 */
+/***/ (function(module, exports) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -4597,82 +4689,13 @@ PluginCache.destroyCustomPlugins = function ()
module.exports = PluginCache;
-/***/ }),
-/* 22 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/**
- * @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
- * @license {@link https://opensource.org/licenses/MIT|MIT License}
- */
-
-/**
- * @namespace Phaser.Scenes.Events
- */
-
-module.exports = {
-
- BOOT: __webpack_require__(681),
- CREATE: __webpack_require__(682),
- DESTROY: __webpack_require__(683),
- PAUSE: __webpack_require__(684),
- POST_UPDATE: __webpack_require__(685),
- PRE_UPDATE: __webpack_require__(686),
- READY: __webpack_require__(687),
- RENDER: __webpack_require__(688),
- RESUME: __webpack_require__(689),
- SHUTDOWN: __webpack_require__(690),
- SLEEP: __webpack_require__(691),
- START: __webpack_require__(692),
- TRANSITION_COMPLETE: __webpack_require__(693),
- TRANSITION_INIT: __webpack_require__(694),
- TRANSITION_OUT: __webpack_require__(695),
- TRANSITION_START: __webpack_require__(696),
- TRANSITION_WAKE: __webpack_require__(697),
- UPDATE: __webpack_require__(698),
- WAKE: __webpack_require__(699)
-
-};
-
-
-/***/ }),
-/* 23 */
-/***/ (function(module, exports) {
-
-/**
- * @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
- * @license {@link https://opensource.org/licenses/MIT|MIT License}
- */
-
-/**
- * Force a value within the boundaries by clamping it to the range `min`, `max`.
- *
- * @function Phaser.Math.Clamp
- * @since 3.0.0
- *
- * @param {number} value - The value to be clamped.
- * @param {number} min - The minimum bounds.
- * @param {number} max - The maximum bounds.
- *
- * @return {number} The clamped value.
- */
-var Clamp = function (value, min, max)
-{
- return Math.max(min, Math.min(max, value));
-};
-
-module.exports = Clamp;
-
-
/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -4756,7 +4779,7 @@ module.exports = GetTilesWithin;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -4823,12 +4846,12 @@ module.exports = PropertyValueSet;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var CONST = __webpack_require__(29);
-var Smoothing = __webpack_require__(162);
+var Smoothing = __webpack_require__(164);
// The pool into which the canvas elements are placed.
var pool = [];
@@ -5084,7 +5107,7 @@ module.exports = CanvasPool();
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -5172,7 +5195,7 @@ module.exports = SetTransform;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -5300,7 +5323,7 @@ module.exports = BuildGameObject;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -5320,11 +5343,11 @@ var CONST = {
* @type {string}
* @since 3.0.0
*/
- VERSION: '3.21.0',
+ VERSION: '3.22.0',
BlendModes: __webpack_require__(52),
- ScaleModes: __webpack_require__(230),
+ ScaleModes: __webpack_require__(231),
/**
* AUTO Detect Renderer.
@@ -5438,14 +5461,14 @@ module.exports = CONST;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var GameObject = __webpack_require__(14);
-var Line = __webpack_require__(55);
+var Line = __webpack_require__(56);
/**
* @classdesc
@@ -5458,7 +5481,7 @@ var Line = __webpack_require__(55);
* @constructor
* @since 3.13.0
*
- * @extends Phaser.GameObjects.Components.Alpha
+ * @extends Phaser.GameObjects.Components.AlphaSingle
* @extends Phaser.GameObjects.Components.BlendMode
* @extends Phaser.GameObjects.Components.ComputedSize
* @extends Phaser.GameObjects.Components.Depth
@@ -5479,7 +5502,7 @@ var Shape = new Class({
Extends: GameObject,
Mixins: [
- Components.Alpha,
+ Components.AlphaSingle,
Components.BlendMode,
Components.ComputedSize,
Components.Depth,
@@ -5738,7 +5761,7 @@ module.exports = Shape;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -5793,7 +5816,7 @@ module.exports = {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -6761,15 +6784,15 @@ module.exports = TransformMatrix;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var GetColor = __webpack_require__(160);
-var GetColor32 = __webpack_require__(278);
-var HSVToRGB = __webpack_require__(161);
-var RGBToHSV = __webpack_require__(279);
+var GetColor = __webpack_require__(162);
+var GetColor32 = __webpack_require__(292);
+var HSVToRGB = __webpack_require__(163);
+var RGBToHSV = __webpack_require__(293);
/**
* @namespace Phaser.Display.Color
@@ -7624,7 +7647,7 @@ module.exports = Color;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -7691,7 +7714,7 @@ module.exports = PropertyValueInc;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -7721,7 +7744,7 @@ module.exports = DegToRad;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -7759,7 +7782,7 @@ module.exports = FillStyleCanvas;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -7787,14 +7810,14 @@ module.exports = GetBottom;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
/**
- * Positions the Game Object so that the bottom of its bounds aligns with the given coordinate.
+ * Positions the Game Object so that the top of its bounds aligns with the given coordinate.
*
- * @function Phaser.Display.Bounds.SetBottom
+ * @function Phaser.Display.Bounds.SetTop
* @since 3.0.0
*
* @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
@@ -7804,14 +7827,14 @@ module.exports = GetBottom;
*
* @return {Phaser.GameObjects.GameObject} The Game Object that was positioned.
*/
-var SetBottom = function (gameObject, value)
+var SetTop = function (gameObject, value)
{
- gameObject.y = (value - gameObject.height) + (gameObject.height * gameObject.originY);
+ gameObject.y = value + (gameObject.height * gameObject.originY);
return gameObject;
};
-module.exports = SetBottom;
+module.exports = SetTop;
/***/ }),
@@ -7820,7 +7843,7 @@ module.exports = SetBottom;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -7848,7 +7871,7 @@ module.exports = GetLeft;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -7881,7 +7904,7 @@ module.exports = SetLeft;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -7909,7 +7932,7 @@ module.exports = GetRight;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -7942,7 +7965,40 @@ module.exports = SetRight;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+/**
+ * Positions the Game Object so that the bottom of its bounds aligns with the given coordinate.
+ *
+ * @function Phaser.Display.Bounds.SetBottom
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be re-positioned.
+ * @param {number} value - The coordinate to position the Game Object bounds on.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was positioned.
+ */
+var SetBottom = function (gameObject, value)
+{
+ gameObject.y = (value - gameObject.height) + (gameObject.height * gameObject.originY);
+
+ return gameObject;
+};
+
+module.exports = SetBottom;
+
+
+/***/ }),
+/* 45 */
+/***/ (function(module, exports) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -7964,46 +8020,13 @@ var GetTop = function (gameObject)
module.exports = GetTop;
-/***/ }),
-/* 45 */
-/***/ (function(module, exports) {
-
-/**
- * @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
- * @license {@link https://opensource.org/licenses/MIT|MIT License}
- */
-
-/**
- * Positions the Game Object so that the top of its bounds aligns with the given coordinate.
- *
- * @function Phaser.Display.Bounds.SetTop
- * @since 3.0.0
- *
- * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
- *
- * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be re-positioned.
- * @param {number} value - The coordinate to position the Game Object bounds on.
- *
- * @return {Phaser.GameObjects.GameObject} The Game Object that was positioned.
- */
-var SetTop = function (gameObject, value)
-{
- gameObject.y = value + (gameObject.height * gameObject.originY);
-
- return gameObject;
-};
-
-module.exports = SetTop;
-
-
/***/ }),
/* 46 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -8083,7 +8106,7 @@ module.exports = GEOM_CONST;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -8118,7 +8141,7 @@ module.exports = Contains;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -8128,21 +8151,21 @@ module.exports = Contains;
module.exports = {
- DESTROY: __webpack_require__(622),
- FADE_IN_COMPLETE: __webpack_require__(623),
- FADE_IN_START: __webpack_require__(624),
- FADE_OUT_COMPLETE: __webpack_require__(625),
- FADE_OUT_START: __webpack_require__(626),
- FLASH_COMPLETE: __webpack_require__(627),
- FLASH_START: __webpack_require__(628),
- PAN_COMPLETE: __webpack_require__(629),
- PAN_START: __webpack_require__(630),
- POST_RENDER: __webpack_require__(631),
- PRE_RENDER: __webpack_require__(632),
- SHAKE_COMPLETE: __webpack_require__(633),
- SHAKE_START: __webpack_require__(634),
- ZOOM_COMPLETE: __webpack_require__(635),
- ZOOM_START: __webpack_require__(636)
+ DESTROY: __webpack_require__(641),
+ FADE_IN_COMPLETE: __webpack_require__(642),
+ FADE_IN_START: __webpack_require__(643),
+ FADE_OUT_COMPLETE: __webpack_require__(644),
+ FADE_OUT_START: __webpack_require__(645),
+ FLASH_COMPLETE: __webpack_require__(646),
+ FLASH_START: __webpack_require__(647),
+ PAN_COMPLETE: __webpack_require__(648),
+ PAN_START: __webpack_require__(649),
+ POST_RENDER: __webpack_require__(650),
+ PRE_RENDER: __webpack_require__(651),
+ SHAKE_COMPLETE: __webpack_require__(652),
+ SHAKE_START: __webpack_require__(653),
+ ZOOM_COMPLETE: __webpack_require__(654),
+ ZOOM_START: __webpack_require__(655)
};
@@ -8153,7 +8176,7 @@ module.exports = {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -8191,7 +8214,7 @@ module.exports = LineStyleCanvas;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -8320,11 +8343,11 @@ module.exports = CONST;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var GetTileAt = __webpack_require__(137);
+var GetTileAt = __webpack_require__(138);
var GetTilesWithin = __webpack_require__(24);
/**
@@ -8386,7 +8409,7 @@ module.exports = CalculateFacesWithin;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -8721,11 +8744,45 @@ module.exports = {
/***/ }),
/* 53 */
+/***/ (function(module, exports) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+/**
+ * Calculate the distance between two sets of coordinates (points).
+ *
+ * @function Phaser.Math.Distance.Between
+ * @since 3.0.0
+ *
+ * @param {number} x1 - The x coordinate of the first point.
+ * @param {number} y1 - The y coordinate of the first point.
+ * @param {number} x2 - The x coordinate of the second point.
+ * @param {number} y2 - The y coordinate of the second point.
+ *
+ * @return {number} The distance between each point.
+ */
+var DistanceBetween = function (x1, y1, x2, y2)
+{
+ var dx = x1 - x2;
+ var dy = y1 - y2;
+
+ return Math.sqrt(dx * dx + dy * dy);
+};
+
+module.exports = DistanceBetween;
+
+
+/***/ }),
+/* 54 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -8735,63 +8792,63 @@ module.exports = {
module.exports = {
- BOOT: __webpack_require__(803),
- DESTROY: __webpack_require__(804),
- DRAG_END: __webpack_require__(805),
- DRAG_ENTER: __webpack_require__(806),
- DRAG: __webpack_require__(807),
- DRAG_LEAVE: __webpack_require__(808),
- DRAG_OVER: __webpack_require__(809),
- DRAG_START: __webpack_require__(810),
- DROP: __webpack_require__(811),
- GAME_OUT: __webpack_require__(812),
- GAME_OVER: __webpack_require__(813),
- GAMEOBJECT_DOWN: __webpack_require__(814),
- GAMEOBJECT_DRAG_END: __webpack_require__(815),
- GAMEOBJECT_DRAG_ENTER: __webpack_require__(816),
- GAMEOBJECT_DRAG: __webpack_require__(817),
- GAMEOBJECT_DRAG_LEAVE: __webpack_require__(818),
- GAMEOBJECT_DRAG_OVER: __webpack_require__(819),
- GAMEOBJECT_DRAG_START: __webpack_require__(820),
- GAMEOBJECT_DROP: __webpack_require__(821),
- GAMEOBJECT_MOVE: __webpack_require__(822),
- GAMEOBJECT_OUT: __webpack_require__(823),
- GAMEOBJECT_OVER: __webpack_require__(824),
- GAMEOBJECT_POINTER_DOWN: __webpack_require__(825),
- GAMEOBJECT_POINTER_MOVE: __webpack_require__(826),
- GAMEOBJECT_POINTER_OUT: __webpack_require__(827),
- GAMEOBJECT_POINTER_OVER: __webpack_require__(828),
- GAMEOBJECT_POINTER_UP: __webpack_require__(829),
- GAMEOBJECT_POINTER_WHEEL: __webpack_require__(830),
- GAMEOBJECT_UP: __webpack_require__(831),
- GAMEOBJECT_WHEEL: __webpack_require__(832),
- MANAGER_BOOT: __webpack_require__(833),
- MANAGER_PROCESS: __webpack_require__(834),
- MANAGER_UPDATE: __webpack_require__(835),
- POINTER_DOWN: __webpack_require__(836),
- POINTER_DOWN_OUTSIDE: __webpack_require__(837),
- POINTER_MOVE: __webpack_require__(838),
- POINTER_OUT: __webpack_require__(839),
- POINTER_OVER: __webpack_require__(840),
- POINTER_UP: __webpack_require__(841),
- POINTER_UP_OUTSIDE: __webpack_require__(842),
- POINTER_WHEEL: __webpack_require__(843),
- POINTERLOCK_CHANGE: __webpack_require__(844),
- PRE_UPDATE: __webpack_require__(845),
- SHUTDOWN: __webpack_require__(846),
- START: __webpack_require__(847),
- UPDATE: __webpack_require__(848)
+ BOOT: __webpack_require__(814),
+ DESTROY: __webpack_require__(815),
+ DRAG_END: __webpack_require__(816),
+ DRAG_ENTER: __webpack_require__(817),
+ DRAG: __webpack_require__(818),
+ DRAG_LEAVE: __webpack_require__(819),
+ DRAG_OVER: __webpack_require__(820),
+ DRAG_START: __webpack_require__(821),
+ DROP: __webpack_require__(822),
+ GAME_OUT: __webpack_require__(823),
+ GAME_OVER: __webpack_require__(824),
+ GAMEOBJECT_DOWN: __webpack_require__(825),
+ GAMEOBJECT_DRAG_END: __webpack_require__(826),
+ GAMEOBJECT_DRAG_ENTER: __webpack_require__(827),
+ GAMEOBJECT_DRAG: __webpack_require__(828),
+ GAMEOBJECT_DRAG_LEAVE: __webpack_require__(829),
+ GAMEOBJECT_DRAG_OVER: __webpack_require__(830),
+ GAMEOBJECT_DRAG_START: __webpack_require__(831),
+ GAMEOBJECT_DROP: __webpack_require__(832),
+ GAMEOBJECT_MOVE: __webpack_require__(833),
+ GAMEOBJECT_OUT: __webpack_require__(834),
+ GAMEOBJECT_OVER: __webpack_require__(835),
+ GAMEOBJECT_POINTER_DOWN: __webpack_require__(836),
+ GAMEOBJECT_POINTER_MOVE: __webpack_require__(837),
+ GAMEOBJECT_POINTER_OUT: __webpack_require__(838),
+ GAMEOBJECT_POINTER_OVER: __webpack_require__(839),
+ GAMEOBJECT_POINTER_UP: __webpack_require__(840),
+ GAMEOBJECT_POINTER_WHEEL: __webpack_require__(841),
+ GAMEOBJECT_UP: __webpack_require__(842),
+ GAMEOBJECT_WHEEL: __webpack_require__(843),
+ MANAGER_BOOT: __webpack_require__(844),
+ MANAGER_PROCESS: __webpack_require__(845),
+ MANAGER_UPDATE: __webpack_require__(846),
+ POINTER_DOWN: __webpack_require__(847),
+ POINTER_DOWN_OUTSIDE: __webpack_require__(848),
+ POINTER_MOVE: __webpack_require__(849),
+ POINTER_OUT: __webpack_require__(850),
+ POINTER_OVER: __webpack_require__(851),
+ POINTER_UP: __webpack_require__(852),
+ POINTER_UP_OUTSIDE: __webpack_require__(853),
+ POINTER_WHEEL: __webpack_require__(854),
+ POINTERLOCK_CHANGE: __webpack_require__(855),
+ PRE_UPDATE: __webpack_require__(856),
+ SHUTDOWN: __webpack_require__(857),
+ START: __webpack_require__(858),
+ UPDATE: __webpack_require__(859)
};
/***/ }),
-/* 54 */
+/* 55 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -8827,20 +8884,20 @@ module.exports = Contains;
/***/ }),
-/* 55 */
+/* 56 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var GetPoint = __webpack_require__(258);
-var GetPoints = __webpack_require__(148);
+var GetPoint = __webpack_require__(272);
+var GetPoints = __webpack_require__(150);
var GEOM_CONST = __webpack_require__(46);
-var Random = __webpack_require__(149);
+var Random = __webpack_require__(151);
var Vector2 = __webpack_require__(3);
/**
@@ -8945,7 +9002,7 @@ var Line = new Class({
* @method Phaser.Geom.Line#getPoints
* @since 3.0.0
*
- * @generic {Phaser.Geom.Point} O - [output,$return]
+ * @generic {Phaser.Geom.Point[]} O - [output,$return]
*
* @param {integer} quantity - The number of points to place on the line. Set to `0` to use `stepRate` instead.
* @param {integer} [stepRate] - The distance between each point on the line. When set, `quantity` is implied and should be set to `0`.
@@ -9164,12 +9221,12 @@ module.exports = Line;
/***/ }),
-/* 56 */
+/* 57 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -9192,12 +9249,12 @@ module.exports = Length;
/***/ }),
-/* 57 */
+/* 58 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -9223,47 +9280,13 @@ var Wrap = function (value, min, max)
module.exports = Wrap;
-/***/ }),
-/* 58 */
-/***/ (function(module, exports) {
-
-/**
- * @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
- * @license {@link https://opensource.org/licenses/MIT|MIT License}
- */
-
-/**
- * Calculate the distance between two sets of coordinates (points).
- *
- * @function Phaser.Math.Distance.Between
- * @since 3.0.0
- *
- * @param {number} x1 - The x coordinate of the first point.
- * @param {number} y1 - The y coordinate of the first point.
- * @param {number} x2 - The x coordinate of the second point.
- * @param {number} y2 - The y coordinate of the second point.
- *
- * @return {number} The distance between each point.
- */
-var DistanceBetween = function (x1, y1, x2, y2)
-{
- var dx = x1 - x2;
- var dy = y1 - y2;
-
- return Math.sqrt(dx * dx + dy * dy);
-};
-
-module.exports = DistanceBetween;
-
-
/***/ }),
/* 59 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -9273,29 +9296,29 @@ module.exports = DistanceBetween;
module.exports = {
- COMPLETE: __webpack_require__(871),
- DECODED: __webpack_require__(872),
- DECODED_ALL: __webpack_require__(873),
- DESTROY: __webpack_require__(874),
- DETUNE: __webpack_require__(875),
- GLOBAL_DETUNE: __webpack_require__(876),
- GLOBAL_MUTE: __webpack_require__(877),
- GLOBAL_RATE: __webpack_require__(878),
- GLOBAL_VOLUME: __webpack_require__(879),
- LOOP: __webpack_require__(880),
- LOOPED: __webpack_require__(881),
- MUTE: __webpack_require__(882),
- PAUSE_ALL: __webpack_require__(883),
- PAUSE: __webpack_require__(884),
- PLAY: __webpack_require__(885),
- RATE: __webpack_require__(886),
- RESUME_ALL: __webpack_require__(887),
- RESUME: __webpack_require__(888),
- SEEK: __webpack_require__(889),
- STOP_ALL: __webpack_require__(890),
- STOP: __webpack_require__(891),
- UNLOCKED: __webpack_require__(892),
- VOLUME: __webpack_require__(893)
+ COMPLETE: __webpack_require__(882),
+ DECODED: __webpack_require__(883),
+ DECODED_ALL: __webpack_require__(884),
+ DESTROY: __webpack_require__(885),
+ DETUNE: __webpack_require__(886),
+ GLOBAL_DETUNE: __webpack_require__(887),
+ GLOBAL_MUTE: __webpack_require__(888),
+ GLOBAL_RATE: __webpack_require__(889),
+ GLOBAL_VOLUME: __webpack_require__(890),
+ LOOP: __webpack_require__(891),
+ LOOPED: __webpack_require__(892),
+ MUTE: __webpack_require__(893),
+ PAUSE_ALL: __webpack_require__(894),
+ PAUSE: __webpack_require__(895),
+ PLAY: __webpack_require__(896),
+ RATE: __webpack_require__(897),
+ RESUME_ALL: __webpack_require__(898),
+ RESUME: __webpack_require__(899),
+ SEEK: __webpack_require__(900),
+ STOP_ALL: __webpack_require__(901),
+ STOP: __webpack_require__(902),
+ UNLOCKED: __webpack_require__(903),
+ VOLUME: __webpack_require__(904)
};
@@ -9306,13 +9329,13 @@ module.exports = {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var CONST = __webpack_require__(19);
-var File = __webpack_require__(20);
+var CONST = __webpack_require__(20);
+var File = __webpack_require__(21);
var FileTypesManager = __webpack_require__(8);
var GetFastValue = __webpack_require__(2);
var GetValue = __webpack_require__(6);
@@ -9536,7 +9559,7 @@ module.exports = JSONFile;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -9771,7 +9794,7 @@ module.exports = MultiFile;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -9822,7 +9845,7 @@ module.exports = WorldToTileX;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -9873,16 +9896,16 @@ module.exports = WorldToTileY;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var Contains = __webpack_require__(54);
-var GetPoint = __webpack_require__(249);
-var GetPoints = __webpack_require__(250);
+var Contains = __webpack_require__(55);
+var GetPoint = __webpack_require__(263);
+var GetPoints = __webpack_require__(264);
var GEOM_CONST = __webpack_require__(46);
-var Random = __webpack_require__(145);
+var Random = __webpack_require__(147);
/**
* @classdesc
@@ -10249,7 +10272,7 @@ module.exports = Circle;
"use strict";
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -10930,7 +10953,7 @@ earcut.flatten = function (data) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -10972,7 +10995,7 @@ module.exports = Clone;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -11021,14 +11044,14 @@ module.exports = SafeRange;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var GameObject = __webpack_require__(14);
-var SpriteRender = __webpack_require__(949);
+var SpriteRender = __webpack_require__(960);
/**
* @classdesc
@@ -11199,7 +11222,7 @@ module.exports = Sprite;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -11274,17 +11297,17 @@ module.exports = StrokePathWebGL;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Contains = __webpack_require__(83);
-var GetPoint = __webpack_require__(403);
-var GetPoints = __webpack_require__(404);
+var GetPoint = __webpack_require__(417);
+var GetPoints = __webpack_require__(418);
var GEOM_CONST = __webpack_require__(46);
-var Line = __webpack_require__(55);
-var Random = __webpack_require__(153);
+var Line = __webpack_require__(56);
+var Random = __webpack_require__(155);
/**
* @classdesc
@@ -11721,13 +11744,13 @@ module.exports = Triangle;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var CONST = __webpack_require__(19);
-var File = __webpack_require__(20);
+var CONST = __webpack_require__(20);
+var File = __webpack_require__(21);
var FileTypesManager = __webpack_require__(8);
var GetFastValue = __webpack_require__(2);
var IsPlainObject = __webpack_require__(7);
@@ -11995,7 +12018,7 @@ module.exports = ImageFile;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -12031,13 +12054,13 @@ module.exports = SetTileCollision;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
-var Rectangle = __webpack_require__(422);
+var Rectangle = __webpack_require__(436);
/**
* @classdesc
@@ -12869,7 +12892,7 @@ module.exports = Tile;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -12897,7 +12920,7 @@ module.exports = GetCenterX;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -12932,7 +12955,35 @@ module.exports = SetCenterX;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+/**
+ * Returns the center y coordinate from the bounds of the Game Object.
+ *
+ * @function Phaser.Display.Bounds.GetCenterY
+ * @since 3.0.0
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object to get the bounds value from.
+ *
+ * @return {number} The center y coordinate of the bounds of the Game Object.
+ */
+var GetCenterY = function (gameObject)
+{
+ return gameObject.y - (gameObject.height * gameObject.originY) + (gameObject.height * 0.5);
+};
+
+module.exports = GetCenterY;
+
+
+/***/ }),
+/* 78 */
+/***/ (function(module, exports) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -12961,41 +13012,13 @@ var SetCenterY = function (gameObject, y)
module.exports = SetCenterY;
-/***/ }),
-/* 78 */
-/***/ (function(module, exports) {
-
-/**
- * @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
- * @license {@link https://opensource.org/licenses/MIT|MIT License}
- */
-
-/**
- * Returns the center y coordinate from the bounds of the Game Object.
- *
- * @function Phaser.Display.Bounds.GetCenterY
- * @since 3.0.0
- *
- * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object to get the bounds value from.
- *
- * @return {number} The center y coordinate of the bounds of the Game Object.
- */
-var GetCenterY = function (gameObject)
-{
- return gameObject.y - (gameObject.height * gameObject.originY) + (gameObject.height * 0.5);
-};
-
-module.exports = GetCenterY;
-
-
/***/ }),
/* 79 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -13041,12 +13064,12 @@ module.exports = SpliceOne;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var FromPoints = __webpack_require__(173);
+var FromPoints = __webpack_require__(174);
var Rectangle = __webpack_require__(11);
var Vector2 = __webpack_require__(3);
@@ -13061,7 +13084,7 @@ var Vector2 = __webpack_require__(3);
* @constructor
* @since 3.0.0
*
- * @param {string} type - [description]
+ * @param {string} type - The curve type.
*/
var Curve = new Class({
@@ -13119,7 +13142,7 @@ var Curve = new Class({
this.needsUpdate = true;
/**
- * [description]
+ * For a curve on a Path, `false` means the Path will ignore this curve.
*
* @name Phaser.Curves.Curve#active
* @type {boolean}
@@ -13172,7 +13195,7 @@ var Curve = new Class({
// So you can chain graphics calls
return graphics.strokePoints(this.getPoints(pointsTotal));
},
-
+
/**
* Returns a Rectangle where the position and dimensions match the bounds of this Curve.
*
@@ -13228,7 +13251,7 @@ var Curve = new Class({
},
/**
- * [description]
+ * Get a point at the end of the curve.
*
* @method Phaser.Curves.Curve#getEndPoint
* @since 3.0.0
@@ -13250,7 +13273,7 @@ var Curve = new Class({
* @method Phaser.Curves.Curve#getLength
* @since 3.0.0
*
- * @return {number} [description]
+ * @return {number} The total length of the curve.
*/
getLength: function ()
{
@@ -13261,14 +13284,22 @@ var Curve = new Class({
/**
- * Get list of cumulative segment lengths
+ * Get a list of cumulative segment lengths.
+ *
+ * These lengths are
+ *
+ * - [0] 0
+ * - [1] The first segment
+ * - [2] The first and second segment
+ * - ...
+ * - [divisions] All segments
*
* @method Phaser.Curves.Curve#getLengths
* @since 3.0.0
*
- * @param {integer} [divisions] - [description]
+ * @param {integer} [divisions] - The number of divisions or segments.
*
- * @return {number[]} [description]
+ * @return {number[]} An array of cumulative lengths.
*/
getLengths: function (divisions)
{
@@ -13309,17 +13340,17 @@ var Curve = new Class({
// - u [0 .. 1]
/**
- * [description]
+ * Get a point at a relative position on the curve, by arc length.
*
* @method Phaser.Curves.Curve#getPointAt
* @since 3.0.0
*
* @generic {Phaser.Math.Vector2} O - [out,$return]
*
- * @param {number} u - [description]
- * @param {Phaser.Math.Vector2} [out] - [description]
+ * @param {number} u - The relative position, [0..1].
+ * @param {Phaser.Math.Vector2} [out] - A point to store the result in.
*
- * @return {Phaser.Math.Vector2} [description]
+ * @return {Phaser.Math.Vector2} The point.
*/
getPointAt: function (u, out)
{
@@ -13331,13 +13362,25 @@ var Curve = new Class({
// Get sequence of points using getPoint( t )
/**
- * [description]
+ * Get a sequence of evenly spaced points from the curve.
+ *
+ * You can pass `divisions`, `stepRate`, or neither.
+ *
+ * The number of divisions will be
+ *
+ * 1. `divisions`, if `divisions` > 0; or
+ * 2. `this.getLength / stepRate`, if `stepRate` > 0; or
+ * 3. `this.defaultDivisions`
+ *
+ * `1 + divisions` points will be returned.
*
* @method Phaser.Curves.Curve#getPoints
* @since 3.0.0
*
- * @param {integer} divisions - The number of evenly spaced points from the curve to return. If falsy, step param will be used to calculate the number of points.
- * @param {number} step - Step between points. Used to calculate the number of points to return when divisions is falsy. Ignored if divisions is positive.
+ * @generic {Phaser.Math.Vector2[]} O - [out,$return]
+ *
+ * @param {integer} [divisions] - The number of divisions to make.
+ * @param {number} [stepRate] - The curve distance between points, implying `divisions`.
* @param {(array|Phaser.Math.Vector2[])} [out] - An optional array to store the points in.
*
* @return {(array|Phaser.Math.Vector2[])} An array of Points from the curve.
@@ -13368,16 +13411,16 @@ var Curve = new Class({
},
/**
- * [description]
+ * Get a random point from the curve.
*
* @method Phaser.Curves.Curve#getRandomPoint
* @since 3.0.0
*
* @generic {Phaser.Math.Vector2} O - [out,$return]
*
- * @param {Phaser.Math.Vector2} [out] - [description]
+ * @param {Phaser.Math.Vector2} [out] - A point object to store the result in.
*
- * @return {Phaser.Math.Vector2} [description]
+ * @return {Phaser.Math.Vector2} The point.
*/
getRandomPoint: function (out)
{
@@ -13389,42 +13432,57 @@ var Curve = new Class({
// Get sequence of points using getPointAt( u )
/**
- * [description]
+ * Get a sequence of equally spaced points (by arc distance) from the curve.
+ *
+ * `1 + divisions` points will be returned.
*
* @method Phaser.Curves.Curve#getSpacedPoints
* @since 3.0.0
*
- * @param {integer} [divisions] - [description]
+ * @param {integer} [divisions=this.defaultDivisions] - The number of divisions to make.
+ * @param {number} [stepRate] - Step between points. Used to calculate the number of points to return when divisions is falsy. Ignored if divisions is positive.
+ * @param {(array|Phaser.Math.Vector2[])} [out] - An optional array to store the points in.
*
- * @return {Phaser.Math.Vector2[]} [description]
+ * @return {Phaser.Math.Vector2[]} An array of points.
*/
- getSpacedPoints: function (divisions)
+ getSpacedPoints: function (divisions, stepRate, out)
{
- if (divisions === undefined) { divisions = this.defaultDivisions; }
+ if (out === undefined) { out = []; }
- var points = [];
+ // If divisions is a falsey value (false, null, 0, undefined, etc) then we calculate it based on the stepRate instead.
+ if (!divisions)
+ {
+ if (!stepRate)
+ {
+ divisions = this.defaultDivisions;
+ }
+ else
+ {
+ divisions = this.getLength() / stepRate;
+ }
+ }
for (var d = 0; d <= divisions; d++)
{
var t = this.getUtoTmapping(d / divisions, null, divisions);
- points.push(this.getPoint(t));
+ out.push(this.getPoint(t));
}
- return points;
+ return out;
},
/**
- * [description]
+ * Get a point at the start of the curve.
*
* @method Phaser.Curves.Curve#getStartPoint
* @since 3.0.0
*
* @generic {Phaser.Math.Vector2} O - [out,$return]
*
- * @param {Phaser.Math.Vector2} [out] - [description]
+ * @param {Phaser.Math.Vector2} [out] - A point to store the result in.
*
- * @return {Phaser.Math.Vector2} [description]
+ * @return {Phaser.Math.Vector2} The point.
*/
getStartPoint: function (out)
{
@@ -13434,7 +13492,7 @@ var Curve = new Class({
},
/**
- * Returns a unit vector tangent at t
+ * Get a unit vector tangent at a relative position on the curve.
* In case any sub curve does not implement its tangent derivation,
* 2 points a small delta apart will be used to find its gradient
* which seems to give a reasonable approximation
@@ -13444,8 +13502,8 @@ var Curve = new Class({
*
* @generic {Phaser.Math.Vector2} O - [out,$return]
*
- * @param {number} t - [description]
- * @param {Phaser.Math.Vector2} [out] - [description]
+ * @param {number} t - The relative position on the curve, [0..1].
+ * @param {Phaser.Math.Vector2} [out] - A vector to store the result in.
*
* @return {Phaser.Math.Vector2} Vector approximating the tangent line at the point t (delta +/- 0.0001)
*/
@@ -13476,17 +13534,17 @@ var Curve = new Class({
},
/**
- * [description]
+ * Get a unit vector tangent at a relative position on the curve, by arc length.
*
* @method Phaser.Curves.Curve#getTangentAt
* @since 3.0.0
*
* @generic {Phaser.Math.Vector2} O - [out,$return]
*
- * @param {number} u - [description]
- * @param {Phaser.Math.Vector2} [out] - [description]
+ * @param {number} u - The relative position on the curve, [0..1].
+ * @param {Phaser.Math.Vector2} [out] - A vector to store the result in.
*
- * @return {Phaser.Math.Vector2} [description]
+ * @return {Phaser.Math.Vector2} The tangent vector.
*/
getTangentAt: function (u, out)
{
@@ -13601,10 +13659,12 @@ var Curve = new Class({
},
/**
- * [description]
+ * Calculate and cache the arc lengths.
*
* @method Phaser.Curves.Curve#updateArcLengths
* @since 3.0.0
+ *
+ * @see Phaser.Curves.Curve#getLengths()
*/
updateArcLengths: function ()
{
@@ -13624,7 +13684,7 @@ module.exports = Curve;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -13634,16 +13694,16 @@ module.exports = Curve;
module.exports = {
- ADD: __webpack_require__(850),
- COMPLETE: __webpack_require__(851),
- FILE_COMPLETE: __webpack_require__(852),
- FILE_KEY_COMPLETE: __webpack_require__(853),
- FILE_LOAD_ERROR: __webpack_require__(854),
- FILE_LOAD: __webpack_require__(855),
- FILE_PROGRESS: __webpack_require__(856),
- POST_PROCESS: __webpack_require__(857),
- PROGRESS: __webpack_require__(858),
- START: __webpack_require__(859)
+ ADD: __webpack_require__(861),
+ COMPLETE: __webpack_require__(862),
+ FILE_COMPLETE: __webpack_require__(863),
+ FILE_KEY_COMPLETE: __webpack_require__(864),
+ FILE_LOAD_ERROR: __webpack_require__(865),
+ FILE_LOAD: __webpack_require__(866),
+ FILE_PROGRESS: __webpack_require__(867),
+ POST_PROCESS: __webpack_require__(868),
+ PROGRESS: __webpack_require__(869),
+ START: __webpack_require__(870)
};
@@ -13654,12 +13714,12 @@ module.exports = {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var EaseMap = __webpack_require__(164);
-var UppercaseFirst = __webpack_require__(178);
+var EaseMap = __webpack_require__(166);
+var UppercaseFirst = __webpack_require__(179);
/**
* This internal function is used to return the correct ease function for a Tween.
@@ -13763,7 +13823,7 @@ module.exports = GetEaseFunction;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -13816,7 +13876,7 @@ module.exports = Contains;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -13892,7 +13952,7 @@ module.exports = LineToLine;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -13921,11 +13981,11 @@ module.exports = Angle;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var Clamp = __webpack_require__(23);
+var Clamp = __webpack_require__(22);
/**
* Return a value based on the range between `min` and `max` and the percentage given.
@@ -13955,7 +14015,7 @@ module.exports = FromPercent;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -13996,7 +14056,7 @@ module.exports = GetBoolean;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -14168,7 +14228,7 @@ module.exports = TWEEN_CONST;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -14178,17 +14238,17 @@ module.exports = TWEEN_CONST;
module.exports = {
- DESTROY: __webpack_require__(557),
- VIDEO_COMPLETE: __webpack_require__(558),
- VIDEO_CREATED: __webpack_require__(559),
- VIDEO_ERROR: __webpack_require__(560),
- VIDEO_LOOP: __webpack_require__(561),
- VIDEO_PLAY: __webpack_require__(562),
- VIDEO_SEEKED: __webpack_require__(563),
- VIDEO_SEEKING: __webpack_require__(564),
- VIDEO_STOP: __webpack_require__(565),
- VIDEO_TIMEOUT: __webpack_require__(566),
- VIDEO_UNLOCKED: __webpack_require__(567)
+ DESTROY: __webpack_require__(576),
+ VIDEO_COMPLETE: __webpack_require__(577),
+ VIDEO_CREATED: __webpack_require__(578),
+ VIDEO_ERROR: __webpack_require__(579),
+ VIDEO_LOOP: __webpack_require__(580),
+ VIDEO_PLAY: __webpack_require__(581),
+ VIDEO_SEEKED: __webpack_require__(582),
+ VIDEO_SEEKING: __webpack_require__(583),
+ VIDEO_STOP: __webpack_require__(584),
+ VIDEO_TIMEOUT: __webpack_require__(585),
+ VIDEO_UNLOCKED: __webpack_require__(586)
};
@@ -14199,7 +14259,7 @@ module.exports = {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -14210,7 +14270,7 @@ var EventEmitter = __webpack_require__(9);
var Events = __webpack_require__(48);
var Rectangle = __webpack_require__(11);
var TransformMatrix = __webpack_require__(32);
-var ValueToColor = __webpack_require__(159);
+var ValueToColor = __webpack_require__(161);
var Vector2 = __webpack_require__(3);
/**
@@ -14776,7 +14836,7 @@ var BaseCamera = new Class({
*
* @param {number} x - The horizontal coordinate to center on.
* @param {number} y - The vertical coordinate to center on.
- * @param {Phaser.Math.Vector2} [out] - A Vec2 to store the values in. If not given a new Vec2 is created.
+ * @param {Phaser.Math.Vector2} [out] - A Vector2 to store the values in. If not given a new Vector2 is created.
*
* @return {Phaser.Math.Vector2} The scroll coordinates stored in the `x` and `y` properties.
*/
@@ -16120,7 +16180,7 @@ module.exports = BaseCamera;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -16130,12 +16190,12 @@ module.exports = BaseCamera;
module.exports = {
- ENTER_FULLSCREEN: __webpack_require__(675),
- FULLSCREEN_FAILED: __webpack_require__(676),
- FULLSCREEN_UNSUPPORTED: __webpack_require__(677),
- LEAVE_FULLSCREEN: __webpack_require__(678),
- ORIENTATION_CHANGE: __webpack_require__(679),
- RESIZE: __webpack_require__(680)
+ ENTER_FULLSCREEN: __webpack_require__(694),
+ FULLSCREEN_FAILED: __webpack_require__(695),
+ FULLSCREEN_UNSUPPORTED: __webpack_require__(696),
+ LEAVE_FULLSCREEN: __webpack_require__(697),
+ ORIENTATION_CHANGE: __webpack_require__(698),
+ RESIZE: __webpack_require__(699)
};
@@ -16146,7 +16206,7 @@ module.exports = {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -16190,12 +16250,12 @@ module.exports = SnapFloor;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var Clamp = __webpack_require__(23);
+var Clamp = __webpack_require__(22);
var Extend = __webpack_require__(17);
/**
@@ -17009,16 +17069,16 @@ module.exports = Frame;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Contains = __webpack_require__(96);
-var GetPoint = __webpack_require__(376);
-var GetPoints = __webpack_require__(377);
+var GetPoint = __webpack_require__(390);
+var GetPoints = __webpack_require__(391);
var GEOM_CONST = __webpack_require__(46);
-var Random = __webpack_require__(152);
+var Random = __webpack_require__(154);
/**
* @classdesc
@@ -17144,11 +17204,13 @@ var Ellipse = new Class({
* @method Phaser.Geom.Ellipse#getPoints
* @since 3.0.0
*
+ * @generic {Phaser.Geom.Point[]} O - [output,$return]
+ *
* @param {integer} quantity - The amount of points to return. If a falsey value the quantity will be derived from the `stepRate` instead.
* @param {number} [stepRate] - Sets the quantity by getting the circumference of the ellipse and dividing it by the stepRate.
- * @param {array} [output] - An array to insert the points in to. If not provided a new array will be created.
+ * @param {(array|Phaser.Geom.Point[])} [output] - An array to insert the points in to. If not provided a new array will be created.
*
- * @return {Phaser.Geom.Point[]} An array of Point objects pertaining to the points around the circumference of the ellipse.
+ * @return {(array|Phaser.Geom.Point[])} An array of Point objects pertaining to the points around the circumference of the ellipse.
*/
getPoints: function (quantity, stepRate, output)
{
@@ -17389,7 +17451,7 @@ module.exports = Ellipse;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -17431,18 +17493,18 @@ module.exports = Contains;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var Actions = __webpack_require__(237);
+var Actions = __webpack_require__(238);
var Class = __webpack_require__(0);
var Events = __webpack_require__(90);
var GetFastValue = __webpack_require__(2);
var GetValue = __webpack_require__(6);
var IsPlainObject = __webpack_require__(7);
-var Range = __webpack_require__(370);
-var Set = __webpack_require__(107);
+var Range = __webpack_require__(384);
+var Set = __webpack_require__(108);
var Sprite = __webpack_require__(69);
/**
@@ -17645,6 +17707,28 @@ var Group = new Class({
*/
this.createMultipleCallback = GetFastValue(config, 'createMultipleCallback', null);
+ /**
+ * A function to be called when adding or creating group members.
+ * For internal use only by a Group, or any class that extends it.
+ *
+ * @name Phaser.GameObjects.Group#internalCreateCallback
+ * @type {?Phaser.Types.GameObjects.Group.GroupCallback}
+ * @private
+ * @since 3.22.0
+ */
+ this.internalCreateCallback = GetFastValue(config, 'internalCreateCallback', null);
+
+ /**
+ * A function to be called when removing group members.
+ * For internal use only by a Group, or any class that extends it.
+ *
+ * @name Phaser.GameObjects.Group#internalRemoveCallback
+ * @type {?Phaser.Types.GameObjects.Group.GroupCallback}
+ * @private
+ * @since 3.22.0
+ */
+ this.internalRemoveCallback = GetFastValue(config, 'internalRemoveCallback', null);
+
if (config)
{
this.createMultiple(config);
@@ -17943,6 +18027,11 @@ var Group = new Class({
this.children.set(child);
+ if (this.internalCreateCallback)
+ {
+ this.internalCreateCallback.call(this, child);
+ }
+
if (this.createCallback)
{
this.createCallback.call(this, child);
@@ -18017,6 +18106,11 @@ var Group = new Class({
this.children.delete(child);
+ if (this.internalRemoveCallback)
+ {
+ this.internalRemoveCallback.call(this, child);
+ }
+
if (this.removeCallback)
{
this.removeCallback.call(this, child);
@@ -19037,14 +19131,14 @@ module.exports = Group;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var GameObject = __webpack_require__(14);
-var ImageRender = __webpack_require__(952);
+var ImageRender = __webpack_require__(963);
/**
* @classdesc
@@ -19138,7 +19232,7 @@ module.exports = Image;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -19167,7 +19261,7 @@ module.exports = HasValue;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -19233,7 +19327,7 @@ module.exports = FillPathWebGL;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -19264,7 +19358,7 @@ module.exports = IsInLayerBounds;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -19458,7 +19552,7 @@ var LayerData = new Class({
* An array of the tile indexes
*
* @name Phaser.Tilemaps.LayerData#data
- * @type {(number[])}
+ * @type {Phaser.Tilemaps.Tile[][]}
* @since 3.0.0
*/
this.data = GetFastValue(config, 'data', []);
@@ -19484,7 +19578,7 @@ module.exports = LayerData;
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -19705,11 +19799,145 @@ module.exports = MapData;
/***/ }),
/* 106 */
+/***/ (function(module, exports) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var ALIGN_CONST = {
+
+ /**
+ * A constant representing a top-left alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.TOP_LEFT
+ * @since 3.0.0
+ * @type {integer}
+ */
+ TOP_LEFT: 0,
+
+ /**
+ * A constant representing a top-center alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.TOP_CENTER
+ * @since 3.0.0
+ * @type {integer}
+ */
+ TOP_CENTER: 1,
+
+ /**
+ * A constant representing a top-right alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.TOP_RIGHT
+ * @since 3.0.0
+ * @type {integer}
+ */
+ TOP_RIGHT: 2,
+
+ /**
+ * A constant representing a left-top alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.LEFT_TOP
+ * @since 3.0.0
+ * @type {integer}
+ */
+ LEFT_TOP: 3,
+
+ /**
+ * A constant representing a left-center alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.LEFT_CENTER
+ * @since 3.0.0
+ * @type {integer}
+ */
+ LEFT_CENTER: 4,
+
+ /**
+ * A constant representing a left-bottom alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.LEFT_BOTTOM
+ * @since 3.0.0
+ * @type {integer}
+ */
+ LEFT_BOTTOM: 5,
+
+ /**
+ * A constant representing a center alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.CENTER
+ * @since 3.0.0
+ * @type {integer}
+ */
+ CENTER: 6,
+
+ /**
+ * A constant representing a right-top alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.RIGHT_TOP
+ * @since 3.0.0
+ * @type {integer}
+ */
+ RIGHT_TOP: 7,
+
+ /**
+ * A constant representing a right-center alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.RIGHT_CENTER
+ * @since 3.0.0
+ * @type {integer}
+ */
+ RIGHT_CENTER: 8,
+
+ /**
+ * A constant representing a right-bottom alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.RIGHT_BOTTOM
+ * @since 3.0.0
+ * @type {integer}
+ */
+ RIGHT_BOTTOM: 9,
+
+ /**
+ * A constant representing a bottom-left alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.BOTTOM_LEFT
+ * @since 3.0.0
+ * @type {integer}
+ */
+ BOTTOM_LEFT: 10,
+
+ /**
+ * A constant representing a bottom-center alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.BOTTOM_CENTER
+ * @since 3.0.0
+ * @type {integer}
+ */
+ BOTTOM_CENTER: 11,
+
+ /**
+ * A constant representing a bottom-right alignment or position.
+ * @constant
+ * @name Phaser.Display.Align.BOTTOM_RIGHT
+ * @since 3.0.0
+ * @type {integer}
+ */
+ BOTTOM_RIGHT: 12
+
+};
+
+module.exports = ALIGN_CONST;
+
+
+/***/ }),
+/* 107 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -19749,12 +19977,12 @@ module.exports = Merge;
/***/ }),
-/* 107 */
+/* 108 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -20198,18 +20426,19 @@ module.exports = Set;
/***/ }),
-/* 108 */
+/* 109 */,
+/* 110 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var BlendModes = __webpack_require__(52);
var Circle = __webpack_require__(65);
-var CircleContains = __webpack_require__(54);
+var CircleContains = __webpack_require__(55);
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var GameObject = __webpack_require__(14);
@@ -20511,12 +20740,12 @@ module.exports = Zone;
/***/ }),
-/* 109 */
+/* 111 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -20526,35 +20755,35 @@ module.exports = Zone;
module.exports = {
- ADD_ANIMATION: __webpack_require__(509),
- ANIMATION_COMPLETE: __webpack_require__(510),
- ANIMATION_REPEAT: __webpack_require__(511),
- ANIMATION_RESTART: __webpack_require__(512),
- ANIMATION_START: __webpack_require__(513),
- PAUSE_ALL: __webpack_require__(514),
- REMOVE_ANIMATION: __webpack_require__(515),
- RESUME_ALL: __webpack_require__(516),
- SPRITE_ANIMATION_COMPLETE: __webpack_require__(517),
- SPRITE_ANIMATION_KEY_COMPLETE: __webpack_require__(518),
- SPRITE_ANIMATION_KEY_REPEAT: __webpack_require__(519),
- SPRITE_ANIMATION_KEY_RESTART: __webpack_require__(520),
- SPRITE_ANIMATION_KEY_START: __webpack_require__(521),
- SPRITE_ANIMATION_KEY_UPDATE: __webpack_require__(522),
- SPRITE_ANIMATION_REPEAT: __webpack_require__(523),
- SPRITE_ANIMATION_RESTART: __webpack_require__(524),
- SPRITE_ANIMATION_START: __webpack_require__(525),
- SPRITE_ANIMATION_UPDATE: __webpack_require__(526)
+ ADD_ANIMATION: __webpack_require__(528),
+ ANIMATION_COMPLETE: __webpack_require__(529),
+ ANIMATION_REPEAT: __webpack_require__(530),
+ ANIMATION_RESTART: __webpack_require__(531),
+ ANIMATION_START: __webpack_require__(532),
+ PAUSE_ALL: __webpack_require__(533),
+ REMOVE_ANIMATION: __webpack_require__(534),
+ RESUME_ALL: __webpack_require__(535),
+ SPRITE_ANIMATION_COMPLETE: __webpack_require__(536),
+ SPRITE_ANIMATION_KEY_COMPLETE: __webpack_require__(537),
+ SPRITE_ANIMATION_KEY_REPEAT: __webpack_require__(538),
+ SPRITE_ANIMATION_KEY_RESTART: __webpack_require__(539),
+ SPRITE_ANIMATION_KEY_START: __webpack_require__(540),
+ SPRITE_ANIMATION_KEY_UPDATE: __webpack_require__(541),
+ SPRITE_ANIMATION_REPEAT: __webpack_require__(542),
+ SPRITE_ANIMATION_RESTART: __webpack_require__(543),
+ SPRITE_ANIMATION_START: __webpack_require__(544),
+ SPRITE_ANIMATION_UPDATE: __webpack_require__(545)
};
/***/ }),
-/* 110 */
+/* 112 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -20577,17 +20806,17 @@ module.exports = Perimeter;
/***/ }),
-/* 111 */
+/* 113 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var Events = __webpack_require__(267);
+var Events = __webpack_require__(281);
/**
* @callback DataEachCallback
@@ -21218,12 +21447,12 @@ module.exports = DataManager;
/***/ }),
-/* 112 */
+/* 114 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -21235,9 +21464,12 @@ module.exports = DataManager;
* @function Phaser.Utils.Array.Shuffle
* @since 3.0.0
*
- * @param {array} array - The array to shuffle. This array is modified in place.
+ * @generic T
+ * @genericUse {T[]} - [array,$return]
*
- * @return {array} The shuffled array.
+ * @param {T[]} array - The array to shuffle. This array is modified in place.
+ *
+ * @return {T[]} The shuffled array.
*/
var Shuffle = function (array)
{
@@ -21256,12 +21488,12 @@ module.exports = Shuffle;
/***/ }),
-/* 113 */
+/* 115 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -21286,12 +21518,12 @@ module.exports = Linear;
/***/ }),
-/* 114 */
+/* 116 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -21455,19 +21687,19 @@ function init ()
module.exports = init();
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(701)))
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(720)))
/***/ }),
-/* 115 */
+/* 117 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var OS = __webpack_require__(114);
+var OS = __webpack_require__(116);
/**
* Determines the browser type and version running this Phaser Game instance.
@@ -21568,12 +21800,12 @@ module.exports = init();
/***/ }),
-/* 116 */
+/* 118 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -21598,12 +21830,12 @@ module.exports = IsSizePowerOfTwo;
/***/ }),
-/* 117 */
+/* 119 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -21613,22 +21845,22 @@ module.exports = IsSizePowerOfTwo;
module.exports = {
- ADD: __webpack_require__(748),
- ERROR: __webpack_require__(749),
- LOAD: __webpack_require__(750),
- READY: __webpack_require__(751),
- REMOVE: __webpack_require__(752)
+ ADD: __webpack_require__(771),
+ ERROR: __webpack_require__(772),
+ LOAD: __webpack_require__(773),
+ READY: __webpack_require__(774),
+ REMOVE: __webpack_require__(775)
};
/***/ }),
-/* 118 */
+/* 120 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -21681,12 +21913,12 @@ module.exports = AddToDOM;
/***/ }),
-/* 119 */
+/* 121 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -21772,12 +22004,12 @@ module.exports = Remove;
/***/ }),
-/* 120 */
+/* 122 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -22678,12 +22910,12 @@ module.exports = KeyCodes;
/***/ }),
-/* 121 */
+/* 123 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -22801,13 +23033,13 @@ module.exports = CONST;
/***/ }),
-/* 122 */
+/* 124 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
* @author Pavle Goloskokovic (http://prunegames.com)
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -23033,8 +23265,9 @@ var BaseSoundManager = new Class({
},
/**
- * Enables playing sound on the fly without the need to keep a reference to it.
- * Sound will auto destroy once its playback ends.
+ * Adds a new sound to the sound manager and plays it.
+ * The sound will be automatically removed (destroyed) once playback ends.
+ * This lets you play a new sound on the fly without the need to keep a reference to it.
*
* @method Phaser.Sound.BaseSoundManager#play
* @listens Phaser.Sound.Events#COMPLETE
@@ -23425,13 +23658,13 @@ module.exports = BaseSoundManager;
/***/ }),
-/* 123 */
+/* 125 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
* @author Pavle Goloskokovic (http://prunegames.com)
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -23925,19 +24158,19 @@ module.exports = BaseSound;
/***/ }),
-/* 124 */
+/* 126 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var ArrayUtils = __webpack_require__(180);
+var ArrayUtils = __webpack_require__(181);
var Class = __webpack_require__(0);
var NOOP = __webpack_require__(1);
-var StableSort = __webpack_require__(126);
+var StableSort = __webpack_require__(128);
/**
* @callback EachListCallback
@@ -24741,17 +24974,17 @@ module.exports = List;
/***/ }),
-/* 125 */
+/* 127 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var CheckMatrix = __webpack_require__(181);
-var TransposeMatrix = __webpack_require__(368);
+var CheckMatrix = __webpack_require__(182);
+var TransposeMatrix = __webpack_require__(382);
/**
* Rotates the array matrix based on the given rotation value.
@@ -24813,12 +25046,12 @@ module.exports = RotateMatrix;
/***/ }),
-/* 126 */
+/* 128 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -24958,27 +25191,27 @@ else {}
})();
/***/ }),
-/* 127 */
+/* 129 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var GameObject = __webpack_require__(14);
-var GetBitmapTextSize = __webpack_require__(927);
-var ParseFromAtlas = __webpack_require__(928);
-var ParseXMLBitmapFont = __webpack_require__(184);
-var Render = __webpack_require__(929);
+var GetBitmapTextSize = __webpack_require__(938);
+var ParseFromAtlas = __webpack_require__(939);
+var ParseXMLBitmapFont = __webpack_require__(185);
+var Render = __webpack_require__(940);
/**
* @classdesc
* BitmapText objects work by taking a texture file and an XML or JSON file that describes the font structure.
- *
+ *
* During rendering for each letter of the text is rendered to the display, proportionally spaced out and aligned to
* match the font structure.
*
@@ -25148,7 +25381,7 @@ var BitmapText = new Class({
/**
* Internal cache var holding the maxWidth.
- *
+ *
* @name Phaser.GameObjects.BitmapText#_maxWidth
* @type {number}
* @private
@@ -25394,7 +25627,7 @@ var BitmapText = new Class({
* If no whitespace was found then no wrapping will take place and consequently the `maxWidth` value will not be honored.
*
* Disable maxWidth by setting the value to 0.
- *
+ *
* You can set the whitespace character to be searched for by setting the `wordWrapCharCode` parameter or property.
*
* @method Phaser.GameObjects.BitmapText#setMaxWidth
@@ -25653,8 +25886,7 @@ BitmapText.ALIGN_RIGHT = 2;
*
* Adds the parsed Bitmap Font data to the cache with the `fontName` key.
*
- * @name Phaser.GameObjects.BitmapText.ParseFromAtlas
- * @type {function}
+ * @method Phaser.GameObjects.BitmapText.ParseFromAtlas
* @since 3.0.0
*
* @param {Phaser.Scene} scene - The Scene to parse the Bitmap Font for.
@@ -25672,8 +25904,7 @@ BitmapText.ParseFromAtlas = ParseFromAtlas;
/**
* Parse an XML font to Bitmap Font data for the Bitmap Font cache.
*
- * @name Phaser.GameObjects.BitmapText.ParseXMLBitmapFont
- * @type {function}
+ * @method Phaser.GameObjects.BitmapText.ParseXMLBitmapFont
* @since 3.17.0
*
* @param {XMLDocument} xml - The XML Document to parse the font from.
@@ -25689,19 +25920,19 @@ module.exports = BitmapText;
/***/ }),
-/* 128 */
+/* 130 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var GameObject = __webpack_require__(14);
-var MeshRender = __webpack_require__(1054);
+var MeshRender = __webpack_require__(1065);
var NOOP = __webpack_require__(1);
/**
@@ -25717,7 +25948,6 @@ var NOOP = __webpack_require__(1);
*
* @extends Phaser.GameObjects.Components.BlendMode
* @extends Phaser.GameObjects.Components.Depth
- * @extends Phaser.GameObjects.Components.GetBounds
* @extends Phaser.GameObjects.Components.Mask
* @extends Phaser.GameObjects.Components.Pipeline
* @extends Phaser.GameObjects.Components.Size
@@ -25743,7 +25973,6 @@ var Mesh = new Class({
Mixins: [
Components.BlendMode,
Components.Depth,
- Components.GetBounds,
Components.Mask,
Components.Pipeline,
Components.Size,
@@ -25862,12 +26091,12 @@ module.exports = Mesh;
/***/ }),
-/* 129 */
+/* 131 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -25900,12 +26129,12 @@ module.exports = RectangleToRectangle;
/***/ }),
-/* 130 */
+/* 132 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -25927,11 +26156,10 @@ var InputPluginCache = {};
* Plugin is the object to instantiate to create the plugin
* Mapping is what the plugin is injected into the Scene.Systems as (i.e. input)
*
- * @name Phaser.Input.InputPluginCache.register
- * @type {function}
+ * @function Phaser.Input.InputPluginCache.register
* @static
* @since 3.10.0
- *
+ *
* @param {string} key - A reference used to get this plugin from the plugin cache.
* @param {function} plugin - The plugin to be stored. Should be the core object, not instantiated.
* @param {string} mapping - If this plugin is to be injected into the Input Plugin, this is the property key used.
@@ -25946,11 +26174,10 @@ InputPluginCache.register = function (key, plugin, mapping, settingsKey, configK
/**
* Returns the input plugin object from the cache based on the given key.
*
- * @name Phaser.Input.InputPluginCache.getCore
- * @type {function}
+ * @function Phaser.Input.InputPluginCache.getCore
* @static
* @since 3.10.0
- *
+ *
* @param {string} key - The key of the input plugin to get.
*
* @return {Phaser.Types.Input.InputPluginContainer} The input plugin object.
@@ -25963,11 +26190,10 @@ InputPluginCache.getPlugin = function (key)
/**
* Installs all of the registered Input Plugins into the given target.
*
- * @name Phaser.Input.InputPluginCache.install
- * @type {function}
+ * @function Phaser.Input.InputPluginCache.install
* @static
* @since 3.10.0
- *
+ *
* @param {Phaser.Input.InputPlugin} target - The target InputPlugin to install the plugins into.
*/
InputPluginCache.install = function (target)
@@ -25993,11 +26219,10 @@ InputPluginCache.install = function (target)
/**
* Removes an input plugin based on the given key.
*
- * @name Phaser.Input.InputPluginCache.remove
- * @type {function}
+ * @function Phaser.Input.InputPluginCache.remove
* @static
* @since 3.10.0
- *
+ *
* @param {string} key - The key of the input plugin to remove.
*/
InputPluginCache.remove = function (key)
@@ -26012,12 +26237,12 @@ module.exports = InputPluginCache;
/***/ }),
-/* 131 */
+/* 133 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -26027,24 +26252,24 @@ module.exports = InputPluginCache;
module.exports = {
- ANY_KEY_DOWN: __webpack_require__(1192),
- ANY_KEY_UP: __webpack_require__(1193),
- COMBO_MATCH: __webpack_require__(1194),
- DOWN: __webpack_require__(1195),
- KEY_DOWN: __webpack_require__(1196),
- KEY_UP: __webpack_require__(1197),
- UP: __webpack_require__(1198)
+ ANY_KEY_DOWN: __webpack_require__(1203),
+ ANY_KEY_UP: __webpack_require__(1204),
+ COMBO_MATCH: __webpack_require__(1205),
+ DOWN: __webpack_require__(1206),
+ KEY_DOWN: __webpack_require__(1207),
+ KEY_UP: __webpack_require__(1208),
+ UP: __webpack_require__(1209)
};
/***/ }),
-/* 132 */
+/* 134 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -26080,12 +26305,12 @@ module.exports = GetURL;
/***/ }),
-/* 133 */
+/* 135 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -26144,17 +26369,17 @@ module.exports = XHRSettings;
/***/ }),
-/* 134 */
+/* 136 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var Components = __webpack_require__(213);
+var Components = __webpack_require__(214);
var Sprite = __webpack_require__(69);
/**
@@ -26245,13 +26470,12 @@ module.exports = ArcadeSprite;
/***/ }),
-/* 135 */,
-/* 136 */
+/* 137 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -26261,59 +26485,59 @@ module.exports = ArcadeSprite;
module.exports = {
- CalculateFacesAt: __webpack_require__(216),
+ CalculateFacesAt: __webpack_require__(217),
CalculateFacesWithin: __webpack_require__(51),
- Copy: __webpack_require__(1286),
- CreateFromTiles: __webpack_require__(1287),
- CullTiles: __webpack_require__(1288),
- Fill: __webpack_require__(1289),
- FilterTiles: __webpack_require__(1290),
- FindByIndex: __webpack_require__(1291),
- FindTile: __webpack_require__(1292),
- ForEachTile: __webpack_require__(1293),
- GetTileAt: __webpack_require__(137),
- GetTileAtWorldXY: __webpack_require__(1294),
+ Copy: __webpack_require__(1301),
+ CreateFromTiles: __webpack_require__(1302),
+ CullTiles: __webpack_require__(1303),
+ Fill: __webpack_require__(1304),
+ FilterTiles: __webpack_require__(1305),
+ FindByIndex: __webpack_require__(1306),
+ FindTile: __webpack_require__(1307),
+ ForEachTile: __webpack_require__(1308),
+ GetTileAt: __webpack_require__(138),
+ GetTileAtWorldXY: __webpack_require__(1309),
GetTilesWithin: __webpack_require__(24),
- GetTilesWithinShape: __webpack_require__(1295),
- GetTilesWithinWorldXY: __webpack_require__(1296),
- HasTileAt: __webpack_require__(456),
- HasTileAtWorldXY: __webpack_require__(1297),
+ GetTilesWithinShape: __webpack_require__(1310),
+ GetTilesWithinWorldXY: __webpack_require__(1311),
+ HasTileAt: __webpack_require__(470),
+ HasTileAtWorldXY: __webpack_require__(1312),
IsInLayerBounds: __webpack_require__(103),
- PutTileAt: __webpack_require__(217),
- PutTileAtWorldXY: __webpack_require__(1298),
- PutTilesAt: __webpack_require__(1299),
- Randomize: __webpack_require__(1300),
- RemoveTileAt: __webpack_require__(457),
- RemoveTileAtWorldXY: __webpack_require__(1301),
- RenderDebug: __webpack_require__(1302),
- ReplaceByIndex: __webpack_require__(455),
- SetCollision: __webpack_require__(1303),
- SetCollisionBetween: __webpack_require__(1304),
- SetCollisionByExclusion: __webpack_require__(1305),
- SetCollisionByProperty: __webpack_require__(1306),
- SetCollisionFromCollisionGroup: __webpack_require__(1307),
- SetTileIndexCallback: __webpack_require__(1308),
- SetTileLocationCallback: __webpack_require__(1309),
- Shuffle: __webpack_require__(1310),
- SwapByIndex: __webpack_require__(1311),
- TileToWorldX: __webpack_require__(138),
- TileToWorldXY: __webpack_require__(1312),
- TileToWorldY: __webpack_require__(139),
- WeightedRandomize: __webpack_require__(1313),
+ PutTileAt: __webpack_require__(218),
+ PutTileAtWorldXY: __webpack_require__(1313),
+ PutTilesAt: __webpack_require__(1314),
+ Randomize: __webpack_require__(1315),
+ RemoveTileAt: __webpack_require__(471),
+ RemoveTileAtWorldXY: __webpack_require__(1316),
+ RenderDebug: __webpack_require__(1317),
+ ReplaceByIndex: __webpack_require__(469),
+ SetCollision: __webpack_require__(1318),
+ SetCollisionBetween: __webpack_require__(1319),
+ SetCollisionByExclusion: __webpack_require__(1320),
+ SetCollisionByProperty: __webpack_require__(1321),
+ SetCollisionFromCollisionGroup: __webpack_require__(1322),
+ SetTileIndexCallback: __webpack_require__(1323),
+ SetTileLocationCallback: __webpack_require__(1324),
+ Shuffle: __webpack_require__(1325),
+ SwapByIndex: __webpack_require__(1326),
+ TileToWorldX: __webpack_require__(139),
+ TileToWorldXY: __webpack_require__(1327),
+ TileToWorldY: __webpack_require__(140),
+ WeightedRandomize: __webpack_require__(1328),
WorldToTileX: __webpack_require__(63),
- WorldToTileXY: __webpack_require__(1314),
+ WorldToTileXY: __webpack_require__(1329),
WorldToTileY: __webpack_require__(64)
};
/***/ }),
-/* 137 */
+/* 138 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -26364,12 +26588,12 @@ module.exports = GetTileAt;
/***/ }),
-/* 138 */
+/* 139 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -26409,12 +26633,12 @@ module.exports = TileToWorldX;
/***/ }),
-/* 139 */
+/* 140 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -26454,12 +26678,12 @@ module.exports = TileToWorldY;
/***/ }),
-/* 140 */
+/* 141 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -26858,12 +27082,12 @@ module.exports = Tileset;
/***/ }),
-/* 141 */
+/* 142 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -26922,26 +27146,26 @@ module.exports = GetNewValue;
/***/ }),
-/* 142 */
+/* 143 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var Defaults = __webpack_require__(226);
+var Defaults = __webpack_require__(227);
var GetAdvancedValue = __webpack_require__(15);
var GetBoolean = __webpack_require__(88);
var GetEaseFunction = __webpack_require__(82);
-var GetNewValue = __webpack_require__(141);
-var GetProps = __webpack_require__(478);
-var GetTargets = __webpack_require__(224);
+var GetNewValue = __webpack_require__(142);
+var GetProps = __webpack_require__(492);
+var GetTargets = __webpack_require__(225);
var GetValue = __webpack_require__(6);
-var GetValueOp = __webpack_require__(225);
-var Tween = __webpack_require__(227);
-var TweenData = __webpack_require__(229);
+var GetValueOp = __webpack_require__(226);
+var Tween = __webpack_require__(228);
+var TweenData = __webpack_require__(230);
/**
* Creates a new Tween.
@@ -27055,146 +27279,47 @@ module.exports = TweenBuilder;
/***/ }),
-/* 143 */
+/* 144 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var ALIGN_CONST = {
-
- /**
- * A constant representing a top-left alignment or position.
- * @constant
- * @name Phaser.Display.Align.TOP_LEFT
- * @since 3.0.0
- * @type {integer}
- */
- TOP_LEFT: 0,
-
- /**
- * A constant representing a top-center alignment or position.
- * @constant
- * @name Phaser.Display.Align.TOP_CENTER
- * @since 3.0.0
- * @type {integer}
- */
- TOP_CENTER: 1,
-
- /**
- * A constant representing a top-right alignment or position.
- * @constant
- * @name Phaser.Display.Align.TOP_RIGHT
- * @since 3.0.0
- * @type {integer}
- */
- TOP_RIGHT: 2,
-
- /**
- * A constant representing a left-top alignment or position.
- * @constant
- * @name Phaser.Display.Align.LEFT_TOP
- * @since 3.0.0
- * @type {integer}
- */
- LEFT_TOP: 3,
-
- /**
- * A constant representing a left-center alignment or position.
- * @constant
- * @name Phaser.Display.Align.LEFT_CENTER
- * @since 3.0.0
- * @type {integer}
- */
- LEFT_CENTER: 4,
-
- /**
- * A constant representing a left-bottom alignment or position.
- * @constant
- * @name Phaser.Display.Align.LEFT_BOTTOM
- * @since 3.0.0
- * @type {integer}
- */
- LEFT_BOTTOM: 5,
-
- /**
- * A constant representing a center alignment or position.
- * @constant
- * @name Phaser.Display.Align.CENTER
- * @since 3.0.0
- * @type {integer}
- */
- CENTER: 6,
-
- /**
- * A constant representing a right-top alignment or position.
- * @constant
- * @name Phaser.Display.Align.RIGHT_TOP
- * @since 3.0.0
- * @type {integer}
- */
- RIGHT_TOP: 7,
-
- /**
- * A constant representing a right-center alignment or position.
- * @constant
- * @name Phaser.Display.Align.RIGHT_CENTER
- * @since 3.0.0
- * @type {integer}
- */
- RIGHT_CENTER: 8,
-
- /**
- * A constant representing a right-bottom alignment or position.
- * @constant
- * @name Phaser.Display.Align.RIGHT_BOTTOM
- * @since 3.0.0
- * @type {integer}
- */
- RIGHT_BOTTOM: 9,
-
- /**
- * A constant representing a bottom-left alignment or position.
- * @constant
- * @name Phaser.Display.Align.BOTTOM_LEFT
- * @since 3.0.0
- * @type {integer}
- */
- BOTTOM_LEFT: 10,
-
- /**
- * A constant representing a bottom-center alignment or position.
- * @constant
- * @name Phaser.Display.Align.BOTTOM_CENTER
- * @since 3.0.0
- * @type {integer}
- */
- BOTTOM_CENTER: 11,
-
- /**
- * A constant representing a bottom-right alignment or position.
- * @constant
- * @name Phaser.Display.Align.BOTTOM_RIGHT
- * @since 3.0.0
- * @type {integer}
- */
- BOTTOM_RIGHT: 12
+/**
+ * Check whether the given values are fuzzily equal.
+ *
+ * Two numbers are fuzzily equal if their difference is less than `epsilon`.
+ *
+ * @function Phaser.Math.Fuzzy.Equal
+ * @since 3.0.0
+ *
+ * @param {number} a - The first value.
+ * @param {number} b - The second value.
+ * @param {number} [epsilon=0.0001] - The epsilon.
+ *
+ * @return {boolean} `true` if the values are fuzzily equal, otherwise `false`.
+ */
+var Equal = function (a, b, epsilon)
+{
+ if (epsilon === undefined) { epsilon = 0.0001; }
+ return Math.abs(a - b) < epsilon;
};
-module.exports = ALIGN_CONST;
+module.exports = Equal;
/***/ }),
-/* 144 */
+/* 145 */,
+/* 146 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -27228,12 +27353,12 @@ module.exports = CircumferencePoint;
/***/ }),
-/* 145 */
+/* 147 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -27272,21 +27397,21 @@ module.exports = Random;
/***/ }),
-/* 146 */
+/* 148 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var Clamp = __webpack_require__(23);
+var Clamp = __webpack_require__(22);
var Class = __webpack_require__(0);
var EventEmitter = __webpack_require__(9);
-var Events = __webpack_require__(109);
-var FindClosestInSorted = __webpack_require__(253);
-var Frame = __webpack_require__(254);
+var Events = __webpack_require__(111);
+var FindClosestInSorted = __webpack_require__(267);
+var Frame = __webpack_require__(268);
var GetValue = __webpack_require__(6);
/**
@@ -28225,16 +28350,16 @@ module.exports = Animation;
/***/ }),
-/* 147 */
+/* 149 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var Perimeter = __webpack_require__(110);
+var Perimeter = __webpack_require__(112);
var Point = __webpack_require__(4);
/**
@@ -28302,16 +28427,16 @@ module.exports = GetPoint;
/***/ }),
-/* 148 */
+/* 150 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var Length = __webpack_require__(56);
+var Length = __webpack_require__(57);
var Point = __webpack_require__(4);
/**
@@ -28367,12 +28492,12 @@ module.exports = GetPoints;
/***/ }),
-/* 149 */
+/* 151 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -28407,12 +28532,12 @@ module.exports = Random;
/***/ }),
-/* 150 */
+/* 152 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -28445,12 +28570,12 @@ module.exports = Random;
/***/ }),
-/* 151 */
+/* 153 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -28574,12 +28699,12 @@ module.exports = Pipeline;
/***/ }),
-/* 152 */
+/* 154 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -28615,12 +28740,12 @@ module.exports = Random;
/***/ }),
-/* 153 */
+/* 155 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -28671,12 +28796,12 @@ module.exports = Random;
/***/ }),
-/* 154 */
+/* 156 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -28708,12 +28833,12 @@ module.exports = RotateAroundDistance;
/***/ }),
-/* 155 */
+/* 157 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -28747,12 +28872,12 @@ module.exports = SmootherStep;
/***/ }),
-/* 156 */
+/* 158 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -28794,12 +28919,12 @@ module.exports = SmoothStep;
/***/ }),
-/* 157 */
+/* 159 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -29167,12 +29292,12 @@ module.exports = Map;
/***/ }),
-/* 158 */
+/* 160 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -29243,19 +29368,19 @@ module.exports = Pad;
/***/ }),
-/* 159 */
+/* 161 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var HexStringToColor = __webpack_require__(277);
-var IntegerToColor = __webpack_require__(280);
-var ObjectToColor = __webpack_require__(282);
-var RGBStringToColor = __webpack_require__(283);
+var HexStringToColor = __webpack_require__(291);
+var IntegerToColor = __webpack_require__(294);
+var ObjectToColor = __webpack_require__(296);
+var RGBStringToColor = __webpack_require__(297);
/**
* Converts the given source color value into an instance of a Color class.
@@ -29299,12 +29424,12 @@ module.exports = ValueToColor;
/***/ }),
-/* 160 */
+/* 162 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -29329,16 +29454,16 @@ module.exports = GetColor;
/***/ }),
-/* 161 */
+/* 163 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var GetColor = __webpack_require__(160);
+var GetColor = __webpack_require__(162);
/**
* Converts an HSV (hue, saturation and value) color value to RGB.
@@ -29430,12 +29555,12 @@ module.exports = HSVToRGB;
/***/ }),
-/* 162 */
+/* 164 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -29562,12 +29687,12 @@ module.exports = Smoothing();
/***/ }),
-/* 163 */
+/* 165 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -29599,27 +29724,27 @@ module.exports = CenterOn;
/***/ }),
-/* 164 */
+/* 166 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var Back = __webpack_require__(285);
-var Bounce = __webpack_require__(286);
-var Circular = __webpack_require__(287);
-var Cubic = __webpack_require__(288);
-var Elastic = __webpack_require__(289);
-var Expo = __webpack_require__(290);
-var Linear = __webpack_require__(291);
-var Quadratic = __webpack_require__(292);
-var Quartic = __webpack_require__(293);
-var Quintic = __webpack_require__(294);
-var Sine = __webpack_require__(295);
-var Stepped = __webpack_require__(296);
+var Back = __webpack_require__(299);
+var Bounce = __webpack_require__(300);
+var Circular = __webpack_require__(301);
+var Cubic = __webpack_require__(302);
+var Elastic = __webpack_require__(303);
+var Expo = __webpack_require__(304);
+var Linear = __webpack_require__(305);
+var Quadratic = __webpack_require__(306);
+var Quartic = __webpack_require__(307);
+var Quintic = __webpack_require__(308);
+var Sine = __webpack_require__(309);
+var Stepped = __webpack_require__(310);
// EaseMap
module.exports = {
@@ -29680,17 +29805,17 @@ module.exports = {
/***/ }),
-/* 165 */
+/* 167 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var OS = __webpack_require__(114);
-var Browser = __webpack_require__(115);
+var OS = __webpack_require__(116);
+var Browser = __webpack_require__(117);
var CanvasPool = __webpack_require__(26);
/**
@@ -29872,12 +29997,12 @@ module.exports = init();
/***/ }),
-/* 166 */
+/* 168 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -29891,62 +30016,62 @@ var Extend = __webpack_require__(17);
var PhaserMath = {
// Collections of functions
- Angle: __webpack_require__(706),
- Distance: __webpack_require__(714),
- Easing: __webpack_require__(716),
- Fuzzy: __webpack_require__(717),
- Interpolation: __webpack_require__(720),
- Pow2: __webpack_require__(725),
- Snap: __webpack_require__(727),
+ Angle: __webpack_require__(725),
+ Distance: __webpack_require__(733),
+ Easing: __webpack_require__(739),
+ Fuzzy: __webpack_require__(740),
+ Interpolation: __webpack_require__(743),
+ Pow2: __webpack_require__(748),
+ Snap: __webpack_require__(750),
// Expose the RNG Class
- RandomDataGenerator: __webpack_require__(729),
+ RandomDataGenerator: __webpack_require__(752),
// Single functions
- Average: __webpack_require__(730),
- Bernstein: __webpack_require__(305),
- Between: __webpack_require__(169),
- CatmullRom: __webpack_require__(168),
- CeilTo: __webpack_require__(731),
- Clamp: __webpack_require__(23),
+ Average: __webpack_require__(753),
+ Bernstein: __webpack_require__(319),
+ Between: __webpack_require__(170),
+ CatmullRom: __webpack_require__(169),
+ CeilTo: __webpack_require__(754),
+ Clamp: __webpack_require__(22),
DegToRad: __webpack_require__(35),
- Difference: __webpack_require__(732),
- Factorial: __webpack_require__(306),
- FloatBetween: __webpack_require__(312),
- FloorTo: __webpack_require__(733),
+ Difference: __webpack_require__(755),
+ Factorial: __webpack_require__(320),
+ FloatBetween: __webpack_require__(326),
+ FloorTo: __webpack_require__(756),
FromPercent: __webpack_require__(87),
- GetSpeed: __webpack_require__(734),
- IsEven: __webpack_require__(735),
- IsEvenStrict: __webpack_require__(736),
- Linear: __webpack_require__(113),
- MaxAdd: __webpack_require__(737),
- MinSub: __webpack_require__(738),
- Percent: __webpack_require__(739),
- RadToDeg: __webpack_require__(170),
- RandomXY: __webpack_require__(740),
- RandomXYZ: __webpack_require__(741),
- RandomXYZW: __webpack_require__(742),
- Rotate: __webpack_require__(313),
- RotateAround: __webpack_require__(259),
- RotateAroundDistance: __webpack_require__(154),
- RoundAwayFromZero: __webpack_require__(314),
- RoundTo: __webpack_require__(743),
- SinCosTableGenerator: __webpack_require__(744),
- SmootherStep: __webpack_require__(155),
- SmoothStep: __webpack_require__(156),
- ToXY: __webpack_require__(745),
- TransformXY: __webpack_require__(315),
- Within: __webpack_require__(746),
- Wrap: __webpack_require__(57),
+ GetSpeed: __webpack_require__(757),
+ IsEven: __webpack_require__(758),
+ IsEvenStrict: __webpack_require__(759),
+ Linear: __webpack_require__(115),
+ MaxAdd: __webpack_require__(760),
+ MinSub: __webpack_require__(761),
+ Percent: __webpack_require__(762),
+ RadToDeg: __webpack_require__(171),
+ RandomXY: __webpack_require__(763),
+ RandomXYZ: __webpack_require__(764),
+ RandomXYZW: __webpack_require__(765),
+ Rotate: __webpack_require__(327),
+ RotateAround: __webpack_require__(273),
+ RotateAroundDistance: __webpack_require__(156),
+ RoundAwayFromZero: __webpack_require__(328),
+ RoundTo: __webpack_require__(766),
+ SinCosTableGenerator: __webpack_require__(767),
+ SmootherStep: __webpack_require__(157),
+ SmoothStep: __webpack_require__(158),
+ ToXY: __webpack_require__(768),
+ TransformXY: __webpack_require__(329),
+ Within: __webpack_require__(769),
+ Wrap: __webpack_require__(58),
// Vector classes
Vector2: __webpack_require__(3),
- Vector3: __webpack_require__(171),
- Vector4: __webpack_require__(316),
- Matrix3: __webpack_require__(317),
- Matrix4: __webpack_require__(318),
- Quaternion: __webpack_require__(319),
- RotateVec3: __webpack_require__(747)
+ Vector3: __webpack_require__(172),
+ Vector4: __webpack_require__(330),
+ Matrix3: __webpack_require__(331),
+ Matrix4: __webpack_require__(332),
+ Quaternion: __webpack_require__(333),
+ RotateVec3: __webpack_require__(770)
};
@@ -29960,46 +30085,12 @@ module.exports = PhaserMath;
/***/ }),
-/* 167 */
+/* 169 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
- * @license {@link https://opensource.org/licenses/MIT|MIT License}
- */
-
-/**
- * Check whether the given values are fuzzily equal.
- *
- * Two numbers are fuzzily equal if their difference is less than `epsilon`.
- *
- * @function Phaser.Math.Fuzzy.Equal
- * @since 3.0.0
- *
- * @param {number} a - The first value.
- * @param {number} b - The second value.
- * @param {number} [epsilon=0.0001] - The epsilon.
- *
- * @return {boolean} `true` if the values are fuzzily equal, otherwise `false`.
- */
-var Equal = function (a, b, epsilon)
-{
- if (epsilon === undefined) { epsilon = 0.0001; }
-
- return Math.abs(a - b) < epsilon;
-};
-
-module.exports = Equal;
-
-
-/***/ }),
-/* 168 */
-/***/ (function(module, exports) {
-
-/**
- * @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -30031,12 +30122,12 @@ module.exports = CatmullRom;
/***/ }),
-/* 169 */
+/* 170 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -30060,12 +30151,12 @@ module.exports = Between;
/***/ }),
-/* 170 */
+/* 171 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -30090,12 +30181,12 @@ module.exports = RadToDeg;
/***/ }),
-/* 171 */
+/* 172 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -30900,12 +30991,12 @@ module.exports = Vector3;
/***/ }),
-/* 172 */
+/* 173 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -31001,12 +31092,12 @@ module.exports = DefaultPlugins;
/***/ }),
-/* 173 */
+/* 174 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -31087,21 +31178,21 @@ module.exports = FromPoints;
/***/ }),
-/* 174 */
+/* 175 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var CONST = {
- CENTER: __webpack_require__(339),
- ORIENTATION: __webpack_require__(340),
- SCALE_MODE: __webpack_require__(341),
- ZOOM: __webpack_require__(342)
+ CENTER: __webpack_require__(353),
+ ORIENTATION: __webpack_require__(354),
+ SCALE_MODE: __webpack_require__(355),
+ ZOOM: __webpack_require__(356)
};
@@ -31109,12 +31200,12 @@ module.exports = CONST;
/***/ }),
-/* 175 */
+/* 176 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -31138,12 +31229,12 @@ module.exports = RemoveFromDOM;
/***/ }),
-/* 176 */
+/* 177 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -31236,23 +31327,23 @@ module.exports = INPUT_CONST;
/***/ }),
-/* 177 */
+/* 178 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var CONST = __webpack_require__(121);
-var DefaultPlugins = __webpack_require__(172);
-var Events = __webpack_require__(22);
-var GetPhysicsPlugins = __webpack_require__(860);
-var GetScenePlugins = __webpack_require__(861);
+var CONST = __webpack_require__(123);
+var DefaultPlugins = __webpack_require__(173);
+var Events = __webpack_require__(19);
+var GetPhysicsPlugins = __webpack_require__(871);
+var GetScenePlugins = __webpack_require__(872);
var NOOP = __webpack_require__(1);
-var Settings = __webpack_require__(355);
+var Settings = __webpack_require__(369);
/**
* @classdesc
@@ -31712,8 +31803,8 @@ var Systems = new Class({
/**
* 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
+ * A sleeping Scene doesn't run its update step or render anything, but it also isn't shut down
+ * or has 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.
*
@@ -31767,6 +31858,22 @@ var Systems = new Class({
return this;
},
+ /**
+ * Returns any data that was sent to this Scene by another Scene.
+ *
+ * The data is also passed to `Scene.init` and in various Scene events, but
+ * you can access it at any point via this method.
+ *
+ * @method Phaser.Scenes.Systems#getData
+ * @since 3.22.0
+ *
+ * @return {any}
+ */
+ getData: function ()
+ {
+ return this.settings.data;
+ },
+
/**
* Is this Scene sleeping?
*
@@ -31994,12 +32101,12 @@ module.exports = Systems;
/***/ }),
-/* 178 */
+/* 179 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -32031,18 +32138,18 @@ module.exports = UppercaseFirst;
/***/ }),
-/* 179 */
+/* 180 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Frame = __webpack_require__(94);
-var TextureSource = __webpack_require__(358);
+var TextureSource = __webpack_require__(372);
var TEXTURE_MISSING_ERROR = 'Texture.frame missing: ';
@@ -32551,12 +32658,12 @@ module.exports = Texture;
/***/ }),
-/* 180 */
+/* 181 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -32566,50 +32673,50 @@ module.exports = Texture;
module.exports = {
- Matrix: __webpack_require__(896),
+ Matrix: __webpack_require__(907),
- Add: __webpack_require__(903),
- AddAt: __webpack_require__(904),
- BringToTop: __webpack_require__(905),
- CountAllMatching: __webpack_require__(906),
- Each: __webpack_require__(907),
- EachInRange: __webpack_require__(908),
- FindClosestInSorted: __webpack_require__(253),
- GetAll: __webpack_require__(909),
- GetFirst: __webpack_require__(910),
- GetRandom: __webpack_require__(182),
- MoveDown: __webpack_require__(911),
- MoveTo: __webpack_require__(912),
- MoveUp: __webpack_require__(913),
- NumberArray: __webpack_require__(914),
- NumberArrayStep: __webpack_require__(915),
- QuickSelect: __webpack_require__(369),
- Range: __webpack_require__(370),
- Remove: __webpack_require__(119),
- RemoveAt: __webpack_require__(916),
- RemoveBetween: __webpack_require__(917),
- RemoveRandomElement: __webpack_require__(918),
- Replace: __webpack_require__(919),
- RotateLeft: __webpack_require__(269),
- RotateRight: __webpack_require__(270),
+ Add: __webpack_require__(914),
+ AddAt: __webpack_require__(915),
+ BringToTop: __webpack_require__(916),
+ CountAllMatching: __webpack_require__(917),
+ Each: __webpack_require__(918),
+ EachInRange: __webpack_require__(919),
+ FindClosestInSorted: __webpack_require__(267),
+ GetAll: __webpack_require__(920),
+ GetFirst: __webpack_require__(921),
+ GetRandom: __webpack_require__(183),
+ MoveDown: __webpack_require__(922),
+ MoveTo: __webpack_require__(923),
+ MoveUp: __webpack_require__(924),
+ NumberArray: __webpack_require__(925),
+ NumberArrayStep: __webpack_require__(926),
+ QuickSelect: __webpack_require__(383),
+ Range: __webpack_require__(384),
+ Remove: __webpack_require__(121),
+ RemoveAt: __webpack_require__(927),
+ RemoveBetween: __webpack_require__(928),
+ RemoveRandomElement: __webpack_require__(929),
+ Replace: __webpack_require__(930),
+ RotateLeft: __webpack_require__(283),
+ RotateRight: __webpack_require__(284),
SafeRange: __webpack_require__(68),
- SendToBack: __webpack_require__(920),
- SetAll: __webpack_require__(921),
- Shuffle: __webpack_require__(112),
+ SendToBack: __webpack_require__(931),
+ SetAll: __webpack_require__(932),
+ Shuffle: __webpack_require__(114),
SpliceOne: __webpack_require__(79),
- StableSort: __webpack_require__(126),
- Swap: __webpack_require__(922)
+ StableSort: __webpack_require__(128),
+ Swap: __webpack_require__(933)
};
/***/ }),
-/* 181 */
+/* 182 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -32665,12 +32772,12 @@ module.exports = CheckMatrix;
/***/ }),
-/* 182 */
+/* 183 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -32700,18 +32807,18 @@ module.exports = GetRandom;
/***/ }),
-/* 183 */
+/* 184 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var EventEmitter = __webpack_require__(9);
-var Events = __webpack_require__(924);
+var Events = __webpack_require__(935);
/**
* @classdesc
@@ -32991,12 +33098,12 @@ module.exports = ProcessQueue;
/***/ }),
-/* 184 */
+/* 185 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -33130,22 +33237,22 @@ module.exports = ParseXMLBitmapFont;
/***/ }),
-/* 185 */
+/* 186 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var BlitterRender = __webpack_require__(932);
-var Bob = __webpack_require__(935);
+var BlitterRender = __webpack_require__(943);
+var Bob = __webpack_require__(946);
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var Frame = __webpack_require__(94);
var GameObject = __webpack_require__(14);
-var List = __webpack_require__(124);
+var List = __webpack_require__(126);
/**
* @callback CreateCallback
@@ -33429,25 +33536,25 @@ module.exports = Blitter;
/***/ }),
-/* 186 */
+/* 187 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
* @author Felipe Alfonso <@bitnenfer>
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var ArrayUtils = __webpack_require__(180);
+var ArrayUtils = __webpack_require__(181);
var BlendModes = __webpack_require__(52);
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var Events = __webpack_require__(90);
var GameObject = __webpack_require__(14);
var Rectangle = __webpack_require__(11);
-var Render = __webpack_require__(936);
-var Union = __webpack_require__(372);
+var Render = __webpack_require__(947);
+var Union = __webpack_require__(386);
var Vector2 = __webpack_require__(3);
/**
@@ -33492,7 +33599,7 @@ var Vector2 = __webpack_require__(3);
* @constructor
* @since 3.4.0
*
- * @extends Phaser.GameObjects.Components.Alpha
+ * @extends Phaser.GameObjects.Components.AlphaSingle
* @extends Phaser.GameObjects.Components.BlendMode
* @extends Phaser.GameObjects.Components.ComputedSize
* @extends Phaser.GameObjects.Components.Depth
@@ -33510,7 +33617,7 @@ var Container = new Class({
Extends: GameObject,
Mixins: [
- Components.Alpha,
+ Components.AlphaSingle,
Components.BlendMode,
Components.ComputedSize,
Components.Depth,
@@ -34754,18 +34861,18 @@ module.exports = Container;
/***/ }),
-/* 187 */
+/* 188 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var BitmapText = __webpack_require__(127);
+var BitmapText = __webpack_require__(129);
var Class = __webpack_require__(0);
-var Render = __webpack_require__(941);
+var Render = __webpack_require__(952);
/**
* @classdesc
@@ -34987,26 +35094,26 @@ module.exports = DynamicBitmapText;
/***/ }),
-/* 188 */
+/* 189 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var BaseCamera = __webpack_require__(91);
var Class = __webpack_require__(0);
-var Commands = __webpack_require__(189);
-var ComponentsAlpha = __webpack_require__(252);
-var ComponentsBlendMode = __webpack_require__(255);
-var ComponentsDepth = __webpack_require__(256);
-var ComponentsMask = __webpack_require__(260);
-var ComponentsPipeline = __webpack_require__(151);
-var ComponentsTransform = __webpack_require__(265);
-var ComponentsVisible = __webpack_require__(266);
-var ComponentsScrollFactor = __webpack_require__(263);
+var Commands = __webpack_require__(190);
+var ComponentsAlpha = __webpack_require__(266);
+var ComponentsBlendMode = __webpack_require__(269);
+var ComponentsDepth = __webpack_require__(270);
+var ComponentsMask = __webpack_require__(274);
+var ComponentsPipeline = __webpack_require__(153);
+var ComponentsTransform = __webpack_require__(279);
+var ComponentsVisible = __webpack_require__(280);
+var ComponentsScrollFactor = __webpack_require__(277);
var TransformMatrix = __webpack_require__(32);
@@ -35015,7 +35122,7 @@ var GameObject = __webpack_require__(14);
var GetFastValue = __webpack_require__(2);
var GetValue = __webpack_require__(6);
var MATH_CONST = __webpack_require__(13);
-var Render = __webpack_require__(947);
+var Render = __webpack_require__(958);
/**
* @classdesc
@@ -35064,7 +35171,7 @@ var Render = __webpack_require__(947);
* @constructor
* @since 3.0.0
*
- * @extends Phaser.GameObjects.Components.Alpha
+ * @extends Phaser.GameObjects.Components.AlphaSingle
* @extends Phaser.GameObjects.Components.BlendMode
* @extends Phaser.GameObjects.Components.Depth
* @extends Phaser.GameObjects.Components.Mask
@@ -36537,12 +36644,12 @@ module.exports = Graphics;
/***/ }),
-/* 189 */
+/* 190 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -36574,12 +36681,12 @@ module.exports = {
/***/ }),
-/* 190 */
+/* 191 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -36616,22 +36723,22 @@ module.exports = CircumferencePoint;
/***/ }),
-/* 191 */
+/* 192 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var GameObject = __webpack_require__(14);
-var GravityWell = __webpack_require__(380);
-var List = __webpack_require__(124);
-var ParticleEmitter = __webpack_require__(382);
-var Render = __webpack_require__(957);
+var GravityWell = __webpack_require__(394);
+var List = __webpack_require__(126);
+var ParticleEmitter = __webpack_require__(396);
+var Render = __webpack_require__(968);
/**
* @classdesc
@@ -36898,6 +37005,21 @@ var ParticleEmitterManager = new Class({
return this.addEmitter(new ParticleEmitter(this, config));
},
+ /**
+ * Removes a Particle Emitter from this Emitter Manager, if the Emitter belongs to this Manager.
+ *
+ * @method Phaser.GameObjects.Particles.ParticleEmitterManager#removeEmitter
+ * @since 3.22.0
+ *
+ * @param {Phaser.GameObjects.Particles.ParticleEmitter} emitter
+ *
+ * @return {?Phaser.GameObjects.Particles.ParticleEmitter} The Particle Emitter if it was removed or null if it was not.
+ */
+ removeEmitter: function (emitter)
+ {
+ return this.emitters.remove(emitter, true);
+ },
+
/**
* Adds an existing Gravity Well object to this Emitter Manager.
*
@@ -37090,12 +37212,12 @@ module.exports = ParticleEmitterManager;
/***/ }),
-/* 192 */
+/* 193 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -37107,9 +37229,9 @@ var Components = __webpack_require__(12);
var CONST = __webpack_require__(29);
var Frame = __webpack_require__(94);
var GameObject = __webpack_require__(14);
-var Render = __webpack_require__(961);
+var Render = __webpack_require__(972);
var Utils = __webpack_require__(10);
-var UUID = __webpack_require__(193);
+var UUID = __webpack_require__(194);
/**
* @classdesc
@@ -37133,6 +37255,7 @@ var UUID = __webpack_require__(193);
* @extends Phaser.GameObjects.Components.Alpha
* @extends Phaser.GameObjects.Components.BlendMode
* @extends Phaser.GameObjects.Components.ComputedSize
+ * @extends Phaser.GameObjects.Components.Crop
* @extends Phaser.GameObjects.Components.Depth
* @extends Phaser.GameObjects.Components.Flip
* @extends Phaser.GameObjects.Components.GetBounds
@@ -38328,12 +38451,12 @@ module.exports = RenderTexture;
/***/ }),
-/* 193 */
+/* 194 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -38363,26 +38486,26 @@ module.exports = UUID;
/***/ }),
-/* 194 */
+/* 195 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var AddToDOM = __webpack_require__(118);
+var AddToDOM = __webpack_require__(120);
var CanvasPool = __webpack_require__(26);
var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var GameEvents = __webpack_require__(18);
var GameObject = __webpack_require__(14);
-var GetTextSize = __webpack_require__(967);
+var GetTextSize = __webpack_require__(978);
var GetValue = __webpack_require__(6);
-var RemoveFromDOM = __webpack_require__(175);
-var TextRender = __webpack_require__(968);
-var TextStyle = __webpack_require__(971);
+var RemoveFromDOM = __webpack_require__(176);
+var TextRender = __webpack_require__(979);
+var TextStyle = __webpack_require__(982);
/**
* @classdesc
@@ -38653,7 +38776,7 @@ var Text = new Class({
if (style && style.lineSpacing)
{
- this.lineSpacing = style.lineSpacing;
+ this.setLineSpacing(style.lineSpacing);
}
scene.sys.game.events.on(GameEvents.CONTEXT_RESTORED, function ()
@@ -38876,16 +38999,20 @@ var Text = new Class({
{
var result = '';
var lines = text.split(this.splitRegExp);
+ var lastLineIndex = lines.length - 1;
+ var whiteSpaceWidth = context.measureText(' ').width;
- for (var i = 0; i < lines.length; i++)
+ for (var i = 0; i <= lastLineIndex; i++)
{
var spaceLeft = wordWrapWidth;
var words = lines[i].split(' ');
+ var lastWordIndex = words.length - 1;
- for (var j = 0; j < words.length; j++)
+ for (var j = 0; j <= lastWordIndex; j++)
{
- var wordWidth = context.measureText(words[j]).width;
- var wordWidthWithSpace = wordWidth + context.measureText(' ').width;
+ var word = words[j];
+ var wordWidth = context.measureText(word).width;
+ var wordWidthWithSpace = wordWidth + whiteSpaceWidth;
if (wordWidthWithSpace > spaceLeft)
{
@@ -38894,24 +39021,24 @@ var Text = new Class({
if (j > 0)
{
result += '\n';
+ spaceLeft = wordWrapWidth;
}
+ }
- result += words[j] + ' ';
- spaceLeft = wordWrapWidth - wordWidthWithSpace;
+ result += word;
+
+ if (j < lastWordIndex)
+ {
+ result += ' ';
+ spaceLeft -= wordWidthWithSpace;
}
else
{
- spaceLeft -= wordWidthWithSpace;
- result += words[j];
-
- if (j < (words.length - 1))
- {
- result += ' ';
- }
+ spaceLeft -= wordWidth;
}
}
- if (i < lines.length - 1)
+ if (i < lastLineIndex)
{
result += '\n';
}
@@ -39768,12 +39895,12 @@ module.exports = Text;
/***/ }),
-/* 195 */
+/* 196 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -39782,9 +39909,9 @@ var Class = __webpack_require__(0);
var Components = __webpack_require__(12);
var GameEvents = __webpack_require__(18);
var GameObject = __webpack_require__(14);
-var GetPowerOfTwo = __webpack_require__(310);
-var Smoothing = __webpack_require__(162);
-var TileSpriteRender = __webpack_require__(973);
+var GetPowerOfTwo = __webpack_require__(324);
+var Smoothing = __webpack_require__(164);
+var TileSpriteRender = __webpack_require__(984);
var Vector2 = __webpack_require__(3);
// bitmask flag for GameObject.renderMask
@@ -40420,24 +40547,24 @@ module.exports = TileSprite;
/***/ }),
-/* 196 */
+/* 197 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var Clamp = __webpack_require__(23);
+var Clamp = __webpack_require__(22);
var Components = __webpack_require__(12);
var Events = __webpack_require__(90);
var GameEvents = __webpack_require__(18);
var GameObject = __webpack_require__(14);
var SoundEvents = __webpack_require__(59);
-var UUID = __webpack_require__(193);
-var VideoRender = __webpack_require__(976);
+var UUID = __webpack_require__(194);
+var VideoRender = __webpack_require__(987);
var MATH_CONST = __webpack_require__(13);
/**
@@ -42189,25 +42316,24 @@ module.exports = Video;
/***/ }),
-/* 197 */
+/* 198 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var Contains = __webpack_require__(198);
-var GetPoints = __webpack_require__(397);
+var Contains = __webpack_require__(199);
+var GetPoints = __webpack_require__(411);
var GEOM_CONST = __webpack_require__(46);
/**
* @classdesc
* A Polygon object
*
-
* The polygon is a closed shape consists of a series of connected straight lines defined by list of ordered points.
* Several formats are supported to define the list of points, check the setTo method for details.
* This is a geometry object allowing you to define and inspect the shape.
@@ -42405,11 +42531,13 @@ var Polygon = new Class({
* @method Phaser.Geom.Polygon#getPoints
* @since 3.12.0
*
+ * @generic {Phaser.Geom.Point[]} O - [output,$return]
+ *
* @param {integer} quantity - The amount of points to return. If a falsey value the quantity will be derived from the `stepRate` instead.
* @param {number} [stepRate] - Sets the quantity by getting the perimeter of the Polygon and dividing it by the stepRate.
- * @param {array} [output] - An array to insert the points in to. If not provided a new array will be created.
+ * @param {(array|Phaser.Geom.Point[])} [output] - An array to insert the points in to. If not provided a new array will be created.
*
- * @return {Phaser.Geom.Point[]} An array of Point objects pertaining to the points around the perimeter of the Polygon.
+ * @return {(array|Phaser.Geom.Point[])} An array of Point objects pertaining to the points around the perimeter of the Polygon.
*/
getPoints: function (quantity, step, output)
{
@@ -42422,12 +42550,12 @@ module.exports = Polygon;
/***/ }),
-/* 198 */
+/* 199 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -42471,17 +42599,17 @@ module.exports = Contains;
/***/ }),
-/* 199 */
+/* 200 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var Mesh = __webpack_require__(128);
+var Mesh = __webpack_require__(130);
/**
* @classdesc
@@ -43132,12 +43260,12 @@ module.exports = Quad;
/***/ }),
-/* 200 */
+/* 201 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -43146,8 +43274,8 @@ var Components = __webpack_require__(12);
var GameObject = __webpack_require__(14);
var GetFastValue = __webpack_require__(2);
var Extend = __webpack_require__(17);
-var SetValue = __webpack_require__(405);
-var ShaderRender = __webpack_require__(1057);
+var SetValue = __webpack_require__(419);
+var ShaderRender = __webpack_require__(1068);
var TransformMatrix = __webpack_require__(32);
/**
@@ -44355,16 +44483,16 @@ module.exports = Shader;
/***/ }),
-/* 201 */
+/* 202 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var DistanceBetween = __webpack_require__(58);
+var DistanceBetween = __webpack_require__(53);
/**
* Checks if two Circles intersect.
@@ -44386,12 +44514,12 @@ module.exports = CircleToCircle;
/***/ }),
-/* 202 */
+/* 203 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -44440,18 +44568,18 @@ module.exports = CircleToRectangle;
/***/ }),
-/* 203 */
+/* 204 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Florian Vazelle
* @author Geoffrey Glaive
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Point = __webpack_require__(4);
-var LineToCircle = __webpack_require__(204);
+var LineToCircle = __webpack_require__(205);
/**
* Checks for intersection between the line segment and circle,
@@ -44532,16 +44660,16 @@ module.exports = GetLineToCircle;
/***/ }),
-/* 204 */
+/* 205 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var Contains = __webpack_require__(54);
+var Contains = __webpack_require__(55);
var Point = __webpack_require__(4);
var tmp = new Point();
@@ -44616,19 +44744,19 @@ module.exports = LineToCircle;
/***/ }),
-/* 205 */
+/* 206 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Florian Vazelle
* @author Geoffrey Glaive
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Point = __webpack_require__(4);
var LineToLine = __webpack_require__(84);
-var LineToRectangle = __webpack_require__(410);
+var LineToRectangle = __webpack_require__(424);
/**
* Checks for intersection between the Line and a Rectangle shape,
@@ -44676,12 +44804,12 @@ module.exports = GetLineToRectangle;
/***/ }),
-/* 206 */
+/* 207 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -44763,12 +44891,12 @@ module.exports = ContainsArray;
/***/ }),
-/* 207 */
+/* 208 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -44811,12 +44939,12 @@ module.exports = RotateAroundXY;
/***/ }),
-/* 208 */
+/* 209 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -44839,12 +44967,12 @@ module.exports = GetAspectRatio;
/***/ }),
-/* 209 */
+/* 210 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -44893,12 +45021,12 @@ module.exports = RotateAroundXY;
/***/ }),
-/* 210 */
+/* 211 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -44908,28 +45036,28 @@ module.exports = RotateAroundXY;
module.exports = {
- BUTTON_DOWN: __webpack_require__(1178),
- BUTTON_UP: __webpack_require__(1179),
- CONNECTED: __webpack_require__(1180),
- DISCONNECTED: __webpack_require__(1181),
- GAMEPAD_BUTTON_DOWN: __webpack_require__(1182),
- GAMEPAD_BUTTON_UP: __webpack_require__(1183)
+ BUTTON_DOWN: __webpack_require__(1189),
+ BUTTON_UP: __webpack_require__(1190),
+ CONNECTED: __webpack_require__(1191),
+ DISCONNECTED: __webpack_require__(1192),
+ GAMEPAD_BUTTON_DOWN: __webpack_require__(1193),
+ GAMEPAD_BUTTON_UP: __webpack_require__(1194)
};
/***/ }),
-/* 211 */
+/* 212 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Extend = __webpack_require__(17);
-var XHRSettings = __webpack_require__(133);
+var XHRSettings = __webpack_require__(135);
/**
* Takes two XHRSettings Objects and creates a new XHRSettings object from them.
@@ -44967,22 +45095,22 @@ module.exports = MergeXHRSettings;
/***/ }),
-/* 212 */
+/* 213 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
-var CONST = __webpack_require__(19);
-var File = __webpack_require__(20);
+var CONST = __webpack_require__(20);
+var File = __webpack_require__(21);
var FileTypesManager = __webpack_require__(8);
var GetFastValue = __webpack_require__(2);
var IsPlainObject = __webpack_require__(7);
-var ParseXML = __webpack_require__(344);
+var ParseXML = __webpack_require__(358);
/**
* @classdesc
@@ -45152,12 +45280,12 @@ module.exports = XMLFile;
/***/ }),
-/* 213 */
+/* 214 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -45167,29 +45295,29 @@ module.exports = XMLFile;
module.exports = {
- Acceleration: __webpack_require__(1238),
- Angular: __webpack_require__(1239),
- Bounce: __webpack_require__(1240),
- Debug: __webpack_require__(1241),
- Drag: __webpack_require__(1242),
- Enable: __webpack_require__(1243),
- Friction: __webpack_require__(1244),
- Gravity: __webpack_require__(1245),
- Immovable: __webpack_require__(1246),
- Mass: __webpack_require__(1247),
- Size: __webpack_require__(1248),
- Velocity: __webpack_require__(1249)
+ Acceleration: __webpack_require__(1249),
+ Angular: __webpack_require__(1250),
+ Bounce: __webpack_require__(1251),
+ Debug: __webpack_require__(1252),
+ Drag: __webpack_require__(1253),
+ Enable: __webpack_require__(1254),
+ Friction: __webpack_require__(1255),
+ Gravity: __webpack_require__(1256),
+ Immovable: __webpack_require__(1257),
+ Mass: __webpack_require__(1258),
+ Size: __webpack_require__(1259),
+ Velocity: __webpack_require__(1260)
};
/***/ }),
-/* 214 */
+/* 215 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -45199,30 +45327,30 @@ module.exports = {
module.exports = {
- COLLIDE: __webpack_require__(1251),
- OVERLAP: __webpack_require__(1252),
- PAUSE: __webpack_require__(1253),
- RESUME: __webpack_require__(1254),
- TILE_COLLIDE: __webpack_require__(1255),
- TILE_OVERLAP: __webpack_require__(1256),
- WORLD_BOUNDS: __webpack_require__(1257),
- WORLD_STEP: __webpack_require__(1258)
+ COLLIDE: __webpack_require__(1262),
+ OVERLAP: __webpack_require__(1263),
+ PAUSE: __webpack_require__(1264),
+ RESUME: __webpack_require__(1265),
+ TILE_COLLIDE: __webpack_require__(1266),
+ TILE_OVERLAP: __webpack_require__(1267),
+ WORLD_BOUNDS: __webpack_require__(1268),
+ WORLD_STEP: __webpack_require__(1269)
};
/***/ }),
-/* 215 */,
-/* 216 */
+/* 216 */,
+/* 217 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var GetTileAt = __webpack_require__(137);
+var GetTileAt = __webpack_require__(138);
/**
* Calculates interesting faces at the given tile coordinates of the specified layer. Interesting
@@ -45289,18 +45417,18 @@ module.exports = CalculateFacesAt;
/***/ }),
-/* 217 */
+/* 218 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Tile = __webpack_require__(74);
var IsInLayerBounds = __webpack_require__(103);
-var CalculateFacesAt = __webpack_require__(216);
+var CalculateFacesAt = __webpack_require__(217);
var SetTileCollision = __webpack_require__(73);
/**
@@ -45369,12 +45497,12 @@ module.exports = PutTileAt;
/***/ }),
-/* 218 */
+/* 219 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -45408,12 +45536,12 @@ module.exports = SetLayerCollisionIndex;
/***/ }),
-/* 219 */
+/* 220 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -45500,12 +45628,12 @@ module.exports = Parse2DArray;
/***/ }),
-/* 220 */
+/* 221 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -45590,12 +45718,12 @@ module.exports = ParseGID;
/***/ }),
-/* 221 */
+/* 222 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Seth Berrier
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -45651,17 +45779,17 @@ module.exports = CreateGroupLayer;
/***/ }),
-/* 222 */
+/* 223 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var Pick = __webpack_require__(466);
-var ParseGID = __webpack_require__(220);
+var Pick = __webpack_require__(480);
+var ParseGID = __webpack_require__(221);
var copyPoints = function (p) { return { x: p.x, y: p.y }; };
@@ -45733,19 +45861,19 @@ module.exports = ParseObject;
/***/ }),
-/* 223 */
+/* 224 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Formats = __webpack_require__(31);
var MapData = __webpack_require__(105);
-var Parse = __webpack_require__(458);
-var Tilemap = __webpack_require__(474);
+var Parse = __webpack_require__(472);
+var Tilemap = __webpack_require__(488);
/**
* Create a Tilemap from the given key or data. If neither is given, make a blank Tilemap. When
@@ -45819,12 +45947,12 @@ module.exports = ParseToTilemap;
/***/ }),
-/* 224 */
+/* 225 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -45868,12 +45996,12 @@ module.exports = GetTargets;
/***/ }),
-/* 225 */
+/* 226 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -46136,12 +46264,12 @@ module.exports = GetValueOp;
/***/ }),
-/* 226 */
+/* 227 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -46180,18 +46308,18 @@ module.exports = TWEEN_DEFAULTS;
/***/ }),
-/* 227 */
+/* 228 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var EventEmitter = __webpack_require__(9);
-var Events = __webpack_require__(228);
+var Events = __webpack_require__(229);
var GameObjectCreator = __webpack_require__(16);
var GameObjectFactory = __webpack_require__(5);
var TWEEN_CONST = __webpack_require__(89);
@@ -47425,7 +47553,7 @@ var Tween = new Class({
{
if (!this.isSeeking)
{
- this.emit(event, this, tweenData.key, tweenData.target);
+ this.emit(event, this, tweenData.key, tweenData.target, tweenData.current, tweenData.previous);
if (callback)
{
@@ -47650,6 +47778,7 @@ var Tween = new Class({
tweenData.elapsed = elapsed;
tweenData.progress = progress;
+ tweenData.previous = tweenData.current;
if (progress === 1)
{
@@ -47823,12 +47952,12 @@ module.exports = Tween;
/***/ }),
-/* 228 */
+/* 229 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -47838,30 +47967,30 @@ module.exports = Tween;
module.exports = {
- TIMELINE_COMPLETE: __webpack_require__(1331),
- TIMELINE_LOOP: __webpack_require__(1332),
- TIMELINE_PAUSE: __webpack_require__(1333),
- TIMELINE_RESUME: __webpack_require__(1334),
- TIMELINE_START: __webpack_require__(1335),
- TIMELINE_UPDATE: __webpack_require__(1336),
- TWEEN_ACTIVE: __webpack_require__(1337),
- TWEEN_COMPLETE: __webpack_require__(1338),
- TWEEN_LOOP: __webpack_require__(1339),
- TWEEN_REPEAT: __webpack_require__(1340),
- TWEEN_START: __webpack_require__(1341),
- TWEEN_UPDATE: __webpack_require__(1342),
- TWEEN_YOYO: __webpack_require__(1343)
+ TIMELINE_COMPLETE: __webpack_require__(1346),
+ TIMELINE_LOOP: __webpack_require__(1347),
+ TIMELINE_PAUSE: __webpack_require__(1348),
+ TIMELINE_RESUME: __webpack_require__(1349),
+ TIMELINE_START: __webpack_require__(1350),
+ TIMELINE_UPDATE: __webpack_require__(1351),
+ TWEEN_ACTIVE: __webpack_require__(1352),
+ TWEEN_COMPLETE: __webpack_require__(1353),
+ TWEEN_LOOP: __webpack_require__(1354),
+ TWEEN_REPEAT: __webpack_require__(1355),
+ TWEEN_START: __webpack_require__(1356),
+ TWEEN_UPDATE: __webpack_require__(1357),
+ TWEEN_YOYO: __webpack_require__(1358)
};
/***/ }),
-/* 229 */
+/* 230 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -47957,6 +48086,7 @@ var TweenData = function (target, index, key, getEnd, getStart, getActive, ease,
// Ease Value Data:
start: 0,
+ previous: 0,
current: 0,
end: 0,
@@ -47982,12 +48112,12 @@ module.exports = TweenData;
/***/ }),
-/* 230 */
+/* 231 */
/***/ (function(module, exports) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -48036,16 +48166,16 @@ module.exports = ScaleModes;
/***/ }),
-/* 231 */
+/* 232 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var MathWrap = __webpack_require__(57);
+var MathWrap = __webpack_require__(58);
/**
* Wrap an angle.
@@ -48068,16 +48198,16 @@ module.exports = Wrap;
/***/ }),
-/* 232 */
+/* 233 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var Wrap = __webpack_require__(57);
+var Wrap = __webpack_require__(58);
/**
* Wrap an angle in degrees.
@@ -48100,13 +48230,13 @@ module.exports = WrapDegrees;
/***/ }),
-/* 233 */
+/* 234 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
* @author Felipe Alfonso <@bitnenfer>
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -48869,25 +48999,25 @@ module.exports = WebGLPipeline;
/***/ }),
-/* 234 */
+/* 235 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
* @author Felipe Alfonso <@bitnenfer>
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = __webpack_require__(0);
var Earcut = __webpack_require__(66);
var GetFastValue = __webpack_require__(2);
-var ModelViewProjection = __webpack_require__(492);
-var ShaderSourceFS = __webpack_require__(756);
-var ShaderSourceVS = __webpack_require__(757);
+var ModelViewProjection = __webpack_require__(506);
+var ShaderSourceFS = __webpack_require__(779);
+var ShaderSourceVS = __webpack_require__(780);
var TransformMatrix = __webpack_require__(32);
var Utils = __webpack_require__(10);
-var WebGLPipeline = __webpack_require__(233);
+var WebGLPipeline = __webpack_require__(234);
/**
* @classdesc
@@ -50377,14 +50507,14 @@ module.exports = TextureTintPipeline;
/***/ }),
-/* 235 */,
/* 236 */,
-/* 237 */
+/* 237 */,
+/* 238 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
@@ -50394,85 +50524,670 @@ module.exports = TextureTintPipeline;
module.exports = {
- Angle: __webpack_require__(504),
- Call: __webpack_require__(505),
- GetFirst: __webpack_require__(506),
- GetLast: __webpack_require__(507),
- GridAlign: __webpack_require__(508),
- IncAlpha: __webpack_require__(568),
- IncX: __webpack_require__(569),
- IncXY: __webpack_require__(570),
- IncY: __webpack_require__(571),
- PlaceOnCircle: __webpack_require__(572),
- PlaceOnEllipse: __webpack_require__(573),
- PlaceOnLine: __webpack_require__(574),
- PlaceOnRectangle: __webpack_require__(575),
- PlaceOnTriangle: __webpack_require__(576),
- PlayAnimation: __webpack_require__(577),
+ AlignTo: __webpack_require__(521),
+ Angle: __webpack_require__(522),
+ Call: __webpack_require__(523),
+ GetFirst: __webpack_require__(524),
+ GetLast: __webpack_require__(525),
+ GridAlign: __webpack_require__(526),
+ IncAlpha: __webpack_require__(587),
+ IncX: __webpack_require__(588),
+ IncXY: __webpack_require__(589),
+ IncY: __webpack_require__(590),
+ PlaceOnCircle: __webpack_require__(591),
+ PlaceOnEllipse: __webpack_require__(592),
+ PlaceOnLine: __webpack_require__(593),
+ PlaceOnRectangle: __webpack_require__(594),
+ PlaceOnTriangle: __webpack_require__(595),
+ PlayAnimation: __webpack_require__(596),
PropertyValueInc: __webpack_require__(34),
PropertyValueSet: __webpack_require__(25),
- RandomCircle: __webpack_require__(578),
- RandomEllipse: __webpack_require__(579),
- RandomLine: __webpack_require__(580),
- RandomRectangle: __webpack_require__(581),
- RandomTriangle: __webpack_require__(582),
- Rotate: __webpack_require__(583),
- RotateAround: __webpack_require__(584),
- RotateAroundDistance: __webpack_require__(585),
- ScaleX: __webpack_require__(586),
- ScaleXY: __webpack_require__(587),
- ScaleY: __webpack_require__(588),
- SetAlpha: __webpack_require__(589),
- SetBlendMode: __webpack_require__(590),
- SetDepth: __webpack_require__(591),
- SetHitArea: __webpack_require__(592),
- SetOrigin: __webpack_require__(593),
- SetRotation: __webpack_require__(594),
- SetScale: __webpack_require__(595),
- SetScaleX: __webpack_require__(596),
- SetScaleY: __webpack_require__(597),
- SetScrollFactor: __webpack_require__(598),
- SetScrollFactorX: __webpack_require__(599),
- SetScrollFactorY: __webpack_require__(600),
- SetTint: __webpack_require__(601),
- SetVisible: __webpack_require__(602),
- SetX: __webpack_require__(603),
- SetXY: __webpack_require__(604),
- SetY: __webpack_require__(605),
- ShiftPosition: __webpack_require__(606),
- Shuffle: __webpack_require__(607),
- SmootherStep: __webpack_require__(608),
- SmoothStep: __webpack_require__(609),
- Spread: __webpack_require__(610),
- ToggleVisible: __webpack_require__(611),
- WrapInRectangle: __webpack_require__(612)
+ RandomCircle: __webpack_require__(597),
+ RandomEllipse: __webpack_require__(598),
+ RandomLine: __webpack_require__(599),
+ RandomRectangle: __webpack_require__(600),
+ RandomTriangle: __webpack_require__(601),
+ Rotate: __webpack_require__(602),
+ RotateAround: __webpack_require__(603),
+ RotateAroundDistance: __webpack_require__(604),
+ ScaleX: __webpack_require__(605),
+ ScaleXY: __webpack_require__(606),
+ ScaleY: __webpack_require__(607),
+ SetAlpha: __webpack_require__(608),
+ SetBlendMode: __webpack_require__(609),
+ SetDepth: __webpack_require__(610),
+ SetHitArea: __webpack_require__(611),
+ SetOrigin: __webpack_require__(612),
+ SetRotation: __webpack_require__(613),
+ SetScale: __webpack_require__(614),
+ SetScaleX: __webpack_require__(615),
+ SetScaleY: __webpack_require__(616),
+ SetScrollFactor: __webpack_require__(617),
+ SetScrollFactorX: __webpack_require__(618),
+ SetScrollFactorY: __webpack_require__(619),
+ SetTint: __webpack_require__(620),
+ SetVisible: __webpack_require__(621),
+ SetX: __webpack_require__(622),
+ SetXY: __webpack_require__(623),
+ SetY: __webpack_require__(624),
+ ShiftPosition: __webpack_require__(625),
+ Shuffle: __webpack_require__(626),
+ SmootherStep: __webpack_require__(627),
+ SmoothStep: __webpack_require__(628),
+ Spread: __webpack_require__(629),
+ ToggleVisible: __webpack_require__(630),
+ WrapInRectangle: __webpack_require__(631)
};
/***/ }),
-/* 238 */
+/* 239 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author samme
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var ALIGN_CONST = __webpack_require__(106);
+
+var AlignToMap = [];
+
+AlignToMap[ALIGN_CONST.BOTTOM_CENTER] = __webpack_require__(240);
+AlignToMap[ALIGN_CONST.BOTTOM_LEFT] = __webpack_require__(241);
+AlignToMap[ALIGN_CONST.BOTTOM_RIGHT] = __webpack_require__(242);
+AlignToMap[ALIGN_CONST.LEFT_BOTTOM] = __webpack_require__(243);
+AlignToMap[ALIGN_CONST.LEFT_CENTER] = __webpack_require__(244);
+AlignToMap[ALIGN_CONST.LEFT_TOP] = __webpack_require__(245);
+AlignToMap[ALIGN_CONST.RIGHT_BOTTOM] = __webpack_require__(246);
+AlignToMap[ALIGN_CONST.RIGHT_CENTER] = __webpack_require__(247);
+AlignToMap[ALIGN_CONST.RIGHT_TOP] = __webpack_require__(248);
+AlignToMap[ALIGN_CONST.TOP_CENTER] = __webpack_require__(249);
+AlignToMap[ALIGN_CONST.TOP_LEFT] = __webpack_require__(250);
+AlignToMap[ALIGN_CONST.TOP_RIGHT] = __webpack_require__(251);
+
+/**
+ * Takes a Game Object and aligns it next to another, at the given position.
+ * The alignment used is based on the `position` argument, which is a `Phaser.Display.Align` property such as `LEFT_CENTER` or `TOP_RIGHT`.
+ *
+ * @function Phaser.Display.Align.To.QuickSet
+ * @since 3.22.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [child,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} child - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {integer} position - The position to align the Game Object with. This is an align constant, such as `Phaser.Display.Align.LEFT_CENTER`.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var QuickSet = function (child, alignTo, position, offsetX, offsetY)
+{
+ return AlignToMap[position](child, alignTo, offsetX, offsetY);
+};
+
+module.exports = QuickSet;
+
+
+/***/ }),
+/* 240 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var ALIGN_CONST = __webpack_require__(143);
+var GetBottom = __webpack_require__(38);
+var GetCenterX = __webpack_require__(75);
+var SetCenterX = __webpack_require__(76);
+var SetTop = __webpack_require__(39);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the bottom center position of the other.
+ *
+ * @function Phaser.Display.Align.To.BottomCenter
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var BottomCenter = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetCenterX(gameObject, GetCenterX(alignTo) + offsetX);
+ SetTop(gameObject, GetBottom(alignTo) + offsetY);
+
+ return gameObject;
+};
+
+module.exports = BottomCenter;
+
+
+/***/ }),
+/* 241 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetBottom = __webpack_require__(38);
+var GetLeft = __webpack_require__(40);
+var SetLeft = __webpack_require__(41);
+var SetTop = __webpack_require__(39);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the bottom left position of the other.
+ *
+ * @function Phaser.Display.Align.To.BottomLeft
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var BottomLeft = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetLeft(gameObject, GetLeft(alignTo) - offsetX);
+ SetTop(gameObject, GetBottom(alignTo) + offsetY);
+
+ return gameObject;
+};
+
+module.exports = BottomLeft;
+
+
+/***/ }),
+/* 242 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetBottom = __webpack_require__(38);
+var GetRight = __webpack_require__(42);
+var SetRight = __webpack_require__(43);
+var SetTop = __webpack_require__(39);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the bottom right position of the other.
+ *
+ * @function Phaser.Display.Align.To.BottomRight
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var BottomRight = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetRight(gameObject, GetRight(alignTo) + offsetX);
+ SetTop(gameObject, GetBottom(alignTo) + offsetY);
+
+ return gameObject;
+};
+
+module.exports = BottomRight;
+
+
+/***/ }),
+/* 243 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetBottom = __webpack_require__(38);
+var GetLeft = __webpack_require__(40);
+var SetBottom = __webpack_require__(44);
+var SetRight = __webpack_require__(43);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the left bottom position of the other.
+ *
+ * @function Phaser.Display.Align.To.LeftBottom
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var LeftBottom = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetRight(gameObject, GetLeft(alignTo) - offsetX);
+ SetBottom(gameObject, GetBottom(alignTo) + offsetY);
+
+ return gameObject;
+};
+
+module.exports = LeftBottom;
+
+
+/***/ }),
+/* 244 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetCenterY = __webpack_require__(77);
+var GetLeft = __webpack_require__(40);
+var SetCenterY = __webpack_require__(78);
+var SetRight = __webpack_require__(43);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the left center position of the other.
+ *
+ * @function Phaser.Display.Align.To.LeftCenter
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var LeftCenter = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetRight(gameObject, GetLeft(alignTo) - offsetX);
+ SetCenterY(gameObject, GetCenterY(alignTo) + offsetY);
+
+ return gameObject;
+};
+
+module.exports = LeftCenter;
+
+
+/***/ }),
+/* 245 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetLeft = __webpack_require__(40);
+var GetTop = __webpack_require__(45);
+var SetRight = __webpack_require__(43);
+var SetTop = __webpack_require__(39);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the left top position of the other.
+ *
+ * @function Phaser.Display.Align.To.LeftTop
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var LeftTop = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetRight(gameObject, GetLeft(alignTo) - offsetX);
+ SetTop(gameObject, GetTop(alignTo) - offsetY);
+
+ return gameObject;
+};
+
+module.exports = LeftTop;
+
+
+/***/ }),
+/* 246 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetBottom = __webpack_require__(38);
+var GetRight = __webpack_require__(42);
+var SetBottom = __webpack_require__(44);
+var SetLeft = __webpack_require__(41);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the right bottom position of the other.
+ *
+ * @function Phaser.Display.Align.To.RightBottom
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var RightBottom = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetLeft(gameObject, GetRight(alignTo) + offsetX);
+ SetBottom(gameObject, GetBottom(alignTo) + offsetY);
+
+ return gameObject;
+};
+
+module.exports = RightBottom;
+
+
+/***/ }),
+/* 247 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetCenterY = __webpack_require__(77);
+var GetRight = __webpack_require__(42);
+var SetCenterY = __webpack_require__(78);
+var SetLeft = __webpack_require__(41);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the right center position of the other.
+ *
+ * @function Phaser.Display.Align.To.RightCenter
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var RightCenter = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetLeft(gameObject, GetRight(alignTo) + offsetX);
+ SetCenterY(gameObject, GetCenterY(alignTo) + offsetY);
+
+ return gameObject;
+};
+
+module.exports = RightCenter;
+
+
+/***/ }),
+/* 248 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetRight = __webpack_require__(42);
+var GetTop = __webpack_require__(45);
+var SetLeft = __webpack_require__(41);
+var SetTop = __webpack_require__(39);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the right top position of the other.
+ *
+ * @function Phaser.Display.Align.To.RightTop
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var RightTop = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetLeft(gameObject, GetRight(alignTo) + offsetX);
+ SetTop(gameObject, GetTop(alignTo) - offsetY);
+
+ return gameObject;
+};
+
+module.exports = RightTop;
+
+
+/***/ }),
+/* 249 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetCenterX = __webpack_require__(75);
+var GetTop = __webpack_require__(45);
+var SetBottom = __webpack_require__(44);
+var SetCenterX = __webpack_require__(76);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the top center position of the other.
+ *
+ * @function Phaser.Display.Align.To.TopCenter
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var TopCenter = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetCenterX(gameObject, GetCenterX(alignTo) + offsetX);
+ SetBottom(gameObject, GetTop(alignTo) - offsetY);
+
+ return gameObject;
+};
+
+module.exports = TopCenter;
+
+
+/***/ }),
+/* 250 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetLeft = __webpack_require__(40);
+var GetTop = __webpack_require__(45);
+var SetBottom = __webpack_require__(44);
+var SetLeft = __webpack_require__(41);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the top left position of the other.
+ *
+ * @function Phaser.Display.Align.To.TopLeft
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var TopLeft = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetLeft(gameObject, GetLeft(alignTo) - offsetX);
+ SetBottom(gameObject, GetTop(alignTo) - offsetY);
+
+ return gameObject;
+};
+
+module.exports = TopLeft;
+
+
+/***/ }),
+/* 251 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var GetRight = __webpack_require__(42);
+var GetTop = __webpack_require__(45);
+var SetBottom = __webpack_require__(44);
+var SetRight = __webpack_require__(43);
+
+/**
+ * Takes given Game Object and aligns it so that it is positioned next to the top right position of the other.
+ *
+ * @function Phaser.Display.Align.To.TopRight
+ * @since 3.0.0
+ *
+ * @generic {Phaser.GameObjects.GameObject} G - [gameObject,$return]
+ *
+ * @param {Phaser.GameObjects.GameObject} gameObject - The Game Object that will be positioned.
+ * @param {Phaser.GameObjects.GameObject} alignTo - The Game Object to base the alignment position on.
+ * @param {number} [offsetX=0] - Optional horizontal offset from the position.
+ * @param {number} [offsetY=0] - Optional vertical offset from the position.
+ *
+ * @return {Phaser.GameObjects.GameObject} The Game Object that was aligned.
+ */
+var TopRight = function (gameObject, alignTo, offsetX, offsetY)
+{
+ if (offsetX === undefined) { offsetX = 0; }
+ if (offsetY === undefined) { offsetY = 0; }
+
+ SetRight(gameObject, GetRight(alignTo) + offsetX);
+ SetBottom(gameObject, GetTop(alignTo) - offsetY);
+
+ return gameObject;
+};
+
+module.exports = TopRight;
+
+
+/***/ }),
+/* 252 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+ * @author Richard Davey
+ * @copyright 2020 Photon Storm Ltd.
+ * @license {@link https://opensource.org/licenses/MIT|MIT License}
+ */
+
+var ALIGN_CONST = __webpack_require__(106);
var AlignInMap = [];
-AlignInMap[ALIGN_CONST.BOTTOM_CENTER] = __webpack_require__(239);
-AlignInMap[ALIGN_CONST.BOTTOM_LEFT] = __webpack_require__(240);
-AlignInMap[ALIGN_CONST.BOTTOM_RIGHT] = __webpack_require__(241);
-AlignInMap[ALIGN_CONST.CENTER] = __webpack_require__(242);
-AlignInMap[ALIGN_CONST.LEFT_CENTER] = __webpack_require__(244);
-AlignInMap[ALIGN_CONST.RIGHT_CENTER] = __webpack_require__(245);
-AlignInMap[ALIGN_CONST.TOP_CENTER] = __webpack_require__(246);
-AlignInMap[ALIGN_CONST.TOP_LEFT] = __webpack_require__(247);
-AlignInMap[ALIGN_CONST.TOP_RIGHT] = __webpack_require__(248);
+AlignInMap[ALIGN_CONST.BOTTOM_CENTER] = __webpack_require__(253);
+AlignInMap[ALIGN_CONST.BOTTOM_LEFT] = __webpack_require__(254);
+AlignInMap[ALIGN_CONST.BOTTOM_RIGHT] = __webpack_require__(255);
+AlignInMap[ALIGN_CONST.CENTER] = __webpack_require__(256);
+AlignInMap[ALIGN_CONST.LEFT_CENTER] = __webpack_require__(258);
+AlignInMap[ALIGN_CONST.RIGHT_CENTER] = __webpack_require__(259);
+AlignInMap[ALIGN_CONST.TOP_CENTER] = __webpack_require__(260);
+AlignInMap[ALIGN_CONST.TOP_LEFT] = __webpack_require__(261);
+AlignInMap[ALIGN_CONST.TOP_RIGHT] = __webpack_require__(262);
+AlignInMap[ALIGN_CONST.LEFT_BOTTOM] = AlignInMap[ALIGN_CONST.BOTTOM_LEFT];
+AlignInMap[ALIGN_CONST.LEFT_TOP] = AlignInMap[ALIGN_CONST.TOP_LEFT];
+AlignInMap[ALIGN_CONST.RIGHT_BOTTOM] = AlignInMap[ALIGN_CONST.BOTTOM_RIGHT];
+AlignInMap[ALIGN_CONST.RIGHT_TOP] = AlignInMap[ALIGN_CONST.TOP_RIGHT];
/**
* Takes given Game Object and aligns it so that it is positioned relative to the other.
@@ -50500,18 +51215,18 @@ module.exports = QuickSet;
/***/ }),
-/* 239 */
+/* 253 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var GetBottom = __webpack_require__(38);
var GetCenterX = __webpack_require__(75);
-var SetBottom = __webpack_require__(39);
+var SetBottom = __webpack_require__(44);
var SetCenterX = __webpack_require__(76);
/**
@@ -50544,18 +51259,18 @@ module.exports = BottomCenter;
/***/ }),
-/* 240 */
+/* 254 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var GetBottom = __webpack_require__(38);
var GetLeft = __webpack_require__(40);
-var SetBottom = __webpack_require__(39);
+var SetBottom = __webpack_require__(44);
var SetLeft = __webpack_require__(41);
/**
@@ -50588,18 +51303,18 @@ module.exports = BottomLeft;
/***/ }),
-/* 241 */
+/* 255 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var GetBottom = __webpack_require__(38);
var GetRight = __webpack_require__(42);
-var SetBottom = __webpack_require__(39);
+var SetBottom = __webpack_require__(44);
var SetRight = __webpack_require__(43);
/**
@@ -50632,18 +51347,18 @@ module.exports = BottomRight;
/***/ }),
-/* 242 */
+/* 256 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
-var CenterOn = __webpack_require__(243);
+var CenterOn = __webpack_require__(257);
var GetCenterX = __webpack_require__(75);
-var GetCenterY = __webpack_require__(78);
+var GetCenterY = __webpack_require__(77);
/**
* Takes given Game Object and aligns it so that it is positioned in the center of the other.
@@ -50674,17 +51389,17 @@ module.exports = Center;
/***/ }),
-/* 243 */
+/* 257 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey
- * @copyright 2019 Photon Storm Ltd.
+ * @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var SetCenterX = __webpack_require__(76);
-var SetCenterY = __webpack_require__(77);
+var SetCenterY = __webpack_require__(78);
/**
* Positions the Game Object so that it is centered on the given coordinates.
@@ -50711,18 +51426,18 @@ module.exports = CenterOn;
/***/ }),
-/* 244 */
+/* 258 */
/***/ (function(module, exports, __webpack_require__) {
/**
* @author Richard Davey