文章目录

• 节点池描述
• 创建节点池脚本PoolManager.ts
• 将原来实例化与销毁通过节点池操作
• 完整代码

节点池描述

通过节点池，您可以更方便地对节点进行分组管理，例如节点运维、节点配置、开启节点自动弹性伸缩、批量管理、指定调度等。本文介绍节点池的概念、使用说明、使用限制，以及节点池分类.

就飞机大战例子而言:每次都去实例子弹\敌机,这个过程现在数量不大看起来好像很快,但是也会损耗性能,而且子弹和敌机都是不断产出的,所以应该将不要的对象放在节点池里做库存,等到下次有需要的时候再从池子里取出(好处是不仅能提高效率还能提高性能)

创建节点池脚本PoolManager.ts

思路就是创建容器对象以及还要有节点的获取与保存方法

import { _decorator, Component, Node, Prefab, NodePool, instantiate } from 'cc';
const { ccclass, property } = _decorator;

interface IDictPool {
    [name: string]: NodePool;
}

interface IDictPrefab {
    [name: string]: Prefab;
}

@ccclass('PoolManager')
export class PoolManager {

    public static instance() {
        if (!this._instance) {
            this._instance = new PoolManager();
        }

        return this._instance;
    }

    /**
     * 容器对象
     */
    private _dictPool: IDictPool = {};//节点容器
    private _dictPrefab: IDictPrefab = {};//缓存预制容器

    private static _instance: PoolManager;

    /**
     * 获取节点
     *      从大容器中取特定分类节点的方法
     * @param prefab 
     * @param parent 
     * @returns 
     */
    public getNode(prefab: Prefab, parent: Node) {
        let name = prefab.data.name;
        // console.log('get node   ' + name);
        let node: Node = null;
        //存预制
        this._dictPrefab[name] = prefab;
        const pool = this._dictPool[name];
        //判断有没有当前分类的容器
        if (pool) {
            if (pool.size() > 0) {//判断小容器内部容量是不是有东西
                node = pool.get();//获取节点
            } else {
                node = instantiate(prefab);//实例化新的对象
            }
        } else {
            //创建新的小容器
            this._dictPool[name] = new NodePool();
            node = instantiate(prefab);
        }
        //设置父节点（归属）
        node.parent = parent;
        node.active = true;//激活
        return node;//返回节点
    }
    /**
     * 将节点保存（节点无用的时候放回库存）
     * @param node 
     */
    public putNode(node: Node) {
        let name = node.name;
        // console.log('put node   ' + name);
        node.parent = null;//节点已被回收，不能作为场景里的对象再继续存在于场景里
        // 判断容器有没有分类节点
        if (!this._dictPool[name]) {
            //创建容器
            this._dictPool[name] = new NodePool();
        }
        //放入容器中
        this._dictPool[name].put(node);
    }
}

将原来实例化与销毁通过节点池操作

先搜索下以防一会改露了

• 实例化的
  
• 销毁的
  
  我这里放个图片清晰下大致改的思路，然后直接放代码了
  

完整代码

• GameManager.ts

import { _decorator, Component, Node, Prefab, instantiate, math, Vec3, BoxCollider, macro, Label } from 'cc';
import { Bullet } from '../bullet/Bullet';
import { BulletProp } from '../bullet/BulletProp';
import { EnemyPlane } from '../plane/EnemyPlane';
import { SelfPlane } from '../plane/SelfPlane';
import { AudioManager } from './AudioManager';
import { Constant } from './Constant';
import { PoolManager } from './PoolManager';
const { ccclass, property } = _decorator;


@ccclass('GameManager')
export class GameManager extends Component {
    // 关联玩家飞机
    @property(SelfPlane)
    public playerPlane: SelfPlane = null;

