declare class SAT { flattenPointsOn(points: Array, normal: SAT.Vector, result: Array): Array; isSeparatingAxis(aPos: SAT.Vector, bPos: SAT.Vector, aPoints: Array, bPoints: Array, axis: SAT.Vector, response: SAT.Response): boolean; vornoiRegion(line: SAT.Vector, point: SAT.Vector): number; testCircleCircle(a: SAT.Circle, b: SAT.Circle, response: SAT.Response): boolean; testPolygonCircle(a: SAT.Polygon, b: SAT.Circle, response: SAT.Response): boolean; testCirclePolygon(a: SAT.Circle, b: SAT.Polygon, response: SAT.Response): boolean; testPolygonPolygon(a: SAT.Polygon, b: SAT.Polygon, response: SAT.Response): boolean; } declare module SAT { class Vector { constructor(x: number, y: number); x: number; y: number; copy(other: SAT.Vector): SAT.Vector; perp(): SAT.Vector; rotate(angle: number): SAT.Vector; rotatePrecalc(sin: number, cos: number): SAT.Vector; reverse(): SAT.Vector; normalize(): SAT.Vector; add(other: SAT.Vector): SAT.Vector; sub(other: SAT.Vector): SAT.Vector; scale(x: number, y: number): SAT.Vector; project(other: SAT.Vector): SAT.Vector; projectN(other: SAT.Vector): SAT.Vector; reflect(axis: SAT.Vector): SAT.Vector; reflectN(axis: SAT.Vector): SAT.Vector; dot(other: SAT.Vector): SAT.Vector; len2(): SAT.Vector; len(): SAT.Vector; } class Circle { constructor(pos: SAT.Vector, radius: number); pos: SAT.Vector; r: number; } class Polygon { constructor(pos: SAT.Vector, points: Array); pos: SAT.Vector; points: Array; recalc(): SAT.Polygon; rotate(angle: number): SAT.Polygon; scale(x: number, y: number): SAT.Polygon; translate(x: number, y: number): SAT.Polygon; } class Box { constructor(pos: SAT.Vector, w: number, h: number); pos: SAT.Vector; w: number; h: number; toPolygon(): SAT.Polygon; } class Response { constructor(); a: any; b: any; overlapN: SAT.Vector; overlapV: SAT.Vector; clear(): SAT.Response; aInB: boolean; bInA: boolean; overlap: number; } } declare class Phaser { static VERSION: string; static DEV_VERSION: string; static GAMES: Array; 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 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: { [key: string]: Phaser.State }; current: string; 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; getCurrentState(): Phaser.State; loadComplete(): void; update(): void; preRender(): void; render(): void; destroy(): void; } 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 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; execute(paramsArr?: Array): 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 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 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; } // Wraps a PIXI.DisplayObjectContainer 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 extends Phaser.Group { 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 { /* * Defaults: * [width=800] - The width of your game in game pixels. * [height=600] - The height of your game in game pixels. * [renderer=Phaser.AUTO] - Which renderer to use: Phaser.AUTO will auto-detect, Phaser.WEBGL, Phaser.CANVAS or Phaser.HEADLESS (no rendering at all). * [parent=''] - The Games DOM parent. * [state=null] - Description. * [transparent=false] - Use a transparent canvas background or not. * [antialias=true] - Anti-alias graphics. * */ 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 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; } 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; addKey(keycode: number): Phaser.Key; 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: 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 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 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 GameObjectFactory { constructor(game: Phaser.Game); game: Phaser.Game; world: Phaser.World; existing(object: any): any; 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); game: Phaser.Game; exists: boolean; alive: boolean; group: Phaser.Group; name: string; type: number; renderOrderID: number; lifespan: number; events: Phaser.Events; animations: Phaser.AnimationManager; input: Phaser.InputHandler; key: string; currentFrame: number; anchor: Phaser.Point; x: number; y: number; cameraOffset:Phaser.Point; position: Phaser.Point; autoCull: boolean; scale: Phaser.Point; scrollFactor: Phaser.Point; offset: Phaser.Point; center: Phaser.Point; topLeft: Phaser.Point; topRight: Phaser.Point; bottomRight: Phaser.Point; bottomLeft: Phaser.Point; bounds: Phaser.Rectangle; body: Phaser.Physics.Arcade.Body; inWorld: boolean; inWorldThreshold: number; angle: number; frame: number; frameName: string; inCamera: boolean; crop: Phaser.Rectangle; cropEnabled: boolean; inputEnabled: boolean; fixedToCamera:boolean; preUpdate(): void; postUpdate(): void; centerOn(x: number, y: number): void; revive(): void; kill(): void; reset(x: number, y: number): void; updateBounds(): void; getLocalPosition(p: Phaser.Point, x: number, y: number): Phaser.Point; getLocalUnmodifiedPosition(p: Phaser.Point, x: number, y: number): Phaser.Point; bringToTop(): void; getBounds(rect: Phaser.Rectangle): Phaser.Rectangle; alpha: number; visible: boolean; renderable: boolean; width: number; height: number; health: number; damage(amount: number): Phaser.Sprite; } 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 Text { constructor(game: Phaser.Game, x: number, y: number, text: string, style: any); exists: boolean; alive: boolean; group: Phaser.Group; content: string; name: string; game: Phaser.Game; type: number; text: string; angle: number; style: any; visible: boolean; position: Phaser.Point; anchor: Phaser.Point; scale: Phaser.Point; scrollFactor: Phaser.Point; renderable: boolean; update(): void; } class BitmapText extends Phaser.Text { constructor(game: Phaser.Game, x?: number, y?: number, text?: string, style?: Object); alive: boolean; anchor: Phaser.Point; angle: number; exist: boolean; game: Phaser.Game; group: Phaser.Group; name: string; renderable: boolean; scale: Phaser.Point; type: number; // readonly x: number; y: number; update(): 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; } // Actually extends PIXI.Graphics but we skip the abstraction here, since pixi is "part" of phaser // PIXI.Graphics extends PIXI.DisplayObjectContainer extends DisplayObject class Graphics extends Phaser.Sprite { constructor(game: Phaser.Game, x: number, y: number); angle: number; x:number; y:number; // Pixi drawing lineStyle(lineWidth:number, color?:number, alpha?:number): void; moveTo(x:number, y:number): void; lineTo(x:number, y:number): void; beginFill(color:number, alpha?:number): void; endFill(): void; drawRect( x:number, y:number, width:number, height:number ): void; drawCircle( x:number, y:number, radius:number): void; drawElipse( x:number, y:number, width:number, height:number): void; clear(): void; updateFilterBounds(): void; } 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 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; pageAlignVertically: 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 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); c: number; s0: number; s1: number; s2: number; rnd(): number; sow(seeds: Array): 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; static shuffleArray(array: Array): Array; 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(x: number, y: number, width: number, height: number, maxObject?: number, maxLevels?: number, level?: 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; nodes: Array; populate(group:Phaser.Group): void; populateHandler(sprite:Phaser.Sprite): void; split(): void; insert(body: Object): void; getIndex(rect: Object): number; retrieve(sprite: Object): Array; clear(): void; } class Line { constructor(x1?: number, y1?: number, x2?: number, y2?: number); start: Phaser.Point; end: Phaser.Point; setTo(x1?: number, y1?: number, x2?: number, y2?: number): Phaser.Line; fromSprite(startSprite: Phaser.Sprite, endSprite: Phaser.Sprite, useCenter: boolean): Phaser.Line; intersects(line: Phaser.Line, asSegment?: boolean, result?: Phaser.Point): Phaser.Point; pointOnLine(x: number, y: number): boolean; pointOnSegment(x: number, y: number): boolean; length: number; angle: number; slope: number; perpSlope: number; static intersectsPoints(a: Phaser.Point, b: Phaser.Point, e: Phaser.Point, f: Phaser.Point, asSegment?: boolean, result?: Phaser.Point): Phaser.Point; static intersects(a: Phaser.Line, b: Phaser.Line, asSegment?: boolean, result?: Phaser.Point): Phaser.Point; } 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); 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; 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 { class Linear { static None(k: number): number; } class Quadratic { static In(k: number): number; static Out(k: number): number; static InOut(k: number): number; } class Cubic { static In(k: number): number; static Out(k: number): number; static InOut(k: number): number; } class Quartic { static In(k: number): number; static Out(k: number): number; static InOut(k: number): number; } class Quintic { static In(k: number): number; static Out(k: number): number; static InOut(k: number): number; } class Sinusoidal { static In(k: number): number; static Out(k: number): number; static InOut(k: number): number; } class Exponential { static In(k: number): number; static Out(k: number): number; static InOut(k: number): number; } class Circular { static In(k: number): number; static Out(k: number): number; static InOut(k: number): number; } class Elastic { static In(k: number): number; static Out(k: number): number; static InOut(k: number): number; } class Back { static In(k: number): number; static Out(k: number): number; static InOut(k: number): number; } class Bounce { static In(k: number): number; static Out(k: number): number; static InOut(k: number): number; } } 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; events: Phaser.Timer; create(autoDestroy: boolean): Phaser.Timer; removeAll(): void; update(time: number): void; gamePaused(): void; gameResumed(): void; totalElapsedSeconds(): number; elapsedSince(since: number): number; elapsedSecondsSince(since: number): number; reset(): void; } class Timer { constructor(game: Phaser.Game, autoDestroy: boolean); game: Phaser.Game; running: boolean; autoDestroy: boolean; expired: boolean; events: Phaser.TimerEvent[]; onComplete: Phaser.Signal; nextTick: number; paused: boolean; static MINUTE: number; static SECOND: number; static HALF: number; static QUARTER: number; add(delay: number, callback: any, callbackContext: any, ...args: any[]): Phaser.TimerEvent; repeat(delay: number, repeatCount: number, callback: any, callbackContext: any, ...args: any[]): Phaser.TimerEvent; loop(delay: number, callback: any, callbackContext: any, ...args: any[]): Phaser.TimerEvent; start(): void; stop(): void; remove(event: Phaser.TimerEvent): boolean; order():void; sortHandler():number; update(time: number): boolean; pause(): void; resume(): void; destroy(): void; next: number; duration: number; length: number; ms: number; seconds: number; } class TimerEvent { constructor(timer: Phaser.Timer, delay: number, tick: number, repeatCount: number, loop: boolean, callback: any, callbackContext, any, args:any[]); timer: Phaser.Timer; delay: number; tick: number; repeatCount: number; loop: boolean; callback: any; callbackContext: any; args: any[]; } 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, frameRate?: number, loop?: boolean, useNumericIndex?: boolean): Phaser.Animation; getAnimation(name: string): Phaser.Animation; validateFrames(frames: Array, 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): Array; getFrames(frames: Array, useNumericIndex?: boolean, output?: Array): Array; getFrameIndexes(frames: Array, useNumericIndex?: boolean, output?: Array): Array; 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): Array; 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(type: string, key: string): boolean; reset(): void; addToFileList(type: string, key: string, url: string, properties: Array): 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; 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; worldLeft: SAT.Box; worldRight: SAT.Box; worldTop: SAT.Box; worldBottom: SAT.Box; worldPolys: any; quadTree: Phaser.QuadTree; maxObjects: number; maxLevels: number; RECT: number; CIRCLE: number; POLYGON: number; checkBounds(body: Phaser.Physics.Arcade.Body): boolean; setBoundsToWorld(left: boolean, right: boolean, top: boolean, bottom: boolean): void; setBounds(x: number, y: number, width: number, height: number, left: boolean, right: boolean, top: boolean, bottom: boolean): void; updateMotion(body: Phaser.Physics.Arcade.Body): Phaser.Point; overlap(object1: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean; collide(object1: any, object2: any, collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean; collideHandler(object1: any, object2: any, collideCallback: Function, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean; collideSpriteVsSprite(sprite1: Phaser.Sprite, sprite2: Phaser.Sprite, collideCallback: Function, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean; collideSpriteVsGroup(sprite1: Phaser.Sprite, group: Phaser.Group, collideCallback: Function, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean; collideGroupVsSelf(group: Phaser.Group, collideCallback: Function, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean; collideGroupVsGroup(group: Phaser.Group, group2: Phaser.Group, collideCallback: Function, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean; collideSpriteVsTilemapLayer(sprite: Phaser.Sprite, tilemapLayer: Phaser.TilemapLayer, collideCallback: Function, processCallback: Function, callbackContext: any): boolean; collideGroupVsTilemapLayer(group: Phaser.Group, tilemapLayer: Phaser.TilemapLayer, collideCallback: Function, processCallback: Function, callbackContext: any): boolean; separate(body: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body, processCallback: Function, callbackContext: any, overlapOnly: boolean): boolean; intersects(a: Phaser.Physics.Arcade.Body, b: Phaser.Physics.Arcade.Body): boolean; tileIntersects(body: Phaser.Physics.Arcade.Body, tile: Phaser.Tile): boolean; separateTiles(body: Phaser.Physics.Arcade.Body, tile: Array): boolean; separateTile(body: Phaser.Physics.Arcade.Body, tile: Phaser.Tile): boolean; processTileSeparation(body: Phaser.Physics.Arcade.Body): boolean; moveToObject(displayObject: Phaser.Sprite, destination: Phaser.Sprite, speed?: number, maxTime?: number): number; moveToPointer(displayObject: Phaser.Sprite, speed?: number, pointer?: Phaser.Pointer, maxTime?: number): number; moveToXY(displayObject: Phaser.Sprite, x: number, y: number, speed?: number, maxTime?: number): number; velocityFromAngle(angle: number, speed?: number, point?: Phaser.Point): Phaser.Point; velocityFromRotation(rotation: number, speed?: number, point?: Phaser.Point): Phaser.Point; accelerationFromRotation(rotation: number, speed?: number, point?: Phaser.Point): Phaser.Point; accelerateToObject(displayObject: Phaser.Sprite, destination: Phaser.Sprite, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number; accelerateToPointer(displayObject: Phaser.Sprite, pointer: Phaser.Pointer, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number; accelerateToXY(displayObject: Phaser.Sprite, x: number, y: number, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number; distanceTo(source: Phaser.Sprite, target: Phaser.Sprite): number; distanceToXY(displayObject: Phaser.Sprite, x: number, y: number): number; distanceToPointer(displayObject: Phaser.Sprite, pointer: Phaser.Pointer): number; angleBetween(source: Phaser.Sprite, target: Phaser.Sprite): number; angleToXY(displayObject: Phaser.Sprite, x: number, y: number): number; angleToPointer(displayObject: Phaser.Sprite, pointer: Phaser.Pointer): number; } module Arcade { class FaceChoices { none: boolean; any: boolean; up: boolean; down: boolean; left: boolean; right: boolean; x: number; y: number; } class Body { constructor(sprite: Phaser.Sprite); sprite: Phaser.Sprite; game: Phaser.Game; offset: Phaser.Point; preX: number; preY: number; preRotation: number; velocity: Phaser.Point; acceleration: Phaser.Point; speed: number; angle: number; gravity: Phaser.Point; bounce: Phaser.Point; minVelocity: Phaser.Point; maxVelocity: Phaser.Point; angularVelocity: number; angularAcceleration: number; angularDrag: number; maxAngular: number; mass: number; linearDamping: number; checkCollision: FaceChoices; touching: FaceChoices; blocked: FaceChoices; facing: number; rebound: boolean; immovable: boolean; moves: boolean; rotation: number; allowRotation: boolean; allowGravity: boolean; customSeparateCallback: any; customSeparateContext: any; collideCallback: any; collideCallbackContext: any; collideWorldBounds: boolean; type: number; shape: any; polygon: any; left: number; right: number; top: number; bottom: number; width: number; height: number; contacts: any; overlapX: number; overlapY: number; updateScale(): void; preUpdate(): void; checkBlocked(): void; updateBounds(): void; applyDamping(): void; reboundCheck(x: number, y: number, rebound: boolean): void; getUpwardForce(): number; getDownwardForce(): number; sub(x: number): void; add(x: number): void; give(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void; take(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void; split(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void; exchange(body: Phaser.Physics.Arcade.Body): void; processRebound(body: Phaser.Physics.Arcade.Body): void; overlap(body: Phaser.Physics.Arcade.Body, response: SAT.Response): boolean; inContact(body: Phaser.Physics.Arcade.Body): boolean; addContact(body: Phaser.Physics.Arcade.Body): boolean; removeContact(body: Phaser.Physics.Arcade.Body): boolean; separate(body: Phaser.Physics.Arcade.Body, response: SAT.Response): boolean; hitLeft(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void; hitRight(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void; hitTop(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void; hitBottom(body: Phaser.Physics.Arcade.Body, response: SAT.Response): void; integrateVelocity():void; postUpdate(): void; reset(full: boolean): void; destroy(): void; setCircle(radius: number, offsetX: number, offsetY: number): void; setRectangle(width: number, height: number, translateX: number, translateY: number): void; setPoints(points: any): void; translate(x: number, y: number): void; onFloor(): boolean; onWall(): boolean; deltaX(): number; deltaY(): number; deltaZ(): number; x: number; y: 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; } 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; layers: Array; 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; 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(game:Phaser.Game, tilemap:Phaser.Tilemap, index:number, width:number, height:number); //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; 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; getTileFromWorldXY(x: number, y: number): Tile; getTileOverlaps(object: Object): Array; 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 TilemapRenderer { constructor(game: Phaser.Game); game: Phaser.Game; render(tilemap: Tilemap): void; } }