From 8432f317395297cda689ec3468f656f0354bbc98 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Par=C3=A9?= <alex.pare.inc@gmail.com>
Date: Mon, 23 Nov 2015 19:07:55 -0500
Subject: [PATCH 1/2] Add p2.js Type definitions

I did it for him
https://github.com/clark-stevenson/p2.d.ts/issues/1
---
 p2/p2-tests.d.ts |   45 +++
 p2/p2.d.ts       | 1005 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 1050 insertions(+)
 create mode 100644 p2/p2-tests.d.ts
 create mode 100644 p2/p2.d.ts

diff --git a/p2/p2-tests.d.ts b/p2/p2-tests.d.ts
new file mode 100644
index 000000000..63c213321
--- /dev/null
+++ b/p2/p2-tests.d.ts
@@ -0,0 +1,45 @@
+/// <reference path="p2.d.ts"/>
+
+// Create a physics world, where bodies and constraints live
+var world = new p2.World({
+    gravity:[0, -9.82]
+});
+
+// Create an empty dynamic body
+var circleBody = new p2.Body({
+    mass: 5,
+    position: [0, 10]
+});
+
+// Add a circle shape to the body.
+var circleShape = new p2.Circle({ radius: 1 });
+circleBody.addShape(circleShape);
+
+// ...and add the body to the world.
+// If we don't add it to the world, it won't be simulated.
+world.addBody(circleBody);
+
+// Create an infinite ground plane.
+var groundBody = new p2.Body({
+    mass: 0 // Setting mass to 0 makes the body static
+});
+var groundShape = new p2.Plane();
+groundBody.addShape(groundShape);
+world.addBody(groundBody);
+
+// To get the trajectories of the bodies,
+// we must step the world forward in time.
+// This is done using a fixed time step size.
+var timeStep = 1 / 60; // seconds
+
+// The "Game loop". Could be replaced by, for example, requestAnimationFrame.
+setInterval(function(){
+
+    // The step method moves the bodies forward in time.
+    world.step(timeStep);
+
+    // Print the circle position to console.
+    // Could be replaced by a render call.
+    console.log("Circle y position: " + circleBody.position[1]);
+
+}, 1000 * timeStep);
diff --git a/p2/p2.d.ts b/p2/p2.d.ts
new file mode 100644
index 000000000..a0e3f8b6a
--- /dev/null
+++ b/p2/p2.d.ts
@@ -0,0 +1,1005 @@
+// Type definitions for p2.js v0.7.1
+// Project: https://github.com/schteppe/p2.js/
+// Definitions by: Clark Stevenson <https://github.com/clark-stevenson>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+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;
+        enableEquations: 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 interface BodyOptions {
+
+        mass?: number;
+        position?: number[];
+        velocity?: number[];
+        angle?: number;
+        angularVelocity?: number;
+        force?: number[];
+        angularForce?: number;
+        fixedRotation?: boolean;
+
+    }
+
+    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[];
+        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;
+        collisionResponse: boolean;
+
+        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 interface CapsuleOptions extends SharedShapeOptions {
+
+      length?: number;
+      radius?: number;
+
+    }
+
+    export class Capsule extends Shape {
+
+        constructor(options?: CapsuleOptions);
+
+        length: number;
+        radius: number;
+
+    }
+
+    export interface CircleOptions extends SharedShapeOptions {
+
+      radius?: number;
+
+    }
+
+    export class Circle extends Shape {
+
+        constructor(options?: CircleOptions);
+
+        radius: number;
+
+    }
+
+    export interface ConvexOptions extends SharedShapeOptions {
+
+      length?: number;
+      radius?: number;
+
+    }
+
+    export class Convex extends Shape {
+
+        static triangleArea(a: number[], b: number[], c: number[]): number;
+
+        constructor(options?: ConvexOptions);
+
+        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 interface HeightfieldOptions extends SharedShapeOptions {
+
+        heights?: number[];
+        minValue?: number;
+        maxValue?: number;
+        elementWidth?: number;
+
+    }
+
+    export class Heightfield extends Shape {
+
+        constructor(options?: HeightfieldOptions);
+
+        data: number[];
+        maxValue: number;
+        minValue: number;
+        elementWidth: number;
+
+    }
+
+    export interface SharedShapeOptions {
+
+        position?: number[];
+        angle?: number;
+        collisionGroup?: number;
+        collisionResponse?: boolean;
+        collisionMask?: number;
+        sensor?: boolean;
+
+    }
+
+    export interface ShapeOptions extends SharedShapeOptions {
+
+        type?: number;
+
+    }
+
+    export class Shape {
+
+        static idCounter: number;
+        static CIRCLE: number;
+        static PARTICLE: number;
+        static PLANE: number;
+        static CONVEX: number;
+        static LINE: number;
+        static BOX: number;
+        static CAPSULE: number;
+        static HEIGHTFIELD: number;
+
+        constructor(options?: ShapeOptions);
+
+        type: number;
+        id: number;
+        position: number[];
+        angle: number;
+        boundingRadius: number;
+        collisionGroup: number;
+        collisionResponse: boolean;
+        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 interface LineOptions extends SharedShapeOptions {
+
+      length?: number;
+
+    }
+
+    export class Line extends Shape {
+
+        constructor(options?: LineOptions);
+
+        length: number;
+
+    }
+
+    export class Particle extends Shape {
+
+        constructor(options?: SharedShapeOptions);
+
+    }
+
+    export class Plane extends Shape {
+
+        constructor(options?: SharedShapeOptions);
+
+    }
+
+    export interface BoxOptions {
+
+      width?: number;
+      height?: number;
+
+    }
+
+    export class Box extends Shape {
+
+        constructor(options?: BoxOptions);
+
+        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<T>(a: Array<T>, b: Array<T>): Array<T>;
+        static splice<T>(array: Array<T>, index: number, howMany: number): void;
+        static extend(a: any, b: any): void;
+        static defaults(options: any, defaults: any): any;
+
+    }
+
+    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: IslandNode[]): 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;
+    }
+
+}

From f1e51ed6ee399c74842fa71453a227f9b74d6fda Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Par=C3=A9?= <alex.pare.inc@gmail.com>
Date: Mon, 23 Nov 2015 19:24:58 -0500
Subject: [PATCH 2/2] rename test file

---
 p2/{p2-tests.d.ts => p2-tests.ts} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename p2/{p2-tests.d.ts => p2-tests.ts} (100%)

diff --git a/p2/p2-tests.d.ts b/p2/p2-tests.ts
similarity index 100%
rename from p2/p2-tests.d.ts
rename to p2/p2-tests.ts