移植打星球，基本改掉语法错误

libs/ShootPlanet.d.ts

+declare namespace RES {
+    function getRes(uuid: string): engine.Texture;
+}
+
+declare interface Math {
+    clamp(target: number, min: number, max: number): number;
+}
+
+declare namespace engine {
+    interface Point {
+        length: number;
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/Bullet.ts

+import { PoolElement } from "./Pool";
+import MoveObjcet from "./MoveObject";
+import { MConst } from "./MConst";
+import GameObject from "./GameObject";
+import Collider, { CircleCollider, ColliderGroup, PointCollider } from "./Collider";
+import Game from "./Game";
+
+export default class Bullet extends MoveObjcet implements PoolElement {
+    public power: number = 1;
+
+    constructor(context: Game) {
+        super(context);
+        this.addChild(new engine.Image(RES.getRes("bullet_png")));
+        this.anchorY = 0;
+
+        let collider = this.addComponent(PointCollider) as PointCollider;
+        collider.group = ColliderGroup.Bullet;
+        collider.setData(2, 0);
+        this.physics.velocity.y = -MConst.BulletSpeedValue;
+    }
+
+    init(power: number) {
+        this.power = power;
+        return this;
+    }
+
+    onElementInit() {
+        this.enableAllComponents();
+        this.visible = true;
+    }
+    onElementRecycle() {
+        this.disableAllComponents();
+        this.visible = false;
+    }
+
+    onCollisionEnter(other: Collider) {
+        if (other.group == ColliderGroup.Ball || other.group == ColliderGroup.Top) {
+            this.context._bulletPool.destroy(this);
+        }
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/Car.ts

+import GameObject from "./GameObject";
+import Collider, { RectCollider, ColliderGroup } from "./Collider";
+import { MConst } from "./MConst";
+import Bullet from "./Bullet";
+import MTweenMgr from "./MTween";
+import SoundMgr from "./SoundMgr";
+import MTimer from "./MTimer";
+import Game from "./Game";
+
+export default class Car extends GameObject {
+    private imgGun: engine.Image = null;
+    private imgParticel: engine.Image = null;
+    private fireTimer: number = null;
+    public touchWall: 1 | -1 | 0 = 0;
+    public onDied: () => void;
+    private isDied: boolean = false;
+
+    private invincibleDuration = 0;
+
+    constructor(context: Game) {
+        super(context);
+        this.x = 124;
+        this.y = 145;
+        this.createPart("car_shadow_png", 4.96, 138.69);
+        this.createPart("car_part_0_png", 12.5, 102.5);
+        this.imgGun = this.createPart("car_gun_png", 33.5, 120);
+        this.createPart("car_wheel_png", 0, 97.5);
+        this.imgParticel = this.createPart("car_particle_png", 15.98, 1.33);
+        // this.imgParticel.alpha = 0;
+        this.imgGun.anchorY = 100;
+
+        this.addEventListener(engine.Event.ENTER_FRAME, this.onEnterFrame, this);
+
+        let collider = this.addComponent<RectCollider>(RectCollider);
+        collider.setData(29, 20, 63, 150);
+        collider.group = ColliderGroup.Car;
+
+        this.addEventListener(engine.Event.REMOVED_FROM_STAGE, this.onDestroy, this);
+    }
+
+    private createPart(source: string, x: number, y: number) {
+        let bitmap = new engine.Image(RES.getRes(source) as engine.Texture);
+        bitmap.x = x;
+        bitmap.y = y;
+        this.addChild(bitmap);
+        return bitmap;
+    }
+
+    private fire() {
+        SoundMgr.instance.playEffect("shoot_mp3");
+        // let column = this.context.fireBulletNumConfig[this.fireBulletNumConfigIndex];
+        // this.fireBulletNumConfigIndex = this.fireBulletNumConfigIndex == 0 ? 1 : 0; //0/1交替
+        const column = this.context._fireBulletNumConfig;
+        const numb = MConst.BulletDisperseFrameNum;
+
+        let bullets: Bullet[] = [];
+        for (let i = 0; i < column; i++) {
+            const bullet = this.context._bulletPool.create(this.context).init(Math.floor(this.context._PowerScore / 100));
+            bullet.posY = this.posY - this.height + 26;
+            bullet.posX = this.posX;
+            let offsetX = (i - (column - 1) / 2) * MConst.BulletWidth;
+            bullet.physics.velocity.x = offsetX / numb;
+            /* MTweenMgr.instance.get(bullet).wait(MConst.BulletDisperseFrameNum, true).call(() => {
+                bullet.physics.velocity.x = 0;
+            }); */
+            bullets.push(bullet);
+        }
+
+        MTimer.set(numb, () => {
+            for (let i of bullets) {
+                i.physics.velocity.x = 0;
+            }
+        });
+    }
+
+    private die() {
+        if (this.isDied) return;
+        this.isDied = true;
+        if (this.invincibleDuration > 0) return;
+
+        this.onDied && this.onDied();
+    }
+
+    onCollisionEnter(other: Collider) {
+        if (other.group == ColliderGroup.Ball) {
+            this.die();
+        }
+
+        if (other.group == ColliderGroup.Wall) {
+            this.touchWall = other.owner.x < 0 ? 1 : -1;
+
+        }
+    }
+
+    onCollisionStay(other: Collider) {
+        if (other.group == ColliderGroup.Ball) {
+            this.die();
+        }
+
+        if (other.group == ColliderGroup.Wall) {
+            this.touchWall = other.owner.x < 0 ? 1 : -1;
+
+        }
+    }
+
+    private onceBlink() {
+        MTweenMgr.instance.get(this)
+            .to({ alpha: 0 }, 1, true)
+            .wait(2)
+            .to({ alpha: 1 }, 1, true)
+            .wait(2)
+            .call(() => { this.onceBlink(); });
+    }
+
+    revive() {
+        this.invincibleDuration = MConst.ReviveInvincibleDuration * 1000;
+        MTweenMgr.instance.removeTweens(this);
+        this.onceBlink();
+        MTimer.set(MConst.ReviveInvincibleDuration * 60, () => {
+            //无敌结束
+            this.alpha = 1;
+            MTweenMgr.instance.removeTweens(this);
+        });
+    }
+
+    move(deltaX: number) {
+        if (this.touchWall == 1 && deltaX <= 0) {
+            return;
+        } else if (this.touchWall == -1 && deltaX >= 0) {
+            return;
+        }
+
+        this.x += deltaX;
+    }
+
+    onCollisionExit(other: Collider) {
+        if (other.group == ColliderGroup.Wall) {
+            this.touchWall = 0;
+        }
+    }
+
+    private frameTimer = 0;
+
+    private onEnterFrame() {
+        if (this.context.pause) return;
+
+        if (this.invincibleDuration > 0) {
+            this.invincibleDuration -= MTimer.deltaTime;
+        }
+
+        this.fireTimer += 1 * MTimer.dtFactor;
+
+        if (this.fireTimer >= 60 / this.context._fireSpeed) {
+            this.fire();
+            this.fireTimer = 0;
+        }
+
+        if (this.frameTimer % 3 == 0) {
+            this.imgParticel.visible = !this.imgParticel.visible;
+        }
+        this.frameTimer++;
+    }
+
+    onDestroy() {
+        this.removeEventListener(engine.Event.ENTER_FRAME, this.onEnterFrame, this);
+        MTweenMgr.instance.removeTweens(this);
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/Collider.ts

+import GameComponent from "./GameComponent";
+import GameObject from "./GameObject";
+import PhycicsSystem from "./PhycicsSystem";
+import Physics from "./Physics";
+
+export default abstract class Collider extends GameComponent {
+    public physics: Physics = null;
+    private _group: ColliderGroup = null;
+    set group(group: ColliderGroup) {
+        if (this._group == null) {
+            this._group = group;
+            PhycicsSystem.instance.addCollider(this);
+        } else {
+            this._group = group;
+        }
+    }
+    get group() {
+        return this._group;
+    }
+    public type: ColliderType = null;
+    setData(...ags: any[]): void {
+        this.physics && this.physics.onColliderResize(this);
+    }
+
+
+
+    onEnabled() {
+        //自动设置物理组件
+        if (this.group)
+            PhycicsSystem.instance.addCollider(this);
+        let physics = this.owner.getComponent<Physics>(Physics);
+        if (physics) {
+            this.physics = physics;
+            physics.collider = this;
+        }
+    }
+
+    protected worldPos: engine.Point = new engine.Point();
+
+    abstract getWorldPosition(out: number[]): void;
+
+    onDisabled() {
+        PhycicsSystem.instance.removeCollider(this);
+    }
+
+    /**获取碰撞器的中心的节点坐标 */
+    abstract getCenter(): number[];
+}
+
+export class CircleCollider extends Collider {
+    public radius: number = 0
+    public center: number[] = []
+    constructor(owner: GameObject) {
+        super(owner);
+        this.type = ColliderType.Circle;
+    }
+
+    setData(x: number, y: number, radius: number) {
+        this.radius = radius;
+        this.center[0] = x;
+        this.center[1] = y;
+        super.setData();
+    }
+
+    getCenter() {
+        return this.center;
+    }
+
+    private t = {
+        x: 0,
+        y: 0
+    };
+    getWorldPosition(out: number[]) {
+        out[0] = this.owner.x - this.owner.anchorX + this.center[0];
+        out[1] = this.owner.y - this.owner.anchorY + this.center[1];
+    }
+}
+
+export class RectCollider extends Collider {
+    public rect: engine.Rectangle = new engine.Rectangle();
+
+    constructor(owner: GameObject) {
+        super(owner);
+        this.type = ColliderType.Rect;
+    }
+
+    setData(x: number, y: number, width: number, height: number) {
+        this.rect.x = x;
+        this.rect.y = y;
+        this.rect.width = width;
+        this.rect.height = height;
+        super.setData();
+    }
+
+    getCenter() {
+        return [this.rect.x + this.rect.width / 2, this.rect.y + this.rect.height / 2];
+    }
+    getWorldPosition(out: number[]) {
+        out[0] = this.owner.x - this.owner.anchorX + this.rect.left;
+        out[1] = this.owner.y - this.owner.anchorY + this.rect.top;
+    }
+}
+
+export class PointCollider extends Collider {
+    public center: number[] = [];
+    constructor(owner: GameObject) {
+        super(owner);
+        this.type = ColliderType.Point;
+    }
+
+    setData(x: number, y: number) {
+        this.center[0] = x;
+        this.center[1] = y;
+        super.setData();
+    }
+
+    getCenter() {
+        return this.center;
+    }
+
+    getWorldPosition(out: number[]) {
+        let owner = this.owner;
+        out[0] = this.owner.x + this.center[0];
+        out[1] = this.owner.y + this.center[1];
+    }
+}
+
+export enum ColliderGroup {
+    None = 0,
+    Ball = 1,
+    Bullet = 2,
+    Wall = 3,
+    Ground = 4,
+    Drop = 5,
+    Car = 6,
+    Top = 7
+}
+
+export enum ColliderType {
+    Circle,
+    Rect,
+    Point
+}

src/custom/ShootPlanet/DebugMgr.ts

+/* import GameMgr from "./GameMgr";
+
+export default class DebugMgr extends engine.Container {
+    public enabled: boolean = false;
+    public enabledGraphic: boolean = false;
+    private shapeMap = {};
+    private graphicDebugLayer: engine.Container = null;
+    private uiLayer: engine.UILayer = null;
+    private log: engine.Label = null;
+    public test: any = null;
+
+    public onClick = () => { }
+
+    constructor() {
+        super();
+        if (!this.enabled) return;
+        //创建图形调试层
+        this.graphicDebugLayer = new engine.Container();
+        this.graphicDebugLayer.touchEnabled = false;
+        this.addChild(this.graphicDebugLayer);
+        //创建UI层
+        this.uiLayer = new engine.UILayer();
+        this.uiLayer.touchThrough = true;
+        this.addChild(this.uiLayer);
+        //创建日志标签
+        this.log = new engine.Label("Log");
+        this.log.horizontalCenter = 0;
+        this.log.top = 50;
+        this.log.textColor = 0xffffff;
+        this.log.stroke = 0.5;
+        this.log.size = 32;
+        this.uiLayer.addChild(this.log);
+        //创建调试按钮
+        let button = new engine.Label("调试");
+        button.textColor = 0x000000;
+        button.borderColor = 0x000000;
+        button.border = true;
+        button.top = 30;
+        button.right = 50;
+        this.uiLayer.addChild(button);
+        button.onTap(this, () => {
+            this.onClick();
+        });
+    }
+
+    public setLog(msg: string) {
+        if (!this.enabled) return;
+        this.log.text = msg;
+    }
+
+    public drawRect(rect: engine.Rectangle, style: GraphicDebug.Style = { color: 0xff0000, lineSize: 1 }) {
+        if (!this.enabled || !this.enabledGraphic) return;
+        let shape = new engine.Shape();
+        shape.graphics.lineStyle(style.lineSize, style.color);
+        shape.graphics.drawRect(rect.x, rect.y, rect.width, rect.height);
+        this.graphicDebugLayer.addChild(shape);
+    }
+
+    public drawCircle(x: number, y: number, radius: number, style: GraphicDebug.Style = { color: 0xff0000, lineSize: 1 }) {
+        if (!this.enabled || !this.enabledGraphic) return;
+
+        let shape = new engine.Shape();
+        shape.graphics.lineStyle(style.lineSize, style.color);
+        shape.graphics.drawCircle(x, y, radius);
+        this.graphicDebugLayer.addChild(shape);
+    }
+
+    public drawLine(line: GraphicDebug.Line, style: GraphicDebug.Style = { color: 0xff0000, lineSize: 1 }) {
+        if (!this.enabled || !this.enabledGraphic) return;
+        let shape = new engine.Shape();
+        shape.graphics.lineStyle(style.lineSize, style.color);
+        shape.graphics.moveTo(line.startX, line.startY);
+        shape.graphics.lineTo(line.endX, line.endY);
+        this.graphicDebugLayer.addChild(shape);
+    }
+
+    public updateLine(key: string, line: GraphicDebug.Line, style: GraphicDebug.Style = { color: 0xff0000, lineSize: 1 }) {
+        if (!this.enabled || !this.enabledGraphic) return;
+        let shape: engine.Shape = this.shapeMap[key];
+        if (!shape) {
+            shape = new engine.Shape();
+            this.graphicDebugLayer.addChild(shape);
+            this.shapeMap[key] = shape;
+        }
+
+        shape.graphics.clear();
+        shape.graphics.lineStyle(style.lineSize, style.color);
+        shape.graphics.moveTo(line.startX, line.startY);
+        shape.graphics.lineTo(line.endX, line.endY);
+    }
+
+    public updateRect(key: string, rect: engine.Rectangle, style: GraphicDebug.Style = { color: 0xff0000, lineSize: 1 }) {
+        if (!this.enabled || !this.enabledGraphic) return;
+        let shape: engine.Shape = this.shapeMap[key];
+        if (!shape) {
+            shape = new engine.Shape();
+            this.graphicDebugLayer.addChild(shape);
+            this.shapeMap[key] = shape;
+        }
+
+        shape.graphics.clear();
+        shape.graphics.lineStyle(style.lineSize, style.color);
+        shape.graphics.drawRect(rect.x, rect.y, rect.width, rect.height);
+    }
+
+    public updateCircle(key: string, x: number, y: number, radius: number, style: GraphicDebug.Style = { color: 0xff0000, lineSize: 1 }) {
+        if (!this.enabled || !this.enabledGraphic) return;
+        let shape: engine.Shape = this.shapeMap[key];
+        if (!shape) {
+            shape = new engine.Shape();
+            this.graphicDebugLayer.addChild(shape);
+            this.shapeMap[key] = shape;
+        }
+
+        shape.graphics.clear();
+        shape.graphics.lineStyle(style.lineSize, style.color);
+        shape.graphics.drawCircle(x, y, radius);
+    }
+
+    public clearShape(key: string) {
+        if (!this.enabled || !this.enabledGraphic) return;
+        let shape: engine.Shape = this.shapeMap[key];
+        if (!shape) {
+            console.warn("collider is nonexistent");
+            return;
+        }
+
+        delete this.shapeMap[key];
+        shape.destroy();
+    }
+
+    private static _instance: DebugMgr = null;
+    public static get instance(): DebugMgr {
+        if (!this._instance) {
+            if (engine.gameStage) {
+                this._instance = new DebugMgr();
+                engine.gameStage.addChild(this._instance);
+            } else {
+                console.error("stage is null,DebugMgr can not instantiate");
+            }
+        }
+
+        return this._instance;
+    }
+}
+
+export namespace GraphicDebug {
+    export interface Style {
+        color: number;
+        lineSize: number;
+    }
+    export interface Line {
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+    }
+}
+
+
+ */
\ No newline at end of file

src/custom/ShootPlanet/Drop.ts

+import MoveObjcet from "./MoveObject";
+import { MConfigs } from "./MConfigs";
+import Collider, { ColliderGroup, PointCollider } from "./Collider";
+import MTweenMgr from "./MTween";
+import SoundMgr from "./SoundMgr";
+import DropBlinkMgr from "./DropBlinkMgr";
+import Game from "./Game";
+
+export default class Drop extends MoveObjcet {
+    private type: string = null;
+    private label: engine.Label = null;
+    public bitmap: engine.Image = null;
+    private scoreValue: number = null;
+    private collider: PointCollider = null;
+    private isGround: boolean = false;
+    private stayGroundCount = 0;
+
+    constructor(context: Game) {
+        super(context);
+        //图像
+        let bitmap = new engine.Image();
+        this.addChild(bitmap);
+        this.bitmap = bitmap;
+
+        //文字
+        let label = new engine.Label();
+        label.size = 24;
+        this.addChild(label);
+        this.label = label;
+        this.collider = this.addComponent<PointCollider>(PointCollider);
+        this.collider.group = ColliderGroup.Drop;
+    }
+
+    init(id: number) {
+        let config: {
+            type: string,
+            value: number,
+            textColor: number,
+            fileIndex: string
+        } = MConfigs.drop[id];
+
+        this.type = config.type;
+        this.scoreValue = config.value;
+        this.physics.acceleration.y = 0.3;
+
+        let texture = RES.getRes(`drop_${config.type}_${config.fileIndex}_png`) as engine.Texture;
+        this.bitmap.texture = texture;
+
+        let str = "+" + config.value;
+        if (config.type == "power") str = str + "%";
+        let label = this.label;
+        label.text = str;
+        label.fillColor = config.textColor;
+        label.visible = false;
+        label.x = texture.width + 2;
+        label.y = texture.height / 2 - label.height / 2;
+
+        this.collider.setData(texture.width / 2, texture.height / 2);
+        return this;
+    }
+
+    private eated() {
+        SoundMgr.instance.playEffect("collect_mp3");
+        this.physics.rotateVelocity = 0;
+        DropBlinkMgr.instance.remove(this);
+        this.visible = true;
+        this.rotation = 0;
+        this.physics.enabled = false;
+        this.getComponent(PointCollider).enabled = false;
+        this.label.visible = true;
+        if (this.type == "bullet") {
+            this.context._BulletScore += this.scoreValue;
+        } else if (this.type == "power") {
+            this.context._PowerScore += this.scoreValue;
+        }
+
+        MTweenMgr.instance.removeTweens(this);
+        MTweenMgr.instance.get(this)
+            .to({ y: this.y - 200, alpha: 0 }, 1000, false)
+            .call(() => {
+                this.context._dropPool.destroy(this);
+            });
+    }
+
+    onCollisionEnter(other: Collider) {
+        if (other.group == ColliderGroup.Car) {
+            this.eated();
+        }
+
+        if (other.group == ColliderGroup.Ground && !this.isGround) {
+            this.stayGroundCount = 0;
+            this.physics.velocity.y = -(this.physics.velocity.y * 0.4);
+        }
+
+        if (other.group == ColliderGroup.Wall) {
+            this.physics.velocity.x = - this.physics.velocity.x;
+            if (this.isGround) {
+                this.physics.rotateVelocity = -this.physics.rotateVelocity
+            }
+        }
+    }
+
+    onCollisionStay(other: Collider) {
+        if (other.group == ColliderGroup.Ground && !this.isGround) {
+            this.stayGroundCount++;
+            if (this.stayGroundCount > 2) {
+                this.isGround = true;
+                this.physics.velocity.y = 0;
+                this.physics.acceleration.y = 0;
+                this.physics.velocity.x *= 0.5;
+                DropBlinkMgr.instance.add(this);
+
+                this.physics.rotateVelocity = this.physics.velocity.x * (180 / (Math.PI * 13));
+            }
+        }
+    }
+
+    onCollisionExit(other: Collider) {
+        if (other.group == ColliderGroup.Ground) {
+            this.stayGroundCount = 0;
+        }
+    }
+
+    /* destroy() {
+        DropBlinkMgr.instance.remove(this);
+        super.destroy();
+    } */
+
+    /* onElementInit() {
+        this.alpha = 1;
+        this.visible = true;
+        this.stayGroundCount = 0;
+        this.isGround = false;
+        this.enableAllComponents();
+    }
+
+    onElementRecycle() {
+        this.visible = false;
+        this.disableAllComponents();
+    } */
+}
\ No newline at end of file

src/custom/ShootPlanet/DropBlinkMgr.ts

+import Drop from "./Drop";
+import { arrayRemove } from "./GUtils";
+
+export default class DropBlinkMgr {
+    private static _instance: DropBlinkMgr = null;
+    public static get instance(): DropBlinkMgr {
+        if (!this._instance) {
+            this._instance = new DropBlinkMgr();
+        }
+
+        return this._instance;
+    }
+
+    private list: {
+        drop: Drop,
+        count: number
+    }[] = [];
+    public add(drop: Drop) {
+        this.list.push({
+            drop: drop,
+            count: 0
+        });
+    }
+    public remove(drop: Drop) {
+        this.list = this.list.filter(e => e.drop !== drop);
+    }
+
+    public static init() {
+        engine.gameStage.addEventListener(engine.Event.ENTER_FRAME, DropBlinkMgr.instance.onUpdate, DropBlinkMgr.instance);
+    }
+
+    private frameTimer: number = 0;
+
+    public onUpdate() {
+        if (this.frameTimer % BlinkDuration == 0) {
+            let temp: {
+                drop: Drop,
+                count: number
+            } = null;
+            for (let i in this.list) {
+                temp = this.list[i];
+                temp.drop.visible = !temp.drop.visible;
+                temp.count++;
+            }
+            this.list = this.list.filter(e => {
+                if (e.count < 60 / BlinkDuration * 2) {
+                    return true;
+                } else {
+                    e.drop.destroy();
+                    return false;
+                }
+
+            });
+        }
+        this.frameTimer++;
+    }
+}
+
+const BlinkDuration = 3;
\ No newline at end of file

src/custom/ShootPlanet/GUtils.ts

+import { MUtils } from "./MUtils";
+import { MConst } from "./MConst";
+import { MConfigs } from "./MConfigs";
+import Net from "./Net";
+import { NetUtils } from "./NetUtils";
+
+export const getResPath = () => window['resPath'] || '';
+export const getSkinPath = (key: any) => `resource/skins/${key}Skin.exml`
+
+let shareImg: HTMLElement = null;
+export function setShareImg(imgUrl: string, rect: engine.Rectangle, visible: boolean = true) {
+    shareImg = shareImg || document.getElementById('shareImg');
+    shareImg.style.position = 'absolute';
+    shareImg.style.display = 'block';
+    shareImg.style.visibility = "visible";
+    shareImg.style.opacity = visible ? "1" : "0";
+    let scaler = document.body.clientWidth / 750;
+    shareImg.style.width = (scaler * rect.width).toString() + "px";
+    shareImg.style.height = (scaler * rect.height).toString() + "px";
+    shareImg.style.left = (rect.x * scaler).toString() + "px";
+    shareImg.style.top = (rect.y * scaler).toString() + "px";
+    shareImg['src'] = imgUrl;
+}
+export function clearShareImg() {
+    if (!shareImg) {
+        console.log("shareImg is null");
+        return;
+    }
+
+    shareImg.style.width = "0px";
+    shareImg.style.height = "0px";
+    shareImg.style.visibility = "hidden";
+}
+
+export function getBallScore(bulletScore: number, powerScore: number, colorIndex: number): any {
+    let getScoreFromRange = ([a, b]) => {
+        a = Math.ceil(a * MConfigs.difficultyFactor);
+        b = Math.ceil(b) * MConfigs.difficultyFactor;
+        let n = Math.abs(b - a) + 1;
+        n = Math.floor(n / 6);
+        const m = [];
+        for (let i = 0; i < 5; i++) {
+            m.push([a + n * i, a + n * i + n - 1]);
+        }
+        m.push([a + n * 4 + n, b])
+        const [a0, b0] = m[colorIndex]; //1-10
+        let result = Math.ceil(Math.random() * (b0 - a0 + 1)) + a0
+        return result;
+    }
+
+    if (bulletScore <= 20)
+        return getScoreFromRange([0.01 * powerScore, 0.2 * powerScore]);
+
+    if (bulletScore > 20 && bulletScore <= 40) {
+        return getScoreFromRange([0.2 * powerScore, 0.6 * powerScore]);
+    }
+
+    let getRange = (list: any[], props: any[]) => {
+        return getScoreFromRange(getProp(list, props)[0]);
+    }
+
+    if (bulletScore > 40 && bulletScore <= 60) {
+        const list = [
+            [0.2 * powerScore, 0.6 * powerScore],
+            [0.6 * powerScore, 0.8 * powerScore],
+            [0.8 * powerScore, 1.5 * powerScore],
+        ]
+        return getRange(list, [3, 5, 2]);
+    }
+    if (bulletScore > 60 && bulletScore <= 80) {
+        const list = [
+            [0.6 * powerScore, 0.8 * powerScore],
+            [0.8 * powerScore, 1.5 * powerScore],
+            [1.5 * powerScore, 2.2 * powerScore],
+        ]
+        return getRange(list, [2, 5, 2]);
+    }
+
+    if (bulletScore > 80 && bulletScore <= 100) {
+        const list = [
+            [1.5 * powerScore, 2.2 * powerScore],
+            [2.2 * powerScore, 3.2 * powerScore],
+            [3.2 * powerScore, 4.2 * powerScore],
+        ]
+        return getRange(list, [1, 5, 4]);
+    }
+
+    if (bulletScore > 100 && bulletScore <= 120) {
+        const list = [
+            [2.2 * powerScore, 3.2 * powerScore],
+            [3.2 * powerScore, 4.2 * powerScore],
+            [4.2 * powerScore, 5.2 * powerScore],
+        ]
+        return getRange(list, [1, 4, 5]);
+    }
+
+    const list = [
+        [2.2 * powerScore, 3.2 * powerScore],
+        [3.2 * powerScore, 4.2 * powerScore],
+        [4.2 * powerScore, 5.2 * powerScore],
+    ]
+    return getRange(list, [1, 3, 6]);
+}
+
+export function getProp(items: any[], props: number[], n = 1) {
+    let pool = [];
+    for (let i in items) {
+        for (let j = 0; j < props[i]; j++) {
+            pool.push(items[i]);
+        }
+
+    }
+
+    const result = [];
+    for (let i = 0; i < n; i++) {
+        result.push(pool[MUtils.randomInt(0, pool.length)]);
+    }
+    return result;
+}
+
+
+export function createPropsCard(id: string): engine.Container {
+    let bgUrl = "score_card_bg_png";
+    if (id == MConst.ReviveCardId) {
+        bgUrl = "revive_card_bg_png"
+    }
+
+    let group = new engine.Container();
+    group.addChild(new engine.Image(RES.getRes(bgUrl)));
+    let label = new engine.Label();
+    label.text = MConfigs.props[id].name;
+    label.fillColor = 0x0a703e;
+    label.size = 24;
+    label.offsetX = 0;
+    label.offsetY = 0;
+    group.addChild(label);
+
+    return group;
+}
+
+export function getPropsTypeName(type: 0 | 1): string {
+    switch (type) {
+        case 0: return "原地复活卡";
+        case 1: return "加分卡";
+        default: return null;
+    }
+}
+
+export function restart() {
+}
+
+export function arrayRemove(array: any[], target: any): any[] {
+    let newArray = [];
+    for (let i = 0; i < array.length; i++) {
+        if (array[i] !== target) {
+            newArray.push(array[i]);
+        }
+    }
+    return newArray;
+}
+
+export function isWeiXin() {
+    var ua = navigator.userAgent.toLowerCase();
+    if (ua.match(/MicroMessenger/i)) {
+        return true
+    } else {
+        return false
+    }
+}
+
+export function wxConfig(): Promise<void> {
+    return new Promise<void>(resolve => {
+        Net.sendGet("/wechatShare/getShareInfo/v2", {
+            wxdebug: false,
+            url: window.location.href
+        }, (res) => {
+            wx.config({
+                debug: false,
+                appId: res.wxappid,
+                timestamp: res.wxtimestamp,
+                nonceStr: res.wxnonceStr,
+                signature: res.wxsignature,
+                jsApiList: ['checkJsApi', 'onMenuShareTimeline', 'onMenuShareAppMessage']
+            });
+
+            wx.error(function (res: any) {
+                console.error("wx error", res);
+            });
+
+            wx.ready(function () {
+                resolve();
+            });
+        }, () => { resolve(); });
+    });
+}
+
+export function invokeWX(onSuccess?: () => void, onCancel?: () => void) {
+    let share = window["shareData"];
+    wx.onMenuShareTimeline({
+        title: share.title,
+        desc: share.desc,
+        link: share.url + NetUtils.getProjectId(),
+        imgUrl: share.imgUrl,
+        success: function () {
+            onSuccess && onSuccess();
+        },
+        cancel: function () {
+            onCancel && onCancel();
+        }
+    });
+
+    wx.onMenuShareAppMessage({
+        title: share.title,
+        desc: share.desc,
+        link: share.url + NetUtils.getProjectId(),
+        imgUrl: share.imgUrl,
+        success: function () {
+            onSuccess && onSuccess();
+        },
+        cancel: function () {
+            onCancel && onCancel();
+        }
+    });
+}
+
+
+export function getAppLocation() {
+    return new Promise<engine.Point>((resolve, reject) => {
+        window["getClientLocation"] = function (latitudeC: number, longitudeC: number) {
+            resolve(new engine.Point(longitudeC, latitudeC));
+        };
+
+        setTimeout(() => {
+            resolve(null);
+        }, 1000);
+        window["App"].getLocation();
+    });
+}
+
+export function getCookie(cookieName: string) {
+    var strCookie = document.cookie;
+    var arrCookie = strCookie.split("; ");
+    for (var i = 0; i < arrCookie.length; i++) {
+        var arr = arrCookie[i].split("=");
+        if (cookieName == arr[0]) {
+            return arr[1];
+        }
+    }
+    return "";
+}
+
+
+export function login() {
+    return new Promise<void>((resolve, reject) => {
+        Net.sendGet(`/ctool/getProjectUserInfo`, undefined, (res) => {
+            window["$"]("body").append(res.data.loginJs);
+            if (window['requirelogin']) {
+                window['requirelogin']();
+                resolve();
+            } else {
+                reject("no function requirelogin");
+            }
+        }, () => {
+            reject();
+        });
+    })
+}
+
+
+
+

src/custom/ShootPlanet/GameComponent.ts

+import GameObject from "./GameObject";
+
+export default abstract class GameComponent {
+    public get enabled(): boolean {
+        return this._enabled;
+    }
+    public set enabled(v: boolean) {
+        if (v == true && this._enabled == false) {
+            this.onEnabled();
+            this._enabled = v;
+        } else if (v == false && this._enabled == true) {
+            this.onDisabled();
+            this._enabled = v;
+        }
+    }
+    private _enabled: boolean = false;
+
+    public get owner(): GameObject {
+        return this._owner;
+    }
+    private _owner: GameObject = null;
+    constructor(owner: GameObject) {
+        this._owner = owner;
+    }
+
+    protected abstract onEnabled(): void;
+    protected abstract onDisabled(): void;
+}
\ No newline at end of file

src/custom/ShootPlanet/GameMgr.ts

+import PoolMgr from "./PoolMgr";
+import Ball from "./Ball";
+import PhycicsSystem from "./PhycicsSystem";
+import MTweenMgr from "./MTween";
+import SoundMgr from "./SoundMgr";
+import { MConfigs } from "./MConfigs";
+import GuideMask from "./GuideMask";
+import SceneCtrl from "./MSceneCtrl";
+
+
+export default class GameMgr {
+    private static _instance: GameMgr = null;
+    public static get instance(): GameMgr {
+        if (!this._instance) {
+            this._instance = new GameMgr();
+        }
+
+        return this._instance;
+    }
+
+    public t: number = 0;
+    public dropNum: number = 0;
+
+    private mainScene: MainScene = null;
+    init(mainScene: MainScene) {
+        this.mainScene = mainScene;
+    }
+
+    public switchSound() {
+        SoundMgr.instance.musicEnabled = !SoundMgr.instance.musicEnabled;
+        SoundMgr.instance.effectEnabled = !SoundMgr.instance.effectEnabled;
+    }
+
+    public get guideFlag(): boolean {
+        return localStorage.getItem("guide") != "false";
+    }
+    public set guideFlag(v: boolean) {
+        localStorage.setItem("guide", v ? "true" : "false");
+    }
+    private currentGuideMask: GuideMask = null;
+    public runGuide(index: number, x: number, y: number, end: boolean = false) {
+        this.mainScene.game.pause = true;
+        this.currentGuideMask = new GuideMask(index, x, y);
+        this.currentGuideMask.onClick = () => {
+            this.currentGuideMask && this.currentGuideMask.destroy();
+            this.mainScene.game.pause = false;
+
+            if (end) {
+                this.guideFlag = false;
+            }
+        };
+        SceneCtrl.instance.parent.addChild(this.currentGuideMask);
+    }
+
+    public minEnableCaptchaScore: number = null;
+    public leftTimes: number = null;
+    public leftShareTimes: number = null;
+    public allPeriodEnd: number = null;
+
+    public isWenzhouUser: boolean = false;
+}
\ No newline at end of file

src/custom/ShootPlanet/GameObject.ts

+
+import GameComponent from "./GameComponent";
+import { MUtils } from "./MUtils";
+import Collider from "./Collider";
+import Game from "./Game";
+
+export default class GameObject extends engine.Container {
+    public name: string = "";
+    private _position: engine.Point = new engine.Point();
+    public get position() {
+        this._position.x = this.x;
+        this._position.y = this.y;
+        return this._position;
+    }
+
+    public addComponent<T extends GameComponent>(cls: any): T {
+        if (this.getComponent(cls) != null) {
+            console.error("component is existent");
+            return;
+        }
+        let ins = new cls(this);
+        ins.enabled = true;
+        this.componentList.push(ins);
+        return ins;
+    }
+
+    public getComponent<T extends GameComponent>(cls: any): T {
+        for (let i of this.componentList) {
+            if (i instanceof cls) {
+                return i as T;
+            }
+        }
+        return null;
+    }
+
+    public removeComponent(cls: any) {
+        for (let i of this.componentList) {
+            if (i instanceof cls) {
+                i.enabled = false;
+                this.componentList = this.componentList.filter(e => e != i);
+                return;
+            }
+        }
+    }
+
+    private componentList: GameComponent[] = [];
+    protected context: Game = null;
+
+    constructor(context?: Game) {
+        super();
+        this.anchorX = 0.5;
+        this.anchorY = 0.5;
+        this.context = context;
+        this.touchEnabled = false;
+        this.touchChildren = false;
+
+        this.addEventListener(engine.Event.REMOVED_FROM_STAGE, this.disableAllComponents, this);
+    }
+
+    /**锚点X轴 */
+    public get anchorX(): number {
+        return this._anchorX;
+    }
+    public set anchorX(v: number) {
+        this._anchorX = Math.clamp(v, 0, 1);
+    }
+    private _anchorX: number = 0;
+
+    /**锚点Y轴 */
+    public get anchorY(): number {
+        return this._anchorY;
+    }
+    public set anchorY(v: number) {
+        this._anchorY = Math.clamp(v, 0, 1);
+    }
+    private _anchorY: number = 0;
+
+    public get posX(): number {
+        return this.x + this.width * this.scaleX * this.anchorX;
+    }
+    public set posX(v: number) {
+        this.x = v - this.width * this.scaleX * this.anchorX;
+    }
+
+    public get posY(): number {
+        return this.y + this.height * this.scaleY * this.anchorY;
+    }
+    public set posY(v: number) {
+        this.y = v - this.height * this.scaleY * this.anchorY;
+    }
+
+    protected disableAllComponents() {
+        Object.keys(this.componentList).forEach(e => this.componentList[e].enabled = false);
+    }
+
+    protected enableAllComponents() {
+        Object.keys(this.componentList).forEach(e => this.componentList[e].enabled = true);
+    }
+
+    public onCollisionEnter(other: Collider) {
+
+    }
+
+    public onCollisionStay(other: Collider) {
+
+    }
+
+    public onCollisionExit(other: Collider) {
+
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/MConfigs.ts

+// export const MConfigs: any = window;
+export namespace MConfigs {
+    export function updateConfig() {
+        let mconfig = window["mconfig"];
+        if (typeof mconfig != "object") return;
+
+        Object.keys(mconfig).forEach(e => {
+            MConfigs[e] = mconfig[e];
+        });
+    }
+
+    export const appId = "123";
+
+    export const size = [0.3125, 0.5357, 0.7321, 1];
+    export const drop = {
+        0: {
+            type: "bullet",
+            value: 1,
+            textColor: 0x5dcefa,
+            fileIndex: "0"
+        },
+        1: {
+            type: "bullet",
+            value: 2,
+            textColor: 0x69e7fc,
+            fileIndex: "1"
+        },
+        2: {
+            type: "power",
+            value: 30,
+            textColor: 0xe83cf7,
+            fileIndex: "2"
+        },
+        3: {
+            type: "power",
+            value: 20,
+            textColor: 0xeb3924,
+            fileIndex: "1"
+        },
+        4: {
+            type: "power",
+            value: 10,
+            textColor: 0xfef552,
+            fileIndex: "0"
+        }
+    }
+
+    export const dropPool = {
+        0: {
+            num: 3,
+            factor: {
+                0: 40,
+                1: 0,
+                2: 0,
+                3: 15,
+                4: 50
+            }
+        },
+        1: {
+            num: 2,
+            factor: {
+                0: 40,
+                1: 0,
+                2: 5,
+                3: 15,
+                4: 50
+            }
+        },
+        2: {
+            num: 1,
+            factor: {
+                0: 40,
+                1: 0,
+                2: 5,
+                3: 15,
+                4: 50
+            }
+        }
+    }
+
+    export const props: {
+        [key: string]: {
+            id: string,
+            type: 0 | 1
+            value: number,
+            name: string
+        }
+    } = {
+        "sp_1": {
+            id: "sp_1",
+            type: 0,
+            value: null,
+            name: "复活卡"
+        },
+        "sp_2": {
+            id: "sp_2",
+            type: 1,
+            value: 100,
+            name: "1万分"
+        },
+        "sp_3": {
+            id: "sp_3",
+            type: 1,
+            value: 200,
+            name: "2万分"
+        },
+        "sp_4": {
+            id: "sp_4",
+            type: 1,
+            value: 300,
+            name: "3万分"
+        },
+        "sp_5": {
+            id: "sp_5",
+            type: 1,
+            value: 600,
+            name: "6万分"
+        },
+        "sp_6": {
+            id: "sp_6",
+            type: 1,
+            value: 800,
+            name: "8万分"
+        }
+    }
+
+    export const boomEffectColor = [
+        0xe41014,
+        0xff9600,
+        0x0090ff,
+        0x8aff00,
+        0xffe720
+    ]
+
+    /**倒计时秒数 */
+    export const countDown = 300;
+
+    /**毫秒 */
+    export const GameOverPanelStayTime = 60000;
+
+    export const rewardList = [
+        {
+            rank: 1,
+            url: ""
+        },
+        {
+            rank: 2,
+            url: ""
+        },
+        {
+            rank: 3,
+            url: ""
+        },
+        {
+            rank: 4,
+            url: ""
+        },
+        {
+            rank: 5,
+            url: ""
+        }
+    ]
+
+    export const guide: {
+        [key: number]: {
+            mask: string,
+            text: {
+                str: string,
+                offsetToMask: {
+                    x: number,
+                    y: number
+                }
+            }
+        }
+    } = {
+        0: {
+            mask: "guide_mask_0_png",
+            text: {
+                str: "左右移动炮车进行射击和躲避",
+                offsetToMask: {
+                    x: 41,
+                    y: 240
+                }
+            }
+        },
+        1: {
+            mask: "guide_mask_1_png",
+            text: {
+                str: "拾取金币可获得更多的炮弹输出和得分加成",
+                offsetToMask: {
+                    x: 41,
+                    y: 394
+                }
+            }
+        },
+    }
+
+    export const difficultyFactor = 0.1;
+
+    export const lastRankListType = "20191104";
+
+    export const rewardRecordUrl = "http://activity.m.duibatest.com.cn/projectx/p98a3fa4c/f09ba186f.html";
+
+    export const onlineDate = "2019-10-31 14:50:49:123";
+
+    export const urlMore = "http://www.baidu.com"
+
+    export const wxRule = `结构一节将帮助你了解常见库的格式以及如何为每种格式
+书写正确的声明文件。 如果你在编辑一个已经存在的文件，那么你可能不需要阅读此章节。 如果你在书写新的声明
+文件，那么你必须阅读此章节以理解库的不同格式是如何影响声明文件的书写的。
+结构一节将帮助你了解常见库的格式以及如何为每种格式书写正确的声明文件。 如果你在
+编辑一个已经存在的文件，那么你可能不需要阅读此
+章节。 如果你在书写新的声明文件，那么你必须阅读此章节以理解库的不同格式是如何影响
+声明文件的书写的。`;
+
+    export const appRule = `结构一节将帮助你了解常见库的格式以及如何为每种格式
+书写正确的声明文件。 如果你在编辑一个已经存在的文件，那么你可能不需要阅读此章节。 如果你在书写新的声明
+文件，那么你必须阅读此章节以理解库的不同格式是如何影响声明文件的书写的。
+结构一节将帮助你了解常见库的格式以及如何为每种格式书写正确的声明文件。 如果你在
+编辑一个已经存在的文件，那么你可能不需要阅读此
+章节。 如果你在书写新的声明文件，那么你必须阅读此章节以理解库的不同格式是如何影响
+声明文件的书写的。`
+
+    export const share = {
+        title: "分享标题",
+        desc: "分享描述",
+        imgUrl: "http://duiba.oss-cn-hangzhou.aliyuncs.com/db_games/activity/zhaohang_bill_2019/share.png",
+        url: "http://activity-2.m.duiba.com.cn/customShare/share?id=3651"
+    }
+
+    export const toAppUrl = "http://www.baidu.com"
+
+    export const wxMoreUrl="http://www.baidu.com"
+}
+
+
+
+
+
+

src/custom/ShootPlanet/MConst.ts

+export namespace MConst {
+    export const MaxColorIndex = 5;
+    export const DesignResolution = {
+        x: 750,
+        y: 1624
+    };
+
+    export const GroundLine = 1110;
+    export const BulletSpeedValue = 20;
+    export const BulletFireSpeed = {
+        min: 10,
+        max: 20
+    }
+    export const Gravity = 0.15;
+    export const BallVelocityX = 2;
+    export const BallVelocityY = 11;
+    export const BallSplitVelocityY = 6.8;
+    export const DropVelocityX = {
+        x: 2,
+        offset: 0.5
+    }
+    export const BallRotateSpeed = 0.7;
+    export const BulletWidth = 14;
+    export const BulletDisperseFrameNum = 4;
+    export const BallInitPosY = 1206 * 0.25;
+    export const CreateBallInterval = 1000;
+    export const ReviveCardId = "sp_1";
+
+    export const ConstantSubmitScoreNum = 30000;
+    export const DefaultBallWidth = 224;
+    export const DefaultRingWidth = 672 * 0.744;
+    export const DefaultStarSize = {
+        width: 76 * 0.744,
+        height: 72 * 0.744
+    };
+
+    export const captchaId = "a869bfdfb9bd4cdf88e1ff2f8667a114";
+
+    export const BallVelocityXRandomFactor = 0.1;
+    export const BallVelocityYRandomFactor = 0.08;
+    export const DropRandomFactor = 0.07;
+    /**
+     * 单位：秒
+     */
+    export const ReviveInvincibleDuration = 3;
+
+    export const WenzhouLocation: engine.Rectangle = new engine.Rectangle(119.37, 27.03, 1.81, 1.33);
+    export const HangzhouLocation: engine.Rectangle = new engine.Rectangle(118.21, 29.11, 2.09, 1.22);
+}
\ No newline at end of file

src/custom/ShootPlanet/MTimer.ts

+const DefaultDtFactor = 60 / 1000;
+
+export default class MTimer {
+    private static onFrameList: ((dt: number, self: Function) => void)[] = [];
+    private static timerList: ((self: Function) => void)[] = [];
+
+    public static deltaTime: number = 0;
+    public static get dtFactor() {
+        return MTimer.deltaTime * DefaultDtFactor;
+    }
+
+    public static init() {
+        engine.gameStage.addEventListener(engine.Event.ENTER_FRAME, () => {
+            for (let i = 0; i < MTimer.onFrameList.length; i++) {
+                MTimer.onFrameList[i](MTimer.deltaTime, MTimer.onFrameList[i]);
+            }
+
+            for (let i = 0; i < MTimer.timerList.length; i++) {
+                MTimer.timerList[i](MTimer.timerList[i]);
+            }
+        }, MTimer);
+    }
+
+    private static removeOnFrame(callback: Function) {
+        MTimer.onFrameList = MTimer.onFrameList.filter(e => e != callback);
+    }
+
+    public static set(frame: number, onTimeOut: () => void) {
+        let count = 0;
+        MTimer.timerList.push((self: Function) => {
+            count += MTimer.dtFactor;
+            if (count >= frame) {
+                onTimeOut();
+                MTimer.timerList = MTimer.timerList.filter(e => e != self);
+            }
+        });
+    }
+
+    public static onFrame(callback: (deltaTime: number, remove?: () => void) => void, frameCount?: number) {
+        if (typeof frameCount != "undefined") {
+            let count = 0;
+            MTimer.onFrameList.push((deltaTime: number, self: Function) => {
+                callback(deltaTime);
+                count += MTimer.dtFactor;
+                if (count >= frameCount) {
+                    MTimer.removeOnFrame(self);
+                }
+            });
+        } else {
+            MTimer.onFrameList.push((deltaTime: number, self: Function) => {
+                callback(deltaTime, () => {
+                    MTimer.removeOnFrame(self);
+                });
+            });
+        }
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/MTween.ts

+import { MUtils } from "./MUtils";
+import MTimer from "./MTimer";
+
+class MTween {
+    public static readonly frameRate = 60;
+    private tweenList: MTweenBase[] = [];
+    public currentTween: MTweenBase = null;
+    public target: object = null
+
+    constructor(target: object) {
+        this.target = target;
+    }
+
+    public wait(duration: number, isFrameCount = true, callback?: () => void) {
+        this.addTween(new WaitTween(isFrameCount ? duration : this.toFrameRate(duration), this, callback));
+        return this;
+    }
+
+    private addTween(tween: MTweenBase) {
+        if (this.currentTween == null) {
+            this.currentTween = tween;
+        } else {
+            this.tweenList.push(tween);
+        }
+    }
+
+    public to(props: object, duration: number, isFrameCount = true) {
+        this.addTween(new LinearTween(props, isFrameCount ? duration : this.toFrameRate(duration), this));
+        return this;
+    }
+
+    public call(callback: () => void) {
+        this.addTween(new CallbackTween(callback, 0, this));
+        return this;
+    }
+
+    private toFrameRate(duration: number) {
+        return duration / 1000 * MTween.frameRate;
+    }
+
+    public update() {
+        if (!this.currentTween) return;
+
+        this.currentTween.apply(MTimer.dtFactor);
+        if (this.currentTween.frameCount <= 0) {
+            if (this.tweenList.length > 0) {
+                this.currentTween = this.tweenList.shift();
+            } else {
+                this.currentTween = null;
+            }
+        }
+    }
+}
+
+abstract class MTweenBase {
+    private started = false;
+    public frameCount: number = 0;
+    protected tweenObjet: MTween = null;
+    constructor(frameCount: number, tweenObject: MTween) {
+        this.tweenObjet = tweenObject;
+        this.frameCount = frameCount;
+    }
+
+    protected start() { }
+    public apply(dtFactor?: number) {
+        if (this.started == false) {
+            this.start();
+            this.started = true;
+        }
+
+        this.frameCount--;
+    }
+}
+
+class LinearTween extends MTweenBase {
+    private once: object = null;
+
+    constructor(props: object, frameCount: number, tweenObject: MTween) {
+        super(frameCount, tweenObject);
+        this.once = props;
+    }
+
+    public start() {
+        Object.keys(this.once).forEach(key => {
+            this.getOnceValue(this.once, key, this.once[key]);
+        });
+    }
+
+    private getOnceValue(props: object, key: string, value: number) {
+        if (typeof value == "undefined" || value == null) return props[key] = value;
+
+        if (this.frameCount == 0) {
+            return props[key] = value;
+        } else {
+            if (typeof this.tweenObjet.target[key] == "number") {
+                let delta = value - this.tweenObjet.target[key];
+                let once = delta / this.frameCount;
+                props[key] = once;
+            } else {
+                console.error("prop is not number");
+                delete props[key];
+            }
+        }
+    }
+
+    public apply(dtFactor: number) {
+        super.apply(dtFactor);
+        Object.keys(this.once).forEach(key => {
+            this.tweenObjet.target[key] += this.once[key] * dtFactor;
+        });
+    }
+}
+
+class WaitTween extends MTweenBase {
+    private callback: () => void = null;
+    constructor(frameCount: number, tweenObject: MTween, callback?: () => void) {
+        super(frameCount, tweenObject);
+        this.callback = callback;
+    }
+
+    apply() {
+        super.apply();
+        this.callback && this.callback();
+    }
+}
+
+class CallbackTween extends MTweenBase {
+    private callback: () => void = null;
+    constructor(callback: () => void, frameCount: number, tweenObject: MTween) {
+        super(frameCount, tweenObject);
+        this.callback = callback;
+    }
+
+    public start() {
+        this.callback();
+        this.callback = null;
+    }
+}
+
+export default class MTweenMgr {
+    public pause: boolean = false;
+    private static _instance: MTweenMgr = null;
+    public static get instance(): MTweenMgr {
+        if (!this._instance) {
+            this._instance = new MTweenMgr();
+        }
+
+        return this._instance;
+    }
+
+    private tweenObjectList: MTween[] = [];
+
+    private removeQueue: any[] = [];
+    private isTraversing = false;
+
+    public init() {
+        // engine.startTick(this.update, this);
+        engine.gameStage.addEventListener(engine.Event.ENTER_FRAME, this.update, this);
+    }
+
+    public removeTweens(target: object) {
+        if (this.isTraversing) {
+            this.removeQueue.push(target);
+        } else {
+            this.tweenObjectList = this.tweenObjectList.filter(e => e.target !== target);
+        }
+    }
+
+    public get(target: object) {
+        let tween = new MTween(target);
+        this.tweenObjectList.push(tween);
+        return tween;
+    }
+
+    private update() {
+        if (this.pause) return;
+
+        this.isTraversing = true;
+        for (let i = 0; i <= this.tweenObjectList.length - 1; i++) {
+            this.tweenObjectList[i].update();
+        }
+        this.isTraversing = false;
+
+        this.tweenObjectList = this.tweenObjectList.filter((tween) => {
+            if (tween.currentTween == null) return false;
+
+            for (let removeTarget of this.removeQueue) {
+                if (removeTarget === tween.target) {
+                    return false;
+                }
+            }
+
+            return true;
+        });
+
+        this.removeQueue = [];
+
+        return false;
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/MUtils.ts

+export namespace MUtils {
+    /**左闭右开 */
+    export function random(min: number, max: number) {
+        return Math.random() * (max - min) + min;
+    }
+
+    /**左闭右开 */
+    export function randomInt(min: number, max: number) {
+        return Math.floor(Math.random() * (max - min) + min);
+    }
+
+    export function toRadians(degrees: number) {
+        return degrees / 180 * Math.PI;
+    }
+
+    export function toDegress(radians: number) {
+        return radians / Math.PI * 180;
+    }
+
+    export function degreesAngelAdd(a: number, b: number) {
+        return (a + b) % 360;
+    }
+
+    export function dot(vec1: engine.Point, vec2: engine.Point): number {
+        return vec1.x * vec2.x + vec1.y * vec2.y;
+    }
+
+    export function getAngle(point: engine.Point) {
+        let radians = Math.acos(point.x / point.length);
+        radians = point.y > 0 ? radians : -radians;
+        return toDegress(radians);
+    }
+
+    /**
+     * 根据角度创建单位向量
+     * @param angle 角度制的角度
+     */
+    export function getVector(angle: number) {
+        angle = toRadians(angle);
+        return new engine.Point(Math.cos(angle), Math.sin(angle));
+    }
+
+    export function stringOverEllipsis(str: string, limit: number) {
+        if (str.length > limit) {
+            return str.substring(0, limit) + "...";
+        } else {
+            return str;
+        }
+    }
+
+    export function getClassName(cls: any) {
+        return cls["prototype"]["constructor"]["name"];
+    }
+
+    export function getInstanceClassName(instance: any) {
+        return getClassName(instance["constructor"]);
+    }
+
+    export function setColorFilter(image: engine.DisplayObject, color: number) {
+        //TODO 颜色滤镜实现
+        // 将16进制颜色分割成rgb值
+        /* let spliceColor = (color: number) => {
+            let result = { r: -1, g: -1, b: -1 };
+            result.b = color % 256;
+            result.g = Math.floor((color / 256)) % 256;
+            result.r = Math.floor((color / 256) / 256);
+            return result;
+        }
+        let result = spliceColor(color);
+        let colorMatrix = [
+            1, 0, 0, 0, 0,
+            0, 1, 0, 0, 0,
+            0, 0, 1, 0, 0,
+            0, 0, 0, 1, 0
+        ];
+        colorMatrix[0] = result.r / 255;
+        colorMatrix[6] = result.g / 255;
+        colorMatrix[12] = result.b / 255;
+        let colorFilter = new engine.ColorMatrixFilter(colorMatrix);
+
+        image.filters = [colorFilter]; */
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/MoveObject.ts

+import GameObject from "./GameObject";
+import Physics from "./Physics";
+
+import Game from "./Game";
+
+export default class MoveObjcet extends GameObject {
+    public physics: Physics = null;
+    constructor(context?: Game) {
+        super(context);
+        this.physics = this.addComponent(Physics);
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/MovieClipMgr.ts

+import Pool, { PoolGroup, PoolElement } from "./Pool";
+
+export default class MovieClipMgr {
+    private static _instance: MovieClipMgr = null;
+    public static get instance(): MovieClipMgr {
+        if (!this._instance) {
+            this._instance = new MovieClipMgr();
+        }
+
+        return this._instance;
+    }
+
+    private movieClipData: { [name: string]: engine.MovieClipData } = {};
+
+    private pool = new class extends PoolGroup<PoolMovieClip>{
+        createPool(key: string) {
+            return new class extends Pool<PoolMovieClip>{
+                createElement() {
+                    return MovieClipMgr.instance.create(key);
+                }
+            }();
+        }
+    }();
+
+    public load(name: string): boolean {
+        if (typeof this.movieClipData[name] == "undefined") {
+            const data = RES.getRes(name + "_json");
+            const txtr = RES.getRes(name + "_png");
+            if (!data || !txtr) {
+                console.error("can not load clip res:" + name);
+                return false;
+            }
+            this.movieClipData[name] = new engine.MovieClipDataFactory(data, txtr).generateMovieClipData(name);
+            return true;
+        } else
+            return true;
+    }
+
+    public create(name: string) {
+        if (typeof this.movieClipData[name] == "undefined") {
+            if (!this.load(name)) {
+                return null;
+            }
+        }
+        return new PoolMovieClip(this.movieClipData[name]);
+    }
+
+    public get(name: string): PoolMovieClip {
+        return this.pool.get(name);
+    }
+
+    public recycle(name: string, clip: PoolMovieClip) {
+        this.pool.recycle(name, clip);
+        clip.destroy();
+    }
+}
+
+class PoolMovieClip extends engine.MovieClip implements PoolElement {
+    onElementInit() { }
+    onElementRecycle() { }
+
+    playOnComplete(): Promise<void> {
+        this.gotoAndPlay(0, 1);
+        return new Promise<void>(resolve => {
+            this.once(engine.Event.COMPLETE, resolve, this);
+        });
+    }
+
+    autoRecyclePlay(name: string) {
+        this.playOnComplete().then(() => {
+            MovieClipMgr.instance.recycle(name, this);
+        });
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/Net.ts

+import { NetUtils } from "./NetUtils";
+import { ToastPanel } from "./ShootPlanet";
+
+const projectId = NetUtils.getProjectId();
+export default class Net {
+    public static cache: object = {};
+
+    /**
+     * 
+     * @param uri URL
+     * @param param 参数
+     * @param onSuccess 返回成功时的回调
+     * @param onFail 返回失败是的回调 | 是否使用默认失败回调函数
+     * @param pollingCheck 每次轮询回调
+     * @param pollingCount 轮询最大次数
+     */
+    public static sendGet(uri: string, param: any, onSuccess: (res: any) => void, onFail?: ((res: any) => any) | boolean, pollingCheck?: (res: any) => boolean, pollingCount?: number) {
+        this.mSend({
+            type: "get",
+            uri: uri,
+            param: param,
+            onSuccess: onSuccess,
+            onFail: onFail,
+            pollingCheck: pollingCheck,
+            pollingCount: pollingCount
+        });
+    }
+
+    /**
+     * 
+     * @param uri URL
+     * @param param 参数
+     * @param onSuccess 返回成功时的回调
+     * @param onFail 返回失败是的回调 | 是否使用默认失败回调函数
+     * @param pollingCheck 每次轮询回调
+     * @param pollingCount 轮询最大次数
+     */
+    public static sendPost(uri: string, param: any, onSuccess: (res: any) => void, onFail?: ((res: any) => any) | boolean, pollingCheck?: (res: any) => boolean, pollingCount?: number) {
+        this.mSend({
+            type: "post",
+            uri: uri,
+            param: param,
+            onSuccess: onSuccess,
+            onFail: onFail,
+            pollingCheck: pollingCheck,
+            pollingCount: pollingCount
+        });
+    }
+
+    private static mSend(net: INetData) {
+        if (net.pollingCheck) {
+            //TODO
+            // Loading.instace.show();
+        }
+
+        window['$'].ajax({
+            type: net.type,
+            url: net.uri,
+            dataType: 'json',
+            data: net.param,
+            async: true,
+            success: (result: any) => {
+                Net.onResponse(net, result);
+            },
+            error: (message: any) => {
+                Net.onError(net, message);
+            }
+        });
+
+        console.log("requset", net.uri, net.param);
+    }
+
+    private static onResponse(net: INetData, result: any): void {
+        //数据处理
+        if (net.pollingCheck) {
+            console.log('polling:', result);
+        }
+        if (net.pollingCount && net.pollingCheck(result)) { //轮询
+            net.pollingCount -= 1;
+            //轮询接口特殊处理
+            setTimeout(() => {
+                Net.mSend(net);
+            }, 500);
+        } else { //接口成功或失败
+            if (net.pollingCheck && !net.pollingCount && net.pollingCheck(result)) {
+                Net.onError(net, result);
+            } else {
+                net.onSuccess(result);
+            }
+
+        }
+    }
+
+    private static onError(net: INetData, res: any) {
+        console.warn("response", net.uri, res);
+
+        let errorMsg = res && ((res["desc"] || res["message"]) || ((res["code"] && "network error:" + res["code"]) || "network error")) || "network error";
+        if (typeof net.onFail == "function") {
+            if (!net.onFail(res)) { //若客户没有处理错误码，怎么默认显示错误消息或描述文字的弹窗
+                ToastPanel.show(errorMsg);
+            }
+        } else {
+            if (typeof net.onFail == "boolean" && net.onFail == true) {
+                Net.defaultOnFail && Net.defaultOnFail(res);
+            }
+            ToastPanel.show(errorMsg);
+        }
+    }
+
+    public static defaultOnFail: (res: any) => void = () => {
+        //TODO:默认网络异常处理
+        console.error("defaultOnFail");
+    }
+
+    public static urlReplace() {
+        for (let i of Object.keys(Net.Url)) {
+            for (let j of Object.keys(Net.urlReplaceConfig)) {
+                Net.Url[i] = Net.Url[i].replace(new RegExp(j, "g"), Net.urlReplaceConfig[j]);
+            }
+        }
+    }
+
+    private static urlReplaceConfig = {
+        "{projectId}": projectId
+    }
+
+    public static readonly Url = {
+        signData: "/projectx/{projectId}/join_1/data.do",
+        signIn: "/projectx/{projectId}/join_1/join.do",
+        queryProps: "/projectx/{projectId}/scoring_1/spData.do",
+        start: "/projectx/{projectId}/scoring_1/start.do",
+        finalSubmit: "/projectx/{projectId}/scoring_1/submit.do",
+        revive: "/projectx/{projectId}/scoring_1/revive.do",
+        constantSubmit: "/projectx/{projectId}/scoring_1/push.do",
+        rankList: "/projectx/{projectId}/join_2/data.do",
+        queryRankListData: "/projectx/{projectId}/getRanking.query",
+        queryNickname: "/projectx/{projectId}/join_3/userInfoList.do",
+        visit: "/projectx/{projectId}/scoring_1/visit.do",
+        share: "/projectx/{projectId}/join_2/join.do"
+    }
+}
+
+interface INetData {
+    type: string,
+    uri: string,
+    param: any,
+    onSuccess: (res: any) => void,
+    onFail?: ((res: any) => any) | boolean,
+    pollingCheck?: (res: any) => boolean,
+    pollingCount?: number
+}
\ No newline at end of file

src/custom/ShootPlanet/NetUtils.ts

+import Net from "./Net";
+import { NetManager } from "../../../libs/tw/manager/NetManager";
+import { Buried } from "../../../libs/tw/util/Buried";
+import { MUtils } from "./MUtils";
+import GameMgr from "../Mgr/GameMgr";
+
+export namespace NetUtils {
+    export function createSgin(ticketId: number, score: number, gameData: any, submitToken: string): string {
+        return window['duiba_md5'](ticketId + '' + score + '' + gameData + '' + submitToken);
+    }
+
+    export function getOrderId() {
+        return Net.cache[NetUtils.getCFG()["doJoin"]]["orderId"];
+    }
+
+    export function gameSubmit(params: {
+        orderId: any,
+        score: any,
+        submitToken: any
+    }, onSuccess: (res: any) => void, onFail?: (res: any) => any) {
+        let sgin = createSgin(params.orderId, params.score, "[]", params.submitToken);
+        Net.sendPost('/hdtool/recon/ngame/ngameSubmit', {
+            orderId: params.orderId,
+            score: params.score,
+            gameData: "[]",
+            sgin: sgin,
+            dynamicData: JSON.stringify(`{t2:${new Date().getTime()}}`),
+            rankId: window["rankId"]
+        }, onSuccess, onFail);
+
+    }
+
+    export function ajaxElement(onSuccess: (res: any) => void, onFail?: (res: any) => void) {
+        let cfg = NetUtils.getCFG();
+        Net.sendPost(cfg["getElement"], {
+            hdType: cfg["hdType"],
+            hdToolId: cfg["hdToolId"],
+            actId: cfg["actId"],
+            preview: cfg["preview"]
+        }, onSuccess, onFail);
+    }
+
+    function doBuried(appIdParam: string, netManager: NetManager, callback: string) {
+        //初始化埋点数据
+        Buried.init();
+        var appId = NetUtils.getCFG()["appId"];
+        var oaId = NetUtils.getCFG()["appId"];
+        let data = Buried.createExposure(appId + `.110.${appIdParam}.1`, `202.${oaId}.0.0`);
+        netManager[callback](data);
+        console.log("exposure", data);
+    }
+
+    export function doClickBuried(appIdParam: string) {
+        doBuried(appIdParam, NetManager.ins, "clickLog");
+    }
+    export function doShowBuried(appIdParam: string) {
+        doBuried(appIdParam, NetManager.ins, "showLog");
+    }
+
+    export function encryptSeq(seq: number) {
+        return Math.round(5 * seq - MUtils.random(0, 4));
+    }
+
+    export function md5(str: string) {
+        return window['duiba_md5'](str);
+    }
+    export function getTimestamp() {
+        return Date.now();
+    }
+
+    export function getCFG(): object {
+        return window['CFG'];
+    }
+
+    const projectxString = "projectx/";
+    export function getProjectId(): string {
+        let windowUrl = window.location.href;
+        let splitArr = windowUrl.split(projectxString);
+        if (splitArr.length != 2) {
+            return "projectId"
+        }
+
+        let start = windowUrl.indexOf(projectxString) + projectxString.length;
+        let end = splitArr[1].indexOf("/");
+        return windowUrl.substr(start, end);
+    }
+
+    export function visit() {
+        return new Promise<any>((resolve, reject) => {
+            Net.sendGet(Net.Url.visit, undefined, (res) => {
+                GameMgr.instance.allPeriodEnd = res.data.allPeriodEnd;
+                GameMgr.instance.leftTimes = res.data.leftTimes;
+                GameMgr.instance.leftShareTimes = res.data.leftShareTimes;
+                GameMgr.instance.minEnableCaptchaScore = res.data.minEnableCaptchaScore;
+
+                resolve(res);
+            }, (res) => {
+                reject(res);
+            })
+        });
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/ParticleMgr.ts

+import Pool from "./Pool";
+import Bullet from "./Bullet";
+import { MConst } from "./MConst";
+import PoolMgr from "./PoolMgr";
+
+import GameMgr from "./GameMgr";
+import GameObject from "./GameObject";
+
+/* export default class ParticleMgr {
+    private data: Bullet[] = [];
+
+    private layer: engine.Container = null;
+    constructor(layer: engine.Container) {
+        this.layer = layer;
+    }
+
+    create(context: MainScene) {
+        if (this.data.length > 0) {
+            let e = this.data.pop();
+            e.onElementInit();
+            return e;
+        } else {
+            let b = new Bullet(context);
+            this.layer.addChild(b);
+            return b;
+        }
+    }
+
+    destroy(bullet: Bullet) {
+        bullet.onElementRecycle();
+        this.data.push(bullet);
+    }
+} */
\ No newline at end of file

src/custom/ShootPlanet/PhycicsSystem.ts

+import Physics from "./Physics";
+import Collider, { CircleCollider, RectCollider, ColliderType, ColliderGroup, PointCollider } from "./Collider";
+import { arrayRemove } from "./GUtils";
+import MTimer from "./MTimer";
+
+let instanceId1: number = null;
+let instanceId2: number = null;
+export default class PhycicsSystem {
+    private static _instance: PhycicsSystem = null;
+    public static get instance(): PhycicsSystem {
+        if (!this._instance) {
+            this._instance = new PhycicsSystem();
+        }
+
+        return this._instance;
+    }
+
+    public static init() {
+        const ins = PhycicsSystem.instance;
+        engine.gameStage.addEventListener(engine.Event.ENTER_FRAME, ins.onUpdate, ins);
+    }
+
+    private _enabled: boolean = false;
+    public set enabled(v: boolean) {
+        this._enabled = v;
+
+        if (this._enabled == true)
+            this.pause = false;
+
+        this.clear();
+    }
+    public get enabled() {
+        return this._enabled;
+    }
+
+    public pause: boolean = false;
+
+
+    private phycicsList: Physics[] = [];
+
+    private clear() {
+        for (let i = 0; i <= GroupMaxIndex; i++) {
+            this.colliderList[i] = [];
+        }
+        this.phycicsList = [];
+    }
+
+    private onUpdate() {
+        if (this.pause) return;
+
+        for (let i of PhycicsSystem.instance.phycicsList) {
+            if (this.enabled == false) return;
+            i.onFixedUpdate(MTimer.dtFactor);
+        }
+
+        this.detectCollision();
+
+
+        return false;
+    }
+
+    public add(phycics: Physics) {
+        this.phycicsList.push(phycics);
+    }
+    public remove(phycics: Physics) {
+        this.phycicsList = arrayRemove(this.phycicsList, phycics);
+    }
+
+    private colliderList: Collider[][] = [];
+    private collisions: number[][] = [];
+
+    /**
+     * 判断两个碰撞器之前是否发生过碰撞
+     * @returns 未找到返回-1
+     */
+    private getCollisionIndex(collider1: number, collider2: number): number {
+        for (let i = 0; i < this.collisions.length; i++) {
+            if ((this.collisions[i][0] == collider1 && this.collisions[i][1] == collider2) || (this.collisions[i][0] == collider2 && this.collisions[i][1] == collider1)) {
+                return i;
+            }
+        }
+        //未碰撞
+        return -1;
+    }
+
+    public addCollider(collider: Collider) {
+        if (typeof this.colliderList[collider.group] == "undefined") {
+            this.colliderList[collider.group] = [];
+        }
+        this.colliderList[collider.group].push(collider);
+    }
+
+    public removeCollider(collider: Collider) {
+        this.collisions = this.collisions.filter(e => {
+            if (e[0] != collider.owner.instanceId && e[1] != collider.owner.instanceId) {
+                return true;
+            } else
+                return false;
+        });
+
+        this.colliderList[collider.group] = arrayRemove(this.colliderList[collider.group], collider);
+    }
+
+    /**检测碰撞 */
+    public detectCollision() {
+        //查找所有碰撞
+        let i = 0,
+            j = 0,
+            m = 0,
+            n = 0,
+            length = this.colliderList.length,
+            group1: Collider[] = null,
+            group2: Collider[] = null;
+        for (i = 0; i <= length - 1; i++) {
+            for (j = i + 1; j <= length - 1; j++) {
+                if (CollisionMap[i] & 1 << j) {
+                    if (this.enabled == false) return;
+                    group1 = this.colliderList[i];
+                    group2 = this.colliderList[j];
+                    for (m = 0; m <= group1.length - 1; m++) {
+                        for (n = 0; n <= group2.length - 1; n++) {
+                            // if (this.enabled == false) return;
+                            this.detectTraverse(group1[m], group2[n]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private detectTraverse(collider1: Collider, collider2: Collider) {
+        instanceId1 = collider1.owner.instanceId;
+        instanceId2 = collider2.owner.instanceId;
+
+        let collisionIndex = this.getCollisionIndex(instanceId1, instanceId2);
+        if (callDetectFunc(collider1, collider2)) { //发生碰撞
+            if (collisionIndex >= 0) { //之前就发生了碰撞
+                collider1.owner.onCollisionStay(collider2);
+                collider2.owner.onCollisionStay(collider1);
+            } else { //之前没有碰撞
+                //添加到索引表
+                this.collisions.push([instanceId1, instanceId2]);
+                collider1.owner.onCollisionEnter(collider2);
+                collider2.owner.onCollisionEnter(collider1);
+            }
+        } else { //未发生碰撞
+            //碰撞退出
+            if (collisionIndex >= 0) { //之前有发生碰撞
+                //在碰撞列表中删除这一对碰撞
+                this.collisions.splice(collisionIndex, 1);
+                collider1.owner.onCollisionExit(collider2);
+                collider2.owner.onCollisionExit(collider1);
+            }
+        }
+    }
+}
+
+function callDetectFunc(collider1: Collider, collider2: Collider): boolean {
+    if (collider1.type == ColliderType.Circle) {
+        if (collider2.type == ColliderType.Circle) {
+            return circleToCircle(collider1 as CircleCollider, collider2 as CircleCollider);
+        } else if (collider2.type == ColliderType.Rect) {
+            return circleToRect(collider1 as CircleCollider, collider2 as RectCollider);
+        } else if (collider2.type == ColliderType.Point) {
+            return circleToPoint(collider1 as CircleCollider, collider2 as PointCollider)
+        }
+    } else if (collider1.type == ColliderType.Rect) {
+        if (collider2.type == ColliderType.Circle) {
+            return circleToRect(collider2 as CircleCollider, collider1 as RectCollider);
+        } else if (collider2.type == ColliderType.Rect) {
+            return rectToRect(collider1 as RectCollider, collider2 as RectCollider);
+        } else if (collider2.type == ColliderType.Point) {
+            return pointToRect(collider2 as PointCollider, collider1 as RectCollider);
+        }
+    } else if (collider1.type == ColliderType.Point) {
+        if (collider2.type == ColliderType.Circle) {
+            return circleToPoint(collider2 as CircleCollider, collider1 as PointCollider);
+        } else if (collider2.type == ColliderType.Rect) {
+            return pointToRect(collider1 as PointCollider, collider2 as RectCollider);
+        }
+    }
+    return false;
+}
+
+let tempPoint1: number[] = [];
+let tempPoint2: number[] = [];
+
+function distance(p1: number[], p2: number[]) {
+    return Math.sqrt((p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]));
+}
+
+function circleToCircle(collider1: CircleCollider, collider2: CircleCollider): boolean {
+    collider1.getWorldPosition(tempPoint1);
+    collider2.getWorldPosition(tempPoint2);
+    return distance(tempPoint1, tempPoint2) < (collider1.radius + collider2.radius);
+}
+
+function circleToRect(circleCollider: CircleCollider, rectCollider: RectCollider) {
+    circleCollider.getWorldPosition(tempPoint1);
+    rectCollider.getWorldPosition(tempPoint2);
+
+    let closestPoint = new engine.Point();
+    if (tempPoint1[1] < tempPoint2[1]) {
+        closestPoint.y = tempPoint2[1];
+    } else if (tempPoint1[1] > tempPoint2[1] + rectCollider.rect.height) {
+        closestPoint.y = tempPoint2[1] + rectCollider.rect.height;
+    } else {
+        closestPoint.y = tempPoint1[1];
+    }
+
+    if (tempPoint1[0] < tempPoint2[0]) {
+        closestPoint.x = tempPoint2[0];
+    } else if (tempPoint1[0] > tempPoint2[0] + rectCollider.rect.width) {
+        closestPoint.x = tempPoint2[0] + rectCollider.rect.width;
+    } else {
+        closestPoint.x = tempPoint1[0];
+    }
+
+    return distance([closestPoint.x, closestPoint.y], tempPoint1) < circleCollider.radius;
+}
+
+function rectToRect(collider1: RectCollider, collider2: RectCollider) {
+    let rect1 = collider1.rect,
+        rect2 = collider2.rect;
+    collider1.getWorldPosition(tempPoint1);
+    collider2.getWorldPosition(tempPoint2);
+
+    let rectW1 = tempPoint1[0] + rect1.width,
+        rectW2 = tempPoint2[0] + rect2.width,
+        rectH1 = rect1.height + tempPoint1[1],
+        rectH2 = tempPoint2[1] + rect2.height;
+    if (tempPoint1[0] <= rectW2 &&
+        rectW1 >= tempPoint2[0] &&
+        tempPoint1[1] <= rectH2 &&
+        rectH1 >= tempPoint2[1]) { //发生碰撞
+        return true;
+    } else
+        return false;
+}
+
+
+function circleToPoint(circle: CircleCollider, point: PointCollider) {
+    circle.getWorldPosition(tempPoint1);
+    point.getWorldPosition(tempPoint2);
+
+    if (distance(tempPoint1, tempPoint2) < circle.radius) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+function pointToRect(point: PointCollider, rect: RectCollider) {
+    rect.getWorldPosition(tempPoint1);
+    point.getWorldPosition(tempPoint2);
+    if (tempPoint2[1] < tempPoint1[1] + rect.rect.height
+        && tempPoint2[1] > tempPoint1[1]
+        && tempPoint2[0] > tempPoint1[0]
+        && tempPoint2[0] < tempPoint1[0] + rect.rect.width
+    ) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+const CollisionMap = {
+    0: 0b00000000,
+    1: 0b01011100,
+    2: 0b10000010,
+    3: 0b01100010,
+    4: 0b00100010,
+    5: 0b01011000,
+    6: 0b00101010,
+    7: 0b00000010
+}
+
+const GroupMaxIndex = 7
\ No newline at end of file

src/custom/ShootPlanet/Physics.ts

+import GameComponent from "./GameComponent";
+import GameObject from "./GameObject";
+import PhycicsSystem from "./PhycicsSystem";
+import Collider from "./Collider";
+
+export default class Physics extends GameComponent {
+    /**旋转速度 
+     * @单位 （弧度制）度/帧
+     * @方向 正值表示顺时针旋转，负表示逆时针旋转
+     **/
+    public rotateVelocity: number = 0;
+    /**每帧速率的增量
+     * x坐标表示对应坐标轴方向上速率的增量（标量）
+     * @单位 像素/帧
+     **/
+    public acceleration: engine.Point = new engine.Point();
+    /**速度 单位：像素/帧 */
+    public velocity: engine.Point = new engine.Point();
+
+    public get collider() {
+        return this._collider;
+    }
+    public set collider(v: Collider) {
+        this._collider = v;
+        v.physics = this;
+    }
+    public _collider: Collider = null;
+
+    public onFixedUpdate(dtFactor: number) {
+        this.velocity.x += this.acceleration.x * dtFactor;
+        this.velocity.y += this.acceleration.y * dtFactor;
+        if (this.velocity.length > 0) {
+            this.moveTo(
+                this.owner.x += this.velocity.x * dtFactor,
+                this.owner.y += this.velocity.y * dtFactor
+            );
+        }
+
+        //旋转
+        if (this.rotateVelocity != 0) {
+            this.owner.rotation += this.rotateVelocity * dtFactor;
+        }
+    }
+
+    public moveTo(x: number | engine.Point, y?: number) {
+        if (typeof x == "number") {
+            if (!y) {
+                console.error("invalid param");
+                return;
+            }
+            this.owner.x = x;
+            this.owner.y = y;
+        } else {
+            this.owner.x = x.x;
+            this.owner.y = x.y;
+        }
+
+        this.onMoved && this.onMoved(this.owner);
+    }
+
+    public onMoved: (owner: GameObject) => void;
+
+    protected onDisabled() {
+        PhycicsSystem.instance.remove(this);
+    }
+    protected onEnabled() {
+        PhycicsSystem.instance.add(this);
+    }
+
+    public onColliderResize(collider: Collider) {
+        let center = collider.getCenter();
+        this.owner.anchorX = center[0];
+        this.owner.anchorY = center[1];
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/PlayerController.ts

+export default class PlayerController extends engine.Container {
+    public onTouchMove: (deltaX: number) => void = null;
+
+    private touchId: number = null;
+    private lastX: number = null;
+    constructor() {
+        super();
+        this.width = engine.gameStage.width;
+        this.height = engine.gameStage.height;
+        this.addEventListener(engine.MouseEvent.MOUSE_DOWN, (e: engine.MouseEvent) => {
+            this.touchId = e.instanceId;
+            this.lastX = e.stageX;
+        }, this);
+        this.addEventListener(engine.MouseEvent.MOUSE_MOVE, (e: engine.MouseEvent) => {
+            if (e.instanceId != this.touchId || this.touchId == null || this.lastX == null) return;
+
+            this.onTouchMove && this.onTouchMove(e.stageX - this.lastX)
+            this.lastX = e.stageX;
+        }, this);
+        this.removeEventListener(engine.MouseEvent.MOUSE_UP, (e: engine.MouseEvent) => {
+            if (e.instanceId != this.touchId) return;
+
+            this.touchId = null;
+            this.lastX = null;
+        }, this);
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/Pool.ts

+import { MUtils } from "./MUtils";
+import MTweenMgr from "./MTween";
+
+export default abstract class Pool<T extends PoolElement>{
+    private data: T[] = [];
+
+    public get(...args: any[]): T {
+        if (this.data.length > 0) {
+            let e = this.data.pop();
+            e.onElementInit();
+            return e;
+        } else {
+            return this.createElement(...args);
+        }
+    }
+
+    public recycle(element: T) {
+        MTweenMgr.instance.removeTweens(element);
+        element.onElementRecycle();
+        for (let i of this.data) {
+            if (i === element) return;
+        }
+        this.data.push(element);
+    }
+
+    protected abstract createElement(...args: any[]): T;
+}
+
+export abstract class PoolGroup<T extends PoolElement>{
+    private data: {
+        [key: string]: Pool<T>
+    } = {};
+
+    public get(key: string): T {
+        return this.getValue(key).get();
+    }
+
+    public recycle(key: string, element: T) {
+        this.getValue(key).recycle(element);
+    }
+
+    private getValue(key: string) {
+        this.data[key] = this.data[key] || this.createPool(key);
+        return this.data[key];
+    }
+
+    protected abstract createPool(key: string): Pool<T>;
+}
+
+export interface PoolElement {
+    /**回收元素时的调用 */
+    onElementRecycle(): void;
+    onElementInit(): void;
+}
\ No newline at end of file

src/custom/ShootPlanet/PoolMgr.ts

+import Pool, { PoolElement } from "./Pool";
+import GameObject from "./GameObject";
+
+export default abstract class PoolMgr<T extends PoolElement & engine.Container>{
+    protected layer: engine.Container = null;
+    private pool: Pool<T> = new class extends Pool<T>{
+        private context: PoolMgr<T> = null;
+        constructor(context: PoolMgr<T>) {
+            super();
+            this.context = context;
+        }
+        createElement(...args: any[]) {
+            return this.context.createElement(args);
+        }
+    }(this);
+
+    constructor(layer: engine.Container) {
+        this.layer = layer;
+    }
+
+    create(...args: any[]): T {
+        let element = this.pool.get(...args);
+        this.layer.addChild(element);
+        return element;
+    }
+
+    destroy(element: T) {
+        this.pool.recycle(element);
+    }
+
+    abstract createElement(...args: any[]): T;
+}
\ No newline at end of file

src/custom/ShootPlanet/ShootPlanet.ts

+/**
+ * Created by rockyl on 2019-11-22.
+ */
+
+export class ShootPlanet extends engine.Container {
+	constructor() {
+		super();
+		this.init();
+		let rect = new engine.Rect();
+		rect.width = 100;
+		rect.height = 100;
+		this.addChild(rect);
+	}
+
+	private init() {
+		RES.getRes = function (uuid: string) {
+			return engine.Texture.from(uuid);
+		}
+		Math.clamp = function (target: number, min: number, max: number) {
+			if (target > max) target = max;
+			if (target < min) target = min;
+			return target;
+		}
+
+		Object.defineProperty(engine.Point, 'length', {
+			get: function () {
+				return Math.sqrt(this.x * this.x + this.y * this.y);
+			}
+		});
+	}
+}
+
+export class ToastPanel {
+	public static show(msg: string) {
+		console.log("toast:" + msg);
+	}
+}

src/custom/ShootPlanet/SoundMgr.ts

+import MTimer from "./MTimer";
+
+export default class SoundMgr {
+    private static _instance: SoundMgr = null;
+    public static get instance(): SoundMgr {
+        if (!this._instance) {
+            this._instance = new SoundMgr();
+        }
+
+        return this._instance;
+    }
+    public effectEnabled = false;
+
+    private _enabled: boolean = false;
+    public set enabled(v: boolean) {
+        this.musicEnabled = v;
+        this.effectEnabled = v;
+        this._enabled = v;
+    }
+    public get enabled() {
+        return this._enabled;
+    }
+
+    private _musicEnabled: boolean = false;
+    public get musicEnabled() {
+        return this._musicEnabled;
+    }
+    public set musicEnabled(v: boolean) {
+        if (v == true) {
+            this.playMusic();
+        } else {
+            this.stopMusic();
+        }
+        this._musicEnabled = v;
+    }
+
+    private music: engine. = null;
+    private musicChannel: engine.SoundChannel = null;
+    private loopChannelMap: { [name: string]: engine.SoundChannel } = {}
+    private effectPool: { [name: string]: PoolSound[] } = {}
+    public firstSeted = false;
+
+    public setMusic(url: string) {
+        this.music = RES.getRes(url);
+        /* if (this.musicChannel) {
+            this.playMusic();
+        } */
+    }
+
+    public playMusic() {
+        if (this.music == null) {
+            console.warn("music do not set");
+            return;
+        }
+        this.musicChannel && this.musicChannel.stop();
+        this.musicChannel = this.music.play(0, 0);
+    }
+
+    public stopMusic() {
+        this.musicChannel && (this.musicChannel.stop());
+    }
+
+    public playEffect(name: string, loop: boolean = false) {
+        if (!this.effectEnabled) return;
+
+        let poolSound = this.createSound(name, loop);
+        let channel = poolSound.sound.play(0, loop ? 0 : 1);
+        if (loop) {
+            if (this.loopChannelMap[name]) {
+                this.loopChannelMap[name].stop();
+            }
+            this.loopChannelMap[name] = channel;
+        } else {
+            return new Promise<void>(resolve => {
+                channel.addEventListener(engine.Event.SOUND_COMPLETE, () => {
+                    this.recycleSound(poolSound);
+                    resolve();
+                }, this);
+            });
+        }
+    }
+
+    public stopLoopEffect(name: string) {
+        if (this.loopChannelMap[name]) {
+            this.loopChannelMap[name].stop();
+        }
+    }
+
+    private t: number = 0;
+
+    private createSound(name: string, loop: boolean): PoolSound {
+        let soundList = this.effectPool[name];
+        if (!soundList || soundList.length <= 0) {
+            let poolSound = new PoolSound(name, RES.getRes(name), loop);
+            if (poolSound.name == "shoot_mp3") {
+                this.t++;
+            }
+            return poolSound;
+        } else {
+            return soundList.pop();
+        }
+    }
+
+    private recycleSound(poolSound: PoolSound) {
+        delete this.loopChannelMap[poolSound.name];
+        this.effectPool[poolSound.name] = this.effectPool[poolSound.name] || [];
+        this.effectPool[poolSound.name].push(poolSound);
+    }
+}
+
+class PoolSound {
+    private loop = false;
+    public onRecycle = (sound: PoolSound) => { }
+    public sound: engine.Sound = null;
+    public name: string = null;
+    constructor(name: string, sound: engine.Sound, loop: boolean) {
+        this.name = name;
+        this.sound = sound;
+        this.loop = loop;
+    }
+}
\ No newline at end of file

src/custom/ShootPlanet/index.ts

+/**
+ * Created by rockyl on 2019-11-20.
+ */
+
+import { ShootPlanet } from "./ShootPlanet";
+
+export default function (options) {
+	let instance = new ShootPlanet();
+	return instance;
+}

src/custom/ShootPlanet/meta.json

+{
+	"name": "Test1",
+	"props": {
+
+	},
+	"assets": [
+		{
+			"url": "//yun.duiba.com.cn/aurora/af90069732223c75818c4799b3130bd0f0ad4ff8.png",
+			"ext": ".png"
+		}
+	]
+}
\ No newline at end of file