增加可跑的物理游戏

build.js

@@ -14,4 +14,5 @@ if (cmd === 'build' && process.argv[3] === 'prod') {
   if (process.argv[4] === 'exml')
     cmd = 'buildProdEXML';
 }
-build[cmd](...remain);
+build[cmd]();
\ No newline at end of file
+// build[cmd](...remain);
\ No newline at end of file

egretProperties.1.json

-{
-  "engineVersion": "5.2.7",
-  "compilerVersion": "5.2.7",
-  "template": {},
-  "target": {
-    "current": "web"
-  },
-  "eui": {
-    "exmlRoot": [
-      "resource/eui_skins"
-    ],
-    "themes": [
-      "resource/default.thm.json"
-    ],
-    "exmlPublishPolicy": "commonjs"
-  },
-  "modules": [
-    {
-      "name": "egret"
-    },
-    {
-      "name": "eui"
-    },
-    {
-      "name": "assetsmanager"
-    },
-    {
-      "name": "tween"
-    },
-    {
-      "name": "game"
-    },
-    {
-      "name": "promise"
-    }
-  ]
-}
\ No newline at end of file

index.html

@@ -38,6 +38,7 @@
     <script src="libs/modules/promise/promise.js"></script>
     <script src="libs/zepto.min.js"></script>
     <script src="libs/security.js"></script>
+    <script src="libs/physics/physics.min.js"></script>
     <!-- <script src="default.thm.js"></script> -->
     <script src="output.js"></script>
     <script>

libs/physics/physics.d.ts

