mergeRPG_client/assets/script/logic/gridMap/UEGridMap.ts

import Gamecfg from "../../common/gameCfg";
import { gameMethod } from "../../common/gameMethod";
import { xlsChapterLayout } from "../../common/xlsConfig";
import UEBase from "../../frameWork/compment/UEBase";
import { uiCommon } from "../../utils/UICommon";
import { GridConstant } from "./GridConstant";
import { GridEvent } from "./GridEvent";
import UECell, { I_CellData } from "./UECell";
import UECube from "./UECube";

const { ccclass, property } = cc._decorator;
const DRAG_THRESHOLD: number = 10; // 拖动判定阈值（像素）

@ccclass
export default class UEGridMap extends UEBase {
    static readonly BundleKey: string = "gridMap";
    static readonly PrefabUrl: string = "UEGridMap";
    static readonly CLS: string = "UEGridMap";
    @property(cc.Prefab)
    cellPrefab: cc.Prefab = null!;
    @property(cc.Prefab)
    cubePrefab: cc.Prefab = null!;
    @property(cc.Node)
    gridLayer: cc.Node = null;
    @property(cc.Node)
    cellLayer: cc.Node = null;
    @property(cc.Node)
    cubeLayer: cc.Node = null;
    cellMap: { [gid: number]: UECell } = {};
    private isDragging: boolean = false;
    private dragStartPos: cc.Vec2 = cc.v2(0, 0);
    private selectedCell: UECell = null!;
    private clickCnt: number = 0;
    Init() {
        this.gridLayer.setContentSize(GridConstant.CELL_WIDTH * GridConstant.ROW, GridConstant.CELL_HEIGHT * GridConstant.COL);
        this.LoadMapData();
        this.InitEvent();
    }

    InitEvent(): void {
        this.gridLayer.on(cc.Node.EventType.TOUCH_START, this.OnTouchStart, this);
        this.gridLayer.on(cc.Node.EventType.TOUCH_MOVE, this.OnTouchMove, this);
        this.gridLayer.on(cc.Node.EventType.TOUCH_END, this.OnTouchEnd, this);
        this.gridLayer.on(cc.Node.EventType.TOUCH_CANCEL, this.OnTouchEnd, this);
        this.initEvent(GridEvent.TRIGGER_EMITTER, this.TriggerEmitter);
    }


    /** 加载地图数据 */
    private LoadMapData() {
        let chapterInfoCfg = Gamecfg.chapterInfo.getItem("1");
        let layoutCfg = Gamecfg.chapterLayoutList.getItemList("1");
        let layoutGridMap: { [grid: number]: xlsChapterLayout } = {};
        layoutCfg.forEach(element => {
            layoutGridMap[element.grid] = element;
        });
        this.cellMap = {};
        for (let i = 0; i < GridConstant.COL; i++) {
            let rowCells = [];
            let rowCubes = [];
            for (let j = 0; j < GridConstant.ROW; j++) {
                let idx = (i + 1) * 10 + (j + 1);
                if (chapterInfoCfg.grid.indexOf(idx) != -1) {
                    let cell = this.CreateCell(i, j);
                    rowCells.push(cell);
                    let cellCfg: xlsChapterLayout = layoutGridMap[idx];
                    let cube = null;
                    if (cellCfg) {
                        cube = this.CreateCube(i, j);
                        rowCubes.push(cube);
                        cube.Init({
                            type: cellCfg.type,
                            id: cellCfg.correlationId,
                            zIndex: idx,
                            unlock: cellCfg.unlock
                        }, idx)
                    }
                    cell.Init({
                        zIndex: idx,
                        ueCube: cube
                    });
                    this.cellMap[idx] = cell;
                }
            }

        }
    }

    /** 根据索引获取实际像素坐标 */
    private GetPosByIdx(i: number, j: number): cc.Vec3 {
        const startX = -(GridConstant.ROW * GridConstant.CELL_WIDTH) / 2;
        const startY = (GridConstant.COL * GridConstant.CELL_HEIGHT) / 2;
        return cc.v3(
            startX + j * GridConstant.CELL_WIDTH + GridConstant.CELL_WIDTH / 2,
            startY - i * GridConstant.CELL_HEIGHT - GridConstant.CELL_HEIGHT / 2
        )
    }

    /** 创建格子 */
    private CreateCell(i: number, j: number) {
        let cell = cc.instantiate(this.cellPrefab).getComponent(UECell);
        this.cellLayer.addChild(cell.node);
        cell.node.width = GridConstant.CELL_WIDTH;
        cell.node.height = GridConstant.CELL_HEIGHT;
        let pos = this.GetPosByIdx(i, j);
        cell.node.setPosition(pos);
        return cell;
    }

