GunfightShoot/assets/scripts/game/GMap.ts

import { _decorator, easing, MeshRenderer, Node, rect, tween, Vec3 } from 'cc';
import { BaseExp } from '../core/base/BaseExp';
import { autoBind } from '../extend/AutoBind';
import { Utils } from '../utils/Utils';
const { ccclass, property } = _decorator;

//坐标类
export class MPos{
    //位置坐标
    public pos: Vec3 = Vec3.ZERO;
    //该站立点是否已经有人在此站位了
    public isVacancy: boolean = false;
}


//埋伏点接口类
export class AmbushPoint {
    //埋伏点位置节点数组
    public standPosArr: MPos[] = [];
    //中间路径节点
    public roadPosArr: MPos[] = [];
    //掩体点位置节点
    public ambushPosArr: MPos[] = [];
    //逃跑点位置节点
    public escapePosArr: MPos[] = [];
    //改大的堆点是否已经遍历过
    public isVacancy: boolean = false;
}

@ccclass('GMap')
export class GMap extends BaseExp {
    @autoBind({ type: Node, tooltip: "埋伏点配置节点" })
    public ambush_points: Node = null;
    @autoBind({type:Node,tooltip:"敌人出生区域"})
    public enemy_born_area: Node = null;
    @autoBind({type:Node,tooltip:"进门内线,用于敌人是否在门内"})
    public miidle_inline: Node = null;
    @autoBind({type:Node,tooltip:"进门外线,用于敌人是否在门外"})
    public miidle_outline: Node = null;
    @autoBind({type:Node,tooltip:"进去的大门"})
    public doors: Node = null;
    @autoBind({type:Node,tooltip:"杂物节点，处理连环爆炸"})
    public sundries: Node = null;

    //埋伏点配置数组
    public ambushPoints: AmbushPoint[] = [];
    //游戏速度
    public game_speed: number = 1;

    start() {
        /*测试时使用 玩家坐标转换
        let n: Node = this.node.getChildByName('player_points');
        let pwww:Vec3 = Utils.convertPosition(this.node.getChildByName("player"),n);
        console.log("GGGGGGG = " + pwww);*/
        //区域隐藏
        const nodes:Node[] = this.ambush_points.children.flatMap(child => child.children);
        [this.enemy_born_area,this.miidle_inline,this.miidle_outline]
        .concat(nodes).forEach(e => {
            e.active = false;
        });
    }

    /**
     * 开门动画
     */
    public openDoor(){
        const left: Node = this.doors.children[0];
        if(left){//左门动画
            tween(left)
                .delay(0.2)
                .to(0.7, { eulerAngles: new Vec3(90, 0, 0) }, {
                    easing: easing.elasticOut,
                    onUpdate: (target, ratio: number) => {
                        target.setRotationFromEuler(target.eulerAngles);
                    }
                })
                .start();
        }
        const right: Node = this.doors.children[1];
        if(right){//右门动画
            tween(right)
                .to(0.7, { eulerAngles: new Vec3(90, 0, 0) }, {
                    easing: easing.elasticOut,
                    onUpdate: (target, ratio: number) => {
                        target.setRotationFromEuler(target.eulerAngles);
                    }
                })
                .start();
        }
    }

    /**
     * 游戏速度
     */
    public multiplySpeed(): number{
        return this.game_speed;
    }

    /**
     * 解析埋伏点
     */
    private parseAmbushPoints() {
        this.ambushPoints = this.ambush_points.children
            .filter(e=>e.active)
            .map(ambushNode => {
                const point = new AmbushPoint();
                point.isVacancy = false;
                //转换为MPos类
                point.standPosArr = ambushNode.children
                    .filter(e => e.name.startsWith('stand_'))
                    .map(node => {
                        let mpos = new MPos();
                        mpos.pos = node.worldPosition.clone();
                        mpos.isVacancy = false;
                        return mpos;
                    });
                point.roadPosArr = ambushNode.children
                    .filter(e => e.name.startsWith('road_'))
                    .sort((a, b) => {
                        const getNumber = (name: string) => {
                            const numPart = name.split('_').pop();
                            return parseInt(numPart || '0', 10);
                        };
                        return getNumber(a.name) - getNumber(b.name);
                    })
                    .map(node => {
                        let mpos = new MPos();
                        mpos.pos = node.worldPosition.clone();
                        mpos.isVacancy = false;
                        return mpos;
                    });
                
                point.ambushPosArr = ambushNode.children
                    .filter(e => e.name.startsWith('bunker_'))
                    .map(node => {
                        let mpos = new MPos();
                        mpos.pos = node.worldPosition.clone();
                        mpos.isVacancy = false;
                        return mpos;
                    });
                
                point.escapePosArr = ambushNode.children
                    .filter(e => e.name.startsWith('escape_'))
                    .map(node => {
                        let mpos = new MPos();
                        mpos.pos = node.worldPosition.clone();
                        mpos.isVacancy = false;
                        return mpos;
                    });
                
                return point;
            });
    }