    // bullet 关联所有子弹
    @property(Prefab)
    public bullet01: Prefab = null;
    @property(Prefab)
    public bullet02: Prefab = null;
    @property(Prefab)
    public bullet03: Prefab = null;
    @property(Prefab)
    public bullet04: Prefab = null;
    @property(Prefab)
    public bullet05: Prefab = null;
    // 射击周期
    @property
    public shootTime = 0.3;
    // 子弹移动速度
    @property
    public bulletSpeed = 1;
    //子弹管理节点
    @property(Node)
    public bulletRoot: Node = null;

    // enemy/** 关联敌机 */
    @property(Prefab)
    public enemy01: Prefab = null;
    @property(Prefab)
    public enemy02: Prefab = null;
    @property
    public createEnemtTime = 1;//创建敌机时间
    @property
    public enemy1Speed = 0.5;//敌机1速度
    @property
    public enemy2Speed = 0.7;//敌机2速度


    // prop 定义道具属性
    @property(Prefab)
    public bulletPropM: Prefab = null;
    @property(Prefab)
    public bulletPropH: Prefab = null;
    @property(Prefab)
    public bulletPropS: Prefab = null;
    @property
    public bulletPropSpeed = 0.3;//道具速度

    // ui
    @property(Node)
    public gamePage: Node = null;//游戏界面
    @property(Node)
    public gameOverPage: Node = null;//游戏结束界面
    @property(Label)
    public gameOverScore: Label = null;//游戏结算分数
    @property(Label)
    public gameScore: Label = null;//游戏分数组件

    // audio
    @property(AudioManager)
    public audioEffect: AudioManager = null;//获取音频脚本

    public isGameStart = false;//游戏是否开始

    private _currShootTime = 0;
    // 是否触摸屏幕
    private _isShooting = false;
    private _currCreateEnemyTime = 0//当前创建的敌机时间
    private _combinationInterval = Constant.Combination.PLAN1//组合间隔状态
    private _bulletType = Constant.BulletPropType.BULLET_M;//子弹类型
    private _score = 0;//分数

    start() {
        this._init();
    }

    update(deltaTime: number) {
        //判断游戏是否开始
        if (!this.isGameStart) {
            return;
        }
        //判断玩家是否死亡
        if (this.playerPlane.isDie) {
            this.gameOver();
            return;
        }
        // 这步加时间是为了发射子弹
        this._currShootTime += deltaTime;

        // 判断是触摸状态 并且射击时间大于我们的周期 发射子弹
        if (this._isShooting && this._currShootTime > this.shootTime) {
            /**
           * 根据吃道具类型来产生子弹
           */
            if (this._bulletType === Constant.BulletPropType.BULLET_H) {
                this.createPlayerBulletH();
            } else if (this._bulletType === Constant.BulletPropType.BULLET_S) {
                this.createPlayerBulletS();
            } else {
                this.createPlayerBulletM();
            }
            //发射子弹播放声音由于音频只有1，2子弹却有3个，这里是处理逻辑
            const name = 'bullet' + (this._bulletType % 2 + 1);
            this.playAudioEffect(name);
            this._currShootTime = 0;
        }

        this._currCreateEnemyTime += deltaTime
        //判断组合方式
        if (this._combinationInterval == Constant.Combination.PLAN1) {
            //只创建单一的飞机 0-10秒飞机创建
            if (this._currCreateEnemyTime > this.createEnemtTime) {//普通飞机创建
                this.createEnemyPlane()
                this._currCreateEnemyTime = 0
            }

        } else if (this._combinationInterval == Constant.Combination.PLAN2) {
            // 10-20秒飞机创建
            if (this._currCreateEnemyTime > this.createEnemtTime * 0.9) {//0.9飞机组合间隔
                const randomCombination = math.randomRangeInt(1, 3)//随机1，2飞机
                if (randomCombination === Constant.Combination.PLAN2) {
                    this.createCombination1()
                } else {
                    this.createEnemyPlane()
                }

                this._currCreateEnemyTime = 0
            }
        } else {
            //20+ 飞机创建
            if (this._currCreateEnemyTime > this.createEnemtTime * 0.8) {//0.8飞机组合间隔
                const randomCombination = math.randomRangeInt(1, 4)//随机1，2，3飞机
                if (randomCombination === Constant.Combination.PLAN2) {
                    this.createCombination1()
                } else if (randomCombination === Constant.Combination.PLAN3) {
                    this.createCombination2()
                } else {
                    this.createEnemyPlane()
                }

                this._currCreateEnemyTime = 0
            }
        }
    }

