节点池描述
通过节点池,您可以更方便地对节点进行分组管理,例如节点运维、节点配置、开启节点自动弹性伸缩、批量管理、指定调度等。本文介绍节点池的概念、使用说明、使用限制,以及节点池分类.
就飞机大战例子而言:每次都去实例子弹\敌机,这个过程现在数量不大看起来好像很快,但是也会损耗性能,而且子弹和敌机都是不断产出的,所以应该将不要的对象放在节点池里做库存,等到下次有需要的时候再从池子里取出(好处是不仅能提高效率还能提高性能)
创建节点池脚本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);
}
}