+//////////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) 2014-present, Egret Technology.
+//  All rights reserved.
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of the Egret nor the
+//       names of its contributors may be used to endorse or promote products
+//       derived from this software without specific prior written permission.
+//
+//  THIS SOFTWARE IS PROVIDED BY EGRET AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+//  OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+//  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+//  IN NO EVENT SHALL EGRET AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;LOSS OF USE, DATA,
+//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+//////////////////////////////////////////////////////////////////////////////////////
+    
+declare module p2 {
+
+    export class AABB {
+        upperBound: number[];
+        lowerBound: number[];
+        constructor(options?: {
+            upperBound?: number[];
+            lowerBound?: number[];
+        });
+
+        containsPoint(point: number[]): boolean;
+        setFromPoints(points: number[][], position: number[], angle: number, skinSize: number): void;
+        copy(aabb: AABB): void;
+        extend(aabb: AABB): void;
+        overlaps(aabb: AABB): boolean;
+        overlapsRay(ray:Ray): number;
+
+    }
+
+    export class Broadphase {
+
+        static AABB: number;
+        static BOUNDING_CIRCLE: 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);
+
+        result: Body[];
+        world: World;
+        boundingVolumeType: number;
+
+        setWorld(world: World): void;
+        getCollisionPairs(world: World): Body[];
+        boundingVolumeCheck(bodyA: Body, bodyB: Body): boolean;
+
+    }
+
+    export class NaiveBroadphase extends Broadphase {
+
+        aabbQuery(world: World, aabb: AABB, result: Body[]): Body[];
+
+    }
+
+    export class Narrowphase {
+
+        static findSeparatingAxis(c1:Convex, offset1:number[], angle1:number, c2:Convex, offset2:number[], angle2:number, sepAxis:number[]): boolean;
+        static getClosestEdge(c:Convex, angle:number, axis:number[], flip:boolean): number;
+        static projectConvexOntoAxis(convexShape:Convex, convexOffset:number[], convexAngle:number, worldAxis:number[], result:number[]): void;
+
+
+        contactEquationPool: ContactEquationPool;
+        contactEquations: ContactEquation[];
+        contactSkinSize: number;
+        enabledEquations: boolean;
+        enableFriction: boolean;
+        frictionCoefficient: number;
+        frictionEquationPool: FrictionEquationPool;
+        frictionEquations: FrictionEquation[];
+        frictionRelaxation: number;
+        frictionStiffness: number;
+        restitution: number;
+        slipForce: number;
+        stiffness: number;
+        surfaceVelocity: number;
+        //官方不赞成使用的属性
+        enableFrictionReduction: boolean;
+
+
+        bodiesOverlap(bodyA: Body, bodyB: Body): boolean;
+        capsuleCapsule(bi: Body, si: Capsule, xi: number[], ai: number, bj: Body, sj: Capsule, xj: number[], aj: number): void;
+        circleCapsule(bi: Body, si: Circle, xi: number[], ai: number, bj: Body, sj: Line, xj: number[], aj: number): void;
+        circleCircle(bodyA: Body, shapeA: Circle, offsetA: number[], angleA: number, bodyB: Body, shapeB: Circle, offsetB: number[], angleB: number, justTest: boolean, radiusA?:number, radiusB?:number): void;
+        circleConvex(circleBody:Body, circleShape:Circle, circleOffset:number[], circleAngle:number, convexBody:Body, convexShape:Convex, convexOffset:number[], convexAngle:number, justTest:boolean, circleRadius:number): void;
+        circleHeightfield(bi:Body, si:Circle, xi:number[], bj:Body, sj:Heightfield, xj:number[], aj:number): void;
+        circleLine(circleBody:Body, circleShape:Circle, circleOffset:number[], circleAngle:number, lineBody:Body, lineShape:Line, lineOffset:number[], lineAngle:number, justTest:boolean, lineRadius:number, circleRadius:number): void;
+        circleParticle(circleBody:Body, circleShape:Circle, circleOffset:number[], circleAngle:number, particleBody:Body, particleShape:Particle, particleOffset:number[], particleAngle:number, justTest:boolean): void;
+        circlePlane(bi:Body, si:Circle, xi:number[], bj:Body, sj:Plane, xj:number[], aj:number): void;
+        collidedLastStep(bodyA: Body, bodyB: Body): boolean;
+        convexCapsule(convexBody:Body, convexShape:Convex, convexPosition:number[], convexAngle:number, capsuleBody:Body, capsuleShape:Capsule, capsulePosition:number[], capsuleAngle:number): void;
+        convexConvex(bi:Body, si:Convex, xi:number[], ai:number, bj:Body, sj:Convex, xj:number[], aj:number): void;
+        convexLine(convexBody:Body, convexShape:Convex, convexOffset:number[], convexAngle:number, lineBody:Body, lineShape:Line, lineOffset:number[], lineAngle:number, justTest:boolean): void;
+        createContactEquation(bodyA: Body, bodyB: Body): ContactEquation;
+        createFrictionEquation(bodyA: Body,bodyB: Body): FrictionEquation;
+        createFrictionFromContact(contactEquation: ContactEquation): FrictionEquation;
+        lineBox(lineBody:Body, lineShape:Line, lineOffset:number[], lineAngle:number, boxBody:Body, boxShape:Box, boxOffset:number[], boxAngle:number, justTest:boolean): void;
+        lineCapsule(lineBody:Body, lineShape:Line, linePosition:number[], lineAngle:number, capsuleBody:Body, capsuleShape:Capsule, capsulePosition:number[], capsuleAngle:number): void;
+        lineLine(bodyA:Body, shapeA:Line, positionA:number[], angleA:number, bodyB:Body, shapeB:Line, positionB:number[], angleB:number): void;
+        particleConvex(particleBody:Body, particleShape:Particle, particleOffset:number[], particleAngle:number, convexBody:Body, convexShape:Convex, convexOffset:number[], convexAngle:number, justTest:boolean): void;
+        particlePlane(particleBody:Body, particleShape:Particle, particleOffset:number[], particleAngle:number, planeBody:Body, planeShape:Plane, planeOffset:number[], planeAngle:number, justTest:boolean): void;
+        planeCapsule(planeBody:Body, planeShape:Circle, planeOffset:number[], planeAngle:number, capsuleBody:Body, capsuleShape:Particle, capsuleOffset:number[], capsuleAngle:number, justTest:boolean): void;
+        planeConvex(planeBody:Body, planeShape:Plane, planeOffset:number[], planeAngle:number, convexBody:Body, convexShape:Convex, convexOffset:number[], convexAngle:number, justTest:boolean): void;
+        planeLine(planeBody:Body, planeShape:Plane, planeOffset:number[], planeAngle:number, lineBody:Body, lineShape:Line, lineOffset:number[], lineAngle:number): void;
+        reset(): void;
+    }
+
+    export class SAPBroadphase extends Broadphase {
+
+        axisIndex: number;
+        axisList: Body[];
+
+        aabbQuery(world: World, aabb: AABB, result: Body[]): Body[];
+        sortAxisList(a: Body[], axisIndex: number): Body[];
+
+    }
+
+    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;
+        });
+
+        type: number;
+        equations: 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, options?: {
+            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(maxForce: number): void;
+        getMaxForce(): number;
+
+    }
+
+    export class GearConstraint extends Constraint {
+
+        constructor(bodyA: Body, bodyB: Body, options?: {
+            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, options?: {
+            localOffsetB?: number[];
+            localAngleB?: number;
+            maxForce?: number;
+            collideConnected?: boolean;
+        });
+
+        localAngleB: number;
+        localOffsetB: number[];
+
+        setMaxForce(force: number): void;
+        getMaxForce(): number;
+
+    }
+
+    export class PrismaticConstraint extends Constraint {
+
+        constructor(bodyA: Body, bodyB: Body, options?: {
+            maxForce?: number;
+            localAnchorA?: number[];
+            localAnchorB?: number[];
+            localAxisA?: number[];
+            disableRotationalLock?: boolean;
+            upperLimit?: number;
+            lowerLimit?: number;
+            collideConnected?: boolean;
+        });
+
+        localAnchorA: number[];
+        localAnchorB: number[];
+        localAxisA: number[];
+        lowerLimit: number;
+        lowerLimitEnabled: boolean;
+        motorEnabled: boolean;
+        motorEquation: Equation;
+        motorSpeed: number;
+        position: number;
+        upperLimit: number;
+        upperLimitEnabled: boolean;
+
+        disableMotor(): void;
+        enableMotor(): void;
+        setLimits(lower: number, upper: number): void;
+
+    }
+
+    export class RevoluteConstraint extends Constraint {
+
+        constructor(bodyA: Body, bodyB: Body, options?: {
+            worldPivot?: number[];
+            localPivotA?: number[];
+            localPivotB?: number[];
+            maxForce?: number;
+            collideConnected?: boolean;
+        });
+
+        angle: number;
+        lowerLimit: number;
+        lowerLimitEnabled: boolean;
+        motorEnabled: boolean;
+        pivotA: number[];
+        pivotB: number[];
+        upperLimit: number;
+        upperLimitEnabled: boolean;
+
+        disableMotor(): void;
+        enableMotor(): void;
+        getMotorSpeed(): number;
+        //官方不赞成使用了
+        motorIsEnabled(): boolean;
+        setLimits(lower: number, upper: number): void;
+        setMotorSpeed(speed: number): void;
+
+    }
+
+    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[];
+        contactPointB: number[];
+        normalA: number[];
+        restitution: number;
+        firstImpact: boolean;
+        shapeA: Shape;
+        shapeB: Shape;
+
+    }
+
+    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[];
+        needsUpdate: boolean;
+        multiplier: number;
+        relativeVelocity: number;
+        enabled: boolean;
+
+        gmult(): number;
+        computeB(): number;
+        computeGq(): number;
+        computeGW(): number;
+        computeGWlambda(): number;
+        computeGiMf(): number;
+        computeGiMGt(): number;
+        addToWlambda(deltalambda: number): void;
+        computeInvC(eps: number): number;
+        update(): void;
+
+    }
+
+    export class FrictionEquation extends Equation {
+
+        constructor(bodyA: Body, bodyB: Body, slipForce: number);
+
+        contactEquations: ContactEquation;
+        contactPointA: number[];
+        contactPointB: number[];
+        t: number[];
+        shapeA: Shape;
+        shapeB: Shape;
+        frictionCoefficient: number;
+
+        setSlipForce(slipForce: number): void;
+        getSlipForce(): number;
+
+    }
+
+    export class RotationalLockEquation extends Equation {
+
+        constructor(bodyA: Body, bodyB: Body, options?: {
+            angle?: number;
+        });
+
+        angle: number;
+
+    }
+
+    export class RotationalVelocityEquation extends Equation {
+
+        constructor(bodyA: Body, bodyB: Body);
+
+    }
+
+    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 {
+
+        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 {
+
+        constructor(id: number);
+
+        id: number;
+
+    }
+
+    export class vec2 {
+
+        static add(out: number[], a: number[], b: number[]): number[];
+        static centroid(out: number[], a: number[], b: number[], c: number[]): number[];
+        static clone(a: number[]): number[];
+        static copy(out: number[], a: number[]): number[];
+        static create(): number[];
+        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 dist(a: number[], b: number[]): number;
+        static distance(a: number[], b: number[]): number;
+        static div(out: number[], a: number[], b: number[]): number[];
+        static divide(out: number[], a: number[], b: number[]): number[];
+        static dot(a: number[], b: number[]): number;
+        static fromValues(x: number, y: number): number[];
+        static getLineSegmentsIntersection(out: number[], p0: number[], p1: number[], p2: number[], p3: number[]): boolean;
+        static getLineSegmentsIntersectionFraction(p0: number[], p1: number[], p2: number[], p3: number[]): number;
+        static len(a: number[]): number;
+        static length(a: number[]): number;
+        static lerp(out: number[], a: number[], b: number[], t: number): void;
+        static mul(out: number[], a: number[], b: number[]): number[];
+        static multiply(out: number[], a: number[], b: number[]): number[];
+        static negate(out: number[], a: number[]): number[];
+        static normalize(out: number[], a: number[]): number[];
+        static reflect(out: number[], vector: number[], normal: number[]): void;
+        static rotate(out: number[], a: number[], angle: number): void;
+        static rotate90cw(out: number[], a: number[]): void;
+        static scale(out: number[], a: number[], b: number): number[];
+        static set(out: number[], x: number, y: number): number[];
+        static sqrDist(a: number[], b: number[]): number;
+        static squaredDistance(a: number[], b: number[]): number;
+        static sqrLen(a: number[]): number;
+        static squaredLength(a: number[]): number;
+        static str(vec: number[]): string;
+        static sub(out: number[], a: number[], b: number[]): number[];
+        static subtract(out: number[], a: number[], b: number[]): number[];
+        static toGlobalFrame(out: number[], localPoint: number[], framePosition: number[], frameAngle: number): void;
+        static toLocalFrame(out: number[], worldPoint: number[], framePosition: number[], frameAngle: number): void;
+        static vectorToLocalFrame(out: number[], worldVector: number[], frameAngle: number): void;
+
+    }
+
+//    export class BodyOptions {
+//
+//        mass: number;
+//        position: number[];
+//        velocity: number[];
+//        angle: number;
+//        angularVelocity: number;
+//        force: number[];
+//        angularForce: number;
+//        fixedRotation: number;
+//
+//    }
+
+    /**
+     * 刚体。有质量、位置、速度等属性以及一组被用于碰撞的形状
+     *
+     * @class Body
+     * @constructor
+     * @extends EventEmitter
+     * @param {Array}               [options.force]
+     * @param {Array}               [options.position]
+     * @param {Array}               [options.velocity]
+     * @param {Boolean}             [options.allowSleep]
+     * @param {Boolean}             [options.collisionResponse]
+     * @param {Number}              [options.angle=0]
+     * @param {Number}              [options.angularForce=0]
+     * @param {Number}              [options.angularVelocity=0]
+     * @param {Number}              [options.ccdIterations=10]
+     * @param {Number}              [options.ccdSpeedThreshold=-1]
+     * @param {Number}              [options.fixedRotation=false]
+     * @param {Number}              [options.gravityScale]
+     * @param {Number}              [options.id]
+     * @param {Number}              [options.mass=0]    一个大于0的数字。如果设置成0，其type属性将被设置为 Body.STATIC.
+     * @param {Number}              [options.sleepSpeedLimit]
+     * @param {Number}              [options.sleepTimeLimit]
+     * @param {Object}              [options]
+     *
+     * @example
+     *     // 创建一个刚体
+     *     var body = new Body({
+     *         mass: 1,
+     *         position: [0, 0],
+     *         angle: 0,
+     *         velocity: [0, 0],
+     *         angularVelocity: 0
+     *     });
+     *
+     *     // 将一个圆形形状添加到刚体
+     *     body.addShape(new Circle({ radius: 1 }));
+     *
+     *     // 将刚体加入 world
+     *     world.addBody(body);
+     */
+    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?);
+
+        /**
+         * 刚体id
+         * @property id
+         * @type {Number}
+         */
+        id: number;
+        /**
+         * 刚体被添加到的 world。如果没有被添加到 world 该属性将被设置为 null
+         * @property world
+         * @type {World}
+         */
+        world: World;
+        /**
+         * 刚体的碰撞形状
+         *
+         * @property shapes
+         * @type {Array}
+         */
+        shapes: Shape[];
+        /**
+         * 质量
+         * @property mass
+         * @type {number}
+         */
+        mass: number;
+        /**
+         * 惯性
+         * @property inertia
+         * @type {number}
+         */
+        inertia: number;
+        /**
+         * 是否固定旋转
+         * @property fixedRotation
+         * @type {Boolean}
+         */
+        fixedRotation: boolean;
+        /**
+         * 位置
+         * @property position
+         * @type {Array}
+         */
+        position: number[];
+        /**
+         * 位置插值
+         * @property interpolatedPosition
+         * @type {Array}
+         */
+        interpolatedPosition: number[];
+        /**
+         * 角度插值
+         * @property interpolatedAngle
+         * @type {Number}
+         */
+        interpolatedAngle: number;
+        /**
+         * 速度
+         * @property velocity
+         * @type {Array}
+         */
+        velocity: number[];
+        /**
+         * 角度
+         * @property angle
+         * @type {number}
+         */
+        angle: number;
+        /**
+         * 力
+         * @property force
+         * @type {Array}
+         */
+        force: number[];
+        /**
+         * 角力
+         * @property angularForce
+         * @type {number}
+         */
+        angularForce: number;
+        /**
+         * 限行阻尼。取值区间[0,1]
+         * @property damping
+         * @type {Number}
+         * @default 0.1
+         */
+        damping: number;
+        /**
+         * 角阻尼。取值区间[0,1]
+         * @property angularDamping
+         * @type {Number}
+         * @default 0.1
+         */
+        angularDamping: number;
+        /**
+         * 运动类型。 应该是Body.STATIC，Body.DYNAMIC，Body.KINEMATIC之一
+         *
+         * * Static 刚体不会动，不响应力或者碰撞
+         * * Dynamic 刚体会动，响应力和碰撞
+         * * Kinematic 刚体仅根据自身属性运动，不响应力或者碰撞
+         *
+         * @property type
+         * @type {number}
+         *
+         * @example
+         *     // 默认值是STATIC
+         *     var body = new Body();
+         *     console.log(body.type == Body.STATIC); // true
+         *
+         * @example
+         *     // 将质量设置为非0的值，会变为DYNAMIC
+         *     var dynamicBody = new Body({
+     *         mass : 1
+     *     });
+         *     console.log(dynamicBody.type == Body.DYNAMIC); // true
+         *
+         * @example
+         *     // KINEMATIC刚体只会运动，如果你改变它的速度
+         *     var kinematicBody = new Body({
+     *         type: Body.KINEMATIC
+     *     });
+         */
+        type: number;
+        /**
+         * 边界圆半径
+         * @property boundingRadius
+         * @type {Number}
+         */
+        boundingRadius: number;
+        /**
+         * 边框
+         * @property aabb
+         * @type {AABB}
+         */
+        aabb: AABB;
+        /**
+         * 设置AABB是否会更新。通过调用 updateAABB 方法更新它
+         * @property aabbNeedsUpdate
+         * @type {Boolean}
+         * @see updateAABB
+         *
+         * @example
+         *     body.aabbNeedsUpdate = true;
+         *     body.updateAABB();
+         *     console.log(body.aabbNeedsUpdate); // false
+         */
+        aabbNeedsUpdate: boolean;
+        /**
+         * 设置为true，刚体会自动进入睡眠。需要在 World 中允许刚体睡眠
+         * @property allowSleep
+         * @type {Boolean}
+         * @default true
+         */
+        allowSleep: boolean;
+        /**
+         * Body.AWAKE，Body.SLEEPY，Body.SLEEPING之一
+         *
+         * 默认值是 Body.AWAKE。如果刚体速度低于 sleepSpeedLimit，该属性将变为 Body.SLEEPY。如果持续 Body.SLEEPY 状态 sleepTimeLimit 秒，该属性将变为 Body.SLEEPY。
+         *
+         * @property sleepState
+         * @type {Number}
+         * @default Body.AWAKE
+         */
+        sleepState: number;
+        /**
+         * 如果速度小于该值，sleepState 将变为 Body.SLEEPY 状态
+         * @property sleepSpeedLimit
+         * @type {Number}
+         * @default 0.2
+         */
+        sleepSpeedLimit: number;
+        /**
+         * 如果持续 Body.SLEEPY 状态 sleepTimeLimit 秒，sleepState 将变为 Body.SLEEPING
+         * @property sleepTimeLimit
+         * @type {Number}
+         * @default 1
+         */
+        sleepTimeLimit: number;
+        /**
+         * 重力缩放因子。如果你想忽略刚体重心，设置为零。如果你想反转重力，将其设置为-1。
+         * @property {Number} gravityScale
+         * @default 1
+         */
+        gravityScale: number;
+
+
+        /**
+         * The angular velocity of the body, in radians per second.
+         * @property angularVelocity
+         * @type {number}
+         */
+        angularVelocity: number;
+        /**
+         * The inverse inertia of the body.
+         * @property invInertia
+         * @type {number}
+         */
+        invInertia: number;
+        /**
+         * The inverse mass of the body.
+         * @property invMass
+         * @type {number}
+         */
+        invMass: number;
+        /**
+         * The previous angle of the body.
+         * @property previousAngle
+         * @type {number}
+         */
+        previousAngle: number;
+        /**
+         * The previous position of the body.
+         * @property previousPosition
+         * @type {Array}
+         */
+        previousPosition: number[];
+        /**
+         * Constraint velocity that was added to the body during the last step.
+         * @property vlambda
+         * @type {Array}
+         */
+        vlambda: number[];
+        /**
+         * Angular constraint velocity that was added to the body during last step.
+         * @property wlambda
+         * @type {Array}
+         */
+        wlambda: number[];
+
+        /**
+         * The number of iterations that should be used when searching for the time of impact during CCD. A larger number will assure that there's a small penetration on CCD collision, but a small number will give more performance.
+         * @property {Number} ccdIterations
+         * @default 10
+         */
+        ccdIterations: number;
+        /**
+         * If the body speed exceeds this threshold, CCD (continuous collision detection) will be enabled. Set it to a negative number to disable CCD completely for this body.
+         * @property {Number} ccdSpeedThreshold
+         * @default -1
+         */
+        ccdSpeedThreshold: number;
+        /**
+         * Whether to produce contact forces when in contact with other bodies. Note that contacts will be generated, but they will be disabled. That means that this body will move through other bodies, but it will still trigger contact events, etc.
+         * @property collisionResponse
+         * @type {Boolean}
+         */
+        collisionResponse: boolean;
+        /**
+         * Set to true if you want to fix the body movement along the X axis. The body will still be able to move along Y.
+         * @property fixedX
+         * @type {Boolean}
+         */
+        fixedX: boolean;
+        /**
+         * Set to true if you want to fix the body movement along the Y axis. The body will still be able to move along X.
+         * @property fixedY
+         * @type {Boolean}
+         */
+        fixedY: boolean;
+        /**
+         * How long the body has been sleeping.
+         * @property idleTime
+         * @type {Number}
+         */
+        idleTime: number;
+
+        /**
+         * 与每个形状对应的显示对象
+         */
+        displays: egret.DisplayObject[];
+
+        /**
+         * 设置刚体总密度
+         * @method setDensity
+         */
+        setDensity(density: number): void;
+        /**
+         * 得到所有形状的总面积
+         * @method getArea
+         * @return {Number}
+         */
+        getArea(): number;
+        /**
+         * 获得AABB
+         * @method getAABB
+         */
+        getAABB(): AABB;
+        /**
+         * 更新AABB
+         * @method updateAABB
+         */
+        updateAABB(): void;
+        /**
+         * 更新外边界
+         * @method updateBoundingRadius
+         */
+        updateBoundingRadius(): void;
+        /**
+         * 添加一个形状
+         *
+         * @method addShape
+         * @param  {Shape} shape 形状
+         * @param  {Array} [offset] 偏移
+         * @param  {Number} [angle] 角度
+         *
+         * @example
+         *     var body = new Body(),
+         *         shape = new Circle();
+         *
+         *     // 位于中心
+         *     body.addShape(shape);
+         *
+         *     // 偏移量为x轴一个单位
+         *     body.addShape(shape,[1,0]);
+         *
+         *     // 偏移量为y轴一个单位，同时逆时针旋转90度
+         *     body.addShape(shape,[0,1],Math.PI/2);
+         */
+        addShape(shape: Shape, offset?: number[], angle?: number): void;
+        /**
+         * 移除形状
+         * @method removeShape
+         * @param  {Shape}  shape
+         * @return {Boolean}
+         */
+        removeShape(shape: Shape): boolean;
+        /**
+         * 更新属性，结构或者质量改变时会被调用
+         *
+         * @method updateMassProperties
+         *
+         * @example
+         *     body.mass += 1;
+         *     body.updateMassProperties();
+         */
+        updateMassProperties(): void;
+        /**
+         * 相对于 world 中的一个点施加力
+         * @method applyForce
+         * @param {Array} force 力
+         * @param {Array} relativePoint 以物体中心点为基准的点
+         */
+        applyForce(force: number[], relativePoint: number[]): void;
+        /**
+         * Wake the body up. Normally you should not need this, as the body is automatically awoken at events such as collisions.
+         * Sets the sleepState to {{#crossLink "Body/AWAKE:property"}}Body.AWAKE{{/crossLink}} and emits the wakeUp event if the body wasn't awake before.
+         * @method wakeUp
+         */
+        wakeUp(): void;
+        /**
+         * Force body sleep
+         * @method sleep
+         */
+        sleep(): void;
+        /**
+         * Called every timestep to update internal sleep timer and change sleep state if needed.
+         * @method sleepTick
+         * @param {number} time The world time in seconds
+         * @param {boolean} dontSleep
+         * @param {number} dt
+         */
+        sleepTick(time: number, dontSleep: boolean, dt: number): void;
+        /**
+         * Check if the body is overlapping another body. Note that this method only works if the body was added to a World and if at least one step was taken.
+         * @method overlaps
+         * @param  {Body} body
+         * @return {boolean}
+         */
+        overlaps(body: Body): boolean;
+
+
+        /**
+         * Moves the shape offsets so their center of mass becomes the body center of mass.
+         * @method adjustCenterOfMass
+         */
+        adjustCenterOfMass(): void;
+
+        /**
+         * Apply damping.
+         * @method applyDamping
+         * @param  {number} dt Current time step
+         */
+        applyDamping(dt: number): void;
+
+        /**
+         * Reads a polygon shape path, and assembles convex shapes from that and puts them at proper offset points.
+         * @method fromPolygon
+         * @param {Array} path An array of 2d vectors, e.g. [[0,0],[0,1],...] that resembles a concave or convex polygon. The shape must be simple and without holes.
+         * @param {Object} [options]
+         * @param {Boolean} [options.optimalDecomp=false]   Set to true if you need optimal decomposition. Warning: very slow for polygons with more than 10 vertices.
+         * @param {Boolean} [options.skipSimpleCheck=false] Set to true if you already know that the path is not intersecting itself.
+         * @param {Boolean|Number} [options.removeCollinearPoints=false] Set to a number (angle threshold value) to remove collinear points, or false to keep all points.
+         * @return {Boolean} True on success, else false.
+         */
+        fromPolygon(path:number[][], options?: {
+            optimalDecomp?: boolean;
+            skipSimpleCheck?: boolean;
+            removeCollinearPoints?: boolean;  // Boolean | Number
+        }): boolean;
+
+        /**
+         * Sets the force on the body to zero.
+         * @method setZeroForce
+         */
+        setZeroForce(): void;
+
+        /**
+         * Transform a world point to local body frame.
+         * @method toLocalFrame
+         * @param  {Array} out          The vector to store the result in
+         * @param  {Array} worldPoint   The input world point
+         */
+        toLocalFrame(out: number[], worldPoint: number[]): void;
+
+        /**
+         * Transform a local point to world frame.
+         * @method toWorldFrame
+         * @param  {Array} out          The vector to store the result in
+         * @param  {Array} localPoint   The input local point
+         */
+        toWorldFrame(out: number[], localPoint: number[]): void;
+
+        /**
+         * Apply force to a body-local point.
+         * @method applyForceLocal
+         * @param  {Array} localForce The force vector to add, oriented in local body space.
+         * @param  {Array} localPoint A point relative to the body in world space. If not given, it is set to zero and all of the impulse will be excerted on the center of mass.
+         */
+        applyForceLocal(localForce: number[], localPoint: number[]): void;
+
+        /**
+         * Apply impulse to a point relative to the body. This could for example be a point on the Body surface. An impulse is a force added to a body during a short period of time (impulse = force * time). Impulses will be added to Body.velocity and Body.angularVelocity.
+         * @method applyImpulse
+         * @param  {Array} impulse The impulse vector to add, oriented in world space.
+         * @param  {Array} relativePoint A point relative to the body in world space. If not given, it is set to zero and all of the impulse will be excerted on the center of mass.
+         */
+        applyImpulse(impulse: number[], relativePoint: number[]): void;
+
+        /**
+         * Apply impulse to a point relative to the body. This could for example be a point on the Body surface. An impulse is a force added to a body during a short period of time (impulse = force * time). Impulses will be added to Body.velocity and Body.angularVelocity.
+         * @method applyImpulseLocal
+         * @param  {Array} impulse The impulse vector to add, oriented in world space.
+         * @param  {Array} relativePoint A point relative to the body in world space. If not given, it is set to zero and all of the impulse will be excerted on the center of mass.
+         */
+        applyImpulseLocal(impulse: number[], relativePoint: number[]): void;
+
+        /**
+         * Get velocity of a point in the body.
+         * @method getVelocityAtPoint
+         * @param  {Array} result A vector to store the result in
+         * @param  {Array} relativePoint A world oriented vector, indicating the position of the point to get the velocity from
+         * @return {Array}
+         */
+        getVelocityAtPoint(result: number[], relativePoint: number[]): number[];
+
+        /**
+         * Move the body forward in time given its current velocity.
+         * @method integrate
+         * @param  {number} dt
+         */
+        integrate(dt: number): void;
+
+        /**
+         * Transform a world point to local body frame.
+         * @method vectorToLocalFrame
+         * @param  {Array} out The vector to store the result in
+         * @param  {Array} worldVector The input world vector
+         */
+        vectorToLocalFrame(out: number[], worldVector: number[]): void;
+
+        /**
+         * Transform a local point to world frame.
+         * @method vectorToWorldFrame
+         * @param  {Array} out The vector to store the result in
+         * @param  {Array} localVector The input local vector
+         */
+        vectorToWorldFrame(out: number[], localVector: number[]): void;
+
+    }
+
+    /**
+     * Box shape class.
+     *
+     * @class Box
+     * @constructor
+     * @extends Convex
+     * @param {Object}              [options]        (Note that this options object will be passed on to the Shape constructor.)
+     * @param {Number}              [options.width=1]        Total width of the box
+     * @param {Number}              [options.height=1]        Total height of the box
+     */
+    export class Box extends Convex {
+
+        constructor(options?: Object);
+
+        width: number;
+        height: number;
+    }
+
+    export class Pool {
+
+        objects: any[];
+
+        get(): Object;
+        release(object: Object): Pool;
+        resize(size: number): Pool;
+
+    }
+
+
+    export class OverlapKeeperRecordPool extends Pool {
+
+    }
+
+    export class IslandPool extends Pool {
+
+    }
+
+    export class IslandNodePool extends Pool {
+
+    }
+
+    export class ContactEquationPool extends Pool {
+
+    }
+
+    export class FrictionEquationPool extends Pool {
+
+    }
+
+    export class Ray {
+
+        static ALL: number;
+        static ANY: number;
+        static CLOSEST: number;
+
+        constructor(options?: {
+            from?: number[];
+            to?: number[];
+            checkCollisionResponse?: boolean;
+            skipBackfaces?: boolean;
+            collisionMask?: number;
+            collisionGroup?: number;
+            mode?: number;
+            callback?: number;
+        });
+
+        callback: Function;
+        checkCollisionResponse: boolean;
+        collisionGroup: number;
+        collisionMask: number;
+        direction: number[];
+        from: number[];
+        length: number;
+        mode: number;
+        skipBackfaces: boolean;
+        to: number[];
+
+        getAABB(aabb: AABB): void;
+        intersectBodies(bodies: Body[]): void;
+        update(): void;
+
+    }
+
+    export class RaycastResult {
+
+        body: Body;
+        faceIndex: number;
+        fraction: number;
+        isStopped: boolean;
+        normal: number[];
+        shape: Shape;
+
+        getHitDistance(ray: Ray): void;
+        getHitPoint(out:number[], ray: Ray): void;
+        hasHit():boolean;
+        reset(): void;
+        stop(): void;
+
+    }
+
+    export class TopDownVehicle {
+
+        constructor(chassisBody: Body, options?: Object);
+
+        chassisBody: Body;
+        wheels: WheelConstraint[];
+
+        addToWorld(world: World): void;
+        addWheel(wheelOptions?: Object): WheelConstraint;
+        removeFromWorld(world: World): void;
+        update(): void;
+
+    }
+
+    export class WheelConstraint extends Constraint {
+
+        constructor(vehicle: TopDownVehicle, options?: {
+            localForwardVector?: number[];
+            localPosition?: number[];
+            sideFriction?: number;
+        });
+
+        engineForce: number;
+        localForwardVector: number[];
+        localPosition: number[];
+        steerValue: number;
+
+        getSpeed(): number;
+        update(): void;
+
+    }
+
+
+    export class Spring {
+
+        constructor(bodyA: Body, bodyB: Body, options?: {
+            stiffness?: number;
+            damping?: number;
+            localAnchorA?: number[];
+            localAnchorB?: number[];
+            worldAnchorA?: number[];
+            worldAnchorB?: number[];
+        });
+
+        bodyA: Body;
+        bodyB: Body;
+        damping: number;
+        stiffness: number;
+
+        applyForce(): void;
+
+    }
+
+    export class LinearSpring extends Spring {
+
+        constructor(bodyA: Body, bodyB: Body, options?: {
+            restLength?: number;
+            stiffness?: number;
+            damping?: number;
+            worldAnchorA?: number[];
+            worldAnchorB?: number[];
+            localAnchorA?: number[];
+            localAnchorB?: number[];
+
+        });
+
+        localAnchorA: number[];
+        localAnchorB: number[];
+        restLength: number;
+
+        setWorldAnchorA(worldAnchorA: number[]): void;
+        setWorldAnchorB(worldAnchorB: number[]): void;
+        getWorldAnchorA(result: number[]): void;
+        getWorldAnchorB(result: number[]): void;
+
+    }
+
+    export class RotationalSpring extends Spring {
+
+        constructor(bodyA: Body, bodyB: Body, options?: {
+            restAngle?: number;
+            stiffness?: number;
+            damping?: number;
+        });
+
+        restAngle: number;
+
+    }
+
+    /**
+     * Capsule shape class.
+     *
+     * @class Capsule
+     * @constructor
+     * @extends Shape
+     * @param {Object}              [options]        (Note that this options object will be passed on to the Shape constructor.)
+     * @param {Number}              [options.length=1]        The distance between the end points
+     * @param {Number}              [options.radius=1]        Radius of the capsule
+     */
+    export class Capsule extends Shape {
+
+        constructor(options?: Object);
+
+        length: number;
+        radius: number;
+
+        conputeMomentOfInertia(mass: number): number;
+
+    }
+
+    /**
+     * Circle shape class.
+     *
+     * @class Circle
+     * @constructor
+     * @extends Shape
+     * @param {Object}              [options]        (Note that this options object will be passed on to the Shape constructor.)
+     * @param {Number}              [options.radius=1]        The radius of this circle
+     * @example
+     *     var circleShape = new Circle({ radius: 1 });
+     *     body.addShape(circleShape);
+     */
+    export class Circle extends Shape {
+
+        constructor(options?: Object);
+
+        /**
+         * 半径
+         * @property radius
+         * @type {number}
+         */
+        radius: number;
+
+    }
+
+    /**
+     * Convex shape class.
+     *
+     * @class Convex
+     * @constructor
+     * @extends Shape
+     * @param {Object}              [options]        (Note that this options object will be passed on to the Shape constructor.)
+     * @param {Array}              [options.vertices]        An array of vertices that span this shape. Vertices are given in counter-clockwise (CCW) direction.
+     * @param {Array}              [options.axes]        An array of unit length vectors, representing the symmetry axes in the convex.
+     * @example
+     *     var vertices = [[-1,-1], [1,-1], [1,1], [-1,1]];
+     *     var convexShape = new Convex({ vertices: vertices });
+     *     body.addShape(convexShape);
+     */
+    export class Convex extends Shape {
+
+        static projectOntoAxis(offset: number[], localAxis: number[], result: number[]): void;
+        static triangleArea(a: number[], b: number[], c: number[]): number;
+
+        constructor(options?: Object);
+
+        vertices: number[][];
+        axes: number[];
+        centerOfMass: number[];
+        triangles: number[];
+
+        updateCenterOfMass(): void;
+        updateTriangles(): void;
+
+    }
+
+    export class Heightfield extends Shape {
+
+        constructor(options?: {
+            heights?: number[];
+            minValue?: number;
+            maxValue?: number;
+            elementWidth?: number;
+        });
+
+        heights: number[];
+        maxValue: number;
+        minValue: number;
+        elementWidth: number;
+
+        getLineSegment(start:number[], end:number[], i:number): void;
+        updateMaxMinValues(): void;
+
+    }
+
+    export class Shape {
+
+        static BOX: number;
+        static CAPSULE: number;
+        static CIRCLE: number;
+        static CONVEX: number;
+        static HEIGHTFIELD: number;
+        static LINE: number;
+        static PARTICLE: number;
+        static PLANE: number;
+
+        constructor(options?:  {
+            position?: number[];
+            angle?: number;
+            collisionGroup?: number;
+            collisionMask?: number;
+            sensor?: boolean;
+            collisionResponse?: boolean;
+            type?: number;
+        });
+
+        angle: number;
+        area: number;
+        body: Body;
+        boundingRadius: number;
+        collisionGroup: number;
+        collisionMask: number;
+        collisionResponse: boolean;
+        id: number;
+        material: Material;
+        position: number[];
+        sensor: boolean;
+        type: number;
+
+        computeAABB(out: AABB, position: number[], angle: number): void;
+        computeMomentOfInertia(mass: number): number;
+        raycast(result: RaycastResult, ray: Ray, position: number[], angle: number): void;
+        updateArea(): void;
+        updateBoundingRadius(): number;
+
+    }
+
+    export class Line extends Shape {
+
+        constructor(options?: {
+            length?: number;
+        });
+
+        length: number;
+
+    }
+
+    export class Particle extends Shape {
+
+    }
+
+    export class Plane extends Shape {
+
+    }
+
+    export class Solver extends EventEmitter {
+
+        constructor();
+
+        equations: Equation[];
+        equationSortFunction: Function; //Function | boolean
+
+        addEquation(eq: Equation): void;
+        addEquations(eqs: Equation[]): void;
+        removeAllEquations(): void;
+        removeEquation(eq: Equation): void;
+        solve(dt: number, world: World): void;
+        solveIsland(dt: number, island: Island): void;
+        sortEquations(): 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();
+
+        recordPool: OverlapKeeperRecordPool;
+
+        tick(): void;
+        setOverlapping(bodyA: Body, shapeA: Body, bodyB: Body, shapeB: Body): void;
+        bodiesAreOverlapping(bodyA: Body, bodyB: Body): boolean;
+
+    }
+
+    export class OverlapKeeperRecord {
+
+        constructor(bodyA: Body, shapeA: Shape, bodyB: Body, shapeB: Shape);
+
+        bodyA: Body;
+        bodyB: Body;
+        shapeA: Shape;
+        shapeB: Shape;
+
+        set(bodyA: Body, shapeA: Shape, bodyB: Body, shapeB: Shape): void;
+
+    }
+
+    export class TupleDictionary {
+
+        data: Object;
+        keys: number[];
+
+        copy(dict: TupleDictionary): void;
+        get(i: number, j: number): number;
+        getByKey(key: number): Object;
+        getKey(i: number, j: number): string;
+        reset(): void;
+        set(i: number, j: number, value: number): 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(): Body[];
+        wantsToSleep(): boolean;
+        sleep(): void;
+
+    }
+
+    export class IslandManager extends Solver {
+
+        static getUnvisitedNode(nodes: Node[]): IslandNode; // IslandNode | boolean
+
+        constructor(options?: Object);
+
+        islands: Island[];
+        nodes: IslandNode[];
+        islandPool: IslandPool;
+        nodePool: IslandNodePool;
+
+        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;
+
+    }
+
+    /**
+     * world，包含所有刚体
+     *
+     * @class World
+     * @constructor
+     * @param {Object}          [options]
+     * @param {Solver}          [options.solver]            默认值 GSSolver.
+     * @param {Array}           [options.gravity]           默认值 [0,-9.78]
+     * @param {Broadphase}      [options.broadphase]        默认值 NaiveBroadphase
+     * @param {Boolean}         [options.islandSplit=false]
+     * @param {Boolean}         [options.doProfiling=false]
+     * @extends EventEmitter
+     *
+     * @example
+     *     var world = new World({
+     *         gravity: [0, -9.81],
+     *         broadphase: new SAPBroadphase()
+     *     });
+     */
+    export class World extends EventEmitter {
+
+        /**
+         * step() 执行之后调用
+         * @event postStep
+         */
+        postStepEvent: {
+            type: string;
+        };
+
+        /**
+         * Body 加入时调用
+         * @event addBody
+         * @param {Body} body
+         */
+        addBodyEvent: {
+            type: string;
+            body: Body;
+        };
+
+        /**
+         * Body移除时调用
+         * @event removeBody
+         * @param {Body} body
+         */
+        removeBodyEvent: {
+            type: string;
+            body: Body;
+        };
+
+        /**
+         * Spring 加入时调用
+         * @event addSpring
+         * @param {Spring} spring
+         */
+        addSpringEvent: {
+            type: string;
+            spring: Spring;
+        };
+
+        /**
+         * 当两个刚体第一次碰撞时调用。调用时碰撞步骤已经完成
+         * @event impact
+         * @param {Body} bodyA
+         * @param {Body} bodyB
+         */
+        impactEvent: {
+            type: string;
+            bodyA: Body;
+            bodyB: Body;
+            shapeA: Shape;
+            shapeB: Shape;
+            contactEquation: ContactEquation;
+        };
+
+        /**
+         * 当 Broadphase 手机对碰之后被调用
+         * @event postBroadphase
+         * @param {Array} 对碰数组
+         */
+        postBroadphaseEvent: {
+            type: string;
+            pairs: Body[];
+        };
+
+        /**
+         * 当两个形状重叠时调用
+         * @event beginContact
+         * @param {Shape} shapeA
+         * @param {Shape} shapeB
+         * @param {Body}  bodyA
+         * @param {Body}  bodyB
+         * @param {Array} contactEquations
+         */
+        beginContactEvent: {
+            type: string;
+            shapeA: Shape;
+            shapeB: Shape;
+            bodyA: Body;
+            bodyB: Body;
+            contactEquations: ContactEquation[];
+        };
+
+        /**
+         * 当两个形状停止重叠时调用
+         * @event endContact
+         * @param {Shape} shapeA
+         * @param {Shape} shapeB
+         * @param {Body}  bodyA
+         * @param {Body}  bodyB
+         */
+        endContactEvent: {
+            type: string;
+            shapeA: Shape;
+            shapeB: Shape;
+            bodyA: Body;
+            bodyB: Body;
+        };
+
+        /**
+         * Fired just before equations are added to the solver to be solved. Can be used to control what equations goes into the solver.
+         * @event preSolve
+         * @param {Array} contactEquations  An array of contacts to be solved.
+         * @param {Array} frictionEquations An array of friction equations to be solved.
+         */
+        preSolveEvent: {
+            type: string;
+            contactEquations: ContactEquation[];
+            frictionEquations: FrictionEquation[];
+        };
+
+        /**
+         * 从不让刚体睡眠
+         * @static
+         * @property {number} NO_SLEEPING
+         */
+        static NO_SLEEPING: number;
+        /**
+         * 刚体睡眠
+         * @static
+         * @property {number} BODY_SLEEPING
+         */
+        static BODY_SLEEPING: number;
+        /**
+         * 取消激活在接触中的刚体，如果所有刚体都接近睡眠。必须设置 World.islandSplit
+         * @static
+         * @property {number} ISLAND_SLEEPING
+         */
+        static ISLAND_SLEEPING: number;
+
+        constructor(options?: {
+            solver?: Solver;
+            gravity?: number[];
+            broadphase?: Broadphase;
+            islandSplit?: boolean;
+        });
+
+        /**
+         * For keeping track of what time step size we used last step
+         * @property lastTimeStep
+         * @type {number}
+         */
+        lastTimeStep: number;
+        overlapKeeper: OverlapKeeper;
+        /**
+         * If the length of .gravity is zero, and .useWorldGravityAsFrictionGravity=true, then switch to using .frictionGravity for friction instead. This fallback is useful for gravityless games.
+         * @property {boolean} useFrictionGravityOnZeroGravity
+         * @default true
+         */
+        useFrictionGravityOnZeroGravity: boolean;
+
+
+        /**
+         * 所有 Spring
+         * @property springs
+         * @type {Array}
+         */
+        springs: Spring[];
+        /**
+         * 所有 Body
+         * @property {Array} bodies
+         */
+        bodies: Body[];
+        /**
+         * 所使用的求解器，以满足约束条件和接触。 默认值是 GSSolver
+         * @property {Solver} solver
+         */
+        solver: Solver;
+        /**
+         * @property narrowphase
+         * @type {Narrowphase}
+         */
+        narrowphase: Narrowphase;
+        /**
+         * The island manager of this world.
+         * @property {IslandManager} islandManager
+         */
+        islandManager: IslandManager;
+        /**
+         * 重力。在每个 step() 开始对所有刚体生效
+         *
+         * @property gravity
+         * @type {Array}
+         */
+        gravity: number[];
+        /**
+         * 重力摩擦
+         * @property {Number} frictionGravity
+         */
+        frictionGravity: number;
+        /**
+         * 设置为true，frictionGravity 会被自动设置为 gravity 长度.
+         * @property {Boolean} useWorldGravityAsFrictionGravity
+         */
+        useWorldGravityAsFrictionGravity: boolean;
+        /**
+         * @property broadphase
+         * @type {Broadphase}
+         */
+        broadphase: Broadphase;
+        /**
+         * 用户添加限制
+         *
+         * @property constraints
+         * @type {Array}
+         */
+        constraints: Constraint[];
+        /**
+         * 默认材料，defaultContactMaterial 时使用
+         * @property {Material} defaultMaterial
+         */
+        defaultMaterial: Material;
+        /**
+         * 使用的默认接触材料，如果没有接触材料被设置为碰撞的材料
+         * @property {ContactMaterial} defaultContactMaterial
+         */
+        defaultContactMaterial: ContactMaterial;
+        /**
+         * 设置自动使用弹簧力
+         * @property applySpringForces
+         * @type {Boolean}
+         */
+        applySpringForces: boolean;
+        /**
+         * 设置自动使用阻尼
+         * @property applyDamping
+         * @type {Boolean}
+         */
+        applyDamping: boolean;
+        /**
+         * 设置自动使用重力
+         * @property applyGravity
+         * @type {Boolean}
+         */
+        applyGravity: boolean;
+        /**
+         * 使用约束求解
+         * @property solveConstraints
+         * @type {Boolean}
+         */
+        solveConstraints: boolean;
+        /**
+         * 接触材料
+         * @property contactMaterials
+         * @type {Array}
+         */
+        contactMaterials: ContactMaterial[];
+        /**
+         * 世界时间
+         * @property time
+         * @type {Number}
+         */
+        time: number;
+        /**
+         * 是否正在 step 阶段
+         * @property {Boolean} stepping
+         */
+        stepping: boolean;
+        /**
+         * 是否启用岛内分裂
+         * @property {Boolean} islandSplit
+         */
+        islandSplit: boolean;
+        /**
+         * 设置为true，world会派发 impact 事件，关闭可以提高性能
+         * @property emitImpactEvent
+         * @type {Boolean}
+         */
+        emitImpactEvent: boolean;
+        /**
+         * 刚体睡眠策略。取值是 World.NO_SLEEPING，World.BODY_SLEEPING，World.ISLAND_SLEEPING 之一
+         * @property sleepMode
+         * @type {number}
+         * @default World.NO_SLEEPING
+         */
+        sleepMode: number;
+
+        /**
+         * 添加约束
+         * @method addConstraint
+         * @param {Constraint} constraint
+         */
+        addConstraint(constraint: Constraint): void;
+        /**
+         * 添加触点材料
+         * @method addContactMaterial
+         * @param {ContactMaterial} contactMaterial
+         */
+        addContactMaterial(contactMaterial: ContactMaterial): void;
+        /**
+         * 移除触点材料
+         * @method removeContactMaterial
+         * @param {ContactMaterial} cm
+         */
+        removeContactMaterial(cm: ContactMaterial): void;
+        /**
+         * 通过2个材料获得触点材料
+         * @method getContactMaterial
+         * @param {Material} materialA
+         * @param {Material} materialB
+         * @return {ContactMaterial} 获得的触点材料或者false
+         */
+        getContactMaterial(materialA: Material, materialB: Material): ContactMaterial;
+        /**
+         * 移除约束
+         * @method removeConstraint
+         * @param {Constraint} constraint
+         */
+        removeConstraint(constraint: Constraint): void;
+        /**
+         * 使物理系统向前经过一定时间
+         *
+         * @method step
+         * @param {Number} dt                       时长
+         * @param {Number} [timeSinceLastCalled=0]
+         * @param {Number} [maxSubSteps=10]
+         *
+         * @example
+         *     var world = new World();
+         *     world.step(0.01);
+         */
+        step(dt: number, timeSinceLastCalled?: number, maxSubSteps?: number): void;
+        /**
+         * 添加一个 Spring
+         *
+         * @method addSpring
+         * @param {Spring} spring
+         */
+        addSpring(spring: Spring): void;
+        /**
+         * 移除一个 Spring
+         *
+         * @method removeSpring
+         * @param {Spring} spring
+         */
+        removeSpring(spring: Spring): void;
+        /**
+         * 添加一个 Body
+         *
+         * @method addBody
+         * @param {Body} body
+         *
+         * @example
+         *     var world = new World(),
+         *         body = new Body();
+         *     world.addBody(body);
+         */
+        addBody(body: Body): void;
+        /**
+         * 移除一个 Body。如果在 step()阶段调用，将会在阶段之后移除
+         *
+         * @method removeBody
+         * @param {Body} body
+         */
+        removeBody(body: Body): void;
+        /**
+         * 通过id获取一个 Body
+         * @method getBodyById
+         * @return {Body|Boolean} 得到的刚体或者false
+         */
+        getBodyByID(id: number): Body;
+        /**
+         * 两个刚体之间禁用碰撞
+         * @method disableBodyCollision
+         * @param {Body} bodyA
+         * @param {Body} bodyB
+         */
+        disableBodyCollision(bodyA: Body, bodyB: Body): void;
+        /**
+         * 两个刚体之间启用碰撞
+         * @method enableBodyCollision
+         * @param {Body} bodyA
+         * @param {Body} bodyB
+         */
+        enableBodyCollision(bodyA: Body, bodyB: Body): void;
+        /**
+         * 重置 world
+         * @method clear
+         */
+        clear(): void;
+
+        /**
+         * Test if a world point overlaps bodies
+         * @method hitTest
+         * @param  {Array}  worldPoint  Point to use for intersection tests
+         * @param  {Array}  bodies      A list of objects to check for intersection
+         * @param  {number} precision   Used for matching against particles and lines. Adds some margin to these infinitesimal objects.
+         * @return {Array}              Array of bodies that overlap the point
+         */
+        hitTest(worldPoint: number[], bodies: Body[], precision: number): Body[];
+
+        /**
+         * Ray cast against all bodies in the world.
+         * @method raycast
+         * @param  {RaycastResult} result
+         * @param  {Ray} ray
+         * @return {boolean} True if any body was hit.
+         */
+        raycast(result: RaycastResult, ray: Ray): boolean;
+
+        /**
+         * Runs narrowphase for the shape pair i and j.
+         * @method runNarrowphase
+         * @param  {Narrowphase} np
+         * @param  {Body} bi
+         * @param  {Shape} si
+         * @param  {Array} xi
+         * @param  {number} ai
+         * @param  {Body} bj
+         * @param  {Shape} sj
+         * @param  {Array} xj
+         * @param  {number} aj
+         * @param  {number} mu
+         */
+        runNarrowphase(np:Narrowphase, bi:Body, si:Shape, xi:number[], ai:number, bj:Body, sj:Shape, xj:number[], aj:number, mu:number): void;
+
+        /**
+         * Set the relaxation for all equations and contact materials.
+         * @method setGlobalRelaxation
+         * @param {number} relaxation
+         */
+        setGlobalRelaxation(relaxation: number): void;
+
+        /**
+         * Set the stiffness for all equations and contact materials.
+         * @method setGlobalStiffness
+         * @param {Number} stiffness
+         */
+        setGlobalStiffness(stiffness: number): void;
+
+    }
+
+}
\ No newline at end of file