    /**
    * 返回主界面逻辑，数据重置
    */
    public returnMain() {
        this._currShootTime = 0;
        this._currCreateEnemyTime = 0;
        this._combinationInterval = Constant.Combination.PLAN1;
        this._bulletType = Constant.BulletPropType.BULLET_M;
        this.playerPlane.node.setPosition(0, 0, 15);
        this._score = 0;
    }
    /**
     * 游戏开始页面数据重置
     */
    public gameStart() {
        this.isGameStart = true;
        this._changePlanMode();//开启定时器
        this._score = 0;
        this.gameScore.string = this._score.toString();
    }
    /**
     * 游戏再次开始
     */
    public gameReStart() {
        this.isGameStart = true;
        this._currShootTime = 0;
        this._currCreateEnemyTime = 0;
        this._combinationInterval = Constant.Combination.PLAN1;
        this._bulletType = Constant.BulletPropType.BULLET_M;
        this.playerPlane.node.setPosition(0, 0, 15);
        this._score = 0;
        this._changePlanMode();//开启定时器
        this.gameScore.string = this._score.toString();
    }
    /**
     * 游戏结束
     */
    public gameOver() {
        this.isGameStart = false;
        this.gamePage.active = false;
        this.gameOverPage.active = true;
        this.gameOverScore.string = this._score.toString();
        this._isShooting = false;
        this.unschedule(this._modeChanged);//取消定时器
        this.playerPlane.init();//这里注意游戏结束要初始化
        this._destroyAll();
    }
    /**
     * 加分
     */
    public addScore() {
        this._score++;
        this.gameScore.string = this._score.toString();
    }

    /**
     * 创建子弹
     */
    public createPlayerBulletM() {
        // 子弹实例化
        const bullet = PoolManager.instance().getNode(this.bullet01, this.bulletRoot);
        // const bullet = instantiate(this.bullet01);
        // 将子弹放在子弹管理节点下面
        bullet.setParent(this.bulletRoot);
        // 获取飞机位置
        const pos = this.playerPlane.node.position;
        // 设置子弹位置
        bullet.setPosition(pos.x, pos.y, pos.z - 7);
        // 设置子弹速度
        const bulletComp = bullet.getComponent(Bullet);
        bulletComp.show(this.bulletSpeed, false)
    }
    /**
     * H形状子弹创建
     */
    public createPlayerBulletH() {
        const pos = this.playerPlane.node.position;
        // left
        // const bullet1 = instantiate(this.bullet03);
        const bullet1 = PoolManager.instance().getNode(this.bullet03, this.bulletRoot);
        bullet1.setParent(this.bulletRoot);
        bullet1.setPosition(pos.x - 2.5, pos.y, pos.z - 7);
        const bulletComp1 = bullet1.getComponent(Bullet);
        bulletComp1.show(this.bulletSpeed, false);

        // right
        // const bullet2 = instantiate(this.bullet03);
        const bullet2 = PoolManager.instance().getNode(this.bullet03, this.bulletRoot);
        bullet2.setParent(this.bulletRoot);
        bullet2.setPosition(pos.x + 2.5, pos.y, pos.z - 7);
        const bulletComp2 = bullet2.getComponent(Bullet);
        bulletComp2.show(this.bulletSpeed, false);
    }
    /**
     * S型子弹创建
     */
    public createPlayerBulletS() {
        const pos = this.playerPlane.node.position;
        // middle
        // const bullet = instantiate(this.bullet05);
        const bullet = PoolManager.instance().getNode(this.bullet05, this.bulletRoot);
        // bullet.setParent(this.bulletRoot);
        bullet.setPosition(pos.x, pos.y, pos.z - 7);
        const bulletComp = bullet.getComponent(Bullet);
        bulletComp.show(this.bulletSpeed, false);

        // left
        // const bullet1 = instantiate(this.bullet05);
        const bullet1 = PoolManager.instance().getNode(this.bullet05, this.bulletRoot);
        // bullet1.setParent(this.bulletRoot);
        bullet1.setPosition(pos.x - 4, pos.y, pos.z - 7);
        const bulletComp1 = bullet1.getComponent(Bullet);
        bulletComp1.show(this.bulletSpeed, false, Constant.Direction.LEFT);

        // right
        // const bullet2 = instantiate(this.bullet05);
        const bullet2 = PoolManager.instance().getNode(this.bullet05, this.bulletRoot);
        // bullet2.setParent(this.bulletRoot);
        bullet2.setPosition(pos.x + 4, pos.y, pos.z - 7);
        const bulletComp2 = bullet2.getComponent(Bullet);
        bulletComp2.show(this.bulletSpeed, false, Constant.Direction.RIGHT);
    }