    /** 创建棋子 */
    private CreateCube(i: number, j: number) {
        let cube = cc.instantiate(this.cubePrefab).getComponent(UECube);
        this.cubeLayer.addChild(cube.node);
        cube.node.width = GridConstant.CELL_WIDTH;
        cube.node.height = GridConstant.CELL_HEIGHT;
        let pos = this.GetPosByIdx(i, j);
        cube.node.setPosition(pos);
        return cube;
    }

    private OnTouchStart(event: cc.Event.EventTouch): void {
        const touchPos = this.gridLayer.convertToNodeSpaceAR(event.getLocation());
        const cell = this.GetCellByPos(touchPos);
        if (cell && cell.CanDrag()) {
            this.dragStartPos = touchPos;
            if (this.selectedCell && this.selectedCell != cell) {
                this.selectedCell.SetSelect(false);
                this.clickCnt = 1;
            } else if (!this.selectedCell) {
                this.clickCnt = 1;
            }
            this.selectedCell = cell;
            cell.SetSelect(true);
        }
    }

    private OnTouchMove(event: cc.Event.EventTouch): void {
        if (!this.selectedCell || !this.dragStartPos) return;

        const touchPos = this.gridLayer.convertToNodeSpaceAR(event.getLocation());
        const distance = touchPos.sub(this.dragStartPos).mag();

        // 只有当移动距离超过阈值时才开始拖动
        if (!this.isDragging && distance >= DRAG_THRESHOLD) {
            this.isDragging = true;
            this.selectedCell.GetCube().StartDrag();
            this.selectedCell.SetSelect(false);
        }

        if (this.isDragging) {
            // 计算移动差值并应用到cube节点
            const deltaPos = touchPos.sub(this.dragStartPos);
            const cube = this.selectedCell.GetCube();
            const originalPos = cube.node.getPosition();
            cube.node.setPosition(originalPos.x + deltaPos.x, originalPos.y + deltaPos.y);
            this.dragStartPos = touchPos;
        }
    }

    private OnTouchEnd(event: cc.Event.EventTouch): void {
        this.dragStartPos = null;
        if (!this.selectedCell) return;
        const touchPos = this.gridLayer.convertToNodeSpaceAR(event.getLocation());
        const targetCell = this.GetCellByPos(touchPos);
        if (!this.isDragging && this.selectedCell === targetCell) {
            //二次点击同一个格子
            if (!targetCell.IsEmpty()) {
                targetCell.GetCube().PlayJellyAnim();
                if (this.clickCnt >= 2) {
                    console.log("二次点击同一个格子");
                    targetCell.GetCube().TriggerClick();
                } else {
                    this.clickCnt++;
                }
            }
        } else {
            if (!this.isDragging) return;
            if (targetCell && targetCell != this.selectedCell) {
                this.TryMergeItems(this.selectedCell, targetCell);
                this.selectedCell.SetSelect(false);
                targetCell.SetSelect(true);
            } else {
                this.selectedCell.GetCube().BackToOriginalPos(true);
            }
            this.isDragging = false;
            this.selectedCell = targetCell;
        }

    }

    /** 根据像素坐标获取格子 */
    private GetCellByPos(pos: cc.Vec2): UECell | null {
        const startX = -(GridConstant.ROW * GridConstant.CELL_WIDTH) / 2;
        const startY = (GridConstant.COL * GridConstant.CELL_HEIGHT) / 2;

        const row = Math.floor((pos.x - startX) / GridConstant.CELL_WIDTH);
        const col = Math.floor((startY - pos.y) / GridConstant.CELL_HEIGHT);

        if (col >= 0 && col < GridConstant.COL && row >= 0 && row < GridConstant.ROW) {
            let idx = (col + 1) * 10 + (row + 1);
            return this.cellMap[idx];
        }
        return null;
    }

    /** 尝试合成 */
    private TryMergeItems(fromCell: UECell, toCell: UECell): void {
        if (toCell.IsEmpty()) {
            //格子上没有物品
            fromCell.MoveCubeToCell(toCell);
            toCell.SetCube(fromCell.GetCube());
            fromCell.SetCube(null);
        } else if (this.CanMergeItems(fromCell, toCell)) {
            toCell.GetCube().PlayMergeAnim();
            fromCell.ClearCube();
            toCell.ClearCube();
            let vec = this.TranIdxToPos(toCell.GetZIndex());
            let mergeCube = this.CreateCube(vec.y, vec.x);
            mergeCube.Init({
                type: 3,
                id: 10022,
                zIndex: toCell.GetZIndex(),
                unlock: 0
            });
            toCell.SetCube(mergeCube);
        } else {
            this.SwitchCell(fromCell, toCell);
        }
    }