resource/TextureMerger/alert_3.tmproject

-{"options":{"layoutMath":"2","sizeMode":"2n","useExtension":1,"layoutGap":1,"extend":0},"projectName":"alert_3","version":5,"files":["../assets/alert/Bitmap-4.png","../assets/alert/Bitmap-2.png","../assets/alert/Bitmap-1.png"]}
\ No newline at end of file

resource/TextureMerger/loading_2.tmproject

-{"options":{"layoutMath":"2","sizeMode":"2n","useExtension":1,"layoutGap":1,"extend":0},"projectName":"loading_2","version":5,"files":["../assets/loading/bg.png","../assets/loading/progress.png"]}
\ No newline at end of file

resource/TextureMerger/msg_0.tmproject

-{"options":{"layoutMath":"2","sizeMode":"2n","useExtension":1,"layoutGap":1,"extend":0},"projectName":"msg_0","version":5,"files":["../assets/msg/msgBg.png","../assets/msg/x.png","../assets/msg/sureBtn.png"]}
\ No newline at end of file

resource/TextureMerger/playScene_1.tmproject

-{"options":{"layoutMath":"2","sizeMode":"2n","useExtension":1,"layoutGap":1,"extend":0},"projectName":"playScene_1","version":5,"files":["../assets/playScene/wheelBg2.png","../assets/playScene/wating.png","../assets/playScene/startBtnBg.png","../assets/playScene/sideLightL.png","../assets/playScene/sideLightD.png","../assets/playScene/ruleBtn.png","../assets/playScene/redPacket.png","../assets/playScene/outShell.png","../assets/playScene/myCreditsBg.png","../assets/playScene/multiple3.png","../assets/playScene/multiple.png","../assets/playScene/heartB.png","../assets/playScene/go.png","../assets/playScene/gift.png","../assets/playScene/finger.png","../assets/playScene/earnPanel.png","../assets/playScene/coinIcon.png","../assets/playScene/coinf8.png","../assets/playScene/coinf7.png","../assets/playScene/coinf6.png","../assets/playScene/coinf5.png","../assets/playScene/coinf4.png","../assets/playScene/coinf3.png","../assets/playScene/coinf2.png","../assets/playScene/coinf1.png","../assets/playScene/circleLight2.png","../assets/playScene/circleLight1.png","../assets/playScene/+.png","../assets/playScene/-_.png"]}
\ No newline at end of file