    /**
     * 根据敌人信息得到敌人行走路径
     * @param eData 敌人数据
     * @param size 预制体大小
     * @returns 
     */
    public getPaths(eData: any){
        let bornPos: Vec3 = this.getRandomBornPosition();
        //进入外门时的坐标
        const outerPos: Vec3 = this.getRandomPos(eData,this.miidle_outline);
         //进入内门时的坐标
        const innerPos: Vec3 = this.getRandomPos(eData,this.miidle_inline);
        //行走路径
        let paths: Array<Vec3> = [bornPos,outerPos,innerPos];
        //最后一个点特殊处理 包含(站位点、埋伏点、逃跑点) 随机一个埋伏点
        const ambush: AmbushPoint = this.getAmbushClas();
        ambush.isVacancy = true;
        eData.ambush = ambush;
        //查找中间路径点
        paths = paths.concat(ambush.roadPosArr.map(mpos => mpos.pos));
        //随机一个站立点到最后坐标
        paths.push(this.getStandPos(ambush.standPosArr));
        //测试时使用
        /*paths.forEach(e => {
            console.log("FFFFFF = " + this.node.getComponent(UITransform).convertToNodeSpaceAR(e));
        });*/
        return paths;
    }

    /**
     * 得到一个敌人的站位点
     */
    private getStandPos(standPosArr: MPos[]): Vec3 {
        if(standPosArr.length <= 0){
           return Vec3.ZERO;
        }else{
            //获取所有可用的站位点（未被占用的）
            const availablePoints = standPosArr.filter(p => !p.isVacancy);
            //随机返回一个可用站位点 当所有点位都被占用时，随机返回任意一个
            let isAddRandom: boolean = availablePoints.length <= 0;
            let points: MPos[] = availablePoints.length > 0 ? availablePoints : standPosArr;
            let pos: Vec3 = Utils.randomArray(points)[0].pos;
            if(isAddRandom){
                pos.x += Utils.getRandomFloat(-0.5,0.5);
                pos.z += Utils.getRandomFloat(-0.5,0.5);
            }
            return pos;
        }
    }

    /**
     * 得到一个堆点类
     */
    private getAmbushClas(){
        if(!this.ambushPoints 
            || this.ambushPoints.length <= 0){
            //埋伏点类解析
            this.parseAmbushPoints();
        }
        //获取所有可用的埋伏点（未被占用的）
        const availablePoints = this.ambushPoints.filter(p => !p.isVacancy);
        //随机返回一个可用埋伏点 当所有点位都被占用时，随机返回任意一个
        let points: AmbushPoint[] = availablePoints.length > 0 ? availablePoints : this.ambushPoints;
        return Utils.randomArray(points)[0];
    }

    /**
     * 根据两个坐标点产生一个两个坐标点之前的随机点
     */
    public getRandomPos(eData:any,target: Node): Vec3 {
        //只有坦克走中间
        const isTan: boolean = eData.id == 20003;
        if(isTan){
           return target.worldPosition.clone();
        }
        let basePos: Vec3 = target.children[0].worldPosition.clone();
        if(target.children.length >= 2){
            let pos1: Vec3 = target.children[0].worldPosition.clone();
            let pos2: Vec3 = target.children[1].worldPosition.clone();
            //生成0-1的随机比例因子
            const ratio = Utils.getRandomFloat(0, 1);
            //分别在x和z轴进行线性插值 这儿为了看起来暂时保留x轴上的距离随机
            basePos.x = pos1.x + (pos2.x - pos1.x) * ratio;
            //y轴就是左边的间隔的距离
            basePos.z = pos1.z + (pos2.z - pos1.z) * ratio;
        }
        return basePos;
    }

    /**
     * 获取随机出生点位置
     */
    public getRandomBornPosition(): Vec3 {
        if (!this.enemy_born_area) return Vec3.ZERO;
        //获取3D节点的世界缩放
        const worldScale = this.enemy_born_area.getWorldScale();
        //使用X和Z轴缩放作为区域尺寸
        const areaWidth = worldScale.x;
        const areaDepth = worldScale.z;
        //在XZ平面生成随机坐标（Y轴保持地面高度）
        const randomX = (Math.random() - 0.5) * areaWidth;
        const randomZ = (Math.random() - 0.5) * areaDepth;
        //基于节点原点位置生成世界坐标 保持与出生区域相同高度
        const basePos = this.enemy_born_area.worldPosition;
        return new Vec3(
            basePos.x + randomX,
            basePos.y,
            basePos.z + randomZ
        );
    }


    /**
     * 还原数据
     */
    public resetData(){
        this.ambushPoints.forEach((e: AmbushPoint) => {
            e.isVacancy = false;
            e.standPosArr.forEach((a: MPos) => a.isVacancy = false);
            e.roadPosArr.forEach((b: MPos) => b.isVacancy = false);
            e.ambushPosArr.forEach((c: MPos) => c.isVacancy = false);
            e.escapePosArr.forEach((d: MPos) => d.isVacancy = false);
        });
    }
}