phaser-ce
Version:
Phaser CE (Community Edition) is a fast, free and fun HTML5 Game Framework for Desktop and Mobile web browsers.
1,331 lines (1,103 loc) • 236 kB
TypeScript
/// <reference path="pixi.d.ts" />
/// <reference path="p2.d.ts" />
// Type definitions for Phaser CE
// Project: https://github.com/photonstorm/phaser-ce
declare module "phaser-ce" {
export = Phaser;
}
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 WEBGL_MULTI: number;
static BITMAPDATA: number;
static BITMAPTEXT: number;
static BUTTON: number;
static CANVAS_FILTER: number;
static CIRCLE: number;
static ELLIPSE: number;
static EMITTER: number;
static GRAPHICS: number;
static GROUP: number;
static IMAGE: number;
static LINE: number;
static MATRIX: number;
static POINT: number;
static POINTER: number;
static POLYGON: number;
static RECTANGLE: number;
static ROUNDEDRECTANGLE: 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 ROPE: number;
static CREATURE: number;
static VIDEO: number;
static NONE: number;
static LEFT: number;
static RIGHT: number;
static UP: number;
static DOWN: number;
static HORIZONTAL: number;
static VERTICAL: number;
static LANDSCAPE: number;
static PORTRAIT: number;
static ANGLE_UP: number;
static ANGLE_DOWN: number;
static ANGLE_LEFT: number;
static ANGLE_RIGHT: number;
static ANGLE_NORTH_EAST: number;
static ANGLE_NORTH_WEST: number;
static ANGLE_SOUTH_EAST: number;
static ANGLE_SOUTH_WEST: number;
static TOP_LEFT: number;
static TOP_CENTER: number;
static TOP_RIGHT: number;
static LEFT_TOP: number;
static LEFT_CENTER: number;
static LEFT_BOTTOM: number;
static CENTER: number;
static RIGHT_TOP: number;
static RIGHT_CENTER: number;
static RIGHT_BOTTOM: number;
static BOTTOM_LEFT: number;
static BOTTOM_CENTER: number;
static BOTTOM_RIGHT: number;
}
declare module Phaser {
enum blendModes {
NORMAL,
ADD,
MULTIPLY,
SCREEN,
OVERLAY,
DARKEN,
LIGHTEN,
COLOR_DODGE,
COLOR_BURN,
HARD_LIGHT,
SOFT_LIGHT,
DIFFERENCE,
EXCLUSION,
HUE,
SATURATION,
COLOR,
LUMINOSITY
}
export enum scaleModes {
DEFAULT,
LINEAR,
NEAREST
}
class Animation {
constructor(game: Phaser.Game, parent: Phaser.Sprite, name: string, frameData: Phaser.FrameData, frames: number[] | string[], frameRate?: number, loop?: boolean);
currentFrame: Phaser.Frame;
delay: number;
enableUpdate: boolean;
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;
onUpdate: Phaser.Signal;
paused: boolean;
reversed: 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;
reverse(): Animation;
reverseOnce(): Animation;
setFrame(frameId?: string | number, useLocalFrameIndex?: boolean): void;
stop(resetFrame?: boolean, dispatchComplete?: boolean): void;
update(): boolean;
updateCurrentFrame(signalUpdate: boolean, fromPlay?: boolean): boolean;
updateFrameData(frameData: 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;
name: string;
paused: boolean;
sprite: Phaser.Sprite;
updateIfVisible: boolean;
add(name: string, frames?: number[] | string[], frameRate?: number, loop?: boolean, useNumericIndex?: boolean): Phaser.Animation;
copyFrameData(frameData: Phaser.FrameData, frame: string | number): boolean;
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;
stop(name?: string, resetFrame?: boolean): void;
update(): boolean;
validateFrames(frames: Phaser.Frame[], useNumericIndex?: boolean): boolean;
}
class AnimationParser {
static JSONData(game: Phaser.Game, json: any): Phaser.FrameData;
static JSONDataHash(game: Phaser.Game, json: any): Phaser.FrameData;
static JSONDataPyxel(game: Phaser.Game, json: any): Phaser.FrameData;
static spriteSheet(game: Phaser.Game, key: string, frameWidth: number, frameHeight: number, frameMax?: number, margin?: number, spacing?: number, skipFrames?: number): Phaser.FrameData;
static XMLData(game: Phaser.Game, xml: any): Phaser.FrameData;
}
class AudioSprite {
constructor(game: Phaser.Game, key: string);
game: Phaser.Game;
key: string;
config: any;
autoplayKey: string;
autoplay: boolean;
sounds: any;
get(marker: string): Phaser.Sound;
play(marker: string, volume?: number): Phaser.Sound;
stop(marker: string): Phaser.Sound;
}
class ArraySet {
constructor(list: any[]);
position: number;
list: any[];
total: number;
first: any;
next: any;
add(item: any): any;
getByKey(property: string, value: any): any;
getIndex(item: any): number;
exists(item: any): boolean;
reset(): void;
remove(item: any): any;
removeAll(destoy?: boolean): void;
setAll(key: any, value: any): void;
callAll(key: string, ...parameter: any[]): void;
}
class ArrayUtils {
static getRandomItem<T>(objects: T[], startIndex?: number, length?: number): T;
static removeRandomItem<T>(objects: T[], startIndex?: number, length?: number): T;
static remove<T>(array: T[], startIndex: number, count?: number): T;
static shuffle<T>(array: T[]): T[];
static transposeMatrix<T>(array: T[]): T;
static rotateMatrix(matrix: any, direction: number | string): any;
static findClosest(value: number, arr: number[]): number;
static rotate(array: any[]): any;
static rotateLeft(array: any[]): any;
static rotateRight(array: any[]): any;
static numberArray(start: number, end?: number): number[];
static numberArrayStep(start: number, end?: number, step?: number): number[];
}
interface BitmapFont {
base: PIXI.BaseTexture;
data: HTMLImageElement;
font: Phaser.BMFont;
url: string;
}
interface BMFont {
chars: Phaser.BMFontChar[];
font: string;
lineHeight: number;
size: number;
}
interface BMFontChar {
x: number;
y: number;
width: number;
height: number;
xOffset: number;
yOffset: number;
xAdvance: number;
kerning: number[];
texture: PIXI.BaseTexture;
}
class BitmapData {
constructor(game: Phaser.Game, key: string, width?: number, height?: number, skipPool?: boolean);
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;
op: string;
pixels: Uint32Array;
smoothed: boolean;
smoothProperty: string;
texture: PIXI.Texture;
textureFrame: Phaser.Frame;
type: number;
width: number;
static getTransform(translateX: number, translateY: number, scaleX: number, scaleY: number, skewX: number, skewY: number): any;
add(object: any): Phaser.BitmapData;
addToWorld(x?: number, y?: number, anchorX?: number, anchorY?: number, scaleX?: number, scaleY?: number): Phaser.Image;
alphaMask(source: any, mask?: any, sourceRect?: Phaser.Rectangle, maskRect?: Phaser.Rectangle): Phaser.BitmapData;
blendAdd(): Phaser.BitmapData;
blendColor(): Phaser.BitmapData;
blendColorBurn(): Phaser.BitmapData;
blendColorDodge(): Phaser.BitmapData;
blendDarken(): Phaser.BitmapData;
blendDestinationAtop(): Phaser.BitmapData;
blendDestinationIn(): Phaser.BitmapData;
blendDestinationOut(): Phaser.BitmapData;
blendDestinationOver(): Phaser.BitmapData;
blendDifference(): Phaser.BitmapData;
blendExclusion(): Phaser.BitmapData;
blendHardLight(): Phaser.BitmapData;
blendHue(): Phaser.BitmapData;
blendLighten(): Phaser.BitmapData;
blendLuminosity(): Phaser.BitmapData;
blendMultiply(): Phaser.BitmapData;
blendOverlay(): Phaser.BitmapData;
blendReset(): Phaser.BitmapData;
blendSaturation(): Phaser.BitmapData;
blendScreen(): Phaser.BitmapData;
blendSoftLight(): Phaser.BitmapData;
blendSourceAtop(): Phaser.BitmapData;
blendSourceIn(): Phaser.BitmapData;
blendSourceOut(): Phaser.BitmapData;
blendSourceOver(): Phaser.BitmapData;
blendXor(): Phaser.BitmapData;
circle(x: number, y: number, radius: number, fillStyle?: string): Phaser.BitmapData;
clear(x?: number, y?: number, width?: number, height?: number): Phaser.BitmapData;
cls(): Phaser.BitmapData;
copy(source?: any, x?: number, y?: number, width?: number, height?: number, tx?: number, ty?: number, newWidth?: number, newHeight?: number, rotate?: number, anchorX?: number, anchorY?: number, scaleX?: number, scaleY?: number, alpha?: number, blendMode?: string, roundPx?: boolean): Phaser.BitmapData;
copyPixels(source: any, area: Phaser.Rectangle, x: number, y: number, alpha?: number): void;
copyRect(source: any, area: Phaser.Rectangle, x?: number, y?: number, alpha?: number, blendMode?: string, roundPx?: boolean): Phaser.BitmapData;
copyTransform(source: any, blendMode?: string, roundPx?: boolean): Phaser.BitmapData;
destroy(): void;
draw(source: any, x?: number, y?: number, width?: number, height?: number, blendMode?: string, roundPx?: boolean): Phaser.BitmapData;
drawFull(parent: any, blendMode?: string, roundPx?: boolean): Phaser.BitmapData;
drawGroup(group: Phaser.Group, blendMode?: string, roundPx?: boolean): Phaser.BitmapData;
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): Phaser.BitmapData;
generateTexture(key: string, callback?: (texture: PIXI.Texture) => void, callbackContext?: any): PIXI.Texture;
getBounds(rect?: Phaser.Rectangle): Phaser.Rectangle;
getFirstPixel(direction: number): { r: number; g: number; b: number; x: number; y: number; };
getPixel(x: number, y: number, out?: any): any;
getPixelRGB(x: number, y: number, out?: any, hsl?: boolean, hsv?: boolean): any;
getPixel32(x: number, y: number): number;
getPixels(rect: Phaser.Rectangle): ImageData;
getTransform(translateX: number, translateY: number, scaleX: number, scaleY: number, skewX: number, skewY: number): any;
line(x1: number, y1: number, x2: number, y2: number, color?: string, width?: number): Phaser.BitmapData;
load(source: any): Phaser.BitmapData;
move(x: number, y: number, wrap?: boolean): Phaser.BitmapData;
moveH(distance: number, wrap?: boolean): Phaser.BitmapData;
moveV(distance: number, wrap?: boolean): Phaser.BitmapData;
processPixel(callback: (color: number, x: number, y: number) => void, callbackContext: any, x?: number, y?: Number, width?: number, height?: number): Phaser.BitmapData;
processPixelRGB(callback: (color: ColorComponents, x: number, y: number) => void, callbackContext: any, x?: number, y?: Number, width?: number, height?: number): Phaser.BitmapData;
rect(x: number, y: number, width: number, height: number, fillStyle?: string): Phaser.BitmapData;
render(): Phaser.BitmapData;
replaceRGB(r1: number, g1: number, b1: number, a1: number, r2: number, g2: number, b2: number, a2: number, region?: Phaser.Rectangle): Phaser.BitmapData;
resize(width: number, height: number): Phaser.BitmapData;
resizeFrame(parent: any, width: number, height: number): void;
setHSL(h?: number, s?: number, l?: number, region?: Phaser.Rectangle): Phaser.BitmapData;
setPixel(x: number, y: number, red: number, green: number, blue: number, immediate?: boolean): Phaser.BitmapData;
setPixel32(x: number, y: number, red: number, green: number, blue: number, alpha: number, immediate?: boolean): Phaser.BitmapData;
shadow(color: string, blur?: number, x?: number, y?: number): Phaser.BitmapData;
shiftHSL(h?: number, s?: number, l?: number, region?: Phaser.Rectangle): Phaser.BitmapData;
text(text: string, x?: number, y?: number, font?: string, color?: string, shadow?: boolean): Phaser.BitmapData;
textureLine(line: Phaser.Line, key: string, repeat?: string): Phaser.BitmapData;
update(x?: number, y?: number, width?: number, height?: number): Phaser.BitmapData;
copyBitmapData(source: Phaser.BitmapData, x: number, y: number): Phaser.BitmapData;
}
class BitmapText extends PIXI.DisplayObjectContainer {
constructor(game: Phaser.Game, x: number, y: number, font: string, text?: string, size?: number, align?: string);
align: string;
alive: boolean;
anchor: Phaser.Point;
animations: Phaser.AnimationManager;
angle: number;
autoCull: boolean;
body: Phaser.Physics.Arcade.Body | Phaser.Physics.P2.Body | Phaser.Physics.Ninja.Body | any;
bottom: number;
cameraOffset: Phaser.Point;
checkWorldBounds: boolean;
data: any;
destroyPhase: boolean;
debug: boolean;
dirty: boolean;
events: Phaser.Events;
exists: boolean;
fixedToCamera: boolean;
font: string;
fontSize: number;
fresh: boolean;
game: Phaser.Game;
input: Phaser.InputHandler;
inputEnabled: boolean;
inCamera: boolean;
inWorld: boolean;
key: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture;
left: number;
name: string;
components: any;
lifespan: number;
maxWidth: number;
offsetX: number;
offsetY: number;
outOfBoundsKill: boolean;
pendingDestroy: boolean;
physicsType: number;
previousPosition: Phaser.Point;
previousRotation: number;
position: Phaser.Point;
renderOrderID: number;
right: number;
text: string;
smoothed: boolean;
textWidth: number;
textHeight: number;
tint: number;
top: number;
type: number;
world: Phaser.Point;
x: number;
y: number;
z: number;
alignIn(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any;
alignTo(container: Phaser.Rectangle | Phaser.Sprite | Phaser.Image | Phaser.Text | Phaser.BitmapText | Phaser.Button | Phaser.Graphics | Phaser.TileSprite, position?: number, offsetX?: number, offsetY?: number): any;
destroy(destroyChildren?: boolean): void;
kill(): void;
postUpdate(): void;
preUpdate(): void;
purgeGlyphs(): number;
reset(x: number, y: number, health?: number): Phaser.BitmapText;
revive(health?: number): Phaser.BitmapText;
scanLine(data: any, scale: number, text: string): { width: number; text: string; end: boolean; chars: string[] };
setText(text: string): void;
update(): void;
updateText(): void;
updateTransform(): void;
}
class Bullet extends Phaser.Sprite {
constructor(game: Phaser.Game, x: number, y: number, key?: any, frame?: any);
kill(): Phaser.Bullet;
update(): void;
}
class Button extends Phaser.Image {
constructor(game: Phaser.Game, x?: number, y?: number, key?: string, callback?: Function, callbackContext?: any, overFrame?: string | number, outFrame?: string | number, downFrame?: string | number, upFrame?: string | number);
forceOut: boolean;
freezeFrames: boolean;
onDownSound: Phaser.Sound | Phaser.AudioSprite;
onDownSoundMarker: string;
onInputDown: Phaser.Signal;
onInputOut: Phaser.Signal;
onInputOver: Phaser.Signal;
onInputUp: Phaser.Signal;
onOutSound: Phaser.Sound | Phaser.AudioSprite;
onOutSoundMarker: string;
onOverSound: Phaser.Sound | Phaser.AudioSprite;
onOverSoundMarker: string;
onOverMouseOnly: boolean;
onUpSound: Phaser.Sound | Phaser.AudioSprite;
onUpSoundMaker: string;
physicsType: number;
type: number;
clearFrames(): void;
setDownSound(sound: Phaser.Sound | Phaser.AudioSprite, marker?: string): void;
setFrames(overFrame?: string | number, outFrame?: string | number, downFrame?: string | number, upFrame?: string | number): void;
onInputOverHandler(sprite: Phaser.Button, pointer: Phaser.Pointer): void;
onInputOutHandler(sprite: Phaser.Button, pointer: Phaser.Pointer): void;
onInputDownHandler(sprite: Phaser.Button, pointer: Phaser.Pointer): void;
onInputUpHandler(sprite: Phaser.Button, pointer: Phaser.Pointer, isOver: boolean): void;
removedFromWorld(): void;
setOutSound(sound: Phaser.Sound | Phaser.AudioSprite, marker?: string): void;
setOverSound(sound: Phaser.Sound | Phaser.AudioSprite, marker?: string): void;
setSounds(overSound?: Phaser.Sound | Phaser.AudioSprite, overMarker?: string, downSound?: Phaser.Sound | Phaser.AudioSprite, downMarker?: string, outSound?: Phaser.Sound | Phaser.AudioSprite, outMarker?: string, upSound?: Phaser.Sound | Phaser.AudioSprite, upMarker?: string): void;
setState(newState: number): void;
setUpSound(sound: Phaser.Sound | Phaser.AudioSprite, marker?: string): void;
}
class PointerMode {
static CURSOR: number;
static CONTACT: number;
}
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 READY_TIMEOUT: number;
static RENDER_TEXTURE: number;
static SHADER: number;
static SOUND: number;
static SPRITE_SHEET: number;
static TEXT: number;
static TEXTURE: number;
static TEXTURE_ATLAS: number;
static TILEMAP: number;
static XML: number;
static VIDEO: number;
static DEFAULT: PIXI.Texture;
static MISSING: PIXI.Texture;
autoResolveURL: boolean;
game: Phaser.Game;
onReady: Phaser.Signal;
onSoundUnlock: Phaser.Signal;
addBinary(key: string, binaryData: any): void;
addBitmapData(key: string, bitmapData: Phaser.BitmapData, frameData?: Phaser.FrameData): Phaser.BitmapData;
addBitmapFont(key: string, url: string, data: any, atlasData: any, atlasType: string, xSpacing?: number, ySpacing?: number): void;
addBitmapFontFromAtlas(key: string, atlasKey: string, atlasFrame: string, dataKey: string, dataType?: string, xSpacing?: number, ySpacing?: number): void;
addCanvas(key: string, canvas: HTMLCanvasElement, context?: CanvasRenderingContext2D): void;
addDefaultImage(): void;
addImage(key: string, url: string, data: any): HTMLImageElement;
addJSON(key: string, urL: string, data: any): void;
addMissingImage(): void;
addPhysicsData(key: string, url: string, JSONData: any, format: number): void;
addRenderTexture(key: string, texture: RenderTexture): void;
addShader(key: string, url: string, data: any): void;
addSound(key: string, url: string, data: any, webAudio: boolean, audioTag: boolean): void;
addSpriteSheet(key: string, url: string, data: any, frameWidth: number, frameHeight: number, frameMax?: number, margin?: number, spacing?: number, skipFrames?: number): void;
addText(key: string, url: string, data: any): void;
addTextureAtlas(key: string, url: string, data: any, atlasData: any, format: number): void;
addTilemap(key: string, url: string, mapData: any, format: number): void;
addVideo(key: string, url: string, data: any, isBlob?: boolean): void;
addXML(key: string, url: string, data: any): void;
checkBinaryKey(key: string): boolean;
checkBitmapDataKey(key: string): boolean;
checkBitmapFontKey(key: string): boolean;
checkCanvasKey(key: string): boolean;
checkImageKey(key: string): boolean;
checkJSONKey(key: string): boolean;
checkKey(cache: number, key: string): boolean;
checkPhysicsKey(key: string): boolean;
checkRenderTextureKey(key: string): boolean;
checkShaderKey(key: string): boolean;
checkSoundKey(key: string): boolean;
checkTextKey(key: string): boolean;
checkTextureKey(key: string): boolean;
checkTilemapKey(key: string): boolean;
checkURL(url: string): any;
checkUrl(url: string): any;
checkXMLKey(key: string): boolean;
checkVideoKey(key: string): boolean;
clearGLTextures(): void;
decodedSound(key: string, data: any): void;
destroy(): void;
getBaseTexture(key: string, cache?: number): PIXI.BaseTexture;
getBinary(key: string): any;
getBitmapData(key: string): Phaser.BitmapData;
getBitmapFont(key: string): Phaser.BitmapFont;
getCanvas(key: string): HTMLCanvasElement;
getFrame(key: string, cache?: number): Phaser.Frame;
getFrameByIndex(key: string, index: number, cache?: number): Phaser.Frame;
getFrameByName(key: string, name: string, cache?: number): Phaser.Frame;
getFrameCount(key: string, cache?: number): number;
getFrameData(key: string, cache?: number): Phaser.FrameData;
getImage(key: string, full?: boolean): HTMLImageElement;
getItem(key: string, cache: number, method?: string, property?: string): any;
getJSON(key: string, clone?: boolean): any;
getKeys(cache: number): string[];
getPhysicsData(key: string, object?: string, fixtureKey?: string): any[];
getRenderTexture(key: string): Phaser.CachedRenderTexture;
getShader(key: string): string;
getSound(key: string): Phaser.Sound;
getSoundData(key: string): any;
getSpriteSheetKey(key: string): boolean;
getText(key: string): string;
getTextKeys(): string[];
getTexture(key: string): Phaser.RenderTexture;
getTextureAtlasKey(key: string): boolean;
getTextureFrame(key: string): Phaser.Frame;
getTilemap(key: string): any;
getTilemapData(key: string): any;
getURL(url: string): any;
getXML(key: string): any;
getVideo(key: string): Phaser.Video;
hasFrameData(key: string, cache?: number): boolean;
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, destroyBaseTexture?: boolean): void;
removeJSON(key: string): void;
removePhysics(key: string): void;
removeRenderTexture(key: string): void;
removeShader(key: string): void;
removeSound(key: string): void;
removeSpriteSheet(key: string): void;
removeText(key: string): void;
removeTextureAtlas(key: string): void;
removeTilemap(key: string): void;
removeXML(key: string): void;
removeVideo(key: string): void;
updateFrameData(key: string, frameData: any, cache?: number): void;
updateSound(key: string, property: string, value: Phaser.Sound): void;
}
interface CachedRenderTexture {
frame: Phaser.Frame;
texture: Phaser.RenderTexture;
}
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;
static SHAKE_BOTH: number;
static SHAKE_HORIZONTAL: number;
static SHAKE_VERTICAL: number;
static ENABLE_FX: number;
atLimit: { x: boolean; y: boolean; };
bounds: Phaser.Rectangle;
deadzone: Phaser.Rectangle;
displayObject: PIXI.DisplayObject;
id: number;
fixedView: Phaser.Rectangle;
fx: Phaser.Graphics;
game: Phaser.Game;
height: number;
lerp: Phaser.Point;
position: Phaser.Point;
roundPx: boolean;
scale: Phaser.Point;
shakeIntensity: number;
onFadeComplete: Phaser.Signal;
onFlashComplete: Phaser.Signal;
onShakeComplete: Phaser.Signal;
target: Phaser.Sprite;
totalInView: number;
view: Phaser.Rectangle;
visible: boolean;
width: number;
world: Phaser.World;
x: number;
y: number;
checkBounds(): void;
fade(color?: number, duration?: number, force?: boolean, alpha?: number): boolean;
flash(color?: number, duration?: number, force?: boolean, alpha?: number): boolean;
focusOn(displayObject: PIXI.DisplayObject): void;
focusOnXY(x: number, y: number): void;
follow(target: Phaser.Sprite, style?: number, lerpX?: number, lerpY?: number): void;
reset(): void;
resetFX(): void;
setBoundsToWorld(): void;
setPosition(x: number, y: number): void;
setSize(width: number, height: number): void;
shake(intensity?: number, duration?: number, force?: boolean, direction?: number, shakeBounds?: boolean): boolean;
unfollow(): void;
update(): void;
}
class Canvas {
static addToDOM(canvas: HTMLCanvasElement, parent: HTMLElement, overflowHidden?: boolean): HTMLCanvasElement;
static create(parent: HTMLDivElement, width?: number, height?: number, id?: string, skipPool?: boolean): HTMLCanvasElement;
static getSmoothingEnabled(context: CanvasRenderingContext2D): boolean;
static getSmoothingPrefix(context: CanvasRenderingContext2D): string;
static removeFromDOM(canvas: HTMLCanvasElement): void;
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;
}
export class CanvasPool {
static create(parent: HTMLElement, width?: number, height?: number): HTMLCanvasElement;
static getFirst(): HTMLCanvasElement;
static remove(parent: HTMLElement): void;
static removeByCanvas(canvas: HTMLCanvasElement): HTMLCanvasElement;
static getTotal(): number;
static getFree(): number;
static length: number;
static log(): void;
}
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(output: Phaser.Circle): Phaser.Circle;
contains(x: number, y: number): boolean;
copyFrom(source: any): Circle;
copyTo(dest: any): any;
distance(dest: any, round?: boolean): number;
getBounds(): Phaser.Rectangle;
offset(dx: number, dy: number): Phaser.Circle;
offsetPoint(point: Phaser.Point): Phaser.Circle;
random(out?: Phaser.Point): Phaser.Point;
sample(steps?: number, startAngle?: number, endAngle?: number, asDegrees?: boolean, out?: any[]): any[];
scale(x: number, y?: number): Phaser.Rectangle;
setTo(x: number, y: number, diameter: number): Circle;
toString(): string;
}
class Color {
static componentToHex(color: number): string;
static createColor(r?: number, g?: number, b?: number, a?: number, h?: number, s?: number, l?: number, v?: number): ColorComponents;
static fromRGBA(rgba: number, out?: ColorComponents): ColorComponents;
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 getGreen(color: number): number;
static getRandomColor(min?: number, max?: number, alpha?: number): number;
static getRed(color: number): number;
static getRGB(color: number): RGBColor;
static getWebRGB(color: number | RGBColor): string;
static hexToRGBArray(color: number): number[];
static hexToRGB(h: string): number;
static hexToColor(hex: string, out?: ColorComponents): ColorComponents;
static HSLtoRGB(h: number, s: number, l: number, out?: ColorComponents): ColorComponents;
static HSLColorWheel(s?: number, l?: number): ColorComponents[];
static HSVtoRGB(h: number, s: number, v: number, out?: ColorComponents): ColorComponents;
static HSVColorWheel(s?: number, v?: number): ColorComponents[];
static hueToColor(p: number, q: number, t: number): number;
static interpolateColor(color1: number, color2: number, steps: number, currentStep: number, alpha?: number, colorSpace?: 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 linear(color1: number, color2: number, t: number): number;
static linearInterpolation(colors: number[], t: number): number;
static packPixel(r: number, g: number, b: number, a: number): number;
static RGBArrayToHex(rgb: number[]): number;
static RGBtoHSL(r: number, g: number, b: number, out?: ColorComponents): ColorComponents;
static RGBtoHSV(r: number, g: number, b: number, out?: ColorComponents): ColorComponents;
static RGBtoString(r: number, g: number, b: number, a?: number, prefix?: string): string;
static toRGBA(r: number, g: number, b: number, a: number): number;
static toABGR(r: number, g: number, b: number, a: number): number;
static unpackPixel(rgba: number, out?: ColorComponents, hsl?: boolean, hsv?: boolean): ColorComponents;
static updateColor(out: ColorComponents): ColorComponents;
static valueToColor(value: string, out?: ColorComponents): ColorComponents;
static webToColor(web: string, out?: ColorComponents): ColorComponents;
static blendNormal(a: number): number;
static blendLighten(a: number, b: number): number;
static blendDarken(a: number, b: number): number;
static blendMultiply(a: number, b: number): number;
static blendAverage(a: number, b: number): number;
static blendAdd(a: number, b: number): number;
static blendSubtract(a: number, b: number): number;
static blendDifference(a: number, b: number): number;
static blendNegation(a: number, b: number): number;
static blendScreen(a: number, b: number): number;
static blendExclusion(a: number, b: number): number;
static blendOverlay(a: number, b: number): number;
static blendSoftLight(a: number, b: number): number;
static blendHardLight(a: number, b: number): number;
static blendColorDodge(a: number, b: number): number;
static blendColorBurn(a: number, b: number): number;
static blendLinearDodge(a: number, b: number): number;
static blendLinearBurn(a: number, b: number): number;
static blendLinearLight(a: number, b: number): number;
static blendVividLight(a: number, b: number): number;
static blendPinLight(a: number, b: number): number;
static blendHardMix(a: number, b: number): number;
static blendReflect(a: number, b: number): number;
static blendGlow(a: number, b: number): number;
static blendPhoenix(a: number, b: number): number;
}
module Component {
module Core {
var skipTypeChecks: boolean;
}
}
interface RGBColor {
r: number;
g: number;
b: number;
a: number;
}
interface ColorComponents extends RGBColor {
h: number;
s: number;
v: number;
l: number;
color: number;
color32: number;
rgba: string;
}
class Create {
constructor(game: Phaser.Game);
static PALETTE_ARNE: number;
static PALETTE_JMP: number;
static PALETTE_CGA: number;
static PALETTE_C64: number;
static PALETTE_JAPANESE_MACHINE: number;
bmd: Phaser.BitmapData;
canvas: HTMLCanvasElement;
ctx: CanvasRenderingContext2D;
game: Phaser.Game;
palettes: any;
copy(dest?: Phaser.BitmapData, x?: number, y?: number, width?: number, height?: number, blendMode?: string, roundPx?: boolean): Phaser.BitmapData;
grid(key: string, width: number, height: number, cellWidth: number, cellHeight: number, color: string, generateTexture?: boolean, callback?: Function, callbackContext?: any): PIXI.Texture;
texture(key: string, data: any, pixelWidth?: number, pixelHeight?: number, palette?: number, generateTexture?: boolean, callback?: Function, callbackContext?: any): PIXI.Texture;
}
interface CursorKeys {
up: Phaser.Key;
down: Phaser.Key;
left: Phaser.Key;
right: Phaser.Key;
}
class Device {
static LITTLE_ENDIAN: boolean;
static onInitialized: Phaser.Signal;
static checkFullScreenSupport(): void;
static canPlayAudio(type: string): boolean;
static canPlayVideo(type: string): boolean;
static isConsoleOpen(): boolean;
static isAndroidStockBrowser(): string;
static whenReady: (callback: Function, context?: any) => void;
android: boolean;
arora: boolean;
audioData: boolean;
cancelFullScreen: string;
canHandleAlpha: boolean;
canUseMultiply: boolean;
canvas: boolean;
chrome: boolean;
chromeOS: boolean;
chromeVersion: number;
cocoonJS: boolean;
cocoonJSApp: boolean;
cordova: boolean;
crosswalk: boolean;
css3D: boolean;
desktop: boolean;
deviceReadyAt: number;
electron: boolean;
ejecta: boolean;
epiphany: boolean;
file: boolean;
fileSystem: boolean;
firefox: boolean;
firefoxVersion: number;
fullScreen: boolean;
fullScreenKeyboard: boolean;
getUserMedia: boolean;
game: Phaser.Game;
h264Video: boolean;
hlsVideo: boolean;
ie: boolean;
ieVersion: number;
iOS: boolean;
iOSVersion: number;
initialized: boolean;
iPad: boolean;
iPhone: boolean;
iPhone4: boolean;
kindle: boolean;
linux: boolean;
littleEndian: boolean;
localStorage: boolean;
m4a: boolean;
macOS: boolean;
midori: boolean;
mobileSafari: boolean;
mp3: boolean;
mp4Video: boolean;
mspointer: boolean;
node: boolean;
nodeWebkit: boolean;
ogg: boolean;
oggVideo: number;
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;
vita: boolean;
wav: boolean;
webApp: boolean;
webAudio: boolean;
webGL: boolean;
webm: boolean;
webmVideo: boolean;
windows: boolean;
windowsPhone: boolean;
wheelEvent: string;
worker: boolean;
wp9Video: boolean;
}
class DeviceButton {
constructor(parent: Phaser.Pointer | Phaser.SinglePad, butonCode: number);
buttonCode: 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(): void;
}
module Easing {
var Default: Function;
var Power0: Function;
var Power1: Function;
var power2: Function;
var power3: Function;
var power4: Function;
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;
type: number;
width: number;
x: number;
y: number;
static constains(a: Phaser.Ellipse, x: number, y: number): boolean;
clone(output: Phaser.Ellipse): Phaser.Ellipse;
contains(x: number, y: number): boolean;
copyFrom(source: any): Phaser.Ellipse;
copyTo(dest: any): any;
getBounds(): Phaser.Rectangle;
random(out?: Phaser.Point): Phaser.Point;
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;
onRemovedFromWorld: Phaser.Signal;
onKilled: Phaser.Signal;
onRevived: Phaser.Signal;
onOutOfBounds: Phaser.Signal;
onEnterBounds: Phaser.Signal;
onInputOver: Phaser.Signal;
onInputOut: Phaser.Signal;
onInputDown: Phaser.Signal;
onInputUp: Phaser.Signal;
onDestroy: Phaser.Signal;
onDragStart: Phaser.Signal;
onDragStop: Phaser.Signal;
onDragUpdate: Phaser.Signal;
onAnimationStart: Phaser.Signal;
onAnimationComplete: Phaser.Signal;
onAnimationLoop: Phaser.Signal;
destroy(): void;
}
class Filter extends PIXI.AbstractFilter {
constructor(game: Phaser.Game, uniforms: any, fragmentSrc: string | string[]);
dirty: boolean;
game: Phaser.Game;
height: number;
fragmentSrc: string | string[];
padding: number;
prevPoint: Phaser.Point;
type: number;
uniforms: any;
width: number;
addToWorld(x?: number, y?: number, width?: number, height?: number, anchorX?: number, anchorY?: number): Phaser.Image;
apply(frameBuffer: WebGLFramebuffer): void;
destroy(): void;
init(...args: any[]): void;
setResolution(width: number, height: number): void;
syncUniforms(): void;
update(pointer?: Phaser.Pointer): void;
}
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 LazerBeam extends Phaser.Filter {
init(width: number, height: number, divisor?: number): 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;
sizeX: number;
sizeY: 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, heig