resource/TextureMerger/rule_4.tmproject → resource/TextureMerger/preload_0.tmproject

-{"options":{"layoutMath":"2","sizeMode":"2n","useExtension":1,"layoutGap":1,"extend":0},"projectName":"rule_4","version":5,"files":["../assets/rule/ruleBg.png","../assets/rule/X.png"]}
+{"options":{"layoutMath":"2","sizeMode":"2n","useExtension":1,"layoutGap":1,"extend":0},"projectName":"preload_0","version":5,"files":["../assets/circle.png","../assets/rect.png"]}
\ No newline at end of file

resource/assets/playScene/coin.json

-{"mc":{
-	"coin":{
-		"frameRate":24,
-		"labels":[
-			{"name":"rotate","frame":1,"end":8}
-			
-			],
-		"events":[
-			
-			],
-		"frames":[
-			
-			{
-			"res":"DB0A020",
-			"x":0,
-			"y":0
-			},
-			{
-			"res":"11118EED",
-			"x":0,
-			"y":0
-			},
-			{
-			"res":"3ED3A22C",
-			"x":8,
-			"y":0
-			},
-			{
-			"res":"EA81E94D",
-			"x":20,
-			"y":0
-			},
-			{
-			"res":"9D677726",
-			"x":37,
-			"y":0
-			},
-			{
-			"res":"7A80B82A",
-			"x":20,
-			"y":0
-			},
-			{
-			"res":"AA7CF946",
-			"x":8,
-			"y":0
-			},
-			{
-			"res":"2E51F51A",
-			"x":0,
-			"y":0
-			}
-			]
-}},
-	"res":{
-		"AA7CF946":{"x":176,"y":97,"w":78,"h":94},
-		"11118EED":{"x":1,"y":1,"w":93,"h":94},
-		"EA81E94D":{"x":191,"y":1,"w":53,"h":94},
-		"2E51F51A":{"x":96,"y":1,"w":93,"h":94},
-		"7A80B82A":{"x":1,"y":193,"w":53,"h":94},
-		"3ED3A22C":{"x":96,"y":97,"w":78,"h":94},
-		"9D677726":{"x":56,"y":193,"w":20,"h":94},
-		"DB0A020":{"x":1,"y":97,"w":93,"h":94}
-	}}
\ No newline at end of file

resource/assets/playScene/goBtn.json

-{"mc":{
-	"go":{
-		"frameRate":20,
-		"labels":[
-			{"name":"light","frame":1,"end":30}
-			
-			],
-		"events":[
-			
-			],
-		"frames":[
-			
-			{
-			"res":"A9D1D9F7",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"A9D1D9F7",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"165B8393",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"165B8393",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"C533ADB8",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"C533ADB8",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"7C56153B",
-			"x":6,
-			"y":5
-			},
-			{
-			"res":"C3226410",
-			"x":6,
-			"y":5
-			},
-			{
-			"res":"C3226410",
-			"x":6,
-			"y":5
-			},
-			{
-			"res":"8A450EA9",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"764FAFD2",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"A86D3DEA",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"F8A55074",
-			"x":8,
-			"y":4
-			},
-			{
-			"res":"6DDF7B77",
-			"x":8,
-			"y":4
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"AF8A3362",
-			"x":8,
-			"y":5
-			},
-			{
-			"res":"10E93F01",
-			"x":8,
-			"y":5
-			}
-			]
-}},
-	"res":{
-		"10E93F01":{"x":709,"y":1,"w":174,"h":176},
-		"C3226410":{"x":1,"y":1,"w":176,"h":176},
-		"764FAFD2":{"x":1,"y":179,"w":174,"h":176},
-		"C533ADB8":{"x":1,"y":357,"w":174,"h":176},
-		"6DDF7B77":{"x":533,"y":1,"w":174,"h":177},
-		"F8A55074":{"x":357,"y":1,"w":174,"h":177},
-		"A86D3DEA":{"x":177,"y":179,"w":174,"h":176},
-		"165B8393":{"x":709,"y":179,"w":174,"h":176},
-		"A9D1D9F7":{"x":353,"y":180,"w":174,"h":176},
-		"AF8A3362":{"x":529,"y":180,"w":174,"h":176},
-		"7C56153B":{"x":179,"y":1,"w":176,"h":176},
-		"8A450EA9":{"x":177,"y":357,"w":174,"h":176}
-	}}
\ No newline at end of file

resource/default.res.json

 {
 	"groups": [
 		{
-			"keys": "msgBg_png,x_png,sureBtn_png",
-			"name": "msg"
-		},
-		{
-			"keys": "wheelBg2_png,wating_png,startBtnBg_png,sideLightL_png,sideLightD_png,ruleBtn_png,redPacket_png,outShell_png,myCreditsBg_png,multiple3_png,multiple_png,heartB_png,goBtn_png,goBtn_json,go_png,gift_png,finger_png,earnPanel_png,coinIcon_png,coinf8_png,coinf7_png,coinf6_png,coinf5_png,coinf4_png,coinf3_png,coinf2_png,coinf1_png,coin_png,coin_json,circleLight2_png,circleLight1_png,+_png,-__png,playSceneBg_jpg",
-			"name": "playScene"
-		},
-		{
-			"keys": "bg_png,progress_png",
-			"name": "loading"
-		},
-		{
-			"keys": "Bitmap-4_png,Bitmap-2_png,Bitmap-1_png",
-			"name": "alert"
-		},
-		{
-			"keys": "ruleBg_png,X_png",
-			"name": "rule"
-		},
-		{
-			"keys": "playSceneBg_jpg",
+			"keys": "bg_jpg,circle_png,jj_jpg,rect_png",
 			"name": "preload"
 		}
 	],
 	"resources": [
 		{
-			"url": "assets/alert/Bitmap-1.png",
-			"type": "image",
-			"name": "Bitmap-1_png"
-		},
-		{
-			"url": "assets/alert/Bitmap-2.png",
-			"type": "image",
-			"name": "Bitmap-2_png"
-		},
-		{
-			"url": "assets/alert/Bitmap-4.png",
-			"type": "image",
-			"name": "Bitmap-4_png"
-		},
-		{
-			"url": "assets/msg/msgBg.png",
-			"type": "image",
-			"name": "msgBg_png"
-		},
-		{
-			"url": "assets/msg/sureBtn.png",
-			"type": "image",
-			"name": "sureBtn_png"
-		},
-		{
-			"url": "assets/msg/x.png",
-			"type": "image",
-			"name": "x_png"
-		},
-		{
-			"url": "assets/playScene/+.png",
-			"type": "image",
-			"name": "+_png"
-		},
-		{
-			"url": "assets/playScene/-_.png",
-			"type": "image",
-			"name": "-__png"
-		},
-		{
-			"url": "assets/playScene/circleLight1.png",
-			"type": "image",
-			"name": "circleLight1_png"
-		},
-		{
-			"url": "assets/playScene/circleLight2.png",
-			"type": "image",
-			"name": "circleLight2_png"
-		},
-		{
-			"url": "assets/playScene/coin.png",
-			"type": "image",
-			"name": "coin_png"
-		},
-		{
-			"url": "assets/playScene/coinIcon.png",
-			"type": "image",
-			"name": "coinIcon_png"
-		},
-		{
-			"url": "assets/playScene/coinf1.png",
-			"type": "image",
-			"name": "coinf1_png"
-		},
-		{
-			"url": "assets/playScene/coinf2.png",
-			"type": "image",
-			"name": "coinf2_png"
-		},
-		{
-			"url": "assets/playScene/coinf3.png",
-			"type": "image",
-			"name": "coinf3_png"
-		},
-		{
-			"url": "assets/playScene/coinf4.png",
-			"type": "image",
-			"name": "coinf4_png"
-		},
-		{
-			"url": "assets/playScene/coinf5.png",
-			"type": "image",
-			"name": "coinf5_png"
-		},
-		{
-			"url": "assets/playScene/coinf6.png",
-			"type": "image",
-			"name": "coinf6_png"
-		},
-		{
-			"url": "assets/playScene/coinf7.png",
+			"url": "assets/bg.jpg",
 			"type": "image",
-			"name": "coinf7_png"
+			"name": "bg_jpg"
 		},
 		{
-			"url": "assets/playScene/coinf8.png",
+			"name": "circle_png",
 			"type": "image",
-			"name": "coinf8_png"
+			"url": "assets/circle.png"
 		},
 		{
-			"url": "assets/playScene/earnPanel.png",
+			"name": "jj_jpg",
 			"type": "image",
-			"name": "earnPanel_png"
-		},
-		{
-			"url": "assets/playScene/finger.png",
-			"type": "image",
-			"name": "finger_png"
-		},
-		{
-			"url": "assets/playScene/gift.png",
-			"type": "image",
-			"name": "gift_png"
-		},
-		{
-			"url": "assets/playScene/go.png",
-			"type": "image",
-			"name": "go_png"
-		},
-		{
-			"url": "assets/playScene/goBtn.png",
-			"type": "image",
-			"name": "goBtn_png"
-		},
-		{
-			"url": "assets/playScene/heartB.png",
-			"type": "image",
-			"name": "heartB_png"
-		},
-		{
-			"url": "assets/playScene/multiple.png",
-			"type": "image",
-			"name": "multiple_png"
-		},
-		{
-			"url": "assets/playScene/multiple3.png",
-			"type": "image",
-			"name": "multiple3_png"
-		},
-		{
-			"url": "assets/playScene/myCreditsBg.png",
-			"type": "image",
-			"name": "myCreditsBg_png"
-		},
-		{
-			"url": "assets/playScene/outShell.png",
-			"type": "image",
-			"name": "outShell_png"
-		},
-		{
-			"url": "assets/playScene/redPacket.png",
-			"type": "image",
-			"name": "redPacket_png"
-		},
-		{
-			"url": "assets/playScene/ruleBtn.png",
-			"type": "image",
-			"name": "ruleBtn_png"
-		},
-		{
-			"url": "assets/playScene/sideLightD.png",
-			"type": "image",
-			"name": "sideLightD_png"
-		},
-		{
-			"url": "assets/playScene/sideLightL.png",
-			"type": "image",
-			"name": "sideLightL_png"
-		},
-		{
-			"url": "assets/playScene/startBtnBg.png",
-			"type": "image",
-			"name": "startBtnBg_png"
-		},
-		{
-			"url": "assets/playScene/wating.png",
-			"type": "image",
-			"name": "wating_png"
-		},
-		{
-			"url": "assets/playScene/wheelBg2.png",
-			"type": "image",
-			"name": "wheelBg2_png"
-		},
-		{
-			"url": "assets/loading/bg.png",
-			"type": "image",
-			"name": "bg_png"
-		},
-		{
-			"url": "assets/loading/progress.png",
-			"type": "image",
-			"name": "progress_png"
-		},
-		{
-			"url": "assets/rule/X.png",
-			"type": "image",
-			"name": "X_png"
-		},
-		{
-			"url": "assets/rule/ruleBg.png",
-			"type": "image",
-			"name": "ruleBg_png"
-		},
-		{
-			"url": "assets/playScene/coin.json",
-			"type": "json",
-			"name": "coin_json"
-		},
-		{
-			"url": "assets/playScene/goBtn.json",
-			"type": "json",
-			"name": "goBtn_json"
+			"url": "assets/jj.jpg"
 		},
 		{
-			"url": "assets/playScene/playSceneBg.jpg",
+			"name": "rect_png",
 			"type": "image",
-			"name": "playSceneBg_jpg"
+			"url": "assets/rect.png"
 		}
 	]
 }
