commit 89d793cb33c4ee86d673d2481400cca1fad5e325 Author: Michaël Lemaire Date: Sun Dec 28 01:00:00 2014 +0100 Initial bootstrap diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9b8661b --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +.* +/bin +/bootstrap.py +/build +/parts +/venv +/eggs +/node_modules +/src/vendor + diff --git a/bootstrap-venv.py b/bootstrap-venv.py new file mode 100644 index 0000000..eced63a --- /dev/null +++ b/bootstrap-venv.py @@ -0,0 +1,162 @@ +#!/usr/bin/env python +# Copyright (c) 2014, Jonathan Ballet +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +""" +Bootstrap a Buildout into its own virtualenv environment. + +This script creates a new empty virtualenv, download Buildout's bootstrap script +and execute it in the context of the previously created virtualenv. + + python bootstrap-venv.py + +Then, you only have to edit your `buildout.cfg` file and run:: + + ./bin/buildout + +You can also specify another directory to bootstrap the whole thing in:: + + python bootstrap-venv.py some-directory + cd some-directory + [ edit buildout.cfg ] + ./bin/buildout + +""" + + +# This URL is supposed to be stable +BOOTSTRAP_BUILDOUT_URL = "https://bootstrap.pypa.io/bootstrap-buildout.py" + +# TODO: find a place where Virtualenv is FOR EVER AND EVER available. +VIRTUALENV_URL = "https://pypi.python.org/packages/source/v/virtualenv/" + \ + "virtualenv-1.11.6.tar.gz" + + +import io +import gzip +import os +import subprocess +import sys +import tarfile +try: + from urllib.request import urlopen +except ImportError: + from urllib2 import urlopen + + +def download_virtualenv(destination): + print("Downloading virtualenv from %s" % VIRTUALENV_URL) + url = urlopen(VIRTUALENV_URL) + + string_fp = io.BytesIO(url.read()) + gz_fp = gzip.GzipFile(fileobj=string_fp) + tar_fp = tarfile.TarFile(fileobj=gz_fp) + tar_fp.extractall(destination) + + path = os.path.join(destination, os.listdir(destination)[0]) + sys.path.insert(0, path) + import virtualenv + print("Using virtualenv module at %s" % virtualenv.__file__) + return virtualenv + + +def create_virtualenv(destination): + venv_dir = os.path.join(destination, "parts", "venv") + + try: + import virtualenv + except ImportError: + venv_dist = os.path.join(destination, "parts", "venv-dist") + virtualenv = download_virtualenv(venv_dist) + + + print("Creating virtual environment in %s..." % venv_dir) + virtualenv.create_environment(venv_dir, + site_packages=False, + clear=True, + unzip_setuptools=False) + print("Virtual environment created in %s." % venv_dir) + return venv_dir + + +def download_bootstrap(destination): + bootstrap_path = os.path.join(destination, "bootstrap.py") + print("Downloading Buildout bootstrap from %s..." % BOOTSTRAP_BUILDOUT_URL) + url = urlopen(BOOTSTRAP_BUILDOUT_URL) + + with open(bootstrap_path, "wb") as fp: + fp.write(url.read()) + + print("Downloaded Buildout bootstrap into %s." % bootstrap_path) + return bootstrap_path + + +def make_default_buildout_cfg(buildout_cfg): + content = [ + "[buildout]", + "parts = default", + "", + "[default]", + "recipe = zc.recipe.egg", + "eggs = zc.recipe.egg", + "interpreter = python", + ] + with open(buildout_cfg, "w") as fp: + fp.writelines(l + "\n" for l in content) + + +def bootstrap_buildout(venv_dir, bootstrap_path): + python_bin = os.path.join(venv_dir, "bin", "python") + assert os.path.exists(python_bin) + + buildout_cfg = os.path.join(os.path.dirname(bootstrap_path), "buildout.cfg") + try: + fp = open(buildout_cfg) + except IOError as err: + if err.errno != 2: + raise + print("Creating a default buildout.cfg file in %s" % buildout_cfg) + make_default_buildout_cfg(buildout_cfg) + else: + fp.close() + + print("Bootstrapping Buildout using: %s %s..." % ( + python_bin, bootstrap_path)) + subprocess.check_call([python_bin, bootstrap_path]) + + +if len(sys.argv) == 2: + real_destination = sys.argv[1] +else: + real_destination = os.getcwd() + + +print("About to create Buildout environment in %s..." % real_destination) + +os.chdir(real_destination) +destination = "." +venv_dir = create_virtualenv(destination) +bootstrap_path = download_bootstrap(destination) +bootstrap_buildout(venv_dir, bootstrap_path) + +print("You can know run ./bin/buildout from directory %s" % real_destination) diff --git a/buildout.cfg b/buildout.cfg new file mode 100644 index 0000000..ecf0a82 --- /dev/null +++ b/buildout.cfg @@ -0,0 +1,71 @@ +[buildout] +update-versions-file = versions.cfg +extends = + versions.cfg +parts = + init-compile + watch + js-tools + js-libraries + +[init-compile] +recipe = collective.recipe.cmd +on_install = true +on_update = true +cmds = ${buildout:bin-directory}/${compile:name} + +[compile] +recipe = yt.recipe.shell +name = compile +script = ${js-tools:bin-gulp} build + +[watch] +recipe = yt.recipe.shell +name = watch +script = ${js-tools:bin-gulp} + +[nodejs] +recipe = gp.recipe.node +executable_node = ${buildout:bin-directory}/node +executable_npm = ${buildout:bin-directory}/npm + +[js-tools] +recipe = rodacom.buildout.npm +node_path = ${nodejs:executable_node} +npm_path = ${nodejs:executable_npm} +strip_extension = true +packages = + bower + del + gulp + gulp-concat + gulp-concat-sourcemap + gulp-connect + gulp-gh-pages + gulp-less + gulp-minify-css + gulp-minify-html + gulp-open + gulp-processhtml + gulp-sourcemaps + gulp-typescript + gulp-uglifyjs + gulp-util + gulp-watch + run-sequence +bin-bower = ${buildout:bin-directory}/bower +bin-gulp = ${buildout:bin-directory}/gulp + +[js-libraries] +recipe = bowerrecipe +executable = ${js-tools:bin-bower} +base-directory = ${buildout:parts-directory}/bower +downloads = jslibs +packages = + phaser-official + +[mkdir-var] +recipe = z3c.recipe.mkdir +paths = + var + var/cache diff --git a/gulpfile.js b/gulpfile.js new file mode 100644 index 0000000..2bbea7a --- /dev/null +++ b/gulpfile.js @@ -0,0 +1,112 @@ +var gulp = require('gulp'), + ts = require('gulp-typescript'), + less = require('gulp-less'), + minifyCSS = require('gulp-minify-css'), + concat = require('gulp-concat-sourcemap'), + sourcemaps = require('gulp-sourcemaps'), + processhtml = require('gulp-processhtml'), + connect = require('gulp-connect'), + open = require('gulp-open'), + del = require('del'), + uglify = require('gulp-uglifyjs'), + deploy = require('gulp-gh-pages'), + runSequence = require('run-sequence'); + +var paths = { + assets: 'src/assets/**/*', + less: 'src/css/main.less', + index: 'src/index.html', + libs: [ + 'src/vendor/phaser-official/build/phaser.min.js' + ], + ts: 'src/scripts/**/*.ts', + build: './build/', + dist: './dist/' +}; + +gulp.task('clean', function (cb) { + return del([paths.build, paths.dist], cb); +}); + +gulp.task('copy', function () { + return gulp.src(paths.assets) + .pipe(gulp.dest(paths.dist + 'assets')); +}); + +var tsProject = ts.createProject({ + declarationFiles: true, + noExternalResolve: true, + sortOutput: true, + sourceRoot: '../scripts' +}); + +gulp.task('typescript', function () { + var tsResult = gulp.src(paths.ts) + .pipe(sourcemaps.init()) + .pipe(ts(tsProject)); + + return tsResult.js + .pipe(concat('main.js')) + .pipe(sourcemaps.write()) + .pipe(gulp.dest(paths.build)); +}); + +gulp.task('less', function () { + return gulp.src(paths.less) + .pipe(less()) + .pipe(gulp.dest(paths.build)); +}); + +gulp.task('processhtml', function () { + return gulp.src(paths.index) + .pipe(processhtml()) + .pipe(gulp.dest(paths.dist)); +}); + +gulp.task('reload', ['typescript'], function () { + gulp.src('src/*.html') + .pipe(connect.reload()); +}); + +gulp.task('watch', function () { + gulp.watch(paths.ts, ['typescript', 'reload']); + gulp.watch(paths.less, ['less', 'reload']); + gulp.watch(paths.index, ['reload']); +}); + +gulp.task('connect', function () { + connect.server({ + root: [__dirname + '/src', paths.build], + port: 9000, + livereload: true + }); +}); + +gulp.task("open", function () { + gulp.src(paths.index) + .pipe(open("", {url: "http://localhost:9000"})); +}); + +gulp.task('minifyJs', ['typescript'], function () { + return gulp.src(paths.libs.concat(paths.build + 'main.js')) + .pipe(uglify('all.min.js', {outSourceMap: false})) + .pipe(gulp.dest(paths.dist)); +}); + +gulp.task('minifyCss', ['less'], function () { + return gulp.src(paths.build + 'main.css') + .pipe(minifyCSS()) + .pipe(gulp.dest(paths.dist)) +}); + +gulp.task('deploy', function () { + return gulp.src('./dist/**/*') + .pipe(deploy()); +}); + +gulp.task('default', function() { + runSequence('clean', ['typescript', 'less', 'connect', 'watch'], 'open'); +}); +gulp.task('build', function() { + return runSequence('clean', ['typescript', 'less', 'copy', 'minifyJs', 'minifyCss', 'processhtml']); +}); diff --git a/src/assets/images/preloader.gif b/src/assets/images/preloader.gif new file mode 100644 index 0000000..d84f653 Binary files /dev/null and b/src/assets/images/preloader.gif differ diff --git a/src/css/main.less b/src/css/main.less new file mode 100644 index 0000000..e3f8348 --- /dev/null +++ b/src/css/main.less @@ -0,0 +1,15 @@ + +html, body { + width: 100%; + height: 100%; + overflow: hidden; + background: rgba(166, 167, 247, 0.32); + padding: 0; + margin: 0; +} + +.game { + width: 800px; + height: 600px; + margin: 20px auto; +} diff --git a/src/index.html b/src/index.html new file mode 100644 index 0000000..444f39b --- /dev/null +++ b/src/index.html @@ -0,0 +1,29 @@ + + + + + SpaceTac + + + + + +
+ + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/scripts/Game.ts b/src/scripts/Game.ts new file mode 100644 index 0000000..8635423 --- /dev/null +++ b/src/scripts/Game.ts @@ -0,0 +1,15 @@ +/// + +module SpaceTac { + export class Game extends Phaser.Game { + constructor() { + super(800, 600, Phaser.CANVAS, '-space-tac'); + + this.state.add('boot', State.Boot); + this.state.add('preload', State.Preload); + this.state.add('main', State.Main); + + this.state.start('boot'); + } + } +} diff --git a/src/scripts/definitions/phaser.d.ts b/src/scripts/definitions/phaser.d.ts new file mode 100644 index 0000000..58562e2 --- /dev/null +++ b/src/scripts/definitions/phaser.d.ts @@ -0,0 +1,5578 @@ +/// + +// Type definitions for Phaser dev2.2.0 RC12 2014-12-02 +// Project: https://github.com/photonstorm/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 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 ROPE: 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[], frameRate?: number, loop?: boolean); + + currentAnim: Phaser.Animation; + 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; + 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: 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?: any[], frameRate?: number, loop?: boolean, useNumericIndex?: boolean): Phaser.Animation; + copyFrameData(frameData: Phaser.FrameData, frame: any): 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; + refreshFrame(): 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, cacheKey: string): Phaser.FrameData; + static JSONDataHash(game: Phaser.Game, json: any, cacheKey: string): 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: any, cacheKey: string): 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; + getIndex(item: any): number; + exists(item: any): boolean; + reset(): void; + remove(item: any): any; + setAll(key: any, value: any): void; + callAll(key: string, ...parameter: any[]): void; + + } + + class ArrayUtils { + + static getRandomItem(objects: T[], startIndex?: number, length?: number): T; + static removeRandomItem(objects: T[], startIndex?: number, length?: number): T; + static shuffle(array: T[]): T[]; + static transposeMatrix(array: T[]): T; + static rotateMatrix(matrix: any, direction: number): any; + static findClosest(value: number, arr: number[]): number; + static rotate(array: any[]): any; + static numberArray(start: number, end: number): number[]; + static numberArrayStep(start: number, end: number, step?: number): number[]; + + } + + 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; + smoothed: boolean; + 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(): 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; + draw(source: any, x?: number, y?: number, width?: number, height?: number, 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; + 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): number; + 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; + load(source: any): Phaser.BitmapData; + processPixel(callback: Function, callbackContext: any, x?: number, y?: Number, width?: number, height?: number): Phaser.BitmapData; + processPixelRGB(callback: Function, 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; + 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; + textureLine(line: Phaser.Line, key: string, repeat?: string): Phaser.BitmapData; + update(x: number, y: number, width: number, height: number): Phaser.BitmapData; + + } + + 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?: any, overFrame?: any, outFrame?: any, downFrame?: any, upFrame?: any); + + forceOut: boolean; + freezeFrames: boolean; + onDownSound: any; + onDownSoundMarker: string; + onInputDown: Phaser.Signal; + onInputOut: Phaser.Signal; + onInputOver: Phaser.Signal; + onInputUp: Phaser.Signal; + onOutSound: any; + onOutSoundMarker: string; + onOverSound: any; + onOverSoundMarker: string; + onOverMouseOnly: boolean; + onUpSound: any; + onUpSoundMaker: string; + type: number; + + clearFrames(): void; + setDownSound(sound: Phaser.Sound, marker?: string): void; + setDownSound(sound: Phaser.AudioSprite, 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; + removedFromWorld(): void; + setOutSound(sound: Phaser.Sound, marker?: string): void; + setOutSound(sound: Phaser.AudioSprite, marker?: string): void; + setOverSound(sound: Phaser.Sound, marker?: string): void; + setOverSound(sound: Phaser.AudioSprite, 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; + setSounds(overSound?: Phaser.AudioSprite, overMarker?: string, downSound?: Phaser.AudioSprite, downMarker?: string, outSound?: Phaser.AudioSprite, outMarker?: string, upSound?: Phaser.AudioSprite, upMarker?: string): void; + setState(newState: number): void; + setUpSound(sound: Phaser.Sound, marker?: string): void; + setUpSound(sound: Phaser.AudioSprite, 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; + static XML: number; + + autoResolveURL: boolean; + game: Phaser.Game; + onSoundUnlock: Phaser.Signal; + + addBinary(key: string, binaryData: any): void; + addBitmapData(key: string, bitmapData: Phaser.BitmapData, frameData?: Phaser.FrameData): Phaser.BitmapData; + addBitmapFont(key: string, texture: Phaser.RetroFont): void; + addBitmapFont(key: string, url: string, data: any, xmlData: any, xSpacing?: number, ySpacing?: number): void; + addCanvas(key: string, canvas: HTMLCanvasElement, context: CanvasRenderingContext2D): void; + addDefaultImage(): void; + addImage(key: string, url: string, data: any): void; + addJSON(key: string, urL: string, data: any): void; + addMisingImage(): void; + addPhysicsData(key: string, url: string, JSONData: any, format: number): void; + addRenderTexture(key: string, texture: RenderTexture): 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): 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; + 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(type: number, key: string): boolean; + checkPhysicsKey(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; + decodedSound(key: string, data: any): void; + destroy(): void; + getBinary(key: string): any; + getBitmapData(key: string): Phaser.BitmapData; + getBitmapFont(key: string): Phaser.RetroFont; + getCanvas(key: string): any; + getFrame(key: string): Phaser.Frame; + getFrameByIndex(key: string, frame: string): Phaser.Frame; + getFrameByName(key: string, frame: string): Phaser.Frame; + getFrameCount(key: string): number; + getFrameData(key: string, map?: string): Phaser.FrameData; + getImage(key: string): Phaser.Image; + getJSON(key: string): any; + getKeys(array: string[]): string[]; + getPhysicsData(key: string, object?: string, fixtureKey?: string): any[]; + getRenderTexture(key: string): Phaser.RenderTexture; + getSound(key: string): Phaser.Sound; + getSoundData(key: string): any; + getText(key: string): string; + getTextKeys(): string[]; + getTexture(key: string): Phaser.RenderTexture; + getTextureFrame(key: string): Phaser.Frame; + getTilemap(key: string): any; + getTilemapData(key: string): any; + getURL(url: string): any; + getUrl(url: string): any; + getXML(key: string): any; + 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, removeFromPixi?: boolean): void; + removeJSON(key: string): void; + removePhysics(key: string): void; + removeSound(key: string): void; + removeText(key: string): void; + removeTilemap(key: string): void; + removeXML(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; + position: Phaser.Point; + roundPx: boolean; + scale: Phaser.Point; + screenView: Phaser.Rectangle; + target: Phaser.Sprite; + totalInView: number; + 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): HTMLCanvasElement; + static getAspectRatio(canvas: HTMLCanvasElement): number; + static getOffset(element: HTMLElement, point?: Phaser.Point): Phaser.Point; + static getSmoothngEnabled(context: CanvasRenderingContext2D): boolean; + 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; + + } + + 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; + 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): any; + static fromRGBA(rgba: number, out?: any): any; + 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): any; + static getWebRGB(color: any): string; + static hexToRGB(h: string): number; + static hexToColor(hex: string, out?: any): any; + static HSLtoRGB(h: number, s: number, l: number, out?: any): any; + static HSLColorWheel(s?: number, l?: number): any[]; + static HSVtoRGB(h: number, s: number, v: number, out?: any): any; + 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?: any): any; + static RGBtoHSV(r: number, g: number, b: number, out?: any): any; + 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 unpackPixel(rgba: number, out?: any, hsl?: boolean, hsv?: boolean): any; + static updateColor(out: any): number; + static valueToColor(value: string, out?: any): { r: number; g: number; b: number; a: number; }; + static webToColor(web: string, out?: any): { r: number; g: number; b: number; a: 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; + + android: boolean; + arora: boolean; + audioData: boolean; + cancelFullScreen: string; + canvas: boolean; + chrome: boolean; + chromeOS: boolean; + cocoonJS: boolean; + cocoonJSApp: boolean; + cordova: boolean; + crosswalk: boolean; + css3D: boolean; + desktop: boolean; + deviceReadyAt: number; + 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; + 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; + mspointer: boolean; + node: boolean; + nodeWebkit: boolean; + ogg: boolean; + onInitialized: Phaser.Signal; + 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; + windows: boolean; + windowsPhone: boolean; + wheelEvent: string; + worker: boolean; + + checkFullScreenSupport(): void; + _checkAudio(): void; + _checkBrowser(): void; + _checkCSS3D(): void; + _checkDevice(): void; + _checkFeatures(): void; + _checkFullScreenSupport(): void; + _checkInput(): void; + _checkIsLittleEndian(): void; + _checkIsUint8ClampedImageData(): boolean; + _checkOS(): void; + canPlayAudio(type: string): boolean; + _initialze(): void; + isConsoleOpen(): boolean; + isAndroidStockBrowser(): string; + _readyCheck(): void; + whenReady: (callback: Function, context?: any) => void; + + } + + class DOMSprite { + //constructor + constructor(game: Phaser.Game, id: string, x: number, y: number, text: string, style: any); + //members + alive: boolean; + exists: boolean; + game: Phaser.Game; + group: Phaser.Group; + name: string; + type: number; + visible: boolean; + } + + 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; + 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; + 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; + onInputOver: Phaser.Signal; + onInputOut: Phaser.Signal; + onInputDown: Phaser.Signal; + onInputUp: Phaser.Signal; + onDestroy: Phaser.Signal; + onDragStart: Phaser.Signal; + onDragStop: Phaser.Signal; + onAnimationStart: Phaser.Signal; + onAnimationComplete: Phaser.Signal; + onAnimationLoop: Phaser.Signal; + + destroy(): void; + + } + + class Filter extends PIXI.AbstractFilter { + + constructor(game: Phaser.Game, ...args: any[]); + + dirty: boolean; + game: Phaser.Game; + height: number; + fragmentSrc: any[]; + padding: number; + prevPoint: Phaser.Point; + type: number; + uniforms: any; + width: number; + + 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; + + } + + 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 FlexGrid { + + constructor(manager: Phaser.ScaleManager, width: number, height: number); + + game: Phaser.Game; + manager: Phaser.ScaleManager; + width: number; + height: number; + boundsCustom: Phaser.Rectangle; + boundsFluid: Phaser.Rectangle; + boundsFull: Phaser.Rectangle; + boundsNone: Phaser.Rectangle; + customWidth: number; + customHeight: number; + customOffsetX: number; + customOffsetY: number; + positionCustom: Phaser.Point; + positionFluid: Phaser.Point; + positionFull: Phaser.Point; + positionNone: Phaser.Point; + scaleCustom: Phaser.Point; + scaleFluid: Phaser.Point; + scaleFluidInversed: Phaser.Point; + scaleFull: Phaser.Point; + scaleNone: Phaser.Point; + ratioH: number; + ratioV: number; + multiplier: number; + + createCustomLayer(width: number, height: number, children?: PIXI.DisplayObject[], addToWorld?: boolean): Phaser.FlexLayer; + createFluidLayer(children: PIXI.DisplayObject[]): Phaser.FlexLayer; + createFullLayer(children: PIXI.DisplayObject[]): Phaser.FlexLayer; + createFixedLayer(children: PIXI.DisplayObject[]): Phaser.FlexLayer; + debug(): void; + onResize(width: number, height: number): void; + refresh(): void; + reset(): void; + setSize(width: number, height: number): void; + + } + + class FlexLayer extends Phaser.Group { + + constructor(manager: Phaser.ScaleManager, position: Phaser.Point, bounds: Phaser.Rectangle, scale: Phaser.Point); + + grid: Phaser.FlexGrid; + manager: Phaser.ScaleManager; + + bottomLeft: Phaser.Point; + bottomMiddle: Phaser.Point; + bottomRight: Phaser.Point; + bounds: Phaser.Rectangle; + position: Phaser.Point; + scale: Phaser.Point; + topLeft: Phaser.Point; + topMiddle: Phaser.Point; + topRight: Phaser.Point; + + debug(): void; + resize(): 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; + + clone(): Phaser.Frame; + 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; + clone(): Phaser.FrameData; + 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; + width?: number; + height?: number; + renderer?: number; + parent?: any; + transparent?: boolean; + antialias?: boolean; + preserveDrawingBuffer?: boolean; + physicsConfig?: any; + seed?: string; + state?: Phaser.State; + + } + + class Game { + + constructor(width?: number, height?: number, renderer?: number, parent?: any, state?: any, transparent?: boolean, antialias?: boolean, physicsConfig?: any); + constructor(config: IGameConfig); + + add: Phaser.GameObjectFactory; + antialias: boolean; + cache: Phaser.Cache; + camera: Phaser.Camera; + canvas: HTMLCanvasElement; + config: IGameConfig; + context: any; + count: number; + debug: Phaser.Utils.Debug; + device: Phaser.Device; + forceSingleUpdate: boolean; + fpsProblemNotifier: Phaser.Signal; + height: number; + id: number; + input: Phaser.Input; + isBooted: boolean; + isRunning: boolean; + load: Phaser.Loader; + lockRender: boolean; + 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: any; + 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; + currentUpdateID: number; + updatesThisFrame: number; + width: number; + world: Phaser.World; + + boot(): void; + destroy(): void; + disableStep(): void; + enableStep(): void; + focusGain(event: any): void; + focusLoss(event: any): void; + gamePaused(event: any): void; + gameResumed(event: any): void; + parseConfig(config: any): void; + removeFromDOM(canvas: HTMLCanvasElement): void; + setUpRenderer(): void; + showDebugHeader(): void; + step(): void; + update(time: number): void; + updateLogic(timeStep: number): void; + updateRender(timeStep: 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; + audioSprite(key: string): Phaser.AudioSprite; + 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?: any, 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.Image; + 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; + rope(x: number, y: number, key: any, frame?: any, points?: Phaser.Point[]): Phaser.Rope; + 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.SpriteBatch; + text(x: number, y: number, text?: string, style?: any): 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: any): 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; + audioSprite(key: string): Phaser.AudioSprite; + 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?: any, 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; + rope(x: number, y: number, key: any, frame?: any, points?: Phaser.Point[]): Phaser.Rope; + 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: any): 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: any; + disabled: boolean; + enabled: 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: any, callbacks: any): 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(): void; + } + + 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; + 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; + ignoreDestroy: boolean; + length: number; + name: string; + onDestroy: Phaser.Signal; + 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; + addMultiple(children: any[], 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: any, callback: Function, length: number): void; + checkAll(key: string[], value: any, checkAlive?: boolean, checkVisible?: boolean, force?: boolean): boolean; + checkProperty(child: any, key: string[], value: any, force?: boolean): boolean; + 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?: any): void; + destroy(destroyChildren?: boolean, soft?: boolean): void; + divideAll(property: string, amount: number, checkAlive?: boolean, checkVisible?: boolean): void; + forEach(callback: Function, callbackContext: any, checkExists?: boolean, ...args: any[]): void; + forEachAlive(callback: Function, callbackContext: any, ...args: any[]): void; + forEachDead(callback: Function, callbackContext: any, ...args:any[]): void; + forEachExists(callback: Function, callbackContext: any): void; + filter(predicate: Function, checkExists?: boolean): ArraySet; + getAt(index: number): any; + getBottom(): any; + getFirstAlive(): any; + getFirstDead(): any; + getFirstExists(exists: 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?: any, ...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; + resetCursor(index?: number): 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(key?: 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); + + alive: boolean; + 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; + setScaleMinMax(minX?: number, minY?: number, maxX?: number, maxY?: number): void; + update(): void; + updateCrop(): void; + + } + + class Input { + + constructor(game: Phaser.Game); + + static MAX_POINTERS: number; + 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; + enabled: boolean; + doubleTapRate: number; + game: Phaser.Game; + gamepad: Phaser.Gamepad; + hitCanvas: HTMLCanvasElement; + hitContext: CanvasRenderingContext2D; + holdRate: number; + interactiveItems: Phaser.ArraySet; + justPressedRate: number; + justReleasedRate: number; + keyboard: Phaser.Keyboard; + maxPointers: number; + minPriorityID: number; + mouse: Phaser.Mouse; + mousePointer: Phaser.Pointer; + moveCallbacks: (pointer: Phaser.Pointer, x: number, y: number) => void[]; + moveCallbackContext: any; + 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; + pointer: Phaser.Pointer[]; + 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; + addMoveCallback(callback: Function, context: any): number; + boot(): void; + countActivePointers(limit?: number): number; + deleteMoveCallback(index: number): void; + destroy(): void; + getLocalPosition(displayObject: any, pointer: Phaser.Pointer): Phaser.Point; + getPointer(isActive?: 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; + startPointer(event: any): Phaser.Pointer; + stopPointer(event: any): Phaser.Pointer; + update(): void; + updatePointer(event: any): Phaser.Pointer; + + } + + class InputHandler { + + 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; + globalToLocalX(x: number): number; + globalToLocalY(y: number): number; + isDragged: boolean; + pixelPerfectAlpha: number; + pixelPerfectClick: boolean; + pixelPerfectOver: boolean; + priorityID: number; + scaleLayer: boolean; + 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: number): 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: number): number; + pointerTimeUp(pointer: number): number; + pointerUp(pointer: number): boolean; + pointerX(pointer: number): number; + pointerY(pointer: number): 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, includePixelPerfect?: boolean): boolean; + + } + + class Key { + + constructor(game: Phaser.Game, keycode: number); + + altKey: boolean; + ctrlKey: boolean; + duration: number; + enabled: boolean; + event: any; + game: Phaser.Game; + isDown: boolean; + isUp: boolean; + _justDown: boolean; + justDown: boolean; + _justUp: boolean; + justUp: boolean; + keyCode: number; + onDown: Phaser.Signal; + onHoldCallback: Function; + onHoldContext: any; + onUp: Phaser.Signal; + repeats: number; + shiftKey: boolean; + timeDown: number; + timeUp: number; + + downDuration(duration?: number): boolean; + processKeyDown(event: KeyboardEvent): void; + processKeyUp(event: KeyboardEvent): void; + reset(hard?: boolean): void; + update(): void; + upDuration(duration?: number): boolean; + + } + + 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; + static PLUS: number; + static MINUS: number; + + callbackContext: any; + disabled: boolean; + enabled: boolean; + event: any; + game: Phaser.Game; + lastChar: string; + lastKey: Phaser.Key; + onDownCallback: Function; + onPressCallback: Function; + onUpCallback: Function; + pressEvent: any; + + addCallbacks(context: any, onDown?: Function, onUp?: Function, onPress?: Function): void; + addKey(keycode: number): Phaser.Key; + addKeyCapture(keycode: any): void; + createCursorKeys(): Phaser.CursorKeys; + clearCaptures(): void; + destroy(): void; + downDuration(keycode: number, duration?: number): boolean; + isDown(keycode: 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; + upDuration(keycode: number, duration?: number): boolean; + + } + + 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; + + clone(output: Phaser.Line): Phaser.Line; + 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 LinkedList { + + first: any; + last: any; + next: any; + prev: any; + total: number; + + add(item: any): any; + callAll(callback: Function): void; + remove(item: any): 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; + onPackComplete: Phaser.Signal; + preloadSprite: any; + progress: number; + progressFloat: number; + useXDomainRequest: boolean; + + addToFileList(type: string, key: string, url: string, properties: any): void; + atlas(key: string, textureURL: string, atlasURL?: string, atlasData?: any, format?: number): Phaser.Loader; + atlasJSONArray(key: string, textureURL: string, atlasURL?: string, atlasData?: any): Phaser.Loader; + atlasJSONHash(key: string, textureURL: string, atlasURL?: string, atlasData?: any): Phaser.Loader; + atlasXML(key: string, textureURL: string, atlasURL?: string, atlasData?: any): Phaser.Loader; + audio(key: string, urls: any, autoDecode?: boolean): Phaser.Loader; + audiosprite(key: string, urls: any, atlasurl: string): Phaser.Loader; + binary(key: string, url: string, callback?: Function, callbackContext?: Function): Phaser.Loader; + bitmapFont(key: string, textureURL: string, xmlURL?: string, xmlData?: any, 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?: any, callbackContext?: any): Phaser.Loader; + physics(key: string, url?: string, data?: any, format?: string): Phaser.Loader; + removeAll(): void; + removeFile(key: string, type: string): void; + replaceInFileList(type: string, key: string, url: string, properties: any): void; + reset(): void; + resize(): void; + script(key: string, url: String, callback?: Function, callbackContext?: any): 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?: any, format?: number): Phaser.Loader; + totalLoadedFiles(): number; + totalLoadedPacks(): number; + totalQueuedFiles(): number; + totalQueuedPacks(): number; + xml(key: string, url: string, overwrite?: boolean): Phaser.Loader; + xmlLoadComplete(index: number): void; + + } + + class LoaderParser { + + static bitmapFont(game: Phaser.Game, xml: any, 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 angleBetweenY(x1: number, y1: number, x2: number, y2: number): number; + static angleBetweenPointsY(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(objects: T[], startIndex?: number, length?: number): T; + 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 normalizeAngle(angle: number, radians?: boolean): number; + static normalizeLatitude(lat: number): number; + static normalizeLongitude(lng: number): number; + static numberArray(start: number, end: number): number[]; + static numberArrayStep(start: number, end: number, step?: 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(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; + + } + + interface WheelEventProxy { + + bindEvent(event: any): WheelEventProxy; + + type: string; + deltaMode: number; + deltaX: number; + deltaY: number; + deltaZ: 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: any; + capture: boolean; + disabled: boolean; + enabled: boolean; + event: MouseEvent; + game: Phaser.Game; + locked: boolean; + mouseDownCallback: (event: MouseEvent) => void; + mouseMoveCallback: (event: MouseEvent) => void; + mouseOutCallback: (event: MouseEvent) => void; + mouseOverCallback: (event: MouseEvent) => void; + mouseUpCallback: (event: MouseEvent) => void; + mouseWheelCallback: (event: MouseEvent) => void; + _onMouseDown: (event: MouseEvent) => void; + _onMouseMove: (event: MouseEvent) => void; + _onMouseUp: (event: MouseEvent) => void; + _onMouseOut: (event: MouseEvent) => void; + _onMouseOver: (event: MouseEvent) => void; + _onMouseWheel: (event: MouseEvent) => void; + _wheelEvent: WheelEventProxy; + pointerLock: Phaser.Signal; + stopOnGameOut: boolean; + wheelDelta: WheelEventProxy; + + onMouseDown(event: MouseEvent): void; + onMouseMove(event: MouseEvent): void; + onMouseOut(event: MouseEvent): void; + onMouseOver(event: MouseEvent): void; + onMouseUp(event: MouseEvent): void; + onMouseUpGlobal(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: any; + 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: any; + 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(minX?: number, maxX?: number, minY?: number, maxY?: number, rate?: number, ease?: (k: number) => 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?: any); + + static ARCADE: number; + static P2JS: number; + static NINJA: number; + static BOX2D: number; + static CHIPMUNK: number; + + arcade: Phaser.Physics.Arcade; + config: any; + 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; + skipQuadTree: boolean; + + 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: any, object2: any, collideCallback?: Function, processCallback?: Function, callbackContext?: any): 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: any, children?: Boolean): void; + enableBody(object: any): void; + getObjectsAtLocation(x: number, y: number, group: Phaser.Group, callback?: (callbackArg: any, object: any) => void, callbackContext?: any, callbackArg?: any): Sprite[]; + 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: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: any): 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?: any, 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; + drag: 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: any, 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?: any): boolean; + convertTilemap(map: Phaser.Tilemap, layer?: any, slopeMap?: any): Phaser.Physics.Ninja.Tile[]; + enableAABB(object: any, children?: boolean): void; + enableCircle(object: any, radius: number, children?: boolean): void; + 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?: any): boolean; + separate(body1: Phaser.Physics.Ninja.Body, body2: Phaser.Physics.Ninja.Body, processCallback?: Function, callbackContext?: any, 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: any; + 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: any; + 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: any): void; + reportCollisionVsBody(px: number, py: number, dx: number, dy: number, obj: any): 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: any; + 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; + distance(dest: number, round?: boolean): number; + integrate(): void; + render(context: any, xOffset: number, yOffset: number, color: string, filled: boolean): void; + reportCollisionVsWorld(px: number, py: number, dx: number, dy: number, obj: any): void; + reportCollisionVsBody(px: number, py: number, dx: number, dy: number, obj: any): 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: any): void; + setType(id: number): number; + + } + + } + + class P2 { + + constructor(game: Phaser.Game, config?: any); + + applyDamping: boolean; + applyGravity: boolean; + applySpringForces: boolean; + boundsCollidesWith: Phaser.Physics.P2.Body[]; + boundsCollisionGroup: Phaser.Physics.P2.CollisionGroup; + config: any; + callbackContext: any; + collisionGroups: Phaser.Physics.P2.CollisionGroup[]; + contactMaterial: Phaser.Physics.P2.ContactMaterial; + emitImpactEvent: 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; + postBroaddphaseCallback: Function; + restitution: number; + solveConstraints: boolean; + time: any; + total: number; + useElapsedTime: boolean; + walls: { + left?: Phaser.Physics.P2.Body; + right?: Phaser.Physics.P2.Body; + top?: Phaser.Physics.P2.Body; + bottom?: Phaser.Physics.P2.Body; + }; + world: p2.World; + + addBody(body: Phaser.Physics.P2.Body): boolean; + addContactMaterial(material: Phaser.Physics.P2.ContactMaterial): Phaser.Physics.P2.ContactMaterial; + addConstraint(constraint: T): T; + addSpring(spring: Phaser.Physics.P2.Spring): Phaser.Physics.P2.Spring; + beginContactHandler(event: any): 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?: p2.BodyOptions, data?: number[][]): Phaser.Physics.P2.Body; + createBody(x: number, y: number, mass: number, addToWorld?: boolean, options?: p2.BodyOptions, data?: number[]): 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?: p2.ContactMaterialOptions): Phaser.Physics.P2.ContactMaterial; + createDistanceConstraint(bodyA: any, bodyB: any, distance: number, localAnchorA?: number[], localAnchorB?: 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?: number[], 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?: p2.BodyOptions, data?: number[][]): Phaser.Physics.P2.Body; + createParticle(x: number, y: number, mass: number, addToWorld?: boolean, options?: p2.BodyOptions, data?: number[]): Phaser.Physics.P2.Body; + createPrismaticConstraint(body: any, bodyB: any, lockRotation?: boolean, anchorA?: number[], anchorB?: number[], axis?: Float32Array, maxForce?: number): Phaser.Physics.P2.PrismaticConstraint; + createRevoluteConstraint(bodyA: any, pivotA: number[], bodyB: any, pivotB: number[], maxForce?: number, worldPivot?: number[]): Phaser.Physics.P2.RevoluteContraint; + createRotationalSpring(bodyA: any, bodyB: any, restAngle?: number, stiffness?: number, damping?: number): p2.RotationalSpring; + createSpring(bodyA: any, bodyB: any, restLength?: number, stiffness?: number, damping?: number, worldA?: number[], worldB?: number[], localA?: number[], localB?: number[]): Phaser.Physics.P2.Spring; + destroy(): void; + enable(object: any, debug?: boolean, children?: boolean): void; + enableBody(object: any, debug: boolean): void; + endContactHandler(event: any): void; + getBodies(): Phaser.Physics.P2.Body[]; + getBody(object: any): Phaser.Physics.P2.Body; + getConstraints(): p2.Constraint[]; + 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: T): T; + removeContactMaterial(material: Phaser.Physics.P2.ContactMaterial): Phaser.Physics.P2.ContactMaterial; + removeSpring(spring: Phaser.Physics.P2.Spring): Phaser.Physics.P2.Spring; + reset(): void; + 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: any, group: Phaser.Physics.P2.CollisionGroup): void; + setImpactEvents(state: boolean): void; + setMaterial(material: Phaser.Physics.P2.Material, bodies?: Phaser.Physics.P2.Body[]): void; + setPostBroadphaseCallback(callback: Function, context: any): void; + setWorldMaterial(material: Phaser.Physics.P2.Material, left?: boolean, right?: boolean, top?: boolean, bottom?: boolean): void; + toJSON(): any; + 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; + collidesWith: Phaser.Physics.P2.CollisionGroup[]; + collideWorldBounds: boolean; + damping: number; + data: p2.Body; + debug: boolean; + debugBody: Phaser.Physics.P2.BodyDebug; + dynamic: boolean; + fixedRotation: boolean; + force: Phaser.Physics.P2.InversePointProxy; + kinematic: boolean; + game: Phaser.Game; + gravity: Phaser.Point; + id: number; + inertia: number; + mass: number; + motionState: number; + offset: Phaser.Point; + onBeginContact: Phaser.Signal; + onEndContact: Phaser.Signal; + rotation: number; + removeNextStep: boolean; + sprite: Phaser.Sprite; + sleepSpeedLimit: number; + static: 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): p2.Capsule; + addCircle(radius: number, offsetX?: number, offsetY?: number, rotation?: number): p2.Circle; + addFixture(fixtureData: string): p2.Shape[]; + addLine(length: number, offsetX?: number, offsetY?: number, rotation?: number): p2.Line; + addParticle(offsetX?: number, offsetY?: number, rotation?: number): p2.Particle; + addPolygon(options: { optimalDecomp?: boolean; skipSimpleCheck?: boolean; removeCollinearPoints?: boolean; }, points: number[][]): boolean; + addPhaserPolygon(key: string, object: string): Phaser.Physics.P2.FixtureList; + addPlane(offsetX?: number, offsetY?: number, rotation?: number): p2.Plane; + addRectangle(width: number, height: number, offsetX?: number, offsetY?: number, rotation?: number): p2.Rectangle; + addShape(shape: p2.Shape, offsetX?: number, offsetY?: number, rotation?: number): p2.Shape; + adjustCenterOfMass(): void; + applyDamping(dt: number): void; + applyForce(force: number[], worldX: number, worldY: number): void; + clearCollision(clearGroup?: boolean, cleanMask?: boolean, shape?: p2.Shape): void; + clearShapes(): void; + collides(group: any, callback?: Function, callbackContext?: any, shape?: p2.Shape): void; + createBodyCallback(object: any, callback: Function, callbackContext: any): void; + createGroupCallback(group: Phaser.Physics.P2.CollisionGroup, callback: Function, callbackContext: any): void; + destroy(): void; + getCollisionMask(): number; + 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: p2.Shape): 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): p2.Circle; + setCollisionGroup(group: Phaser.Physics.P2.CollisionGroup, shape?: p2.Shape): void; + setRectangle(width?: number, height?: number, offsetX?: number, offsetY?: number, rotation?: number): p2.Rectangle; + setRectangleFromSprite(sprite: any): p2.Rectangle; + setMaterial(material: Phaser.Physics.P2.Material, shape?: p2.Shape): void; + setZeroDamping(): void; + setZeroForce(): void; + setZeroRotation(): void; + setZeroVelocity(): void; + toLocalFrame(out: number[], worldPoint: number[]): void; + thrust(speed: number): void; + toWorldFrame(out: number[], localPoint: number[]): void; + updateCollisionMask(shape?: p2.Shape): void; + + } + + class BodyDebug extends Phaser.Group { + + constructor(game: Phaser.Game, body: Phaser.Physics.P2.Body, settings: { pixelsPerLengthUnit?: number; debugPolygons?: boolean; lineWidth?: number; alpha?: number; }); + + body: Phaser.Physics.P2.Body; + canvas: Phaser.Graphics; + ppu: number; + + updateSpriteTransform(): void; + draw(): void; + + } + + class CollisionGroup { + + constructor(bitmask: number); + + mask: number; + + } + + class ContactMaterial extends p2.ContactMaterial { + + } + + class DistanceConstraint extends p2.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: any, fixtureKey: string): void; + setSensor(value: boolean, fixtureKey: string): void; + + } + + class GearConstraint extends p2.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; + mx: number; + my: number; + + } + + class LockConstraint extends p2.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 extends p2.Material { + + constructor(name: string); + + name: string; + + } + + class PointProxy { + + constructor(world: Phaser.Physics.P2, destination: any); + + x: number; + y: number; + mx: number; + my: number; + + } + + class PrismaticConstraint extends p2.PrismaticConstraint { + + constructor(world: Phaser.Physics.P2, bodyA?: Phaser.Physics.P2.Body, bodyB?: Phaser.Physics.P2.Body, lockRotation?: boolean, anchorA?: number[], anchorB?: number[], axis?: number[], maxForce?: number); + + game: Phaser.Game; + world: Phaser.Physics.P2; + + } + + class RevoluteContraint extends p2.RevoluteConstraint { + + constructor(world: Phaser.Physics.P2, bodyA: Phaser.Physics.P2.Body, pivotA: number[], bodyB: Phaser.Physics.P2.Body, pivotB: number[], 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?: number[], worldB?: number[], localA?: number[], localB?: number[]); + + data: p2.LinearSpring; + 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): any; + getComplementHarmony(color: number): number; + getSplitComplementHarmony(color: number, threshold: number): any; + getTriadicHarmony(color: number): any; + + } + + 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): void; + 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 subtract(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point; + static multiply(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point; + static divide(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point; + static equals(a: Phaser.Point, b: Phaser.Point): boolean; + static angle(a: Phaser.Point, b: Phaser.Point): number; + static angleSq(a: Phaser.Point, b: Phaser.Point): number; + static negative(a: Phaser.Point, out?: Phaser.Point): Phaser.Point; + static multiplyAdd(a: Phaser.Point, b: Phaser.Point, scale: number, out?: Phaser.Point): Phaser.Point; + static interpolate(a: Phaser.Point, b: Phaser.Point, alpha: number, out?: Phaser.Point): Phaser.Point; + static parse(obj: any, xProp?: string, yProp?: string): Phaser.Point; + static perp(a: Phaser.Point, out?: Phaser.Point): Phaser.Point; + static rperp(a: Phaser.Point, out?: Phaser.Point): Phaser.Point; + static distance(a: any, b: any, round?: boolean): number; + static project(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point; + static projectUnit(a: Phaser.Point, b: Phaser.Point, out?: Phaser.Point): Phaser.Point; + static normalRightHand(a: Phaser.Point, out?: Phaser.Point): Phaser.Point; + static normalize(a: 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 centroid(points: 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): 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: Phaser.Point): Phaser.Point; + copyTo(dest: T): T; + ceil(): Phaser.Point; + cross(a: Phaser.Point): number; + divide(x: number, y: number): Phaser.Point; + distance(dest: Phaser.Point, round?: boolean): number; + dot(a: Phaser.Point): number; + equals(a: Phaser.Point): boolean; + floor(): Phaser.Point; + getMagnitude(): number; + getMagnitudeSq(): number; + invert(): Phaser.Point; + isZero(): boolean; + multiply(x: number, y: number): Phaser.Point; + normalize(): Phaser.Point; + normalRightHand(): Phaser.Point; + perp(): Phaser.Point; + rperp(): Phaser.Point; + rotate(x: number, y: number, angle: number, asDegrees?: boolean, distance?: number): 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; + dirty: boolean; + 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; + + addClickTrampoline(name: string, callback: Function, callbackContext: any, ...callbackArgs: any[]): void; + 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[]; //number : point + type: number; + + clone(output: Phaser.Polygon): Phaser.Polygon; + contains(x: number, y: number): boolean; + setTo(points: any[]): void; + + } + + 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: any): 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(ary: T[]): T; + real(): number; + realInRange(min: number, max: number): number; + sow(seeds: number[]): void; + timestamp(min: number, max: number): number; + uuid(): number; + weightedPick(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; + topRight: Phaser.Point; + volume: number; + width: number; + x: number; + y: number; + + static aabb(points: Phaser.Point[], out?: Phaser.Rectangle): Phaser.Rectangle; + 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; + + centerOn(x: number, y: number): 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): any; + 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; + scale(x: number, y?: 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, resolution?: number); + + crop: PIXI.Rectangle; + game: Phaser.Game; + key: string; + type: number; + + render(displayObject: PIXI.DisplayObject, position: Phaser.Point, clear?: boolean): void; + 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(rafTime: number): 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: Image; + frameData: Phaser.FrameData; + 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 Rope extends PIXI.Rope { + + constructor(game: Phaser.Game, x: number, y: number, key: any, frame?: any, points?: Phaser.Point[]); + + angle: number; + animations: AnimationManager; + autoCull: boolean; + body: any; + cameraOffset: Phaser.Point; + checkWorldBounds: boolean; + destroyPhase: boolean; + exists: boolean; + events: Phaser.Events; + fixedToCamera: boolean; + frame: number; + frameName: string; + game: Phaser.Game; + input: Phaser.InputHandler; + inputEnabled: boolean; + key: any; + name: string; + points: Phaser.Point[]; + position: Phaser.Point; + segments: Phaser.Rectangle[]; + type: number; + world: Phaser.Point; + x: number; + y: number; + z: number; + + destroy(destroyChildren?: boolean): void; + loadTexture(key: any, frame?: any): void; + play(): void; + preUpdate(): void; + postUpdate(): void; + reset(x: number, y: number): void; + setFrame(frame: Phaser.Frame): void; + update(): void; + updateAnimation(): void; + + } + + class Signal { + + active: boolean; + boundDispatch: Function; + 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?: any, priority?: number); + + active: boolean; + callCount: number; + context: any; + 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: any); + + callbackContext: any; + 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; + addCallbacks(context: any, callbacks: any): void; + buttonValue(buttonCode: number): number; + connect(rawPad: any): void; + destroy(): 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: any): void; + processButtonDown(buttonCode: number, value: any): void; + processButtonFloat(buttonCode: number, value: any): void; + processButtonUp(buttonCode: number, value: any): void; + reset(): void; + + } + + class Sound { + + constructor(game: Phaser.Game, key: string, volume?: number, loop?: boolean, connect?: boolean); + + autoplay: boolean; + allowMultiple: boolean; + context: any; + currentMarker: string; + currentTime: number; + destroy(remove?: boolean): void; + duration: number; + durationMS: number; + externalNode: any; + game: Phaser.Game; + gainNode: any; + isDecoded: boolean; + isDecoding: boolean; + isPlaying: boolean; + key: string; + loop: boolean; + markers: any; + masterGainNode: any; + mute: boolean; + name: string; + onDecoded: Phaser.Signal; + onFadeComplete: 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; + fadeIn(duration?: number, loop?: boolean): void; + fadeOut(duration?: number): void; + fadeTo(duration?: number, volume?: number): 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; + addSprite(key: string): Phaser.AudioSprite; + boot(): void; + decode(key: string, sound?: Phaser.Sound): void; + destroy(): 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; + scaleMin: Phaser.Point; + scaleMax: 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; + setScaleMinMax(minX?: number, minY?: number, maxX?: number, maxY?: number): 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); + + backgroundColor: any; + currentRenderOrderID: number; + disableVisibilityChange: boolean; + exists: boolean; + game: Phaser.Game; + name: string; + smoothed: boolean; + + boot(): void; + checkVisiblity(): void; + destroy(): void; + parseConfig(config: any): void; + postUpdate(): void; + preUpdate(): void; + setBackgroundColor(backgroundColor: number): void; + setBackgroundColor(backgroundColor: string): void; + update(): void; + visibilityChange(event: any): void; + + } + + interface ResizeCallback { + (width: number, height: number): any; + } + + class ScaleManager { + + constructor(game: Phaser.Game, width: number, height: number); + constructor(game: Phaser.Game, width: string, height: string); + + static EXACT_FIT: number; + static NO_SCALE: number; + static SHOW_ALL: number; + static RESIZE: number; + static USER_SCALE: number; + + aspectRatio: number; + bounds: Rectangle; + boundingParent: HTMLElement; + compatibility: { + canExpandParent: boolean; + forceMinimumDocumentHeight: boolean; + noMargins: boolean; + scrollTo: Point; + supportsFullScreen: boolean; + }; + currentScaleMode: number; + dom: Phaser.DOM; + enterIncorrectOrientation: Signal; + enterFullScreen: Signal; + enterLandscape: Signal; + enterPortrait: Signal; + event: any; + forceLandscape: boolean; + forcePortrait: boolean; + fullScreenScaleMode: number; + fullScreenFailed: Signal; + fullScreenTarget: HTMLElement; + game: Phaser.Game; + grid: Phaser.FlexGrid; + height: number; + incorrectOrientation: boolean; + isFullScreen: boolean; + isPortrait: boolean; + isLandscape: boolean; + leaveFullScreen: Signal; + leaveIncorrectOrientation: Signal; + margin: { left: number; top: number; right: number; bottom: number; x: number; y: number; }; + maxIterations: number; + maxHeight: number; + maxWidth: number; + minHeight: number; + minWidth: number; + offset: Point; + onFullScreenInit: Phaser.Signal; + onFullScreenChange: Phaser.Signal; + onFullScreenError: Phaser.Signal; + onOrientationChange: Phaser.Signal; + onSizeChange: Signal; + orientation: number; + pageAlignHorizontally: boolean; + pageAlignVertically: boolean; + parentNode: HTMLElement; + parentIsWindow: boolean; + parentScaleFactor: Point; + scaleFactor: Point; + scaleFactorInversed: Point; + scaleMode: number; + screenOrientation: string; + sourceAspectRatio: number; + trackParentInterval: number; + width: number; + windowConstraints: { + bottom: boolean; + right: boolean; + }; + + boot(): void; + checkOrientationState(): boolean; + createFullScreenTarget(): HTMLDivElement; + destroy(): void; + forceOrientation(forceLandscape: boolean, forcePortrait?: boolean): void; + getParentBounds(target?: Rectangle): Rectangle; + parseConfig(config: any): void; + preUpdate(): void; + pauseUpdate(): void; + refresh(): void; + setGameSize(width: number, height: number): void; + setResizeCallback(callback: ResizeCallback, context: any): void; + setUserScale(hScale: number, vScale: number, hTrim?: number, vTrim?: number): void; + setMinMax(minWidth: number, minHeight: number, maxWidth?: number, maxHeight?: number): void; + setupScale(width: number, height: number): void; + setupScale(width: string, height: string): void; + scaleSprite(sprite: Sprite, width?: number, height?: number, letterBox?: boolean): Sprite; + scaleSprite(sprite: Image, width?: number, height?: number, letterBox?: boolean): Sprite; + startFullScreen(antialias?: boolean, allowTrampoline?: boolean): boolean; + stopFullScreen(): boolean; + + } + + class DOM { + + static visualBounds: Phaser.Rectangle; + static layoutBounds: Phaser.Rectangle; + static documentBounds: Phaser.Rectangle; + + static calibrate(coords: any, cushion?: number): any; + static getAspectRatio(object: any): number; + static getScreenOrientation(primaryFallback?: string): string; + static getBounds(element: any, cushion?: number): any; + static getOffset(element: any, point?: Point): Point; + static inLayoutViewport(element: any, cushion?: number): boolean; + + } + + 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; + 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; + resize(): 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; + onResizeCallback: Function; + onShutDownCallback: Function; + onUpdateCallback: Function; + states: any; + + add(key: string, state: any, autoStart?: boolean): void; + checkState(key: string): boolean; + clearCurrentState(): void; + destroy(): void; + getCurrentState(): Phaser.State; + link(key: string): void; + loadComplete(): void; + pause(): void; + preRender(elapsedTime: number): void; + preUpdate(): void; + render(): void; + remove(key: string): void; + resume(): void; + restart(clearWorld?: boolean, clearCache?: boolean): void; + resize(width: number, height: number): void; + start(key: string, clearWorld?: boolean, clearCache?: boolean, ...args: any[]): void; + update(): void; + unlink(key: string): 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; + colors: string[]; + destroyPhase: boolean; + events: Phaser.Events; + exists: boolean; + fill: any; + fixedToCamera: boolean; + font: string; + fontSize: number; + fontWeight: string; + 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; + + addColor(color: string, position: number): void; + clearColors(): void; + destroy(destroyChildren?: boolean): void; + postUpdate(): void; + preUpdate(): void; + setShadow(x?: number, y?: number, color?: any, blur?: number): void; + setStyle(style?: { font?: string; fill?: any; 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: any, index: number, x: number, y: Number, width: number, height: number);// + + alpha: number; + bottom: number; + callback: Function; + callbackContext: any; + centerX: number; + centerY: number; + canCollide: boolean; + collideDown: boolean; + collideLeft: boolean; + collideNone: boolean; + collideRight: boolean; + collisionCallback: Function; + collisionCallbackContext: any; + collides: boolean; + collideUp: boolean; + faceBottom: boolean; + faceLeft: boolean; + faceRight: boolean; + faceTop: boolean; + game: Phaser.Game; + height: number; + index: number; + layer: any; + left: number; + properties: any; + right: number; + scanned: boolean; + top: number; + width: number; + worldX: number; + worldY: number; + x: number; + y: number; + + copy(tile: Phaser.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: any): 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: any[]; + objects: any[]; + orientation: string; + properties: any; + 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?: any, adjustY?: boolean): void; + createFromTiles(tiles: any, replacements: any, key: string, layer?: any, group?: Phaser.Group, properties?: any): number; + 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: any, layer?: any): void; + setTileLocationCallback(x: number, y: number, width: number, height: number, callback: Function, callbackContext: any, 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; + debugSettings: { missingImageFill: string; debuggedTileOverfill: string; forceFullRedraw: boolean; debugAlpha: number; facingEdgeStroke: string; collidingTileOverfill: string; }; + dirty: boolean; + fixedToCamera: boolean; + game: Phaser.Game; + index: number; + layer: Phaser.TilemapLayer; + map: Phaser.Tilemap; + name: string; + rayStepRate: number; + renderSettings: { enableScrollDelta: boolean; overdrawRatio: 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): number; + getTileXY(x: number, y: number, point: Phaser.Point): Phaser.Point; + getTileY(y: number): number; + postUpdate(): void; + render(): void; + resizeWorld(): void; + resetTilesetCache(): void; + updateMax(): void; + + } + + class TilemapParser { + + static getEmptyData(tileWidth?: number, tileHeight?: number, width?: number, height?: number): any; + static parse(game: Phaser.Game, key: string, tileWidth?: number, tileHeight?: number, width?: number, height?: number): any; + static parseCSV(key: string, data: string, tileWidth?: number, tileHeight?: number): any; + static parseJSON(json: any): any; + + } + + class Tileset { + + constructor(name: string, firstgid: number, width?: number, height?: number, margin?: number, spacing?: number, properties?: any); + + columns: number; + firstgid: number; + image: any; + name: string; + properties: any; + rows: number; + tileHeight: number; + tileMargin: number; + tileSpacing: number; + tileWidth: number; + total: number; + + containsTileIndex(tileIndex: number): boolean; + 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); + + alive: boolean; + 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; + desiredFps: number; + elapsed: number; + events: Phaser.Timer; + elapsedMS: number; + 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; + physicsElapsedMS: number; + prevTime: number; + slowMotion: number; + suggestedFps: number; + time: number; + timeExpected: 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: any, ...args: any[]): Phaser.TimerEvent; + clearPendingEvents(): void; + destroy(): void; + loop(delay: number, callback: Function, callbackContext: any, ...args: any[]): Phaser.TimerEvent; + order(): void; + pause(): void; + remove(event: Phaser.TimerEvent): boolean; + removeAll(): void; + repeat(delay: number, repeatCount: number, callback: Function, callbackContext: any, ...args: any[]): Phaser.TimerEvent; + resume(): void; + sortHandler(a: any, b: any): number; + start(startDelay?: number): void; + stop(clearEvents?: boolean): void; + update(time: number): boolean; + + } + + class TimerEvent { + + constructor(timer: Phaser.Timer, delay: number, tick: number, repeatCount: number, loop: boolean, callback: Function, callbackContext: any, ...args: any[]); + + args: any[]; + callback: Function; + callbackContext: any; + delay: number; + loop: boolean; + pendingDelete: boolean; + repeatCount: number; + tick: number; + timer: Phaser.Timer; + + } + + class Touch { + + constructor(game: Phaser.Game); + + callbackContext: any; + disabled: boolean; + enabled: 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(target: any, game: Phaser.Game, manager: Phaser.TweenManager); + + chainedTween: Phaser.Tween; + current: number; + game: Phaser.Game; + isRunning: boolean; + isPaused: boolean; + manager: Phaser.TweenManager; + onChildComplete: Phaser.Signal; + onComplete: Phaser.Signal; + onLoop: Phaser.Signal; + onRepeat: Phaser.Signal; + onStart: Phaser.Signal; + pendingDelete: boolean; + properties: any; + repeatCounter: number; + repeatDelay: number; + reverse: boolean; + target: any; + timeline: Phaser.TweenData[]; + timeScale: number; + totalDuration: number; + + chain(...args: any[]): Phaser.Tween; + delay(duration: number, index?: number): Phaser.Tween; + easing(ease: Function, index?: number): Phaser.Tween; + easing(ease: string, index?: number): Phaser.Tween; + from(properties: any, duration?: number, ease?: Function, autoStart?: boolean, delay?: number, repeat?: number, yoyo?: boolean): Phaser.Tween; + from(properties: any, duration?: number, ease?: string, autoStart?: boolean, delay?: number, repeat?: number, yoyo?: boolean): Phaser.Tween; + generateData(frameRate?: number, data?: any): any[]; + interpolation(interpolation: Function, index?: number): Phaser.Tween; + loop(value?: boolean): Phaser.Tween; + onUpdateCallback(callback: Function, callbackContext: any): Phaser.Tween; + pause(): void; + repeat(total: number, index?: number): Phaser.Tween; + repeatAll(total?: number): Phaser.Tween; + resume(): void; + start(index?: number): Phaser.Tween; + stop(complete?: boolean): Phaser.Tween; + to(properties: any, duration?: number, ease?: Function, autoStart?: boolean, delay?: number, repeat?: number, yoyo?: boolean): Phaser.Tween; + to(properties: any, duration?: number, ease?: string, autoStart?: boolean, delay?: number, repeat?: number, yoyo?: boolean): Phaser.Tween; + update(time: number): boolean; + yoyo(enable: boolean, index?: number): Phaser.Tween; + + } + + class TweenData { + + constructor(parent: Phaser.Tween); + + static COMPLETE: number; + static LOOPED: number; + static PENDING: number; + static RUNNING: number; + + delay: number; + dt: number; + duration: number; + easingFunction: Function; + game: Phaser.Game; + inReverse: boolean; + interpolationFunction: Function; + isRunning: boolean; + isFrom: boolean; + parent: Phaser.Tween; + percent: number; + repeatCounter: number; + startTime: number; + value: number; + yoyo: boolean; + + from(properties: any, duration?: number, ease?: Function, delay?: number, repeat?: number, yoyo?: boolean): Phaser.TweenData; + generateData(frameRate?: number): any[]; + repeat(): number; + start(): Phaser.TweenData; + to(properties: any, duration?: number, ease?: Function, delay?: number, repeat?: number, yoyo?: boolean): Phaser.TweenData; + update(): number; + + } + + class TweenManager { + + constructor(game: Phaser.Game); + + game: Phaser.Game; + + add(tween: Phaser.Tween): Phaser.Tween; + create(object: any): Phaser.Tween; + getAll(): Phaser.Tween[]; + isTweening(object: any): boolean; + remove(tween: Phaser.Tween): Phaser.Tween; + removeAll(): void; + removeFrom(obj: any, children?: boolean): void; + resumeAll(): void; + update(): boolean; + pauseAll(): void; + + } + + class Utils { + + static extend(deep: boolean, target: any): any; + static getProperty(obj: any, prop: string): any; + static isPlainObject(object: any): boolean; + static mixin(from: any, to: any): any; + static pad(str: string, len: number, pad: number, dir?: number): string; + static parseDimension(size: any, dimension: number): number; + static rotateArray(array: T[], direction: any): T; + static setProperty(obj: any, prop: string, value: any): any; + static shuffle(array: T[]): T[]; + static transposeArray(array: T[]): T[]; + + } + + module Utils { + + class Debug { + + constructor(game: Phaser.Game); + + bmd: Phaser.BitmapData; + canvas: HTMLCanvasElement; + columnWidth: number; + context: CanvasRenderingContext2D; + currentAlpha: number; + currentX: number; + currentY: number; + dirty: boolean; + font: string; + game: Phaser.Game; + lineHeight: number; + renderShadow: boolean; + sprite: Phaser.Image; + + 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; + box2dBody(body: Phaser.Sprite, color?: string): void; + box2dWorld(): 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): void; + 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; + reset(): void; + ropeSegments(rope: Phaser.Rope, color?: number, 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?: any): Phaser.Sprite; + resize(width: number, height: number): void; + setBounds(x: number, y: number, width: number, height: number): void; + shutdown(): void; + wrap(sprite: any, padding?: number, useBounds?: boolean, horizontal?: boolean, vertical?: boolean): void; + + } +} + +// Type definitions for p2.js v0.6.0 +// Project: https://github.com/schteppe/p2.js/ + +declare module p2 { + + export class AABB { + + constructor(options?: { + upperBound?: number[]; + lowerBound?: number[]; + }); + + setFromPoints(points: number[][], position: number[], angle: number, skinSize: number): void; + copy(aabb: AABB): void; + extend(aabb: AABB): void; + overlaps(aabb: AABB): boolean; + + } + + export class Broadphase { + + static AABB: number; + static BOUNDING_CIRCLE: number; + + static NAIVE: number; + static SAP: number; + + static boundingRadiusCheck(bodyA: Body, bodyB: Body): boolean; + static aabbCheck(bodyA: Body, bodyB: Body): boolean; + static canCollide(bodyA: Body, bodyB: Body): boolean; + + constructor(type: number); + + type: number; + result: Body[]; + world: World; + boundingVolumeType: number; + + setWorld(world: World): void; + getCollisionPairs(world: World): Body[]; + boundingVolumeCheck(bodyA: Body, bodyB: Body): boolean; + + } + + export class GridBroadphase extends Broadphase { + + constructor(options?: { + xmin?: number; + xmax?: number; + ymin?: number; + ymax?: number; + nx?: number; + ny?: number; + }); + + xmin: number; + xmax: number; + ymin: number; + ymax: number; + nx: number; + ny: number; + binsizeX: number; + binsizeY: number; + + } + + export class NativeBroadphase extends Broadphase { + + } + + export class Narrowphase { + + contactEquations: ContactEquation[]; + frictionEquations: FrictionEquation[]; + enableFriction: boolean; + slipForce: number; + frictionCoefficient: number; + surfaceVelocity: number; + reuseObjects: boolean; + resuableContactEquations: any[]; + reusableFrictionEquations: any[]; + restitution: number; + stiffness: number; + relaxation: number; + frictionStiffness: number; + frictionRelaxation: number; + enableFrictionReduction: boolean; + contactSkinSize: number; + + collidedLastStep(bodyA: Body, bodyB: Body): boolean; + reset(): void; + createContactEquation(bodyA: Body, bodyB: Body, shapeA: Shape, shapeB: Shape): ContactEquation; + createFrictionFromContact(c: ContactEquation): FrictionEquation; + + } + + export class SAPBroadphase extends Broadphase { + + axisList: Body[]; + axisIndex: number; + + } + + export class Constraint { + + static DISTANCE: number; + static GEAR: number; + static LOCK: number; + static PRISMATIC: number; + static REVOLUTE: number; + + constructor(bodyA: Body, bodyB: Body, type: number, options?: { + collideConnected?: boolean; + wakeUpBodies?: boolean; + }); + + type: number; + equeations: Equation[]; + bodyA: Body; + bodyB: Body; + collideConnected: boolean; + + update(): void; + setStiffness(stiffness: number): void; + setRelaxation(relaxation: number): void; + + } + + export class DistanceConstraint extends Constraint { + + constructor(bodyA: Body, bodyB: Body, type: number, options?: { + collideConnected?: boolean; + wakeUpBodies?: boolean; + distance?: number; + localAnchorA?: number[]; + localAnchorB?: number[]; + maxForce?: number; + }); + + localAnchorA: number[]; + localAnchorB: number[]; + distance: number; + maxForce: number; + upperLimitEnabled: boolean; + upperLimit: number; + lowerLimitEnabled: boolean; + lowerLimit: number; + position: number; + + setMaxForce(f: number): void; + getMaxForce(): number; + + } + + export class GearConstraint extends Constraint { + + constructor(bodyA: Body, bodyB: Body, type: number, options?: { + collideConnected?: boolean; + wakeUpBodies?: boolean; + angle?: number; + ratio?: number; + maxTorque?: number; + }); + + ratio: number; + angle: number; + + setMaxTorque(torque: number): void; + getMaxTorque(): number; + + } + + export class LockConstraint extends Constraint { + + constructor(bodyA: Body, bodyB: Body, type: number, options?: { + collideConnected?: boolean; + wakeUpBodies?: boolean; + localOffsetB?: number[]; + localAngleB?: number; + maxForce?: number; + }); + + setMaxForce(force: number): void; + getMaxForce(): number; + + } + + export class PrismaticConstraint extends Constraint { + + constructor(bodyA: Body, bodyB: Body, type: number, options?: { + collideConnected?: boolean; + wakeUpBodies?: boolean; + maxForce?: number; + localAnchorA?: number[]; + localAnchorB?: number[]; + localAxisA?: number[]; + disableRotationalLock?: boolean; + upperLimit?: number; + lowerLimit?: number; + }); + + localAnchorA: number[]; + localAnchorB: number[]; + localAxisA: number[]; + position: number; + velocity: number; + lowerLimitEnabled: boolean; + upperLimitEnabled: boolean; + lowerLimit: number; + upperLimit: number; + upperLimitEquation: ContactEquation; + lowerLimitEquation: ContactEquation; + motorEquation: Equation; + motorEnabled: boolean; + motorSpeed: number; + + enableMotor(): void; + disableMotor(): void; + setLimits(lower: number, upper: number): void; + + } + + export class RevoluteConstraint extends Constraint { + + constructor(bodyA: Body, bodyB: Body, type: number, options?: { + collideConnected?: boolean; + wakeUpBodies?: boolean; + worldPivot?: number[]; + localPivotA?: number[]; + localPivotB?: number[]; + maxForce?: number; + }); + + pivotA: number[]; + pivotB: number[]; + motorEquation: RotationalVelocityEquation; + motorEnabled: boolean; + angle: number; + lowerLimitEnabled: boolean; + upperLimitEnabled: boolean; + lowerLimit: number; + upperLimit: number; + upperLimitEquation: ContactEquation; + lowerLimitEquation: ContactEquation; + + enableMotor(): void; + disableMotor(): void; + motorIsEnabled(): boolean; + setLimits(lower: number, upper: number): void; + setMotorSpeed(speed: number): void; + getMotorSpeed(): number; + + } + + export class AngleLockEquation extends Equation { + + constructor(bodyA: Body, bodyB: Body, options?: { + angle?: number; + ratio?: number; + }); + + computeGq(): number; + setRatio(ratio: number): number; + setMaxTorque(torque: number): number; + + } + + export class ContactEquation extends Equation { + + constructor(bodyA: Body, bodyB: Body); + + contactPointA: number[]; + penetrationVec: number[]; + contactPointB: number[]; + normalA: number[]; + restitution: number; + firstImpact: boolean; + shapeA: Shape; + shapeB: Shape; + + computeB(a: number, b: number, h: number): number; + + } + + export class Equation { + + static DEFAULT_STIFFNESS: number; + static DEFAULT_RELAXATION: number; + + constructor(bodyA: Body, bodyB: Body, minForce?: number, maxForce?: number); + + minForce: number; + maxForce: number; + bodyA: Body; + bodyB: Body; + stiffness: number; + relaxation: number; + G: number[]; + offset: number; + a: number; + b: number; + epsilon: number; + timeStep: number; + needsUpdate: boolean; + multiplier: number; + relativeVelocity: number; + enabled: boolean; + + gmult(G: number[], vi: number[], wi: number[], vj: number[], wj: number[]): number; + computeB(a: number, b: number, h: number): number; + computeGq(): number; + computeGW(): number; + computeGWlambda(): number; + computeGiMf(): number; + computeGiMGt(): number; + addToWlambda(deltalambda: number): number; + computeInvC(eps: number): number; + + } + + export class FrictionEquation extends Equation { + + constructor(bodyA: Body, bodyB: Body, slipForce: number); + + contactPointA: number[]; + contactPointB: number[]; + t: number[]; + shapeA: Shape; + shapeB: Shape; + frictionCoefficient: number; + + setSlipForce(slipForce: number): number; + getSlipForce(): number; + computeB(a: number, b: number, h: number): number; + + } + + export class RotationalLockEquation extends Equation { + + constructor(bodyA: Body, bodyB: Body, options?: { + angle?: number; + }); + + angle: number; + + computeGq(): number; + + } + + export class RotationalVelocityEquation extends Equation { + + constructor(bodyA: Body, bodyB: Body); + + computeB(a: number, b: number, h: number): number; + + } + + export class EventEmitter { + + on(type: string, listener: Function, context: any): EventEmitter; + has(type: string, listener: Function): boolean; + off(type: string, listener: Function): EventEmitter; + emit(event: any): EventEmitter; + + } + + export class ContactMaterialOptions { + + friction: number; + restitution: number; + stiffness: number; + relaxation: number; + frictionStiffness: number; + frictionRelaxation: number; + surfaceVelocity: number; + + } + + export class ContactMaterial { + + static idCounter: number; + + constructor(materialA: Material, materialB: Material, options?: ContactMaterialOptions); + + id: number; + materialA: Material; + materialB: Material; + friction: number; + restitution: number; + stiffness: number; + relaxation: number; + frictionStuffness: number; + frictionRelaxation: number; + surfaceVelocity: number; + contactSkinSize: number; + + } + + export class Material { + + static idCounter: number; + + constructor(id: number); + + id: number; + + } + + export class vec2 { + + static crossLength(a: number[], b: number[]): number; + static crossVZ(out: number[], vec: number[], zcomp: number): number; + static crossZV(out: number[], zcomp: number, vec: number[]): number; + static rotate(out: number[], a: number[], angle: number): void; + static rotate90cw(out: number[], a: number[]): number; + static centroid(out: number[], a: number[], b: number[], c: number[]): number[]; + static create(): number[]; + static clone(a: number[]): number[]; + static fromValues(x: number, y: number): number[]; + static copy(out: number[], a: number[]): number[]; + static set(out: number[], x: number, y: number): number[]; + static toLocalFrame(out: number[], worldPoint: number[], framePosition: number[], frameAngle: number): void; + static toGlobalFrame(out: number[], localPoint: number[], framePosition: number[], frameAngle: number): void; + static add(out: number[], a: number[], b: number[]): number[]; + static subtract(out: number[], a: number[], b: number[]): number[]; + static sub(out: number[], a: number[], b: number[]): number[]; + static multiply(out: number[], a: number[], b: number[]): number[]; + static mul(out: number[], a: number[], b: number[]): number[]; + static divide(out: number[], a: number[], b: number[]): number[]; + static div(out: number[], a: number[], b: number[]): number[]; + static scale(out: number[], a: number[], b: number): number[]; + static distance(a: number[], b: number[]): number; + static dist(a: number[], b: number[]): number; + static squaredDistance(a: number[], b: number[]): number; + static sqrDist(a: number[], b: number[]): number; + static length(a: number[]): number; + static len(a: number[]): number; + static squaredLength(a: number[]): number; + static sqrLen(a: number[]): number; + static negate(out: number[], a: number[]): number[]; + static normalize(out: number[], a: number[]): number[]; + static dot(a: number[], b: number[]): number; + static str(a: number[]): string; + + } + + export class BodyOptions { + + mass: number; + position: number[]; + velocity: number[]; + angle: number; + angularVelocity: number; + force: number[]; + angularForce: number; + fixedRotation: number; + + } + + export class Body extends EventEmitter { + + sleepyEvent: { + type: string; + }; + + sleepEvent: { + type: string; + }; + + wakeUpEvent: { + type: string; + }; + + static DYNAMIC: number; + static STATIC: number; + static KINEMATIC: number; + static AWAKE: number; + static SLEEPY: number; + static SLEEPING: number; + + constructor(options?: BodyOptions); + + id: number; + world: World; + shapes: Shape[]; + shapeOffsets: number[][]; + shapeAngles: number[]; + mass: number; + invMass: number; + inertia: number; + invInertia: number; + invMassSolve: number; + invInertiaSolve: number; + fixedRotation: number; + position: number[]; + interpolatedPosition: number[]; + interpolatedAngle: number; + previousPosition: number[]; + previousAngle: number; + velocity: number[]; + vlambda: number[]; + wlambda: number[]; + angle: number; + angularVelocity: number; + force: number[]; + angularForce: number; + damping: number; + angularDamping: number; + type: number; + boundingRadius: number; + aabb: AABB; + aabbNeedsUpdate: boolean; + allowSleep: boolean; + wantsToSleep: boolean; + sleepState: number; + sleepSpeedLimit: number; + sleepTimeLimit: number; + gravityScale: number; + + updateSolveMassProperties(): void; + setDensity(density: number): void; + getArea(): number; + getAABB(): AABB; + updateAABB(): void; + updateBoundingRadius(): void; + addShape(shape: Shape, offset?: number[], angle?: number): void; + removeShape(shape: Shape): boolean; + updateMassProperties(): void; + applyForce(force: number[], worldPoint: number[]): void; + toLocalFrame(out: number[], worldPoint: number[]): void; + toWorldFrame(out: number[], localPoint: number[]): void; + fromPolygon(path: number[][], options?: { + optimalDecomp?: boolean; + skipSimpleCheck?: boolean; + removeCollinearPoints?: any; //boolean | number + }): boolean; + adjustCenterOfMass(): void; + setZeroForce(): void; + resetConstraintVelocity(): void; + applyDamping(dy: number): void; + wakeUp(): void; + sleep(): void; + sleepTick(time: number, dontSleep: boolean, dt: number): void; + getVelocityFromPosition(story: number[], dt: number): number[]; + getAngularVelocityFromPosition(timeStep: number): number; + overlaps(body: Body): boolean; + + } + + export class Spring { + + constructor(bodyA: Body, bodyB: Body, options?: { + + stiffness?: number; + damping?: number; + localAnchorA?: number[]; + localAnchorB?: number[]; + worldAnchorA?: number[]; + worldAnchorB?: number[]; + + }); + + stiffness: number; + damping: number; + bodyA: Body; + bodyB: Body; + + applyForce(): void; + + } + + export class LinearSpring extends Spring { + + localAnchorA: number[]; + localAnchorB: number[]; + restLength: number; + + setWorldAnchorA(worldAnchorA: number[]): void; + setWorldAnchorB(worldAnchorB: number[]): void; + getWorldAnchorA(result: number[]): number[]; + getWorldAnchorB(result: number[]): number[]; + applyForce(): void; + + } + + export class RotationalSpring extends Spring { + + constructor(bodyA: Body, bodyB: Body, options?: { + restAngle?: number; + stiffness?: number; + damping?: number; + }); + + restAngle: number; + + } + + export class Capsule extends Shape { + + constructor(length?: number, radius?: number); + + length: number; + radius: number; + + } + + export class Circle extends Shape { + + constructor(radius: number); + + radius: number; + + } + + export class Convex extends Shape { + + static triangleArea(a: number[], b: number[], c: number[]): number; + + constructor(vertices: number[][], axes: number[]); + + vertices: number[][]; + axes: number[]; + centerOfMass: number[]; + triangles: number[]; + boundingRadius: number; + + projectOntoLocalAxis(localAxis: number[], result: number[]): void; + projectOntoWorldAxis(localAxis: number[], shapeOffset: number[], shapeAngle: number, result: number[]): void; + + updateCenterOfMass(): void; + + } + + export class Heightfield extends Shape { + + constructor(data: number[], options?: { + minValue?: number; + maxValue?: number; + elementWidth: number; + }); + + data: number[]; + maxValue: number; + minValue: number; + elementWidth: number; + + } + + export class Shape { + + static idCounter: number; + static CIRCLE: number; + static PARTICLE: number; + static PLANE: number; + static CONVEX: number; + static LINE: number; + static RECTANGLE: number; + static CAPSULE: number; + static HEIGHTFIELD: number; + + constructor(type: number); + + type: number; + id: number; + boundingRadius: number; + collisionGroup: number; + collisionMask: number; + material: Material; + area: number; + sensor: boolean; + + computeMomentOfInertia(mass: number): number; + updateBoundingRadius(): number; + updateArea(): void; + computeAABB(out: AABB, position: number[], angle: number): void; + + } + + export class Line extends Shape { + + constructor(length?: number); + + length: number; + + } + + export class Particle extends Shape { + + } + + export class Plane extends Shape { + + } + + export class Rectangle extends Shape { + + static sameDimensions(a: Rectangle, b: Rectangle): boolean; + + constructor(width?: number, height?: number); + + width: number; + height: number; + + } + + export class Solver extends EventEmitter { + + static GS: number; + static ISLAND: number; + + constructor(options?: {}, type?: number); + + type: number; + equations: Equation[]; + equationSortFunction: Equation; //Equation | boolean + + solve(dy: number, world: World): void; + solveIsland(dy: number, island: Island): void; + sortEquations(): void; + addEquation(eq: Equation): void; + addEquations(eqs: Equation[]): void; + removeEquation(eq: Equation): void; + removeAllEquations(): void; + + } + + export class GSSolver extends Solver { + + constructor(options?: { + iterations?: number; + tolerance?: number; + }); + + iterations: number; + tolerance: number; + useZeroRHS: boolean; + frictionIterations: number; + usedIterations: number; + + solve(h: number, world: World): void; + + } + + export class OverlapKeeper { + + constructor(bodyA: Body, shapeA: Shape, bodyB: Body, shapeB: Shape); + + shapeA: Shape; + shapeB: Shape; + bodyA: Body; + bodyB: Body; + + tick(): void; + setOverlapping(bodyA: Body, shapeA: Shape, bodyB: Body, shapeB: Body): void; + bodiesAreOverlapping(bodyA: Body, bodyB: Body): boolean; + set(bodyA: Body, shapeA: Shape, bodyB: Body, shapeB: Shape): void; + + } + + export class TupleDictionary { + + data: number[]; + keys: number[]; + + getKey(id1: number, id2: number): string; + getByKey(key: number): number; + get(i: number, j: number): number; + set(i: number, j: number, value: number): number; + reset(): void; + copy(dict: TupleDictionary): void; + + } + + export class Utils { + + static appendArray(a: Array, b: Array): Array; + static chanceRoll(chance: number): boolean; + static defaults(options: any, defaults: any): any; + static extend(a: any, b: any): void; + static randomChoice(choice1: any, choice2: any): any; + static rotateArray(matrix: any[], direction: any): any[]; + static splice(array: Array, index: number, howMany: number): void; + static shuffle(array: T[]): T[]; + static transposeArray(array: T[]): T[]; + + } + + export class Island { + + equations: Equation[]; + bodies: Body[]; + + reset(): void; + getBodies(result: any): Body[]; + wantsToSleep(): boolean; + sleep(): boolean; + + } + + export class IslandManager extends Solver { + + static getUnvisitedNode(nodes: Node[]): IslandNode; // IslandNode | boolean + + equations: Equation[]; + islands: Island[]; + nodes: IslandNode[]; + + visit(node: IslandNode, bds: Body[], eqs: Equation[]): void; + bfs(root: IslandNode, bds: Body[], eqs: Equation[]): void; + split(world: World): Island[]; + + } + + export class IslandNode { + + constructor(body: Body); + + body: Body; + neighbors: IslandNode[]; + equations: Equation[]; + visited: boolean; + + reset(): void; + + } + + export class World extends EventEmitter { + + postStepEvent: { + type: string; + }; + + addBodyEvent: { + type: string; + }; + + removeBodyEvent: { + type: string; + }; + + addSpringEvent: { + type: string; + }; + + impactEvent: { + type: string; + bodyA: Body; + bodyB: Body; + shapeA: Shape; + shapeB: Shape; + contactEquation: ContactEquation; + }; + + postBroadphaseEvent: { + type: string; + pairs: Body[]; + }; + + beginContactEvent: { + type: string; + shapeA: Shape; + shapeB: Shape; + bodyA: Body; + bodyB: Body; + contactEquations: ContactEquation[]; + }; + + endContactEvent: { + type: string; + shapeA: Shape; + shapeB: Shape; + bodyA: Body; + bodyB: Body; + }; + + preSolveEvent: { + type: string; + contactEquations: ContactEquation[]; + frictionEquations: FrictionEquation[]; + }; + + static NO_SLEEPING: number; + static BODY_SLEEPING: number; + static ISLAND_SLEEPING: number; + + static integrateBody(body: Body, dy: number): void; + + constructor(options?: { + solver?: Solver; + gravity?: number[]; + broadphase?: Broadphase; + islandSplit?: boolean; + doProfiling?: boolean; + }); + + springs: Spring[]; + bodies: Body[]; + solver: Solver; + narrowphase: Narrowphase; + islandManager: IslandManager; + gravity: number[]; + frictionGravity: number; + useWorldGravityAsFrictionGravity: boolean; + useFrictionGravityOnZeroGravity: boolean; + doProfiling: boolean; + lastStepTime: number; + broadphase: Broadphase; + constraints: Constraint[]; + defaultMaterial: Material; + defaultContactMaterial: ContactMaterial; + lastTimeStep: number; + applySpringForces: boolean; + applyDamping: boolean; + applyGravity: boolean; + solveConstraints: boolean; + contactMaterials: ContactMaterial[]; + time: number; + stepping: boolean; + islandSplit: boolean; + emitImpactEvent: boolean; + sleepMode: number; + + addConstraint(c: Constraint): void; + addContactMaterial(contactMaterial: ContactMaterial): void; + removeContactMaterial(cm: ContactMaterial): void; + getContactMaterial(materialA: Material, materialB: Material): ContactMaterial; // ContactMaterial | boolean + removeConstraint(c: Constraint): void; + step(dy: number, timeSinceLastCalled?: number, maxSubSteps?: number): void; + runNarrowphase(np: Narrowphase, bi: Body, si: Shape, xi: any[], ai: number, bj: Body, sj: Shape, xj: any[], aj: number, cm: number, glen: number): void; + addSpring(s: Spring): void; + removeSpring(s: Spring): void; + addBody(body: Body): void; + removeBody(body: Body): void; + getBodyByID(id: number): Body; //Body | boolean + disableBodyCollision(bodyA: Body, bodyB: Body): void; + enableBodyCollision(bodyA: Body, bodyB: Body): void; + clear(): void; + clone(): World; + hitTest(worldPoint: number[], bodies: Body[], precision: number): Body[]; + setGlobalEquationParameters(parameters: { + relaxation?: number; + stiffness?: number; + }): void; + setGlobalStiffness(stiffness: number): void; + setGlobalRelaxation(relaxation: number): void; + } + +} diff --git a/src/scripts/definitions/pixi.d.ts b/src/scripts/definitions/pixi.d.ts new file mode 100644 index 0000000..8fac045 --- /dev/null +++ b/src/scripts/definitions/pixi.d.ts @@ -0,0 +1,1900 @@ +// Type definitions for PIXI 2.2.0 dev 2014-11-02 +// Project: https://github.com/GoodBoyDigital/pixi.js/ + +declare module PIXI { + + 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 enum scaleModes { + + DEFAULT, + LINEAR, + NEAREST + + } + + export var defaultRenderOptions: PixiRendererOptions; + + export var INTERACTION_REQUENCY: number; + export var AUTO_PREVENT_DEFAULT: boolean; + + export var PI_2: number; + export var RAD_TO_DEG: number; + export var DEG_TO_RAD: number; + + export var RETINA_PREFIX: string; + export var identityMatrix: Matrix; + export var glContexts: WebGLRenderingContext[]; + export var instances: any[]; + + export var BaseTextureCache: { [key: string]: BaseTexture } + export var TextureCache: { [key: string]: Texture } + + export function isPowerOfTwo(width: number, height: number): boolean; + + export function rgb2hex(rgb: number[]): string; + export function hex2rgb(hex: string): number[]; + + export function autoDetectRenderer(width?: number, height?: number, options?: PixiRendererOptions): PixiRenderer; + export function autoDetectRecommendedRenderer(width?: number, height?: number, options?: PixiRendererOptions): PixiRenderer; + + export function canUseNewCanvasBlendModes(): boolean; + export function getNextPowerOfTwo(number: number): number; + + export function AjaxRequest(): XMLHttpRequest; + + export function CompileFragmentShader(gl: WebGLRenderingContext, shaderSrc: string[]): any; + export function CompileProgram(gl: WebGLRenderingContext, vertexSrc: string[], fragmentSrc: string[]): any; + + + export interface IEventCallback { + (e?: IEvent): void + } + + export interface IEvent { + type: string; + content: any; + } + + export interface HitArea { + contains(x: number, y: number): boolean; + } + + export interface IInteractionDataCallback { + (interactionData: InteractionData): void + } + + export interface PixiRenderer { + + autoResize: boolean; + height: number; + transparent: boolean; + type: number; + width: number; + view: HTMLCanvasElement; + + render(stage: Stage): void; + resize(width: number, height: number): void; + + } + + export interface PixiRendererOptions { + + autoResize?: boolean; + antialias?: boolean; + clearBeforeRender?: boolean; + preserveDrawingBuffer?: boolean; + resolution?: number; + transparent?: boolean; + view?: HTMLCanvasElement; + + } + + export interface BitmapTextStyle { + + font?: string; + align?: string; + tint?: string; + + } + + export interface TextStyle { + + align?: string; + dropShadow?: boolean; + dropShadowColor?: string; + dropShadowAngle?: number; + dropShadowDistance?: number; + fill?: string; + font?: string; + stroke?: string; + strokeThickness?: number; + wordWrap?: boolean; + wordWrapWidth?: number; + + } + + export interface Loader { + + load(): void; + + } + + export interface MaskData { + + alpha: number; + worldTransform: number[]; + + } + + export interface RenderSession { + + context: CanvasRenderingContext2D; + maskManager: CanvasMaskManager; + scaleMode: scaleModes; + smoothProperty: string; + roundPixels: boolean; + + } + + export interface ShaderAttribute { + // TODO: Find signature of shader attributes + } + + export interface FilterBlock { + + visible: boolean; + renderable: boolean; + + } + + export class AbstractFilter { + + constructor(fragmentSrc: string[], uniforms: any); + + dirty: boolean; + padding: number; + uniforms: any; + fragmentSrc: string[]; + + apply(frameBuffer: WebGLFramebuffer): void; + syncUniforms(): void; + + } + + export class AlphaMaskFilter extends AbstractFilter { + + constructor(texture: Texture); + + map: Texture; + + onTextureLoaded(): void; + + } + + export class AsciiFilter extends AbstractFilter { + + size: number; + + } + + export class AssetLoader implements Mixin { + + assetURLs: string[]; + crossorigin: boolean; + loadersByType: { [key: string]: Loader }; + + constructor(assetURLs: string[], crossorigin: boolean); + + listeners(eventName: string): Function[]; + emit(eventName: string, data?: any): boolean; + dispatchEvent(eventName: string, data?: any): boolean; + on(eventName: string, fn: Function): Function; + addEventListener(eventName: string, fn: Function): Function; + once(eventName: string, fn: Function): Function; + off(eventName: string, fn: Function): Function; + removeAllEventListeners(eventName: string): void; + + load(): void; + + + } + + export class AtlasLoader implements Mixin { + + url: string; + baseUrl: string; + crossorigin: boolean; + loaded: boolean; + + constructor(url: string, crossorigin: boolean); + + listeners(eventName: string): Function[]; + emit(eventName: string, data?: any): boolean; + dispatchEvent(eventName: string, data?: any): boolean; + on(eventName: string, fn: Function): Function; + addEventListener(eventName: string, fn: Function): Function; + once(eventName: string, fn: Function): Function; + off(eventName: string, fn: Function): Function; + removeAllEventListeners(eventName: string): void; + + load(): void; + + } + + export class BaseTexture implements Mixin { + + static fromImage(imageUrl: string, crossorigin?: boolean, scaleMode?: scaleModes): BaseTexture; + static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: scaleModes): BaseTexture; + + constructor(source: HTMLImageElement, scaleMode: scaleModes); + constructor(source: HTMLCanvasElement, scaleMode: scaleModes); + + height: number; + hasLoaded: boolean; + mipmap: boolean; + premultipliedAlpha: boolean; + resolution: number; + scaleMode: scaleModes; + source: HTMLImageElement; + width: number; + + listeners(eventName: string): Function[]; + emit(eventName: string, data?: any): boolean; + dispatchEvent(eventName: string, data?: any): boolean; + on(eventName: string, fn: Function): Function; + addEventListener(eventName: string, fn: Function): Function; + once(eventName: string, fn: Function): Function; + off(eventName: string, fn: Function): Function; + removeAllEventListeners(eventName: string): void; + + destroy(): void; + dirty(): void; + updateSourceImage(newSrc: string): void; + unloadFromGPU(): void; + + } + + export class BitmapFontLoader implements Mixin { + + constructor(url: string, crossorigin: boolean); + + baseUrl: string; + crossorigin: boolean; + texture: Texture; + url: string; + + listeners(eventName: string): Function[]; + emit(eventName: string, data?: any): boolean; + dispatchEvent(eventName: string, data?: any): boolean; + on(eventName: string, fn: Function): Function; + addEventListener(eventName: string, fn: Function): Function; + once(eventName: string, fn: Function): Function; + off(eventName: string, fn: Function): Function; + removeAllEventListeners(eventName: string): void; + + load(): void; + + } + + export class BitmapText extends DisplayObjectContainer { + + static fonts: any; + + constructor(text: string, style: BitmapTextStyle); + + dirty: boolean; + fontName: string; + fontSize: number; + textWidth: number; + textHeight: number; + tint: number; + style: BitmapTextStyle; + + setText(text: string): void; + setStyle(style: BitmapTextStyle): 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 CanvasBuffer { + + constructor(width: number, height: number); + + canvas: HTMLCanvasElement; + context: CanvasRenderingContext2D; + height: number; + width: number; + + clear(): void; + resize(width: number, height: number): void; + + } + + export class CanvasMaskManager { + + pushMask(maskData: MaskData, renderSession: RenderSession): void; + popMask(renderSession: RenderSession): void; + + } + + export class CanvasRenderer implements PixiRenderer { + + constructor(width?: number, height?: number, options?: PixiRendererOptions); + + autoResize: boolean; + clearBeforeRender: boolean; + context: CanvasRenderingContext2D; + count: number; + height: number; + maskManager: CanvasMaskManager; + refresh: boolean; + renderSession: RenderSession; + resolution: number; + transparent: boolean; + type: number; + view: HTMLCanvasElement; + width: number; + + destroy(removeView?: boolean): void; + render(stage: Stage): void; + resize(width: number, height: number): void; + + } + + export class CanvasTinter { + + static getTintedTexture(sprite: Sprite, color: number): HTMLCanvasElement; + static tintWithMultiply(texture: Texture, color: number, canvas: HTMLCanvasElement): void; + static tintWithOverlay(texture: Texture, color: number, canvas: HTMLCanvasElement): void; + static tintWithPerPixel(texture: Texture, color: number, canvas: HTMLCanvasElement): void; + static roundColor(color: number): void; + + static cacheStepsPerColorChannel: number; + static convertTintToImage: boolean; + static canUseMultiply: boolean; + static tintMethod: any; + + } + + export class Circle implements HitArea { + + constructor(x: number, y: number, radius: number); + + x: number; + y: number; + radius: number; + + clone(): Circle; + contains(x: number, y: number): boolean; + getBounds(): Rectangle; + + } + + export class ColorMatrixFilter extends AbstractFilter { + + matrix: Matrix; + + } + + export class ColorStepFilter extends AbstractFilter { + + step: number; + + } + + export class ConvolutionFilter extends AbstractFilter { + + constructor(matrix: number[], width: number, height: number); + + matrix: Matrix; + width: number; + height: number; + + } + + export class CrossHatchFilter extends AbstractFilter { + + blur: number; + + } + + export class DisplacementFilter extends AbstractFilter { + + constructor(texture: Texture); + + map: Texture; + offset: Point; + scale: Point; + + } + + export class DotScreenFilter extends AbstractFilter { + + angle: number; + scale: Point; + + } + + export class DisplayObject { + + alpha: number; + buttonMode: boolean; + cacheAsBitmap: boolean; + defaultCursor: string; + filterArea: Rectangle; + filters: AbstractFilter[]; + hitArea: HitArea; + interactive: boolean; + mask: Graphics; + parent: DisplayObjectContainer; + pivot: Point; + position: Point; + renderable: boolean; + rotation: number; + scale: Point; + stage: Stage; + visible: boolean; + worldAlpha: number; + worldVisible: boolean; + x: number; + y: number; + + click(e: InteractionData): void; + displayObjectUpdateTransform(): void; + getBounds(matrix?: Matrix): Rectangle; + getLocalBounds(): Rectangle; + generateTexture(resolution: number, scaleMode: scaleModes, renderer: PixiRenderer): RenderTexture; + mousedown(e: InteractionData): void; + mouseout(e: InteractionData): void; + mouseover(e: InteractionData): void; + mouseup(e: InteractionData): void; + mousemove(e: InteractionData): void; + mouseupoutside(e: InteractionData): void; + rightclick(e: InteractionData): void; + rightdown(e: InteractionData): void; + rightup(e: InteractionData): void; + rightupoutside(e: InteractionData): void; + setStageReference(stage: Stage): void; + tap(e: InteractionData): void; + toGlobal(position: Point): Point; + toLocal(position: Point, from: DisplayObject): Point; + touchend(e: InteractionData): void; + touchendoutside(e: InteractionData): void; + touchstart(e: InteractionData): void; + touchmove(e: InteractionData): void; + updateTransform(): void; + + } + + export class DisplayObjectContainer extends DisplayObject { + + constructor(); + + children: DisplayObject[]; + height: number; + width: number; + + addChild(child: DisplayObject): DisplayObject; + addChildAt(child: DisplayObject, index: number): DisplayObject; + getBounds(): Rectangle; + getChildAt(index: number): DisplayObject; + getChildIndex(child: DisplayObject): number; + getLocalBounds(): Rectangle; + removeChild(child: DisplayObject): DisplayObject; + removeChildAt(index: number): DisplayObject; + removeChildren(beginIndex?: number, endIndex?: number): DisplayObject[]; + removeStageReference(): void; + setChildIndex(child: DisplayObject, index: number): void; + swapChildren(child: DisplayObject, child2: DisplayObject): void; + + } + + export class Ellipse implements HitArea { + + constructor(x: number, y: number, width: number, height: number); + + x: number; + y: number; + width: number; + height: number; + + clone(): Ellipse; + contains(x: number, y: number): boolean; + getBounds(): Rectangle; + + } + + export class Event { + + constructor(target: any, name: string, data: any); + + target: any; + type: string; + data: any; + timeStamp: number; + + stopPropagation(): void; + preventDefault(): void; + stopImmediatePropagation(): void; + + } + + export class EventTarget { + + static mixin(obj: any): void; + + } + + export class FilterTexture { + + constructor(gl: WebGLRenderingContext, width: number, height: number, scaleMode: scaleModes); + + fragmentSrc: string[]; + frameBuffer: WebGLFramebuffer; + gl: WebGLRenderingContext; + program: WebGLProgram; + scaleMode: number; + texture: WebGLTexture; + + clear(): void; + resize(width: number, height: number): void; + destroy(): void; + + } + + export class GraphicsData { + + constructor(lineWidth?: number, lineColor?: number, lineAlpha?: number, fillColor?: number, fillAlpha?: number, fill?: boolean, shape?: any); + + lineWidth: number; + lineColor: number; + lineAlpha: number; + fillColor: number; + fillAlpha: number; + fill: boolean; + shape: any; + type: number; + + } + + export class Graphics extends DisplayObjectContainer { + + static POLY: number; + static RECT: number; + static CIRC: number; + static ELIP: number; + static RREC: number; + + blendMode: number; + boundsPadding: number; + fillAlpha: number; + isMask: boolean; + lineWidth: number; + lineColor: string; + tint: number; + worldAlpha: number; + + arc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise: boolean): Graphics; + arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): Graphics; + beginFill(color?: number, alpha?: number): Graphics; + bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): Graphics; + clear(): Graphics; + destroyCachedSprite(): void; + drawCircle(x: number, y: number, radius: number): Graphics; + drawEllipse(x: number, y: number, width: number, height: number): Graphics; + drawPolygon(path: any): Graphics; + drawRect(x: number, y: number, width: number, height: number): Graphics; + drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): Graphics; + drawShape(shape: Circle): GraphicsData; + drawShape(shape: Rectangle): GraphicsData; + drawShape(shape: Ellipse): GraphicsData; + drawShape(shape: Polygon): GraphicsData; + endFill(): Graphics; + lineStyle(lineWidth?: number, color?: number, alpha?: number): Graphics; + lineTo(x: number, y: number): Graphics; + moveTo(x: number, y: number): Graphics; + quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): Graphics; + + } + + export class GrayFilter extends AbstractFilter { + + gray: number; + + } + + export class ImageLoader implements Mixin { + + constructor(url: string, crossorigin?: boolean); + + texture: Texture; + + listeners(eventName: string): Function[]; + emit(eventName: string, data?: any): boolean; + dispatchEvent(eventName: string, data?: any): boolean; + on(eventName: string, fn: Function): Function; + addEventListener(eventName: string, fn: Function): Function; + once(eventName: string, fn: Function): Function; + off(eventName: string, fn: Function): Function; + removeAllEventListeners(eventName: string): void; + + 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; + last: number; + mouse: InteractionData; + mouseOut: boolean; + mouseoverEnabled: boolean; + onMouseMove: Function; + onMouseDown: Function; + onMouseOut: Function; + onMouseUp: Function; + onTouchStart: Function; + onTouchEnd: Function; + onTouchMove: Function; + pool: InteractionData[]; + resolution: number; + stage: Stage; + touches: { [id: string]: InteractionData }; + + constructor(stage: Stage); + } + + export class InvertFilter extends AbstractFilter { + + invert: number; + + } + + export class JsonLoader implements Mixin { + + constructor(url: string, crossorigin?: boolean); + + baseUrl: string; + crossorigin: boolean; + loaded: boolean; + url: string; + + listeners(eventName: string): Function[]; + emit(eventName: string, data?: any): boolean; + dispatchEvent(eventName: string, data?: any): boolean; + on(eventName: string, fn: Function): Function; + addEventListener(eventName: string, fn: Function): Function; + once(eventName: string, fn: Function): Function; + off(eventName: string, fn: Function): Function; + removeAllEventListeners(eventName: string): void; + + load(): void; + + } + + export class Matrix { + + a: number; + b: number; + c: number; + d: number; + tx: number; + ty: number; + + append(matrix: Matrix): Matrix; + apply(pos: Point, newPos: Point): Point; + applyInverse(pos: Point, newPos: Point): Point; + determineMatrixArrayType(): number[]; + identity(): Matrix; + rotate(angle: number): Matrix; + fromArray(array: number[]): void; + translate(x: number, y: number): Matrix; + toArray(transpose: boolean): number[]; + scale(x: number, y: number): Matrix; + + } + + export interface Mixin { + + listeners(eventName: string): Function[]; + emit(eventName: string, data?: any): boolean; + dispatchEvent(eventName: string, data?: any): boolean; + on(eventName: string, fn: Function): Function; + addEventListener(eventName: string, fn: Function): Function; + once(eventName: string, fn: Function): Function; + off(eventName: string, fn: Function): Function; + removeAllEventListeners(eventName: string): void; + + } + + export class MovieClip extends Sprite { + + static fromFrames(frames: string[]): MovieClip; + static fromImages(images: HTMLImageElement[]): HTMLImageElement; + + constructor(textures: Texture[]); + + animationSpeed: number; + currentFrame: number; + loop: boolean; + playing: boolean; + textures: Texture[]; + totalFrames: number; + + gotoAndPlay(frameNumber: number): void; + gotoAndStop(frameNumber: number): void; + onComplete(): void; + play(): void; + stop(): void; + + } + + export class NoiseFilter extends AbstractFilter { + + noise: number; + + } + + export class NormalMapFilter extends AbstractFilter { + + map: Texture; + offset: Point; + scale: Point; + + } + + export class PixelateFilter extends AbstractFilter { + + size: number; + + } + + export interface IPixiShader { + + fragmentSrc: string[]; + gl: WebGLRenderingContext; + program: WebGLProgram; + vertexSrc: string[]; + + destroy(): void; + init(): void; + + } + + export class PixiShader implements IPixiShader { + + constructor(gl: WebGLRenderingContext); + + attributes: ShaderAttribute[]; + defaultVertexSrc: string[]; + dirty: boolean; + firstRun: boolean; + textureCount: number; + fragmentSrc: string[]; + gl: WebGLRenderingContext; + program: WebGLProgram; + vertexSrc: string[]; + + initSampler2D(): void; + initUniforms(): void; + syncUniforms(): void; + + destroy(): void; + init(): void; + + } + + export class PixiFastShader implements IPixiShader { + + constructor(gl: WebGLRenderingContext); + + textureCount: number; + fragmentSrc: string[]; + gl: WebGLRenderingContext; + program: WebGLProgram; + vertexSrc: string[]; + + destroy(): void; + init(): void; + + } + + export class PrimitiveShader implements IPixiShader { + + constructor(gl: WebGLRenderingContext); + fragmentSrc: string[]; + gl: WebGLRenderingContext; + program: WebGLProgram; + vertexSrc: string[]; + + destroy(): void; + init(): void; + + } + + export class ComplexPrimitiveShader implements IPixiShader { + + constructor(gl: WebGLRenderingContext); + fragmentSrc: string[]; + gl: WebGLRenderingContext; + program: WebGLProgram; + vertexSrc: string[]; + + destroy(): void; + init(): void; + + } + + export class StripShader implements IPixiShader { + + constructor(gl: WebGLRenderingContext); + fragmentSrc: string[]; + gl: WebGLRenderingContext; + program: WebGLProgram; + vertexSrc: string[]; + + destroy(): void; + init(): void; + + } + + export class Point { + + constructor(x?: number, y?: number); + + x: number; + y: number; + + clone(): Point; + set(x: number, y: number): void; + + } + + export class Polygon implements HitArea { + + constructor(points: Point[]); + constructor(points: number[]); + constructor(...points: Point[]); + constructor(...points: number[]); + + points: number[]; + + clone(): Polygon; + contains(x: number, y: number): boolean; + + } + + export class Rectangle implements HitArea { + + constructor(x?: number, y?: number, width?: number, height?: number); + + x: number; + y: number; + width: number; + height: number; + + clone(): Rectangle; + contains(x: number, y: number): boolean; + + } + + export class RGBSplitFilter extends AbstractFilter { + + red: Point; + green: Point; + blue: Point; + + } + + export class Rope extends Strip { + + points: Point[]; + vertices: number[]; + + constructor(texture: Texture, points: Point[]); + + refresh(): void; + setTexture(texture: Texture): void; + + } + + export class RoundedRectangle implements HitArea { + + constructor(x?: number, y?: number, width?: number, height?: number, radius?: number); + + x: number; + y: number; + width: number; + height: number; + radius: number; + + clone(): RoundedRectangle; + contains(x: number, y: number): boolean; + + } + + export class SepiaFilter extends AbstractFilter { + + sepia: number; + + } + + export class SmartBlurFilter extends AbstractFilter { + + blur: number; + + } + + export class SpineLoader implements Mixin { + + url: string; + crossorigin: boolean; + loaded: boolean; + + constructor(url: string, crossOrigin: boolean); + + listeners(eventName: string): Function[]; + emit(eventName: string, data?: any): boolean; + dispatchEvent(eventName: string, data?: any): boolean; + on(eventName: string, fn: Function): Function; + addEventListener(eventName: string, fn: Function): Function; + once(eventName: string, fn: Function): Function; + off(eventName: string, fn: Function): Function; + removeAllEventListeners(eventName: string): void; + + load(): void; + + } + + export class SpineTextureLoader { + + constructor(basePath: string, crossorigin: boolean); + + load(page: AtlasPage, file: string): void; + unload(texture: BaseTexture): void; + + } + + export class Sprite extends DisplayObjectContainer { + + static fromFrame(frameId: string): Sprite; + static fromImage(url: string, crossorigin?: boolean, scaleMode?: scaleModes): Sprite; + + constructor(texture: Texture); + + anchor: Point; + blendMode: blendModes; + shader: IPixiShader; + texture: Texture; + tint: number; + + setTexture(texture: Texture): void; + + } + + export class SpriteBatch extends DisplayObjectContainer { + + constructor(texture?: Texture); + + ready: boolean; + textureThing: Texture; + + initWebGL(gl: WebGLRenderingContext): void; + + } + + export class SpriteSheetLoader implements Mixin { + + constructor(url: string, crossorigin?: boolean); + + baseUrl: string; + crossorigin: boolean; + frames: any; + texture: Texture; + url: string; + + listeners(eventName: string): Function[]; + emit(eventName: string, data?: any): boolean; + dispatchEvent(eventName: string, data?: any): boolean; + on(eventName: string, fn: Function): Function; + addEventListener(eventName: string, fn: Function): Function; + once(eventName: string, fn: Function): Function; + off(eventName: string, fn: Function): Function; + removeAllEventListeners(eventName: string): void; + + load(): void; + + } + + export class Stage extends DisplayObjectContainer { + + constructor(backgroundColor: number); + + interactionManager: InteractionManager; + + getMousePosition(): Point; + setBackgroundColor(backgroundColor: number): void; + setInteractionDelegate(domElement: HTMLElement): void; + + } + + export class Strip extends DisplayObjectContainer { + + static DrawModes: { + + TRIANGLE_STRIP: number; + TRIANGLES: number; + + } + + constructor(texture: Texture); + + blendMode: number; + colors: number[]; + dirty: boolean; + indices: number[]; + canvasPadding: number; + texture: Texture; + uvs: number[]; + vertices: number[]; + + getBounds(matrix?: Matrix): Rectangle; + + } + + export class Text extends Sprite { + + constructor(text: string, style?: TextStyle); + + context: CanvasRenderingContext2D; + resolution: number; + + destroy(destroyTexture: boolean): void; + setStyle(style: TextStyle): void; + setText(text: string): void; + + } + + export class Texture implements Mixin { + + static emptyTexture: Texture; + + static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: scaleModes): Texture; + static fromFrame(frameId: string): Texture; + static fromImage(imageUrl: string, crossorigin?: boolean, scaleMode?: scaleModes): Texture; + static addTextureToCache(texture: Texture, id: string): void; + static removeTextureFromCache(id: string): Texture; + + constructor(baseTexture: BaseTexture, frame?: Rectangle, crop?: Rectangle, trim?: Rectangle); + + baseTexture: BaseTexture; + crop: Rectangle; + frame: Rectangle; + height: number; + noFrame: boolean; + requiresUpdate: boolean; + trim: Point; + width: number; + scope: any; + valid: boolean; + + listeners(eventName: string): Function[]; + emit(eventName: string, data?: any): boolean; + dispatchEvent(eventName: string, data?: any): boolean; + on(eventName: string, fn: Function): Function; + addEventListener(eventName: string, fn: Function): Function; + once(eventName: string, fn: Function): Function; + off(eventName: string, fn: Function): Function; + removeAllEventListeners(eventName: string): void; + + destroy(destroyBase: boolean): void; + setFrame(frame: Rectangle): void; + + } + + export class TilingSprite extends Sprite { + + constructor(texture: Texture, width: number, height: number); + + blendMode: number; + texture: Texture; + tint: number; + tilePosition: Point; + tileScale: Point; + tileScaleOffset: Point; + + generateTilingTexture(forcePowerOfTwo: boolean): void; + setTexture(texture: Texture): void; + + } + + export class TiltShiftFilter extends AbstractFilter { + + blur: number; + gradientBlur: number; + start: number; + end: number; + + } + + export class TiltShiftXFilter extends AbstractFilter { + + blur: number; + gradientBlur: number; + start: number; + end: number; + + updateDelta(): void; + + } + + export class TiltShiftYFilter extends AbstractFilter { + + blur: number; + gradientBlur: number; + start: number; + end: number; + + updateDelta(): void; + + } + + export class TwistFilter extends AbstractFilter { + + angle: number; + offset: Point; + radius: number; + + } + + export class VideoTexture extends BaseTexture { + + static baseTextureFromVideo(video: HTMLVideoElement, scaleMode: number): BaseTexture; + static textureFromVideo(video: HTMLVideoElement, scaleMode: number): Texture; + static fromUrl(videoSrc: string, scaleMode: number): Texture; + + autoUpdate: boolean; + + destroy(): void; + updateBound(): void; + onPlayStart(): void; + onPlayStop(): void; + onCanPlay(): void; + + } + + export class WebGLBlendModeManager { + + currentBlendMode: number; + + destroy(): void; + setBlendMode(blendMode: number): boolean; + setContext(gl: WebGLRenderingContext): void; + + } + + export class WebGLFastSpriteBatch { + + constructor(gl: CanvasRenderingContext2D); + + currentBatchSize: number; + currentBaseTexture: BaseTexture; + currentBlendMode: number; + renderSession: RenderSession; + drawing: boolean; + indexBuffer: any; + indices: number[]; + lastIndexCount: number; + matrix: Matrix; + maxSize: number; + shader: IPixiShader; + size: number; + vertexBuffer: any; + vertices: number[]; + vertSize: number; + + end(): void; + begin(spriteBatch: SpriteBatch, renderSession: RenderSession): void; + destroy(removeView?: boolean): void; + flush(): void; + render(spriteBatch: SpriteBatch): void; + renderSprite(sprite: Sprite): void; + setContext(gl: WebGLRenderingContext): void; + start(): void; + stop(): void; + + } + + export class WebGLFilterManager { + + filterStack: AbstractFilter[]; + transparent: boolean; + offsetX: number; + offsetY: number; + + applyFilterPass(filter: AbstractFilter, filterArea: Texture, width: number, height: number): void; + begin(renderSession: RenderSession, buffer: ArrayBuffer): void; + destroy(): void; + initShaderBuffers(): void; + popFilter(): void; + pushFilter(filterBlock: FilterBlock): void; + setContext(gl: WebGLRenderingContext): void; + + } + + export class WebGLGraphics { + + static graphicsDataPool: any[]; + + static renderGraphics(graphics: Graphics, renderRession: RenderSession): void; + static updateGraphics(graphics: Graphics, gl: WebGLRenderingContext): void; + static switchMode(webGL: WebGLRenderingContext, type: number): any; //WebGLData + static buildRectangle(graphicsData: GraphicsData, webGLData: any): void; + static buildRoundedRectangle(graphicsData: GraphicsData, webGLData: any): void; + static quadraticBezierCurve(fromX: number, fromY: number, cpX: number, cpY: number, toX: number, toY: number): number[]; + static buildCircle(graphicsData: GraphicsData, webGLData: any): void; + static buildLine(graphicsData: GraphicsData, webGLData: any): void; + static buildComplexPoly(graphicsData: GraphicsData, webGLData: any): void; + static buildPoly(graphicsData: GraphicsData, webGLData: any): boolean; + + reset(): void; + upload(): void; + + } + + export class WebGLGraphicsData { + + constructor(gl: WebGLRenderingContext); + + gl: WebGLRenderingContext; + glPoints: any[]; + color: number[]; + points: any[]; + indices: any[]; + buffer: WebGLBuffer; + indexBuffer: WebGLBuffer; + mode: number; + alpha: number; + dirty: boolean; + + reset(): void; + upload(): void; + + } + + export class WebGLMaskManager { + + destroy(): void; + popMask(renderSession: RenderSession): void; + pushMask(maskData: any[], renderSession: RenderSession): void; + setContext(gl: WebGLRenderingContext): void; + + } + + export class WebGLRenderer implements PixiRenderer { + + static createWebGLTexture(texture: Texture, gl: WebGLRenderingContext): void; + + constructor(width?: number, height?: number, options?: PixiRendererOptions); + + autoResize: boolean; + clearBeforeRender: boolean; + contextLost: boolean; + contextLostBound: Function; + contextRestoreLost: boolean; + contextRestoredBound: Function; + height: number; + gl: WebGLRenderingContext; + offset: Point; + preserveDrawingBuffer: boolean; + projection: Point; + resolution: number; + renderSession: RenderSession; + shaderManager: WebGLShaderManager; + spriteBatch: WebGLSpriteBatch; + maskManager: WebGLMaskManager; + filterManager: WebGLFilterManager; + stencilManager: WebGLStencilManager; + blendModeManager: WebGLBlendModeManager; + transparent: boolean; + type: number; + view: HTMLCanvasElement; + width: number; + + destroy(): void; + initContext(): void; + mapBlendModes(): void; + render(stage: Stage): void; + renderDisplayObject(displayObject: DisplayObject, projection: Point, buffer: WebGLBuffer): void; + resize(width: number, height: number): void; + updateTexture(texture: Texture): void; + + } + + export class WebGLShaderManager { + + maxAttibs: number; + attribState: any[]; + stack: any[]; + tempAttribState: any[]; + + destroy(): void; + setAttribs(attribs: ShaderAttribute[]): void; + setContext(gl: WebGLRenderingContext): void; + setShader(shader: IPixiShader): boolean; + + } + + export class WebGLStencilManager { + + stencilStack: any[]; + reverse: boolean; + count: number; + + bindGraphics(graphics: Graphics, webGLData: any[], renderSession: RenderSession): void; + destroy(): void; + popStencil(graphics: Graphics, webGLData: any[], renderSession: RenderSession): void; + pushStencil(graphics: Graphics, webGLData: any[], renderSession: RenderSession): void; + setContext(gl: WebGLRenderingContext): void; + + } + + export class WebGLSpriteBatch { + + blendModes: number[]; + colors: number[]; + currentBatchSize: number; + currentBaseTexture: Texture; + defaultShader: AbstractFilter; + dirty: boolean; + drawing: boolean; + indices: number[]; + lastIndexCount: number; + positions: number[]; + textures: Texture[]; + shaders: IPixiShader[]; + size: number; + sprites: any[]; //todo Sprite[]? + vertices: number[]; + vertSize: number; + + begin(renderSession: RenderSession): void; + destroy(): void; + end(): void; + flush(shader?: IPixiShader): void; + render(sprite: Sprite): void; + renderBatch(texture: Texture, size: number, startIndex: number): void; + renderTilingSprite(sprite: TilingSprite): void; + setBlendMode(blendMode: blendModes): void; + setContext(gl: WebGLRenderingContext): void; + start(): void; + stop(): void; + + } + + export class RenderTexture extends Texture { + + constructor(width?: number, height?: number, renderer?: PixiRenderer, scaleMode?: scaleModes, resolution?: number); + + frame: Rectangle; + baseTexture: BaseTexture; + renderer: PixiRenderer; + resolution: number; + valid: boolean; + + clear(): void; + getBase64(): string; + getCanvas(): HTMLCanvasElement; + getImage(): HTMLImageElement; + resize(width: number, height: number, updateBase: boolean): void; + render(displayObject: DisplayObject, position?: Point, clear?: boolean): void; + + } + + //SPINE + + export class BoneData { + + constructor(name: string, parent?: any); + + name: string; + parent: any; + length: number; + x: number; + y: number; + rotation: number; + scaleX: number; + scaleY: number; + + } + + export class SlotData { + + constructor(name: string, boneData: BoneData); + + name: string; + boneData: BoneData; + r: number; + g: number; + b: number; + a: number; + attachmentName: string; + + } + + export class Bone { + + constructor(boneData: BoneData, parent?: any); + + data: BoneData; + parent: any; + yDown: boolean; + x: number; + y: number; + rotation: number; + scaleX: number; + scaleY: number; + worldRotation: number; + worldScaleX: number; + worldScaleY: number; + + updateWorldTransform(flipX: boolean, flip: boolean): void; + setToSetupPose(): void; + + } + + export class Slot { + + constructor(slotData: SlotData, skeleton: Skeleton, bone: Bone); + + data: SlotData; + skeleton: Skeleton; + bone: Bone; + r: number; + g: number; + b: number; + a: number; + attachment: RegionAttachment; + setAttachment(attachment: RegionAttachment): void; + setAttachmentTime(time: number): void; + getAttachmentTime(): number; + setToSetupPose(): void; + + } + + export class Skin { + + constructor(name: string); + + name: string; + attachments: any; + + addAttachment(slotIndex: number, name: string, attachment: RegionAttachment): void; + getAttachment(slotIndex: number, name: string): void; + + } + + export class Animation { + + constructor(name: string, timelines: ISpineTimeline[], duration: number); + + name: string; + timelines: ISpineTimeline[]; + duration: number; + apply(skeleton: Skeleton, time: number, loop: boolean): void; + min(skeleton: Skeleton, time: number, loop: boolean, alpha: number): void; + + } + + export class Curves { + + constructor(frameCount: number); + + curves: number[]; + + setLinear(frameIndex: number): void; + setStepped(frameIndex: number): void; + setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void; + getCurvePercent(frameIndex: number, percent: number): number; + + } + + export interface ISpineTimeline { + + curves: Curves; + frames: number[]; + + getFrameCount(): number; + apply(skeleton: Skeleton, time: number, alpha: number): void; + + } + + export class RotateTimeline implements ISpineTimeline { + + constructor(frameCount: number); + + curves: Curves; + frames: number[]; + boneIndex: number; + + getFrameCount(): number; + setFrame(frameIndex: number, time: number, angle: number): void; + apply(skeleton: Skeleton, time: number, alpha: number): void; + + } + + export class TranslateTimeline implements ISpineTimeline { + + constructor(frameCount: number); + + curves: Curves; + frames: number[]; + boneIndex: number; + + getFrameCount(): number; + setFrame(frameIndex: number, time: number, x: number, y: number): void; + apply(skeleton: Skeleton, time: number, alpha: number): void; + + } + + export class ScaleTimeline implements ISpineTimeline { + + constructor(frameCount: number); + + curves: Curves; + frames: number[]; + boneIndex: number; + + getFrameCount(): number; + setFrame(frameIndex: number, time: number, x: number, y: number): void; + apply(skeleton: Skeleton, time: number, alpha: number): void; + + } + + export class ColorTimeline implements ISpineTimeline { + + constructor(frameCount: number); + + curves: Curves; + frames: number[]; + boneIndex: number; + + getFrameCount(): number; + setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void; + apply(skeleton: Skeleton, time: number, alpha: number): void; + + } + + export class AttachmentTimeline implements ISpineTimeline { + + constructor(frameCount: number); + + curves: Curves; + frames: number[]; + attachmentNames: string[]; + slotIndex: number; + + getFrameCount(): number; + setFrame(frameIndex: number, time: number, attachmentName: string): void; + apply(skeleton: Skeleton, time: number, alpha: number): void; + + } + + export class SkeletonData { + + bones: Bone[]; + slots: Slot[]; + skins: Skin[]; + animations: Animation[]; + defaultSkin: Skin; + + findBone(boneName: string): Bone; + findBoneIndex(boneName: string): number; + findSlot(slotName: string): Slot; + findSlotIndex(slotName: string): number; + findSkin(skinName: string): Skin; + findAnimation(animationName: string): Animation; + + } + + export class Skeleton { + + constructor(skeletonData: SkeletonData); + + data: SkeletonData; + bones: Bone[]; + slots: Slot[]; + drawOrder: any[]; + x: number; + y: number; + skin: Skin; + r: number; + g: number; + b: number; + a: number; + time: number; + flipX: boolean; + flipY: boolean; + + updateWorldTransform(): void; + setToSetupPose(): void; + setBonesToSetupPose(): void; + setSlotsToSetupPose(): void; + getRootBone(): Bone; + findBone(boneName: string): Bone; + fineBoneIndex(boneName: string): number; + findSlot(slotName: string): Slot; + findSlotIndex(slotName: string): number; + setSkinByName(skinName: string): void; + setSkin(newSkin: Skin): void; + getAttachmentBySlotName(slotName: string, attachmentName: string): RegionAttachment; + getAttachmentBySlotIndex(slotIndex: number, attachmentName: string): RegionAttachment; + setAttachment(slotName: string, attachmentName: string): void; + update(data: number): void; + + } + + export class RegionAttachment { + + offset: number[]; + uvs: number[]; + x: number; + y: number; + rotation: number; + scaleX: number; + scaleY: number; + width: number; + height: number; + rendererObject: any; + regionOffsetX: number; + regionOffsetY: number; + regionWidth: number; + regionHeight: number; + regionOriginalWidth: number; + regionOriginalHeight: number; + + setUVs(u: number, v: number, u2: number, v2: number, rotate: number): void; + updateOffset(): void; + computeVertices(x: number, y: number, bone: Bone, vertices: number[]): void; + + } + + export class AnimationStateData { + + constructor(skeletonData: SkeletonData); + + skeletonData: SkeletonData; + animationToMixTime: any; + defaultMix: number; + + setMixByName(fromName: string, toName: string, duration: number): void; + setMix(from: string, to: string): number; + + } + + export class AnimationState { + + constructor(stateData: any); + + animationSpeed: number; + current: any; + previous: any; + currentTime: number; + previousTime: number; + currentLoop: boolean; + previousLoop: boolean; + mixTime: number; + mixDuration: number; + queue: Animation[]; + + update(delta: number): void; + apply(skeleton: any): void; + clearAnimation(): void; + setAnimation(animation: any, loop: boolean): void; + setAnimationByName(animationName: string, loop: boolean): void; + addAnimationByName(animationName: string, loop: boolean, delay: number): void; + addAnimation(animation: any, loop: boolean, delay: number): void; + isComplete(): number; + + } + + export class SkeletonJson { + + constructor(attachmentLoader: AtlasAttachmentLoader); + + attachmentLoader: AtlasAttachmentLoader; + scale: number; + + readSkeletonData(root: any): SkeletonData; + readAttachment(skin: Skin, name: string, map: any): RegionAttachment; + readAnimation(name: string, map: any, skeletonData: SkeletonData): void; + readCurve(timeline: ISpineTimeline, frameIndex: number, valueMap: any): void; + toColor(hexString: string, colorIndex: number): number; + + } + + export class Atlas { + + static FORMAT: { + + alpha: number; + intensity: number; + luminanceAlpha: number; + rgb565: number; + rgba4444: number; + rgb888: number; + rgba8888: number; + + } + + static TextureFilter: { + + nearest: number; + linear: number; + mipMap: number; + mipMapNearestNearest: number; + mipMapLinearNearest: number; + mipMapNearestLinear: number; + mipMapLinearLinear: number; + + } + + static textureWrap: { + + mirroredRepeat: number; + clampToEdge: number; + repeat: number; + + } + + constructor(atlasText: string, textureLoader: AtlasLoader); + + textureLoader: AtlasLoader; + pages: AtlasPage[]; + regions: AtlasRegion[]; + + findRegion(name: string): AtlasRegion; + dispose(): void; + updateUVs(page: AtlasPage): void; + + } + + export class AtlasPage { + + name: string; + format: number; + minFilter: number; + magFilter: number; + uWrap: number; + vWrap: number; + rendererObject: any; + width: number; + height: number; + + } + + export class AtlasRegion { + + page: AtlasPage; + name: string; + x: number; + y: number; + width: number; + height: number; + u: number; + v: number; + u2: number; + v2: number; + offsetX: number; + offsetY: number; + originalWidth: number; + originalHeight: number; + index: number; + rotate: boolean; + splits: any[]; + pads: any[]; + + } + + export class AtlasReader { + + constructor(text: string); + + lines: string[]; + index: number; + + trim(value: string): string; + readLine(): string; + readValue(): string; + readTuple(tuple: number): number; + + } + + export class AtlasAttachmentLoader { + + constructor(atlas: Atlas); + + atlas: Atlas; + + newAttachment(skin: Skin, type: number, name: string): RegionAttachment; + + } + + export class Spine extends DisplayObjectContainer { + + constructor(url: string); + + autoUpdate: boolean; + spineData: any; + skeleton: Skeleton; + stateData: AnimationStateData; + state: AnimationState; + slotContainers: DisplayObjectContainer[]; + + createSprite(slot: Slot, descriptor: { name: string }): Sprite[]; + update(dt: number): void; + + } + +} + +declare function requestAnimFrame(callback: Function): void; + +declare module PIXI.PolyK { + export function Triangulate(p: number[]): number[]; +} diff --git a/src/scripts/state/Boot.ts b/src/scripts/state/Boot.ts new file mode 100644 index 0000000..31bcad7 --- /dev/null +++ b/src/scripts/state/Boot.ts @@ -0,0 +1,16 @@ +module SpaceTac.State { + export class Boot extends Phaser.State { + preload() { + this.load.image('preload-bar', 'assets/images/preloader.gif'); + } + + create() { + this.game.stage.backgroundColor = 0xFFFFFF; + + this.input.maxPointers = 1; + this.stage.disableVisibilityChange = true; + + this.game.state.start('preload'); + } + } +} diff --git a/src/scripts/state/Main.ts b/src/scripts/state/Main.ts new file mode 100644 index 0000000..bed9620 --- /dev/null +++ b/src/scripts/state/Main.ts @@ -0,0 +1,8 @@ +module SpaceTac.State { + export class Main extends Phaser.State { + + create() { + this.add.text(10, 10, "Let's code !", { font: "65px Arial" }); + } + } +} diff --git a/src/scripts/state/Preload.ts b/src/scripts/state/Preload.ts new file mode 100644 index 0000000..b10987b --- /dev/null +++ b/src/scripts/state/Preload.ts @@ -0,0 +1,13 @@ +module SpaceTac.State { + export class Preload extends Phaser.State { + private preloadBar:Phaser.Sprite; + + preload() { + this.preloadBar = this.add.sprite(290, 290, 'preload-bar'); + } + + create() { + this.game.state.start('main'); + } + } +} diff --git a/versions.cfg b/versions.cfg new file mode 100644 index 0000000..142404d --- /dev/null +++ b/versions.cfg @@ -0,0 +1,28 @@ +[versions] + +# Added by buildout at 2014-12-28 20:27:17.084358 +bowerrecipe = 0.1.1 +collective.recipe.cmd = 0.9 +gp.recipe.node = 0.10.28.0 +rodacom.buildout.npm = 0.6 +yt.recipe.shell = 0.1.7 +zc.buildout = 2.3.1 +zc.recipe.egg = 2.0.1 + +# Required by: +# gp.recipe.node==0.10.28.0 +hexagonit.recipe.cmmi = 2.0 + +# Required by: +# hexagonit.recipe.cmmi==2.0 +hexagonit.recipe.download = 1.7 + +# Required by: +# gp.recipe.node==0.10.28.0 +python-archive = 0.2 + +# Required by: +# gp.recipe.node==0.10.28.0 +# hexagonit.recipe.cmmi==2.0 +# zc.recipe.egg==2.0.1 +setuptools = 8.3