Version History
---------------
8.0.0
* Physic : me.game.world is now a specific container (based on me.Container) that will manage all related physic updates
* Physic : gravity for physic bodies is now defined globally under me.game.world.gravity, and can be scaled individually using me.Body.gravityScale
* Renderable : add support for free-texture-packer (http://free-tex-packer.com), the free Texture Packer alternative (thanks @PLAYERKILLERS)

7.1.1
* Core : fix a crash when a game reset is triggered manually before any default stage has been defined
* Core : new option to automatically change to a newly define stage
* Input : fixed a regression with gamepad polling
* Renderer : fixed an issue where a failed attempt at creating a WebGL context would then prevent from creating a canvas context as fallback

7.1.0
* Audio : audio core update (2.1.2) to fix audio unlock on Firefox 66 and onwards
* Core : new me.event.GAME_UPDATE system event that will be triggered at the beginning of the update loop
* Core : me.game.HASH is deprecated and replaced by the me.utils.getUriFragment() function
* Debug : fixed DebugPanel minimum version requirements (should have been 7.0 since last release)
* Font : fix an issue with setText wronly converting a given array of string to a string representing the array
* Input : use passive event listeners when preventDefault is used (default behaviour)
* Input : simplified pointer / keyboard / gamepad implementation and removed support for legacy API (e.g. mousewheel event)
* Input : added a new getBindingKey() method that returns the associated action to a given key
* Input : exposed default targets for Keyboard and Pointer events under me.input
* Physic : fix an issue where gravity was not properly applied on the x axis
* Renderer : fix fill and stroke operations for arc and ellipse in the Canvas Renderer
* Renderer : added missing fill and stroke operations for arc in WebGL mode
* Renderer : align the canvas renderer with the WebGL renderer to properly use CSS scaling
* Sprite : new rotate method as a shortcut to apply a rotation transform to the sprite
* TMX : fixed parsing of string custom properties containing newline(s)
* TMX : use the offsetx/offsety properties when parsing ImageLayer data over the deprecated x/y ones
* TMX : add support for Staggered Isometric maps
* TMX : fix rendering of Staggered Hexagonal maps
* TMX : fix pointer position detection on Hexagonal maps (was slightly off previously)

7.0.0
* General : new "grunt-free" build process based on npm, rollup & friends
* Core : removed support for CocoonJS (following service shutdown)
* Core : simplified error/exception handling by removing the custom me.Error class
* Input : removed obsolete support for proprietary windows 8 accelerometer API (not a thing anymore)
* Input : fixed potential issue with hardware not reporting proper event geometry
* Input : improved pointer detection when using complex css layouts
* Math : prevent recalculating edges and normals when resizing a rectangle shape with the same width and height values
* Renderer : renderer selection now set to AUTO by default (Attempt WebGL first, with fallback to Canvas)
* Timer : added arguments passing to setTimeout and setInterval
* TMX : fixed temporary vectors recycling in the hexagonal map renderer
* WebGL : shader implementation has been rewritten to allow for a more generic approach, and ease definition of custom shader (see me.GLShader)
* WebGL : properly handle WebGL context lost and restore
* WebGL : updated earcut to version 2.1.5

6.4.0
* Documentation : new documentation format, including a search feature
* Math : new PI related constants under me.Math (TAU, ETA, etc..)
* Renderable : added a basic color tint feature (WebGL mode only)
* Renderable : added support for Texture Packer multipack textures
* Renderable : moved the name property definition at the me.Renderable level (prevent mostly all deriving objects from re-defining one)
* Renderable : fixed an issue where a non Boolean value was passed to the onVisibilityChange callback
* Sprite : cleaned up/simplified animation data handling
* TMX : small memory optimization in the isometric renderer, where one temporary vector object was not properly recycled
* Renderer : fixed stroke and fill default color to match standard W3C canvas stroke and fill style (black)

6.3.0
* Audio : audio core update (2.1.1), mostly improve auto audio unlock on latest (non-mobile) browser versions
* Color : fixed alpha value not being properly clamped (leading to issue in WebGL mode when passing the glArray buffer)
* Debug : fixed wrong bounding box drawing position for nested containers and entity childs
* Entity : fixed ancestor value for renderable component
* Renderable : added support for rendering mask (in both Canvas and WebGL mode), allowing to use any me.Shape object as a mask
* Renderer : `drawShape()` is deprecated and has been replaced by a `fill()` and `stroke() methods
* Renderer : cleaned and aligned drawing APIs between the Canvas and WebGL Renderer
* WebGLRenderer : added stroke and fill operations for all me.Shape objects
* WebGLRenderer : fillRect() now use newly added fill method, instead of creating/using a fill texture
* WebGLRenderer : optimized memory usage for shape drawing operations
* WebGLRenderer : enable batching of triangle vertices to speed up shape drawing (when applicable)
* WebGLRenderer : fixed a clipping issue with nested containers
* WebGLRenderer : fixed the clearRect method

6.2.0
* Audio : fixed a regression when passing an initial volume value to the play function (thanks @PLAYERKILLERS)
* Container : new `getNextChild` function that returns the next child within the container
* Core : renamed `me.ScreenObject` to `me.Stage` (with an alias to `me.ScreenObject` for Backward compatibility)
* Core : cleaned and improved the window auto focus feature
* Core : improve automatic object instance collection & recycling of base components like vectors and shapes.
* Core : ensure the internal coordinates system is updated when the DOM tree structure is modified
* Camera : `me.Camera2d` objects can now be defined per Stage, rather than having one static global camera under `me.game`
* Camera : fix infinite generation of the VIEWPORT_ONCHANGE event when using camera damping
* Device : added a me.device.focus() function
* Entity : fix "DRAGEND" event triggering for Draggable Entity, when pointer is moved outside of the screen area
* Entity : fix a regression introduced in 6.0 on optional me.Entity constructor parameters
* Font : fix bounds calculation for BitmapFont objects
* Font : enable Font & BitmapFont bounding box drawing through the Debug Panel
* Font : fix missing documentation on properties for BitmapFont Object.
* Font : Font & BitmapFont objects can now be directly added to a container like any other me.Renderable
* Font : Improved performances when drawing regular me.Font objects
* Font : new me.Text and me.BitmapText generic object replacing me.Font and me.BitmapFont (now deprecated)
* Input : fix a potential issue with "undefined" pointer location upon loading
* Loader : added support for Font Face preloading
* Math : new `toBeCloseTo` function to determine if two values are closed "enough" to eachother
* Renderable : new onVisibilityChange event handler that is called when leaving or entering a camera viewport
* Renderable : fix documentation for the container `clipping` flag (was accidentally left private)
* Renderable : update visibility flag for floating objects using actual screen coordinates
* Sprite : fix an issue when flipping trimmed sprite textures (@YosuaHamonangan)
* TMX : add support for orthogonal tile rendering order
* TMX : add support for Text object, allowing to add me.Text or me.BitmapText directly from Tiled
* TMX : optimized the getTile function to avoid duplicate calls to the pixel to tile coordinates functions
* WebGLRenderer : fix a bug when clipping is disabled due to the clipping area being equal to the canvas size

6.1.0
* Audio : latest audio core update (2.0.15)
* Core : new linux detection flag under me.device
* Renderer : now systematically warn when using non POT texture in both Canvas and WebGL mode
* Sprite : new function to allow reversing a given or current animation
* TMX : support for the Tiled 1.2 beta JSON property format (backward compatible with previous 1.1 version)
* CanvasRenderer : fix drawImage sub-pixel rendering in Canvas mode when using the short notation (2 or 4 parameters)
* WebGLRenderer : only throw an exception (e.g. stop execution) when using repeat/wrap mode with a non POT texture
* WebGLRenderer : properly fallback to Canvas mode in AUTO and WEBGL mode when failing at creating a valid WebGL Context

6.0.0
* Audio : latest audio core update to fix HTML5 Audio issue with FB Instant Games, and Chrome API deprecation
* Camera : renamed `me.Viewport` to `me.Camera2d` and move it to its own folder
* Container : new `clipping` feature to automatically clip childrens to their parent container bounds (disable by default)
* Core : Removed unnecessary ES6 polyfill (based on melonJS 5.x minimum browser version)
* Core : API update to sandbox all previous language extension under the `me` namespace
* Core : added console debug information (melonJS version & basic device capabilities)
* Core : properly support (requires the official weapp-adapter) WeChat Mini Games (@qinchunren)
* Color : fix the me.Color.toHex8() function
* Debug : fix "undefined width error" when instantiating the debug panel
* Font : fix a regression where drawing a web font was not restoring the renderer context properly
* Input : fix an issue where the focus was sometimes lost when using an integrated WebView (e.g. Instant Games)
* Loader : new loader feature to allow preloading of javascript files
* Math : new vector linear interpolation functions
* Math : new `equals` function for me.Rect shape
* Physic : avoid duplicating the given collision shape through addShape, and directly use the object references
* Physic : gravity property for solid bodies is now a vector object, allowing to defined gravity for both axis
* Physic : new mass property for solid bodies
* Physic : new me.Body.force property allowing to automatically apply a force or acceleration to a solid body
* Physic : me.Body.accel and me.Body.setVelocity are now deprecated and to be replaced by me.Body.force
* Physic : automatically apply any defined physic properties when importing a physic editor JSON file
* Renderable : fix onComplete not being called for me.Sprite single animation frame (@Adrian)
* Renderable : fix animation not cycling when using GUI_Object(s)
* Renderable : fix a regression in Sprite when using Texture Packer
* Renderable : fix floating renderable's bounds following its parent container position (@YosuaHamonangan)
* Renderable : fix a potential parameter mismatch in me.Sprite for an animation `onComplete` callback
* Renderer : use prefixed "image-rendering" CSS properties for non standard browsers
* Renderer : new clipRect function to clip the specified rectangle area
* TMX : allows different tile size per layer (not supported by Tiled, only works with "manually" generated maps) (@YosuaHamonangan)
* TMX : optimised object allocation to lower memory usage (and later GC) when loading a level
* Viewport : new damping feature to enable smooth camera movement
* WebGLRenderer : enable `failIfMajorPerformanceCaveat` by default when attempting to create a GL Context
* WebGLRenderer : feature to change the blending mode (experimental and limited to "normal" and "multiply" for now)
* WebGLRenderer : fix a deprecation warning in Firefox

5.1.0
* Audio : Howler core update (2.0.8)
* Core : window.onReady is now marked as deprecated, and replaced by me.device.onReady
* Container : new `onChildChange` callback for when a child is added or removed
* Input : further improvements to multitouch support (compatibility on latest device/browser)
* Input : new me.input.setTouchAction function to enable/disable gesture by default (default to "none")
* Input : fix a pointer offset issue when using the browser zoom
* Loader : new "withCredentials" setting to specify if cross-site Access-Control requests should be made using credentials
* Physic : new me.collision.rayCast function for basic Line of Sight implementation
* Physic : slight me.Body refactoring to allow adding a physic body to any base me.Renderable
* Physic : new bounce property for solid bodies
* Renderable : `isKinematic` is now true by default except for me.Entity, me.Container and me.GUI object
* Renderable : anchor point and transform are now properly applied to me.Sprite Bounding Rect
* TMX : add support for "Collection of Image" tilesets
* Viewport : apply current transformation when converting given coordinates from localToWorld and WorldToLocal
* Viewport : fix a regression where transforms were not applied anymore to the camera/viewport

5.0.1
* Input : fix a regression with bindPointer
* Loader : fix the progressBar position when resizing the screen

5.0.0
* Audio : Howler core update (2.0.5)
* Audio : added a function to check if audio is muted globally
* Core : fix fullscreen detection when not set on the main canvas
* Core : remove obsolete ES5 shim (it's 2017, update your browser!)
* Core : updated orientation detection, based on the new (draft) Orientation API
* Debug : fixed debug panel toggle features, and automatically display the toggle key
* Geometry : new specific values can be returned through the callback for Observable Vectors
* Input : fix a bug where the gamepad axes may not trigger KEYUP events
* Input : remove deprecated argument type for `me.input.bindGamepad()`
* Input : remove deprecated `mousewheel` event
* Input : remove deprecated `MS` prefixed Pointer Event
* Input : standardize Event.button value and usage across all input models
* Input : me.input.preventDefault now correctly define the default action for pointer events
* Input : fix potential multitouch issues on "hybrid" browsers supporting both TouchEvent and PointerEvent
* Renderable : properly apply transformation and anchor for all me.Renderable objects
* Renderable : move flipX/flipY to me.Renderable, and remove deprecation warning
* Renderable : new `isKinematic` property allowing to opt-out from collision and input events
* Renderable : slightly refactored me.ColorLayer and exposed its me.Color property
* TMX : added support for layer grouping (Tiled 1.0.0)
* Viewport : added a method to unfollow the current target

4.1.1
* Core : fixed a bug in `Number.prototype.round()`
* Core : throw an exception when attempting to add an invalid state in `me.state.set()`
* Core : fixed `falling` and `jumping` flags on `me.Body` when gravity is reversed
* Geometry : fixed a bug in `me.Vector3d.abs()`
* Geometry : added a new `me.Matrix2d.multiplyVectorInverse()` method
* Pointer : fixed `touchstart` events
* Pointer : replaced non-standard `mousewheel` with W3C standard `wheel` events
* Pointer : fixed duplicate `wheel` events

4.1.0
* Audio : updated to latest Howler 2.0.2 (WebAudio resume/seek fixes, and IE related security issues)
* Audio : added a `me.audio.seek` function, to change or get the current position of a specific audio clip
* Core : throw an error message when registering a non valid object in the object pool (i.e. undefined class)
* Loader : added the possibility to configure path (baseUrl) by asset types.
* Loader : added a 'crossOrigin' option to enable/allow cross-origin image loading for WebGL
* Loader : fixed an issue where callbacks were randomly fired twice when refreshing the page (krojew)
* Loader : reduced memory usage (reduced overlay size for the logo, and prevent from creating the Font overlay in WebGL)
* Particles : fixed a (huge) performance regression with particle generation / handling
* Pointer: fixed bug where a device allowing both mouse & touch events would only emit touch events.
* Pointer: fixed a regression with multi-touch event detection on iOS & Android
* Pointer: fixed a regression with callback handling & cleaning in the releasePointerEvent function
* Renderable : fixed a regression in me.Sprite.isCurrentAnimation()
* TMX : TMX maps and renderers are now fully contained in their own space, and do no pollute me.game anymore
* TMX : exposed the TMX renderers API and related utility functions to convert tile to/from pixel coordinates
* TMX : improved API to manage isometric map & coordinates (e.g. vector and shape conversion)
* TMX : added a simple isometric "tile selector" in the isometric map example
* TMX : me.Layer.getTile() will now return `null` if there is no corresponding tile, instead of throwing an exception
* TMX : added a getRenderer() function to me.Layer that returns the layer TMX renderer.
* Viewport : added the possibility to define a global transformation to the viewport
* WebGLRenderer : now properly complain when using NPOT textures, and throw an exception for repetitive ones
* WebGLRenderer : does not create anymore a default overlay for me.Font drawing, unless required (reminder: me.Font+WebGL = Bad!)

4.0.0
* Audio : updated to the latest Howler 2.0.1 version
* Container : added a 'forEach' function that allows to iterate through all children
* Core : largely improved and completed the matrix implementation and usage
* Core : Object.assign polyfill update
* Core : various improvements and fixes to jasmine test units
* Debug : fixed the debug panel display when using the WebGL renderer
* Font : added true support for bitmap font generated out of true type fonts (e.g. Littera, bmfont, bmglypgh, etc...)
* Particles : reduced creation/use of temporary (vector) objects
* Pointer : fixed bug with Chrome on Windows touch devices where touch input would register, but mouse input would not. (credit to BrianRosamilia)
* Pointer : PointerEvent detection is now fully W3C compliant
* Pointer : automaticaly free any defined region if there is no callback left
* Renderable : added a new `currentTransform` property that defines the renderable transformation matrix
* Renderable : transformations can now be automatically applied through the `autoTransform` flag (off by default for user-defined objects)
* Renderable : me.AnimationSheet has been merged into me.Sprite (me.AnimationSheet is now only an alias), and rendering function simplified
* Renderable : fixed image layer first update, when added to a child container (and not directly the root one)
* Renderer : simplified/aligned both the Canvas and WebGL renderer API in a more WebGL fashion
* Renderer : added a subPixel rendering option (off by default)
* Shapes : polygon based shapes can now be freely transformed, and bounding box will be resized accordingly
* TMX : scaling and rotation can now be applied to a tilemap (see me.levelDirector.loadLevel() for example)
* TMX : fixed some issues when loading TMX level into a child container.
* WebGLRenderer : fixed the currentColor alpha not taking in account the "globalAlpha" (now better match canvas renderer)

3.1.0
* Audio : exposed a `me.audio.rate` function to allow modifying the playback rate of the specified audio clip.
* Audio : added back the possibility to stream audio elements (through the `stream` flag when defining audio assets)
* Camera : use the `alpha` component of the given color as the threshold for fading effect
* Color : normalized support for #RGBA and #RRGGBBAA formats (to match CSS standard)
* Core : added a `me.game.updateFrameRate` function to change the renderer framerate at runtime
* Core : simplified the "startup" functions to allow for shorter initialization code (see boilerplate)
* Core : removed previous Ejecta "hacks" (requires the latest Ejecta 2.1/development version)
* Documentation : various fixes and missing items added (e.g me.Object that was missing)
* Debug : debug panel(s) now automatically register themselves upon loading (see boilerplate)
* Input : added support for gamepad analogue axis binding
* Input : fixed a regression with pointer events not firing with "floating" regions (@thedrumchannell)
* Particles : fixed a crash when removing a particle emmiter during a level change/reset
* Renderable : fixed missing `onDestroyEvent` function when adding basic renderables to the game world.
* Renderable : fixed Sprite objects initialization when using a string argument for "image" (@trevorjwilliams)
* TMX : added support for JSON-format external tilesets
* TMX : fixed the clearTile function when using `preRender` and the WebGL renderer
* TMX : fixed `prerender` on browsers that support Canvas2DContextAttributes.alpha
* TMX : disabled animated tiles when using the `prerender` mode (these two are not compatible)
* TMX : fixed a regression with Tile property parsing
* TMX : fixed a regression with level loading when no tilesets are defined.
* TMX : fixed decoding of maps using CSV data format (in Tiled) and exported to JSON
* TMX : added support for typed custom properties (Tiled 0.16)
* WebGLRenderer : added a workaround for Safari resetting WebGL attributes bindings (see #783)

3.0.1
* Core : fixed/improved compatibility with Ejecta (e.g. initialization, CAFF support)
* Input : actually really truly fix pointer event z-ordering, finally

3.0.0
* Audio : updated to the latest Howler v2.0.0 beta version
* Audio : added a `me.audio.resume` function for added convenience (was already possible by calling back `me.audio.play`)
* Container : added an `autoDepth` feature that auto-increments a child's z-coordinate when inserted
* Color : add support for the #ARGB and #AARRGGBB formats
* Core : renamed `Object.extend` to `me.Object.extend` (fixes conflicts with FaceBook SDK and underscore/lodash) (@jdrorrer)
* Core : plugins are now registered to `me.plugins` to prevent collisions within the `me.plugin` namespace
* Core : replaced `String.contains` by its ES6 equivalent: `String.includes`
* Core : replaced `Number.sign` by its ES6 equivalentL `Math.sign`
* Core : `me.game.currentLevel` has been removed in favor of accessing objects through `me.game.world` -- added `me.LevelDirector.getCurrentLevel()` as a stop-gap
* Core : added `me.sys.updatesPerSecond` to configure updating less often than drawing (@Giwayume)
* Entity : new positioning method, where the renderable is positioned according to its anchor and the Entity's body anchor (@Giwayume)
* Examples : added an example showing how to build a basic menu (with a panel, checkboxes and buttons)
* Font : fixed font height not being set when specifying a CSS Unit for the size
* Font : added basic CSS Unit conversion from ‘pt’,’ex’,’em’ to ‘px’ (these are approximation and not guaranteed accurate)
* General : the release build files are no longer versioned; this replaces the old style "melonJS-x.x.x.js" file naming convention with just "melonJS.js"
* Geometry : added a new `me.Vector3d` and `me.ObservableVector3d` class
* Geometry : removed `reverse` method from Vector classes; use `negateSelf` instead
* Geometry : removed `reflect` and `reflectN` methods from Vector classes
* Geometry : fixed `floor` and `floorSelf` methods on Vector classes with negative values
* Geometry : fixed `angle` method on Vector classes
* LevelDirector : level loading is now asynchronous; for sequential behavior, use the LEVEL_LOADED event or new `onLoaded` callback
* LevelDirector : added an `options` argument to the loading method; for specifying a target container, callback, and whether to merge (flatten) object groups
* Input : renamed last remaining mouse-related objects : `me.input.mouse` => `me.input.pointer`, `me.event.MOVEMOVE` => `me.event.POINTERMOVE`
* Input : added HTML5 Gamepad API support, with button and axis remapping
* Input : optimised pointer detection using the quadtree
* Input : now properly respect object z ordering when firing pointer events
* Input : fixed event detection on items in a nested container
* Renderable : prevent position vector re-allocation when pooling renderable objects
* Renderable : renderables are now using a 3d Vector for position, using the z axis for layer ordering.
* Renderable : fixed a distortion issue when scaling and rotating sprites (@Giwayume)
* Renderable : fixed frame position when using cropping in TexturePacker (@Giwayume)
* Renderable : `anchorPoints` now defines the renderable position, scaling and rotation default origin point (@Giwayume)
* Renderable : better animation definition, allowing to set the animation delay on a per-frame basis
* Renderable : added `anchorPoint` setting to the constructor
* Renderer : added `renderer.createPattern()` and `renderer.drawPattern()`
* Shapes : added support for the free Physic Body Editor tool (in addition to the existing PhysicsEditor support)
* Shapes : refactored `me.Rect` to inherit from `me.Polygon`
* Texture : added support for per-frame pivot points in animations (@Giwayume)
* TMX : added hexagonal map support (@matthewmmorrow)
* TMX : optimized all renderers to be more GC friendly (using the pooling system for temporary objects)
* TMX : refactored the `me.TMXTileMap` object, so that it can be used to easily add level into a container object
* TMX : `me.ImageLayer` is now drawn relative to the viewport boundary, and can be anchored appropriately
* TMX : internally normalizes XML into the same JSON format supported by Tiled; cleans up many compatibility functions and removes several fallback cases
* TMX : removed `me.TMXTileMap.moveToCenter` and `me.TMXTileMap.reset` methods
* TMX : added support for per-frame animation delay to Tiled Objects (for tileset animations)
* TMX : added support for layer data encoding in JSON map format (Tiled 0.13)
* TMX : added support for evaluations in TMX data; see spike entities in the platformer for a useful example
* TMX : fixed an isometric rendering bug with odd tile heights
* TMX : throw an error message when using map exported in XML (deprecated in Tiled 0.15)
* TMX : allow to parse the `backgroundcolor` attribute as formatted in Tiled 0.15 (#AARRGGBB)
* TMX : use the new `columns` property (if available) when parsing maps (Tiled 0.15)
* TMX : fixed a regression in AD tile rotation (squares tiles only)
* Video : optimized ImageLayer repeat modes (repeat modes require power-of-two sized images for WebGL)
* Video : added `fill-min` and `flex` scaling modes
* Video : animations are now able to skip frames for low FPS devices and high-speed animations
* WebGLRenderer : added a `repeat` parameter to `createTexture` method

2.1.4
* Audio : fixed the audio-enable workaround on iOS9
* Tween : fixed potential re-initialization issues when recycling tween objects.

2.1.3
* Audio : fixed an issue with decoding audio data on Opera
* Audio : updated to the latest 2.0 Howler beta (fixes a loop issue on Chrome mobile, and touch event for iOS playback)
* Core : fixed an exception in the Map polyfill
* Documentation : added docs for the Renderer interface, including the beta WebGLRenderer and shader
* Particles : fix an exception in `me.ParticleContainer` (introduced in 2.1.2)
* TMX : fixed TMXLayer opacity when preRender is enabled
* TMX : fixed ImageLayer opacity
* Video : fixed a regression where `me.device.getPixelRatio()` no longer works when called before `me.video.init()` (introduced in 2.1.0)
* WebGLRenderer : fixed a bug that causes a compile failure with the quad fragment shader on a small number of platforms

2.1.2
* LevelDirector : do not replace Tile Object's `renderable`
* Renderable : fixed renderable bounds initialization with object pooling

2.1.1
* Container : fixed child bounds when manipulating the container position.
* Core : fixed a regression when using the pooling system with renderables.
* Examples : fixed conditional debugPanel loading in cocoonJS
* Font : fixed the drawStroke function (@zoiba)
* Input : fixed an uncaught exception with the 'maxTouchPoints' polyfill under Chrome 43+
* Input : fixed/improved `pointerEvent` and `pointerLeave` event bindings for the sample GUI Object
* Loader : throw an exception indicating to use JSON if XML parsing is not supported by the browser/platform

2.1.0
* Audio & Loader : file/clip names passed to various methods are now case sensitive. Removed uses of toLowerCase on variables.
* Audio : properly dispose of audio resources when using cocoonJS
* Container : `getChildByProp` and friends now accepts a RegExp for value matching
* Color : added high-precision color transformation for me.Color
* Core : added `me.pool.exists` (@xorinzor)
* Core : fixed collision detection with nested Containers
* Core : added `me.game.HASH` to pass key-value options in the URL
* Core : now uses only case-sensitive string matching; DoN't MiX cAsE!
* Device : added browser language detection
* Entity : entity bodies now have a default shape if not overridden by the entity constructor.
* Entity : renderables are now positioned relative to the body bounds
* Font : updated me.Font to work with me.Color (@xorinzor)
* Font : updated the me.Font api to be consistent with me.BitmapFont and the Renderer class
* Font : added support for WebGL (using me.Font is however not recommended for performances reason)
* Input : added support for `pointerenter` and `pointerleave` events (@TheManuz)
* Input : allow regions to be any shape when registering pointer event, and not just me.Rect
* Input : `releasePointerEvent` now accepts an optional extra argument that references "which callback" to release
* Particles : fixed angle variation and speed variation in `me.ParticleEmitter`
* Renderable : normalized constructors for `me.Sprite` and `me.AnimationSheet` (see the wiki upgrade guide)
* Renderable : removed `hWidth` and `hHeight` properties
* Shapes : added basic support for the PhysicsEditor tool (mainly shapes definition)
* Texture : added support for the WebGL Renderer
* Texture : texture atlas can now be created using a “standard” sprite sheet
* Texture : `me.TextureAtlas` has been renamed to `me.video.renderer.Texture`
* TMX : added parsing of the new `id` (unique ID) property for objects (Tiled 0.11.0)
* TMX : fixed horizontal, vertical and antidiagonal flipping for tile objects
* TMX : remove deprecated "transparency color" - use PNG images with alpha channel instead
* Video : refactored the me.video.init to be more flexible in terms of mandatory/optional arguments
* Video : turn canvas transparency off by default; can be enabled by passing `options.transparent = true` to `me.video.init()`
* Video : renderers are now classes that can be instantiated with `new me.CanvasRenderer` and `new me.WebGLRenderer`
* Video : added support for the `image-rendering` CSS property standard "pixelated" value
* Video : added new `scaleMethod` option : `fit`, `fill-max`, `flex-height`, `flex-width`, and `stretch`; replaces old `maintainAspectRatio` flag (@Djokal)

2.0.2
* Audio : automatically cleanup `onend` callbacks in `me.audio.play`
* Audio : `me.audio.play` now applies the `loop`, `onend`, and `volume` properties only to the expected sound instance ID
* Audio : fix `me.audio.unmute()`
* Audio : updated to the latest Howler 2.0 build (various fixes and improvements)
* Audio : added `instance_id` parameter to `mute` and `unmute` methods
* Audio : updated documentation
* CanvasRenderer : fixed an issue/regression with the `globalAlpha` functions
* Core : fixed collision detection between `me.Ellipse` (circle) and `me.Line` shapes
* Core : fixed renderable positioning with nested me.Container objects
* Core : fixed an uncaught exception in IE9 with Float32Array
* Documentation : fixed anchor positioning
* Documentation : added anchor target highlighting
* Documentation : fixes in me.Font, me.BitmapFont, and me.Entity
* Entity : removed `me.ObjectSettings`
* Font : fixed globalAlpha not being set when using `me.Font.setOpacity()`
* TMX : fixed an uncaught exception when loading a map with an empty object layer (thanks @Tiagojdferreira)

2.0.1
* Core : fixed loading under CocoonJS when using Canvas+
* Shapes : replaced the isometric magic numbers used for scaling, by proper and more accurate math constants (ldd)
* Audio : fixed sound looping
* Audio : fixed onend callback not being repeatedly fired when looping a sound
* Audio : cleaned the onend callback when stopping a sound
* Audio : added a me.audio.fade() function

2.0.0
* Core : implemented a new shape based collision system for the collision layer
* Core : added user agent detection for Kindle devices
* Core : fixed the collision response for circles (me.Ellipse with a uniform radius)
* Shapes : renamed me.PolyShape to me.Polygon and simplified the constructor (no longer needs a fourth param)
* Shapes : added a new shape: me.Line
* Shapes : added multi shapes support for body
* Shapes : added rotation and scaling support for `me.Polygon`/`me.Line` shapes.
* Audio : the Howler library has been updated to the last 2.0 beta
* Audio : removed the cocoonJS hack, as the pause/resume function have been fixed through Howler 2.0
* Entity : added automatic collision response handling (not fully done yet actually)
* Container : fixed an issue where "non-floating" containers always passed the in-viewport test
* CanvasRenderer : All fill & stroke methods have removed the color & line width parameters. Use the new setColor and setLineWidth methods.
* CanvasRenderer : Removed strokeLine, was duplicate with drawLine
* WebGLRenderer : New WebGLRenderer has reached "alpha", and can be enabled by passing the `me.video.WEBGL` flag to `me.video.init()`
* Particles : fixed randomness in the emitter for scaling and rotation of particles
* Particles : fixed widget drawing in Particle Editor
* TMX : added rotation support for Polygon/PolyLine objects (Tiled 0.10+)
* TMX : added support for tileset animations (Tiled 0.10+)
* TMX : fixed isometric projection for Polygon/PolyLine objects
* TMX : fixed TSX external tileset loading

1.1.0
* Core : reorganised source code for all basic object definition/augmentation
* Core : new CI and unit testing frameworks
* Core : new object inheritance mechanism: http://github.com/parasyte/jay-inheritance
* Core : added array random and weightedRandom functions (aaschmitz)
* Core : added a Base64 Encode function (aaschmitz)
* Core : new `me.Error` class to help better track down exceptions' origin
* Core : brand new "Separate Axis Theorem " based collision algorithm (support polygon/ellipse, and provides more accurate collision response)
* Core : added collision filtering support
* Core : added a spatial partitioning algorithm (QuadTree) for super fast collision detection
* Container : `addChild` and `addChildAt` now return the added child
* Video : refactored canvas drawing out to me.CanvasRenderer. Video is now agnostic of rendering target. Use me.video.renderer to call things like getWidth, getHeight, getCanvas, getContext, etc.
* Video : constructor parameters changed. 2nd parameter now expects renderer type. For now, just supports me.video.CANVAS
* CanvasRenderer : object is passed to the draw calls of each object in the world Container. Implemented various draw apis fillRect, and fillArc for example. me.Font still requires an instance of Context2d.
* Renderable : renamed `me.SpriteObject` to `me.Sprite` and `me.ObjectContainer` to `me.Container`, for a cleaner API
* Renderable : constructors refactored to accept x & y numeric values, over a single vector object. Effects: me.Container, me.Rect, me.PolyShape, me.Ellipse, me.Renderable
* Shapes : setShape updated to accept x & y numeric values over a vector object for: me.Rect, me.PolyShape, me.Ellipse
* Camera : fixed viewport bounds setting when using isometric map (Juhana Paavola)
* Entity : entity object redesign with a full polygon shape based physic body implementation
* Entity : `me.ObjectEntity` has been renamed to `me.Entity` to avoid confusion between the old and new entity component.
* Audio : fixed some audio load issues and error callbacks
* Audio : sync'ed with last Howler 1.1.25 version (fixes numerous issues, see official changelog for more details)
* TMX : fixed the background color drawing when the level is smaller than the display canvas
* TMX : fixed the getTile function returning wrong tiles when using isometric maps
* TMX : fixed collision layer rendering issue with isometric map
* TMX : fixed world container size not being updated after a new level is loaded

1.0.2
* Core : improved general compatibility with IE9/IE10 (Desktop/Mobile/Tablets)
* Geometry : added basic type check for the `me.Vector2d` constructor
* Input : fixed event detection on Chrome 35+

1.0.1
* Core : removed unused `Object.mixin` method, (caused compatibility issues with socket.io and other libs)
* Entity : disable falling flag when gravity is disabled
* Entity : fix an exception in ObjectEntity.checkCollision()
* Entity : fixed a regression on breakable tiles
* Entity : use width and height by default if spritewidth and spriteheight are not defined
* Entity : throw an exception if mandatory fields width and height are not defined
* Entity : fixed an exception in ObjectEntity.flipX/Y()
* Loader : fixed asset loading when named as a number
* ObjectContainer : use cyclic zIndex by default instead of Infinity
* Audio : sync'ed with last Howler version (as now officially and properly support CocoonJS)
* Audio : melonJS now throws an exception when attempting to load audio assets before audio is initialized
* TMX : fixed a potential issue with ImageLayer when ratio is set to 0 in Tiled
* Font : fixed opacity property usage for me.BitmapFont object.
* Renderable : added a tap and hold feature to the me.GUI_Object object (juhanapaavola)
* Particles : fixed the particle emitter bounds (aaschmitz)
* Input : added several keyboard keys for input mapping (aaschmitz)

1.0.0
* Core : now pass the elapsed time as a parameter when calling any object update function
* Core : cleaned-up/renamed conflicting set function in shape and font objects
* Core : added new shapes objects (Ellipse, Polygon) on top of the existing Rectangle one
* Core : added a mixing property to object (insidiator)
* Core : deprecated object manipulation (add, remove) have been removed from me.game
* Core : renamed the `me.entityPool` API to `me.pool` and related functions (see documentation & upgrade guide)
* Entity : deprecated helper function (doJump, doWalk) have been removed
* ObjectContainer : renamed getEntityByProp to getChildByProp
* ObjectContainer : getChildByProp now returns all matching object type and not only "entities"
* Camera : camera bounds are now defined as a rectangle and not only in width and height
* Loader : added resource information to loader progress event (warpten)
* Loader : added loading of TMX data from javascript (json) objects (paulmedwal)
* Color : melonJS now defines a new me.Color class for advanced color manipulation
* Particles : added basic Particle System, with emitters and particles (aaschmitz/insidiator)
* Particles : added a particle emitter editor, see the example folder (insidiator)
* Device : added full cross-browser support for the Fullscreen API (see me.device)
* Device : added support for the vibration API (me.device.vibrate)
* Device : renamed the me.save.delete function to me.save.removed (delete is a reserved keyword)
* Device : added support for the visibilitychange API (pause/stop state on window show/hidden status)
* Audio : modernised (and also mobile compatible) web audio API based on the awesome Howler library
* Input : added the possibility to disable globally or per key the default browser action
* Input : automatically enable keyboard even on desktop type devices
* Input : the registerPointerEvent function now only accepts the standardized Pointer Event names.
* TMX : added proper support for all shape type (collision is still however resolved using AABB detection)
* TMX : XML TMX map are now converted to a JXON object on-the-fly, allowing to remove duplicated parsing code
* TMX : added the Tiled "type" property to TMXObject
* TMX : melonJS will now respect the object size as defined in Tiled when parsing/creating related object in the game world
* Timer : added a setTimeout and setIntevral function obeying the engine pause state
* Tween : fixed tweens to properly maintain time state when paused
* Renderable : `collisionBox` has been replaced by a more cleaner implementation (see `getShape`/`addShape`/`getBounds`)
* Renderable : the flicker function now takes the global flickering duration in ms (as opposed in frame count)
* Renderable : removed the visible property

0.9.11
* Documentation : numerous fixes and improvements
* General : fix initial loading for me.save, and update documentation
* General : fix detection of localStorage on some phones (agmcleod)
* General : fix uncaught exception when objects without a position vector are added to a container
* Input : fully support event-driven key input with me.event.KEYDOWN and me.event.KEYUP
* Input : multiple keys bound to the same action will no longer cancel each other
* Input : fixed pointerEvent support on IE11
* ObjectContainer : fixed rendering of nested containers (again) - Thanks to Peter Hull
* ObjectContainer : fixed getEntityByProp with nested containers
* Animation : (quick) fixed hWidth and hHeight not being updated when the frame size is different
* Core : better support object reset through a onResetEvent function when using object pooling
* Tween : updated the me.Tween object to be usable with the object pooling mechanism
* Font : added a trimRight polyfill to the String class to help fixing multi-line ASCII rendering
* Font : added a drawStroke function
* Font : fixed a bug that broke some CSS font-family names, like `monospace` and `"Trebuchet MS"`

0.9.10
* Core : fixed object `visible` flag not being set based on their parent group visible status
* Core : fixed both `pauseOnBlur` and `StopOnBlur` being enabled by default
* TMX : fixed the imageLayer reset bug (when unsubscribing the viewport change event)
* TMX : fixed an undefined tileset issue when adding a new Tile through the `setTile` function
* Documentation : fixed the parameter value of the hasChild function
* Renderable : moved the opacity related getter/setter function into the Renderable class
* Renderable : fixed group opacity setting fully overwriting renderable opacity settings
* ScreenObject : fixed cases where ScreenObjects may not be considered in the viewport
* ObjectContainer : fixed rendering of nested containers

0.9.9
* General : added proper support for a jslint task and cleaned source code accordingly (nvlbg)
* General : added a renderable container object (me.ObjectContainer) and reorganize `me.game` accordingly
* General : added `me.game.world` as a reference to the game world root object container.
* General : added a new me.save class to manage localStorage, and moved (deprecated) the old me.stat to the plugin repository
* Core : improved game pause management (by swmuron)
* Core : added a `me.device` object containing device specific capabilities and events (agmcleod)
* Core : moved all device read-only flags to the new me.device object
* Core : fixed Opera Mobile detection when sniffing user agent
* Core : improved orientation change detection, added me.device.orientation and a specific minpubsub channel
* Core : moved debug flags to the debugPanel plugin
* Input : fixed accelerometer event registration when supported
* Input : added support for windows 8 accelerometer (Halfman)
* Input : improved mouse wheel event support to be compatible with all recent browsers
* Input : added support for the touchCancel and mousecancel events
* Input : added TAB key definition to key bindings (agmcleod)
* Loader : refreshed the loader a bit, and added the new logo
* Loader : fixed binary loader (agmcleod)
* Video : added support for CocoonJS 1.4 ('antialias' parameter and the new `dispose` function)
* Video : added proper support for video scaling on High-DPI devices (no longer requires the JS hack in the index HTML file)
* Video : fix `me.sys.scalingInterpolation` when display is resized.
* TMX : fixed default group opacity value not being applied to child objects.
* TMX : optimized tile rendering, by using a tileset reference in Tile object
* TMX : added preliminary support for non rectangular shapes in Tiled (although currently converted to me.Rect)
* TMX : fixed multiple image backgrounds with `ratio` properties that are different values
* TMX : fixed me.ImageLayer drawing being delayed by one frame
* Font : Font objects now properly extend me.Renderable
* GUI : `HUD` objects have been completely replaced by me.ObjectContainer; See Platformer example for new HUD implementation pattern.
* Animation : the `animationspeed` property, now defines the delay between frames in terms of milliseconds (as opposed to framecount)
* Animation : allow animation callback to prevent resetting to first frame by returning `false` *really fixed this time*
* Shapes : new shapes added for future expansion: me.Ellipse, me.PolyShape
* Shapes : `me.Rect.getRect()` renamed `getBounds()`
* Tween : the tween implementation has been updated to the last official r11 version.
* Camera : renamed the mislabeled worldToScreen and ScreenToWorld, and fixed a bug in one of the function.

0.9.8
* Renderable : added ShoeBox Packed Texture Support (see `me.TextureAtlas`)
* Loader : the `tps` data type has been changed to a more generic `json` data type (agmcleaod)
* Input : added MSPointer support (Halfman)
* Input : normalized API and management of input event and enabled multi-touch for PointerEvent
* Input : added throttling support for `****move` events
* Core : main loop now uses requestAnimationFrame by default with a fallback to setTimeout
* Video : added the possibility to specify a maximum size when enabling video scaling
* Video : automatically limit the maximum size if the corresponding CSS properties are set
* TMX : added the possibility to specify different axis value for the scrolling ratio
* Font : fixed drawing characters with charCode smaller than the firstChar value.
* Renderable : allow animation callback to prevent resetting to first frame by returning `false
* Core : added "Mobile" to `me.sys.isMobile` UA sniffer (fix Firefox OS detection)

0.9.7
* General : melonJS now uses Grunt, the task manager, for the build system
* General : game objects will not update unless inside the viewport or `obj.alwaysUpdate` flag is enabled
* Audio : preliminary audio support for mobile devices (iOS6 for now)
* Core : added a `me.sys.isMobile` flag to detect running on a mobile device
* Core : now using `screencanvas` extension for CocoonJS
* Core : fixed `me.game.remove()` destroying the object too early
* Entity : ObjectEntity is now composed with a `renderable` component (does not anymore inherit from AnimationSheet)
* Entity : renderable default position is now set based on the me.ObjectEntity default anchor point.
* Entity : fixed ladder collision detection/management
* Examples : new collision_test example (see ticket #103)
* Examples : new font_test example
* Font : changed default alignement to `left`/`top`
* Font : added multiline support for `me.Font` and `me.BitmapFont`
* Geometry : most `me.Vector2d` methods return a reference to `this`, to allow method chaining
* Input : added a `me.input.unlockKey()` function that allows to manually unlock key (DblK)
* Loader : fixed loader when repeatedly calling the preloader
* Renderable : new base class for any objects that needs to draw (Sprite, ImageLayer, GUI, etc...)
* Renderable : added TexturePacker Support (see `me.TextureAtlas`)
* TMX : fixed `me.ImageLayer.ratio` on Firefox & Opera
* TMX : allows changing the imageLayer default origin using the imageLayer anchorPoint
* TMX : added a new `me.game.getEntityByProp()` function (DblK)
* TMX : added JSON map parsing support
* TMX : small optimization for isometric rendering (`pixelToTileCoords()` function)
* TMX : fixed access to inherited properties
* TMX : added an entry point for a potential gzip/zlib TMX decompression plugin
* TMX : fixed object positioning on isometric maps (andyveliz)
* TMX : property value convention for automatically JSON-decoding; prefix with `json:`
* Video : fixed `viewport.shake()`
* Video : optimized framerate on cocoonJS platforms by using the 'screencanvas' extension
* Video : disable video scaling interpolation by default

0.9.6
* General : fix compatibility issue with previous iOS(5.x) and Android version
* Core : workaround for useNativeFrame when cancelAnimationRequest is not supported
* Audio : added volume and mute control settings
* Audio : added the possibility to stream audio elements
* TMX : code optimization to lower memory usage
* TMX : fixed layer scrolling when using pre-rendering
* Loader : fixed `me.loader.load` not adding TMX into the `me.levelDirector`

0.9.5
* Audio : added mp4/aac pre-loading support
* Audio : added codec selection based on audio support level
* Core : fixed requestAnimationFrame
* Core : added an official plugin API
* Core : fixed a object removing and sorting lock issue
* Core : added a 'floating' property for renderables
* Core : added Object Pooling support
* Core : fixed the `me.game.getEntityByName` function when using camelcase names
* Debug : added a simple debug panel plugin
* Font : fixed font name starting with a decimal value
* Font : added changes to allow specifying a flat number of px,em, etc for font sizes.
* Font : added support for comma separated font names like in CSS
* Event : added Daniel Lamb minPubSub library for event publishing
* Event : fixed touch event support detection on cocoonJS
* Event : added `click`, `dblclick`, `tap` events
* Event : fixed mouse event conflict and mousewheel event
* Geometry : added a function to return the angle between two vectors
* Input : me.GUI_Object's onClicked() function has been renamed to onClick()
* Loader : use asynchronous mode when loading XML files
* Entity : added spacing and margin capacities for sprite (same as Tile Map Sprite)
* Entity : fixed flickering when using requestAnimationFrame
* Entity : added opacity setting
* Entity : fixed visible property automatic setting
* Entity : moved collision check outside of the Entity Object
* Entity : cleaned and renamed the collision utility function
* Entity : added the possibility to check for multiple collision
* Entity : added a `collideType` function to check for collision with a specific type
* Entity : moved collisionBox from SpriteObject to Entity Object
* Entity : added a distanceToPoint, angleTo and angleToPoint function
* Tween : fixed tween when pausing game
* Tween : various fixes and optimization from the official repository
* TMX : fixed a bug that was preventing a non visible layer to be set visible later
* TMX : fixed the clearTile function on non visible layers (e.g. collision map)
* TMX : added official support for Opacity in TiledLayer, TMXLayer, colorLayer and ImageLayer
* TMX : added support for TSX files
* TMX : added a `repeat` property to Image Layer instances, similar to CSS background-position
* TMX : parallax layer is now based on the new "official" Image Layer support (from Tiled 0.9.0)
* TMX : fixed the `getObjectGroupByName()` function
* TMX : added support for custom tile type
* Tutorial : fixed camel case issue in resource names
* Tutorial : update the parallax part to reflect last changes in melonJS (Image Layer)
* Video : added support for display scaling
* Video : added a setImageSmoothing function
* Example : added "whack-a-mole" as an official example
* Example : added a new "platfomer" example (using legal assets) and removed alex kidd based examples

0.9.4
* General : melonJS is now only using Google Closure (removed YUI compressor)
* General : melonJS is now ES5 strict mode compliant
* General : added a .editorconfig file to provide basic rules to editors
* Core : added a flag to enable/disable automatic pause on loosing/gaining focus
* Core : fixed rendering loop when using requestAnimationFrame (parasyte)
* Core : added a renderCollisionMap debug setting (parasyte)
* Core : use console.error instead of window.alert
* Core : added the possibility to specify a user-defined sort function
* Core : fixed mixing screenObject added as object, and TMX level loading
* Core : fixed screenObject when extending update & draw function
* Entity : added an anchor point for renderables (through SpriteObject)
* Entity : added rotation support (through SpriteObject)
* Entity : added the possibility to pause an animation (parasyte)
* Entity : fixed default position by using top-left coordinates as in Tiled
* Entity : fixed invisible entities being removed when colliding
* Font : fixed me.Font horizontal alignement
* General : fixed & enhanced object/memory deallocation when switching levels
* General : rewrote the parallax code using the new Generic Image Layer Object
* General : added support for vertical parallax layer
* Geometry : added a function to test for vector "equality"
* Geometry : added a couple of Self function (to help avoid object creation)
* Loader : fixed a case issue between filename and asset name
* Input : added the possibility to check for mouse event based on world or screen coordinates
* Input : fixed a false-positive issue at initialization, and usage of special keys (parasyte)
* TMX : added dynamic layer rendering (configurable globally or per layer through Tiled)
* TMX : added Image Layer Support (Tiled daily builds only)
* TMX : added support for the new map background property (Tiled daily builds only)
* TMX : added a Color Layer (used when a background color is defined)
* TMX : another round of clean-up and various bug fixing
* TMX : added support for TMX Object without name (parasyte)
* TMX : added preliminary support for polygon and polyline objects (parasyte)
* TMX : fixed visible flag and user-defined properties not being applied to ObjectGroup
* TMX : fixed rendering issue with transformed tiles (AD, H, V)
* TMX : fixed display of map being smaller than the viewport
* TMX : fixed TMXObject not being declared correctly under the "me" namespace
* Utils : fixed the HexToRGB function and added support for the 3 char format (#hhh)
* Tween : fixed exception in the tween library (parasyte)
* Documentation : corrected and added missing documentation

0.9.3
* General : better error management and reporting
* General : added a dummy console.log for platforms not supporting it
* General : melonJS now uses Google Closure for library minification
* General : added a global gravity setting that will override entities default value if defined
* Core : now properly calls all objects onDestroyEvent function when resetting game
* Core : added the possibility to define a callback when a level is fully loaded
* Core : added a couple of utility functions (degToRad, radToDeg)
* Core : fixed GUID creation when passing a non string parameter
* Core : only check for collision when the projection vector is set
* TMX : global rewrite, code optimization and clean-up
* TMX : added support for isometric map loading and display
* TMX : added support for perspective map loading and display
* TMX : relaxed TMX property case sensitive checks
* TMX : added tile rotation support (Tiled 0.8.0)
* TMX : fixed level name property not being set, and use it when required
* LevelDirector : fixed the nextLevel & previousLevel functions
* Loader : added binary file support
* Loader : added possibility to dynamically load any resources (i.e. during the game)
* AnimationSheet : the entire sprite-sheet is now use to create the default animation
* Entity : fixed CollisionBox not being properly used on y axis when checking for collision
* Entity : fixed CollisionBox issue when dealing with sub-pixel positioning
* Entity : fixed setVelocity not setting y velocity when x velocity is null
* Entity : added missing properties (GUID, name) in InvisibleEntity
* Entity : fixed res.obj not defined in InvisibleEntity
* HUD : added a removeItem function
* GUI  : rewrote the GUI Object accordingly to the new event management
* Geometry : added a containsPoint function
* Geometry : added a floor() and ceil() function to Vector2d
* BitmapFont : fixed BitmapFont ignoring  'center' alignment
* BitmapFont : avoid implicit object conversion when rendering a bitmapFont
* Input : fixed use of numeric keys by using a proper constant value.
* Input : rewrote mouse event management
* Input : added touch event management (with mouse event emulation)
* Input : (beta) multitouch support
* Input : added Accelerometer event management
* Documentation : added a lots of missing documentation on various API
* Documentation : added JS syntax highlighting in the tutorial
* Documentation : don't use onDestroyEvent to manage score in the examples
* Documentation : exposed more TMX objects and APIs

0.9.2
* General : melonJS is now licensed under the terms of the MIT License
* General : added some Cake magic, allowing to use melonJS with CoffeeScript (by scan)
* General : added melonJS UML Class Diagram in the official repository (by Ben2303)
* General : melonJS now properly stays in it's own namespace (me)
* Audio : configurable behavior in case of audio loading error
* Core : fixed a shaking bug when collision box is not aligned with the sprite box
* Core : fixed collision detection bug (object being tested again itself)
* Core : refactored fading function using Tween objects (API CHANGE, see documentation)
* Core : added a helper method to know the sign of an number
* Core : corrected variables definition (global->local)
* Core : added a GUID (Game Unique Identifier) to objects
* Core : getEntityByName now also returns non Entity Object (like layers)
* Core : fixed state change when using custom state values
* Core : me.game.collide now also returns an object reference in the collision vector
* Core : renamed and correctly initialize the localStorage flag capability
* Documentation : various documentation correction and improvements
* Entity : added friction management
* Entity : updateMovement function now returns a collision "vector" (API CHANGE, see documentation)
* Entity : refactored/cleaned-up movement/collision function
* Entity : added support for multiline spritesheet (fixed cell size)
* Entity : added the possibility to define a specific transparent color for spritesheet
* Entity : implemented a resize function, allowing to resize a sprite on the fly
* Entity : optimized/refactored SpriteObject
* Entity : fixed object with 1 single sprite (no animation) not begin updated
* Entity : added the possibility to also specify a callback when an animation is over
* Entity : fixed an initialization issue when using melonJS without a Tilemap
* GUI : corrected me.GUI_Object and added missing documentation
* GUI : marked me.GUI_Object as deprecated, as it will be rewritten in a next release
* Event : also cancel event bubbling
* Font : added support for multiline fontsheet
* HUD : added a setItemValue() function
* HUD : corrected display issue on Opera
* Loader : added possibility to add graphics resources after pre-loading (e.g. ingame)
* TMX : use native Base64 decoding when available
* Viewport : object to follow can either be a Object Entity or a position Vector
* Viewport : fixed default value (if parameter not specified) for Axis to follow on
* Video : cleaned-up the applyRGBFilter function

0.9.1
* Core : "cache image" option (disabled by default) to use canvas instead of directly using Image Object
* Core : add onPause and onResume callback when game is paused/resumed on losing/gaining focus
* Core : added possibility to pass more than 1 extra argument to me.state.change (extra arguments will be passed to the reset function of the target object)
* Core : object can now only be destroyed using me.game.remove(obj), made of ObjectEntity.destroy a private function
* Core : beta dirty Rectangle support (only working for non scrolling level for now)
* Core : experimental webGL wrapper
* Core : added a getEntityByName function
* Core : fixed some kind of "lag" issues when deleting objects
* Core : improved the requestAnimFrame usage, and fallback to setInterval. me.sys.useNativeAnimFrame to enable it (disable by default)
* Core : optimized the way objects are managed in the game loop
* Core : defined (and used) a Object.defineProperty function to replace __defineGetter__ / __defineSetter__ (was not supported on IE9/IE10)
* TMX : implemented Tiled "transparency" property for Tileset, allowing to specify which color should be transparent (note: this slows down level loading)
* TMX : fixed unnecessary canvas creation for the collision layer (should free some memory)
* TMX : cleaned/optimized data loading and fixed an issue on FF with XML parsing of "big" Base64 encoded maps (only first nodeValue was parsed by the engine)
* TMX : added support for CSV data encoding
* TMX : added support for flipped tiles, as supported in Tiled 0.7
* TMX : added multiple tileset support
* TMX : added a "background_image" property. To be set through Tiled, and allowing to specify a fix background.
* Entity : merge AnimatedSpriteObject into SpriteObject. SpriteObject now takes an optional additional argument to create an animated sprite
* Entity : added a distanceTo function
* Viewport : fixed camera refresh when changing "deadzone" values
* Loader : added a "onProgress" callback to get progress notification, removing the need to poll the loader each frame for loading progress
* Loader : fix progress notification when TMX files are loaded into the levelDirector
* Loader : added a retry counter for the audio loading : script will now stop and throw an exception after 3 unsuccessful loading attempts.
* Video : renamed "applyEffect" to "applyRGBFilter", and fixed an issue on Opera
* Audio : fixed compatibility issues with IE9/10
* Geometry : added a merge function to me.Rect

0.9.0
* Documentation : API documentation using jsdoc-toolkit (finally!)
* Geometry : define getter for me.Rect coordinates (simplify code)
* Level : support for fadeOut/fadeIn effect in me.LevelEntity (when changing levels)
* Entity : correctly implemented InvisibleEntity Objects (no longer inherit from ObjectEntity)
* Entity : makes SpriteObjet inherit from me.Rect (make it easier to manage sprite pos and size)
* Loader : cosmetic update of the preloader screen
* Viewport : "rounding" issue fix in the viewportEntity (~~30% less CPU usage on Safari/OSX!)
* TMX : cleaned & refactored tilemap collision detection (still not perfect though)

0.8.0
* TMX : support for "TiledObject" (as supported in Tiled 0.6.2)
* Entity : re-factored constructor call to Object Entities (to use the settings obj produced through Tiled)
* Entity : moved collision function from AnimatedSpriteObject to ObjectEntity

0.7.9
* Viewport : added some effects to the camera object (shaking, fading, ...)
* Viewport : re-factored and fixed the camera/viewport code
* Core : re-factored public objects using John Resig Inheritance mechanism.
* Core : fixed the "bootstrap" (unnecessary double call)
* Entity : re-factored parallax code & corrected a bug that was causing the layers to be drawn 2x times
* Audio : partially fix crash audio in safari when audio is enabled
* Core : fixed gfx glitches (rounding issues)

0.7.6 (May 16, 2011)
first public version with alex4 !
www.melonjs.org is live :)