    /**
     * 创建敌机子弹
     * @param targetPos 敌机子弹位置
     */
    public createEnemyBullet(targetPos: Vec3) {
        // 子弹实例化
        // const bullet = instantiate(this.bullet01);
        const bullet = PoolManager.instance().getNode(this.bullet02, this.bulletRoot);
        // 将子弹放在子弹管理节点下面
        bullet.setParent(this.bulletRoot);
        // 设置子弹位置
        bullet.setPosition(targetPos.x, targetPos.y, targetPos.z + 6);
        // 设置子弹速度
        const bulletComp = bullet.getComponent(Bullet);
        bulletComp.show(1, true)

        /**
         * 敌机子弹分组
         */
        const colliderComp = bullet.getComponent(BoxCollider);
        colliderComp.setGroup(Constant.CollisionType.ENEMY_BULLET);
        colliderComp.setMask(Constant.CollisionType.SELF_PLANE);//设置掩码
    }

    /**
     * 创建敌机
     *
     */
    public createEnemyPlane() {
        // 两架飞机随机选一（1，2）
        const whichEnemy = math.randomRangeInt(1, 3)
        let prefab: Prefab = null
        let speed = 0
        // 创建敌机1或2
        if (whichEnemy == Constant.EnemyType.TYPE1) {
            prefab = this.enemy01
            speed = this.enemy1Speed
        } else {
            prefab = this.enemy02
            speed = this.enemy2Speed
        }

        // 预制实例化
        // const enemy = instantiate(prefab)
        const enemy = PoolManager.instance().getNode(prefab, this.node);
        console.log(enemy);

        enemy.setParent(this.node)
        const enemyComp = enemy.getComponent(EnemyPlane)
        enemyComp.show(this, speed, true)//单架敌机需要发射子弹

        // 设置飞机位置 
        const randomPos = math.randomRangeInt(-25, 26)
        enemy.setPosition(randomPos, 0, -50)
    }

    /**
     * 组合1创建 横向排列 z轴50，x轴从-20开始
     *
     */
    public createCombination1() {
        const enemyArray = new Array<Node>(5)//飞机数组
        for (let i = 0; i < enemyArray.length; i++) {
            // 敌机资源实例化
            // enemyArray[i] = instantiate(this.enemy01)
            enemyArray[i] = PoolManager.instance().getNode(this.enemy01, this.node);
            const element = enemyArray[i]
            element.parent = this.node
            element.setPosition(-20 + i * 10, 0, -50)//-20起始左位置，10飞机间隔，其实创建位置
            //设置飞机速度
            const enemyComp = element.getComponent(EnemyPlane)
            enemyComp.show(this, this.enemy1Speed, false)//组合飞机不需要发射子弹
        }
    }

