Mirrors/phaser
2
0
Fork 0
mirror of https://github.com/photonstorm/phaser synced 2024-11-26 22:52:14 +00:00
Code Issues Projects Releases Packages Wiki Activity
phaser/build/phaser.d.ts

5184 lines
174 KiB
TypeScript
Raw Blame History

// Type definitions for PIXI 1.5.4
// Project: https://github.com/GoodBoyDigital/pixi.js/
// Original 1.3 by: xperiments <http://github.com/xperiments>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module PIXI {
/* CONSTANTS */
export var WEBGL_RENDERER: number;
export var CANVAS_RENDERER: number;
export var VERSION: string;
export enum blendModes {
NORMAL,
ADD,
MULTIPLY,
SCREEN,
OVERLAY,
DARKEN,
LIGHTEN,
COLOR_DODGE,
COLOR_BURN,
HARD_LIGHT,
SOFT_LIGHT,
DIFFERENCE,
EXCLUSION,
HUE,
SATURATION,
COLOR,
LUMINOSITY
}
export class scaleModes {
public static DEFAULT: number;
public static LINEAR: number;
public static NEAREST: number;
}
export var INTERACTION_FREQUENCY: number;
export var AUTO_PREVENT_DEFAULT: boolean;
export var RAD_TO_DEG: number;
export var DEG_TO_RAD: number;
/* MODULE FUNCTIONS */
export function autoDetectRenderer(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean, antialias?: boolean): IPixiRenderer;
export function AjaxRequest(): XMLHttpRequest;
export function canUseNewCanvasBlendModes(): boolean;
export function getNextPowerOfTwo(): number;
export function rgb2hex(rgb: any): number;
export function hex2rgb(hex: number): any;
export function sayHello(): void;
/*INTERFACES*/
export interface IBasicCallback {
(): void
}
export interface IEventCallback {
(e?: IEvent): void
}
export interface IEvent {
type: string;
content: any;
}
export interface IHitArea {
contains(x: number, y: number): boolean;
}
export interface IInteractionDataCallback {
(interactionData: InteractionData): void
}
export interface IAbstractFilter {
}
export interface IPixiRenderer {
type: number;
transparent: boolean;
width: number;
height: number;
view: HTMLCanvasElement;
render(stage: Stage): void;
resize(width: number, height: number): void;
}
export interface IBitmapTextStyle {
font?: string;
align?: string;
tint?: string;
}
export interface ITextStyle {
font?: string;
stroke?: string;
fill?: string;
align?: string;
strokeThickness?: number;
wordWrap?: boolean;
wordWrapWidth?: number;
}
export interface IUniform {
type: string;
value: any;
}
export interface ILoader {
constructor(url: string, crossorigin: any);
load();
}
export interface ITintMethod {
(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
}
export interface IMaskData {
alpha: number;
worldTransform: number[];
}
export interface IRenderSession // unclear; Taken from DisplayObjectContainer:152
{
context: CanvasRenderingContext2D;
maskManager: CanvasMaskManager;
scaleMode: scaleModes;
smoothProperty: string;
}
export interface IShaderAttribute {
// TODO: Find signature of shader attributes
}
export interface IFilterBlock {
// TODO: Find signature of filterBlock
}
export interface IMatrix {
// TODO: Find signature of Matrix
}
/* CLASSES */
export class AbstractFilter implements IAbstractFilter {
passes: AbstractFilter[];
shaders: PixiShader[];
dirty: boolean;
padding: number;
uniforms: { [name: string]: IUniform };
fragmentSrc: any[];
}
export class AlphaMaskFilter extends AbstractFilter {
map: Texture;
constructor(texture: Texture);
onTextureLoaded(): void;
}
export class AssetLoader extends EventTarget {
assetURLs: string[];
crossorigin: any;
loadersByType: { [key: string]: ILoader };
constructor(assetURLs: string[], crossorigin: any);
load(): void;
}
export class AtlasLoader extends EventTarget {
url: string;
baseUrl: string;
crossorigin: any;
loaded: boolean;
constructor(url: string, crossorigin: any);
load(): void;
}
export class BaseTexture extends EventTarget {
id: number;
hasLoaded: boolean;
height: number;
premultipliedAlpha: boolean;
source: HTMLImageElement;
scaleMode: scaleModes;
width: number;
constructor(source: HTMLImageElement, scaleMode: scaleModes);
constructor(source: HTMLCanvasElement, scaleMode: scaleModes);
destroy(): void;
updateSourceImage(newSrc: string): void;
static fromImage(imageUrl: string, crossorigin: any, scaleMode: scaleModes): BaseTexture;
static fromCanvas(canvas: HTMLCanvasElement, scaleMode: scaleModes): BaseTexture;
}
export class BitmapFontLoader extends EventTarget {
baseUrl: string;
crossorigin: any;
texture: Texture;
url: string;
constructor(url: string, crossorigin: any);
load(): void;
}
export class BitmapText extends DisplayObjectContainer {
width: number;
height: number;
fontName: string;
fontSize: number;
tint: number;
textWidth: number;
textHeight: number;
constructor(text: string, style: IBitmapTextStyle);
setText(text: string): void;
setStyle(style: IBitmapTextStyle): void;
}
export class BlurFilter extends AbstractFilter {
blur: number;
blurX: number;
blurY: number;
}
export class BlurXFilter extends AbstractFilter {
blur: number;
}
export class BlurYFilter extends AbstractFilter {
blur: number;
}
export class CanvasMaskManager {
pushMask(maskData: IMaskData, context: CanvasRenderingContext2D): void;
popMask(context: CanvasRenderingContext2D): void;
}
export class CanvasRenderer implements IPixiRenderer {
type: number;
clearBeforeRender: boolean;
roundPixels: boolean;
transparent: boolean;
width: number;
height: number;
view: HTMLCanvasElement;
context: CanvasRenderingContext2D;
refresh: boolean;
count: number;
maskManager: CanvasMaskManager;
renderSession: IRenderSession;
constructor(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean);
render(stage: Stage): void;
resize(width: number, height: number): void;
}
export class CanvasTinter {
canvas: HTMLCanvasElement;
getTintedTexture(sprite: Sprite, color: number): HTMLCanvasElement;
tintWithMultiply(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
tintWithOverlay(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
tintWithPerPixel(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
static cacheStepsPerColorChannel: number;
static convertTintToImage: boolean;
static canUseMultiply: boolean;
static tintMethod: ITintMethod;
static roundColor(color: number): number;
}
export class Circle implements IHitArea {
x: number;
y: number;
radius: number;
constructor(x: number, y: number, radius: number);
clone(): Circle;
contains(x: number, y: number): boolean;
getBounds(): PIXI.Rectangle;
}
export class ColorMatrixFilter extends AbstractFilter {
matrix: number[];
}
export class ColorStepFilter extends AbstractFilter {
step: number;
}
export class CrossHatchFilter extends AbstractFilter {
blur: number;
}
export class DisplacementFilter extends AbstractFilter {
map: Texture;
offset: Point;
scale: Point;
constructor(texture: Texture);
}
export class DotScreenFilter extends AbstractFilter {
scale: Point;
angle: number;
}
export class DisplayObject {
alpha: number;
buttonMode: boolean;
defaultCursor: string;
filterArea: Rectangle;
filters: IAbstractFilter[];
hitArea: IHitArea;
interactive: boolean;
mask: Graphics;
parent: DisplayObjectContainer;
pivot: Point;
position: Point;
renderable: boolean;
rotation: number;
scale: Point;
stage: Stage;
visible: boolean;
worldAlpha: number;
worldVisible: boolean;
worldTransform: IMatrix;
x: number;
y: number;
click(e: InteractionData): void;
getBounds(matrix?: IMatrix): Rectangle;
getLocalBounds(): Rectangle;
generateTexture(renderer: PIXI.IPixiRenderer): RenderTexture;
mousedown(e: InteractionData): void;
mouseout(e: InteractionData): void;
mouseover(e: InteractionData): void;
mouseup(e: InteractionData): void;
mouseupoutside(e: InteractionData): void;
setStageReference(stage: Stage): void;
tap(e: InteractionData): void;
touchend(e: InteractionData): void;
touchendoutside(e: InteractionData): void;
touchstart(e: InteractionData): void;
}
export class DisplayObjectContainer extends PIXI.DisplayObject {
height: number;
width: number;
children: DisplayObject[];
addChild(child: DisplayObject): void;
addChildAt(child: DisplayObject, index: number): void;
getChildAt(index: number): DisplayObject;
removeChild(child: DisplayObject): void;
removeStageReference(): void;
}
export class Ellipse implements IHitArea {
x: number;
y: number;
width: number;
height: number;
constructor(x: number, y: number, width: number, height: number);
clone(): Ellipse;
contains(x: number, y: number): boolean;
getBounds(): Rectangle;
}
export class EventTarget {
listeners: { [key: string]: IEventCallback[] };
addEventListener(type: string, listener: IEventCallback): void;
dispatchEvent(event: IEvent): void;
removeAllEventListeners(type: string): void;
removeEventListener(type: string, listener: IEventCallback): void;
}
export class FilterBlock {
visible: boolean;
renderable: boolean;
}
export class FilterTexture {
fragmentSrc: string[];
gl: any;
program: any;
constructor(gl: any, width: number, height: number);
clear(): void;
resize(width: number, height: number): void;
destroy(): void;
}
export class Graphics extends Texture {
blendMode: blendModes;
bounds: Rectangle;
boundsPadding: number;
dirty: boolean;
fillAlpha: number;
isMask: boolean;
lineColor: string;
lineWidth: number;
renderable: boolean;
tint: number;
arc(cx: number, cy: number, radius: number, startAngule: number, endAngle: number, anticlockwise: boolean): PIXI.Graphics;
arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): PIXI.Graphics;
beginFill(color: number, alpha: number): void;
bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): PIXI.Graphics;
clear(): void;
drawCircle(x: number, y: number, radius: number): void;
drawEllipse(x: number, y: number, width: number, height: number): void;
drawPath(x: number, y: number): PIXI.Graphics;
drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): PIXI.Graphics;
drawRect(x: number, y: number, width: number, height: number): void;
endFill(): void;
generateTexture(): Texture;
generateTexture(renderer: PIXI.IPixiRenderer): RenderTexture;
getBounds(): Rectangle;
lineStyle(lineWidth: number, color: number, alpha: number): void;
lineTo(x: number, y: number): void;
moveTo(x: number, y: number): void;
quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): PIXI.Graphics;
updateBounds(): void;
}
export class GrayFilter extends AbstractFilter {
gray: number;
}
export class ImageLoader extends EventTarget {
texture: Texture;
constructor(url: string, crossorigin?: any);
load(): void;
loadFramedSpriteSheet(frameWidth: number, frameHeight: number, textureName: string): void;
}
export class InteractionData {
global: Point;
target: Sprite;
originalEvent: Event;
getLocalPosition(displayObject: DisplayObject): Point;
}
export class InteractionManager {
currentCursorStyle: string;
mouse: InteractionData;
mouseOut: boolean;
mouseoverEnabled: boolean;
pool: InteractionData[];
stage: Stage;
touchs: { [id: string]: InteractionData };
constructor(stage: Stage);
removeEvents(): void;
}
export class InvertFilter {
invert: number;
}
export class JsonLoader extends EventTarget {
baseUrl: string;
crossorigin: any;
loaded: boolean;
url: string;
constructor(url: string, crossorigin?: any);
load(): void;
}
export class MovieClip extends Sprite {
static fromFrames(frames: any[]): MovieClip;
static fromImages(images: any[]): MovieClip;
animationSpeed: number;
currentFrame: number;
loop: boolean;
playing: boolean;
textures: Texture[];
totalFrames: number;
constructor(textures: Texture[]);
onComplete: IBasicCallback;
gotoAndPlay(frameNumber: number): void;
gotoAndStop(frameNumber: number): void;
play(): void;
stop(): void;
}
export class NormalMapFilter extends AbstractFilter {
map: Texture;
offset: Point;
scale: Point;
}
export class PixelateFilter extends AbstractFilter {
size: number;
}
export class PixiFastShader {
gl: any;
fragmentSrc: string[];
program: any;
textureCount: number;
vertexSrc: string[];
constructor(gl: any);
destroy(): void;
init(): void;
}
export class PixiShader {
defaultVertexSrc: string;
fragmentSrc: string[];
gl: any;
program: any;
textureCount: number;
attributes: IShaderAttribute[];
defaultVertexSr: string;
constructor(gl: any);
destroy(): void;
init(): void;
initSampler2D(): void;
initUniforms(): void;
syncUniforms(): void;
}
export class Point {
x: number;
y: number;
constructor(x?: number, y?: number);
clone(): Point;
set(x: number, y: number): void;
}
export class Polygon implements IHitArea {
points: Point[];
constructor(points: Point[]);
constructor(points: number[]);
constructor(...points: Point[]);
constructor(...points: number[]);
clone(): Polygon;
contains(x: number, y: number): boolean;
}
export class PrimitiveShader {
gl: any;
program: any;
fragmentSrc: string[];
vertextSrc: string[];
destroy(): void;
init(): void;
}
export class Rectangle implements IHitArea {
x: number;
y: number;
width: number;
height: number;
constructor(x?: number, y?: number, width?: number, height?: number);
clone(): Rectangle;
contains(x: number, y: number): boolean;
}
export class RenderTexture extends Texture {
width: number;
height: number;
frame: Rectangle;
baseTexture: BaseTexture;
constructor(width: number, height: number, renderer: IPixiRenderer);
clear(): void;
resize(width: number, height: number, updateBase: boolean): void;
}
export class RGBSplitFilter extends AbstractFilter {
angle: number;
}
export class Rope {
points: Point[];
vertices: Float32Array;
uvs: Float32Array;
colors: Float32Array;
indices: Uint16Array;
constructor(texture: Texture, points: Point[]);
refresh(): void;
setTexture(texture: Texture);
}
export class SepiaFilter {
sepia: number;
}
export class SmartBlurFilter {
blur: number;
}
export class Spine {
animationSpeed: number;
url: string;
crossorigin: any;
loaded: boolean;
constructor(url: string);
createSprite(slot: any, descriptor: string): Sprite;
load();
}
export class SpineLoader extends EventTarget {
url: string;
crossorigin: any;
loaded: boolean;
constructor(url: string, crossorigin?: any);
load(): void;
}
export class Sprite extends DisplayObjectContainer {
anchor: Point;
blendMode: number;
texture: Texture;
height: number;
width: number;
tint: number;
constructor(texture: Texture);
getBounds(matrix?: IMatrix): Rectangle;
setTexture(texture: Texture): void;
static fromFrame(frameId: string): Sprite;
static fromImage(url: string): Sprite;
}
export class SpriteBatch {
constructor(texture: Texture);
}
/* TODO determine type of frames */
export class SpriteSheetLoader extends EventTarget {
url: string;
crossorigin: any;
baseUrl: string;
texture: Texture;
frames: Object;
constructor(url: string, crossorigin?: any);
load();
}
export class Stage extends DisplayObjectContainer {
bounds: Phaser.Rectangle;
interactive: boolean;
interactionManager: InteractionManager;
worldTransform: IMatrix;
constructor(backgroundColor: number);
getMousePosition(): Point;
setBackgroundColor(backgroundColor: number): void;
setInteractionDelegate(domElement: HTMLElement): void;
}
export class Strip extends DisplayObjectContainer {
constructor(texture: Texture);
}
export class StripShader {
//where is WebGLContext in TypeScript? "any" is used
constructor(gl:any)
program: any;
fragmentSrc: any[];
vertexSrc: any[];
init(): void;
destroy(): void;
}
export class Text extends Sprite {
canvas: HTMLCanvasElement;
context: CanvasRenderingContext2D;
constructor(text: string, style: ITextStyle);
destroy(destroyBaseTexture: boolean): void;
setText(text: string): void;
setStyle(style: ITextStyle): void;
}
export class Texture extends EventTarget {
baseTexture: BaseTexture;
crop: Rectangle;
frame: Rectangle;
height: number;
noFrame: boolean;
scope: Object;
trim: Point;
valid: boolean;
width: number;
constructor(baseTexture: BaseTexture, frame?: Rectangle);
destroy(destroyBase?: boolean): void;
setFrame(frame: Rectangle): void;
render(displayObject: DisplayObject, position: Point, clear: boolean): void;
static fromImage(imageUrl: string, crossorigin: any, scaleMode: scaleModes): Texture;
static fromFrame(frameId: string): Texture;
static fromCanvas(canvas: HTMLCanvasElement, scaleMode: scaleModes): Texture;
static addTextureToCache(texture: Texture, id: string): void;
static removeTextureFromCache(id: string): Texture;
}
export class TilingSprite extends DisplayObjectContainer {
width: number;
height: number;
renderable: boolean;
texture: Texture;
tint: number;
tilePosition: Point;
tileScale: Point;
tileScaleOffset: Point;
blendMode: blendModes;
constructor(texture: Texture, width: number, height: number);
generateTilingTexture(forcePowerOfTwo: boolean): void;
}
export class TwistFilter extends AbstractFilter {
size: Point;
angle: number;
radius: number;
}
export class WebGLComplexGraphics {
}
export class WebGLFastSpriteBatch {
vertSize: number;
maxSize: number;
size: number;
vertices: Float32Array;
indices: Uint16Array;
vertextBuffer: any;
indexBuffer: any;
lastIndexCount: number;
drawing: boolean;
currentBatchSize: number;
currentBaseTexture: Texture;
currentBlendMode: number;
renderSession: any;
shader: any;
matrix: any;
begin(spriteBatch: any, renderSession: any): void;
end(): void;
flush(): void;
render(spriteBatch: any): void;
renderSprite(sprite: any): void;
stop(): void;
start(): void;
setContext(gl: any): void;
setBlendMode(blendMode: PIXI.blendModes): void;
}
export class WebGLFilterManager {
filterStack: IAbstractFilter[];
transparent: boolean;
offsetX: number;
offsetY: number;
constructor(gl: any, transparent: boolean);
applyFilterPass(filter: AbstractFilter, filterArea: Texture, width: number, height: number): void;
begin(renderSession: IRenderSession, buffer: ArrayBuffer): void;
destroy(): void;
initShaderBuffers(): void;
pushFilter(filterBlock: IFilterBlock): void;
popFilter(): void;
setContext(gl: any);
}
export class WebGLGraphics {
}
export class WebGLMaskManager {
constructor(gl: any);
destroy(): void;
pushMask(maskData: any[], renderSession: IRenderSession): void;
popMask(renderSession: IRenderSession): void;
setBlendMode(blendMode: number): void;
setContext(gl: any);
}
export class WebGLPrimitiveBatch {
}
export class WebGLRenderer implements IPixiRenderer {
contextLost: boolean;
width: number;
height: number;
preserveDrawingBuffer: boolean;
transparent: boolean;
type: number;
view: HTMLCanvasElement;
constructor(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean, antialias?: boolean, preserveDrawingBuffer?: boolean);
destroy(): void;
render(stage: Stage): void;
renderDisplayObject(displayObject: DisplayObject, projection: Point, buffer: any): void;
resize(width: number, height: number): void;
static createWebGLTexture(texture: Texture, gl: any): void;
}
export class WebGLShaderManager {
activatePrimitiveShader(): void;
activateShader(shader: PixiShader): void;
deactivatePrimitiveShader(): void;
destroy(): void;
setAttribs(attribs: IShaderAttribute[]): void;
setContext(gl: any, transparent: boolean);
}
export class WebGLStencilManager {
}
export class WebGLShaderUtils {
}
export class WebGLSpriteBatch {
currentBatchSize: number;
currentBaseTexture: any;
drawing: boolean;
indices: Uint16Array;
lastIndexCount: number;
size: number;
vertices: Float32Array;
vertSize: number;
constructor(gl: any);
begin(renderSession: IRenderSession): void;
flush(): void;
end(): void;
destroy(): void;
render(sprite: Sprite): void;
renderTilingSprite(sprite: TilingSprite): void;
setBlendMode(blendMode: blendModes): void;
setContext(gl: any): void;
start(): void;
stop(): void;
}
}
declare module PIXI.PolyK {
export function Triangulate(p: number[]): number[];
}
declare function canUseNewCanvasBlendModes(): boolean;
declare function getBounds(): Phaser.Rectangle;
declare function getNextPowerOfTwo(value: number): number;
declare function hex2rgb(hex: number): number[];
declare function hitText(displayObject: any): boolean;
declare function rgb2hex(rgb: number[]): number;
declare class Phaser {
static VERSION: string;
static DEV_VERSION: string;
static GAMES: Phaser.Game[];
static AUTO: number;
static CANVAS: number;
static WEBGL: number;
static HEADLESS: number;
static BITMAPDATA: number;
static BITMAPTEXT: number;
static BUTTON: number;
static CANVAS_FILTER: number;
static ELLIPSE: number;
static EMITTER: number;
static GRAPHICS: number;
static GROUP: number;
static IMAGE: number;
static POINTER: number;
static POLYGON: number;
static RENDERTEXTURE: number;
static RETROFONT: number;
static SPRITE: number;
static SPRITEBATCH: number;
static TEXT: number;
static TILEMAP: number;
static TILEMAPLAYER: number;
static TILESPRITE: number;
static WEBGL_FILTER: number;
static NONE: number;
static LEFT: number;
static RIGHT: number;
static UP: number;
static DOWN: number;
}
declare module Phaser {
class Animation {
constructor(game: Phaser.Game, parent: Phaser.Sprite, name: string, frameData: Phaser.FrameData, frames: any[], delay: number, loop: boolean);
currentAnim: Phaser.Animation;
currentFrame: Phaser.Frame;
delay: number;
frame: number;
frameTotal: number;
game: Phaser.Game;
isFinished: boolean;
isPaused: boolean;
isPlaying: boolean;
killOnComplete: boolean;
loop: boolean;
loopCount: number;
name: string;
onComplete: Phaser.Signal;
onLoop: Phaser.Signal;
onStart: Phaser.Signal;
paused: boolean;
speed: number;
complete(): void;
destroy(): void;
static generateFrameNames(prefix: string, start: number, stop: number, suffix?: string, zeroPad?: number): string[];
next(quantity?: number): void;
onPause(): void;
onResume(): void;
play(frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation;
previous(quantity?: number): void;
restart(): void;
setFrame(frameId?: any, useLocalFrameIndex?: boolean): void;
stop(resetFrame?: boolean, dispatchComplete?: boolean): void;
update(): boolean;
updateFrameData(frameData: Phaser.FrameData): void;
}
class AnimationManager {
constructor(sprite: Phaser.Sprite);
currentAnim: Phaser.Animation;
currentFrame: Phaser.Frame;
frame: number;
frameData: Phaser.FrameData;
frameName: string;
frameTotal: number;
game: Phaser.Game;
isLoaded: boolean;
paused: boolean;
sprite: Phaser.Sprite;
updateIfVisible: boolean;
add(name: string, frames?: any[], frameRate?: number, loop?: boolean, useNumericIndex?: boolean): Phaser.Animation;
destroy(): void;
getAnimation(name: string): Phaser.Animation;
next(quantity?: number): void;
play(name: string, frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation;
previous(quantity?: number): void;
refreshFrame();
stop(name?: string, resetFrame?: boolean): void;
update(): boolean;
validateFrames(frames: Phaser.Frame[], useNumericIndex?: boolean): boolean;
}
class AnimationParser {
static JSONData(game: Phaser.Game, json: Object): Phaser.FrameData;
static JSONDataHash(game: Phaser.Game, json: Object): Phaser.FrameData;
static spriteSheet(game: Phaser.Game, key: string, frameWidth: number, frameHeight: number, frameMax?: number, margin?: number, spacing?: number): Phaser.FrameData;
static XMLData(game: Phaser.Game, xml: Object): Phaser.FrameData;
}
class ArrayList {
first: Object;
list: any[];
next: Object;
position: number;
total: number;
add(child: Object): Object;
callAll(callback: Function, ...parameters: any[]);
exists(child: Object): boolean;
getIndex(child: Object): number;
remove(child: Object): Object;
reset(): void;
}
class BitmapData {
constructor(game: Phaser.Game, key: string, width?: number, height?: number);
baseTexture: PIXI.BaseTexture;
buffer: ArrayBuffer;
canvas: HTMLCanvasElement;
context: CanvasRenderingContext2D;
ctx: CanvasRenderingContext2D;
data: Uint8Array;
dirty: boolean;
disableTextureUpload: boolean;
game: Phaser.Game;
height: number;
imageData: ImageData;
key: string;
pixels: Uint32Array;
texture: PIXI.Texture;
textureFrame: Phaser.Frame;
type: number;
width: number;
add(object: any): void;
alphaMask(source: any, mask: any, sourceRect?: Phaser.Rectangle, maskRect?: Phaser.Rectangle): void;
circle(x: number, y: number, radius: number, fillStyle?: string): void;
clear(): void;
cls(): void;
copyPixels(source: any, area: Phaser.Rectangle, destX: number, destY: number): void;
draw(source: any, x?: number, y?: number, width?: number, height?: number): void;
drawSprite(sprite: any, x?: number, y?: number): void;
extract(destination: Phaser.BitmapData, r: number, g: number, b: number, a?: number, resize?: boolean, r2?: number, g2?: number, b2?: number): Phaser.BitmapData;
fill(r: number, g: number, b: number, a?: number): void;
getPixel(x: number, y: number, out?: Object): number;
getPixelRGB(x: number, y: number, out?: Object, hsl?: boolean, hsv?: boolean): Object;
getPixel32(x: number, y: number): number;
getPixels(rect: Phaser.Rectangle): ImageData;
load(source: any): void;
processPixel(callback: Function, callbackContext: Object, x?: number, y?: Number, width?: number, height?: number): void;
processPixelRGB(callback: Function, callbackContext: Object, x?: number, y?: Number, width?: number, height?: number): void;
rect(x: number, y: number, width: number, height: number, fillStyle?: string): void;
refreshBuffer(x?: number, y?: number, width?: number, height?: number): void;
render(): void;
replaceRGB(r1: number, g1: number, b1: number, a1: number, r2: number, g2: number, b2: number, a2: number, region: Phaser.Rectangle): void;
resize(width: number, height: number): void;
shiftHSL(h?: number, s?: number, l?: number, region?: Phaser.Rectangle): void;
setHSL(h?: number, s?: number, l?: number, region?: Phaser.Rectangle): void;
setPixel(x: number, y: number, red: number, green: number, blue: number, immediate?: boolean): void;
setPixel32(x: number, y: number, red: number, green: number, blue: number, alpha: number, immediate?: boolean): void;
}
class BitmapText extends PIXI.BitmapText {
constructor(game: Phaser.Game, x: number, y: number, font: string, text?: string, size?: number);
align: string;
angle: number;
cameraOffset: Phaser.Point;
destroyPhase: boolean;
events: Phaser.Events;
exists: boolean;
fixedToCamera: boolean;
font: string;
fontSize: number;
game: Phaser.Game;
input: Phaser.InputHandler;
inputEnabled: boolean;
name: string;
position: Phaser.Point;
text: string;
tint: number;
type: number;
world: Phaser.Point;
z: number;
destroy(destroyChildren?: boolean): void;
postUpdate(): void;
preUpdate(): void;
update(): void;
updateText(): void;
updateTransform(): void;
}
class Button extends Phaser.Image {
constructor(game: Phaser.Game, x?: number, y?: number, key?: string, callback?: Function, callbackContext?: Object, overFrame?: any, outFrame?: any, downFrame?: any, upFrame?: any);
forceOut: boolean;
freezeFrames: boolean;
onDownSound: Phaser.Sound;
onDownSoundMarker: string;
onInputDown: Phaser.Signal;
onInputOut: Phaser.Signal;
onInputOver: Phaser.Signal;
onInputUp: Phaser.Signal;
onOutSound: Phaser.Sound;
onOutSoundMarker: string;
onOverSound: Phaser.Sound;
onOverSoundMarker: string;
onOverMouseOnly: boolean;
onUpSound: Phaser.Sound;
onUpSoundMaker: string;
type: number;
clearFrames(): void;
setDownSound(sound: Phaser.Sound, marker?: string): void;
setFrames(overFrame?: any, outFrame?: any, downFrame?: any, upFrame?: any): void;
onInputDownHandler(sprite: Phaser.Button, pointer: Phaser.Pointer): void;
onInputUpHandler(sprite: Phaser.Button, pointer: Phaser.Pointer, isOver: boolean): void;
setOutSound(sound: Phaser.Sound, marker?: string): void;
setOverSound(sound: Phaser.Sound, marker?: string): void;
setSounds(overSound?: Phaser.Sound, overMarker?: string, downSound?: Phaser.Sound, downMarker?: string, outSound?: Phaser.Sound, outMarker?: string, upSound?: Phaser.Sound, upMarker?: string): void;
setState(newState: number): void;
setUpSound(sound: Phaser.Sound, marker?: string): void;
}
class Cache {
constructor(game: Phaser.Game);
static BINARY: number;
static BITMAPDATA: number;
static BITMAPFONT: number;
static CANVAS: number;
static IMAGE: number;
static JSON: number;
static PHYSICS: number;
static SOUND: number;
static TEXT: number;
static TEXTURE: number;
static TILEMAP: number;
game: Phaser.Game;
onSoundUnlock: Phaser.Signal;
addBinary(key: string, binaryData: Object): void;
addBitmapData(key: string, bitmapData: Phaser.BitmapData): Phaser.BitmapData;
addBitmapFont(key: string, texture: Phaser.RetroFont): void;
addBitmapFont(key: string, url: string, data: Object, xmlData: Object, xSpacing?: number, ySpacing?: number): void;
addCanvas(key: string, canvas: HTMLCanvasElement, context: CanvasRenderingContext2D): void;
addDefaultImage(): void;
addImage(key: string, url: string, data: Object): void;
addJSON(key: string, urL: string, data: Object): void;
addMisingImage(): void;
addPhysicsData(key: string, url: string, JSONData: Object, format: number): void;
addRenderTexture(key: string, texture: RenderTexture): void;
addSound(key: string, url: string, data: Object, webAudio: boolean, audioTag: boolean): void;
addSpriteSheet(key: string, url: string, data: Object, frameWidth: number, frameHeight: number, frameMax?: number, margin?: number, spacing?: number): void;
addText(key: string, url: string, data: Object): void;
addTextureAtlas(key: string, url: string, data: Object, atlasData: Object, format: number): void;
addTilemap(key: string, url: string, mapData: Object, format: number): void;
checkKey(type: number, key: string): boolean;
checkCanvasKey(key: string): boolean;
checkImageKey(key: string): boolean;
checkTextureKey(key: string): boolean;
checkSoundKey(key: string): boolean;
checkTextKey(key: string): boolean;
checkPhysicsKey(key: string): boolean;
checkTilemapKey(key: string): boolean;
checkBinaryKey(key: string): boolean;
checkBitmapDataKey(key: string): boolean;
checkBitmapFontKey(key: string): boolean;
checkJSONKey(key: string): boolean;
decodedSound(key: string, data: Object): void;
destroy(): void;
getBinary(key: string): Object;
getBitmapData(key: string): Phaser.BitmapData;
getBitmapFont(key: string): Phaser.RetroFont;
getCanvas(key: string): Object;
getFrame(key: string): Phaser.Frame;
getFrameByIndex(key: string, frame: string): Phaser.Frame;
getFrameByName(key: string, frame: string): Phaser.Frame;
getFrameData(key: string): Phaser.FrameData;
getImage(key: string): Object;
getJSON(key: string): Object;
getKeys(array: string[]): string[];
getPhysicsData(key: string, object?: string, fixtureKey?: string): Object[];
getSound(key: string): Phaser.Sound;
getSoundData(key: string): Object;
getText(key: string): string;
getTextKeys(): string[];
getTexture(key: string): Phaser.RenderTexture;
getTextureFrame(key: string): Phaser.Frame;
getTilemapData(key: string): Object;
getTilemap(key: string): Object;
isSoundDecoded(key: string): boolean;
isSoundReady(key: string): boolean;
isSpriteSheet(key: string): boolean;
reloadSound(key: string): void;
reloadSoundComplete(key: string): void;
removeBinary(key: string): void;
removeBitmapData(key: string): void;
removeBitmapFont(key: string): void;
removeCanvas(key: string): void;
removeImage(key: string): void;
removeJSON(key: string): void;
removePhysics(key: string): void;
removeSound(key: string): void;
removeText(key: string): void;
removeTilemap(key: string): void;
updateFrameData(key: string, frameData: any): void;
updateSound(key: string, property: string, value: Phaser.Sound): void;
}
class Camera {
constructor(game: Phaser.Game, id: number, x: number, y: number, width: number, height: number);
static FOLLOW_LOCKON: number;
static FOLLOW_PLATFORMER: number;
static FOLLOW_TOPDOWN: number;
static FOLLOW_TOPDOWN_TIGHT: number;
atLimit: { x: boolean; y: boolean; };
bounds: Phaser.Rectangle;
deadzone: Phaser.Rectangle;
displayObject: PIXI.DisplayObject;
id: number;
game: Phaser.Game;
height: number;
scale: Phaser.Point;
screenView: Phaser.Rectangle;
target: Phaser.Sprite;
view: Phaser.Rectangle;
visible: boolean;
width: number;
world: Phaser.World;
x: number;
y: number;
checkBounds(): void;
focusOn(displayObject: any): void;
focusOnXY(x: number, y: number): void;
follow(target: Phaser.Sprite, style?: number): void;
reset(): void;
setBoundsToWorld(): void;
setPosition(x: number, y: number): void;
setSize(width: number, height: number): void;
update(): void;
}
class Canvas {
static addToDOM(canvas: HTMLCanvasElement, parent: any, overflowHidden?: boolean): HTMLCanvasElement;
static create(width?: number, height?: number, id?: string, noCocoon?: boolean): HTMLCanvasElement;
static getAspectRatio(canvas: HTMLCanvasElement): number;
static getOffset(element: HTMLElement, point?: Phaser.Point): Phaser.Point;
static setBackgroundColor(canvas: HTMLCanvasElement, color: string): HTMLCanvasElement;
static setImageRenderingBicubic(canvas: HTMLCanvasElement): HTMLCanvasElement;
static setImageRenderingCrisp(canvas: HTMLCanvasElement): HTMLCanvasElement;
static setSmoothingEnabled(context: CanvasRenderingContext2D, value: boolean): CanvasRenderingContext2D;
static setTouchAction(canvas: HTMLCanvasElement, value: string): HTMLCanvasElement;
static setTransform(context: CanvasRenderingContext2D, translateX: number, translateY: number, scaleX: number, scaleY: number, skewX: number, skewY: number): CanvasRenderingContext2D;
static setUserSelect(canvas: HTMLCanvasElement, value?: string): HTMLCanvasElement;
}
class Circle {
constructor(x?: number, y?: number, diameter?: number);
area: number;
bottom: number;
diameter: number;
empty: boolean;
left: number;
radius: number;
right: number;
top: number;
x: number;
y: number;
static circumferencePoint(a: Phaser.Circle, angle: number, asDegrees: boolean, out?: Phaser.Point): Phaser.Point;
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 intersectsRectangle(c: Phaser.Circle, r: Phaser.Rectangle): boolean;
circumference(): number;
circumferencePoint(angle: number, asDegrees?: boolean, out?: Phaser.Point): Phaser.Point;
clone(out: Phaser.Circle): Phaser.Circle;
contains(x: number, y: number): boolean;
copyFrom(source: any): Circle;
copyTo(dest: Object): Object;
distance(dest: Object, round?: boolean): number;
offset(dx: number, dy: number): Phaser.Circle;
offsetPoint(point: Phaser.Point): Phaser.Circle;
setTo(x: number, y: number, diameter: number): Circle;
toString(): string;
}
class Color {
static colorToHexstring(color: number): string;
static componentToHex(color: number): string;
static createColor(r?: number, g?: number, b?: number, a?: number, h?: number, s?: number, l?: number, v?: number): Object;
static fromRGBA(rgba: number, out?: Object): Object;
static getAlpha(color: number): number;
static getAlphaFloat(color: number): number;
static getBlue(color: number): number;
static getColor(red: number, green: number, blue: number): number;
static getColor32(alpha: number, red: number, green: number, blue: number): number;
static getColorInfo(color: number): string;
static getGreen(color: number): number;
static getRandomColor(min?: number, max?: number, alpha?: number): number;
static getRed(color: number): number;
static getRGB(color: number): Object;
static getWebRGB(color: any): string;
static hexToRGB(h: string): number;
static hexToColor(hex: string, out?: Object): Object;
static HSLtoRGB(h: number, s: number, l: number, out?: Object): Object;
static HSLColorWheel(s?: number, l?: number): any[];
static HSVtoRGB(h: number, s: number, v: number, out?: Object): Object;
static HSVColorWheel(s?: number, v?: number): any[];
static hueToColor(p: number, q: number, t: number): number;
static interpolateColor(color1: number, color2: number, steps: number, currentStep: number, alpha: number): number;
static interpolateColorWithRGB(color: number, r: number, g: number, b: number, steps: number, currentStep: number): number;
static interpolateRGB(r1: number, g1: number, b1: number, r2: number, g2: number, b2: number, steps: number, currentStep: number): number;
static packPixel(r: number, g: number, b: number, a: number): number;
static RGBtoHSL(r: number, g: number, b: number, out?: Object): Object;
static RGBtoHSV(r: number, g: number, b: number, out?: Object): Object;
static RGBtoString(r: number, g: number, b: number, a?: number, prefix?: string): string;
static RGBtoHexstring(color: number): string;
static RGBtoWebstring(color: number): string;
static toRGBA(r: number, g: number, b: number, a: number): number;
static unpackPixel(rgba: number, out?: Object, hsl?: boolean, hsv?: boolean): Object;
static updateColor(out: any): number;
}
class ComplexPrimitiveShader {
//where is WebGLContext in TypeScript? "any" is used
constructor(gl: any);
gl: any;
program: any;
fragmentSrc: any[];
vertexSrc: any[];
destroy(): void;
init(): void;
}
interface CursorKeys {
up: Phaser.Key;
down: Phaser.Key;
left: Phaser.Key;
right: Phaser.Key;
}
class Device {
static LITTLE_ENDIAN: boolean;
constructor(game: Phaser.Game);
android: boolean;
arora: boolean;
audioData: boolean;
cancelFullScreen: string;
canvas: boolean;
chrome: boolean;
chromeOS: boolean;
cocoonJS: boolean;
crosswalk: boolean;
css3D: boolean;
desktop: boolean;
ejecta: boolean;
epiphany: boolean;
file: boolean;
fileSystem: boolean;
firefox: boolean;
fullScreen: boolean;
fullScreenKeyboard: boolean;
getUserMedia: boolean;
game: Phaser.Game;
ie: boolean;
ieVersion: number;
iOS: boolean;
iPad: boolean;
iPhone: boolean;
iPhone4: boolean;
linux: boolean;
littleEndian: boolean;
localStorage: boolean;
m4a: boolean;
macOS: boolean;
midori: boolean;
mobileSafari: boolean;
mp3: boolean;
mspointer: boolean;
ogg: boolean;
opera: boolean;
opus: boolean;
pixelRatio: number;
pointerLock: boolean;
quirksMode: boolean;
requestFullScreen: string;
safari: boolean;
silk: boolean;
support32bit: boolean;
touch: boolean;
trident: boolean;
tridentVersion: number;
typedArray: boolean;
vibration: boolean;
wav: boolean;
webApp: boolean;
webAudio: boolean;
webGL: boolean;
webm: boolean;
windows: boolean;
windowsPhone: boolean;
worker: boolean;
checkFullScreenSupport(): void;
canPlayAudio(type: string): boolean;
isConsoleOpen(): boolean;
}
class DOMSprite {
//constructor
constructor(game: Phaser.Game, id: string, x: number, y: number, text: string, style: Object);
//members
alive: boolean;
exists: boolean;
game: Phaser.Game;
group: Phaser.Group;
name: string;
type: number;
visible: boolean;
}
module Easing {
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 Circular {
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 Elastic {
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 Linear {
static None(k: number): number;
}
class Quadratic {
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 Ellipse {
constructor(x?: number, y?: number, width?: number, height?: number);
bottom: number;
empty: boolean;
height: number;
left: number;
right: number;
top: number;
width: number;
x: number;
y: number;
static constains(a: Phaser.Ellipse, x: number, y: number): boolean;
clone(out: Phaser.Ellipse): Phaser.Ellipse;
contains(x: number, y: number): boolean;
copyFrom(source: any): Phaser.Ellipse;
copyTo(dest: any): Object;
setTo(x: number, y: number, width: number, height: number): Phaser.Ellipse;
toString(): string;
}
class Events {
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;
}
module Filter {
class BinarySerpents extends Phaser.Filter {
constructor(game: Phaser.Game, width: number, height: number, march?: number, maxDistance?: number);
fog: number;
}
class BlurX extends Phaser.Filter {
blur: number;
}
class BlurY extends Phaser.Filter {
blur: number;
}
class CausticLight extends Phaser.Filter {
constructor(game: Phaser.Game, width: number, height: number, divisor?: number);
init(width: number, height: number, divisor?: number): void;
}
class CheckerWave extends Phaser.Filter {
constructor(game: Phaser.Game, width: number, height: number);
alpha: number;
cameraX: number;
cameraY: number;
cameraZ: number;
init(width: number, height: number): void;
setColor1(red: number, green: number, blue: number): void;
setColor2(red: number, green: number, blue: number): void;
}
class ColorBars extends Phaser.Filter {
constructor(game: Phaser.Game, width: number, height: number);
alpha: number;
init(width: number, height: number): void;
}
class Fire extends Phaser.Filter {
constructor(width: number, height: number, alpha?: number, shift?: number);
alpha: number;
shift: number;
speed: number;
init(width: number, height: number, alpha?: number, shift?: number): void;
}
class Gray extends Phaser.Filter {
gray: number;
}
class HueRotate extends Phaser.Filter {
constructor(game: Phaser.Game, width: number, height: number, texture: any);
alpha: number;
init(width: number, height: number, texture: any): void;
}
class LightBeam extends Phaser.Filter {
constructor(game: Phaser.Game, width: number, height: number);
alpha: number;
blue: number;
green: number;
red: number;
thickness: number;
speed: number;
init(width: number, height: number): void;
}
class Marble extends Phaser.Filter {
constructor(game: Phaser.Game, width: number, height: number, speed?: number, intensity?: number);
alpha: number;
intensity: number;
speed: number;
init(width: number, height: number, speed?: number, intensity?: number): void;
}
class Pixelate extends Phaser.Filter {
size: number;
}
class Plasma extends Phaser.Filter {
constructor(game: Phaser.Game, width: number, height: number, alpha?: number, size?: number);
alpha: number;
blueShift: number;
greenShift: number;
redShift: number;
size: number;
init(width: number, height: number, alpha?: number, size?: number): void;
}
class SampleFilter extends Phaser.Filter {
constructor(game: Phaser.Game, width: number, height: number, divisor?: number);
init(width: number, height: number, divisor?: number): void;
}
class Tunnel extends Phaser.Filter {
constructor(game: Phaser.Game, width: number, height: number, texture: any);
alpha: number;
origin: number;
init(width: number, height: number, texture: any): void;
}
}
class Filter implements PIXI.IAbstractFilter {
constructor(game: Phaser.Game, ...args: any[]);
dirty: boolean;
game: Phaser.Game;
height: number;
padding: number;
type: number;
uniforms: Object;
fragmentSrc: any[];
width: number;
destroy(): void;
init(...args: any[]): void;
setResolution(width: number, height: number);
update(pointer?: Phaser.Pointer): void;
}
class Frame {
constructor(index: number, x: number, y: number, width: number, height: number, name: string, uuid: string);
bottom: number;
centerX: number;
centerY: number;
distance: number;
height: number;
index: number;
name: string;
right: number;
rotated: boolean;
rotationDirection: string;
sourceSizeH: number;
sourceSizeW: number;
spriteSourceSizeH: number;
spriteSourceSizeW: number;
spriteSourceSizeX: number;
spriteSourceSizeY: number;
trimmed: boolean;
uuid: string;
width: number;
x: number;
y: number;
getRect(out?: Phaser.Rectangle): Phaser.Rectangle;
setTrim(trimmed: boolean, actualWidth: number, actualHeight: number, destX: number, destY: number, destWidth: number, destHeight: number): void;
}
class FrameData {
total: number;
addFrame(frame: Frame): Phaser.Frame;
checkFrameName(name: string): boolean;
getFrame(index: number): Phaser.Frame;
getFrameByName(name: string): Phaser.Frame;
getFrameIndexes(frames: number[], useNumericIndex?: boolean, output?: number[]): number[];
getFrameRange(start: number, end: number, output: Phaser.Frame[]): Phaser.Frame[];
getFrames(frames: number[], useNumericIndex?: boolean, output?: Phaser.Frame[]): Phaser.Frame[];
}
interface IGameConfig {
enableDebug?: boolean;
}
class Game {
constructor(width?: number, height?: number, renderer?: number, parent?: any, state?: Object, transparent?: boolean, antialias?: boolean, physicsConfig?: Object);
add: Phaser.GameObjectFactory;
antialias: boolean;
cache: Phaser.Cache;
camera: Phaser.Camera;
canvas: HTMLCanvasElement;
config: IGameConfig;
context: Object;
debug: Phaser.Utils.Debug;
device: Phaser.Device;
height: number;
id: number;
input: Phaser.Input;
isBooted: boolean;
isRunning: boolean;
load: Phaser.Loader;
make: Phaser.GameObjectCreator;
math: Phaser.Math;
net: Phaser.Net;
onBlur: Phaser.Signal;
onFocus: Phaser.Signal;
onPause: Phaser.Signal;
onResume: Phaser.Signal;
parent: HTMLElement;
particles: Phaser.Particles;
paused: boolean;
pendingStep: boolean;
physics: Phaser.Physics;
physicsConfig: Object;
preserveDrawingBuffer: Boolean;
raf: Phaser.RequestAnimationFrame;
renderer: number;
renderType: number;
rnd: Phaser.RandomDataGenerator;
scale: Phaser.ScaleManager;
scratch: Phaser.BitmapData;
sound: Phaser.SoundManager;
stage: Phaser.Stage;
state: Phaser.StateManager;
stepCount: number;
stepping: boolean;
time: Phaser.Time;
transparent: boolean;
tweens: Phaser.TweenManager;
width: number;
world: Phaser.World;
boot(): void;
destroy(): void;
disableStep(): void;
enableStep(): void;
focusGain(event: Object): void;
focusLoss(event: Object): void;
gamePaused(event: Object): void;
gameResumed(event: Object): void;
parseConfig(config: Object): void;
setUpRenderer(): void;
showDebugHeader(): void;
step(): void;
update(time: number): void;
}
class GameObjectCreator {
constructor(game: Phaser.Game);
game: Phaser.Game;
world: Phaser.World;
audio(key: string, volume?: number, loop?: boolean, connect?: boolean): Phaser.Sound;
bitmapData(width?: number, height?: number, key?: string, addToCache?: boolean): Phaser.BitmapData;
bitmapText(x: number, y: number, font: string, text?: string, size?: number): Phaser.BitmapText;
button(x?: number, y?: number, key?: string, callback?: Function, callbackContext?: Object, overFrame?: any, outFrame?: any, downFrame?: any, upFrame?: any): Phaser.Button;
emitter(x?: number, y?: number, maxParticles?: number): Phaser.Particles.Arcade.Emitter;
filter(filter: any, ...args: any[]): Phaser.Filter;
graphics(x: number, y: number): Phaser.Graphics;
group(parent?: any, name?: string, addToStage?: boolean, enableBody?: boolean, physicsBodyType?: number): Phaser.Group;
image(x: number, y: number, key: any, frame?: any): Phaser.Sprite;
renderTexture(width?: number, height?: number, key?: any, addToCache?: boolean): Phaser.RenderTexture;
retroFont(font: string, characterWidth: number, characterHeight: number, chars: string, charsPerRow: number, xSpacing?: number, ySpacing?: number, xOffset?: number, yOffset?: number): Phaser.RetroFont;
sound(key: string, volume?: number, loop?: boolean, connect?: boolean): Phaser.Sound;
sprite(x: number, y: number, key?: any, frame?: any): Phaser.Sprite;
spriteBatch(parent: any, name?: String, addToStage?: boolean): Phaser.Group;
text(x: number, y: number, text?: string, style?: Object): Phaser.Text;
tileMap(key: string, tileWidth?: number, tileHeight?: number, width?: number, height?: number): Phaser.Tilemap;
tileSprite(x: number, y: number, width: number, height: number, key: any, frame: any): Phaser.TileSprite;
tween(obj: Object): Phaser.Tween;
}
class GameObjectFactory {
constructor(game: Phaser.Game);
game: Phaser.Game;
world: Phaser.World;
audio(key: string, volume?: number, loop?: boolean, connect?: boolean): Phaser.Sound;
bitmapData(width?: number, height?: number, key?: string, addToCache?: boolean): Phaser.BitmapData;
bitmapText(x: number, y: number, font: string, text?: string, size?: number, group?: Phaser.Group): Phaser.BitmapText;
button(x?: number, y?: number, key?: string, callback?: Function, callbackContext?: Object, overFrame?: any, outFrame?: any, downFrame?: any, upFrame?: any, group?: Phaser.Group): Phaser.Button;
emitter(x?: number, y?: number, maxParticles?: number): Phaser.Particles.Arcade.Emitter;
existing(object: any): any;
filter(filter: string, ...args: any[]): Phaser.Filter;
graphics(x: number, y: number, group?: Phaser.Group): Phaser.Graphics;
group(parent?: any, name?: string, addToStage?: boolean, enableBody?: boolean, physicsBodyType?: number): Phaser.Group;
image(x: number, y: number, key: any, frame?: any, group?: Phaser.Group): Phaser.Image;
physicsGroup(physicsBodyType: number, parent?: any, name?: string, addToStage?: boolean): Phaser.Group;
plugin(plugin: Phaser.Plugin, ...parameter: any[]): Phaser.Plugin;
renderTexture(width?: number, height?: number, key?: string, addToCache?: boolean): Phaser.RenderTexture;
retroFont(font: string, characterWidth: number, characterHeight: number, chars: string, charsPerRow: number, xSpacing?: number, ySpacing?: number, xOffset?: number, yOffset?: number): Phaser.RetroFont;
sound(key: string, volume?: number, loop?: number, connect?: boolean): Phaser.Sound;
sprite(x: number, y: number, key?: any, frame?: any, group?: Phaser.Group): Phaser.Sprite;
spriteBatch(parent: any, name?: string, addToStage?: boolean): Phaser.Group;
text(x: number, y: number, text: string, style: any, group?: Phaser.Group): Phaser.Text;
tilemap(key?: string, tileWidth?: number, tileHeight?: number, width?: number, height?: number): Phaser.Tilemap;
tileSprite(x: number, y: number, width: number, height: number, key?: any, frame?: any, group?: Phaser.Group): Phaser.TileSprite;
tween(obj: Object): Phaser.Tween;
}
class Gamepad {
constructor(game: Phaser.Game);
static BUTTON_0: number;
static BUTTON_1: number;
static BUTTON_2: number;
static BUTTON_3: number;
static BUTTON_4: number;
static BUTTON_5: number;
static BUTTON_6: number;
static BUTTON_7: number;
static BUTTON_8: number;
static BUTTON_9: number;
static BUTTON_10: number;
static BUTTON_11: number;
static BUTTON_12: number;
static BUTTON_13: number;
static BUTTON_14: number;
static BUTTON_15: number;
static AXIS_0: number;
static AXIS_1: number;
static AXIS_2: number;
static AXIS_3: number;
static AXIS_4: number;
static AXIS_5: number;
static AXIS_6: number;
static AXIS_7: number;
static AXIS_8: number;
static AXIS_9: number;
static XBOX360_A: number;
static XBOX360_B: number;
static XBOX360_X: number;
static XBOX360_Y: number;
static XBOX360_LEFT_BUMPER: number;
static XBOX360_RIGHT_BUMPER: number;
static XBOX360_LEFT_TRIGGER: number;
static XBOX360_RIGHT_TRIGGER: number;
static XBOX360_BACK: number;
static XBOX360_START: number;
static XBOX360_STICK_LEFT_BUTTON: number;
static XBOX360_STICK_RIGHT_BUTTON: number;
static XBOX360_DPAD_LEFT: number;
static XBOX360_DPAD_RIGHT: number;
static XBOX360_DPAD_UP: number;
static XBOX360_DPAD_DOWN: number;
static XBOX360_STICK_LEFT_X: number;
static XBOX360_STICK_LEFT_Y: number;
static XBOX360_STICK_RIGHT_X: number;
static XBOX360_STICK_RIGHT_Y: number;
static PS3XC_X: number;
static PS3XC_CIRCLE: number;
static PS3XC_SQUARE: number;
static PS3XC_TRIANGLE: number;
static PS3XC_L1: number;
static PS3XC_R1: number;
static PS3XC_L2: number;
static PS3XC_R2: number;
static PS3XC_SELECT: number;
static PS3XC_START: number;
static PS3XC_STICK_LEFT_BUTTON: number;
static PS3XC_STICK_RIGHT_BUTTON: number;
static PS3XC_DPAD_UP: number;
static PS3XC_DPAD_DOWN: number;
static PS3XC_DPAD_LEFT: number;
static PS3XC_DPAD_RIGHT: number;
static PS3XC_STICK_LEFT_X: number;
static PS3XC_STICK_LEFT_Y: number;
static PS3XC_STICK_RIGHT_X: number;
static PS3XC_STICK_RIGHT_Y: number;
active: boolean;
callbackContext: Object;
disabled: boolean;
game: Phaser.Game;
onAxisCallBack: Function;
onConnectCallback: Function;
onDisconnectCallback: Function;
onDownCallback: Function;
onFloatCallback: Function;
onUpCallback: Function;
pad1: Phaser.SinglePad;
pad2: Phaser.SinglePad;
pad3: Phaser.SinglePad;
pad4: Phaser.SinglePad;
padsConnected: number;
supported: boolean;
addCallbacks(context: Object, callbacks: Object): void;
isDown(buttonCode: number): boolean;
justPressed(buttonCode: number, duration?: number): boolean;
justReleased(buttonCode: number, duration?: number): boolean;
reset(): void;
setDeadZones(value: any): void;
start(): void;
stop(): void;
update(): void;
}
class GamepadButton {
constructor(pad: Phaser.SinglePad, buttonCode: number);
buttonCode: number;
duration: number;
game: Phaser.Game;
isDown: boolean;
isUp: boolean;
onDown: Phaser.Signal;
onFloat: Phaser.Signal;
onUp: Phaser.Signal;
pad: Phaser.Gamepad;
repeats: number;
timeDown: number;
timeUp: number;
value: number;
destroy(): void;
justPressed(duration?: number): boolean;
justReleased(duration?: number): boolean;
processButtonDown(value: number): void;
processButtonFloat(value: number): void;
processButtonUp(value: number): void;
reset();
}
class Graphics extends PIXI.Graphics {
constructor(game: Phaser.Game, x: number, y: number);
angle: number;
cameraOffset: Phaser.Point;
destroyPhase: boolean;
exists: boolean;
fixedToCamera: boolean;
game: Phaser.Game;
height: number;
name: string;
position: Phaser.Point;
type: number;
world: Phaser.Point;
z: number;
destroy(): void;
drawPolygon(poly: any): void;
drawTriangle(points: Phaser.Point[], cull?: boolean): void;
drawTriangles(vertices: any[], indices?: number[], cull?: boolean): void;
postUpdate(): void;
preUpdate(): void;
update(): void;
}
class Group extends PIXI.DisplayObjectContainer {
constructor(game: Phaser.Game, parent?: any, name?: string, addToStage?: boolean, enableBody?: boolean, physicsBodyType?: number);
static RETURN_CHILD: number;
static RETURN_NONE: number;
static RETURN_TOTAL: number;
static SORT_ASCENDING: number;
static SORT_DESCENDING: number;
angle: number;
alive: boolean;
cameraOffset: Phaser.Point;
classType: any;
cursor: any;
enableBody: boolean;
enableBodyDebug: boolean;
exists: boolean;
fixedToCamera: boolean;
game: Phaser.Game;
length: number;
name: string;
physicsBodyType: number;
position: Phaser.Point;
scale: Phaser.Point;
total: number;
type: number;
z: number;
add(child: any, silent?: boolean): any;
addAll(property: string, amount: number, checkAlive: boolean, checkVisible: boolean): void;
addAt(child: any, index: number, silent?: boolean): any;
bringToTop(child: any): any;
callAll(method: string, context: any, ...parameters: any[]): void;
callAllExists(callback: Function, existsValue: boolean, ...parameters: any[]): void;
callbackFromArray(child: Object, callback: Function, length: number): void;
countDead(): number;
countLiving(): number;
create(x: number, y: number, key: string, frame?: any, exists?: boolean): any;
createMultiple(quantity: number, key: string, frame?: any, exists?: boolean): void;
customSort(sortHandler: Function, context: Object): void;
destroy(destroyChildren?: boolean, soft?: boolean): void;
divideAll(property: string, amount: number, checkAlive?: boolean, checkVisible?: boolean): void;
forEach(callback: Function, callbackContext: Object, checkExists?: boolean): void;
forEachAlive(callback: Function, callbackContext: Object): void;
forEachDead(callback: Function, callbackContext: Object): void;
forEachExists(callback: Function, callbackContext: Object): void;
getAt(index: number): any;
getBottom(): any;
getFirstAlive(): any;
getFirstDead(): any;
getFirstExists(state: boolean): any;
getIndex(child: any): number;
getRandom(startIndex: number, length: number): any;
getTop(): any;
hasProperty(child: any, key: string[]): boolean;
iterate(key: string, value: any, returnType: number, callback?: Function, callbackContext?: Object, ...args: any[]): any;
moveDown(child: any): any;
moveUp(child: any): any;
multiplyAll(property: string, amount: number, checkAlive: boolean, checkVisible: boolean): void;
next(): void;
postUpdate(): void;
preUpdate(): void;
previous(): void;
remove(child: any, destroy?: boolean, silent?: boolean): boolean;
removeAll(destroy?: boolean, silent?: boolean): void;
removeBetween(startIndex: number, endIndex?: number, destroy?: boolean, silent?: boolean): void;
replace(oldChild: any, newChild: any): any;
reverse(): void;
sendToBack(child: any): any;
set(child: any, key: string[], value: any, operation?: number, force?: boolean): boolean;
setAll(key: string, value: any, checkAlive?: boolean, checkVisible?: boolean, operation?: number, force?:boolean): boolean;
setProperty(child: any, key: string[], value: any, operation?: number, force?: boolean): boolean;
sort(index?: string, order?: number): void;
subAll(property: string, amount: number, checkAlive: boolean, checkVisible: boolean): void;
swap(child1: any, child2: any): boolean;
update(): void;
updateZ(): void;
xy(index: number, x: number, y: number): void;
}
class Image extends PIXI.Sprite {
constructor(game: Phaser.Game, x: number, y: number, key: any, frame: any);
angle: number;
anchor: Phaser.Point;
autoCull: boolean;
cameraOffset: Phaser.Point;
cropRect: Phaser.Rectangle;
deltaX: number;
deltaY: number;
deltaZ: number;
destroyPhase: boolean;
events: Phaser.Events;
exists: boolean;
fixedToCamera: boolean;
frame: any;
frameName: string;
game: Phaser.Game;
inCamera: boolean;
input: Phaser.InputHandler;
inputEnabled: boolean;
inWorld: boolean;
key: any;
name: string;
position: Phaser.Point;
renderOrderID: number;
scale: Phaser.Point;
smoothed: boolean;
type: number;
z: number;
bringToTop(): Phaser.Image;
crop(rect: Phaser.Rectangle, copy: boolean): void;
destroy(destroyChildren?: boolean): void;
kill(): Phaser.Image;
loadTexture(key: any, frame: any): void;
postUpdate(): void;
preUpdate(): void;
reset(x: number, y: number): Phaser.Image;
resetFrame(): void;
revive(): Phaser.Image;
setFrame(frame: Phaser.Frame): void;
update(): void;
updateCrop(): void;
}
class Input {
constructor(game: Phaser.Game);
static MOUSE_OVERRIDES_TOUCH: number;
static MOUSE_TOUCH_COMBINE: number;
static TOUCH_OVERRIDES_MOUSE: number;
activePointer: Phaser.Pointer;
circle: Phaser.Circle;
currentPointers: number;
disabled: boolean;
doubleTapRate: number;
game: Phaser.Game;
gamepad: Phaser.Gamepad;
hitCanvas: HTMLCanvasElement;
hitContext: CanvasRenderingContext2D;
holdRate: number;
interactiveItems: Phaser.ArrayList;
justPressedRate: number;
justReleasedRate: number;
keyboard: Phaser.Keyboard;
maxPointers: number;
minPriorityID: number;
mouse: Phaser.Mouse;
mousePointer: Phaser.Pointer;
moveCallback: Function;
moveCallbacks: Function[];
moveCallbackContext: Object;
mspointer: Phaser.MSPointer;
multiInputOverride: number;
onDown: Phaser.Signal;
onHold: Phaser.Signal;
onTap: Phaser.Signal;
onUp: Phaser.Signal;
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;
pollLocked: boolean;
pollRate: number;
position: Phaser.Point;
recordLimit: number;
recordPointerHistory: boolean;
recordRate: number;
resetLocked: boolean;
scale: Phaser.Point;
speed: Phaser.Point;
tapRate: number;
totalActivePointers: number;
totalInactivePointers: number;
touch: Phaser.Touch;
worldX: number;
worldY: number;
x: number;
y: number;
addPointer(): Phaser.Pointer;
boot(): void;
deleteMoveCallback(index: number): void;
destroy(): void;
getLocalPosition(displayObject: any, pointer: Phaser.Pointer): Phaser.Point;
getPointer(state: boolean): Phaser.Pointer;
getPointerFromId(pointerID: number): Phaser.Pointer;
getPointerFromIdentifier(identifier: number): Phaser.Pointer;
hitTest(displayObject: any, pointer: Phaser.Pointer, localPoint: Phaser.Point): void;
reset(hard?: boolean): void;
resetSpeed(x: number, y: number): void;
setMoveCallback(callBack: Function, callbackContext: Object): void;
startPointer(event: any): Phaser.Pointer;
stopPointer(event: any): Phaser.Pointer;
update(): void;
updatePointer(event: any): Phaser.Pointer;
}
class InputHandler extends Phaser.LinkedListItem {
constructor(sprite: Phaser.Sprite);
allowHorizontalDrag: boolean;
allowVerticalDrag: boolean;
boundsRect: Phaser.Rectangle;
boundsSprite: Phaser.Sprite;
bringToTop: boolean;
consumePointerEvent: boolean;
draggable: boolean;
enabled: boolean;
game: Phaser.Game;
isDragged: boolean;
pixelPerfectAlpha: number;
pixelPerfectClick: boolean;
pixelPerfectOver: boolean;
priorityID: number;
snapOffset: Phaser.Point;
snapOffsetX: number;
snapOffsetY: number;
snapOnDrag: boolean;
snapOnRelease: boolean;
snapX: number;
snapY: number;
sprite: Phaser.Sprite;
useHandCursor: boolean;
checkBoundsRect(): void;
checkBoundsSprite(): void;
checkPixel(x: number, y: number, pointer?: Phaser.Pointer): boolean;
checkPointerDown(pointer: Phaser.Pointer, fastTest?: boolean): boolean;
checkPointerOver(pointer: Phaser.Pointer, fastTest?: boolean): boolean;
destroy(): void;
disableDrag(): void;
disableSnap(): void;
downDuration(pointer: Phaser.Pointer): number;
enableDrag(lockCenter?: boolean, bringToTop?: boolean, pixelPerfect?: boolean, alphaThreshold?: number, boundsRect?: Phaser.Rectangle, boundsSprite?: Phaser.Rectangle): void;
enableSnap(snapX: number, snapY: number, onDrag?: boolean, onRelease?: boolean, snapOffsetX?: number, snapOffsetY?: number): void;
isPixelPerfect(): boolean;
justOut(pointer: number, delay: number): boolean;
justOver(pointer: number, delay: number): boolean;
justPressed(pointer: number, delay: number): boolean;
justReleased(pointer: number, delay: number): boolean;
overDuration(pointer: Phaser.Pointer): number;
pointerDown(pointer: Phaser.Pointer): boolean;
pointerDragged(pointer: Phaser.Pointer): boolean;
pointerOut(index?: number): boolean;
pointerOver(index?: number): boolean;
pointerTimeDown(pointer: Phaser.Pointer): number;
pointerTimeOut(pointer: Phaser.Pointer): number;
pointerTimeOver(pointer: Phaser.Pointer): number;
pointerTimeUp(pointer: Phaser.Pointer): number;
pointerUp(pointer: Phaser.Pointer): boolean;
pointerX(pointer: Phaser.Pointer): number;
pointerY(pointer: Phaser.Pointer): number;
reset(): void;
setDragLock(allowHorizontal?: boolean, allowVertical?: boolean): void;
start(priority: number, useHandCursor: boolean): Phaser.Sprite;
startDrag(pointer: Phaser.Pointer): void;
stop(): void;
stopDrag(pointer: Phaser.Pointer): void;
update(pointer: Phaser.Pointer): void;
updateDrag(pointer: Phaser.Pointer): boolean;
validForInput(highestID: number, highestRenderID: number): boolean;
}
class Key {
constructor(game: Phaser.Game, keycode: number);
altKey: boolean;
ctrlKey: boolean;
duration: number;
event: Object;
game: Phaser.Game;
isDown: boolean;
isUp: boolean;
keyCode: number;
onDown: Phaser.Signal;
onHoldCallback: Function;
onHoldContext: Object;
onUp: Phaser.Signal;
repeats: number;
shiftKey: boolean;
timeDown: number;
timeUp: number;
justPressed(duration?: number): boolean;
justReleased(duration?: number): boolean;
processKeyDown(event: KeyboardEvent): void;
processKeyUp(event: KeyboardEvent): void;
reset(hard?: boolean): void;
update(): void;
}
class Keyboard {
constructor(game: Phaser.Game);
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;
callbackContext: Object;
disabled: boolean;
event: Object;
game: Phaser.Game;
lastChar: string;
lastKey: string;
onDownCallback: Function;
onPressCallback: Function;
onUpCallback: Function;
pressEvent: Object;
addCallbacks(context: Object, onDown?: Function, onUp?: Function, onPress?: Function): void;
addKey(keycode: number): Phaser.Key;
addKeyCapture(keycode: any): void;
createCursorKeys(): Phaser.CursorKeys;
clearCaptures(): void;
destroy(): void;
isDown(keycode: number): boolean;
justPressed(keycode: number, duration?: number): boolean;
justReleased(keycode: number, duration?: number): boolean;
processKeyDown(event: KeyboardEvent): void;
processKeyPress(event: KeyboardEvent): void;
processKeyUp(event: KeyboardEvent): void;
removeKey(keycode: number): void;
removeKeyCapture(keycode: number): void;
reset(hard?: boolean): void;
start(): void;
stop(): void;
update(): void;
}
class Line {
constructor(x1?: number, y1?: number, x2?: number, y2?: number);
angle: number;
end: Phaser.Point;
height: number;
left: number;
length: number;
perpSlope: number;
right: number;
slope: number;
start: Phaser.Point;
top: number;
width: number;
x: number;
y: 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;
coordinatesOnLine(stepRate: number, results: any[]): any[];
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;
setTo(x1?: number, y1?: number, x2?: number, y2?: number): Phaser.Line;
}
class LinkedListItem {
next: LinkedListItem;
prev: LinkedListItem;
first: LinkedListItem;
last: LinkedListItem;
}
class LinkedList extends LinkedListItem {
first: LinkedListItem;
last: LinkedListItem;
next: LinkedListItem;
prev: LinkedListItem;
total: number;
add(child: LinkedListItem): LinkedListItem;
callAll(callback: Function): void;
remove(child: LinkedListItem): void;
reset(): void;
}
class Loader {
constructor(game: Phaser.Game);
static PHYSICS_LIME_CORONA_JSON: number;
static PHYSICS_PHASER_JSON: number;
static TEXTURE_ATLAS_JSON_ARRAY: number;
static TEXTURE_ATLAS_JSON_HASH: number;
static TEXTURE_ATLAS_XML_STARLING: number;
baseURL: string;
crossOrigin: any;
game: Phaser.Game;
hasLoaded: boolean;
isLoading: boolean;
onFileStart: Phaser.Signal;
onFileComplete: Phaser.Signal;
onFileError: Phaser.Signal;
onLoadComplete: Phaser.Signal;
onLoadStart: Phaser.Signal;
preloadSprite: any;
progress: number;
progressFloat: number;
addToFileList(type: string, key: string, url: string, properties: any): void;
atlas(key: string, textureURL: string, atlasURL?: string, atlasData?: Object, format?: number): Phaser.Loader;
atlasJSONArray(key: string, textureURL: string, atlasURL?: string, atlasData?: Object): Phaser.Loader;
atlasJSONHash(key: string, textureURL: string, atlasURL?: string, atlasData?: Object): Phaser.Loader;
atlasXML(key: string, textureURL: string, atlasURL?: string, atlasData?: Object): Phaser.Loader;
audio(key: string, urls: any, autoDecode?: boolean): Phaser.Loader;
binary(key: string, url: string, callback?: Function, callbackContext?: Function): Phaser.Loader;
bitmapFont(key: string, textureURL: string, xmlURL?: string, xmlData?: Object, xSpacing?: number, ySpacing?: number): Phaser.Loader;
checkKeyExists(type: string, key: string): boolean;
csvLoadComplete(index: number): void;
dataLoadError(index: number): void;
fileComplete(index: number): void;
fileError(index: number): void;
getAsset(type: string, key: string): any;
getAssetIndex(type: string, key: string): number;
image(key: string, url: string, overwrite?: boolean): Phaser.Loader;
json(key: string, url: string, overwrite?: boolean): Phaser.Loader;
jsonLoadComplete(index: number): void;
pack(key: string, url?: string, data?: Object, callbackContext?: any): Phaser.Loader;
physics(key: string, url?: string, data?: Object, format?: string): Phaser.Loader;
removeAll(): void;
removeFile(key: string, type: string): void;
replaceInFileList(type: string, key: string, url: string, properties: Object): void;
reset(): void;
script(key: string, url: String, callback?: Function, callbackContext?: Object): Phaser.Loader;
setPreloadSprite(sprite: Phaser.Sprite, direction?: number): void;
spritesheet(key: string, url: string, frameWidth: number, frameHeight: number, frameMax?: number, margin?: number, spacing?: number): Phaser.Loader;
start(): void;
text(key: string, url: string, overwrite?: boolean): Phaser.Loader;
tilemap(key: string, url?: string, data?: Object, format?: number): Phaser.Loader;
totalLoadedFiles(): number;
totalLoadedPacks(): number;
totalQueuedFiles(): number;
totalQueuedPacks(): number;
xmlLoadComplete(index: number): void;
}
class LoaderParser {
static bitmapFont(game: Phaser.Game, xml: Object, cacheKey: string, xSpacing: number, ySpacing: number): Phaser.FrameData;
}
class Math {
static angleBetween(x1: number, y1: number, x2: number, y2: number): number;
static angleBetweenPoints(point1: Phaser.Point, point2: Phaser.Point): number;
static angleLimit(angle: number, min: number, max: number): number;
static average(...numbers: number[]): number;
static bernstein(n: number, i: number): number;
static bezierInterpolation(v: number[], k: number): number;
static catmullRom(p0: number, p1: number, p2: number, p3: number, t: number): number;
static catmullRomInterpolation(v: number[], k: number): number;
static ceil(value: number): number;
static ceilTo(value: number, place?: number, base?: number): number;
static chanceRoll(chance: number): boolean;
static clamp(x: number, a: number, b: number): number;
static clampBottom(x: number, a: number): number;
static degToRad(degrees: number): number;
static difference(a: number, b: number): number;
static distance(x1: number, y1: number, x2: number, y2: number): number;
static distancePow(xy: number, y1: number, x2: number, y2: number, pow?: number): number;
static distanceRounded(x1: number, y1: number, x2: number, y2: number): number;
static factorial(value: number): number;
static floor(value: number): number;
static floorTo(value: number, place: number, base: number): number;
static fuzzyCeil(val: number, epsilon?: number): boolean;
static fuzzyEqual(a: number, b: number, epsilon?: number): boolean;
static fuzzyLessThan(a: Number, b: number, epsilon?: number): boolean;
static fuzzyFloor(val: number, epsilon?: number): boolean;
static fuzzyGreaterThan(a: number, b: number, epsilon?: number): boolean;
static fuzzyLessThan(a: number, b: number, epsilon?: number): boolean;
static getRandom<T>(objects: T[], startIndex?: number, length?: number): T;
static interpolateAngles(a1: number, a2: number, weight: number, radians?: boolean, ease?: any): number;
static interpolateFloat(a: number, b: number, weight: number): number;
static isEven(n: number): boolean;
static isOdd(n: number): boolean;
static linear(p0: number, p1: number, t: number): number;
static linearInterpolation(v: number[], k: number): number;
static limitValue(value: number, min: number, max: number): number;
static mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number;
static max(...numbers: number[]): number;
static maxAdd(value: number, amount: number, max: number): number;
static maxProperty(...numbers: number[]): number;
static min(...numbers: number[]): number;
static minProperty(...numbers: number[]): number;
static minSub(value: number, amount: number, min: number): number;
static nearestAngleBetween(a1: number, a2: number, radians?: boolean): number;
static normalizeAngle(angle: number, radians?: boolean): number;
static normalizeLatitude(lat: number): number;
static normalizeLongitude(lng: number): number;
static numberArray(min: number, max: number): number[];
static percent(a: number, b: number, base?: number): number;
static p2px(v: number): number;
static PI2: number;
static radToDeg(radians: number): number;
static randomSign(): number;
static reverseAngle(angleRed: number): number;
static removeRandom<T>(objects: T[], startIndex?: number, length?: number): T;
static roundTo(value: number, place?: number, base?: number): number;
static shear(n: number): number;
static shift(stack: any[]): any;
static shuffleArray(array: any[]): any[];
static sign(x: number): number;
static sinCosGenerator(length: number, sinAmplitude?: number, cosAmplitude?: number, frequency?: number): { sin: number[]; cos: number[]; };
static smootherstep(x: number, min: number, max: number): number;
static smoothstep(x: number, min: number, max: number): number;
static snapTo(input: number, gap: number, start?: number): number;
static snapToCeil(input: number, gap: number, start?: number): number;
static snapToFloor(input: number, gap: number, start?: number): number;
static snapToInArray(input: number, arr: number[], sort?: boolean): number;
static truncate(n: number): number;
static within(a: number, b: number, tolerance: number): boolean;
static wrap(value: number, min: number, max: number): number;
static wrapAngle(angle: number, radians?: boolean): number;
static wrapValue(value: number, amount: number, max: number): number;
}
class Mouse {
constructor(game: Phaser.Game);
static LEFT_BUTTON: number;
static MIDDLE_BUTTON: number;
static NO_BUTTON: number;
static RIGHT_BUTTON: number;
static WHEEL_DOWN: number;
static WHEEL_UP: number;
button: number;
callbackContext: Object;
capture: boolean;
disabled: boolean;
event: MouseEvent;
game: Phaser.Game;
locked: boolean;
mouseDownCallback: Function;
mouseMoveCallback: Function;
mouseOutCallback: Function;
mouseOverCallback: Function;
mouseUpCallback: Function;
mouseWheelCallback: Function;
pointerLock: Phaser.Signal;
stopOnGameOut: boolean;
wheelDelta: number;
onMouseDown(event: MouseEvent): void;
onMouseMove(event: MouseEvent): void;
onMouseOut(event: MouseEvent): void;
onMouseOver(event: MouseEvent): void;
onMouseUp(event: MouseEvent): void;
onMouseWheel(event: MouseEvent): void;
pointerLockChange(event: MouseEvent): void;
releasePointerLock(): void;
requestPointerLock(): void;
start(): void;
stop(): void;
}
class MSPointer {
constructor(game: Phaser.Game);
callbackContext: Object;
disabled: boolean;
game: Phaser.Game;
onPointerDown(event: MSPointerEvent): void;
onPointerMove(event: MSPointerEvent): void;
onPointerUp(event: MSPointerEvent): void;
mouseDownCallback(event: MSPointerEvent): void;
mouseMoveCallback(event: MSPointerEvent): void;
mouseUpCallback(event: MSPointerEvent): void;
start(): void;
stop(): void;
}
class Net {
constructor(game: Phaser.Game);
game: Phaser.Game;
checkDomainName(domain: string): boolean;
decodeURI(value: string): string;
getHostName(): string;
getQueryString(parameter?: string): string;
updateQueryString(key: string, value: any, redirect?: boolean, url?: string): string;
}
class Particle extends Phaser.Sprite {
constructor(game: Phaser.Game, x: number, y: number, key?: any, frame?: any);
onEmit(): void;
reset(x: number, y: number, health?: number): Phaser.Particle;
setAlphaData(data: any[]): void;
setScaleData(data: any[]): void;
update(): void;
}
class Particles {
constructor(game: Phaser.Game);
emitters: Object;
game: Phaser.Game;
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);
alphaData: any[];
autoAlpha: boolean;
autoScale: boolean;
angle: number;
angularDrag: number;
bottom: number;
bounce: Phaser.Point;
emitX: number;
emitY: number;
exists: boolean;
frequency: number;
gravity: number;
group: Phaser.Group;
height: number;
left: number;
lifespan: number;
maxParticles: number;
maxParticleScale: number;
maxParticleSpeed: Phaser.Point;
maxRotation: number;
minParticleScale: number;
minParticleSpeed: Phaser.Point;
minRotation: number;
name: string;
on: boolean;
particleBringToTop: boolean;
particleSendToBack: boolean;
particleClass: Phaser.Sprite;
particleDrag: Phaser.Point;
position: Phaser.Point;
right: number;
scaleData: any[];
top: number;
type: number;
width: number;
x: number;
y: number;
at(object: any): void;
emitParticle(): void;
explode(lifespan?: number, quantity?: number): void;
flow(lifespan?: number, frequency?: number, quantity?: number): void;
kill(): void;
makeParticles(keys: any, frames?: any, quantity?: number, collide?: boolean, collideWorldBounds?: boolean): Phaser.Particles.Arcade.Emitter;
reset(x: number, y: number, health?: number): Phaser.Particles;
setAlpha(min?: number, max?: number, rate?: number, ease?: number, yoyo?: boolean): void;
setRotation(min?: number, max?: number): void;
setScale(min?: number, max?: number, rate?: number, ease?: number, yoyo?: boolean): void;
setSize(width: number, height: number): void;
setXSpeed(min: number, max: number): void;
setYSpeed(min: number, max: number): void;
start(explode?: boolean, lifespan?: number, frequency?: number, quantity?: number, forceQuantity?: boolean): void;
update(): void;
revive(): void;
}
}
}
class Physics {
constructor(game: Phaser.Game, config?: Object);
static ARCADE: number;
static P2JS: number;
static NINJA: number;
static BOX2D: number;
static CHIPMUNK: number;
arcade: Phaser.Physics.Arcade;
config: Object;
game: Phaser.Game;
ninja: Phaser.Physics.Ninja;
p2: Phaser.Physics.P2;
clear(): void;
destroy(): void;
enable(object: any, system?: number, debug?: boolean): void;
parseConfig(): void;
preUpdate(): void;
setBoundsToWorld(): void;
startSystem(system: number): void;
update(): void;
}
module Physics {
class Arcade {
static OVERLAP_BIAS: number;
static TILE_BIAS: number;
constructor(game: Phaser.Game);
bounds: Phaser.Rectangle;
checkCollision: { up?: boolean; down?: boolean; left?: boolean; right?: boolean; };
forceX: boolean;
game: Phaser.Game;
gravity: Phaser.Point;
quadTree: Phaser.QuadTree;
maxObjects: number;
maxLevels: number;
accelerationFromRotation(rotation: number, speed?: number, point?: Phaser.Point): Phaser.Point;
accelerateToObject(displayObject: any, destination: any, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number;
accelerateToPointer(displayObject: any, pointer?: Phaser.Pointer, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number;
accelerateToXY(displayObject: any, x: number, y: number, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number;
angleBetween(source: any, target: any): number;
angleToPointer(displayObject: any, pointer?: Phaser.Pointer): number;
angleToXY(displayObject: any, x: number, y: number): number;
collide(object1: Object, object2: Object, collideCallback?: Function, processCallback?: Function, callbackContext?: Object): boolean;
computeVelocity(axis: number, body: Phaser.Physics.Arcade.Body, velocity: number, acceleration: number, drag: number, max?: number): number;
distanceBetween(source: any, target: any): number;
distanceToPointer(displayObject: any, pointer?: Phaser.Pointer): number;
distanceToXY(displayObject: any, x: number, y: number): number;
enable(object: Object, children?: Boolean): void;
enableBody(object: Object): void;
intersects(body1: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body): boolean;
moveToObject(displayObject: any, destination: any, speed?: number, maxTime?: number): number;
moveToPointer(displayObject: any, speed?: number, pointer?: Phaser.Pointer, maxTime?: number): number;
moveToXY(displayObject: any, x: number, y: number, speed?: number, maxTime?: number): number;
overlap(object1: Object, object2: Object, overlapCallback?: Function, processCallback?: Function, callbackContext?: Object): boolean;
processTileSeparationX(body: Phaser.Physics.Arcade.Body, x: number): boolean;
processTileSeparationY(body: Phaser.Physics.Arcade.Body, y: number): void;
setBounds(x: number, y: number, width: number, height: number): void;
setBoundsToWorld(): void;
separate(body1: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body, processCallback?: Function, callbackContext?: Object, overlapOnly?: boolean): boolean;
separateX(body1: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body, overlapOnly: boolean): boolean;
separateY(body1: Phaser.Physics.Arcade.Body, body2: Phaser.Physics.Arcade.Body, overlapOnly: boolean): boolean;
separateTile(i: number, body: Phaser.Physics.Arcade.Body, tile: Phaser.Tile): boolean;
tileCheckX(body: Phaser.Physics.Arcade.Body, tile: Phaser.Tile): number;
tileCheckY(body: Phaser.Physics.Arcade.Body, tile: Phaser.Tile): number;
updateMotion(body: Phaser.Physics.Arcade.Body): void;
velocityFromAngle(angle: number, speed?: number, point?: Phaser.Point): Phaser.Point;
velocityFromRotation(rotation: number, speed?: number, point?: Phaser.Point): Phaser.Point;
}
module Arcade {
class Body {
constructor(sprite: Phaser.Sprite);
acceleration: Phaser.Point;
allowGravity: boolean;
allowRotation: boolean;
angle: number;
angularAcceleration: number;
angularDrag: number;
angularVelocity: number;
blocked: FaceChoices;
bottom: number;
bounce: Phaser.Point;
center: Phaser.Point;
checkCollision: FaceChoices;
collideWorldBounds: boolean;
customSeparateX: boolean;
customSeparateY: boolean;
deltaMax: Phaser.Point;
draw: Phaser.Point;
embedded: boolean;
enable: boolean;
facing: number;
game: Phaser.Game;
gravity: Phaser.Point;
halfWidth: number;
halfHeight: number;
immovable: boolean;
mass: number;
maxAngular: number;
maxVelocity: Phaser.Point;
moves: boolean;
newVelocity: Phaser.Point;
offset: Phaser.Point;
overlapX: number;
overlapY: number;
phase: number;
position: Phaser.Point;
preRotation: number;
prev: Phaser.Point;
right: number;
rotation: number;
skipQuadTree: boolean;
sourceWidth: number;
sourceHeight: number;
speed: number;
sprite: Phaser.Sprite;
tilePadding: Phaser.Point;
touching: FaceChoices;
type: number;
wasTouching: FaceChoices;
width: number;
velocity: Phaser.Point;
x: number;
y: number;
checkWorldBounds(): void;
deltaX(): number;
deltaY(): number;
deltaZ(): number;
deltaAbsX(): void;
deltaAbsY(): void;
destroy(): void;
hitTest(x: number, y: number): boolean;
onFloor(): void;
onWall(): void;
preUpdate(): void;
postUpdate(): void;
render(context: Object, body: Phaser.Physics.Arcade.Body, color?: string, filled?: boolean): void;
renderBodyInfo(debug: Phaser.Utils.Debug, body: Phaser.Physics.Arcade.Body): void;
reset(x: number, y: number): void;
setSize(width: number, height: number, offsetX?: number, offsetY?: number): void;
updateBounds(): boolean;
}
class FaceChoices {
none: boolean;
any: boolean;
up: boolean;
down: boolean;
left: boolean;
right: boolean;
}
}
class Ninja {
constructor(game: Phaser.Game);
game: Phaser.Game
gravity: number;
bounds: Phaser.Rectangle;
maxObjects: number;
maxLevels: number;
quadTree: Phaser.QuadTree;
time: Phaser.Time;
clearTilemapLayerBodies(map: Phaser.Tilemap, layer: any): void;
collide(object1: any, object2: any, collideCallback?: Function, processCallback?: Function, callbackContext?: Object): boolean;
convertTilemap(map: Phaser.Tilemap, layer?: any, slopeMap?: Object): Phaser.Physics.Ninja.Tile[];
enableAABB(object: any, children?: boolean): void;
enableCircle(object: any, radius: number, children?: boolean);
enableTile(object: any, id: number, children?: boolean): void;
enable(object: any, type?: number, id?: number, radius?: number, children?: boolean): void;
enableBody(object: any, type?: number, id?: number, radius?: number): void;
overlap(object1: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: Object): boolean;
separate(body1: Phaser.Physics.Ninja.Body, body2: Phaser.Physics.Ninja.Body, processCallback?: Function, callbackContext?: Object, overlapOnly?: boolean): boolean;
setBounds(x: number, y: number, width: number, height: number): void;
setBoundsToWorld(): void;
}
module Ninja {
class Body {
constructor(system: Phaser.Physics.Ninja, sprite: Phaser.Sprite, type?: number, id?: number, radius?: number, x?: number, y?: number, width?: number, height?: number);
aabb: Phaser.Physics.Ninja.AABB;
angle: number;
bottom: number;
bounce: number;
checkCollision: Phaser.Physics.Arcade.FaceChoices;
circle: Phaser.Physics.Ninja.Circle;
collideWorldBounds: boolean;
drag: number;
facing: number;
friction: number;
game: Phaser.Game;
gravityScale: number;
height: number;
immovable: boolean;
maxSpeed: number;
right: number;
sprite: Phaser.Sprite;
system: Phaser.Physics.Ninja;
tile: Phaser.Physics.Ninja.Tile;
touching: Phaser.Physics.Arcade.FaceChoices;
type: number;
shape: Object;
speed: number;
velocity: Phaser.Point;
wasTouching: Phaser.Physics.Arcade.FaceChoices;
width: number;
x: number;
y: number;
deltaAbsX(): number;
deltaAbsY(): number;
deltaX(): number;
deltaY(): number;
destroy(): void;
setZeroVelocity(): void;
moveTo(speed: number, angle: number): void;
moveFrom(speed: number, angle: number): void;
moveLeft(speed: number): void;
moveRight(speed: number): void;
moveUp(speed: number): void;
moveDown(speed: number): void;
poseUpdate(): void;
preUpdate(): void;
render(context: any, body: Phaser.Physics.Ninja.Body, color?: string, filled?: boolean): void;
reset(): void;
}
class AABB {
constructor(body: Phaser.Physics.Ninja.Body, x: number, y: number, width: number, height: number);
static COL_NONE: number;
static COL_AXIS: number;
static COL_OTHER: number;
aabbTileProjections: Object;
body: Phaser.Physics.Ninja.Body;
height: number;
oldPos: Phaser.Point;
pos: Phaser.Point;
system: Phaser.Physics.Ninja;
width: number;
velocity: Phaser.Point;
xw: number;
yw: number;
collideWorldBounds(): void;
collideAABBVsAABB(aabb: Phaser.Physics.Ninja.AABB): boolean;
collideAABBVsTile(tile: Phaser.Physics.Ninja.Tile): boolean;
destroy(): void;
integrate(): void;
render(context: any, xOffset: number, yOffset: number, color: string, filled: boolean): void;
reportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: Object): void;
reportCollisionVsBody(px: number, py: number, dx: number, dy: number, obj: Object): void;
resolveTile(x: number, y: number, body: Phaser.Physics.Ninja.AABB, tile: Phaser.Physics.Ninja.Tile): boolean;
reverse(): void;
}
class Circle {
constructor(body: Phaser.Physics.Ninja.Body, x: number, y: number, radius: number);
COL_NONE: number;
COL_AXIS: number;
COL_OTHER: number;
body: Phaser.Physics.Ninja.Body;
circleTileProjections: Object;
oldPos: Phaser.Point;
height: number;
pos: Phaser.Point;
radius: number;
system: Phaser.Physics.Ninja;
velocity: Phaser.Point;
width: number;
xw: number;
yw: number;
collideCircleVsTile(tile: Phaser.Physics.Ninja.Tile): boolean;
collideWorldBounds(): void;
destroy(): void;
integrate(): void;
render(context: any, xOffset: number, yOffset: number, color: string, filled: boolean): void;
reportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: Object): void;
reportCollisionVsBody(px: number, py: number, dx: number, dy: number, obj: Object): void;
resolveCircleTile(x: number, y: number, oH: number, oV: number, obj: Phaser.Physics.Ninja.Circle, t: Phaser.Physics.Ninja.Tile): boolean;
}
class Tile {
constructor(body: Phaser.Physics.Ninja.Body, x: number, y: number, width: number, height: number, type?: number);
body: Phaser.Physics.Ninja.Body;
bottom: number;
height: number;
id: number;
oldpos: Phaser.Point;
pos: Phaser.Point;
right: number;
system: Phaser.Physics.Ninja;
type: number;
velocity: Phaser.Point;
width: number;
xw: number;
yw: number;
x: number;
y: number;
clear(): void;
collideWorldBounds(): void;
destroy(): void;
integrate(): void;
reportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: Object);
setType(id: number): number;
}
}
class P2 {
static LIME_CORONA_JSON: number;
constructor(game: Phaser.Game, config?: Object);
applyDamping: boolean;
applyGravity: boolean;
applySpringForced: boolean;
bounds: Phaser.Physics.P2.Body;
boundsCollidesWith: Phaser.Physics.P2.Body[];
boundsCollisionGroup: Phaser.Physics.P2.CollisionGroup;
contactMaterial: Phaser.Physics.P2.ContactMaterial;
emitImpactEvent: boolean;
enableBodySleeping: boolean;
everythingCollisionGroup: Phaser.Physics.P2.CollisionGroup;
frameRate: number;
friction: number;
game: Phaser.Game;
gravity: Phaser.Physics.P2.InversePointProxy;
materials: Phaser.Physics.P2.Material[];
nothingCollisionGroup: Phaser.Physics.P2.CollisionGroup;
onBodyAdded: Phaser.Signal;
onBodyRemoved: Phaser.Signal;
onBeginContact: Phaser.Signal;
onConstraintAdded: Phaser.Signal;
onConstraintRemoved: Phaser.Signal;
onContactMaterialAdded: Phaser.Signal;
onContactMaterialRemoved: Phaser.Signal;
onEndContact: Phaser.Signal;
onSpringAdded: Phaser.Signal;
onSpringRemoved: Phaser.Signal;
paused: boolean;
restitution: number;
solveConstraints: boolean;
time: any;
total: number;
useElapsedTime: boolean;
world: Phaser.Physics.P2;
addBody(body: Phaser.Physics.P2.Body): boolean;
addContactMaterial(material: Phaser.Physics.P2.ContactMaterial): Phaser.Physics.P2.ContactMaterial;
addConstraint(constraint: any): any;
addSpring(spring: Phaser.Physics.P2.Spring): Phaser.Physics.P2.Spring;
beginContactHandler(event: Object): void;
clear(): void;
clearTilemapLayerBodies(map: Phaser.Tilemap, layer?: any): void;
convertCollisionObjects(map: Phaser.Tilemap, layer?: any, addToWorld?: boolean): Phaser.Physics.P2.Body[];
convertTilemap(map: Phaser.Tilemap, layer?: any, addToWorld?: Boolean, optimize?: boolean): Phaser.Physics.P2.Body[];
createBody(x: number, y: number, mass: number, addToWorld?: boolean, options?: Object, data?: Object): Phaser.Physics.P2.Body;
createCollisionGroup(group?: Phaser.Group): Phaser.Physics.P2.CollisionGroup;
createCollisionGroup(group?: Phaser.Sprite): Phaser.Physics.P2.CollisionGroup;
createContactMaterial(materialA: Phaser.Physics.P2.Material, materialB: Phaser.Physics.P2.Material, options?: number): Phaser.Physics.P2.ContactMaterial;
createDistanceConstraint(bodyA: any, bodyB: any, distance: number, maxForce?: number): Phaser.Physics.P2.DistanceConstraint;
createGearConstraint(bodyA: any, bodyB: any, angle?: number, ratio?: number): Phaser.Physics.P2.GearConstraint;
createLockConstraint(bodyA: any, bodyB: any, offset: Float32Array, angle?: number, maxForce?: number): Phaser.Physics.P2.LockConstraint;
createMaterial(name?: string, body?: Phaser.Physics.P2.Body): Phaser.Physics.P2.Material;
createParticle(x: number, y: number, mass: number, addToWorld?: Boolean, options?: Object, data?: Object): Phaser.Physics.P2.Body;
createPrismaticConstraint(body: any, bodyB: any, lockRotation?: boolean, anchorA?: Float32Array, anchorB?: Float32Array, axis?: Float32Array, maxForce?: number): Phaser.Physics.P2.PrismaticConstraint;
createRevoluteConstraint(bodyA: any, pivotA: Float32Array, bodyB: any, pivotB: Float32Array, maxForce?: number): Phaser.Physics.P2.RevoluteContraint;
createSpring(bodyA: any, bodyB: any, restLength?: number, stiffness?: number, damping?: number, worldA?: Float32Array, worldB?: Float32Array, localA?: Float32Array, localB?: Float32Array): Phaser.Physics.P2.Spring;
destroy(): void;
enable(object: any, debug?: boolean, children?: boolean): void;
enableBody(object: Object, debug: boolean): void;
endContactHandler(event: Object): void;
getBodies(): Phaser.Physics.P2.Body[];
getBody(object: Object): Phaser.Physics.P2.Body;
getConstraints(): any[];
getSprings(): Phaser.Physics.P2.Spring[];
getContactMaterial(materialA: Phaser.Physics.P2.Material, materialB: Phaser.Physics.P2.Material): Phaser.Physics.P2.ContactMaterial;
hitTest(worldPoint: Phaser.Point, bodies?: any[], precision?: number, filterStatic?: boolean): Phaser.Physics.P2.Body[];
mpx(v: number): number;
mpxi(v: number): number;
pause(): void;
preUpdate(): void;
pxm(v: number): number;
pxmi(v: number): number;
removeBody(body: Phaser.Physics.P2.Body): Phaser.Physics.P2.Body;
removeBodyNextStep(body: Phaser.Physics.P2.Body): void;
removeConstraint(constraint: any): any;
removeContactMaterial(material: Phaser.Physics.P2.ContactMaterial);
removeSpring(spring: Phaser.Physics.P2.Spring): Phaser.Physics.P2.Spring;
resume(): void;
setBounds(x: number, y: number, width: number, height: number, left?: Boolean, right?: boolean, top?: boolean, bottom?: boolean, setCollisionGroup?: boolean): void;
setBoundsToWorld(left?: boolean, right?: boolean, top?: boolean, bottom?: boolean, setCollisionGroup?: boolean): void;
setCollisionGroup(object: Object, group: Phaser.Physics.P2.CollisionGroup): void;
setImpactEvents(state: boolean): void;
setMaterial(material: Phaser.Physics.P2.Material): Phaser.Physics.P2.Body[];
setPostBroadphaseCallback(callback: Function, context: Object): void;
setWorldMaterial(material: Phaser.Physics.P2.Material, left?: boolean, right?: boolean, top?: boolean, bottom?: boolean): void;
toJSON(): Object;
update(): void;
updateBoundsCollisionGroup(setCollisionGroup?: boolean): void;
}
module P2 {
class Body {
static DYNAMIC: number;
static STATIC: number;
static KINEMATIC: number;
constructor(game: Phaser.Game, sprite?: Phaser.Sprite, x?: number, y?: number, mass?: number);
allowSleep: boolean;
angle: number;
angularDamping: number;
angularForce: number;
angularVelocity: number;
collideWorldBounds: boolean;
damping: number;
data: Phaser.Physics.P2.Body;
debug: boolean;
debugBody: Phaser.Physics.P2.BodyDebug;
fixedRotation: boolean;
force: Phaser.Physics.P2.InversePointProxy;
game: Phaser.Game;
gravity: Phaser.Point;
id: number;
inertia: number;
kinematic: boolean;
mass: number;
motionState: number;
offset: Phaser.Point;
onBeginContact: Phaser.Signal;
onEndContact: Phaser.Signal;
onImpact: Phaser.Signal;
rotation: number;
sprite: Phaser.Sprite;
sleepSpeedLimit: number;
static: boolean;
dynamic: boolean;
type: number;
velocity: Phaser.Physics.P2.InversePointProxy;
world: Phaser.Physics.P2;
x: number;
y: number;
addToWorld(): void;
addCapsule(length: number, radius: number, offsetX?: number, offsetY?: number, rotation?: number): any;
addCircle(radius: number, offsetX?: number, offsetY?: number, rotation?: number): any;
addLine(length: number, offsetX?: number, offsetY?: number, rotation?: number): any;
addParticle(offsetX?: number, offsetY?: number, rotation?: number): any;
addPolygon(options: { optimalDecomp?: boolean; skipSimpleCheck?: boolean; removeCollinearPoints?: boolean; }, points: any): boolean;
addPlane(offsetX?: number, offsetY?: number, rotation?: number): any;
addRectangle(width: number, height: number, offsetX?: number, offsetY?: number, rotation?: number): any;
addShape(shape: any, offsetX?: number, offsetY?: number, rotation?: number): any;
adjustCenterOfMass(): void;
applyDamping(dt: number): void;
applyForce(force: number, worldX: number, worldY: number): void;
clearCollision(clearGroup?: boolean, cleanMask?: boolean, shape?: any): void;
clearShapes(): void;
collides(group: any, callback?: Function, callbackContext?: Object, shape?: any): void;
createBodyCallback(object: any, callback: Function, callbackContext: Object): void;
createGroupCallback(group: Phaser.Physics.P2.CollisionGroup, callback: Function, callbackContext: Object): void;
destroy(): void;
getCollisionMask(): number;
loadData(key: string, object: string): boolean;
loadPolygon(key: string, object: string): boolean;
moveBackward(speed: number): void;
moveDown(speed: number): void;
moveForward(speed: number): void;
moveLeft(speed: number): void;
moveRight(speed: number): void;
moveUp(speed: number): void;
preUpdate(): void;
postUpdate(): void;
removeFromWorld(): void;
removeShape(shape: any): boolean;
reverse(Speed: number): void;
rotateLeft(speed: number): void;
rotateRight(speed: number): void;
reset(x: number, y: number, resetDamping?: boolean, resetMass?: boolean): void;
shapeChanged(): void;
setCircle(radius: number, offsetX?: number, offsetY?: number, rotation?: number): void;
setCollisionGroup(group: Phaser.Physics.P2.CollisionGroup, shape?: any): void;
setRectangle(width?: number, height?: number, offsetX?: number, offsetY?: number, rotation?: number): any;
setRectangleFromSprite(sprite: any): any;
setMaterial(material: Phaser.Physics.P2.Material, shape?: any): void;
setZeroDamping(): void;
setZeroForce(): void;
setZeroRotation(): void;
setZeroVelocity(): void;
toLocalFrame(out: Float32Array, worldPoint: Float32Array): void;
thrust(speed: number): void;
toWorldFrame(out: Float32Array, localPoint: Float32Array): void;
updateCollisionMask(shape?: any): void;
}
class BodyDebug extends Phaser.Group {
constructor(game: Phaser.Game, body: Phaser.Physics.P2.Body, settings: { pixelsPerLengthUnit?: number; debugPolygons?: boolean; lineWidth?: number; alpha?: number; });
}
class CollisionGroup {
constructor(bitmask: any);
mask: number;
}
class ContactMaterial {
constructor(materialA: Phaser.Physics.P2.Material, materialB: Phaser.Physics.P2.Material, options?: Object);
id: number;
friction: number;
materialA: Phaser.Physics.P2.Material;
materialB: Phaser.Physics.P2.Material;
restitution: number;
stiffness: number;
relaxation: number;
frictionStiffness: number;
frictionRelaxation: number;
surfaceVelocity: number;
}
class DistanceConstraint {
constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, bodyB: Phaser.Physics.P2.Body, distance: number, maxForce: number);
game: Phaser.Game;
world: Phaser.Physics.P2;
}
class FixtureList {
constructor(list: any[]);
flatten(array: any[]): any[];
getFixtures(keys: string): any[];
getFixtureByKey(key: string): any[];
getGroup(groupID: number): any[];
init(): void;
parse(): void;
setCategory(bit: number, fictureKey: string): void;
setMask(bit: number, fixtureKey: string): void;
setMaterial(material: Object, fixtureKey: string): void;
setSensor(value: boolean, fixtureKey: string): void;
}
class GearConstraint {
constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, bodyB: Phaser.Physics.P2.Body, angle?: number, ratio?: number);
game: Phaser.Game;
world: Phaser.Physics.P2;
}
class InversePointProxy {
constructor(world: Phaser.Physics.P2, destination: any);
x: number;
y: number;
}
class LockConstraint {
constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, bodyB: Phaser.Physics.P2.Body, offset?: number[], angle?: number, maxForce?: number);
game: Phaser.Game;
world: Phaser.Physics.P2;
}
class Material {
constructor(name: string);
name: string;
}
class PointProxy {
constructor(world: Phaser.Physics.P2, destination: any);
x: number;
y: number;
}
class PrismaticConstraint {
constructor(world: Phaser.Physics.P2, bodyA?: Phaser.Physics.P2.Body, bodyB?: Phaser.Physics.P2.Body, lockRotation?: boolean, anchorA?: Float32Array, anchorB?: Float32Array, axis?: Float32Array, maxForce?: number);
game: Phaser.Game;
world: Phaser.Physics.P2;
}
class RevoluteContraint {
constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, pivotA: Float32Array, bodyB: Phaser.Physics.P2.Body, pivotB: Float32Array, maxForce?: number);
game: Phaser.Game;
world: Phaser.Physics.P2;
}
class Spring {
constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, bodyB: Phaser.Physics.P2.Body, restLength?: number, stiffness?: number, damping?: number, worldA?: Float32Array, worldB?: Float32Array, localA?: Float32Array, localB?: Float32Array);
game: Phaser.Game;
world: Phaser.Physics.P2;
}
}
}
class Plugin extends StateCycle {
constructor(game: Phaser.Game, parent: any);
active: boolean;
game: Phaser.Game;
hasPostRender: boolean;
hasPostUpdate: boolean;
hasPreUpdate: boolean;
hasRender: boolean;
hasUpdate: boolean;
parent: any;
visible: boolean;
destroy(): void;
postRender(): void;
preUpdate(): void;
render(): void;
update(): void;
}
module Plugin {
class AStar extends Phaser.Plugin {
static VERSION: string;
static COST_ORTHAGONAL: number;
static COST_DIAGAONAL: number;
static DISTANCE_MANHATTEN: string;
static DISTANCE_EUCLIDIAN: string;
constructor(parent: any);
parent: any;
version: string;
findPath(startPoint: Phaser.Point, goalPoint: Phaser.Point): Phaser.Plugin.AStar.AStarPath;
isWalkable(x: number, y: number): boolean;
setAStarMap(map: Phaser.Tilemap, layerName: string, tilesetName: string): Phaser.Plugin.AStar;
}
module AStar {
class AStarNode {
constructor(x: number, y: number, isWalkable: boolean);
x: number;
y: number;
g: number;
h: number;
f: number;
parent: Phaser.Plugin.AStar.AStarNode;
travelCost: number;
walkable: boolean;
}
class AStarPath {
constructor(nodes: Phaser.Plugin.AStar.AStarNode[], start: Phaser.Plugin.AStar.AStarNode, goal: Phaser.Plugin.AStar.AStarNode);
nodes: Phaser.Plugin.AStar.AStarNode[];
start: Phaser.Plugin.AStar.AStarNode;
goal: Phaser.Plugin.AStar.AStarNode;
visited: Phaser.Plugin.AStar.AStarNode[];
}
}
class ColorHarmony extends Phaser.Plugin {
getAnalogousHarmony(color: number, threshold?: number): Object;
getComplementHarmony(color: number): number;
getSplitComplementHarmony(color: number, threshold: number): Object;
getTriadicHarmony(color: number): Object;
}
class CSS3Filters extends Phaser.Plugin {
constructor(parent: any);
blur: number;
brightness: number;
contrast: number;
grayscale: number;
hueRotate: number;
invert: number;
opacity: number;
saturate: number;
sepia: number;
}
class TilemapWalker extends Phaser.Plugin {
constructor(game: Phaser.Game, map: Phaser.Tilemap, layer?: any, x?: number, y?: number);
collides: boolean;
game: Phaser.Game;
history: boolean;
facing: number;
map: Phaser.Tilemap;
location: Phaser.Point;
locationLayer: number;
checkTile(x: number, y: number): boolean;
getTileFromLocation(x: number, y: number): Phaser.Tile;
getTiles(width: number, height: number, center?: boolean): any[];
getTileBehind(distance?: number): Phaser.Tile;
getTileBehindLeft(distance?: number): Phaser.Tile;
getTileBehindRight(distance?: number): Phaser.Tile;
getTileAhead(distance?: number): Phaser.Tile;
getTileAheadLeft(distance?: number): Phaser.Tile;
getTileAheadRight(distance?: number): Phaser.Tile;
getTileLeft(distance: number): Phaser.Tile;
getTileRight(distance: number): Phaser.Tile;
moveForward(): boolean;
moveBackward(): boolean;
moveLeft(): boolean;
moveRight(): boolean;
putTile(index: number): void;
setLocation(x: number, y: number, layer?: any): boolean;
turnLeft(): void;
turnRight(): void;
updateLocation(x: number, y: number): boolean;
}
class SamplePlugin extends Phaser.Plugin {
constructor(game: Phaser.Game, parent: any);
addSprite(sprite: Phaser.Sprite);
update(): void;
}
class VirtualJoystick extends Phaser.Plugin {
constructor(game: Phaser.Game, parent: any);
angle: number;
base: Phaser.Sprite;
baseBMD: Phaser.BitmapData;
baseCircle: Phaser.Circle;
deltaX: number;
deltaY: number;
distance: number;
force: number;
isDragging: boolean;
limit: number;
limitPoint: Phaser.Point;
location: Phaser.Point;
nub: Phaser.Sprite;
nubBMD: Phaser.BitmapData;
speed: number;
x: number;
y: number;
init(x: number, y: number, diameter?: number, limit?: number): void;
move(pointer: Phaser.Pointer, x: number, y: number): void;
render(): void;
setVelocity(sprite: Phaser.Sprite, minSpeed?: number, maxSpeed?: number): Phaser.Sprite;
startDrag(): void;
stopDrag(nub: Phaser.Sprite, pointer: Phaser.Pointer): void;
update(): void;
}
class Webcam extends Phaser.Plugin{
constructor(game: Phaser.Game, parent: any);
active: boolean;
context: any;
stream: any;
video: HTMLVideoElement;
connectCallback: (stream: any) => void;
errorCallback: (e: any) => void;
grab: (context: any, x: number, y: number) => void;
start(width: number, height: number, context: any): void;
stop(): void;
update(): void;
}
}
class PluginManager extends StateCycle {
constructor(game: Phaser.Game, parent: any);
game: Phaser.Game;
plugins: Phaser.Plugin[];
add(plugin: Phaser.Plugin, ...parameter: any[]): Phaser.Plugin;
destroy(): void;
postRender(): void;
postUpdate(): void;
preUpdate(): void;
remove(plugin: Phaser.Plugin): void;
removeAll(): void;
render(): void;
update(): void;
}
class Point extends PIXI.Point {
constructor(x?: number, y?: number);
x: number;
y: number;
static add(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
static centroid(points: Phaser.Point[], out?: Phaser.Point): Phaser.Point;
static distance(a: Phaser.Point, b: Phaser.Point, round?: boolean): number;
static divide(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
static equals(a: Phaser.Point, b: Phaser.Point): boolean;
static multiply(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
static rotate(a: Phaser.Point, x: number, y: number, angle: number, asDegrees: boolean, distance?: number): Phaser.Point;
static subtract(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
add(x: number, y: number): Phaser.Point;
angle(a: Phaser.Point, asDegrees?: boolean): number;
angleSq(a: Phaser.Point, b: Phaser.Point): number;
clamp(min: number, max: number): Phaser.Point;
clampX(min: number, max: number): Phaser.Point;
clampY(min: number, max: number): Phaser.Point;
clone(output?: Phaser.Point): Phaser.Point;
copyFrom(source: any): Phaser.Point;
copyTo(dest: any): Object;
cross(a: Phaser.Point): number;
distance(dest: Object, round?: boolean): number;
divide(x: number, y: number): Phaser.Point;
dot(a: Phaser.Point): number;
equals(a: Phaser.Point): boolean;
getMagnitude(): number;
getMagnitudeSq(): number;
interpolate(a: Phaser.Point, b: Phaser.Point, f: number, out?: Phaser.Point): Phaser.Point;
invert(): Phaser.Point;
isZero(): boolean;
multiply(x: number, y: number): Phaser.Point;
multiplyAdd(a: Phaser.Point, b: Phaser.Point, s: number, out?: Phaser.Point): Phaser.Point;
negative(a: Phaser.Point, out?: Phaser.Point): Phaser.Point;
normalize(a: Phaser.Point, out?: Phaser.Point): Phaser.Point;
normalRightHand(a: Phaser.Point, out?: Phaser.Point): Phaser.Point;
perp(a: Phaser.Point, out?: Phaser.Point): Phaser.Point;
project(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
projectUnit(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point;
rotate(x: number, y: number, angle: number, asDegrees?: boolean, distance?: number): Phaser.Point;
rperp(a: Phaser.Point, out?: Phaser.Point): Phaser.Point;
set(x: number, y?: number): Phaser.Point;
setMagnitude(magnitude: number): Phaser.Point;
setTo(x: number, y?: number): Phaser.Point;
subtract(x: number, y: number): Phaser.Point;
toString(): string;
}
class Pointer {
constructor(game: Phaser.Game, id: number);
active: boolean;
button: any;
circle: Phaser.Circle;
clientX: number;
clientY: number;
duration: number;
exists: boolean;
game: Phaser.Game;
id: number;
identifier: number;
isDown: boolean;
isMouse: boolean;
isUp: boolean;
movementX: number;
movementY: number;
msSinceLastClick: number;
pageX: number;
pageY: number;
pointerId: number;
position: Phaser.Point;
positionDown: Phaser.Point;
positionUp: Phaser.Point;
previousTapTime: number;
rawMovementX: number;
rawMovementY: number;
screenX: number;
screenY: number;
target: any;
targetObject: any;
timeDown: number;
timeUp: number;
totalTouches: number;
type: number;
withinGame: boolean;
worldX: number;
worldY: number;
x: number;
y: number;
justPressed(duration?: number): boolean;
justReleased(duration?: number): boolean;
leave(event: any): void;
move(event: any, fromClick?: boolean): void;
reset(): void;
resetMovement(): void;
start(event: any): void;
stop(event: any): void;
update(): void;
}
class Polygon {
constructor(points: any[]);
area: number;
points: any[];
type: number;
clone(): Phaser.Polygon;
contains(x: number, y: number): boolean;
}
class QuadTree {
constructor(x: number, y: number, width: number, height: number, maxObject?: number, maxLevels?: number, level?: number);
bounds: {
x: number;
y: number;
width: number;
height: number;
subWidth: number;
subHeight: number;
right: number;
bottom: number;
};
level: number;
maxObjects: number;
maxLevels: number;
objects: any[];
nodes: any[];
clear(): void;
getIndex(rect: Object): number;
insert(body: any): void;
populate(group: Phaser.Group): void;
populateHandler(sprite: Phaser.Sprite): void;
reset(x: number, y: number, width: number, height: number, maxObject?: number, maxLevels?: number, level?: number): void;
retrieve(source: any): any[];
split(): void;
}
class RandomDataGenerator {
constructor(seeds: number[]);
angle(): number;
between(min: number, max: number): number;
frac(): number;
integer(): number;
integerInRange(min: number, max: number): number;
normal(): number;
pick<T>(ary: T[]): T;
real(): number;
realInRange(min: number, max: number): number;
sow(seeds: number[]): void;
timestamp(min: number, max: number): number;
uuid(): number;
weightedPick<T>(ary: T[]): T;
}
class Rectangle {
constructor(x: number, y: number, width: number, height: number);
bottom: number;
bottomRight: Phaser.Point;
centerX: number;
centerY: number;
empty: boolean;
halfHeight: number;
halfWidth: number;
height: number;
left: number;
perimeter: number;
randomX: number;
randomY: number;
right: number;
top: number;
topLeft: Phaser.Point;
volume: number;
width: number;
x: number;
y: number;
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 containsRaw(rx: number, ry: number, rw: number, rh: number, x: number, y: number): boolean;
static containsRect(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean;
static equals(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean;
static inflate(a: Phaser.Rectangle, dx: number, dy: number): Phaser.Rectangle;
static inflatePoint(a: Phaser.Rectangle, point: Phaser.Point): Phaser.Rectangle;
static intersection(a: Phaser.Rectangle, b: Phaser.Rectangle, out?: Phaser.Rectangle): Phaser.Rectangle;
static intersects(a: Phaser.Rectangle, b: Phaser.Rectangle): boolean;
static intersectsRaw(left: number, right: number, top: number, bottom: number, tolerance: number): boolean;
static size(a: Phaser.Rectangle, output?: Phaser.Point): Phaser.Point;
static union(a: Phaser.Rectangle, b: Phaser.Rectangle, out?: Phaser.Rectangle): Phaser.Rectangle;
clone(output: Phaser.Rectangle): Phaser.Rectangle;
contains(x: number, y: number): boolean;
containsRect(b: Phaser.Rectangle): boolean;
copyFrom(source: any): Phaser.Rectangle;
copyTo(dest: any): Object;
equals(b: Phaser.Rectangle): boolean;
floor(): void;
floorAll(): void;
inflate(dx: number, dy: number): Phaser.Rectangle;
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;
offset(dx: number, dy: number): Phaser.Rectangle;
offsetPoint(point: Phaser.Point): Phaser.Rectangle;
setTo(x: number, y: number, width: number, height: number): Phaser.Rectangle;
size(output?: Phaser.Point): Phaser.Point;
toString(): string;
union(b: Phaser.Rectangle, out?: Phaser.Rectangle): Phaser.Rectangle;
}
class RenderTexture extends PIXI.RenderTexture {
constructor(game: Phaser.Game, width?: number, height?: number, key?: string, scaleMode?: number);
crop: PIXI.Rectangle;
game: Phaser.Game;
key: string;
type: number;
renderXY(displayObject: PIXI.DisplayObject, x: number, y: number, clear?: boolean): void;
}
class RequestAnimationFrame {
constructor(game: Phaser.Game, forceSetTimeOut?: boolean);
game: Phaser.Game;
isRunning: boolean;
isRAF(): boolean;
isSetTimeOut(): boolean;
start(): boolean;
stop(): void;
updateRAF(): void;
updateSetTimeout(): void;
}
class RetroFont extends Phaser.RenderTexture {
constructor(game: Phaser.Game, key: string, characterWidth: number, characterHeight: number, chars: string, charsPerRow?: number, xSpacing?: number, ySpacing?: number, xOffset?: number, yOffset?: number);
static ALIGN_CENTER: string;
static ALIGN_LEFT: string;
static ALIGN_RIGHT: string;
static TEXT_SET1: string;
static TEXT_SET2: string;
static TEXT_SET3: string;
static TEXT_SET4: string;
static TEXT_SET5: string;
static TEXT_SET6: string;
static TEXT_SET7: string;
static TEXT_SET8: string;
static TEXT_SET9: string;
static TEXT_SET10: string;
static TEXT_SET11: string;
align: string;
autoUpperCase: boolean;
characterHeight: number;
characterPerRow: number;
characterSpacingX: number;
characterSpacingY: number;
characterWidth: number;
customSpacingX: number;
customSpacingY: number;
fixedWidth: number;
fontSet: HTMLImageElement;
multiLine: boolean;
offsetX: number;
offsetY: number;
smoothed: string;
stamp: Phaser.Image;
text: string;
buildRetroFontText(): void;
getLongestLine(): number;
pasteLine(line: string, x: number, y: number, customSpacingX: number): void;
removeUnsupportedCharacters(stripCR?: boolean): string;
setFixedWidth(width: number, lineAlignment?: string): void;
setText(content: string, multiLine?: boolean, characterSpacing?: number, lineSpacing?: number, lineAlignment?: string, allowLowerCase?: boolean): void;
updateOffset(x?: number, y?: number): void;
}
class Signal {
active: boolean;
memorize: boolean;
add(listener: Function, listenerContext?: any, priority?: number): Phaser.SignalBinding;
addOnce(listener: Function, listenerContext?: any, priority?: number): Phaser.SignalBinding;
dispatch(...params: any[]): void;
dispose(): void;
forget(): void;
getNumListeners(): number;
halt(): void;
has(listener: Function, context?: any): boolean;
remove(listener: Function, context?: any): Function;
removeAll(context?: any): void;
toString(): string;
validateListener(listener: Function, fnName: string): void;
}
class SignalBinding {
constructor(signal: Phaser.Signal, listener: Function, isOnce: boolean, listenerContext?: Object, priority?: number);
active: boolean;
context: Object;
params: any[];
execute(paramsArr?: any[]): void;
detach(): Function;
isBound(): boolean;
isOnce(): boolean;
getListener(): Function;
getSignal(): Phaser.Signal;
toString(): string;
}
class SinglePad {
constructor(game: Phaser.Game, padParent: Object);
callbackContext: Object;
connected: boolean;
deadZone: number;
game: Phaser.Game;
index: number;
onAxisCallback: Function;
onConnectCallback: Function;
onDisconnectCallback: Function;
onDownCallback: Function;
onFloatCallback: Function;
onUpCallback: Function;
axis(axisCode: number): number;
addButton(buttonCode: number): Phaser.GamepadButton;
addCallbacks(context: Object, callbacks: Object): void;
buttonValue(buttonCode: number): number;
connect(rawPad: Object): void;
disconnect(): void;
getButton(buttonCode: number): Phaser.GamepadButton;
isDown(buttonCode: number): boolean;
isUp(buttonCode: number): boolean;
justPressed(buttonCode: number, duration?: number): boolean;
justReleased(buttonCode: number, duration?: number): boolean;
pollStatus(): void;
processAxisChange(axisState: Object): void;
processButtonDown(buttonCode: number, value: Object): void;
processButtonFloat(buttonCode: number, value: Object): void;
processButtonUp(buttonCode: number, value: Object): void;
reset(): void;
}
class Sound {
constructor(game: Phaser.Game, key: string, volume?: number, loop?: boolean, connect?: boolean);
autoplay: boolean;
context: any;
currentMarker: string;
currentTime: number;
destroy(remove?: boolean): void;
duration: number;
durationMS: number;
externalNode: Object;
game: Phaser.Game;
gainNode: Object;
isDecoded: boolean;
isDecoding: boolean;
isPlaying: boolean;
key: string;
loop: boolean;
markers: Object;
masterGainNode: Object;
mute: boolean;
name: string;
onDecoded: Phaser.Signal;
onLoop: Phaser.Signal;
onMarkerComplete: Phaser.Signal;
onMute: Phaser.Signal;
onPause: Phaser.Signal;
onPlay: Phaser.Signal;
onResume: Phaser.Signal;
onStop: Phaser.Signal;
override: boolean;
paused: boolean;
pausedPosition: number;
pausedTime: number;
pendingPlayback: boolean;
position: number;
startTime: number;
stopTime: number;
totalDuration: number;
usingAudioTag: boolean;
usingWebAudio: boolean;
volume: number;
addMarker(name: string, start: number, duration: number, volume?: number, loop?: boolean): void;
destroy(): void;
pause(): void;
play(marker?: string, position?: number, volume?: number, loop?: boolean, forceRestart?: boolean): Phaser.Sound;
removeMarker(name: string): void;
restart(marker: string, position: number, volume?: number, loop?: boolean): void;
resume(): void;
soundHasUnlocked(key: string): void;
stop(): void;
update(): void;
}
class SoundManager {
constructor(game: Phaser.Game);
channels: number;
connectToMaster: boolean;
context: any;
game: Phaser.Game;
mute: boolean;
noAudio: boolean;
onSoundDecode: Phaser.Signal;
touchLocked: boolean;
usingAudioTag: boolean;
usingWebAudio: boolean;
volume: number;
add(key: string, volume?: number, loop?: boolean, connect?: boolean): Phaser.Sound;
boot(): void;
decode(key: string, sound?: Phaser.Sound): void;
pauseAll(): void;
play(key: string, volume?: number, loop?: boolean): Phaser.Sound;
remove(sound: Phaser.Sound): boolean;
removeByKey(key: string): number;
resumeAll(): void;
stopAll(): void;
unlock(): void;
update(): void;
}
class Sprite extends PIXI.Sprite {
constructor(game: Phaser.Game, x: number, y: number, key?: any, frame?: any);
alive: boolean;
anchor: Phaser.Point;
angle: number;
animations: Phaser.AnimationManager;
autoCull: boolean;
body: any;
cameraOffset: Phaser.Point;
checkWorldBounds: boolean;
cropRect: Phaser.Rectangle;
debug: boolean;
deltaX: number;
deltaY: number;
deltaZ: number;
destroyPhase: boolean;
events: Phaser.Events;
exists: boolean;
fixedToCamera: boolean;
frame: number;
frameName: string;
game: Phaser.Game;
health: number;
inCamera: boolean;
input: Phaser.InputHandler;
inputEnabled: boolean;
inWorld: boolean;
key: any;
lifespan: number;
name: string;
outOfBoundsKill: boolean;
position: Phaser.Point;
physicsEnabled: boolean;
renderOrderID: number;
scale: Phaser.Point;
smoothed: boolean;
type: number;
world: Phaser.Point;
x: number;
y: number;
z: number;
bringToTop(): Phaser.Sprite;
crop(rect: Phaser.Rectangle, copy: boolean): void;
damage(amount: number): Phaser.Sprite;
destroy(destroyChildren?: boolean): void;
drawPolygon(): void;
kill(): Phaser.Sprite;
loadTexture(key: any, frame: any, stopAnimation?: boolean): void;
overlap(displayObject: any): boolean;
play(name: string, frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation;
postUpdate(): void;
preUpdate(): void;
reset(x: number, y: number, health?: number): Phaser.Sprite;
resetFrame(): void;
revive(health?: number): Phaser.Sprite;
setFrame(frame: Phaser.Frame): void;
update(): void;
updateCrop(): void;
}
class SpriteBatch extends Phaser.Group {
constructor(game: Phaser.Game, parent: any, name?: string, addedToStage?: boolean);
type: number;
}
class Stage extends PIXI.Stage {
constructor(game: Phaser.Game, width: number, height: number);
backgroundColor: any;
checkOffsetInterval: any;
currentRenderOrderID: number;
disableVisibilityChange: boolean;
exists: boolean;
game: Phaser.Game;
name: string;
offset: Phaser.Point;
smoothed: boolean;
checkVisiblity(): void;
parseConfig(config: Object): void;
postUpdate(): void;
preUpdate(): void;
setBackgroundColor(backgroundColor: number): void;
setBackgroundColor(backgroundColor: string): void;
update(): void;
visibilityChange(event: any): void;
}
class ScaleManager {
constructor(game: Phaser.Game, width: number, height: number);
static EXACT_FIT: number;
static NO_SCALE: number;
static SHOW_ALL: number;
aspectRatio: number;
bounds: Phaser.Rectangle;
enterFullScreen: Phaser.Signal;
enterIncorrectOrientation: Phaser.Signal;
enterLandscape: Phaser.Signal;
enterPortrait: Phaser.Signal;
event: any;
height: number;
forcePortrait: boolean;
forceLandscape: boolean;
fullScreenTarget: any;
fullScreenScaleMode: number;
game: Phaser.Game;
hasResized: Phaser.Signal;
incorrectOrientation: boolean;
leaveFullScreen: Phaser.Signal;
leaveIncorrectOrientation: Phaser.Signal;
isLandscape: boolean;
isFullScreen: boolean;
isPortrait: boolean;
margin: Phaser.Point;
maxHeight: number;
maxIterations: number;
maxWidth: number;
minHeight: number;
minWidth: number;
orientation: number;
orientationSprite: any;
pageAlignHorizontally: boolean;
pageAlignVertically: boolean;
scaleFactor: Phaser.Point;
scaleFactorInversed: Phaser.Point;
scaleMode: number;
sourceAspectRatio: number;
width: number;
checkOrientation(event: any): void;
checkOrientationState(): void;
checkResize(event: any): void;
forceOrientation(forceLandscape: boolean, forcePortrait?: boolean, orientationImage?: string): void;
fullScreenChange(event: any): void;
refresh(): void;
setExactFit(): void;
setMaximum(): void;
setScreenSize(force: boolean): void;
setShowAll(): void;
setSize(): void;
startFullScreen(antialias: boolean): void;
stopFullScreen(): void;
}
class State {
add: Phaser.GameObjectFactory;
cache: Phaser.Cache;
camera: Phaser.Camera;
game: Phaser.Game;
input: Phaser.Input;
load: Phaser.Loader;
make: Phaser.GameObjectCreator;
math: Phaser.Math;
particles: Phaser.Particles;
physics: Phaser.Physics.Arcade;
rnd: Phaser.RandomDataGenerator;
scale: Phaser.ScaleManager;
sound: Phaser.SoundManager;
stage: Phaser.Stage;
time: Phaser.Time;
tweens: Phaser.TweenManager;
world: Phaser.World;
create(): void;
loadRender(): void;
loadUpdate(): void;
paused(): void;
preload(): void;
render(): void;
shutdown(): void;
update(): void;
}
class StateCycle {
preUpdate(): void;
update(): void;
render(): void;
postRender(): void;
destroy(): void;
}
class StateManager {
constructor(game: Phaser.Game, pendingState?: Phaser.State);
current: string;
game: Phaser.Game;
onCreateCallback: Function;
onInitCallback: Function;
onLoadRenderCallback: Function;
onLoadUpdateCallback: Function;
onPausedCallback: Function;
onPauseUpdateCallback: Function;
onPreloadCallback: Function;
onPreRenderCallback: Function;
onRenderCallback: Function;
onResumedCallback: Function;
onShutDownCallback: Function;
onUpdateCallback: Function;
states: Object;
add(key: string, state: any, autoStart?: boolean): void;
checkState(key: string): boolean;
destroy(): void;
getCurrentState(): Phaser.State;
link(key: string): void;
loadComplete(): void;
pause(): void;
preRender(): void;
preUpdate(): void;
render(): void;
remove(key: string): void;
resume(): void;
restart(clearWorld?: boolean, clearCache?: boolean): void;
start(key: string, clearWorld?: boolean, clearCache?: boolean, ...args: any[]): void;
update(): void;
}
class Text extends PIXI.Text {
constructor(game: Phaser.Game, x: number, y: number, text: string, style: any);
align: string;
angle: number;
cameraOffset: Phaser.Point;
destroyPhase: boolean;
events: Phaser.Events;
exists: boolean;
fill: Object;
fixedToCamera: boolean;
font: string;
fontSize: number;
fontWeight: number;
game: Phaser.Game;
input: Phaser.InputHandler;
inputEnabled: boolean;
lineSpacing: number;
name: string;
position: Phaser.Point;
shadowBlur: number;
shadowColor: string;
shadowOffsetX: number;
shadowOffsetY: number;
stroke: string;
strokeThickness: number;
scale: Phaser.Point;
text: string;
type: number;
world: Phaser.Point;
wordWrap: boolean;
wordWrapWidth: number;
z: number;
destroy(destroyChildren?: boolean): void;
postUpdate(): void;
preUpdate(): void;
setShadow(x?: number, y?: number, color?: Object, blur?: number): void;
setStyle(style?: { font?: string; fill?: Object; align?: string; stroke?: string; strokeThickness?: number; wordWrap?: boolean; wordWrapWidth?: number; shadowOffsetX?: number; shadowOffsetY?: number; shadowColor?: string; shadowBlur?: number; }): void;
update(): void;
}
class Tile {
constructor(layer: Object, index: number, x: number, y: Number, width: number, height: number);//
alpha: number;
bottom: number;
callback: Function;
callbackContext: Object;
centerX: number;
centerY: number;
canCollide: boolean;
collideDown: boolean;
collideLeft: boolean;
collideNone: boolean;
collideRight: boolean;
collisionCallback: Function;
collisionCallbackContext: Object;
collides: boolean;
collideUp: boolean;
faceBottom: boolean;
faceLeft: boolean;
faceRight: boolean;
faceTop: boolean;
game: Phaser.Game;
height: number;
index: number;
layer: Object;
left: number;
properties: Object;
right: number;
scanned: boolean;
top: number;
width: number;
worldX: number;
worldY: number;
x: number;
y: number;
copy(tile): Phaser.Tile;
containsPoint(x: number, y: number): boolean;
destroy(): void;
intersects(x: number, y: number, right: number, bottom: number): boolean;
isInterested(collides: boolean, faces: boolean): boolean;
resetCollision(): void;
setCollision(left: boolean, right: boolean, up: boolean, down: boolean): void;
setCollisionCallback(callback: Function, context: Object): void;
}
class Tilemap {
constructor(game: Phaser.Game, key?: string, tileWidth?: number, tileHeight?: number, width?: number, height?: number);
static CSV: number;
static TILED_JSON: number;
static NORTH: number;
static EAST: number;
static SOUTH: number;
static WEST: number;
collision: any[];
collideIndexes: any[];
currentLayer: number;
debugMap: any[];
format: number;
game: Phaser.Game;
height: number;
heightInPixels: number;
images: any[];
key: string;
layer: Phaser.TilemapLayer[];
layers: Object[];
objects: any[];
orientation: string;
properties: Object;
tileHeight: number;
tiles: Phaser.Tile[];
tilesets: Phaser.Tileset[];
tileWidth: number;
version: number;
width: number;
widthInPixels: number;
addTilesetImage(tileset: string, key?: string, tileWidth?: number, tileHeight?: number, tileMargin?: number, tileSpacing?: number, gid?: number): Phaser.Tileset;
calculateFaces(layer: number): void;
copy(x: number, y: number, width: number, height: number, layer?: any): Phaser.Tile[];
create(name: string, width: number, height: number, tileWidth: number, tileHeight: number, group?: Phaser.Group): Phaser.TilemapLayer;
createBlankLayer(name: string, width: number, height: number, tileWidth: number, tileHeight: number, group?: Phaser.Group): Phaser.TilemapLayer;
createFromObjects(name: string, gid: number, key: string, frame?: any, exists?: boolean, autoCull?: boolean, group?: Phaser.Group, CustomClass?: Object, adjustY?: boolean): void;
createLayer(layer: any, width?: number, height?: number, group?: Phaser.Group): Phaser.TilemapLayer;
destroy(): void;
dump(): void;
fill(index: number, x: number, y: number, width: number, height: number, layer?: any): void;
forEach(callback: Function, context: any, x: number, y: Number, width: number, height: number, layer?: any): void;
getImageIndex(name: string): number;
getIndex(location: any[], name: string): number;
getLayer(layer: any): number;
getLayerIndex(name: string): number;
getObjectIndex(name: string): number;
getTile(x: number, y: number, layer?: any, nonNull?: boolean): Phaser.Tile;
getTileAbove(layer: number, x: number, y: number): Phaser.Tile;
getTileBelow(layer: number, x: number, y: number): Phaser.Tile;
getTileLeft(layer: number, x: number, y: number): Phaser.Tile;
getTileRight(layer: number, x: number, y: number): Phaser.Tile;
getTilesetIndex(name: string): number;
getTileWorldXY(x: number, y: number, tileWidth?: number, tileHeight?: number, layer?: any): Phaser.Tile;
hasTile(x: number, y: number, layer: Phaser.TilemapLayer): boolean;
paste(x: number, y: number, tileblock: Phaser.Tile[], layer?: any): void;
putTile(tile: any, x: number, y: number, layer?: any): Phaser.Tile;
putTileWorldXY(tile: any, x: number, y: number, tileWidth: number, tileHeight: number, layer?: any): void;
random(x: number, y: number, width: number, height: number, layer?: any): void;
removeAllLayers(): void;
removeTile(x: number, y: number, layer?: any): Phaser.Tile;
removeTileWorldXY(x: number, y: number, tileWidth: number, tileHeight: number, layer?: any): Phaser.Tile;
replace(source: number, dest: number, x: number, y: number, width: number, height: number, layer?: any): void;
searchTileIndex(index: number, skip?: number, reverse?: boolean, layer?: any): Phaser.Tile;
setCollision(indexes: any, collides?: boolean, layer?: any, recalculate?: boolean): void;
setCollisionBetween(start: number, stop: number, collides?: boolean, layer?: any, recalculate?: boolean): void;
setCollisionByExclusion(indexes: any[], collides?: boolean, layer?: any, recalculate?: boolean): void;
setCollisionByIndex(index: number, collides?: boolean, layer?: number, recalculate?: boolean): void;
setLayer(layer: any): void;
setPreventRecalculate(value: boolean): void;
setTileIndexCallback(indexes: any, callback: Function, callbackContext: Object, layer?: any): void;
setTileLocationCallback(x: number, y: number, width: number, height: number, callback: Function, callbackContext: Object, layer?: any): void;
setTileSize(tileWidth: number, tileHeight: number): void;
shuffle(x: number, y: number, width: number, height: number, layer: any): void;
swap(tileA: number, tileB: number, x: number, y: number, width: number, height: number, layer?: any): void;
}
class TilemapLayer extends Phaser.Image {
constructor(game: Phaser.Game, tilemap: Phaser.Tilemap, index: number, width: number, height: number);
baseTexture: PIXI.BaseTexture;
cameraOffset: Phaser.Point;
canvas: HTMLCanvasElement;
collisionHeight: number;
collisionWidth: number;
context: CanvasRenderingContext2D;
debug: boolean;
debugAlpha: number;
debugCallbackColor: string;
debugColor: string;
debugFill: boolean;
debugFillColor: string;
dirty: boolean;
fixedToCamera: boolean;
game: Phaser.Game;
index: number;
layer: Object;
map: Phaser.Tilemap;
name: string;
rayStepRate: number;
scrollFactorX: number;
scrollFactorY: number;
scrollX: number;
scrollY: number;
texture: PIXI.Texture;
textureFrame: Phaser.Frame;
tileColor: string;
type: number;
wrap: boolean;
getRayCastTiles(line: Phaser.Line, stepRate?: number, collides?: boolean, interestingFace?: boolean): Phaser.Tile[];
getTiles(x: number, y: number, width: number, height: number, collides?: boolean, interestingFace?: boolean): Phaser.Tile[];
getTileX(x: number): Phaser.Tile;
getTileXY(x: number, y: number, point: Phaser.Point): Phaser.Point;
getTileY(y: number): Phaser.Tile;
postUpdate(): void;
render(): void;
renderDebug(): void;
resizeWorld(): void;
updateMax(): void;
}
class TilemapParser {
static getEmptyData(tileWidth?: number, tileHeight?: number, width?: number, height?: number): Object;
static parse(game: Phaser.Game, key: string, tileWidth?: number, tileHeight?: number, width?: number, height?: number): Object;
static parseCSV(key: string, data: string, tileWidth?: number, tileHeight?: number): Object;
static parseJSON(json: Object): Object;
}
class Tileset {
constructor(name: string, firstgid: number, width?: number, height?: number, margin?: number, spacing?: number, properties?: Object);
columns: number;
firstgid: number;
image: Object;
name: string;
properties: Object;
rows: number;
tileHeight: number;
tileMargin: number;
tileSpacing: number;
tileWidth: number;
total: number;
draw(context: CanvasRenderingContext2D, x: number, y: number, index: number): void;
setImage(image: any): void;
setSpacing(margin?: number, spacing?: number): void;
}
class TileSprite extends PIXI.TilingSprite {
constructor(game: Phaser.Game, x: number, y: number, width: number, height: number, key?: any, frame?: any);
angle: number;
animations: Phaser.AnimationManager;
autoCull: boolean;
body: any;
cameraOffset: Phaser.Point;
checkWorldBounds: boolean;
destroyPhase: boolean;
events: Phaser.Events;
exists: boolean;
fixedToCamera: boolean;
frame: number;
frameName: string;
game: Phaser.Game;
input: Phaser.InputHandler;
inputEnabled: boolean;
key: any;
name: string;
position: Phaser.Point;
type: number;
world: Phaser.Point;
z: number;
autoScroll(x: number, y: number): void;
destroy(destroyChildren: boolean): void;
loadTexture(key: any, frame: any): void;
play(name: string, frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation;
postUpdate(): void;
preUpdate(): void;
reset(x: number, y: number): Phaser.TileSprite;
setFrame(frame: Phaser.Frame): void;
stopScroll(): void;
update(): void;
}
class Time {
constructor(game: Phaser.Game);
advancedTiming: boolean;
deltaCap: number;
elapsed: number;
events: Phaser.Timer;
fps: number;
fpsMax: number;
fpsMin: number;
frames: number;
game: Phaser.Game;
lastTime: number;
msMax: number;
msMin: number;
now: number;
pausedTime: number;
pauseDuration: number;
physicsElapsed: number;
time: number;
timeToCall: number;
add(timer: Phaser.Timer): Phaser.Timer;
boot(): void;
create(autoDestroy?: boolean): Phaser.Timer;
elapsedSecondsSince(since: number): number;
elapsedSince(since: number): number;
removeAll(): void;
reset(): void;
totalElapsedSeconds(): number;
update(time: number): void;
}
class Timer {
constructor(game: Phaser.Game, autoDestroy?: boolean);
static HALF: number;
static MINUTE: number;
static QUARTER: number;
static SECOND: number;
autoDestroy: boolean;
duration: number;
events: Phaser.TimerEvent[];
expired: boolean;
game: Phaser.Game;
length: number;
ms: number;
next: number;
nextTick: number;
onComplete: Phaser.Signal;
running: boolean;
paused: boolean;
seconds: number;
add(delay: number, callback: Function, callbackContext: Object, ...args: any[]): Phaser.TimerEvent;
clearPendingEvents(): void;
destroy(): void;
loop(delay: number, callback: Function, callbackContext: Object, ...args: any[]): Phaser.TimerEvent;
order(): void;
pause(): void;
remove(event: Phaser.TimerEvent): boolean;
repeat(delay: number, repeatCount: number, callback: Function, callbackContext: Object, ...args: any[]): Phaser.TimerEvent;
resume(): void;
sortHandler(a: any, b: any): number;
start(startDelay?: number): void;
stop(): void;
update(time: number): boolean;
}
class TimerEvent {
constructor(timer: Phaser.Timer, delay: number, tick: number, repeatCount: number, loop: boolean, callback: Function, callbackContext, Object, args: any[]);
args: any[];
callback: Function;
callbackContext: Object;
delay: number;
loop: boolean;
pendingDelete: boolean;
repeatCount: number;
tick: number;
timer: Phaser.Timer;
}
class Touch {
constructor(game: Phaser.Game);
callbackContext: Object;
disabled: boolean;
event: any;
game: Phaser.Game;
preventDefault: boolean;
touchCancelCallback: Function;
touchEndCallback: Function;
touchEnterCallback: Function;
touchLeaveCallback: Function;
touchMoveCallback: Function;
touchStartCallback: Function;
consumeTouchMove(): void;
onTouchCancel(event: any): void;
onTouchEnd(event: any): void;
onTouchEnter(event: any): void;
onTouchLeave(event: any): void;
onTouchMove(event: any): void;
onTouchStart(event: any): void;
start(): void;
stop(): void;
}
class Tween {
constructor(object: Object, game: Phaser.Game, manager: Phaser.TweenManager);
game: Phaser.Game;
isRunning: boolean;
onComplete: Phaser.Signal;
onLoop: Phaser.Signal;
onStart: Phaser.Signal;
pendingDelete: boolean;
chain(): Phaser.Tween;
delay(amount: number): Phaser.Tween;
easing(easing: Function): Phaser.Tween;
from(properties: Object, duration?: number, ease?: Function, autoStart?: boolean, delay?: number, repeat?: number, yoyo?: boolean): Phaser.Tween;
generateData(frameRate: number, data: Object): any[];
interpolation(interpolation: Function): Phaser.Tween;
loop(): Phaser.Tween;
onUpdateCallback(callback: Function, callbackContext: Object): Phaser.Tween;
pause(): void;
repeat(times: number): Phaser.Tween;
resume(): void;
start(): Phaser.Tween;
stop(): Phaser.Tween;
to(properties: Object, duration?: number, ease?: Function, autoStart?: boolean, delay?: number, repeat?: number, yoyo?: boolean): Phaser.Tween;
update(time: number): boolean;
yoyo(yoyo: boolean): Phaser.Tween;
}
class TweenManager {
constructor(game: Phaser.Game);
game: Phaser.Game;
add(tween: Phaser.Tween): Phaser.Tween;
create(object: Object): Phaser.Tween;
getAll(): Phaser.Tween[];
isTweening(object: Object): boolean;
remove(tween: Phaser.Tween): Phaser.Tween;
removeAll(): void;
resumeAll(): void;
update(): boolean;
pauseAll(): void;
}
class Utils {
static extend(deep: boolean, target: Object): Object;
static isPlainObject(object: Object): boolean;
static mixin(from: Object, to: Object): Object;
static pad(str: string, len: number, pad: number, dir?: number): string;
static parseDimension(size: any, dimension: number): number;
static rotateArray<T>(array: T[], direction: any): T;
static shuffle<T>(array: T[]): T;
static transposeArray<T>(array: T[]): T;
}
module Utils {
class Debug {
constructor(game: Phaser.Game);
baseTexture: PIXI.BaseTexture;
canvas: HTMLCanvasElement;
columnWidth: number;
context: CanvasRenderingContext2D;
currentAlpha: number;
currentX: number;
currentY: number;
dirty: boolean;
font: string;
game: Phaser.Game;
lineHeight: number;
renderShadow: boolean;
sprite: PIXI.Sprite;
texture: PIXI.Texture;
textureFrame: Phaser.Frame;
AStar(astar: Phaser.Plugin.AStar, x: number, y: number, showVisited: boolean): void;
boot(): void;
body(sprite: Phaser.Sprite, color?: string, filled?: boolean): void;
bodyInfo(sprite: Phaser.Sprite, x: number, y: Number, color?: string): void;
cameraInfo(camera: Phaser.Camera, x: number, y: number, color?: string): void;
geom(object: any, color?: string, fiiled?: boolean, forceType?: number): void;
inputInfo(x: number, y: number, color?: string): void;
lineInfo(line: Phaser.Line, x: number, y: number, color?: string): void;
key(key: Phaser.Key, x?: number, y?: number, color?: string);
line(): void;
preUpdate(): void;
pixel(x: number, y: number, color?: string, size?: number): void;
pointer(pointer: Phaser.Pointer, hideIfUp?: boolean, downColor?: string, upColor?: string, color?: string): void;
quadTree(quadtree: Phaser.QuadTree, color?: string): void;
rectangle(object: Phaser.Rectangle, color?: string, filled?: boolean): void;
soundInfo(sound: Phaser.Sound, x: number, y: number, color?: string): void;
spriteBounds(sprite: any, color?: string, filled?: boolean): void;
spriteCoords(sprite: any, x: number, y: number, color?: string): void;
spriteInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
spriteInputInfo(sprite: Phaser.Sprite, x: number, y: number, color?: string): void;
start(x?: number, y?: number, color?: string, columnWidth?: number): void;
stop(): void;
text(text: string, x: number, y: number, color?: string, font?: string): void;
timer(timer: Phaser.Timer, x: number, y: number, color?: string): void;
}
}
class World extends Phaser.Group {
constructor(game: Phaser.Game);
bounds: Phaser.Rectangle;
camera: Phaser.Camera;
centerX: number;
centerY: number;
game: Phaser.Game;
height: number;
randomX: number;
randomY: number;
width: number;
boot(): void;
getObjectsUnderPointer(pointer: Phaser.Pointer, group: Phaser.Group, callback?: Function, callbackContext?: Object): Phaser.Sprite;
setBounds(x: number, y: number, width: number, height: number): void;
shutdown(): void;
wrap(sprite: any, padding?: number, useBounds?: boolean, horizontal?: boolean, vertical?: boolean): void;
}
}
Reference in a new issue View git blame Copy permalink