\ No newline at end of file

resource/default.thm.json

 {
-	"skins": {},
+	"skins": {
+		"eui.Button": "resource/eui_skins/ButtonSkin.exml",
+		"eui.CheckBox": "resource/eui_skins/CheckBoxSkin.exml",
+		"eui.HScrollBar": "resource/eui_skins/HScrollBarSkin.exml",
+		"eui.HSlider": "resource/eui_skins/HSliderSkin.exml",
+		"eui.Panel": "resource/eui_skins/PanelSkin.exml",
+		"eui.TextInput": "resource/eui_skins/TextInputSkin.exml",
+		"eui.ProgressBar": "resource/eui_skins/ProgressBarSkin.exml",
+		"eui.RadioButton": "resource/eui_skins/RadioButtonSkin.exml",
+		"eui.Scroller": "resource/eui_skins/ScrollerSkin.exml",
+		"eui.ToggleSwitch": "resource/eui_skins/ToggleSwitchSkin.exml",
+		"eui.VScrollBar": "resource/eui_skins/VScrollBarSkin.exml",
+		"eui.VSlider": "resource/eui_skins/VSliderSkin.exml",
+		"eui.ItemRenderer": "resource/eui_skins/ItemRendererSkin.exml"
+	},
 	"autoGenerateExmlsList": true,
 	"exmls": [
-		"resource/skins/AlertSkin.exml",
-		"resource/skins/LoadingSkin.exml",
-		"resource/skins/MsgSkin.exml",
-		"resource/skins/PlaySkin.exml",
-		"resource/skins/RuleSkin.exml",
-		"resource/skins/component/ResultPanel.exml",
-		"resource/skins/component/WheelBg.exml",
-		"resource/skins/component/WheelGift.exml",
-		"resource/skins/ui/IconButtonSkin.exml",
-		"resource/skins/ui/ProgressBarSkin.exml",
-		"resource/skins/ui/StartButtonSkin.exml"
+		"resource/eui_skins/ButtonSkin.exml",
+		"resource/eui_skins/CheckBoxSkin.exml",
+		"resource/eui_skins/HScrollBarSkin.exml",
+		"resource/eui_skins/HSliderSkin.exml",
+		"resource/eui_skins/ItemRendererSkin.exml",
+		"resource/eui_skins/PanelSkin.exml",
+		"resource/eui_skins/ProgressBarSkin.exml",
+		"resource/eui_skins/RadioButtonSkin.exml",
+		"resource/eui_skins/ScrollerSkin.exml",
+		"resource/eui_skins/TextInputSkin.exml",
+		"resource/eui_skins/ToggleSwitchSkin.exml",
+		"resource/eui_skins/VScrollBarSkin.exml",
+		"resource/eui_skins/VSliderSkin.exml"
 	],
 	"path": "resource/default.thm.json"
 }
\ No newline at end of file

resource/eui_skins/ButtonSkin.exml

+<?xml version="1.0" encoding="utf-8" ?>
+<e:Skin class="skins.ButtonSkin" states="up,down,disabled" minHeight="50" minWidth="100" xmlns:e="http://ns.egret.com/eui">
+    <e:Image width="100%" height="100%" scale9Grid="1,3,8,8" alpha.disabled="0.5"
+             source="button_up_png"
+             source.down="button_down_png"/>
+    <e:Label id="labelDisplay" top="8" bottom="8" left="8" right="8"
+             size="20"
+             textColor="0xFFFFFF" verticalAlign="middle" textAlign="center"/>
+    <e:Image id="iconDisplay" horizontalCenter="0" verticalCenter="0"/>
+</e:Skin>

resource/eui_skins/CheckBoxSkin.exml

+<?xml version="1.0" encoding="utf-8"?>
+<e:Skin class="skins.CheckBoxSkin" states="up,down,disabled,upAndSelected,downAndSelected,disabledAndSelected" xmlns:e="http://ns.egret.com/eui">
+    <e:Group width="100%" height="100%">
+        <e:layout>
+            <e:HorizontalLayout verticalAlign="middle"/>
+        </e:layout>
+        <e:Image fillMode="scale" alpha="1" alpha.disabled="0.5" alpha.down="0.7"
+                 source="checkbox_unselect_png"
+                 source.upAndSelected="checkbox_select_up_png"
+                 source.downAndSelected="checkbox_select_down_png"
+                 source.disabledAndSelected="checkbox_select_disabled_png"/>
+        <e:Label id="labelDisplay" size="20" textColor="0x707070"
+                 textAlign="center" verticalAlign="middle"
+                 fontFamily="Tahoma"/>
+    </e:Group>
+</e:Skin>

resource/eui_skins/HScrollBarSkin.exml

+<?xml version="1.0" encoding="utf-8"?>
+<e:Skin class="skins.HScrollBarSkin" minWidth="20" minHeight="8" xmlns:e="http://ns.egret.com/eui">
+    <e:Image id="thumb" source="roundthumb_png" scale9Grid="3,3,2,2" height="8" width="30" verticalCenter="0"/>
+</e:Skin>

resource/eui_skins/HSliderSkin.exml

+<?xml version="1.0" encoding="utf-8"?>
+<e:Skin class="skins.HSliderSkin" minWidth="20" minHeight="8" xmlns:e="http://ns.egret.com/eui">
+    <e:Image id="track" source="track_sb_png" scale9Grid="1,1,4,4" width="100%"
+             height="6" verticalCenter="0"/>
+    <e:Image id="thumb" source="thumb_png" verticalCenter="0"/>
+</e:Skin>

resource/eui_skins/ItemRendererSkin.exml

+<?xml version="1.0" encoding="utf-8" ?>
+<e:Skin class="skins.ItemRendererSkin" states="up,down,disabled" minHeight="50" minWidth="100" xmlns:e="http://ns.egret.com/eui">
+    <e:Image width="100%" height="100%" scale9Grid="1,3,8,8" alpha.disabled="0.5"
+             source="button_up_png"
+             source.down="button_down_png"/>
+    <e:Label id="labelDisplay" top="8" bottom="8" left="8" right="8"
+             size="20" fontFamily="Tahoma"
+             textColor="0xFFFFFF" text="{data}" verticalAlign="middle" textAlign="center"/>
+</e:Skin>

resource/eui_skins/PanelSkin.exml

+<?xml version="1.0" encoding="utf-8"?>
+<e:Skin class="skins.PanelSkin" minHeight="230" minWidth="450" xmlns:e="http://ns.egret.com/eui">
+    <e:Image left="0" right="0" bottom="0"  top="0" source="border_png" scale9Grid="2,2,12,12" />
+    <e:Group id="moveArea" left="0" right="0" top="0" height="45">
+        <e:Image left="0" right="0" bottom="0"  top="0" source="header_png"/>
+        <e:Label id="titleDisplay" size="20" fontFamily="Tahoma" textColor="0xFFFFFF"
+                 wordWrap="false" left="15" right="5" verticalCenter="0"/>
+    </e:Group>
+    <e:Button id="closeButton" label="close" bottom="5" horizontalCenter="0"/>
+</e:Skin>

resource/eui_skins/ProgressBarSkin.exml

+<?xml version="1.0" encoding="utf-8"?>
+<e:Skin class="skins.ProgressBarSkin" minWidth="30" minHeight="18" xmlns:e="http://ns.egret.com/eui">
+	<e:Image source="track_pb_png" scale9Grid="1,1,4,4" width="100%"
+			 height="100%" verticalCenter="0"/>
+	<e:Image id="thumb" height="100%" width="100%" source="thumb_pb_png"/>
+	<e:Label id="labelDisplay" textAlign="center" verticalAlign="middle"
+			 size="15" fontFamily="Tahoma" textColor="0x707070"
+			 horizontalCenter="0" verticalCenter="0"/>
+</e:Skin>

resource/eui_skins/RadioButtonSkin.exml

+<?xml version="1.0" encoding="utf-8"?>
+<e:Skin class="skins.RadioButtonSkin" states="up,down,disabled,upAndSelected,downAndSelected,disabledAndSelected" xmlns:e="http://ns.egret.com/eui">
+    <e:Group width="100%" height="100%">
+        <e:layout>
+            <e:HorizontalLayout verticalAlign="middle"/>
+        </e:layout>
+        <e:Image fillMode="scale" alpha="1" alpha.disabled="0.5" alpha.down="0.7"
+                 source="radiobutton_unselect_png"
+                 source.upAndSelected="radiobutton_select_up_png"
+                 source.downAndSelected="radiobutton_select_down_png"
+                 source.disabledAndSelected="radiobutton_select_disabled_png"/>
+        <e:Label id="labelDisplay" size="20" textColor="0x707070"
+                 textAlign="center" verticalAlign="middle"
+                 fontFamily="Tahoma"/>
+    </e:Group>
+</e:Skin>

resource/eui_skins/ScrollerSkin.exml

+<?xml version="1.0" encoding="utf-8"?>
+<e:Skin class="skins.ScrollerSkin" minWidth="20" minHeight="20" xmlns:e="http://ns.egret.com/eui">
+    <e:HScrollBar id="horizontalScrollBar" width="100%" bottom="0"/>
+    <e:VScrollBar id="verticalScrollBar" height="100%" right="0"/>
+</e:Skin>
\ No newline at end of file

resource/eui_skins/TextInputSkin.exml

+<?xml version='1.0' encoding='utf-8'?>
+<e:Skin class="skins.TextInputSkin" minHeight="40" minWidth="300" states="normal,disabled,normalWithPrompt,disabledWithPrompt" xmlns:e="http://ns.egret.com/eui">
+	<e:Image width="100%" height="100%" scale9Grid="1,3,8,8" source="button_up_png"/>
+	<e:Rect height="100%" width="100%" fillColor="0xffffff"/>
+ 	<e:EditableText id="textDisplay" verticalCenter="0" left="10" right="10"
+	                textColor="0x000000" textColor.disabled="0xff0000" width="100%" height="24" size="20" />
+	<e:Label id="promptDisplay" verticalCenter="0" left="10" right="10"
+	                textColor="0xa9a9a9" width="100%" height="24" size="20" touchEnabled="false" includeIn="normalWithPrompt,disabledWithPrompt"/>
+</e:Skin>
\ No newline at end of file

resource/eui_skins/ToggleSwitchSkin.exml

+<?xml version="1.0" encoding="utf-8"?>
+<e:Skin class="skins.ToggleSwitchSkin" states="up,down,disabled,upAndSelected,downAndSelected,disabledAndSelected" xmlns:e="http://ns.egret.com/eui">
+    <e:Image source="on_png"
+             source.up="off_png"
+             source.down="off_png"
+             source.disabled="off_png"/>
+    <e:Image source="handle_png"
+             horizontalCenter="-18"
+             horizontalCenter.upAndSelected="18"
+             horizontalCenter.downAndSelected="18"
+             horizontalCenter.disabledAndSelected="18"
+             verticalCenter="0"/>
+</e:Skin>

resource/eui_skins/VScrollBarSkin.exml

+<?xml version="1.0" encoding="utf-8"?>
+<e:Skin class="skins.VScrollBarSkin" minWidth="8" minHeight="20" xmlns:e="http://ns.egret.com/eui">
+    <e:Image id="thumb" source="roundthumb_png" scale9Grid="3,3,2,2" height="30" width="8" horizontalCenter="0"/>
+</e:Skin>

resource/eui_skins/VSliderSkin.exml

+<?xml version="1.0" encoding="utf-8"?>
+<e:Skin class="skins.VSliderSkin" minWidth="25" minHeight="30" xmlns:e="http://ns.egret.com/eui">
+    <e:Image id="track" source="track_png" scale9Grid="1,1,4,4" width="7" height="100%" horizontalCenter="0"/>
+    <e:Image id="thumb" source="thumb_png" horizontalCenter="0" />
+</e:Skin>

resource/skins/AlertSkin.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="AlertSkin" width="750" height="1206" xmlns:e="http://ns.egret.com/eui" xmlns:w="http://ns.egret.com/wing">
-	<e:Image source="Bitmap-1_png" y="175" horizontalCenter="0"/>
-	<e:Button id="confirmBtn" label="{data.btnTxt}" y="361" horizontalCenter="0">
-		<e:skinName>
-			<e:Skin states="up,down,disabled">
-			<e:Image width="100%" height="100%" source="Bitmap-2_png" source.down="Bitmap-2_png" source.disabled="Bitmap-2_png"  horizontalCenter.down="0" verticalCenter.down="0"/>
-			<e:Label id="labelDisplay" horizontalCenter="0" verticalCenter="0"/>
-			</e:Skin>
-		</e:skinName>
-	</e:Button>
-	<e:Button id="closeBtn" label="" x="586.18" y="143">
-		<e:skinName>
-			<e:Skin states="up,down,disabled">
-			<e:Image width="100%" height="100%" source="Bitmap-4_png" source.down="Bitmap-4_png" source.disabled="Bitmap-4_png"/>
-			<e:Label id="labelDisplay" horizontalCenter="0" verticalCenter="0"/>
-			</e:Skin>
-		</e:skinName>
-	</e:Button>
-	<e:Label text="{data.message}" y="239" textColor="0x000000" horizontalCenter="0"/>
-</e:Skin>
\ No newline at end of file

resource/skins/LoadingSkin.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="loadingSkin" width="750" height="1206" xmlns:e="http://ns.egret.com/eui" xmlns:w="http://ns.egret.com/wing" xmlns:tween="egret.tween.*">
-	<w:Declarations>
-	</w:Declarations>
-	<e:Image y="288" source="bg_png" horizontalCenter="0"/>
-	<e:Image id="waitImg" source="progress_png" y="380" anchorOffsetX="28" anchorOffsetY="28" horizontalCenter="0" rotation="{data.speed}"/>
-</e:Skin>
\ No newline at end of file

resource/skins/MsgSkin.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="MsgSkin" width="750" height="1624" xmlns:e="http://ns.egret.com/eui" xmlns:w="http://ns.egret.com/wing">
-
-
-
-	<e:Rect id="dark" width="750" height="1624" x="0" y="0" fillAlpha="0.5"/>
-	<e:Image id="bg" y="160" x="105.5" source="msgBg_png"/>
-	<e:Button id="confirmBtn" label="{data.btnTxt}" y="610" x="209.5">
-		<e:skinName>
-		<e:Skin states="up,down,disabled">
-			<e:Image width="100%" height="100%" source="sureBtn_png" source.down="sureBtn_png" source.disabled="sureBtn_png"/>
-		</e:Skin>
-		</e:skinName>
-	</e:Button>
-	<e:Button id="closeBtn" label="" x="562.83" y="398.51">
-		<e:skinName>
-		<e:Skin states="up,down,disabled">
-			<e:Image width="100%" height="100%" source="x_png" source.down="x_png" source.disabled="x_png"/>
-			<e:Label id="labelDisplay" horizontalCenter="0" verticalCenter="0"/>
-		</e:Skin>
-		</e:skinName>
-	</e:Button>
-	<e:Label id="msgTxt" text="{data.message}" y="469.51" textColor="0xeeeeee" anchorOffsetX="0" width="380.66" anchorOffsetY="0" height="113.34" size="34" textAlign="center" horizontalCenter="0"/>
-	<e:Button id="creditsOutBtn" label="" x="209.33" y="610">
-		<e:skinName>
-			<e:Skin states="up,down,disabled">
-			<e:Image width="100%" height="100%" source="sureBtn_png" source.down="sureBtn_png" source.disabled="sureBtn_png"/>
-			<e:Label id="labelDisplay" horizontalCenter="0" verticalCenter="0"/>
-			</e:Skin>
-		</e:skinName>
-	</e:Button>
-</e:Skin>
\ No newline at end of file