    /**
     * 组合2创建 V字排列
     *
     */
    public createCombination2() {
        const enemyArray = new Array<Node>(7)//飞机数组
        // 位置数组
        const combinationPos = [
            -21, 0, -60,
            -14, 0, -55,
            -7, 0, -50,
            0, 0, -45,
            7, 0, -50,
            14, 0, -55,
            21, 0, -60
        ]

        for (let i = 0; i < enemyArray.length; i++) {
            // 敌机资源实例化
            // enemyArray[i] = instantiate(this.enemy02)
            enemyArray[i] = PoolManager.instance().getNode(this.enemy02, this.node);
            const element = enemyArray[i]
            element.parent = this.node
            const startIndex = i * 3//因为位置数组有7个 但是位置有3×7 21个  所以每架飞机位置偏移是3
            element.setPosition(combinationPos[startIndex], combinationPos[startIndex + 1], combinationPos[startIndex + 2])
            //设置飞机速度
            const enemyComp = element.getComponent(EnemyPlane)
            enemyComp.show(this, this.enemy2Speed, false)//组合飞机不需要发射子弹
        }
    }

    /**
     * 创建子弹道具
     * 随机1～3是根据然后创建相对应的道具
     */
    public createBulletProp() {
        const randomProp = math.randomRangeInt(1, 4);
        let prefab: Prefab = null;
        if (randomProp === Constant.BulletPropType.BULLET_H) {
            prefab = this.bulletPropH;
        } else if (randomProp === Constant.BulletPropType.BULLET_S) {
            prefab = this.bulletPropS;
        } else {
            prefab = this.bulletPropM;
        }
        //实例化道具
        // const prop = instantiate(prefab);
        const prop = PoolManager.instance().getNode(prefab, this.node);
        prop.setParent(this.node);
        prop.setPosition(15, 0, -50);
        const propComp = prop.getComponent(BulletProp);
        propComp.show(this, -this.bulletPropSpeed);
    }

    /**
     * 触摸状态设置
     * @param value  true/false
     */
    public isShooting(value: boolean) {
        this._isShooting = value;
    }

    /**
     * 改变子弹类型
     * @param type  类型
     */
    public changeBulletType(type: number) {
        this._bulletType = type;
    }

    /**
     * 播放音频
     * @param name 音频名字
     */
    public playAudioEffect(name: string) {
        this.audioEffect.play(name);
    }

    /**
     * 默认发射子弹
     */
    private _init() {
        this._currShootTime = this.shootTime;
        this.playerPlane.init();
        // this._changePlanMode();
    }

    /**
     * 设计定时器 
     */
    private _changePlanMode() {
        /**
         * 每10秒改变一次状态，，根据状态就能决定采用什么组合
         */
        this.schedule(this._modeChanged, 10, macro.REPEAT_FOREVER);//组件自带定时器(回调函数，间隔时间,重复次数，延迟时间)
    }

    /**
     * 改变组合状态
     */
    private _modeChanged() {
        this._combinationInterval++
        this.createBulletProp();//创建子弹道具
    }

    /**
     * 销毁所有的飞机与子弹
     */
    private _destroyAll() {
        let children = this.node.children;
        let length = children.length;
        let i = 0;
        for (i = length - 1; i >= 0; i--) {
            const child = children[i];
            // child.destroy();
            PoolManager.instance().putNode(child);
        }

        children = this.bulletRoot.children;
        length = children.length;
        for (i = length - 1; i >= 0; i--) {
            const child = children[i];
            // child.destroy();
            PoolManager.instance().putNode(child);
        }
    }
}

• EnemyPlane.ts

