There are no known breaking changes.
- Timer
- Uses standard Math.min/Math.max (it's better 2, 3 items).
- Math
- Updated documentation
- Marked various Math functions as deprecated, proxying as appropriate
- Array-based functions -> ArrayUtils
- RNG-based functions -> Utils
- Updated core-usage
- floor/ceil should not be used (alternatives provided)
- Altered for some equivalencies
- Also fixes some assorted issues
- Marked a few internal functions as private
- Utils
- Moved polyfills to their own file for better visibility
- Moved array functions to ArrayUtils and marked proxies as deprecated
- Created Phaser.ArrayUtils for array-related functions
- polyfills moved to their own file
- Functions given function names
- Added Math.trunc
Some cache getters returned nothing on a missing entry (which is evaluated to undefined).
This fixes the issue by making the getters return null, as is the case with other functions in Phaser.Cache.
- Added `compatibility` settings
- CHANGE (2.1.2-4): moved `supportsFullScreen` and `noMargins` into it
- Added additional properties for greater control and up-front settings.
- `scrollTo`: where the browser will scrollTo, if anywhere
- `forceMinimumDocumentHeight`: apply document element style?
- `allowShowAllExpand`: allow SHOW_ALL to try to expand? (It already
could, this allows configuration.)
- Removed `windowConstraints.top/left`. This may be a feature in the
future, but scrubbed for now.
- Added `USER_SCALE` scale mode. This is like NO_SCALE but it scales off
of a user-specified scale factor, as set by `setUserScale`. This is
marked as "experimental" as the exactly semantics of non-adjusting modes
(e.g. NO_SCALE and USER_SCALE) wrt. Canvas and "maximum" size clamps
need to be re-examined.
- FIX: `onSizeChange` now works as documented, which means it is also
fired if the game size changes even though the game canvas size does
not.
- CHANGE (no known breaking): `margins` is now non-Point/non-Rectangle
that uses top/left/bottom/right properties (any quasi-updated x/y). This
is to get around the issue that Rectangle is only designed for positive
width/height cases.
- Cleaned up property access / quotes for consistency
- Various documentation cleanup and consistency
- Fixed issue with not clearing an unparented `_createdFullScreenTarget`
- Added Phaser.Rectangle.sameDimensions which does a strict equality check
over the `width` and `height` properties of two objects, perhaps
Rectangles.
We have separated the logic and render updates to permit slow motion and time slicing effects. We've fixed time calling to fix physics problems caused by variable time updates (i.e. collisions sometimes missing, objects tunneling, etc)
Once per frame calling for rendering and tweening to keep things as smooth as possible
Calculates a `suggestedFps` value (in multiples of 5 fps) based on a 2 second average of actual elapsed time values in the `Time.update` method. This is recalculated every 2 seconds so it could be used on a level-by-level basis if a game varies dramatically. I.e. if the fps rate consistently drops, you can adjust your game effects accordingly.
Game loop now tries to "catch up" frames if it is falling behind by iterating the logic update. This will help if the logic is occasionally causing things to run too slow, or if the renderer occasionally pushes the combined frame time over the FPS time. It's not a band-aid for a game that floods a low powered device however, so you still need to code accordingly. But it should help capture issues such as gc spikes or temporarily overloaded CPUs.
It now detects 'spiralling' which happens if a lot of frames are pushed out in succession meaning the CPU can never "catch up". It skips frames instead of trying to catch them up in this case. Note: the time value passed to the logic update functions is always constant regardless of these shenanigans.
Signals to the game program if there is a problem which might be fixed by lowering the desiredFps
Time.desiredFps is the new desired frame rate for your game.
Time.suggestedFps is the suggested frame rate for the game based on system load.
Time.slowMotion allows you to push the game into a slow motion mode. The default value is 1.0. 2.0 would be half speed, and so on.
Time.timeCap is no longer used and now deprecated. All timing is now handled by the fixed time-step code we've introduced.
ScaleManager.calibrate is a private method that calibrates element coordinates for viewport checks.
ScaleManager.aspect gets the viewport aspect ratio (or the aspect ratio of an object or element)
ScaleManager.inViewport tests if the given DOM element is within the viewport, with an optional cushion parameter that allows you to specify a distance.
ScaleManager.scaleSprite takes a Sprite or Image object and scales it to fit the given dimensions. Scaling happens proportionally without distortion to the sprites texture. The letterBox parameter controls if scaling will produce a letter-box effect or zoom the sprite until it fills the given values.
ScaleManager.viewportWidth returns the viewport width in pixels.
ScaleManager.viewportHeight returns the viewport height in pixels.
ScaleManager.documentWidth returns the document width in pixels.
ScaleManager.documentHeight returns the document height in pixels.
- Adds `ScaleManager#windowContraints`
- In 2.1.3 and prior the scale modes (EXACT_FIT, SHOW_ALL) were actually
based off the window dimensions, even though the parent element did
not correctly reflect this nature.
- When set (the default now is that right and bottom are set) the
behavior will mostly correctly mimic the 2.1.3 (minus bugs) and
before.
- CHANGE (from 2.1.3): The window constraints also affect the RESIZE
mode, arguably this is more consistent.
- To disable this "constrain to window" behavior, simply set the
appropriate property to false, as in:
`game.scale.windowConstraints.bottom = false`
- Sizing events:
- CHANGE: The `onResize` callback is called only from `preUpdate` (which
may be triggered from a window resize) and it will be called on
refreshes even if the parent size has not actually changed.
- A new `onSizeChange` Signal has been added. It is called _only_ when
the Game size or Game canvas size has changed and is generally more
applicable for performing layout updates.
- Game documentation now links to ScaleManager#setGameSize (which was
renamed from #setGameDimensions)
- Removed extra/legacy full-screen restore code
- Margins:
- Added `noMargins` flag; if set to true the Canvas margins will never
be altered. This also means that
- Margins are now set/cleared individually to avoid conflict with
'margins' style compound property
- Code consistency updates
- NOTE: Changing `game.width/game.height` via user code was always
problematic. This commit updates the documentation for such members as
read-only. The only supported way to change the GAME SIZE after it is
created is to use `ScaleManager#setGameDimensions`, which has been
added.
- The GAME SIZE will be reset to the initial (or as set by
`setGameDimensions`) values upon changing the scale mode or
entering/leaving full screen. This may be a breaking from 2.1.2 (but
many mode changes acted oddly prior).
- SHOW_ALL will now EXPAND it's parent container if it can. As per
@tjkopena 's notes, this should more closely represented the expected
behavior.
- SHOW_ALL will first try to expand by the OVERFLOW AXIS and then
attempt to resize to fit into the possibly larger area; use the
parent's max-height/max-width properties to limit how far SHOW_ALL can
expand.
- RE-BREAKING: This changes the behavior from 2.1.4 and makes it more like
2.1.3, with fixes.
- As per previous commit the ScaleManager _owns_ the margins and size of
the GAME CANVAS. To control the dimensions of the GAME CANVAS, use the min/max
height/width of the parent. Setting padding on the parent is _NOT_
supported.
- Fixes various issues with switching between Scale Modes
This includes some minor breaking changes.
- Unifies SHOW_ALL and NO_SCALE being stretched in Firefox and IE
- As suggested by MDN: "..to emulate WebKit's behavior on Gecko, you
need to place the element you want to present inside another
element.."
- This done via an (overwritable) `createFullScreenTarget` function.
The (new) DOM element returned from this is placed into the DOM and
the canvas is added to (and later removed) as the full screen mode
changes.
- MINOR BREAK: may affect code that assumes the Phaser canvas has a
fixed DOM/CSS path (which should hopefully be nobody). To use to the
original behavior, where the canvas is not moved, simply set
`this.fullScreenTarget = game.canvas` manually.
- Updates the refresh/queue to be unified and uses a smarter back-off to
detect and react to parent dimension changes
- Cleans up some odd browser issues; not tried on mobile
- Fixes an issue were update might be called too much and spend time
doing nothing useful.
- `maxIterations` is no longer user and marked as deprecated
- MINOR BREAK: previous approach would occasionally (but not always)
back off updates the entire iteration/setTimeout sequence; under the
new approach "onResize" may be called more frequently.
- Fixes a number various transition issues, mostly around RESIZE
- MINOR BREAK, but correct: leaving RESIZE restores the original game
size possible
- Fixes assorted quirks with scales not being updated
- Layout
- MINOR BREAK: All Canvas margins are "OWNED" by the ScaleManager. They
will be reset in all modes as appropriate. This is for consistency
fixes as well as coping with the updated full screen.
- MINOR BREAK: Canvas right/bottom margins are set to negative margins
to counter left/top margins. This prevents Canvas margin adjustments
from affecting the flow .. much.
- `getParentBounds` rounds to the nearest pixel to avoid "close to"
value propagation from CSS.
- Fixes page-align center pushing canvas out of parent
- Misc.
- MINOR BREAK: `setScreenSize` will update the game size if the mode is
RESIZE. User-code shoulde use `refresh` instead to ensure that any
relevant changes are propagated.
- Corrected incorrect documentation
- In the "Particle Class" demo there was no explicitly-created FrameData which cause issues later on.
This cache updates ensures that FrameData will be automatically created for any added cached bitmap data, unless such is explicitly supplied or forbidden.
- Impact: low
- AnimationManager.loadFrameData is called for all Sprites with BitmapData (except those with an explicit null FrameData) added to the cache
