From 77a8dc321f495340f8215bc1fb44bf86ac381310 Mon Sep 17 00:00:00 2001
From: niondir <tobiall@niondir.de>
Date: Tue, 7 Jan 2014 10:58:00 +0100
Subject: [PATCH] phaser.d.ts corrections

---
 build/phaser.d.ts | 3393 +++++++++++++++++++++++----------------------
 1 file changed, 1697 insertions(+), 1696 deletions(-)

diff --git a/build/phaser.d.ts b/build/phaser.d.ts
index 33ec8578..1e00927e 100644
--- a/build/phaser.d.ts
+++ b/build/phaser.d.ts
@@ -1,708 +1,708 @@
 declare class Phaser {
-      static VERSION: string;
-      static DEV_VERSION: string;
-      static GAMES: Array<Phaser.Game>;
-      static AUTO: number;
-      static CANVAS: number;
-      static WEBGL: number;
-      static SPRITE: number;
-      static BUTTON: number;
-      static BULLET: number;
-      static GRAPHICS: number;
-      static TEXT: number;
-      static TILESPRITE: number;
-      static BITMAPTEXT: number;
-      static GROUP: number;
-      static RENDERTEXTURE: number;
-      static TILEMAP: number;
-      static TILEMAPLAYER: number;
-      static EMITTER: number;
-      static BITMAPDATA: number;
-      static CANVAS_FILTER: number;
-      static WEBGL_FILTER: number;
+    static VERSION: string;
+    static DEV_VERSION: string;
+    static GAMES: Array<Phaser.Game>;
+    static AUTO: number;
+    static CANVAS: number;
+    static WEBGL: number;
+    static SPRITE: number;
+    static BUTTON: number;
+    static BULLET: number;
+    static GRAPHICS: number;
+    static TEXT: number;
+    static TILESPRITE: number;
+    static BITMAPTEXT: number;
+    static GROUP: number;
+    static RENDERTEXTURE: number;
+    static TILEMAP: number;
+    static TILEMAPLAYER: number;
+    static EMITTER: number;
+    static BITMAPDATA: number;
+    static CANVAS_FILTER: number;
+    static WEBGL_FILTER: number;
 }
 
 declare module Phaser {
-      class Camera {
-            constructor(game: Phaser.Game, id: number, x: number, y: number, width: number, height: number);
-            game: Phaser.Game;
-            world: Phaser.World;
-            id: number;
-            x: number;
-            y: number;
-            width: number;
-            height: number;
-            view: Phaser.Rectangle;
-            screenView: Phaser.Rectangle;
-            bounds: Phaser.Rectangle;
-            deadzone: Phaser.Rectangle;
-            visible: boolean;
-            atLimit: { x: boolean; y: boolean; };
-            target: Phaser.Sprite;
-            private _edge: number;
-            static FOLLOW_LOCKON: number;
-            static FOLLOW_PLATFORMER: number;
-            static FOLLOW_TOPDOWN: number;
-            static FOLLOW_TOPDOWN_TIGHT: number;
-            follow(target: Phaser.Sprite, style?: number): void;
-            focusOnXY(x: number, y: number): void;
-            update(): void;
-            checkWorldBounds(): void;
-            setPosition(x: number, y: number): void;
-            setSize(width: number, height: number): void;
-      }
+    class Camera {
+        constructor(game: Phaser.Game, id: number, x: number, y: number, width: number, height: number);
+        game: Phaser.Game;
+        world: Phaser.World;
+        id: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        view: Phaser.Rectangle;
+        screenView: Phaser.Rectangle;
+        bounds: Phaser.Rectangle;
+        deadzone: Phaser.Rectangle;
+        visible: boolean;
+        atLimit: { x: boolean; y: boolean; };
+        target: Phaser.Sprite;
+        private _edge: number;
+        static FOLLOW_LOCKON: number;
+        static FOLLOW_PLATFORMER: number;
+        static FOLLOW_TOPDOWN: number;
+        static FOLLOW_TOPDOWN_TIGHT: number;
+        follow(target: Phaser.Sprite, style?: number): void;
+        focusOnXY(x: number, y: number): void;
+        update(): void;
+        checkWorldBounds(): void;
+        setPosition(x: number, y: number): void;
+        setSize(width: number, height: number): void;
+    }
 
-      class State {
-            game: Phaser.Game;
-            add: Phaser.GameObjectFactory;
-            camera: Phaser.Camera;
-            cache: Phaser.Cache;
-            input: Phaser.Input;
-            load: Phaser.Loader;
-            stage: Phaser.Stage;
-            math: Phaser.Math;
-            sound: Phaser.SoundManager;
-            time: Phaser.Time;
-            tweens: Phaser.TweenManager;
-            world: Phaser.World;
-            particles: Phaser.Particles;
-            physics: Phaser.Physics.Arcade;
-            preload();
-            loadUpdate();
-            loadRender();
-            create();
-            update();
-            render(); 
-            paused();
-            destroy();
-      }
+    class State {
+        game: Phaser.Game;
+        add: Phaser.GameObjectFactory;
+        camera: Phaser.Camera;
+        cache: Phaser.Cache;
+        input: Phaser.Input;
+        load: Phaser.Loader;
+        stage: Phaser.Stage;
+        math: Phaser.Math;
+        sound: Phaser.SoundManager;
+        time: Phaser.Time;
+        tweens: Phaser.TweenManager;
+        world: Phaser.World;
+        particles: Phaser.Particles;
+        physics: Phaser.Physics.Arcade;
+        preload();
+        loadUpdate();
+        loadRender();
+        create();
+        update();
+        render();
+        paused();
+        destroy();
+    }
 
-      class StateManager {
-            constructor(game: Phaser.Game, pendingState: Phaser.State);
-            game: Phaser.Game;
-            states: Object;
-            current: Phaser.State;
-            onInitCallback(): void;
-            onPreloadCallback(): void;
-            onCreateCallback(): void;
-            onUpdateCallback(): void;
-            onRenderCallback(): void;
-            onPreRenderCallback(): void;
-            onLoadUpdateCallback(): void;
-            onLoadRenderCallback(): void;
-            onPausedCallback(): void;
-            onShutDownCallback(): void;
-            boot(): void;
-            add(key: string, state: any, autoStart?: boolean): void;
-            remove(key: string): void;
-            start(key: string, clearWorld?: boolean, clearCache?: boolean): void;
-            dummy(): void;
-            checkState(key: string): boolean;
-            link(key: string): void;
-            setCurrentState(key: string): void;
-            loadComplete(): void;
-            update(): void;
-            preRender(): void;
-            render(): void;
-            destroy(): void;
-      }
+    class StateManager {
+        constructor(game: Phaser.Game, pendingState: Phaser.State);
+        game: Phaser.Game;
+        states: Object;
+        current: Phaser.State;
+        onInitCallback(): void;
+        onPreloadCallback(): void;
+        onCreateCallback(): void;
+        onUpdateCallback(): void;
+        onRenderCallback(): void;
+        onPreRenderCallback(): void;
+        onLoadUpdateCallback(): void;
+        onLoadRenderCallback(): void;
+        onPausedCallback(): void;
+        onShutDownCallback(): void;
+        boot(): void;
+        add(key: string, state: any, autoStart?: boolean): void;
+        remove(key: string): void;
+        start(key: string, clearWorld?: boolean, clearCache?: boolean): void;
+        dummy(): void;
+        checkState(key: string): boolean;
+        link(key: string): void;
+        setCurrentState(key: string): void;
+        loadComplete(): void;
+        update(): void;
+        preRender(): void;
+        render(): void;
+        destroy(): void;
+    }
 
-      class LinkedListItem {
-            next: LinkedListItem;
-            prev: LinkedListItem;
-            first: LinkedListItem;
-            last: LinkedListItem;
-      }
+    class LinkedListItem {
+        next: LinkedListItem;
+        prev: LinkedListItem;
+        first: LinkedListItem;
+        last: LinkedListItem;
+    }
 
-      class LinkedList extends LinkedListItem {
-            total: number;
-            add(child: LinkedListItem): LinkedListItem;
-            remove(child: LinkedListItem): void;
-            callAll(callback: string): void;
-            dump(): void;
-      }
+    class LinkedList extends LinkedListItem {
+        total: number;
+        add(child: LinkedListItem): LinkedListItem;
+        remove(child: LinkedListItem): void;
+        callAll(callback: string): void;
+        dump(): void;
+    }
 
-      class Signal {
-            memorize: boolean;
-            active: boolean;
-            validateListener(listener: Function, fnName: string): void;
-            has(listener: Function, context?: any): boolean;
-            add(listener: Function, listenerContext?: any, priority?: number): Phaser.SignalBinding;
-            addOnce(listener: Function, listenerContext?: any, priority?: number): Phaser.SignalBinding;
-            remove(listener: Function, context?: any): Function;
-            removeAll(): void;
-            getNumListeners(): number;
-            halt(): void;
-            dispatch(...params: any[]): void;
-            forget(): void;
-            dispose(): void;
-            toString(): string;
-      }
+    class Signal {
+        memorize: boolean;
+        active: boolean;
+        validateListener(listener: Function, fnName: string): void;
+        has(listener: Function, context?: any): boolean;
+        add(listener: Function, listenerContext?: any, priority?: number): Phaser.SignalBinding;
+        addOnce(listener: Function, listenerContext?: any, priority?: number): Phaser.SignalBinding;
+        remove(listener: Function, context?: any): Function;
+        removeAll(): void;
+        getNumListeners(): number;
+        halt(): void;
+        dispatch(...params: any[]): void;
+        forget(): void;
+        dispose(): void;
+        toString(): string;
+    }
 
-      class SignalBinding {
-            constructor(signal: Phaser.Signal, listener: Function, isOnce: boolean, listenerContext: Object, priority?: number);
-            context: Object;
-            active: boolean;
-            params: Array<any>;
-            execute(paramsArr?: Array<any>): void;
-            detach(): Function;
-            isBound(): boolean;
-            isOnce(): boolean;
-            getListener(): Function;
-            getSignal(): Phaser.Signal;
-            toString(): string;
-      }
+    class SignalBinding {
+        constructor(signal: Phaser.Signal, listener: Function, isOnce: boolean, listenerContext: Object, priority?: number);
+        context: Object;
+        active: boolean;
+        params: Array<any>;
+        execute(paramsArr?: Array<any>): void;
+        detach(): Function;
+        isBound(): boolean;
+        isOnce(): boolean;
+        getListener(): Function;
+        getSignal(): Phaser.Signal;
+        toString(): string;
+    }
 
-      class StateCycle {
-            preUpdate(): void;
-            update(): void;
-            render(): void;
-            postRender(): void;
-            destroy(): void;
-      }
+    class StateCycle {
+        preUpdate(): void;
+        update(): void;
+        render(): void;
+        postRender(): void;
+        destroy(): void;
+    }
 
-      class Plugin extends StateCycle {
-            constructor(game: Phaser.Game, parent: any);
-            game: Phaser.Game;
-            parent: any;
-            active: boolean;
-            visible: boolean;
-            hasPreUpdate: boolean;
-            hasUpdate: boolean;
-            hasRender: boolean;
-            hasPostRender: boolean;
-      }
+    class Plugin extends StateCycle {
+        constructor(game: Phaser.Game, parent: any);
+        game: Phaser.Game;
+        parent: any;
+        active: boolean;
+        visible: boolean;
+        hasPreUpdate: boolean;
+        hasUpdate: boolean;
+        hasRender: boolean;
+        hasPostRender: boolean;
+    }
 
-      class PluginManager extends StateCycle {
-            constructor(game: Phaser.Game, parent: any);
-            game: Phaser.Game;
-            private _parent: any;
-            plugins: Phaser.Plugin[];
-            add(plugin: Phaser.Plugin): Phaser.Plugin;
-            remove(plugin: Phaser.Plugin): void;
-      }
+    class PluginManager extends StateCycle {
+        constructor(game: Phaser.Game, parent: any);
+        game: Phaser.Game;
+        private _parent: any;
+        plugins: Phaser.Plugin[];
+        add(plugin: Phaser.Plugin): Phaser.Plugin;
+        remove(plugin: Phaser.Plugin): void;
+    }
 
-      class Stage {
-            constructor(game: Phaser.Game, width: number, height: number);
-            game: Phaser.Game;
-            offset: Phaser.Point;
-            canvas: HTMLCanvasElement;
-            scaleMode: number;
-            scale: Phaser.StageScaleMode;
-            aspectRatio: number;
-            backgroundColor: string;
-            disableVisibilityChange: boolean;
-            boot(): void;
-            visibilityChange(event: Event): void;
-      }
+    class Stage {
+        constructor(game: Phaser.Game, width: number, height: number);
+        game: Phaser.Game;
+        offset: Phaser.Point;
+        canvas: HTMLCanvasElement;
+        scaleMode: number;
+        scale: Phaser.StageScaleMode;
+        aspectRatio: number;
+        backgroundColor: string;
+        disableVisibilityChange: boolean;
+        boot(): void;
+        visibilityChange(event: Event): void;
+    }
 
-      class Group {
-            constructor(game: Phaser.Game, parent: any, name: string, useStage: boolean);
-            game: Phaser.Game;
-            name: string;
-            type: number;
-            exists: boolean;
-            sortIndex: string;
-            length: number;
-            x: number;
-            y: number;
-            angle: number;
-            rotation: number;
-            visible: boolean;
-            add(child: any): any;
-            addAt(child: any, index: number): any;
-            getAt(index: number): any;
-            create(x: number, y: number, key: string, frame?: any, exists?: boolean): Phaser.Sprite;
-            swap(child1: any, child2: any): boolean;
-            bringToTop(child: any): any;
-            getIndex(child: any): number;
-            replace(oldChild: any, newChild: any): void;
-            setProperty(child: any, key: string[], value: string, operation: number): void;
-            setAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
-            subAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
-            multiplyAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
-            divideAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
-            callAllExists(callback: Function, callbackContext: Object, existsValue: boolean): void;
-            callAll(callback: string, callbackContext?: Object): void;
-            forEach(callback: Function, callbackContext: Object, checkExists: boolean): void;
-            forEachAlive(callback: Function, callbackContext: Object): void;
-            forEachDead(callback: Function, callbackContext: Object): void;
-            getFirstExists(state: boolean): any;
-            getFirstAlive(): any;
-            getFirstDead(): any;
-            countLiving(): number;
-            countDead(): number;
-            getRandom(startIndex: number, length: number): any;
-            remove(child: any): void;
-            removeAll(): void;
-            removeBetween(startIndex: number, endIndex: number): void;
-            destroy(): void;
-            dump(full: boolean): void;
-      }
+    class Group {
+        constructor(game: Phaser.Game, parent: any, name: string, useStage: boolean);
+        game: Phaser.Game;
+        name: string;
+        type: number;
+        exists: boolean;
+        sortIndex: string;
+        length: number;
+        x: number;
+        y: number;
+        angle: number;
+        rotation: number;
+        visible: boolean;
+        add(child: any): any;
+        addAt(child: any, index: number): any;
+        getAt(index: number): any;
+        create(x: number, y: number, key: string, frame?: any, exists?: boolean): Phaser.Sprite;
+        swap(child1: any, child2: any): boolean;
+        bringToTop(child: any): any;
+        getIndex(child: any): number;
+        replace(oldChild: any, newChild: any): void;
+        setProperty(child: any, key: string[], value: string, operation: number): void;
+        setAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
+        subAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
+        multiplyAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
+        divideAll(key: string, value: number, checkAlive: boolean, checkVisible: boolean, operation: number): void;
+        callAllExists(callback: Function, callbackContext: Object, existsValue: boolean): void;
+        callAll(callback: string, callbackContext?: Object): void;
+        forEach(callback: Function, callbackContext: Object, checkExists: boolean): void;
+        forEachAlive(callback: Function, callbackContext: Object): void;
+        forEachDead(callback: Function, callbackContext: Object): void;
+        getFirstExists(state: boolean): any;
+        getFirstAlive(): any;
+        getFirstDead(): any;
+        countLiving(): number;
+        countDead(): number;
+        getRandom(startIndex: number, length: number): any;
+        remove(child: any): void;
+        removeAll(): void;
+        removeBetween(startIndex: number, endIndex: number): void;
+        destroy(): void;
+        dump(full: boolean): void;
+    }
 
-      class World {
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            bounds: Phaser.Rectangle;
-            camera: Phaser.Camera;
-            currentRenderOrderID: number;
-            group: Phaser.Group;
-            width: number;
-            height: number;
-            centerX: number;
-            centerY: number;
-            randomX: number;
-            randomY: number;
-            boot(): void;
-            update(): void;
-            setBounds( x:number, y:number, width: number, height: number): void;
-            destroy(): void;
-      }
+    class World {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        bounds: Phaser.Rectangle;
+        camera: Phaser.Camera;
+        currentRenderOrderID: number;
+        group: Phaser.Group;
+        width: number;
+        height: number;
+        centerX: number;
+        centerY: number;
+        randomX: number;
+        randomY: number;
+        boot(): void;
+        update(): void;
+        setBounds( x:number, y:number, width: number, height: number): void;
+        destroy(): void;
+    }
 
-      class Game {
-            constructor(width: number, height: number, renderer: number, parent: string, state: Object, transparent?: boolean, antialias?: boolean);
-            id: number;
-            width: number;
-            height: number;
-            renderer: number;
-            transparent: boolean;
-            antialias: boolean;
-            parent: string;
-            state: Phaser.StateManager;
-            renderType: number;
-            isBooted: boolean;
-            raf: Phaser.RequestAnimationFrame;
-            add: Phaser.GameObjectFactory;
-            cache: Phaser.Cache;
-            input: Phaser.Input;
-            load: Phaser.Loader;
-            math: Phaser.Math;
-            sound: Phaser.SoundManager;
-            stage: Phaser.Stage;
-            time: Phaser.Time;
-            tweens: Phaser.TweenManager;
-            world: Phaser.World;
-            physics: Phaser.Physics.Arcade;
-            rnd: Phaser.RandomDataGenerator;
-            device: Phaser.Device;
-            camera: Phaser.Camera;
-            canvas: HTMLCanvasElement;
-            context: Object;
-            debug: Phaser.Utils.Debug;
-            particles: Phaser.Particles;
-            _paused: boolean;
-            paused: boolean;
-            boot(): void;
-            setUpRenderer(): void;
-            loadComplete(): void;
-            update(): void;
-            destroy(): void;
-      }
+    class Game {
+        constructor(width?: number, height?: number, renderer?: number, parent?: string, state?: Object, transparent?: boolean, antialias?: boolean);
+        id: number;
+        width: number;
+        height: number;
+        renderer: number;
+        transparent: boolean;
+        antialias: boolean;
+        parent: string;
+        state: Phaser.StateManager;
+        renderType: number;
+        isBooted: boolean;
+        raf: Phaser.RequestAnimationFrame;
+        add: Phaser.GameObjectFactory;
+        cache: Phaser.Cache;
+        input: Phaser.Input;
+        load: Phaser.Loader;
+        math: Phaser.Math;
+        sound: Phaser.SoundManager;
+        stage: Phaser.Stage;
+        time: Phaser.Time;
+        tweens: Phaser.TweenManager;
+        world: Phaser.World;
+        physics: Phaser.Physics.Arcade;
+        rnd: Phaser.RandomDataGenerator;
+        device: Phaser.Device;
+        camera: Phaser.Camera;
+        canvas: HTMLCanvasElement;
+        context: Object;
+        debug: Phaser.Utils.Debug;
+        particles: Phaser.Particles;
+        _paused: boolean;
+        paused: boolean;
+        boot(): void;
+        setUpRenderer(): void;
+        loadComplete(): void;
+        update(): void;
+        destroy(): void;
+    }
 
-      class Input {
-            constructor(game: Phaser.Game);
-            static MOUSE_OVERRIDES_TOUCH: number;
-            static TOUCH_OVERRIDES_MOUSE: number;
-            static MOUSE_TOUCH_COMBINE: number;
-            id: number;
-            active: boolean;
-            game: Phaser.Game;
-            hitCanvas: any;
-            hitContext: any;
-            pollRate: number;
-            disabled: boolean;
-            multiInputOverride: number;
-            position: Phaser.Point;
-            speed: Phaser.Point;
-            circle: Phaser.Circle;
-            scale: Phaser.Point;
-            maxPointers: number;
-            currentPointers: number;
-            tapRate: number;
-            doubleTapRate: number;
-            holdRate: number;
-            justPressedRate: number;
-            justReleasedRate: number;
-            recordPointerHistory: boolean;
-            recordRate: number;
-            recordLimit: number;
-            x: number; 
-            y: number;
-            totalInactivePointers: number;
-            totalActivePointers: number;
-            worldX: number;
-            worldY: number;
-            pollLocked: boolean;
-            pointer1: Phaser.Pointer;
-            pointer2: Phaser.Pointer;
-            pointer3: Phaser.Pointer;
-            pointer4: Phaser.Pointer;
-            pointer5: Phaser.Pointer;
-            pointer6: Phaser.Pointer;
-            pointer7: Phaser.Pointer;
-            pointer8: Phaser.Pointer;
-            pointer9: Phaser.Pointer;
-            pointer10: Phaser.Pointer;
-            activePointer: Phaser.Pointer;
-            mousePointer: Phaser.Pointer;
-            mouse: Phaser.Mouse;
-            keyboard: Phaser.Keyboard;
-            touch: Phaser.Touch;
-            mspointer: Phaser.MSPointer;
-            interactiveItems: Phaser.LinkedList;
-            onDown: Phaser.Signal;
-            onUp: Phaser.Signal;
-            onTap: Phaser.Signal;
-            onHold: Phaser.Signal;
-            boot(): void;
-            update(): void;
-            reset(hard?: boolean);
-            resetSpeed(x: number, y: number);
-            startPointer(event: Event): Phaser.Pointer;
-            updatePointer(event: Event): Phaser.Pointer;
-            stopPointer(event: Event): Phaser.Pointer;
-            getPointer(state: boolean): Phaser.Pointer;
-            getPointerFromIdentifier(identifier: number): Phaser.Pointer;
-            addPointer(): Phaser.Pointer;
-      }
+    class Input {
+        constructor(game: Phaser.Game);
+        static MOUSE_OVERRIDES_TOUCH: number;
+        static TOUCH_OVERRIDES_MOUSE: number;
+        static MOUSE_TOUCH_COMBINE: number;
+        id: number;
+        active: boolean;
+        game: Phaser.Game;
+        hitCanvas: any;
+        hitContext: any;
+        pollRate: number;
+        disabled: boolean;
+        multiInputOverride: number;
+        position: Phaser.Point;
+        speed: Phaser.Point;
+        circle: Phaser.Circle;
+        scale: Phaser.Point;
+        maxPointers: number;
+        currentPointers: number;
+        tapRate: number;
+        doubleTapRate: number;
+        holdRate: number;
+        justPressedRate: number;
+        justReleasedRate: number;
+        recordPointerHistory: boolean;
+        recordRate: number;
+        recordLimit: number;
+        x: number;
+        y: number;
+        totalInactivePointers: number;
+        totalActivePointers: number;
+        worldX: number;
+        worldY: number;
+        pollLocked: boolean;
+        pointer1: Phaser.Pointer;
+        pointer2: Phaser.Pointer;
+        pointer3: Phaser.Pointer;
+        pointer4: Phaser.Pointer;
+        pointer5: Phaser.Pointer;
+        pointer6: Phaser.Pointer;
+        pointer7: Phaser.Pointer;
+        pointer8: Phaser.Pointer;
+        pointer9: Phaser.Pointer;
+        pointer10: Phaser.Pointer;
+        activePointer: Phaser.Pointer;
+        mousePointer: Phaser.Pointer;
+        mouse: Phaser.Mouse;
+        keyboard: Phaser.Keyboard;
+        touch: Phaser.Touch;
+        mspointer: Phaser.MSPointer;
+        interactiveItems: Phaser.LinkedList;
+        onDown: Phaser.Signal;
+        onUp: Phaser.Signal;
+        onTap: Phaser.Signal;
+        onHold: Phaser.Signal;
+        boot(): void;
+        update(): void;
+        reset(hard?: boolean);
+        resetSpeed(x: number, y: number);
+        startPointer(event: Event): Phaser.Pointer;
+        updatePointer(event: Event): Phaser.Pointer;
+        stopPointer(event: Event): Phaser.Pointer;
+        getPointer(state: boolean): Phaser.Pointer;
+        getPointerFromIdentifier(identifier: number): Phaser.Pointer;
+        addPointer(): Phaser.Pointer;
+    }
 
-      class Key {
-          constructor( game:Phaser.Game, keycode:number )
-          isDown:boolean;
-          isUp:boolean;
-          altKey:boolean;
-          ctrlKey:boolean;
-          shiftKey:boolean;
-          timeDown:number;
-          duration:number;
-          timeUp:number;
-          repeats:number;
-          keycode:number;
-          onDown:Phaser.Signal;
-          onUp:Phaser.Signal;
-          justPressed( duration:number ):boolean;
-          justReleased( duration:number ):boolean;
-      }
+    class Key {
+        constructor( game:Phaser.Game, keycode:number )
+        isDown:boolean;
+        isUp:boolean;
+        altKey:boolean;
+        ctrlKey:boolean;
+        shiftKey:boolean;
+        timeDown:number;
+        duration:number;
+        timeUp:number;
+        repeats:number;
+        keycode:number;
+        onDown:Phaser.Signal;
+        onUp:Phaser.Signal;
+        justPressed( duration:number ):boolean;
+        justReleased( duration:number ):boolean;
+    }
 
-      interface CursorKeys
-      {
-          up:Phaser.Key;
-          down:Phaser.Key;
-          left:Phaser.Key;
-          right:Phaser.Key;
-      }
+    interface CursorKeys
+    {
+        up:Phaser.Key;
+        down:Phaser.Key;
+        left:Phaser.Key;
+        right:Phaser.Key;
+    }
 
-      class Keyboard {
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            disabled: boolean;
-            static A: number;
-            static B: number;
-            static C: number;
-            static D: number;
-            static E: number;
-            static F: number;
-            static G: number;
-            static H: number;
-            static I: number;
-            static J: number;
-            static K: number;
-            static L: number;
-            static M: number;
-            static N: number;
-            static O: number;
-            static P: number;
-            static Q: number;
-            static R: number;
-            static S: number;
-            static T: number;
-            static U: number;
-            static V: number;
-            static W: number;
-            static X: number;
-            static Y: number;
-            static Z: number;
-            static ZERO: number;
-            static ONE: number;
-            static TWO: number;
-            static THREE: number;
-            static FOUR: number;
-            static FIVE: number;
-            static SIX: number;
-            static SEVEN: number;
-            static EIGHT: number;
-            static NINE: number;
-            static NUMPAD_0: number;
-            static NUMPAD_1: number;
-            static NUMPAD_2: number;
-            static NUMPAD_3: number;
-            static NUMPAD_4: number;
-            static NUMPAD_5: number;
-            static NUMPAD_6: number;
-            static NUMPAD_7: number;
-            static NUMPAD_8: number;
-            static NUMPAD_9: number;
-            static NUMPAD_MULTIPLY: number;
-            static NUMPAD_ADD: number;
-            static NUMPAD_ENTER: number;
-            static NUMPAD_SUBTRACT: number;
-            static NUMPAD_DECIMAL: number;
-            static NUMPAD_DIVIDE: number;
-            static F1: number;
-            static F2: number;
-            static F3: number;
-            static F4: number;
-            static F5: number;
-            static F6: number;
-            static F7: number;
-            static F8: number;
-            static F9: number;
-            static F10: number;
-            static F11: number;
-            static F12: number;
-            static F13: number;
-            static F14: number;
-            static F15: number;
-            static COLON: number;
-            static EQUALS: number;
-            static UNDERSCORE: number;
-            static QUESTION_MARK: number;
-            static TILDE: number;
-            static OPEN_BRACKET: number;
-            static BACKWARD_SLASH: number;
-            static CLOSED_BRACKET: number;
-            static QUOTES: number;
-            static BACKSPACE: number;
-            static TAB: number;
-            static CLEAR: number;
-            static ENTER: number;
-            static SHIFT: number;
-            static CONTROL: number;
-            static ALT: number;
-            static CAPS_LOCK: number;
-            static ESC: number;
-            static SPACEBAR: number;
-            static PAGE_UP: number;
-            static PAGE_DOWN: number;
-            static END: number;
-            static HOME: number;
-            static LEFT: number;
-            static UP: number;
-            static RIGHT: number;
-            static DOWN: number;
-            static INSERT: number;
-            static DELETE: number;
-            static HELP: number;
-            static NUM_LOCK: number;
-            start(): void;
-            stop(): void;
-            addKeyCapture(keycode: any): void;
-            removeKeyCapture(keycode: number): void;
-            clearCaptures(): void;
-            onKeyDown(event: any): void;
-            onKeyUp(event: any): void;
-            reset(): void;
-            justPressed(keycode: number, duration?: number): boolean;
-            justReleased(keycode: number, duration?: number): boolean;
-            isDown(keycode: number): boolean;
-            createCursorKeys():CursorKeys;
-      }
+    class Keyboard {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        disabled: boolean;
+        static A: number;
+        static B: number;
+        static C: number;
+        static D: number;
+        static E: number;
+        static F: number;
+        static G: number;
+        static H: number;
+        static I: number;
+        static J: number;
+        static K: number;
+        static L: number;
+        static M: number;
+        static N: number;
+        static O: number;
+        static P: number;
+        static Q: number;
+        static R: number;
+        static S: number;
+        static T: number;
+        static U: number;
+        static V: number;
+        static W: number;
+        static X: number;
+        static Y: number;
+        static Z: number;
+        static ZERO: number;
+        static ONE: number;
+        static TWO: number;
+        static THREE: number;
+        static FOUR: number;
+        static FIVE: number;
+        static SIX: number;
+        static SEVEN: number;
+        static EIGHT: number;
+        static NINE: number;
+        static NUMPAD_0: number;
+        static NUMPAD_1: number;
+        static NUMPAD_2: number;
+        static NUMPAD_3: number;
+        static NUMPAD_4: number;
+        static NUMPAD_5: number;
+        static NUMPAD_6: number;
+        static NUMPAD_7: number;
+        static NUMPAD_8: number;
+        static NUMPAD_9: number;
+        static NUMPAD_MULTIPLY: number;
+        static NUMPAD_ADD: number;
+        static NUMPAD_ENTER: number;
+        static NUMPAD_SUBTRACT: number;
+        static NUMPAD_DECIMAL: number;
+        static NUMPAD_DIVIDE: number;
+        static F1: number;
+        static F2: number;
+        static F3: number;
+        static F4: number;
+        static F5: number;
+        static F6: number;
+        static F7: number;
+        static F8: number;
+        static F9: number;
+        static F10: number;
+        static F11: number;
+        static F12: number;
+        static F13: number;
+        static F14: number;
+        static F15: number;
+        static COLON: number;
+        static EQUALS: number;
+        static UNDERSCORE: number;
+        static QUESTION_MARK: number;
+        static TILDE: number;
+        static OPEN_BRACKET: number;
+        static BACKWARD_SLASH: number;
+        static CLOSED_BRACKET: number;
+        static QUOTES: number;
+        static BACKSPACE: number;
+        static TAB: number;
+        static CLEAR: number;
+        static ENTER: number;
+        static SHIFT: number;
+        static CONTROL: number;
+        static ALT: number;
+        static CAPS_LOCK: number;
+        static ESC: number;
+        static SPACEBAR: number;
+        static PAGE_UP: number;
+        static PAGE_DOWN: number;
+        static END: number;
+        static HOME: number;
+        static LEFT: number;
+        static UP: number;
+        static RIGHT: number;
+        static DOWN: number;
+        static INSERT: number;
+        static DELETE: number;
+        static HELP: number;
+        static NUM_LOCK: number;
+        start(): void;
+        stop(): void;
+        addKeyCapture(keycode: any): void;
+        removeKeyCapture(keycode: number): void;
+        clearCaptures(): void;
+        onKeyDown(event: any): void;
+        onKeyUp(event: any): void;
+        reset(): void;
+        justPressed(keycode: number, duration?: number): boolean;
+        justReleased(keycode: number, duration?: number): boolean;
+        isDown(keycode: number): boolean;
+        createCursorKeys():CursorKeys;
+    }
 
-      class Mouse {
-            constructor(game: Phaser.Game)
-            game: Phaser.Game;
-            callbackContext: Object;
-            disabled: boolean;
-            locked: boolean;
-            static LEFT_BUTTON: number;
-            static MIDDLE_BUTTON: number;
-            static RIGHT_BUTTON: number;
-            mouseDownCallback(): void;
-            mouseMoveCallback(): void;
-            mouseUpCallback(): void;
-            start(): void;
-            onMouseDown(): void;
-            onMouseUp(): void;
-            onMouseMove(): void;
-            requestPointerLock(): void;
-            pointerLockChange(): void;
-            releasePointerLock(): void;
-            stop();
-      }
+    class Mouse {
+        constructor(game: Phaser.Game)
+        game: Phaser.Game;
+        callbackContext: Object;
+        disabled: boolean;
+        locked: boolean;
+        static LEFT_BUTTON: number;
+        static MIDDLE_BUTTON: number;
+        static RIGHT_BUTTON: number;
+        mouseDownCallback: Function;
+        mouseMoveCallback: Function;
+        mouseUpCallback: Function;
+        start(): void;
+        onMouseDown(): void;
+        onMouseUp(): void;
+        onMouseMove(): void;
+        requestPointerLock(): void;
+        pointerLockChange(): void;
+        releasePointerLock(): void;
+        stop();
+    }
 
-      class MSPointer {
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            callbackContext: Object;
-            disabled: boolean;
-            mouseDownCallback(): void;
-            mouseMoveCallback(): void;
-            mouseUpCallback(): void;
-            start(): void;
-            onPointerDown(): void;
-            onPointerUp(): void;
-            onPointerMove(): void;
-            stop(): void;
-      }
+    class MSPointer {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        callbackContext: Object;
+        disabled: boolean;
+        mouseDownCallback(): void;
+        mouseMoveCallback(): void;
+        mouseUpCallback(): void;
+        start(): void;
+        onPointerDown(): void;
+        onPointerUp(): void;
+        onPointerMove(): void;
+        stop(): void;
+    }
 
-      class Pointer {
-            constructor(game: Phaser.Game, id: number);
-            game: Phaser.Game;
-            id: number;
-            active: boolean;
-            positionDown: Phaser.Point;
-            position: Phaser.Point;
-            circle: Phaser.Circle;
-            withinGame: boolean;
-            clientX: number;
-            clientY: number;
-            pageX: number;
-            pageY: number; 
-            screenX: number;
-            screenY: number;
-            duation: number; 
-            worldX: number;
-            worldY: number;
-            x: number;
-            y: number;
-            isMouse: boolean;
-            isDown: boolean;
-            isUp: boolean;
-            timeDown: number;
-            timeUp: number;
-            previousTapTime: number;
-            totalTouches: number;
-            msSinceLastClick: number;
-            targetObject: any;
-            start(event: any): Phaser.Pointer;
-            update(): void;
-            move(event: any): void;
-            leave(event: any): void;
-            stop(event: any): void;
-            justPressed(duration?: number): boolean;
-            justReleased(duration?: number): boolean;
-            reset(): void;
-            toString(): string;
-      }
+    class Pointer {
+        constructor(game: Phaser.Game, id: number);
+        game: Phaser.Game;
+        id: number;
+        active: boolean;
+        positionDown: Phaser.Point;
+        position: Phaser.Point;
+        circle: Phaser.Circle;
+        withinGame: boolean;
+        clientX: number;
+        clientY: number;
+        pageX: number;
+        pageY: number;
+        screenX: number;
+        screenY: number;
+        duation: number;
+        worldX: number;
+        worldY: number;
+        x: number;
+        y: number;
+        isMouse: boolean;
+        isDown: boolean;
+        isUp: boolean;
+        timeDown: number;
+        timeUp: number;
+        previousTapTime: number;
+        totalTouches: number;
+        msSinceLastClick: number;
+        targetObject: any;
+        start(event: any): Phaser.Pointer;
+        update(): void;
+        move(event: any): void;
+        leave(event: any): void;
+        stop(event: any): void;
+        justPressed(duration?: number): boolean;
+        justReleased(duration?: number): boolean;
+        reset(): void;
+        toString(): string;
+    }
 
-      class Touch {
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            callbackContext: any;
-            touchStartCallback: Function;
-            touchMoveCallback: Function;
-            touchEndCallback: Function;
-            touchEnterCallback: Function;
-            touchLeaveCallback: Function;
-            touchCancelCallback: Function;
-            preventDefault: boolean;
-            disabled: boolean;
-            start(): void;
-            consumeDocumentTouches(): void;
-            onTouchStart(event: any): void;
-            onTouchCancel(event: any): void;
-            onTouchEnter(event: any): void;
-            onTouchLeave(event: any): void;
-            onTouchMove(event: any): void;
-            onTouchEnd(event: any): void;
-            stop(): void;
-      }
+    class Touch {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        callbackContext: any;
+        touchStartCallback: Function;
+        touchMoveCallback: Function;
+        touchEndCallback: Function;
+        touchEnterCallback: Function;
+        touchLeaveCallback: Function;
+        touchCancelCallback: Function;
+        preventDefault: boolean;
+        disabled: boolean;
+        start(): void;
+        consumeDocumentTouches(): void;
+        onTouchStart(event: any): void;
+        onTouchCancel(event: any): void;
+        onTouchEnter(event: any): void;
+        onTouchLeave(event: any): void;
+        onTouchMove(event: any): void;
+        onTouchEnd(event: any): void;
+        stop(): void;
+    }
 
-      class InputHandler extends LinkedListItem {
-            constructor(sprite: Phaser.Sprite);
-            game: Phaser.Game;
-            sprite: Phaser.Sprite;
-            enabled: boolean;
-            priorityID: number;
-            useHandCursor: boolean;
-            isDragged: boolean;
-            allowHorizontalDrag: boolean;
-            allowVerticalDrag: boolean;
-            bringToTop: boolean;
-            snapOffset: number;
-            snapOnDrag: boolean;
-            snapOnRelease: boolean;
-            snapX: number;
-            snapY: number;
-            pixelPerfect: boolean;
-            pixelPerfectAlpha: number;
-            draggable: boolean;
-            boundsSprite: Phaser.Sprite;
-            consumePointerEvent: boolean;
-            start(priority: number, useHandCursor: boolean): void;
-            reset(): void;
-            stop(): void;
-            destroy(): void;
-            pointerX(pointer: number): number;
-            pointerY(pointer: number): number;
-            pointerDown(pointer: number): boolean;
-            pointerUp(pointer: number): boolean;
-            pointerTimeDown(pointer: number): number;
-            pointerTimeUp(pointer: number): number;
-            pointerOver(pointer: number): boolean;
-            pointerOut(pointer: number): boolean;
-            pointerTimeOver(pointer: number): number;
-            pointerTimeOut(pointer: number): number;
-            pointerDragged(pointer: number): boolean;
-            checkPointerOver(pointer: number): boolean;
-            checkPixel(x: number, y: number): boolean;
-            update(pointer: number): void;
-            updateDrag(pointer: number): boolean;
-            justOver(pointer: number, delay: number): boolean;
-            justOut(pointer: number, delay: number): boolean;
-            justPressed(pointer: number, delay: number): boolean;
-            justReleased(pointer: number, delay: number): boolean;
-            overDuration(pointer: number): number;
-            downDuration(pointer: number): number;
-            enableDrag(lockCenter: boolean, bringToTop: boolean, pixelPerfect: boolean, alphaThreshold?: number, boundsRect?: Phaser.Rectangle, boundsSprite?: Phaser.Rectangle): void;
-            disableDrag(): void; 
-            startDrag(): void;
-            stopDrag(): void;
-            setDragLock(allowHorizontal: boolean, allowVertical: boolean): void;
-            enableSnap(snapX: number, snapY: number, onDrag?: boolean, onRelease?: boolean): void;
-            disableSnap(): void;
-            checkBoundsRect(): void;
-            checkBoundsSprite(): void;
-      }
+    class InputHandler extends LinkedListItem {
+        constructor(sprite: Phaser.Sprite);
+        game: Phaser.Game;
+        sprite: Phaser.Sprite;
+        enabled: boolean;
+        priorityID: number;
+        useHandCursor: boolean;
+        isDragged: boolean;
+        allowHorizontalDrag: boolean;
+        allowVerticalDrag: boolean;
+        bringToTop: boolean;
+        snapOffset: number;
+        snapOnDrag: boolean;
+        snapOnRelease: boolean;
+        snapX: number;
+        snapY: number;
+        pixelPerfect: boolean;
+        pixelPerfectAlpha: number;
+        draggable: boolean;
+        boundsSprite: Phaser.Sprite;
+        consumePointerEvent: boolean;
+        start(priority: number, useHandCursor: boolean): void;
+        reset(): void;
+        stop(): void;
+        destroy(): void;
+        pointerX(pointer: number): number;
+        pointerY(pointer: number): number;
+        pointerDown(pointer: number): boolean;
+        pointerUp(pointer: number): boolean;
+        pointerTimeDown(pointer: number): number;
+        pointerTimeUp(pointer: number): number;
+        pointerOver(pointer: number): boolean;
+        pointerOut(pointer: number): boolean;
+        pointerTimeOver(pointer: number): number;
+        pointerTimeOut(pointer: number): number;
+        pointerDragged(pointer: number): boolean;
+        checkPointerOver(pointer: number): boolean;
+        checkPixel(x: number, y: number): boolean;
+        update(pointer: number): void;
+        updateDrag(pointer: number): boolean;
+        justOver(pointer: number, delay: number): boolean;
+        justOut(pointer: number, delay: number): boolean;
+        justPressed(pointer: number, delay: number): boolean;
+        justReleased(pointer: number, delay: number): boolean;
+        overDuration(pointer: number): number;
+        downDuration(pointer: number): number;
+        enableDrag(lockCenter: boolean, bringToTop: boolean, pixelPerfect: boolean, alphaThreshold?: number, boundsRect?: Phaser.Rectangle, boundsSprite?: Phaser.Rectangle): void;
+        disableDrag(): void;
+        startDrag(): void;
+        stopDrag(): void;
+        setDragLock(allowHorizontal: boolean, allowVertical: boolean): void;
+        enableSnap(snapX: number, snapY: number, onDrag?: boolean, onRelease?: boolean): void;
+        disableSnap(): void;
+        checkBoundsRect(): void;
+        checkBoundsSprite(): void;
+    }
 
-      class Event {
-            constructor(sprite: Phaser.Sprite);
-            parent: Phaser.Sprite;
-            onAddedToGroup: Phaser.Signal;
-            onRemovedFromGroup: Phaser.Signal;
-            onKilled: Phaser.Signal;
-            onRevived: Phaser.Signal;
-            onOutOfBounds: Phaser.Signal;
-            onInputOver: Phaser.Signal;
-            onInputOut: Phaser.Signal;
-            onInputDown: Phaser.Signal;
-            onInputUp: Phaser.Signal;
-            onDragStart: Phaser.Signal;
-            onDragStop: Phaser.Signal;
-            onAnimationStart: Phaser.Signal;
-            onAnimationComplete: Phaser.Signal;
-            onAnimationLoop: Phaser.Signal;
-      }
+    class Event {
+        constructor(sprite: Phaser.Sprite);
+        parent: Phaser.Sprite;
+        onAddedToGroup: Phaser.Signal;
+        onRemovedFromGroup: Phaser.Signal;
+        onKilled: Phaser.Signal;
+        onRevived: Phaser.Signal;
+        onOutOfBounds: Phaser.Signal;
+        onInputOver: Phaser.Signal;
+        onInputOut: Phaser.Signal;
+        onInputDown: Phaser.Signal;
+        onInputUp: Phaser.Signal;
+        onDragStart: Phaser.Signal;
+        onDragStop: Phaser.Signal;
+        onAnimationStart: Phaser.Signal;
+        onAnimationComplete: Phaser.Signal;
+        onAnimationLoop: Phaser.Signal;
+    }
 
-      class GameObjectFactory {
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            world: Phaser.World;
-            existing(object: any): boolean;
-            sprite(x: number, y: number, key?: string, frame?: any): Phaser.Sprite;
-            child(parent: any, x: number, y: number, key?: string, frame?: number): Phaser.Sprite;
-            tween(obj: Object): Phaser.Tween;
-            group(parent?: any, name?: string): Phaser.Group;
-            audio(key: string, volume?: number, loop?: boolean): Phaser.Sound;
-            tileSprite(x: number, y: number, width: number, height: number, key?: string, frame?: number): Phaser.TileSprite;
-            text(x: number, y: number, text: string, style: any): Phaser.Text;
-            button(x: number, y: number, key: string, callback: Function, callbackContext: Object, overFrame?: any, outFrame?: any, downFrame?: any): Phaser.Button;
-            graphics(x: number, y: number): Phaser.Graphics;
-            emitter(x: number, y: number, maxParticles: number): Phaser.Particles.Arcade.Emitter;
-            bitmapText(x: number, y: number, text: string, style: string): Phaser.BitmapText;
-            tilemap(x: number, y: number, key: string, resizeWorld: boolean, tileWidth: number, tileHeight: number): Phaser.Tilemap;
-            renderTexture(key: string, width: number, height: number): Phaser.RenderTexture;
-      }
+    class GameObjectFactory {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        world: Phaser.World;
+        existing(object: any): boolean;
+        sprite(x: number, y: number, key?: string, frame?: any): Phaser.Sprite;
+        child(parent: any, x: number, y: number, key?: string, frame?: number): Phaser.Sprite;
+        tween(obj: Object): Phaser.Tween;
+        group(parent?: any, name?: string): Phaser.Group;
+        audio(key: string, volume?: number, loop?: boolean): Phaser.Sound;
+        tileSprite(x: number, y: number, width: number, height: number, key?: string, frame?: number): Phaser.TileSprite;
+        text(x: number, y: number, text: string, style: any): Phaser.Text;
+        button(x: number, y: number, key: string, callback: Function, callbackContext: Object, overFrame?: any, outFrame?: any, downFrame?: any): Phaser.Button;
+        graphics(x: number, y: number): Phaser.Graphics;
+        emitter(x: number, y: number, maxParticles: number): Phaser.Particles.Arcade.Emitter;
+        bitmapText(x: number, y: number, text: string, style: any): Phaser.BitmapText;
+        tilemap(x: number, y: number, key: string, resizeWorld: boolean, tileWidth: number, tileHeight: number): Phaser.Tilemap;
+        renderTexture(key: string, width: number, height: number): Phaser.RenderTexture;
+    }
 
     class Sprite {
         constructor(game: Phaser.Game, x: number, y: number, key: string, frame: number);
@@ -760,457 +760,457 @@ declare module Phaser {
         renderable: boolean;
     }
 
-      class Events {
-            parent: Phaser.Sprite;
-            onAddedToGroup: Phaser.Signal;
-            onRemovedFromGroup: Phaser.Signal;
-            onKilled: Phaser.Signal;
-            onRevived: Phaser.Signal;
-            onOutOfBounds: Phaser.Signal;
-            onInputOver: Phaser.Signal;
-            onInputOut: Phaser.Signal;
-            onInputDown: Phaser.Signal;
-            onInputUp: Phaser.Signal;
-            onDragStart: Phaser.Signal;
-            onDragStop: Phaser.Signal;
-            onAnimationStart: Phaser.Signal;
-            onAnimationComplete: Phaser.Signal;
-            onAnimationLoop: Phaser.Signal;
-      }
+    class Events {
+        parent: Phaser.Sprite;
+        onAddedToGroup: Phaser.Signal;
+        onRemovedFromGroup: Phaser.Signal;
+        onKilled: Phaser.Signal;
+        onRevived: Phaser.Signal;
+        onOutOfBounds: Phaser.Signal;
+        onInputOver: Phaser.Signal;
+        onInputOut: Phaser.Signal;
+        onInputDown: Phaser.Signal;
+        onInputUp: Phaser.Signal;
+        onDragStart: Phaser.Signal;
+        onDragStop: Phaser.Signal;
+        onAnimationStart: Phaser.Signal;
+        onAnimationComplete: Phaser.Signal;
+        onAnimationLoop: Phaser.Signal;
+    }
 
-      class TileSprite extends Sprite {
-            constructor(game: Phaser.Game, x: number, y: number, width: number, height: number, key?: string, frame?: number);
-            texture: Phaser.RenderTexture;
-            type: number;
-            tileScale: Phaser.Point;
-            tilePosition: Phaser.Point;
-      }
+    class TileSprite extends Sprite {
+        constructor(game: Phaser.Game, x: number, y: number, width: number, height: number, key?: string, frame?: number);
+        texture: Phaser.RenderTexture;
+        type: number;
+        tileScale: Phaser.Point;
+        tilePosition: Phaser.Point;
+    }
 
-      class Text {
-            constructor(game: Phaser.Game, x: number, y: number, text: string, style: string);
-            exists: boolean;
-            alive: boolean;
-            group: Phaser.Group;
-            content: string;
-            name: string;
-            game: Phaser.Game;
-            type: number;
-            text: string;
-            angle: number;
-            style: string;
-            visible: boolean;
-            position: Phaser.Point;
-            anchor: Phaser.Point;
-            scale: Phaser.Point;
-            scrollFactor: Phaser.Point;
-            renderable: boolean;
-            update(): void;
-      }
+    class Text {
+        constructor(game: Phaser.Game, x: number, y: number, text: string, style: string);
+        exists: boolean;
+        alive: boolean;
+        group: Phaser.Group;
+        content: string;
+        name: string;
+        game: Phaser.Game;
+        type: number;
+        text: string;
+        angle: number;
+        style: string;
+        visible: boolean;
+        position: Phaser.Point;
+        anchor: Phaser.Point;
+        scale: Phaser.Point;
+        scrollFactor: Phaser.Point;
+        renderable: boolean;
+        update(): void;
+    }
 
-      class BitmapText extends Phaser.Text {
-      }
+    class BitmapText extends Phaser.Text {
+    }
 
-      class Button {
-            constructor(game: Phaser.Game, x: number, y: number, key: string, callback: Function, overFrame: number, outFrame: number, downFrame: number);
-            input: Phaser.InputHandler;
-            onInputUp: Phaser.Signal;
-            onInputDown: Phaser.Signal;
-            onInputOut: Phaser.Signal;
-            onInputOver: Phaser.Signal;
-            events: Phaser.Event[];
-            setFrames(overFrame?: number, outFrame?: number, downFrame?: number): void;
-            onInputOverHandler(pointer: Phaser.Pointer): void;
-            onInputUpHandler(pointer: Phaser.Pointer): void;
-            onInputDownHandler(pointer: Phaser.Pointer): void;
-            onInputOutHandler(pointer: Phaser.Pointer): void;
-      }
+    class Button {
+        constructor(game: Phaser.Game, x: number, y: number, key: string, callback: Function, overFrame: number, outFrame: number, downFrame: number);
+        input: Phaser.InputHandler;
+        onInputUp: Phaser.Signal;
+        onInputDown: Phaser.Signal;
+        onInputOut: Phaser.Signal;
+        onInputOver: Phaser.Signal;
+        events: Phaser.Event[];
+        setFrames(overFrame?: number, outFrame?: number, downFrame?: number): void;
+        onInputOverHandler(pointer: Phaser.Pointer): void;
+        onInputUpHandler(pointer: Phaser.Pointer): void;
+        onInputDownHandler(pointer: Phaser.Pointer): void;
+        onInputOutHandler(pointer: Phaser.Pointer): void;
+    }
 
-      class Graphics extends Phaser.Sprite {
-            constructor(game: Phaser.Game, x: number, y: number);
-            angle: number;
-      }
+    class Graphics extends Phaser.Sprite {
+        constructor(game: Phaser.Game, x: number, y: number);
+        angle: number;
+    }
 
-      class RenderTexture {
-            constructor(game: Phaser.Game, key: string, width: number, height: number);
-            name: string;
-            type: number;
-      }
+    class RenderTexture {
+        constructor(game: Phaser.Game, key: string, width: number, height: number);
+        name: string;
+        type: number;
+    }
 
-      class Canvas {
-            create(width: number, height: number): HTMLCanvasElement;
-            getOffset(element: HTMLElement, point?: Phaser.Point): Phaser.Point;
-            getAspectRatio(canvas: HTMLCanvasElement): number;
-            setBackgroundColor(canvas: HTMLCanvasElement, color: string): HTMLCanvasElement;
-            setTouchAction(canvas: HTMLCanvasElement, value: string): HTMLCanvasElement;
-            addToDOM(canvas: HTMLCanvasElement, parent: string, overflowHidden: boolean): HTMLCanvasElement;
-            setTransform(context: CanvasRenderingContext2D, translateX: number, translateY: number, scaleX: number, scaleY: number, skewX: number, skewY: number): CanvasRenderingContext2D;
-            setSmoothingEnabled(context: CanvasRenderingContext2D, value: boolean): CanvasRenderingContext2D;
-            setImageRenderingCrisp(canvas: HTMLCanvasElement): HTMLCanvasElement;
-            setImageRenderingBicubic(canvas: HTMLCanvasElement): HTMLCanvasElement;
-      }
+    class Canvas {
+        create(width: number, height: number): HTMLCanvasElement;
+        getOffset(element: HTMLElement, point?: Phaser.Point): Phaser.Point;
+        getAspectRatio(canvas: HTMLCanvasElement): number;
+        setBackgroundColor(canvas: HTMLCanvasElement, color: string): HTMLCanvasElement;
+        setTouchAction(canvas: HTMLCanvasElement, value: string): HTMLCanvasElement;
+        addToDOM(canvas: HTMLCanvasElement, parent: string, overflowHidden: boolean): HTMLCanvasElement;
+        setTransform(context: CanvasRenderingContext2D, translateX: number, translateY: number, scaleX: number, scaleY: number, skewX: number, skewY: number): CanvasRenderingContext2D;
+        setSmoothingEnabled(context: CanvasRenderingContext2D, value: boolean): CanvasRenderingContext2D;
+        setImageRenderingCrisp(canvas: HTMLCanvasElement): HTMLCanvasElement;
+        setImageRenderingBicubic(canvas: HTMLCanvasElement): HTMLCanvasElement;
+    }
 
-      class StageScaleMode {
-            constructor(game: Phaser.Game, width: number, height: number);
-            static EXACT_FIT: number;
-            static NO_SCALE: number;
-            static SHOW_ALL: number;
-            forceLandscape: boolean;
-            forcePortrait: boolean;
-            incorrectOrientation: boolean;
-            pageAlignHorizontally: boolean;
-            pageAlignVeritcally: boolean;
-            minWidth: number;
-            maxWidth: number;
-            minHeight: number;
-            maxHeight: number;
-            width: number;
-            height: number;
-            maxIterations: number;
-            game: Phaser.Game;
-            enterLandscape: Phaser.Signal;
-            enterPortrait: Phaser.Signal;
-            orientation: number;
-            scaleFactor: Phaser.Point;
-            aspectRatio: number;
-            isFullScreen: boolean;
-            isPortrait: boolean;
-            isLandscape: boolean;
-            startFullScreen(): void;
-            stopFullScreen(): void;
-            checkOrientationState(): void;
-            checkOrientation(): void;
-            checkResize(event: any): void;
-            refresh(): void;
-            setScreenSize(force: boolean): void;
-            setSize(): void;
-            setMaximum(): void;
-            setShowAll(): void;
-            setExactFit(): void;
-      }
+    class StageScaleMode {
+        constructor(game: Phaser.Game, width: number, height: number);
+        static EXACT_FIT: number;
+        static NO_SCALE: number;
+        static SHOW_ALL: number;
+        forceLandscape: boolean;
+        forcePortrait: boolean;
+        incorrectOrientation: boolean;
+        pageAlignHorizontally: boolean;
+        pageAlignVeritcally: boolean;
+        minWidth: number;
+        maxWidth: number;
+        minHeight: number;
+        maxHeight: number;
+        width: number;
+        height: number;
+        maxIterations: number;
+        game: Phaser.Game;
+        enterLandscape: Phaser.Signal;
+        enterPortrait: Phaser.Signal;
+        orientation: number;
+        scaleFactor: Phaser.Point;
+        aspectRatio: number;
+        isFullScreen: boolean;
+        isPortrait: boolean;
+        isLandscape: boolean;
+        startFullScreen(): void;
+        stopFullScreen(): void;
+        checkOrientationState(): void;
+        checkOrientation(): void;
+        checkResize(event: any): void;
+        refresh(): void;
+        setScreenSize(force: boolean): void;
+        setSize(): void;
+        setMaximum(): void;
+        setShowAll(): void;
+        setExactFit(): void;
+    }
 
-      class Device {
-            patchAndroidClearRect: boolean; 
-            desktop: boolean;
-            iOS: boolean;
-            android: boolean;
-            chromeOS: boolean;
-            linux: boolean;
-            macOS: boolean;
-            windows: boolean;
-            canvas: boolean;
-            file: boolean;
-            fileSystem: boolean; 
-            localStorage: boolean;
-            webGL: boolean;
-            worker: boolean;
-            touch: boolean;
-            mspointer: boolean;
-            css3D: boolean;
-            pointerLock: boolean;
-            arora: boolean;
-            chrome: boolean;
-            epiphany: boolean;
-            firefox: boolean;
-            ie: boolean;
-            ieVersion: number;
-            mobileSafari: boolean;
-            midori: boolean;
-            opera: boolean;
-            safari: boolean;
-            webApp: boolean;
-            audioData: boolean;
-            webAudio: boolean;
-            ogg: boolean;
-            opus: boolean;
-            mp3: boolean;
-            wav: boolean;
-            m4a: boolean;
-            webm: boolean;
-            iPhone: boolean;
-            iPhone4: boolean;
-            iPad: boolean;
-            pixelRatio: number;
-            canPlayAudio(type: string): boolean;
-            isConsoleOpen(): boolean;
-      }
+    class Device {
+        patchAndroidClearRect: boolean;
+        desktop: boolean;
+        iOS: boolean;
+        android: boolean;
+        chromeOS: boolean;
+        linux: boolean;
+        macOS: boolean;
+        windows: boolean;
+        canvas: boolean;
+        file: boolean;
+        fileSystem: boolean;
+        localStorage: boolean;
+        webGL: boolean;
+        worker: boolean;
+        touch: boolean;
+        mspointer: boolean;
+        css3D: boolean;
+        pointerLock: boolean;
+        arora: boolean;
+        chrome: boolean;
+        epiphany: boolean;
+        firefox: boolean;
+        ie: boolean;
+        ieVersion: number;
+        mobileSafari: boolean;
+        midori: boolean;
+        opera: boolean;
+        safari: boolean;
+        webApp: boolean;
+        audioData: boolean;
+        webAudio: boolean;
+        ogg: boolean;
+        opus: boolean;
+        mp3: boolean;
+        wav: boolean;
+        m4a: boolean;
+        webm: boolean;
+        iPhone: boolean;
+        iPhone4: boolean;
+        iPad: boolean;
+        pixelRatio: number;
+        canPlayAudio(type: string): boolean;
+        isConsoleOpen(): boolean;
+    }
 
-      class RequestAnimationFrame {
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            isRunning: boolean;
-            start(): boolean;
-            updateRAF(time: number): void;
-            updateSetTimeout(): void;
-            stop(): void;
-            isSetTimeOut(): boolean;
-            isRAF(): boolean;
-      }
+    class RequestAnimationFrame {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        isRunning: boolean;
+        start(): boolean;
+        updateRAF(time: number): void;
+        updateSetTimeout(): void;
+        stop(): void;
+        isSetTimeOut(): boolean;
+        isRAF(): boolean;
+    }
 
-      class RandomDataGenerator {
-            constructor(seeds: Array<number>);
-            c: number;
-            s0: number;
-            s1: number;
-            s2: number; 
-            rnd(): number;
-            sow(seeds: Array<any>): void;
-            hash(data: any): number;
-            integer(): number;
-            frac(): number;
-            real(): number;
-            integerInRange(min: number, max: number): number;
-            realInRange(min: number, max: number): number;
-            normal(): number;
-            uuid(): number;
-            pick(ary: number[]): number; 
-            weightedPick(ary: number[]): number;
-            timestamp(a?: number, b?: number): number;
-            angle(): number;
-      }
+    class RandomDataGenerator {
+        constructor(seeds: Array<number>);
+        c: number;
+        s0: number;
+        s1: number;
+        s2: number;
+        rnd(): number;
+        sow(seeds: Array<any>): void;
+        hash(data: any): number;
+        integer(): number;
+        frac(): number;
+        real(): number;
+        integerInRange(min: number, max: number): number;
+        realInRange(min: number, max: number): number;
+        normal(): number;
+        uuid(): number;
+        pick(ary: number[]): number;
+        weightedPick(ary: number[]): number;
+        timestamp(a?: number, b?: number): number;
+        angle(): number;
+    }
 
-      class Math {
-            static PI2: number;
-            static fuzzyEqual(a: number, b: number, epsilon?: number): boolean;
-            static fuzzyLessThan(a: number, b: number, epsilon?: number): boolean;
-            static fuzzyGreaterThan(a: number, b: number, epsilon?: number): boolean;
-            static fuzzyCeil(a: number, b: number, epsilon?: number): boolean;
-            static fuzzyFloor(a: number, b: number, epsilon?: number): boolean;
-            static average(...numbers: number[]): number;
-            static truncate(n: number): number;
-            static shear(n: number): number;
-            static snapTo(input: number, gap: number, start?: number): number;
-            static snapToFloor(input: number, gap: number, start?: number): number;
-            static snapToCeil(input: number, gap: number, start?: number): number;
-            static snapToInArray(input: number, arr: number[], sort?: boolean): number;
-            static roundTo(value: number, place?: number, base?: number): number;
-            static floorTo(value: number, place?: number, base?: number): number;
-            static ceilTo(value: number, place?: number, base?: number): number;
-            static interpolateFloat(a: number, b: number, weight: number): number;
-            static angleBetween(x1: number, y1: number, x2: number, y2: number): number;
-            static normalizeAngle(angle: number, radians?: boolean): number;
-            static nearestAngleBetween(a1: number, a2: number, radians?: boolean): number;
-            static interpolateAngles(a1: number, a2: number, weight: number, radians?: boolean, ease?: any): number;
-            static chanceRoll(chance?: number): boolean;
-            static numberArray(min: number, max: number): number[];
-            static maxAdd(value: number, amount: number, max: number): number;
-            static minSub(value: number, amount: number, min: number): number;
-            static wrap(value: number, min: number, max: number): number;
-            static wrapValue(value: number, amount: number, max: number): number;
-            static randomSign(): number;
-            static isOdd(n: number): boolean; 
-            static isEven(n: number): boolean;
-            static max(...numbers: number[]): number;
-            static min(...numbers: number[]): number;
-            static wrapAngle(angle: number): number;
-            static angleLimit(angle: number, min: number, max: number): number;
-            static linearInterpolation(v: number[], k: number): number;
-            static bezierInterpolation(v: number[], k: number): number;
-            static catmullRomInterpolation(v: number[], k: number): number;
-            static linear(p0: number, p1: number, t: number): number;
-            static bernstein(n: number, i: number): number;
-            static catmullRom(p0: number, p1: number, p2: number, p3: number, t: number): number;
-            static difference(a: number, b: number): number;
-            static getRandom(objects: Object[], startIndex?: number, length?: number): Object;
-            static floor(value: number): number;
-            static ceil(value: number): number;
-            static sinCosGenerator(length: number, sinAmplitude?: number, cosAmplitude?: number, frequency?: number): { sin: number[]; cos: number[]; };
-            static shift(stack: Array<any>): any;
-            static shuffleArray(array: Array<any>): Array<any>;
-            static distance(x1: number, y1: number, x2: number, y2: number): number;
-            static distanceRounded(x1: number, y1: number, x2: number, y2: number): number;
-            static clamp(x: number, a: number, b: number): number;
-            static clampBottom(x: number, a: number): number;
-            static mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number;
-            static smoothstep(x: number, min: number, max: number): number;
-            static smootherstep(x: number, min: number, max: number): number;
-            static sign(x: number): number;
-            static degToRad(degrees: number): number;
-            static radToDeg(radians: number): number;
-      }
+    class Math {
+        static PI2: number;
+        static fuzzyEqual(a: number, b: number, epsilon?: number): boolean;
+        static fuzzyLessThan(a: number, b: number, epsilon?: number): boolean;
+        static fuzzyGreaterThan(a: number, b: number, epsilon?: number): boolean;
+        static fuzzyCeil(a: number, b: number, epsilon?: number): boolean;
+        static fuzzyFloor(a: number, b: number, epsilon?: number): boolean;
+        static average(...numbers: number[]): number;
+        static truncate(n: number): number;
+        static shear(n: number): number;
+        static snapTo(input: number, gap: number, start?: number): number;
+        static snapToFloor(input: number, gap: number, start?: number): number;
+        static snapToCeil(input: number, gap: number, start?: number): number;
+        static snapToInArray(input: number, arr: number[], sort?: boolean): number;
+        static roundTo(value: number, place?: number, base?: number): number;
+        static floorTo(value: number, place?: number, base?: number): number;
+        static ceilTo(value: number, place?: number, base?: number): number;
+        static interpolateFloat(a: number, b: number, weight: number): number;
+        static angleBetween(x1: number, y1: number, x2: number, y2: number): number;
+        static normalizeAngle(angle: number, radians?: boolean): number;
+        static nearestAngleBetween(a1: number, a2: number, radians?: boolean): number;
+        static interpolateAngles(a1: number, a2: number, weight: number, radians?: boolean, ease?: any): number;
+        static chanceRoll(chance?: number): boolean;
+        static numberArray(min: number, max: number): number[];
+        static maxAdd(value: number, amount: number, max: number): number;
+        static minSub(value: number, amount: number, min: number): number;
+        static wrap(value: number, min: number, max: number): number;
+        static wrapValue(value: number, amount: number, max: number): number;
+        static randomSign(): number;
+        static isOdd(n: number): boolean;
+        static isEven(n: number): boolean;
+        static max(...numbers: number[]): number;
+        static min(...numbers: number[]): number;
+        static wrapAngle(angle: number): number;
+        static angleLimit(angle: number, min: number, max: number): number;
+        static linearInterpolation(v: number[], k: number): number;
+        static bezierInterpolation(v: number[], k: number): number;
+        static catmullRomInterpolation(v: number[], k: number): number;
+        static linear(p0: number, p1: number, t: number): number;
+        static bernstein(n: number, i: number): number;
+        static catmullRom(p0: number, p1: number, p2: number, p3: number, t: number): number;
+        static difference(a: number, b: number): number;
+        static getRandom(objects: Object[], startIndex?: number, length?: number): Object;
+        static floor(value: number): number;
+        static ceil(value: number): number;
+        static sinCosGenerator(length: number, sinAmplitude?: number, cosAmplitude?: number, frequency?: number): { sin: number[]; cos: number[]; };
+        static shift(stack: Array<any>): any;
+        static shuffleArray(array: Array<any>): Array<any>;
+        static distance(x1: number, y1: number, x2: number, y2: number): number;
+        static distanceRounded(x1: number, y1: number, x2: number, y2: number): number;
+        static clamp(x: number, a: number, b: number): number;
+        static clampBottom(x: number, a: number): number;
+        static mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number;
+        static smoothstep(x: number, min: number, max: number): number;
+        static smootherstep(x: number, min: number, max: number): number;
+        static sign(x: number): number;
+        static degToRad(degrees: number): number;
+        static radToDeg(radians: number): number;
+    }
 
-      class QuadTree {
-            constructor(physicsManager: Phaser.Physics.Arcade, x: number, y: number, width: number, height: number, maxObject?: number, maxLevels?: number, level?: number);
-            physicsManager: Phaser.Physics.Arcade;
-            ID: number;
-            maxObjects: number;
-            maxLevels: number;
-            level: number;
-            bounds: { 
-                  x: number;
-                  y: number;
-                  width: number;
-                  height: number;
-                  subWidth: number;
-                  subHeight: number;
-                  right: number;
-                  bottom: number;
-            };
-            objects: Array<any>;
-            nodes: Array<any>;
-            split(): void;
-            insert(body: Object): void;  
-            getIndex(rect: Object): number;
-            retrieve(sprite: Object): Array<any>;
-            clear(): void;
-      }
-
-      class Circle {
-            constructor(x?: number, y?: number, diameter?: number);
-            x: number;
-            y: number;
-            diameter: number;
-            radius: number;
-            left: number;
-            right: number;
-            top: number;
-            bottom: number;
-            area: number;
-            empty: boolean;
-            circumference(): number;
-            setTo(x: number, y: number, diameter: number): Circle;
-            copyFrom(source: any): Circle;
-            copyTo(dest: Object): Object;
-            distance(dest: Object, round: boolean): number;
-            clone(out: Phaser.Circle): Phaser.Circle;
-            contains(x: number, y: number): Phaser.Circle;
-            circumferencePoint(angle: number, asDegrees: number, output?: Phaser.Point): Phaser.Point;
-            offset(dx: number, dy: number): Phaser.Circle;
-            offsetPoint(point: Phaser.Point): Phaser.Circle;
-            toString(): string;
-            static contains(a: Phaser.Circle, x: number, y: number): boolean;
-            static equals(a: Phaser.Circle, b: Phaser.Circle): boolean;
-            static intersects(a: Phaser.Circle, b: Phaser.Circle): boolean;
-            static circumferencePoint(a: Phaser.Circle, angle: number, asDegrees: boolean, output?: Phaser.Point): Phaser.Point;
-            static intersectsRectangle(c: Phaser.Circle, r: Phaser.Rectangle): boolean;
-      }
-
-      class Point {
-            constructor(x: number, y: number);
-            x: number;
-            y: number;
-            copyFrom(source: any): Phaser.Point;
-            invert(): Phaser.Point;
-            setTo(x: number, y: number): Phaser.Point;
-            add(x: number, y: number): Phaser.Point;
-            subtract(x: number, y: number): Phaser.Point;
-            multiply(x: number, y: number): Phaser.Point;
-            divide(x: number, y: number): Phaser.Point;
-            clampX(min: number, max: number): Phaser.Point;
-            clampY(min: number, max: number): Phaser.Point;
-            clamp(min: number, max: number): Phaser.Point;
-            clone(output: Phaser.Point): Phaser.Point;
-            copyTo(dest: any): Object;
-            distance(dest: Object, round?: boolean): number;
-            equals(a: Phaser.Point): boolean;
-            rotate(x: number, y: number, angle: number, asDegrees: boolean, distance: number): Phaser.Point;
-            toString(): string;
-            static add(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
-            static subtract(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
-            static multiply(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
-            static divide(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
-            static equals(a: Phaser.Point, b: Phaser.Point): boolean;
-            static distance(a: Phaser.Point, b: Phaser.Point, round: boolean): number;
-            static rotate(a: Phaser.Point, x: number, y: number, angle: number, asDegrees: boolean, distance: boolean): Phaser.Point;
-      }
-
-      class Rectangle {
-            constructor(x: number, y: number, width: number, height: number);
+    class QuadTree {
+        constructor(physicsManager: Phaser.Physics.Arcade, x: number, y: number, width: number, height: number, maxObject?: number, maxLevels?: number, level?: number);
+        physicsManager: Phaser.Physics.Arcade;
+        ID: number;
+        maxObjects: number;
+        maxLevels: number;
+        level: number;
+        bounds: {
             x: number;
             y: number;
             width: number;
             height: number;
-            halfWidth: number;
-            halfHeight: number;
-            bottom: number;
-            bottomRight: Phaser.Point;
-            left: number;
+            subWidth: number;
+            subHeight: number;
             right: number;
-            volume: number;
-            perimeter: number;
-            centerX: number;
-            centerY: number;
-            top: number;
-            topLeft: Phaser.Point;
-            empty: boolean;
-            offset(dx: number, dy: number): Phaser.Rectangle;
-            offsetPoint(point: Phaser.Point): Phaser.Rectangle;
-            setTo(x: number, y: number, width: number, height: number): Phaser.Rectangle;
-            floor(): void;
-            copyFrom(source: any): Phaser.Rectangle;
-            copyTo(dest: any): Object;
-            inflate(dx: number, dy: number): Phaser.Rectangle;
-            size(output: Phaser.Point): Phaser.Point;
-            clone(output: Phaser.Rectangle): Phaser.Rectangle;
-            contains(x: number, y: number): boolean;
-            containsRect(b: Phaser.Rectangle): boolean;
-            equals(b: Phaser.Rectangle): boolean;
-            intersection(b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
-            intersects(b: Phaser.Rectangle, tolerance: number): boolean;
-            intersectsRaw(left: number, right: number, top: number, bottom: number, tolerance: number): boolean;
-            union(b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
-            toString(): string;
-            static inflate(a: Phaser.Rectangle, dx: number, dy: number): Phaser.Rectangle;
-            static inflatePoint(a: Phaser.Rectangle, point: Phaser.Point): Phaser.Rectangle;
-            static size(a: Phaser.Rectangle, output: Phaser.Point): Phaser.Point;
-            static clone(a: Phaser.Rectangle, output: Phaser.Rectangle): Phaser.Rectangle;
-            static contains(a: Phaser.Rectangle, x: number, y: number): boolean;
-            static containsPoint(a: Phaser.Rectangle, point: Phaser.Point): boolean;
-            static containsRect(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean;
-            static equals(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean;
-            static intersection(a: Phaser.Rectangle, b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
-            static intersects(a: Phaser.Rectangle, b: Phaser.Rectangle, tolerance: number): boolean;
-            static intersectsRaw(a: Phaser.Rectangle, left: number, right: number, top: number, bottom: number, tolerance: number): boolean;
-            static union(a: Phaser.Rectangle, b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
-      }
+            bottom: number;
+        };
+        objects: Array<any>;
+        nodes: Array<any>;
+        split(): void;
+        insert(body: Object): void;
+        getIndex(rect: Object): number;
+        retrieve(sprite: Object): Array<any>;
+        clear(): void;
+    }
 
-      class Net {
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            getHostName(): string;
-            checkDomainName(domain: string): string;
-            updateQueryString(key: string, value: any, redirect?: boolean, url?: string): string;
-            getQueryString(parameter?: string): string;
-            decodeURI(value: string): string;
-      }
+    class Circle {
+        constructor(x?: number, y?: number, diameter?: number);
+        x: number;
+        y: number;
+        diameter: number;
+        radius: number;
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        area: number;
+        empty: boolean;
+        circumference(): number;
+        setTo(x: number, y: number, diameter: number): Circle;
+        copyFrom(source: any): Circle;
+        copyTo(dest: Object): Object;
+        distance(dest: Object, round: boolean): number;
+        clone(out: Phaser.Circle): Phaser.Circle;
+        contains(x: number, y: number): Phaser.Circle;
+        circumferencePoint(angle: number, asDegrees: number, output?: Phaser.Point): Phaser.Point;
+        offset(dx: number, dy: number): Phaser.Circle;
+        offsetPoint(point: Phaser.Point): Phaser.Circle;
+        toString(): string;
+        static contains(a: Phaser.Circle, x: number, y: number): boolean;
+        static equals(a: Phaser.Circle, b: Phaser.Circle): boolean;
+        static intersects(a: Phaser.Circle, b: Phaser.Circle): boolean;
+        static circumferencePoint(a: Phaser.Circle, angle: number, asDegrees: boolean, output?: Phaser.Point): Phaser.Point;
+        static intersectsRectangle(c: Phaser.Circle, r: Phaser.Rectangle): boolean;
+    }
 
-      class TweenManager {
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            REVISION: string;
-            getAll(): Phaser.Tween[];
-            removeAll(): void;
-            add(tween: Phaser.Tween): Phaser.Tween;
-            create(object: Object): Phaser.Tween;
-            remove(tween: Phaser.Tween): void;
-            update(): boolean;
-            pauseAll(): void;
-            resumeAll(): void;
-      }
+    class Point {
+        constructor(x: number, y: number);
+        x: number;
+        y: number;
+        copyFrom(source: any): Phaser.Point;
+        invert(): Phaser.Point;
+        setTo(x: number, y: number): Phaser.Point;
+        add(x: number, y: number): Phaser.Point;
+        subtract(x: number, y: number): Phaser.Point;
+        multiply(x: number, y: number): Phaser.Point;
+        divide(x: number, y: number): Phaser.Point;
+        clampX(min: number, max: number): Phaser.Point;
+        clampY(min: number, max: number): Phaser.Point;
+        clamp(min: number, max: number): Phaser.Point;
+        clone(output: Phaser.Point): Phaser.Point;
+        copyTo(dest: any): Object;
+        distance(dest: Object, round?: boolean): number;
+        equals(a: Phaser.Point): boolean;
+        rotate(x: number, y: number, angle: number, asDegrees: boolean, distance: number): Phaser.Point;
+        toString(): string;
+        static add(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
+        static subtract(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
+        static multiply(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
+        static divide(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
+        static equals(a: Phaser.Point, b: Phaser.Point): boolean;
+        static distance(a: Phaser.Point, b: Phaser.Point, round: boolean): number;
+        static rotate(a: Phaser.Point, x: number, y: number, angle: number, asDegrees: boolean, distance: boolean): Phaser.Point;
+    }
 
-      class Tween {
-            constructor(object: Object, game: Phaser.Game);
-            game: Phaser.Game;
-            pending: boolean;
-            pendingDelete: boolean;
-            onStart: Phaser.Signal;
-            onComplete: Phaser.Signal;
-            isRunning: boolean;
-            to(properties: Object, duration?: number, ease?: any, autoStart?: boolean, delay?: number, loop?: boolean): Phaser.Tween;
-            start(time: number): Phaser.Tween;
-            stop(): Phaser.Tween;
-            delay(amount: number): Phaser.Tween;
-            repeat(times: number): Phaser.Tween;
-            yoyo(yoyo: boolean): Phaser.Tween;
-            easing(easing: any): Phaser.Tween;
-            interpolation(interpolation: Function): Phaser.Tween;
-            chain(...tweens: Phaser.Tween[]): Phaser.Tween;
-            loop(): Phaser.Tween;
-            onStartCallback(callback: Function): Phaser.Tween;
-            onUpdateCallback(callback: Function): Phaser.Tween;
-            onCompleteCallback(callback: Function): Phaser.Tween;
-            pause(): void;
-            resume(): void;
-            update(time: number): boolean;
+    class Rectangle {
+        constructor(x: number, y: number, width: number, height: number);
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        halfWidth: number;
+        halfHeight: number;
+        bottom: number;
+        bottomRight: Phaser.Point;
+        left: number;
+        right: number;
+        volume: number;
+        perimeter: number;
+        centerX: number;
+        centerY: number;
+        top: number;
+        topLeft: Phaser.Point;
+        empty: boolean;
+        offset(dx: number, dy: number): Phaser.Rectangle;
+        offsetPoint(point: Phaser.Point): Phaser.Rectangle;
+        setTo(x: number, y: number, width: number, height: number): Phaser.Rectangle;
+        floor(): void;
+        copyFrom(source: any): Phaser.Rectangle;
+        copyTo(dest: any): Object;
+        inflate(dx: number, dy: number): Phaser.Rectangle;
+        size(output: Phaser.Point): Phaser.Point;
+        clone(output: Phaser.Rectangle): Phaser.Rectangle;
+        contains(x: number, y: number): boolean;
+        containsRect(b: Phaser.Rectangle): boolean;
+        equals(b: Phaser.Rectangle): boolean;
+        intersection(b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
+        intersects(b: Phaser.Rectangle, tolerance: number): boolean;
+        intersectsRaw(left: number, right: number, top: number, bottom: number, tolerance: number): boolean;
+        union(b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
+        toString(): string;
+        static inflate(a: Phaser.Rectangle, dx: number, dy: number): Phaser.Rectangle;
+        static inflatePoint(a: Phaser.Rectangle, point: Phaser.Point): Phaser.Rectangle;
+        static size(a: Phaser.Rectangle, output: Phaser.Point): Phaser.Point;
+        static clone(a: Phaser.Rectangle, output: Phaser.Rectangle): Phaser.Rectangle;
+        static contains(a: Phaser.Rectangle, x: number, y: number): boolean;
+        static containsPoint(a: Phaser.Rectangle, point: Phaser.Point): boolean;
+        static containsRect(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean;
+        static equals(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean;
+        static intersection(a: Phaser.Rectangle, b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
+        static intersects(a: Phaser.Rectangle, b: Phaser.Rectangle, tolerance: number): boolean;
+        static intersectsRaw(a: Phaser.Rectangle, left: number, right: number, top: number, bottom: number, tolerance: number): boolean;
+        static union(a: Phaser.Rectangle, b: Phaser.Rectangle, out: Phaser.Rectangle): Phaser.Rectangle;
+    }
+
+    class Net {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        getHostName(): string;
+        checkDomainName(domain: string): string;
+        updateQueryString(key: string, value: any, redirect?: boolean, url?: string): string;
+        getQueryString(parameter?: string): string;
+        decodeURI(value: string): string;
+    }
+
+    class TweenManager {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        REVISION: string;
+        getAll(): Phaser.Tween[];
+        removeAll(): void;
+        add(tween: Phaser.Tween): Phaser.Tween;
+        create(object: Object): Phaser.Tween;
+        remove(tween: Phaser.Tween): void;
+        update(): boolean;
+        pauseAll(): void;
+        resumeAll(): void;
+    }
+
+    class Tween {
+        constructor(object: Object, game: Phaser.Game);
+        game: Phaser.Game;
+        pending: boolean;
+        pendingDelete: boolean;
+        onStart: Phaser.Signal;
+        onComplete: Phaser.Signal;
+        isRunning: boolean;
+        to(properties: Object, duration?: number, ease?: any, autoStart?: boolean, delay?: number, loop?: boolean): Phaser.Tween;
+        start(time: number): Phaser.Tween;
+        stop(): Phaser.Tween;
+        delay(amount: number): Phaser.Tween;
+        repeat(times: number): Phaser.Tween;
+        yoyo(yoyo: boolean): Phaser.Tween;
+        easing(easing: any): Phaser.Tween;
+        interpolation(interpolation: Function): Phaser.Tween;
+        chain(...tweens: Phaser.Tween[]): Phaser.Tween;
+        loop(): Phaser.Tween;
+        onStartCallback(callback: Function): Phaser.Tween;
+        onUpdateCallback(callback: Function): Phaser.Tween;
+        onCompleteCallback(callback: Function): Phaser.Tween;
+        pause(): void;
+        resume(): void;
+        update(time: number): boolean;
     }
 
     module Easing {
@@ -1281,610 +1281,611 @@ declare module Phaser {
 
     }
 
-      class Time {
+    class Time {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        physicsElapsed: number;
+        time: number;
+        pausedTime: number;
+        now: number;
+        elapsed: number;
+        fps: number;
+        fpsMin: number;
+        fpsMax: number;
+        msMin: number;
+        msMax: number;
+        frames: number;
+        pauseDuration: number;
+        timeToCall: number;
+        lastTime: number;
+        totalElapsedSeconds(): number;
+        update(time: number): number;
+        gamePaused(): void;
+        gameResumed(): void;
+        elapsedSince(since: number): number;
+        elapsedSecondsSince(since: number): number;
+        reset(): void;
+    }
+
+    class AnimationManager {
+        constructor(sprite);
+        sprite: Phaser.Sprite;
+        game: Phaser.Game;
+        currentFrame: Phaser.Frame;
+        updateIfVisible: boolean;
+        frameData: Phaser.FrameData;
+        frameTotal: number;
+        frame: number;
+        frameName: string;
+        loadFrameData(frameData: Phaser.FrameData): void;
+        add(name: string, frames?: Array<any>, frameRate?: number, loop?: boolean, useNumericIndex?: boolean): Phaser.Animation;
+        validateFrames(frames: Array<any>, useNumericIndex?: boolean): boolean;
+        play(name: string, frameRate?: number, loop?: boolean): Phaser.Animation;
+        stop(name?: string, resetFrame?: boolean): void;
+        update(): boolean;
+        destroy(): void;
+    }
+
+    class Animation {
+        constructor(game: Phaser.Game, parent: Phaser.Sprite, name: string, frameData: Phaser.FrameData, frames: any[], delay: number, looped: boolean);
+        game: Phaser.Game;
+        name: string;
+        delay: number;
+        looped: boolean;
+        isFinished: boolean;
+        isPlaying: boolean;
+        currentFrame: Phaser.Frame;
+        frameTotal: number;
+        frame: number;
+        play(frameRate?: number, loop?: boolean): Phaser.Animation;
+        restart(): void;
+        stop(resetFrame?: boolean): void;
+        update(): boolean;
+        destroy(): void;
+        onComplete(): void;
+    }
+
+    class Frame {
+        constructor(index: number, x: number, y: number, width: number, height: number, name: string, uuid: string);
+        index: number;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        centerX: number;
+        centerY: number;
+        distance: number;
+        name: string;
+        uuid: string;
+        rotated: boolean;
+        rotationDirection: string;
+        trimmed: boolean;
+        sourceSizeW: number;
+        sourceSizeH: number;
+        spriteSourceSizeX: number;
+        spriteSourceSizeY: number;
+        spriteSourceSizeW: number;
+        spriteSourcesizeH: number;
+        setTrim(trimmed: boolean, actualWidth: number, actualHeight: number, destX: number, destY: number, destWidth: number, destHeight: number): void;
+    }
+
+    class FrameData {
+        addFrame(frame: Frame): Frame;
+        getFrame(index: number): Frame;
+        getFrameByName(name: string): Frame;
+        checkFrame(name: string): boolean;
+        getFrameRange(start: number, end: number, output: Array<Frame>): Array<Frame>;
+        getFrames(frames: Array<number>, useNumericIndex?: boolean, output?: Array<Frame>): Array<Frame>;
+        getFrameIndexes(frames: Array<number>, useNumericIndex?: boolean, output?: Array<number>): Array<number>;
+        total: number;
+    }
+
+    class AnimationParser {
+        spriteSheet(game: Phaser.Game, key: string, frameWidth: number, frameHeight: number, frameMax?: number): Phaser.FrameData;
+        JSONData(game: Phaser.Game, json: Object, cacheKey: string): Phaser.FrameData;
+        JSONDataHash(game: Phaser.Game, json: Object, cacheKey: string): Phaser.FrameData;
+        XMLData(game: Phaser.Game, xml: Object, cacheKey: string): Phaser.FrameData;
+    }
+
+    class Cache {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        onSoundUnlock: Phaser.Signal;
+        addCanvas(key: string, canvas: HTMLCanvasElement, context: CanvasRenderingContext2D): void;
+        addRenderTexture(key: string, texture: RenderTexture): void;
+        addSpriteSheet(key: string, url: string, data: Object, frameWidth: number, frameHeight: number, frameMax: number): void;
+        addTilemap(key: string, url: string, data: Object, mapData: Object, atlasData: Object): void;
+        addTextureAtlas(key: string, url: string, data: Object, atlasData: Object): void;
+        addBitmapFont(key: string, url: string, data: Object, xmlData: Object): void;
+        addDefaultImage(): void;
+        addImage(key: string, url: string, data: Object): void;
+        addSound(key: string, url: string, data: Object): void;
+        reloadSound(key: string): void;
+        reloadSoundComplete(key: string): void;
+        updateSound(key: string, property: string, value: Phaser.Sound): void;
+        decodedSound(key: string, data: Object): void;
+        addText(key: string, url: string, data: Object): void;
+        getCanvas(key: string): Object;
+        checkImageKey(key: string): boolean;
+        getImage(key: string): Object;
+        getTilemap(key: string): Phaser.Tilemap;
+        getFrameData(key: string): Phaser.FrameData;
+        getFrameByIndex(key: string, frame: string): Phaser.Frame;
+        getFrameByName(key: string, frame: string): Phaser.Frame;
+        getFrame(key: string): Phaser.Frame;
+        getTextureFrame(key: string): Phaser.Frame;
+        getTexture(key: string): Phaser.RenderTexture;
+        getSound(key: string): Phaser.Sound;
+        getSoundData(key: string): Object;
+        isSoundDecoded(key: string): boolean;
+        isSoundReady(key: string): boolean;
+        isSpriteSheet(key: string): boolean;
+        getText(key: string): Object;
+        getKeys(array: Array<string>): Array<string>;
+        getImageKeys(): string[];
+        getSoundKeys(): string[];
+        getTextKeys(): string[];
+        removeCanvas(key: string): void;
+        removeImage(key: string): void;
+        removeSound(key: string): void;
+        removeText(key: string): void;
+        destroy(): void;
+    }
+
+    class Loader {
+        static TEXTURE_ATLAS_JSON_ARRAY: number;
+        static TEXTURE_ATLAS_JSON_HASH: number;
+        static TEXTURE_ATLAS_XML_STARLING: number;
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        queueSize: number;
+        isLoading: boolean;
+        hasLoaded: boolean;
+        progress: number;
+        preloadSprite: Phaser.Sprite;
+        crossOrigin: string;
+        baseURL: string;
+        onFileComplete: Phaser.Signal;
+        onFileError: Phaser.Signal;
+        onLoadStart: Phaser.Signal;
+        onLoadComplete: Phaser.Signal;
+        setPreloadSprite(sprite: Phaser.Sprite, direction?: number): void;
+        checkKeyExists(key: string): boolean;
+        reset(): void;
+        addToFileList(type: string, key: string, url: string, properties: Array<any>): void;
+        image(key: string, url: string, overwrite?: boolean): void;
+        text(key: string, url: string, overwrite?: boolean): void;
+        spritesheet(key: string, url: string, frameWidth: number, frameHeight: number, frameMax: number): void;
+        audio(key: string, urls: any, autoDecode?: boolean): void;
+        tilemap(key: string, tilesetURL: string, mapDataURL?: string, mapData?: Object, format?: string): void;
+        tileset(key: string, url: string, tileWidth: number, tileHeight: number, tileMargin?: number, tileSpacing?: number, rows?: number, columns?: number, limit?: number): void;
+        bitmapFont(key: string, textureURL: string, xmlURL?: string, xmlData?: Object): void;
+        atlasJSONArray(key: string, textureURL: string, atlasURL: string, atlasData: Object): void;
+        atlasJSONHash(key: string, textureURL: string, atlasURL: string, atlasData: Object): void;
+        atlasXML(key: string, textureURL: string, atlasURL: string, atlasData: Object): void;
+        atlas(key: string, textureURL: string, atlasURL?: string, atlasData?: Object, format?: number): void;
+        removeFile(key: string): void;
+        removeAll(): void;
+        start(): void;
+        loadFile(): void;
+        getAudioURL(urls: string[]): string;
+        fileError(key: string): void;
+        fileComplete(key: string): void;
+        jsonLoadComplete(key: string): void;
+        csvLoadComplete(key: string): void;
+        dataLoadError(key: string): void;
+        xmlLoadComplete(key: string): void;
+        nextFile(previousKey: string, success: boolean): void;
+    }
+
+    class LoaderParser {
+        bitmapFont(game: Phaser.Game, xml: Object, cacheKey: Phaser.FrameData): void;
+    }
+
+    class Sound {
+        constructor(game: Phaser.Game, key: string, volume?: number, loop?: boolean);
+        game: Phaser.Game;
+        name: string;
+        key: string;
+        loop: boolean;
+        markers: Object;
+        context: any;
+        autoplay: boolean;
+        totalDuration: number;
+        startTime: number;
+        currentTime: number;
+        duration: number;
+        stopTime: number;
+        paused: boolean;
+        isPlaying: boolean;
+        currentMarker: string;
+        pendingPlayback: boolean;
+        override: boolean;
+        usingWebAudio: boolean;
+        usingAudioTag: boolean;
+        onDecoded: Phaser.Signal;
+        onPlay: Phaser.Signal;
+        onPause: Phaser.Signal;
+        onResume: Phaser.Signal;
+        onLoop: Phaser.Signal;
+        onStop: Phaser.Signal;
+        onMute: Phaser.Signal;
+        isDecoded: boolean;
+        isDecoding: boolean;
+        mute: boolean;
+        volume: number;
+        onMarkerComplete: Phaser.Signal;
+        soundHasUnlocked(key: string): void;
+        addMarker(name: string, start: number, stop: number, volume?: number, loop?: boolean): void;
+        removeMarker(name: string): void;
+        update(): void;
+        play(marker?: string, position?: number, volume?: number, loop?: boolean): Phaser.Sound;
+        restart(marker: string, position: number, volume?: number, loop?: boolean): void;
+        pause(): void;
+        resume(): void;
+        stop(): void;
+    }
+
+    class SoundManager {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        onSoundDecode: Phaser.Signal;
+        context: any;
+        usingWebAudio: boolean;
+        usingAudioTag: boolean;
+        noAudio: boolean;
+        touchLocked: boolean;
+        channels: number;
+        mute: boolean;
+        volume: number;
+        boot(): void;
+        unlock(): void;
+        stopAll(): void;
+        pauseAll(): void;
+        resumeAll(): void;
+        decode(key: string, sound?: Phaser.Sound): void;
+        update(): void;
+        add(key: string, volume: number, loop: boolean): Phaser.Sound;
+    }
+
+    module Utils {
+        class Debug {
             constructor(game: Phaser.Game);
             game: Phaser.Game;
-            physicsElapsed: number;
-            time: number;
-            pausedTime: number;
-            now: number;
-            elapsed: number;
-            fps: number;
-            fpsMin: number;
-            fpsMax: number;
-            msMin: number;
-            msMax: number;
-            frames: number;
-            pauseDuration: number;
-            timeToCall: number;
-            lastTime: number;
-            totalElapsedSeconds(): number;
-            update(time: number): number;
-            gamePaused(): void;
-            gameResumed(): void;
-            elapsedSince(since: number): number;
-            elapsedSecondsSince(since: number): number;
-            reset(): void;
-      }
-
-      class AnimationManager {
-            constructor(sprite);
-            sprite: Phaser.Sprite;
-            game: Phaser.Game;
-            currentFrame: Phaser.Frame;
-            updateIfVisible: boolean;
-            frameData: Phaser.FrameData;
-            frameTotal: number;
-            frame: number;
-            frameName: string;
-            loadFrameData(frameData: Phaser.FrameData): void;
-            add(name: string, frames?: Array<any>, frameRate?: number, loop?: boolean, useNumericIndex?: boolean): Phaser.Animation;
-            validateFrames(frames: Array<any>, useNumericIndex?: boolean): boolean;
-            play(name: string, frameRate?: number, loop?: boolean): Phaser.Animation;
-            stop(name?: string, resetFrame?: boolean): void;
-            update(): boolean;
-            destroy(): void;
-      }
-
-      class Animation {
-            constructor(game: Phaser.Game, parent: Phaser.Sprite, name: string, frameData: Phaser.FrameData, frames: any[], delay: number, looped: boolean);
-            game: Phaser.Game;
-            name: string;
-            delay: number;
-            looped: boolean;
-            isFinished: boolean;
-            isPlaying: boolean;
-            currentFrame: Phaser.Frame;
-            frameTotal: number;
-            frame: number;
-            play(frameRate?: number, loop?: boolean): Phaser.Animation;
-            restart(): void;
-            stop(resetFrame?: boolean): void;
-            update(): boolean;
-            destroy(): void;
-            onComplete(): void;
-      }
-
-      class Frame {
-            constructor(index: number, x: number, y: number, width: number, height: number, name: string, uuid: string);
-            index: number;
-            x: number;
-            y: number;
-            width: number;
-            height: number;
-            centerX: number;
-            centerY: number;
-            distance: number;
-            name: string;
-            uuid: string;
-            rotated: boolean;
-            rotationDirection: string;
-            trimmed: boolean;
-            sourceSizeW: number;
-            sourceSizeH: number;
-            spriteSourceSizeX: number;
-            spriteSourceSizeY: number;
-            spriteSourceSizeW: number;
-            spriteSourcesizeH: number;
-            setTrim(trimmed: boolean, actualWidth: number, actualHeight: number, destX: number, destY: number, destWidth: number, destHeight: number): void;
-      }
-
-      class FrameData {
-            addFrame(frame: Frame): Frame;
-            getFrame(index: number): Frame;
-            getFrameByName(name: string): Frame;
-            checkFrame(name: string): boolean;
-            getFrameRange(start: number, end: number, output: Array<Frame>): Array<Frame>;
-            getFrames(frames: Array<number>, useNumericIndex?: boolean, output?: Array<Frame>): Array<Frame>;
-            getFrameIndexes(frames: Array<number>, useNumericIndex?: boolean, output?: Array<number>): Array<number>;
-            total: number;
-      }
-
-      class AnimationParser {
-            spriteSheet(game: Phaser.Game, key: string, frameWidth: number, frameHeight: number, frameMax?: number): Phaser.FrameData;
-            JSONData(game: Phaser.Game, json: Object, cacheKey: string): Phaser.FrameData;
-            JSONDataHash(game: Phaser.Game, json: Object, cacheKey: string): Phaser.FrameData;
-            XMLData(game: Phaser.Game, xml: Object, cacheKey: string): Phaser.FrameData;
-      }
-
-      class Cache {
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            onSoundUnlock: Phaser.Signal;
-            addCanvas(key: string, canvas: HTMLCanvasElement, context: CanvasRenderingContext2D): void;
-            addRenderTexture(key: string, texture: RenderTexture): void;
-            addSpriteSheet(key: string, url: string, data: Object, frameWidth: number, frameHeight: number, frameMax: number): void;
-            addTilemap(key: string, url: string, data: Object, mapData: Object, atlasData: Object): void;
-            addTextureAtlas(key: string, url: string, data: Object, atlasData: Object): void;
-            addBitmapFont(key: string, url: string, data: Object, xmlData: Object): void;
-            addDefaultImage(): void;
-            addImage(key: string, url: string, data: Object): void;
-            addSound(key: string, url: string, data: Object): void;
-            reloadSound(key: string): void;
-            reloadSoundComplete(key: string): void;
-            updateSound(key: string, property: string, value: Phaser.Sound): void;
-            decodedSound(key: string, data: Object): void;
-            addText(key: string, url: string, data: Object): void;
-            getCanvas(key: string): Object;
-            checkImageKey(key: string): boolean;
-            getImage(key: string): Object;
-            getTilemap(key: string): Phaser.Tilemap;
-            getFrameData(key: string): Phaser.FrameData;
-            getFrameByIndex(key: string, frame: string): Phaser.Frame;
-            getFrameByName(key: string, frame: string): Phaser.Frame;
-            getFrame(key: string): Phaser.Frame;
-            getTextureFrame(key: string): Phaser.Frame;
-            getTexture(key: string): Phaser.RenderTexture;
-            getSound(key: string): Phaser.Sound;
-            getSoundData(key: string): Object;
-            isSoundDecoded(key: string): boolean;
-            isSoundReady(key: string): boolean;
-            isSpriteSheet(key: string): boolean;
-            getText(key: string): Object;
-            getKeys(array: Array<string>): Array<string>;
-            getImageKeys(): string[];
-            getSoundKeys(): string[];
-            getTextKeys(): string[];
-            removeCanvas(key: string): void;
-            removeImage(key: string): void;
-            removeSound(key: string): void;
-            removeText(key: string): void;
-            destroy(): void;
-      }
-
-      class Loader {
-            static TEXTURE_ATLAS_JSON_ARRAY: number;
-            static TEXTURE_ATLAS_JSON_HASH: number;
-            static TEXTURE_ATLAS_XML_STARLING: number;
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            queueSize: number;
-            isLoading: boolean;
-            hasLoaded: boolean;
-            progress: number;
-            preloadSprite: Phaser.Sprite;
-            crossOrigin: string;
-            baseURL: string;
-            onFileComplete: Phaser.Signal;
-            onFileError: Phaser.Signal; 
-            onLoadStart: Phaser.Signal;
-            onLoadComplete: Phaser.Signal;
-            setPreloadSprite(sprite: Phaser.Sprite, direction?: number): void;
-            checkKeyExists(key: string): boolean;
-            reset(): void;
-            addToFileList(type: string, key: string, url: string, properties: Array<any>): void;
-            image(key: string, url: string, overwrite?: boolean): void;
-            text(key: string, url: string, overwrite?: boolean): void;
-            spritesheet(key: string, url: string, frameWidth: number, frameHeight: number, frameMax: number): void;
-            audio(key: string, urls: any, autoDecode?: boolean): void;
-            tilemap(key: string, tilesetURL: string, mapDataURL?: string, mapData?: Object, format?: string): void;
-            tileset(key: string, url: string, tileWidth: number, tileHeight: number, tileMargin?: number, tileSpacing?: number, rows?: number, columns?: number, limit?: number): void;
-            bitmapFont(key: string, textureURL: string, xmlURL?: string, xmlData?: Object): void;
-            atlasJSONArray(key: string, textureURL: string, atlasURL: string, atlasData: Object): void;
-            atlasJSONHash(key: string, textureURL: string, atlasURL: string, atlasData: Object): void;
-            atlasXML(key: string, textureURL: string, atlasURL: string, atlasData: Object): void;
-            atlas(key: string, textureURL: string, atlasURL?: string, atlasData?: Object, format?: number): void;
-            removeFile(key: string): void;
-            removeAll(): void;
-            start(): void;
-            loadFile(): void;
-            getAudioURL(urls: string[]): string;
-            fileError(key: string): void;
-            fileComplete(key: string): void;
-            jsonLoadComplete(key: string): void;
-            csvLoadComplete(key: string): void;
-            dataLoadError(key: string): void;
-            xmlLoadComplete(key: string): void;
-            nextFile(previousKey: string, success: boolean): void;
-      }
-
-      class LoaderParser {
-            bitmapFont(game: Phaser.Game, xml: Object, cacheKey: Phaser.FrameData): void;
-      }
-
-      class Sound {
-            constructor(game: Phaser.Game, key: string, volume?: number, loop?: boolean);
-            game: Phaser.Game;
-            name: string;
-            key: string;
-            loop: boolean;
-            markers: Object;
-            context: any;
-            autoplay: boolean;
-            totalDuration: number;
-            startTime: number;
-            currentTime: number;
-            duration: number;
-            stopTime: number;
-            paused: boolean;
-            isPlaying: boolean;
-            currentMarker: string;
-            pendingPlayback: boolean;
-            override: boolean;
-            usingWebAudio: boolean;
-            usingAudioTag: boolean;
-            onDecoded: Phaser.Signal;
-            onPlay: Phaser.Signal;
-            onPause: Phaser.Signal;
-            onResume: Phaser.Signal;
-            onLoop: Phaser.Signal;
-            onStop: Phaser.Signal;
-            onMute: Phaser.Signal;
-            isDecoded: boolean;
-            isDecoding: boolean;
-            mute: boolean;
-            volume: number;
-            onMarkerComplete: Phaser.Signal;
-            soundHasUnlocked(key: string): void;
-            addMarker(name: string, start: number, stop: number, volume?: number, loop?: boolean): void;
-            removeMarker(name: string): void;
-            update(): void;
-            play(marker?: string, position?: number, volume?: number, loop?: boolean): Phaser.Sound;
-            restart(marker: string, position: number, volume?: number, loop?: boolean): void;
-            pause(): void;
-            resume(): void; 
+            font: string;
+            lineHeight: number;
+            renderShadow: boolean;
+            currentX: number;
+            currentY: number;
+            currentAlpha: number;
+            start(x?: number, y?: number, color?: string): void;
             stop(): void;
-      }
+            line(text: string, x: number, y: number): void;
+            renderQuadTree(quadtree: Phaser.QuadTree, color?: string): void;
+            renderSpriteCorners(sprite: Phaser.Sprite, showText?: boolean, showBounds?: boolean, color?: string): void;
+            renderSoundInfo(sound: Phaser.Sound, x: number, y: number, color?: string): void;
+            renderCameraInfo(camera: Phaser.Camera, x: number, y: number, color?: string): void;
+            renderPointer(pointer: Phaser.Pointer, hideIfUp?: boolean, downColor?: string, upColor?: string, color?: string): void;
+            renderSpriteInputInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
+            renderSpriteCollision(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
+            renderInputInfo(x: number, y: number, color?: string): void;
+            renderSpriteInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
+            renderWorldTransformInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
+            renderLocalTransformInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
+            renderPointInfo(point: Phaser.Point, x: number, y: number, color?: string): void;
+            renderSpriteBody(sprite: Phaser.Sprite, color?: string): void;
+            renderSpriteBounds(sprite: Phaser.Sprite, color?: string, fill?: boolean): void;
+            renderPixel(x: number, y: number, fillStyle?: string): void;
+            renderPoint(point: Phaser.Point, fillStyle?: string): void;
+            renderRectangle(rect: Phaser.Rectangle, fillStyle?: string): void;
+            renderCircle(circle: Phaser.Circle, fillStyle?: string): void;
+            renderText(text: string, x: number, y: number, color?: string, font?: string): void;
+        }
+    }
 
-      class SoundManager {
-            constructor(game: Phaser.Game);
+    class Color {
+        getColor32(alpha: number, red: number, green: number, blue: number): number;
+        getColor(red: number, green: number, blue: number): number;
+        hexToRGB(h: string): number;
+        getColorInfo(color: number): string;
+        RGBtoHexstring(color: number): string;
+        RGBtoWebstring(color: number): string;
+        colorToHexstring(color: number): string;
+        interpolateColor(color1: number, color2: number, steps: number, currentStep: number, alpha: number): number;
+        interpolateColorWithRGB(color: number, r: number, g: number, b: number, steps: number, currentStep: number): number;
+        interpolateRGB(r1: number, g1: number, b1: number, r2: number, g2: number, b2: number, steps: number, currentStep: number): number;
+        getRandomColor(min?: number, max?: number, alpha?: number): number;
+        getRGB(color: number): Object;
+        getWebRGB(color: number): string;
+        getAlpha(color: number): number;
+        getAlphaFloat(color: number): number;
+        getRed(color: number): number;
+        getGreen(color: number): number;
+        getBlue(color: number): number;
+    }
+
+    module Physics {
+        class Arcade {
+            constructor(game: Phaser.Game)
             game: Phaser.Game;
-            onSoundDecode: Phaser.Signal;
-            context: any;
-            usingWebAudio: boolean;
-            usingAudioTag: boolean;
-            noAudio: boolean;
-            touchLocked: boolean;
-            channels: number;
-            mute: boolean;
-            volume: number;
-            boot(): void;
-            unlock(): void;
-            stopAll(): void;
-            pauseAll(): void;
-            resumeAll(): void;
-            decode(key: string, sound?: Phaser.Sound): void;
-            update(): void;
-            add(key: string, volume: number, loop: boolean): Phaser.Sound;
-      }
+            gravity: Phaser.Point;
+            bounds: Phaser.Rectangle;
+            maxObjects: number;
+            maxLevels: number;
+            OVERLAP_BIAS: number;
+            TILE_OVERLAP: number;
+            quadTree: Phaser.QuadTree;
+            quadTreeID: number;
+            updateMotion(body: Phaser.Physics.Arcade.Body);
+            computeVelocity(axis: number, body: Phaser.Physics.Arcade.Body, velocity: number, acceleration: number, drag: number, max: number): void;
+            preUpdate(): void;
+            postUpdate(): void;
+            overlap(object1: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            overlapSpriteVsSprite(sprite1: Phaser.Sprite, sprite2: Phaser.Sprite,  overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            overlapSpriteVsGroup(sprite1: Phaser.Sprite, group: Phaser.Group,  overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            overlapGroupVsGroup(group: Phaser.Group, group2: Phaser.Group,  overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            collide(object1: any, object2: any, collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            collideSpriteVsSprite(sprite1: Phaser.Sprite, sprite2: Phaser.Sprite,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            collideSpriteVsTilemap(sprite1: Phaser.Sprite, tilemap: Phaser.Tilemap,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            collideSpriteVsGroup(sprite1: Phaser.Sprite, group: Phaser.Group,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            collideGroupVsTilemap(group: Phaser.Group, tilemap: Phaser.Tilemap,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            collideGroupVsGroup(group: Phaser.Group, group2: Phaser.Group,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+            separate(body: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body): void;
+            separateX(body: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body): void;
+            separateY(body: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body): void;
+            separateTile(object: Object, x: number, y: number, width: number, height: number, mass: number, collideLeft: boolean, collideRight: boolean, collideUp: boolean, collideDown: boolean, separateX: boolean, separateY: boolean): boolean;
+            separateTileX(object: Object, x: number, y: number, width: number, height: number, mass: number, collideLeft: boolean, collideRight: boolean, collideUp: boolean, collideDown: boolean, separateX: boolean, separateY: boolean): boolean;
+            separateTileY(object: Object, x: number, y: number, width: number, height: number, mass: number, collideLeft: boolean, collideRight: boolean, collideUp: boolean, collideDown: boolean, separateX: boolean, separateY: boolean): boolean;
+            velocityFromAngle(angle: number, speed?: number, point?: Phaser.Point): Phaser.Point;
+            moveToObject(source: Phaser.Sprite, dest: Phaser.Sprite, speed?: number, maxTime?: number): void;
+            accelerateTowardsObject(source: Phaser.Sprite, dest: Phaser.Sprite, speed?: number, xSpeedMax?: number, ySpeedMax?: number): void;
+            moveToMouse(source: Phaser.Sprite, speed?: number, maxTime?: number): void;
+            accelerateTowardsMouse(source: Phaser.Sprite, speed: number, xSpeedMax?: number, ySpeedMax?: number): void;
+            moveToPoint(source: Phaser.Sprite, target: Phaser.Point, speed?: number, maxTime?: number): void;
+            accelerateTowardsPoint(source: Phaser.Sprite, target: Phaser.Point, speed: number, xSpeedMax?: number, ySpeedMax?: number): void;
+            distanceBetween(a: Phaser.Sprite, b: Phaser.Sprite): number;
+            distanceToPoint(a: Phaser.Sprite, target: Phaser.Point): number;
+            distanceToMouse(a: Phaser.Sprite): number;
+            angleBetweenPoint(a: Phaser.Sprite, target: Phaser.Point, asDegrees?: boolean): number;
+            angleBetween(a: Phaser.Sprite, b: Phaser.Sprite, asDegrees?: boolean): number;
+            velocityFromFacing(parent: Phaser.Sprite, speed: number): Phaser.Point;
+            angleBetweenMouse(a: Phaser.Sprite, asDegress?: boolean): number;
+        }
 
-      module Utils {
-            class Debug {
-                  constructor(game: Phaser.Game);
-                  game: Phaser.Game;
-                  font: string;
-                  lineHeight: number;
-                  renderShadow: boolean;
-                  currentX: number;
-                  currentY: number;
-                  currentAlpha: number;
-                  start(x?: number, y?: number, color?: string): void;
-                  stop(): void;
-                  line(text: string, x: number, y: number): void;
-                  renderQuadTree(quadtree: Phaser.QuadTree, color?: string): void;
-                  renderSpriteCorners(sprite: Phaser.Sprite, showText?: boolean, showBounds?: boolean, color?: string): void;
-                  renderSoundInfo(sound: Phaser.Sound, x: number, y: number, color?: string): void;
-                  renderCameraInfo(camera: Phaser.Camera, x: number, y: number, color?: string): void;
-                  renderPointer(pointer: Phaser.Pointer, hideIfUp?: boolean, downColor?: string, upColor?: string, color?: string): void;
-                  renderSpriteInputInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
-                  renderSpriteCollision(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
-                  renderInputInfo(x: number, y: number, color?: string): void;
-                  renderSpriteInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
-                  renderWorldTransformInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
-                  renderLocalTransformInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
-                  renderPointInfo(point: Phaser.Point, x: number, y: number, color?: string): void;
-                  renderSpriteBody(sprite: Phaser.Sprite, color?: string): void;
-                  renderSpriteBounds(sprite: Phaser.Sprite, color?: string, fill?: boolean): void;
-                  renderPixel(x: number, y: number, fillStyle?: string): void;
-                  renderPoint(point: Phaser.Point, fillStyle?: string): void;
-                  renderRectangle(rect: Phaser.Rectangle, fillStyle?: string): void;
-                  renderCircle(circle: Phaser.Circle, fillStyle?: string): void;
-                  renderText(text: string, x: number, y: number, color?: string, font?: string): void;
-            }
-      }
-
-      class Color {
-            getColor32(alpha: number, red: number, green: number, blue: number): number;
-            getColor(red: number, green: number, blue: number): number;
-            hexToRGB(h: string): number;
-            getColorInfo(color: number): string;
-            RGBtoHexstring(color: number): string;
-            RGBtoWebstring(color: number): string;
-            colorToHexstring(color: number): string;
-            interpolateColor(color1: number, color2: number, steps: number, currentStep: number, alpha: number): number;
-            interpolateColorWithRGB(color: number, r: number, g: number, b: number, steps: number, currentStep: number): number;
-            interpolateRGB(r1: number, g1: number, b1: number, r2: number, g2: number, b2: number, steps: number, currentStep: number): number;
-            getRandomColor(min?: number, max?: number, alpha?: number): number;
-            getRGB(color: number): Object;
-            getWebRGB(color: number): string;
-            getAlpha(color: number): number;
-            getAlphaFloat(color: number): number;
-            getRed(color: number): number;
-            getGreen(color: number): number;
-            getBlue(color: number): number;
-      }
-
-      module Physics {
-            class Arcade {
-                  constructor(game: Phaser.Game)
-                  game: Phaser.Game;
-                  gravity: Phaser.Point;
-                  bounds: Phaser.Rectangle;
-                  maxObjects: number;
-                  maxLevels: number;
-                  OVERLAP_BIAS: number;
-                  TILE_OVERLAP: number;
-                  quadTree: Phaser.QuadTree;
-                  quadTreeID: number;
-                  updateMotion(body: Phaser.Physics.Arcade.Body);
-                  computeVelocity(axis: number, body: Phaser.Physics.Arcade.Body, velocity: number, acceleration: number, drag: number, max: number): void;
-                  preUpdate(): void;
-                  postUpdate(): void;
-                  overlap(object1: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
-                  overlapSpriteVsSprite(sprite1: Phaser.Sprite, sprite2: Phaser.Sprite,  overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
-                  overlapSpriteVsGroup(sprite1: Phaser.Sprite, group: Phaser.Group,  overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
-                  overlapGroupVsGroup(group: Phaser.Group, group2: Phaser.Group,  overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
-                  collide(object1: any, object2: any, collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
-                  collideSpriteVsSprite(sprite1: Phaser.Sprite, sprite2: Phaser.Sprite,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
-                  collideSpriteVsTilemap(sprite1: Phaser.Sprite, tilemap: Phaser.Tilemap,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
-                  collideSpriteVsGroup(sprite1: Phaser.Sprite, group: Phaser.Group,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
-                  collideGroupVsTilemap(group: Phaser.Group, tilemap: Phaser.Tilemap,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
-                  collideGroupVsGroup(group: Phaser.Group, group2: Phaser.Group,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
-                  separate(body: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body): void;
-                  separateX(body: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body): void;
-                  separateY(body: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body): void;
-                  separateTile(object: Object, x: number, y: number, width: number, height: number, mass: number, collideLeft: boolean, collideRight: boolean, collideUp: boolean, collideDown: boolean, separateX: boolean, separateY: boolean): boolean;
-                  separateTileX(object: Object, x: number, y: number, width: number, height: number, mass: number, collideLeft: boolean, collideRight: boolean, collideUp: boolean, collideDown: boolean, separateX: boolean, separateY: boolean): boolean;
-                  separateTileY(object: Object, x: number, y: number, width: number, height: number, mass: number, collideLeft: boolean, collideRight: boolean, collideUp: boolean, collideDown: boolean, separateX: boolean, separateY: boolean): boolean;
-                  velocityFromAngle(angle: number, speed?: number, point?: Phaser.Point): Phaser.Point;
-                  moveTowardsObject(source: Phaser.Sprite, dest: Phaser.Sprite, speed?: number, maxTime?: number): void;
-                  accelerateTowardsObject(source: Phaser.Sprite, dest: Phaser.Sprite, speed?: number, xSpeedMax?: number, ySpeedMax?: number): void;
-                  moveTowardsMouse(source: Phaser.Sprite, speed?: number, maxTime?: number): void; 
-                  accelerateTowardsMouse(source: Phaser.Sprite, speed: number, xSpeedMax?: number, ySpeedMax?: number): void;
-                  moveTowardsPoint(source: Phaser.Sprite, target: Phaser.Point, speed?: number, maxTime?: number): void;
-                  accelerateTowardsPoint(source: Phaser.Sprite, target: Phaser.Point, speed: number, xSpeedMax?: number, ySpeedMax?: number): void;
-                  distanceBetween(a: Phaser.Sprite, b: Phaser.Sprite): number;
-                  distanceToPoint(a: Phaser.Sprite, target: Phaser.Point): number;
-                  distanceToMouse(a: Phaser.Sprite): number;
-                  angleBetweenPoint(a: Phaser.Sprite, target: Phaser.Point, asDegrees?: boolean): number;
-                  angleBetween(a: Phaser.Sprite, b: Phaser.Sprite, asDegrees?: boolean): number;
-                  velocityFromFacing(parent: Phaser.Sprite, speed: number): Phaser.Point;
-                  angleBetweenMouse(a: Phaser.Sprite, asDegress?: boolean): number;
+        module Arcade {
+            class BorderChoices {
+                none: boolean;
+                any: boolean;
+                up: boolean;
+                down: boolean;
+                left: boolean;
+                right: boolean;
             }
 
-            module Arcade {
-                  class BorderChoices {
-                        none: boolean;
-                        any: boolean;
-                        up: boolean;
-                        down: boolean;
-                        left: boolean;
-                        right: boolean;
-                  }
-
-                  class Body {
-                        constructor(sprite: Phaser.Sprite);
-                        sprite: Phaser.Sprite;
-                        game: Phaser.Game;
-                        offset: Phaser.Point;
-                        x: number;
-                        y: number;
-                        lastX: number;
-                        lastY: number;
-                        sourceWidth: number;
-                        sourceHeight: number;
-                        width: number;
-                        height: number; 
-                        halfWidth: number;
-                        helfHeight: number;
-                        velocity: Phaser.Point;
-                        acceleration: Phaser.Point;
-                        drag: Phaser.Point;
-                        gravity: Phaser.Point;
-                        bounce: Phaser.Point;
-                        maxVelocity: Phaser.Point;
-                        angularVelocity: number;
-                        angularAcceleration: number;
-                        angularDrag: number;
-                        maxAngular: number;
-                        mass: number;
-                        quadTreeIDs: string[];
-                        quadTreeIndex: number;
-                        allowCollision: BorderChoices;
-                        touching: BorderChoices;
-                        wasTouching: BorderChoices;
-                        immovable: boolean;
-                        moves: boolean;
-                        rotation: number;
-                        allowRotation: boolean;
-                        allowGravity: boolean;
-                        customSeparateX: boolean;
-                        customSeparateY: boolean;
-                        overlapX: number;
-                        overlapY: number;
-                        collideWorldBounds: boolean;
-                        bottom: number;
-                        right: number;
-                        updateBounds(centerX: number, centerY: number, scaleX: number, scaleY: number): void;
-                        update(): void;
-                        postUpdate(): void;
-                        checkWorldBounds(): void;
-                        setSize(width: number, height: number, offsetX: number, offsetY: number): void;
-                        reset(): void;
-                        deltaAbsX(): number;
-                        deltaAbsY(): number;
-                        deltaX(): number;
-                        deltaY(): number;
-                  }
+            class Body {
+                constructor(sprite: Phaser.Sprite);
+                sprite: Phaser.Sprite;
+                game: Phaser.Game;
+                offset: Phaser.Point;
+                x: number;
+                y: number;
+                lastX: number;
+                lastY: number;
+                sourceWidth: number;
+                sourceHeight: number;
+                width: number;
+                height: number;
+                halfWidth: number;
+                helfHeight: number;
+                velocity: Phaser.Point;
+                acceleration: Phaser.Point;
+                drag: Phaser.Point;
+                gravity: Phaser.Point;
+                bounce: Phaser.Point;
+                maxVelocity: Phaser.Point;
+                angularVelocity: number;
+                angularAcceleration: number;
+                angularDrag: number;
+                maxAngular: number;
+                mass: number;
+                quadTreeIDs: string[];
+                quadTreeIndex: number;
+                allowCollision: BorderChoices;
+                touching: BorderChoices;
+                wasTouching: BorderChoices;
+                immovable: boolean;
+                moves: boolean;
+                rotation: number;
+                allowRotation: boolean;
+                allowGravity: boolean;
+                customSeparateX: boolean;
+                customSeparateY: boolean;
+                overlapX: number;
+                overlapY: number;
+                collideWorldBounds: boolean;
+                bottom: number;
+                right: number;
+                updateBounds(centerX: number, centerY: number, scaleX: number, scaleY: number): void;
+                update(): void;
+                postUpdate(): void;
+                checkWorldBounds(): void;
+                setSize(width: number, height: number, offsetX: number, offsetY: number): void;
+                reset(): void;
+                deltaAbsX(): number;
+                deltaAbsY(): number;
+                deltaX(): number;
+                deltaY(): number;
             }
-      }
+        }
+    }
 
-      class Particles {
-            constructor(game: Phaser.Game);
-            emitters: Object;
-            ID: number;
-            add(emitter: Phaser.Particles.Arcade.Emitter): Phaser.Particles.Arcade.Emitter;
-            remove(emitter: Phaser.Particles.Arcade.Emitter): void;
-            update(): void;
-      }
+    class Particles {
+        constructor(game: Phaser.Game);
+        emitters: Object;
+        ID: number;
+        add(emitter: Phaser.Particles.Arcade.Emitter): Phaser.Particles.Arcade.Emitter;
+        remove(emitter: Phaser.Particles.Arcade.Emitter): void;
+        update(): void;
+    }
 
-      module Particles {
-            module Arcade {
-                  class Emitter {
-                        constructor(game: Phaser.Game, x: number, y: number, maxParticles?: number);
-                        name: string;
-                        type: number;
-                        x: number;
-                        y: number;
-                        width: number;
-                        height: number;
-                        minParticleSpeed: Phaser.Point;
-                        maxParticleSpeed: Phaser.Point;
-                        minParticleScale: number;
-                        maxParticleScale: number;
-                        minRotation: number;
-                        maxRotation: number;
-                        gravity: number;
-                        particleClass: string;
-                        particleDrag: Phaser.Point;
-                        angularDrag: number;
-                        frequency: number;
-                        maxParticles: number;
-                        lifespan: number;
-                        bounce: Phaser.Point;
-                        on: boolean;
-                        exists: boolean;
-                        emitX: number;
-                        emitY: number;
-                        alpha: number;
-                        visible: boolean;
-                        left: number;
-                        top: number;
-                        bottom: number;
-                        right: number;
-                        update(): void;
-                        makeParticles(keys: string[], frames: string[], quantity: number, collide: boolean, collideWorldBounds: boolean): Phaser.Particles.Arcade.Emitter;
-                        kill(): void;
-                        revive(): void;
-                        start(explode: boolean, lifespan: number, frequency: number, quantity: number): void;
-                        emitParticle(): void;
-                        setSize(width: number, height: number): void;
-                        setXSpeed(min: number, max: number): void;
-                        setYSpeed(min: number, max: number): void;
-                        setRotation(min: number, max: number): void;
-                        at(object: Object): void;
+    module Particles {
+        module Arcade {
+            class Emitter extends Phaser.Group
+            {
+                constructor(game: Phaser.Game, x: number, y: number, maxParticles?: number);
+                name: string;
+                type: number;
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+                minParticleSpeed: Phaser.Point;
+                maxParticleSpeed: Phaser.Point;
+                minParticleScale: number;
+                maxParticleScale: number;
+                minRotation: number;
+                maxRotation: number;
+                gravity: number;
+                particleClass: string;
+                particleDrag: Phaser.Point;
+                angularDrag: number;
+                frequency: number;
+                maxParticles: number;
+                lifespan: number;
+                bounce: Phaser.Point;
+                on: boolean;
+                exists: boolean;
+                emitX: number;
+                emitY: number;
+                alpha: number;
+                visible: boolean;
+                left: number;
+                top: number;
+                bottom: number;
+                right: number;
+                update(): void;
+                makeParticles(keys: string[], frames: string[], quantity: number, collide: boolean, collideWorldBounds: boolean): Phaser.Particles.Arcade.Emitter;
+                kill(): void;
+                revive(): void;
+                start(explode: boolean, lifespan: number, frequency: number, quantity: number): void;
+                emitParticle(): void;
+                setSize(width: number, height: number): void;
+                setXSpeed(min: number, max: number): void;
+                setYSpeed(min: number, max: number): void;
+                setRotation(min: number, max: number): void;
+                at(object: Object): void;
 
-                  }
             }
-      }
+        }
+    }
 
-      class Tilemap {
-            constructor(game: Phaser.Game, key: string, x: number, y: number, resizeWorld?: boolean, tileWidth?: number, tileHeight?: number);
-            game: Phaser.Game;
-            group: Phaser.Group;
-            name: string;
-            key: string;
-            renderOrderID: number;
-            collisionCallback: Function;
-            exists: boolean;
-            visible: boolean;
-            tiles: Array<any>;
-            layers: Array<TilemapLayer>;
-            position: Phaser.Point;
-            type: number;
-            renderer: Phaser.TilemapRenderer;
-            mapFormat: string;
-            widthInPixels: number;
-            heightInPixels: number;
-            static CSV: number;
-            static JSON: number;
-            parseCSV(data: string, key: string, tileWidth: number, tileHeight: number): void;
-            parseTiledJSON(json: string, key: string): void;
-            generateTiles(quantity: number): void;
-            setCollisionCallback(context: Object, callback: Function): void;
-            setCollisionRange(start: number, end: number, collision: number, resetCollisions?: boolean, separateX?: boolean, separateY?: boolean): void;
-            setCollisionByIndex(value: number[], collision: number, resetCollisions?: boolean, separateX?: boolean, separateY?: boolean): void;
-            getTileByIndex(value: number): Tile;
-            getTile(x: number, y: number, layer?: number): Tile;
-            getTileFromWorldXY(x: number, y: number, layer?: number): Tile;
-            getTileFromInputXY(layer?: number): Tile;
-            getTileOverlaps(object: Object): Array<any>;
-            collide(objectOrGroup: any, callback: Function, context: Object): boolean;
-            collideGameObject(object: Object): boolean;
-            putTile(x: number, y: number, index: number, layer?: number): void;
-            update(): void;
-            destroy(): void;
-      }
+    class Tilemap {
+        constructor(game: Phaser.Game, key: string, x: number, y: number, resizeWorld?: boolean, tileWidth?: number, tileHeight?: number);
+        game: Phaser.Game;
+        group: Phaser.Group;
+        name: string;
+        key: string;
+        renderOrderID: number;
+        collisionCallback: Function;
+        exists: boolean;
+        visible: boolean;
+        tiles: Array<any>;
+        layers: Array<TilemapLayer>;
+        position: Phaser.Point;
+        type: number;
+        renderer: Phaser.TilemapRenderer;
+        mapFormat: string;
+        widthInPixels: number;
+        heightInPixels: number;
+        static CSV: number;
+        static JSON: number;
+        parseCSV(data: string, key: string, tileWidth: number, tileHeight: number): void;
+        parseTiledJSON(json: string, key: string): void;
+        generateTiles(quantity: number): void;
+        setCollisionCallback(context: Object, callback: Function): void;
+        setCollisionRange(start: number, end: number, collision: number, resetCollisions?: boolean, separateX?: boolean, separateY?: boolean): void;
+        setCollisionByIndex(value: number[], collision: number, resetCollisions?: boolean, separateX?: boolean, separateY?: boolean): void;
+        getTileByIndex(value: number): Tile;
+        getTile(x: number, y: number, layer?: number): Tile;
+        getTileFromWorldXY(x: number, y: number, layer?: number): Tile;
+        getTileFromInputXY(layer?: number): Tile;
+        getTileOverlaps(object: Object): Array<any>;
+        collide(objectOrGroup: any, callback: Function, context: Object): boolean;
+        collideGameObject(object: Object): boolean;
+        putTile(x: number, y: number, index: number, layer?: number): void;
+        update(): void;
+        destroy(): void;
+    }
 
-      class TilemapLayer {
-            constructor(parent: Tilemap, id: number, key: string, mapFormat: number, name: string, tileWidth: number, tileHeight: number);
-            exists: boolean;
-            visible: boolean;
-            widthInTiles: number;
-            heightInTiles: number;
-            widthInPixels: number;
-            heightInPixels: number;
-            tileMargin: number;
-            tileSpacing: number;
-            parent: Tilemap;
-            game: Phaser.Game;
-            ID: number;
-            name: string;
-            key: string;
-            type: number;
-            mapFormat: number;
-            tileWidth: number;
-            tileHeight: number;
-            boundsInTiles: Phaser.Rectangle;
-            tileset: Object;
-            canvas: any;
-            context: any;
-            baseTexture: any;
-            texture: any;
-            sprite: Phaser.Sprite;
-            mapData: Array<any>;
-            alpha: number;
-            putTileWorldXY(x: number, y: number, index: number): void;
-            putTile(x: number, y: number, index: number): void;
-            swapTile(tileA: number, tileB: number, x?: number, y?: number, width?: number, height?: number): void;
-            fillTile(index: number, x?: number, y?: number, width?: number, height?: number): void;
-            randomiseTiles(tiles: number[], x?: number, y?: number, width?: number, height?: number): void;
-            replaceTile(tileA: number, tileB: number, x?: number, y?: number, width?: number, height?: number): void;
-            getTileBlock(x: number, y: number, width: number, height: number): Array<Tile>;
-            getTileFromWorldXY(x: number, y: number): Tile;
-            getTileOverlaps(object: Object): Array<Tile>;
-            getTempBlock(x: number, y: number, width: number, height: number, collisionOnly?: boolean): void;
-            getTileIndex(x: number, y: number): number;
-            addColumn(column: string[]): void;
-            createCanvas(): void;
-            updateBounds(): void;
-            parseTileOffsets(): number;
-      }
+    class TilemapLayer {
+        constructor(parent: Tilemap, id: number, key: string, mapFormat: number, name: string, tileWidth: number, tileHeight: number);
+        exists: boolean;
+        visible: boolean;
+        widthInTiles: number;
+        heightInTiles: number;
+        widthInPixels: number;
+        heightInPixels: number;
+        tileMargin: number;
+        tileSpacing: number;
+        parent: Tilemap;
+        game: Phaser.Game;
+        ID: number;
+        name: string;
+        key: string;
+        type: number;
+        mapFormat: number;
+        tileWidth: number;
+        tileHeight: number;
+        boundsInTiles: Phaser.Rectangle;
+        tileset: Object;
+        canvas: any;
+        context: any;
+        baseTexture: any;
+        texture: any;
+        sprite: Phaser.Sprite;
+        mapData: Array<any>;
+        alpha: number;
+        putTileWorldXY(x: number, y: number, index: number): void;
+        putTile(x: number, y: number, index: number): void;
+        swapTile(tileA: number, tileB: number, x?: number, y?: number, width?: number, height?: number): void;
+        fillTile(index: number, x?: number, y?: number, width?: number, height?: number): void;
+        randomiseTiles(tiles: number[], x?: number, y?: number, width?: number, height?: number): void;
+        replaceTile(tileA: number, tileB: number, x?: number, y?: number, width?: number, height?: number): void;
+        getTileBlock(x: number, y: number, width: number, height: number): Array<Tile>;
+        getTileFromWorldXY(x: number, y: number): Tile;
+        getTileOverlaps(object: Object): Array<Tile>;
+        getTempBlock(x: number, y: number, width: number, height: number, collisionOnly?: boolean): void;
+        getTileIndex(x: number, y: number): number;
+        addColumn(column: string[]): void;
+        createCanvas(): void;
+        updateBounds(): void;
+        parseTileOffsets(): number;
+    }
 
-      class Tile {
-            constructor(game: Phaser.Game, tilemap: Tilemap, index: number, width: number, height: number);
-            mass: number;
-            collideNone: boolean;
-            collideLeft: boolean;
-            collideRight: boolean;
-            collideUp: boolean;
-            collideDown: boolean;
-            separateX: boolean;
-            separateY: boolean;
-            game: Phaser.Game;
-            tilemap: Tilemap;
-            index: number;
-            width: number;
-            height: number;
-            destroy(): void;
-            setCollision(left: boolean, right: boolean, up: boolean, down: boolean, reset: boolean, seperateX: boolean, seperateY: boolean): void;
-            resetCollsion(): void;
-            toString(): string;
-      }
+    class Tile {
+        constructor(game: Phaser.Game, tilemap: Tilemap, index: number, width: number, height: number);
+        mass: number;
+        collideNone: boolean;
+        collideLeft: boolean;
+        collideRight: boolean;
+        collideUp: boolean;
+        collideDown: boolean;
+        separateX: boolean;
+        separateY: boolean;
+        game: Phaser.Game;
+        tilemap: Tilemap;
+        index: number;
+        width: number;
+        height: number;
+        destroy(): void;
+        setCollision(left: boolean, right: boolean, up: boolean, down: boolean, reset: boolean, seperateX: boolean, seperateY: boolean): void;
+        resetCollsion(): void;
+        toString(): string;
+    }
 
-      class TilemapRenderer {
-            constructor(game: Phaser.Game);
-            game: Phaser.Game;
-            render(tilemap: Tilemap): void;
-      }
+    class TilemapRenderer {
+        constructor(game: Phaser.Game);
+        game: Phaser.Game;
+        render(tilemap: Tilemap): void;
+    }
 }
\ No newline at end of file