diff --git a/.gitignore b/.gitignore
index a4a5d19..cd452a7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,4 +4,5 @@
/out/vendor
/out/build.*
/graphics/**/*.blend?*
+/typings/
*.log
diff --git a/package.json b/package.json
index 561ec02..e241d61 100644
--- a/package.json
+++ b/package.json
@@ -4,9 +4,10 @@
"description": "A tactical RPG set in space",
"main": "src/build.js",
"scripts": {
- "deps": "bower install",
+ "deps": "bower install && typings install",
"build": "tsc -p .",
"test": "jasmine",
+ "build-test": "tsc -p . && jasmine",
"cover": "istanbul cover node_modules/jasmine/bin/jasmine.js && remap-istanbul -i coverage/coverage.json -o coverage -t html",
"serve": "simple-server out 8012"
},
@@ -17,11 +18,12 @@
"author": "Michael Lemaire",
"license": "MIT",
"devDependencies": {
- "bower": "^1.7.9",
- "jasmine": "^2.5.2",
- "istanbul": "0.4",
- "remap-istanbul": "0.6",
- "simple-server": "^1.0.1",
- "typescript": "^2.0.6"
+ "bower": "~1.8",
+ "istanbul": "~0.4",
+ "jasmine": "~2.5",
+ "remap-istanbul": "~0.6",
+ "simple-server": "~1.0",
+ "typescript": "~2.1",
+ "typings": "~1.4"
}
-}
\ No newline at end of file
+}
diff --git a/src/GameUI.ts b/src/GameUI.ts
index 243d478..158ea29 100644
--- a/src/GameUI.ts
+++ b/src/GameUI.ts
@@ -1,4 +1,4 @@
-///
+///
module SpaceTac {
"use strict";
@@ -35,7 +35,7 @@ module SpaceTac {
// Save current game in local browser storage
saveGame(): boolean {
- if (typeof(Storage) !== "undefined") {
+ if (typeof (Storage) !== "undefined") {
localStorage.setItem("spacetac-savegame", this.session.saveToString());
(this.state.getCurrentState()).messages.addMessage("Game saved");
return true;
@@ -47,7 +47,7 @@ module SpaceTac {
// Load current game from local browser storage
loadGame(): boolean {
- if (typeof(Storage) !== "undefined") {
+ if (typeof (Storage) !== "undefined") {
var loaded = localStorage.getItem("spacetac-savegame");
if (loaded) {
this.session = Game.GameSession.loadFromString(loaded);
diff --git a/src/definitions/jasmine.d.ts b/src/definitions/jasmine.d.ts
deleted file mode 100644
index 0ade8ee..0000000
--- a/src/definitions/jasmine.d.ts
+++ /dev/null
@@ -1,429 +0,0 @@
-// Type definitions for Jasmine 2.0
-// Project: http://pivotal.github.com/jasmine/
-// Definitions by: Boris Yankov , Theodore Brown
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-
-// For ddescribe / iit use : https://github.com/borisyankov/DefinitelyTyped/blob/master/karma-jasmine/karma-jasmine.d.ts
-
-declare function describe(description: string, specDefinitions: () => void): void;
-// declare function ddescribe(description: string, specDefinitions: () => void): void; Not a part of jasmine. Angular team adds these
-declare function xdescribe(description: string, specDefinitions: () => void): void;
-
-declare function it(expectation: string, assertion?: () => void): void;
-declare function it(expectation: string, assertion?: (done: () => void) => void): void;
-// declare function iit(expectation: string, assertion?: () => void): void; Not a part of jasmine. Angular team adds these
-// declare function iit(expectation: string, assertion?: (done: () => void) => void): void; Not a part of jasmine. Angular team adds these
-declare function xit(expectation: string, assertion?: () => void): void;
-declare function xit(expectation: string, assertion?: (done: () => void) => void): void;
-
-/** If you call the function pending anywhere in the spec body, no matter the expectations, the spec will be marked pending. */
-declare function pending(): void;
-
-declare function beforeEach(action: () => void): void;
-declare function beforeEach(action: (done: () => void) => void): void;
-declare function afterEach(action: () => void): void;
-declare function afterEach(action: (done: () => void) => void): void;
-
-declare function expect(spy: Function): jasmine.Matchers;
-declare function expect(actual: any): jasmine.Matchers;
-
-declare function spyOn(object: any, method: string): jasmine.Spy;
-
-declare function runs(asyncMethod: Function): void;
-declare function waitsFor(latchMethod: () => boolean, failureMessage?: string, timeout?: number): void;
-declare function waits(timeout?: number): void;
-
-declare module jasmine {
-
- var clock: () => Clock;
-
- function any(aclass: any): Any;
- function objectContaining(sample: any): ObjectContaining;
- function createSpy(name: string, originalFn?: Function): Spy;
- function createSpyObj(baseName: string, methodNames: any[]): any;
- function createSpyObj(baseName: string, methodNames: any[]): T;
- function pp(value: any): string;
- function getEnv(): Env;
- function addMatchers(matchers: any): Any;
-
- interface Any {
-
- new (expectedClass: any): any;
-
- jasmineMatches(other: any): boolean;
- jasmineToString(): string;
- }
-
- interface ObjectContaining {
- new (sample: any): any;
-
- jasmineMatches(other: any, mismatchKeys: any[], mismatchValues: any[]): boolean;
- jasmineToString(): string;
- }
-
- interface Block {
-
- new (env: Env, func: SpecFunction, spec: Spec): any;
-
- execute(onComplete: () => void): void;
- }
-
- interface WaitsBlock extends Block {
- new (env: Env, timeout: number, spec: Spec): any;
- }
-
- interface WaitsForBlock extends Block {
- new (env: Env, timeout: number, latchFunction: SpecFunction, message: string, spec: Spec): any;
- }
-
- interface Clock {
- install(): void;
- uninstall(): void;
- /** Calls to any registered callback are triggered when the clock is ticked forward via the jasmine.clock().tick function, which takes a number of milliseconds. */
- tick(ms: number): void;
- }
-
- interface Env {
- setTimeout: any;
- clearTimeout: void;
- setInterval: any;
- clearInterval: void;
- updateInterval: number;
-
- currentSpec: Spec;
-
- matchersClass: Matchers;
-
- version(): any;
- versionString(): string;
- nextSpecId(): number;
- addReporter(reporter: Reporter): void;
- execute(): void;
- describe(description: string, specDefinitions: () => void): Suite;
- // ddescribe(description: string, specDefinitions: () => void): Suite; Not a part of jasmine. Angular team adds these
- beforeEach(beforeEachFunction: () => void): void;
- currentRunner(): Runner;
- afterEach(afterEachFunction: () => void): void;
- xdescribe(desc: string, specDefinitions: () => void): XSuite;
- it(description: string, func: () => void): Spec;
- // iit(description: string, func: () => void): Spec; Not a part of jasmine. Angular team adds these
- xit(desc: string, func: () => void): XSpec;
- compareRegExps_(a: RegExp, b: RegExp, mismatchKeys: string[], mismatchValues: string[]): boolean;
- compareObjects_(a: any, b: any, mismatchKeys: string[], mismatchValues: string[]): boolean;
- equals_(a: any, b: any, mismatchKeys: string[], mismatchValues: string[]): boolean;
- contains_(haystack: any, needle: any): boolean;
- addEqualityTester(equalityTester: (a: any, b: any, env: Env, mismatchKeys: string[], mismatchValues: string[]) => boolean): void;
- specFilter(spec: Spec): boolean;
- }
-
- interface FakeTimer {
-
- new (): any;
-
- reset(): void;
- tick(millis: number): void;
- runFunctionsWithinRange(oldMillis: number, nowMillis: number): void;
- scheduleFunction(timeoutKey: any, funcToCall: () => void, millis: number, recurring: boolean): void;
- }
-
- interface HtmlReporter {
- new (): any;
- }
-
- interface HtmlSpecFilter {
- new (): any;
- }
-
- interface Result {
- type: string;
- }
-
- interface NestedResults extends Result {
- description: string;
-
- totalCount: number;
- passedCount: number;
- failedCount: number;
-
- skipped: boolean;
-
- rollupCounts(result: NestedResults): void;
- log(values: any): void;
- getItems(): Result[];
- addResult(result: Result): void;
- passed(): boolean;
- }
-
- interface MessageResult extends Result {
- values: any;
- trace: Trace;
- }
-
- interface ExpectationResult extends Result {
- matcherName: string;
- passed(): boolean;
- expected: any;
- actual: any;
- message: string;
- trace: Trace;
- }
-
- interface Trace {
- name: string;
- message: string;
- stack: any;
- }
-
- interface PrettyPrinter {
-
- new (): any;
-
- format(value: any): void;
- iterateObject(obj: any, fn: (property: string, isGetter: boolean) => void): void;
- emitScalar(value: any): void;
- emitString(value: string): void;
- emitArray(array: any[]): void;
- emitObject(obj: any): void;
- append(value: any): void;
- }
-
- interface StringPrettyPrinter extends PrettyPrinter {
- }
-
- interface Queue {
-
- new (env: any): any;
-
- env: Env;
- ensured: boolean[];
- blocks: Block[];
- running: boolean;
- index: number;
- offset: number;
- abort: boolean;
-
- addBefore(block: Block, ensure?: boolean): void;
- add(block: any, ensure?: boolean): void;
- insertNext(block: any, ensure?: boolean): void;
- start(onComplete?: () => void): void;
- isRunning(): boolean;
- next_(): void;
- results(): NestedResults;
- }
-
- interface Matchers {
-
- new (env: Env, actual: any, spec: Env, isNot?: boolean): any;
-
- env: Env;
- actual: any;
- spec: Env;
- isNot?: boolean;
- message(): any;
-
- toBe(expected: any): boolean;
- toEqual(expected: any): boolean;
- toMatch(expected: any): boolean;
- toBeDefined(): boolean;
- toBeUndefined(): boolean;
- toBeNull(): boolean;
- toBeNaN(): boolean;
- toBeTruthy(): boolean;
- toBeFalsy(): boolean;
- toHaveBeenCalled(): boolean;
- toHaveBeenCalledWith(...params: any[]): boolean;
- toContain(expected: any): boolean;
- toBeLessThan(expected: any): boolean;
- toBeGreaterThan(expected: any): boolean;
- toBeCloseTo(expected: any, precision: any): boolean;
- toContainHtml(expected: string): boolean;
- toContainText(expected: string): boolean;
- toThrow(expected?: any): boolean;
- toThrowError(expected?: any): boolean;
- not: Matchers;
-
- Any: Any;
- }
-
- interface Reporter {
- reportRunnerStarting(runner: Runner): void;
- reportRunnerResults(runner: Runner): void;
- reportSuiteResults(suite: Suite): void;
- reportSpecStarting(spec: Spec): void;
- reportSpecResults(spec: Spec): void;
- log(str: string): void;
- }
-
- interface MultiReporter extends Reporter {
- addReporter(reporter: Reporter): void;
- }
-
- interface Runner {
-
- new (env: Env): any;
-
- execute(): void;
- beforeEach(beforeEachFunction: SpecFunction): void;
- afterEach(afterEachFunction: SpecFunction): void;
- finishCallback(): void;
- addSuite(suite: Suite): void;
- add(block: Block): void;
- specs(): Spec[];
- suites(): Suite[];
- topLevelSuites(): Suite[];
- results(): NestedResults;
- }
-
- interface SpecFunction {
- (spec?: Spec): void;
- }
-
- interface SuiteOrSpec {
- id: number;
- env: Env;
- description: string;
- queue: Queue;
- }
-
- interface Spec extends SuiteOrSpec {
-
- new (env: Env, suite: Suite, description: string): any;
-
- suite: Suite;
-
- afterCallbacks: SpecFunction[];
- spies_: Spy[];
-
- results_: NestedResults;
- matchersClass: Matchers;
-
- getFullName(): string;
- results(): NestedResults;
- log(arguments: any): any;
- runs(func: SpecFunction): Spec;
- addToQueue(block: Block): void;
- addMatcherResult(result: Result): void;
- expect(actual: any): any;
- waits(timeout: number): Spec;
- waitsFor(latchFunction: SpecFunction, timeoutMessage?: string, timeout?: number): Spec;
- fail(e?: any): void;
- getMatchersClass_(): Matchers;
- addMatchers(matchersPrototype: any): void;
- finishCallback(): void;
- finish(onComplete?: () => void): void;
- after(doAfter: SpecFunction): void;
- execute(onComplete?: () => void): any;
- addBeforesAndAftersToQueue(): void;
- explodes(): void;
- spyOn(obj: any, methodName: string, ignoreMethodDoesntExist: boolean): Spy;
- removeAllSpies(): void;
- }
-
- interface XSpec {
- id: number;
- runs(): void;
- }
-
- interface Suite extends SuiteOrSpec {
-
- new (env: Env, description: string, specDefinitions: () => void, parentSuite: Suite): any;
-
- parentSuite: Suite;
-
- getFullName(): string;
- finish(onComplete?: () => void): void;
- beforeEach(beforeEachFunction: SpecFunction): void;
- afterEach(afterEachFunction: SpecFunction): void;
- results(): NestedResults;
- add(suiteOrSpec: SuiteOrSpec): void;
- specs(): Spec[];
- suites(): Suite[];
- children(): any[];
- execute(onComplete?: () => void): void;
- }
-
- interface XSuite {
- execute(): void;
- }
-
- interface Spy {
- (...params: any[]): any;
-
- identity: string;
- and: SpyAnd;
- calls: Calls;
- mostRecentCall: { args: any[]; };
- argsForCall: any[];
- wasCalled: boolean;
- callCount: number;
- }
-
- interface SpyAnd {
- /** By chaining the spy with and.callThrough, the spy will still track all calls to it but in addition it will delegate to the actual implementation. */
- callThrough(): void;
- /** By chaining the spy with and.returnValue, all calls to the function will return a specific value. */
- returnValue(val: any): void;
- /** By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied function. */
- callFake(fn: Function): void;
- /** By chaining the spy with and.throwError, all calls to the spy will throw the specified value. */
- throwError(msg: string): void;
- /** When a calling strategy is used for a spy, the original stubbing behavior can be returned at any time with and.stub. */
- stub(): void;
- }
-
- interface Calls {
- /** By chaining the spy with calls.any(), will return false if the spy has not been called at all, and then true once at least one call happens. **/
- any(): boolean;
- /** By chaining the spy with calls.count(), will return the number of times the spy was called **/
- count(): number;
- /** By chaining the spy with calls.argsFor(), will return the arguments passed to call number index **/
- argsFor(index: number): any[];
- /** By chaining the spy with calls.allArgs(), will return the arguments to all calls **/
- allArgs(): any[];
- /** By chaining the spy with calls.all(), will return the context (the this) and arguments passed all calls **/
- all(): any;
- /** By chaining the spy with calls.mostRecent(), will return the context (the this) and arguments for the most recent call **/
- mostRecent(): any;
- /** By chaining the spy with calls.first(), will return the context (the this) and arguments for the first call **/
- first(): any;
- /** By chaining the spy with calls.reset(), will clears all tracking for a spy **/
- reset(): void;
- }
-
- interface Util {
- inherit(childClass: Function, parentClass: Function): any;
- formatException(e: any): any;
- htmlEscape(str: string): string;
- argsToArray(args: any): any;
- extend(destination: any, source: any): any;
- }
-
- interface JsApiReporter extends Reporter {
-
- started: boolean;
- finished: boolean;
- result: any;
- messages: any;
-
- new (): any;
-
- suites(): Suite[];
- summarize_(suiteOrSpec: SuiteOrSpec): any;
- results(): any;
- resultsForSpec(specId: any): any;
- log(str: any): any;
- resultsForSpecs(specIds: any): any;
- summarizeResult_(result: any): any;
- }
-
- interface Jasmine {
- Spec: Spec;
- clock: Clock;
- util: Util;
- }
-
- export var HtmlReporter: HtmlReporter;
- export var HtmlSpecFilter: HtmlSpecFilter;
- export var DEFAULT_TIMEOUT_INTERVAL: number;
-}
diff --git a/src/definitions/p2.d.ts b/src/definitions/p2.d.ts
deleted file mode 100644
index 1e65718..0000000
--- a/src/definitions/p2.d.ts
+++ /dev/null
@@ -1,948 +0,0 @@
-// 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/definitions/phaser.d.ts b/src/definitions/phaser.d.ts
deleted file mode 100644
index 18e3aa2..0000000
--- a/src/definitions/phaser.d.ts
+++ /dev/null
@@ -1,4831 +0,0 @@
-///
-///
-
-// Type definitions for Phaser 2.3.0 RC1 2015-03-24
-// 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 CIRCLE: number;
- static ELLIPSE: number;
- static EMITTER: number;
- static GRAPHICS: number;
- static GROUP: number;
- static IMAGE: number;
- static LINE: number;
- static MATRIX: number;
- static POINT: number;
- static POINTER: number;
- static POLYGON: number;
- static RECTANGLE: number;
- static ROUNDEDRECTANGLE: number;
- static RENDERTEXTURE: number;
- static RETROFONT: number;
- static SPRITE: number;
- static SPRITEBATCH: number;
- static TEXT: number;
- static TILEMAP: number;
- static TILEMAPLAYER: number;
- static TILESPRITE: number;
- static WEBGL_FILTER: number;
- static ROPE: number;
-
- static 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: number[]|string[], frameRate?: number, loop?: boolean);
-
- currentFrame: Phaser.Frame;
- delay: number;
- enableUpdate: boolean;
- frame: number;
- frameTotal: number;
- game: Phaser.Game;
- isFinished: boolean;
- isPaused: boolean;
- isPlaying: boolean;
- killOnComplete: boolean;
- loop: boolean;
- loopCount: number;
- name: string;
- onComplete: Phaser.Signal;
- onLoop: Phaser.Signal;
- onStart: Phaser.Signal;
- onUpdate: Phaser.Signal;
- paused: boolean;
- 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?: string|number, 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?: number[]|string[], frameRate?: number, loop?: boolean, useNumericIndex?: boolean): Phaser.Animation;
- copyFrameData(frameData: Phaser.FrameData, frame: string|number): boolean;
- destroy(): void;
- getAnimation(name: string): Phaser.Animation;
- next(quantity?: number): void;
- play(name: string, frameRate?: number, loop?: boolean, killOnComplete?: boolean): Phaser.Animation;
- previous(quantity?: number): void;
- 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;
- getByKey(property: string, value: any): any;
- getIndex(item: any): number;
- exists(item: any): boolean;
- reset(): void;
- remove(item: any): any;
- removeAll(destoy?: boolean): void;
- setAll(key: any, value: any): void;
- callAll(key: string, ...parameter: any[]): void;
-
- }
-
- class ArrayUtils {
-
- static getRandomItem(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?: number, 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?: number, roundPx?: boolean): Phaser.BitmapData;
- draw(source: any, x?: number, y?: number, width?: number, height?: number, blendMode?: number, roundPx?: boolean): Phaser.BitmapData;
- drawGroup(group: Phaser.Group, blendMode?: number, 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;
- text(text: string, x?: number, y?: number, font?: string, color?: string, shadow?: boolean): Phaser.BitmapData;
- textureLine(line: Phaser.Line, key: string, repeat?: string): Phaser.BitmapData;
- update(x?: number, y?: number, width?: number, height?: number): Phaser.BitmapData;
-
- }
-
- 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;
- physicsType: number;
- previousPosition: Phaser.Point;
- previousRotation: Phaser.Point;
- position: Phaser.Point;
- renderOrderID: number;
- 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?: string|number, outFrame?: string|number, downFrame?: string|number, upFrame?: string|number);
-
- forceOut: boolean;
- freezeFrames: boolean;
- onDownSound: Phaser.Sound|Phaser.AudioSprite;
- onDownSoundMarker: string;
- onInputDown: Phaser.Signal;
- onInputOut: Phaser.Signal;
- onInputOver: Phaser.Signal;
- onInputUp: Phaser.Signal;
- onOutSound: Phaser.Sound|Phaser.AudioSprite;
- onOutSoundMarker: string;
- onOverSound: Phaser.Sound|Phaser.AudioSprite;
- onOverSoundMarker: string;
- onOverMouseOnly: boolean;
- onUpSound: Phaser.Sound|Phaser.AudioSprite;
- onUpSoundMaker: string;
- physicsType: number;
- type: number;
-
- clearFrames(): void;
- setDownSound(sound: Phaser.Sound|Phaser.AudioSprite, marker?: string): void;
- setFrames(overFrame?: string|number, outFrame?: string|number, downFrame?: string|number, upFrame?: string|number): void;
- onInputDownHandler(sprite: Phaser.Button, pointer: Phaser.Pointer): void;
- onInputUpHandler(sprite: Phaser.Button, pointer: Phaser.Pointer, isOver: boolean): void;
- removedFromWorld(): void;
- setOutSound(sound: Phaser.Sound|Phaser.AudioSprite, marker?: string): void;
- setOverSound(sound: Phaser.Sound|Phaser.AudioSprite, marker?: string): void;
- setSounds(overSound?: Phaser.Sound|Phaser.AudioSprite, overMarker?: string, downSound?: Phaser.Sound|Phaser.AudioSprite, downMarker?: string, outSound?: Phaser.Sound|Phaser.AudioSprite, outMarker?: string, upSound?: Phaser.Sound|Phaser.AudioSprite, upMarker?: string): void;
- setState(newState: number): void;
- setUpSound(sound: Phaser.Sound|Phaser.AudioSprite, marker?: string): void;
-
- }
-
- class 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;
- addMissingImage(): 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: PIXI.DisplayObject): 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;
- unfollow(): void;
- update(): void;
-
- }
-
- class Canvas {
-
- static addToDOM(canvas: HTMLCanvasElement, parent: HTMLElement, 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; };
-
- }
-
- interface CursorKeys {
-
- up: Phaser.Key;
- down: Phaser.Key;
- left: Phaser.Key;
- right: Phaser.Key;
-
- }
-
- class Device {
-
- static LITTLE_ENDIAN: boolean;
- static onInitialized: Phaser.Signal;
-
- static checkFullScreenSupport(): void;
- static canPlayAudio(type: string): boolean;
- static isConsoleOpen(): boolean;
- static isAndroidStockBrowser(): string;
- static whenReady: (callback: Function, context?: any) => void;
-
- 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;
- 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;
-
- }
-
-
- module Easing {
-
- var Default: Function;
- var Power0: Function;
- var Power1: Function;
- var power2: Function;
- var power3: Function;
- var power4: Function;
-
- class Back {
- static In(k: number): number;
- static Out(k: number): number;
- static InOut(k: number): number;
- }
-
- class Bounce {
- static In(k: number): number;
- static Out(k: number): number;
- static InOut(k: number): number;
- }
-
- class Circular {
- static In(k: number): number;
- static Out(k: number): number;
- static InOut(k: number): number;
- }
-
- class Cubic {
- static In(k: number): number;
- static Out(k: number): number;
- static InOut(k: number): number;
- }
-
- class Elastic {
- static In(k: number): number;
- static Out(k: number): number;
- static InOut(k: number): number;
- }
-
- class Exponential {
- static In(k: number): number;
- static Out(k: number): number;
- static InOut(k: number): number;
- }
-
- class Linear {
- static None(k: number): number;
- }
-
- class Quadratic {
- static In(k: number): number;
- static Out(k: number): number;
- static InOut(k: number): number;
- }
-
- class Quartic {
- static In(k: number): number;
- static Out(k: number): number;
- static InOut(k: number): number;
- }
-
- class Quintic {
- static In(k: number): number;
- static Out(k: number): number;
- static InOut(k: number): number;
- }
-
- class Sinusoidal {
- static In(k: number): number;
- static Out(k: number): number;
- static InOut(k: number): number;
- }
-
- }
-
- class Ellipse {
-
- constructor(x?: number, y?: number, width?: number, height?: number);
-
- bottom: number;
- empty: boolean;
- height: number;
- left: number;
- right: number;
- top: number;
- type: number;
- width: number;
- x: number;
- y: number;
-
- static constains(a: Phaser.Ellipse, x: number, y: number): boolean;
-
- clone(output: Phaser.Ellipse): Phaser.Ellipse;
- contains(x: number, y: number): boolean;
- copyFrom(source: any): Phaser.Ellipse;
- copyTo(dest: any): any;
- getBounds(): Phaser.Rectangle;
- setTo(x: number, y: number, width: number, height: number): Phaser.Ellipse;
- toString(): string;
-
- }
-
- class Events {
-
- constructor(sprite: Phaser.Sprite);
-
- parent: Phaser.Sprite;
- onAddedToGroup: Phaser.Signal;
- onRemovedFromGroup: Phaser.Signal;
- onRemovedFromWorld: Phaser.Signal;
- onKilled: Phaser.Signal;
- onRevived: Phaser.Signal;
- onOutOfBounds: Phaser.Signal;
- onEnterBounds: Phaser.Signal;
- onInputOver: Phaser.Signal;
- onInputOut: Phaser.Signal;
- onInputDown: Phaser.Signal;
- onInputUp: Phaser.Signal;
- onDestroy: Phaser.Signal;
- onDragStart: Phaser.Signal;
- onDragStop: Phaser.Signal;
- 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;
- fitSprite(sprite: Phaser.Sprite): 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;
- persist: boolean;
- 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|string, height?: number|string, 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: CanvasRenderingContext2D;
- 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;
- plugins: PluginManager;
- preserveDrawingBuffer: Boolean;
- raf: Phaser.RequestAnimationFrame;
- renderer: number;
- renderType: number;
- resolution: 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;
- physicsType: number;
- position: Phaser.Point;
- previousPosition: Point;
- previousRotation: number;
- 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?: PIXI.DisplayObjectContainer, 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;
-
- alpha: number;
- angle: number;
- alive: boolean;
- cameraOffset: Phaser.Point;
- classType: any;
- cursor: any;
- cursorIndex: number;
- enableBody: boolean;
- enableBodyDebug: boolean;
- exists: boolean;
- fixedToCamera: boolean;
- game: Phaser.Game;
- ignoreDestroy: boolean;
- length: number;
- name: string;
- onDestroy: Phaser.Signal;
- physicsBodyType: number;
- physicsType: number;
- position: Phaser.Point;
- rotation: number;
- scale: Phaser.Point;
- total: number;
- type: number;
- visible: boolean;
- 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): PIXI.DisplayObject;
- 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(): PIXI.DisplayObject;
- 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): void;
- setAllChildren(key: string, value: any, checkAlive?: boolean, checkVisible?: boolean, operation?: number, force?: boolean): void;
- 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: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture, frame: string|number);
-
- alive: boolean;
- angle: number;
- anchor: Phaser.Point;
- animations: Phaser.AnimationManager;
- autoCull: boolean;
- bottom: number;
- cameraOffset: Phaser.Point;
- cropRect: Phaser.Rectangle;
- debug: boolean;
- deltaX: number;
- deltaY: number;
- deltaZ: number;
- destroyPhase: boolean;
- events: Phaser.Events;
- exists: boolean;
- fixedToCamera: boolean;
- frame: string|number;
- frameName: string;
- fresh: boolean;
- game: Phaser.Game;
- inCamera: boolean;
- input: Phaser.InputHandler;
- inputEnabled: boolean;
- inWorld: boolean;
- key: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture;
- left: number;
- name: string;
- offsetX: number;
- offsetY: number;
- position: Phaser.Point;
- previousPosition: Phaser.Point;
- previousRotation: number;
- renderOrderID: number;
- right: number;
- scale: Phaser.Point;
- smoothed: boolean;
- top: number;
- type: number;
- world: Phaser.Point;
- z: number;
-
- bringToTop(): Phaser.Image;
- crop(rect: Phaser.Rectangle, copy?: boolean): void;
- destroy(destroyChildren?: boolean): void;
- kill(): Phaser.Image;
- loadTexture(key: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture, frame: string|number): 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;
- moveCallback: (pointer: Phaser.Pointer, x: number, y: number) => void;
- 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: PIXI.DisplayObject, 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;
- dragOffset: Phaser.Point;
- dragFromCenter: boolean;
- draggable: boolean;
- dragStartPoint: Phaser.Point;
- 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.Sprite): 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;
- normalAngle: number;
- normalX: number;
- normalY: number;
- perpSlope: number;
- right: number;
- slope: number;
- start: Phaser.Point;
- top: number;
- type: 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;
- static reflect(a: Phaser.Line, b: Phaser.Line): number;
-
- clone(output: Phaser.Line): Phaser.Line;
- coordinatesOnLine(stepRate: number, results: any[]): any[];
- fromAngle(x: number, y: number, angle: number, length: number): Phaser.Line;
- fromSprite(startSprite: Phaser.Sprite, endSprite: Phaser.Sprite, useCenter?: boolean): Phaser.Line;
- intersects(line: Phaser.Line, asSegment?: boolean, result?: Phaser.Point): Phaser.Point;
- pointOnLine(x: number, y: number): boolean;
- pointOnSegment(x: number, y: number): boolean;
- reflect(line: Phaser.Line): number;
- 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: boolean|string;
- enableParallel: boolean;
- game: Phaser.Game;
- hasLoaded: boolean;
- isLoading: boolean;
- maxParallelDownloads: number;
- onFileStart: Phaser.Signal;
- onFileComplete: Phaser.Signal;
- onFileError: Phaser.Signal;
- onLoadComplete: Phaser.Signal;
- onLoadStart: Phaser.Signal;
- onPackComplete: Phaser.Signal;
- preloadSprite: any;
- progress: number;
- progressFloat: number;
- resetLocked: boolean;
- useXDomainRequest: boolean;
-
- asyncComplete(file: any, errorMessage?: string): void;
- addSyncPoint(type: string, key: string): Phaser.Loader;
- addToFileList(type: string, key: string, url: string, properties: any, overwrite: boolean): 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: string|string[]|any, autoDecode?: boolean): Phaser.Loader;
- audiosprite(key: string, urls: string[], jsonURL?: string, jsonData?: string|any, autoDecode?: boolean): Phaser.Loader;
- binary(key: string, url: string, callback?: Function, callbackContext?: any): Phaser.Loader;
- bitmapFont(key: string, textureURL: string, xmlURL?: string, xmlData?: any, xSpacing?: number, ySpacing?: number): Phaser.Loader;
- checkKeyExists(type: string, key: string): boolean;
- csvLoadComplete(file: any, xhr: XMLHttpRequest): void;
- fileComplete(file: any, xhr: XMLHttpRequest): void;
- fileError(file: any, xhr: XMLHttpRequest, reason: string): void;
- finishedLoading(abnormal?: boolean): void;
- getAsset(type: string, key: string): any;
- getAssetIndex(type: string, key: string): number;
- getAudioURL(urls: any[]): void;
- image(key: string, url: string, overwrite?: boolean): Phaser.Loader;
- json(key: string, url: string, overwrite?: boolean): Phaser.Loader;
- jsonLoadComplete(file: any, xhr: XMLHttpRequest): void;
- loadAudioTag(file: any): void;
- loadFile(file: any): void;
- loadImageTag(file: any): void;
- pack(key: string, url?: string, data?: any, callbackContext?: any): Phaser.Loader;
- parseXml(data: string): XMLDocument;
- physics(key: string, url?: string, data?: any, format?: string): Phaser.Loader;
- processLoadQueue(): void;
- processPack(pack: any): void;
- removeAll(): void;
- removeFile(type: string, key: string): void;
- replaceInFileList(type: string, key: string, url: string, properties: any): void;
- reset(hard?: boolean, clearEvents?: boolean): void;
- resize(): void;
- script(key: string, url: String, callback?: Function, callbackContext?: any): Phaser.Loader;
- setPreloadSprite(sprite: Phaser.Sprite|Phaser.Image, 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;
- transformUrl(url: string): string;
- updateProgress(): void;
- withSyncPoint(callback: Function, callbackContext?: any): Phaser.Loader;
- xml(key: string, url: string, overwrite?: boolean): Phaser.Loader;
- xhrLoad(file: any, url: string, type: string, onload: Function, onerror?: Function): void;
- xhrLoadWithXDR(file: any, url: string, type: string, onload: Function, onerror?: Function): void;
- xmlLoadComplete(file: any, xhr: XMLHttpRequest): void;
-
- }
-
- class LoaderParser {
-
- static bitmapFont(game: Phaser.Game, xml: any, cacheKey: string, xSpacing: number, ySpacing: number): Phaser.FrameData;
-
- }
-
- class Matrix extends PIXI.Matrix {
-
- a: number;
- b: number;
- c: number;
- d: number;
- tx: number;
- ty: number;
- type: number;
-
- apply(pos: Phaser.Point, newPos?: Phaser.Point): Phaser.Point;
- applyInverse(pos: Phaser.Point, newPos?: Phaser.Point): Phaser.Point;
- fromArray(array: number[]);
- toArray(transpose: boolean): number[];
- translate(x: number, y: number): Phaser.Matrix;
- scale(x: number, y: number): Phaser.Matrix;
- rotate(angle: number): Phaser.Matrix;
- append(matrix: Phaser.Matrix): Phaser.Matrix;
- identity(): Phaser.Matrix;
-
- }
-
- 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 roundAwayFromZero(value: number): number;
- static roundTo(value: number, place?: number, base?: number): number;
- static shear(n: number): number;
- static shift(stack: any[]): any;
- static shuffleArray(array: T[]): T[];
- 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: number;
-
- 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);
-
- button: number;
- capture: boolean;
- callbackContext: any;
- event: MSPointerEvent;
- 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;
- pointerDownCallback: (event: MSPointerEvent) => void;
- pointerMoveCallback: (event: MSPointerEvent) => void;
- pointerUpCallback: (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);
-
- fresh: boolean;
-
- 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: typeof Phaser.Particle;
- particleDrag: Phaser.Point;
- physicsType: number;
- 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, total?: number, immediate?: boolean): 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?: (k: number) => 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;
- reset(): void;
- setBoundsToWorld(): void;
- startSystem(system: number): void;
- update(): void;
-
- }
-
- module Physics {
-
- class Arcade {
-
- static SORT_NONE: number;
- static LEFT_RIGHT: number;
- static RIGHT_LEFT: number;
- static TOP_BOTTOM: number;
- static BOTTOM_TOP: number;
- 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;
- sortDirection: number;
-
- accelerationFromRotation(rotation: number, speed?: number, point?: Phaser.Point): Phaser.Point;
- accelerateToObject(displayObject: any, destination: any, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number;
- accelerateToPointer(displayObject: any, pointer?: Phaser.Pointer, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number;
- accelerateToXY(displayObject: any, x: number, y: number, speed?: number, xSpeedMax?: number, ySpeedMax?: number): number;
- angleBetween(source: any, target: any): number;
- angleToPointer(displayObject: any, pointer?: Phaser.Pointer): number;
- angleToXY(displayObject: any, x: number, y: number): number;
- collide(object1: 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;
- sort(group: Phaser.Group): void;
- 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;
- dirty: boolean;
- drag: Phaser.Point;
- embedded: boolean;
- enable: boolean;
- facing: number;
- friction: Phaser.Point;
- 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: { [index: number]: ((x: number, y: number, oH: number, oV: number, obj: Phaser.Physics.Ninja.Circle, t: Phaser.Physics.Ninja.Tile) => number); };
- oldPos: Phaser.Point;
- height: number;
- pos: Phaser.Point;
- radius: number;
- system: Phaser.Physics.Ninja;
- type: number;
- 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;
-
- }
-
- enum TileType {
- TYPE_EMPTY,
- TYPE_FULL,
- TYPE_45DEG,
- TYPE_CONCAVE,
- TYPE_CONVEX,
- TYPE_22DEGs,
- TYPE_22DEGb,
- TYPE_67DEGs,
- TYPE_67DEGb,
- TYPE_HALF
- }
-
- 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;
- flipped: boolean;
- height: number;
- id: number;
- oldpos: Phaser.Point;
- pos: Phaser.Point;
- right: number;
- rotation: number;
- system: Phaser.Physics.Ninja;
- type: Phaser.Physics.Ninja.TileType;
- 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.RevoluteConstraint;
- 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 RevoluteConstraint 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 implements IStateCycle {
-
- constructor(game: Phaser.Game, parent: PIXI.DisplayObject);
-
- active: boolean;
- game: Phaser.Game;
- hasPostRender: boolean;
- hasPostUpdate: boolean;
- hasPreUpdate: boolean;
- hasRender: boolean;
- hasUpdate: boolean;
- parent: PIXI.DisplayObject;
- 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: PIXI.DisplayObject);
-
- parent: PIXI.DisplayObject;
- 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: PIXI.DisplayObject);
-
- 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: PIXI.DisplayObject);
-
- 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: PIXI.DisplayObject);
-
- 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 Juicy extends Phaser.Plugin {
-
- constructor(game: Phaser.Game);
-
- createScreenFlash(color?: string): Phaser.Plugin.Juicy.ScreenFlash;
- createTrail(length?: number, color?: number): Phaser.Plugin.Juicy.Trail;
- overScale(object: Phaser.Sprite, scale?: number, initialScale?: Phaser.Point): void;
- jelly(object: Phaser.Sprite, strength?: number, delay?: number, initialScale?: Phaser.Point): void;
- mouseStretch(object: Phaser.Sprite, strength?: number, initialScale?: Phaser.Point): void;
- update(): void;
- shake(duration?: number, strength?: number): void;
- }
-
- module Juicy {
-
- class Trail {
-
- constructor(game: Phaser.Game, trailLength?: number, color?: number);
-
- target: Phaser.Sprite;
- trailLength: number;
- trailWidth: number;
- trailScaling: boolean;
- trailColor: number;
-
- update(): void;
- addSegment(x: number, y: number): void;
- redrawSegments(offsetX: number, offsetY: number): void;
-
- }
-
- class ScreenFlash {
-
- constructor(game: Phaser.Game, color?: string);
-
- flash(maxAlpha?: number, duration?: number): void;
-
- }
- }
- }
-
- class PluginManager implements IStateCycle {
-
- constructor(game: Phaser.Game);
-
- game: Phaser.Game;
- plugins: Phaser.Plugin[];
-
- add(plugin: Phaser.Plugin | typeof 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;
- type: 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: Phaser.Point[]|number[]);
- constructor(...points: Phaser.Point[]);
- constructor(...points: number[]);
-
- area: number;
- points: number[]|Phaser.Point[];
- type: number;
-
- clone(output: Phaser.Polygon): Phaser.Polygon;
- contains(x: number, y: number): boolean;
- flatten(): Phaser.Polygon;
- setTo(points: Phaser.Point[]|number[]): void;
- setTo(...points: Phaser.Point[]): void;
- setTo(...points: number[]): void;
- toNumberArray(output?: number[]): number[];
-
- }
-
- 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;
- type: number;
- 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;
- matrix: PIXI.Matrix;
- 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);
-
- 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: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture, frame?: string|number, 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: string|number;
- frameName: string;
- fresh: boolean;
- game: Phaser.Game;
- input: Phaser.InputHandler;
- inputEnabled: boolean;
- key: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture;
- name: string;
- points: Phaser.Point[];
- position: Phaser.Point;
- previousPosition: Phaser.Point;
- previousRotation: number;
- renderOrderID: number;
- segments: Phaser.Rectangle[];
- type: number;
- updateAnimation: Function;
- world: Phaser.Point;
- x: number;
- y: number;
- z: number;
-
- destroy(destroyChildren?: boolean): void;
- loadTexture(key: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture, frame?: string|number): void;
- play(): void;
- preUpdate(): void;
- postUpdate(): void;
- reset(x: number, y: number): void;
- setFrame(frame: Phaser.Frame): void;
- update(): void;
-
- }
-
- class RoundedRectangle extends PIXI.RoundedRectangle {
-
- x: number;
- y: number;
- width: number;
- height: number;
- radius: number;
- type: number;
-
- clone(): RoundedRectangle;
- contains(x: number, y: number): boolean;
-
- }
-
- 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;
- fadeTween: Phaser.Tween;
- 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;
- onEndedHandler: () => void;
- 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, marker?: string): void;
- fadeOut(duration?: number): void;
- fadeTo(duration?: number, volume?: number): void;
- loopFull(volume?: number): Phaser.Sound;
- 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;
- setDecodedCallback(files: string[]|Phaser.Sound[], callback: Function, callbackContext: any): void;
- stopAll(): void;
- unlock(): void;
- update(): void;
-
- }
-
- class Sprite extends PIXI.Sprite {
-
- constructor(game: Phaser.Game, x: number, y: number, key?: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture, frame?: string|number);
-
- alive: boolean;
- anchor: Phaser.Point;
- angle: number;
- animations: Phaser.AnimationManager;
- autoCull: boolean;
- body: any;
- bottom: number;
- 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: string|number;
- frameName: string;
- fresh: boolean;
- game: Phaser.Game;
- health: number;
- inCamera: boolean;
- input: Phaser.InputHandler;
- inputEnabled: boolean;
- inWorld: boolean;
- key: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture;
- left: number;
- lifespan: number;
- name: string;
- offsetX: number;
- offsetY: number;
- outOfBoundsKill: boolean;
- previousPosition: Phaser.Point;
- previousRotation: number;
- position: Phaser.Point;
- physicsEnabled: boolean;
- physicsType: number;
- renderOrderID: number;
- right: number;
- scale: Phaser.Point;
- scaleMin: Phaser.Point;
- scaleMax: Phaser.Point;
- smoothed: boolean;
- top: number;
- 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: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture, frame?: string|number, stopAnimation?: boolean): void;
- overlap(displayObject: PIXI.DisplayObject): 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: PIXI.DisplayObjectContainer, 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;
- checkVisibility(): void;
- destroy(): void;
- parseConfig(config: any): void;
- postUpdate(): void;
- preUpdate(): void;
- setBackgroundColor(backgroundColor: number|string): void;
- update(): void;
- updateTransform(): void;
- visibilityChange(event: Event): void;
-
- }
-
- interface ResizeCallback {
- (scale: ScaleManager, parentBounds: Rectangle): any;
- }
-
- class ScaleManager {
-
- constructor(game: Phaser.Game, width: number|string, height: number|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;
- clickTrampoline: string;
- 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;
- isGameLandscape: boolean; //readonly
- isGamePortrait: boolean; //readonly
- 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;
- key: string;
- 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;
- init(...args: any[]): void;
- loadRender(): void;
- loadUpdate(): void;
- paused(): void;
- pauseUpdate(): void;
- preload(): void;
- render(): void;
- resize(): void;
- shutdown(): void;
- update(): void;
-
- }
-
- interface IStateCycle {
-
- 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;
- 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[];
- cssFont: string;
- destroyPhase: boolean;
- events: Phaser.Events;
- exists: boolean;
- fill: any;
- fixedToCamera: boolean;
- font: string;
- fontSize: number|string;
- fontWeight: string;
- fontStyle: string;
- fontVariant: string;
- game: Phaser.Game;
- input: Phaser.InputHandler;
- inputEnabled: boolean;
- lineSpacing: number;
- name: string;
- padding: Phaser.Point;
- physicsType: number;
- position: Phaser.Point;
- previousPosition: Phaser.Point;
- previousRotation: number;
- renderOrderID: number;
- 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;
- componentsToFont(components: any): string;
- destroy(destroyChildren?: boolean): void;
- fontToComponents(font: string): any;
- 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;
- updateFont(components: any): void;
- updateTexture(): void;
- updateLine(text: string, x?: number, y?: number): 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;
- exists: boolean;
- fixedToCamera: boolean;
- game: Phaser.Game;
- index: number;
- layer: Phaser.TilemapLayer;
- map: Phaser.Tilemap;
- name: string;
- physicsType: number;
- rayStepRate: number;
- renderSettings: { enableScrollDelta: boolean; overdrawRatio: number; copyCanvas: any; };
- 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;
- setScale(xScale?: number, yScale?: number): 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?: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture, frame?: string|number);
-
- 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: string|number;
- frameName: string;
- fresh: boolean;
- game: Phaser.Game;
- input: Phaser.InputHandler;
- inputEnabled: boolean;
- key: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture;
- name: string;
- position: Phaser.Point;
- previousPosition: Phaser.Point;
- previousRoation: number;
- renderOrderID: number;
- type: number;
- world: Phaser.Point;
- z: number;
-
- autoScroll(x: number, y: number): void;
- destroy(destroyChildren?: boolean): void;
- loadTexture(key: string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture, frame: string|number): 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, context?: any, index?: number): Phaser.Tween;
- loop(value?: boolean): Phaser.Tween;
- onUpdateCallback(callback: Function, callbackContext: any): Phaser.Tween;
- pause(): void;
- repeat(total: number, repeatDelay?: number, index?: number): Phaser.Tween;
- repeatDelay(duration: 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;
- updateTweenData(property: string, value: number | Function, index?: number): Phaser.Tween;
- yoyo(enable: boolean, yoyoDelay?: number, index?: number): Phaser.Tween;
- yoyoDelay(duration: number, 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;
- interpolate: boolean;
- interpolateFunctionContext: Phaser.Math;
- interpolationContext: Phaser.Math;
- interpolationFunction: Function;
- isRunning: boolean;
- isFrom: boolean;
- parent: Phaser.Tween;
- percent: number;
- repeatCounter: number;
- startTime: number;
- value: number;
- yoyo: boolean;
- yoyoDelay: number;
-
- 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 randomChoice(choice1: any, choice2: any): any;
- 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;
- isPaused: boolean;
- randomX: number;
- randomY: number;
- stats: {
- skipped: number;
- ignored: number;
- checked: 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;
-
- }
-}
diff --git a/src/definitions/pixi.d.ts b/src/definitions/pixi.d.ts
deleted file mode 100644
index c8405e9..0000000
--- a/src/definitions/pixi.d.ts
+++ /dev/null
@@ -1,1910 +0,0 @@
-// Type definitions for PIXI 2.2.8 2015-03-24
-// 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;
- clearBeforeRender: boolean;
- height: number;
- resolution: number;
- transparent: boolean;
- type: number;
- view: HTMLCanvasElement;
- width: number;
-
- destroy(): void;
- 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;
- lineJoin?: 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;
- maxWidth: 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: number;
- 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?: Point, globalPos?: Point): 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: any[]; //number[] Point[]
-
- 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);
-
- static fontPropertiesCanvas: any;
- static fontPropertiesContext: any;
- static fontPropertiesCache: any;
-
- 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;
-
- destroy(): void;
- 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/game/ai/specs/BullyAI.spec.ts b/src/game/ai/specs/BullyAI.spec.ts
index 176e0e9..a7f5a7f 100644
--- a/src/game/ai/specs/BullyAI.spec.ts
+++ b/src/game/ai/specs/BullyAI.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.AI.Specs {
"use strict";
diff --git a/src/game/equipments/specs/EnergyDepleter.spec.ts b/src/game/equipments/specs/EnergyDepleter.spec.ts
index b110ccf..ace4e46 100644
--- a/src/game/equipments/specs/EnergyDepleter.spec.ts
+++ b/src/game/equipments/specs/EnergyDepleter.spec.ts
@@ -1,4 +1,3 @@
-///
///
module SpaceTac.Game.Specs {
diff --git a/src/game/equipments/specs/SubMunitionMissile.spec.ts b/src/game/equipments/specs/SubMunitionMissile.spec.ts
index bfcb493..72aba11 100644
--- a/src/game/equipments/specs/SubMunitionMissile.spec.ts
+++ b/src/game/equipments/specs/SubMunitionMissile.spec.ts
@@ -1,4 +1,3 @@
-///
///
module SpaceTac.Game.Specs {
diff --git a/src/game/specs/AbstractWeapon.spec.ts b/src/game/specs/AbstractWeapon.spec.ts
index dc82ab9..db4ad94 100644
--- a/src/game/specs/AbstractWeapon.spec.ts
+++ b/src/game/specs/AbstractWeapon.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/Attribute.spec.ts b/src/game/specs/Attribute.spec.ts
index 2bf3868..4129270 100644
--- a/src/game/specs/Attribute.spec.ts
+++ b/src/game/specs/Attribute.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game {
"use strict";
diff --git a/src/game/specs/AttributeCollection.spec.ts b/src/game/specs/AttributeCollection.spec.ts
index bb9a88e..b4f821e 100644
--- a/src/game/specs/AttributeCollection.spec.ts
+++ b/src/game/specs/AttributeCollection.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game {
"use strict";
diff --git a/src/game/specs/BaseAction.spec.ts b/src/game/specs/BaseAction.spec.ts
index eb4f509..7519a3c 100644
--- a/src/game/specs/BaseAction.spec.ts
+++ b/src/game/specs/BaseAction.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game {
"use strict";
diff --git a/src/game/specs/Battle.spec.ts b/src/game/specs/Battle.spec.ts
index 073e25c..e865611 100644
--- a/src/game/specs/Battle.spec.ts
+++ b/src/game/specs/Battle.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game {
"use strict";
diff --git a/src/game/specs/BattleLog.spec.ts b/src/game/specs/BattleLog.spec.ts
index 7e5d1c8..4f34829 100644
--- a/src/game/specs/BattleLog.spec.ts
+++ b/src/game/specs/BattleLog.spec.ts
@@ -1,4 +1,3 @@
-///
///
module SpaceTac.Game {
@@ -6,7 +5,7 @@ module SpaceTac.Game {
// Check a single game log event
function checkEvent(got: BaseLogEvent, ship: Ship, code: string,
- target_ship: Ship = null, target_x: number = null, target_y: number = null): void {
+ target_ship: Ship = null, target_x: number = null, target_y: number = null): void {
if (target_ship) {
if (target_x === null) {
target_x = target_ship.arena_x;
diff --git a/src/game/specs/BattleOutcome.spec.ts b/src/game/specs/BattleOutcome.spec.ts
index e2e297a..65b90be 100644
--- a/src/game/specs/BattleOutcome.spec.ts
+++ b/src/game/specs/BattleOutcome.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/EffectTemplate.spec.ts b/src/game/specs/EffectTemplate.spec.ts
index 1f01ef0..6388e20 100644
--- a/src/game/specs/EffectTemplate.spec.ts
+++ b/src/game/specs/EffectTemplate.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/EndTurnAction.spec.ts b/src/game/specs/EndTurnAction.spec.ts
index c3ea386..10690af 100644
--- a/src/game/specs/EndTurnAction.spec.ts
+++ b/src/game/specs/EndTurnAction.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/Equipment.spec.ts b/src/game/specs/Equipment.spec.ts
index ded774f..be55c24 100644
--- a/src/game/specs/Equipment.spec.ts
+++ b/src/game/specs/Equipment.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/Fleet.spec.ts b/src/game/specs/Fleet.spec.ts
index 356ebb7..75b8575 100644
--- a/src/game/specs/Fleet.spec.ts
+++ b/src/game/specs/Fleet.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game {
"use strict";
diff --git a/src/game/specs/GameSession.spec.ts b/src/game/specs/GameSession.spec.ts
index 8fcb011..56230ea 100644
--- a/src/game/specs/GameSession.spec.ts
+++ b/src/game/specs/GameSession.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/LootGenerator.spec.ts b/src/game/specs/LootGenerator.spec.ts
index d00cab8..6f1b597 100644
--- a/src/game/specs/LootGenerator.spec.ts
+++ b/src/game/specs/LootGenerator.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/LootTemplate.spec.ts b/src/game/specs/LootTemplate.spec.ts
index 1f76be4..586ab94 100644
--- a/src/game/specs/LootTemplate.spec.ts
+++ b/src/game/specs/LootTemplate.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/MoveAction.spec.ts b/src/game/specs/MoveAction.spec.ts
index aef8fdd..c7243b9 100644
--- a/src/game/specs/MoveAction.spec.ts
+++ b/src/game/specs/MoveAction.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game {
"use strict";
diff --git a/src/game/specs/NameGenerator.spec.ts b/src/game/specs/NameGenerator.spec.ts
index 1c542c7..05b546a 100644
--- a/src/game/specs/NameGenerator.spec.ts
+++ b/src/game/specs/NameGenerator.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/Range.spec.ts b/src/game/specs/Range.spec.ts
index f3d978a..4b792cd 100644
--- a/src/game/specs/Range.spec.ts
+++ b/src/game/specs/Range.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/Serializer.spec.ts b/src/game/specs/Serializer.spec.ts
index 0394608..bee2ef7 100644
--- a/src/game/specs/Serializer.spec.ts
+++ b/src/game/specs/Serializer.spec.ts
@@ -1,4 +1,3 @@
-///
///
module SpaceTac.Game.Specs {
diff --git a/src/game/specs/Ship.spec.ts b/src/game/specs/Ship.spec.ts
index 4f75721..446469a 100644
--- a/src/game/specs/Ship.spec.ts
+++ b/src/game/specs/Ship.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/ShipGenerator.spec.ts b/src/game/specs/ShipGenerator.spec.ts
index ac35afa..aa4b75e 100644
--- a/src/game/specs/ShipGenerator.spec.ts
+++ b/src/game/specs/ShipGenerator.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/Slot.spec.ts b/src/game/specs/Slot.spec.ts
index 141ba30..89492dc 100644
--- a/src/game/specs/Slot.spec.ts
+++ b/src/game/specs/Slot.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/Star.spec.ts b/src/game/specs/Star.spec.ts
index b3fc58d..577b009 100644
--- a/src/game/specs/Star.spec.ts
+++ b/src/game/specs/Star.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/StarLink.spec.ts b/src/game/specs/StarLink.spec.ts
index f5c3bf8..e695fae 100644
--- a/src/game/specs/StarLink.spec.ts
+++ b/src/game/specs/StarLink.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/StarLocation.spec.ts b/src/game/specs/StarLocation.spec.ts
index 6c17d1e..b62bed9 100644
--- a/src/game/specs/StarLocation.spec.ts
+++ b/src/game/specs/StarLocation.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/Target.spec.ts b/src/game/specs/Target.spec.ts
index 126562e..b647bd5 100644
--- a/src/game/specs/Target.spec.ts
+++ b/src/game/specs/Target.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/game/specs/Tools.spec.ts b/src/game/specs/Tools.spec.ts
index 911a324..50d4cd3 100644
--- a/src/game/specs/Tools.spec.ts
+++ b/src/game/specs/Tools.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
@@ -9,7 +7,7 @@ module SpaceTac.Game.Specs {
constructor() {
this.a = "test";
- this.b = {c: 5.1, d: ["unit", "test", 5]};
+ this.b = { c: 5.1, d: ["unit", "test", 5] };
}
get(): string {
@@ -31,8 +29,8 @@ module SpaceTac.Game.Specs {
it("merges objects", () => {
expect(Tools.merge({}, {})).toEqual({});
- expect(Tools.merge({"a": 1}, {"b": 2})).toEqual({"a": 1, "b": 2});
- expect(Tools.merge({"a": 1}, {"a": 3, "b": 2})).toEqual({"a": 3, "b": 2});
+ expect(Tools.merge({ "a": 1 }, { "b": 2 })).toEqual({ "a": 1, "b": 2 });
+ expect(Tools.merge({ "a": 1 }, { "a": 3, "b": 2 })).toEqual({ "a": 3, "b": 2 });
});
});
}
diff --git a/src/game/specs/Universe.spec.ts b/src/game/specs/Universe.spec.ts
index b28ac7f..7ab1624 100644
--- a/src/game/specs/Universe.spec.ts
+++ b/src/game/specs/Universe.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.Game.Specs {
"use strict";
diff --git a/src/view/specs/ActionBar.spec.ts b/src/view/specs/ActionBar.spec.ts
index cd8d99c..c95d587 100644
--- a/src/view/specs/ActionBar.spec.ts
+++ b/src/view/specs/ActionBar.spec.ts
@@ -1,4 +1,3 @@
-///
///
module SpaceTac.View.Specs {
diff --git a/src/view/specs/BattleView.spec.ts b/src/view/specs/BattleView.spec.ts
index 4dc9188..c0f845d 100644
--- a/src/view/specs/BattleView.spec.ts
+++ b/src/view/specs/BattleView.spec.ts
@@ -1,4 +1,3 @@
-///
///
///
diff --git a/src/view/specs/ShipList.spec.ts b/src/view/specs/ShipList.spec.ts
index ab90d43..1b7baf2 100644
--- a/src/view/specs/ShipList.spec.ts
+++ b/src/view/specs/ShipList.spec.ts
@@ -1,4 +1,3 @@
-///
///
module SpaceTac.View.Specs {
diff --git a/src/view/specs/Targetting.spec.ts b/src/view/specs/Targetting.spec.ts
index 83a4386..3ff9073 100644
--- a/src/view/specs/Targetting.spec.ts
+++ b/src/view/specs/Targetting.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.View.Specs {
"use strict";
diff --git a/src/view/specs/TestGame.ts b/src/view/specs/TestGame.ts
index 0c8bdf8..3d76f74 100644
--- a/src/view/specs/TestGame.ts
+++ b/src/view/specs/TestGame.ts
@@ -1,4 +1,3 @@
-///
///
module SpaceTac.View.Specs {
@@ -6,7 +5,7 @@ module SpaceTac.View.Specs {
// Test game wrapper (use instead of jasmine 'it')
export function ingame_it(desc: string, func: (game: Phaser.Game, state: Phaser.State) => void,
- state: Phaser.State = null, ...stateargs: any[]) {
+ state: Phaser.State = null, ...stateargs: any[]) {
it(desc, (done: () => void) => {
spyOn(console, "log").and.stub();
spyOn(console, "warn").and.stub();
diff --git a/src/view/specs/Tools.spec.ts b/src/view/specs/Tools.spec.ts
index f912f92..7772d7c 100644
--- a/src/view/specs/Tools.spec.ts
+++ b/src/view/specs/Tools.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.View.Specs {
"use strict";
diff --git a/src/view/specs/ValueBar.spec.ts b/src/view/specs/ValueBar.spec.ts
index ed8de79..d204e76 100644
--- a/src/view/specs/ValueBar.spec.ts
+++ b/src/view/specs/ValueBar.spec.ts
@@ -1,5 +1,3 @@
-///
-
module SpaceTac.View.Specs {
"use strict";
diff --git a/typings.json b/typings.json
new file mode 100644
index 0000000..c2ed178
--- /dev/null
+++ b/typings.json
@@ -0,0 +1,8 @@
+{
+ "name": "succession",
+ "dependencies": {},
+ "globalDependencies": {
+ "jasmine": "registry:dt/jasmine#2.5.0+20161003201800",
+ "phaser": "github:photonstorm/phaser/v2/typescript/typings.json"
+ }
+}