import { _decorator, Component, Node, Collider, ITriggerEvent } from 'cc';
import { Constant } from '../framework/Constant';
import { GameManager } from '../framework/GameManager';
import { PoolManager } from '../framework/PoolManager';
const { ccclass, property } = _decorator;


// 敌机销毁位置
const OUTOFBOUNCE = 50

@ccclass('EnemyPlane')
export class EnemyPlane extends Component {
    /** 子弹发射周期 */
    @property
    public createBulletTime = 0.5
    // 敌机速度
    private _enemySpeed = 0;
    private _needBullet = false//当前是否发射子弹
    private _gameManager: GameManager = null
    private _currCreateBulletTime = 0
    // // 敌机类型
    // public enemyType = Constant.EnemyType.TYPE1
    start() {
        // [3]
    }

    //监听事件
    onEnable() {
        const collider = this.getComponent(Collider);//获取碰撞组件
        collider.on('onTriggerEnter', this._onTriggerEnter, this);//碰撞到了立马处理逻辑
    }

    //取消事件
    onDisable() {
        const collider = this.getComponent(Collider);//获取碰撞组件
        collider.off('onTriggerEnter', this._onTriggerEnter, this);
    }

    update(deltaTime: number) {
        const pos = this.node.position
        const movePos = pos.z + this._enemySpeed
        // 因为敌机向西飞所以为正向
        this.node.setPosition(pos.x, pos.y, movePos)

        if (this._needBullet) {//发射子弹逻辑
            this._currCreateBulletTime += deltaTime
            if (this._currCreateBulletTime > this.createBulletTime) {
                this._gameManager.createEnemyBullet(this.node.position)
                this._currCreateBulletTime = 0
            }
        }

        if (movePos > OUTOFBOUNCE) {//超出边界销毁
            // this.node.destroy()
            PoolManager.instance().putNode(this.node);
        }
    }
    /**
     * 设置飞机移动速度
     * @param speed 移动速度
     */
    show(gameManager: GameManager, speed: number, needBullet: boolean) {
        this._gameManager = gameManager
        this._enemySpeed = speed
        this._needBullet = needBullet
    }

    private _onTriggerEnter(event: ITriggerEvent) {
        const collisionGroup = event.otherCollider.getGroup();//获取分组
        if (collisionGroup === Constant.CollisionType.SELF_PLANE || collisionGroup === Constant.CollisionType.SELF_BULLET) {//玩家飞机或者玩家子弹判断掉血
            // console.log('trigger enemy destroy');
            //敌方飞机销毁的时候播放音频
            this._gameManager.playAudioEffect('enemy');
            // this.node.destroy();
            PoolManager.instance().putNode(this.node);
            this._gameManager.addScore();//获得分数
        }
    }
}

• Bullet.ts

import { _decorator, Component, Node, Collider, ITriggerEvent } from 'cc';
import { Constant } from '../framework/Constant';
import { PoolManager } from '../framework/PoolManager';
const { ccclass, property } = _decorator;




@ccclass('Bullet')
export class Bullet extends Component {
    // 子弹速度
    private _bulletSpeed = 0;
    private _direction = Constant.Direction.MIDDLE;//子弹方向，默认直线发射
    private _isEnemyBullet = false;//判断是否是敌机子弹

    //监听事件
    onEnable() {
        const collider = this.getComponent(Collider);//获取碰撞组件
        collider.on('onTriggerEnter', this._onTriggerEnter, this);//碰撞到了立马处理逻辑
    }

    //取消事件
    onDisable() {
        const collider = this.getComponent(Collider);//获取碰撞组件
        collider.off('onTriggerEnter', this._onTriggerEnter, this);
    }