    private TranIdxToPos(idx: number): cc.Vec2 {
        let row = idx % 10;
        let col = Math.floor(idx / 10);
        return cc.v2(row - 1, col - 1);
    }

    private CanMergeItems(fromCell: UECell, toCell: UECell): boolean {
        if (fromCell.GetCube().GetCubeData().type == toCell.GetCube().GetCubeData().type) {
            return true;
        }

        return false;
    }

    private SwitchCell(fromCell: UECell, toCell: UECell): void {
        //交换格子
        let fromCube = fromCell.GetCube();
        let toCube = toCell.GetCube();
        fromCell.SetCube(toCube);
        toCell.SetCube(fromCube);
        toCube.MoveToNewPos(cc.v3(fromCell.node.x, fromCell.node.y));
        fromCube.MoveToNewPos(cc.v3(toCell.node.x, toCell.node.y), 0.05);
    }

    private GetEmptyCell(): UECell {
        for (const key in this.cellMap) {
            const element = this.cellMap[key];
            if (element.IsEmpty()) {
                return element;
            }
        }
        return null;
    }

    /** 发射出新的物品 */
    private TriggerEmitter(idx: number, itemId: number, targetIdx: number) {
        let emptyCell = this.GetEmptyCell();
        if (!emptyCell) return;
        targetIdx = emptyCell.GetZIndex();
        let startPos = this.TranIdxToPos(idx);
        let mergeCube = this.CreateCube(startPos.y, startPos.x);
        mergeCube.Init({
            type: 3,
            id: itemId,
            zIndex: idx,
            unlock: 0
        });
        emptyCell.SetCube(mergeCube);
        mergeCube.SetZIndex(1000);
        let targetPos = this.TranIdxToPos(targetIdx);

        // 设置动画时间
        const duration = 0.8;
        // 设置最大高度（向上弹跳的高度）
        const maxHeight = 400;

        // 计算起点和终点
        const startWorldPos = mergeCube.node.getPosition();
        const endWorldPos = this.GetPosByIdx(targetPos.y, targetPos.x);

        // 计算方向向量和总距离
        const moveVec = cc.v2(endWorldPos.x - startWorldPos.x, endWorldPos.y - startWorldPos.y);
        const totalDistance = moveVec.mag();
        const normalizedDir = moveVec.normalize();

        // 计算最后弹跳的起点（在终点前100像素）
        const bounceStartPos = cc.v3(
            endWorldPos.x - normalizedDir.x * 100,
            endWorldPos.y - normalizedDir.y * 100,
            0
        );

        // 创建第一段抛物线（抛向空中然后落到弹跳起点）
        const bezier1 = [];
        const midPoint1 = cc.v3(
            startWorldPos.x + moveVec.x * 0.3,
            Math.max(startWorldPos.y, bounceStartPos.y) + maxHeight,
            0
        );
        bezier1.push(cc.v2(startWorldPos.x, startWorldPos.y));
        bezier1.push(cc.v2(midPoint1.x, midPoint1.y));
        bezier1.push(cc.v2(bounceStartPos.x, bounceStartPos.y));

        // 创建最后的弹跳到终点
        const bezier2 = [];
        const bounceHeight = 80; // 弹跳高度

        // 计算弹跳的最高点（在起跳点和终点之间）
        const bounceTopPoint = cc.v2(
            (bounceStartPos.x + endWorldPos.x) / 2,  // 水平位置在中间
            endWorldPos.y + bounceHeight  // 垂直高度为弹跳高度
        );
        // const bounceSecondPos = cc.v3(
        //     endWorldPos.x - normalizedDir.x * 100,
        //     endWorldPos.y - normalizedDir.y * 100,
        //     0
        // );

        // 最后一次弹跳到终点
        bezier2.push(cc.v2(bounceStartPos.x, bounceStartPos.y)); // 起跳点
        bezier2.push(bounceTopPoint); // 最高点
        bezier2.push(cc.v2(endWorldPos.x, endWorldPos.y)); // 终点

        // 创建动作序列
        const bezierAction1 = cc.bezierTo(duration * 0.8, bezier1);
        const bezierAction2 = cc.bezierTo(duration * 0.2, bezier2);


        // 组合所有动作
        const seq = cc.sequence(
            bezierAction1,
            bezierAction2,
            cc.callFunc(() => {
                mergeCube.SetZIndex(targetIdx);
            })
        );

        // 执行动画
        mergeCube.node.runAction(seq);
    }

}