273 lines
8.3 KiB
TypeScript
273 lines
8.3 KiB
TypeScript
import {
|
|
Animation,
|
|
Component,
|
|
Node,
|
|
NodePool,
|
|
Prefab,
|
|
Tween,
|
|
Vec2,
|
|
Vec3,
|
|
_decorator,
|
|
game,
|
|
instantiate,
|
|
tween,
|
|
} from 'cc'
|
|
|
|
import FishBase from '../../../fish/script/FishBase'
|
|
import FishMover from '../../../fish/script/FishMover'
|
|
import FishUI from '../../../fish/script/FishUI'
|
|
import { Logger } from '../../engine/utils/Logger'
|
|
import RandomUtil from '../../engine/utils/RandomUtil'
|
|
import { FishConfig } from '../config/FishConfig'
|
|
import { FishInfo } from '../config/FishInfo'
|
|
import { FishMap } from '../config/FishMap'
|
|
import { FishMapInfo } from '../config/FishMapInfo'
|
|
import { FishPathConfig } from '../config/FishPathConfig'
|
|
import GameMusicHelper from '../utils/GameMusicHelper'
|
|
|
|
import TimeHelper from '../utils/TimeHelper'
|
|
|
|
import ScoreManager from './ScoreManager'
|
|
import WsManager from './WsManager'
|
|
import { FishPathInfo } from '../config/FishPathInfo'
|
|
|
|
const { ccclass, property } = _decorator
|
|
|
|
interface dataType {
|
|
fisn: Array<FishType>
|
|
}
|
|
|
|
interface FishType {
|
|
fishId: string
|
|
fishInfo: FishInfo
|
|
fishType: string
|
|
isDead: number
|
|
fishPathInfo: Array<fishPathInfoType>
|
|
}
|
|
|
|
interface fishPathInfoType {
|
|
pathId: string
|
|
path: Array<PathPoint>
|
|
}
|
|
|
|
interface PathPoint {
|
|
x: number
|
|
y: number
|
|
}
|
|
|
|
// 鱼管理类
|
|
@ccclass('FishManager')
|
|
export default class FishManager extends Component {
|
|
public static instance: FishManager = null
|
|
@property({ type: Node })
|
|
private fishContainer: Node | null = null
|
|
|
|
@property({ type: [Prefab] })
|
|
public fishPrefabList: Array<Prefab> = []
|
|
|
|
private fishPool: Array<NodePool> = []
|
|
private fishList: Map<string, FishBase> = new Map()
|
|
private nextRandomFishTime: number = 0
|
|
private minRandomTime: number = 2 * (game.frameRate as number)
|
|
private maxRandomTime: number = 5 * (game.frameRate as number)
|
|
private isFishMap: boolean = false
|
|
private mapCount: number = 0
|
|
|
|
private _fishPosCache: Vec3
|
|
|
|
onLoad() {
|
|
WsManager.instance.on(100, this.randomFish, this)
|
|
FishManager.instance = this
|
|
this._fishPosCache = new Vec3()
|
|
Logger.log('maxRandomTime=', this.minRandomTime, this.maxRandomTime, game.frameRate)
|
|
}
|
|
|
|
start() {
|
|
// this.randomFish()
|
|
}
|
|
|
|
update() {
|
|
// this.checkRandomFish()
|
|
this.checkFishMoveEnd()
|
|
// this.checkFishMap()
|
|
}
|
|
|
|
private checkFishMap() {
|
|
if (!this.isFishMap) {
|
|
if (this.mapCount > 0) {
|
|
this.mapCount--
|
|
if (this.mapCount <= 0) FishUI.instance.playWaveEffect()
|
|
}
|
|
}
|
|
}
|
|
|
|
// 检测是否随机鱼
|
|
private checkRandomFish() {
|
|
if (!this.isFishMap) {
|
|
if (this.nextRandomFishTime > 0) {
|
|
this.nextRandomFishTime--
|
|
// if (this.nextRandomFishTime === 0) this.randomFish()
|
|
}
|
|
}
|
|
}
|
|
|
|
// 检测鱼是否移动结束
|
|
private checkFishMoveEnd() {
|
|
this.fishList.forEach(async (item: FishBase, key: string) => {
|
|
if (this.isFishMap) {
|
|
// 鱼阵回收
|
|
if (item.isDead === 2) {
|
|
item.node.getPosition(this._fishPosCache)
|
|
this._fishPosCache.x -= 2
|
|
item.node.setPosition(this._fishPosCache)
|
|
if (this._fishPosCache.x <= -screen.width / 2) {
|
|
// winSize.width
|
|
await WsManager.instance.onSend({
|
|
type: 102,
|
|
fish_id: item.fishId,
|
|
})
|
|
// this.fishList.splice(index, 1)
|
|
this.destroyFish(item)
|
|
// this.fishList.delete(item.fishId)
|
|
this.checkEndFishMap()
|
|
}
|
|
}
|
|
} else if (!item.getComponent(FishMover).isMoving) {
|
|
// 普通鱼回收
|
|
await WsManager.instance.onSend({
|
|
type: 102,
|
|
fish_id: item.fishId,
|
|
})
|
|
// this.fishList.splice(index, 1)
|
|
this.destroyFish(item)
|
|
// this.fishList.delete(item.fishId)
|
|
}
|
|
})
|
|
}
|
|
|
|
private checkEndFishMap() {
|
|
// Logger.log('checkEndFishMap==', this.isFishMap, this.fishList)
|
|
if (this.isFishMap && this.fishList.size <= 0) {
|
|
this.isFishMap = false
|
|
// this.randomFish()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 原：本地随机生成鱼
|
|
* 新：服务端生成鱼
|
|
*/
|
|
private async randomFish(data: dataType) {
|
|
const arr = data.fisn
|
|
const paths: Array<FishPathInfo> = []
|
|
if (!Array.isArray(arr) || this.isFishMap) return
|
|
for (let i = 0; i < arr.length; i++) {
|
|
const fish: FishBase = this.createFishByType(arr[i])
|
|
for (let k = 0; k < arr[i].fishPathInfo.length; k++) {
|
|
const path: Array<Vec2> = []
|
|
|
|
for (let j = 0; j < arr[i].fishPathInfo[k].path.length; j++) {
|
|
const p: Vec2 = new Vec2(
|
|
arr[i].fishPathInfo[k].path[j].x,
|
|
arr[i].fishPathInfo[k].path[j].y,
|
|
)
|
|
path.push(p)
|
|
}
|
|
paths.push(new FishPathInfo(arr[i].fishPathInfo[k].pathId, path))
|
|
}
|
|
fish.fishPathInfo = paths[0]
|
|
this._fishPosCache.z = 0
|
|
this._fishPosCache.x = fish.fishPathInfo.path[0].x
|
|
this._fishPosCache.y = fish.fishPathInfo.path[0].y
|
|
fish.node.setPosition(this._fishPosCache)
|
|
fish.getComponent(FishMover).bezierPList = fish.fishPathInfo.path
|
|
fish.getComponent(FishMover).startMove()
|
|
// this.fishList.push(fish)
|
|
this.fishList.set(fish.fishId, fish)
|
|
// this.fishContainer.addChild(fish.node)
|
|
this.fishContainer.addChild(this.fishList.get(fish.fishId).node)
|
|
}
|
|
}
|
|
|
|
// 创建鱼类
|
|
public createFishByType(data: FishType | any): FishBase {
|
|
let fishNode: Node
|
|
const fishType: number = Number(data.fishType)
|
|
if (this.fishPool[fishType - 1] && this.fishPool[fishType - 1].size() > 0) {
|
|
fishNode = this.fishPool[fishType - 1].get()
|
|
} else {
|
|
fishNode = instantiate(this.fishPrefabList[fishType - 1])
|
|
}
|
|
TimeHelper.exeNextFrame(fishNode, () => fishNode.getComponent(Animation).play())
|
|
const fishInfo: FishInfo = FishConfig.getFishInfoByType(fishType)
|
|
fishNode.getComponent(FishBase).fishInfo = fishInfo
|
|
fishNode.getComponent(FishBase).fishType = fishType
|
|
fishNode.getComponent(FishBase).fishId = data.fishId
|
|
fishNode.getComponent(FishBase).isDead = 2
|
|
return fishNode.getComponent(FishBase)
|
|
}
|
|
|
|
// 销毁鱼类
|
|
public killFish(res: any) {
|
|
const fishCheck = this.fishList.get(res.fish_id)
|
|
// console.log('正在执行销毁=', fishCheck.fishId, res.fish_id, res.fish_status, fishCheck.isDead)
|
|
if (fishCheck) {
|
|
fishCheck.isDead = 1
|
|
setTimeout(() => {
|
|
GameMusicHelper.playFishDead(fishCheck.fishType)
|
|
fishCheck.node.getPosition(this._fishPosCache)
|
|
const vec2 = new Vec2(this._fishPosCache.x, this._fishPosCache.y)
|
|
ScoreManager.instance.addScore(Number(res.fish_number), vec2)
|
|
this.destroyFish(fishCheck)
|
|
// console.log('killFish=', fishCheck.fishId, fishCheck.fishInfo.name)
|
|
this.checkEndFishMap()
|
|
}, 500)
|
|
tween(fishCheck.node)
|
|
.repeatForever(tween().by(0.6, { angle: -360 }))
|
|
.start()
|
|
|
|
// this.fishList.splice(index, 1)
|
|
}
|
|
}
|
|
|
|
private destroyFish(fish: FishBase) {
|
|
const f = this.fishList.get(fish.fishId)
|
|
if (!f) return
|
|
if (!this.fishPool[f.fishType - 1]) {
|
|
this.fishPool[f.fishType - 1] = new NodePool()
|
|
}
|
|
this.fishPool[f.fishType - 1].put(f.node)
|
|
this.fishList.delete(f.fishId)
|
|
}
|
|
|
|
public playFishMap() {
|
|
this.isFishMap = true
|
|
this.fishList.forEach((fish: FishBase, key: string) => {
|
|
this.destroyFish(fish)
|
|
})
|
|
}
|
|
|
|
public startFishMap() {
|
|
const map: FishMap = FishPathConfig.randomFishMap()
|
|
const fishMapInfoList: Array<FishMapInfo> = map.fishMapInfoList
|
|
Logger.log('startFishMap==', this.isFishMap, this.fishList, map)
|
|
for (let i = 0; i < fishMapInfoList.length; i++) {
|
|
const fishMapInfo: FishMapInfo = fishMapInfoList[i]
|
|
// 暂时屏蔽
|
|
// @ts-ignore
|
|
const fish: FishBase = this.createFishByType(fishMapInfo.fishType)
|
|
fish.node.angle = 0
|
|
this.fishContainer.addChild(fish.node)
|
|
fish.node.setPosition(fishMapInfo.x + screen.width, fishMapInfo.y)
|
|
this.fishList.set(fish.fishId, fish)
|
|
}
|
|
}
|
|
|
|
onDestroy() {
|
|
FishManager.instance = null
|
|
WsManager.instance.off(100)
|
|
}
|
|
|
|
protected onDisable(): void {}
|
|
}
|