    update(deltaTime: number) {
        // 子弹移动
        const pos = this.node.position;
        let moveLength = 0

        // 敌机子弹
        if (this._isEnemyBullet) {
            moveLength = pos.z + this._bulletSpeed;
            this.node.setPosition(pos.x, pos.y, moveLength);
            // 超出屏幕销毁
            if (moveLength > 50) {//敌机子弹移动的最大位置范围为50
                PoolManager.instance().putNode(this.node);
                // this.node.destroy();
            }

        } else {//玩家子弹
            moveLength = pos.z - this._bulletSpeed;
             /**
             * * 根据子弹方向控制移动
             * 这里定义的左右一定是给扇形子弹使用的，因为其他直线发射就可以和il
             */
              if(this._direction === Constant.Direction.LEFT){
                this.node.setPosition(pos.x - this._bulletSpeed * 0.2, pos.y, moveLength);
            } else if(this._direction === Constant.Direction.RIGHT){
                this.node.setPosition(pos.x + this._bulletSpeed * 0.2, pos.y, moveLength);
            } else{
                this.node.setPosition(pos.x, pos.y, moveLength);
            }
            // 超出屏幕销毁
            if (moveLength < -50) {//玩家子弹移动的最大位置范围为-50
                PoolManager.instance().putNode(this.node);
                // this.node.destroy();
            }
        }

    }

    /**
     * 设置子弹移动速度即判断子弹是谁发出的
     * @param speed  子弹速度
     * @param isEnemyBullet 是否是敌机子弹
     */
    show(speed: number, isEnemyBullet: boolean, direction = Constant.Direction.MIDDLE) {
        this._bulletSpeed = speed
        this._isEnemyBullet = isEnemyBullet
        this._direction = direction;
    }

    /**
     * 子弹碰撞销毁
     * @param event:ITriggerEvent
     */
    private _onTriggerEnter(event: ITriggerEvent) {
        console.log('trigger  bullet destroy');
        // this.node.destroy();
        PoolManager.instance().putNode(this.node);
    }
}

• BulletProp.ts

import { _decorator, Component, Node, Collider, ITriggerEvent } from 'cc';
import { Constant } from '../framework/Constant';
import { GameManager } from '../framework/GameManager';
import { PoolManager } from '../framework/PoolManager';
const { ccclass, property } = _decorator;


@ccclass('BulletProp')
export class BulletProp extends Component {
    private _propSpeed = 0.3;//道具移动速度
    private _propXSpeed = 0.3;//X轴移动速度
    private _gameManager: GameManager = null;

    onEnable () {
        const collider = this.getComponent(Collider);
        collider.on('onTriggerEnter', this._onTriggerEnter, this);
    }

    onDisable () {
        const collider = this.getComponent(Collider);
        collider.off('onTriggerEnter', this._onTriggerEnter, this);
    }

    update (deltaTime: number) {
        let pos = this.node.position;//获取位置
        if (pos.x >= 15) {//到右边界处理
            this._propXSpeed = this._propSpeed;
        } else if (pos.x <= -15) {//到左边界处理
            this._propXSpeed = -this._propSpeed;
        }

        this.node.setPosition(pos.x + this._propXSpeed, pos.y, pos.z - this._propSpeed);
        pos = this.node.position;
        //超出50销毁
        if(pos.z > 50){
            // this.node.destroy();
            PoolManager.instance().putNode(this.node);
        }
    }
    //传速度与gameManager
    show(gameManager: GameManager, speed: number){
        this._gameManager = gameManager;
        this._propSpeed = speed;
    }

    private _onTriggerEnter(event: ITriggerEvent){
        const name = event.selfCollider.node.name;
        // 根据名字替换子弹
        if(name === 'bulletH'){
            this._gameManager.changeBulletType(Constant.BulletPropType.BULLET_H);
        } else if (name === 'bulletS') {
            this._gameManager.changeBulletType(Constant.BulletPropType.BULLET_S);
        } else {
            this._gameManager.changeBulletType(Constant.BulletPropType.BULLET_M);
        }

        // this.node.destroy();
        PoolManager.instance().putNode(this.node);
    }
}