resource/skins/PlaySkin.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="PlaySkin" width="750" height="1206" xmlns:e="http://ns.egret.com/eui" xmlns:w="http://ns.egret.com/wing"  >
-	<e:Image id="gamebg" x="0" y="0" source="playSceneBg_jpg"/>
-	<e:Button id="ruleBtn" label="" skinName="ui.IconButtonSkin" icon="ruleBtn_png" name="ruleBtn" horizontalCenter="-340" verticalCenter="-522.5"/>
-	<e:Button id="addBtn" label="" icon="+_png" name="addBtn" skinName="ui.IconButtonSkin" horizontalCenter="129.5" verticalCenter="388"/>
-	<e:Button id="reduceBtn" label="" icon="-__png" name="reduceBtn" skinName="ui.IconButtonSkin" anchorOffsetX="0" anchorOffsetY="0" horizontalCenter="-61.5" verticalCenter="388"/>
-	<e:Component id="WheelBg" skinName="WheelBg" width="603" height="603" horizontalCenter="0" verticalCenter="-23.5"/>
-	<e:Image id="outShell" source="outShell_png" verticalCenter="-20.5" horizontalCenter="3.5"/>
-	<e:Button id="startBtn" label="" icon="startBtnBg_png" horizontalCenter="0.5" verticalCenter="-40" skinName="ui.StartButtonSkin"/>
-	<e:Label id="unitTxt" text="投入积分" x="201.61" y="960" anchorOffsetX="0" width="63.39" anchorOffsetY="0" height="63.97" textAlign="center" textColor="0xffc303" fontFamily="微软雅黑"/>
-	<e:Label id="costTxt" text="40" size="40" anchorOffsetX="0" width="132" x="343" y="974.24" textAlign="center"/>
-	<e:Image id="myCreditsBg" source="myCreditsBg_png" y="884" horizontalCenter="0"/>
-	<e:Image x="233.31" y="893" anchorOffsetX="0" width="36" anchorOffsetY="0" height="36" source="coinIcon_png"/>
-	<e:Label id="userCreditsUnitName" text="总积分积分" x="276.8" y="898.34" anchorOffsetX="0" width="156.03" size="22" textColor="0xf7de4c" fontFamily="微软雅黑" height="25.33" anchorOffsetY="0"/>
-	<e:Label id="userCreditsNum" text="2000" x="384.33" y="895" anchorOffsetX="0" width="129.87" size="30" textAlign="center" textColor="0xf7de4c" height="24"/>
-	<e:Image id="circleLight1" source="circleLight1_png" y="265" height="630" width="630" horizontalCenter="0"/>
-	<e:Image id="circleLight2" source="circleLight2_png" width="630" height="630" horizontalCenter="0" verticalCenter="-23"/>
-	<e:Image id="sideLightD" source="sideLightD_png" x="46" y="396"/>
-	<e:Image id="sideLightL" source="sideLightL_png" x="-10" y="361.67"/>
-	<e:Image id="finger" source="finger_png" horizontalCenter="87.5" verticalCenter="44"/>
-	<e:Panel id="resulePanel" width="374" height="159" skinName="component.ResultPanel" anchorOffsetX="187" anchorOffsetY="79.5" scaleX="0" scaleY="0" horizontalCenter="-1" verticalCenter="-23.5"/>
-</e:Skin>
\ No newline at end of file

resource/skins/RuleSkin.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="RuleSkin" width="750" height="1624" xmlns:e="http://ns.egret.com/eui" xmlns:w="http://ns.egret.com/wing">
-	<e:Rect id="dark" width="750" height="1624" x="0" y="0" fillAlpha="0.5"/>
-	<e:Image id="ruleBg" source="ruleBg_png" horizontalCenter="0.5" verticalCenter="-231"/>
-	<e:Button id="closeBtn" label="" horizontalCenter="296.5" verticalCenter="-561">
-		<e:skinName>
-		<e:Skin states="up,down,disabled">
-			<e:Image width="100%" height="100%" source="X_png" source.down="X_png" source.disabled="X_png"/>
-			<e:Label id="labelDisplay" horizontalCenter="0" verticalCenter="0"/>
-		</e:Skin>
-		</e:skinName>
-	</e:Button>
-</e:Skin>
\ No newline at end of file

resource/skins/component/ResultPanel.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="component.ResultPanel" width="378" height="164" xmlns:e="http://ns.egret.com/eui" xmlns:w="http://ns.egret.com/wing">
-	<e:Image id="bg" source="earnPanel_png" x="0" y="0"/>
-	<e:Label id="credits" text="0" x="41.5" y="65" size="64" anchorOffsetX="0" width="292" textAlign="center"/>
-</e:Skin>
\ No newline at end of file

resource/skins/component/WheelBg.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="WheelBg" width="603" height="603" xmlns:e="http://ns.egret.com/eui" xmlns:w="http://ns.egret.com/wing">
-	<e:Image id="wheelBg" source="wheelBg2_png" anchorOffsetX="301.5" anchorOffsetY="301.5" left="0" top="0"/>
-	<e:Image source="gift_png" x="176.5" y="76.5" rotation="-22.5"/>
-</e:Skin>
\ No newline at end of file

resource/skins/component/WheelGift.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="WheelGift" width="92" height="300" xmlns:e="http://ns.egret.com/eui" xmlns:w="http://ns.egret.com/wing">
-	<e:Image id="gift" source="gift_png" y="61" horizontalCenter="0"/>
-</e:Skin>
\ No newline at end of file

resource/skins/ui/IconButtonSkin.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="ui.IconButtonSkin" xmlns:e="http://ns.egret.com/eui" xmlns:ns1="*" states="up,down,disabled" >
-    <e:Image id="iconDisplay" source="" horizontalCenter="0" verticalCenter="0" scaleX.down="0.95" scaleY.down="0.95"/>
-</e:Skin>
\ No newline at end of file

resource/skins/ui/ProgressBarSkin.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="ui.ProgressBarSkin" xmlns:e="http://ns.egret.com/eui" xmlns:w="http://ns.egret.com/wing">
-	<e:Image id="thumb" source="loading_progress_thumb" x="3" y="3"/>
-	<e:Image id="track" source="loading_progress_track" scale9Grid="16,13,2,2" width="404"/>
-</e:Skin>
\ No newline at end of file

resource/skins/ui/StartButtonSkin.exml

-<?xml version="1.0" encoding="utf-8"?>
-<e:Skin class="ui.StartButtonSkin" xmlns:e="http://ns.egret.com/eui" xmlns:ns1="*" states="up,down,disabled,wating" >
-    <e:Image id="iconDisplay" source="" horizontalCenter="0" verticalCenter="0" scaleX.down="0.95" scaleY.down="0.95"/>
-	<e:Image source="startBtnBg_png" includeIn="wating" x="0" y="0"/>
-	<e:Image source="wating_png" includeIn="wating" horizontalCenter="0" verticalCenter="23.5"/>
-	<e:Image source="startBtnBg_png" includeIn="disabled" x="0" y="0"/>
-	<e:Image source="go_png" includeIn="disabled" x="62" y="143"/>
-	<e:Image source="startBtnBg_png" includeIn="down" x="0" y="0" scaleX="0.95" scaleY="0.95"/>
-	<e:Image source="go_png" includeIn="down" horizontalCenter="0.5" verticalCenter="25.5" scaleX="0.95" scaleY="0.95"/>
-	<e:Image source="startBtnBg_png" includeIn="up" horizontalCenter="0" verticalCenter="0"/>
-	<e:Image source="go_png" includeIn="up" horizontalCenter="0.5" verticalCenter="25.5"/>
-</e:Skin>
\ No newline at end of file

src/LoadingUI.ts

-export default  class LoadingUI extends egret.Sprite implements RES.PromiseTaskReporter {
-
-    public constructor() {
-        super();
-        this.createView();
-    }
-
-    private textField: egret.TextField;
-
-    private createView(): void {
-        this.textField = new egret.TextField();
-        this.addChild(this.textField);
-        this.textField.y = 300;
-        this.textField.width = 480;
-        this.textField.height = 100;
-        this.textField.textAlign = "center";
-    }
-
-    public onProgress(current: number, total: number): void {
-        this.textField.text = `Loading...${current}/${total}`;
-    }
-}

src/Main.ts

-import { DataManager, NetManager } from "duiba-tw";
-import Msg from "./alert/Msg";
 import AssetAdapter from "./AssetAdapter";
-import PanelCtrl from "./ctrls/panelCtrl";
-import SceneCtrl from "./ctrls/sceneCtrl";
-import Loading from "./loading/Loading";
-import PlayScene from "./playScene/PlayScene";
-import RulePanel from "./rulePanel/RulePanel";
 import ThemeAdapter from "./ThemeAdapter";
-import { ModuleTypes } from "./types/sceneTypes";
 import { getResPath } from "./utils";
-import layers from "./views/layers";
 
 class Main extends eui.UILayer {
+    /**
+     * 创建场景界面
+     * Create scene interface
+     */
+    protected createGameScene(): void {
+        let img: egret.Bitmap = new egret.Bitmap();
+        img = this.createBitmapByName("bg_jpg");
+        img.width = this.stage.stageWidth;
+        img.height = this.stage.stageHeight;
+        this.addChild(img);
+        this.CreateWorld();
+        this.CreatePlane();
+
+        this.addEventListener(egret.Event.ENTER_FRAME, this.update, this);
+        this.stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.onButtonClick, this);
+    }
+
+    //使用P2物理引擎创建物理应用的过程大致分为5个步骤：
+    // 1创建world世界
+    // 2创建shape形状
+    // 3创建body刚体
+    // 4实时调用step()函数，更新物理模拟计算
+    // 5基于形状、刚体，使用Egret渲染，显示物理模拟效果
+
+    //创建Word世界
+    private world: p2.World;
+    private CreateWorld() {
+        this.world = new p2.World();
+        //设置world为睡眠状态
+        this.world.sleepMode = p2.World.BODY_SLEEPING;
+        // gravity=[x,y] x为水平方向重力，正数表示方向向右。y为垂直方向重力，正数表示方向向下。
+        this.world.gravity = [0, 10];
+        // this.world.gravity = [0, 10];
+    }
+
+    //生成地板Plane
+    private planeBody: p2.Body;
+    private CreatePlane() {
+        let planeShape: p2.Plane = new p2.Plane();
+        this.planeBody = new p2.Body({
+            type: p2.Body.STATIC,   //刚体类型
+            position: [0, this.stage.stageHeight],  //刚体的位置
+        });
+        this.planeBody.angle = Math.PI;//Plane相当于地面，默认面向Y轴方向。将地面翻转180度
+        this.planeBody.displays = [];
+        this.planeBody.addShape(planeShape);
+        this.world.addBody(this.planeBody);
+    }
+
+    private shpeBody: p2.Body;
+    //贴图显示对象
+    private display: egret.DisplayObject;
+    private onButtonClick(e: egret.TouchEvent) {
+        if (Math.random() > 0.5) {
+            //添加方形刚体 
+            var boxShape = new p2.Box({ width: 140, height: 80 });
+            this.shpeBody = new p2.Body({
+                mass: 1,
+                position: [e.stageX, e.stageY],
+                angularVelocity: 1//下落时旋转的速度
+            });
+            this.shpeBody.addShape(boxShape);
+            this.world.addBody(this.shpeBody);
+            this.display = this.createBitmapByName("rect_png");
+            this.display.width = boxShape.width;
+            this.display.height = boxShape.height;
+            console.log(e.stageX, e.stageY);
+
+        }
+        else {
+            //添加圆形刚体
+            var circleShape = new p2.Circle({ radius: 60 });
+            this.shpeBody = new p2.Body({ mass: 1, position: [e.stageX, e.stageY] });
+            this.shpeBody.addShape(circleShape);
+            this.world.addBody(this.shpeBody);
+            this.display = this.createBitmapByName("circle_png");
+            this.display.width = circleShape.radius * 2
+            this.display.height = circleShape.radius * 2
+        }
+        //Egret中加载进来的图像，其原点默认为左上角，而P2中刚体的原点处于其中心位置，如下图（盗了一张图）
+        this.display.anchorOffsetX = this.display.width / 2
+        this.display.anchorOffsetY = this.display.height / 2;
+        this.display.x = -100;
+        this.display.y = -100;
+        this.display.rotation = 270
+        this.shpeBody.displays = [this.display];
+        this.addChild(this.display);
+    }
+
+    //帧事件，步函数
+    private update() {
+        this.world.step(1);
+        var l = this.world.bodies.length;
+        for (var i: number = 0; i < l; i++) {
+            var boxBody: p2.Body = this.world.bodies[i];
+            var box: egret.DisplayObject = boxBody.displays[0];
+            if (box) {
+                box.x = boxBody.position[0];
+                box.y = boxBody.position[1];
+                //这里刷新图片旋转
+                box.rotation = boxBody.angle * 180 / Math.PI;
+                if (boxBody.sleepState == p2.Body.SLEEPING) {
+                    box.alpha = 0.5;
+                }
+                else {
+                    box.alpha = 1;
+                }
+            }
+        }
+    }
+
+    /**
+     * 根据name关键字创建一个Bitmap对象。name属性请参考resources/resource.json配置文件的内容。
+     */
+    private createBitmapByName(name: string): egret.Bitmap {
+        var result: egret.Bitmap = new egret.Bitmap();
+        var texture: egret.Texture = RES.getRes(name);
+        result.texture = texture;
+        return result;
+
+    }
+
     protected createChildren(): void {
         super.createChildren();
-        // alert(1)
 
         egret.lifecycle.addLifecycleListener((context) => {
             // custom lifecycle plugin
@@ -34,23 +146,7 @@ class Main extends eui.UILayer {
         egret.registerImplementation("eui.IAssetAdapter", assetAdapter);
         egret.registerImplementation("eui.IThemeAdapter", new ThemeAdapter());
 
-        egret.ImageLoader.crossOrigin = "anonymous";
-
-        DataManager.ins.gameCfgData = window['CFG'];
-        DataManager.ins.gameCfgData.gameInfo.gameId = window["gameId"];
-        NetManager.ins.getCredits(()=>{});
 
-        layers.init(this);
-        Loading.init(layers.topLayer);
-        PanelCtrl.instance.init(layers.popupLayer);
-        SceneCtrl.instance.init(layers.sceneLayer);
-
-        this.stage.scaleMode = egret.StageScaleMode.FIXED_WIDTH;
-
-        PanelCtrl.instance.registerPanelClass(ModuleTypes.MSG_PANEL, Msg);
-        PanelCtrl.instance.registerPanelClass(ModuleTypes.RULE_PANEL, RulePanel);
-        SceneCtrl.instance.registerSceneClass(ModuleTypes.PALY_SCENE, PlayScene);
-        
         this.runGame().catch(e => {
             console.log(e);
         })
@@ -59,7 +155,11 @@ class Main extends eui.UILayer {
     private async runGame() {
         await this.loadResource()
         this.createGameScene();
-        RES.loadGroup("msg", 10);
+        const result = await RES.getResAsync("description_json")
+        await platform.login();
+        const userInfo = await platform.getUserInfo();
+        console.log(userInfo);
+
     }
 
     private async loadResource() {
@@ -68,8 +168,7 @@ class Main extends eui.UILayer {
             // this.stage.addChild(loadingView);
             await RES.loadConfig("default.res.json", getResPath() + "resource/");
             await this.loadTheme();
-            // await RES.loadGroup("msg", 10);
-            // this.stage.removeChild(loadingView);
+            await RES.loadGroup("preload", 0);
         }
         catch (e) {
             console.error(e);
@@ -87,32 +186,6 @@ class Main extends eui.UILayer {
 
         })
     }
-
-    private textfield: egret.TextField;
-    /**
-     * 创建场景界面
-     * Create scene interface
-     */
-    protected createGameScene(): void {
-        NetManager.ins.getInfo(() => {
-            // 等待开奖 ↓
-            if (DataManager.ins.getInfoData.status.code == 4) { 
-
-            // 已开奖 ↓
-            } else if (DataManager.ins.getInfoData.status.code == 5) {
-
-            // 正常游戏 ↓
-            } else {
-                SceneCtrl.instance.change(ModuleTypes.PALY_SCENE)
-            }
-        });
-        
-        // setTimeout(() => {
-        //     // panelCtrl.showAlertPanel('te111st');
-        //     // Loading.instace.show()
-
-        // }, 3000);
-    }
 }
 
 window['Main'] = Main;
\ No newline at end of file

src/Platform.ts

@@ -12,7 +12,7 @@ declare interface Platform {
 
 }
 
-export class DebugPlatform implements Platform {
+class DebugPlatform implements Platform {
     async getUserInfo() {
         return { nickName: "username" }
     }
@@ -22,9 +22,15 @@ export class DebugPlatform implements Platform {
 }
 
 
-export declare let platform: Platform;
+if (!window.platform) {
+    window.platform = new DebugPlatform();
+}
+
+
+
+declare let platform: Platform;
 
-export declare interface Window {
+declare interface Window {
 
     platform: Platform
 }

src/alert/Alert.ts

-import Panel from "../views/Panel";
-export default class Alert extends Panel {
-
-    set message(val) {
-
-    }
-    set btnTxt(val) {
-
-    }
-
-    start(data) {
-        const { message, btnTxt } = data;
-        this.data.message = message;
-        this.data.btnTxt = btnTxt || '确定';
-    }
-
-    protected get skinKey() { return 'Alert' }
-
-    protected get closeBtns(): eui.Button[] {
-        return [this['closeBtn'], this['confirmBtn']]
-    }
-}
\ No newline at end of file

src/alert/Msg.ts

-import Panel from "../views/Panel";
-export default class Msg extends Panel {
-
-    constructor(){
-        super()
-
-    }
-
-    set message(val) {
-
-    }
-    set btnTxt(val) {
-
-    }
-
-    start(data) {
-        const { msg } = data;
-        this.data.message = msg;
-        this['msgTxt'].text = `${this.data.message }`
-
-        switch(data.type){
-            case 'creditsOut':
-                if(this['creditsOutBtn']){
-                    this['creditsOutBtn'].visible = true;
-                    this['creditsOutBtn'].enabled = true;
-                }
-                if(this['confirmBtn']){
-                    this['confirmBtn'].visible = false;
-                    this['confirmBtn'].enabled = false;
-                }
-            break;
-            case 'err':
-                if(this['creditsOutBtn']){
-                    this['creditsOutBtn'].visible = false;
-                    this['creditsOutBtn'].enabled = false;
-                }
-                if(this['confirmBtn']){
-                    this['confirmBtn'].visible = true;
-                    this['confirmBtn'].enabled = true;
-                }
-            break;
-            default:
-                if(this['creditsOutBtn']){
-                    this['creditsOutBtn'].visible = false;
-                    this['creditsOutBtn'].enabled = false;
-                }
-                if(this['confirmBtn']){
-                    this['confirmBtn'].visible = true;
-                    this['confirmBtn'].enabled = true;
-                }
-            break;
-        }
-    }
-
-    protected get creditsOutBtns(): eui.Button[] {
-        return [this['creditsOutBtn']]
-    }
-
-    protected get closeBtns(): eui.Button[] {
-        return [this['closeBtn']]
-    }
-    
-    protected get skinKey() { return 'Msg' }
-}
\ No newline at end of file

src/components/ComponentBase.ts

-import { getSkinPath } from "../utils";
-
-export default class ComponentBase extends eui.Component {
-    protected data: any;
-    constructor() {
-        super();
-        this.data = {};
-        this.skinName = getSkinPath(this.skinKey);
-        this.addEventListener(egret.Event.COMPLETE, this.onSkinComplete, this);
-        if (this.skin) {
-            this.onSkinComplete();
-        }
-    }
-
-    protected initEvents() { }
-
-    protected removeEvents() { }
-
-    start(data?) {
-
-    }
-
-    protected get skinKey() { return null }
-
-    protected onSkinComplete() {
-        this.initEvents();
-    }
-
-    destroy() {
-        this.removeEvents();
-    }
-    
-}
\ No newline at end of file

src/ctrls/net/doStart.ts

-import { NetManager, DataManager } from "duiba-tw";
-import Loading from "../../loading/Loading";
-
-const getStartOrderStatus = (callback: Function, customizedType?: number) => {
-    NetManager.ins.getStartStatus(
-        callback,
-        DataManager.ins.doStartData.ticketId,
-        () => { return DataManager.ins.getStartStatusData.code != 1; },
-        5,
-        customizedType);
-}
-/**
-* 开始游戏
-* @param {string} isAgain 是否是再来一次
-* @param {number} credits 主动要求花费多少积分玩游戏
-* @param {number} customizedType xx类型
-*/
-export default
-    (isAgain = false, credits?: number, customizedType?: number) => new Promise((resolve) => {
-        if (window['requirelogin']) {
-            window['requirelogin']();
-            return;
-        }
-        const callback = (data) => {
-            Loading.instace.hide();
-            resolve(data);
-        }
-        Loading.instace.show();
-        NetManager.ins.doStart((success: boolean) => {
-            if (success) {
-                getStartOrderStatus(callback, customizedType);
-            } else {
-                callback(success);
-            }
-        },
-            isAgain,
-            credits,
-            customizedType);
-    });
\ No newline at end of file

src/ctrls/net/getRule.ts

-import { DataManager, NetManager } from "duiba-tw";
-import Loading from "../../loading/Loading";
-
-export default
-    () => new Promise((resolve) => {
-        const _callback = (data) => {
-            Loading.instace.hide();
-            resolve(data);
-        }
-        Loading.instace.show();
-        if (DataManager.ins.getRuleData) {
-            _callback(true);
-        } else {
-            NetManager.ins.getRule(_callback);
-        }
-    })
-

src/ctrls/net/realtimerank.ts

-import { NetManager } from "duiba-tw";
-import Loading from "../../loading/Loading";
-
-/**
-* 实时排行榜
-* @param {number} type 0总排行榜 1今日排行榜 2 多游戏总排行榜 3 昨日排行榜
-* @param {number} count 返回榜单长度 最大50
-*/
-export default (callback, type, count) => {
-    const _callback = (data) => {
-        Loading.instace.hide();
-        callback(data);
-    }
-    Loading.instace.show();
-    NetManager.ins.realtimerank(_callback, type, count);
-}
\ No newline at end of file

src/ctrls/panelCtrl.ts

-import { ModuleTypes } from "../types/sceneTypes";
-import Panel from "../views/Panel";
-export default class PanelCtrl {
-    private _parent: egret.Sprite;
-    private _mask: egret.Shape;
-
-    static _instance: PanelCtrl;
-    static get instance() {
-        return PanelCtrl._instance || (PanelCtrl._instance = new PanelCtrl())
-    }
-
-    init(parent: egret.Sprite) {
-        this._parent = parent;
-    }
-
-    show(type: ModuleTypes, data?) {
-        const cls = this._panelClassMap[type];
-        const panel: Panel = new cls(data);
-        this._current = panel;
-        panel.start(data);
-        this.add(panel);
-    }
-
-    private add(panel: Panel) {
-        this._parent.addChild(panel);
-        panel.addEventListener('onDestroy', this.onPanelHide, this);
-        panel.addEventListener('onCreditsOut', this.onCreditsOut, this);
-    }
-
-    private remove(panel: Panel) {
-        this._parent.removeChild(panel);
-    }
-
-    private onPanelHide(e: egret.Event) {
-        const panel = e.target as Panel;
-        panel.removeEventListener('onDestroy', this.onPanelHide, this);
-        panel.removeEventListener('onCreditsOut', this.onCreditsOut, this);
-        this.remove(panel);
-    }
-
-    private onCreditsOut(e: egret.Event){
-        if(!window['CFG'] || !window['CFG'].appInfo) return;
-        window.location.href = window['CFG'].appInfo.earnCreditsUrl;
-    }
-
-    private _panelClassMap: any;
-    registerPanelClass(name, definition) {
-        this._panelClassMap = this._panelClassMap || {};
-        this._panelClassMap[name] = definition;
-    }
-
-    
-    private _current: Panel;
-
-    closeCurrent() {
-        if (this._current)
-            this.remove(this._current);
-    }
-}
\ No newline at end of file

src/ctrls/sceneCtrl.ts

-import { ModuleTypes } from "../types/sceneTypes";
-import Scene from "../views/Scene";
-export default class SceneCtrl {
-    private _parent: egret.Sprite;
-    private _currentScene: Scene;
-
-    static _instance: SceneCtrl;
-    static get instance() {
-        return SceneCtrl._instance || (SceneCtrl._instance = new SceneCtrl())
-    }
-    init(parent: egret.Sprite) {
-        this._parent = parent;
-    }
-
-    change(type: ModuleTypes) {
-        if (this._currentScene) {
-            this._currentScene.destroy();
-            this._parent.removeChild(this._currentScene);
-        }
-        const cls = this._sceneClassMap[type];
-        const scene: Scene = new cls();
-        scene.start();
-        this.addToStage(scene);
-    }
-
-    private addToStage(scene: Scene) {
-        this._currentScene = scene;
-        this._parent.addChild(scene);
-    }
-
-    private _sceneClassMap: any;
-    registerSceneClass(name, definition) {
-        this._sceneClassMap = this._sceneClassMap || {};
-        this._sceneClassMap[name] = definition;
-    }
-}
\ No newline at end of file

src/ctrls/showAlertPanel.ts

-import { ModuleTypes } from "../types/sceneTypes";
-import PanelCtrl from "./panelCtrl";
-
-export default (message: string, btnTxt?: string) => {
-
-    PanelCtrl.instance.show(ModuleTypes.ALERT_PANEL, { message: message, btnTxt: btnTxt })
-}
\ No newline at end of file

src/loading/Loading.ts

-import ComponentBase from "../components/ComponentBase";
-
-export default class Loading extends ComponentBase {
-    private static _parent: egret.Sprite;
-    private static _instance: Loading;
-    static get instace(): Loading {
-        return Loading._instance || (Loading._instance = new Loading());
-    }
-    constructor() {
-        super();
-        this.horizontalCenter = 0;
-        this.verticalCenter = 0;
-    }
-
-    show() {
-        Loading._parent.addChild(this);
-        if (this.skin && !this.hasEventListener(egret.Event.ENTER_FRAME))
-            this.addEventListener(egret.Event.ENTER_FRAME, this.onEnterFrame, this);
-    }
-
-    hide() {
-        Loading._parent.removeChild(this);
-        if (this.hasEventListener(egret.Event.ENTER_FRAME))
-            this.removeEventListener(egret.Event.ENTER_FRAME, this.onEnterFrame, this);
-    }
-
-    static init(parent: egret.Sprite) {
-        Loading._parent = parent;
-    }
-
-    onSkinComplete(): any {
-        super.onSkinComplete();
-        if (!this.hasEventListener(egret.Event.ENTER_FRAME))
-            this.addEventListener(egret.Event.ENTER_FRAME, this.onEnterFrame, this);
-    }
-
-    onEnterFrame() {
-        this.data.speed += 5;
-    }
-
-    protected get skinKey() { return 'Loading' }
-}

src/playScene/PlayScene.ts

-
-import { INetData } from 'duiba-tc';
-import { NetManager, DataManager, NetName } from 'duiba-tw';
-import Scene from "../views/Scene";
-import PanelCtrl from '../ctrls/panelCtrl';
-import { ModuleTypes } from '../types/sceneTypes';
-
-const { TouchEvent } = egret;
-export default class PlayScene extends Scene {
-    
-    // 游戏参数
-    private userCredits:number = 0;
-    private unitNum:number = 10;
-    private unitName:string;
-    private currCostCredits:number = 0;
-    private lightCount:number = 0;
-    private lightRate = 30;
-    private isLight:boolean = false;
-    private wbgloop:any;
-    private multiplesArr:any[] = [];
-    private angleArr:any[] = [];
-    private ranArr:any[] = [];
-    private coinsArr:any[] = [];
-    private gravity:number = 4.5;
-    private multiple:number;
-
-    // 导出的元件
-    public bg:eui.Image;
-    public ruleBtn:eui.Button;
-    public addBtn:eui.Button;
-    public reduceBtn:eui.Button;
-    public WheelBg:eui.Component;
-    public outShell:eui.Image;
-    public startBtn:eui.Button;
-    public unitTxt:eui.Label;
-    public costTxt:eui.Label;
-    public myCreditsBg:eui.Image;
-    public userCreditsUnitName:eui.Label;
-    public userCreditsNum:eui.Label;
-    public circleLight1:eui.Image;
-    public circleLight2:eui.Image;
-    public sideLightD:eui.Image;
-    public sideLightL:eui.Image;
-    public finger:eui.Image;
-    public resulePanel:eui.Panel;
-    public rulePanel:eui.Panel;
-
-    initEvents() {
-        this.startBtn.addEventListener(egret.TouchEvent.TOUCH_TAP,this.onClick_startBtn,this);
-        this.reduceBtn.addEventListener(egret.TouchEvent.TOUCH_TAP,this.onClick_reduceBtn,this);
-        this.addBtn.addEventListener(egret.TouchEvent.TOUCH_TAP,this.onClick_addBtn,this);
-        this.ruleBtn.addEventListener(egret.TouchEvent.TOUCH_TAP,this.onClick_ruleBtn,this);
-    }
-
-    removeEvents() {
-        this.startBtn.removeEventListener(egret.TouchEvent.TOUCH_TAP,this.onClick_startBtn,this);
-        this.reduceBtn.removeEventListener(egret.TouchEvent.TOUCH_TAP,this.onClick_reduceBtn,this);
-        this.addBtn.removeEventListener(egret.TouchEvent.TOUCH_TAP,this.onClick_addBtn,this);
-        this.ruleBtn.removeEventListener(egret.TouchEvent.TOUCH_TAP,this.onClick_ruleBtn,this);
-    }
-
-    start() {
-        this.once(egret.Event.ADDED_TO_STAGE,this.onLoad,this);
-        this.circleLight1.$touchEnabled = false;
-        this.circleLight2.$touchEnabled = false;
-        this.finger.$touchEnabled = false;
-        this.sideLightL.visible = false;
-        this.userCredits = DataManager.ins.getInfoData ? DataManager.ins.getInfoData.credits : 0;
-        this.unitName = DataManager.ins.getCreditsData ? `${DataManager.ins.getCreditsData.unitName}` : `积分`;
-        if(this.userCredits<10){
-            this.currCostCredits = 0;
-        }else if(this.userCredits <= 200){
-            this.currCostCredits = 10;
-        }else if(this.userCredits <= 500){
-            this.currCostCredits = 20;
-        }else if(this.userCredits <= 1000){
-            this.currCostCredits = 30;
-        }else if(this.userCredits <= 5000){
-            this.currCostCredits = 50;
-        }else if(this.userCredits <= 10000){
-            this.currCostCredits = 100;
-        }else if(this.userCredits > 10000){
-            this.currCostCredits = 200;
-        }
-        this.costTxt.text = `${this.currCostCredits}`;
-        this.unitTxt.text = `投入${this.unitName}`; 
-        this.userCreditsUnitName.text = `总${this.unitName}`;
-        this.userCreditsNum.text = `${this.userCredits}`;
-        let fingerTw = egret.Tween.get( this.finger, {loop: true} );
-        fingerTw.to({scaleX:0.9, scaleY:0.9}, 500).to({scaleX:1, scaleY:1}, 500)
-
-        this.WheelBg['realRotation'] = 0;
-        console.log(this.WheelBg)
-
-
-        // 按从小到大排序
-        this.multiplesArr = [0, 0.2, 0.4, 0.5, 0.8, 1.0, 1.1, 1.2, 1.4, 1.5, 2];
-        let unitAngle = 360/16;
-        this.angleArr = [13*unitAngle, 11*unitAngle, 0, 5*unitAngle, 8*unitAngle, 14*unitAngle, 12*unitAngle, 6*unitAngle, 10*unitAngle, 3*unitAngle, 2*unitAngle];
-        this.ranArr = [1/11,1/11,1/11,1/11,1/11,1/11,1/11,1/11,1/11,1/11,1/11];
-    }
-
-
-    private timeOnEnterFrame:number = 0;
-
-    private onLoad(event:egret.Event) {
-        this.addEventListener(egret.Event.ENTER_FRAME,this.onEnterFrame,this);
-    }
-
-    private onEnterFrame(e:egret.Event){
-        let scope = this;  
-        scope.lightCount ++;
-        if(scope.lightCount%scope.lightRate == 0){
-            scope.isLight = !scope.isLight;
-        }
-        scope.circleLight2.visible = scope.isLight;
-        
-        if(scope.coinsArr.length > 0){
-            for(let c = scope.coinsArr.length-1; c>=0;c--){
-                scope.coinsArr[c].x += scope.coinsArr[c].dirX * scope.coinsArr[c].vx;
-                scope.coinsArr[c].y -= scope.coinsArr[c].vy;
-                scope.coinsArr[c].vy -= scope.gravity;
-            } 
-        }
-    }
-    
-    // 开始游戏
-    private onClick_startBtn(e:egret.TouchEvent){
-        if(window['requirelogin']) {
-            window['requirelogin']();
-            return;
-        }
-
-        if(this.userCredits < 10){
-            let data = {msg:`${this.unitName}不足最小投值10${this.unitName}快去赚取${this.unitName}吧`, type:'creditsOut'}
-            PanelCtrl.instance.show(ModuleTypes.MSG_PANEL, data)
-            return;
-        }
-
-        let scope = this;
-        let wbg = egret.Tween.get( this.WheelBg, {onChange: scope.onWbgRotationChange.bind(scope)});
-        
-        scope.removeChild(scope.goAni)
-
-        let func:Function;
-        wbg.to({realRotation:(scope.WheelBg['realRotation'] + 3600)}, 2000, egret.Ease.quartIn).call( func = function(){ 
-            
-            let _rotation = scope.WheelBg['realRotation'] + 360;
-            scope.wbgloop = egret.Tween.get( scope.WheelBg, {onChange: scope.onWbgRotationChange.bind(scope), loop: true});
-            scope.wbgloop.to({realRotation: _rotation}, 300).call(()=>{
-                _rotation = scope.WheelBg['realRotation'] + 360;
-            }); 
-        });
-
-        this.finger.visible = false;
-        this.lightRate = 5;
-        this.sideLightL.visible = true;
-        this.buttonEnable(false);
-        this.startBtn.currentState = 'wating';
-        this.doStart(this.doStartResult.bind(this), false, this.currCostCredits, 1);
-    }
-
-    // 开始游戏接口
-    public doStart(callback: Function, isAgain = false, credits?: number, customizedType?: number): void {
-        if(window['requirelogin']) {
-            window['requirelogin']();
-            return;
-        }
-        NetManager.ins.doStart((success: boolean) => {
-            if(success) {
-                this.getStartStatus(callback, customizedType);
-            } else {
-                callback(success);
-            }
-        },
-        isAgain,
-        credits,
-        customizedType);
-    }
-
-    // 查询开始状态
-    private getStartStatus(callback: Function, customizedType?: number): void {
-        const param: any = {
-            ticketId: DataManager.ins.doStartData.ticketId
-        };
-        if (customizedType) {
-            param.customizedType = customizedType
-        }
-        const net: INetData = {
-            name: 'getStartStatus',
-            uri: '/ngapi/getStartStatus',
-            type: 'post',
-            dataType: 'json',
-            param: param,
-            callback: callback,
-            pollingCount: 5,
-            pollingCheck: () => { return DataManager.ins.getData('getStartStatus').code != 1; }
-        };
-        NetManager.ins.send(net)
-    }
-
-    // 开始的回调
-    private doStartResult(success:boolean){
-        let scope = this;
-        if(!success) {
-            this.defaultErr()
-            return;
-        }
-
-        let upperCreditsLimit = DataManager.ins.getData('getStartStatus').upperCreditsLimit ? DataManager.ins.getData('getStartStatus').upperCreditsLimit : scope.currCostCredits;
-        // 取得的返回最大倍数
-        let maxMultiple = upperCreditsLimit/scope.currCostCredits;
-        console.log(`最大倍数:${maxMultiple}`)
-        // 改变数组
-        let newMultiplesArr:any[] = [];
-        for(let m = 0; m<scope.multiplesArr.length; m++){
-            if(scope.multiplesArr[m] < maxMultiple){
-                newMultiplesArr.push(scope.multiplesArr[m]);
-            }
-        }
-        
-        // 更新用户积分文案
-        scope.userCreditsNum.text = `${DataManager.ins.getInfoData ? DataManager.ins.getInfoData.credits : scope.userCredits}`
-        
-        // 拿到倍数
-        let newAngleArr:any[] = [];
-        let newRanArr:any[] = [];
-        let arr:any[] = [];
-        for(let i = 0; i < newMultiplesArr.length; i++){
-            newAngleArr.push(scope.angleArr[i]);
-            newRanArr.push(scope.ranArr[i]);
-
-            let num = Math.round(120 * newRanArr[i]);
-            let a = (new Array(num))["fill"](newAngleArr[i]);
-            arr = arr.concat(a);
-        }
-        
-        let randomT = (e, n?) => {
-            return e && "number" == typeof e.length && e.length ? e[Math.floor(Math.random() * e.length)] : ("number" != typeof n && (n = e || 1, e = 0), e + Math.random() * (n - e))
-        }
-
-        let targetAngle = randomT(arr);
-        let i = scope.angleArr.indexOf(targetAngle);
-        let multiple = scope.multiplesArr[i];
-        this.multiple = multiple;
-        console.log(`随机倍数:${multiple}`)
-
-        let timeout = setTimeout(() => {
-            clearTimeout(timeout)
-            egret.Tween.removeTweens( scope.WheelBg );
-            let tw = egret.Tween.get( scope.WheelBg, {onChange:scope.onWbgRotationChange.bind(scope)} );
-            let _rotation = Math.random() > 0.5 ? scope.WheelBg['realRotation'] + ( 360 - scope.WheelBg['realRotation'] % 360 ) + targetAngle + 1440 + Math.random() * 8 : scope.WheelBg['realRotation'] + ( 360 - scope.WheelBg['realRotation'] % 360 ) + targetAngle + 1440 - Math.random() * 8;
-            tw.to({realRotation:_rotation}, 8000 ,egret.Ease.quartOut).call(()=>{
-                scope.startBtn.currentState = 'up';
-                scope.buttonEnable(false)
-                scope.sideLightL.visible = false;
-                scope.lightRate = 30;
-                scope.coinsFall(true)
-            });        
-        }, 1000);
-
-        // 延时提交分数
-        let timeout2 = setTimeout(()=>{
-            this.gameSubmitData(this.gameSubmitResult.bind(this), this.currCostCredits * multiple, false, 1);
-        },500)
-    }
-
-    private gameSubmitResult(){
-        NetManager.ins.getInfo(()=>{})
-        console.log('提交成功')
-    }
-
-
-    /**
-     * 提交游戏成绩
-     * @param callback 
-     * @param score 得分
-     * @param allDynamics 防作弊数据
-     * @param checkScore  是否校验得分
-     * @param customizedType 定制类型 1推币机    
-     */
-    protected gameSubmitData(callback: Function, score: number, checkScore?: boolean, customizedType?: number): void {
-        NetManager.ins.gameSubmit(
-            (success: boolean) => { 
-                if(success) {
-                    this.getSubmitResult(callback, DataManager.ins.gameSubmitData.orderId); 
-                } else {
-                    callback(success);
-                }
-            },
-            DataManager.ins.doStartData.ticketId,
-            score,
-            '[]',
-            DataManager.ins.doStartData.submitToken,
-            '',
-            checkScore,
-            customizedType);
-    }
-    
-    /**
-     * 查询提交结果
-     * @param callback 
-     * @param orderId 
-     */
-    private getSubmitResult(callback: Function, orderId: number): void {
-        NetManager.ins.getSubmitResult(callback, orderId, () => {
-            return DataManager.ins.gameGetSubmitResultData.flag;
-        });
-    }
-
-    // 默认出错——转到0后弹错误窗
-    private defaultErr(){
-        let timeout = setTimeout(() => {
-            clearTimeout(timeout)
-            egret.Tween.removeTweens( this.WheelBg );
-            let tw = egret.Tween.get( this.WheelBg, {onChange:this.onWbgRotationChange.bind(this)} );
-            this.multiple = 0;
-            let _rotation = this.WheelBg['realRotation'] + ( 360 - this.WheelBg['realRotation'] % 360 ) + 360*13/16 + 1440;
-            tw.to({realRotation:_rotation}, 8000 ,egret.Ease.quartOut).call(()=>{
-                this.startBtn.currentState = 'up';
-                this.buttonEnable(true);
-                this.sideLightL.visible = false;
-                this.lightRate = 30;
-                this.coinsFall(false)
-            });        
-        }, 2000);
-    }
-    private onWbgRotationChange(){
-        this.WheelBg.rotation = this.WheelBg['realRotation'];
-    }
-
-    // 减号
-    private onClick_reduceBtn(e:egret.TouchEvent){
-        if(window['requirelogin']) {
-            window['requirelogin']();
-            return;
-        }
-        if((this.currCostCredits - this.unitNum) > 0 && (this.userCredits - this.unitNum) > 0 ){
-            this.currCostCredits -= this.unitNum;
-        }
-        this.costTxt.text = `${this.currCostCredits}`;
-    }
-
-    // 加号
-    private onClick_addBtn(e:egret.TouchEvent){
-        if(window['requirelogin']) {
-            window['requirelogin']();
-            return;
-        }
-        if((this.currCostCredits + this.unitNum) <= this.userCredits && this.currCostCredits < 500){
-            this.currCostCredits += this.unitNum;
-        }
-        this.costTxt.text = `${this.currCostCredits}`;
-    }
-
-    // 规则按钮
-    private onClick_ruleBtn(e:egret.TouchEvent){
-        PanelCtrl.instance.show(ModuleTypes.RULE_PANEL);
-    }
-
-    // 加载动画资源
-    private goAni:any;
-    protected childrenCreated():void{
-        super.childrenCreated();
-        this.ayncLoad2Mc("goBtn_json");
-        this.ayncLoad2Mc("coin_json");
-    }
-    private ayncLoad2Mc( resname : string) : void{
-        let scope = this;
-        RES.getResAsync(resname,
-        (data: any,key: string): void => {
-            if(key == "coin_json") {
-                scope.ayncLoad2Mc("coin_png");
-            }else if(key == "coin_png") {
-                for(let i=0;i<100;i++){
-                    let data2mc = RES.getRes("coin_json");
-                    let texture2mc = RES.getRes("coin_png");
-                    let mcFactory : egret.MovieClipDataFactory = new egret.MovieClipDataFactory(data2mc,texture2mc);
-                    let mc:egret.MovieClip = new egret.MovieClip(mcFactory.generateMovieClipData("coin"));
-                    scope.coinsArr.push(mc);
-                }
-            }else if(key == "goBtn_json") {
-                scope.ayncLoad2Mc("goBtn_png");
-            }else if(key == "goBtn_png") {
-                let data2mc = RES.getRes("goBtn_json");
-                let texture2mc = RES.getRes("goBtn_png");
-                let mcFactory : egret.MovieClipDataFactory = new egret.MovieClipDataFactory(data2mc,texture2mc);
-                let mc:egret.MovieClip = new egret.MovieClip(mcFactory.generateMovieClipData("go"));
-                mc.gotoAndPlay('light', -1);
-                scope.goAni = mc;
-                scope.addChild(scope.goAni)
-                scope.addChild(scope.finger)
-                mc.x = 279;
-                mc.y = 494;
-            }
-        },
-        this);
-    }
-
-    // 金币掉落效果
-    private coinsFall(isSuccess:boolean):void{
-        let scope = this;
-        let count = 0;
-        let coinsFall = setInterval(()=>{
-            if(count<100){
-                scope.addChild(scope.coinsArr[count]);
-                scope.coinsArr[count].gotoAndPlay('rotate', -1);
-                if(Math.random()>0.5){
-                    scope.coinsArr[count].dirX = 1;
-                }else{
-                    scope.coinsArr[count].dirX = -1;
-                }
-                scope.coinsArr[count].vy = Math.random() * 60;
-                scope.coinsArr[count].vx = Math.random() * 30;
-                scope.coinsArr[count].x = this.stage.stageWidth/2 - scope.coinsArr[count].width/2;
-                scope.coinsArr[count].y = 500;
-                count++;
-                this.addChild(this.resulePanel)
-            }else{
-                if(!isSuccess){
-                   // 失败
-                    let msg = DataManager.ins.doStartData ? DataManager.ins.doStartData.message : `网络出了点小问题请退出后重试`;
-                    let data = {msg:msg, type:'err'}
-                    PanelCtrl.instance.show(ModuleTypes.MSG_PANEL, data) 
-                }
-                clearInterval(coinsFall)
-            }
-        },10)
-        
-        scope.showResultPanel()
-    }
-
-    private currEarnCredits:number = 0;
-    private showResultPanel(){
-        let scope = this;
-        scope.currEarnCredits = scope.currCostCredits * scope.multiple;
-        let resultPanelTw = egret.Tween.get( scope.resulePanel );
-        resultPanelTw.to({scaleX:1, scaleY:1}, 300).wait(2000).call(()=>{
-            scope.resulePanel.scaleX = 0;
-            scope.resulePanel.scaleY = 0;
-            scope.buttonEnable(true);
-            scope.addChild(scope.goAni);
-        })
-        this.resulePanel['credits'].text = `0`;
-        let credits:any = {num:0}; 
-        credits.num = Number(this.resulePanel['credits'].text);
-        let creditTw = egret.Tween.get( credits , { onChange:onCreditsChange});
-        creditTw.to({num: this.currEarnCredits},1000)
-
-        function onCreditsChange(){
-            let c = Math.floor(credits.num);
-            scope.resulePanel['credits'].text = `${c}`
-        }
-    }
-
-    // 按钮状态
-    private buttonEnable(enabled:boolean){
-        this.startBtn.enabled = enabled;
-        this.addBtn.enabled = enabled;
-        this.reduceBtn.enabled = enabled;
-        this.ruleBtn.enabled = enabled;
-    }
-
-
-
-    protected get skinKey() { return 'Play' }
-}
\ No newline at end of file

src/rulePanel/RulePanel.ts

-import { NetManager } from 'duiba-tw';
-import { DataManager } from 'duiba-tw';
-import Panel from "../views/Panel";
-export default class RulePanel extends Panel {
-    constructor(){
-        super()
-        NetManager.ins.getRule(()=>{
-            var tx:egret.TextField = new egret.TextField;
-            tx.width = this.stage.stageWidth - 220;
-            tx.textFlow = (new egret.HtmlTextParser).parser(
-                DataManager.ins.getRuleData ? DataManager.ins.getRuleData.ruleText : 
-                (DataManager.ins.ajaxElementData ? DataManager.ins.ajaxElementData.rule : 
-                    (window['ruleCFG'] ? window['ruleCFG'] : "规则")
-                )
-            );
-            tx.x = 110;
-            tx.y = 330;
-            tx.textColor = 0x333333;
-            this.addChild( tx );
-        })
-    }
-
-    protected get skinKey() { return 'Rule' }
-}
\ No newline at end of file

src/types/sceneTypes.ts

-export enum ModuleTypes {
-    START_SCENE,
-    PALY_SCENE,
-    ALERT_PANEL,
-    RULE_PANEL,
-    MSG_PANEL
-}
\ No newline at end of file

src/views/Panel.ts

-import ComponentBase from "../components/ComponentBase";
-
-export default class Panel extends ComponentBase {
-    constructor() {
-        super();
-    }
-
-    initEvents() {
-        if(this.closeBtns && this.closeBtns.length > 0){
-            this.closeBtns.forEach(
-                btn => { if(btn) btn.addEventListener(egret.TouchEvent.TOUCH_TAP, this.onTouchTap, this) }
-            )
-        }
-        if(this.confirmBtns && this.confirmBtns.length > 0){
-            this.confirmBtns.forEach(
-                btn => { if(btn) btn.addEventListener(egret.TouchEvent.TOUCH_TAP, this.onTouchTap, this) }
-            )
-        }
-        if(this.creditsOutBtns && this.creditsOutBtns.length > 0){
-            this.creditsOutBtns.forEach(
-                btn => { if(btn) btn.addEventListener(egret.TouchEvent.TOUCH_TAP, this.creditsOut, this) } 
-            )
-        }
-        
-    }
-    removeEvents() {
-        if(this.closeBtns && this.closeBtns.length > 0){
-            this.closeBtns.forEach(
-                btn => { if(btn) btn.removeEventListener(egret.TouchEvent.TOUCH_TAP, this.onTouchTap, this) }
-            )
-        }
-        if(this.confirmBtns && this.confirmBtns.length > 0){
-            this.confirmBtns.forEach(
-                btn => { if(btn) btn.removeEventListener(egret.TouchEvent.TOUCH_TAP, this.onTouchTap, this) }
-            )
-        }
-        
-        if(this.creditsOutBtns && this.creditsOutBtns.length > 0){
-            this.creditsOutBtns.forEach(
-                btn => { if(btn) btn.removeEventListener(egret.TouchEvent.TOUCH_TAP, this.creditsOut, this) } 
-            )
-        }
-    }
-
-    protected get closeBtns(): eui.Button[] { return [this['closeBtn']] }
-    protected get confirmBtns(): eui.Button[] { return [this['confirmBtn']]}
-    protected get creditsOutBtns(): eui.Button[] { return [this['creditsOutBtn']] }
-
-    onTouchTap(): any {
-        this.hidePanel();
-    }
-
-    hidePanel() {
-        this.destroy();
-        this.dispatchEvent(new egret.Event('onDestroy'));
-    }
-    
-    creditsOut(){
-        this.destroy();
-        this.dispatchEvent(new egret.Event('onCreditsOut'));
-    }
-
-}
\ No newline at end of file

src/views/Scene.ts

-import ComponentBase from "../components/ComponentBase";
-
-export default class Scene extends ComponentBase {
-    
-}
\ No newline at end of file

src/views/layers.ts

-
-class Layers extends eui.UILayer {
-    private _topLayer: egret.Sprite;
-    private _popupLayer: egret.Sprite;
-    private _sceneLayer: egret.Sprite;
-    init(root: eui.UILayer) {
-        root.addChild(this);
-        this._topLayer = new egret.Sprite();
-        this._popupLayer = new egret.Sprite();
-        this._sceneLayer = new egret.Sprite();
-        this.addChild(this._sceneLayer);
-        this.addChild(this._popupLayer);
-        this.addChild(this._topLayer);
-    }
-
-    get topLayer() { return this._topLayer }
-    get popupLayer() { return this._popupLayer }
-    get sceneLayer() { return this._sceneLayer }
-
-}
-
-const instance = new Layers();
-export default instance
\ No newline at end of file